|
|
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.LambdaUpdateWrapper;
|
|
|
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.*;
|
|
|
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;
|
|
|
@Resource
|
|
|
IoCollectOrderOriginService collectOrderOriginService;
|
|
|
@Resource
|
|
|
IoCollectOrderBizOriginService collectOrderBizOriginService;
|
|
|
|
|
|
@Resource
|
|
|
IoCollectOrderBackupService ioCollectOrderBackupService;
|
|
|
@Resource
|
|
|
IoCollectSetService collectSetService;
|
|
|
|
|
|
public IoCollectOrder getByBillNo(String billNo) {
|
|
|
return collectOrderMapper.selectOne(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, billNo).last("limit 1"));
|
|
|
}
|
|
|
|
|
|
public IoCollectOrderResponse unionSearch(Long workPlaceCode, String busType, String unionKey) {
|
|
|
CollectOrderRequest collectOrderRequest = new CollectOrderRequest();
|
|
|
collectOrderRequest.setUnionKey(unionKey);
|
|
|
collectOrderRequest.setWorkPlaceCode(workPlaceCode);
|
|
|
collectOrderRequest.setBusType(busType);
|
|
|
List<IoCollectOrderResponse> collectOrderResponses = filterList(collectOrderRequest);
|
|
|
if (CollUtil.isNotEmpty(collectOrderResponses))
|
|
|
return collectOrderResponses.get(0);
|
|
|
else
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
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 && collectOrderRequest.getLimit() != 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() {
|
|
|
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);
|
|
|
}
|
|
|
}
|
|
|
);
|
|
|
}
|
|
|
|
|
|
// TODO: 2024/10/14 下载本地单据类型
|
|
|
public void importUdi(String action) {
|
|
|
FilterOrderRequest filterOrderRequest = new FilterOrderRequest();
|
|
|
filterOrderRequest.setStatus(7);
|
|
|
filterOrderRequest.setAction(action);
|
|
|
filterOrderRequest.setProductType(null);
|
|
|
List<IoOrderResponse> list = orderService.filterList(filterOrderRequest);
|
|
|
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;
|
|
|
IoCollectOrder collectOrder = IoCollectOrder.builder()
|
|
|
.billNo(ioOrderEntity.getBillNo())
|
|
|
.fromType("UDI系统")
|
|
|
.busType(ioOrderEntity.getAction())
|
|
|
.fromCorp(ioOrderEntity.getFromName())
|
|
|
.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);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
public void importPrescribe(List<BasicSkPrescribeEntity> basicSkPrescribeEntities) {
|
|
|
//下载处方
|
|
|
if (CollUtil.isEmpty(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())
|
|
|
.batchNo(bizEntity.getBatchNo())
|
|
|
.count((int) doubleValue)
|
|
|
.measureUnit(bizEntity.getMeasureUnit())
|
|
|
.tagStatus(1)
|
|
|
.unTagCount(bizEntity.getCount()).build();
|
|
|
|
|
|
if (IntUtil.value(udiRelevanceResponse.getProductsType()) == 2) {
|
|
|
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);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/**
|
|
|
* 单据回填
|
|
|
*
|
|
|
* @param ioCollectOrderList
|
|
|
* @param addr
|
|
|
*/
|
|
|
@Transactional(rollbackFor = Exception.class)
|
|
|
public void importPrescribe(List<IoCollectOrder> ioCollectOrderList, String addr) {
|
|
|
|
|
|
if (CollUtil.isNotEmpty(ioCollectOrderList)) {
|
|
|
|
|
|
//是否自动转成待处理单据
|
|
|
Boolean autoDealOrder = collectSetService.getSet().getAutoDealOrder();
|
|
|
|
|
|
List<IoCollectOrder> allotCollects = new ArrayList<>();
|
|
|
List<IoCollectOrderBiz> allotCollectBizs = new ArrayList<>();
|
|
|
for (IoCollectOrder collectOrder : ioCollectOrderList) {
|
|
|
IoCollectOrderOrigin ioCollectOrderOrigin = new IoCollectOrderOrigin();
|
|
|
if (collectOrderMapper.exists(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, collectOrder.getBillNo()))) {
|
|
|
continue;
|
|
|
}
|
|
|
SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity = sysWorkplaceDocumentService.findByBusType(addr);
|
|
|
if (sysWorkplaceDocumentEntity == null) {
|
|
|
continue;
|
|
|
}
|
|
|
//暂时不自动分配工位
|
|
|
// if (collectOrder.getWorkPlaceCode() == null) {
|
|
|
// //自动分配工位
|
|
|
// final Long[] defaultWorkplace = {null};
|
|
|
// List<SysWorkplaceResponse> sysWorkplaces = sysWorkplaceService.getAllByBusType(addr);
|
|
|
// 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();
|
|
|
// }
|
|
|
// }
|
|
|
// }
|
|
|
// collectOrder.setWorkPlaceCode(defaultWorkplace[0]);
|
|
|
// }
|
|
|
|
|
|
collectOrder.setBusType(sysWorkplaceDocumentEntity.getDocumentTypeCode());
|
|
|
collectOrder.setOrderCirType(sysWorkplaceDocumentEntity.getOrderCirType());
|
|
|
BeanUtils.copyProperties(collectOrder, ioCollectOrderOrigin);
|
|
|
boolean save = collectOrderOriginService.save(ioCollectOrderOrigin);
|
|
|
if (!save) {
|
|
|
throw new JsonException(500, "charu cuowu ");
|
|
|
}
|
|
|
|
|
|
|
|
|
List<IoCollectOrderBiz> bizList = collectOrder.getBizList();
|
|
|
if (CollUtil.isNotEmpty(bizList)) {
|
|
|
//先清空 原来的biz
|
|
|
String billNo = collectOrder.getBillNo();
|
|
|
collectOrderBizOriginService.remove(new LambdaUpdateWrapper<IoCollectOrderBizOrigin>().eq(IoCollectOrderBizOrigin::getOrderIdFk, billNo));
|
|
|
|
|
|
for (IoCollectOrderBiz collectOrderBiz : bizList) {
|
|
|
if (collectOrderBiz.getRelId() != null) {
|
|
|
UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByRelId(collectOrderBiz.getRelId() + "");
|
|
|
if (udiRelevanceResponse != null) {
|
|
|
collectOrderBiz.setYbbm(udiRelevanceResponse.getYbbm());
|
|
|
collectOrderBiz.setPayFeeCode(udiRelevanceResponse.getPayFeeCode());
|
|
|
collectOrderBiz.setNameCode(udiRelevanceResponse.getNameCode());
|
|
|
if (IntUtil.value(udiRelevanceResponse.getProductsType()) == 2) {
|
|
|
collectOrderBiz.setMeasureUnit(udiRelevanceResponse.getPrepnUnit());
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
List<IoCollectOrderBizOrigin> ioCollectOrderBizOrigins = BeanCopyUtils.copyList(bizList, IoCollectOrderBizOrigin.class);
|
|
|
collectOrderBizOriginService.saveBatch(ioCollectOrderBizOrigins);
|
|
|
}
|
|
|
|
|
|
if (!collectOrder.getTagStatus().equals(4) && autoDealOrder) {//没出现耗材不匹配 且 开启了自动转成待处理单据
|
|
|
collectOrder.setTagStatus(1);
|
|
|
allotCollects.add(collectOrder);
|
|
|
allotCollectBizs.addAll(bizList);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (CollUtil.isNotEmpty(allotCollects)) {
|
|
|
saveBatch(allotCollects);
|
|
|
collectOrderBizService.saveBatch(allotCollectBizs);
|
|
|
for (IoCollectOrder collectOrder : allotCollects) {
|
|
|
SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity = sysWorkplaceDocumentService.findByBusType(addr);
|
|
|
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(ioCollectOrderCodeMan.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);
|
|
|
|
|
|
//插入备用表
|
|
|
IoCollectOrderBackup ioCollectOrderBackup = new IoCollectOrderBackup();
|
|
|
BeanUtils.copyProperties(collectOrder, ioCollectOrderBackup);
|
|
|
ioCollectOrderBackupService.save(ioCollectOrderBackup);
|
|
|
|
|
|
//删除原来单据
|
|
|
removeOrderByBillNo(collectOrder);
|
|
|
|
|
|
ThreadUtil.execAsync(() -> {
|
|
|
//插入到码表
|
|
|
collectCodeService.insertCodesByBill(collectOrderRequest.getBillNo());
|
|
|
//更新数据至第三方系统
|
|
|
});
|
|
|
}
|
|
|
|
|
|
private void removeOrderByBillNo(IoCollectOrder collectOrder) {
|
|
|
String billNo = collectOrder.getBillNo();
|
|
|
this.remove(new LambdaUpdateWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, billNo));
|
|
|
collectOrderBizService.remove(new LambdaUpdateWrapper<IoCollectOrderBiz>().eq(IoCollectOrderBiz::getOrderIdFk, billNo));
|
|
|
}
|
|
|
|
|
|
|
|
|
@Resource
|
|
|
IoCollectOrderBizBackupService ioCollectOrderBizBackupService;
|
|
|
/**
|
|
|
* @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());
|
|
|
// }
|
|
|
//
|
|
|
// }
|
|
|
// //插入处方备份表
|
|
|
// IoCollectOrderBackup ioCollectOrderBackup = new IoCollectOrderBackup();
|
|
|
// BeanUtils.copyProperties(collectOrder, ioCollectOrderBackup);
|
|
|
// boolean save = ioCollectOrderBackupService.save(ioCollectOrderBackup);
|
|
|
// if (!save){
|
|
|
// throw new JsonException(500,"处方备用上传失败");
|
|
|
// }
|
|
|
// List<IoCollectOrderBiz> ioCollectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());
|
|
|
// for (IoCollectOrderBiz ioCollectOrderBiz : ioCollectOrderBizs){
|
|
|
// IoCollectOrderBizBackup ioCollectOrderBizBackup = new IoCollectOrderBizBackup();
|
|
|
// BeanUtils.copyProperties(ioCollectOrderBiz, ioCollectOrderBizBackup);
|
|
|
// boolean save1 = ioCollectOrderBizBackupService.save(ioCollectOrderBizBackup);
|
|
|
// if (!save1){
|
|
|
// throw new JsonException(500,"处方备用明细上传失败");
|
|
|
// }
|
|
|
// }
|
|
|
//
|
|
|
//
|
|
|
// }
|
|
|
|
|
|
@Resource
|
|
|
UdiRlSupService udiRlSupService;
|
|
|
|
|
|
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());
|
|
|
CompanyProductRelevanceEntity udiRlSupEntity = udiRlSupService.selOneByRlId(tempEntity.getRelId());
|
|
|
if (udiRlSupEntity != null)
|
|
|
tempEntity.setSupId(udiRlSupEntity.getCustomerId());
|
|
|
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);
|
|
|
}
|
|
|
|
|
|
|
|
|
public Boolean decideOrder(CollectOrderRequest request) {
|
|
|
List<IoCollectOrder> ioCollectOrders = collectOrderMapper.selectList(new LambdaQueryWrapper<IoCollectOrder>()
|
|
|
.eq(IoCollectOrder::getWorkPlaceCode, request.getWorkPlaceCode())
|
|
|
.eq(IoCollectOrder::getTagStatus, request.getTagStatus()));
|
|
|
|
|
|
if (ioCollectOrders.size() > 0) {
|
|
|
return false;
|
|
|
}
|
|
|
//如果有判断是否是当前单据
|
|
|
if (ioCollectOrders.size() == 1) {
|
|
|
IoCollectOrder ioCollectOrder = ioCollectOrders.get(0);
|
|
|
if (ioCollectOrder.getBillNo().equals(request.getBillNo())) {
|
|
|
return true;
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
return true;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
