|
|
package com.glxp.api.service.collect;
|
|
|
|
|
|
import cn.hutool.core.bean.BeanUtil;
|
|
|
import cn.hutool.core.collection.CollUtil;
|
|
|
import cn.hutool.core.lang.Assert;
|
|
|
import cn.hutool.core.thread.ThreadUtil;
|
|
|
import cn.hutool.core.util.IdUtil;
|
|
|
import cn.hutool.core.util.StrUtil;
|
|
|
import com.alibaba.fastjson.JSONObject;
|
|
|
import com.alibaba.fastjson.TypeReference;
|
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
|
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
|
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
|
|
import com.github.pagehelper.PageHelper;
|
|
|
import com.glxp.api.common.res.BaseResponse;
|
|
|
import com.glxp.api.common.util.ResultVOUtils;
|
|
|
import com.glxp.api.constant.Constant;
|
|
|
import com.glxp.api.constant.ConstantStatus;
|
|
|
import com.glxp.api.constant.ConstantType;
|
|
|
import com.glxp.api.dao.collect.IoCollectOrderMapper;
|
|
|
import com.glxp.api.dao.inout.IoCodeTempDao;
|
|
|
import com.glxp.api.entity.auth.SysWorkplace;
|
|
|
import com.glxp.api.entity.basic.*;
|
|
|
import com.glxp.api.entity.collect.IoCollectOrder;
|
|
|
import com.glxp.api.entity.collect.IoCollectOrderBiz;
|
|
|
import com.glxp.api.entity.collect.IoCollectOrderCodeAuto;
|
|
|
import com.glxp.api.entity.collect.IoCollectOrderCodeMan;
|
|
|
import com.glxp.api.entity.inout.IoCodeTempEntity;
|
|
|
import com.glxp.api.entity.inout.IoOrderDetailBizEntity;
|
|
|
import com.glxp.api.entity.inout.IoOrderEntity;
|
|
|
import com.glxp.api.entity.inout.IoSplitFifoInv;
|
|
|
import com.glxp.api.entity.inv.InvCountOrderDetailEntity;
|
|
|
import com.glxp.api.entity.inv.InvCountOrderEntity;
|
|
|
import com.glxp.api.entity.inv.InvCountSettingEntity;
|
|
|
import com.glxp.api.entity.thrsys.ThrSystemEntity;
|
|
|
import com.glxp.api.exception.JsonException;
|
|
|
import com.glxp.api.http.ErpBasicClient;
|
|
|
import com.glxp.api.http.HttpOkClient;
|
|
|
import com.glxp.api.req.basic.FilterUdiRelRequest;
|
|
|
import com.glxp.api.req.collect.CollectOrderBizRequest;
|
|
|
import com.glxp.api.req.collect.CollectOrderRequest;
|
|
|
import com.glxp.api.req.collect.PostCollectOrderRequest;
|
|
|
import com.glxp.api.req.inout.DeleteTageCodeRequest;
|
|
|
import com.glxp.api.req.inout.FilterOrderRequest;
|
|
|
import com.glxp.api.req.inout.PostOrderRequest;
|
|
|
import com.glxp.api.res.PageSimpleResponse;
|
|
|
import com.glxp.api.res.basic.BasicSkPrescribeResponse;
|
|
|
import com.glxp.api.res.basic.SysWorkplaceResponse;
|
|
|
import com.glxp.api.res.basic.UdiRelevanceResponse;
|
|
|
import com.glxp.api.res.collect.CollectOrderBizResponse;
|
|
|
import com.glxp.api.res.collect.IoCollectOrderResponse;
|
|
|
import com.glxp.api.res.inout.IoOrderResponse;
|
|
|
import com.glxp.api.res.thrsys.ThrInvProductResponse;
|
|
|
import com.glxp.api.service.auth.SysWorkplaceService;
|
|
|
import com.glxp.api.service.basic.*;
|
|
|
import com.glxp.api.service.inout.*;
|
|
|
import com.glxp.api.service.inout.impl.IoCodeService;
|
|
|
import com.glxp.api.util.*;
|
|
|
import com.glxp.api.util.udi.FilterUdiUtils;
|
|
|
import com.glxp.api.util.udi.UdiCalCountUtil;
|
|
|
import net.sf.jasperreports.engine.util.JRStyledText;
|
|
|
import org.springframework.beans.BeanUtils;
|
|
|
import org.springframework.context.annotation.Lazy;
|
|
|
import org.springframework.stereotype.Service;
|
|
|
import org.springframework.transaction.annotation.Propagation;
|
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
|
|
|
|
import javax.annotation.Resource;
|
|
|
import java.time.LocalDateTime;
|
|
|
import java.util.*;
|
|
|
import java.util.stream.Collectors;
|
|
|
|
|
|
@Service
|
|
|
public class IoCollectOrderService extends ServiceImpl<IoCollectOrderMapper, IoCollectOrder> {
|
|
|
|
|
|
@Resource
|
|
|
IoCollectOrderMapper collectOrderMapper;
|
|
|
@Resource
|
|
|
IoCollectOrderCodeManService ioCollectOrderCodeManService;
|
|
|
@Resource
|
|
|
IoOrderService orderService;
|
|
|
@Resource
|
|
|
IoOrderDetailBizService orderDetailBizService;
|
|
|
@Resource
|
|
|
IoCollectOrderBizService collectOrderBizService;
|
|
|
@Resource
|
|
|
UdiRelevanceService udiRelevanceService;
|
|
|
@Resource
|
|
|
BasicSkPrescribeService basicSkPrescribeService;
|
|
|
@Resource
|
|
|
BasicSkPrescirbeDetailService basicSkPrescirbeDetailService;
|
|
|
@Resource
|
|
|
IoOrderDetailBizService orderDetailCodeService;
|
|
|
@Resource
|
|
|
IoCodeTempService codeTempService;
|
|
|
@Resource
|
|
|
IoCodeService codeService;
|
|
|
@Resource
|
|
|
SysWorkplaceService sysWorkplaceService;
|
|
|
@Resource
|
|
|
SysWorkplaceDocumentService sysWorkplaceDocumentService;
|
|
|
@Resource
|
|
|
IoSplitFifoCodeService splitFifoCodeService;
|
|
|
@Resource
|
|
|
IoCollectOrderCodeAutoService collectOrderCodeAutoService;
|
|
|
@Resource
|
|
|
IoCollectOrderCodeManService collectOrderCodeManService;
|
|
|
@Resource
|
|
|
IoCollectCodeService collectCodeService;
|
|
|
@Resource
|
|
|
UdiCalCountUtil udiCalCountUtil;
|
|
|
@Resource
|
|
|
IBasicBussinessTypeService bussinessTypeService;
|
|
|
@Resource
|
|
|
private GennerOrderUtils gennerOrderUtils;
|
|
|
@Resource
|
|
|
private IoCodeTempDao codesTempDao;
|
|
|
@Resource
|
|
|
IoAddInoutService addInoutService;
|
|
|
@Resource
|
|
|
@Lazy
|
|
|
IoCheckInoutService ioCheckInoutService;
|
|
|
|
|
|
@Resource
|
|
|
private ErpBasicClient erpBasicClient;
|
|
|
@Resource
|
|
|
IoSplitCodeService splitCodeService;
|
|
|
|
|
|
public IoCollectOrder getByBillNo(String billNo) {
|
|
|
return collectOrderMapper.selectOne(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, billNo).last("limit 1"));
|
|
|
}
|
|
|
|
|
|
public int updateByBillNo(IoCollectOrder collectOrder) {
|
|
|
return collectOrderMapper.update(collectOrder, new UpdateWrapper<IoCollectOrder>().eq("billNo", collectOrder.getBillNo()));
|
|
|
}
|
|
|
|
|
|
|
|
|
public List<IoCollectOrderResponse> filterList(CollectOrderRequest collectOrderRequest) {
|
|
|
if (collectOrderRequest == null) {
|
|
|
return Collections.emptyList();
|
|
|
}
|
|
|
if (collectOrderRequest.getPage() != null) {
|
|
|
int offset = (collectOrderRequest.getPage() - 1) * collectOrderRequest.getLimit();
|
|
|
PageHelper.offsetPage(offset, collectOrderRequest.getLimit());
|
|
|
}
|
|
|
List<IoCollectOrderResponse> data = collectOrderMapper.filterList(collectOrderRequest);
|
|
|
return data;
|
|
|
}
|
|
|
|
|
|
|
|
|
public List<CollectOrderBizResponse> combieOrderDetail(CollectOrderBizRequest collectOrderBizRequest) {
|
|
|
List<CollectOrderBizResponse> list = collectOrderBizService.filterList(collectOrderBizRequest);
|
|
|
|
|
|
List<IoCollectOrderCodeAuto> splitCodes = collectOrderCodeAutoService.listByBillNo(collectOrderBizRequest.getOrderIdFk(), 1);
|
|
|
List<IoCollectOrderCodeAuto> unSplitCodes = collectOrderCodeAutoService.listByBillNo(collectOrderBizRequest.getOrderIdFk(), 2);
|
|
|
List<IoCollectOrderCodeMan> manList = collectOrderCodeManService.listByBillNo(collectOrderBizRequest.getOrderIdFk());
|
|
|
|
|
|
List<CollectOrderBizResponse> collectOrderBizResponses = new ArrayList<>();
|
|
|
for (CollectOrderBizResponse collectOrderBiz : list) {
|
|
|
CollectOrderBizResponse collectOrderBizResponse = new CollectOrderBizResponse();
|
|
|
BeanUtils.copyProperties(collectOrderBiz, collectOrderBizResponse);
|
|
|
//拆零
|
|
|
for (IoCollectOrderCodeAuto collectOrderCodeAuto : splitCodes) {
|
|
|
if (IntUtil.value(collectOrderCodeAuto.getBizIdFk()) == IntUtil.value(collectOrderBiz.getId())) {
|
|
|
collectOrderBizResponse.setSplitUdiCode(StrUtil.trimToEmpty(collectOrderBizResponse.getSplitUdiCode()) + "," + collectOrderCodeAuto.getUdiCode());
|
|
|
}
|
|
|
}
|
|
|
if (StrUtil.isNotEmpty(collectOrderBizResponse.getSplitUdiCode())) {
|
|
|
collectOrderBizResponse.setSplitUdiCode(collectOrderBizResponse.getSplitUdiCode().substring(1));
|
|
|
}
|
|
|
//整取
|
|
|
for (IoCollectOrderCodeAuto collectOrderCodeAuto : unSplitCodes) {
|
|
|
if (IntUtil.value(collectOrderCodeAuto.getBizIdFk()) == IntUtil.value(collectOrderBiz.getId())) {
|
|
|
collectOrderBizResponse.setUnSplitUdiCode(StrUtil.trimToEmpty(collectOrderBizResponse.getUnSplitUdiCode()) + "," + collectOrderCodeAuto.getUdiCode());
|
|
|
}
|
|
|
}
|
|
|
if (StrUtil.isNotEmpty(collectOrderBizResponse.getUnSplitUdiCode())) {
|
|
|
collectOrderBizResponse.setUnSplitUdiCode(collectOrderBizResponse.getUnSplitUdiCode().substring(1));
|
|
|
}
|
|
|
//手动
|
|
|
for (IoCollectOrderCodeMan collectOrderCodeMan : manList) {
|
|
|
if (IntUtil.value(collectOrderCodeMan.getBizIdFk()) == IntUtil.value(collectOrderBiz.getId())) {
|
|
|
collectOrderBizResponse.setScanUdiCode(StrUtil.trimToEmpty(collectOrderBizResponse.getScanUdiCode()) + "," + collectOrderCodeMan.getUdiCode());
|
|
|
}
|
|
|
}
|
|
|
if (StrUtil.isNotEmpty(collectOrderBizResponse.getScanUdiCode())) {
|
|
|
collectOrderBizResponse.setScanUdiCode(collectOrderBizResponse.getScanUdiCode().substring(1));
|
|
|
}
|
|
|
|
|
|
if (StrUtil.isNotEmpty(collectOrderBizResponse.getReplaceCode())) {
|
|
|
collectOrderBizResponse.setFinishUdiCode(collectOrderBizResponse.getReplaceCode());
|
|
|
} else if (StrUtil.isNotEmpty(collectOrderBizResponse.getScanUdiCode())) {
|
|
|
collectOrderBizResponse.setFinishUdiCode(collectOrderBizResponse.getScanUdiCode());
|
|
|
} else if (StrUtil.isNotEmpty(collectOrderBizResponse.getSplitUdiCode())) {
|
|
|
collectOrderBizResponse.setFinishUdiCode(collectOrderBizResponse.getSplitUdiCode());
|
|
|
} else if (StrUtil.isNotEmpty(collectOrderBizResponse.getUnSplitUdiCode())) {
|
|
|
collectOrderBizResponse.setFinishUdiCode(collectOrderBizResponse.getUnSplitUdiCode());
|
|
|
}
|
|
|
|
|
|
collectOrderBizResponses.add(collectOrderBizResponse);
|
|
|
}
|
|
|
return collectOrderBizResponses;
|
|
|
}
|
|
|
|
|
|
|
|
|
/**
|
|
|
* 导入内部数据
|
|
|
*/
|
|
|
public void importOrder() {
|
|
|
importUdi();
|
|
|
importPrescribe(null);
|
|
|
}
|
|
|
|
|
|
public void clearOrder() {
|
|
|
collectOrderMapper.clearOrder();
|
|
|
List<IoOrderEntity> orderEntities = new ArrayList<>();
|
|
|
List<IoOrderEntity> orderEntities1 = orderService.findAllByAction("SC72197936495755");
|
|
|
List<IoOrderEntity> orderEntities2 = orderService.findAllByAction("SC72249388338364");
|
|
|
orderEntities.addAll(orderEntities1);
|
|
|
orderEntities.addAll(orderEntities2);
|
|
|
orderEntities.parallelStream().forEach(item ->
|
|
|
{
|
|
|
List<String> delBillNos = new ArrayList<>();
|
|
|
delBillNos.add(item.getBillNo());
|
|
|
orderService.deleteInvByBillNo(delBillNos);
|
|
|
for (String billNo : delBillNos) {
|
|
|
orderService.deleteByBillNo(billNo);
|
|
|
orderDetailBizService.deleteByOrderId(billNo);
|
|
|
orderDetailCodeService.deleteByOrderId(billNo);
|
|
|
codeTempService.deleteByBillNo(billNo);
|
|
|
codeService.deleteCodeByOrderId(billNo);
|
|
|
}
|
|
|
}
|
|
|
);
|
|
|
}
|
|
|
|
|
|
|
|
|
public void importUdi() {
|
|
|
//下载UDI内部单据
|
|
|
FilterOrderRequest filterOrderRequest = new FilterOrderRequest();
|
|
|
filterOrderRequest.setStatus(7);
|
|
|
filterOrderRequest.setProductType(null);
|
|
|
List<IoOrderResponse> list = orderService.filterList(filterOrderRequest);
|
|
|
List<IoCollectOrder> collectOrderList = new ArrayList<>();
|
|
|
List<SysWorkplaceResponse> allWorksList = new ArrayList<>();
|
|
|
for (IoOrderResponse ioOrderEntity : list) {
|
|
|
|
|
|
if (collectOrderMapper.exists(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, ioOrderEntity.getBillNo()))) {
|
|
|
continue;
|
|
|
}
|
|
|
SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity = sysWorkplaceDocumentService.findByBusType(ioOrderEntity.getAction());
|
|
|
if (sysWorkplaceDocumentEntity == null)
|
|
|
continue;
|
|
|
List<SysWorkplaceResponse> sysWorkplaces = sysWorkplaceService.getAllByBusType(ioOrderEntity.getAction());
|
|
|
|
|
|
//自动分配工位
|
|
|
final Long[] defaultWorkplace = {null};
|
|
|
if (CollUtil.isNotEmpty(sysWorkplaces)) {
|
|
|
if (sysWorkplaces.size() == 1) {
|
|
|
defaultWorkplace[0] = sysWorkplaces.get(0).getWorkplaceId();
|
|
|
} else {
|
|
|
List<SysWorkplaceResponse> addWorkplace = new ArrayList<>();
|
|
|
for (SysWorkplaceResponse sysWorkplace : sysWorkplaces) {
|
|
|
//获取是否有正在处理的工位
|
|
|
List<IoCollectOrder> collectOrderList1 = collectOrderMapper.selectList(new LambdaQueryWrapper<IoCollectOrder>()
|
|
|
.eq(IoCollectOrder::getWorkPlaceCode, sysWorkplace.getWorkplaceId()).in(IoCollectOrder::getTagStatus, -1, 1, 2));
|
|
|
sysWorkplace.setOrderCount(collectOrderList1.size());
|
|
|
if (IntUtil.value(sysWorkplace.getOrderCount()) > 0) {
|
|
|
addWorkplace.add(sysWorkplace);
|
|
|
}
|
|
|
}
|
|
|
if (addWorkplace.size() > 0) {
|
|
|
Optional<SysWorkplaceResponse> minCountObject = addWorkplace.stream()
|
|
|
.min((o1, o2) -> Integer.compare(o1.getOrderCount(), o2.getOrderCount()));
|
|
|
minCountObject.ifPresent(sysWorkplace -> defaultWorkplace[0] = sysWorkplace.getWorkplaceId());
|
|
|
} else {
|
|
|
defaultWorkplace[0] = sysWorkplaces.get(0).getWorkplaceId();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
IoCollectOrder collectOrder = IoCollectOrder.builder()
|
|
|
.billNo(ioOrderEntity.getBillNo())
|
|
|
.fromType("UDI系统")
|
|
|
.busType(ioOrderEntity.getAction())
|
|
|
.fromCorp(ioOrderEntity.getFromName())
|
|
|
.workPlaceCode(defaultWorkplace[0])
|
|
|
.billTime(ioOrderEntity.getCreateTime())
|
|
|
.createTime(ioOrderEntity.getCreateTime())
|
|
|
.createUser(ioOrderEntity.getCreateUser())
|
|
|
.updateTime(new Date())
|
|
|
.orderCirType(sysWorkplaceDocumentEntity.getOrderCirType())
|
|
|
.splitStatus(0)
|
|
|
.tagStatus(0)
|
|
|
.build();
|
|
|
if (collectOrder.getWorkPlaceCode() != null) {
|
|
|
collectOrder.setTagStatus(1);
|
|
|
}
|
|
|
save(collectOrder);
|
|
|
List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(ioOrderEntity.getBillNo());
|
|
|
|
|
|
List<IoCollectOrderBiz> collectOrderBizs = new ArrayList<>();
|
|
|
for (IoOrderDetailBizEntity bizEntity : orderDetailBizEntities) {
|
|
|
UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByRelId(bizEntity.getBindRlFk() + "");
|
|
|
IoCollectOrderBiz collectOrderBiz = IoCollectOrderBiz.builder().orderIdFk(collectOrder.getBillNo())
|
|
|
.relId(bizEntity.getBindRlFk())
|
|
|
.thrCode(udiRelevanceResponse.getMainId())
|
|
|
.ybbm(udiRelevanceResponse.getYbbm())
|
|
|
.payFeeCode(udiRelevanceResponse.getPayFeeCode())
|
|
|
.cpmctymc(bizEntity.getCoName())
|
|
|
.nameCode(bizEntity.getNameCode())
|
|
|
.ggxh(bizEntity.getSpec())
|
|
|
.batchNo(bizEntity.getBatchNo())
|
|
|
.productDate(bizEntity.getProductDate())
|
|
|
.expireDate(bizEntity.getExpireDate())
|
|
|
.count(bizEntity.getCount())
|
|
|
.measureUnit(bizEntity.getMeasname())
|
|
|
.tagStatus(1)
|
|
|
.unTagCount(bizEntity.getCount()).build();
|
|
|
|
|
|
if (IntUtil.value(udiRelevanceResponse.getProductsType()) == 2) {
|
|
|
collectOrderBiz.setGgxh(udiRelevanceResponse.getBzgg());
|
|
|
collectOrderBiz.setMeasureUnit(udiRelevanceResponse.getPrepnUnit());
|
|
|
}
|
|
|
collectOrderBizs.add(collectOrderBiz);
|
|
|
}
|
|
|
if (CollUtil.isNotEmpty(collectOrderBizs)) {
|
|
|
collectOrderBizService.saveBatch(collectOrderBizs);
|
|
|
}
|
|
|
allWorksList.addAll(sysWorkplaces);
|
|
|
|
|
|
if (IntUtil.value(sysWorkplaceDocumentEntity.getAutoTag()) == 1 && IntUtil.value(collectOrder.getTagStatus()) == 1) {
|
|
|
splitFifoCodeService.lockInventoryByOrder(collectOrder.getBillNo(), 1);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
// if (CollUtil.isNotEmpty(collectOrderList)) {
|
|
|
// saveBatch(collectOrderList);
|
|
|
// }
|
|
|
|
|
|
// Map<Long, SysWorkplaceResponse> sysWorkplaceMap = new HashMap<>();
|
|
|
// for (SysWorkplaceResponse sysWorkplace : allWorksList) {
|
|
|
// sysWorkplaceMap.put(sysWorkplace.getId(), sysWorkplace);
|
|
|
// }
|
|
|
// for (SysWorkplaceResponse value : sysWorkplaceMap.values()) {
|
|
|
// splitFifoCodeService.preAllotInv(value.getWorkplaceId());
|
|
|
// }
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
public void importPrescribe(List<BasicSkPrescribeEntity> basicSkPrescribeEntities) {
|
|
|
//下载处方
|
|
|
if (CollUtil.isNotEmpty(basicSkPrescribeEntities))
|
|
|
basicSkPrescribeEntities = basicSkPrescribeService.list();
|
|
|
List<SysWorkplaceResponse> allWorksList = new ArrayList<>();
|
|
|
for (BasicSkPrescribeEntity basicSkPrescribeEntity : basicSkPrescribeEntities) {
|
|
|
if (collectOrderMapper.exists(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, basicSkPrescribeEntity.getCode()))) {
|
|
|
continue;
|
|
|
}
|
|
|
SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity = sysWorkplaceDocumentService.findByBusType(basicSkPrescribeEntity.getAddr());
|
|
|
if (sysWorkplaceDocumentEntity == null)
|
|
|
continue;
|
|
|
//自动分配工位
|
|
|
final Long[] defaultWorkplace = {null};
|
|
|
List<SysWorkplaceResponse> sysWorkplaces = sysWorkplaceService.getAllByBusType(basicSkPrescribeEntity.getAddr());
|
|
|
if (CollUtil.isNotEmpty(sysWorkplaces)) {
|
|
|
if (sysWorkplaces.size() == 1) {
|
|
|
defaultWorkplace[0] = sysWorkplaces.get(0).getWorkplaceId();
|
|
|
} else {
|
|
|
List<SysWorkplaceResponse> addWorkplace = new ArrayList<>();
|
|
|
for (SysWorkplaceResponse sysWorkplace : sysWorkplaces) {
|
|
|
//获取是否有正在处理的工位
|
|
|
List<IoCollectOrder> collectOrderList1 = collectOrderMapper.selectList(new LambdaQueryWrapper<IoCollectOrder>()
|
|
|
.eq(IoCollectOrder::getWorkPlaceCode, sysWorkplace.getWorkplaceId()).in(IoCollectOrder::getTagStatus, -1, 1, 2));
|
|
|
sysWorkplace.setOrderCount(collectOrderList1.size());
|
|
|
if (IntUtil.value(sysWorkplace.getOrderCount()) > 0) {
|
|
|
addWorkplace.add(sysWorkplace);
|
|
|
}
|
|
|
}
|
|
|
if (addWorkplace.size() > 0) {
|
|
|
Optional<SysWorkplaceResponse> minCountObject = addWorkplace.stream()
|
|
|
.min((o1, o2) -> Integer.compare(o1.getOrderCount(), o2.getOrderCount()));
|
|
|
minCountObject.ifPresent(sysWorkplace -> defaultWorkplace[0] = sysWorkplace.getWorkplaceId());
|
|
|
} else {
|
|
|
defaultWorkplace[0] = sysWorkplaces.get(0).getWorkplaceId();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
IoCollectOrder collectOrder = IoCollectOrder.builder()
|
|
|
.billNo(basicSkPrescribeEntity.getCode())
|
|
|
.busType(sysWorkplaceDocumentEntity.getDocumentTypeCode())
|
|
|
.fromType("HIS系统")
|
|
|
.fromCorp(basicSkPrescribeEntity.getSickerCode())
|
|
|
.workPlaceCode(defaultWorkplace[0])
|
|
|
.billTime(MsDateUtil.localToDate(basicSkPrescribeEntity.getPrescribeDate()))
|
|
|
.createTime(new Date())
|
|
|
.createUser(basicSkPrescribeEntity.getCreateUser())
|
|
|
.backupOrderRemark1(basicSkPrescribeEntity.getStooutNo())
|
|
|
.updateTime(new Date())
|
|
|
.orderCirType(sysWorkplaceDocumentEntity.getOrderCirType())
|
|
|
.splitStatus(0)
|
|
|
.tagStatus(0)
|
|
|
.build();
|
|
|
if (collectOrder.getWorkPlaceCode() != null) {
|
|
|
collectOrder.setTagStatus(1);
|
|
|
}
|
|
|
save(collectOrder);
|
|
|
List<BasicSkPrescribeItemEntity> basicSkPrescribeItemEntities = basicSkPrescirbeDetailService.findByPrescribeNum(basicSkPrescribeEntity.getCode());
|
|
|
List<IoCollectOrderBiz> collectOrderBizs = new ArrayList<>();
|
|
|
for (BasicSkPrescribeItemEntity bizEntity : basicSkPrescribeItemEntities) {
|
|
|
UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByRelId(bizEntity.getRelId() + "");
|
|
|
double doubleValue = Double.parseDouble(bizEntity.getMeasureCount());
|
|
|
IoCollectOrderBiz collectOrderBiz = IoCollectOrderBiz.builder().orderIdFk(collectOrder.getBillNo())
|
|
|
.relId(bizEntity.getRelId())
|
|
|
.thrCode(bizEntity.getItemCode())
|
|
|
.ybbm(udiRelevanceResponse.getYbbm())
|
|
|
.payFeeCode(udiRelevanceResponse.getPayFeeCode())
|
|
|
.cpmctymc(bizEntity.getItemName())
|
|
|
.nameCode(udiRelevanceResponse.getNameCode())
|
|
|
.ggxh(bizEntity.getGgxh())
|
|
|
.batchNo(bizEntity.getBatchNo())
|
|
|
.count((int) doubleValue)
|
|
|
.measureUnit(bizEntity.getMeasureUnit())
|
|
|
.tagStatus(1)
|
|
|
.unTagCount(bizEntity.getCount()).build();
|
|
|
|
|
|
if (IntUtil.value(udiRelevanceResponse.getProductsType()) == 2) {
|
|
|
collectOrderBiz.setGgxh(udiRelevanceResponse.getBzgg());
|
|
|
collectOrderBiz.setMeasureUnit(udiRelevanceResponse.getPrepnUnit());
|
|
|
}
|
|
|
collectOrderBizs.add(collectOrderBiz);
|
|
|
}
|
|
|
if (CollUtil.isNotEmpty(collectOrderBizs))
|
|
|
collectOrderBizService.saveBatch(collectOrderBizs);
|
|
|
|
|
|
allWorksList.addAll(sysWorkplaces);
|
|
|
if (IntUtil.value(sysWorkplaceDocumentEntity.getAutoTag()) == 1 && IntUtil.value(collectOrder.getTagStatus()) == 1) {
|
|
|
splitFifoCodeService.lockInventoryByOrder(collectOrder.getBillNo(), 1);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@Transactional(rollbackFor = Exception.class)
|
|
|
public void removeCode(DeleteTageCodeRequest deleteTageCodeRequest) {
|
|
|
Integer delType = deleteTageCodeRequest.getDelType();
|
|
|
Long codeManId = deleteTageCodeRequest.getCodeManId();
|
|
|
IoCollectOrderCodeMan ioCollectOrderCodeMan = ioCollectOrderCodeManService.getById(codeManId);
|
|
|
if (ioCollectOrderCodeMan == null) throw new JsonException("码明细id有误");
|
|
|
Long bizIdFk = ioCollectOrderCodeMan.getBizIdFk();
|
|
|
Integer scanCount = ioCollectOrderCodeMan.getScanCount();
|
|
|
Integer delCount = 0;
|
|
|
if (delType == 1) {//1.减一，，，IoCollectOrderCodeMan-1 IoCollectOrderBiz-1
|
|
|
Integer newCount = scanCount - 1;
|
|
|
delCount = 1;
|
|
|
if (newCount == 0) {
|
|
|
ioCollectOrderCodeManService.removeById(codeManId);
|
|
|
} else {
|
|
|
ioCollectOrderCodeMan.setScanCount(newCount);
|
|
|
ioCollectOrderCodeManService.updateById(ioCollectOrderCodeMan);
|
|
|
}
|
|
|
} else if (delType == 2) {//2.删除 IoCollectOrderCodeMan-删除 IoCollectOrderBiz-数量
|
|
|
delCount = scanCount;
|
|
|
ioCollectOrderCodeManService.removeById(codeManId);
|
|
|
}
|
|
|
|
|
|
if (delCount > 0) {
|
|
|
IoCollectOrderBiz bizServiceOne = collectOrderBizService.getOne(new LambdaQueryWrapper<IoCollectOrderBiz>()
|
|
|
.eq(IoCollectOrderBiz::getId, bizIdFk));
|
|
|
if (bizServiceOne == null) throw new JsonException("扫码详情未查找到");
|
|
|
//反查单据类型 查看是否来源业务单
|
|
|
String orderIdFk = bizServiceOne.getOrderIdFk();
|
|
|
IoCollectOrder ioCollectOrder = collectOrderMapper.selectOne(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, orderIdFk));
|
|
|
if (ioCollectOrder == null) throw new JsonException("反查单据失败");
|
|
|
String busType = ioCollectOrder.getBusType();
|
|
|
Long workPlaceCode = ioCollectOrder.getWorkPlaceCode();
|
|
|
SysWorkplaceDocumentEntity byWorkplaceCode = sysWorkplaceDocumentService.findByWorkplaceCode(workPlaceCode, busType);
|
|
|
if (byWorkplaceCode == null) throw new JsonException("反查工位单据类型失败");
|
|
|
Integer scanType = byWorkplaceCode.getScanType();
|
|
|
Integer oneScanCount = bizServiceOne.getScanCount();
|
|
|
Integer newCount = oneScanCount - delCount;
|
|
|
if (scanType == 1 && newCount <= 0) {
|
|
|
collectOrderBizService.removeById(bizServiceOne);
|
|
|
} else {
|
|
|
bizServiceOne.setScanCount(newCount);
|
|
|
|
|
|
List<UdiRelevanceResponse> udiRelevanceResponses = udiRelevanceService.selectGroupByNameCode(bizServiceOne.getNameCode(), null);
|
|
|
if (IntUtil.value(byWorkplaceCode.getOrderCirType()) == 1) {
|
|
|
bizServiceOne.setScanActCount(IntUtil.value(bizServiceOne.getScanActCount()) - delCount * udiCalCountUtil.getCirActCount(udiRelevanceResponses.get(0)));
|
|
|
} else {
|
|
|
bizServiceOne.setScanActCount(IntUtil.value(bizServiceOne.getScanActCount()) - delCount * udiCalCountUtil.getUseActCount(udiRelevanceResponses.get(0)));
|
|
|
}
|
|
|
|
|
|
collectOrderBizService.updateById(bizServiceOne);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 更新排序时间
|
|
|
*
|
|
|
* @param collectOrderRequest
|
|
|
*/
|
|
|
@Transactional(rollbackFor = Exception.class)
|
|
|
public void orderTop(CollectOrderRequest collectOrderRequest) {
|
|
|
Assert.notNull(collectOrderRequest.getId(), "id不能为空");
|
|
|
IoCollectOrder old = this.getById(collectOrderRequest.getId());
|
|
|
Assert.notNull(old, "不存在该库存预警设置");
|
|
|
this.lambdaUpdate()
|
|
|
.set(IoCollectOrder::getUpdateTime, new Date())
|
|
|
.set(collectOrderRequest.getUpdateUser() != null, IoCollectOrder::getUpdateUser, collectOrderRequest.getUpdateUser())
|
|
|
.set(IoCollectOrder::getOrderTime, new Date())
|
|
|
.eq(IoCollectOrder::getId, collectOrderRequest.getId()).update();
|
|
|
}
|
|
|
|
|
|
public void finishOrder(CollectOrderRequest collectOrderRequest) {
|
|
|
IoCollectOrder collectOrder = new IoCollectOrder();
|
|
|
BeanUtils.copyProperties(collectOrderRequest, collectOrder);
|
|
|
collectOrder.setTagStatus(3);
|
|
|
collectOrder.setUpdateTime(new Date());
|
|
|
updateByBillNo(collectOrder);
|
|
|
splitCodeService.finishAutoTagCode(collectOrder);
|
|
|
|
|
|
ThreadUtil.execAsync(() -> {
|
|
|
//插入到码表
|
|
|
collectCodeService.insertCodesByBill(collectOrderRequest.getBillNo());
|
|
|
//更新数据至第三方系统
|
|
|
});
|
|
|
}
|
|
|
|
|
|
|
|
|
/**
|
|
|
* @param billNo
|
|
|
*/
|
|
|
@Transactional(rollbackFor = Exception.class)
|
|
|
public void generateOrder(String billNo) {
|
|
|
|
|
|
IoCollectOrder collectOrder = getByBillNo(billNo);
|
|
|
SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity = sysWorkplaceDocumentService.findByWorkplaceCode(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());
|
|
|
//1.内部系统，且单据为扫码生成业务单则创建系统单据
|
|
|
if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 1 && sysWorkplaceDocumentEntity.getScanType() == 1) {
|
|
|
List<IoCollectOrderCodeMan> collectOrderCodes = collectOrderCodeManService.listByBillNo(collectOrder.getBillNo());
|
|
|
BasicBussinessTypeEntity bussinessTypeEntity;
|
|
|
sysWorkplaceDocumentEntity.getInoutType();
|
|
|
|
|
|
//构造单据数据
|
|
|
IoOrderEntity orderEntity = new IoOrderEntity();
|
|
|
bussinessTypeEntity = bussinessTypeService.findByAction(sysWorkplaceDocumentEntity.getDocumentTypeCode());
|
|
|
orderEntity.setMainAction(bussinessTypeEntity.getMainAction());
|
|
|
orderEntity.setAction(bussinessTypeEntity.getAction());
|
|
|
orderEntity.setCreateTime(new Date());
|
|
|
orderEntity.setInvCode(sysWorkplaceDocumentEntity.getInvCode() + "");
|
|
|
orderEntity.setDeptCode("");
|
|
|
orderEntity.setFromCorp(collectOrder.getFromCorp());
|
|
|
orderEntity.setCorpOrderId(CustomUtil.getId() + "x");
|
|
|
orderEntity.setExportStatus(0);
|
|
|
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_PROCESS);
|
|
|
orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_DRAFT);
|
|
|
orderEntity.setCreateUser(collectOrder.getCreateUser());
|
|
|
orderEntity.setCreateTime(new Date());
|
|
|
orderEntity.setUpdateUser(collectOrder.getCreateUser());
|
|
|
orderEntity.setUpdateTime(new Date());
|
|
|
orderEntity.setCustomerId("110");
|
|
|
orderEntity.setOrderType(2);
|
|
|
orderEntity.setFromType(2);
|
|
|
String orderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(bussinessTypeEntity.getPrefix()), "yyyyMMdd"));
|
|
|
orderEntity.setBillNo(orderNo);
|
|
|
List<IoCodeTempEntity> lossCodesList = new ArrayList<>();
|
|
|
|
|
|
for (IoCollectOrderCodeMan collectOrderCodeMan : collectOrderCodes) {
|
|
|
lossCodesList.add(buildCodeEntity(collectOrderCodeMan, orderEntity));
|
|
|
}
|
|
|
orderService.insertOrder(orderEntity);
|
|
|
codesTempDao.insertBatch(lossCodesList);
|
|
|
addInoutService.dealProcess(orderEntity);
|
|
|
if (!ioCheckInoutService.checkManual(orderEntity.getBillNo())) {
|
|
|
ioCheckInoutService.check(orderEntity.getBillNo());
|
|
|
}
|
|
|
} else if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 1 && sysWorkplaceDocumentEntity.getScanType() != 1) {
|
|
|
//更新单据为已完成
|
|
|
IoOrderEntity orderEntity = orderService.findByBillNo(collectOrder.getBillNo());
|
|
|
orderEntity.setStatus(7);
|
|
|
orderService.update(orderEntity);
|
|
|
} else if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 0) {
|
|
|
//todo 根据单据类型上传医保或者第三方系统
|
|
|
PostCollectOrderRequest orderRequest = new PostCollectOrderRequest();
|
|
|
orderRequest.setThirdSys("thirdId");
|
|
|
CollectOrderBizRequest collectOrderBizRequest = new CollectOrderBizRequest();
|
|
|
collectOrderBizRequest.setOrderIdFk(collectOrder.getBillNo());
|
|
|
List<CollectOrderBizResponse> collectOrderBizResponses = combieOrderDetail(collectOrderBizRequest);
|
|
|
collectOrder.setCollectOrderBizResponseList(collectOrderBizResponses);
|
|
|
List<IoCollectOrder> collectOrderList = new ArrayList<>();
|
|
|
collectOrderList.add(collectOrder);
|
|
|
orderRequest.setCollectOrderList(collectOrderList);
|
|
|
BaseResponse<BasicSkPrescribeResponse> baseResponse = erpBasicClient.postOrder(orderRequest);
|
|
|
log.debug("单据返回=========" + baseResponse);
|
|
|
if (baseResponse.getCode() == 20000) {
|
|
|
//
|
|
|
} else {
|
|
|
throw new JsonException("连接第三方系统接口服务出错，" + baseResponse.getMessage());
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
private IoCodeTempEntity buildCodeEntity(IoCollectOrderCodeMan collectOrderCodeMan, IoOrderEntity orderEntity) {
|
|
|
IoCodeTempEntity tempEntity = new IoCodeTempEntity();
|
|
|
tempEntity.setOrderId(orderEntity.getBillNo());
|
|
|
tempEntity.setCode(collectOrderCodeMan.getUdiCode());
|
|
|
tempEntity.setRelId(collectOrderCodeMan.getRelId());
|
|
|
tempEntity.setMainAction(orderEntity.getMainAction());
|
|
|
tempEntity.setInvCode(orderEntity.getInvCode());
|
|
|
tempEntity.setBatchNo(collectOrderCodeMan.getBatchNo());
|
|
|
tempEntity.setProduceDate(collectOrderCodeMan.getProductDate());
|
|
|
tempEntity.setExpireDate(collectOrderCodeMan.getExpireDate());
|
|
|
tempEntity.setSerialNo(collectOrderCodeMan.getSerialNo());
|
|
|
tempEntity.setNameCode(collectOrderCodeMan.getNameCode());
|
|
|
tempEntity.setCount(collectOrderCodeMan.getScanCount());
|
|
|
tempEntity.setReCount(collectOrderCodeMan.getScanCount());
|
|
|
tempEntity.setCreateTime(new Date());
|
|
|
tempEntity.setUpdateTime(new Date());
|
|
|
tempEntity.setDeptCode(orderEntity.getDeptCode());
|
|
|
return tempEntity;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 上传更新状态
|
|
|
*
|
|
|
* @param billNo
|
|
|
*/
|
|
|
@Transactional(rollbackFor = Exception.class)
|
|
|
public void orderUpload(String billNo) {
|
|
|
IoCollectOrder updateOrder = new IoCollectOrder();
|
|
|
updateOrder.setBillNo(billNo);
|
|
|
try {
|
|
|
this.generateOrder(billNo);
|
|
|
updateOrder.setUploadStatus(2);
|
|
|
} catch (Exception e) {
|
|
|
updateOrder.setUploadStatus(3);
|
|
|
updateOrder.setUploadError(e.getMessage());
|
|
|
}
|
|
|
//更新状态
|
|
|
this.updateByBillNo(updateOrder);
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
