Merge remote-tracking branch 'origin/master'

blade-ops/blade-job/src/main/java/org/springblade/job/processor/device/LimsMeasuringToolProcessor.java

@@ -0,0 +1,55 @@
+package org.springblade.job.processor.device;
+
+import com.baomidou.mybatisplus.core.toolkit.StringUtils;
+import jakarta.annotation.Resource;
+import lombok.Data;
+import lombok.extern.slf4j.Slf4j;
+import org.springblade.desk.device.feign.LimsMeaToolTaskClient;
+import org.springblade.desk.device.feign.MesMeasuringToolClient;
+import org.springblade.desk.device.pojo.entity.MeasurementRecordsEntity;
+import org.springblade.desk.device.pojo.entity.MesMeasuringToolEntity;
+import org.springframework.stereotype.Component;
+import org.springframework.util.CollectionUtils;
+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.ArrayList;
+import java.util.List;
+
+@Data
+@Component
+@Slf4j
+public class LimsMeasuringToolProcessor implements BasicProcessor {
+
+    @Resource
+    private LimsMeaToolTaskClient limsMeaToolTaskClient;
+    @Resource
+    private MesMeasuringToolClient mesMeasuringToolClient;
+
+    @Override
+    public ProcessResult process(TaskContext context) throws Exception {
+        log.info("同步lims检验量具任务开始");
+        List<MesMeasuringToolEntity> checkToolList = mesMeasuringToolClient.selectCheckTool();
+        if (!CollectionUtils.isEmpty(checkToolList)) {
+            List<MeasurementRecordsEntity> limsList = limsMeaToolTaskClient.selectSyncMeasurementRecordsTask();
+            List<MesMeasuringToolEntity> updList = new ArrayList<>();
+            if (!CollectionUtils.isEmpty(limsList)) {
+                for (MesMeasuringToolEntity mesMeasuringToolEntity : checkToolList) {
+                    MeasurementRecordsEntity lims = limsList.stream().filter(e -> StringUtils.isNotEmpty(e.getMcCode()) && e.getMcCode().equals(mesMeasuringToolEntity.getToolCode())).findFirst().orElse(null);
+                    if (lims != null) {
+                        MesMeasuringToolEntity upd = new MesMeasuringToolEntity();
+                        upd.setId(mesMeasuringToolEntity.getId());
+                        upd.setDueDate(lims.getDueDate());
+                        updList.add(upd);
+                    }
+                }
+            }
+            if (!CollectionUtils.isEmpty(updList)) {
+                mesMeasuringToolClient.saveOrUpdateBatch(updList);
+            }
+        }
+        log.info("同步lims检验量具任务结束");
+        return new ProcessResult(true);
+    }
+}

blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/device/feign/LimsMeaToolTaskClient.java

@@ -1,9 +1,13 @@
 package org.springblade.desk.device.feign;
 
 import org.springblade.core.launch.constant.AppConstant;
+import org.springblade.core.tool.api.R;
+import org.springblade.desk.device.pojo.entity.MeasurementRecordsEntity;
 import org.springframework.cloud.openfeign.FeignClient;
 import org.springframework.web.bind.annotation.GetMapping;
 
+import java.util.List;
+
 @FeignClient(
         value = AppConstant.APPLICATION_DESK_NAME
 )
@@ -16,10 +20,15 @@ public interface LimsMeaToolTaskClient {
 
     String SYNC_MEASUREMENT_RECORDS_TASK = API_PREFIX + "/sync-measurement-records-task";
 
+    String SELECT_SYNC_MEASUREMENT_RECORDS_TASK = API_PREFIX + "/select-sync-measurement-records-task";
+
 
     /**
      * 同步量具数据
      */
     @GetMapping(SYNC_MEASUREMENT_RECORDS_TASK)
     void syncMeasurementRecordsTask();
+
+    @GetMapping(SELECT_SYNC_MEASUREMENT_RECORDS_TASK)
+    List<MeasurementRecordsEntity> selectSyncMeasurementRecordsTask();
 }

blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/device/feign/MesMeasuringToolClient.java

@@ -0,0 +1,29 @@
+package org.springblade.desk.device.feign;
+
+import oracle.jdbc.proxy.annotation.Post;
+import org.springblade.core.launch.constant.AppConstant;
+import org.springblade.desk.device.pojo.entity.MesMeasuringToolEntity;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+
+import java.util.List;
+
+@FeignClient(
+        value = AppConstant.APPLICATION_DESK_NAME
+)
+public interface MesMeasuringToolClient {
+
+    String API_PREFIX = "/feign/client/mes_measuring_tool";
+
+    String SELECT_CHECK_TOOL = API_PREFIX + "/select-check-tool";
+
+    String SAVE_OR_UPDATE_BATCH = API_PREFIX + "/save-or-update-batch";
+
+    @GetMapping(SELECT_CHECK_TOOL)
+    List<MesMeasuringToolEntity> selectCheckTool();
+
+    @PostMapping(SAVE_OR_UPDATE_BATCH)
+    boolean saveOrUpdateBatch(@RequestBody List<MesMeasuringToolEntity> list);
+}

blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/device/pojo/entity/MesMeasuringToolEntity.java

@@ -0,0 +1,50 @@
+package org.springblade.desk.device.pojo.entity;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.springblade.core.mp.base.BaseEntity;
+
+import java.io.Serial;
+import java.util.Date;
+
+@Data
+@TableName("MES_MEASURING_TOOL")
+@Schema(description = "MesMeasuringTool对象")
+@EqualsAndHashCode(callSuper = true)
+public class MesMeasuringToolEntity extends BaseEntity {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 量具编码
+     */
+    @Schema(description = "量具编码")
+    private String toolCode;
+
+    /**
+     * 量具名称
+     */
+    @Schema(description = "量具名称")
+    private String toolName;
+
+    /**
+     * 量具尺寸
+     */
+    @Schema(description = "量具尺寸")
+    private String toolSize;
+
+    /**
+     * 量具类型:1-工艺量具, 2-检验量具
+     */
+    @Schema(description = "量具类型")
+    private String toolType;
+
+    /**
+     * 到期日
+     */
+    @Schema(description = "到期日")
+    private Date dueDate;
+}

blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/device/pojo/excel/MesMeasuringToolCheckExcel.java

@@ -0,0 +1,37 @@
+package org.springblade.desk.device.pojo.excel;
+
+import com.alibaba.excel.annotation.ExcelProperty;
+import com.alibaba.excel.annotation.write.style.ColumnWidth;
+import com.alibaba.excel.annotation.write.style.ContentRowHeight;
+import com.alibaba.excel.annotation.write.style.HeadRowHeight;
+import lombok.Data;
+
+import java.io.Serial;
+import java.io.Serializable;
+import java.util.Date;
+
+@Data
+@ColumnWidth(25)
+@HeadRowHeight(20)
+@ContentRowHeight(18)
+public class MesMeasuringToolCheckExcel implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+    @ColumnWidth(20)
+    @ExcelProperty("量具编码")
+    private String toolCode;
+
+    @ColumnWidth(20)
+    @ExcelProperty("到期日期")
+    private Date dueDate;
+
+    @ColumnWidth(20)
+    @ExcelProperty("维护人")
+    private String updateUserName;
+
+    @ColumnWidth(20)
+    @ExcelProperty("维护时间")
+    private Date updateTime;
+}

blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/device/pojo/excel/MesMeasuringToolImportExcel.java

@@ -0,0 +1,39 @@
+package org.springblade.desk.device.pojo.excel;
+
+import com.alibaba.excel.annotation.ExcelProperty;
+import com.alibaba.excel.annotation.write.style.ColumnWidth;
+import com.alibaba.excel.annotation.write.style.ContentRowHeight;
+import com.alibaba.excel.annotation.write.style.HeadRowHeight;
+import lombok.Data;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.io.Serial;
+import java.io.Serializable;
+import java.util.Date;
+
+@Data
+@ColumnWidth(25)
+@HeadRowHeight(20)
+@ContentRowHeight(18)
+public class MesMeasuringToolImportExcel implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+    @ColumnWidth(20)
+    @ExcelProperty("量具编码")
+    private String toolCode;
+
+    @ColumnWidth(20)
+    @ExcelProperty("量具名称")
+    private String toolName;
+
+    @ColumnWidth(20)
+    @ExcelProperty("到期日期")
+    @DateTimeFormat(pattern = "yyyy-MM-dd")
+    private Date dueDate;
+
+    @ColumnWidth(20)
+    @ExcelProperty("尺寸")
+    private String toolSize;
+}

blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/device/pojo/excel/MesMeasuringToolProcessExcel.java

@@ -0,0 +1,37 @@
+package org.springblade.desk.device.pojo.excel;
+
+import com.alibaba.excel.annotation.ExcelProperty;
+import com.alibaba.excel.annotation.write.style.ColumnWidth;
+import com.alibaba.excel.annotation.write.style.ContentRowHeight;
+import com.alibaba.excel.annotation.write.style.HeadRowHeight;
+import lombok.Data;
+
+import java.io.Serial;
+import java.io.Serializable;
+import java.util.Date;
+
+@Data
+@ColumnWidth(25)
+@HeadRowHeight(20)
+@ContentRowHeight(18)
+public class MesMeasuringToolProcessExcel implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+    @ColumnWidth(20)
+    @ExcelProperty("量具名称")
+    private String toolName;
+
+    @ColumnWidth(20)
+    @ExcelProperty("尺寸")
+    private String toolSize;
+
+    @ColumnWidth(20)
+    @ExcelProperty("维护人")
+    private String updateUserName;
+
+    @ColumnWidth(20)
+    @ExcelProperty("维护时间")
+    private Date updateTime;
+}

blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/device/pojo/vo/MesMeasuringToolVO.java

@@ -0,0 +1,19 @@
+package org.springblade.desk.device.pojo.vo;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.springblade.desk.device.pojo.entity.MesMeasuringToolEntity;
+
+import java.io.Serial;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class MesMeasuringToolVO extends MesMeasuringToolEntity {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "维护人")
+    private String updateUserName;
+}

blade-service/blade-desk/src/main/java/org/springblade/desk/device/controller/MeasurementRecordsController.java

@@ -66,8 +66,7 @@ public class MeasurementRecordsController extends BladeController {
     @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 mesMeasurementRecordsService.selectSyncMeasurementRecordsPage(Condition.getPage(query), mesMeasurementRecords);
-        return R.data(pages);
     }
 
     //查询合格的量具

blade-service/blade-desk/src/main/java/org/springblade/desk/device/controller/MesMeasuringToolController.java

@@ -0,0 +1,212 @@
+package org.springblade.desk.device.controller;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.core.toolkit.StringUtils;
+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;
+import org.springblade.core.mp.support.Condition;
+import org.springblade.core.mp.support.Query;
+import org.springblade.core.secure.BladeUser;
+import org.springblade.core.secure.annotation.IsAdmin;
+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.basic.util.ExcelExtUtil;
+import org.springblade.desk.device.pojo.entity.MesMeasuringToolEntity;
+import org.springblade.desk.device.pojo.excel.MesMeasuringToolCheckExcel;
+import org.springblade.desk.device.pojo.excel.MesMeasuringToolImportExcel;
+import org.springblade.desk.device.pojo.excel.MesMeasuringToolProcessExcel;
+import org.springblade.desk.device.pojo.vo.MesMeasuringToolVO;
+import org.springblade.desk.device.service.IMesMeasuringToolService;
+import org.springframework.beans.BeanUtils;
+import org.springframework.core.io.Resource;
+import org.springframework.http.ResponseEntity;
+import org.springframework.util.CollectionUtils;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * 设备量具控制类
+ */
+@RestController
+@AllArgsConstructor
+@RequestMapping("/mesMeasuringTool")
+@Tag(name = "设备量具", description = "设备量具接口")
+public class MesMeasuringToolController extends BladeController {
+
+    private final IMesMeasuringToolService mesMeasuringToolService;
+
+    @GetMapping("/page")
+    @Operation(summary = "分页", description = "传入bsEnergyQuota")
+    public R<IPage<MesMeasuringToolVO>> page(MesMeasuringToolEntity mesMeasuringTool, Query query) {
+        IPage<MesMeasuringToolVO> pages = mesMeasuringToolService.selectMeaToolPage(Condition.getPage(query), mesMeasuringTool);
+        return R.data(pages);
+    }
+
+    /**
+     * 能源定额 新增或修改
+     */
+    @PostMapping("/submit")
+    @Operation(summary = "新增或修改", description = "传入bsEnergyQuota")
+    public R submit(@Valid @RequestBody MesMeasuringToolEntity mesMeasuringTool) {
+        LambdaQueryWrapper<MesMeasuringToolEntity> qw = new LambdaQueryWrapper<MesMeasuringToolEntity>().eq(MesMeasuringToolEntity::getToolType, mesMeasuringTool.getToolType());
+        if (StringUtils.isEmpty(mesMeasuringTool.getToolType()) || !("1".equals(mesMeasuringTool.getToolType()) || "2".equals(mesMeasuringTool.getToolType()))) {
+            return R.fail("未知量具类型");
+        }
+        if ("1".equals(mesMeasuringTool.getToolType())) {
+            if (StringUtils.isEmpty(mesMeasuringTool.getToolName())) {
+                return R.fail("名称为空");
+            }
+            qw.eq(MesMeasuringToolEntity::getToolName, mesMeasuringTool.getToolName());
+        } else if ("2".equals(mesMeasuringTool.getToolType())) {
+            if (StringUtils.isEmpty(mesMeasuringTool.getToolCode())) {
+                return R.fail("编码为空");
+            }
+            qw.eq(MesMeasuringToolEntity::getToolCode, mesMeasuringTool.getToolCode());
+        }
+        if (mesMeasuringTool.getId() != null) {
+            qw.ne(MesMeasuringToolEntity::getId, mesMeasuringTool.getId());
+        }
+        List<MesMeasuringToolEntity> exist = mesMeasuringToolService.list(qw);
+        if (!CollectionUtils.isEmpty(exist)) {
+            return R.fail("量具已存在");
+        }
+        return R.status(mesMeasuringToolService.saveOrUpdate(mesMeasuringTool));
+    }
+
+    @PostMapping("/remove")
+    @Operation(summary = "逻辑删除", description = "传入ids")
+    public R remove(@Parameter(description = "主键集合", required = true) @RequestParam String ids) {
+        return R.status(mesMeasuringToolService.deleteLogic(Func.toLongList(ids)));
+    }
+
+    /**
+     * 导出数据
+     */
+    @IsAdmin
+    @GetMapping("/export-process")
+    @Operation(summary = "导出数据", description = "传入bsEnergyMonitor")
+    public void exportProcess(MesMeasuringToolEntity mesMeasuringTool, BladeUser bladeUser, HttpServletResponse response) {
+        mesMeasuringTool.setToolType("1");
+        List<MesMeasuringToolVO> list = mesMeasuringToolService.selectMeaTool(mesMeasuringTool);
+        List<MesMeasuringToolProcessExcel> excels = new ArrayList<>();
+        for (MesMeasuringToolVO vo : list) {
+            MesMeasuringToolProcessExcel excel = new MesMeasuringToolProcessExcel();
+            BeanUtils.copyProperties(vo, excel);
+            excels.add(excel);
+        }
+        ExcelUtil.export(response, "工艺量具" + DateUtil.time(), "工艺量具", excels, MesMeasuringToolProcessExcel.class);
+    }
+
+    /**
+     * 导出数据
+     */
+    @IsAdmin
+    @GetMapping("/export-check")
+    @Operation(summary = "导出数据", description = "传入bsEnergyMonitor")
+    public void exportCheck(MesMeasuringToolEntity mesMeasuringTool, BladeUser bladeUser, HttpServletResponse response) {
+        mesMeasuringTool.setToolType("2");
+        List<MesMeasuringToolVO> list = mesMeasuringToolService.selectMeaTool(mesMeasuringTool);
+        List<MesMeasuringToolCheckExcel> excels = new ArrayList<>();
+        for (MesMeasuringToolVO vo : list) {
+            MesMeasuringToolCheckExcel excel = new MesMeasuringToolCheckExcel();
+            BeanUtils.copyProperties(vo, excel);
+            excels.add(excel);
+        }
+        ExcelUtil.export(response, "检验量具" + DateUtil.time(), "检验量具", excels, MesMeasuringToolCheckExcel.class);
+    }
+
+    @GetMapping("/process-download-excel-template")
+    @Operation(summary = "下载Excel模板", description = "")
+    public ResponseEntity<Resource> processDownloadExcelTemplate() {
+        return ExcelExtUtil.downloadXlsTemplate(
+                "Excel/device/工艺量具.xls",
+                "导入模版-工艺量具.xls");
+    }
+
+    @GetMapping("/check-download-excel-template")
+    @Operation(summary = "下载Excel模板", description = "")
+    public ResponseEntity<Resource> checkDownloadExcelTemplate() {
+        return ExcelExtUtil.downloadXlsTemplate(
+                "Excel/device/检验量具.xls",
+                "导入模版-检验量具.xls");
+    }
+
+    @PostMapping("/process-import-excel")
+    @Operation(summary = "导入Excel", description = "MultipartFile")
+    public R processImportExcel(@RequestParam("file") MultipartFile file) {
+        R checkR = ExcelExtUtil.importExcelCheck(file);
+        if (checkR != null) {
+            return checkR;
+        }
+        List<MesMeasuringToolImportExcel> importList = ExcelUtil.read(
+                file, 0, 1, MesMeasuringToolImportExcel.class
+        );
+        Set<String> existSet = new HashSet<>();
+        List<MesMeasuringToolEntity> list = new ArrayList<>();
+        for (MesMeasuringToolImportExcel excel : importList) {
+            if (existSet.contains(excel.getToolName())) {
+                return R.fail("Excel里量具【" + excel.getToolName() + "】重复了");
+            }
+            existSet.add(excel.getToolName());
+            MesMeasuringToolEntity exist = mesMeasuringToolService.getOne(new LambdaQueryWrapper<MesMeasuringToolEntity>()
+                    .eq(MesMeasuringToolEntity::getToolType, "1")
+                    .eq(MesMeasuringToolEntity::getToolName, excel.getToolName()));
+            if (exist != null) {
+                return R.fail("量具" + excel.getToolName() + "已存在");
+            }
+            MesMeasuringToolEntity mesMeasuringToolEntity = new MesMeasuringToolEntity();
+            BeanUtils.copyProperties(excel, mesMeasuringToolEntity);
+            mesMeasuringToolEntity.setToolType("1");
+            list.add(mesMeasuringToolEntity);
+        }
+        return R.status(mesMeasuringToolService.saveBatch(list));
+    }
+
+    @PostMapping("/check-import-excel")
+    @Operation(summary = "导入Excel", description = "MultipartFile")
+    public R checkImportExcel(@RequestParam("file") MultipartFile file) {
+        R checkR = ExcelExtUtil.importExcelCheck(file);
+        if (checkR != null) {
+            return checkR;
+        }
+        List<MesMeasuringToolImportExcel> importList = ExcelUtil.read(
+                file, 0, 1, MesMeasuringToolImportExcel.class
+        );
+        Set<String> existSet = new HashSet<>();
+        List<MesMeasuringToolEntity> list = new ArrayList<>();
+        for (MesMeasuringToolImportExcel excel : importList) {
+            if(StringUtils.isEmpty(excel.getToolCode())){
+                return R.fail("量具名称为空");
+            }
+            if (existSet.contains(excel.getToolCode())) {
+                return R.fail("Excel里量具【" + excel.getToolCode() + "】重复了");
+            }
+            existSet.add(excel.getToolCode());
+            MesMeasuringToolEntity exist = mesMeasuringToolService.getOne(
+                    new LambdaQueryWrapper<MesMeasuringToolEntity>()
+                            .eq(MesMeasuringToolEntity::getToolType, "2")
+                            .eq(MesMeasuringToolEntity::getToolCode, excel.getToolCode()));
+            if (exist != null) {
+                return R.fail("量具" + excel.getToolCode() + "已存在");
+            }
+            MesMeasuringToolEntity mesMeasuringToolEntity = new MesMeasuringToolEntity();
+            BeanUtils.copyProperties(excel, mesMeasuringToolEntity);
+            mesMeasuringToolEntity.setToolType("2");
+            list.add(mesMeasuringToolEntity);
+        }
+        return R.status(mesMeasuringToolService.saveBatch(list));
+    }
+}

blade-service/blade-desk/src/main/java/org/springblade/desk/device/feign/LimsMeaToolTaskClientImpl.java

@@ -4,10 +4,16 @@ 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.core.tool.api.R;
 import org.springblade.desk.device.pojo.entity.MeasurementRecordsEntity;
+import org.springblade.desk.device.pojo.vo.MeasurementRecordsVO;
 import org.springblade.desk.device.service.IMeasurementRecordsService;
+import org.springframework.util.CollectionUtils;
 import org.springframework.web.bind.annotation.RestController;
 
+import java.util.ArrayList;
+import java.util.List;
+
 @RestController
 @Hidden
 public class LimsMeaToolTaskClientImpl implements LimsMeaToolTaskClient {
@@ -20,4 +26,37 @@ public class LimsMeaToolTaskClientImpl implements LimsMeaToolTaskClient {
         IPage<MeasurementRecordsEntity> page = new Page<>(1, 9999);
         measurementRecordsService.syncMeasurementRecords(page, 1);
     }
+
+    @Override
+    public List<MeasurementRecordsEntity> selectSyncMeasurementRecordsTask() {
+        List<MeasurementRecordsEntity> resultList = new ArrayList<>();
+        Integer currentPage = 1;
+        Integer pageSize = 500;
+        MeasurementRecordsVO mesMeasurementRecords = new MeasurementRecordsVO();
+        mesMeasurementRecords.setCmType(1);
+        while (true) {
+            // 单页查询
+            IPage<MeasurementRecordsEntity> page = new Page<>(currentPage, pageSize);
+            R result = measurementRecordsService.selectSyncMeasurementRecordsPage(page, mesMeasurementRecords);
+            if (!result.isSuccess() || result.getData() == null) {
+                break;
+            }
+            Object data = result.getData();
+            if (!(data instanceof IPage<?>)) {
+                break;
+            }
+            IPage<MeasurementRecordsEntity> pageData = (IPage<MeasurementRecordsEntity>) data;
+            List<MeasurementRecordsEntity> records = pageData.getRecords();
+            if (CollectionUtils.isEmpty(records)) {
+                break;
+            }
+            resultList.addAll(records);
+            if (records.size() < pageSize) {
+                break;
+            }
+            currentPage++;
+        }
+        return resultList;
+    }
+
 }

blade-service/blade-desk/src/main/java/org/springblade/desk/device/feign/MesMeasuringToolClientImpl.java

@@ -0,0 +1,28 @@
+package org.springblade.desk.device.feign;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import io.swagger.v3.oas.annotations.Hidden;
+import jakarta.annotation.Resource;
+import org.springblade.desk.device.pojo.entity.MesMeasuringToolEntity;
+import org.springblade.desk.device.service.IMesMeasuringToolService;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+@RestController
+@Hidden
+public class MesMeasuringToolClientImpl implements MesMeasuringToolClient {
+
+    @Resource
+    private IMesMeasuringToolService mesMeasuringToolService;
+
+    @Override
+    public List<MesMeasuringToolEntity> selectCheckTool() {
+        return mesMeasuringToolService.list(new LambdaQueryWrapper<MesMeasuringToolEntity>().eq(MesMeasuringToolEntity::getToolType, "2"));
+    }
+
+    @Override
+    public boolean saveOrUpdateBatch(List<MesMeasuringToolEntity> list) {
+        return mesMeasuringToolService.saveOrUpdateBatch(list);
+    }
+}

blade-service/blade-desk/src/main/java/org/springblade/desk/device/mapper/MesMeasuringToolMapper.java

@@ -0,0 +1,30 @@
+package org.springblade.desk.device.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import org.apache.ibatis.annotations.Param;
+import org.springblade.desk.device.pojo.entity.MesMeasuringToolEntity;
+import org.springblade.desk.device.pojo.vo.MesMeasuringToolVO;
+
+import java.util.List;
+
+public interface MesMeasuringToolMapper extends BaseMapper<MesMeasuringToolEntity> {
+
+    /**
+     * 自定义分页
+     *
+     * @param page
+     * @param query
+     * @return
+     */
+    List<MesMeasuringToolVO> selectMesMeasuringToolPage(IPage page, MesMeasuringToolEntity query);
+
+    /**
+     * 自定义查询
+     *
+     * @param query
+     * @return
+     */
+    List<MesMeasuringToolVO> selectMesMeasuringTool(@Param("query") MesMeasuringToolEntity query);
+
+}

blade-service/blade-desk/src/main/java/org/springblade/desk/device/mapper/MesMeasuringToolMapper.xml

@@ -0,0 +1,57 @@
+<?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.MesMeasuringToolMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="mesMeasuringToolResultMap" type="org.springblade.desk.device.pojo.entity.MesMeasuringToolEntity">
+        <result column="ID" property="id"/>
+        <result column="TOOL_CODE" property="toolCode"/>
+        <result column="TOOL_NAME" property="toolName"/>
+        <result column="TOOL_SIZE" property="toolSize"/>
+        <result column="TOOL_TYPE" property="toolType"/>
+        <result column="DUE_DATE" property="dueDate"/>
+        <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"/>
+    </resultMap>
+
+    <resultMap id="mesMeasuringToolVOResultMap" type="org.springblade.desk.device.pojo.vo.MesMeasuringToolVO" extends="mesMeasuringToolResultMap">
+        <result column="UPDATE_USER_NAME" property="updateUserName"/>
+    </resultMap>
+
+    <sql id="selectMesMeasuringToolSql">
+        select a.*, bu.REAL_NAME as UPDATE_USER_NAME
+        from MES_MEASURING_TOOL a
+        LEFT JOIN BLADE_USER bu on a.UPDATE_USER = bu.id
+        where a.is_deleted = 0
+        <if test="query.toolCode != null and query.toolCode != ''">
+            AND a.TOOL_CODE LIKE CONCAT('%', CONCAT(#{query.toolCode}, '%'))
+        </if>
+        <if test="query.toolName != null and query.toolName != ''">
+            AND a.TOOL_NAME LIKE CONCAT('%', CONCAT(#{query.toolName}, '%'))
+        </if>
+        <if test="query.toolSize != null and query.toolSize != ''">
+            AND a.TOOL_SIZE = #{query.toolSize}
+        </if>
+        <if test="query.toolType != null and query.toolType != ''">
+            AND a.TOOL_TYPE = #{query.toolType}
+        </if>
+        <if test="query.status != null and query.status != ''">
+            AND a.STATUS = #{query.status}
+        </if>
+        ORDER BY a.CREATE_TIME ASC
+    </sql>
+
+    <select id="selectMesMeasuringToolPage" resultMap="mesMeasuringToolVOResultMap">
+        <include refid="selectMesMeasuringToolSql"/>
+    </select>
+
+    <select id="selectMesMeasuringTool" resultMap="mesMeasuringToolVOResultMap">
+        <include refid="selectMesMeasuringToolSql"/>
+    </select>
+
+</mapper>

blade-service/blade-desk/src/main/java/org/springblade/desk/device/service/IMeasurementRecordsService.java

@@ -40,4 +40,6 @@ public interface IMeasurementRecordsService extends BaseService<MeasurementRecor
 //	 * @return List<EquipmentExcel>
 //	 */
 //	List<EquipmentExcel> exportEquipment(Wrapper<EquipmentEntity> queryWrapper);
+
+    R selectSyncMeasurementRecordsPage(IPage<MeasurementRecordsEntity> page, MeasurementRecordsVO mesMeasurementRecords);
 }

blade-service/blade-desk/src/main/java/org/springblade/desk/device/service/IMesMeasuringToolService.java

@@ -0,0 +1,19 @@
+package org.springblade.desk.device.service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import org.springblade.core.mp.base.BaseService;
+import org.springblade.desk.device.pojo.entity.MesMeasuringToolEntity;
+import org.springblade.desk.device.pojo.vo.MesMeasuringToolVO;
+
+import java.util.List;
+
+/**
+ * 设备量具服务类
+ */
+public interface IMesMeasuringToolService extends BaseService<MesMeasuringToolEntity> {
+
+    IPage<MesMeasuringToolVO> selectMeaToolPage(IPage<MesMeasuringToolVO> page, MesMeasuringToolEntity query);
+
+    List<MesMeasuringToolVO> selectMeaTool(MesMeasuringToolEntity query);
+
+}

blade-service/blade-desk/src/main/java/org/springblade/desk/device/service/impl/IMeasurementRecordsServiceImpl.java

@@ -6,22 +6,18 @@ 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.StringUtils;
 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;
@@ -64,16 +60,10 @@ public class IMeasurementRecordsServiceImpl extends BaseServiceImpl<MeasurementR
     public R syncMeasurementRecords(IPage<MeasurementRecordsEntity> page, Integer cmType) {
 
         // 构建请求体JSON
-        JSONObject requestBody = buildRequestBody(page, cmType);
+        JSONObject requestBody = buildRequestBody(page, cmType, null);
 
         // 创建HTTP请求
-        HttpRequest request = HttpRequest.newBuilder()
+        HttpRequest request = buildRequest(requestBody);
-                .uri(URI.create(limsUrl + "/api/cloud-customized/zhgdDeviceParams/getDeviceListZhgd"))
-                .header("Content-Type", "application/json")
-                .header("Accept", "application/json")
-                .POST(HttpRequest.BodyPublishers.ofString(requestBody.toJSONString()))
-                .timeout(Duration.ofSeconds(60))
-                .build();
 
         try {
             // 发送同步请求
@@ -88,21 +78,123 @@ public class IMeasurementRecordsServiceImpl extends BaseServiceImpl<MeasurementR
         }
     }
 
+    @Override
+    public R selectSyncMeasurementRecordsPage(IPage<MeasurementRecordsEntity> page, MeasurementRecordsVO mesMeasurementRecords) {
+        // 构建请求体JSON
+        JSONObject requestBody = buildRequestBody(page, mesMeasurementRecords.getCmType(), mesMeasurementRecords.getMcCode());
+
+        // 创建HTTP请求
+        HttpRequest request = buildRequest(requestBody);
+
+        try {
+            // 发送同步请求
+            HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
+            // 处理响应
+            return processSelectResponse(response, page);
+        } catch (Exception e) {
+            log.error("获取计量记录记录数据接口调用失败: {}", e.getMessage(), e);
+            return R.fail("获取计量记录记录数据接口调用失败");
+        }
+    }
+
     /**
      * 构建请求体
      */
-    private JSONObject buildRequestBody(IPage<MeasurementRecordsEntity> page, Integer cmType) {
+    private JSONObject buildRequestBody(IPage<MeasurementRecordsEntity> page, Integer cmType, String mcCode) {
         JSONObject requestBody = new JSONObject();
         requestBody.put("currPage", page.getCurrent());
         requestBody.put("pageSize", page.getSize());
         requestBody.put("workGuideNo", "热表分厂");
         requestBody.put("labId", "2");
         requestBody.put("str1", cmType == null ? 1 : 2);
-
+        if (StringUtils.isNotEmpty(mcCode)) {
+            requestBody.put("assetsCode", mcCode);
+        }
         log.debug("请求参数: {}", requestBody.toJSONString());
         return requestBody;
     }
 
+    private HttpRequest buildRequest(JSONObject requestBody) {
+        HttpRequest request = HttpRequest.newBuilder()
+                .uri(URI.create(limsUrl + "/api/cloud-customized/zhgdDeviceParams/getDeviceListZhgd"))
+                .header("Content-Type", "application/json")
+                .header("Accept", "application/json")
+                .POST(HttpRequest.BodyPublishers.ofString(requestBody.toJSONString()))
+                .timeout(Duration.ofSeconds(60))
+                .build();
+        return request;
+    }
+
+    /**
+     * 处理HTTP响应
+     */
+    private R processSelectResponse(HttpResponse<String> response, IPage<MeasurementRecordsEntity> page) {
+        if (response.statusCode() != 200) {
+            log.error("HTTP请求失败，状态码: {}", response.statusCode());
+            return R.fail("HTTP请求失败，状态码: " + response.statusCode());
+        }
+        String responseBody = response.body();
+        if (responseBody == null || responseBody.trim().isEmpty()) {
+            log.error("响应体为空");
+            return R.fail("响应体为空");
+        }
+
+        try {
+            JSONObject result = JSONObject.parseObject(responseBody);
+            if (result != null && result.getBoolean("success")) {
+                JSONArray data = result.getJSONArray("rows");
+                if (data != null) {
+                    List<JSONObject> records = JSONArray.parseArray(data.toJSONString(), JSONObject.class);
+                    log.info("成功获取{}条计量记录记录", records != null ? records.size() : 0);
+                    MeasurementRecordsEntity measurementRecordsEntity;
+                    List<MeasurementRecordsEntity> list = new ArrayList<>();
+                    for (JSONObject jsonObj : records) {
+                        measurementRecordsEntity = new MeasurementRecordsEntity();
+                        measurementRecordsEntity.setMcName(jsonObj.getString("deviceName"));
+                        measurementRecordsEntity.setNorms(jsonObj.getString("model"));
+                        measurementRecordsEntity.setMcClass(jsonObj.getString("unit"));
+                        measurementRecordsEntity.setLabelNo(jsonObj.getString("labelNo"));
+                        measurementRecordsEntity.setStr2(jsonObj.getString("str2"));
+                        measurementRecordsEntity.setMcCode(jsonObj.getString("assetsCode"));
+                        measurementRecordsEntity.setUseUnit(jsonObj.getString("workGuideNo"));
+                        measurementRecordsEntity.setAccuracy(jsonObj.getString("describe"));
+                        measurementRecordsEntity.setOemCode(jsonObj.getString("serialNo"));
+                        measurementRecordsEntity.setMcOem(jsonObj.getString("deviceWhere"));
+                        measurementRecordsEntity.setEnableDate(jsonObj.getDate("whenUse"));
+                        measurementRecordsEntity.setWhenDccept(jsonObj.getString("whenDccept"));
+                        measurementRecordsEntity.setMcType(jsonObj.getString("str5"));
+                        measurementRecordsEntity.setTestCycle(jsonObj.getInteger("guaranteePeriod"));
+                        measurementRecordsEntity.setDueDate(jsonObj.getDate("date1"));
+                        measurementRecordsEntity.setDate2(jsonObj.getDate("date2"));
+                        measurementRecordsEntity.setBelong(jsonObj.getString("belong"));
+                        measurementRecordsEntity.setWhenBuy(jsonObj.getDate("whenBuy"));
+                        measurementRecordsEntity.setTestDept(jsonObj.getString("deviceSource"));
+                        measurementRecordsEntity.setTestMethod(jsonObj.getString("str8"));
+                        measurementRecordsEntity.setStr9(jsonObj.getString("str9"));
+                        measurementRecordsEntity.setStr10(jsonObj.getString("str10"));
+                        measurementRecordsEntity.setAssetsNo(jsonObj.getString("assetsNo"));
+                        measurementRecordsEntity.setStr6(jsonObj.getString("str6"));
+                        measurementRecordsEntity.setPurposeClass(jsonObj.getString("str7"));
+                        measurementRecordsEntity.setIsOverStr(jsonObj.getString("isOverStr"));
+                        list.add(measurementRecordsEntity);
+                    }
+                    page.setRecords(list);
+                    page.setTotal(result.getInteger("total"));
+                    return R.data(MeasurementRecordsWrapper.build().pageVO(page));
+                }
+            } else {
+                String errorMsg = result != null ? result.getString("message") : "未知错误";
+                log.error("接口返回错误: {}", errorMsg);
+                R.fail("接口返回错误: " + errorMsg);
+            }
+        } catch (Exception e) {
+            log.error("响应数据解析失败: {}", e.getMessage(), e);
+            R.fail("响应数据解析失败: " + e.getMessage());
+        }
+
+        return R.fail("处理失败");
+    }
+
     /**
      * 处理HTTP响应
      */

blade-service/blade-desk/src/main/java/org/springblade/desk/device/service/impl/MesMeasuringToolServiceImpl.java

@@ -0,0 +1,28 @@
+package org.springblade.desk.device.service.impl;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import org.springblade.core.mp.base.BaseServiceImpl;
+import org.springblade.desk.device.mapper.MesMeasuringToolMapper;
+import org.springblade.desk.device.pojo.entity.MesMeasuringToolEntity;
+import org.springblade.desk.device.pojo.vo.MesMeasuringToolVO;
+import org.springblade.desk.device.service.IMesMeasuringToolService;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * 设备量具服务实现类
+ */
+@Service
+public class MesMeasuringToolServiceImpl extends BaseServiceImpl<MesMeasuringToolMapper, MesMeasuringToolEntity> implements IMesMeasuringToolService {
+
+    @Override
+    public IPage<MesMeasuringToolVO> selectMeaToolPage(IPage<MesMeasuringToolVO> page, MesMeasuringToolEntity query) {
+        return page.setRecords(baseMapper.selectMesMeasuringToolPage(page, query));
+    }
+
+    @Override
+    public List<MesMeasuringToolVO> selectMeaTool(MesMeasuringToolEntity query) {
+        return baseMapper.selectMesMeasuringTool(query);
+    }
+}

blade-service/blade-desk/src/main/java/org/springblade/desk/quality/mapper/WorkPlanItemMapper.xml

@@ -81,7 +81,7 @@
         LEFT JOIN MES_WORK_ORDER c ON b.WO_ID = c.ID
         LEFT JOIN BS_PROCESS_SET d ON b.PPS_ID = d.ID
         INNER JOIN (
-            SELECT t.item_name, m.WO_ID
+            SELECT t.item_name, m.WO_ID,t.wp_id
             FROM QA_WORK_PLAN_ITEM t
             LEFT JOIN MES_WORK_PLAN m ON t.WP_ID = m.ID
             WHERE t.id = #{wpiId}
@@ -89,6 +89,7 @@
         ON a.item_name = cond.item_name
         AND b.WO_ID = cond.WO_ID
         WHERE a.is_deleted = 0 AND a.SOURCE_TYPE = 1
+        and a.wp_id != cond.wp_id
     </select>
 
     <select id="listShareBySameSlot" resultMap="workPlanItemVOResultMap">

blade-service/blade-desk/src/main/java/org/springblade/desk/quality/service/impl/WorkPlanItemServiceImpl.java

@@ -293,7 +293,7 @@ public class WorkPlanItemServiceImpl extends BaseServiceImpl<WorkPlanItemMapper,
         if (CollectionUtils.isNotEmpty(listVO)) {
             for (WorkPlanItemVO vo : listVO) {
                 setVOValue(vo);
-                vo.setCheckName("工序检验");
+                vo.setCheckName("当前订单");
             }
         }
         List<WorkPlanItemVO> itemVOS = listShareBySameSlot(wpiId);