diff --git a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/entity/OemStatementEntity.java b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/entity/OemStatementEntity.java index feeb67d8e..8de2373df 100644 --- a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/entity/OemStatementEntity.java +++ b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/entity/OemStatementEntity.java @@ -29,27 +29,27 @@ public class OemStatementEntity extends BaseEntity { private static final long serialVersionUID = 1L; /** - * 未结算 + * 无需结算 */ - public static Short NOT_NEED_SETTLEMENT = -1; + public static Integer NOT_NEED_SETTLEMENT = -1; /** * 未结算 */ - public static Short NO_SETTLEMENT = 1; + public static Integer NO_SETTLEMENT = 1; /** * 结算中 */ - public static Short IN_SETTLEMENT = 2; + public static Integer IN_SETTLEMENT = 2; /** * 结算异常 */ - public static Short ERR_SETTLEMENT = 3; + public static Integer ERR_SETTLEMENT = 3; /** * 已结算 */ - public static Short OK_SETTLEMENT = 4; + public static Integer OK_SETTLEMENT = 4; - public static Map rosStatusMap = new HashMap<>(8); + public static Map rosStatusMap = new HashMap<>(8); static { rosStatusMap.put(NOT_NEED_SETTLEMENT, "无需结算"); @@ -95,4 +95,14 @@ public class OemStatementEntity extends BaseEntity { @Schema(description = "状态") private Integer rosStatus; + public String getRosStatusName() { + return rosStatusMap.get(rosStatus); + } + + /** + * 备注 + */ + @Schema(description = "备注") + private String memo; + } diff --git a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/entity/PlatingTypeRulesEntity.java b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/entity/PlatingTypeRulesEntity.java new file mode 100644 index 000000000..409e79431 --- /dev/null +++ b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/entity/PlatingTypeRulesEntity.java @@ -0,0 +1,42 @@ +package org.springblade.desk.oem.pojo.entity; + +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.io.Serial; + +/** + * 外协镀种规则 实体类 + * + * @author qyl + * @since 2026-03-03 + */ +@Data +@TableName("MES_PLATING_TYPE_RULES") +@Schema(description = "PlatingTypeRules对象") +@EqualsAndHashCode(callSuper = true) +public class PlatingTypeRulesEntity extends BaseEntity { + + @Serial + private static final long serialVersionUID = 1L; + + /** + * 订单镀种 + */ + @Schema(description = "订单镀种") + private String orderPlat; + /** + * 报价单镀种 + */ + @Schema(description = "报价单镀种") + private String quotationPlat; + +} diff --git a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/excel/PlatingTypeRulesExcel.java b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/excel/PlatingTypeRulesExcel.java new file mode 100644 index 000000000..f7bdd5aeb --- /dev/null +++ b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/excel/PlatingTypeRulesExcel.java @@ -0,0 +1,45 @@ +package org.springblade.desk.oem.pojo.excel; + + +import lombok.Data; + +import java.math.BigDecimal; +import java.util.Date; + +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 java.io.Serializable; +import java.io.Serial; + + +/** + * 外协镀种规则 Excel实体类 + * + * @author qyl + * @since 2026-03-03 + */ +@Data +@ColumnWidth(25) +@HeadRowHeight(20) +@ContentRowHeight(18) +public class PlatingTypeRulesExcel implements Serializable { + + @Serial + private static final long serialVersionUID = 1L; + /** + * 订单镀种 + */ + @ColumnWidth(20) + @ExcelProperty("订单镀种") + private String orderPlat; + /** + * 报价单镀种 + */ + @ColumnWidth(20) + @ExcelProperty("报价单镀种") + private String quotationPlat; + +} diff --git a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/excel/PlatingTypeRulesImport.java b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/excel/PlatingTypeRulesImport.java new file mode 100644 index 000000000..110da7ce0 --- /dev/null +++ b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/excel/PlatingTypeRulesImport.java @@ -0,0 +1,29 @@ +package org.springblade.desk.oem.pojo.excel; + +import com.alibaba.excel.annotation.ExcelProperty; +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.springblade.core.mp.base.BaseEntity; + +/** + * 外协镀种规则导入 + * + * @author qyl + * @since 2026年3月3日 + */ +@Data +@EqualsAndHashCode(callSuper = true) +public class PlatingTypeRulesImport extends BaseEntity { + + /** + * 订单镀种 + */ + @ExcelProperty(index = 0) + private String orderPlat; + /** + * 报价单镀种 + */ + @ExcelProperty(index = 1) + private String quotationPlat; + +} diff --git a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/request/OemApprovalQuery.java b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/request/OemApprovalQuery.java index 129654e00..ca4bb63d7 100644 --- a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/request/OemApprovalQuery.java +++ b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/request/OemApprovalQuery.java @@ -22,7 +22,7 @@ public class OemApprovalQuery { * 车间订单号 */ @Schema(description = "车间订单号") - private String orderCode; + private String woCode; /** * 零件号 */ diff --git a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/request/OemSettleAccountsSave.java b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/request/OemSettleAccountsSave.java new file mode 100644 index 000000000..f9e36d9d2 --- /dev/null +++ b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/request/OemSettleAccountsSave.java @@ -0,0 +1,30 @@ +package org.springblade.desk.oem.pojo.request; + +import io.swagger.v3.oas.annotations.media.Schema; +import jakarta.validation.constraints.NotNull; +import lombok.Data; +import org.springblade.desk.oem.pojo.vo.StatementVO; +import org.springframework.format.annotation.DateTimeFormat; + +import java.math.BigDecimal; +import java.time.LocalDate; +import java.util.List; + +/** + * 外协结算入参 + */ +@Data +public class OemSettleAccountsSave { + + @DateTimeFormat(pattern = "yyyy-MM-dd") + @Schema(description = "镀后入库时间") + @NotNull(message = "镀后入库时间不能为空") + private LocalDate putStoreDate; + + @Schema(description = "现执行价格") + private BigDecimal price; + + @Schema(description = "外协结算单集合") + @NotNull(message = "外协结算单集合不能为空") + List statementList; +} diff --git a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/request/PriceSheetQuery.java b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/request/PriceSheetQuery.java index c2c09cd43..c119b600a 100644 --- a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/request/PriceSheetQuery.java +++ b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/request/PriceSheetQuery.java @@ -17,6 +17,11 @@ public class PriceSheetQuery { */ @Schema(description = "外协厂商CODE") private String ocCode; + /** + * 外协厂商名称 + */ + @Schema(description = "外协厂商名称") + private String ocName; /** * 零件号 */ diff --git a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/request/StatementQuery.java b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/request/StatementQuery.java index cb3b48bba..074bc04eb 100644 --- a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/request/StatementQuery.java +++ b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/request/StatementQuery.java @@ -1,6 +1,7 @@ package org.springblade.desk.oem.pojo.request; import io.swagger.v3.oas.annotations.media.Schema; +import jakarta.validation.constraints.NotNull; import lombok.Data; import org.springframework.format.annotation.DateTimeFormat; @@ -62,6 +63,7 @@ public class StatementQuery { /** * 结算单状态 */ - @Schema(description = "结算单状态（传字符串1,2,3,4）") + @Schema(description = "结算单状态（传字符串1,2,3,4）-1无需结算，1未结算，2结算中，3结算异常，4已结算") + @NotNull(message = "结算单状态不能为空") private String rosStatusList; } diff --git a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/OemApprovalVO.java b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/OemApprovalVO.java index e0d2c1296..056c209bb 100644 --- a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/OemApprovalVO.java +++ b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/OemApprovalVO.java @@ -4,11 +4,10 @@ import io.swagger.v3.oas.annotations.media.Schema; import lombok.Data; import lombok.EqualsAndHashCode; import org.springblade.desk.produce.pojo.entity.WorkOrderRun; -import org.springblade.desk.produce.pojo.enums.WorkOrderRunStatusEnum; import java.io.Serial; -import java.time.LocalDateTime; -import java.util.Date; +import java.util.HashMap; +import java.util.Map; /** * 外协审批 视图实体类 @@ -22,7 +21,30 @@ import java.util.Date; public class OemApprovalVO extends WorkOrderRun { @Serial private static final long serialVersionUID = 1L; + /** + * 1:正常 + */ + public static Integer APPROVAL_STATUS_NORMAL = 1; + /** + * 2:审批中 + */ + public static Integer APPROVAL_STATUS_UNDER = 2; + /** + * 3:不通过 + */ + public static Integer APPROVAL_STATUS_FAIL = 3; + /** + * 4:通过 + */ + public static Integer APPROVAL_STATUS_VIA = 4; + public static Map approvalStatusMap = new HashMap(4); + static { + approvalStatusMap.put(APPROVAL_STATUS_NORMAL, "正常"); + approvalStatusMap.put(APPROVAL_STATUS_UNDER, "审批中"); + approvalStatusMap.put(APPROVAL_STATUS_FAIL, "审批不通过"); + approvalStatusMap.put(APPROVAL_STATUS_VIA, "审批通过"); + } @Schema(description = "车间订单ID") private Long woId; @@ -50,7 +72,7 @@ public class OemApprovalVO extends WorkOrderRun { private Long makeQty; @Schema(description = "面积(dm²)") - private String totalArea; + private String area; // @Schema(description = "建立时间") // private Date createDate; @@ -60,4 +82,15 @@ public class OemApprovalVO extends WorkOrderRun { @Schema(description = "审批人") private String approver; + + @Schema(description = "审批状态;1:正常，2:审批中，3:不通过，4:通过") + private Integer approvalStatus; + + @Schema(description = "审批状态名称") + private String approvalName; + + public String getApprovalName() { + return approvalStatusMap.get(approvalStatus); + } + } diff --git a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/OemOrderVO.java b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/OemOrderVO.java index 6eb7f817b..907e92ced 100644 --- a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/OemOrderVO.java +++ b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/OemOrderVO.java @@ -5,6 +5,7 @@ import lombok.Data; import lombok.EqualsAndHashCode; import org.springblade.desk.order.pojo.enums.YieldOrderEnum; import org.springblade.desk.produce.pojo.entity.WorkOrderRun; +import org.springblade.desk.produce.pojo.enums.WorkOrderEnum; import org.springblade.desk.produce.pojo.enums.WorkOrderRunStatusEnum; import java.io.Serial; @@ -41,7 +42,7 @@ public class OemOrderVO extends WorkOrderRun { @Schema(description = "运行订单状态(运行状态;1.正常，2.已下达，3.加工中，4.检验中，13.审理中，14.返工中，15.已完工，21已作废)") public String getRunStatusName() { - return WorkOrderRunStatusEnum.getName(this.getRunStatus().intValue()); + return WorkOrderEnum.getName(this.getWorkOrderStatus().intValue()); } @Schema(description = "批次号") @@ -107,4 +108,7 @@ public class OemOrderVO extends WorkOrderRun { @Schema(description = "外协订单分类（车间单号为WX：外协订单，车间单号为WO：协作订单）") private String oemOrderType; + + @Schema(description = "审批状态;1:正常，2:审批中，3:不通过，4:通过") + private Integer approvalStatus; } diff --git a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/OemProcessVO.java b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/OemProcessVO.java index 496eaecca..22f635b87 100644 --- a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/OemProcessVO.java +++ b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/OemProcessVO.java @@ -6,6 +6,8 @@ import lombok.Data; import lombok.EqualsAndHashCode; import java.io.Serial; +import java.time.ZoneId; +import java.time.format.DateTimeFormatter; /** * 外协工序 视图实体类 @@ -24,4 +26,11 @@ public class OemProcessVO extends OemProcessEntity { @Schema(description = "工艺能力名称集合") private String caNames; + + @Schema(description = "工序IDStr,前端用") + private String processIdStr; + + public String getProcessIdStr() { + return this.getProcessId().toString(); + } } diff --git a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/PlatingTypeRulesVO.java b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/PlatingTypeRulesVO.java new file mode 100644 index 000000000..382cd2745 --- /dev/null +++ b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/PlatingTypeRulesVO.java @@ -0,0 +1,21 @@ +package org.springblade.desk.oem.pojo.vo; + +import org.springblade.desk.oem.pojo.entity.PlatingTypeRulesEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.io.Serial; + +/** + * 外协镀种规则 视图实体类 + * + * @author qyl + * @since 2026-03-03 + */ +@Data +@EqualsAndHashCode(callSuper = true) +public class PlatingTypeRulesVO extends PlatingTypeRulesEntity { + @Serial + private static final long serialVersionUID = 1L; + +} diff --git a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/StatementVO.java b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/StatementVO.java index 7c81ce4cd..93a3ebf86 100644 --- a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/StatementVO.java +++ b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/oem/pojo/vo/StatementVO.java @@ -2,15 +2,16 @@ package org.springblade.desk.oem.pojo.vo; import io.swagger.v3.oas.annotations.media.Schema; import lombok.Data; +import org.springblade.desk.oem.pojo.entity.OemStatementEntity; + +import java.util.List; /** * 外协订单结算VO */ @Data -public class StatementVO { +public class StatementVO extends OemStatementEntity { - @Schema(description = "车间作业计划ID") - private Long wpId; @Schema(description = "车间订单ID") private Long woId; @@ -48,13 +49,19 @@ public class StatementVO { @Schema(description = "零件名称") private String partName; + @Schema(description = "镀层物料") + private String plateGoodsCode; + @Schema(description = "批次号") private String batchNo; @Schema(description = "生产标识") private String prodIdent; - @Schema(description = "工序") + @Schema(description = "工序编码") + private String psCode; + + @Schema(description = "工序名称") private String psName; @Schema(description = "工艺能力") @@ -75,6 +82,9 @@ public class StatementVO { @Schema(description = "外协厂商") private String ocCode; + @Schema(description = "外协厂商名称") + private String ocName; + @Schema(description = "镀种") private String plate; @@ -90,16 +100,8 @@ public class StatementVO { @Schema(description = "涂箭个数") private String tjtNum; - @Schema(description = "结算单价") - private String unitPrice; - - @Schema(description = "计量单位") - private String unit; - - @Schema(description = "结算金额") - private String totalPrice; - - @Schema(description = "报价单号") - private String quotation; - + /** + * 同外协厂家下有效期内的全部该工序报价 + */ + private List priceSheetList; } diff --git a/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/util/PriceMatcher.java b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/util/PriceMatcher.java new file mode 100644 index 000000000..6a5de8b5b --- /dev/null +++ b/blade-service-api/blade-desk-api/src/main/java/org/springblade/desk/util/PriceMatcher.java @@ -0,0 +1,100 @@ +package org.springblade.desk.util; + +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.stream.Collectors; + +/** + * 价格处理 + */ +public class PriceMatcher { + + /** + * 查找包含指定价格的备注 + * + * @param remarks 备注列表 + * @param targetPrice 目标价格 + * @return 匹配的备注列表 + */ + public static List findRemarksByPrice(List remarks, BigDecimal targetPrice) { + if (remarks == null || targetPrice == null) { + return new ArrayList<>(); + } + + List matchedRemarks = new ArrayList<>(); + + for (String remark : remarks) { + if (remark == null || remark.trim().isEmpty()) { + continue; + } + + if (containsPrice(remark, targetPrice)) { + matchedRemarks.add(remark); + } + } + + return matchedRemarks; + } + + /** + * 判断备注是否包含目标价格 + */ + private static boolean containsPrice(String remark, BigDecimal targetPrice) { + // 正则表达式匹配价格范围或单价 + // 匹配如：350.01-360、467.5、100.5-200.8 + String regex = "(\\d+(?:\\.\\d+)?)(?:-(\\d+(?:\\.\\d+)?))?"; + Pattern pattern = Pattern.compile(regex); + Matcher matcher = pattern.matcher(remark); + + while (matcher.find()) { + String startPriceStr = matcher.group(1); + String endPriceStr = matcher.group(2); + + try { + if (endPriceStr != null) { + // 价格范围，如 "350.01-360" + BigDecimal startPrice = new BigDecimal(startPriceStr); + BigDecimal endPrice = new BigDecimal(endPriceStr); + + // 检查目标价格是否在范围内 + if (targetPrice.compareTo(startPrice) >= 0 && + targetPrice.compareTo(endPrice) <= 0) { + return true; + } + } else { + // 单一价格，如 "467.5" + BigDecimal singlePrice = new BigDecimal(startPriceStr); + + // 检查目标价格是否等于这个价格 + if (targetPrice.compareTo(singlePrice) == 0) { + return true; + } + } + } catch (NumberFormatException e) { + // 解析失败，跳过这个匹配 + continue; + } + } + + return false; + } + + /** + * 使用Stream API的版本 + */ + public static Set findRemarksByPriceStream(Set remarks, BigDecimal targetPrice) { + if (remarks == null || targetPrice == null) { + return new HashSet<>(); + } + + return remarks.stream() + .filter(remark -> remark != null && !remark.trim().isEmpty()) + .filter(remark -> containsPrice(remark, targetPrice)) + .collect(Collectors.toSet()); + } +} diff --git a/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/controller/OemOrderController.java b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/controller/OemOrderController.java index a7b635067..689cf7787 100644 --- a/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/controller/OemOrderController.java +++ b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/controller/OemOrderController.java @@ -144,11 +144,30 @@ public class OemOrderController extends BladeController { return workOrderRunService.changeOemManufacturer(worId, ocId); } + + @PostMapping(value = "/reviewQualityRecords") + @ApiOperationSupport(order = 7) + @Operation(summary = "外协质量记录跳转", description = "") + public R reviewQualityRecords(@RequestBody JSONObject data) { + String deliverKey = data.getString("deliverKey"); + String url = "http://192.168.242.158:80/mms/login/login_vendorJpageZljl.jsp?LOGIN158=admin&deliverNo=" + deliverKey; + return R.success(url); + } + + @PostMapping(value = "/reviewQualification") + @ApiOperationSupport(order = 8) + @Operation(summary = "外协合格证跳转", description = "") + public R reviewQualification(@RequestBody JSONObject data) { + String deliverKey = data.getString("deliverKey"); + String url = "http://192.168.242.158:80/mms/login/login_vendorJpage.jsp?LOGIN158=admin&deliverNo=" + deliverKey; + return R.success(url); + } + /** * 报价单 自定义分页 */ @GetMapping("/priceSheetData") - @ApiOperationSupport(order = 7) + @ApiOperationSupport(order = 9) @Operation(summary = "报价单分页", description = "传入mesOemStatement") public R> priceSheetData(PriceSheetQuery priceSheetQuery, Query query) { R> pageR = erpDataOemClient.priceSheetData(priceSheetQuery, query); diff --git a/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/controller/OemStatementController.java b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/controller/OemStatementController.java index 53182f1e4..1f87e8f54 100644 --- a/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/controller/OemStatementController.java +++ b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/controller/OemStatementController.java @@ -13,6 +13,7 @@ import org.springblade.core.mp.support.Query; import org.springblade.core.tool.api.R; import org.springblade.core.tool.utils.Func; import org.springblade.desk.oem.pojo.excel.OemStatementExcel; +import org.springblade.desk.oem.pojo.request.OemSettleAccountsSave; import org.springblade.desk.oem.pojo.request.StatementQuery; import org.springblade.desk.oem.pojo.vo.StatementVO; import org.springframework.web.bind.annotation.*; @@ -107,6 +108,16 @@ public class OemStatementController extends BladeController { return R.status(mesOemStatementService.deleteLogic(Func.toLongList(ids))); } + /** + * 外协结算 + */ + @PostMapping("/oemSettleAccounts") + @ApiOperationSupport(order = 8) + @Operation(summary = "外协结算", description = "") + public R oemSettleAccounts(@Valid @RequestBody OemSettleAccountsSave oemSettleAccountsSave) { + return mesOemStatementService.oemSettleAccounts(oemSettleAccountsSave.getStatementList(), oemSettleAccountsSave.getPrice(), oemSettleAccountsSave.getPutStoreDate()); + } + /** * 导出数据 diff --git a/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/controller/PlatingTypeRulesController.java b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/controller/PlatingTypeRulesController.java new file mode 100644 index 000000000..183f4b57a --- /dev/null +++ b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/controller/PlatingTypeRulesController.java @@ -0,0 +1,162 @@ +package org.springblade.desk.oem.controller; + +import io.swagger.v3.oas.annotations.tags.Tag; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport; +import lombok.AllArgsConstructor; +import jakarta.validation.Valid; + +import org.springblade.core.secure.BladeUser; +import org.springblade.core.secure.annotation.IsAdmin; +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.Func; +import org.springblade.desk.basic.util.ExcelExtUtil; +import org.springblade.desk.oem.pojo.excel.OemProcessImport; +import org.springblade.desk.oem.pojo.excel.PlatingTypeRulesExcel; +import org.springblade.desk.oem.pojo.excel.PlatingTypeRulesImport; +import org.springframework.core.io.Resource; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; +import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; +import com.baomidou.mybatisplus.core.metadata.IPage; +import org.springblade.desk.oem.pojo.entity.PlatingTypeRulesEntity; +import org.springblade.desk.oem.pojo.vo.PlatingTypeRulesVO; +import org.springblade.desk.oem.wrapper.PlatingTypeRulesWrapper; +import org.springblade.desk.oem.service.IPlatingTypeRulesService; +import org.springblade.core.boot.ctrl.BladeController; +import org.springblade.core.tool.utils.DateUtil; +import org.springblade.core.excel.util.ExcelUtil; +import org.springblade.core.tool.constant.BladeConstant; + +import java.util.Map; +import java.util.List; + +import jakarta.servlet.http.HttpServletResponse; +import org.springframework.web.multipart.MultipartFile; + +/** + * 外协镀种规则 控制器 + * + * @author qyl + * @since 2026-03-03 + */ +@RestController +@AllArgsConstructor +@RequestMapping("/mesPlatingTypeRules") +@Tag(name = "外协镀种规则", description = "外协镀种规则接口") +public class PlatingTypeRulesController extends BladeController { + + private final IPlatingTypeRulesService mesPlatingTypeRulesService; + + /** + * 外协镀种规则 详情 + */ + @GetMapping("/detail") + @ApiOperationSupport(order = 1) + @Operation(summary = "详情", description = "传入mesPlatingTypeRules") + public R detail(PlatingTypeRulesEntity mesPlatingTypeRules) { + PlatingTypeRulesEntity detail = mesPlatingTypeRulesService.getOne(Condition.getQueryWrapper(mesPlatingTypeRules)); + return R.data(PlatingTypeRulesWrapper.build().entityVO(detail)); + } + + /** + * 外协镀种规则 自定义分页 + */ + @GetMapping("/page") + @ApiOperationSupport(order = 3) + @Operation(summary = "分页", description = "传入mesPlatingTypeRules") + public R> page(PlatingTypeRulesVO mesPlatingTypeRules, Query query) { + IPage pages = mesPlatingTypeRulesService.selectPlatingTypeRulesPage(Condition.getPage(query), mesPlatingTypeRules); + return R.data(pages); + } + + /** + * 外协镀种规则 新增 + */ + @PostMapping("/save") + @ApiOperationSupport(order = 4) + @Operation(summary = "新增", description = "传入mesPlatingTypeRules") + public R save(@Valid @RequestBody PlatingTypeRulesEntity mesPlatingTypeRules) { + return R.status(mesPlatingTypeRulesService.save(mesPlatingTypeRules)); + } + + /** + * 外协镀种规则 修改 + */ + @PostMapping("/update") + @ApiOperationSupport(order = 5) + @Operation(summary = "修改", description = "传入mesPlatingTypeRules") + public R update(@Valid @RequestBody PlatingTypeRulesEntity mesPlatingTypeRules) { + return R.status(mesPlatingTypeRulesService.updateById(mesPlatingTypeRules)); + } + + /** + * 外协镀种规则 新增或修改 + */ + @PostMapping("/submit") + @ApiOperationSupport(order = 6) + @Operation(summary = "新增或修改", description = "传入mesPlatingTypeRules") + public R submit(@Valid @RequestBody PlatingTypeRulesEntity mesPlatingTypeRules) { + return R.status(mesPlatingTypeRulesService.saveOrUpdate(mesPlatingTypeRules)); + } + + /** + * 外协镀种规则 删除 + */ + @PostMapping("/remove") + @ApiOperationSupport(order = 7) + @Operation(summary = "逻辑删除", description = "传入ids") + public R remove(@Parameter(description = "主键集合", required = true) @RequestParam String ids) { + return R.status(mesPlatingTypeRulesService.deleteLogic(Func.toLongList(ids))); + } + + + /** + * 导出数据 + */ + @IsAdmin + @GetMapping("/export-mesPlatingTypeRules") + @ApiOperationSupport(order = 9) + @Operation(summary = "导出数据", description = "传入mesPlatingTypeRules") + public void exportPlatingTypeRules(@Parameter(hidden = true) @RequestParam Map mesPlatingTypeRules, BladeUser bladeUser, HttpServletResponse response) { + QueryWrapper queryWrapper = Condition.getQueryWrapper(mesPlatingTypeRules, PlatingTypeRulesEntity.class); + //if (!AuthUtil.isAdministrator()) { + // queryWrapper.lambda().eq(PlatingTypeRules::getTenantId, bladeUser.getTenantId()); + //} + //queryWrapper.lambda().eq(PlatingTypeRulesEntity::getIsDeleted, BladeConstant.DB_NOT_DELETED); + List list = mesPlatingTypeRulesService.exportPlatingTypeRules(queryWrapper); + ExcelUtil.export(response, "外协镀种规则数据" + DateUtil.time(), "外协镀种规则数据表", list, PlatingTypeRulesExcel.class); + } + + /** + * 下载Excel模板 + */ + @GetMapping("/downloadExcelTemplate") + @ApiOperationSupport(order = 10) + @Operation(summary = "下载Excel模板", description = "") + public ResponseEntity downloadExcelTemplate() { + return ExcelExtUtil.downloadXlsTemplate( + "Excel/oem/外协镀种规则.xls", + "外协镀种规则.xls"); + } + + /** + * 导入Excel + */ + @PostMapping("/importExcel") + @ApiOperationSupport(order = 11) + @Operation(summary = "导入Excel", description = "MultipartFile") + public R importExcel(@RequestParam("file") MultipartFile file) { + R checkR = ExcelExtUtil.importExcelCheck(file); + if (checkR != null) { + return checkR; + } + List importList = ExcelUtil.read( + file, 0, 1, PlatingTypeRulesImport.class + ); + return mesPlatingTypeRulesService.saveExcelData(importList); + } +} diff --git a/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/mapper/OemAndAbilityMapper.xml b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/mapper/OemAndAbilityMapper.xml index bbef7423e..daa092173 100644 --- a/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/mapper/OemAndAbilityMapper.xml +++ b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/mapper/OemAndAbilityMapper.xml @@ -28,17 +28,17 @@ oaa.*, oem.oc_name AS oem_name, oem.code AS oem_code, - pa.code AS ca_code, - pa.name AS ca_name + ca.ca_code, + ca.ca_name from MES_OEM_AND_ABILITY oaa LEFT JOIN BS_OEM oem ON oaa.oc_id = oem.id - LEFT JOIN BA_PROCESS_ABILITY pa ON oaa.ca_id = pa.id + LEFT JOIN BS_CRAFT_ABILITY ca ON oaa.ca_id = ca.id where oaa.is_deleted = 0 AND oem.oc_name LIKE CONCAT('%', CONCAT(#{query.oemName}, '%')) - AND pa.id = #{query.caId} + AND ca.id = #{query.caId} diff --git a/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/mapper/OemStatementMapper.xml b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/mapper/OemStatementMapper.xml index eab68e013..979331de4 100644 --- a/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/mapper/OemStatementMapper.xml +++ b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/mapper/OemStatementMapper.xml @@ -20,11 +20,29 @@ + - + + + + + + + + + + + + + + + + + + @@ -44,10 +62,13 @@ + + + @@ -62,11 +83,6 @@ - - - - - diff --git a/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/mapper/PlatingTypeRulesMapper.java b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/mapper/PlatingTypeRulesMapper.java new file mode 100644 index 000000000..bf0d8d476 --- /dev/null +++ b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/mapper/PlatingTypeRulesMapper.java @@ -0,0 +1,39 @@ +package org.springblade.desk.oem.mapper; + +import org.springblade.desk.oem.pojo.entity.PlatingTypeRulesEntity; +import org.springblade.desk.oem.pojo.excel.PlatingTypeRulesExcel; +import org.springblade.desk.oem.pojo.vo.PlatingTypeRulesVO; +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 PlatingTypeRulesMapper extends BaseMapper { + + /** + * 自定义分页 + * + * @param page 分页参数 + * @param mesPlatingTypeRules 查询参数 + * @return List + */ + List selectPlatingTypeRulesPage(IPage page, PlatingTypeRulesVO mesPlatingTypeRules); + + + /** + * 获取导出数据 + * + * @param queryWrapper 查询条件 + * @return List + */ + List exportPlatingTypeRules(@Param("ew") Wrapper queryWrapper); + +} diff --git a/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/mapper/PlatingTypeRulesMapper.xml b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/mapper/PlatingTypeRulesMapper.xml new file mode 100644 index 000000000..befcddb8e --- /dev/null +++ b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/mapper/PlatingTypeRulesMapper.xml @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/service/IPlatingTypeRulesService.java b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/service/IPlatingTypeRulesService.java new file mode 100644 index 000000000..1e54864de --- /dev/null +++ b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/service/IPlatingTypeRulesService.java @@ -0,0 +1,46 @@ +package org.springblade.desk.oem.service; + +import com.baomidou.mybatisplus.core.conditions.Wrapper; +import org.springblade.core.tool.api.R; +import org.springblade.desk.oem.pojo.entity.PlatingTypeRulesEntity; +import org.springblade.desk.oem.pojo.excel.PlatingTypeRulesExcel; +import org.springblade.desk.oem.pojo.excel.PlatingTypeRulesImport; +import org.springblade.desk.oem.pojo.vo.PlatingTypeRulesVO; +import com.baomidou.mybatisplus.core.metadata.IPage; +import org.springblade.core.mp.base.BaseService; + +import java.util.List; + +/** + * 外协镀种规则 服务类 + * + * @author qyl + * @since 2026-03-03 + */ +public interface IPlatingTypeRulesService extends BaseService { + /** + * 自定义分页 + * + * @param page 分页参数 + * @param mesPlatingTypeRules 查询参数 + * @return IPage + */ + IPage selectPlatingTypeRulesPage(IPage page, PlatingTypeRulesVO mesPlatingTypeRules); + + + /** + * 导出数据 + * + * @param queryWrapper 查询条件 + * @return List + */ + List exportPlatingTypeRules(Wrapper queryWrapper); + + /** + * 导入 + * + * @param list + * @return + */ + R saveExcelData(List list); +} diff --git a/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/service/impl/OemStatementServiceImpl.java b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/service/impl/OemStatementServiceImpl.java index 5098ce2cb..c2804fd27 100644 --- a/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/service/impl/OemStatementServiceImpl.java +++ b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/service/impl/OemStatementServiceImpl.java @@ -1,20 +1,25 @@ package org.springblade.desk.oem.service.impl; +import cn.hutool.core.bean.BeanUtil; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.toolkit.StringUtils; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import jakarta.annotation.Resource; import org.springblade.core.mp.support.Query; import org.springblade.core.tool.api.R; -import org.springblade.desk.dashboard.utils.DateUtils; +import org.springblade.desk.oem.mapper.PlatingTypeRulesMapper; import org.springblade.desk.oem.pojo.entity.OemStatementEntity; +import org.springblade.desk.oem.pojo.entity.PlatingTypeRulesEntity; import org.springblade.desk.oem.pojo.excel.OemStatementExcel; import org.springblade.desk.oem.pojo.request.PriceSheetQuery; import org.springblade.desk.oem.pojo.request.StatementQuery; -import org.springblade.desk.oem.pojo.vo.OemStatementVO; import org.springblade.desk.oem.mapper.OemStatementMapper; import org.springblade.desk.oem.pojo.vo.PriceSheetVO; import org.springblade.desk.oem.pojo.vo.StatementVO; import org.springblade.desk.oem.service.IOemStatementService; +import org.springblade.desk.util.PriceMatcher; import org.springblade.erpdata.feign.IErpDataOemClient; +import org.springframework.beans.BeanUtils; import org.springframework.stereotype.Service; import com.baomidou.mybatisplus.core.conditions.Wrapper; import com.baomidou.mybatisplus.core.metadata.IPage; @@ -22,8 +27,7 @@ import org.springblade.core.mp.base.BaseServiceImpl; import java.math.BigDecimal; import java.time.LocalDate; -import java.util.List; -import java.util.Map; +import java.util.*; import java.util.stream.Collectors; /** @@ -38,6 +42,9 @@ public class OemStatementServiceImpl extends BaseServiceImpl selectOemStatementPage(IPage page, StatementQuery mesOemStatement) { return page.setRecords(baseMapper.selectOemStatementPage(page, mesOemStatement)); @@ -55,31 +62,660 @@ public class OemStatementServiceImpl extends BaseServiceImpl statementVOS, BigDecimal price, LocalDate putStoreDate) { - //以外协厂商分组的Map<厂家代码, 待结算工序结算单列表> - Map> oemAndStatementMap = statementVOS.stream().collect(Collectors.groupingBy(StatementVO::getOemCode)); + //1.以外协厂商分组的Map<厂家名称, 待结算工序结算单列表> + Map> oemAndStatementMap = statementVOS.stream().collect(Collectors.groupingBy(StatementVO::getOcName)); for (Map.Entry> listEntry : oemAndStatementMap.entrySet()) { //外协厂商下全部需要结算的结算单 List statementVOList = listEntry.getValue(); - //以外协代码，日期查出的全部报价单 - String oemCode = listEntry.getKey(); - PriceSheetQuery query = new PriceSheetQuery(); - query.setOcCode(oemCode); - query.setInDateStart(putStoreDate); - query.setInDateEnd(putStoreDate); - R> pageR = erpDataOemClient.priceSheetData(query, new Query() {{ - setSize(99999); - }}); - //外协厂商下规定日期内的全部报价单 - List priceSheetVOList = null; - if (pageR != null && pageR.getData() != null && pageR.getData().getRecords() != null && pageR.getData().getRecords().size() > 0) { - priceSheetVOList = pageR.getData().getRecords(); + //2.以外协名称，日期查出的全部报价单 + String oemName = listEntry.getKey(); + List priceSheetAllList = getPriceSheets(oemName, putStoreDate); + if (priceSheetAllList.isEmpty()) { + //【结算异常】 + statementVOList.forEach(statementVO -> { + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】匹配无报价记录", oemName)); + }); + } else { + //工序分组Map<工序, 报价列表> + Map> priceSheetMap = priceSheetAllList.stream().collect(Collectors.groupingBy(PriceSheetVO::getGxinfo)); + /*statementVOList.forEach(statementVO -> { + List matchedPriceSheets = MatchTheQuotations(statementVO, priceSheetMap); + if (matchedPriceSheets.isEmpty()) { + return; + } + statementVO.setPriceSheetList(matchedPriceSheets); + });*/ + //3.为每个结算单匹配报价集合 + statementVOList.forEach(statementVO -> { + List matchedPriceSheets = MatchTheQuotations(statementVO, priceSheetMap); + if (matchedPriceSheets.isEmpty()) { + return; + } + statementVO.setPriceSheetList(matchedPriceSheets); + //4.匹配规则，过滤出唯一报价 + //①.匹配车间订单号 + if (ruleWoNo(statementVO)) { + return; + } + //②.匹配物料名称和质量等级 + if (rulePartNameAndProdIdent(statementVO)) { + return; + } + //③.匹配金价银价 + if (ruleGoldAndSilverPrices(statementVO, price)) { + return; + } + //④.涂色标、涂色带、涂箭头 + if (ruleColor(statementVO)) { + return; + } + //⑤.物料号匹配 + if (ruleGoods(statementVO)) { + return; + } + //⑥.阶梯价匹配 + if (ruleTieredPricing(statementVO)) { + return; + } + }); } - statementVOList.forEach(statementVO -> { + //保存 + List saves = statementVOList.stream() + .map(statementVO -> { + OemStatementEntity entity = new OemStatementEntity(); + BeanUtils.copyProperties(statementVO, entity); + entity.setUpdateTime(new Date()); + return entity; + }) + .collect(Collectors.toList()); + baseMapper.insertOrUpdate(saves); + } + return R.success("操作完成"); + + } + + /** + * 获取报价单列表 + */ + private List getPriceSheets(String oemName, LocalDate putStoreDate) { + PriceSheetQuery query = new PriceSheetQuery(); + query.setOcName(oemName); + query.setInDateStart(putStoreDate); + query.setInDateEnd(putStoreDate); + +// R> pageR = erpDataOemClient.priceSheetData(query, new Query() {{ +// setSize(99999); +// }}); + +// if (pageR != null && pageR.getData() != null) { +// return pageR.getData().getRecords(); +// } + return Collections.emptyList(); + } + + /** + * 为结算单匹配报价集合 + * + * @param statementVO 外协厂家下镀后入库的外协工序结算单 + * @param priceSheetMap 外协厂家下有效期内的全部工序报价 + */ + private List MatchTheQuotations(StatementVO statementVO, Map> priceSheetMap) { + String psName = statementVO.getPsName(); + if (!priceSheetMap.containsKey(psName)) { + //【结算异常】 + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】匹配无报价记录", statementVO.getOcName(), psName)); + return null; + } + //获得外协厂商该工序下报价单列表 + return priceSheetMap.get(psName); + } + + /** + * 规则：匹配车间订单号 + * + * @param statementVO + * @return + */ + private boolean ruleWoNo(StatementVO statementVO) { + List priceSheetList = statementVO.getPriceSheetList(); + //取出匹配车间订单号的报价和无车间订单号的报价 + Map> woNoPriceSheetMap = priceSheetList.stream() + .collect(Collectors.groupingBy( + priceSheet -> { + String wono = priceSheet.getWono(); + return wono == null || wono.trim().isEmpty() ? "EMPTY_WONO" : wono; + }, + Collectors.toList() + )); + //匹配车间订单号报价 + if (woNoPriceSheetMap.containsKey(statementVO.getWoCode())) { + List woNoPriceSheetList = woNoPriceSheetMap.get(statementVO.getWoCode()); + //多条【结算异常】 + if (woNoPriceSheetList.size() > 1) { + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,工作订单号【%s】匹配多条报价记录", statementVO.getOcName(), statementVO.getPartName(), statementVO.getWoCode())); + //结算异常：多条报价记录结算结果 + return true; + } + PriceSheetVO priceSheet = woNoPriceSheetList.get(0); + //唯一使用此报价单**结算** + BigDecimal unitPrice = new BigDecimal(priceSheet.getPrice()); + BigDecimal qty = new BigDecimal(statementVO.getMakeQty()); + statementVO.setRosStatus(StatementVO.IN_SETTLEMENT); + statementVO.setUnitPrice(unitPrice); + statementVO.setUnit(priceSheet.getPrtum()); + statementVO.setTotalPrice(unitPrice.multiply(qty)); + statementVO.setMemo("结算中"); + statementVO.setQuotation(priceSheet.getSeqid()); + //使用此报价 + return true; + } else { + //筛选出无车间订单号报价单列表 + priceSheetList = woNoPriceSheetMap.get("EMPTY_WONO"); + if (priceSheetList.size() < 1) { + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】匹配无报价记录", statementVO.getOcName(), statementVO.getPartName())); + //结算异常：无报价记录结算结果 + return true; + } else { + statementVO.setPriceSheetList(priceSheetList); + //结束当前规则匹配，进入下一规则匹配 + return false; + } + } + } + + /** + * 规则：匹配物料名称和质量等级 + * + * @param statementVO + * @return + */ + private boolean rulePartNameAndProdIdent(StatementVO statementVO) { + List priceSheetList = statementVO.getPriceSheetList(); + //报价单判断同时满足物料名称和质量等级 || 为空 + priceSheetList = priceSheetList.stream() + .filter(priceSheet -> matchesCondition1(priceSheet, statementVO)) + .filter(priceSheet -> matchesCondition2(priceSheet, statementVO)) + .collect(Collectors.toList()); + //无报价单【结算异常】 + if (priceSheetList.size() < 1) { + //结算异常：无报价记录结算结果 + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,物料名【%s】,质量等级【%s】匹配无报价记录", statementVO.getOcName(), statementVO.getPartName(), statementVO.getPartName(), statementVO.getProdIdent())); + return true; + } + //保存结果，结束当前规则匹配，进入下一规则匹配 + statementVO.setPriceSheetList(priceSheetList); + return false; + } + + /** + * 规则：金价银价 + * + * @param statementVO + * @return + */ + private boolean ruleGoldAndSilverPrices(StatementVO statementVO, BigDecimal price) { + List priceSheetList = statementVO.getPriceSheetList(); + String plateGoodsCode = statementVO.getPlateGoodsCode(); + //判断传入参数的当前金价银价 > 0 && 零件镀层物料编码不为空，则需匹配规则 + if (price.compareTo(BigDecimal.ZERO) > 0 && StringUtils.isEmpty(plateGoodsCode)) { + //取出所有备注 + Map> remarkPriceSheetMap = priceSheetList.stream() + .filter(priceSheet -> { + String remark = priceSheet.getRemark(); + return remark != null && !remark.trim().isEmpty(); + }) + .collect(Collectors.groupingBy( + PriceSheetVO::getRemark, + Collectors.toList() + )); + Set remarksByPrice = PriceMatcher.findRemarksByPriceStream(remarkPriceSheetMap.keySet(), price); + if (remarksByPrice.size() < 1) { + //结算异常：无报价记录结算结果 + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,金价银价【%s】匹配无报价记录", statementVO.getOcName(), statementVO.getPartName(), price)); + return true; + } + //保存结果，结束当前规则匹配，进入下一规则匹配 + List priceSheetVOList = remarkPriceSheetMap.entrySet().stream() + .filter(entry -> remarksByPrice.contains(entry.getKey())) // 过滤key在keys中的条目 + .flatMap(entry -> entry.getValue().stream()) // 将List扁平化为PriceSheetVO流 + .collect(Collectors.toList()); + statementVO.setPriceSheetList(priceSheetVOList); + return false; + } + //结束当前规则匹配，进入下一规则匹配 + return false; + } + + /** + * 涂色标、涂色带、涂箭头匹配规则 + * + * @param statementVO + * @return + */ + private boolean ruleColor(StatementVO statementVO) { + List priceSheetList = statementVO.getPriceSheetList(); + //结算单色标色带箭头数量>0,需要匹配报价里色标色带箭头 + //如果结算单没有数量，直接返回false进入下个规则 + if (!hasColorCount(statementVO)) { + //结束当前规则匹配，进入下一规则匹配 + return false; + } + //涂色标、涂色带、涂箭头的报价集合 + Map> prtnoPriceSheetMap = priceSheetList.stream() + .filter(priceSheet -> { + String prtno = priceSheet.getPrtno(); + return prtno != null && !prtno.trim().isEmpty() && ("涂色标".equals(prtno) || "涂色带".equals(prtno) || "涂箭头".equals(prtno)); + }) + .collect(Collectors.groupingBy( + PriceSheetVO::getPrtno, + Collectors.toList() + )); + // 如果没有任何报价记录 + if (prtnoPriceSheetMap.isEmpty()) { + //结算异常：无报价记录结算结果 + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】涂色标、涂色带、涂箭头匹配无报价记录", statementVO.getOcName(), statementVO.getPartName())); + return true; + } + //总价 + BigDecimal totalPrice = BigDecimal.ZERO; + //涂箭头 + Integer tjtNum = StringUtils.isNotEmpty(statementVO.getTjtNum()) ? Integer.valueOf(statementVO.getTjtNum()) : 0; + //涂色标 + Integer tsbNum = StringUtils.isNotEmpty(statementVO.getTsbNum()) ? Integer.valueOf(statementVO.getTsbNum()) : 0; + //涂色带 + Integer tsdNum = StringUtils.isNotEmpty(statementVO.getTsdNum()) ? Integer.valueOf(statementVO.getTsdNum()) : 0; + //报价单号 + String quotation = ""; + if (tjtNum > 0 && prtnoPriceSheetMap.containsKey("涂箭头")) { + List tjtPriceSheetList = prtnoPriceSheetMap.get("涂箭头"); + if (tjtPriceSheetList.size() > 1) { + //结算异常：多条报价记录结算结果 + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,涂箭头数量【%s】匹配多条报价记录", statementVO.getOcName(), statementVO.getPartName(), tjtNum)); + return true; + } + //唯一使用此报价单**结算** + BigDecimal unitPrice = new BigDecimal(tjtPriceSheetList.get(0).getPrice()); + BigDecimal itemTotalPrice = unitPrice.multiply(BigDecimal.valueOf(tjtNum)); + totalPrice = totalPrice.add(itemTotalPrice); + quotation = tjtPriceSheetList.get(0).getSeqid(); + } + if (tsdNum > 0 && prtnoPriceSheetMap.containsKey("涂色带")) { + List tsdPriceSheetList = prtnoPriceSheetMap.get("涂色带"); + if (tsdPriceSheetList.size() > 1) { + //结算异常：多条报价记录结算结果 + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,涂色带数量【%s】匹配多条报价记录", statementVO.getOcName(), statementVO.getPartName(), tsdNum)); + return true; + } + //唯一使用此报价单**结算** + BigDecimal unitPrice = new BigDecimal(tsdPriceSheetList.get(0).getPrice()); + BigDecimal itemTotalPrice = unitPrice.multiply(BigDecimal.valueOf(tsdNum)); + totalPrice = totalPrice.add(itemTotalPrice); + quotation = tsdPriceSheetList.get(0).getSeqid(); + } + if (tsbNum > 0 && prtnoPriceSheetMap.containsKey("涂色标")) { + List tsbPriceSheetList = prtnoPriceSheetMap.get("涂色标"); + if (tsbPriceSheetList.size() > 1) { + //结算异常：多条报价记录结算结果 + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,涂色标数量【%s】匹配多条报价记录", statementVO.getOcName(), statementVO.getPartName(), tsbNum)); + return true; + } + //唯一使用此报价单**结算** + BigDecimal unitPrice = new BigDecimal(tsbPriceSheetList.get(0).getPrice()); + BigDecimal itemTotalPrice = unitPrice.multiply(BigDecimal.valueOf(tsbNum)); + totalPrice = totalPrice.add(itemTotalPrice); + quotation = tsbPriceSheetList.get(0).getSeqid(); + } + //如总价大于0，则报价成功 + if (totalPrice.compareTo(BigDecimal.ZERO) > 0) { + statementVO.setRosStatus(StatementVO.IN_SETTLEMENT); + statementVO.setTotalPrice(totalPrice); + statementVO.setMemo("结算中"); + statementVO.setQuotation(quotation); + return true; + } else { + //结算异常：多条报价记录结算结果 + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】涂色标、涂色带、涂箭头匹配无报价记录", statementVO.getOcName(), statementVO.getPartName())); + return true; + } + } + + /** + * 规则：物料号匹配 + * + * @param statementVO + * @return + */ + private boolean ruleGoods(StatementVO statementVO) { + List priceSheetList = statementVO.getPriceSheetList(); + //1.结算单的镀种、零件号、镀层厚度,三个维度分别匹配报价的物料号,匹配出单一维度的报价 + StatementVO statementPlate = BeanUtil.copyProperties(statementVO, StatementVO.class); + StatementVO statementPartCode = BeanUtil.copyProperties(statementVO, StatementVO.class); + StatementVO statementPlateThickness = BeanUtil.copyProperties(statementVO, StatementVO.class); + //2.统计结果为 true 的规则数量 + int trueCount = 0; + if (rulePlate(statementPlate)) { + statementVO.setPriceSheetList(statementPlate.getPriceSheetList()); + trueCount++; + } + if (rulePartCode(statementPartCode)) { + statementVO.setPriceSheetList(statementPartCode.getPriceSheetList()); + trueCount++; + } + if (rulePlateThickness(statementPlateThickness)) { + statementVO.setPriceSheetList(statementPlateThickness.getPriceSheetList()); + trueCount++; + } + if (trueCount == 1) { + //保存结果，结束当前规则匹配，进入下一规则匹配 + return false; + } else if (trueCount > 1) { + //结算异常：多条报价记录结算结果 + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,物料号匹配多条报价记录", statementVO.getOcName(), statementVO.getPartName())); + return true; + } else { + //结算异常：无报价记录结算结果 + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,物料号匹配无报价记录", statementVO.getOcName(), statementVO.getPartName())); + return true; + } + } - }); + /** + * 规则：镀种匹配 + * + * @param statementVO + * @return + */ + private boolean rulePlate(StatementVO statementVO) { + List priceSheetList = statementVO.getPriceSheetList(); + //结算单的镀种维度匹配报价的物料号 + String plate = statementVO.getPlate(); + if (StringUtils.isEmpty(plate)) { + return false; + } + Map> map = priceSheetList.stream().collect(Collectors.groupingBy(PriceSheetVO::getPrtno)); + //1.精确匹配，完整的镀种 + if (map.containsKey(plate)) { + statementVO.setPriceSheetList(map.get(plate)); + return true; } - return null; + //2.使用模糊查询。根据订单中的镀种，到镀种映射表中查询对应的代码，再根据代码查找报价，适用于：Ap.Ni15、Ap.Ni20有同一个报价Ap.Ni%Cu%Xn% + LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper(); + queryWrapper.eq(PlatingTypeRulesEntity::getOrderPlat, plate) + .orderByDesc(PlatingTypeRulesEntity::getCreateTime) // 按创建时间降序 + .last("AND ROWNUM = 1"); // 只取第一条 + PlatingTypeRulesEntity platingTypeRulesEntity = platingTypeRulesMapper.selectOne(queryWrapper); + if (platingTypeRulesEntity == null || StringUtils.isBlank(platingTypeRulesEntity.getQuotationPlat())) { + return false; + } + if (map.containsKey(platingTypeRulesEntity.getQuotationPlat())) { + statementVO.setPriceSheetList(map.get(plate)); + return true; + } + return true; } + /** + * 规则：零件号匹配 + * + * @param statementVO + * @return + */ + private boolean rulePartCode(StatementVO statementVO) { + List priceSheetList = statementVO.getPriceSheetList(); + //结算单的零件号维度匹配报价的物料号 + String partCode = statementVO.getPartCode(); + if (StringUtils.isEmpty(partCode)) { + return false; + } + Map> map = priceSheetList.stream().collect(Collectors.groupingBy(PriceSheetVO::getPrtno)); + //1.精确匹配，完整的零件号 + if (map.containsKey(partCode)) { + statementVO.setPriceSheetList(map.get(partCode)); + return true; + } + //2.模糊查询报价单中为一类零件号， 如81E6-%螺母 + Map> newMap = map.entrySet().stream() + .filter(entry -> entry.getKey().contains("-%")) + .collect(Collectors.toMap( + entry -> entry.getKey().split("%")[0], // 只保留%之前的部分 + Map.Entry::getValue + )); + List priceSheetVOList = newMap.entrySet().stream() + .filter(entry -> partCode.startsWith(entry.getKey())) + .flatMap(entry -> entry.getValue().stream()) // 将 List 扁平化为 Stream + .collect(Collectors.toList()); + //匹配成功,保存报价集合 + if (null != priceSheetVOList && !priceSheetVOList.isEmpty()) { + statementVO.setPriceSheetList(priceSheetVOList); + return true; + } + return false; + } + + /** + * 规则：镀层厚度匹配 + * + * @param statementVO + * @return + */ + private boolean rulePlateThickness(StatementVO statementVO) { + List priceSheetList = statementVO.getPriceSheetList(); + //结算单的镀层厚度维度分匹配报价的物料号, + String plateThickness = statementVO.getPlateThickness(); + if (StringUtils.isEmpty(plateThickness)) { + return false; + } + Map> map = priceSheetList.stream().collect(Collectors.groupingBy(PriceSheetVO::getPrtno)); + //镀层厚度值相等,保存报价集合 + if (map.containsKey(plateThickness)) { + statementVO.setPriceSheetList(map.get(plateThickness)); + return true; + } + return false; + } + + /** + * 规则：阶梯价匹配 + * + * @param statementVO + * @return + */ + private boolean ruleTieredPricing(StatementVO statementVO) { + List priceSheetList = statementVO.getPriceSheetList(); + //如果无报价，结算异常：无报价记录结算结果 + if (null == priceSheetList || priceSheetList.isEmpty()) { + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,阶梯价匹配无报价记录", statementVO.getOcName(), statementVO.getPartName())); + return true; + } + //如果只剩唯一报价，则直接使用 + if (priceSheetList.size() == 1) { + //唯一使用此报价单**结算** + PriceSheetVO priceSheet = priceSheetList.get(0); + BigDecimal unitPrice = new BigDecimal(priceSheet.getPrice()); + BigDecimal qty = new BigDecimal(statementVO.getMakeQty()); + statementVO.setRosStatus(StatementVO.IN_SETTLEMENT); + statementVO.setUnitPrice(unitPrice); + statementVO.setUnit(priceSheet.getPrtum()); + statementVO.setTotalPrice(unitPrice.multiply(qty)); + statementVO.setMemo("结算中"); + statementVO.setQuotation(priceSheet.getSeqid()); + //使用此报价 + return true; + } + //匹配阶梯价 + //1.只允许有一种阶梯价 + Map> StairPriceSheetMap = priceSheetList.stream().filter(priceSheet -> { + String stairflag = priceSheet.getStairflag(); + return stairflag != null && !stairflag.trim().isEmpty(); + }).collect(Collectors.groupingBy(PriceSheetVO::getStairflag)); + if (StairPriceSheetMap.keySet().size() > 1) { + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,阶梯价类型【%s】匹配多条报价记录", statementVO.getOcName(), statementVO.getPartName(), String.join(", ", StairPriceSheetMap.keySet()))); + return true; + } else if (StairPriceSheetMap.keySet().size() < 1) { + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,阶梯价匹配无报价记录", statementVO.getOcName(), statementVO.getPartName())); + return true; + } + if (StairPriceSheetMap.keySet().contains("非阶梯价")) { + //2.如果阶梯价是非阶梯价，判断报价是否唯一 + List priceSheetVOS = StairPriceSheetMap.get("非阶梯价"); + if (null == priceSheetVOS || priceSheetVOS.isEmpty()) { + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,阶梯价【】匹配无报价记录", statementVO.getOcName(), statementVO.getPartName(), "非阶梯价")); + return true; + } else if (null != priceSheetVOS && priceSheetVOS.size() > 1) { + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,阶梯价【】匹配多条报价记录", statementVO.getOcName(), statementVO.getPartName(), "非阶梯价")); + return true; + } + //唯一使用此报价单**结算** + PriceSheetVO priceSheet = priceSheetVOS.get(0); + BigDecimal unitPrice = new BigDecimal(priceSheet.getPrice()); + BigDecimal qty = new BigDecimal(statementVO.getMakeQty()); + statementVO.setRosStatus(StatementVO.IN_SETTLEMENT); + statementVO.setUnitPrice(unitPrice); + statementVO.setUnit(priceSheet.getPrtum()); + statementVO.setTotalPrice(unitPrice.multiply(qty)); + statementVO.setMemo("结算中"); + statementVO.setQuotation(priceSheet.getSeqid()); + return true; + } else if (StairPriceSheetMap.keySet().contains("单批阶梯价（按单件面积）")) { + //3.如果阶梯价是按单件面积，判断报价是否唯一 + List priceSheetVOS = StairPriceSheetMap.get("单批阶梯价（按单件面积）"); + //获取结算单的单件面积，匹配报价里的阶梯上下限 + String ypArea = statementVO.getYpArea(); + if (ypArea != null && ypArea.endsWith(".")) { + ypArea = ypArea.substring(0, ypArea.length() - 1); + } + double ypAreaValue = Double.parseDouble(ypArea); + if (null != priceSheetVOS && priceSheetVOS.size() > 1) { + List priceSheetVOList = priceSheetVOS.stream() + .filter(vo -> { + double lower = Double.parseDouble(vo.getLower()); + double upper = Double.parseDouble(vo.getUpper()); + return ypAreaValue >= lower && ypAreaValue <= upper; + }).collect(Collectors.toList()); + if (null != priceSheetVOList && priceSheetVOList.size() > 1) { + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,阶梯价【】匹配多条报价记录", statementVO.getOcName(), statementVO.getPartName(), "单批阶梯价（按单件面积）")); + return true; + } else if (null != priceSheetVOList && priceSheetVOList.size() == 1) { + //唯一使用此报价单**结算** + PriceSheetVO priceSheet = priceSheetVOList.get(0); + BigDecimal unitPrice = new BigDecimal(priceSheet.getPrice()); + BigDecimal qty = new BigDecimal(statementVO.getMakeQty()); + statementVO.setRosStatus(StatementVO.IN_SETTLEMENT); + statementVO.setUnitPrice(unitPrice); + statementVO.setUnit(priceSheet.getPrtum()); + statementVO.setTotalPrice(unitPrice.multiply(qty)); + statementVO.setMemo("结算中"); + statementVO.setQuotation(priceSheet.getSeqid()); + return true; + } + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,阶梯价【】匹配无报价记录", statementVO.getOcName(), statementVO.getPartName(), "单批阶梯价（按单件面积）")); + return true; + } + return true; + } else if (StairPriceSheetMap.keySet().contains("单批阶梯价（按单批面积）")) { + //4.如果阶梯价是按单批面积，判断报价是否唯一 + List priceSheetVOS = StairPriceSheetMap.get("单批阶梯价（按单批面积）"); + //获取结算单的单件面积，匹配报价里的阶梯上下限 + String totalArea = statementVO.getTotalArea(); + if (totalArea != null && totalArea.endsWith(".")) { + totalArea = totalArea.substring(0, totalArea.length() - 1); + } + double totalAreaValue = Double.parseDouble(totalArea); + if (null != priceSheetVOS && priceSheetVOS.size() > 1) { + List priceSheetVOList = priceSheetVOS.stream() + .filter(vo -> { + double lower = Double.parseDouble(vo.getLower()); + double upper = Double.parseDouble(vo.getUpper()); + return totalAreaValue >= lower && totalAreaValue <= upper; + }).collect(Collectors.toList()); + if (null != priceSheetVOList && priceSheetVOList.size() > 1) { + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,阶梯价【】匹配多条报价记录", statementVO.getOcName(), statementVO.getPartName(), "单批阶梯价（按单批面积）")); + return true; + } else if (null != priceSheetVOList && priceSheetVOList.size() == 1) { + //唯一使用此报价单**结算** + PriceSheetVO priceSheet = priceSheetVOList.get(0); + BigDecimal unitPrice = new BigDecimal(priceSheet.getPrice()); + BigDecimal qty = new BigDecimal(statementVO.getMakeQty()); + statementVO.setRosStatus(StatementVO.IN_SETTLEMENT); + statementVO.setUnitPrice(unitPrice); + statementVO.setUnit(priceSheet.getPrtum()); + statementVO.setTotalPrice(unitPrice.multiply(qty)); + statementVO.setMemo("结算中"); + statementVO.setQuotation(priceSheet.getSeqid()); + return true; + } + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,阶梯价【】匹配无报价记录", statementVO.getOcName(), statementVO.getPartName(), "单批阶梯价（按单批面积）")); + return true; + } + return true; + } else { + //todo:qyl 5.其他阶梯价类型暂不处理，找客户确认 + statementVO.setRosStatus(StatementVO.ERR_SETTLEMENT); + statementVO.setMemo(String.format("外协厂商【%s】,工序内容【%s】,阶梯价匹配无报价记录", statementVO.getOcName(), statementVO.getPartName())); + return true; + } + } + + /** + * 检查是否有涂色相关的数量 + */ + private boolean hasColorCount(StatementVO statementVO) { + return StringUtils.isNotEmpty(statementVO.getTjtNum()) + || StringUtils.isNotEmpty(statementVO.getTsbNum()) + || StringUtils.isNotEmpty(statementVO.getTsdNum()); + } + + /** + * 条件1: prtdesc 匹配 + */ + private boolean matchesCondition1(PriceSheetVO priceSheet, StatementVO statementVO) { + String prtdesc = priceSheet.getPrtdesc(); + String partName = statementVO.getPartName(); + + // 条件: prtdesc 为空 或 与 partName 相等 + return StringUtils.isBlank(prtdesc) || partName.equals(prtdesc); + } + + /** + * 条件2: prtlotno 匹配 + */ + private boolean matchesCondition2(PriceSheetVO priceSheet, StatementVO statementVO) { + String prtlotno = priceSheet.getPrtlotno(); + String prodIdent = statementVO.getProdIdent(); + + // 如果 prtlotno 是 "/"，条件满足 + if ("/".equals(prtlotno)) { + return true; + } + + // 按"和"分割，检查前缀 + String[] prefixes = prtlotno.split("和"); + + return Arrays.stream(prefixes) + .map(String::trim) // 去除空格 + .anyMatch(prodIdent::startsWith); + } } diff --git a/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/service/impl/PlatingTypeRulesServiceImpl.java b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/service/impl/PlatingTypeRulesServiceImpl.java new file mode 100644 index 000000000..8812c9072 --- /dev/null +++ b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/service/impl/PlatingTypeRulesServiceImpl.java @@ -0,0 +1,58 @@ +package org.springblade.desk.oem.service.impl; + +import org.springblade.core.tool.api.R; +import org.springblade.desk.oem.pojo.entity.OemProcessEntity; +import org.springblade.desk.oem.pojo.entity.PlatingTypeRulesEntity; +import org.springblade.desk.oem.pojo.excel.PlatingTypeRulesExcel; +import org.springblade.desk.oem.pojo.excel.PlatingTypeRulesImport; +import org.springblade.desk.oem.pojo.vo.PlatingTypeRulesVO; +import org.springblade.desk.oem.mapper.PlatingTypeRulesMapper; +import org.springblade.desk.oem.service.IPlatingTypeRulesService; +import org.springframework.beans.BeanUtils; +import org.springframework.stereotype.Service; +import com.baomidou.mybatisplus.core.conditions.Wrapper; +import com.baomidou.mybatisplus.core.metadata.IPage; +import org.springblade.core.mp.base.BaseServiceImpl; + +import java.util.ArrayList; +import java.util.Date; +import java.util.List; + +/** + * 外协镀种规则 服务实现类 + * + * @author qyl + * @since 2026-03-03 + */ +@Service +public class PlatingTypeRulesServiceImpl extends BaseServiceImpl implements IPlatingTypeRulesService { + + @Override + public IPage selectPlatingTypeRulesPage(IPage page, PlatingTypeRulesVO mesPlatingTypeRules) { + return page.setRecords(baseMapper.selectPlatingTypeRulesPage(page, mesPlatingTypeRules)); + } + + + @Override + public List exportPlatingTypeRules(Wrapper queryWrapper) { + List mesPlatingTypeRulesList = baseMapper.exportPlatingTypeRules(queryWrapper); + //mesPlatingTypeRulesList.forEach(mesPlatingTypeRules -> { + // mesPlatingTypeRules.setTypeName(DictCache.getValue(DictEnum.YES_NO, PlatingTypeRules.getType())); + //}); + return mesPlatingTypeRulesList; + } + + @Override + public R saveExcelData(List importList) { + List saves = new ArrayList<>(); + importList.forEach(platingTypeRulesImport -> { + PlatingTypeRulesEntity mesPlatingTypeRulesEntity = new PlatingTypeRulesEntity(); + BeanUtils.copyProperties(platingTypeRulesImport, mesPlatingTypeRulesEntity); + mesPlatingTypeRulesEntity.setCreateTime(new Date()); + saves.add(mesPlatingTypeRulesEntity); + }); + baseMapper.insertOrUpdate(saves); + return R.success("操作完成"); + } + +} diff --git a/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/wrapper/PlatingTypeRulesWrapper.java b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/wrapper/PlatingTypeRulesWrapper.java new file mode 100644 index 000000000..73208789d --- /dev/null +++ b/blade-service/blade-desk/src/main/java/org/springblade/desk/oem/wrapper/PlatingTypeRulesWrapper.java @@ -0,0 +1,35 @@ +package org.springblade.desk.oem.wrapper; + +import org.springblade.core.mp.support.BaseEntityWrapper; +import org.springblade.core.tool.utils.BeanUtil; +import org.springblade.desk.oem.pojo.entity.PlatingTypeRulesEntity; +import org.springblade.desk.oem.pojo.vo.PlatingTypeRulesVO; + +import java.util.Objects; + +/** + * 外协镀种规则 包装类,返回视图层所需的字段 + * + * @author qyl + * @since 2026-03-03 + */ +public class PlatingTypeRulesWrapper extends BaseEntityWrapper { + + public static PlatingTypeRulesWrapper build() { + return new PlatingTypeRulesWrapper(); + } + + @Override + public PlatingTypeRulesVO entityVO(PlatingTypeRulesEntity mesPlatingTypeRules) { + PlatingTypeRulesVO mesPlatingTypeRulesVO = Objects.requireNonNull(BeanUtil.copyProperties(mesPlatingTypeRules, PlatingTypeRulesVO.class)); + + //User createUser = UserCache.getUser(mesPlatingTypeRules.getCreateUser()); + //User updateUser = UserCache.getUser(mesPlatingTypeRules.getUpdateUser()); + //mesPlatingTypeRulesVO.setCreateUserName(createUser.getName()); + //mesPlatingTypeRulesVO.setUpdateUserName(updateUser.getName()); + + return mesPlatingTypeRulesVO; + } + + +} diff --git a/blade-service/blade-desk/src/main/java/org/springblade/desk/produce/mapper/WorkOrderRunMapper.xml b/blade-service/blade-desk/src/main/java/org/springblade/desk/produce/mapper/WorkOrderRunMapper.xml index ddbcb3389..a66a37a4b 100644 --- a/blade-service/blade-desk/src/main/java/org/springblade/desk/produce/mapper/WorkOrderRunMapper.xml +++ b/blade-service/blade-desk/src/main/java/org/springblade/desk/produce/mapper/WorkOrderRunMapper.xml @@ -42,6 +42,7 @@ + @@ -78,6 +79,7 @@ two.inventory_qty, two.send_down_time, two.put_store_time, + two.approval_status, tyo.yp_code, tyo.part_code, tyo.part_name, @@ -106,9 +108,9 @@ -- 关联生产订单表 LEFT JOIN MES_YIELD_ORDER tyo ON two.yo_id = tyo.id -- 关联转出班组（只取名称） - LEFT JOIN BA_TEAM_SET out_team ON mwor.out_team = out_team.id + LEFT JOIN BS_TEAM_SET out_team ON mwor.out_team = out_team.id -- 关联转入班组（只取名称） - LEFT JOIN BA_TEAM_SET in_team ON mwor.in_team = in_team.id + LEFT JOIN BS_TEAM_SET in_team ON mwor.in_team = in_team.id -- 关联审批人员（只取名称） LEFT JOIN blade_user approval_user ON mwor.approval_man = approval_user.id -- 关联计划员 @@ -159,8 +161,8 @@ AND dispatcher_user.real_name LIKE CONCAT('%', CONCAT(#{query.dispatcher}, '%')) - AND (ome.code LIKE CONCAT('%', CONCAT(#{query.oemCode}, '%')) - OR ome.oc_name LIKE CONCAT('%', CONCAT(#{query.oemCode}, '%'))) + AND (oem.code LIKE CONCAT('%', CONCAT(#{query.oemCode}, '%')) + OR oem.oc_name LIKE CONCAT('%', CONCAT(#{query.oemCode}, '%'))) AND two.priority = #{query.priority} @@ -169,21 +171,21 @@ AND tyo.release_date >= #{query.planIssuanceTimeStart} - AND tyo.release_date <= #{query.planIssuanceTimeEnd} + AND tyo.release_date < #{query.planIssuanceTimeEnd} + 1 AND two.put_store_time >= #{query.postPlatingStorageTimeStart} - AND two.put_store_time <= #{query.postPlatingStorageTimeEnd} + AND two.put_store_time < #{query.postPlatingStorageTimeEnd}+ 1 AND two.demand_date >= #{query.demandDateStart} - AND two.demand_date <= #{query.demandDateEnd} + AND two.demand_date < #{query.demandDateEnd}+ 1 @@ -226,6 +228,7 @@ + @@ -254,6 +257,7 @@ two.wo_code, two.batch_no, two.inventory_qty, + two.approval_status, tyo.part_code, tyo.part_name, tyo.product_ident, @@ -285,8 +289,8 @@ AND mwor.system_data = #{query.systemData} - - AND two.wo_code LIKE CONCAT('%', CONCAT(#{query.orderCode}, '%')) + + AND two.wo_code LIKE CONCAT('%', CONCAT(#{query.woCode}, '%')) AND tyo.part_code LIKE CONCAT('%', CONCAT(#{query.partCode}, '%')) @@ -302,7 +306,7 @@ AND mwor.create_time >= #{query.startTime} - AND mwor.create_time <= #{query.endTime} + AND mwor.create_time < #{query.endTime} + 1 diff --git a/blade-service/blade-desk/src/main/java/org/springblade/desk/produce/service/impl/WorkOrderRunServiceImpl.java b/blade-service/blade-desk/src/main/java/org/springblade/desk/produce/service/impl/WorkOrderRunServiceImpl.java index df875dc73..9c5ca2596 100644 --- a/blade-service/blade-desk/src/main/java/org/springblade/desk/produce/service/impl/WorkOrderRunServiceImpl.java +++ b/blade-service/blade-desk/src/main/java/org/springblade/desk/produce/service/impl/WorkOrderRunServiceImpl.java @@ -420,7 +420,7 @@ public class WorkOrderRunServiceImpl extends BaseServiceImpl batchResults = workPlanMapper.insertOrUpdate(workPlans); - // todo 2.在MES更改后同步给ERP + // todo:qyl 2.在MES更改后同步给ERP return null; } diff --git a/blade-service/blade-desk/src/main/resources/Excel/oem/外协镀种规则.xls b/blade-service/blade-desk/src/main/resources/Excel/oem/外协镀种规则.xls new file mode 100644 index 000000000..ee6607529 Binary files /dev/null and b/blade-service/blade-desk/src/main/resources/Excel/oem/外协镀种规则.xls differ diff --git a/blade-service/blade-erpdata/src/main/java/org/springblade/erpdata/mapper/ErpDataOemMapper.xml b/blade-service/blade-erpdata/src/main/java/org/springblade/erpdata/mapper/ErpDataOemMapper.xml index 1f4966f31..f7f8b7967 100644 --- a/blade-service/blade-erpdata/src/main/java/org/springblade/erpdata/mapper/ErpDataOemMapper.xml +++ b/blade-service/blade-erpdata/src/main/java/org/springblade/erpdata/mapper/ErpDataOemMapper.xml @@ -12,6 +12,9 @@ AND a.splycode LIKE concat(concat('%', #{query.ocCode}),'%') + + AND a.splyname LIKE concat(concat('%', #{query.ocName}),'%') + AND a.prtno LIKE concat(concat('%', #{query.partCode}),'%')