From 09dc2d215cc61b5f94b12f1b3977209a9bfd11e4 Mon Sep 17 00:00:00 2001 From: zhaoqiaobo <583671871@qq.com> Date: Wed, 26 Feb 2025 13:57:50 +0800 Subject: [PATCH] =?UTF-8?q?feat(all):=20=E4=BB=B7=E6=A0=BC=E4=BD=93?= =?UTF-8?q?=E7=B3=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 1 增加价格体系多维度导入，导出 2 移除价格体系截止时间字段 --- .../entity/BasicdataPriceEntity.java | 2 + .../vo/BasicdataPriceBasicUpdateV2VO.java | 49 + .../basicdata/vo/BasicdataPricePageV2VO.java | 82 + .../controller/BasicdataPriceController.java | 138 +- .../BasicdataPriceCategoryV2Excel.java | 64 +- .../BasicdataPriceFullVehicleV2Excel.java | 48 +- .../pricev2/BasicdataPriceGeneralV2Excel.java | 4 + .../excel/pricev2/BasicdataPriceV3Excel.java | 84 + .../mapper/BasicdataPriceMapper.java | 12 +- .../basicdata/mapper/BasicdataPriceMapper.xml | 145 ++ .../query/BasicdataPriceV2Query.java | 52 + .../service/IBasicdataPriceService.java | 17 + .../impl/BasicdataPriceServiceImpl.java | 2194 ++++++++++++++--- 13 files changed, 2528 insertions(+), 363 deletions(-) create mode 100644 blade-service-api/logpm-basicdata-api/src/main/java/com/logpm/basicdata/vo/BasicdataPriceBasicUpdateV2VO.java create mode 100644 blade-service-api/logpm-basicdata-api/src/main/java/com/logpm/basicdata/vo/BasicdataPricePageV2VO.java create mode 100644 blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/excel/pricev2/BasicdataPriceV3Excel.java create mode 100644 blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/query/BasicdataPriceV2Query.java diff --git a/blade-service-api/logpm-basicdata-api/src/main/java/com/logpm/basicdata/entity/BasicdataPriceEntity.java b/blade-service-api/logpm-basicdata-api/src/main/java/com/logpm/basicdata/entity/BasicdataPriceEntity.java index d80f89430..3c3b6e7c8 100644 --- a/blade-service-api/logpm-basicdata-api/src/main/java/com/logpm/basicdata/entity/BasicdataPriceEntity.java +++ b/blade-service-api/logpm-basicdata-api/src/main/java/com/logpm/basicdata/entity/BasicdataPriceEntity.java @@ -55,6 +55,8 @@ public class BasicdataPriceEntity extends TenantEntity { private Long brandId; @ApiModelProperty(value = "维护状态(1:未维护,2:已维护,3:已到期)") private Integer maintenanceStatus; + @ApiModelProperty(value = "生效状态 -1未生效 0生效中 1已失效") + private Integer effectiveStatus; @ApiModelProperty(value = "生效时间") private Date effectiveTime; @ApiModelProperty(value = "到期时间") diff --git a/blade-service-api/logpm-basicdata-api/src/main/java/com/logpm/basicdata/vo/BasicdataPriceBasicUpdateV2VO.java b/blade-service-api/logpm-basicdata-api/src/main/java/com/logpm/basicdata/vo/BasicdataPriceBasicUpdateV2VO.java new file mode 100644 index 000000000..14017249b --- /dev/null +++ b/blade-service-api/logpm-basicdata-api/src/main/java/com/logpm/basicdata/vo/BasicdataPriceBasicUpdateV2VO.java @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2018-2028, Chill Zhuang All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * Neither the name of the dreamlu.net developer nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * Author: Chill 庄骞 (smallchill@163.com) + */ +package com.logpm.basicdata.vo; + +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import javax.validation.constraints.NotNull; +import java.io.Serializable; +import java.util.Date; + +/** + * 基础配置 视图实体类 + * + * @author zqb + * @since 2024-04-02 + */ +@Data +public class BasicdataPriceBasicUpdateV2VO implements Serializable { + private static final long serialVersionUID = 1L; + + @ApiModelProperty(value = "id") + private Long id; + @NotNull(message = "模板不能为空") + @ApiModelProperty(value = "模板id") + private Long templateId; + @ApiModelProperty(value = "客户id") + private Long clientId; + @ApiModelProperty(value = "品牌id") + private Long brandId; + @NotNull(message = "生效时间不能为空") + @ApiModelProperty(value = "生效时间") + private Date effectiveTime; + +} diff --git a/blade-service-api/logpm-basicdata-api/src/main/java/com/logpm/basicdata/vo/BasicdataPricePageV2VO.java b/blade-service-api/logpm-basicdata-api/src/main/java/com/logpm/basicdata/vo/BasicdataPricePageV2VO.java new file mode 100644 index 000000000..35419f81c --- /dev/null +++ b/blade-service-api/logpm-basicdata-api/src/main/java/com/logpm/basicdata/vo/BasicdataPricePageV2VO.java @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2018-2028, Chill Zhuang All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * Neither the name of the dreamlu.net developer nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * Author: Chill 庄骞 (smallchill@163.com) + */ +package com.logpm.basicdata.vo; + +import com.fasterxml.jackson.annotation.JsonFormat; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.io.Serializable; +import java.util.Date; + +/** + * 基础价格表 视图实体类 + * + * @author zqb + * @since 2024-04-02 + */ +@Data +public class BasicdataPricePageV2VO implements Serializable { + private static final long serialVersionUID = 1L; + + @ApiModelProperty(value = "id") + private String id; + + @ApiModelProperty(value = "客户名称") + private String clientName; + + @ApiModelProperty(value = "品牌名称") + private String brandName; + + @ApiModelProperty(value = "品牌id") + private String brandId; + + @ApiModelProperty(value = "客户id") + private String clientId; + + @ApiModelProperty(value = "价格模板id") + private String templateId; + + @ApiModelProperty(value = "价格模板名称") + private String templateName; + + @ApiModelProperty(value = "模板服务类型") + private String serviceType; + + @ApiModelProperty(value = "维护状态") + private String maintenanceStatus; + + @ApiModelProperty(value = "生效状态") + private String effectiveStatus; + + @ApiModelProperty(value = "修改时间") + private String updateTime; + + @ApiModelProperty(value = "配送-上楼费免费楼层") + private String dispatchStairsCarryingCharge; + + @ApiModelProperty(value = "配送-向上判断件数") + private String dispatchUpwardJudgment; + + @ApiModelProperty(value = "配送-向上判断加价") + private String dispatchUpwardJudgmentCost; + + @ApiModelProperty(value = "生效时间") + @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8") + private Date effectiveTime; + +} diff --git a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/controller/BasicdataPriceController.java b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/controller/BasicdataPriceController.java index e58a9176e..9d98a0385 100644 --- a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/controller/BasicdataPriceController.java +++ b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/controller/BasicdataPriceController.java @@ -23,9 +23,25 @@ import com.alibaba.excel.write.metadata.WriteSheet; import com.alibaba.excel.write.metadata.WriteTable; import com.baomidou.mybatisplus.core.metadata.IPage; import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport; -import com.logpm.basicdata.excel.price.*; +import com.logpm.basicdata.excel.price.BasicdataPriceCategoryBasicExcel; +import com.logpm.basicdata.excel.price.BasicdataPriceCategoryDispatchExcel; +import com.logpm.basicdata.excel.price.BasicdataPriceCategoryWarehouseExcel; +import com.logpm.basicdata.excel.price.BasicdataPriceExcel; +import com.logpm.basicdata.excel.price.BasicdataPriceFullVehicleExcel; +import com.logpm.basicdata.excel.price.BasicdataPriceGeneralExcel; +import com.logpm.basicdata.excel.pricev2.BasicdataPriceCategoryV2Excel; +import com.logpm.basicdata.excel.pricev2.BasicdataPriceFullVehicleV2Excel; +import com.logpm.basicdata.excel.pricev2.BasicdataPriceGeneralV2Excel; +import com.logpm.basicdata.excel.pricev2.BasicdataPriceV3Excel; +import com.logpm.basicdata.query.BasicdataPriceV2Query; import com.logpm.basicdata.service.IBasicdataPriceService; -import com.logpm.basicdata.vo.*; +import com.logpm.basicdata.vo.BasicdatPriceApiVO; +import com.logpm.basicdata.vo.BasicdataPriceBasicUpdateV2VO; +import com.logpm.basicdata.vo.BasicdataPriceBasicUpdateVO; +import com.logpm.basicdata.vo.BasicdataPricePageV2VO; +import com.logpm.basicdata.vo.BasicdataPricePageVO; +import com.logpm.basicdata.vo.PriceClientVO; +import com.logpm.basicdata.vo.PriceVO; import io.swagger.annotations.Api; import io.swagger.annotations.ApiImplicitParam; import io.swagger.annotations.ApiImplicitParams; @@ -35,7 +51,17 @@ import org.springblade.core.boot.ctrl.BladeController; import org.springblade.core.mp.support.Condition; import org.springblade.core.mp.support.Query; import org.springblade.core.tool.api.R; -import org.springframework.web.bind.annotation.*; +import org.springframework.web.bind.annotation.DeleteMapping; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PatchMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.PutMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.RequestPart; +import org.springframework.web.bind.annotation.RestController; import org.springframework.web.multipart.MultipartFile; import springfox.documentation.annotations.ApiIgnore; @@ -78,18 +104,41 @@ public class BasicdataPriceController extends BladeController { */ @GetMapping @ApiOperationSupport(order = 2) - @ApiOperation(value = "基础价格分页", notes = "传入basicdataPrice") - public R> page(BasicdataPricePageVO basicdataPrice, Query query) { + @ApiOperation(value = "基础价格分页v2", notes = "传入basicdataPrice") + public R> pageV2(BasicdataPriceV2Query basicdataPrice, Query query) { + IPage pages = basicdataPriceService.selectBasicdataPricePageV2(Condition.getPage(query), basicdataPrice); + return R.data(pages); + } + + /** + * 基础价格表 自定义分页 + */ + @GetMapping("page/v1") + @ApiOperationSupport(order = 2) + @ApiOperation(value = "基础价格分页v1", notes = "传入basicdataPrice") + public R> pageV1(BasicdataPricePageVO basicdataPrice, Query query) { IPage pages = basicdataPriceService.selectBasicdataPricePage(Condition.getPage(query), basicdataPrice); return R.data(pages); } + /** * 基础价格表 历史版本查询 */ @GetMapping("hisPage") @ApiOperationSupport(order = 2) - @ApiOperation(value = "历史版本查询", notes = "历史版本查询") - public R> hisPage(BasicdataPricePageVO basicdataPrice, Query query) { + @ApiOperation(value = "历史版本查询v2", notes = "历史版本查询") + public R> hisPageV2(BasicdataPricePageV2VO basicdataPrice, Query query) { + IPage pages = basicdataPriceService.hisPageV2(Condition.getPage(query), basicdataPrice); + return R.data(pages); + } + + /** + * 基础价格表 历史版本查询 + */ + @GetMapping("hisPage/v1") + @ApiOperationSupport(order = 2) + @ApiOperation(value = "历史版本查询v1", notes = "历史版本查询") + public R> hisPageV1(BasicdataPricePageVO basicdataPrice, Query query) { IPage pages = basicdataPriceService.hisPage(Condition.getPage(query), basicdataPrice); return R.data(pages); } @@ -99,8 +148,18 @@ public class BasicdataPriceController extends BladeController { */ @PatchMapping @ApiOperationSupport(order = 4) - @ApiOperation(value = "基础配置", notes = "传入basicdataPrice") - public R basicUpdate(@Valid @RequestBody BasicdataPriceBasicUpdateVO vo) { + @ApiOperation(value = "基础配置v2", notes = "传入basicdataPrice") + public R basicUpdateV2(@Valid @RequestBody BasicdataPriceBasicUpdateV2VO vo) { + return R.status(basicdataPriceService.basicUpdateV2(vo)); + } + + /** + * 基础价格表 修改 + */ + @PatchMapping("/v1") + @ApiOperationSupport(order = 4) + @ApiOperation(value = "基础配置v1", notes = "传入basicdataPrice") + public R basicUpdateV1(@Valid @RequestBody BasicdataPriceBasicUpdateVO vo) { return R.status(basicdataPriceService.basicUpdate(vo)); } @@ -114,6 +173,7 @@ public class BasicdataPriceController extends BladeController { Boolean res = basicdataPriceService.updatePrice(vo); return R.status(res); } + @DeleteMapping("{id}") @ApiOperationSupport(order = 5) @ApiOperation(value = "删除待生效的价格", notes = "删除待生效的价格") @@ -134,12 +194,14 @@ public class BasicdataPriceController extends BladeController { public R upload(@RequestPart("file") MultipartFile file) { return R.data(basicdataPriceService.upload(file)); } + /** - * 基础价格表 导入 + * 基础价格表 导入 覆盖导入 v2 + * 带生效时间和结束时间的版本 */ @PostMapping("upload/v2") @ApiOperationSupport(order = 6) - @ApiOperation(value = "导入v2", notes = "导入v2") + @ApiOperation(value = "导入v2 覆盖导入", notes = "导入v2 覆盖导入") @ApiImplicitParams({ @ApiImplicitParam(name = "file", value = "文件", dataType = "MultipartFile") }) @@ -147,6 +209,34 @@ public class BasicdataPriceController extends BladeController { return R.data(basicdataPriceService.uploadV2(file)); } + /** + * 基础价格表 导入 更新导入 + * 只有生效时间的版本 + */ + @PostMapping("upload/v3/update") + @ApiOperationSupport(order = 6) + @ApiOperation(value = "导入v3 更新导入", notes = "导入v3 更新导入") + @ApiImplicitParams({ + @ApiImplicitParam(name = "file", value = "文件", dataType = "MultipartFile") + }) + public R uploadV3Update(@RequestPart("file") MultipartFile file) { + return R.data(basicdataPriceService.uploadV3Update(file)); + } + + /** + * 基础价格表 导入 覆盖导入 + * 只有生效时间的版本 + */ + @PostMapping("upload/v3") + @ApiOperationSupport(order = 6) + @ApiOperation(value = "导入v3 覆盖导入", notes = "导入v3 覆盖导入") + @ApiImplicitParams({ + @ApiImplicitParam(name = "file", value = "文件", dataType = "MultipartFile") + }) + public R uploadV3(@RequestPart("file") MultipartFile file) { + return R.data(basicdataPriceService.uploadV3(file)); + } + /** * 基础价格表 指定查询 */ @@ -193,4 +283,30 @@ public class BasicdataPriceController extends BladeController { } } + @GetMapping("/export/v2") + @ApiOperationSupport(order = 8) + @ApiOperation(value = "导出", notes = "导出") + public void exportV2(BasicdataPriceV2Query basicdataPrice, HttpServletResponse response) { + try { + String fileName = "基础价格表" + DateUtil.today(); + response.setContentType("application/vnd.ms-excel"); + response.setCharacterEncoding(StandardCharsets.UTF_8.name()); + fileName = URLEncoder.encode(fileName, StandardCharsets.UTF_8.name()); + response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xlsx"); + ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream()).build(); + WriteTable table1 = EasyExcel.writerTable(0).head(BasicdataPriceV3Excel.class).build(); + WriteTable table2 = EasyExcel.writerTable(1).head(BasicdataPriceFullVehicleV2Excel.class).build(); + WriteTable table3 = EasyExcel.writerTable(2).head(BasicdataPriceGeneralV2Excel.class).build(); + WriteTable table4 = EasyExcel.writerTable(3).head(BasicdataPriceCategoryV2Excel.class).build(); + WriteSheet writeSheet1 = EasyExcel.writerSheet(0, "基础数据模版").build(); + WriteSheet writeSheet2 = EasyExcel.writerSheet(1, "整车包含路径提货、干线、配送整车费用").build(); + WriteSheet writeSheet3 = EasyExcel.writerSheet(2, "最低价格（保底价）").build(); + WriteSheet writeSheet4 = EasyExcel.writerSheet(3, "品类（正常计费）").build(); + basicdataPriceService.exportV2(basicdataPrice, excelWriter, writeSheet1, table1, writeSheet2, table2, writeSheet3, table3, writeSheet4, table4); + excelWriter.finish(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } diff --git a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/excel/pricev2/BasicdataPriceCategoryV2Excel.java b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/excel/pricev2/BasicdataPriceCategoryV2Excel.java index 1f05060d9..019c36aac 100644 --- a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/excel/pricev2/BasicdataPriceCategoryV2Excel.java +++ b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/excel/pricev2/BasicdataPriceCategoryV2Excel.java @@ -40,65 +40,69 @@ public class BasicdataPriceCategoryV2Excel implements Serializable { private static final long serialVersionUID = 1L; - @ExcelProperty(value = {"商场名称", "商场名称"}, index = 0) + @ExcelProperty(value = {"商场(客户)名称", "商场(客户)名称", "商场(客户)名称", "商场(客户)名称"}, index = 0) private String client; - @ExcelProperty(value = {"品牌", "品牌"}, index = 1) + @ExcelProperty(value = {"品牌", "品牌", "品牌", "品牌"}, index = 1) private String brand; - @ExcelProperty(value = {"发站", "省"}, index = 2) + @ExcelProperty(value = {"路径", "发站", "省", "省"}, index = 2) private String startProvince; - @ExcelProperty(value = {"发站", "市"}, index = 3) + @ExcelProperty(value = {"路径", "发站", "市", "市"}, index = 3) private String startCity; - @ExcelProperty(value = {"发站", "区"}, index = 4) + @ExcelProperty(value = {"路径", "发站", "区", "区"}, index = 4) private String startArea; - @ExcelProperty(value = {"到站", "省"}, index = 5) + @ExcelProperty(value = {"路径", "到站", "省", "省"}, index = 5) private String endProvince; - @ExcelProperty(value = {"到站", "市"}, index = 6) + @ExcelProperty(value = {"路径", "到站", "市", "市"}, index = 6) private String endCity; - @ExcelProperty(value = {"到站", "区"}, index = 7) + @ExcelProperty(value = {"路径", "到站", "区", "区"}, index = 7) private String endArea; - @ExcelProperty(value = {"发货单位", "发货单位编码"}, index = 8) + @ExcelProperty(value = {"路径", "发货单位", "发货单位ID", "发货单位ID"}, index = 8) private String sendOrgCode; - @ExcelProperty(value = {"发货单位", "发货单位"}, index = 9) + @ExcelProperty(value = {"路径", "发货单位", "发货单位", "发货单位"}, index = 9) private String sendOrg; - @ExcelProperty(value = {"品类", "品类"}, index = 10) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","品类（财务统一结算品类名称）", "品类", "品类"}, index = 10) private String category; - @ExcelProperty(value = {"提货", "单位"}, index = 11) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","提货", "单位", "单位"}, index = 11) private String pickupUnit; - @ExcelProperty(value = {"提货", "单价"}, index = 12) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","提货", "单价", "单价"}, index = 12) private String pickupPrice; - @ExcelProperty(value = {"干线", "单位"}, index = 13) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","干线", "单位", "单位"}, index = 13) private String trunkLineUnit; - @ExcelProperty(value = {"干线", "单价"}, index = 14) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","干线", "单价", "单价"}, index = 14) private String trunkLinePrice; - @ExcelProperty(value = {"仓储", "30天内"}, index = 15) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","仓储", "仓储", "30天内"}, index = 15) private String withinThirtyPrice; - @ExcelProperty(value = {"仓储", "30-60天"}, index = 16) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","仓储", "仓储", "30-60天"}, index = 16) private String betweenThirtySixtyPrice; - @ExcelProperty(value = {"仓储", "60-90天"}, index = 17) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","仓储", "仓储", "60-90天"}, index = 17) private String beyondSixtyPrice; - @ExcelProperty(value = {"仓储", "90天以上"}, index = 18) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","仓储", "仓储", "90天以上"}, index = 18) private String beyondNinetyPrice; - @ExcelProperty(value = {"仓储附加费", "仓储操作/装卸费"}, index = 19) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","仓储", "仓储附加费", "仓储操作/装卸费"}, index = 19) private String warehouseOperatePrice; - @ExcelProperty(value = {"仓储附加费", "仓储管理费"}, index = 20) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","仓储", "仓储附加费", "仓储管理费"}, index = 20) private String warehouseManagementPrice; - @ExcelProperty(value = {"仓储附加费", "仓储分货费"}, index = 21) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","仓储", "仓储附加费", "仓储分货费"}, index = 21) private String warehouseSortPrice; - @ExcelProperty(value = {"配送", "单位"}, index = 22) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","配送", "配送", "单位"}, index = 22) private String dispatchUnit; - @ExcelProperty(value = {"配送", "一般单价"}, index = 23) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","配送", "配送", "一般单价"}, index = 23) private String dispatchPrice; - @ExcelProperty(value = {"配送", "遗留单价"}, index = 24) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","配送", "配送", "遗留单价"}, index = 24) private String dispatchLeaveBehindPrice; - @ExcelProperty(value = {"配送附加费", "分货费"}, index = 25) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","配送", "配送附加费", "分货费"}, index = 25) private String dispatchSortPrice; - @ExcelProperty(value = {"配送附加费", "操作/装卸费价格"}, index = 26) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","配送", "配送附加费", "操作/装卸费价格"}, index = 26) private String dispatchHandlingPrice; - @ExcelProperty(value = {"配送附加费", "平移费价格"}, index = 27) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","配送", "配送附加费", "平移费价格"}, index = 27) private String dispatchRelocationPrice; - @ExcelProperty(value = {"配送附加费", "上楼费价格"}, index = 28) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","配送", "配送附加费", "上楼费价格"}, index = 28) private String dispatchDeliveryPrice; - @ExcelProperty(value = {"配送附加费", "上楼免楼层数"}, index = 29) + @ExcelProperty(value = {"正常维护价格仅区分品类计费（金牌需要单独维护按件计费价格）","配送", "配送附加费", "上楼免楼层数"}, index = 29) private String dispatchStairsCarryingCharge; + @ExcelProperty(value = {"生效时间", "生效时间", "生效时间", "生效时间"}, index = 30) + private String effectiveTime; + @ExcelProperty(value = {"生效状态", "生效状态", "生效状态", "生效状态"}, index = 31) + private String effectiveStatus; } diff --git a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/excel/pricev2/BasicdataPriceFullVehicleV2Excel.java b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/excel/pricev2/BasicdataPriceFullVehicleV2Excel.java index a27bd5b0f..96e114761 100644 --- a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/excel/pricev2/BasicdataPriceFullVehicleV2Excel.java +++ b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/excel/pricev2/BasicdataPriceFullVehicleV2Excel.java @@ -20,6 +20,7 @@ package com.logpm.basicdata.excel.pricev2; 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.ContentStyle; import com.alibaba.excel.annotation.write.style.HeadRowHeight; import lombok.Data; @@ -40,33 +41,50 @@ public class BasicdataPriceFullVehicleV2Excel implements Serializable { private static final long serialVersionUID = 1L; - @ExcelProperty(value = {"商场名称", "商场名称"}, index = 0) + @ExcelProperty(value = {"包含路径提货、干线、配送整车费用\n配送不区分路径，只需要填写一次车型价格","商场名称", "商场名称"}, index = 0) + @ContentStyle(wrapped = true) private String client; - @ExcelProperty(value = {"品牌", "品牌"}, index = 1) + @ExcelProperty(value = {"包含路径提货、干线、配送整车费用\n配送不区分路径，只需要填写一次车型价格","品牌", "品牌"}, index = 1) + @ContentStyle(wrapped = true) private String brand; - @ExcelProperty(value = {"发站", "省"}, index = 2) + @ExcelProperty(value = {"包含路径提货、干线、配送整车费用\n配送不区分路径，只需要填写一次车型价格","发站", "省"}, index = 2) + @ContentStyle(wrapped = true) private String startProvince; - @ExcelProperty(value = {"发站", "市"}, index = 3) + @ExcelProperty(value = {"包含路径提货、干线、配送整车费用\n配送不区分路径，只需要填写一次车型价格","发站", "市"}, index = 3) + @ContentStyle(wrapped = true) private String startCity; - @ExcelProperty(value = {"发站", "区"}, index = 4) + @ExcelProperty(value = {"包含路径提货、干线、配送整车费用\n配送不区分路径，只需要填写一次车型价格","发站", "区"}, index = 4) + @ContentStyle(wrapped = true) private String startArea; - @ExcelProperty(value = {"到站", "省"}, index = 5) + @ExcelProperty(value = {"包含路径提货、干线、配送整车费用\n配送不区分路径，只需要填写一次车型价格","到站", "省"}, index = 5) + @ContentStyle(wrapped = true) private String endProvince; - @ExcelProperty(value = {"到站", "市"}, index = 6) + @ExcelProperty(value = {"包含路径提货、干线、配送整车费用\n配送不区分路径，只需要填写一次车型价格","到站", "市"}, index = 6) + @ContentStyle(wrapped = true) private String endCity; - @ExcelProperty(value = {"到站", "区"}, index = 7) + @ExcelProperty(value = {"包含路径提货、干线、配送整车费用\n配送不区分路径，只需要填写一次车型价格","到站", "区"}, index = 7) + @ContentStyle(wrapped = true) private String endArea; - @ExcelProperty(value = {"发货单位", "发货单位ID"}, index = 8) + @ExcelProperty(value = {"包含路径提货、干线、配送整车费用\n配送不区分路径，只需要填写一次车型价格","发货单位", "发货单位ID"}, index = 8) + @ContentStyle(wrapped = true) private String sendOrgCode; - @ExcelProperty(value = {"发货单位", "发货单位"}, index = 9) + @ExcelProperty(value = {"包含路径提货、干线、配送整车费用\n配送不区分路径，只需要填写一次车型价格","发货单位", "发货单位"}, index = 9) + @ContentStyle(wrapped = true) private String sendOrg; - @ExcelProperty(value = {"车型", "车型"}, index = 10) + @ExcelProperty(value = {"包含路径提货、干线、配送整车费用\n配送不区分路径，只需要填写一次车型价格","车型", "车型"}, index = 10) + @ContentStyle(wrapped = true) private String vehicleType; - @ExcelProperty(value = {"提货", "单价"}, index = 11) + @ExcelProperty(value = {"包含路径提货、干线、配送整车费用\n配送不区分路径，只需要填写一次车型价格","提货", "单价"}, index = 11) + @ContentStyle(wrapped = true) private String pickupPrice; - @ExcelProperty(value = {"干线", "单价"}, index = 12) + @ExcelProperty(value = {"包含路径提货、干线、配送整车费用\n配送不区分路径，只需要填写一次车型价格","干线", "单价"}, index = 12) + @ContentStyle(wrapped = true) private String trunkLinePrice; - @ExcelProperty(value = {"配送", "单价"}, index = 13) + @ExcelProperty(value = {"包含路径提货、干线、配送整车费用\n配送不区分路径，只需要填写一次车型价格","配送", "单价"}, index = 13) + @ContentStyle(wrapped = true) private String dispatchPrice; - + @ExcelProperty(value = {"生效时间", "生效时间", "生效时间"}, index = 14) + private String effectiveTime; + @ExcelProperty(value = {"生效状态", "生效状态", "生效状态"}, index = 15) + private String effectiveStatus; } diff --git a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/excel/pricev2/BasicdataPriceGeneralV2Excel.java b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/excel/pricev2/BasicdataPriceGeneralV2Excel.java index 2a2879b03..f3770cb0d 100644 --- a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/excel/pricev2/BasicdataPriceGeneralV2Excel.java +++ b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/excel/pricev2/BasicdataPriceGeneralV2Excel.java @@ -80,5 +80,9 @@ public class BasicdataPriceGeneralV2Excel implements Serializable { private String dispatchLeaveBehindMinCost; @ExcelProperty(value = {"配送", "遗留加算价格"}, index = 19) private String dispatchLeaveBehindAddCost; + @ExcelProperty(value = {"生效时间", "生效时间"}, index = 20) + private String effectiveTime; + @ExcelProperty(value = {"生效状态", "生效状态"}, index = 21) + private String effectiveStatus; } diff --git a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/excel/pricev2/BasicdataPriceV3Excel.java b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/excel/pricev2/BasicdataPriceV3Excel.java new file mode 100644 index 000000000..d075b3a14 --- /dev/null +++ b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/excel/pricev2/BasicdataPriceV3Excel.java @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2018-2028, Chill Zhuang All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * Neither the name of the dreamlu.net developer nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * Author: Chill 庄骞 (smallchill@163.com) + */ +package com.logpm.basicdata.excel.pricev2; + + +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.Serializable; + + +/** + * 价格 Excel实体类 + * + * @author chao + * @since 2024-04-19 + */ +@Data +@ColumnWidth(25) +@HeadRowHeight(20) +@ContentRowHeight(18) +public class BasicdataPriceV3Excel implements Serializable { + + private static final long serialVersionUID = 1L; + + @ExcelProperty(value = {"基础信息维护", "商场编码(工厂)"}, index = 0) + private String clientCode; + /** + * 客户名称 + */ + @ExcelProperty(value = {"基础信息维护", "商场名称:(必填)"}, index = 1) + private String client; + /** + * 品牌 + */ + @ExcelProperty(value = {"基础信息维护", "品牌:(必填)"}, index = 2) + private String brand; + /** + * 生效时间 + */ + @ExcelProperty(value = {"基础信息维护", "生效日期:(必填)"}, index = 3) + private String effectiveTime; + + /** + * 配送服务类型 + */ + @ExcelProperty(value = {"基础信息维护", "配送服务类型:(必填)"}, index = 4) + private String serviceType; + /** + * 结算方式 + */ + @ExcelProperty(value = {"基础信息维护", "结算方式"}, index = 5) + private String settlementMethod; + /** + * 付款方 + */ + @ExcelProperty(value = {"基础信息维护", "付款方"}, index = 6) + private String payingParty; + /** + * 模版名称 + */ + @ExcelProperty(value = {"基础信息维护", "模版名称"}, index = 7) + private String templateName; + @ExcelProperty(value = {"生效状态", "生效状态"}, index = 8) + private String effectiveStatus; + +} diff --git a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/mapper/BasicdataPriceMapper.java b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/mapper/BasicdataPriceMapper.java index 49631d70f..1b4086f2c 100644 --- a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/mapper/BasicdataPriceMapper.java +++ b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/mapper/BasicdataPriceMapper.java @@ -16,19 +16,19 @@ */ package com.logpm.basicdata.mapper; -import com.baomidou.mybatisplus.core.conditions.Wrapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.metadata.IPage; import com.logpm.basicdata.entity.BasicdataPriceEntity; import com.logpm.basicdata.excel.price.BasicdataPriceExcel; import com.logpm.basicdata.excel.pricev2.BasicdataPriceV2Excel; +import com.logpm.basicdata.query.BasicdataPriceV2Query; import com.logpm.basicdata.vo.BasicdataPriceImportVO; +import com.logpm.basicdata.vo.BasicdataPricePageV2VO; import com.logpm.basicdata.vo.BasicdataPricePageVO; import org.apache.ibatis.annotations.Delete; import org.apache.ibatis.annotations.Param; import java.util.List; -import java.util.Set; /** * 基础价格表 Mapper 接口 @@ -45,7 +45,7 @@ public interface BasicdataPriceMapper extends BaseMapper { * @param basicdataPrice * @return */ - List selectBasicdataPricePage(IPage page, BasicdataPricePageVO basicdataPrice); + List selectBasicdataPricePage(@Param("page") IPage page, @Param("basicdataPrice") BasicdataPricePageVO basicdataPrice); @Delete("delete from logpm_basicdata_price_route where price_id = #{id}") @@ -56,4 +56,10 @@ public interface BasicdataPriceMapper extends BaseMapper { List findEntityByClientAndBrandV2(@Param("prices") List priceExcels); List hisPage(IPage page, BasicdataPricePageVO basicdataPrice); + + List selectBasicdataPricePageV2(@Param("page") IPage page, @Param("basicdataPrice") BasicdataPriceV2Query basicdataPrice); + + List hisPageV2(@Param("page") IPage page, @Param("basicdataPrice") BasicdataPricePageV2VO basicdataPrice); + + List selectBasicdataPricePageV2Export(@Param("page") IPage page, @Param("basicdataPrice") BasicdataPriceV2Query basicdataPrice); } diff --git a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/mapper/BasicdataPriceMapper.xml b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/mapper/BasicdataPriceMapper.xml index f8361bad3..b902457c4 100644 --- a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/mapper/BasicdataPriceMapper.xml +++ b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/mapper/BasicdataPriceMapper.xml @@ -101,4 +101,149 @@ + + + + + + diff --git a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/query/BasicdataPriceV2Query.java b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/query/BasicdataPriceV2Query.java new file mode 100644 index 000000000..a4687badf --- /dev/null +++ b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/query/BasicdataPriceV2Query.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2018-2028, Chill Zhuang All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * Neither the name of the dreamlu.net developer nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * Author: Chill 庄骞 (smallchill@163.com) + */ +package com.logpm.basicdata.query; + +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.io.Serializable; + +/** + * 基础价格表 视图实体类 + * + * @author zqb + * @since 2024-04-02 + */ +@Data +public class BasicdataPriceV2Query implements Serializable { + private static final long serialVersionUID = 1L; + + @ApiModelProperty(value = "ids 用于勾选导出") + private String ids; + + @ApiModelProperty(value = "客户名称") + private String clientName; + + @ApiModelProperty(value = "品牌名称") + private String brandName; + + @ApiModelProperty(value = "客户ids 用于批量查询") + private String clientIds; + + @ApiModelProperty(value = "品牌ids 用于批量查询") + private String brandIds; + + @ApiModelProperty(value = "维护状态") + private String maintenanceStatus; + +} diff --git a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/service/IBasicdataPriceService.java b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/service/IBasicdataPriceService.java index 4e217179b..a65b87ccb 100644 --- a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/service/IBasicdataPriceService.java +++ b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/service/IBasicdataPriceService.java @@ -16,10 +16,16 @@ */ package com.logpm.basicdata.service; +import com.alibaba.excel.ExcelWriter; +import com.alibaba.excel.write.metadata.WriteSheet; +import com.alibaba.excel.write.metadata.WriteTable; import com.baomidou.mybatisplus.core.metadata.IPage; import com.logpm.basicdata.entity.BasicdataPriceEntity; +import com.logpm.basicdata.query.BasicdataPriceV2Query; import com.logpm.basicdata.vo.BasicdatPriceApiVO; +import com.logpm.basicdata.vo.BasicdataPriceBasicUpdateV2VO; import com.logpm.basicdata.vo.BasicdataPriceBasicUpdateVO; +import com.logpm.basicdata.vo.BasicdataPricePageV2VO; import com.logpm.basicdata.vo.BasicdataPricePageVO; import com.logpm.basicdata.vo.PriceClientVO; import com.logpm.basicdata.vo.PriceDispatchAddClientVO; @@ -44,6 +50,7 @@ public interface IBasicdataPriceService extends BaseService selectBasicdataPricePage(IPage page, BasicdataPricePageVO basicdataPrice); + IPage selectBasicdataPricePageV2(IPage page, BasicdataPriceV2Query basicdataPrice); Boolean basicUpdate(BasicdataPriceBasicUpdateVO vo); @@ -86,4 +93,14 @@ public interface IBasicdataPriceService extends BaseService dispatchAddPrice(BasicdatPriceApiVO param); + + IPage hisPageV2(IPage page, BasicdataPricePageV2VO basicdataPrice); + + boolean basicUpdateV2(BasicdataPriceBasicUpdateV2VO vo); + + String uploadV3(MultipartFile file); + + String uploadV3Update(MultipartFile file); + + void exportV2(BasicdataPriceV2Query basicdataPrice, ExcelWriter excelWriter, WriteSheet writeSheet1, WriteTable table1, WriteSheet writeSheet2, WriteTable table2, WriteSheet writeSheet3, WriteTable table3, WriteSheet writeSheet4, WriteTable table4); } diff --git a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/service/impl/BasicdataPriceServiceImpl.java b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/service/impl/BasicdataPriceServiceImpl.java index f62c002b4..7e2009499 100644 --- a/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/service/impl/BasicdataPriceServiceImpl.java +++ b/blade-service/logpm-basicdata/src/main/java/com/logpm/basicdata/service/impl/BasicdataPriceServiceImpl.java @@ -25,9 +25,13 @@ import cn.hutool.core.util.NumberUtil; import cn.hutool.core.util.ObjectUtil; import cn.hutool.core.util.StrUtil; import cn.hutool.json.JSONUtil; +import com.alibaba.excel.ExcelWriter; +import com.alibaba.excel.write.metadata.WriteSheet; +import com.alibaba.excel.write.metadata.WriteTable; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.logpm.basic.entity.BasicCarModelEntity; import com.logpm.basic.feign.IBasicCarModelClient; import com.logpm.basicdata.constant.BasicdataConstants; @@ -61,7 +65,9 @@ import com.logpm.basicdata.excel.pricev2.BasicdataPriceCategoryV2Excel; import com.logpm.basicdata.excel.pricev2.BasicdataPriceFullVehicleV2Excel; import com.logpm.basicdata.excel.pricev2.BasicdataPriceGeneralV2Excel; import com.logpm.basicdata.excel.pricev2.BasicdataPriceV2Excel; +import com.logpm.basicdata.excel.pricev2.BasicdataPriceV3Excel; import com.logpm.basicdata.mapper.BasicdataPriceMapper; +import com.logpm.basicdata.query.BasicdataPriceV2Query; import com.logpm.basicdata.service.IBasicdataBrandService; import com.logpm.basicdata.service.IBasicdataCategoryService; import com.logpm.basicdata.service.IBasicdataClientService; @@ -76,9 +82,11 @@ import com.logpm.basicdata.service.IBasicdataPriceTemplateService; import com.logpm.basicdata.service.IBasicdataStoreBrandService; import com.logpm.basicdata.util.EasyExcelUtil; import com.logpm.basicdata.vo.BasicdatPriceApiVO; +import com.logpm.basicdata.vo.BasicdataPriceBasicUpdateV2VO; import com.logpm.basicdata.vo.BasicdataPriceBasicUpdateVO; import com.logpm.basicdata.vo.BasicdataPriceFullVehicleVO; import com.logpm.basicdata.vo.BasicdataPriceImportVO; +import com.logpm.basicdata.vo.BasicdataPricePageV2VO; import com.logpm.basicdata.vo.BasicdataPricePageVO; import com.logpm.basicdata.vo.PriceBasicVO; import com.logpm.basicdata.vo.PriceClientVO; @@ -109,13 +117,17 @@ import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import org.springframework.web.multipart.MultipartFile; +import java.time.LocalDateTime; +import java.time.temporal.ChronoUnit; import java.util.ArrayList; +import java.util.Collection; import java.util.Date; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Objects; +import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; @@ -176,6 +188,26 @@ public class BasicdataPriceServiceImpl extends BaseServiceImpl selectBasicdataPricePageV2(IPage page, BasicdataPriceV2Query basicdataPrice) { + List basicdataPriceVOS = baseMapper.selectBasicdataPricePageV2(page, basicdataPrice); + if (CollUtil.isNotEmpty(basicdataPriceVOS)) { + for (BasicdataPricePageV2VO basicdataPriceVO : basicdataPriceVOS) { + // 服务类型 + String serviceType = basicdataPriceVO.getServiceType(); + if (StrUtil.isNotEmpty(serviceType)) { + List res = new ArrayList<>(); + List split = StrUtil.split(serviceType, ","); + for (String s : split) { + res.add(IDict.getTextByCode(ServiceTypeEnums.class, Convert.toInt(s))); + } + basicdataPriceVO.setServiceType(StrUtil.join("/", res)); + } + } + } + return page.setRecords(basicdataPriceVOS); + } + @Override public IPage hisPage(IPage page, BasicdataPricePageVO basicdataPrice) { if (ObjectUtil.hasEmpty(basicdataPrice.getClientId(), basicdataPrice.getBrandId())) { @@ -218,6 +250,660 @@ public class BasicdataPriceServiceImpl extends BaseServiceImpl hisPageV2(IPage page, BasicdataPricePageV2VO basicdataPrice) { + if (ObjectUtil.hasEmpty(basicdataPrice.getClientId(), basicdataPrice.getBrandId())) { + throw new ServiceException("客户id和品牌id不能为空"); + } + List basicdataPriceVOS = baseMapper.hisPageV2(page, basicdataPrice); + if (CollUtil.isNotEmpty(basicdataPriceVOS)) { + for (BasicdataPricePageV2VO basicdataPriceVO : basicdataPriceVOS) { + // 服务类型 + String serviceType = basicdataPriceVO.getServiceType(); + if (StrUtil.isNotEmpty(serviceType)) { + List res = new ArrayList<>(); + List split = StrUtil.split(serviceType, ","); + for (String s : split) { + res.add(IDict.getTextByCode(ServiceTypeEnums.class, Convert.toInt(s))); + } + basicdataPriceVO.setServiceType(StrUtil.join("/", res)); + } + } + } + return page.setRecords(basicdataPriceVOS); + } + + @Override + public boolean basicUpdateV2(BasicdataPriceBasicUpdateV2VO vo) { + // 生效开始时间不能小于今天的结束时间 + if (ObjectUtil.isEmpty(vo.getId()) && ObjectUtil.isNotEmpty(vo.getEffectiveTime())) { + LocalDateTime now = DateUtil.date().toLocalDateTime(); + LocalDateTime todayEnd = now.truncatedTo(ChronoUnit.DAYS).plusDays(1).minusSeconds(1); + if (vo.getEffectiveTime().before(DateUtil.date(todayEnd))) { + throw new ServiceException("生效时间必须从明天开始"); + } + } + Long clientId1 = vo.getClientId(); + Long brandId1 = vo.getBrandId(); + LambdaQueryWrapper eq = Wrappers.lambdaQuery() + .eq(BasicdataPriceEntity::getClientId, clientId1) + .eq(BasicdataPriceEntity::getBrandId, brandId1) + .eq(BasicdataPriceEntity::getEffectiveTime, DateUtil.beginOfDay(vo.getEffectiveTime())) + .eq(BasicdataPriceEntity::getIsDeleted, 0); + if (ObjectUtil.isNotEmpty(vo.getId())) { + eq.ne(BasicdataPriceEntity::getId, vo.getId()); + } + List list1 = this.list(eq); + if (CollUtil.isNotEmpty(list1)) { + throw new ServiceException("已经存在该生效时间的数据"); + } + // 如果是切换模版，则删除所有本价格相关的数据 + BasicdataPriceEntity entity = null; + if (ObjectUtil.isNotEmpty(vo.getId())) { + entity = this.getById(vo.getId()); + Date effectiveTime = entity.getEffectiveTime(); + Date effectiveTime1 = vo.getEffectiveTime(); + Integer effectiveStatus = entity.getEffectiveStatus(); + if (!NumberUtil.equals(effectiveStatus, -1) && DateUtil.compare(effectiveTime, effectiveTime1) != 0) { + throw new ServiceException("生效时间不能修改"); + } + } + if (ObjectUtil.isNotEmpty(entity)) { + Long templateId = entity.getTemplateId(); + if (!ObjectUtil.equal(templateId, vo.getTemplateId())) { + // 删除数据 + deleteByPriceId(vo.getId()); + entity.setDispatchStairsCarryingCharge(0); + entity.setDispatchUpwardJudgment(0d); + entity.setDispatchUpwardJudgmentCost(0d); + log.info("价格体系：{} 切换模版删除数据", vo.getId()); + } + } else { + entity = new BasicdataPriceEntity(); + entity.setClientId(vo.getClientId()); + entity.setBrandId(vo.getBrandId()); + entity.setMaintenanceStatus(1); + entity.setEffectiveStatus(-1); + } + entity.setEffectiveTime(vo.getEffectiveTime()); + entity.setTemplateId(vo.getTemplateId()); + boolean b = this.saveOrUpdate(entity); + return b; + } + + @Override + public String uploadV3(MultipartFile file) { + StringBuilder message = new StringBuilder(); + try { + // 从build中获取5个sheet的数据 + List priceExcels = EasyExcelUtil.readTrim(file, 0, 2, BasicdataPriceV3Excel.class); + // 校验数据 + String sheet1 = "基础数据"; + String sheet2 = "整车费用"; + String sheet3 = "保底价"; + String sheet4 = "正常计费"; + if (CollUtil.isNotEmpty(priceExcels)) { + // 模板名称为key + Map templateEntityMap = new HashMap<>(); + // 客户名称 + 品牌名称为key + Map templateMap = new HashMap<>(); + // 客户编码为key + Map clientEntityMap = new HashMap<>(); + // 品牌名称为key + Map brandEntityMap = new HashMap<>(); + // 客户名称 + 品牌名称为key + Map priceEntityMap = new HashMap<>(); + Map> checkPriceEntityMap = new HashMap<>(); + Map clientBrandMap = new HashMap<>(); + List fullVehicleExcels = EasyExcelUtil.readTrim(file, 1, 3, BasicdataPriceFullVehicleV2Excel.class); + List generalExcels = EasyExcelUtil.readTrim(file, 2, 2, BasicdataPriceGeneralV2Excel.class); + List basicExcels = EasyExcelUtil.readTrim(file, 3, 4, BasicdataPriceCategoryV2Excel.class); + // 初始化导入校验数据 + initImportDataV3(priceExcels, basicExcels, generalExcels, fullVehicleExcels, templateEntityMap, clientEntityMap, brandEntityMap, + priceEntityMap, clientBrandMap, checkPriceEntityMap, templateMap); + // 校验数据 + checkPriceDataV3(message, priceExcels, sheet1, templateEntityMap, clientEntityMap, brandEntityMap, priceEntityMap, clientBrandMap, + checkPriceEntityMap); + // 第一个sheet数据不合格直接返回 + if (StrUtil.isNotEmpty(message.toString())) { + return message.toString(); + } + // 品类名称为key + Map categoryEntityMap = new HashMap<>(); + // 省市区 + Map provinceMap = new HashMap<>(); + Map provinceCityMap = new HashMap<>(); + Map provinceCityAearMap = new HashMap<>(); + // 初始化行政区划 + initRegion(provinceMap, provinceCityMap, provinceCityAearMap); + // 路径为key 客户编码&&&品牌&&&发货单位编码 || 客户编码&&&品牌&&&发货单位编码&&&发站省市 || 客户编码&&&品牌&&&发货单位编码&&&发站省市&&&发站省市区 + Map routeMap = new HashMap<>(); + initRouteMapV2(routeMap, basicExcels, generalExcels, fullVehicleExcels); + // 初始化品类 + initCategoryDataV2(basicExcels, categoryEntityMap); + // 提货干线按品类计费 + checkBasicExcelsV2(message, sheet4, clientEntityMap, priceEntityMap, basicExcels, categoryEntityMap, provinceMap, + provinceCityMap, provinceCityAearMap, clientBrandMap, templateMap); + // 一般计费 + checkGeneralExcelsV2(generalExcels, clientEntityMap, priceEntityMap, provinceMap, provinceCityMap, + provinceCityAearMap, message, sheet3, clientBrandMap, templateMap); + // 封装整车车型 车型名称为key + Map vehicleTypeMap = new HashMap<>(); + initVehicleTypeMapV2(vehicleTypeMap); + // 整车 + checkFullExcelV2(fullVehicleExcels, clientEntityMap, priceEntityMap, provinceMap, provinceCityMap, + provinceCityAearMap, vehicleTypeMap, message, sheet2, clientBrandMap, templateMap); + if (StrUtil.isNotEmpty(message.toString())) { + return message.toString(); + } + // 保存数据 + // 先处理 + saveExcelV3(priceExcels, basicExcels, generalExcels, fullVehicleExcels, + templateEntityMap, clientEntityMap, brandEntityMap, priceEntityMap, categoryEntityMap, provinceMap, + provinceCityMap, provinceCityAearMap, vehicleTypeMap, routeMap, clientBrandMap, templateMap); + } else { + message.append("请维护").append(sheet1).append("中的基础数据"); + } + } catch (Exception e) { + log.error("价格导入失败", e); + throw new ServiceException("导入失败"); + } + return message.toString(); + } + + @Override + public String uploadV3Update(MultipartFile file) { + StringBuilder message = new StringBuilder(); + try { + // 从build中获取5个sheet的数据 + List priceExcels = EasyExcelUtil.readTrim(file, 0, 2, BasicdataPriceV3Excel.class); + // 校验数据 + String sheet1 = "基础数据"; + String sheet2 = "整车费用"; + String sheet3 = "保底价"; + String sheet4 = "正常计费"; + if (CollUtil.isNotEmpty(priceExcels)) { + // 模板名称为key + Map templateEntityMap = new HashMap<>(); + // 客户名称 + 品牌名称为key + Map templateMap = new HashMap<>(); + // 客户编码为key + Map clientEntityMap = new HashMap<>(); + // 品牌名称为key + Map brandEntityMap = new HashMap<>(); + // 客户名称 + 品牌名称为key + Map priceEntityMap = new HashMap<>(); + Map> checkPriceEntityMap = new HashMap<>(); + Map clientBrandMap = new HashMap<>(); + List fullVehicleExcels = EasyExcelUtil.readTrim(file, 1, 3, BasicdataPriceFullVehicleV2Excel.class); + List generalExcels = EasyExcelUtil.readTrim(file, 2, 2, BasicdataPriceGeneralV2Excel.class); + List basicExcels = EasyExcelUtil.readTrim(file, 3, 4, BasicdataPriceCategoryV2Excel.class); + // 初始化导入校验数据 + initImportDataV3(priceExcels, basicExcels, generalExcels, fullVehicleExcels, templateEntityMap, clientEntityMap, brandEntityMap, + priceEntityMap, clientBrandMap, checkPriceEntityMap, templateMap); + // 校验数据 + checkPriceDataV3(message, priceExcels, sheet1, templateEntityMap, clientEntityMap, brandEntityMap, priceEntityMap, clientBrandMap, + checkPriceEntityMap); + // 第一个sheet数据不合格直接返回 + if (StrUtil.isNotEmpty(message.toString())) { + return message.toString(); + } + // 品类名称为key + Map categoryEntityMap = new HashMap<>(); + // 省市区 + Map provinceMap = new HashMap<>(); + Map provinceCityMap = new HashMap<>(); + Map provinceCityAearMap = new HashMap<>(); + // 初始化行政区划 + initRegion(provinceMap, provinceCityMap, provinceCityAearMap); + // 路径为key 客户编码&&&品牌&&&发货单位编码 || 客户编码&&&品牌&&&发货单位编码&&&发站省市 || 客户编码&&&品牌&&&发货单位编码&&&发站省市&&&发站省市区 + Map routeMap = new HashMap<>(); + initRouteMapV2(routeMap, basicExcels, generalExcels, fullVehicleExcels); + // 初始化品类 + initCategoryDataV2(basicExcels, categoryEntityMap); + // 提货干线按品类计费 + checkBasicExcelsV2(message, sheet4, clientEntityMap, priceEntityMap, basicExcels, categoryEntityMap, provinceMap, + provinceCityMap, provinceCityAearMap, clientBrandMap, templateMap); + // 一般计费 + checkGeneralExcelsV2(generalExcels, clientEntityMap, priceEntityMap, provinceMap, provinceCityMap, + provinceCityAearMap, message, sheet3, clientBrandMap, templateMap); + // 封装整车车型 车型名称为key + Map vehicleTypeMap = new HashMap<>(); + initVehicleTypeMapV2(vehicleTypeMap); + // 整车 + checkFullExcelV2(fullVehicleExcels, clientEntityMap, priceEntityMap, provinceMap, provinceCityMap, + provinceCityAearMap, vehicleTypeMap, message, sheet2, clientBrandMap, templateMap); + if (StrUtil.isNotEmpty(message.toString())) { + return message.toString(); + } + // 保存数据 + // 先处理 + saveExcelV3Update(priceExcels, basicExcels, generalExcels, fullVehicleExcels, + templateEntityMap, clientEntityMap, brandEntityMap, priceEntityMap, categoryEntityMap, provinceMap, + provinceCityMap, provinceCityAearMap, vehicleTypeMap, routeMap, clientBrandMap, templateMap); + } else { + message.append("请维护").append(sheet1).append("中的基础数据"); + } + } catch (Exception e) { + log.error("价格导入失败", e); + throw new ServiceException("导入失败"); + } + return message.toString(); + } + + @Override + public void exportV2(BasicdataPriceV2Query basicdataPrice, ExcelWriter excelWriter, WriteSheet writeSheet1, WriteTable table1, + WriteSheet writeSheet2, WriteTable table2, WriteSheet writeSheet3, WriteTable table3, WriteSheet writeSheet4, WriteTable table4) { + IPage page = new Page<>(1, -1); + // 根据 客户和品牌 查询出对应的所有价格 + IPage basicdataPricePageV2VOIPage = selectBasicdataPricePageV2Export(page, basicdataPrice); + List records = basicdataPricePageV2VOIPage.getRecords(); + if (CollUtil.isNotEmpty(records)) { + List basicdataPriceV3Excels = new ArrayList<>(); + // 配送保底费 + Set priceIdSet = new HashSet<>(); + Map basicdataPricePageV2VOMap = new HashMap<>(); + for (BasicdataPricePageV2VO pricePageV2VO : records) { + BasicdataPriceV3Excel basicdataPriceV3Excel = new BasicdataPriceV3Excel(); + basicdataPriceV3Excel.setBrand(pricePageV2VO.getBrandName()); + basicdataPriceV3Excel.setClient(pricePageV2VO.getClientName()); + basicdataPriceV3Excel.setEffectiveTime(DateUtil.formatDate(pricePageV2VO.getEffectiveTime())); + basicdataPriceV3Excel.setTemplateName(pricePageV2VO.getTemplateName()); + basicdataPriceV3Excel.setEffectiveStatus(pricePageV2VO.getEffectiveStatus()); + basicdataPriceV3Excels.add(basicdataPriceV3Excel); + basicdataPricePageV2VOMap.put(Convert.toLong(pricePageV2VO.getId()), pricePageV2VO); + priceIdSet.add(pricePageV2VO.getId()); + } + excelWriter.write(basicdataPriceV3Excels, writeSheet1, table1); + if (CollUtil.isNotEmpty(priceIdSet)) { + // 省市区 + Map regionMap = new HashMap<>(); + // 初始化行政区划 code为key 名称为值 + initRegionExport(regionMap); + Map categoryEntityMap = new HashMap<>(); + initCategoryDataV2Export(categoryEntityMap); + List clientEntities = clientService.list(); + Map clientMap = new HashMap<>(); + if (CollUtil.isNotEmpty(clientEntities)) { + for (BasicdataClientEntity clientEntity : clientEntities) { + clientMap.put(clientEntity.getId(), clientEntity.getClientName()); + } + } + Map vehicleTypeMap = new HashMap<>(); + initVehicleTypeMapV2Export(vehicleTypeMap); + // 查询出本次导出的所有的路径数据 + Map priceRouteEntityMap = new HashMap<>(); + List routeEntities = basicdataPriceRouteService.list(Wrappers.lambdaQuery().in(BasicdataPriceRouteEntity::getPriceId, priceIdSet)); + if (CollUtil.isNotEmpty(routeEntities)) { + for (BasicdataPriceRouteEntity routeEntity : routeEntities) { + priceRouteEntityMap.put(routeEntity.getId(), routeEntity); + } + } + // 查询出整车数据 + List fullVehicleEntities = fullVehicleService.list(Wrappers.lambdaQuery().in(BasicdataPriceFullVehicleEntity::getPriceId, priceIdSet)); + if (CollUtil.isNotEmpty(fullVehicleEntities)) { + List fullVehicleV2Excels = new ArrayList<>(); + // 业务id + 类型 + 车型 = 一条数据 + Map> fullVehicleMap = fullVehicleEntities.stream().collect(Collectors.groupingBy(BasicdataPriceFullVehicleEntity::getBoId)); + for (Map.Entry> fullVehicleMapEntry : fullVehicleMap.entrySet()) { + Long fullVehicleBoId = fullVehicleMapEntry.getKey(); + List value = fullVehicleMapEntry.getValue(); + Map> fullVehicleTypeMap = value.stream().collect(Collectors.groupingBy(BasicdataPriceFullVehicleEntity::getVehicleType)); + for (Map.Entry> fullVehicleTypeMapEntry : fullVehicleTypeMap.entrySet()) { + Long fullVehicleType = fullVehicleTypeMapEntry.getKey(); + List fullVehicleTypeValue = fullVehicleTypeMapEntry.getValue(); + // 一条数据 + BasicdataPriceFullVehicleV2Excel fullVehicleV2Excel = new BasicdataPriceFullVehicleV2Excel(); + BasicdataPricePageV2VO pricePageV2VO = null; + if (basicdataPricePageV2VOMap.containsKey(fullVehicleBoId)) { + // 不是路径 + pricePageV2VO = basicdataPricePageV2VOMap.get(fullVehicleBoId); + } else { + // 路径 + BasicdataPriceRouteEntity priceRouteEntity = priceRouteEntityMap.get(fullVehicleBoId); + Long priceId = priceRouteEntity.getPriceId(); + pricePageV2VO = basicdataPricePageV2VOMap.get(priceId); + fullVehicleV2Excel.setStartProvince(regionMap.get(Convert.toStr(priceRouteEntity.getStartProvinceId()))); + fullVehicleV2Excel.setStartCity(regionMap.get(Convert.toStr(priceRouteEntity.getStartCityId()))); + fullVehicleV2Excel.setStartArea(regionMap.get(Convert.toStr(priceRouteEntity.getStartCountyId()))); + fullVehicleV2Excel.setEndProvince(regionMap.get(Convert.toStr(priceRouteEntity.getEndProvinceId()))); + fullVehicleV2Excel.setEndCity(regionMap.get(Convert.toStr(priceRouteEntity.getEndCityId()))); + fullVehicleV2Excel.setEndArea(regionMap.get(Convert.toStr(priceRouteEntity.getEndCountyId()))); + fullVehicleV2Excel.setSendOrg(clientMap.get(priceRouteEntity.getSendOrgId())); + } + fullVehicleV2Excel.setVehicleType(vehicleTypeMap.get(fullVehicleType)); + if (ObjectUtil.isNotEmpty(pricePageV2VO)) { + fullVehicleV2Excel.setClient(pricePageV2VO.getClientName()); + fullVehicleV2Excel.setBrand(pricePageV2VO.getBrandName()); + fullVehicleV2Excel.setEffectiveTime(DateUtil.formatDate(pricePageV2VO.getEffectiveTime())); + fullVehicleV2Excel.setEffectiveStatus(pricePageV2VO.getEffectiveStatus()); + } + for (BasicdataPriceFullVehicleEntity basicdataPriceFullVehicleEntity : fullVehicleTypeValue) { + Integer type = basicdataPriceFullVehicleEntity.getType(); + Double price = basicdataPriceFullVehicleEntity.getPrice(); + String priceStr = Convert.toStr(price); + if (ObjectUtil.isNotEmpty(type)) { + if (type == 1) { + fullVehicleV2Excel.setPickupPrice(priceStr); + } else if (type == 2) { + fullVehicleV2Excel.setTrunkLinePrice(priceStr); + } else if (type == 4) { + fullVehicleV2Excel.setDispatchPrice(priceStr); + } + } + } + fullVehicleV2Excels.add(fullVehicleV2Excel); + } + } + if (CollUtil.isNotEmpty(fullVehicleV2Excels)) { + excelWriter.write(fullVehicleV2Excels, writeSheet2, table2); + }else{ + excelWriter.write(new ArrayList(), writeSheet2, table2); + } + }else{ + excelWriter.write(new ArrayList(), writeSheet2, table2); + } + // 查询出一般计费数据 + List generalEntities = generalService.list(Wrappers.lambdaQuery().in(BasicdataPriceGeneralEntity::getPriceId, priceIdSet)); + if (CollUtil.isNotEmpty(generalEntities)) { + List generalV2Excels = new ArrayList<>(); + // 业务id + 类型 + 车型 = 一条数据 + Map> generalMap = generalEntities.stream().collect(Collectors.groupingBy(BasicdataPriceGeneralEntity::getBoId)); + for (Map.Entry> generalMapEntry : generalMap.entrySet()) { + Long generalBoId = generalMapEntry.getKey(); + List value = generalMapEntry.getValue(); + // 一条数据 + BasicdataPriceGeneralV2Excel generalV2Excel = new BasicdataPriceGeneralV2Excel(); + BasicdataPricePageV2VO pricePageV2VO = null; + if (basicdataPricePageV2VOMap.containsKey(generalBoId)) { + // 不是路径 + pricePageV2VO = basicdataPricePageV2VOMap.get(generalBoId); + } else { + // 路径 + BasicdataPriceRouteEntity priceRouteEntity = priceRouteEntityMap.get(generalBoId); + Long priceId = priceRouteEntity.getPriceId(); + pricePageV2VO = basicdataPricePageV2VOMap.get(priceId); + generalV2Excel.setStartProvince(regionMap.get(Convert.toStr(priceRouteEntity.getStartProvinceId()))); + generalV2Excel.setStartCity(regionMap.get(Convert.toStr(priceRouteEntity.getStartCityId()))); + generalV2Excel.setStartArea(regionMap.get(Convert.toStr(priceRouteEntity.getStartCountyId()))); + generalV2Excel.setEndProvince(regionMap.get(Convert.toStr(priceRouteEntity.getEndProvinceId()))); + generalV2Excel.setEndCity(regionMap.get(Convert.toStr(priceRouteEntity.getEndCityId()))); + generalV2Excel.setEndArea(regionMap.get(Convert.toStr(priceRouteEntity.getEndCountyId()))); + generalV2Excel.setSendOrg(clientMap.get(priceRouteEntity.getSendOrgId())); + } + if (ObjectUtil.isNotEmpty(pricePageV2VO)) { + generalV2Excel.setClient(pricePageV2VO.getClientName()); + generalV2Excel.setBrand(pricePageV2VO.getBrandName()); + generalV2Excel.setEffectiveTime(DateUtil.formatDate(pricePageV2VO.getEffectiveTime())); + generalV2Excel.setEffectiveStatus(pricePageV2VO.getEffectiveStatus()); + generalV2Excel.setDispatchUpwardJudgment(pricePageV2VO.getDispatchUpwardJudgment()); + generalV2Excel.setDispatchUpwardJudgmentCost(pricePageV2VO.getDispatchUpwardJudgmentCost()); + } + for (BasicdataPriceGeneralEntity basicdataPriceFullVehicleEntity : value) { + Integer type = basicdataPriceFullVehicleEntity.getServiceType(); + Double price = basicdataPriceFullVehicleEntity.getMinCost(); + Double additionalCost = basicdataPriceFullVehicleEntity.getAdditionalCost(); + String priceStr = Convert.toStr(price); + String additionalCostStr = Convert.toStr(additionalCost); + if (ObjectUtil.isNotEmpty(type)) { + if (type == 1) { + generalV2Excel.setPickupMinCost(priceStr); + generalV2Excel.setPickupAddCost(additionalCostStr); + } else if (type == 2) { + generalV2Excel.setTrunkLineMinCost(priceStr); + generalV2Excel.setTrunkLineAddCost(additionalCostStr); + } else if (type == 4) { + generalV2Excel.setDispatchMinCost(priceStr); + generalV2Excel.setDispatchAddCost(additionalCostStr); + } else if (type == 5) { + generalV2Excel.setDispatchLeaveBehindMinCost(priceStr); + generalV2Excel.setDispatchLeaveBehindAddCost(additionalCostStr); + } + } + } + generalV2Excels.add(generalV2Excel); + } + if (CollUtil.isNotEmpty(generalV2Excels)) { + excelWriter.write(generalV2Excels, writeSheet3, table3); + } else { + excelWriter.write(new ArrayList(), writeSheet3, table3); + } + } else { + excelWriter.write(new ArrayList(), writeSheet3, table3); + } + // 查询出品类数据 + Map categoryMap = new HashMap<>(); + List basicEntities = categoryBasicService.list(Wrappers.lambdaQuery().in(BasicdataPriceCategoryBasicEntity::getPriceId, priceIdSet)); + if (CollUtil.isNotEmpty(basicEntities)) { + // 业务id + 类型 + 车型 = 一条数据 + Map> basicMap = basicEntities.stream().collect(Collectors.groupingBy(BasicdataPriceCategoryBasicEntity::getBoId)); + for (Map.Entry> basicMapEntry : basicMap.entrySet()) { + Long fullVehicleBoId = basicMapEntry.getKey(); + List value = basicMapEntry.getValue(); + Map> basicCategoryMap = value.stream().collect(Collectors.groupingBy(entity -> Optional.ofNullable(entity.getCategoryId()) + .map(String::valueOf) + .orElse(""))); + for (Map.Entry> basicCategoryMapEntry : basicCategoryMap.entrySet()) { + String categoryId = basicCategoryMapEntry.getKey(); + List categoryBasicEntities = basicCategoryMapEntry.getValue(); + // 一条数据 + BasicdataPriceCategoryV2Excel fullVehicleV2Excel = new BasicdataPriceCategoryV2Excel(); + BasicdataPricePageV2VO pricePageV2VO = null; + if (basicdataPricePageV2VOMap.containsKey(fullVehicleBoId)) { + // 不是路径 + pricePageV2VO = basicdataPricePageV2VOMap.get(fullVehicleBoId); + } else { + // 路径 + BasicdataPriceRouteEntity priceRouteEntity = priceRouteEntityMap.get(fullVehicleBoId); + Long priceId = priceRouteEntity.getPriceId(); + pricePageV2VO = basicdataPricePageV2VOMap.get(priceId); + fullVehicleV2Excel.setStartProvince(regionMap.get(Convert.toStr(priceRouteEntity.getStartProvinceId()))); + fullVehicleV2Excel.setStartCity(regionMap.get(Convert.toStr(priceRouteEntity.getStartCityId()))); + fullVehicleV2Excel.setStartArea(regionMap.get(Convert.toStr(priceRouteEntity.getStartCountyId()))); + fullVehicleV2Excel.setEndProvince(regionMap.get(Convert.toStr(priceRouteEntity.getEndProvinceId()))); + fullVehicleV2Excel.setEndCity(regionMap.get(Convert.toStr(priceRouteEntity.getEndCityId()))); + fullVehicleV2Excel.setEndArea(regionMap.get(Convert.toStr(priceRouteEntity.getEndCountyId()))); + fullVehicleV2Excel.setSendOrg(clientMap.get(priceRouteEntity.getSendOrgId())); + } + fullVehicleV2Excel.setCategory(categoryEntityMap.get(categoryId)); + if (ObjectUtil.isNotEmpty(pricePageV2VO)) { + fullVehicleV2Excel.setClient(pricePageV2VO.getClientName()); + fullVehicleV2Excel.setBrand(pricePageV2VO.getBrandName()); + fullVehicleV2Excel.setEffectiveTime(DateUtil.formatDate(pricePageV2VO.getEffectiveTime())); + fullVehicleV2Excel.setEffectiveStatus(pricePageV2VO.getEffectiveStatus()); + } + for (BasicdataPriceCategoryBasicEntity basicdataPriceFullVehicleEntity : categoryBasicEntities) { + Integer type = basicdataPriceFullVehicleEntity.getType(); + String typeStr = ""; + if (ObjectUtil.isNotEmpty(type)) { + if (type == 1) { + typeStr = "按件"; + } else if (type == 3) { + typeStr = "按方"; + } else if (type == 4) { + typeStr = "按重量"; + } + } + Integer serviceType = basicdataPriceFullVehicleEntity.getServiceType(); + Double price = basicdataPriceFullVehicleEntity.getPrice(); + String priceStr = Convert.toStr(price); + if (ObjectUtil.isNotEmpty(serviceType)) { + if (serviceType == 1) { + fullVehicleV2Excel.setPickupUnit(typeStr); + fullVehicleV2Excel.setPickupPrice(priceStr); + } else if (serviceType == 2) { + fullVehicleV2Excel.setTrunkLineUnit(typeStr); + fullVehicleV2Excel.setTrunkLinePrice(priceStr); + } + } + } + categoryMap.put(Convert.toStr(fullVehicleBoId) + Convert.toStr(categoryId), fullVehicleV2Excel); + } + } + } + List warehouseEntities = categoryWarehouseService.list(Wrappers.lambdaQuery().in(BasicdataPriceCategoryWarehouseEntity::getPriceId, priceIdSet)); + if (CollUtil.isNotEmpty(warehouseEntities)) { + // 业务id + 类型 + 车型 = 一条数据 + Map> basicMap = warehouseEntities.stream().collect(Collectors.groupingBy(BasicdataPriceCategoryWarehouseEntity::getBoId)); + for (Map.Entry> basicMapEntry : basicMap.entrySet()) { + Long fullVehicleBoId = basicMapEntry.getKey(); + List value = basicMapEntry.getValue(); + Map> basicCategoryMap = value.stream().collect(Collectors.groupingBy(entity -> Optional.ofNullable(entity.getCategoryId()) + .map(String::valueOf) + .orElse(""))); + for (Map.Entry> basicCategoryMapEntry : basicCategoryMap.entrySet()) { + String categoryId = basicCategoryMapEntry.getKey(); + List categoryBasicEntities = basicCategoryMapEntry.getValue(); + // 一条数据 + BasicdataPriceCategoryV2Excel fullVehicleV2Excel = null; + if (categoryMap.containsKey(Convert.toStr(fullVehicleBoId) + Convert.toStr(categoryId))) { + fullVehicleV2Excel = categoryMap.get(Convert.toStr(fullVehicleBoId) + Convert.toStr(categoryId)); + } else { + fullVehicleV2Excel = new BasicdataPriceCategoryV2Excel(); + } + for (BasicdataPriceCategoryWarehouseEntity basicdataPriceFullVehicleEntity : categoryBasicEntities) { + Integer costType = basicdataPriceFullVehicleEntity.getCostType(); + Double withinThirtyPrice = basicdataPriceFullVehicleEntity.getWithinThirtyPrice(); + String withinThirtyPriceStr = Convert.toStr(withinThirtyPrice); + Double betweenThirtySixtyPrice = basicdataPriceFullVehicleEntity.getBetweenThirtySixtyPrice(); + String betweenThirtySixtyPriceStr = Convert.toStr(betweenThirtySixtyPrice); + Double beyondSixtyPrice = basicdataPriceFullVehicleEntity.getBeyondSixtyPrice(); + String beyondSixtyPriceStr = Convert.toStr(beyondSixtyPrice); + Double beyondNinetyPrice = basicdataPriceFullVehicleEntity.getBeyondNinetyPrice(); + String beyondNinetyPriceStr = Convert.toStr(beyondNinetyPrice); + Double operatePrice = basicdataPriceFullVehicleEntity.getOperatePrice(); + String operatePriceStr = Convert.toStr(operatePrice); + Double warehouseManagementPrice = basicdataPriceFullVehicleEntity.getWarehouseManagementPrice(); + String warehouseManagementPriceStr = Convert.toStr(warehouseManagementPrice); + Double warehouseSortPrice = basicdataPriceFullVehicleEntity.getWarehouseSortPrice(); + String warehouseSortPriceStr = Convert.toStr(warehouseSortPrice); + if (ObjectUtil.isNotEmpty(costType)) { + if (costType == 1) { + fullVehicleV2Excel.setWithinThirtyPrice(withinThirtyPriceStr); + fullVehicleV2Excel.setBetweenThirtySixtyPrice(betweenThirtySixtyPriceStr); + fullVehicleV2Excel.setBeyondSixtyPrice(beyondSixtyPriceStr); + fullVehicleV2Excel.setBeyondNinetyPrice(beyondNinetyPriceStr); + } else if (costType == 2) { + fullVehicleV2Excel.setWarehouseOperatePrice(operatePriceStr); + fullVehicleV2Excel.setWarehouseManagementPrice(warehouseManagementPriceStr); + fullVehicleV2Excel.setWarehouseSortPrice(warehouseSortPriceStr); + } + } + } + } + } + } + List dispatchEntities = categoryDispatchService.list(Wrappers.lambdaQuery().in(BasicdataPriceCategoryDispatchEntity::getPriceId, priceIdSet)); + if (CollUtil.isNotEmpty(dispatchEntities)) { + Map> basicMap = dispatchEntities.stream().collect(Collectors.groupingBy(BasicdataPriceCategoryDispatchEntity::getBoId)); + for (Map.Entry> basicMapEntry : basicMap.entrySet()) { + Long fullVehicleBoId = basicMapEntry.getKey(); + List value = basicMapEntry.getValue(); + Map> basicCategoryMap = value.stream().collect(Collectors.groupingBy(entity -> Optional.ofNullable(entity.getCategoryId()) + .map(String::valueOf) + .orElse(""))); + for (Map.Entry> basicCategoryMapEntry : basicCategoryMap.entrySet()) { + String categoryId = basicCategoryMapEntry.getKey(); + List categoryBasicEntities = basicCategoryMapEntry.getValue(); + // 一条数据 + BasicdataPriceCategoryV2Excel fullVehicleV2Excel = null; + if (categoryMap.containsKey(Convert.toStr(fullVehicleBoId) + Convert.toStr(categoryId))) { + fullVehicleV2Excel = categoryMap.get(Convert.toStr(fullVehicleBoId) + Convert.toStr(categoryId)); + } else { + fullVehicleV2Excel = new BasicdataPriceCategoryV2Excel(); + } + BasicdataPricePageV2VO pricePageV2VO = null; + if (basicdataPricePageV2VOMap.containsKey(fullVehicleBoId)) { + // 不是路径 + pricePageV2VO = basicdataPricePageV2VOMap.get(fullVehicleBoId); + } else { + // 路径 + BasicdataPriceRouteEntity priceRouteEntity = priceRouteEntityMap.get(fullVehicleBoId); + Long priceId = priceRouteEntity.getPriceId(); + pricePageV2VO = basicdataPricePageV2VOMap.get(priceId); + } + for (BasicdataPriceCategoryDispatchEntity basicdataPriceFullVehicleEntity : categoryBasicEntities) { + Integer costType = basicdataPriceFullVehicleEntity.getCostType(); + if (ObjectUtil.isNotEmpty(costType)) { + if (costType == 1) { + Double price = basicdataPriceFullVehicleEntity.getPrice(); + String priceStr = Convert.toStr(price); + Double leaveBehindPrice = basicdataPriceFullVehicleEntity.getLeaveBehindPrice(); + String leaveBehindPriceStr = Convert.toStr(leaveBehindPrice); + // 1：按件，2：按方，3：按重量，4：按公里，5：按吨公里，6：按吨 + Integer type = basicdataPriceFullVehicleEntity.getType(); + if (ObjectUtil.isNotEmpty(type)) { + if (type == 1) { + fullVehicleV2Excel.setDispatchUnit("按件"); + } else if (type == 2) { + fullVehicleV2Excel.setDispatchUnit("按方"); + } else if (type == 3) { + fullVehicleV2Excel.setDispatchUnit("按重量"); + } else if (type == 4) { + fullVehicleV2Excel.setDispatchUnit("按公里"); + } else if (type == 5) { + fullVehicleV2Excel.setDispatchUnit("按吨公里"); + } else if (type == 6) { + fullVehicleV2Excel.setDispatchUnit("按吨"); + } + } + fullVehicleV2Excel.setDispatchPrice(priceStr); + fullVehicleV2Excel.setDispatchLeaveBehindPrice(leaveBehindPriceStr); + } else if (costType == 2) { + Double sortPrice = basicdataPriceFullVehicleEntity.getSortPrice(); + String sortPriceStr = Convert.toStr(sortPrice); + Double handlingPrice = basicdataPriceFullVehicleEntity.getHandlingPrice(); + String handlingPriceStr = Convert.toStr(handlingPrice); + Double relocationPrice = basicdataPriceFullVehicleEntity.getRelocationPrice(); + String relocationPriceStr = Convert.toStr(relocationPrice); + Double upstairsDeliveryPrice = basicdataPriceFullVehicleEntity.getUpstairsDeliveryPrice(); + String upstairsDeliveryPriceStr = Convert.toStr(upstairsDeliveryPrice); + String dispatchStairsCarryingCharge = pricePageV2VO.getDispatchStairsCarryingCharge(); + fullVehicleV2Excel.setDispatchSortPrice(sortPriceStr); + fullVehicleV2Excel.setDispatchHandlingPrice(handlingPriceStr); + fullVehicleV2Excel.setDispatchRelocationPrice(relocationPriceStr); + fullVehicleV2Excel.setDispatchDeliveryPrice(upstairsDeliveryPriceStr); + fullVehicleV2Excel.setDispatchStairsCarryingCharge(dispatchStairsCarryingCharge); + } + } + } + } + } + } + if (CollUtil.isNotEmpty(categoryMap)) { + Collection values = categoryMap.values(); + if (CollUtil.isNotEmpty(values)) { + List objects = new ArrayList<>(); + objects.addAll(values); + excelWriter.write(objects, writeSheet4, table4); + }else{ + excelWriter.write(new ArrayList(), writeSheet4, table4); + } + } + } + } + + } + + private IPage selectBasicdataPricePageV2Export(IPage page, BasicdataPriceV2Query basicdataPrice) { + List basicdataPriceVOS = baseMapper.selectBasicdataPricePageV2Export(page, basicdataPrice); + if (CollUtil.isNotEmpty(basicdataPriceVOS)) { + for (BasicdataPricePageV2VO basicdataPriceVO : basicdataPriceVOS) { + // 服务类型 + String serviceType = basicdataPriceVO.getServiceType(); + if (StrUtil.isNotEmpty(serviceType)) { + List res = new ArrayList<>(); + List split = StrUtil.split(serviceType, ","); + for (String s : split) { + res.add(IDict.getTextByCode(ServiceTypeEnums.class, Convert.toInt(s))); + } + basicdataPriceVO.setServiceType(StrUtil.join("/", res)); + } + } + } + return page.setRecords(basicdataPriceVOS); + } + @Override public Boolean deletePrice(String id) { BasicdataPriceEntity entity = this.getById(id); @@ -334,11 +1020,11 @@ public class BasicdataPriceServiceImpl extends BaseServiceImpl priceExcels, List basicExcels, + List generalExcels, List fullVehicleExcels, + Map templateEntityMap, + Map clientEntityMap, Map brandEntityMap, + Map priceEntityMap, Map categoryEntityMap, + Map provinceMap, Map provinceCityMap, + Map provinceCityAearMap, Map vehicleTypeMap, + Map routeMap, Map clientBrandMap, Map templateMap) { + if (CollUtil.isNotEmpty(priceExcels)) { + List priceEntities = new ArrayList<>(); + List basicEntities = new ArrayList<>(); + List warehouseEntities = new ArrayList<>(); + List dispatchEntities = new ArrayList<>(); + List fullVehicleEntities = new ArrayList<>(); + List generalEntities = new ArrayList<>(); + List routeEntities = new ArrayList<>(); +// Map templateMap = new HashMap<>(); + // 保存基本信息 + buildPriceEntitiesExcelV2(priceExcels, templateEntityMap, priceEntityMap, priceEntities, templateMap, generalExcels, basicExcels, clientBrandMap); + if (CollUtil.isNotEmpty(priceEntities)) { + this.saveOrUpdateBatch(priceEntities); + } + // 封装保存好的路径 + Map routeEntityMap = new HashMap<>(); + // 保存路径 + buildSaveRouteEntitiesExcelV2(clientEntityMap, priceEntityMap, provinceMap, provinceCityMap, + provinceCityAearMap, routeMap, routeEntities, routeEntityMap, templateMap); + if (CollUtil.isNotEmpty(routeEntities)) { + basicdataPriceRouteService.saveBatch(routeEntities); + } + // 处理 提货干线按品类计费 + buildSaveBasicEntitiesExcelV2(basicExcels, priceEntityMap, categoryEntityMap, basicEntities, templateMap, routeEntityMap, warehouseEntities, dispatchEntities); + if (CollUtil.isNotEmpty(basicEntities)) { + categoryBasicService.saveBatch(basicEntities); + } + if (CollUtil.isNotEmpty(warehouseEntities)) { + categoryWarehouseService.saveBatch(warehouseEntities); + } + if (CollUtil.isNotEmpty(dispatchEntities)) { + categoryDispatchService.saveBatch(dispatchEntities); + } + // 处理整车费用 + buildSaveFullVehicleEntitiesExcelV2(fullVehicleExcels, priceEntityMap, categoryEntityMap, fullVehicleEntities, templateMap, routeEntityMap, vehicleTypeMap); + if (CollUtil.isNotEmpty(fullVehicleEntities)) { + fullVehicleService.saveBatch(fullVehicleEntities); + } + // 处理一般费用 + buildSaveGeneralEntitiesExcelV2(generalExcels, priceEntityMap, categoryEntityMap, generalEntities, templateMap, routeEntityMap); + if (CollUtil.isNotEmpty(generalEntities)) { + generalService.saveBatch(generalEntities); + } + if (CollUtil.isNotEmpty(priceEntities)) { + this.saveOrUpdateBatch(priceEntities); + } + } + } + + @Transactional(rollbackFor = Exception.class) + public void saveExcelV3(List priceExcels, List basicExcels, + List generalExcels, List fullVehicleExcels, + Map templateEntityMap, + Map clientEntityMap, Map brandEntityMap, + Map priceEntityMap, Map categoryEntityMap, + Map provinceMap, Map provinceCityMap, + Map provinceCityAearMap, Map vehicleTypeMap, + Map routeMap, Map clientBrandMap, Map templateMap) { + if (CollUtil.isNotEmpty(priceExcels)) { + List priceEntities = new ArrayList<>(); + List basicEntities = new ArrayList<>(); + List warehouseEntities = new ArrayList<>(); + List dispatchEntities = new ArrayList<>(); + List fullVehicleEntities = new ArrayList<>(); + List generalEntities = new ArrayList<>(); + List routeEntities = new ArrayList<>(); +// Map templateMap = new HashMap<>(); + // 保存基本信息 + buildPriceEntitiesExcelV3(priceExcels, templateEntityMap, priceEntityMap, priceEntities, templateMap, generalExcels, basicExcels, clientBrandMap); + if (CollUtil.isNotEmpty(priceEntities)) { + this.saveOrUpdateBatch(priceEntities); + } + // 封装保存好的路径 + Map routeEntityMap = new HashMap<>(); + // 保存路径 + buildSaveRouteEntitiesExcelV2(clientEntityMap, priceEntityMap, provinceMap, provinceCityMap, + provinceCityAearMap, routeMap, routeEntities, routeEntityMap, templateMap); + if (CollUtil.isNotEmpty(routeEntities)) { + basicdataPriceRouteService.saveBatch(routeEntities); + } + // 处理 提货干线按品类计费 + buildSaveBasicEntitiesExcelV2(basicExcels, priceEntityMap, categoryEntityMap, basicEntities, templateMap, routeEntityMap, warehouseEntities, dispatchEntities); + if (CollUtil.isNotEmpty(basicEntities)) { + categoryBasicService.saveBatch(basicEntities); + } + if (CollUtil.isNotEmpty(warehouseEntities)) { + categoryWarehouseService.saveBatch(warehouseEntities); + } + if (CollUtil.isNotEmpty(dispatchEntities)) { + categoryDispatchService.saveBatch(dispatchEntities); + } + // 处理整车费用 + buildSaveFullVehicleEntitiesExcelV2(fullVehicleExcels, priceEntityMap, categoryEntityMap, fullVehicleEntities, templateMap, routeEntityMap, vehicleTypeMap); if (CollUtil.isNotEmpty(fullVehicleEntities)) { fullVehicleService.saveBatch(fullVehicleEntities); } // 处理一般费用 - buildSaveGeneralEntitiesExcel(generalExcels, priceEntityMap, categoryEntityMap, generalEntities, templateMap, routeEntityMap); + buildSaveGeneralEntitiesExcelV2(generalExcels, priceEntityMap, categoryEntityMap, generalEntities, templateMap, routeEntityMap); if (CollUtil.isNotEmpty(generalEntities)) { generalService.saveBatch(generalEntities); } + if (CollUtil.isNotEmpty(priceEntities)) { + this.saveOrUpdateBatch(priceEntities); + } } } @Transactional(rollbackFor = Exception.class) - public void saveExcelV2(List priceExcels, List basicExcels, - List generalExcels, List fullVehicleExcels, - Map templateEntityMap, - Map clientEntityMap, Map brandEntityMap, - Map priceEntityMap, Map categoryEntityMap, - Map provinceMap, Map provinceCityMap, - Map provinceCityAearMap, Map vehicleTypeMap, - Map routeMap, Map clientBrandMap, Map templateMap) { + public void saveExcelV3Update(List priceExcels, List basicExcels, + List generalExcels, List fullVehicleExcels, + Map templateEntityMap, + Map clientEntityMap, Map brandEntityMap, + Map priceEntityMap, Map categoryEntityMap, + Map provinceMap, Map provinceCityMap, + Map provinceCityAearMap, Map vehicleTypeMap, + Map routeMap, Map clientBrandMap, Map templateMap) { if (CollUtil.isNotEmpty(priceExcels)) { List priceEntities = new ArrayList<>(); List basicEntities = new ArrayList<>(); @@ -968,38 +1770,38 @@ public class BasicdataPriceServiceImpl extends BaseServiceImpl routeEntities = new ArrayList<>(); // Map templateMap = new HashMap<>(); // 保存基本信息 - buildPriceEntitiesExcelV2(priceExcels, templateEntityMap, priceEntityMap, priceEntities, templateMap, generalExcels, basicExcels, clientBrandMap); + buildPriceEntitiesExcelV3Update(priceExcels, templateEntityMap, priceEntityMap, priceEntities, templateMap, generalExcels, basicExcels, clientBrandMap); if (CollUtil.isNotEmpty(priceEntities)) { this.saveOrUpdateBatch(priceEntities); } // 封装保存好的路径 Map routeEntityMap = new HashMap<>(); // 保存路径 - buildSaveRouteEntitiesExcelV2(clientEntityMap, priceEntityMap, provinceMap, provinceCityMap, + buildSaveRouteEntitiesExcelV3Update(clientEntityMap, priceEntityMap, provinceMap, provinceCityMap, provinceCityAearMap, routeMap, routeEntities, routeEntityMap, templateMap); if (CollUtil.isNotEmpty(routeEntities)) { - basicdataPriceRouteService.saveBatch(routeEntities); + basicdataPriceRouteService.saveOrUpdateBatch(routeEntities); } // 处理 提货干线按品类计费 - buildSaveBasicEntitiesExcelV2(basicExcels, priceEntityMap, categoryEntityMap, basicEntities, templateMap, routeEntityMap, warehouseEntities, dispatchEntities); + buildSaveBasicEntitiesExcelV3Update(basicExcels, priceEntityMap, categoryEntityMap, basicEntities, templateMap, routeEntityMap, warehouseEntities, dispatchEntities); if (CollUtil.isNotEmpty(basicEntities)) { - categoryBasicService.saveBatch(basicEntities); + categoryBasicService.saveOrUpdateBatch(basicEntities); } if (CollUtil.isNotEmpty(warehouseEntities)) { - categoryWarehouseService.saveBatch(warehouseEntities); + categoryWarehouseService.saveOrUpdateBatch(warehouseEntities); } if (CollUtil.isNotEmpty(dispatchEntities)) { - categoryDispatchService.saveBatch(dispatchEntities); + categoryDispatchService.saveOrUpdateBatch(dispatchEntities); } // 处理整车费用 - buildSaveFullVehicleEntitiesExcelV2(fullVehicleExcels, priceEntityMap, categoryEntityMap, fullVehicleEntities, templateMap, routeEntityMap, vehicleTypeMap); + buildSaveFullVehicleEntitiesExcelV3Update(fullVehicleExcels, priceEntityMap, categoryEntityMap, fullVehicleEntities, templateMap, routeEntityMap, vehicleTypeMap); if (CollUtil.isNotEmpty(fullVehicleEntities)) { - fullVehicleService.saveBatch(fullVehicleEntities); + fullVehicleService.saveOrUpdateBatch(fullVehicleEntities); } // 处理一般费用 - buildSaveGeneralEntitiesExcelV2(generalExcels, priceEntityMap, categoryEntityMap, generalEntities, templateMap, routeEntityMap); + buildSaveGeneralEntitiesExcelV3Update(generalExcels, priceEntityMap, categoryEntityMap, generalEntities, templateMap, routeEntityMap); if (CollUtil.isNotEmpty(generalEntities)) { - generalService.saveBatch(generalEntities); + generalService.saveOrUpdateBatch(generalEntities); } if (CollUtil.isNotEmpty(priceEntities)) { this.saveOrUpdateBatch(priceEntities); @@ -1173,6 +1975,112 @@ public class BasicdataPriceServiceImpl extends BaseServiceImpl priceExcels, Map templateEntityMap, + Map priceEntityMap, List priceEntities, + Map templateMap, List generalExcels, + List basicExcels, Map clientBrandMap) { + for (BasicdataPriceV3Excel priceExcel : priceExcels) { + BasicdataPriceEntity priceEntity = priceEntityMap.get(priceExcel.getClient() + priceExcel.getBrand()); + if (ObjectUtil.isEmpty(priceEntity)) { + priceEntity = new BasicdataPriceEntity(); + priceEntity.setClientId(clientBrandMap.get(priceExcel.getClient() + priceExcel.getBrand()).getClientId()); + priceEntity.setBrandId(clientBrandMap.get(priceExcel.getClient() + priceExcel.getBrand()).getBrandId()); + priceEntityMap.put(priceExcel.getClient() + priceExcel.getBrand(), priceEntity); + } + BasicdataPriceTemplateEntity templateEntity = templateEntityMap.get(priceExcel.getTemplateName()); + templateMap.put(priceExcel.getClient() + priceExcel.getBrand(), templateEntity); + if (ObjectUtil.isNotEmpty(priceEntity)) { + // 删除数据 + if (ObjectUtil.isNotEmpty(priceEntity.getId())) { + deleteByPriceId(priceEntity.getId()); + } + priceEntity.setMaintenanceStatus(2); + // 设置值 +// setPriceExcelV2(templateEntityMap, priceExcel, priceEntity); + priceEntity.setEffectiveTime(DateUtil.parseDate(priceExcel.getEffectiveTime())); + // priceEntity.setExpiryTime(DateUtil.parseDate(priceExcel.getExpiryTime())); + priceEntity.setTemplateId(templateEntity.getId()); + // 是否配置向上判断数 + if (ObjectUtil.equal(templateEntity.getDispatchIsUpwardJudgment(), BooleanZeroOneEnums.YES.getCode())) { + for (BasicdataPriceGeneralV2Excel basicExcel : generalExcels) { + if (ObjectUtil.equal(basicExcel.getClient(), priceExcel.getClient()) + && ObjectUtil.equal(basicExcel.getBrand(), priceExcel.getBrand())) { + if (StrUtil.isNotEmpty(basicExcel.getDispatchUpwardJudgment())) { + priceEntity.setDispatchUpwardJudgmentCost(Convert.toDouble(basicExcel.getDispatchUpwardJudgment())); + } + if (StrUtil.isNotEmpty(basicExcel.getDispatchUpwardJudgmentCost())) { + priceEntity.setDispatchUpwardJudgmentCost(Convert.toDouble(basicExcel.getDispatchUpwardJudgmentCost())); + } + } + } + } + // 是否配置免楼层数 + if (ObjectUtil.equal(templateEntity.getDispatchIsFeeFloor(), BooleanZeroOneEnums.YES.getCode())) { + for (BasicdataPriceCategoryV2Excel basicExcel : basicExcels) { + if (ObjectUtil.equal(basicExcel.getClient(), priceExcel.getClient()) + && ObjectUtil.equal(basicExcel.getBrand(), priceExcel.getBrand())) { + if (StrUtil.isNotEmpty(basicExcel.getDispatchStairsCarryingCharge())) { + priceEntity.setDispatchStairsCarryingCharge(Convert.toInt(basicExcel.getDispatchStairsCarryingCharge())); + } + } + } + } + priceEntities.add(priceEntity); + } + } + } + + private void buildPriceEntitiesExcelV3Update(List priceExcels, Map templateEntityMap, + Map priceEntityMap, List priceEntities, + Map templateMap, List generalExcels, + List basicExcels, Map clientBrandMap) { + for (BasicdataPriceV3Excel priceExcel : priceExcels) { + BasicdataPriceEntity priceEntity = priceEntityMap.get(priceExcel.getClient() + priceExcel.getBrand()); + if (ObjectUtil.isEmpty(priceEntity)) { + priceEntity = new BasicdataPriceEntity(); + priceEntity.setClientId(clientBrandMap.get(priceExcel.getClient() + priceExcel.getBrand()).getClientId()); + priceEntity.setBrandId(clientBrandMap.get(priceExcel.getClient() + priceExcel.getBrand()).getBrandId()); + priceEntityMap.put(priceExcel.getClient() + priceExcel.getBrand(), priceEntity); + } + BasicdataPriceTemplateEntity templateEntity = templateEntityMap.get(priceExcel.getTemplateName()); + templateMap.put(priceExcel.getClient() + priceExcel.getBrand(), templateEntity); + if (ObjectUtil.isNotEmpty(priceEntity)) { + priceEntity.setMaintenanceStatus(2); + // 设置值 +// setPriceExcelV2(templateEntityMap, priceExcel, priceEntity); + priceEntity.setEffectiveTime(DateUtil.parseDate(priceExcel.getEffectiveTime())); + // priceEntity.setExpiryTime(DateUtil.parseDate(priceExcel.getExpiryTime())); + priceEntity.setTemplateId(templateEntity.getId()); + // 是否配置向上判断数 + if (ObjectUtil.equal(templateEntity.getDispatchIsUpwardJudgment(), BooleanZeroOneEnums.YES.getCode())) { + for (BasicdataPriceGeneralV2Excel basicExcel : generalExcels) { + if (ObjectUtil.equal(basicExcel.getClient(), priceExcel.getClient()) + && ObjectUtil.equal(basicExcel.getBrand(), priceExcel.getBrand())) { + if (StrUtil.isNotEmpty(basicExcel.getDispatchUpwardJudgment())) { + priceEntity.setDispatchUpwardJudgmentCost(Convert.toDouble(basicExcel.getDispatchUpwardJudgment())); + } + if (StrUtil.isNotEmpty(basicExcel.getDispatchUpwardJudgmentCost())) { + priceEntity.setDispatchUpwardJudgmentCost(Convert.toDouble(basicExcel.getDispatchUpwardJudgmentCost())); + } + } + } + } + // 是否配置免楼层数 + if (ObjectUtil.equal(templateEntity.getDispatchIsFeeFloor(), BooleanZeroOneEnums.YES.getCode())) { + for (BasicdataPriceCategoryV2Excel basicExcel : basicExcels) { + if (ObjectUtil.equal(basicExcel.getClient(), priceExcel.getClient()) + && ObjectUtil.equal(basicExcel.getBrand(), priceExcel.getBrand())) { + if (StrUtil.isNotEmpty(basicExcel.getDispatchStairsCarryingCharge())) { + priceEntity.setDispatchStairsCarryingCharge(Convert.toInt(basicExcel.getDispatchStairsCarryingCharge())); + } + } + } + } + priceEntities.add(priceEntity); + } + } + } + private void buildSaveRouteEntitiesExcel(Map clientEntityMap, Map priceEntityMap, Map provinceMap, Map provinceCityMap, Map provinceCityAearMap, Map routeMap, List routeEntities, Map routeEntityMap) { if (CollUtil.isNotEmpty(routeMap)) { for (Map.Entry entry : routeMap.entrySet()) { @@ -1311,6 +2219,116 @@ public class BasicdataPriceServiceImpl extends BaseServiceImpl clientEntityMap, Map priceEntityMap, + Map provinceMap, Map provinceCityMap, Map provinceCityAearMap, + Map routeMap, List routeEntities, + Map routeEntityMap, Map templateMap) { + if (CollUtil.isNotEmpty(routeMap)) { + for (Map.Entry entry : routeMap.entrySet()) { + // 客户编码&&&品牌&&&发货单位编码 || 客户编码&&&品牌&&&发货单位编码&&&发站省市 || 客户编码&&&品牌&&&发货单位编码&&&发站省市&&&发站省市区 + // + &&&1/&&&2 + String key = entry.getKey(); + if (StrUtil.isNotEmpty(key)) { + List regions = StrUtil.split(key, "&&&"); + if (CollUtil.isNotEmpty(regions)) { + String s = regions.get(0) + regions.get(1); + BasicdataPriceTemplateEntity templateEntity = templateMap.get(s); + String sendOrg = regions.get(2); + String serviceType = regions.get(3); + BasicdataPriceEntity priceEntity = priceEntityMap.get(s); + BasicdataPriceRouteEntity routeEntity = new BasicdataPriceRouteEntity(); + routeEntity.setPriceId(priceEntity.getId()); + routeEntity.setServiceType(Convert.toInt(serviceType)); + setSendOrgExcel(clientEntityMap, routeEntity, sendOrg); + // 发货单位-省市 6 + if (regions.size() >= 6) { + setStarProvinceExcel(provinceMap, routeEntity, regions.get(4)); + setStartCityExcel(provinceCityMap, routeEntity, regions.get(4), regions.get(5)); + } + // 发货单位-省市区 7 + if (ObjectUtil.equal(regions.size(), 7)) { + setStartCountExcel(provinceCityAearMap, routeEntity, regions.get(4), regions.get(5), regions.get(6)); + } + // 发货单位-省市-省市 8 + if (ObjectUtil.equal(regions.size(), 8)) { + setEndProvinceExcel(provinceMap, routeEntity, regions.get(6)); + setEndCityExcel(provinceCityMap, routeEntity, regions.get(6) + regions.get(7)); + } + // 发货单位-省市区-省市区 10 + if (ObjectUtil.equal(regions.size(), 10)) { + setStartCountExcel(provinceCityAearMap, routeEntity, regions.get(4), regions.get(5), regions.get(6)); + setEndProvinceExcel(provinceMap, routeEntity, regions.get(7)); + setEndCityExcel(provinceCityMap, routeEntity, regions.get(7) + regions.get(8)); + setEndCountExcel(provinceCityAearMap, routeEntity, regions.get(7), regions.get(8), regions.get(9)); + } + // 发货单位-省市区-省市 9 + if (ObjectUtil.equal(regions.size(), 9)) { + // 如果 s3s4s5 是省市区 则说明 s5 是区 + if (provinceCityAearMap.containsKey(regions.get(4) + regions.get(5) + regions.get(6))) { + setStartCountExcel(provinceCityAearMap, routeEntity, regions.get(4), regions.get(5), regions.get(6)); + setEndProvinceExcel(provinceMap, routeEntity, regions.get(7)); + setEndCityExcel(provinceCityMap, routeEntity, regions.get(7) + regions.get(8)); + } else { + // 发货单位-省市-省市区 9 + setEndProvinceExcel(provinceMap, routeEntity, regions.get(6)); + setEndCityExcel(provinceCityMap, routeEntity, regions.get(6) + regions.get(7)); + setEndCountExcel(provinceCityAearMap, routeEntity, regions.get(6), regions.get(7), regions.get(8)); + } + } + // 根据模板确定是否创建路径 + if (ObjectUtil.isNotEmpty(templateEntity)) { + if (StrUtil.contains(templateEntity.getServiceType(), "1") && ObjectUtil.equal(templateEntity.getPickupIsUnifyAreaBill(), 0)) { + routeEntityMap.put(key, routeEntity); + routeEntities.add(routeEntity); + } else if (StrUtil.contains(templateEntity.getServiceType(), "2") && ObjectUtil.equal(templateEntity.getTrunklineIsUnifyAreaBill(), 0)) { + routeEntityMap.put(key, routeEntity); + routeEntities.add(routeEntity); + } + } + } + } + } + } + // 当前路径是否存在，存在则更新，不存在则新增 + if (CollUtil.isNotEmpty(routeEntities)) { + Set collect = routeEntities.stream().map(BasicdataPriceRouteEntity::getPriceId).collect(Collectors.toSet()); + List list = basicdataPriceRouteService.list(Wrappers.lambdaQuery().in(BasicdataPriceRouteEntity::getPriceId, collect)); + if (CollUtil.isNotEmpty(list)) { + Map map = list.stream() + .collect(Collectors.toMap( + item -> String.join("_", + Convert.toStr(item.getPriceId()), + Convert.toStr(item.getSendOrgId()), + Convert.toStr(item.getStartProvinceId()), + Convert.toStr(item.getStartCityId()), + Convert.toStr(item.getStartCountyId()), + Convert.toStr(item.getEndProvinceId()), + Convert.toStr(item.getEndCityId()), + Convert.toStr(item.getEndCountyId()), + Convert.toStr(item.getServiceType()) + ), + BasicdataPriceRouteEntity::getId, + (existing, replacement) -> existing // 处理键冲突，这里选择保留旧值 + )); + for (BasicdataPriceRouteEntity routeEntity : routeEntities) { + String key = String.join("_", + Convert.toStr(routeEntity.getPriceId()), + Convert.toStr(routeEntity.getSendOrgId()), + Convert.toStr(routeEntity.getStartProvinceId()), + Convert.toStr(routeEntity.getStartCityId()), + Convert.toStr(routeEntity.getStartCountyId()), + Convert.toStr(routeEntity.getEndProvinceId()), + Convert.toStr(routeEntity.getEndCityId()), + Convert.toStr(routeEntity.getEndCountyId()), + Convert.toStr(routeEntity.getServiceType())); + if (map.containsKey(key)) { + routeEntity.setId(map.get(key)); + } + } + } + } + } + private void buildSaveFullVehicleEntitiesExcel(List excels, Map priceEntityMap, Map categoryEntityMap, @@ -1386,159 +2404,214 @@ public class BasicdataPriceServiceImpl extends BaseServiceImpl pickupEntityMap = new HashMap<>(); Map trunkLineEntityMap = new HashMap<>(); Map dispatchEntityMap = new HashMap<>(); - for (BasicdataPriceFullVehicleV2Excel excel : excels) { - BasicdataPriceEntity priceEntity = priceEntityMap.get(excel.getClient() + excel.getBrand()); - if (ObjectUtil.isEmpty(priceEntity)) { - log.error("导入价格体系在系统中不存在：{}_{}", excel.getClient(), excel.getBrand()); - continue; - } - BasicdataPriceTemplateEntity templateEntity = templateMap.get(excel.getClient() + excel.getBrand()); - // 是否按区域计费 - Integer pickupIsUnifyAreaBill = templateEntity.getPickupIsUnifyAreaBill(); - Integer trunklineIsUnifyAreaBill = templateEntity.getTrunklineIsUnifyAreaBill(); - String pickupPrice = excel.getPickupPrice(); - String trunkLinePrice = excel.getTrunkLinePrice(); - String dispatchPrice = excel.getDispatchPrice(); - if (StrUtil.isNotEmpty(pickupPrice) && Convert.toDouble(pickupPrice) > 0) { - String pickupPricingType = templateEntity.getPickupPricingType(); - // 提货费的计价方式是否包含整车 - if (StrUtil.isNotEmpty(pickupPricingType) && StrUtil.contains(pickupPricingType, PickupPricingTypeEnums.COMPLETE_VEHICLE.getCode().toString())) { - boolean b = ObjectUtil.isNotEmpty(pickupIsUnifyAreaBill) && ObjectUtil.equal(pickupIsUnifyAreaBill, BooleanZeroOneEnums.NO.getCode()); - BasicdataPriceFullVehicleEntity entity = null; - if (b) { - entity = new BasicdataPriceFullVehicleEntity(); - } else { - if (pickupEntityMap.containsKey(excel.getClient() + excel.getBrand() + excel.getVehicleType())) { - entity = pickupEntityMap.get(excel.getClient() + excel.getBrand() + excel.getVehicleType()); - } else { - entity = new BasicdataPriceFullVehicleEntity(); - pickupEntityMap.put(excel.getClient() + excel.getBrand() + excel.getVehicleType(), entity); - } - } - if (b) { - if (!ObjectUtil.isAllEmpty(excel.getClient(), excel.getBrand(), excel.getSendOrg())) { - String key = buildRoutKeyV2(excel.getClient(), excel.getBrand(), excel.getStartProvince(), excel.getStartCity(), - excel.getStartArea(), excel.getEndProvince(), excel.getEndCity(), excel.getEndArea(), excel.getSendOrg(), "1"); - BasicdataPriceRouteEntity routeEntity = routeEntityMap.get(key); - if (ObjectUtil.isNotEmpty(routeEntity)) { - entity.setBoId(routeEntity.getId()); - } - } else { - entity.setBoId(priceEntity.getId()); - log.error("价格体系导入FullVehicle数据无法处理,模板配置的按区域计费，数据不满足路径条件：{}", JSONUtil.toJsonStr(excel)); - continue; - } - } else { - // 统一计费 - entity.setBoId(priceEntity.getId()); - } - entity.setPriceId(priceEntity.getId()); - // 类型 - entity.setType(FullVehicleTypeEnums.PICK_UP.getCode()); - // 车型 - if (ObjectUtil.isNotEmpty(excel.getVehicleType())) { - String vehicleType = vehicleTypeMap.get(excel.getVehicleType()); - if (StrUtil.isNotEmpty(vehicleType)) { - entity.setVehicleType(Convert.toLong(vehicleType)); - } - } - // 价格 - entity.setPrice(Convert.toDouble(pickupPrice)); - if (b) { - entities.add(entity); + buildPickupEntityMap(excels, priceEntityMap, entities, templateMap, routeEntityMap, vehicleTypeMap, pickupEntityMap, trunkLineEntityMap, dispatchEntityMap); + if (CollUtil.isNotEmpty(pickupEntityMap)) { + entities.addAll(pickupEntityMap.values()); + } + if (CollUtil.isNotEmpty(dispatchEntityMap)) { + entities.addAll(dispatchEntityMap.values()); + } + if (CollUtil.isNotEmpty(trunkLineEntityMap)) { + entities.addAll(trunkLineEntityMap.values()); + } + } + } + + private void buildSaveFullVehicleEntitiesExcelV3Update(List excels, + Map priceEntityMap, + Map categoryEntityMap, + List entities, + Map templateMap, + Map routeEntityMap, + Map vehicleTypeMap) { + if (CollUtil.isNotEmpty(excels)) { + Map pickupEntityMap = new HashMap<>(); + Map trunkLineEntityMap = new HashMap<>(); + Map dispatchEntityMap = new HashMap<>(); + buildPickupEntityMap(excels, priceEntityMap, entities, templateMap, routeEntityMap, vehicleTypeMap, pickupEntityMap, trunkLineEntityMap, dispatchEntityMap); + if (CollUtil.isNotEmpty(pickupEntityMap)) { + entities.addAll(pickupEntityMap.values()); + } + if (CollUtil.isNotEmpty(dispatchEntityMap)) { + entities.addAll(dispatchEntityMap.values()); + } + if (CollUtil.isNotEmpty(trunkLineEntityMap)) { + entities.addAll(trunkLineEntityMap.values()); + } + if (CollUtil.isNotEmpty(entities)) { + Set collect = entities.stream().map(BasicdataPriceFullVehicleEntity::getPriceId).collect(Collectors.toSet()); + List list = fullVehicleService.list(Wrappers.lambdaQuery().in(BasicdataPriceFullVehicleEntity::getPriceId, collect)); + if (CollUtil.isNotEmpty(list)) { + Map map = list.stream() + .collect(Collectors.toMap( + item -> String.join("_", + Convert.toStr(item.getBoId()), + Convert.toStr(item.getPriceId()), + Convert.toStr(item.getVehicleType()), + Convert.toStr(item.getType()) + ), + BasicdataPriceFullVehicleEntity::getId, + (existing, replacement) -> existing // 处理键冲突，这里选择保留旧值 + )); + for (BasicdataPriceFullVehicleEntity routeEntity : entities) { + String key = String.join("_", + Convert.toStr(routeEntity.getBoId()), + Convert.toStr(routeEntity.getPriceId()), + Convert.toStr(routeEntity.getVehicleType()), + Convert.toStr(routeEntity.getType()) + ); + if (map.containsKey(key)) { + routeEntity.setId(map.get(key)); } } - } + } + } + } - if (StrUtil.isNotEmpty(trunkLinePrice) && Convert.toDouble(trunkLinePrice) > 0) { - String pricingType = templateEntity.getTrunklinePricingType(); - // 提货费的计价方式是否包含整车 - if (StrUtil.isNotEmpty(pricingType) && StrUtil.contains(pricingType, TrunkLinePricingTypeEnums.COMPLETE_VEHICLE.getCode().toString())) { - boolean b = ObjectUtil.isNotEmpty(trunklineIsUnifyAreaBill) && ObjectUtil.equal(trunklineIsUnifyAreaBill, BooleanZeroOneEnums.NO.getCode()); - BasicdataPriceFullVehicleEntity entity = null; - if (b) { - entity = new BasicdataPriceFullVehicleEntity(); + private void buildPickupEntityMap(List excels, Map priceEntityMap, List entities, Map templateMap, Map routeEntityMap, Map vehicleTypeMap, Map pickupEntityMap, Map trunkLineEntityMap, Map dispatchEntityMap) { + for (BasicdataPriceFullVehicleV2Excel excel : excels) { + BasicdataPriceEntity priceEntity = priceEntityMap.get(excel.getClient() + excel.getBrand()); + if (ObjectUtil.isEmpty(priceEntity)) { + log.error("导入价格体系在系统中不存在：{}_{}", excel.getClient(), excel.getBrand()); + continue; + } + BasicdataPriceTemplateEntity templateEntity = templateMap.get(excel.getClient() + excel.getBrand()); + // 是否按区域计费 + Integer pickupIsUnifyAreaBill = templateEntity.getPickupIsUnifyAreaBill(); + Integer trunklineIsUnifyAreaBill = templateEntity.getTrunklineIsUnifyAreaBill(); + String pickupPrice = excel.getPickupPrice(); + String trunkLinePrice = excel.getTrunkLinePrice(); + String dispatchPrice = excel.getDispatchPrice(); + if (StrUtil.isNotEmpty(pickupPrice) && Convert.toDouble(pickupPrice) > 0) { + String pickupPricingType = templateEntity.getPickupPricingType(); + // 提货费的计价方式是否包含整车 + if (StrUtil.isNotEmpty(pickupPricingType) && StrUtil.contains(pickupPricingType, PickupPricingTypeEnums.COMPLETE_VEHICLE.getCode().toString())) { + boolean b = ObjectUtil.isNotEmpty(pickupIsUnifyAreaBill) && ObjectUtil.equal(pickupIsUnifyAreaBill, BooleanZeroOneEnums.NO.getCode()); + BasicdataPriceFullVehicleEntity entity = null; + if (b) { + entity = new BasicdataPriceFullVehicleEntity(); + } else { + if (pickupEntityMap.containsKey(excel.getClient() + excel.getBrand() + excel.getVehicleType())) { + entity = pickupEntityMap.get(excel.getClient() + excel.getBrand() + excel.getVehicleType()); } else { - if (trunkLineEntityMap.containsKey(excel.getClient() + excel.getBrand() + excel.getVehicleType())) { - entity = trunkLineEntityMap.get(excel.getClient() + excel.getBrand() + excel.getVehicleType()); - } else { - entity = new BasicdataPriceFullVehicleEntity(); - trunkLineEntityMap.put(excel.getClient() + excel.getBrand() + excel.getVehicleType(), entity); - } + entity = new BasicdataPriceFullVehicleEntity(); + pickupEntityMap.put(excel.getClient() + excel.getBrand() + excel.getVehicleType(), entity); } - if (ObjectUtil.isNotEmpty(trunklineIsUnifyAreaBill) && ObjectUtil.equal(trunklineIsUnifyAreaBill, BooleanZeroOneEnums.NO.getCode())) { - if (!ObjectUtil.isAllEmpty(excel.getClient(), excel.getBrand(), excel.getSendOrg())) { - String key = buildRoutKeyV2(excel.getClient(), excel.getBrand(), excel.getStartProvince(), excel.getStartCity(), - excel.getStartArea(), excel.getEndProvince(), excel.getEndCity(), excel.getEndArea(), excel.getSendOrg(), "2"); - BasicdataPriceRouteEntity routeEntity = routeEntityMap.get(key); - if (ObjectUtil.isNotEmpty(routeEntity)) { - entity.setBoId(routeEntity.getId()); - } - } else { - entity.setBoId(priceEntity.getId()); - log.error("价格体系导入FullVehicle数据无法处理,模板配置的按区域计费，数据不满足路径条件：{}", JSONUtil.toJsonStr(excel)); - continue; + } + if (b) { + if (!ObjectUtil.isAllEmpty(excel.getClient(), excel.getBrand(), excel.getSendOrg())) { + String key = buildRoutKeyV2(excel.getClient(), excel.getBrand(), excel.getStartProvince(), excel.getStartCity(), + excel.getStartArea(), excel.getEndProvince(), excel.getEndCity(), excel.getEndArea(), excel.getSendOrg(), "1"); + BasicdataPriceRouteEntity routeEntity = routeEntityMap.get(key); + if (ObjectUtil.isNotEmpty(routeEntity)) { + entity.setBoId(routeEntity.getId()); } } else { - // 统一计费 entity.setBoId(priceEntity.getId()); + log.error("价格体系导入FullVehicle数据无法处理,模板配置的按区域计费，数据不满足路径条件：{}", JSONUtil.toJsonStr(excel)); + continue; } - entity.setPriceId(priceEntity.getId()); - // 类型 - entity.setType(FullVehicleTypeEnums.TRUNK_LINE.getCode()); - // 车型 - if (ObjectUtil.isNotEmpty(excel.getVehicleType())) { - String vehicleType = vehicleTypeMap.get(excel.getVehicleType()); - if (StrUtil.isNotEmpty(vehicleType)) { - entity.setVehicleType(Convert.toLong(vehicleType)); - } - } - // 价格 - entity.setPrice(Convert.toDouble(trunkLinePrice)); - if (b) { - entities.add(entity); + } else { + // 统一计费 + entity.setBoId(priceEntity.getId()); + } + entity.setPriceId(priceEntity.getId()); + // 类型 + entity.setType(FullVehicleTypeEnums.PICK_UP.getCode()); + // 车型 + if (ObjectUtil.isNotEmpty(excel.getVehicleType())) { + String vehicleType = vehicleTypeMap.get(excel.getVehicleType()); + if (StrUtil.isNotEmpty(vehicleType)) { + entity.setVehicleType(Convert.toLong(vehicleType)); } } + // 价格 + entity.setPrice(Convert.toDouble(pickupPrice)); + if (b) { + entities.add(entity); + } } - if (StrUtil.isNotEmpty(dispatchPrice) && Convert.toDouble(dispatchPrice) > 0) { - String pricingType = templateEntity.getDispatchPricingType(); - // 提货费的计价方式是否包含整车 - if (StrUtil.isNotEmpty(pricingType) && StrUtil.contains(pricingType, DispatchPricingTypeEnums.COMPLETE_VEHICLE.getCode().toString())) { - BasicdataPriceFullVehicleEntity entity = null; - if (dispatchEntityMap.containsKey(excel.getClient() + excel.getBrand() + excel.getVehicleType())) { - entity = dispatchEntityMap.get(excel.getClient() + excel.getBrand() + excel.getVehicleType()); + } + + if (StrUtil.isNotEmpty(trunkLinePrice) && Convert.toDouble(trunkLinePrice) > 0) { + String pricingType = templateEntity.getTrunklinePricingType(); + // 提货费的计价方式是否包含整车 + if (StrUtil.isNotEmpty(pricingType) && StrUtil.contains(pricingType, TrunkLinePricingTypeEnums.COMPLETE_VEHICLE.getCode().toString())) { + boolean b = ObjectUtil.isNotEmpty(trunklineIsUnifyAreaBill) && ObjectUtil.equal(trunklineIsUnifyAreaBill, BooleanZeroOneEnums.NO.getCode()); + BasicdataPriceFullVehicleEntity entity = null; + if (b) { + entity = new BasicdataPriceFullVehicleEntity(); + } else { + if (trunkLineEntityMap.containsKey(excel.getClient() + excel.getBrand() + excel.getVehicleType())) { + entity = trunkLineEntityMap.get(excel.getClient() + excel.getBrand() + excel.getVehicleType()); } else { entity = new BasicdataPriceFullVehicleEntity(); - dispatchEntityMap.put(excel.getClient() + excel.getBrand() + excel.getVehicleType(), entity); + trunkLineEntityMap.put(excel.getClient() + excel.getBrand() + excel.getVehicleType(), entity); + } + } + if (ObjectUtil.isNotEmpty(trunklineIsUnifyAreaBill) && ObjectUtil.equal(trunklineIsUnifyAreaBill, BooleanZeroOneEnums.NO.getCode())) { + if (!ObjectUtil.isAllEmpty(excel.getClient(), excel.getBrand(), excel.getSendOrg())) { + String key = buildRoutKeyV2(excel.getClient(), excel.getBrand(), excel.getStartProvince(), excel.getStartCity(), + excel.getStartArea(), excel.getEndProvince(), excel.getEndCity(), excel.getEndArea(), excel.getSendOrg(), "2"); + BasicdataPriceRouteEntity routeEntity = routeEntityMap.get(key); + if (ObjectUtil.isNotEmpty(routeEntity)) { + entity.setBoId(routeEntity.getId()); + } + } else { + entity.setBoId(priceEntity.getId()); + log.error("价格体系导入FullVehicle数据无法处理,模板配置的按区域计费，数据不满足路径条件：{}", JSONUtil.toJsonStr(excel)); + continue; } + } else { // 统一计费 entity.setBoId(priceEntity.getId()); - entity.setPriceId(priceEntity.getId()); - // 类型 - entity.setType(FullVehicleTypeEnums.DISPATCH.getCode()); - // 车型 - if (ObjectUtil.isNotEmpty(excel.getVehicleType())) { - String vehicleType = vehicleTypeMap.get(excel.getVehicleType()); - if (StrUtil.isNotEmpty(vehicleType)) { - entity.setVehicleType(Convert.toLong(vehicleType)); - } + } + entity.setPriceId(priceEntity.getId()); + // 类型 + entity.setType(FullVehicleTypeEnums.TRUNK_LINE.getCode()); + // 车型 + if (ObjectUtil.isNotEmpty(excel.getVehicleType())) { + String vehicleType = vehicleTypeMap.get(excel.getVehicleType()); + if (StrUtil.isNotEmpty(vehicleType)) { + entity.setVehicleType(Convert.toLong(vehicleType)); } - // 价格 - entity.setPrice(Convert.toDouble(dispatchPrice)); + } + // 价格 + entity.setPrice(Convert.toDouble(trunkLinePrice)); + if (b) { + entities.add(entity); } } - - } - if (CollUtil.isNotEmpty(pickupEntityMap)) { - entities.addAll(pickupEntityMap.values()); - } - if (CollUtil.isNotEmpty(dispatchEntityMap)) { - entities.addAll(dispatchEntityMap.values()); } - if (CollUtil.isNotEmpty(trunkLineEntityMap)) { - entities.addAll(trunkLineEntityMap.values()); + + if (StrUtil.isNotEmpty(dispatchPrice) && Convert.toDouble(dispatchPrice) > 0) { + String pricingType = templateEntity.getDispatchPricingType(); + // 提货费的计价方式是否包含整车 + if (StrUtil.isNotEmpty(pricingType) && StrUtil.contains(pricingType, DispatchPricingTypeEnums.COMPLETE_VEHICLE.getCode().toString())) { + BasicdataPriceFullVehicleEntity entity = null; + if (dispatchEntityMap.containsKey(excel.getClient() + excel.getBrand() + excel.getVehicleType())) { + entity = dispatchEntityMap.get(excel.getClient() + excel.getBrand() + excel.getVehicleType()); + } else { + entity = new BasicdataPriceFullVehicleEntity(); + dispatchEntityMap.put(excel.getClient() + excel.getBrand() + excel.getVehicleType(), entity); + } + // 统一计费 + entity.setBoId(priceEntity.getId()); + entity.setPriceId(priceEntity.getId()); + // 类型 + entity.setType(FullVehicleTypeEnums.DISPATCH.getCode()); + // 车型 + if (ObjectUtil.isNotEmpty(excel.getVehicleType())) { + String vehicleType = vehicleTypeMap.get(excel.getVehicleType()); + if (StrUtil.isNotEmpty(vehicleType)) { + entity.setVehicleType(Convert.toLong(vehicleType)); + } + } + // 价格 + entity.setPrice(Convert.toDouble(dispatchPrice)); + } } } } @@ -1607,187 +2680,243 @@ public class BasicdataPriceServiceImpl extends BaseServiceImpl trunkLineEntityMap = new HashMap<>(); Map dispatchEntityMap = new HashMap<>(); Map dispatchLeaveBehindEntityMap = new HashMap<>(); - for (BasicdataPriceGeneralV2Excel basicExcel : excels) { - BasicdataPriceEntity priceEntity = priceEntityMap.get(basicExcel.getClient() + basicExcel.getBrand()); - if (ObjectUtil.isEmpty(priceEntity)) { - log.error("导入价格体系在系统中不存在"); - continue; - } - BasicdataPriceTemplateEntity templateEntity = templateMap.get(basicExcel.getClient() + basicExcel.getBrand()); + buildGeneralEntiryMap(excels, priceEntityMap, entities, templateMap, routeEntityMap, pickupEntityMap, trunkLineEntityMap, dispatchEntityMap, dispatchLeaveBehindEntityMap); + if (CollUtil.isNotEmpty(pickupEntityMap)) { + entities.addAll(pickupEntityMap.values()); + } + if (CollUtil.isNotEmpty(dispatchLeaveBehindEntityMap)) { + entities.addAll(dispatchLeaveBehindEntityMap.values()); + } + if (CollUtil.isNotEmpty(dispatchEntityMap)) { + entities.addAll(dispatchEntityMap.values()); + } + if (CollUtil.isNotEmpty(trunkLineEntityMap)) { + entities.addAll(trunkLineEntityMap.values()); + } + } + } - // 是否按区域计费 - Integer pickupIsUnifyAreaBill = templateEntity.getPickupIsUnifyAreaBill(); - Integer trunklineIsUnifyAreaBill = templateEntity.getTrunklineIsUnifyAreaBill(); - String pickupMinCost = basicExcel.getPickupMinCost(); - String trunkLineMinCost = basicExcel.getTrunkLineMinCost(); - String dispatchMinCost = basicExcel.getDispatchMinCost(); - String dispatchLeaveBehindMinCost = basicExcel.getDispatchLeaveBehindMinCost(); - if (StrUtil.isNotEmpty(pickupMinCost) && Convert.toDouble(pickupMinCost) > 0) { - Integer isMinCost = templateEntity.getPickupIsMinCost(); - if (ObjectUtil.isNotEmpty(isMinCost) && ObjectUtil.equal(isMinCost, BooleanZeroOneEnums.YES.getCode())) { - boolean b = ObjectUtil.isNotEmpty(pickupIsUnifyAreaBill) && ObjectUtil.equal(pickupIsUnifyAreaBill, BooleanZeroOneEnums.NO.getCode()); - // 服务类型 - BasicdataPriceGeneralEntity basicEntity = null; - if (b) { - basicEntity = new BasicdataPriceGeneralEntity(); - } else { - if (pickupEntityMap.containsKey(basicExcel.getClient() + basicExcel.getBrand())) { - basicEntity = pickupEntityMap.get(basicExcel.getClient() + basicExcel.getBrand()); - } else { - basicEntity = new BasicdataPriceGeneralEntity(); - pickupEntityMap.put(basicExcel.getClient() + basicExcel.getBrand(), basicEntity); - } - } - basicEntity.setServiceType(GeneralServiceTypeEnums.PICK_UP.getCode()); - // 按区域计费 - if (b) { - if (!ObjectUtil.isAllEmpty(basicExcel.getClient(), basicExcel.getBrand(), basicExcel.getSendOrg())) { - String key = buildRoutKeyV2(basicExcel.getClient(), basicExcel.getBrand(), basicExcel.getStartProvince(), basicExcel.getStartCity(), - basicExcel.getStartArea(), basicExcel.getEndProvince(), basicExcel.getEndCity(), basicExcel.getEndArea(), basicExcel.getSendOrg(), "1"); - BasicdataPriceRouteEntity routeEntity = routeEntityMap.get(key); - if (ObjectUtil.isNotEmpty(routeEntity)) { - basicEntity.setBoId(routeEntity.getId()); - } - } else { - basicEntity.setBoId(priceEntity.getId()); - log.error("价格体系导入General数据无法处理,模板配置的按区域计费，数据不满足路径条件：{}", JSONUtil.toJsonStr(basicExcel)); - continue; - } - } else { - // 统一计费 - basicEntity.setBoId(priceEntity.getId()); - } - basicEntity.setPriceId(priceEntity.getId()); - // 最低计费 - basicEntity.setMinCost(Convert.toDouble(pickupMinCost)); - // 加算价格 - if (StrUtil.isNotEmpty(basicExcel.getPickupAddCost())) { - basicEntity.setAdditionalCost(Convert.toDouble(basicExcel.getPickupAddCost())); - } - // 按区域计费直接加入保存队列 - if (b) { - entities.add(basicEntity); + private void buildSaveGeneralEntitiesExcelV3Update(List excels, Map priceEntityMap, + Map categoryEntityMap, List entities, + Map templateMap, Map routeEntityMap) { + if (CollUtil.isNotEmpty(excels)) { + // 不按区域计费时 客户+品牌 唯一 + Map pickupEntityMap = new HashMap<>(); + Map trunkLineEntityMap = new HashMap<>(); + Map dispatchEntityMap = new HashMap<>(); + Map dispatchLeaveBehindEntityMap = new HashMap<>(); + buildGeneralEntiryMap(excels, priceEntityMap, entities, templateMap, routeEntityMap, pickupEntityMap, trunkLineEntityMap, dispatchEntityMap, dispatchLeaveBehindEntityMap); + if (CollUtil.isNotEmpty(pickupEntityMap)) { + entities.addAll(pickupEntityMap.values()); + } + if (CollUtil.isNotEmpty(dispatchLeaveBehindEntityMap)) { + entities.addAll(dispatchLeaveBehindEntityMap.values()); + } + if (CollUtil.isNotEmpty(dispatchEntityMap)) { + entities.addAll(dispatchEntityMap.values()); + } + if (CollUtil.isNotEmpty(trunkLineEntityMap)) { + entities.addAll(trunkLineEntityMap.values()); + } + if (CollUtil.isNotEmpty(entities)) { + Set collect = entities.stream().map(BasicdataPriceGeneralEntity::getPriceId).collect(Collectors.toSet()); + List list = generalService.list(Wrappers.lambdaQuery().in(BasicdataPriceGeneralEntity::getPriceId, collect)); + if (CollUtil.isNotEmpty(list)) { + Map map = list.stream() + .collect(Collectors.toMap( + item -> String.join("_", + Convert.toStr(item.getBoId()), + Convert.toStr(item.getPriceId()), + Convert.toStr(item.getServiceType()) + ), + BasicdataPriceGeneralEntity::getId, + (existing, replacement) -> existing // 处理键冲突，这里选择保留旧值 + )); + for (BasicdataPriceGeneralEntity routeEntity : entities) { + String key = String.join("_", + Convert.toStr(routeEntity.getBoId()), + Convert.toStr(routeEntity.getPriceId()), + Convert.toStr(routeEntity.getServiceType()) + ); + if (map.containsKey(key)) { + routeEntity.setId(map.get(key)); } } - } + } + } + } - if (StrUtil.isNotEmpty(trunkLineMinCost) && Convert.toDouble(trunkLineMinCost) > 0) { - Integer isMinCost = templateEntity.getTrunklineIsMinCost(); - if (ObjectUtil.isNotEmpty(isMinCost) && ObjectUtil.equal(isMinCost, BooleanZeroOneEnums.YES.getCode())) { - boolean b = ObjectUtil.isNotEmpty(trunklineIsUnifyAreaBill) && ObjectUtil.equal(trunklineIsUnifyAreaBill, BooleanZeroOneEnums.NO.getCode()); - // 服务类型 - BasicdataPriceGeneralEntity basicEntity = null; - if (b) { - basicEntity = new BasicdataPriceGeneralEntity(); + private void buildGeneralEntiryMap(List excels, Map priceEntityMap, List entities, Map templateMap, Map routeEntityMap, Map pickupEntityMap, Map trunkLineEntityMap, Map dispatchEntityMap, Map dispatchLeaveBehindEntityMap) { + for (BasicdataPriceGeneralV2Excel basicExcel : excels) { + BasicdataPriceEntity priceEntity = priceEntityMap.get(basicExcel.getClient() + basicExcel.getBrand()); + if (ObjectUtil.isEmpty(priceEntity)) { + log.error("导入价格体系在系统中不存在"); + continue; + } + BasicdataPriceTemplateEntity templateEntity = templateMap.get(basicExcel.getClient() + basicExcel.getBrand()); + + // 是否按区域计费 + Integer pickupIsUnifyAreaBill = templateEntity.getPickupIsUnifyAreaBill(); + Integer trunklineIsUnifyAreaBill = templateEntity.getTrunklineIsUnifyAreaBill(); + String pickupMinCost = basicExcel.getPickupMinCost(); + String trunkLineMinCost = basicExcel.getTrunkLineMinCost(); + String dispatchMinCost = basicExcel.getDispatchMinCost(); + String dispatchLeaveBehindMinCost = basicExcel.getDispatchLeaveBehindMinCost(); + if (StrUtil.isNotEmpty(pickupMinCost) && Convert.toDouble(pickupMinCost) > 0) { + Integer isMinCost = templateEntity.getPickupIsMinCost(); + if (ObjectUtil.isNotEmpty(isMinCost) && ObjectUtil.equal(isMinCost, BooleanZeroOneEnums.YES.getCode())) { + boolean b = ObjectUtil.isNotEmpty(pickupIsUnifyAreaBill) && ObjectUtil.equal(pickupIsUnifyAreaBill, BooleanZeroOneEnums.NO.getCode()); + // 服务类型 + BasicdataPriceGeneralEntity basicEntity = null; + if (b) { + basicEntity = new BasicdataPriceGeneralEntity(); + } else { + if (pickupEntityMap.containsKey(basicExcel.getClient() + basicExcel.getBrand())) { + basicEntity = pickupEntityMap.get(basicExcel.getClient() + basicExcel.getBrand()); } else { - if (trunkLineEntityMap.containsKey(basicExcel.getClient() + basicExcel.getBrand())) { - basicEntity = trunkLineEntityMap.get(basicExcel.getClient() + basicExcel.getBrand()); - } else { - basicEntity = new BasicdataPriceGeneralEntity(); - trunkLineEntityMap.put(basicExcel.getClient() + basicExcel.getBrand(), basicEntity); - } + basicEntity = new BasicdataPriceGeneralEntity(); + pickupEntityMap.put(basicExcel.getClient() + basicExcel.getBrand(), basicEntity); } - basicEntity.setServiceType(GeneralServiceTypeEnums.TRUNK_LINE.getCode()); - // 按区域计费 - if (b) { - if (!ObjectUtil.isAllEmpty(basicExcel.getClient(), basicExcel.getBrand(), basicExcel.getSendOrg())) { - String key = buildRoutKeyV2(basicExcel.getClient(), basicExcel.getBrand(), basicExcel.getStartProvince(), basicExcel.getStartCity(), - basicExcel.getStartArea(), basicExcel.getEndProvince(), basicExcel.getEndCity(), basicExcel.getEndArea(), basicExcel.getSendOrg(), "2"); - BasicdataPriceRouteEntity routeEntity = routeEntityMap.get(key); - if (ObjectUtil.isNotEmpty(routeEntity)) { - basicEntity.setBoId(routeEntity.getId()); - } - } else { - basicEntity.setBoId(priceEntity.getId()); - log.error("价格体系导入General数据无法处理,模板配置的按区域计费，数据不满足路径条件：{}", JSONUtil.toJsonStr(basicExcel)); - continue; + } + basicEntity.setServiceType(GeneralServiceTypeEnums.PICK_UP.getCode()); + // 按区域计费 + if (b) { + if (!ObjectUtil.isAllEmpty(basicExcel.getClient(), basicExcel.getBrand(), basicExcel.getSendOrg())) { + String key = buildRoutKeyV2(basicExcel.getClient(), basicExcel.getBrand(), basicExcel.getStartProvince(), basicExcel.getStartCity(), + basicExcel.getStartArea(), basicExcel.getEndProvince(), basicExcel.getEndCity(), basicExcel.getEndArea(), basicExcel.getSendOrg(), "1"); + BasicdataPriceRouteEntity routeEntity = routeEntityMap.get(key); + if (ObjectUtil.isNotEmpty(routeEntity)) { + basicEntity.setBoId(routeEntity.getId()); } } else { - // 统一计费 basicEntity.setBoId(priceEntity.getId()); + log.error("价格体系导入General数据无法处理,模板配置的按区域计费，数据不满足路径条件：{}", JSONUtil.toJsonStr(basicExcel)); + continue; } - basicEntity.setPriceId(priceEntity.getId()); - // 最低计费 - basicEntity.setMinCost(Convert.toDouble(trunkLineMinCost)); - // 加算价格 - if (StrUtil.isNotEmpty(basicExcel.getTrunkLineAddCost())) { - basicEntity.setAdditionalCost(Convert.toDouble(basicExcel.getTrunkLineAddCost())); - } - if (b) { - entities.add(basicEntity); - } + } else { + // 统一计费 + basicEntity.setBoId(priceEntity.getId()); + } + basicEntity.setPriceId(priceEntity.getId()); + // 最低计费 + basicEntity.setMinCost(Convert.toDouble(pickupMinCost)); + // 加算价格 + if (StrUtil.isNotEmpty(basicExcel.getPickupAddCost())) { + basicEntity.setAdditionalCost(Convert.toDouble(basicExcel.getPickupAddCost())); + } + // 按区域计费直接加入保存队列 + if (b) { + entities.add(basicEntity); } } - if (StrUtil.isNotEmpty(dispatchMinCost) && Convert.toDouble(dispatchMinCost) > 0) { + } + + if (StrUtil.isNotEmpty(trunkLineMinCost) && Convert.toDouble(trunkLineMinCost) > 0) { + Integer isMinCost = templateEntity.getTrunklineIsMinCost(); + if (ObjectUtil.isNotEmpty(isMinCost) && ObjectUtil.equal(isMinCost, BooleanZeroOneEnums.YES.getCode())) { + boolean b = ObjectUtil.isNotEmpty(trunklineIsUnifyAreaBill) && ObjectUtil.equal(trunklineIsUnifyAreaBill, BooleanZeroOneEnums.NO.getCode()); // 服务类型 - Integer isMinCost = templateEntity.getDispatchIsMinCost(); - if (ObjectUtil.isNotEmpty(isMinCost) && ObjectUtil.equal(isMinCost, BooleanZeroOneEnums.YES.getCode())) { - BasicdataPriceGeneralEntity basicEntity = null; - if (dispatchEntityMap.containsKey(basicExcel.getClient() + basicExcel.getBrand())) { - basicEntity = dispatchEntityMap.get(basicExcel.getClient() + basicExcel.getBrand()); + BasicdataPriceGeneralEntity basicEntity = null; + if (b) { + basicEntity = new BasicdataPriceGeneralEntity(); + } else { + if (trunkLineEntityMap.containsKey(basicExcel.getClient() + basicExcel.getBrand())) { + basicEntity = trunkLineEntityMap.get(basicExcel.getClient() + basicExcel.getBrand()); } else { basicEntity = new BasicdataPriceGeneralEntity(); - dispatchEntityMap.put(basicExcel.getClient() + basicExcel.getBrand(), basicEntity); - } - basicEntity.setServiceType(GeneralServiceTypeEnums.DISPATCH.getCode()); - // 统一计费 - basicEntity.setBoId(priceEntity.getId()); - basicEntity.setPriceId(priceEntity.getId()); - // 最低计费 - basicEntity.setMinCost(Convert.toDouble(dispatchMinCost)); - // 加算价格 - if (StrUtil.isNotEmpty(basicExcel.getDispatchAddCost())) { - basicEntity.setAdditionalCost(Convert.toDouble(basicExcel.getDispatchAddCost())); + trunkLineEntityMap.put(basicExcel.getClient() + basicExcel.getBrand(), basicEntity); } } - } - - if (StrUtil.isNotEmpty(dispatchLeaveBehindMinCost) && Convert.toDouble(dispatchLeaveBehindMinCost) > 0) { - // 服务类型 - Integer isMinCost = templateEntity.getDispatchIsMinCost(); - if (ObjectUtil.isNotEmpty(isMinCost) && ObjectUtil.equal(isMinCost, BooleanZeroOneEnums.YES.getCode())) { - BasicdataPriceGeneralEntity basicEntity = null; - if (dispatchLeaveBehindEntityMap.containsKey(basicExcel.getClient() + basicExcel.getBrand())) { - basicEntity = dispatchLeaveBehindEntityMap.get(basicExcel.getClient() + basicExcel.getBrand()); + basicEntity.setServiceType(GeneralServiceTypeEnums.TRUNK_LINE.getCode()); + // 按区域计费 + if (b) { + if (!ObjectUtil.isAllEmpty(basicExcel.getClient(), basicExcel.getBrand(), basicExcel.getSendOrg())) { + String key = buildRoutKeyV2(basicExcel.getClient(), basicExcel.getBrand(), basicExcel.getStartProvince(), basicExcel.getStartCity(), + basicExcel.getStartArea(), basicExcel.getEndProvince(), basicExcel.getEndCity(), basicExcel.getEndArea(), basicExcel.getSendOrg(), "2"); + BasicdataPriceRouteEntity routeEntity = routeEntityMap.get(key); + if (ObjectUtil.isNotEmpty(routeEntity)) { + basicEntity.setBoId(routeEntity.getId()); + } } else { - basicEntity = new BasicdataPriceGeneralEntity(); - dispatchLeaveBehindEntityMap.put(basicExcel.getClient() + basicExcel.getBrand(), basicEntity); + basicEntity.setBoId(priceEntity.getId()); + log.error("价格体系导入General数据无法处理,模板配置的按区域计费，数据不满足路径条件：{}", JSONUtil.toJsonStr(basicExcel)); + continue; } - basicEntity.setServiceType(GeneralServiceTypeEnums.DISPATCH_LEAVE_BEHIND.getCode()); + } else { // 统一计费 basicEntity.setBoId(priceEntity.getId()); - basicEntity.setPriceId(priceEntity.getId()); - // 最低计费 - basicEntity.setMinCost(Convert.toDouble(dispatchLeaveBehindMinCost)); - // 加算价格 - if (StrUtil.isNotEmpty(basicExcel.getDispatchLeaveBehindAddCost())) { - basicEntity.setAdditionalCost(Convert.toDouble(basicExcel.getDispatchLeaveBehindAddCost())); - } + } + basicEntity.setPriceId(priceEntity.getId()); + // 最低计费 + basicEntity.setMinCost(Convert.toDouble(trunkLineMinCost)); + // 加算价格 + if (StrUtil.isNotEmpty(basicExcel.getTrunkLineAddCost())) { + basicEntity.setAdditionalCost(Convert.toDouble(basicExcel.getTrunkLineAddCost())); + } + if (b) { + entities.add(basicEntity); } } + } - String dispatchUpwardJudgment = basicExcel.getDispatchUpwardJudgment(); - if (StrUtil.isNotEmpty(dispatchUpwardJudgment)) { - priceEntity.setDispatchUpwardJudgment(Convert.toDouble(dispatchUpwardJudgment)); - } - String dispatchUpwardJudgmentCost = basicExcel.getDispatchUpwardJudgmentCost(); - if (StrUtil.isNotEmpty(dispatchUpwardJudgmentCost)) { - priceEntity.setDispatchUpwardJudgmentCost(Convert.toDouble(dispatchUpwardJudgmentCost)); + if (StrUtil.isNotEmpty(dispatchMinCost) && Convert.toDouble(dispatchMinCost) > 0) { + // 服务类型 + Integer isMinCost = templateEntity.getDispatchIsMinCost(); + if (ObjectUtil.isNotEmpty(isMinCost) && ObjectUtil.equal(isMinCost, BooleanZeroOneEnums.YES.getCode())) { + BasicdataPriceGeneralEntity basicEntity = null; + if (dispatchEntityMap.containsKey(basicExcel.getClient() + basicExcel.getBrand())) { + basicEntity = dispatchEntityMap.get(basicExcel.getClient() + basicExcel.getBrand()); + } else { + basicEntity = new BasicdataPriceGeneralEntity(); + dispatchEntityMap.put(basicExcel.getClient() + basicExcel.getBrand(), basicEntity); + } + basicEntity.setServiceType(GeneralServiceTypeEnums.DISPATCH.getCode()); + // 统一计费 + basicEntity.setBoId(priceEntity.getId()); + basicEntity.setPriceId(priceEntity.getId()); + // 最低计费 + basicEntity.setMinCost(Convert.toDouble(dispatchMinCost)); + // 加算价格 + if (StrUtil.isNotEmpty(basicExcel.getDispatchAddCost())) { + basicEntity.setAdditionalCost(Convert.toDouble(basicExcel.getDispatchAddCost())); + } } } - if (CollUtil.isNotEmpty(pickupEntityMap)) { - entities.addAll(pickupEntityMap.values()); - } - if (CollUtil.isNotEmpty(dispatchLeaveBehindEntityMap)) { - entities.addAll(dispatchLeaveBehindEntityMap.values()); + + if (StrUtil.isNotEmpty(dispatchLeaveBehindMinCost) && Convert.toDouble(dispatchLeaveBehindMinCost) > 0) { + // 服务类型 + Integer isMinCost = templateEntity.getDispatchIsMinCost(); + if (ObjectUtil.isNotEmpty(isMinCost) && ObjectUtil.equal(isMinCost, BooleanZeroOneEnums.YES.getCode())) { + BasicdataPriceGeneralEntity basicEntity = null; + if (dispatchLeaveBehindEntityMap.containsKey(basicExcel.getClient() + basicExcel.getBrand())) { + basicEntity = dispatchLeaveBehindEntityMap.get(basicExcel.getClient() + basicExcel.getBrand()); + } else { + basicEntity = new BasicdataPriceGeneralEntity(); + dispatchLeaveBehindEntityMap.put(basicExcel.getClient() + basicExcel.getBrand(), basicEntity); + } + basicEntity.setServiceType(GeneralServiceTypeEnums.DISPATCH_LEAVE_BEHIND.getCode()); + // 统一计费 + basicEntity.setBoId(priceEntity.getId()); + basicEntity.setPriceId(priceEntity.getId()); + // 最低计费 + basicEntity.setMinCost(Convert.toDouble(dispatchLeaveBehindMinCost)); + // 加算价格 + if (StrUtil.isNotEmpty(basicExcel.getDispatchLeaveBehindAddCost())) { + basicEntity.setAdditionalCost(Convert.toDouble(basicExcel.getDispatchLeaveBehindAddCost())); + } + } } - if (CollUtil.isNotEmpty(dispatchEntityMap)) { - entities.addAll(dispatchEntityMap.values()); + + String dispatchUpwardJudgment = basicExcel.getDispatchUpwardJudgment(); + if (StrUtil.isNotEmpty(dispatchUpwardJudgment)) { + priceEntity.setDispatchUpwardJudgment(Convert.toDouble(dispatchUpwardJudgment)); } - if (CollUtil.isNotEmpty(trunkLineEntityMap)) { - entities.addAll(trunkLineEntityMap.values()); + String dispatchUpwardJudgmentCost = basicExcel.getDispatchUpwardJudgmentCost(); + if (StrUtil.isNotEmpty(dispatchUpwardJudgmentCost)) { + priceEntity.setDispatchUpwardJudgmentCost(Convert.toDouble(dispatchUpwardJudgmentCost)); } } } @@ -1944,6 +3073,184 @@ public class BasicdataPriceServiceImpl extends BaseServiceImpl basicExcels, Map priceEntityMap, + Map categoryEntityMap, List basicEntities, + Map templateMap, Map routeEntityMap, List warehouseEntities, List dispatchEntities) { + if (CollUtil.isNotEmpty(basicExcels)) { + Map pickupEntityMap = new HashMap<>(); + Map trunkLineEntityMap = new HashMap<>(); + Map warehouseEntityMap = new HashMap<>(); + Map warehouseAddEntityMap = new HashMap<>(); + Map dispatchEntityMap = new HashMap<>(); + Map dispatchAddEntityMap = new HashMap<>(); + for (BasicdataPriceCategoryV2Excel basicExcel : basicExcels) { + BasicdataPriceEntity priceEntity = priceEntityMap.get(basicExcel.getClient() + basicExcel.getBrand()); + if (ObjectUtil.isEmpty(priceEntity)) { + log.error("导入价格体系在系统中不存在"); + continue; + } + BasicdataPriceTemplateEntity templateEntity = templateMap.get(basicExcel.getClient() + basicExcel.getBrand()); + // 是否按区域计费 + Integer pickupIsUnifyAreaBill = templateEntity.getPickupIsUnifyAreaBill(); + Integer trunklineIsUnifyAreaBill = templateEntity.getTrunklineIsUnifyAreaBill(); + String pickupPrice = basicExcel.getPickupPrice(); + String trunkLinePrice = basicExcel.getTrunkLinePrice(); + if (StrUtil.isNotEmpty(pickupPrice) && Convert.toDouble(pickupPrice) > 0) { + buildSaveBasicExcel(categoryEntityMap, routeEntityMap, pickupEntityMap, basicExcel, priceEntity, templateEntity, pickupIsUnifyAreaBill, pickupPrice); + } + if (StrUtil.isNotEmpty(trunkLinePrice) && Convert.toDouble(trunkLinePrice) > 0) { + buildSaveTrunkLineExcel(categoryEntityMap, routeEntityMap, trunkLineEntityMap, basicExcel, priceEntity, templateEntity, trunklineIsUnifyAreaBill, trunkLinePrice); + } + String withinThirtyPrice = basicExcel.getWithinThirtyPrice(); + String betweenThirtySixtyPrice = basicExcel.getBetweenThirtySixtyPrice(); + String beyondSixtyPrice = basicExcel.getBeyondSixtyPrice(); + String beyondNinetyPrice = basicExcel.getBeyondNinetyPrice(); + // 4个仓储费只要有一个不为空则创建 + if ((ObjectUtil.isNotEmpty(withinThirtyPrice) && Convert.toDouble(withinThirtyPrice) > 0) + || (ObjectUtil.isNotEmpty(betweenThirtySixtyPrice) && Convert.toDouble(betweenThirtySixtyPrice) > 0) + || (ObjectUtil.isNotEmpty(beyondSixtyPrice) && Convert.toDouble(beyondSixtyPrice) > 0) + || (ObjectUtil.isNotEmpty(beyondNinetyPrice) && Convert.toDouble(beyondNinetyPrice) > 0)) { + buildSaveWarehouseExcel(categoryEntityMap, warehouseEntityMap, basicExcel, priceEntity, templateEntity); + } + String warehouseOperatePrice = basicExcel.getWarehouseOperatePrice(); + String warehouseManagementPrice = basicExcel.getWarehouseManagementPrice(); + String warehouseSortPrice = basicExcel.getWarehouseSortPrice(); + if ((ObjectUtil.isNotEmpty(warehouseOperatePrice) && Convert.toDouble(warehouseOperatePrice) > 0) + || (ObjectUtil.isNotEmpty(warehouseManagementPrice) && Convert.toDouble(warehouseManagementPrice) > 0) + || (ObjectUtil.isNotEmpty(warehouseSortPrice) && Convert.toDouble(warehouseSortPrice) > 0)) { + buildSaveWarehouseAddExcel(categoryEntityMap, warehouseAddEntityMap, basicExcel, priceEntity, templateEntity); + } + String dispatchPrice = basicExcel.getDispatchPrice(); + if (StrUtil.isNotEmpty(dispatchPrice) && Convert.toDouble(dispatchPrice) > 0) { + buildSaveDispatchExcel(categoryEntityMap, dispatchEntityMap, basicExcel, priceEntity, templateEntity); + } + String dispatchSortPrice = basicExcel.getDispatchSortPrice(); + String dispatchHandlingPrice = basicExcel.getDispatchHandlingPrice(); + String dispatchRelocationPrice = basicExcel.getDispatchRelocationPrice(); + String dispatchDeliveryPrice = basicExcel.getDispatchDeliveryPrice(); + if ((ObjectUtil.isNotEmpty(dispatchSortPrice) && Convert.toDouble(dispatchSortPrice) > 0) + || (ObjectUtil.isNotEmpty(dispatchHandlingPrice) && Convert.toDouble(dispatchHandlingPrice) > 0) + || (ObjectUtil.isNotEmpty(dispatchRelocationPrice) && Convert.toDouble(dispatchRelocationPrice) > 0) + || (ObjectUtil.isNotEmpty(dispatchDeliveryPrice) && Convert.toDouble(dispatchDeliveryPrice) > 0)) { + buildSaveDispatchAddExcel(categoryEntityMap, dispatchAddEntityMap, basicExcel, priceEntity, templateEntity); + } + String dispatchStairsCarryingCharge = basicExcel.getDispatchStairsCarryingCharge(); + if (StrUtil.isNotEmpty(dispatchStairsCarryingCharge)) { + priceEntity.setDispatchStairsCarryingCharge(Convert.toInt(dispatchStairsCarryingCharge)); + } + } + if (CollUtil.isNotEmpty(pickupEntityMap)) { + basicEntities.addAll(pickupEntityMap.values()); + } + if (CollUtil.isNotEmpty(trunkLineEntityMap)) { + basicEntities.addAll(trunkLineEntityMap.values()); + } + if (CollUtil.isNotEmpty(basicEntities)) { + Set collect = basicEntities.stream().map(BasicdataPriceCategoryBasicEntity::getPriceId).collect(Collectors.toSet()); + List list = categoryBasicService.list(Wrappers.lambdaQuery().in(BasicdataPriceCategoryBasicEntity::getPriceId, collect)); + if (CollUtil.isNotEmpty(list)) { + Map map = list.stream() + .collect(Collectors.toMap( + item -> String.join("_", + Convert.toStr(item.getPriceId()), + Convert.toStr(item.getBoId()), + Convert.toStr(item.getCategoryId()), + Convert.toStr(item.getType()), + Convert.toStr(item.getServiceType()) + ), + BasicdataPriceCategoryBasicEntity::getId, + (existing, replacement) -> existing // 处理键冲突，这里选择保留旧值 + )); + for (BasicdataPriceCategoryBasicEntity routeEntity : basicEntities) { + String key = String.join("_", + Convert.toStr(routeEntity.getPriceId()), + Convert.toStr(routeEntity.getBoId()), + Convert.toStr(routeEntity.getCategoryId()), + Convert.toStr(routeEntity.getType()), + Convert.toStr(routeEntity.getServiceType())); + if (map.containsKey(key)) { + routeEntity.setId(map.get(key)); + } + } + } + } + if (CollUtil.isNotEmpty(warehouseEntityMap)) { + warehouseEntities.addAll(warehouseEntityMap.values()); + } + if (CollUtil.isNotEmpty(warehouseAddEntityMap)) { + warehouseEntities.addAll(warehouseAddEntityMap.values()); + } + if (CollUtil.isNotEmpty(warehouseEntities)) { + Set collect = warehouseEntities.stream().map(BasicdataPriceCategoryWarehouseEntity::getPriceId).collect(Collectors.toSet()); + List list = categoryWarehouseService.list(Wrappers.lambdaQuery().in(BasicdataPriceCategoryWarehouseEntity::getPriceId, collect)); + if (CollUtil.isNotEmpty(list)) { + Map map = list.stream() + .collect(Collectors.toMap( + item -> String.join("_", + Convert.toStr(item.getPriceId()), + Convert.toStr(item.getBoId()), + Convert.toStr(item.getCategoryId()), + Convert.toStr(item.getType()), + Convert.toStr(item.getCostType()), + Convert.toStr(item.getServiceType()) + ), + BasicdataPriceCategoryWarehouseEntity::getId, + (existing, replacement) -> existing // 处理键冲突，这里选择保留旧值 + )); + for (BasicdataPriceCategoryWarehouseEntity routeEntity : warehouseEntities) { + String key = String.join("_", + Convert.toStr(routeEntity.getPriceId()), + Convert.toStr(routeEntity.getBoId()), + Convert.toStr(routeEntity.getCategoryId()), + Convert.toStr(routeEntity.getType()), + Convert.toStr(routeEntity.getCostType()), + Convert.toStr(routeEntity.getServiceType())); + if (map.containsKey(key)) { + routeEntity.setId(map.get(key)); + } + } + } + } + if (CollUtil.isNotEmpty(dispatchEntityMap)) { + dispatchEntities.addAll(dispatchEntityMap.values()); + } + if (CollUtil.isNotEmpty(dispatchAddEntityMap)) { + dispatchEntities.addAll(dispatchAddEntityMap.values()); + } + if (CollUtil.isNotEmpty(dispatchEntities)) { + Set collect = dispatchEntities.stream().map(BasicdataPriceCategoryDispatchEntity::getPriceId).collect(Collectors.toSet()); + List list = categoryDispatchService.list(Wrappers.lambdaQuery().in(BasicdataPriceCategoryDispatchEntity::getPriceId, collect)); + if (CollUtil.isNotEmpty(list)) { + Map map = list.stream() + .collect(Collectors.toMap( + item -> String.join("_", + Convert.toStr(item.getPriceId()), + Convert.toStr(item.getBoId()), + Convert.toStr(item.getCategoryId()), + Convert.toStr(item.getType()), + Convert.toStr(item.getCostType()), + Convert.toStr(item.getServiceType()) + ), + BasicdataPriceCategoryDispatchEntity::getId, + (existing, replacement) -> existing // 处理键冲突，这里选择保留旧值 + )); + for (BasicdataPriceCategoryDispatchEntity routeEntity : dispatchEntities) { + String key = String.join("_", + Convert.toStr(routeEntity.getPriceId()), + Convert.toStr(routeEntity.getBoId()), + Convert.toStr(routeEntity.getCategoryId()), + Convert.toStr(routeEntity.getType()), + Convert.toStr(routeEntity.getCostType()), + Convert.toStr(routeEntity.getServiceType())); + if (map.containsKey(key)) { + routeEntity.setId(map.get(key)); + } + } + } + } + } + } + private void buildSaveDispatchAddExcel(Map categoryEntityMap, Map dispatchAddEntityMap, BasicdataPriceCategoryV2Excel basicExcel, BasicdataPriceEntity priceEntity, BasicdataPriceTemplateEntity templateEntity) { // 配送是否附加费 Integer dispatchIsAddFee = templateEntity.getDispatchIsAddFee(); @@ -2433,7 +3740,16 @@ public class BasicdataPriceServiceImpl extends BaseServiceImpl carModelList = carModelClient.getCarModelList(); if (CollUtil.isNotEmpty(carModelList)) { for (BasicCarModelEntity basicCarModelEntity : carModelList) { - vehicleTypeMap.put(basicCarModelEntity.getVehicleModel(),Convert.toStr(basicCarModelEntity.getId())); + vehicleTypeMap.put(basicCarModelEntity.getVehicleModel(), Convert.toStr(basicCarModelEntity.getId())); + } + } + } + + private void initVehicleTypeMapV2Export(Map vehicleTypeMap) { + List carModelList = carModelClient.getCarModelList(); + if (CollUtil.isNotEmpty(carModelList)) { + for (BasicCarModelEntity basicCarModelEntity : carModelList) { + vehicleTypeMap.put(basicCarModelEntity.getId(), basicCarModelEntity.getVehicleModel()); } } } @@ -3063,6 +4379,30 @@ public class BasicdataPriceServiceImpl extends BaseServiceImpl regionMap) { + R> regionALL = sysClient.getRegionALL(); + if (regionALL.isSuccess()) { + List data = regionALL.getData(); + if (CollUtil.isNotEmpty(data)) { + for (RegionAllVO datum : data) { + regionMap.put(datum.getValue(), datum.getLabel()); + List children = datum.getChildren(); + if (CollUtil.isNotEmpty(children)) { + for (RegionAllVO child : children) { + regionMap.put(child.getValue(), child.getLabel()); + List children1 = child.getChildren(); + if (CollUtil.isNotEmpty(children1)) { + for (RegionAllVO regionAllVO : children1) { + regionMap.put(regionAllVO.getValue(), regionAllVO.getLabel()); + } + } + } + } + } + } + } + } + private void initCategoryData(List basicExcels, List dispatchExcels, List warehouseExcels, @@ -3121,6 +4461,16 @@ public class BasicdataPriceServiceImpl extends BaseServiceImpl categoryEntityMap) { + List list = categoryService.list(); + if (CollUtil.isNotEmpty(list)) { + // 将List中的数据方到categoryEntityMap中 + list.forEach(basicdataCategoryEntity -> { + categoryEntityMap.put(Convert.toStr(basicdataCategoryEntity.getId()), basicdataCategoryEntity.getName()); + }); + } + } + private void initImportData(List priceExcels, List basicExcels, List generalExcels, List fullVehicleExcels, Map templateEntityMap, Map clientEntityMap, Map brandEntityMap, Map priceEntityMap) { Set templateNameSet = new HashSet<>(); Set clientSet = new HashSet<>(); @@ -3307,6 +4657,132 @@ public class BasicdataPriceServiceImpl extends BaseServiceImpl priceEntities = this.list(Wrappers.lambdaQuery() .in(BasicdataPriceEntity::getClientId, clientEntityMap.values().stream().map(BasicdataClientEntity::getId).collect(Collectors.toList())) .in(BasicdataPriceEntity::getBrandId, brandEntityMap.values().stream().map(BasicdataBrandEntity::getId).collect(Collectors.toList())) + .lt(BasicdataPriceEntity::getEffectiveStatus, 1) + ); + if (CollUtil.isNotEmpty(priceEntities)) { + // 分组存入map中 + priceEntities.forEach(priceEntity -> { + checkPriceMap.computeIfAbsent(clientMap.get(priceEntity.getClientId().toString()) + brandMap.get(priceEntity.getBrandId().toString()), k -> new ArrayList<>()); + checkPriceMap.get(clientMap.get(priceEntity.getClientId().toString()) + brandMap.get(priceEntity.getBrandId().toString())).add(priceEntity); + }); + } + } + +// List priceEntities = this.baseMapper.findEntityByClientAndBrandV2(priceExcels); +// if (CollUtil.isNotEmpty(priceEntities)) { +// priceEntities.forEach(priceEntity -> { +// priceEntityMap.put(priceEntity.getClientName() + priceEntity.getBrandName(), priceEntity); +// }); +// } + } + } + + private void initImportDataV3(List priceExcels, List basicExcels, + List generalExcels, List fullVehicleExcels, + Map templateEntityMap, Map clientEntityMap, + Map brandEntityMap, Map priceEntityMap, + Map clientBrandMap, Map> checkPriceMap, + Map templateMap) { + Set templateNameSet = new HashSet<>(); + Set clientSet = new HashSet<>(); + Set brandSet = new HashSet<>(); + // 将数据封装到set中 + priceExcels.forEach(priceExcel -> { + if (StrUtil.isNotEmpty(priceExcel.getTemplateName())) { + templateNameSet.add(priceExcel.getTemplateName()); + } + if (StrUtil.isNotEmpty(priceExcel.getClient())) { + clientSet.add(priceExcel.getClient()); + } + if (StrUtil.isNotEmpty(priceExcel.getBrand())) { + brandSet.add(priceExcel.getBrand()); + } + }); + if (CollUtil.isNotEmpty(basicExcels)) { + for (BasicdataPriceCategoryV2Excel basicExcel : basicExcels) { + if (StrUtil.isNotEmpty(basicExcel.getSendOrg())) { + clientSet.add(basicExcel.getSendOrg()); + } + } + } + if (CollUtil.isNotEmpty(generalExcels)) { + for (BasicdataPriceGeneralV2Excel generalExcel : generalExcels) { + if (StrUtil.isNotEmpty(generalExcel.getSendOrg())) { + clientSet.add(generalExcel.getSendOrg()); + } + } + } + if (CollUtil.isNotEmpty(fullVehicleExcels)) { + for (BasicdataPriceFullVehicleV2Excel fullVehicleExcel : fullVehicleExcels) { + if (StrUtil.isNotEmpty(fullVehicleExcel.getSendOrg())) { + clientSet.add(fullVehicleExcel.getSendOrg()); + } + } + } + // 先校验数据完整性 + if (CollUtil.isNotEmpty(templateNameSet)) { + LambdaQueryWrapper templateWrapper = Wrappers.lambdaQuery().in(BasicdataPriceTemplateEntity::getName, templateNameSet); + List templateEntities = templateService.list(templateWrapper); + // 将templateEntities中的数据放到map中 + templateEntities.forEach(templateEntity -> { + templateEntityMap.put(templateEntity.getName(), templateEntity); + }); + } + + priceExcels.forEach(priceExcel -> { + if (ObjectUtil.isAllNotEmpty(priceExcel.getClient(), priceExcel.getBrand(), priceExcel.getTemplateName())) { + if (templateEntityMap.containsKey(priceExcel.getTemplateName())) { + templateMap.put(priceExcel.getClient() + priceExcel.getBrand(), templateEntityMap.get(priceExcel.getTemplateName())); + } + } + }); + + Map clientMap = new HashMap<>(); + if (CollUtil.isNotEmpty(clientSet)) { + LambdaQueryWrapper clientWrapper = Wrappers.lambdaQuery().in(BasicdataClientEntity::getClientName, clientSet); + List clientEntities = clientService.list(clientWrapper); + // 将clientEntities中的数据放到map中 + clientEntities.forEach(clientEntity -> { + clientEntityMap.put(clientEntity.getClientName(), clientEntity); + clientMap.put(clientEntity.getId().toString(), clientEntity.getClientName()); + }); + } + Map brandMap = new HashMap<>(); + if (CollUtil.isNotEmpty(brandSet)) { + LambdaQueryWrapper brandWrapper = Wrappers.lambdaQuery().in(BasicdataBrandEntity::getBrandName, brandSet); + List brandEntities = brandService.list(brandWrapper); + // 将brandEntities中的数据放到map中 + brandEntities.forEach(brandEntity -> { + brandEntityMap.put(brandEntity.getBrandName(), brandEntity); + brandMap.put(brandEntity.getId().toString(), brandEntity.getBrandName()); + }); + } + + + Boolean flag = Boolean.FALSE; + for (BasicdataPriceV3Excel priceExcel : priceExcels) { + if (!ObjectUtil.isAllEmpty(priceExcel.getClient(), priceExcel.getBrand())) { + flag = Boolean.TRUE; + break; + } + } + if (flag) { + // 封装客户和品牌的关系 + if (!ObjectUtil.isAllEmpty(clientEntityMap, brandEntityMap)) { + List list = storeBrandService.list(Wrappers.lambdaQuery() + .in(BasicdataStoreBrandEntity::getClientId, clientEntityMap.values().stream().map(BasicdataClientEntity::getId).collect(Collectors.toList())) + .in(BasicdataStoreBrandEntity::getBrandId, brandEntityMap.values().stream().map(BasicdataBrandEntity::getId).collect(Collectors.toList())) + .eq(BasicdataStoreBrandEntity::getIsDeleted, 0) + ); + if (CollUtil.isNotEmpty(list)) { + list.forEach(storeBrandEntity -> { + clientBrandMap.put(clientMap.get(storeBrandEntity.getClientId().toString()) + brandMap.get(storeBrandEntity.getBrandId().toString()), storeBrandEntity); + }); + } + List priceEntities = this.list(Wrappers.lambdaQuery() + .in(BasicdataPriceEntity::getClientId, clientEntityMap.values().stream().map(BasicdataClientEntity::getId).collect(Collectors.toList())) + .in(BasicdataPriceEntity::getBrandId, brandEntityMap.values().stream().map(BasicdataBrandEntity::getId).collect(Collectors.toList())) + .lt(BasicdataPriceEntity::getEffectiveStatus, 1) ); if (CollUtil.isNotEmpty(priceEntities)) { // 分组存入map中 @@ -3539,6 +5015,115 @@ public class BasicdataPriceServiceImpl extends BaseServiceImpl priceExcels, String sheet1, + Map templateEntityMap, Map clientEntityMap, + Map brandEntityMap, Map priceEntityMap, + Map clientBrandMap, Map> checkPriceEntityMap) { + if (CollUtil.isNotEmpty(priceExcels)) { + Map checkRepeatMap = new HashMap<>(); + for (int i = 0; i < priceExcels.size(); i++) { + StringBuilder rowMessage = new StringBuilder(); + int rowNum = i + 2; + String firstMessage = sheet1 + "-第" + rowNum + "行："; + BasicdataPriceV3Excel priceExcel = priceExcels.get(i); + // 校验必填项 + Boolean clientFlag = Boolean.FALSE; + if (StrUtil.isEmpty(priceExcel.getClient())) { + rowMessage.append("客户名称不能为空；"); + } else { + if (!clientEntityMap.containsKey(priceExcel.getClient())) { + rowMessage.append("客户名称[").append(priceExcel.getClient()).append("]在系统中不存在；"); + } else { + clientFlag = Boolean.TRUE; + } + } + Boolean brandFlag = Boolean.FALSE; + if (StrUtil.isEmpty(priceExcel.getBrand())) { + rowMessage.append("品牌名称名称不能为空；"); + } else { + if (!brandEntityMap.containsKey(priceExcel.getBrand())) { + rowMessage.append("品牌名称[").append(priceExcel.getBrand()).append("]在系统中不存在；"); + } else { + brandFlag = Boolean.TRUE; + } + } + checkRepeatMap.put(priceExcel.getClient() + priceExcel.getBrand(), priceExcel.getClient() + priceExcel.getBrand()); + Boolean templateFlag = Boolean.FALSE; + if (StrUtil.isEmpty(priceExcel.getTemplateName())) { + rowMessage.append("模板名称不能为空；"); + } else { + if (!templateEntityMap.containsKey(priceExcel.getTemplateName())) { + rowMessage.append("模板名称[").append(priceExcel.getTemplateName()).append("]在系统中不存在；"); + } else { + templateFlag = Boolean.TRUE; + } + } + if (brandFlag && templateFlag) { + if (!ObjectUtil.equal(brandEntityMap.get(priceExcel.getBrand()).getId(), templateEntityMap.get(priceExcel.getTemplateName()).getBrandId())) { + rowMessage.append("品牌名称[").append(priceExcel.getBrand()).append("]与模板对应的品牌").append("不相同，请填写对应品牌的模板；"); + } + } + if (!ObjectUtil.isAllEmpty(priceExcel.getClient(), priceExcel.getBrand())) { + if (!clientBrandMap.containsKey(priceExcel.getClient() + priceExcel.getBrand())) { + rowMessage.append("客户名称[").append(priceExcel.getClient()).append("]下不存在品牌名称[").append(priceExcel.getBrand()).append("]，请维护客户和品牌的关系；"); + } + } + DateTime startTime = null; + if (StrUtil.isNotEmpty(priceExcel.getEffectiveTime())) { + // 校验是否为日期格式 + try { + startTime = DateUtil.parseDate(priceExcel.getEffectiveTime()); + } catch (Exception e) { + rowMessage.append("生效时间格式错误,例:2020-01-01；"); + } + } else { + rowMessage.append("生效时间不能为空"); + } + if (ObjectUtil.isNotEmpty(startTime)) { + // 校验时间是否合法 + // 1 输入的开始时间不能小于明天的开始时间 + + // 2 当前输入的时间范围不能跨越2个已有的价格体系 + if (clientFlag && brandFlag) { + List priceEntities = checkPriceEntityMap.get(priceExcel.getClient() + priceExcel.getBrand()); + if (CollUtil.isNotEmpty(priceEntities)) { + for (BasicdataPriceEntity priceEntity : priceEntities) { + LocalDateTime now = DateUtil.date().toLocalDateTime(); + LocalDateTime todayEnd = now.truncatedTo(ChronoUnit.DAYS).plusDays(1).minusSeconds(1); + if (startTime.isBefore(DateUtil.date(todayEnd))) { + // 开始时间在明天之前 + // 开始时间 = 生效中的价格体系的开始时间 + if (startTime.equals(priceEntity.getEffectiveTime())) { + // 把存在交集的价格体系放到内存中供后续使用 + if (!ObjectUtil.isAllEmpty(priceExcel.getClient(), priceExcel.getBrand())) { + priceEntityMap.put(priceExcel.getClient() + priceExcel.getBrand(), priceEntity); + } + } else { + rowMessage.append("已经存在生效时间小于当前时间的数据；"); + } + } else { + // 开始时间在明天之后 判断开始时间是否存在，存在则修改，不存在则新增 + if (startTime.equals(priceEntity.getEffectiveTime())) { + // 把存在交集的价格体系放到内存中供后续使用 + if (!ObjectUtil.isAllEmpty(priceExcel.getClient(), priceExcel.getBrand())) { + priceEntityMap.put(priceExcel.getClient() + priceExcel.getBrand(), priceEntity); + } + } + } + } + } + } + } + buildErrorMessageExcel(message, rowMessage, firstMessage); + } + if (StrUtil.isEmpty(message.toString())) { + if (CollUtil.isNotEmpty(checkRepeatMap) && !ObjectUtil.equal(priceExcels.size(), checkRepeatMap.size())) { + message.append(sheet1).append("中存在 客户名称+品牌 重复的数据，请检查；"); + } + } + } } @@ -4157,6 +5742,7 @@ public class BasicdataPriceServiceImpl extends BaseServiceImpl