9/11 已完成处方修改

dev_no_inv
wangwei 10 months ago
parent 50987f7f7e
commit 717ff55dd6

@ -0,0 +1,103 @@
package com.glxp.api.controller.collect;
import cn.hutool.core.util.StrUtil;
import com.github.pagehelper.PageInfo;
import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.common.util.ResultVOUtils;
import com.glxp.api.controller.BaseController;
import com.glxp.api.entity.collect.IoCollectOrder;
import com.glxp.api.entity.collect.IoCollectOrderBackup;
import com.glxp.api.req.basic.BasicCollectUserRequest;
import com.glxp.api.req.collect.CollectOrderBizRequest;
import com.glxp.api.req.collect.CollectOrderRequest;
import com.glxp.api.res.PageSimpleResponse;
import com.glxp.api.res.basic.UserWorkResponse;
import com.glxp.api.res.collect.CollectOrderBizResponse;
import com.glxp.api.res.collect.IoCollectOrderResponse;
import com.glxp.api.service.basic.BasicCollectUserService;
import com.glxp.api.service.collect.IoCollectOrderBackupService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.List;
import java.util.stream.Collectors;
/**
* @author : zhu
* @date : 2024/9/11 10:36
* @modyified By :
*/
@RestController
public class IoCollectOrderBackupController extends BaseController {
@Resource
IoCollectOrderBackupService ioCollectOrderBackupService;
@Resource
private BasicCollectUserService basicCollectUserService;
@GetMapping("/udiwms/basic/collect/orderFinish/filter")
public BaseResponse filterOrder(CollectOrderRequest collectOrderRequest) {
List<Long> workPlaceCodes = null;
List<UserWorkResponse> page;
if (collectOrderRequest.getWorkPlaceCode() == null) {
Long userId = getUserId();
BasicCollectUserRequest request = new BasicCollectUserRequest();
request.setPage(1);
request.setLimit(100);
request.setUserId(userId.toString());
page = basicCollectUserService.filterList(request);
if (page != null) {
workPlaceCodes = page.stream()
.map(UserWorkResponse::getWorkplaceId)
.collect(Collectors.toList());
}
collectOrderRequest.setWorkPlaceCodes(workPlaceCodes);
}
List<IoCollectOrderResponse> orderResponses = ioCollectOrderBackupService.filterList(collectOrderRequest);
PageInfo<IoCollectOrderResponse> pageInfo = new PageInfo<>(orderResponses);
PageSimpleResponse<IoCollectOrderResponse> pageSimpleResponse = new PageSimpleResponse<>();
pageSimpleResponse.setTotal(pageInfo.getTotal());
pageSimpleResponse.setList(orderResponses);
return ResultVOUtils.success(pageSimpleResponse);
}
@GetMapping("/udiwms/basic/collect/orderFinish/detail")
public BaseResponse allDetail(CollectOrderBizRequest collectOrderBizRequest) {
if (StrUtil.isBlank(collectOrderBizRequest.getOrderIdFk())) {
return ResultVOUtils.error(500, "单据号不能为空");
}
IoCollectOrderBackup collectOrder = ioCollectOrderBackupService.getByBillNo(collectOrderBizRequest.getOrderIdFk());
if (collectOrder == null) {
return ResultVOUtils.error(500, "未找到单据");
}
List<CollectOrderBizResponse> collectOrderBizResponses = ioCollectOrderBackupService.combieOrderDetail(collectOrderBizRequest);
PageInfo<CollectOrderBizResponse> pageInfo = new PageInfo<>(collectOrderBizResponses);
PageSimpleResponse<CollectOrderBizResponse> pageSimpleResponse = new PageSimpleResponse<>();
pageSimpleResponse.setTotal(pageInfo.getTotal());
pageSimpleResponse.setList(collectOrderBizResponses);
return ResultVOUtils.success(pageSimpleResponse);
}
/**
*
* @param collectOrderRequest
* @return
*/
@PostMapping("/udiwms/basic/collect/order/upload")
public BaseResponse orderUpload(@RequestBody CollectOrderRequest collectOrderRequest) {
if (StrUtil.isEmpty(collectOrderRequest.getBillNo()))
return ResultVOUtils.error(500, "单据号不能为空");
ioCollectOrderBackupService.orderUpload(collectOrderRequest.getBillNo());
return ResultVOUtils.success();
}
}

@ -358,12 +358,12 @@ public class IoCollectOrderController extends BaseController {
* @param collectOrderRequest
* @return
*/
@PostMapping("/udiwms/basic/collect/order/upload")
public BaseResponse orderUpload(@RequestBody CollectOrderRequest collectOrderRequest) {
if (StrUtil.isEmpty(collectOrderRequest.getBillNo()))
return ResultVOUtils.error(500, "单据号不能为空");
collectOrderService.orderUpload(collectOrderRequest.getBillNo());
return ResultVOUtils.success();
}
// @PostMapping("/udiwms/basic/collect/order/upload")
// public BaseResponse orderUpload(@RequestBody CollectOrderRequest collectOrderRequest) {
// if (StrUtil.isEmpty(collectOrderRequest.getBillNo()))
// return ResultVOUtils.error(500, "单据号不能为空");
// collectOrderService.orderUpload(collectOrderRequest.getBillNo());
// return ResultVOUtils.success();
// }
}

@ -13,4 +13,5 @@ import java.util.List;
@Mapper
public interface IoCollectOrderBackupMapper extends BaseMapper<IoCollectOrderBackup> {
List<IoCollectOrderResponse> filterList(CollectOrderRequest collectOrderRequest);
}

@ -3,10 +3,15 @@ package com.glxp.api.dao.collect;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.glxp.api.entity.collect.IoCollectOrderBizBackup;
import com.glxp.api.req.collect.CollectOrderBizRequest;
import com.glxp.api.res.collect.CollectOrderBizResponse;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
@Mapper
public interface IoCollectOrderBizBackupMapper extends BaseMapper<IoCollectOrderBizBackup> {
List<CollectOrderBizResponse> filterList(CollectOrderBizRequest collectOrderRequest);
}

@ -93,12 +93,12 @@ public class IoCollectOrderBackup implements Serializable {
@ApiModelProperty(value = "采集时间")
private Date collectTime;
/**
*
*/
@TableField(value = "collectCode")
@ApiModelProperty(value = "采集点编码")
private String collectCode;
// /**
// * 采集点编码
// */
// @TableField(value = "collectCode")
// @ApiModelProperty(value = "采集点编码")
// private String collectCode;
/**
*

@ -1,6 +1,7 @@
package com.glxp.api.req.collect;
import com.glxp.api.entity.collect.IoCollectOrder;
import com.glxp.api.entity.collect.IoCollectOrderBackup;
import lombok.Data;
import java.util.List;
@ -10,7 +11,7 @@ public class PostCollectOrderRequest {
private String thirdSys;
List<IoCollectOrder> collectOrderList;
List<IoCollectOrderBackup> collectOrderList;
}

@ -1,13 +1,293 @@
package com.glxp.api.service.collect;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
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.constant.Constant;
import com.glxp.api.constant.ConstantStatus;
import com.glxp.api.dao.collect.IoCollectOrderBackupMapper;
import com.glxp.api.dao.inout.IoCodeTempDao;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.basic.CompanyProductRelevanceEntity;
import com.glxp.api.entity.basic.SysWorkplaceDocumentEntity;
import com.glxp.api.entity.collect.*;
import com.glxp.api.entity.inout.IoCodeTempEntity;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.exception.JsonException;
import com.glxp.api.http.ErpBasicClient;
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.res.basic.BasicSkPrescribeResponse;
import com.glxp.api.res.collect.CollectOrderBizResponse;
import com.glxp.api.res.collect.IoCollectOrderResponse;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
import com.glxp.api.service.basic.SysWorkplaceDocumentService;
import com.glxp.api.service.basic.UdiRlSupService;
import com.glxp.api.service.inout.IoAddInoutService;
import com.glxp.api.service.inout.IoCheckInoutService;
import com.glxp.api.service.inout.IoOrderService;
import com.glxp.api.util.CustomUtil;
import com.glxp.api.util.GennerOrderUtils;
import com.glxp.api.util.IntUtil;
import com.glxp.api.util.OrderNoTypeBean;
import org.springframework.beans.BeanUtils;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;
@Service
public class IoCollectOrderBackupService extends ServiceImpl<IoCollectOrderBackupMapper, IoCollectOrderBackup> {
@Resource
IoCollectOrderBackupMapper ioCollectOrderBackupMapper;
@Resource
IoCollectOrderBizBackupService ioCollectOrderBizBackupService;
@Resource
IoCollectOrderCodeAutoService collectOrderCodeAutoService;
@Resource
IoCollectOrderCodeManService collectOrderCodeManService;
@Resource
SysWorkplaceDocumentService sysWorkplaceDocumentService;
@Resource
IBasicBussinessTypeService bussinessTypeService;
@Resource
private GennerOrderUtils gennerOrderUtils;
@Resource
IoOrderService orderService;
@Resource
private IoCodeTempDao codesTempDao;
@Resource
IoAddInoutService addInoutService;
@Resource
@Lazy
IoCheckInoutService ioCheckInoutService;
@Resource
private ErpBasicClient erpBasicClient;
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 = ioCollectOrderBackupMapper.filterList(collectOrderRequest);
return data;
}
public IoCollectOrderBackup getByBillNo(String billNo) {
return ioCollectOrderBackupMapper.selectOne(new LambdaQueryWrapper<IoCollectOrderBackup>().eq(IoCollectOrderBackup::getBillNo, billNo).last("limit 1"));
}
public int updateByBillNo(IoCollectOrderBackup collectOrder) {
return ioCollectOrderBackupMapper.update(collectOrder, new UpdateWrapper<IoCollectOrderBackup>().eq("billNo", collectOrder.getBillNo()));
}
public List<CollectOrderBizResponse> combieOrderDetail(CollectOrderBizRequest collectOrderBizRequest) {
List<CollectOrderBizResponse> list = ioCollectOrderBizBackupService.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;
}
@Transactional(rollbackFor = Exception.class)
public void generateOrder(String billNo) {
IoCollectOrderBackup 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<IoCollectOrderBackup> 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;
}
@Transactional(rollbackFor = Exception.class)
public void orderUpload(String billNo) {
IoCollectOrderBackup updateOrder = new IoCollectOrderBackup();
updateOrder.setBillNo(billNo);
try {
this.generateOrder(billNo);
updateOrder.setUploadStatus(2);
} catch (Exception e) {
updateOrder.setUploadStatus(3);
updateOrder.setUploadError(e.getMessage());
}
//更新状态
this.updateByBillNo(updateOrder);
}
}

@ -2,13 +2,34 @@ package com.glxp.api.service.collect;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.PageHelper;
import com.glxp.api.dao.collect.IoCollectOrderBizBackupMapper;
import com.glxp.api.entity.collect.IoCollectOrderBizBackup;
import com.glxp.api.req.collect.CollectOrderBizRequest;
import com.glxp.api.res.collect.CollectOrderBizResponse;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.List;
@Service
public class IoCollectOrderBizBackupService extends ServiceImpl<IoCollectOrderBizBackupMapper, IoCollectOrderBizBackup> {
@Resource
IoCollectOrderBizBackupMapper ioCollectOrderBizBackupMapper;
public List<CollectOrderBizResponse> filterList(CollectOrderBizRequest collectOrderRequest) {
if (collectOrderRequest == null) {
return Collections.emptyList();
}
if (collectOrderRequest.getPage() != null) {
int offset = (collectOrderRequest.getPage() - 1) * collectOrderRequest.getLimit();
PageHelper.offsetPage(offset, collectOrderRequest.getLimit());
}
List<CollectOrderBizResponse> data = ioCollectOrderBizBackupMapper.filterList(collectOrderRequest);
return data;
}
}

@ -128,6 +128,9 @@ public class IoCollectOrderService extends ServiceImpl<IoCollectOrderMapper, IoC
@Resource
IoCollectOrderBizOriginService collectOrderBizOriginService;
@Resource
IoCollectOrderBackupService ioCollectOrderBackupService;
public IoCollectOrder getByBillNo(String billNo) {
return collectOrderMapper.selectOne(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, billNo).last("limit 1"));
}
@ -622,7 +625,10 @@ public class IoCollectOrderService extends ServiceImpl<IoCollectOrderMapper, IoC
collectOrder.setUpdateTime(new Date());
updateByBillNo(collectOrder);
splitCodeService.finishAutoTagCode(collectOrder);
//插入备用表
IoCollectOrderBackup ioCollectOrderBackup = new IoCollectOrderBackup();
BeanUtils.copyProperties(collectOrder, ioCollectOrderBackup);
ioCollectOrderBackupService.save(ioCollectOrderBackup);
ThreadUtil.execAsync(() -> {
//插入到码表
collectCodeService.insertCodesByBill(collectOrderRequest.getBillNo());
@ -631,102 +637,100 @@ public class IoCollectOrderService extends ServiceImpl<IoCollectOrderMapper, IoC
}
@Resource
IoCollectOrderBackupService ioCollectOrderBackupService;
@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,"处方备用明细上传失败");
}
}
}
// @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;
@ -764,7 +768,7 @@ public class IoCollectOrderService extends ServiceImpl<IoCollectOrderMapper, IoC
IoCollectOrder updateOrder = new IoCollectOrder();
updateOrder.setBillNo(billNo);
try {
this.generateOrder(billNo);
// this.generateOrder(billNo);
updateOrder.setUploadStatus(2);
} catch (Exception e) {
updateOrder.setUploadStatus(3);

@ -9,10 +9,7 @@ import com.glxp.api.dao.inout.IoSplitCodeMapper;
import com.glxp.api.entity.basic.BasicSkPrescribeDiEntity;
import com.glxp.api.entity.basic.BasicSkPrescribeEntity;
import com.glxp.api.entity.basic.UdiRelevanceEntity;
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.collect.*;
import com.glxp.api.entity.inout.IoSplitCodeEntity;
import com.glxp.api.entity.inout.IoSplitFifoCodeEntity;
import com.glxp.api.entity.inout.IoSplitFifoInv;
@ -21,10 +18,7 @@ import com.glxp.api.req.inout.IoSplitCodeRequest;
import com.glxp.api.service.basic.BasicSkPrescribeDiService;
import com.glxp.api.service.basic.BasicSkPrescribeService;
import com.glxp.api.service.basic.UdiRelevanceService;
import com.glxp.api.service.collect.IoCollectOrderBizService;
import com.glxp.api.service.collect.IoCollectOrderCodeAutoService;
import com.glxp.api.service.collect.IoCollectOrderCodeManService;
import com.glxp.api.service.collect.IoCollectOrderService;
import com.glxp.api.service.collect.*;
import com.glxp.api.util.IntUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
@ -371,12 +365,13 @@ public class IoSplitCodeService extends ServiceImpl<IoSplitCodeMapper, IoSplitCo
IoCollectOrderCodeManService collectOrderCodeManService;
@Resource
IoSplitCodeService splitCodeService;
@Resource
IoCollectOrderBizBackupService ioCollectOrderBizBackupService;
@Transactional(rollbackFor = Exception.class)
public void finishAutoTagCode(IoCollectOrder collectOrder) {
List<IoCollectOrderBiz> collectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());
//如果手动扫码判断该码是否在队列里,如果已在队列,则队列里剔除
List<IoCollectOrderCodeMan> collectOrderCodeMEN = collectOrderCodeManService.listByBillNo(collectOrder.getBillNo());
if (CollUtil.isNotEmpty(collectOrderCodeMEN)) {
@ -496,7 +491,13 @@ public class IoSplitCodeService extends ServiceImpl<IoSplitCodeMapper, IoSplitCo
splitRemove(collectOrderBiz, collectOrder);
}
}
ArrayList<IoCollectOrderBizBackup> ioCollectOrderBizBackups = new ArrayList<>();
for (IoCollectOrderBiz ioCollectOrderBiz : collectOrderBizs){
IoCollectOrderBizBackup ioCollectOrderBizBackup = new IoCollectOrderBizBackup();
BeanUtils.copyProperties(ioCollectOrderBiz, ioCollectOrderBizBackup);
ioCollectOrderBizBackups.add(ioCollectOrderBizBackup);
}
ioCollectOrderBizBackupService.saveBatch(ioCollectOrderBizBackups);
}

@ -2,4 +2,108 @@
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.glxp.api.dao.collect.IoCollectOrderBackupMapper">
<select id="filterList" resultType="com.glxp.api.res.collect.IoCollectOrderResponse">
SELECT icob.billNo,
icob.busType,
icob.fromType,
icob.fromTypeDesc,
icob.fromCorp,
icob.billTime,
icob.orderCirType,
icob.createTime,
icob.workPlaceCode,
icob.remark,
icob.createUser,
icob.updateTime,
icob.updateUser,
icob.tagStatus,
icob.splitStatus,
icob.invAlert,
icob.splitMsg,
icob.fromCorpName,
icob.tagMsg,
sys_workplace_document.busName busTypeName,
sw.workplaceName,
icob.id,
icob.orderTime,
icob.uploadStatus,
icob.uploadError,
icob.errorMsg,
row_number() over ( order by case when icob.orderTime is null then icob.createTime else icob.orderTime end desc )
as orderSequence
FROM io_collect_order_backup icob
left join sys_workplace_document on icob.busType = sys_workplace_document.documentTypeCode
left join basic_corp bc on icob.fromCorp = bc.erpId
left join sys_workplace sw on icob.workPlaceCode = sw.workplaceId
<where>
<if test="billNo != '' and billNo != null">
AND billNo LIKE concat('%', #{billNo}, '%')
</if>
<if test="workplaceName != '' and workplaceName != null">
AND workplaceName LIKE concat('%', #{workplaceName}, '%')
</if>
<if test="busType != null and busType != ''">
AND busType = #{busType}
</if>
<if test="fromCorp != '' and fromCorp != null">
AND fromCorp LIKE concat('%', #{fromCorp}, '%')
</if>
<if test="collectCode != null and collectCode != ''">
AND collectCode = #{collectCode}
</if>
<if test="busType != null and busType != ''">
AND busType = #{busType}
</if>
<if test="tagStatus != null">
AND tagStatus = #{tagStatus}
</if>
<if test="workPlaceCode != null">
AND icob.workPlaceCode = #{workPlaceCode}
</if>
<if test="chargeUser != null">
AND sw.chargeUser = #{chargeUser}
</if>
<if test="unionKey != null">
AND (
icob.billNo like concat('%', #{unionKey}, '%')
or icob.fromCorp like concat('%', #{unionKey}, '%')
or icob.fromCorpName like concat('%', #{unionKey}, '%')
or icob.backupOrderRemark1 like concat('%', #{unionKey}, '%')
or icob.backupOrderRemark2 like concat('%', #{unionKey}, '%')
or icob.backupOrderRemark3 like concat('%', #{unionKey}, '%')
or icob.backupOrderRemark4 like concat('%', #{unionKey}, '%')
or icob.backupOrderRemark5 like concat('%', #{unionKey}, '%')
or icob.backupOrderRemark6 like concat('%', #{unionKey}, '%'))
</if>
<if test="tagStatusList != null and tagStatusList.size() > 0">
and tagStatus in
<foreach collection="tagStatusList" item="item" index="index" separator="," open="(" close=")">
#{item}
</foreach>
</if>
<if test="workPlaceCodes != null and workPlaceCodes.size() > 0">
and icob.workPlaceCode in
<foreach collection="workPlaceCodes" item="item" index="index" separator="," open="(" close=")">
#{item}
</foreach>
</if>
<if test="invAlert != null">
and icob.invAlert =#{invAlert}
</if>
<if test="invAlerts != null and invAlerts.size() > 0">
and icob.invAlert in
<foreach collection="invAlerts" item="item" index="index" separator="," open="(" close=")">
#{item}
</foreach>
</if>
<if test="uploadStatus != null">
and icob.uploadStatus = #{uploadStatus}
</if>
</where>
GROUP BY
icob.billNo
order by case when icob.orderTime is null then icob.createTime else icob.orderTime end desc
</select>
</mapper>

@ -2,4 +2,38 @@
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.glxp.api.dao.collect.IoCollectOrderBizBackupMapper">
<select id="filterList" resultType="com.glxp.api.res.collect.CollectOrderBizResponse">
SELECT icobb.*,
bp.nameCode diCode,
bp.zczbhhzbapzbh,
bp.manufactory,
bp.bzgg
FROM io_collect_order_biz_backup icobb
left join basic_udirel bu on icobb.relId = bu.id
left join basic_products bp on bu.uuid = bp.uuid
<where>
<if test="thrCode != '' and thrCode != null">
AND icobb.thrCode LIKE concat('%', #{thrCode}, '%')
</if>
<if test="orderIdFk != null and orderIdFk != ''">
AND icobb.orderIdFk = #{orderIdFk}
</if>
<if test="relId != null">
AND icobb.relId = #{relId}
</if>
<if test="cpmctymc != null and cpmctymc != ''">
AND icobb.cpmctymc LIKE concat('%', #{cpmctymc}, '%')
</if>
<if test="unionCode != '' and unionCode != null">
and (
bp.nameCode LIKE concat('%', #{unionCode}, '%')
or bp.ybbm LIKE concat('%', #{unionCode}, '%')
or bp.sptm LIKE concat('%', #{unionCode}, '%'))
</if>
<if test="ggxh != '' and ggxh != null">
AND ggxh LIKE concat('%', #{ggxh}, '%')
</if>
</where>
group by icobb.id
</select>
</mapper>

Loading…
Cancel
Save