Merge remote-tracking branch 'origin/master'

liweidong
绫Umbrella 2 months ago
commit 2593b221a0
  1. 4
      blade-common/src/main/java/org/springblade/common/constant/LauncherConstant.java
  2. 2
      blade-ops/blade-job/src/main/java/org/springblade/job/processor/device/IotEquipmentProcessor.java
  3. 38
      blade-ops/blade-job/src/main/java/org/springblade/job/processor/device/LimsMeaToolProcessor.java
  4. 25
      blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/device/feign/LimsMeaToolTaskClient.java
  5. 239
      blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/device/pojo/entity/MeasurementRecordsEntity.java
  6. 21
      blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/device/pojo/vo/MeasurementRecordsVO.java
  7. 74
      blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/logistics/pojo/entity/Task.java
  8. 105
      blade-service/blade-desk/src/main/java/org/springblade/desk/device/controller/MeasurementRecordsController.java
  9. 23
      blade-service/blade-desk/src/main/java/org/springblade/desk/device/feign/LimsMeaToolTaskClientImpl.java
  10. 39
      blade-service/blade-desk/src/main/java/org/springblade/desk/device/mapper/MeasurementRecordsMapper.java
  11. 62
      blade-service/blade-desk/src/main/java/org/springblade/desk/device/mapper/MeasurementRecordsMapper.xml
  12. 22
      blade-service/blade-desk/src/main/java/org/springblade/desk/device/service/IMeasurementRecordsService.java
  13. 128
      blade-service/blade-desk/src/main/java/org/springblade/desk/device/service/impl/IMeasurementRecordsServiceImpl.java
  14. 35
      blade-service/blade-desk/src/main/java/org/springblade/desk/device/wrapper/MeasurementRecordsWrapper.java
  15. 13
      blade-service/blade-desk/src/main/java/org/springblade/desk/logistics/constant/AgvConstant.java
  16. 19
      blade-service/blade-desk/src/main/java/org/springblade/desk/logistics/controller/PipelineController.java
  17. 2
      blade-service/blade-desk/src/main/java/org/springblade/desk/logistics/mapper/StationMapper.java
  18. 4
      blade-service/blade-desk/src/main/java/org/springblade/desk/logistics/mapper/StationMapper.xml
  19. 4
      blade-service/blade-desk/src/main/java/org/springblade/desk/logistics/service/IStationService.java
  20. 3
      blade-service/blade-desk/src/main/java/org/springblade/desk/logistics/service/ITaskService.java
  21. 15
      blade-service/blade-desk/src/main/java/org/springblade/desk/logistics/service/impl/IOrderBoxServiceImpl.java
  22. 16
      blade-service/blade-desk/src/main/java/org/springblade/desk/logistics/service/impl/IPipelineOrderBoxServiceImpl.java
  23. 10
      blade-service/blade-desk/src/main/java/org/springblade/desk/logistics/service/impl/PipelineServiceImpl.java
  24. 4
      blade-service/blade-desk/src/main/java/org/springblade/desk/logistics/service/impl/StationServiceImpl.java
  25. 2
      blade-service/blade-desk/src/main/java/org/springblade/desk/logistics/service/impl/StorageMonitoringServiceImpl.java
  26. 8
      blade-service/blade-desk/src/main/java/org/springblade/desk/logistics/service/impl/TaskExecuteRecordServiceImpl.java
  27. 3
      blade-service/blade-desk/src/main/java/org/springblade/desk/logistics/service/impl/TaskServiceImpl.java
  28. 151
      blade-service/blade-desk/src/main/java/org/springblade/desk/logistics/utils/AgvTaskTypeUtil.java

@ -31,8 +31,8 @@ public interface LauncherConstant {
/**
* nacos dev 地址
*/
String NACOS_DEV_ADDR = "192.168.249.27:8848";
// String NACOS_DEV_ADDR = "192.168.0.3:8848";
// String NACOS_DEV_ADDR = "192.168.249.27:8848";
String NACOS_DEV_ADDR = "127.0.0.1:8848";
/**
* nacos prod 地址

@ -4,12 +4,10 @@ import jakarta.annotation.Resource;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springblade.desk.device.feign.IotEquipmentTaskClient;
import org.springblade.desk.quality.feign.ILquidTankTaskClient;
import org.springframework.stereotype.Component;
import tech.powerjob.worker.core.processor.ProcessResult;
import tech.powerjob.worker.core.processor.TaskContext;
import tech.powerjob.worker.core.processor.sdk.BasicProcessor;
import tech.powerjob.worker.log.OmsLogger;
import java.util.concurrent.CompletableFuture;

@ -0,0 +1,38 @@
package org.springblade.job.processor.device;
import jakarta.annotation.Resource;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springblade.desk.device.feign.LimsMeaToolTaskClient;
import org.springframework.stereotype.Component;
import tech.powerjob.worker.core.processor.ProcessResult;
import tech.powerjob.worker.core.processor.TaskContext;
import tech.powerjob.worker.core.processor.sdk.BasicProcessor;
import java.util.concurrent.CompletableFuture;
/**
* 同步量具计量记录数据任务
*/
@Data
@Component
@Slf4j
public class LimsMeaToolProcessor implements BasicProcessor {
@Resource
private LimsMeaToolTaskClient limsMeaToolTaskClient;
@Override
public ProcessResult process(TaskContext context) throws Exception {
log.info("同步量具计量记录数据任务开始");
CompletableFuture<Void> runFuture = CompletableFuture.runAsync(() -> limsMeaToolTaskClient.syncMeasurementRecordsTask());
runFuture.whenComplete((result, exception) -> {
if (exception != null) {
log.error("同步量具计量记录数据任务失败", exception);
} else {
log.info("同步量具计量记录数据任务完毕");
}
});
return new ProcessResult(true);
}
}

@ -0,0 +1,25 @@
package org.springblade.desk.device.feign;
import org.springblade.core.launch.constant.AppConstant;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
@FeignClient(
value = AppConstant.APPLICATION_DESK_NAME
)
/**
* 同步Lims量具相关信息
*/
public interface LimsMeaToolTaskClient {
String API_PREFIX = "/feign/device/lims-task";
String SYNC_MEASUREMENT_RECORDS_TASK = API_PREFIX + "/sync-measurement-records-task";
/**
* 同步量具数据
*/
@GetMapping(SYNC_MEASUREMENT_RECORDS_TASK)
void syncMeasurementRecordsTask();
}

@ -1,140 +1,183 @@
package org.springblade.desk.device.pojo.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import io.swagger.v3.oas.annotations.media.Schema;
import com.baomidou.mybatisplus.annotation.TableName;
import java.math.BigDecimal;
import java.util.Date;
import lombok.EqualsAndHashCode;
import org.springblade.core.mp.base.BaseEntity;
import org.springblade.core.tenant.mp.TenantEntity;
import java.util.Date;
import java.io.Serial;
/**
* 计量记录 实体类
* 量具计量记录 实体类
*
* @author qyl
* @since 2026年1月4日
* @since 2026-03-03
*/
@Data
@Schema(description = "计量记录对象")
@TableName("MES_MEASUREMENT_RECORDS")
@Schema(description = "MeasurementRecords对象")
@EqualsAndHashCode(callSuper = true)
public class MeasurementRecordsEntity extends BaseEntity {
@Schema(name = "名称(设备名称)")
//@Column(name = "MC_NAME")
private String mcName;
@Schema(name = "规格")
//@Column(name = "NORMS")
private String norms;
@Serial
private static final long serialVersionUID = 1L;
@Schema(name = "类别(管理类别)")
//@Column(name = "MC_CLASS")
/**
* 名称(设备名称)
*/
@Schema(description = "名称(设备名称)")
private String mcName;
/**
* 规格
*/
@Schema(description = "规格")
private String norms;
/**
* 类别(管理类别)
*/
@Schema(description = "类别(管理类别)")
private String mcClass;
@Schema(name = "计量类型")
//@Column(name = "LABEL_NO")
/**
* 计量类型
*/
@Schema(description = "计量类型")
private String labelNo;
@Schema(name = "计量子类型")
//@Column(name = "STR2")
/**
* 计量子类型
*/
@Schema(description = "计量子类型")
private String str2;
@Schema(name = "编号(测量设备编码)")
//@Column(name = "MC_CODE")
/**
* 编号(测量设备编码)
*/
@Schema(description = "编号(测量设备编码)")
@NotNull(message = "编号不能为空")
private String mcCode;
@Schema(name = "使用单位(试用部门)")
//@Column(name = "USE_UNIT")
/**
* 使用单位(试用部门)
*/
@Schema(description = "使用单位(试用部门)")
private String useUnit;
@Schema(name = "精度(精度等级)")
//@Column(name = "ACCURACY")
/**
* 精度(精度等级)
*/
@Schema(description = "精度(精度等级)")
private String accuracy;
@Schema(name = "出厂编号")
//@Column(name = "OEM_CODE")
/**
* 出厂编号
*/
@Schema(description = "出厂编号")
private String oemCode;
@Schema(name = "生产厂家(制造厂商)")
//@Column(name = "MC_OEM")
/**
* 生产厂家(制造厂商)
*/
@Schema(description = "生产厂家(制造厂商)")
private String mcOem;
@Schema(name = "启用日期")
//@Column(name = "ENABLE_DATE")
/**
* 启用日期
*/
@Schema(description = "启用日期")
private Date enableDate;
@Schema(name = "检定日期")
//@Column(name = "WHEN_DCCEPT")
/**
* 检定日期
*/
@Schema(description = "检定日期")
private String whenDccept;
@Schema(name = "型号(型号)")
//@Column(name = "MC_TYPE")
/**
* 型号(型号)
*/
@Schema(description = "型号(型号)")
private String mcType;
@Schema(name = "检定周期(检定周期)")
//@Column(name = "TEST_CYCLE")
/**
* 检定周期(检定周期)
*/
@Schema(description = "检定周期(检定周期)")
private Integer testCycle;
@Schema(name = "到期日期(有效日期)")
//@Column(name = "DUE_DATE")
/**
* 到期日期(有效日期)
*/
@Schema(description = "到期日期(有效日期)")
private Date dueDate;
@Schema(name = "报废日期")
//@Column(name = "DATE2")
/**
* 报废日期
*/
@Schema(description = "报废日期")
private Date date2;
@Schema(name = "状态")
//@Column(name = "BELONG")
/**
* 状态
*/
@Schema(description = "状态")
private String belong;
@Schema(name = "停用日期")
//@Column(name = "WHEN_BUY")
/**
* 停用日期
*/
@Schema(description = "停用日期")
private Date whenBuy;
@Schema(name = "检定部门")
//@Column(name = "TEST_DEPT")
/**
* 检定部门
*/
@Schema(description = "检定部门")
private String testDept;
@Schema(name = "检定/校验方法(检定校准方法)")
//@Column(name = "TEST_METHOD")
/**
* 检定/校验方法(检定校准方法)
*/
@Schema(description = "检定/校验方法(检定校准方法)")
private String testMethod;
@Schema(name = "备注")
//@Column(name = "STR9")
/**
* 备注
*/
@Schema(description = "备注")
private String str9;
@Schema(name = "备注2")
//@Column(name = "STR10")
/**
* 备注2
*/
@Schema(description = "备注2")
private String str10;
@Schema(name = "使用人工号")
//@Column(name = "ASSETS_NO")
/**
* 使用人工号
*/
@Schema(description = "使用人工号")
private String assetsNo;
@Schema(name = "责任人")
//@Column(name = "STR6")
/**
* 责任人
*/
@Schema(description = "责任人")
private String str6;
@Schema(name = "用途分类")
//@Column(name = "PURPOSE_CLASS")
/**
* 用途分类
*/
@Schema(description = "用途分类")
private String purposeClass;
@Schema(name = "超期情况")
//@Column(name = "IS_OVER_STR")
/**
* 超期情况
*/
@Schema(description = "超期情况")
private String isOverStr;
/**
* 类型1仪表计量2设备计量
*/
@Schema(description = "类型1、仪表计量;2、设备计量")
private Integer cmType;
/**
* 是否送检1:0:
*/
@Schema(description = "是否送检1:是,0:否")
private String censorship;
/**
* 检验状态1:在检0:未检
*/
@Schema(description = "检验状态1:在检,0:未检")
private String checkStatus;
/**
* 检验结果1:合格0:不合格
*/
@Schema(description = "检验结果1:合格,0:不合格")
private String checkResult;
@Schema(name = "类型", title = "1、仪表计量;2、设备计量")
//@Column(name = "CM_TYPE")
private Short cmType;
@Schema(name = "是否送检", title = "1:是,0:否")
//@Column(name = "CENSORSHIP")
private Boolean censorship;
@Schema(name = "检验状态", title = "1:在检,0:未检")
//@Column(name = "CHECK_STATUS")
private Boolean checkStatus;
@Schema(name = "检验结果", title = "1:合格,0:不合格")
//@Column(name = "CHECK_RESULT")
private Boolean checkResult;
}

@ -0,0 +1,21 @@
package org.springblade.desk.device.pojo.vo;
import org.springblade.desk.device.pojo.entity.MeasurementRecordsEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serial;
/**
* 量具计量记录 视图实体类
*
* @author qyl
* @since 2026-03-03
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class MeasurementRecordsVO extends MeasurementRecordsEntity {
@Serial
private static final long serialVersionUID = 1L;
}

@ -26,12 +26,7 @@ public class Task extends BaseEntity {
/**
* 起点位置
*/
public static final Integer STATUS_START = 0;
/**
* 输送线起点
*/
public static final Integer STATUS_CONVEYOR_START = 1;
public static final Integer STATUS_START = 1;
/**
* 退回(超重)
@ -39,39 +34,20 @@ public class Task extends BaseEntity {
public static final Integer STATUS_RETURNED = 2;
/**
* 输送线末尾
* 输送线末尾(配送中)
*/
public static final Integer STATUS_CONVEYOR_END = 3;
/**
* 站点
*/
public static final Integer STATUS_STATION = 4;
/**
* 库位
*/
public static final Integer STATUS_LOCATION = 5;
/**
* 等待
*/
public static final Integer STATUS_WAITING = 6;
/**
* 站点接收
*/
public static final Integer STATUS_STATION_RECEIVE = 7;
/**
* 回库
* 结束
*/
public static final Integer STATUS_BACK_TO_STORAGE = 8;
public static final Integer STATUS_FINISHED = 4;
/**
* 结束
* 失败
*/
public static final Integer STATUS_FINISHED = 9;
public static final Integer STATUS_FAILING = 5;
/**
* ID主键
@ -125,42 +101,4 @@ public class Task extends BaseEntity {
@Schema(description = "备注")
private String remark;
/**
* 获取状态描述
* @return 状态描述
*/
public String getStatusDesc() {
return getStatusDesc(this.taskStatus);
}
/**
* 根据状态值获取状态描述
* @param status 状态值
* @return 状态描述
*/
public static String getStatusDesc(Integer status) {
if (STATUS_RETURNED.equals(status)) {
return "退回(超重)";
} else if (STATUS_STATION.equals(status)) {
return "站点";
} else if (STATUS_LOCATION.equals(status)) {
return "库位";
} else if (STATUS_WAITING.equals(status)) {
return "等待";
} else if (STATUS_BACK_TO_STORAGE.equals(status)) {
return "回库";
} else if (STATUS_FINISHED.equals(status)) {
return "结束";
}else if (STATUS_START.equals(status)) {
return "起点位置";
}else if (STATUS_CONVEYOR_START.equals(status)) {
return "输送线起点";
}else if (STATUS_CONVEYOR_END.equals(status)) {
return "输送线末尾";
}else if (STATUS_STATION_RECEIVE.equals(status)) {
return "站点接收";
} else {
return "未知状态";
}
}
}

@ -1,10 +1,14 @@
package org.springblade.desk.device.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.Valid;
import lombok.AllArgsConstructor;
import org.springblade.core.boot.ctrl.BladeController;
import org.springblade.core.excel.util.ExcelUtil;
@ -12,15 +16,14 @@ import org.springblade.core.mp.support.Condition;
import org.springblade.core.mp.support.Query;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.utils.DateUtil;
import org.springblade.core.tool.utils.Func;
import org.springblade.desk.device.pojo.entity.MeasurementRecordsEntity;
import org.springblade.desk.device.pojo.excel.MeasurementRecordsExcel;
import org.springblade.desk.device.pojo.vo.MeasurementRecordsVO;
import org.springblade.desk.device.service.IMeasurementRecordsService;
import org.springblade.desk.device.wrapper.MeasurementRecordsWrapper;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;
@ -37,43 +40,97 @@ import java.util.List;
@RequestMapping("/measurementRecords")
@Tag(name = "计量记录", description = "计量记录接口")
public class MeasurementRecordsController extends BladeController {
@Autowired
IMeasurementRecordsService iMeasurementRecordsService;
private final IMeasurementRecordsService mesMeasurementRecordsService;
/**
* 计量记录 自定义分页
*
* @param cmType 1仪表计量2设备计量
* @param query
* @return
* 量具计量记录 详情
*/
@GetMapping("/page")
@GetMapping("/detail")
@ApiOperationSupport(order = 1)
@Operation(summary = "分页", description = "")
public R<IPage<MeasurementRecordsEntity>> page(@RequestParam("cmType") Integer cmType, Query query) {
IPage<MeasurementRecordsEntity> pages = iMeasurementRecordsService.selectMeasurementRecordsPage(Condition.getPage(query), cmType);
@Operation(summary = "详情", description = "传入mesMeasurementRecords")
public R<MeasurementRecordsVO> detail(MeasurementRecordsEntity mesMeasurementRecords) {
MeasurementRecordsEntity detail = mesMeasurementRecordsService.getOne(Condition.getQueryWrapper(mesMeasurementRecords));
return R.data(MeasurementRecordsWrapper.build().entityVO(detail));
}
/**
* 量具计量记录 自定义分页
*/
@GetMapping("/page")
@ApiOperationSupport(order = 3)
@Operation(summary = "分页", description = "传入mesMeasurementRecords")
public R<IPage<MeasurementRecordsVO>> page(MeasurementRecordsVO mesMeasurementRecords, Query query) {
IPage<MeasurementRecordsVO> pages = mesMeasurementRecordsService.selectMeasurementRecordsPage(Condition.getPage(query), mesMeasurementRecords);
return R.data(pages);
}
/**
* 量具计量记录 新增
*/
@PostMapping("/save")
@ApiOperationSupport(order = 4)
@Operation(summary = "新增", description = "传入mesMeasurementRecords")
public R save(@Valid @RequestBody MeasurementRecordsEntity mesMeasurementRecords) {
MeasurementRecordsEntity one = mesMeasurementRecordsService.getOne(Wrappers.<MeasurementRecordsEntity>lambdaQuery().eq(MeasurementRecordsEntity::getMcCode, mesMeasurementRecords.getMcCode()));
if (one != null) {
return R.fail("量具已存在");
}
return R.status(mesMeasurementRecordsService.save(mesMeasurementRecords));
}
/**
* 量具计量记录 修改
*/
@PostMapping("/update")
@ApiOperationSupport(order = 5)
@Operation(summary = "修改", description = "传入mesMeasurementRecords")
public R update(@Valid @RequestBody MeasurementRecordsEntity mesMeasurementRecords) {
MeasurementRecordsEntity one = mesMeasurementRecordsService.getOne(Wrappers.<MeasurementRecordsEntity>lambdaQuery().eq(MeasurementRecordsEntity::getMcCode, mesMeasurementRecords.getMcCode()));
if (one != null && !one.getId().equals(mesMeasurementRecords.getId())) {
return R.fail("量具已存在");
}
return R.status(mesMeasurementRecordsService.updateById(mesMeasurementRecords));
}
/**
* 量具计量记录 新增或修改
*/
// @PostMapping("/submit")
// @ApiOperationSupport(order = 6)
// @Operation(summary = "新增或修改", description = "传入mesMeasurementRecords")
// public R submit(@Valid @RequestBody MeasurementRecordsEntity mesMeasurementRecords) {
// return R.status(mesMeasurementRecordsService.saveOrUpdate(mesMeasurementRecords));
// }
/**
* 量具计量记录 删除
*/
@PostMapping("/remove")
@ApiOperationSupport(order = 7)
@Operation(summary = "逻辑删除", description = "传入ids")
public R remove(@Parameter(description = "主键集合", required = true) @RequestParam String ids) {
return R.status(mesMeasurementRecordsService.deleteLogic(Func.toLongList(ids)));
}
/**
* 导出数据
*/
// @IsAdmin
@GetMapping("/export-measurementRecords")
@ApiOperationSupport(order = 2)
@ApiOperationSupport(order = 11)
@Operation(summary = "导出数据", description = "")
public void exportMeasuringUpkeep(@RequestParam("cmType") Integer cmType, Query query, HttpServletResponse response) {
query.setSize(99999);
IPage<MeasurementRecordsEntity> pages = iMeasurementRecordsService.selectMeasurementRecordsPage(Condition.getPage(query), cmType);
List<MeasurementRecordsEntity> list = pages.getRecords();
public void exportMeasuringUpkeep(MeasurementRecordsVO mesMeasurementRecords, Query query, HttpServletResponse response) {
query.setSize(9999);
IPage<MeasurementRecordsVO> pages = mesMeasurementRecordsService.selectMeasurementRecordsPage(Condition.getPage(query), mesMeasurementRecords);
List<MeasurementRecordsVO> list = pages.getRecords();
List<MeasurementRecordsExcel> excels = new ArrayList<>();
for (MeasurementRecordsEntity measurementRecordsEntity : list) {
for (MeasurementRecordsVO measurementRecordsEntity : list) {
MeasurementRecordsExcel excel = new MeasurementRecordsExcel();
BeanUtils.copyProperties(measurementRecordsEntity, excel);
excels.add(excel);
}
ExcelUtil.export(response, "量具保养数据" + DateUtil.time(), "计量记录", excels, MeasurementRecordsExcel.class);
ExcelUtil.export(response, "仪表计量记录数据" + DateUtil.time(), "仪表计量记录数据", excels, MeasurementRecordsExcel.class);
}
}

@ -0,0 +1,23 @@
package org.springblade.desk.device.feign;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.v3.oas.annotations.Hidden;
import jakarta.annotation.Resource;
import org.springblade.desk.device.pojo.entity.MeasurementRecordsEntity;
import org.springblade.desk.device.service.IMeasurementRecordsService;
import org.springframework.web.bind.annotation.RestController;
@RestController
@Hidden
public class LimsMeaToolTaskClientImpl implements LimsMeaToolTaskClient {
@Resource
private IMeasurementRecordsService measurementRecordsService;
@Override
public void syncMeasurementRecordsTask() {
IPage<MeasurementRecordsEntity> page = new Page<>(1, 9999);
measurementRecordsService.syncMeasurementRecords(page, 1);
}
}

@ -0,0 +1,39 @@
package org.springblade.desk.device.mapper;
import org.springblade.desk.device.pojo.entity.MeasurementRecordsEntity;
import org.springblade.desk.device.pojo.excel.MeasurementRecordsExcel;
import org.springblade.desk.device.pojo.vo.MeasurementRecordsVO;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 量具计量记录 Mapper 接口
*
* @author qyl
* @since 2026-03-03
*/
public interface MeasurementRecordsMapper extends BaseMapper<MeasurementRecordsEntity> {
/**
* 自定义分页
*
* @param page 分页参数
* @param mesMeasurementRecords 查询参数
* @return List<MeasurementRecordsVO>
*/
List<MeasurementRecordsVO> selectMeasurementRecordsPage(IPage page, MeasurementRecordsVO mesMeasurementRecords);
/**
* 获取导出数据
*
* @param queryWrapper 查询条件
* @return List<MeasurementRecordsExcel>
*/
List<MeasurementRecordsExcel> exportMeasurementRecords(@Param("ew") Wrapper<MeasurementRecordsEntity> queryWrapper);
}

@ -0,0 +1,62 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.springblade.desk.device.mapper.MeasurementRecordsMapper">
<!-- 通用查询映射结果 -->
<resultMap id="mesMeasurementRecordsResultMap"
type="org.springblade.desk.device.pojo.entity.MeasurementRecordsEntity">
<result column="ID" property="id"/>
<result column="TENANT_ID" property="tenantId"/>
<result column="CREATE_USER" property="createUser"/>
<result column="CREATE_TIME" property="createTime"/>
<result column="CREATE_DEPT" property="createDept"/>
<result column="UPDATE_USER" property="updateUser"/>
<result column="UPDATE_TIME" property="updateTime"/>
<result column="STATUS" property="status"/>
<result column="IS_DELETED" property="isDeleted"/>
<result column="MC_NAME" property="mcName"/>
<result column="NORMS" property="norms"/>
<result column="MC_CLASS" property="mcClass"/>
<result column="LABEL_NO" property="labelNo"/>
<result column="STR2" property="str2"/>
<result column="MC_CODE" property="mcCode"/>
<result column="USE_UNIT" property="useUnit"/>
<result column="ACCURACY" property="accuracy"/>
<result column="OEM_CODE" property="oemCode"/>
<result column="MC_OEM" property="mcOem"/>
<result column="ENABLE_DATE" property="enableDate"/>
<result column="WHEN_DCCEPT" property="whenDccept"/>
<result column="MC_TYPE" property="mcType"/>
<result column="TEST_CYCLE" property="testCycle"/>
<result column="DUE_DATE" property="dueDate"/>
<result column="DATE2" property="date2"/>
<result column="BELONG" property="belong"/>
<result column="WHEN_BUY" property="whenBuy"/>
<result column="TEST_DEPT" property="testDept"/>
<result column="TEST_METHOD" property="testMethod"/>
<result column="STR9" property="str9"/>
<result column="STR10" property="str10"/>
<result column="ASSETS_NO" property="assetsNo"/>
<result column="STR6" property="str6"/>
<result column="PURPOSE_CLASS" property="purposeClass"/>
<result column="IS_OVER_STR" property="isOverStr"/>
<result column="CM_TYPE" property="cmType"/>
<result column="CENSORSHIP" property="censorship"/>
<result column="CHECK_STATUS" property="checkStatus"/>
<result column="CHECK_RESULT" property="checkResult"/>
</resultMap>
<select id="selectMeasurementRecordsPage" resultMap="mesMeasurementRecordsResultMap">
select *
from MES_MEASUREMENT_RECORDS
where is_deleted = 0
</select>
<select id="exportMeasurementRecords" resultType="org.springblade.desk.device.pojo.excel.MeasurementRecordsExcel">
SELECT *
FROM MES_MEASUREMENT_RECORDS ${ew.customSqlSegment}
</select>
</mapper>

@ -2,8 +2,11 @@ package org.springblade.desk.device.service;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.springblade.core.mp.base.BaseService;
import org.springblade.core.tool.api.R;
import org.springblade.desk.device.pojo.entity.MeasurementRecordsEntity;
import org.springblade.desk.device.pojo.request.MeasuringUsageQuery;
import org.springblade.desk.device.pojo.vo.MeasurementRecordsVO;
/**
* 计量记录 服务类
@ -12,17 +15,24 @@ import org.springblade.desk.device.pojo.request.MeasuringUsageQuery;
* @since 2026年1月4日
*/
public interface IMeasurementRecordsService {
public interface IMeasurementRecordsService extends BaseService<MeasurementRecordsEntity> {
/**
* 自定义分页
*
* @param page 分页参数
* @param cmType 查询参数
* @return IPage<JSONObject>
* @param page 分页参数
* @param mesMeasurementRecords 查询参数
* @return IPage<MeasurementRecordsVO>
*/
IPage<MeasurementRecordsEntity> selectMeasurementRecordsPage(IPage<MeasurementRecordsEntity> page, Integer cmType);
IPage<MeasurementRecordsVO> selectMeasurementRecordsPage(IPage<MeasurementRecordsEntity> page, MeasurementRecordsVO mesMeasurementRecords);
/**
* 同步lims的量具计量记录
*
* @param page
* @param cmType 类型1仪表计量2设备计量
* @return
*/
R syncMeasurementRecords(IPage<MeasurementRecordsEntity> page, Integer cmType);
// /**
// * 导出数据
// *

@ -2,27 +2,39 @@ package org.springblade.desk.device.service.impl;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.nacos.common.utils.CollectionUtils;
import com.alibaba.nacos.shaded.com.google.common.collect.Lists;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import jodd.util.StringUtil;
import lombok.extern.slf4j.Slf4j;
import org.springblade.core.mp.base.BaseServiceImpl;
import org.springblade.core.tool.api.R;
import org.springblade.desk.device.mapper.MeasurementRecordsMapper;
import org.springblade.desk.device.pojo.entity.FeiBaSetEntity;
import org.springblade.desk.device.pojo.entity.MeasurementRecordsEntity;
import org.springblade.desk.device.pojo.request.MeasuringUsageQuery;
import org.springblade.desk.device.pojo.vo.MeasurementRecordsVO;
import org.springblade.desk.device.service.IMeasurementRecordsService;
import org.springblade.desk.device.service.IMeasuringUsageService;
import org.springblade.desk.device.wrapper.MeasurementRecordsWrapper;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
@Slf4j
@Service
public class IMeasurementRecordsServiceImpl implements IMeasurementRecordsService {
public class IMeasurementRecordsServiceImpl extends BaseServiceImpl<MeasurementRecordsMapper, MeasurementRecordsEntity> implements IMeasurementRecordsService {
// 使用JDK 17内置的HttpClient(线程安全,可复用)
private final HttpClient httpClient = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(30))
@ -33,7 +45,22 @@ public class IMeasurementRecordsServiceImpl implements IMeasurementRecordsServic
private String limsUrl;
@Override
public IPage<MeasurementRecordsEntity> selectMeasurementRecordsPage(IPage<MeasurementRecordsEntity> page, Integer cmType) {
public IPage<MeasurementRecordsVO> selectMeasurementRecordsPage(IPage<MeasurementRecordsEntity> page, MeasurementRecordsVO mesMeasurementRecords) {
// 1. 创建条件构造器
LambdaQueryWrapper<MeasurementRecordsEntity> wrapper = Wrappers.<MeasurementRecordsEntity>lambdaQuery();
// 2. 动态添加条件(核心!)
// 根据实体对象 entity 中字段是否为空,来动态拼接WHERE条件
wrapper.eq(Objects.nonNull(mesMeasurementRecords.getMcCode()), MeasurementRecordsEntity::getMcCode, mesMeasurementRecords.getMcCode());
// 3. 执行分页查询
IPage<MeasurementRecordsEntity> measurementRecordsEntityIPage = baseMapper.selectPage(page, wrapper);
return MeasurementRecordsWrapper.build().pageVO(measurementRecordsEntityIPage);
}
@Override
public R syncMeasurementRecords(IPage<MeasurementRecordsEntity> page, Integer cmType) {
// 构建请求体JSON
JSONObject requestBody = buildRequestBody(page, cmType);
@ -56,8 +83,7 @@ public class IMeasurementRecordsServiceImpl implements IMeasurementRecordsServic
} catch (Exception e) {
log.error("获取计量记录记录数据接口调用失败: {}", e.getMessage(), e);
List<MeasurementRecordsEntity> entityList1 = new ArrayList<>();
return page.setRecords(List.of()); // 返回空列表而不是null
return R.fail("获取计量记录记录数据接口调用失败");
}
}
@ -79,10 +105,10 @@ public class IMeasurementRecordsServiceImpl implements IMeasurementRecordsServic
/**
* 处理HTTP响应
*/
private IPage<MeasurementRecordsEntity> processResponse(HttpResponse<String> response, IPage<MeasurementRecordsEntity> page) {
private R processResponse(HttpResponse<String> response, IPage<MeasurementRecordsEntity> page) {
if (response.statusCode() != 200) {
log.error("HTTP请求失败,状态码: {}", response.statusCode());
throw new RuntimeException("HTTP请求失败,状态码: " + response.statusCode());
return R.fail("HTTP请求失败,状态码: " + response.statusCode());
}
/*String responseBody = "{\n" +
@ -300,7 +326,7 @@ public class IMeasurementRecordsServiceImpl implements IMeasurementRecordsServic
String responseBody = response.body();
if (responseBody == null || responseBody.trim().isEmpty()) {
log.error("响应体为空");
return page.setRecords(List.of());
return R.fail("响应体为空");
}
try {
@ -342,19 +368,95 @@ public class IMeasurementRecordsServiceImpl implements IMeasurementRecordsServic
measurementRecordsEntity.setIsOverStr(jsonObj.getString("isOverStr"));
list.add(measurementRecordsEntity);
}
return page.setRecords(list != null ? list : List.of());
return R.status(saveOrUpdateBatchByMcCode(list));
}
} else {
String errorMsg = result != null ? result.getString("message") : "未知错误";
log.error("接口返回错误: {}", errorMsg);
throw new RuntimeException("接口返回错误: " + errorMsg);
R.fail("接口返回错误: " + errorMsg);
}
} catch (Exception e) {
log.error("响应数据解析失败: {}", e.getMessage(), e);
throw new RuntimeException("响应数据解析失败: " + e.getMessage(), e);
R.fail("响应数据解析失败: " + e.getMessage());
}
return R.fail("处理失败");
}
/**
* 批量增改
*
* @param list
* @return
*/
public boolean saveOrUpdateBatchByMcCode(List<MeasurementRecordsEntity> list) {
if (CollectionUtils.isEmpty(list)) {
return false;
}
// 分批处理,提高性能
List<List<MeasurementRecordsEntity>> partitions = Lists.partition(list, 1000);
int totalAffected = 0;
for (List<MeasurementRecordsEntity> partition : partitions) {
// 按mcCode分组
Map<String, MeasurementRecordsEntity> codeToEntityMap = partition.stream()
.collect(Collectors.toMap(
MeasurementRecordsEntity::getMcCode,
Function.identity(),
(oldValue, newValue) -> newValue
));
// 1. 查询已存在的记录
List<String> mcCodes = new ArrayList<>(codeToEntityMap.keySet());
List<MeasurementRecordsEntity> existingList = this.lambdaQuery()
.in(MeasurementRecordsEntity::getMcCode, mcCodes)
.list();
// 2. 分离需要新增和更新的记录
Map<String, MeasurementRecordsEntity> existingMap = existingList.stream()
.collect(Collectors.toMap(MeasurementRecordsEntity::getMcCode, Function.identity()));
List<MeasurementRecordsEntity> toInsert = new ArrayList<>();
List<MeasurementRecordsEntity> toUpdate = new ArrayList<>();
Date now = new Date();
for (MeasurementRecordsEntity entity : partition) {
MeasurementRecordsEntity existingEntity = existingMap.get(entity.getMcCode());
if (existingEntity != null) {
// 更新记录
entity.setId(existingEntity.getId());
entity.setUpdateTime(now);
// 保持创建信息不变
entity.setCreateTime(existingEntity.getCreateTime());
toUpdate.add(entity);
} else {
// 新增记录
entity.setCreateTime(now);
entity.setUpdateTime(now);
toInsert.add(entity);
}
}
// 3. 批量操作
if (!toInsert.isEmpty()) {
boolean insertSuccess = this.saveBatch(toInsert);
if (insertSuccess) {
totalAffected += toInsert.size();
}
}
if (!toUpdate.isEmpty()) {
boolean updateSuccess = this.updateBatchById(toUpdate);
if (updateSuccess) {
totalAffected += toUpdate.size();
}
}
}
return page.setRecords(List.of());
log.info("批量增改处理完成,共处理 {} 条记录", totalAffected);
return totalAffected > 0;
}
}

@ -0,0 +1,35 @@
package org.springblade.desk.device.wrapper;
import org.springblade.core.mp.support.BaseEntityWrapper;
import org.springblade.core.tool.utils.BeanUtil;
import org.springblade.desk.device.pojo.entity.MeasurementRecordsEntity;
import org.springblade.desk.device.pojo.vo.MeasurementRecordsVO;
import java.util.Objects;
/**
* 量具计量记录 包装类,返回视图层所需的字段
*
* @author qyl
* @since 2026-03-03
*/
public class MeasurementRecordsWrapper extends BaseEntityWrapper<MeasurementRecordsEntity, MeasurementRecordsVO> {
public static MeasurementRecordsWrapper build() {
return new MeasurementRecordsWrapper();
}
@Override
public MeasurementRecordsVO entityVO(MeasurementRecordsEntity mesMeasurementRecords) {
MeasurementRecordsVO mesMeasurementRecordsVO = Objects.requireNonNull(BeanUtil.copyProperties(mesMeasurementRecords, MeasurementRecordsVO.class));
//User createUser = UserCache.getUser(mesMeasurementRecords.getCreateUser());
//User updateUser = UserCache.getUser(mesMeasurementRecords.getUpdateUser());
//mesMeasurementRecordsVO.setCreateUserName(createUser.getName());
//mesMeasurementRecordsVO.setUpdateUserName(updateUser.getName());
return mesMeasurementRecordsVO;
}
}

@ -16,4 +16,17 @@ public interface AgvConstant {
*/
public static final String EQUIPMENT_TYPE_CTU = "05";
/**
* 任务模板CTU
*/
public static final String CTU_TASK_TYP = "QM1";
/**
* 容器类型CTU
*/
public static final String CTU_CTNR_TYP = "1";
}

@ -35,7 +35,9 @@ import org.springblade.core.boot.ctrl.BladeController;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.tool.api.R;
import org.springblade.desk.basic.util.StatusCountMap;
import org.springblade.desk.logistics.pojo.entity.Station;
import org.springblade.desk.logistics.service.IPipelineService;
import org.springblade.desk.logistics.utils.AgvTaskTypeUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
@ -145,6 +147,8 @@ public class PipelineController extends BladeController {
return R.data(isPassed);
}
@Autowired
AgvTaskTypeUtil agvTaskTypeUtil;
/**
* 接收空物料箱到输送线通知
@ -162,6 +166,21 @@ public class PipelineController extends BladeController {
}
/**
* 接收空物料箱到输送线通知
*/
@GetMapping("/test")
@ApiOperationSupport(order = 4)
@Operation(summary = "接收物料箱", description = "传入箱条码")
public R test(@RequestParam String test1,@RequestParam String test2) {
String taskType = agvTaskTypeUtil.getTaskTypeByPositions(test1,test2);
return R.data(true);
}

@ -11,5 +11,5 @@ public interface StationMapper extends BaseMapper<Station> {
List<Station> selectByWcId(@Param("wcId") Long wcId);
Station selectByStationPosition(@Param("StationPosition") String freeStationCode);
Station selectByStationCode(@Param("StationCode") String StationCode);
}

@ -10,8 +10,8 @@
from LM_STATION where IS_DELETED = 0 and WC_ID = #{wcId}
</select>
<select id="selectByStationPosition" resultType="org.springblade.desk.logistics.pojo.entity.Station">
<select id="selectByStationCode" resultType="org.springblade.desk.logistics.pojo.entity.Station">
select id, station_name, station_code, station_status, status, create_user, create_time, create_dept, update_user, update_time, is_deleted, remark, station_position, wc_id
from LM_STATION where IS_DELETED = 0 and STATION_POSITION = #{StationPosition}
from LM_STATION where IS_DELETED = 0 and STATION_CODE = #{StationCode}
</select>
</mapper>

@ -48,8 +48,8 @@ public interface IStationService extends BaseService<Station> {
/**
* 根据站点编码 查询站点信息
* @param freeStationCode
* @param stationCode
* @return
*/
Station getByStationPosition(String freeStationCode);
Station getByStationCode(String stationCode);
}

@ -45,9 +45,8 @@ public interface ITaskService extends BaseService<Task> {
* 保存输送线称重数据
* @param boxBarcode 箱条码
* @param actualWeight 输送线重量
* @param statusReturned 任务状态
*/
void savePipelineWeigh(String boxBarcode, BigDecimal actualWeight, Integer statusReturned);
void savePipelineWeigh(String boxBarcode, BigDecimal actualWeight);
/**
* 获取输送箱信息

@ -70,13 +70,10 @@ public class IOrderBoxServiceImpl implements IOrderBoxService {
static {
// 初始化运行中任务状态
RUNNING_STATUSES.add(Task.STATUS_START); // 任务启动
RUNNING_STATUSES.add(Task.STATUS_CONVEYOR_START); // 输送机启动
RUNNING_STATUSES.add(Task.STATUS_CONVEYOR_END); // 输送机结束
RUNNING_STATUSES.add(Task.STATUS_STATION); // 站点状态
RUNNING_STATUSES.add(Task.STATUS_LOCATION); // 库位状态
RUNNING_STATUSES.add(Task.STATUS_WAITING); // 等待状态
RUNNING_STATUSES.add(Task.STATUS_STATION_RECEIVE);// 站点接收
RUNNING_STATUSES.add(Task.STATUS_BACK_TO_STORAGE);// 返库状态
RUNNING_STATUSES.add(Task.STATUS_RETURNED); // 退回
RUNNING_STATUSES.add(Task.STATUS_CONVEYOR_END); // 配送
RUNNING_STATUSES.add(Task.STATUS_FINISHED); // 结束
RUNNING_STATUSES.add(Task.STATUS_FAILING); // 失败
}
public IOrderBoxServiceImpl(IYieldOrderService iYieldOrderService, ITaskService iTaskService, IOrderBindService iOrderBindService, IStationService iStationService, ILocationService iLocationService, AgvTaskTypeUtil agvTaskTypeUtil, IBsWorkCenterService bsWorkCenterService, ITaskExecuteRecordService iTaskExecuteRecordService) {
@ -324,7 +321,7 @@ public class IOrderBoxServiceImpl implements IOrderBoxService {
try {
// 2. 获取AGV任务类型并调用调度接口
String taskType = agvTaskTypeUtil.getTaskType(Integer.valueOf(targetStation.getStationPosition()), true);
String taskType = agvTaskTypeUtil.getTaskTypeByPositions(stationCode,DROPOFF_CONVEYOR_LINE);
boolean agvResult = iTaskExecuteRecordService.genAgvSchedulingTask(
taskType, stationCode, DROPOFF_CONVEYOR_LINE, EQUIPMENT_TYPE_AGV, taskList.get(0)
);
@ -358,7 +355,7 @@ public class IOrderBoxServiceImpl implements IOrderBoxService {
try {
// 3. 获取AGV任务类型并调用调度接口
String taskType = agvTaskTypeUtil.getTaskType(Integer.valueOf(targetStation.getStationPosition()), false);
String taskType = agvTaskTypeUtil.getTaskTypeByPositions(sourceStationCode,endStation.getStationCode());
boolean agvResult = iTaskExecuteRecordService.genAgvSchedulingTask(
taskType, sourceStationCode, endStation.getStationCode(), EQUIPMENT_TYPE_AGV, taskList.get(0)
);

@ -46,15 +46,13 @@ public class IPipelineOrderBoxServiceImpl implements IPipelineOrderBoxService {
private static final Set<Integer> RUNNING_STATUSES = new HashSet<>();
static {
// 初始化运行中任务状态
RUNNING_STATUSES.add(Task.STATUS_START); // 任务启动
RUNNING_STATUSES.add(Task.STATUS_CONVEYOR_START); // 输送机启动
RUNNING_STATUSES.add(Task.STATUS_CONVEYOR_END); // 输送机结束
RUNNING_STATUSES.add(Task.STATUS_STATION); // 站点状态
RUNNING_STATUSES.add(Task.STATUS_LOCATION); // 库位状态
RUNNING_STATUSES.add(Task.STATUS_WAITING); // 等待状态
RUNNING_STATUSES.add(Task.STATUS_STATION_RECEIVE);// 站点接收
RUNNING_STATUSES.add(Task.STATUS_BACK_TO_STORAGE);// 返库状态
// // 初始化运行中任务状态
// RUNNING_STATUSES.add(Task.STATUS_START); // 任务启动
// RUNNING_STATUSES.add(Task.STATUS_CONVEYOR_END); // 输送机结束
// RUNNING_STATUSES.add(Task.STATUS_LOCATION); // 库位状态
// RUNNING_STATUSES.add(Task.STATUS_WAITING); // 等待状态
// RUNNING_STATUSES.add(Task.STATUS_STATION_RECEIVE);// 站点接收
// RUNNING_STATUSES.add(Task.STATUS_BACK_TO_STORAGE);// 返库状态
}
public IPipelineOrderBoxServiceImpl(ITaskService iTaskService, IStationService iStationService, ILocationService iLocationService, IOrderBindService iOrderBindService) {

@ -78,7 +78,7 @@ public class PipelineServiceImpl implements IPipelineService {
// 1. 判断是否超重
if (WeighData.RETURN_STATUS_RETURNED.equals(returnStatus)) {
// 2. 保存称重数据
taskService.savePipelineWeigh(boxBarcode,actualWeight, Task.STATUS_RETURNED);
taskService.savePipelineWeigh(boxBarcode,actualWeight);
// 3.超重处理,解绑
R ret = iPipelineOrderBoxService.boxOrderUnbind(boxBarcode);
@ -89,7 +89,7 @@ public class PipelineServiceImpl implements IPipelineService {
return false;
} else {
// 2. 保存称重数据
taskService.savePipelineWeigh(boxBarcode,actualWeight, Task.STATUS_CONVEYOR_START);
taskService.savePipelineWeigh(boxBarcode,actualWeight);
log.info("物料箱[{}]重量校验通过", boxBarcode);
return true;
}
@ -152,8 +152,7 @@ public class PipelineServiceImpl implements IPipelineService {
log.info("站点有预占,将物料箱送往指定站点:{}", station.getStationCode());
String stationPosition = station.getStationPosition();
String taskType = agvTaskTypeUtil.getTaskType(Integer.parseInt(stationPosition));
String taskType = agvTaskTypeUtil.getTaskTypeByPositions(Station.PICKUP_CONVEYOR_LINE,station.getStationCode());
// 入库记录
Task task = taskService.getBoxBarcode(boxBarcode);
@ -178,8 +177,7 @@ public class PipelineServiceImpl implements IPipelineService {
if (null != station) {
log.info("找到空闲站点:{},将物料箱送往该站点", station.getStationCode());
String stationPosition = station.getStationPosition();
String taskType = agvTaskTypeUtil.getTaskType(Integer.parseInt(stationPosition));
String taskType = agvTaskTypeUtil.getTaskTypeByPositions(Station.PICKUP_CONVEYOR_LINE,station.getStationCode());
boolean agvSchedulingTask = iTaskExecuteRecordService.genAgvSchedulingTask
(taskType, Station.PICKUP_CONVEYOR_LINE, station.getStationCode(), AgvConstant.EQUIPMENT_TYPE_AGV, task);

@ -54,7 +54,7 @@ public class StationServiceImpl extends BaseServiceImpl<StationMapper, Station>
}
@Override
public Station getByStationPosition(String freeStationCode) {
return stationMapper.selectByStationPosition(freeStationCode);
public Station getByStationCode(String stationCode) {
return stationMapper.selectByStationCode(stationCode);
}
}

@ -182,7 +182,7 @@ public class StorageMonitoringServiceImpl implements IStorageMonitoringService {
String locationCode = locationList.get(0).getLocationCode();
//调用ctu
AgvSchedulingTaskVO ctuSchedulingTask = taskExecuteRecordService.genCtuSchedulingTask("QM1", "1", firstTask.getBoxBarcode(), location.getLocationCode(),
AgvSchedulingTaskVO ctuSchedulingTask = taskExecuteRecordService.genCtuSchedulingTask(AgvConstant.CTU_TASK_TYP, AgvConstant.CTU_CTNR_TYP, firstTask.getBoxBarcode(), location.getLocationCode(),
locationCode, AgvConstant.EQUIPMENT_TYPE_CTU);
//调用成功 添加任务

@ -292,7 +292,7 @@ public class TaskExecuteRecordServiceImpl extends BaseServiceImpl<TaskExecuteRe
if(null == task.getLocationId()){
//证明不需要送到库位
//更新task状态 根据taskCode查询
task.setTaskStatus(Task.STATUS_STATION);
task.setTaskStatus(Task.STATUS_FINISHED);
boolean taskUpdate = taskService.updateById(task);
if(!taskUpdate){
log.error("Task状态修改失败");
@ -303,10 +303,10 @@ public class TaskExecuteRecordServiceImpl extends BaseServiceImpl<TaskExecuteRe
Location location = locationService.getById(task.getLocationId());
AgvSchedulingTaskVO ctuSchedulingTask = genCtuSchedulingTask
("QM1", "1", task.getBoxBarcode(), taskExecuteRecord.getEndPos(), location.getLocationCode(), AgvConstant.EQUIPMENT_TYPE_CTU);
(AgvConstant.CTU_TASK_TYP, AgvConstant.CTU_CTNR_TYP, task.getBoxBarcode(), taskExecuteRecord.getEndPos(), location.getLocationCode(), AgvConstant.EQUIPMENT_TYPE_CTU);
if(null != ctuSchedulingTask){
task.setTaskStatus(Task.STATUS_LOCATION);
task.setTaskStatus(Task.STATUS_FINISHED);
boolean taskUpdate = taskService.updateById(task);
if(!taskUpdate){
log.error("Task状态修改失败");
@ -423,7 +423,7 @@ public class TaskExecuteRecordServiceImpl extends BaseServiceImpl<TaskExecuteRe
//调用agv小车
// 调用AGV
String taskType = agvTaskTypeUtil.getTaskType(Integer.valueOf(station.getStationPosition()));
String taskType = agvTaskTypeUtil.getTaskTypeByPositions(location.getLocationCode(),station.getStationCode());
boolean agvResult = genAgvSchedulingTask(
taskType, location.getLocationCode(),station.getStationCode() , EQUIPMENT_TYPE_AGV, task

@ -56,12 +56,11 @@ public class TaskServiceImpl extends BaseServiceImpl<TaskMapper, Task> implement
TaskMapper taskMapper;
@Override
public void savePipelineWeigh(String boxBarcode, BigDecimal actualWeight, Integer statusReturned) {
public void savePipelineWeigh(String boxBarcode, BigDecimal actualWeight) {
// 1.查询物料箱 筛选状态
Task task = taskMapper.selectByBoxBarcode(boxBarcode);
// 2.更新重量以及任务状态
task.setMachineWeight(actualWeight);
task.setTaskStatus(statusReturned);
taskMapper.updateById(task);
}

@ -1,4 +1,7 @@
package org.springblade.desk.logistics.utils;
import org.springblade.desk.logistics.pojo.entity.Station;
import org.springblade.desk.logistics.service.IStationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
@ -9,103 +12,85 @@ import lombok.extern.slf4j.Slf4j;
@Service
public class AgvTaskTypeUtil {
@Autowired
IStationService stationService;
/**
* 获取AGV任务类型
* @param floor 楼层 (1:一层, 3:三层)
* @param isRecycle 是否回收 (true:空箱回收, false:正常任务)
* @return 任务类型 (QM3, QM5, QM6, QM7)
* 根据起点和终点获取AGV任务类型
* @param startPosition 起点位置编码 (1001/1002/站点code)
* @param endPosition 终点位置编码 (1001/1002/站点code)
* @return 任务类型 (QM, QM3, QM5, QM6, QM7)
*/
public String getTaskType(Integer floor, Boolean isRecycle) {
public String getTaskTypeByPositions(String startPosition, String endPosition) {
// 参数校验
if (floor == null) {
log.error("楼层参数不能为空");
throw new IllegalArgumentException("楼层参数不能为空");
if (startPosition == null || endPosition == null) {
log.error("起点或终点位置不能为空");
throw new IllegalArgumentException("起点和终点位置不能为空");
}
// 默认isRecycle为false
isRecycle = isRecycle != null ? isRecycle : false;
String taskType;
// 判断起点和终点的类型及楼层
boolean isStartConveyorStart = "1002".equals(startPosition);
boolean isStartConveyorEnd = "1001".equals(startPosition);
boolean isEndConveyorStart = "1002".equals(endPosition);
boolean isEndConveyorEnd = "1001".equals(endPosition);
switch (floor) {
case 1:
// 一层
if (isRecycle) {
// 一层空箱回收 -> QM6 (同楼层放货放到输送线上)
taskType = "QM6";
log.info("一层空箱回收任务,使用QM6");
} else {
// 一层正常任务 -> QM7 (输送线取货放到普通梳齿架站点)
taskType = "QM7";
log.info("一层正常任务,使用QM7");
}
break;
// 获取站点楼层(如果不是站点,返回null)
Integer startFloor = null;
Integer endFloor = null;
case 3:
// 三层
if (isRecycle) {
// 三层空箱回收 -> QM5 (三楼站点取货放到三楼电梯接驳位到一层)
taskType = "QM5";
log.info("三层空箱回收任务,使用QM5");
} else {
// 三层正常任务 -> QM3 (输送线取货-电梯跨楼层)
taskType = "QM3";
log.info("三层正常任务,使用QM3");
}
break;
if (!isStartConveyorStart && !isStartConveyorEnd) {
// 起点是站点,查询楼层
Station startStation = stationService.getByStationCode(startPosition);
if (startStation == null) {
log.error("未找到起点站点信息,站点编码:{}", startPosition);
throw new IllegalArgumentException("无效的起点站点编码:" + startPosition);
}
startFloor = Integer.parseInt(startStation.getStationPosition());
}
default:
log.error("不支持的楼层:{}", floor);
throw new IllegalArgumentException("不支持的楼层:" + floor);
if (!isEndConveyorStart && !isEndConveyorEnd) {
// 终点是站点,查询楼层
Station endStation = stationService.getByStationCode(endPosition);
if (endStation == null) {
log.error("未找到终点站点信息,站点编码:{}", endPosition);
throw new IllegalArgumentException("无效的终点站点编码:" + endPosition);
}
endFloor = Integer.parseInt(endStation.getStationPosition());
}
return taskType;
}
// 场景1: 站点 <-----> 站点 -> QM
if (startFloor != null && endFloor != null) {
log.info("站点到站点任务,使用QM");
return "QM";
}
/**
* 获取AGV任务类型简化版只传楼层
* @param floor 楼层
* @return 任务类型
*/
public String getTaskType(Integer floor) {
return getTaskType(floor, false);
}
// 场景2: 输送线起点(1002) ---> 站点(一层) -> QM7
if (isStartConveyorStart && endFloor != null && endFloor == 1) {
log.info("输送线起点到一层站点任务,使用QM7");
return "QM7";
}
/**
* 判断是否为跨楼层任务
* @param taskType 任务类型
* @return true:跨楼层 false:同楼层
*/
public boolean isCrossFloor(String taskType) {
return "QM3".equals(taskType) || "QM5".equals(taskType);
}
// 场景3: 站点(一层) ----> 输送线终点(1001) -> QM6
if (startFloor != null && startFloor == 1 && isEndConveyorEnd) {
log.info("一层站点到输送线终点任务,使用QM6");
return "QM6";
}
/**
* 判断是否为回收任务
* @param taskType 任务类型
* @return true:回收任务 false:正常任务
*/
public boolean isRecycleTask(String taskType) {
return "QM5".equals(taskType) || "QM6".equals(taskType);
}
// 场景4: 输送线起点(1002) ---> 站点(二层) -> QM3
if (isStartConveyorStart && endFloor != null && endFloor == 2) {
log.info("输送线起点到二层站点任务,使用QM3");
return "QM3";
}
/**
* 获取任务描述
* @param taskType 任务类型
* @return 任务描述
*/
public String getTaskDescription(String taskType) {
switch (taskType) {
case "QM3":
return "输送线取货-电梯跨楼层(小车不做电梯),货物放电梯接驳位,三楼小车接货后放到目标站点";
case "QM5":
return "三楼站点取货放到三楼电梯接驳位到一层后,一楼小车取电梯内货物放到输送线(空箱回收)";
case "QM6":
return "同楼层放货放到输送线上(不跨楼层)";
case "QM7":
return "输送线取货放到普通梳齿架站点(不跨电梯仅同楼层)";
default:
return "未知任务类型";
// 场景5: 站点(二层) ----> 输送线终点(1001) -> QM5
if (startFloor != null && startFloor == 2 && isEndConveyorEnd) {
log.info("二层站点到输送线终点任务,使用QM5");
return "QM5";
}
// 其他情况,记录日志并抛出异常
log.error("无法确定任务类型,起点:{},终点:{}", startPosition, endPosition);
throw new IllegalArgumentException("无法确定任务类型,请检查起点和终点位置的组合");
}
}

Loading…
Cancel
Save