|
|
package com.glxp.api.service.collect;
|
|
|
|
|
|
import cn.hutool.core.collection.CollUtil;
|
|
|
import cn.hutool.core.io.FileUtil;
|
|
|
import cn.hutool.core.lang.Assert;
|
|
|
import cn.hutool.core.thread.ThreadUtil;
|
|
|
import cn.hutool.core.util.StrUtil;
|
|
|
import com.alibaba.excel.EasyExcel;
|
|
|
import com.alibaba.excel.context.AnalysisContext;
|
|
|
import com.alibaba.excel.event.AnalysisEventListener;
|
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
|
|
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.github.pagehelper.PageInfo;
|
|
|
import com.glxp.api.common.res.BaseResponse;
|
|
|
import com.glxp.api.common.util.ResultVOUtils;
|
|
|
import com.glxp.api.constant.ConstantStatus;
|
|
|
import com.glxp.api.constant.ConstantType;
|
|
|
import com.glxp.api.dao.basic.UdiRelevanceDao;
|
|
|
import com.glxp.api.dao.collect.IoCollectOrderMapper;
|
|
|
import com.glxp.api.dao.collect.IoCollectOrderOriginMapper;
|
|
|
import com.glxp.api.entity.auth.AuthAdmin;
|
|
|
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.IoCodeEntity;
|
|
|
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.exception.JsonException;
|
|
|
import com.glxp.api.http.sync.SpGetHttpClient;
|
|
|
import com.glxp.api.req.collect.CollectOrderBizRequest;
|
|
|
import com.glxp.api.req.collect.CollectOrderRequest;
|
|
|
import com.glxp.api.req.collect.VA010Mx;
|
|
|
import com.glxp.api.req.inout.DeleteTageCodeRequest;
|
|
|
import com.glxp.api.req.inout.FilterOrderRequest;
|
|
|
import com.glxp.api.req.inout.ReviewSpmsRequest;
|
|
|
import com.glxp.api.res.PageSimpleResponse;
|
|
|
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.sync.SpsSyncOrderResponse;
|
|
|
import com.glxp.api.service.auth.CustomerService;
|
|
|
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.service.sync.HeartService;
|
|
|
import com.glxp.api.service.thrsys.SysWorkplacePutRelService;
|
|
|
import com.glxp.api.util.BeanCopyUtils;
|
|
|
import com.glxp.api.util.IntUtil;
|
|
|
import com.glxp.api.util.MsDateUtil;
|
|
|
import com.glxp.api.util.udi.UdiCalCountUtil;
|
|
|
import org.springframework.beans.BeanUtils;
|
|
|
import org.springframework.stereotype.Service;
|
|
|
import org.springframework.transaction.annotation.Isolation;
|
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
|
import org.springframework.web.multipart.MultipartFile;
|
|
|
|
|
|
import javax.annotation.Resource;
|
|
|
import java.io.IOException;
|
|
|
import java.io.InputStream;
|
|
|
import java.text.ParseException;
|
|
|
import java.text.SimpleDateFormat;
|
|
|
import java.util.*;
|
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
|
import java.util.stream.Collectors;
|
|
|
|
|
|
@Service
|
|
|
public class IoCollectOrderService extends ServiceImpl<IoCollectOrderMapper, IoCollectOrder> {
|
|
|
|
|
|
@Resource
|
|
|
IoCollectOrderMapper collectOrderMapper;
|
|
|
@Resource
|
|
|
IoCollectOrderOriginMapper collectOrderOriginMapper;
|
|
|
@Resource
|
|
|
IoCollectOrderCodeManService ioCollectOrderCodeManService;
|
|
|
@Resource
|
|
|
IoOrderService orderService;
|
|
|
@Resource
|
|
|
IoOrderDetailBizService orderDetailBizService;
|
|
|
@Resource
|
|
|
IoCollectOrderBizService collectOrderBizService;
|
|
|
@Resource
|
|
|
IoOrderDetailResultService orderDetailResultService;
|
|
|
@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
|
|
|
IoSplitQxService splitQxService;
|
|
|
@Resource
|
|
|
IoSplitCodeService splitCodeService;
|
|
|
@Resource
|
|
|
IoCollectOrderOriginService collectOrderOriginService;
|
|
|
@Resource
|
|
|
IoCollectOrderBizOriginService collectOrderBizOriginService;
|
|
|
|
|
|
@Resource
|
|
|
IoCollectOrderBackupService ioCollectOrderBackupService;
|
|
|
@Resource
|
|
|
IoCollectSetService collectSetService;
|
|
|
|
|
|
@Resource
|
|
|
SpGetHttpClient spGetHttpClient;
|
|
|
@Resource
|
|
|
DownloadFactory downloadFactory;
|
|
|
@Resource
|
|
|
UdiRelevanceDao udiRelevanceDao;
|
|
|
|
|
|
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);
|
|
|
orderDetailResultService.deleteByOrderId(billNo);
|
|
|
codeTempService.deleteByBillNo(billNo);
|
|
|
codeService.deleteCodeByOrderId(billNo);
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
|
|
|
// TODO: 2024/10/14 下载本地单据类型
|
|
|
public BaseResponse importUdi(CollectOrderRequest collectOrderRequest) {
|
|
|
|
|
|
FilterOrderRequest filterOrderRequest = new FilterOrderRequest();
|
|
|
filterOrderRequest.setStatus(10);
|
|
|
filterOrderRequest.setAction(collectOrderRequest.getBusType());
|
|
|
filterOrderRequest.setProductType(null);
|
|
|
filterOrderRequest.setLimit(collectOrderRequest.getLimit());
|
|
|
filterOrderRequest.setPage(collectOrderRequest.getPage());
|
|
|
filterOrderRequest.setStartTime(collectOrderRequest.getStartTime());
|
|
|
filterOrderRequest.setEndTime(collectOrderRequest.getEndTime());
|
|
|
filterOrderRequest.setBillNo(collectOrderRequest.getBillNo());
|
|
|
filterOrderRequest.setFromCorp(collectOrderRequest.getFromCorpName());
|
|
|
filterOrderRequest.setAction(collectOrderRequest.getBusType());
|
|
|
filterOrderRequest.setKeyWords(collectOrderRequest.getKeyWords());
|
|
|
|
|
|
if (collectOrderRequest.getBusType().equals(ConstantType.SPLIT_OUT)) {
|
|
|
List<SysWorkplace> sysWorkplaceList = sysWorkplaceService.list(new LambdaQueryWrapper<SysWorkplace>().eq(SysWorkplace::getJobMode, 1));
|
|
|
if (CollUtil.isNotEmpty(sysWorkplaceList)) {
|
|
|
List<Long> workplaceCodes = sysWorkplaceList.stream().map(SysWorkplace::getWorkplaceId).collect(Collectors.toList());
|
|
|
filterOrderRequest.setWorkplaceCodes(workplaceCodes);
|
|
|
filterOrderRequest.setStatus(7);
|
|
|
}
|
|
|
}
|
|
|
List<IoOrderResponse> list = orderService.filterList(filterOrderRequest);
|
|
|
List<IoCollectOrder> allotCollects = new ArrayList<>();
|
|
|
List<IoCollectOrderBiz> allotCollectBizs = new ArrayList<>();
|
|
|
if (list == null) {
|
|
|
return ResultVOUtils.error(500, "未查到此业务单据");
|
|
|
}
|
|
|
|
|
|
for (IoOrderResponse ioOrderEntity : list) {
|
|
|
if (collectOrderMapper.exists(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, ioOrderEntity.getBillNo()))) {
|
|
|
continue;
|
|
|
}
|
|
|
if (collectOrderOriginMapper.exists(new LambdaQueryWrapper<IoCollectOrderOrigin>().eq(IoCollectOrderOrigin::getBillNo, ioOrderEntity.getBillNo()))) {
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity = sysWorkplaceDocumentService.findByBusType(ioOrderEntity.getAction());
|
|
|
if (sysWorkplaceDocumentEntity == null) continue;
|
|
|
String mainAction = ioOrderEntity.getMainAction();
|
|
|
String fromCorpName = "";
|
|
|
String shipperName = "";
|
|
|
if (mainAction.equals(ConstantType.TYPE_PUT)) {
|
|
|
shipperName = ioOrderEntity.getFromName();
|
|
|
fromCorpName = ioOrderEntity.getDeptName();
|
|
|
} else {
|
|
|
shipperName = ioOrderEntity.getDeptName();
|
|
|
fromCorpName = ioOrderEntity.getFromName();
|
|
|
}
|
|
|
IoCollectOrder collectOrder = IoCollectOrder.builder().workPlaceCode(ioOrderEntity.getWorkPlaceCode()).billNo(ioOrderEntity.getBillNo()).fromType("药械追溯管理系统").busType(ioOrderEntity.getAction()).fromCorp(ioOrderEntity.getFromName()).fromCorpName(fromCorpName).billTime(ioOrderEntity.getCreateTime()).shipperName(shipperName).createTime(ioOrderEntity.getCreateTime()).createUser(ioOrderEntity.getCreateUser()).updateTime(new Date()).orderCirType(sysWorkplaceDocumentEntity.getOrderCirType()).splitStatus(0).tagStatus(1).remark(ioOrderEntity.getRemark()).build();
|
|
|
if (collectOrder.getWorkPlaceCode() != null) {
|
|
|
collectOrder.setTagStatus(1);
|
|
|
}
|
|
|
save(collectOrder);
|
|
|
IoCollectOrderOrigin ioCollectOrderOrigin = new IoCollectOrderOrigin();
|
|
|
BeanUtils.copyProperties(collectOrder, ioCollectOrderOrigin);
|
|
|
ioCollectOrderOrigin.setTagStatus(2);
|
|
|
collectOrderOriginService.saveOrUpdate(ioCollectOrderOrigin);
|
|
|
|
|
|
List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(ioOrderEntity.getBillNo());
|
|
|
List<IoCollectOrderBiz> collectOrderBizs = new ArrayList<>();
|
|
|
List<IoCollectOrderBizOrigin> collectOrderOriginBizs = 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);
|
|
|
IoCollectOrderBizOrigin ioCollectOrderBizOrigin = new IoCollectOrderBizOrigin();
|
|
|
BeanUtils.copyProperties(collectOrderBiz, ioCollectOrderBizOrigin);
|
|
|
ioCollectOrderBizOrigin.setId(null);
|
|
|
collectOrderOriginBizs.add(ioCollectOrderBizOrigin);
|
|
|
}
|
|
|
if (CollUtil.isNotEmpty(collectOrderBizs)) {
|
|
|
collectOrderBizService.saveBatch(collectOrderBizs);
|
|
|
}
|
|
|
if (CollUtil.isNotEmpty(collectOrderOriginBizs)) {
|
|
|
collectOrderBizOriginService.saveBatch(collectOrderOriginBizs);
|
|
|
}
|
|
|
|
|
|
//导入扫码明细
|
|
|
List<IoCodeEntity> codeEntities = codeService.findByOrderId(ioOrderEntity.getBillNo());
|
|
|
List<IoCollectOrderCodeMan> collectOrderCodeManList = new ArrayList<>();
|
|
|
if (CollUtil.isNotEmpty(codeEntities)) {
|
|
|
for (IoCodeEntity codeEntity : codeEntities) {
|
|
|
IoCollectOrderBiz mCollectOrderBiz = null;
|
|
|
for (IoCollectOrderBiz collectOrderBiz : collectOrderBizs) {
|
|
|
if (collectOrderBiz.getRelId().equals(codeEntity.getRelId()) && StrUtil.trimToEmpty(collectOrderBiz.getBatchNo()).equals(StrUtil.trimToEmpty(codeEntity.getBatchNo()))) {
|
|
|
mCollectOrderBiz = collectOrderBiz;
|
|
|
continue;
|
|
|
}
|
|
|
}
|
|
|
collectOrderCodeManList.add(IoCollectOrderCodeMan.builder().udiCode(codeEntity.getCode()).orderIdFk(collectOrder.getBillNo()).bizIdFk(mCollectOrderBiz == null ? null : mCollectOrderBiz.getId()).relId(codeEntity.getRelId()).nameCode(codeEntity.getNameCode()).batchNo(codeEntity.getBatchNo()).serialNo(codeEntity.getSerialNo()).productDate(codeEntity.getProduceDate()).expireDate(codeEntity.getExpireDate()).createTime(new Date()).createUser(1l).updateTime(new Date()).updateUser(1l).scanCount(1).isSplitCode(false).scanActCount(codeEntity.getMyReCount()).build());
|
|
|
}
|
|
|
collectOrderCodeManService.saveBatch(collectOrderCodeManList);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (CollUtil.isNotEmpty(allotCollects)) {
|
|
|
saveBatch(allotCollects);
|
|
|
collectOrderBizService.saveBatch(allotCollectBizs);
|
|
|
}
|
|
|
|
|
|
return ResultVOUtils.success("下载成功");
|
|
|
}
|
|
|
|
|
|
|
|
|
@Resource
|
|
|
HeartService heartService;
|
|
|
@Resource
|
|
|
SpGetHttpClient spGetHttp;
|
|
|
|
|
|
// TODO: 2024/10/14 下载本地单据类型
|
|
|
public BaseResponse importSpmsUdi(CollectOrderRequest collectOrderRequest) {
|
|
|
ReviewSpmsRequest reviewSpmsRequest = new ReviewSpmsRequest();
|
|
|
reviewSpmsRequest.setBillNo(collectOrderRequest.getBillNo());
|
|
|
reviewSpmsRequest.setAction(collectOrderRequest.getBusType());
|
|
|
|
|
|
//获取自助平台待审核单据，并插入到数据库
|
|
|
BaseResponse<SpsSyncOrderResponse> baseResponse = spGetHttp.getReviewOrder(reviewSpmsRequest, 1 + "");
|
|
|
if (baseResponse.getCode() == 20000) {
|
|
|
SpsSyncOrderResponse spsSyncOrderResponse = baseResponse.getData();
|
|
|
List<IoOrderEntity> orderEntities = spsSyncOrderResponse.getOrderEntities();
|
|
|
if (CollUtil.isNotEmpty(orderEntities)) {
|
|
|
IoOrderEntity orderEntity;
|
|
|
orderEntity = orderEntities.get(0);
|
|
|
orderEntity.setUpdateTime(null);
|
|
|
orderEntity.setFromType(ConstantStatus.FROM_UDISP);
|
|
|
orderEntity.setReviewSp(true);
|
|
|
// orderEntity.setStatus(ConstantStatus.ORDER_STATUS_PROCESS);
|
|
|
IoOrderEntity temp = orderService.findByBillNo(orderEntity.getBillNo());
|
|
|
if (temp == null) {
|
|
|
orderEntity.setId(null);
|
|
|
orderService.insertOrder(orderEntity);
|
|
|
heartService.insetOrderDb(spsSyncOrderResponse, orderEntity);
|
|
|
// orderEntity = orderService.findByBillNo(orderEntity.getBillNo());
|
|
|
// addInoutService.dealProcess(orderEntity);
|
|
|
// orderEntity = orderService.findByBillNo(orderEntity.getBillNo());
|
|
|
// if (orderEntity.getStatus() != ConstantStatus.ORDER_STATS_ERROR && !ioCheckInoutService.checkManual(orderEntity.getBillNo())) {
|
|
|
// ioCheckInoutService.check(orderEntity.getBillNo());
|
|
|
// }
|
|
|
}
|
|
|
orderEntity = orderService.findByBillNo(orderEntity.getBillNo());
|
|
|
collectOrderRequest.setBillNo(orderEntity.getBillNo());
|
|
|
if (orderEntity.getStatus() != ConstantStatus.ORDER_STATUS_CHECK_REW) {
|
|
|
return ResultVOUtils.error(500, "非待审核单据！");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
this.importUdi(collectOrderRequest);
|
|
|
}
|
|
|
return baseResponse;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
public BaseResponse<PageSimpleResponse<IoCollectOrder>> selectImportUdi(FilterOrderRequest filterOrderRequest) {
|
|
|
|
|
|
List<IoCollectOrder> ioCollectOrders = new ArrayList<>();
|
|
|
List<IoOrderResponse> list = orderService.filterList(filterOrderRequest);
|
|
|
PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(list);
|
|
|
|
|
|
int removedCount = 0; // 用于记录移除的元素数量
|
|
|
for (IoOrderResponse ioOrderEntity : list) {
|
|
|
if (collectOrderMapper.exists(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, ioOrderEntity.getBillNo()))) {
|
|
|
removedCount++;
|
|
|
continue;
|
|
|
}
|
|
|
SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity = sysWorkplaceDocumentService.findByBusType(ioOrderEntity.getAction());
|
|
|
if (sysWorkplaceDocumentEntity == null) continue;
|
|
|
String mainAction = ioOrderEntity.getMainAction();
|
|
|
String fromCorpName = "";
|
|
|
String shipperName = "";
|
|
|
if (mainAction.equals(ConstantType.TYPE_PUT)) {
|
|
|
shipperName = ioOrderEntity.getFromName();
|
|
|
fromCorpName = ioOrderEntity.getDeptName();
|
|
|
} else {
|
|
|
shipperName = ioOrderEntity.getDeptName();
|
|
|
fromCorpName = ioOrderEntity.getFromName();
|
|
|
}
|
|
|
IoCollectOrder collectOrder = IoCollectOrder.builder().billNo(ioOrderEntity.getBillNo()).fromType("药械追溯管理系统").busType(ioOrderEntity.getAction()).fromCorp(ioOrderEntity.getFromName()).fromCorpName(fromCorpName).billTime(ioOrderEntity.getCreateTime()).shipperName(shipperName).createTime(ioOrderEntity.getCreateTime()).createUser(ioOrderEntity.getCreateUser()).updateTime(new Date()).orderCirType(sysWorkplaceDocumentEntity.getOrderCirType()).splitStatus(0).tagStatus(0).remark(ioOrderEntity.getRemark()).build();
|
|
|
if (collectOrder.getWorkPlaceCode() != null) {
|
|
|
collectOrder.setTagStatus(1);
|
|
|
}
|
|
|
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).remark(bizEntity.getRemark()).unTagCount(bizEntity.getCount()).build();
|
|
|
|
|
|
if (IntUtil.value(udiRelevanceResponse.getProductsType()) == 2) {
|
|
|
collectOrderBiz.setGgxh(udiRelevanceResponse.getBzgg());
|
|
|
collectOrderBiz.setMeasureUnit(udiRelevanceResponse.getPrepnUnit());
|
|
|
}
|
|
|
collectOrderBizs.add(collectOrderBiz);
|
|
|
}
|
|
|
collectOrder.setBizList(collectOrderBizs);
|
|
|
ioCollectOrders.add(collectOrder);
|
|
|
}
|
|
|
|
|
|
PageInfo<IoCollectOrder> pageInfoReturn = new PageInfo<>(ioCollectOrders);
|
|
|
int newTotal = Math.toIntExact(pageInfo.getTotal() - removedCount);
|
|
|
pageInfo.setTotal(newTotal);
|
|
|
BeanUtils.copyProperties(pageInfo, pageInfoReturn);
|
|
|
pageInfoReturn.setList(ioCollectOrders);
|
|
|
return ResultVOUtils.success(pageInfoReturn);
|
|
|
}
|
|
|
|
|
|
|
|
|
// 添加一个用于同步的Map，存储正在处理的单号
|
|
|
private static final Map<String, Object> BILL_LOCKS = new ConcurrentHashMap<>();
|
|
|
|
|
|
public void importPrescribe(List<BasicSkPrescribeEntity> basicSkPrescribeEntities) {
|
|
|
//下载处方
|
|
|
if (CollUtil.isEmpty(basicSkPrescribeEntities)) basicSkPrescribeEntities = basicSkPrescribeService.list();
|
|
|
List<SysWorkplaceResponse> allWorksList = new ArrayList<>();
|
|
|
for (BasicSkPrescribeEntity basicSkPrescribeEntity : basicSkPrescribeEntities) {
|
|
|
// 获取单号
|
|
|
String billNo = basicSkPrescribeEntity.getCode();
|
|
|
// 为每个单号创建一个锁对象，如果已存在则使用现有的
|
|
|
Object billLock = BILL_LOCKS.computeIfAbsent(billNo, k -> new Object());
|
|
|
// 使用同步块确保同一单号的处理是同步的
|
|
|
synchronized (billLock) {
|
|
|
try {
|
|
|
if (collectOrderMapper.exists(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, billNo))) {
|
|
|
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(billNo).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).remark(basicSkPrescribeEntity.getRemark()).build();
|
|
|
if (collectOrder.getWorkPlaceCode() != null) {
|
|
|
collectOrder.setTagStatus(1);
|
|
|
}
|
|
|
save(collectOrder);
|
|
|
List<BasicSkPrescribeItemEntity> basicSkPrescribeItemEntities = basicSkPrescirbeDetailService.findByPrescribeNum(billNo);
|
|
|
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(billNo, 1);
|
|
|
}
|
|
|
} finally {
|
|
|
// 处理完成后，移除锁对象，释放内存
|
|
|
BILL_LOCKS.remove(billNo);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
@Resource
|
|
|
CustomerService customerService;
|
|
|
|
|
|
|
|
|
/**
|
|
|
* 单据回填
|
|
|
*
|
|
|
* @param ioCollectOrderList
|
|
|
*/
|
|
|
// @Transactional(rollbackFor = Exception.class, isolation = Isolation.READ_COMMITTED)
|
|
|
public void importPrescribe(List<IoCollectOrder> ioCollectOrderList, CollectOrderRequest collectOrderRequest) {
|
|
|
String addr = collectOrderRequest.getBusType();
|
|
|
if (CollUtil.isNotEmpty(ioCollectOrderList)) {
|
|
|
//是否自动转成待处理单据
|
|
|
IoCollectSet collectSet = collectSetService.getSet();
|
|
|
|
|
|
for (IoCollectOrder collectOrder : ioCollectOrderList) {
|
|
|
// 获取单号
|
|
|
String billNo = collectOrder.getBillNo();
|
|
|
// 为每个单号创建一个锁对象，如果已存在则使用现有的
|
|
|
Object billLock = BILL_LOCKS.computeIfAbsent(billNo, k -> new Object());
|
|
|
// 使用同步块确保同一单号的处理是同步的
|
|
|
synchronized (billLock) {
|
|
|
try {
|
|
|
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;
|
|
|
}
|
|
|
|
|
|
collectOrder.setOrderCirType(sysWorkplaceDocumentEntity.getOrderCirType());
|
|
|
BeanUtils.copyProperties(collectOrder, ioCollectOrderOrigin);
|
|
|
collectOrderOriginService.remove(new LambdaUpdateWrapper<IoCollectOrderOrigin>().eq(IoCollectOrderOrigin::getBillNo, ioCollectOrderOrigin.getBillNo()));
|
|
|
collectOrderOriginService.save(ioCollectOrderOrigin);
|
|
|
List<IoCollectOrderBiz> bizList = collectOrder.getBizList();
|
|
|
if (CollUtil.isNotEmpty(bizList)) {
|
|
|
//先清空 原来的biz
|
|
|
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.remove(new LambdaUpdateWrapper<IoCollectOrderBizOrigin>().eq(IoCollectOrderBizOrigin::getOrderIdFk, billNo));
|
|
|
collectOrderBizOriginService.saveBatch(ioCollectOrderBizOrigins);
|
|
|
}
|
|
|
|
|
|
if (!collectOrder.getTagStatus().equals(4) && (IntUtil.value(collectSet.getAutoDealOrder()) || IntUtil.value(collectOrderRequest.getForceAllot()))) {//没出现耗材不匹配 且 开启了自动转成待处理单据
|
|
|
collectOrder.setTagStatus(1);
|
|
|
boolean isExit = collectOrderMapper.exists(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, collectOrder.getBillNo()).eq(IoCollectOrder::getBusType, collectOrder.getBusType()));
|
|
|
if (!isExit) {
|
|
|
collectOrderMapper.insert(collectOrder);
|
|
|
collectOrderBizService.saveBatch(bizList);
|
|
|
}
|
|
|
}
|
|
|
} finally {
|
|
|
// 处理完成后，移除锁对象，释放内存
|
|
|
BILL_LOCKS.remove(billNo);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@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有误");
|
|
|
List<UdiRelevanceResponse> udiRelevanceResponses = udiRelevanceService.selectGroupByNameCode(ioCollectOrderCodeMan.getNameCode(), null);
|
|
|
IoCollectOrder ioCollectOrder = collectOrderMapper.selectOne(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, ioCollectOrderCodeMan.getOrderIdFk()));
|
|
|
String busType = ioCollectOrder.getBusType();
|
|
|
Long workPlaceCode = ioCollectOrder.getWorkPlaceCode();
|
|
|
SysWorkplaceDocumentEntity byWorkplaceCode = sysWorkplaceDocumentService.findByWorkplaceCode(workPlaceCode, busType);
|
|
|
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);
|
|
|
if (IntUtil.value(byWorkplaceCode.getOrderCirType()) == 1) {
|
|
|
ioCollectOrderCodeMan.setScanActCount(IntUtil.value(ioCollectOrderCodeMan.getScanActCount()) - delCount * udiCalCountUtil.getCirActCount(udiRelevanceResponses.get(0)));
|
|
|
} else {
|
|
|
ioCollectOrderCodeMan.setScanActCount(IntUtil.value(ioCollectOrderCodeMan.getScanActCount()) - delCount * udiCalCountUtil.getUseActCount(udiRelevanceResponses.get(0)));
|
|
|
}
|
|
|
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("扫码详情未查找到");
|
|
|
//反查单据类型 查看是否来源业务单
|
|
|
|
|
|
if (ioCollectOrder == null) throw new JsonException("反查单据失败");
|
|
|
|
|
|
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);
|
|
|
|
|
|
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();
|
|
|
}
|
|
|
|
|
|
SysWorkplacePutRelService sysWorkplacePutRelService;
|
|
|
|
|
|
@Transactional(rollbackFor = Exception.class)
|
|
|
public void finishOrder(CollectOrderRequest collectOrderRequest, AuthAdmin authAdmin, Boolean isAuto) {
|
|
|
IoCollectOrder collectOrder = new IoCollectOrder();
|
|
|
BeanUtils.copyProperties(collectOrderRequest, collectOrder);
|
|
|
collectOrder.setTagStatus(3);
|
|
|
collectOrder.setUpdateTime(new Date());
|
|
|
SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity = sysWorkplaceDocumentService.getOne(new LambdaQueryWrapper<SysWorkplaceDocumentEntity>().eq(SysWorkplaceDocumentEntity::getDocumentTypeCode, collectOrderRequest.getBusType()));
|
|
|
if (sysWorkplaceDocumentEntity.getScanType() == 1) {
|
|
|
IoCollectOrder collectOrder1 = getOne(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, collectOrderRequest.getBillNo()));
|
|
|
collectOrder1.setTagStatus(3);
|
|
|
collectOrder1.setUpdateTime(new Date());
|
|
|
updateById(collectOrder1);
|
|
|
collectOrder = collectOrder1;
|
|
|
ArrayList<IoCollectOrderBizBackup> ioCollectOrderBizBackups = new ArrayList<>();
|
|
|
List<IoCollectOrderBiz> collectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());
|
|
|
for (IoCollectOrderBiz ioCollectOrderBiz : collectOrderBizs) {
|
|
|
IoCollectOrderBizBackup ioCollectOrderBizBackup = new IoCollectOrderBizBackup();
|
|
|
BeanUtils.copyProperties(ioCollectOrderBiz, ioCollectOrderBizBackup);
|
|
|
ioCollectOrderBizBackup.setId(ioCollectOrderBiz.getId());
|
|
|
ioCollectOrderBizBackups.add(ioCollectOrderBizBackup);
|
|
|
}
|
|
|
ioCollectOrderBizBackupService.saveBatch(ioCollectOrderBizBackups);
|
|
|
|
|
|
if (sysWorkplaceDocumentEntity.getDocumentTypeCode().equals(ConstantType.SPLIT_OUT)) {
|
|
|
splitCodeService.finishSellOrder(collectOrder, collectOrder.getWorkPlaceCode());
|
|
|
}
|
|
|
} else {
|
|
|
if (sysWorkplaceDocumentEntity.getDocumentTypeCode().startsWith("QXCF")) {
|
|
|
splitQxService.finishQxAutoTagCode(collectOrder, isAuto, collectOrderRequest.getQueueCode());
|
|
|
} else if (sysWorkplaceDocumentEntity.getDocumentTypeCode().equals(ConstantType.SPLIT_OUT)) {
|
|
|
splitCodeService.finishSellOrder(collectOrder, collectOrder.getWorkPlaceCode());
|
|
|
} else {
|
|
|
splitCodeService.finishAutoTagCode(collectOrder, isAuto, collectOrderRequest.getQueueCode());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//插入备用表
|
|
|
IoCollectOrderBackup ioCollectOrderBackup = new IoCollectOrderBackup();
|
|
|
BeanUtils.copyProperties(collectOrder, ioCollectOrderBackup);
|
|
|
ioCollectOrderBackup.setCheckCodeStatus(0);
|
|
|
ioCollectOrderBackup.setCheckCodeConfirm(0);
|
|
|
ioCollectOrderBackupService.save(ioCollectOrderBackup);
|
|
|
//todo 备份码表
|
|
|
IoCollectOrder finalCollectOrder = collectOrder;
|
|
|
//插入到码表
|
|
|
collectCodeService.insertCodesByBill(collectOrderRequest.getBillNo(), collectOrderRequest.getIsCheckFinish());
|
|
|
//删除原来单据
|
|
|
removeOrderByBillNo(finalCollectOrder);
|
|
|
|
|
|
//校验拆零是否都已赋码
|
|
|
splitCodeService.delaySplitVail(ioCollectOrderBackup);
|
|
|
|
|
|
//更新数据至第三方系统
|
|
|
//单据更新
|
|
|
if (IntUtil.value(sysWorkplaceDocumentEntity.getUploadIsMatching()) == 0 && StrUtil.isNotEmpty(sysWorkplaceDocumentEntity.getUploadDocumentTypeCode())) {
|
|
|
ioCollectOrderBackupService.uploadInnerOrder(ioCollectOrderBackup, sysWorkplaceDocumentEntity);
|
|
|
}
|
|
|
if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 1 && sysWorkplaceDocumentEntity.getScanType() != 1) {
|
|
|
ioCollectOrderBackupService.updateSpmsOrder(collectOrderRequest.getBillNo(), authAdmin);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
@Transactional(rollbackFor = Exception.class)
|
|
|
public void confirmFinishOrder(CollectOrderRequest collectOrderRequest, AuthAdmin authAdmin) {
|
|
|
IoCollectOrder collectOrder = new IoCollectOrder();
|
|
|
BeanUtils.copyProperties(collectOrderRequest, collectOrder);
|
|
|
collectOrder.setTagStatus(3);
|
|
|
collectOrder.setUpdateTime(new Date());
|
|
|
|
|
|
//插入备用表
|
|
|
IoCollectOrderBackup ioCollectOrderBackup = new IoCollectOrderBackup();
|
|
|
BeanUtils.copyProperties(collectOrder, ioCollectOrderBackup);
|
|
|
ioCollectOrderBackupService.save(ioCollectOrderBackup);
|
|
|
ArrayList<IoCollectOrderBizBackup> ioCollectOrderBizBackups = new ArrayList<>();
|
|
|
List<IoCollectOrderBiz> collectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());
|
|
|
for (IoCollectOrderBiz ioCollectOrderBiz : collectOrderBizs) {
|
|
|
IoCollectOrderBizBackup ioCollectOrderBizBackup = new IoCollectOrderBizBackup();
|
|
|
BeanUtils.copyProperties(ioCollectOrderBiz, ioCollectOrderBizBackup);
|
|
|
ioCollectOrderBizBackups.add(ioCollectOrderBizBackup);
|
|
|
}
|
|
|
ioCollectOrderBizBackupService.saveBatch(ioCollectOrderBizBackups);
|
|
|
|
|
|
//删除原来单据
|
|
|
removeOrderByBillNo(collectOrder);
|
|
|
|
|
|
ThreadUtil.execAsync(() -> {
|
|
|
//插入到码表
|
|
|
collectCodeService.insertCodesByBill(collectOrderRequest.getBillNo(), null);
|
|
|
//更新数据至第三方系统
|
|
|
//单据更新
|
|
|
ioCollectOrderBackupService.generateOrder(collectOrder.getBillNo(), authAdmin);
|
|
|
});
|
|
|
}
|
|
|
|
|
|
|
|
|
@Transactional(rollbackFor = Exception.class, isolation = Isolation.READ_COMMITTED)
|
|
|
public 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;
|
|
|
|
|
|
@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, Long userId) {
|
|
|
//判断当前用户是否已经绑定该工位
|
|
|
SysWorkplace workplace = sysWorkplaceService.getWorkplaceByUser(request, userId);
|
|
|
if (workplace == null) {
|
|
|
throw new JsonException(500, "当前用户未绑定该工位");
|
|
|
}
|
|
|
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;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
public void xlsxUpload(MultipartFile file) {
|
|
|
|
|
|
try {
|
|
|
String fileName = file.getOriginalFilename();
|
|
|
String suffix = FileUtil.getSuffix(fileName);
|
|
|
if (!"xlsx".equals(suffix)) {
|
|
|
throw new JsonException("仅支持.xlsx，文件类型错误" + suffix);
|
|
|
}
|
|
|
if (file.getSize() > 5 * 1024 * 1024) {
|
|
|
throw new JsonException("上传文件超过5M");
|
|
|
}
|
|
|
} catch (Exception e) {
|
|
|
throw new JsonException("上传失败：" + e.getMessage());
|
|
|
}
|
|
|
|
|
|
|
|
|
List<VA010Mx> a010details = this.getList(file);
|
|
|
if (CollUtil.isEmpty(a010details)) {
|
|
|
throw new JsonException("文件数据为空");
|
|
|
}
|
|
|
|
|
|
Map<String, List<VA010Mx>> detailsMap = a010details.stream().collect(Collectors.groupingBy(VA010Mx::getCodefk));
|
|
|
|
|
|
|
|
|
List<IoCollectOrder> ioCollectOrders = new ArrayList<>();
|
|
|
Map<String, List<VA010Mx>> finalDetailsMap = detailsMap;
|
|
|
for (Map.Entry<String, List<VA010Mx>> entry : finalDetailsMap.entrySet()) {
|
|
|
List<IoCollectOrderBiz> bizList = new ArrayList<>();
|
|
|
String billNo = entry.getKey();
|
|
|
List<VA010Mx> itemDetails = entry.getValue();
|
|
|
VA010Mx item = itemDetails.get(0);
|
|
|
|
|
|
StringBuilder errorMsg = new StringBuilder();
|
|
|
IoCollectOrder ioCollectOrder = new IoCollectOrder();
|
|
|
ioCollectOrder.setBillNo(item.getCodefk());
|
|
|
ioCollectOrder.setFromType("HIS系统");
|
|
|
ioCollectOrder.setFromCorp(item.getDeptcode());
|
|
|
ioCollectOrder.setWorkPlaceCode(null);
|
|
|
ioCollectOrder.setFromCorpName(item.getSickname());
|
|
|
ioCollectOrder.setShipperName(item.getDeptname());
|
|
|
ioCollectOrder.setBusType("YPCF002");
|
|
|
Date date = null;
|
|
|
try {
|
|
|
date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(item.getPrescribedate());
|
|
|
} catch (ParseException e) {
|
|
|
|
|
|
}
|
|
|
ioCollectOrder.setBillTime(date);
|
|
|
ioCollectOrder.setCreateTime(new Date());
|
|
|
ioCollectOrder.setCreateUser(String.valueOf(customerService.getUserId()));
|
|
|
ioCollectOrder.setBackupOrderRemark1(item.getCodefk());
|
|
|
ioCollectOrder.setUpdateTime(new Date());
|
|
|
ioCollectOrder.setSplitStatus(0);
|
|
|
ioCollectOrder.setTagStatus(0);
|
|
|
|
|
|
if (CollUtil.isNotEmpty(itemDetails)) {
|
|
|
itemDetails.forEach(entity -> {
|
|
|
IoCollectOrderBiz collectOrderBiz = new IoCollectOrderBiz();
|
|
|
BeanUtils.copyProperties(entity, collectOrderBiz);
|
|
|
|
|
|
List<UdiRelevanceEntity> basicUdirelEntities = udiRelevanceDao.selectList(new LambdaQueryWrapper<UdiRelevanceEntity>().eq(UdiRelevanceEntity::getMainId, entity.getItemcode()));
|
|
|
if (CollUtil.isNotEmpty(basicUdirelEntities)) {
|
|
|
UdiRelevanceEntity basicUdirelEntity = basicUdirelEntities.get(0);
|
|
|
collectOrderBiz.setRelId(basicUdirelEntity.getId());
|
|
|
} else {
|
|
|
errorMsg.append(entity.getItemname()).append("字典未对照").append(";");
|
|
|
}
|
|
|
|
|
|
collectOrderBiz.setGgxh(entity.getBzgg());
|
|
|
collectOrderBiz.setMeasureUnit(entity.getMeasureunit());
|
|
|
collectOrderBiz.setCount(IntUtil.value(entity.getCount()));
|
|
|
collectOrderBiz.setThrCode(entity.getHiltstCode());
|
|
|
collectOrderBiz.setYbbm(entity.getHiltstCode());
|
|
|
collectOrderBiz.setCpmctymc(entity.getItemname());
|
|
|
collectOrderBiz.setOrderIdFk(ioCollectOrder.getBillNo());
|
|
|
collectOrderBiz.setNameCode(entity.getHiltstCode());
|
|
|
collectOrderBiz.setTagStatus(1);
|
|
|
collectOrderBiz.setUnTagCount(0);
|
|
|
bizList.add(collectOrderBiz);
|
|
|
});
|
|
|
|
|
|
}
|
|
|
if (StrUtil.isNotBlank(errorMsg)) {
|
|
|
ioCollectOrder.setErrorMsg(errorMsg.toString());
|
|
|
ioCollectOrder.setTagStatus(4);
|
|
|
}
|
|
|
ioCollectOrder.setBizList(this.summarizeByCode(bizList));
|
|
|
ioCollectOrders.add(ioCollectOrder);
|
|
|
|
|
|
}
|
|
|
|
|
|
if (CollUtil.isNotEmpty(ioCollectOrders)) {
|
|
|
CollectOrderRequest collectOrderRequest = new CollectOrderRequest();
|
|
|
|
|
|
collectOrderRequest.setBusType("YPCF002");
|
|
|
collectOrderRequest.setCreateUser(String.valueOf(customerService.getUserId()));
|
|
|
collectOrderRequest.setWorkPlaceCode(null);
|
|
|
downloadFactory.importThrOrder(ioCollectOrders, collectOrderRequest);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
public List<VA010Mx> getList(MultipartFile file) {
|
|
|
List<VA010Mx> entities = new ArrayList<>();
|
|
|
|
|
|
try (InputStream inputStream = file.getInputStream()) {
|
|
|
EasyExcel.read(inputStream, VA010Mx.class, new AnalysisEventListener<VA010Mx>() {
|
|
|
|
|
|
@Override
|
|
|
public void invoke(VA010Mx data, AnalysisContext context) {
|
|
|
entities.add(data);
|
|
|
}
|
|
|
|
|
|
@Override
|
|
|
public void doAfterAllAnalysed(AnalysisContext context) {
|
|
|
// 所有数据解析完成后的操作，可以在这里进行后续处理
|
|
|
// 比如：保存数据到数据库
|
|
|
}
|
|
|
|
|
|
// 可以选择性地覆盖其他方法，比如处理表头、异常等
|
|
|
}).sheet().doRead();
|
|
|
} catch (IOException e) {
|
|
|
e.printStackTrace();
|
|
|
}
|
|
|
|
|
|
return entities;
|
|
|
}
|
|
|
|
|
|
|
|
|
public static List<IoCollectOrderBiz> summarizeByCode(List<IoCollectOrderBiz> bizList) {
|
|
|
Map<String, IoCollectOrderBiz> summarizedMap = new HashMap<>();
|
|
|
|
|
|
for (IoCollectOrderBiz biz : bizList) {
|
|
|
String code = biz.getThrCode();
|
|
|
|
|
|
if (summarizedMap.containsKey(code)) {
|
|
|
IoCollectOrderBiz existingBiz = summarizedMap.get(code);
|
|
|
existingBiz.setCount(existingBiz.getCount() + biz.getCount());
|
|
|
} else {
|
|
|
summarizedMap.put(code, biz);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return new ArrayList<>(summarizedMap.values());
|
|
|
}
|
|
|
}
|
