package com.huaheng.pc.receipt.receiptContainerHeader.service; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.huaheng.common.utils.Wrappers; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.huaheng.common.constant.QuantityConstant; import com.huaheng.common.exception.service.ServiceException; import com.huaheng.common.utils.StringUtils; import com.huaheng.common.utils.http.HttpUtils; import com.huaheng.common.utils.security.ShiroUtils; import com.huaheng.framework.web.domain.AjaxResult; import com.huaheng.framework.web.service.ConfigService; import com.huaheng.mobile.receipt.ReceiptBill; import com.huaheng.pc.config.address.domain.Address; import com.huaheng.pc.config.address.service.AddressService; import com.huaheng.pc.config.company.domain.CompanyU8; import com.huaheng.pc.config.company.service.CompanyU8Service; import com.huaheng.pc.config.configValue.domain.ConfigValue; import com.huaheng.pc.config.configValue.mapper.ConfigValueMapper; import com.huaheng.pc.config.configValue.service.ConfigValueService; import com.huaheng.pc.config.container.domain.Container; import com.huaheng.pc.config.container.service.ContainerService; import com.huaheng.pc.config.location.domain.Location; import com.huaheng.pc.config.location.service.LocationService; import com.huaheng.pc.config.material.domain.Material; import com.huaheng.pc.config.material.service.MaterialService; import com.huaheng.pc.config.receiptPreference.domain.ReceiptPreference; import com.huaheng.pc.config.receiptPreference.mapper.ReceiptPreferenceMapper; import com.huaheng.pc.inventory.inventoryDetail.domain.InventoryDetail; import com.huaheng.pc.inventory.inventoryDetail.service.InventoryDetailService; import com.huaheng.pc.receipt.receiptContainerDetail.domain.ReceiptContainerDetail; import com.huaheng.pc.receipt.receiptContainerDetail.service.ReceiptContainerDetailService; import com.huaheng.pc.receipt.receiptContainerHeader.domain.ReceiptContainerHeader; import com.huaheng.pc.receipt.receiptContainerHeader.domain.ReceiptContainerView; import com.huaheng.pc.receipt.receiptContainerHeader.mapper.ReceiptContainerHeaderMapper; import com.huaheng.pc.receipt.receiptDetail.domain.ReceiptDetail; import com.huaheng.pc.receipt.receiptDetail.service.ReceiptDetailService; import com.huaheng.pc.receipt.receiptHeader.domain.ReceiptHeader; import com.huaheng.pc.receipt.receiptHeader.service.ReceiptHeaderService; import com.huaheng.pc.receipt.receiving.domain.ReceivingDamain; import com.huaheng.pc.shipment.shipmentContainerHeader.domain.ShipmentContainerHeader; import com.huaheng.pc.shipment.shipmentContainerHeader.service.ShipmentContainerHeaderService; import com.huaheng.pc.srm.service.FinishedProductService; import com.huaheng.pc.task.taskHeader.domain.TaskHeader; import com.huaheng.pc.task.taskHeader.service.TaskHeaderService; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import javax.annotation.Resource; import java.math.BigDecimal; import java.text.MessageFormat; import java.util.*; /** * @author huaheng */ @Service public class ReceiptContainerHeaderServiceImpl extends ServiceImpl<ReceiptContainerHeaderMapper, ReceiptContainerHeader> implements ReceiptContainerHeaderService{ @Resource private TaskHeaderService taskHeaderService; @Resource private LocationService locationService; @Resource private ReceiptDetailService receiptDetailService; @Resource private ReceiptContainerDetailService receiptContainerDetailService; @Resource private MaterialService materialService; @Resource private ContainerService containerService; @Resource private ReceiptHeaderService receiptHeaderService; @Resource private InventoryDetailService inventoryDetailService; @Resource private ReceiptPreferenceMapper receiptPreferenceMapper; @Resource private ConfigValueMapper configValueMapper; @Resource private ConfigService configService; @Resource private ShipmentContainerHeaderService shipmentContainerHeaderService; @Resource private CompanyU8Service companyU8Service; @Resource private FinishedProductService finishedProductService; /** * 保存入库组盘 * param receiptCode 入库单编码 * param containerCode 容器编码 * param receiptDetailId 入库单详情id * param locationCode 库位编码 * param qty 收货数量 * param locatingRule 定位规则 * @return 是否保存成功 */ @Override @Transactional(rollbackFor = Exception.class) public AjaxResult saveContainer(ReceiptContainerView receivingDamain) { String receiptCode=receivingDamain.getReceiptCode(); String containerCode=receivingDamain.getContainerCode(); Integer receiptDetailId=receivingDamain.getReceiptDetailId(); String locationCode=receivingDamain.getLocationCode(); BigDecimal qty=receivingDamain.getQty(); String locatingRule=receivingDamain.getLocatingRule(); ReceiptDetail detail = receiptDetailService.getById(receiptDetailId); BigDecimal receiptQty = detail.getQty().subtract(detail.getTaskQty()); if(receiptQty.compareTo(qty) < 0) { return AjaxResult.error("入库明细可用数量"+receiptQty+",收货数量"+qty+";不允许超收"); } //检查容器编码合法性 Integer taskType = checkContainer(containerCode, detail.getMaterialCode()); switch (taskType){ case 1: //创建临时容器 // containerCode = createContainer(); // taskType = QuantityConstant.TASK_TYPE_WHOLERECEIPT; throw new ServiceException("没有容器"); case 2: throw new ServiceException("该物料不能放在这个容器上,请检查该物料是否可以混放"); default: if (taskType == 0){ throw new ServiceException("容器状态未知"); } break; } /*if (taskType == 1) { throw new ServiceException("没有容器"); } else if (taskType == 2) { throw new ServiceException("该物料不能放在这个容器上,请检查该物料是否可以混放"); } else { if (taskType == 0){ throw new ServiceException("容器状态未知"); } }*/ if (QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT == taskType.intValue()) { Container container = containerService.getContainerByCode(containerCode); if (StringUtils.isNotNull(container) && StringUtils.isNotEmpty(container.getLocationCode())) { locationCode = container.getLocationCode(); } } //检查库位编码合法性 checkLocationCode(locationCode, containerCode, taskType); int unCompleteCombineNumber = shipmentContainerHeaderService.getUnCompleteCombineNumber(containerCode); if(unCompleteCombineNumber > 0) { throw new ServiceException("该托盘已经用于出库组盘"); } /* 新建保存组盘头表记录*/ //根据容器编码查询组盘表头记录 LambdaQueryWrapper<ReceiptContainerHeader> lambda = Wrappers.lambdaQuery(); lambda.eq(ReceiptContainerHeader::getContainerCode, containerCode) .eq(ReceiptContainerHeader::getStatus, QuantityConstant.RECEIPT_CONTAINER_TASK); lambda.last("limit 1"); ReceiptContainerHeader receiptContainerHeader = this.getOne(lambda); // ReceiptContainerHeader receiptContainerHeader = new ReceiptContainerHeader(); //当size大于等于1表示容器已经有组盘了 if (receiptContainerHeader==null){ ReceiptDetail receiptDetail = receiptDetailService.getById(receiptDetailId); // 创建组盘头表 receiptContainerHeader=createReceiptContainerHeader(receiptContainerHeader,containerCode,locationCode,receiptDetail,taskType,locatingRule); if (!this.save(receiptContainerHeader)){ throw new ServiceException("入库组盘头表保存失败"); } } else { // receiptContainerHeader = list.get(0); if (receiptContainerHeader.getStatus() > QuantityConstant.RECEIPT_CONTAINER_TASK && receiptContainerHeader.getStatus() < QuantityConstant.RECEIPT_CONTAINER_FINISHED){ throw new ServiceException("容器已经生成任务,不能放物料了!"); } } List<ReceiptContainerHeader> receiptContainerHeaders = this.list(lambda); /* 更新入库单详情的收货数量*/ //根据入库单详情id查询入库详情 ReceiptDetail receiptDetail = receiptDetailService.getById(receiptDetailId); receiptDetail.setId(receiptDetailId); receiptDetail.setTaskQty(qty.add(receiptDetail.getTaskQty())); //更新入库单详情的收货数量 if (!receiptDetailService.updateById(receiptDetail)){ throw new ServiceException("更新入库单详情失败"); } receiptDetail = receiptDetailService.getById(receiptDetailId); //save组盘明细 receiptContainerDetailAdd(receiptContainerHeaders.get(0), receiptDetail, qty, containerCode, locationCode); //如果单据数量等于已收数量,更新入库详情状态和入库单状态 if (receiptDetail.getQty().compareTo(receiptDetail.getTaskQty()) == 0){ if (StringUtils.isNotEmpty(locationCode)){ receiptDetail.setProcessStamp(QuantityConstant.RECEIPT_HEADER_POSITION.toString()); } else { receiptDetail.setProcessStamp(QuantityConstant.RECEIPT_HEADER_RECEIVING.toString()); } if (!receiptDetailService.updateById(receiptDetail)){ throw new ServiceException("更新入库详情处理标记失败"); } ReceiptDetail receiptDetail1 = receiptDetailService.queryflow(receiptDetail); if (!receiptDetailService.updateById(receiptDetail1)){ throw new ServiceException("更新入库详情下一流程失败"); } } receiptDetailService.updateReceiptHeaderLastStatus(receiptDetail.getReceiptId()); return AjaxResult.success("组盘成功"); } public ReceiptContainerHeader createReceiptContainerHeader(ReceiptContainerHeader receiptContainerHeader ,String containerCode,String locationCode,ReceiptDetail receiptDetail,Integer taskType,String locatingRule){ receiptContainerHeader=new ReceiptContainerHeader(); receiptContainerHeader.setWarehouseCode(ShiroUtils.getWarehouseCode()); receiptContainerHeader.setCompanyCode(receiptDetail.getCompanyCode()); receiptContainerHeader.setContainerCode(containerCode); Container container = containerService.getContainerByCode(containerCode); receiptContainerHeader.setContainerType(container.getContainerType()); receiptContainerHeader.setTaskType(taskType); //判断地面托盘 if("D".equals(container.getContainerType())){ receiptContainerHeader.setToLocation(container.getLocationCode()); receiptContainerHeader.setFromLocation(container.getLocationCode()); taskType = QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT; } if(ShiroUtils.getWarehouseCode().equals(QuantityConstant.WAREHOUSE_KS)){ //U8工单领料齐套验证 ksCheckMesReceipt(receiptDetail); } if (taskType.equals(QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT)) { receiptContainerHeader.setFromLocation(container.getLocationCode()); String value = configService.getKey(QuantityConstant.RULE_TASK_LOCATION); int taskLocationRule = Integer.parseInt(value); if (taskLocationRule == QuantityConstant.RULE_TASK_SET_LOCATION) { receiptContainerHeader.setToLocation(container.getLocationCode()); } } else { receiptContainerHeader.setPort("P1004"); receiptContainerHeader.setToLocation(locationCode); } receiptContainerHeader.setProjectNo(receiptDetail.getProjectNo()); receiptContainerHeader.setCreatedBy(ShiroUtils.getLoginName()); receiptContainerHeader.setLastUpdatedBy(ShiroUtils.getLoginName()); receiptContainerHeader.setLocatingRule(locatingRule); return receiptContainerHeader; } //U8工单领料齐套验证 public void ksCheckMesReceipt(ReceiptDetail receiptDetail){ ReceiptHeader receiptHeader=receiptHeaderService.getById(receiptDetail.getReceiptId()); if(receiptHeader.getReceiptType().equals("SI")&&StringUtils.isNotEmpty(receiptDetail.getReferLineNum())){ CompanyU8 companyWu = new CompanyU8(); companyWu.setCompanyCode(receiptHeader.getCompanyCode()); companyWu = companyU8Service.getByCode(companyWu); if(companyWu == null){ throw new ServiceException("入库单对应的U8账套不存在"); } Map detailMap = new HashMap(); detailMap.put("MODID",receiptDetail.getReferLineNum()); detailMap.put("iQuantity",receiptDetail.getQty()); detailMap.put("itemcode",receiptDetail.getMaterialCode()); List<Map> maps = new ArrayList<>(); maps.add(detailMap); Map<String,Object> map = new HashMap(); map.put("CompanyCode",companyWu.getUCompanyCode()); map.put("details",maps); AjaxResult ajaxResult = finishedProductService.checkMesReceipt(map); if(ajaxResult.hasErr()){ throw new ServiceException(ajaxResult.getMsg()); } } } /** * 超收检查 * @param detail * @param qty */ private void checkOverReceiving(ReceiptDetail detail, BigDecimal qty){ BigDecimal _total = detail.getTaskQty().add(qty); if(_total.compareTo(detail.getQty()) <= 0){ //收货量<=明细总量 return; } ConfigValue configValue = configValueMapper.getConfigValue(ShiroUtils.getWarehouseCode(), "receipt"); ReceiptPreference preference = receiptPreferenceMapper.getReceiptPreference(ShiroUtils.getWarehouseCode(),configValue.getValue()); if(!preference.getAllowOverReceiving()){ //入库首选项配置为不允许超收 throw new ServiceException(String.format("不允许超收")); } //超收比例 BigDecimal _over_rate = new BigDecimal(String.valueOf(1 + preference.getAllowOverReceivingQty() / 100.0)); //超收量上限 BigDecimal _total_over = detail.getQty().multiply (_over_rate); if(_total_over.compareTo(_total) >= 0){ //在入库首选项的超收范围内 return; } //超过了入库首选项配置的超收比例 throw new ServiceException(String.format("超收上限是: %s%", _over_rate.multiply(new BigDecimal(100)) )); } /** * 批量撤销入库组盘 * @param ids 容器头表标识列表 * @return true 全部取消成功 */ @Override @Transactional(rollbackFor = Exception.class) public Boolean cancelByIds(List<Integer> ids) { for (Integer id : ids) { //如果已生成任务则不允许取消组盘 if (this.getById(id).getStatus() < QuantityConstant.RECEIPT_CONTAINER_TASK){ //根据组盘头表id查询组盘明细表 LambdaQueryWrapper<ReceiptContainerDetail> containerDetailLambda = Wrappers.lambdaQuery(); containerDetailLambda.eq(ReceiptContainerDetail::getReceiptContainerId, id); List<ReceiptContainerDetail> receiptContainerDetails = receiptContainerDetailService.list(containerDetailLambda); //查询入库单明细,减去已收数量,更新单据 for (ReceiptContainerDetail receiptContainerDetail: receiptContainerDetails){ ReceiptDetail receiptDetail = receiptDetailService.getById(receiptContainerDetail.getReceiptDetailId()); receiptDetail.setTaskQty(receiptDetail.getTaskQty().subtract(receiptContainerDetail.getQty())); if (!receiptDetailService.updateById(receiptDetail)){throw new ServiceException("回滚入库明细失败"); } containerDetailLambda = Wrappers.lambdaQuery(); containerDetailLambda.eq(ReceiptContainerDetail::getReceiptId, receiptContainerDetail.getReceiptId()); List<ReceiptContainerDetail> containerDetailList = receiptContainerDetailService.list(containerDetailLambda); //如果是临时容器,取消组盘时删除容器表 containerService.removeContainer(receiptContainerDetail.getContainerType(), receiptContainerDetail.getContainerCode()); //如果入库组盘没有该入库单的组盘信息,回滚入库单状态 if (containerDetailList == null){ ReceiptHeader receiptHeader = new ReceiptHeader(); receiptHeader.setId(receiptContainerDetail.getReceiptId()); receiptHeader.setFirstStatus(QuantityConstant.RECEIPT_HEADER_RECEIVING); receiptHeader.setLastStatus(QuantityConstant.RECEIPT_HEADER_RECEIVING); receiptHeader.setLastUpdatedBy(ShiroUtils.getLoginName()); if (!receiptHeaderService.updateById(receiptHeader)){ throw new ServiceException("回滚头表状态失败"); } } if (!receiptContainerDetailService.removeById(receiptContainerDetail.getId())){ throw new ServiceException("删除入库组盘明细表失败,id是"+receiptContainerDetail.getId()); } } //删除入库组盘头表 if (!this.removeById(id)){ throw new ServiceException("删除入库组盘头表失败"); } } else { throw new ServiceException("已生成任务不允许取消"); } } return true; } /** * 检查容器状态 * * @param record 容器实列 * @return 成功 ;可以使用容器 */ @Override public AjaxResult checkContainer(ReceiptContainerView record) { //容器都是单据SN码,每个入库单都是新增容器 if (com.huaheng.common.utils.StringUtils.isEmpty(record.getContainerCode())) { throw new ServiceException("容器不能为空"); } if (taskHeaderService.UncompleteCount(record.getContainerCode()).intValue() > 0) { throw new ServiceException("容器已经存在任务,请更换容器"); } return AjaxResult.success(""); } @Override public AjaxResult batchSave(List<ReceiptContainerView> list) { if (list.size() < 1) { throw new ServiceException("收货明细是空!"); } checkContainer(list.get(0)); AjaxResult ajaxResult = null; for (ReceiptContainerView receiptContainerView : list) { /* ReceivingDamain receivingDamain=new ReceivingDamain(); com.huaheng.common.utils.bean.BeanUtils.copyBeanProp(receivingDamain, receiptContainerView); receivingDamain.setContainerCode(receiptContainerView.getReceiptContainerCode());*/ ajaxResult = saveContainer(receiptContainerView); } return ajaxResult; } /** * 移动端校验库位 * @param record * @return */ @Override public Boolean mobileCheckLocationCode(ReceiptContainerView record) { return checkLocationCode(record.getLocationCode(), record.getContainerCode(), Integer.valueOf(record.getTaskType())); } /** * 检查容器编码合法性 * @param containerCode 容器编码 * @param materialCode 物料编码 * @return 返回容器状态,如果需自动生成容器编码返回1 */ @Transactional public Integer checkContainer(String containerCode, String materialCode) { Material material = materialService.getMaterialByCode(materialCode); if (StringUtils.isEmpty(containerCode)){ if (material.getAutoGenSerialNum() == 0){ return 1; //需自动生成容器编码 } else { throw new ServiceException("容器不能为空"); } } /** * 判断物料是否可以放在当前容器 */ if (!material.getIsMix()) { LambdaQueryWrapper<InventoryDetail> queryWrapper = Wrappers.lambdaQuery(); queryWrapper.eq(InventoryDetail::getContainerCode, containerCode); /* 该容器已存物料数*/ int inventoryDetailCount = inventoryDetailService.count(queryWrapper); LambdaQueryWrapper<InventoryDetail> lambdaQueryWrapper = Wrappers.lambdaQuery(); lambdaQueryWrapper.eq(InventoryDetail::getContainerCode, containerCode) .eq(InventoryDetail::getMaterialCode, materialCode); /* 该容器存放该物料的记录数*/ int inventoryDetailMaterialCount = inventoryDetailService.count(lambdaQueryWrapper); /* 存放多种物料时返回*/ if (inventoryDetailCount != inventoryDetailMaterialCount) { return 2; } } LambdaQueryWrapper<Container> lambda = Wrappers.lambdaQuery(); lambda.eq(Container::getCode, containerCode); lambda.eq(Container::getWarehouseCode, ShiroUtils.getWarehouseCode()); Container container = containerService.getOne(lambda); if (container == null){ throw new ServiceException("该容器编号不存在"); } if (container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_LOCK)){ // throw new ServiceException("容器已经锁定,不能再组盘"); } //检查该容器编码是否已存任务 LambdaQueryWrapper<TaskHeader> lambdaQueryWrapper = Wrappers.lambdaQuery(); lambdaQueryWrapper.eq(TaskHeader::getContainerCode, containerCode) .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED) .ge(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_RELEASE) .eq(TaskHeader::getWarehouseCode, ShiroUtils.getWarehouseCode()); if (taskHeaderService.count(lambdaQueryWrapper) > 0){ throw new ServiceException("容器已经存在任务,请更换容器"); } if (StringUtils.isEmpty(container.getLocationCode())){ return QuantityConstant.TASK_TYPE_WHOLERECEIPT; }else if (StringUtils.isNotEmpty(container.getStatus()) &&(container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_EMPTY) ||container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_SOME))) { return QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT; } else if (QuantityConstant.STATUS_CONTAINER_FULL.equals(container.getStatus())) { throw new ServiceException("该容器已满,请更换容器"); }else if (StringUtils.isNotEmpty(container.getStatus()) &&container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_LOCK)){ LambdaQueryWrapper<TaskHeader> lambdaQuery = Wrappers.lambdaQuery(); lambdaQuery.lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED); lambdaQuery.eq(TaskHeader::getInternalTaskType,100); lambdaQuery.last("limit 1"); lambdaQuery.orderByDesc(TaskHeader::getId); TaskHeader taskHeader=taskHeaderService.getOne(lambdaQuery); if(taskHeader!=null){ return taskHeader.getTaskType(); } } return 0; } /** * 检查库位是否合法 * @param locationCode 库位编码 * @param containerCode 容器编码 * @param taskType 任务类型 * @return */ @Transactional Boolean checkLocationCode(String locationCode, String containerCode, Integer taskType) { //如果选了库位,就要校验库位和已经组盘的库位是否一致,避免重入库 if (StringUtils.isEmpty(locationCode)) { if (QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT == taskType.intValue()) { throw new ServiceException("补充入库,必须填写库位"); } else { return true; } } Location location = locationService.getLocationByCode(locationCode, ShiroUtils.getWarehouseCode()); if (location == null) { throw new ServiceException("库位不存在!"); } if (!QuantityConstant.STATUS_LOCATION_EMPTY.equals(location.getStatus()) ) { // throw new ServiceException("库位不是空闲状态!"); } if (QuantityConstant.TASK_TYPE_WHOLERECEIPT == taskType.intValue()) { if (StringUtils.isNotEmpty(location.getContainerCode())) { throw new ServiceException("库位(" + locationCode + ")有容器(" + location.getContainerCode() + "),不能整盘入库!"); } } if(QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT== taskType.intValue()) { if (StringUtils.isEmpty(location.getContainerCode())){ throw new ServiceException("库位(" + locationCode + ")没有容器,不能补充入库!"); } else if (!location.getContainerCode().equals(containerCode)) { throw new ServiceException("库位(" + containerCode + ")对应的容器是:" + location.getContainerCode()+ ",请重选库位!"); } } return true; } /** * 增加组盘明细记录 * @param * @param receiptDetail 入库详情 * @param qty 收货数量 * @param containerCode 容器编码 */ @Transactional public void receiptContainerDetailAdd(ReceiptContainerHeader receiptContainerHeader, ReceiptDetail receiptDetail, BigDecimal qty, String containerCode, String locationCode){ int receiptContainerHeaderId = receiptContainerHeader.getId(); LambdaQueryWrapper<ReceiptContainerDetail> lambda = Wrappers.lambdaQuery(); lambda.eq(ReceiptContainerDetail::getReceiptContainerId, receiptContainerHeaderId) .eq(ReceiptContainerDetail::getReceiptId, receiptDetail.getReceiptId()) .eq(ReceiptContainerDetail::getReceiptDetailId, receiptDetail.getId()) .last("Limit 1"); ReceiptContainerDetail receiptContainerDetail = receiptContainerDetailService.getOne(lambda); //查询容器 LambdaQueryWrapper<Container> containerLambda = Wrappers.lambdaQuery(); containerLambda.eq(Container::getCode, containerCode) .eq(Container::getWarehouseCode, ShiroUtils.getWarehouseCode()); Container container = containerService.getOne(containerLambda); if (receiptContainerDetail == null){ //查询入库头表 LambdaQueryWrapper<ReceiptHeader> receiptHeaderLambda = Wrappers.lambdaQuery(); receiptHeaderLambda.eq(ReceiptHeader::getId, receiptDetail.getReceiptId()) .eq(ReceiptHeader::getCode, receiptDetail.getReceiptCode()); ReceiptHeader receiptHeader = receiptHeaderService.getOne(receiptHeaderLambda); receiptContainerDetail = new ReceiptContainerDetail(); receiptContainerDetail.setReceiptContainerId(receiptContainerHeaderId); receiptContainerDetail.setWarehouseCode(ShiroUtils.getWarehouseCode()); receiptContainerDetail.setReceiptId(receiptDetail.getReceiptId()); receiptContainerDetail.setReceiptDetailId(receiptDetail.getId()); receiptContainerDetail.setTaskType(receiptContainerHeader.getTaskType()); receiptContainerDetail.setReceiptCode(receiptDetail.getReceiptCode()); receiptContainerDetail.setReceiptType(receiptHeader.getReceiptType()); receiptContainerDetail.setLocationCode(locationCode); receiptContainerDetail.setContainerCode(container.getCode()); receiptContainerDetail.setContainerType(container.getContainerType()); receiptContainerDetail.setCompanyCode(receiptDetail.getCompanyCode()); receiptContainerDetail.setMaterialCode(receiptDetail.getMaterialCode()); receiptContainerDetail.setMaterialName(receiptDetail.getMaterialName()); receiptContainerDetail.setMaterialSpec(receiptDetail.getMaterialSpec()); receiptContainerDetail.setMaterialUnit(receiptDetail.getMaterialUnit()); receiptContainerDetail.setQty(qty); receiptContainerDetail.setSupplierCode(receiptDetail.getSupplierCode()); receiptContainerDetail.setBatch(receiptDetail.getBatch()); receiptContainerDetail.setLot(receiptDetail.getLot()); receiptContainerDetail.setProjectNo(receiptDetail.getProjectNo()); receiptContainerDetail.setManufactureDate(receiptDetail.getManufactureDate()); receiptContainerDetail.setExpirationDate(receiptDetail.getExpirationDate()); receiptContainerDetail.setAgingDate(receiptDetail.getAgingDate()); receiptContainerDetail.setInventorySts(receiptDetail.getInventorySts()); receiptContainerDetail.setCreatedBy(ShiroUtils.getLoginName()); receiptContainerDetail.setLastUpdatedBy(ShiroUtils.getLoginName()); receiptContainerDetail.setSyncMms(0); receiptContainerDetail.setZoneCode(container.getZoneCode()); if (!receiptContainerDetailService.save(receiptContainerDetail)){ throw new ServiceException("保存入库组盘详情失败"); } } else { receiptContainerDetail.setQty(receiptContainerDetail.getQty().add(qty)); receiptContainerDetail.setZoneCode(container.getZoneCode()); if (!receiptContainerDetailService.updateById(receiptContainerDetail)){ throw new ServiceException("更新入库组盘详情失败"); } } } /** * 自动生成容器编码 * @return 容器编码 */ @Transactional public String createContainer(){ String code = MessageFormat.format("{0}{1}", "LS", String.format("%d", Calendar.getInstance().getTimeInMillis())); Container container = new Container(); container.setCode(code); container.setWarehouseCode(ShiroUtils.getWarehouseCode()); container.setCompanyCode(ShiroUtils.getCompanyCodeList().get(0)); container.setContainerType("LS"); container.setCreatedBy(ShiroUtils.getLoginName()); container.setLastUpdated(new Date()); container.setLastUpdatedBy(ShiroUtils.getLoginName()); container.setEnable(true); container.setStatus(QuantityConstant.STATUS_CONTAINER_EMPTY); if (!containerService.save(container)){ throw new ServiceException("新增容器失败"); } return code; } @Override @Transactional public int insertTodayReceiptContainerHeader(ReceiptBill receiptBill, String receiptCode) { String receiptContainerCode = receiptBill.getReceiptContainerCode(); String locationCode = receiptBill.getLocationCode(); String companyCode = receiptBill.getCompanyCode(); ReceiptContainerHeader recorder = new ReceiptContainerHeader(); recorder.setContainerCode(receiptContainerCode); recorder.setToLocation(locationCode); recorder.setWarehouseCode(ShiroUtils.getWarehouseCode()); recorder.setCompanyCode(companyCode); recorder.setTaskType(QuantityConstant.TASK_TYPE_WHOLERECEIPT); recorder.setStatus(QuantityConstant.RECEIPT_CONTAINER_BUILD); recorder.setCreatedBy(ShiroUtils.getLoginName()); recorder.setLastUpdatedBy(ShiroUtils.getLoginName()); LambdaQueryWrapper<ReceiptContainerHeader> receiptContainerHeaderLambada = Wrappers.lambdaQuery(); receiptContainerHeaderLambada.eq(ReceiptContainerHeader::getContainerCode, receiptContainerCode) .eq(ReceiptContainerHeader::getCompanyCode, companyCode) .eq(ReceiptContainerHeader::getTaskType, String.valueOf(QuantityConstant.TASK_TYPE_WHOLERECEIPT)) .eq(ReceiptContainerHeader::getStatus, 0); ReceiptContainerHeader receiptContainerHeader = getOne(receiptContainerHeaderLambada); if(receiptContainerHeader == null) { save(recorder); } else { return receiptContainerHeader.getId(); } locationService.updateStatus(locationCode, QuantityConstant.STATUS_LOCATION_LOCK); containerService.updateLocationCodeAndStatus(receiptContainerCode, locationCode, QuantityConstant.STATUS_CONTAINER_SOME); return recorder.getId(); } /** * 取消入库任务 * @param id 入库组盘头id * @return */ @Override @Transactional public AjaxResult cancelReceipt(Integer id) { /** * 回滚组盘主表状态 */ ReceiptContainerHeader receiptContainerHeader = new ReceiptContainerHeader(); receiptContainerHeader.setStatus(QuantityConstant.RECEIPT_CONTAINER_BUILD); receiptContainerHeader.setId(id); if (!updateById(receiptContainerHeader)){ throw new ServiceException("回滚入库组盘头表失败"); } /** * 回滚组盘明细状态 */ LambdaQueryWrapper<ReceiptContainerDetail> lambdaQueryWrapper = Wrappers.lambdaQuery(); lambdaQueryWrapper.eq(ReceiptContainerDetail::getReceiptContainerId, id); List<ReceiptContainerDetail> containerDetailList = receiptContainerDetailService.list(lambdaQueryWrapper); for (ReceiptContainerDetail containerDetail : containerDetailList) { containerDetail.setStatus(QuantityConstant.RECEIPT_CONTAINER_BUILD); } if (!receiptContainerDetailService.updateBatchById(containerDetailList)) { throw new ServiceException("回滚入库组盘明细失败"); } /** * 回滚入库单头表、入库单明细状态 */ for (ReceiptContainerDetail containerDetail : containerDetailList) { ReceiptHeader receiptHeader = receiptHeaderService.getById(containerDetail.getReceiptId()); receiptHeader.setLastStatus(QuantityConstant.RECEIPT_HEADER_WAIT); ReceiptDetail receiptDetail = receiptDetailService.getById(containerDetail.getReceiptDetailId()); receiptDetail.setProcessStamp(String.valueOf(QuantityConstant.RECEIPT_HEADER_WAIT)); if (!receiptHeaderService.updateById(receiptHeader)) { throw new ServiceException("回滚入库单头表失败"); } if (!receiptDetailService.updateById(receiptDetail)) { throw new ServiceException("回滚入库单明细失败"); } } return AjaxResult.success("成功"); } @Override public int getUnCompleteCombineNumber(String containerCode) { LambdaQueryWrapper<ReceiptContainerHeader> receiptContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery(); receiptContainerHeaderLambdaQueryWrapper.eq(ReceiptContainerHeader::getContainerCode, containerCode) .lt(ReceiptContainerHeader::getStatus, QuantityConstant.RECEIPT_CONTAINER_FINISHED); int number = 0; List<ReceiptContainerHeader> receiptContainerHeaderList = list(receiptContainerHeaderLambdaQueryWrapper); if(receiptContainerHeaderList != null && receiptContainerHeaderList.size() > 0) { number = receiptContainerHeaderList.size(); } return number; } @Override public List<ReceiptContainerHeader> getUnCompleteCombineList() { LambdaQueryWrapper<ReceiptContainerHeader> receiptContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery(); receiptContainerHeaderLambdaQueryWrapper .lt(ReceiptContainerHeader::getStatus, QuantityConstant.RECEIPT_CONTAINER_FINISHED); List<ReceiptContainerHeader> receiptContainerHeaderList = list(receiptContainerHeaderLambdaQueryWrapper); return receiptContainerHeaderList; } @Override public AjaxResult clearContainerHeader(){ LambdaQueryWrapper<ReceiptContainerHeader> receiptContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery(); receiptContainerHeaderLambdaQueryWrapper.eq(ReceiptContainerHeader::getStatus, QuantityConstant.RECEIPT_CONTAINER_BUILD); List<ReceiptContainerHeader> receiptContainerHeaderList = this.list(receiptContainerHeaderLambdaQueryWrapper); for(ReceiptContainerHeader receiptContainerHeader : receiptContainerHeaderList) { Date date = receiptContainerHeader.getCreated(); Date now = new Date(); int fore = date.getDay(); int day = now.getDay(); if(fore != day) { this.removeById(receiptContainerHeader); } } LambdaQueryWrapper<ReceiptContainerHeader> receiptContainerHeaderLambdaQueryWrapper1 = Wrappers.lambdaQuery(); receiptContainerHeaderLambdaQueryWrapper1.eq(ReceiptContainerHeader::getStatus, QuantityConstant.RECEIPT_CONTAINER_TASK); List<ReceiptContainerHeader> receiptContainerHeaderList1 = this.list(receiptContainerHeaderLambdaQueryWrapper1); for(ReceiptContainerHeader receiptContainerHeader : receiptContainerHeaderList1) { String containerCode = receiptContainerHeader.getContainerCode(); LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery(); taskHeaderLambdaQueryWrapper.lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED) .in(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_WHOLERECEIPT, QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT) .eq(TaskHeader::getContainerCode, containerCode); List<TaskHeader> taskHeaderList = taskHeaderService.list(taskHeaderLambdaQueryWrapper); if(taskHeaderList.size() == 0) { receiptContainerHeader.setStatus(QuantityConstant.RECEIPT_CONTAINER_FINISHED); this.updateById(receiptContainerHeader); } } LambdaQueryWrapper<ShipmentContainerHeader> shipmentContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery(); shipmentContainerHeaderLambdaQueryWrapper.eq(ShipmentContainerHeader::getStatus, QuantityConstant.SHIPMENT_CONTAINER_BUILD); List<ShipmentContainerHeader> shipmentContainerHeaderList = shipmentContainerHeaderService.list(shipmentContainerHeaderLambdaQueryWrapper); for(ShipmentContainerHeader shipmentContainerHeader : shipmentContainerHeaderList) { Date date = shipmentContainerHeader.getCreated(); Date now = new Date(); int fore = date.getDay(); int day = now.getDay(); if(fore != day) { shipmentContainerHeaderService.removeById(shipmentContainerHeader); } } LambdaQueryWrapper<ShipmentContainerHeader> shipmentContainerHeaderLambdaQueryWrapper1 = Wrappers.lambdaQuery(); shipmentContainerHeaderLambdaQueryWrapper1.eq(ShipmentContainerHeader::getStatus, QuantityConstant.SHIPMENT_CONTAINER_TASK); List<ShipmentContainerHeader> shipmentContainerHeaderList1 = shipmentContainerHeaderService.list(shipmentContainerHeaderLambdaQueryWrapper1); for(ShipmentContainerHeader shipmentContainerHeader : shipmentContainerHeaderList1) { String containerCode = shipmentContainerHeader.getContainerCode(); LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery(); taskHeaderLambdaQueryWrapper.lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED) .in(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_WHOLESHIPMENT, QuantityConstant.TASK_TYPE_SORTINGSHIPMENT) .eq(TaskHeader::getContainerCode, containerCode); List<TaskHeader> taskHeaderList = taskHeaderService.list(taskHeaderLambdaQueryWrapper); if(taskHeaderList.size() == 0) { shipmentContainerHeader.setStatus(QuantityConstant.SHIPMENT_CONTAINER_FINISHED); shipmentContainerHeaderService.updateById(shipmentContainerHeader); } } return AjaxResult.success(); } }