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 * @param collectOrderRequest
* @return * @return
*/ */
@PostMapping("/udiwms/basic/collect/order/upload") // @PostMapping("/udiwms/basic/collect/order/upload")
public BaseResponse orderUpload(@RequestBody CollectOrderRequest collectOrderRequest) { // public BaseResponse orderUpload(@RequestBody CollectOrderRequest collectOrderRequest) {
if (StrUtil.isEmpty(collectOrderRequest.getBillNo())) // if (StrUtil.isEmpty(collectOrderRequest.getBillNo()))
return ResultVOUtils.error(500, "单据号不能为空"); // return ResultVOUtils.error(500, "单据号不能为空");
collectOrderService.orderUpload(collectOrderRequest.getBillNo()); // collectOrderService.orderUpload(collectOrderRequest.getBillNo());
return ResultVOUtils.success(); // return ResultVOUtils.success();
} // }
} }

@ -13,4 +13,5 @@ import java.util.List;
@Mapper @Mapper
public interface IoCollectOrderBackupMapper extends BaseMapper<IoCollectOrderBackup> { 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.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.glxp.api.entity.collect.IoCollectOrderBizBackup; 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 org.apache.ibatis.annotations.Mapper;
import java.util.List;
@Mapper @Mapper
public interface IoCollectOrderBizBackupMapper extends BaseMapper<IoCollectOrderBizBackup> { public interface IoCollectOrderBizBackupMapper extends BaseMapper<IoCollectOrderBizBackup> {
List<CollectOrderBizResponse> filterList(CollectOrderBizRequest collectOrderRequest);
} }

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

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

@ -1,13 +1,293 @@
package com.glxp.api.service.collect; 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.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.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.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.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 @Service
public class IoCollectOrderBackupService extends ServiceImpl<IoCollectOrderBackupMapper, IoCollectOrderBackup> { 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.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.PageHelper;
import com.glxp.api.dao.collect.IoCollectOrderBizBackupMapper; import com.glxp.api.dao.collect.IoCollectOrderBizBackupMapper;
import com.glxp.api.entity.collect.IoCollectOrderBizBackup; 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 org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.List;
@Service @Service
public class IoCollectOrderBizBackupService extends ServiceImpl<IoCollectOrderBizBackupMapper, IoCollectOrderBizBackup> { 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 @Resource
IoCollectOrderBizOriginService collectOrderBizOriginService; IoCollectOrderBizOriginService collectOrderBizOriginService;
@Resource
IoCollectOrderBackupService ioCollectOrderBackupService;
public IoCollectOrder getByBillNo(String billNo) { public IoCollectOrder getByBillNo(String billNo) {
return collectOrderMapper.selectOne(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, billNo).last("limit 1")); 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()); collectOrder.setUpdateTime(new Date());
updateByBillNo(collectOrder); updateByBillNo(collectOrder);
splitCodeService.finishAutoTagCode(collectOrder); splitCodeService.finishAutoTagCode(collectOrder);
//插入备用表
IoCollectOrderBackup ioCollectOrderBackup = new IoCollectOrderBackup();
BeanUtils.copyProperties(collectOrder, ioCollectOrderBackup);
ioCollectOrderBackupService.save(ioCollectOrderBackup);
ThreadUtil.execAsync(() -> { ThreadUtil.execAsync(() -> {
//插入到码表 //插入到码表
collectCodeService.insertCodesByBill(collectOrderRequest.getBillNo()); collectCodeService.insertCodesByBill(collectOrderRequest.getBillNo());
@ -631,102 +637,100 @@ public class IoCollectOrderService extends ServiceImpl<IoCollectOrderMapper, IoC
} }
@Resource
IoCollectOrderBackupService ioCollectOrderBackupService;
@Resource @Resource
IoCollectOrderBizBackupService ioCollectOrderBizBackupService; IoCollectOrderBizBackupService ioCollectOrderBizBackupService;
/** /**
* @param billNo * @param billNo
*/ */
@Transactional(rollbackFor = Exception.class) // @Transactional(rollbackFor = Exception.class)
public void generateOrder(String billNo) { // public void generateOrder(String billNo) {
//
IoCollectOrder collectOrder = getByBillNo(billNo); // IoCollectOrder collectOrder = getByBillNo(billNo);
SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity = sysWorkplaceDocumentService.findByWorkplaceCode(collectOrder.getWorkPlaceCode(), collectOrder.getBusType()); // SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity = sysWorkplaceDocumentService.findByWorkplaceCode(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());
//1.内部系统,且单据为扫码生成业务单则创建系统单据 // //1.内部系统,且单据为扫码生成业务单则创建系统单据
if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 1 && sysWorkplaceDocumentEntity.getScanType() == 1) { // if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 1 && sysWorkplaceDocumentEntity.getScanType() == 1) {
List<IoCollectOrderCodeMan> collectOrderCodes = collectOrderCodeManService.listByBillNo(collectOrder.getBillNo()); // List<IoCollectOrderCodeMan> collectOrderCodes = collectOrderCodeManService.listByBillNo(collectOrder.getBillNo());
BasicBussinessTypeEntity bussinessTypeEntity; // BasicBussinessTypeEntity bussinessTypeEntity;
sysWorkplaceDocumentEntity.getInoutType(); // sysWorkplaceDocumentEntity.getInoutType();
//
//构造单据数据 // //构造单据数据
IoOrderEntity orderEntity = new IoOrderEntity(); // IoOrderEntity orderEntity = new IoOrderEntity();
bussinessTypeEntity = bussinessTypeService.findByAction(sysWorkplaceDocumentEntity.getDocumentTypeCode()); // bussinessTypeEntity = bussinessTypeService.findByAction(sysWorkplaceDocumentEntity.getDocumentTypeCode());
orderEntity.setMainAction(bussinessTypeEntity.getMainAction()); // orderEntity.setMainAction(bussinessTypeEntity.getMainAction());
orderEntity.setAction(bussinessTypeEntity.getAction()); // orderEntity.setAction(bussinessTypeEntity.getAction());
orderEntity.setCreateTime(new Date()); // orderEntity.setCreateTime(new Date());
orderEntity.setInvCode(sysWorkplaceDocumentEntity.getInvCode() + ""); // orderEntity.setInvCode(sysWorkplaceDocumentEntity.getInvCode() + "");
orderEntity.setDeptCode(""); // orderEntity.setDeptCode("");
orderEntity.setFromCorp(collectOrder.getFromCorp()); // orderEntity.setFromCorp(collectOrder.getFromCorp());
orderEntity.setCorpOrderId(CustomUtil.getId() + "x"); // orderEntity.setCorpOrderId(CustomUtil.getId() + "x");
orderEntity.setExportStatus(0); // orderEntity.setExportStatus(0);
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_PROCESS); // orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_PROCESS);
orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_DRAFT); // orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_DRAFT);
orderEntity.setCreateUser(collectOrder.getCreateUser()); // orderEntity.setCreateUser(collectOrder.getCreateUser());
orderEntity.setCreateTime(new Date()); // orderEntity.setCreateTime(new Date());
orderEntity.setUpdateUser(collectOrder.getCreateUser()); // orderEntity.setUpdateUser(collectOrder.getCreateUser());
orderEntity.setUpdateTime(new Date()); // orderEntity.setUpdateTime(new Date());
orderEntity.setCustomerId("110"); // orderEntity.setCustomerId("110");
orderEntity.setOrderType(2); // orderEntity.setOrderType(2);
orderEntity.setFromType(2); // orderEntity.setFromType(2);
String orderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(bussinessTypeEntity.getPrefix()), "yyyyMMdd")); // String orderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(bussinessTypeEntity.getPrefix()), "yyyyMMdd"));
orderEntity.setBillNo(orderNo); // orderEntity.setBillNo(orderNo);
List<IoCodeTempEntity> lossCodesList = new ArrayList<>(); // List<IoCodeTempEntity> lossCodesList = new ArrayList<>();
//
for (IoCollectOrderCodeMan collectOrderCodeMan : collectOrderCodes) { // for (IoCollectOrderCodeMan collectOrderCodeMan : collectOrderCodes) {
lossCodesList.add(buildCodeEntity(collectOrderCodeMan, orderEntity)); // lossCodesList.add(buildCodeEntity(collectOrderCodeMan, orderEntity));
} // }
orderService.insertOrder(orderEntity); // orderService.insertOrder(orderEntity);
codesTempDao.insertBatch(lossCodesList); // codesTempDao.insertBatch(lossCodesList);
addInoutService.dealProcess(orderEntity); // addInoutService.dealProcess(orderEntity);
if (!ioCheckInoutService.checkManual(orderEntity.getBillNo())) { // if (!ioCheckInoutService.checkManual(orderEntity.getBillNo())) {
ioCheckInoutService.check(orderEntity.getBillNo()); // ioCheckInoutService.check(orderEntity.getBillNo());
} // }
} else if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 1 && sysWorkplaceDocumentEntity.getScanType() != 1) { // } else if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 1 && sysWorkplaceDocumentEntity.getScanType() != 1) {
//更新单据为已完成 // //更新单据为已完成
IoOrderEntity orderEntity = orderService.findByBillNo(collectOrder.getBillNo()); // IoOrderEntity orderEntity = orderService.findByBillNo(collectOrder.getBillNo());
orderEntity.setStatus(7); // orderEntity.setStatus(7);
orderService.update(orderEntity); // orderService.update(orderEntity);
} else if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 0) { // } else if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 0) {
//todo 根据单据类型上传医保或者第三方系统 // //todo 根据单据类型上传医保或者第三方系统
PostCollectOrderRequest orderRequest = new PostCollectOrderRequest(); // PostCollectOrderRequest orderRequest = new PostCollectOrderRequest();
orderRequest.setThirdSys("thirdId"); // orderRequest.setThirdSys("thirdId");
CollectOrderBizRequest collectOrderBizRequest = new CollectOrderBizRequest(); // CollectOrderBizRequest collectOrderBizRequest = new CollectOrderBizRequest();
collectOrderBizRequest.setOrderIdFk(collectOrder.getBillNo()); // collectOrderBizRequest.setOrderIdFk(collectOrder.getBillNo());
List<CollectOrderBizResponse> collectOrderBizResponses = combieOrderDetail(collectOrderBizRequest); // List<CollectOrderBizResponse> collectOrderBizResponses = combieOrderDetail(collectOrderBizRequest);
collectOrder.setCollectOrderBizResponseList(collectOrderBizResponses); // collectOrder.setCollectOrderBizResponseList(collectOrderBizResponses);
List<IoCollectOrder> collectOrderList = new ArrayList<>(); // List<IoCollectOrder> collectOrderList = new ArrayList<>();
collectOrderList.add(collectOrder); // collectOrderList.add(collectOrder);
orderRequest.setCollectOrderList(collectOrderList); // orderRequest.setCollectOrderList(collectOrderList);
BaseResponse<BasicSkPrescribeResponse> baseResponse = erpBasicClient.postOrder(orderRequest); // BaseResponse<BasicSkPrescribeResponse> baseResponse = erpBasicClient.postOrder(orderRequest);
log.debug("单据返回=========" + baseResponse); // log.debug("单据返回=========" + baseResponse);
if (baseResponse.getCode() == 20000) { // if (baseResponse.getCode() == 20000) {
// // //
} else { // } else {
throw new JsonException("连接第三方系统接口服务出错," + baseResponse.getMessage()); // throw new JsonException("连接第三方系统接口服务出错," + baseResponse.getMessage());
} // }
//
} // }
//插入处方备份表 // //插入处方备份表
IoCollectOrderBackup ioCollectOrderBackup = new IoCollectOrderBackup(); // IoCollectOrderBackup ioCollectOrderBackup = new IoCollectOrderBackup();
BeanUtils.copyProperties(collectOrder, ioCollectOrderBackup); // BeanUtils.copyProperties(collectOrder, ioCollectOrderBackup);
boolean save = ioCollectOrderBackupService.save(ioCollectOrderBackup); // boolean save = ioCollectOrderBackupService.save(ioCollectOrderBackup);
if (!save){ // if (!save){
throw new JsonException(500,"处方备用上传失败"); // throw new JsonException(500,"处方备用上传失败");
} // }
List<IoCollectOrderBiz> ioCollectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo()); // List<IoCollectOrderBiz> ioCollectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());
for (IoCollectOrderBiz ioCollectOrderBiz : ioCollectOrderBizs){ // for (IoCollectOrderBiz ioCollectOrderBiz : ioCollectOrderBizs){
IoCollectOrderBizBackup ioCollectOrderBizBackup = new IoCollectOrderBizBackup(); // IoCollectOrderBizBackup ioCollectOrderBizBackup = new IoCollectOrderBizBackup();
BeanUtils.copyProperties(ioCollectOrderBiz, ioCollectOrderBizBackup); // BeanUtils.copyProperties(ioCollectOrderBiz, ioCollectOrderBizBackup);
boolean save1 = ioCollectOrderBizBackupService.save(ioCollectOrderBizBackup); // boolean save1 = ioCollectOrderBizBackupService.save(ioCollectOrderBizBackup);
if (!save1){ // if (!save1){
throw new JsonException(500,"处方备用明细上传失败"); // throw new JsonException(500,"处方备用明细上传失败");
} // }
} // }
//
//
} // }
@Resource @Resource
UdiRlSupService udiRlSupService; UdiRlSupService udiRlSupService;
@ -764,7 +768,7 @@ public class IoCollectOrderService extends ServiceImpl<IoCollectOrderMapper, IoC
IoCollectOrder updateOrder = new IoCollectOrder(); IoCollectOrder updateOrder = new IoCollectOrder();
updateOrder.setBillNo(billNo); updateOrder.setBillNo(billNo);
try { try {
this.generateOrder(billNo); // this.generateOrder(billNo);
updateOrder.setUploadStatus(2); updateOrder.setUploadStatus(2);
} catch (Exception e) { } catch (Exception e) {
updateOrder.setUploadStatus(3); 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.BasicSkPrescribeDiEntity;
import com.glxp.api.entity.basic.BasicSkPrescribeEntity; import com.glxp.api.entity.basic.BasicSkPrescribeEntity;
import com.glxp.api.entity.basic.UdiRelevanceEntity; import com.glxp.api.entity.basic.UdiRelevanceEntity;
import com.glxp.api.entity.collect.IoCollectOrder; import com.glxp.api.entity.collect.*;
import com.glxp.api.entity.collect.IoCollectOrderBiz;
import com.glxp.api.entity.collect.IoCollectOrderCodeAuto;
import com.glxp.api.entity.collect.IoCollectOrderCodeMan;
import com.glxp.api.entity.inout.IoSplitCodeEntity; import com.glxp.api.entity.inout.IoSplitCodeEntity;
import com.glxp.api.entity.inout.IoSplitFifoCodeEntity; import com.glxp.api.entity.inout.IoSplitFifoCodeEntity;
import com.glxp.api.entity.inout.IoSplitFifoInv; 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.BasicSkPrescribeDiService;
import com.glxp.api.service.basic.BasicSkPrescribeService; import com.glxp.api.service.basic.BasicSkPrescribeService;
import com.glxp.api.service.basic.UdiRelevanceService; import com.glxp.api.service.basic.UdiRelevanceService;
import com.glxp.api.service.collect.IoCollectOrderBizService; import com.glxp.api.service.collect.*;
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.util.IntUtil; import com.glxp.api.util.IntUtil;
import org.springframework.beans.BeanUtils; import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
@ -371,12 +365,13 @@ public class IoSplitCodeService extends ServiceImpl<IoSplitCodeMapper, IoSplitCo
IoCollectOrderCodeManService collectOrderCodeManService; IoCollectOrderCodeManService collectOrderCodeManService;
@Resource @Resource
IoSplitCodeService splitCodeService; IoSplitCodeService splitCodeService;
@Resource
IoCollectOrderBizBackupService ioCollectOrderBizBackupService;
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public void finishAutoTagCode(IoCollectOrder collectOrder) { public void finishAutoTagCode(IoCollectOrder collectOrder) {
List<IoCollectOrderBiz> collectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo()); List<IoCollectOrderBiz> collectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());
//如果手动扫码判断该码是否在队列里,如果已在队列,则队列里剔除 //如果手动扫码判断该码是否在队列里,如果已在队列,则队列里剔除
List<IoCollectOrderCodeMan> collectOrderCodeMEN = collectOrderCodeManService.listByBillNo(collectOrder.getBillNo()); List<IoCollectOrderCodeMan> collectOrderCodeMEN = collectOrderCodeManService.listByBillNo(collectOrder.getBillNo());
if (CollUtil.isNotEmpty(collectOrderCodeMEN)) { if (CollUtil.isNotEmpty(collectOrderCodeMEN)) {
@ -496,7 +491,13 @@ public class IoSplitCodeService extends ServiceImpl<IoSplitCodeMapper, IoSplitCo
splitRemove(collectOrderBiz, collectOrder); 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"> <!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"> <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> </mapper>

@ -2,4 +2,38 @@
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!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"> <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> </mapper>

Loading…
Cancel
Save