package org.dromara.qa.md.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
|
import org.dromara.common.core.utils.DateUtils;
|
import org.dromara.common.mybatis.core.page.PageQuery;
|
import org.dromara.common.mybatis.core.page.TableDataInfo;
|
import org.dromara.qa.md.domain.bo.BatchCalibrateBo;
|
import org.dromara.qa.md.domain.bo.BatchConfigBo;
|
import org.dromara.qa.md.domain.CalibrationRecord;
|
import org.dromara.qa.md.domain.WeighingBox;
|
import org.dromara.qa.md.mapper.WeighingBoxMapper;
|
import org.dromara.qa.md.service.ICalibrationRecordService;
|
import org.dromara.qa.md.service.IWeighingBoxService;
|
import org.dromara.qa.md.service.INotificationService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.math.BigDecimal;
|
import java.util.*;
|
import java.util.concurrent.TimeUnit;
|
|
/**
|
* 称重盒子服务实现
|
*
|
* @author ruoyi
|
* @date 2026-04-09
|
*/
|
@Service
|
public class WeighingBoxServiceImpl extends ServiceImpl<WeighingBoxMapper, WeighingBox> implements IWeighingBoxService
|
{
|
@Autowired
|
private WeighingBoxMapper weighingBoxMapper;
|
|
@Autowired
|
private ICalibrationRecordService calibrationRecordService;
|
|
@Autowired
|
private INotificationService notificationService;
|
|
@Override
|
public TableDataInfo<WeighingBox> queryPageList(WeighingBox weighingBox, PageQuery pageQuery) {
|
// 检查是否需要按校准状态过滤
|
if (weighingBox.getCalibStatus() != null && !weighingBox.getCalibStatus().isEmpty()) {
|
// 使用带校准状态过滤的查询
|
long total = weighingBoxMapper.selectWeighingBoxCountWithCalibStatus(weighingBox);
|
List<WeighingBox> records = weighingBoxMapper.selectWeighingBoxListWithCalibStatus(weighingBox);
|
|
// 手动分页
|
int pageNum = pageQuery.getPageNum();
|
int pageSize = pageQuery.getPageSize();
|
int start = (pageNum - 1) * pageSize;
|
int end = Math.min(start + pageSize, records.size());
|
List<WeighingBox> pageRecords = start < records.size() ? records.subList(start, end) : new ArrayList<>();
|
|
// 计算每个盒子的校准状态（保持与前端一致）
|
for (WeighingBox box : pageRecords) {
|
calculateCalibStatus(box);
|
}
|
|
// 构建返回结果
|
TableDataInfo<WeighingBox> tableDataInfo = new TableDataInfo<>();
|
tableDataInfo.setRows(pageRecords);
|
tableDataInfo.setTotal(total);
|
tableDataInfo.setCode(200);
|
tableDataInfo.setMsg("查询成功");
|
return tableDataInfo;
|
} else {
|
// 使用常规分页查询
|
Page<WeighingBox> page = new Page<>(pageQuery.getPageNum(), pageQuery.getPageSize());
|
|
// 构建查询条件
|
LambdaQueryWrapper<WeighingBox> queryWrapper = new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<>();
|
queryWrapper.eq(WeighingBox::getDelFlag, 0);
|
|
if (weighingBox.getName() != null && !weighingBox.getName().isEmpty()) {
|
queryWrapper.like(WeighingBox::getName, weighingBox.getName())
|
.or().like(WeighingBox::getCode, weighingBox.getName())
|
.or().like(WeighingBox::getDescription, weighingBox.getName())
|
.or().like(WeighingBox::getLocation, weighingBox.getName());
|
}
|
if (weighingBox.getActiveStatus() != null) {
|
queryWrapper.eq(WeighingBox::getActiveStatus, weighingBox.getActiveStatus());
|
}
|
|
queryWrapper.orderByDesc(WeighingBox::getCreateTime);
|
|
// 执行分页查询
|
Page<WeighingBox> resultPage = baseMapper.selectPage(page, queryWrapper);
|
|
// 计算每个盒子的校准状态
|
for (WeighingBox box : resultPage.getRecords()) {
|
calculateCalibStatus(box);
|
}
|
|
return TableDataInfo.build(resultPage);
|
}
|
}
|
|
@Override
|
public List<WeighingBox> selectWeighingBoxList(WeighingBox weighingBox)
|
{
|
List<WeighingBox> list = weighingBoxMapper.selectWeighingBoxList(weighingBox);
|
for (WeighingBox box : list)
|
{
|
calculateCalibStatus(box);
|
}
|
return list;
|
}
|
|
@Override
|
public int insertWeighingBox(WeighingBox weighingBox)
|
{
|
// 计算下次校准日期
|
if (weighingBox.getLastCalibDate() != null && weighingBox.getCalibCycleDays() != null)
|
{
|
Date nextCalibDate = DateUtils.addDays(weighingBox.getLastCalibDate(), weighingBox.getCalibCycleDays());
|
weighingBox.setNextCalibDate(nextCalibDate);
|
}
|
return baseMapper.insert(weighingBox);
|
}
|
|
@Override
|
public int updateWeighingBox(WeighingBox weighingBox)
|
{
|
// 计算下次校准日期
|
if (weighingBox.getLastCalibDate() != null && weighingBox.getCalibCycleDays() != null)
|
{
|
Date nextCalibDate = DateUtils.addDays(weighingBox.getLastCalibDate(), weighingBox.getCalibCycleDays());
|
weighingBox.setNextCalibDate(nextCalibDate);
|
}
|
return baseMapper.updateById(weighingBox);
|
}
|
|
@Override
|
public int deleteWeighingBoxByIds(Long[] boxIds)
|
{
|
return baseMapper.deleteBatchIds(Arrays.asList(boxIds));
|
}
|
|
@Override
|
@Transactional
|
public int calibrate(Long boxId, Date calibDate, BigDecimal actualWeight, String note)
|
{
|
WeighingBox box = baseMapper.selectById(boxId);
|
if (box == null)
|
{
|
return 0;
|
}
|
|
// 保存校准前的状态
|
Date prevCalibDate = box.getLastCalibDate();
|
|
// 更新盒子信息
|
box.setLastCalibDate(calibDate);
|
box.setNextCalibDate(DateUtils.addDays(calibDate, box.getCalibCycleDays()));
|
baseMapper.updateById(box);
|
|
// 计算偏差
|
BigDecimal deviation = null;
|
BigDecimal deviationPct = null;
|
if (actualWeight != null)
|
{
|
deviation = actualWeight.subtract(box.getWeight());
|
if (box.getWeight().compareTo(BigDecimal.ZERO) > 0)
|
{
|
deviationPct = deviation.divide(box.getWeight(), 3, BigDecimal.ROUND_HALF_UP).multiply(new BigDecimal(100));
|
}
|
}
|
|
// 创建校准记录
|
CalibrationRecord record = new CalibrationRecord();
|
record.setTargetType("weighing_box");
|
record.setTargetId(boxId);
|
record.setTargetCode(box.getCode());
|
record.setTargetName(box.getName());
|
record.setCalibDate(calibDate);
|
record.setCalibCycleDays(box.getCalibCycleDays());
|
record.setStandardWeight(box.getWeight());
|
record.setActualWeight(actualWeight);
|
record.setDeviation(deviation);
|
record.setDeviationPct(deviationPct);
|
record.setPrevCalibDate(prevCalibDate);
|
record.setNextCalibDate(box.getNextCalibDate());
|
record.setOperator("admin"); // 实际应该从当前用户获取
|
record.setNote(note);
|
record.setCreateTime(new Date());
|
calibrationRecordService.save(record);
|
|
return 1;
|
}
|
|
@Override
|
@Transactional
|
public Map<String, Object> batchCalibrate(BatchCalibrateBo batchCalibrateDTO)
|
{
|
List<Long> boxIds = batchCalibrateDTO.getBoxIds();
|
Date calibDate = batchCalibrateDTO.getCalibDate();
|
String note = batchCalibrateDTO.getNote();
|
List<BatchCalibrateBo.CalibrateItem> items = batchCalibrateDTO.getItems();
|
|
Map<Long, BigDecimal> actualWeightMap = new HashMap<>();
|
if (items != null)
|
{
|
for (BatchCalibrateBo.CalibrateItem item : items)
|
{
|
actualWeightMap.put(item.getBoxId(), item.getActualWeight());
|
}
|
}
|
|
String batchId = UUID.randomUUID().toString();
|
List<CalibrationRecord> records = new ArrayList<>();
|
List<Map<String, Object>> results = new ArrayList<>();
|
|
for (Long boxId : boxIds)
|
{
|
WeighingBox box = baseMapper.selectById(boxId);
|
if (box == null)
|
{
|
continue;
|
}
|
|
// 保存校准前的状态
|
Date prevCalibDate = box.getLastCalibDate();
|
|
// 更新盒子信息
|
box.setLastCalibDate(calibDate);
|
box.setNextCalibDate(DateUtils.addDays(calibDate, box.getCalibCycleDays()));
|
baseMapper.updateById(box);
|
|
// 计算偏差
|
BigDecimal actualWeight = actualWeightMap.get(boxId);
|
BigDecimal deviation = null;
|
BigDecimal deviationPct = null;
|
if (actualWeight != null)
|
{
|
deviation = actualWeight.subtract(box.getWeight());
|
if (box.getWeight().compareTo(BigDecimal.ZERO) > 0)
|
{
|
deviationPct = deviation.divide(box.getWeight(), 3, BigDecimal.ROUND_HALF_UP).multiply(new BigDecimal(100));
|
}
|
}
|
|
// 创建校准记录
|
CalibrationRecord record = new CalibrationRecord();
|
record.setTargetType("weighing_box");
|
record.setTargetId(boxId);
|
record.setTargetCode(box.getCode());
|
record.setTargetName(box.getName());
|
record.setCalibDate(calibDate);
|
record.setCalibCycleDays(box.getCalibCycleDays());
|
record.setStandardWeight(box.getWeight());
|
record.setActualWeight(actualWeight);
|
record.setDeviation(deviation);
|
record.setDeviationPct(deviationPct);
|
record.setPrevCalibDate(prevCalibDate);
|
record.setNextCalibDate(box.getNextCalibDate());
|
record.setBatchId(batchId);
|
record.setOperator("admin"); // 实际应该从当前用户获取
|
record.setNote(note);
|
record.setCreateTime(new Date());
|
records.add(record);
|
|
// 准备返回结果
|
Map<String, Object> result = new HashMap<>();
|
result.put("boxId", boxId);
|
result.put("nextCalibDate", box.getNextCalibDate());
|
results.add(result);
|
}
|
|
// 批量插入校准记录
|
if (!records.isEmpty())
|
{
|
calibrationRecordService.batchInsert(records);
|
}
|
|
Map<String, Object> resultMap = new HashMap<>();
|
resultMap.put("successCount", boxIds.size());
|
resultMap.put("failCount", 0);
|
resultMap.put("results", results);
|
return resultMap;
|
}
|
|
@Override
|
@Transactional
|
public int batchConfig(BatchConfigBo batchConfigDTO)
|
{
|
Integer calibCycleDays = batchConfigDTO.getCalibCycleDays();
|
Integer remindDays = batchConfigDTO.getRemindDays();
|
String applyScope = batchConfigDTO.getApplyScope();
|
List<Long> boxIds = batchConfigDTO.getBoxIds();
|
|
List<Long> targetBoxIds = new ArrayList<>();
|
if ("all".equals(applyScope))
|
{
|
// 所有已启用的盒子
|
List<WeighingBox> boxes = weighingBoxMapper.selectActiveWeighingBoxes();
|
for (WeighingBox box : boxes)
|
{
|
targetBoxIds.add(box.getId());
|
}
|
}
|
else if ("selected".equals(applyScope) && boxIds != null)
|
{
|
targetBoxIds.addAll(boxIds);
|
}
|
|
if (targetBoxIds.isEmpty())
|
{
|
return 0;
|
}
|
|
// 批量更新校准配置
|
int result = weighingBoxMapper.batchUpdateCalibConfig(targetBoxIds, calibCycleDays, remindDays);
|
|
// 重新计算下次校准日期
|
for (Long boxId : targetBoxIds)
|
{
|
WeighingBox box = baseMapper.selectById(boxId);
|
if (box.getLastCalibDate() != null)
|
{
|
box.setNextCalibDate(DateUtils.addDays(box.getLastCalibDate(), calibCycleDays));
|
baseMapper.updateById(box);
|
}
|
}
|
|
return result;
|
}
|
|
@Override
|
public int batchUpdateStatus(List<Long> boxIds, Integer activeStatus)
|
{
|
return weighingBoxMapper.batchUpdateStatus(boxIds, activeStatus);
|
}
|
|
@Override
|
public Map<String, Object> copyBox(Long sourceId, Integer count)
|
{
|
WeighingBox sourceBox = baseMapper.selectById(sourceId);
|
if (sourceBox == null)
|
{
|
throw new RuntimeException("源盒子不存在");
|
}
|
Date nextCalibDate = null;
|
List<Long> newIds = new ArrayList<>();
|
List<String> newCodes = new ArrayList<>();
|
// 计算下次校准日期
|
if ( sourceBox.getCalibCycleDays() != null)
|
{
|
nextCalibDate = DateUtils.addDays(new Date(), sourceBox.getCalibCycleDays());
|
}
|
for (int i = 1; i <= count; i++)
|
{
|
WeighingBox newBox = new WeighingBox();
|
newBox.setName(sourceBox.getName() + "-" + (char)('a' + i - 1));
|
newBox.setCode(sourceBox.getCode() + "-" + (char)('a' + i - 1));
|
newBox.setWeight(sourceBox.getWeight());
|
newBox.setUnit(sourceBox.getUnit());
|
newBox.setLocation(sourceBox.getLocation());
|
newBox.setCalibCycleDays(sourceBox.getCalibCycleDays());
|
newBox.setRemindDays(sourceBox.getRemindDays());
|
newBox.setActiveStatus(sourceBox.getActiveStatus());
|
newBox.setDescription(sourceBox.getDescription());
|
newBox.setLastCalibDate(new Date());
|
newBox.setNextCalibDate(nextCalibDate);
|
newBox.setCreateBy("admin"); // 实际应该从当前用户获取
|
newBox.setCreateTime(new Date());
|
baseMapper.insert(newBox);
|
newIds.add(newBox.getId());
|
newCodes.add(newBox.getCode());
|
}
|
|
Map<String, Object> result = new HashMap<>();
|
result.put("ids", newIds);
|
result.put("codes", newCodes);
|
return result;
|
}
|
|
@Override
|
public Map<String, Integer> getStatistics()
|
{
|
Map<String, Integer> statistics = new HashMap<>();
|
statistics.put("total", Math.toIntExact(baseMapper.selectCount(null)));
|
|
// 已启用
|
int activeCount = Math.toIntExact(baseMapper.selectCount(new LambdaQueryWrapper<WeighingBox>()
|
.eq(WeighingBox::getActiveStatus, 1)
|
.eq(WeighingBox::getDelFlag, 0)));
|
statistics.put("active", activeCount);
|
|
// 已停用
|
int inactiveCount = Math.toIntExact(baseMapper.selectCount(new LambdaQueryWrapper<WeighingBox>()
|
.eq(WeighingBox::getActiveStatus, 0)
|
.eq(WeighingBox::getDelFlag, 0)));
|
statistics.put("inactive", inactiveCount);
|
|
// 校准状态统计
|
List<WeighingBox> boxes = baseMapper.selectList(new LambdaQueryWrapper<WeighingBox>()
|
.eq(WeighingBox::getDelFlag, 0)
|
.eq(WeighingBox::getActiveStatus, 1));
|
|
int normal = 0, warning = 0, overdue = 0, unset = 0;
|
for (WeighingBox box : boxes)
|
{
|
calculateCalibStatus(box);
|
String status = box.getCalibStatus();
|
if ("normal".equals(status)) normal++;
|
else if ("warning".equals(status)) warning++;
|
else if ("overdue".equals(status)) overdue++;
|
else if ("unset".equals(status)) unset++;
|
}
|
|
statistics.put("normal", normal);
|
statistics.put("warning", warning);
|
statistics.put("overdue", overdue);
|
statistics.put("unset", unset);
|
|
return statistics;
|
}
|
|
@Override
|
public WeighingBox calculateCalibStatus(WeighingBox weighingBox)
|
{
|
Date nextCalibDate = weighingBox.getNextCalibDate();
|
if (nextCalibDate == null)
|
{
|
weighingBox.setCalibStatus("unset");
|
weighingBox.setCalibDaysLeft(null);
|
return weighingBox;
|
}
|
|
long daysLeft = DateUtils.getTimeDifference(new Date(), nextCalibDate, TimeUnit.DAYS);
|
weighingBox.setCalibDaysLeft((int) daysLeft);
|
|
if (daysLeft < 0)
|
{
|
weighingBox.setCalibStatus("overdue");
|
}
|
else if (daysLeft <= weighingBox.getRemindDays())
|
{
|
weighingBox.setCalibStatus("warning");
|
}
|
else
|
{
|
weighingBox.setCalibStatus("normal");
|
}
|
|
return weighingBox;
|
}
|
}
|
