You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
361 lines
17 KiB
Java
361 lines
17 KiB
Java
package com.glxp.api.controller.collect;
|
|
|
|
import cn.hutool.core.collection.CollUtil;
|
|
import cn.hutool.core.util.StrUtil;
|
|
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.core.conditions.query.LambdaQueryWrapper;
|
|
import com.github.pagehelper.PageInfo;
|
|
import com.glxp.api.annotation.AuthRuleAnnotation;
|
|
import com.glxp.api.common.enums.ResultEnum;
|
|
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.IoCollectOrderBiz;
|
|
import com.glxp.api.entity.collect.IoCollectOrderCodeMan;
|
|
import com.glxp.api.exception.JsonException;
|
|
import com.glxp.api.req.collect.CollectOrderCodeManRequest;
|
|
import com.glxp.api.req.collect.IoCollectCodeRequest;
|
|
import com.glxp.api.req.inout.AddTagCodeReqeust;
|
|
import com.glxp.api.req.inout.DeleteTageCodeRequest;
|
|
import com.glxp.api.res.PageSimpleResponse;
|
|
import com.glxp.api.res.collect.CollectOrderCodeManResponse;
|
|
import com.glxp.api.res.inout.VailCodeResultResponse;
|
|
import com.glxp.api.res.inout.VailTagResultResponse;
|
|
import com.glxp.api.service.collect.IoCollectOrderBizService;
|
|
import com.glxp.api.service.collect.IoCollectOrderCodeManService;
|
|
import com.glxp.api.service.collect.IoCollectOrderService;
|
|
import com.glxp.api.util.IntUtil;
|
|
import lombok.extern.slf4j.Slf4j;
|
|
import org.springframework.validation.BindingResult;
|
|
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 javax.validation.Valid;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.concurrent.ExecutorService;
|
|
import java.util.concurrent.Executors;
|
|
import java.util.concurrent.Future;
|
|
import java.util.stream.Collectors;
|
|
|
|
@Slf4j
|
|
@RestController
|
|
public class IoCollectOrderCodeManController extends BaseController {
|
|
|
|
|
|
@Resource
|
|
IoCollectOrderService collectOrderService;
|
|
@Resource
|
|
IoCollectOrderCodeManService collectOrderCodeManService;
|
|
|
|
/**
|
|
* 器械拆零处方赋码明细
|
|
*
|
|
* @return
|
|
*/
|
|
@GetMapping("/udiwms/ioSplit/collect/manual/code/list")
|
|
public BaseResponse manuCodeList(CollectOrderCodeManRequest collectOrderCodeManRequest,
|
|
BindingResult bindingResult) {
|
|
if (bindingResult.hasErrors()) {
|
|
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
|
|
}
|
|
List<CollectOrderCodeManResponse> collectOrderCodeManResponses = collectOrderCodeManService.filterList(collectOrderCodeManRequest);
|
|
PageInfo<CollectOrderCodeManResponse> pageInfo = new PageInfo<>(collectOrderCodeManResponses);
|
|
PageSimpleResponse<CollectOrderCodeManResponse> pageSimpleResponse = new PageSimpleResponse<>();
|
|
pageSimpleResponse.setTotal(pageInfo.getTotal());
|
|
pageSimpleResponse.setList(collectOrderCodeManResponses);
|
|
return ResultVOUtils.success(pageSimpleResponse);
|
|
}
|
|
|
|
|
|
/**
|
|
* 器械拆零处方赋码（手动赋码)
|
|
*
|
|
* @return
|
|
*/
|
|
@PostMapping("/udiwms/ioSplit/collect/order/tagCode")
|
|
public BaseResponse prescribeTagCode(@RequestBody @Valid AddTagCodeReqeust addTagCodeReqeust,
|
|
BindingResult bindingResult) {
|
|
if (bindingResult.hasErrors()) {
|
|
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
|
|
}
|
|
IoCollectOrder collectOrder;
|
|
try {
|
|
collectOrder = collectOrderCodeManService.prescribeTagCode(addTagCodeReqeust);
|
|
return ResultVOUtils.success(collectOrder);
|
|
} catch (JsonException e) {
|
|
if (e.getCode() == 503) {
|
|
// 单据扫码数量大于1 的需要拆零确认
|
|
List<VailCodeResultResponse> vailCodeResultResponses = new ArrayList<>();
|
|
String msg = e.getMessage();
|
|
String[] data = msg.split(";");
|
|
String count = data[1];
|
|
List<String> vailCodesList = new ArrayList<String>();
|
|
if (IntUtil.value(count) > 1) {
|
|
VailCodeResultResponse vailCodeResultResponse = new VailCodeResultResponse();
|
|
vailCodeResultResponse.setStatus(4);
|
|
vailCodeResultResponse.setCode(addTagCodeReqeust.getCode());
|
|
vailCodeResultResponse.setBizId(data[0]);
|
|
vailCodeResultResponse.setCpmctymc(data[2]);
|
|
vailCodeResultResponse.setErrMsg(data[3]);
|
|
vailCodeResultResponses.add(vailCodeResultResponse);
|
|
vailCodesList.add(addTagCodeReqeust.getCode());
|
|
String errMsg = countSameErrMsg(vailCodeResultResponses);
|
|
if (StrUtil.isNotEmpty(errMsg)) {
|
|
return ResultVOUtils.error(500, errMsg);
|
|
} else {
|
|
addTagCodeReqeust.setInsert(true);
|
|
collectOrder = collectOrderCodeManService.prescribeTagCode(addTagCodeReqeust);
|
|
}
|
|
IoCollectOrderBiz collectOrderBiz = new IoCollectOrderBiz();
|
|
collectOrderBiz.setId(collectOrder.getId());
|
|
collectOrderBiz.setSplitUnCheck(true);
|
|
collectOrderBizService.updateById(collectOrderBiz);
|
|
return ResultVOUtils.success(collectOrder);
|
|
} else {
|
|
addTagCodeReqeust.setInsert(true);
|
|
collectOrder = collectOrderCodeManService.prescribeTagCode(addTagCodeReqeust);
|
|
return ResultVOUtils.success(collectOrder);
|
|
}
|
|
|
|
} else {
|
|
return ResultVOUtils.error(e.getCode(), e.getMessage());
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 器械拆零处方赋码（批量赋码)
|
|
*
|
|
* @return
|
|
*/
|
|
@PostMapping("/udiwms/ioSplit/collect/order/batchAddCode")
|
|
public BaseResponse batchAddCode(@RequestBody @Valid AddTagCodeReqeust addTagCodeReqeust,
|
|
BindingResult bindingResult) {
|
|
if (bindingResult.hasErrors()) {
|
|
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
|
|
}
|
|
IoCollectOrder collectOrder = null;
|
|
VailTagResultResponse vailTagResultResponse = new VailTagResultResponse();
|
|
List<VailCodeResultResponse> vailCodeResultResponses = new ArrayList<>();
|
|
List<String> vailCodesList = new ArrayList<String>();
|
|
if (CollUtil.isNotEmpty(addTagCodeReqeust.getCodeList())) {
|
|
for (String code : addTagCodeReqeust.getCodeList()) {
|
|
VailCodeResultResponse vailCodeResultResponse = new VailCodeResultResponse();
|
|
addTagCodeReqeust.setCode(code);
|
|
vailCodeResultResponse.setCode(code);
|
|
vailCodeResultResponse.setStatus(1);
|
|
try {
|
|
collectOrder = collectOrderCodeManService.prescribeTagCode(addTagCodeReqeust);
|
|
} catch (JsonException e) {
|
|
vailCodeResultResponse.setErrMsg(e.getMessage());
|
|
if (e.getCode() == 502) {
|
|
vailCodeResultResponse.setStatus(3);
|
|
} else if (e.getCode() == 503) {
|
|
// 单据扫码数量大于1 的需要拆零确认
|
|
String msg = e.getMessage();
|
|
String[] data = msg.split(";");
|
|
String count = data[1];
|
|
if (IntUtil.value(count) > 1) {
|
|
vailCodeResultResponse.setStatus(4);
|
|
vailCodeResultResponse.setBizId(data[0]);
|
|
vailCodeResultResponse.setCpmctymc(data[2]);
|
|
vailCodeResultResponse.setErrMsg(data[3]);
|
|
}
|
|
vailCodesList.add(code);
|
|
} else {
|
|
vailCodeResultResponse.setStatus(2);
|
|
}
|
|
}
|
|
vailCodeResultResponses.add(vailCodeResultResponse);
|
|
}
|
|
}
|
|
vailTagResultResponse.setCollectOrder(collectOrder);
|
|
vailTagResultResponse.setVailCodeResultResponses(vailCodeResultResponses);
|
|
String errMsg = countSameErrMsg(vailCodeResultResponses);
|
|
if (StrUtil.isNotEmpty(errMsg)) {
|
|
return ResultVOUtils.error(500, errMsg);
|
|
} else {
|
|
addTagCodeReqeust.setCodeList(vailCodesList);
|
|
addTagCodeReqeust.setInsert(true);
|
|
for (String code : vailCodesList) {
|
|
addTagCodeReqeust.setCode(code);
|
|
collectOrderCodeManService.prescribeTagCode(addTagCodeReqeust);
|
|
}
|
|
|
|
|
|
}
|
|
return ResultVOUtils.success(vailTagResultResponse);
|
|
}
|
|
|
|
@Resource
|
|
IoCollectOrderBizService collectOrderBizService;
|
|
|
|
/**
|
|
* 拆零确认
|
|
*
|
|
* @param
|
|
* @return
|
|
*/
|
|
@PostMapping("/udiwms/ioSplit/collect/order/batchUpdateCode")
|
|
public BaseResponse batchUpdate(@RequestBody AddTagCodeReqeust addTagCodeReqeust,
|
|
BindingResult bindingResult) {
|
|
if (bindingResult.hasErrors()) {
|
|
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
|
|
}
|
|
List<IoCollectOrderCodeMan> collectOrderCodeMEN = new ArrayList<>();
|
|
if (CollUtil.isNotEmpty(addTagCodeReqeust.getCodeList())) {
|
|
for (String code : addTagCodeReqeust.getCodeList()) {
|
|
IoCollectOrderCodeMan collectOrderCodeMan = collectOrderCodeManService.findByCode(addTagCodeReqeust.getBillNo(), code);
|
|
if (collectOrderCodeMan == null) {
|
|
return ResultVOUtils.error("非此单追溯码！");
|
|
} else {
|
|
collectOrderCodeMEN.add(collectOrderCodeMan);
|
|
}
|
|
}
|
|
|
|
} else collectOrderCodeMEN = addTagCodeReqeust.getCollectOrderCodeManList();
|
|
if (CollUtil.isNotEmpty(collectOrderCodeMEN)) {
|
|
for (IoCollectOrderCodeMan collectOrderCodeMan : collectOrderCodeMEN) {
|
|
collectOrderCodeManService.updateById(collectOrderCodeMan);
|
|
IoCollectOrderBiz collectiveOrderBiz = new IoCollectOrderBiz();
|
|
collectiveOrderBiz.setId(collectOrderCodeMan.getBizIdFk());
|
|
collectiveOrderBiz.setSplitUnCheck(false);
|
|
collectOrderBizService.updateById(collectiveOrderBiz);
|
|
}
|
|
return ResultVOUtils.success("更新成功！");
|
|
}
|
|
|
|
|
|
return ResultVOUtils.error("扫码不能为空！");
|
|
|
|
// if (CollUtil.isNotEmpty(addTagCodeReqeust.getCodeList())) {
|
|
// List<String> codeList = addTagCodeReqeust.getCodeList();
|
|
// String billNo = addTagCodeReqeust.getBillNo();
|
|
// List<IoCollectOrderCodeMan> ioCollectOrderCodeMEN = collectOrderCodeManService.listByBillNo(billNo);
|
|
// Map<String, IoCollectOrderCodeMan> codeManMap = ioCollectOrderCodeMEN.stream().collect(Collectors.toMap(IoCollectOrderCodeMan::getUdiCode, x -> x));
|
|
// List<Long> bizIdFks = new ArrayList<>();
|
|
// //codeList 拆零确认码 对 单据的biz进行匹配 匹配上标记是拆零码
|
|
// for (int i = 0; i < codeList.size(); i++) {
|
|
// String code = codeList.get(i);
|
|
// IoCollectOrderCodeMan ioCollectOrderCodeMan = codeManMap.get(code);
|
|
// if (ioCollectOrderCodeMan != null) {
|
|
// //更新业务表为无需确认拆零码、码明细确认拆零字段为true
|
|
// ioCollectOrderCodeMan.setIsSplitCode(true);
|
|
// collectOrderCodeManService.updateById(ioCollectOrderCodeMan);
|
|
// bizIdFks.add(ioCollectOrderCodeMan.getBizIdFk());
|
|
// }
|
|
// }
|
|
// if (bizIdFks.size() > 0) {
|
|
// UpdateWrapper<IoCollectOrderBiz> updateWrapper = new UpdateWrapper<>();
|
|
// updateWrapper.set("splitUnCheck", false);
|
|
// updateWrapper.in("id", bizIdFks);
|
|
// collectOrderBizService.update(updateWrapper);
|
|
// }
|
|
// return ResultVOUtils.success("更新成功");
|
|
// } else {
|
|
// return ResultVOUtils.error("数据不能为空");
|
|
// }
|
|
}
|
|
|
|
public String countSameErrMsg(List<VailCodeResultResponse> vailCodeResultResponses) {
|
|
Map<String, Integer> errMsgCountMap = new HashMap<>();
|
|
|
|
for (VailCodeResultResponse response : vailCodeResultResponses) {
|
|
if (response.getStatus() == 4) {
|
|
String errMsg = response.getCode().substring(0, 7) + ";" + response.getErrMsg();
|
|
if (errMsgCountMap.containsKey(errMsg)) {
|
|
errMsgCountMap.put(errMsg, errMsgCountMap.get(errMsg) + 1);
|
|
} else {
|
|
errMsgCountMap.put(errMsg, 1);
|
|
}
|
|
if (StrUtil.isNotEmpty(response.getBizId())) {
|
|
IoCollectOrderBiz collectOrderBiz = new IoCollectOrderBiz();
|
|
collectOrderBiz.setId(Long.parseLong(response.getBizId()));
|
|
collectOrderBiz.setSplitUnCheck(true);
|
|
collectOrderBizService.updateById(collectOrderBiz);
|
|
}
|
|
}
|
|
}
|
|
for (Map.Entry<String, Integer> entry : errMsgCountMap.entrySet()) {
|
|
String key = entry.getKey();
|
|
Integer value = entry.getValue();
|
|
if (value > 1) {
|
|
return key.substring(8);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@PostMapping("/udiwms/ioSplit/collect/code/remove")
|
|
public BaseResponse removeCode(@RequestBody @Valid DeleteTageCodeRequest deleteTageCodeRequest,
|
|
BindingResult bindingResult) {
|
|
if (CollUtil.isNotEmpty(deleteTageCodeRequest.getCodeManIds())) {
|
|
for (Long codeManId : deleteTageCodeRequest.getCodeManIds()) {
|
|
deleteTageCodeRequest.setCodeManId(codeManId);
|
|
collectOrderService.removeCode(deleteTageCodeRequest);
|
|
}
|
|
} else {
|
|
collectOrderService.removeCode(deleteTageCodeRequest);
|
|
}
|
|
|
|
|
|
return ResultVOUtils.success("操作成功!");
|
|
}
|
|
|
|
@PostMapping("/udiwms/ioSplit/collect/code/removeByScanCode")
|
|
public BaseResponse removeByScanCode(@RequestBody @Valid DeleteTageCodeRequest deleteTageCodeRequest,
|
|
BindingResult bindingResult) {
|
|
//codes orderId
|
|
//todo 重复条码
|
|
String orderId = deleteTageCodeRequest.getOrderId();
|
|
IoCollectOrder ioCollectOrder = collectOrderService.getByBillNo(orderId);
|
|
StringBuilder messages = new StringBuilder(); // 用于存储重复条码
|
|
if (ioCollectOrder == null)
|
|
return ResultVOUtils.error(500, "单据不存在");
|
|
if (CollUtil.isNotEmpty(deleteTageCodeRequest.getCodeList())) {
|
|
List<IoCollectOrderCodeMan> ioCollectOrderCodes = collectOrderCodeManService.selectByCodeAndOrderId(deleteTageCodeRequest.getCodeList(), orderId);
|
|
if (ioCollectOrderCodes.size() == 0) {
|
|
return ResultVOUtils.error("无效条码");
|
|
}
|
|
for (IoCollectOrderCodeMan ioCollectOrderCode : ioCollectOrderCodes) {
|
|
deleteTageCodeRequest.setDelType(1);
|
|
deleteTageCodeRequest.setCodeManId(Long.valueOf(ioCollectOrderCode.getId()));
|
|
collectOrderService.removeCode(deleteTageCodeRequest);
|
|
}
|
|
} else
|
|
return ResultVOUtils.error("无效条码");
|
|
if (StrUtil.isEmpty(messages)) {
|
|
return ResultVOUtils.success("剔除成功!");
|
|
} else
|
|
return ResultVOUtils.error(501, messages.toString());
|
|
}
|
|
|
|
|
|
@PostMapping("/udiwms/basic/collect/IoCollectOrderCodeMan/checkCode")
|
|
public BaseResponse checkCollectOrderManCode(@RequestBody CollectOrderCodeManRequest request){
|
|
ExecutorService executor = Executors.newSingleThreadExecutor();
|
|
Future<BaseResponse> future = executor.submit(() -> collectOrderCodeManService.CheckCode(request));
|
|
BaseResponse response = null;
|
|
try {
|
|
response = future.get();
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
} finally {
|
|
executor.shutdown();
|
|
}
|
|
return response;
|
|
}
|
|
|
|
|
|
|
|
}
|