|
|
package com.glxp.api.controller.inout;
|
|
|
|
|
|
import cn.hutool.core.bean.BeanUtil;
|
|
|
import cn.hutool.core.collection.CollUtil;
|
|
|
import cn.hutool.core.util.IdUtil;
|
|
|
import cn.hutool.core.util.StrUtil;
|
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
|
|
import com.github.pagehelper.PageInfo;
|
|
|
import com.glxp.api.annotation.AuthRuleAnnotation;
|
|
|
import com.glxp.api.annotation.Log;
|
|
|
import com.glxp.api.annotation.RepeatSubmit;
|
|
|
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.constant.BusinessType;
|
|
|
import com.glxp.api.constant.Constant;
|
|
|
import com.glxp.api.constant.ConstantStatus;
|
|
|
import com.glxp.api.controller.BaseController;
|
|
|
import com.glxp.api.entity.auth.AuthAdmin;
|
|
|
import com.glxp.api.entity.auth.InvBusUserEntity;
|
|
|
import com.glxp.api.entity.auth.InvWarehouseEntity;
|
|
|
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
|
|
|
import com.glxp.api.entity.basic.BasicCorpEntity;
|
|
|
import com.glxp.api.entity.basic.EntrustReceEntity;
|
|
|
import com.glxp.api.entity.inout.*;
|
|
|
import com.glxp.api.http.sync.SpGetHttpClient;
|
|
|
import com.glxp.api.req.auth.FilterInvBusUserRequest;
|
|
|
import com.glxp.api.req.basic.BasicEntrustRecRequest;
|
|
|
import com.glxp.api.req.inout.*;
|
|
|
import com.glxp.api.req.system.DeleteRequest;
|
|
|
import com.glxp.api.res.PageSimpleResponse;
|
|
|
import com.glxp.api.res.inout.*;
|
|
|
import com.glxp.api.service.auth.CustomerService;
|
|
|
import com.glxp.api.service.auth.InvBusUserService;
|
|
|
import com.glxp.api.service.auth.InvWarehouseService;
|
|
|
import com.glxp.api.service.basic.BasicCorpService;
|
|
|
import com.glxp.api.service.basic.EntrustReceService;
|
|
|
import com.glxp.api.service.basic.IBasicBussinessTypeService;
|
|
|
import com.glxp.api.service.inout.*;
|
|
|
import com.glxp.api.service.inout.impl.IoOrderInvoiceService;
|
|
|
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 lombok.extern.slf4j.Slf4j;
|
|
|
import org.apache.commons.collections.CollectionUtils;
|
|
|
import org.springframework.beans.BeanUtils;
|
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
|
import org.springframework.validation.BindingResult;
|
|
|
import org.springframework.web.bind.annotation.*;
|
|
|
|
|
|
import javax.annotation.Resource;
|
|
|
import java.util.*;
|
|
|
import java.util.stream.Collectors;
|
|
|
|
|
|
import static com.glxp.api.constant.ConstantStatus.ORDER_STATUS_CHECK_PROCESS;
|
|
|
|
|
|
|
|
|
@Slf4j
|
|
|
@RestController
|
|
|
public class IoOrderController extends BaseController {
|
|
|
|
|
|
@Resource
|
|
|
private IoOrderService orderService;
|
|
|
@Resource
|
|
|
private IBasicBussinessTypeService basicBussinessTypeService;
|
|
|
@Resource
|
|
|
private IoCodeTempService codeTempService;
|
|
|
@Resource
|
|
|
private IoCheckInoutService checkInoutService;
|
|
|
@Resource
|
|
|
IoOrderDetailBizService orderDetailBizService;
|
|
|
@Resource
|
|
|
IoOrderDetailCodeService orderDetailCodeService;
|
|
|
@Resource
|
|
|
IoAddInoutService ioAddInoutService;
|
|
|
@Resource
|
|
|
IoCheckInoutService ioCheckInoutService;
|
|
|
@Resource
|
|
|
BasicCorpService basicCorpService;
|
|
|
@Resource
|
|
|
IoOrderInvoiceService orderInvoiceService;
|
|
|
@Resource
|
|
|
CustomerService customerService;
|
|
|
|
|
|
/**
|
|
|
* 查询单据列表
|
|
|
*
|
|
|
* @param filterOrderRequest
|
|
|
* @return
|
|
|
*/
|
|
|
@AuthRuleAnnotation("")
|
|
|
@GetMapping("/udiwms/inout/order/filter")
|
|
|
public BaseResponse filterOrder(FilterOrderRequest filterOrderRequest) {
|
|
|
if (StrUtil.isNotBlank(filterOrderRequest.getStatusType())) {
|
|
|
orderService.setFilterStatus(filterOrderRequest);
|
|
|
}
|
|
|
if (StrUtil.isNotBlank(filterOrderRequest.getVueType())) {
|
|
|
orderService.setActions(filterOrderRequest);
|
|
|
//要是不存在要查询的单据类型就直接放回空
|
|
|
if (CollUtil.isEmpty(filterOrderRequest.getActions())) {
|
|
|
PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(new ArrayList<>());
|
|
|
return ResultVOUtils.page(pageInfo);
|
|
|
}
|
|
|
}
|
|
|
if (StrUtil.isNotEmpty(filterOrderRequest.getSupInoivceSearch())) {
|
|
|
orderService.setInvoiceFiltes(filterOrderRequest);
|
|
|
}
|
|
|
if (filterOrderRequest.getSourceLocalType() != null) {
|
|
|
if (filterOrderRequest.getSourceLocalType() == 1) {
|
|
|
filterOrderRequest.setSourceTypes(Arrays.asList(1, 2, 3, 4, 5));
|
|
|
} else {
|
|
|
filterOrderRequest.setSourceTypes(Arrays.asList(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
String customerId = getCustomerId();
|
|
|
if (!customerId.equals("110")) {
|
|
|
filterOrderRequest.setFromCorp(customerId);
|
|
|
}
|
|
|
List<IoOrderResponse> list = orderService.filterList(filterOrderRequest);
|
|
|
PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(list);
|
|
|
return ResultVOUtils.page(pageInfo);
|
|
|
}
|
|
|
|
|
|
@AuthRuleAnnotation("")
|
|
|
@GetMapping("/udiwms/inout/order/filterList")
|
|
|
public BaseResponse filterOrderList(FilterOrderRequest filterOrderRequest) {
|
|
|
|
|
|
|
|
|
if (StrUtil.isNotBlank(filterOrderRequest.getStatusType())) {
|
|
|
orderService.setFilterStatus(filterOrderRequest);
|
|
|
}
|
|
|
if (StrUtil.isNotBlank(filterOrderRequest.getVueType())) {
|
|
|
//要是不存在要查询的单据类型就直接放回空
|
|
|
if (orderService.setActions(filterOrderRequest) == null) {
|
|
|
PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(new ArrayList<>());
|
|
|
return ResultVOUtils.page(pageInfo);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
if (StrUtil.isNotEmpty(filterOrderRequest.getSupInoivceSearch())) {
|
|
|
orderService.setInvoiceFiltes(filterOrderRequest);
|
|
|
}
|
|
|
|
|
|
if (filterOrderRequest.getSourceLocalType() != null) {
|
|
|
if (filterOrderRequest.getSourceLocalType() == 1) {
|
|
|
filterOrderRequest.setSourceTypes(Arrays.asList(1, 2, 3, 4, 5));
|
|
|
} else {
|
|
|
filterOrderRequest.setSourceTypes(Arrays.asList(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
String customerId = getCustomerId();
|
|
|
if (!customerId.equals("110")) {
|
|
|
filterOrderRequest.setFromCorp(customerId);
|
|
|
}
|
|
|
List<IoOrderResponse> list = orderService.getfilterOrderList(filterOrderRequest);
|
|
|
|
|
|
for (IoOrderResponse ioOrderResponse : list) {
|
|
|
if (ioOrderResponse.getCheckStatus() == null) {
|
|
|
ioOrderResponse.setCheckStatus(0 + "");
|
|
|
}
|
|
|
ioOrderResponse = orderInvoiceService.findRegStausByBillNo(ioOrderResponse);
|
|
|
}
|
|
|
|
|
|
PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(list);
|
|
|
return ResultVOUtils.page(pageInfo);
|
|
|
}
|
|
|
|
|
|
|
|
|
@AuthRuleAnnotation("")
|
|
|
@GetMapping("/udiwms/inout/preInorder/filter")
|
|
|
public BaseResponse filterPreInorder(FilterOrderRequest filterOrderRequest) {
|
|
|
|
|
|
|
|
|
filterOrderRequest.setVueType(Constant.ORDER_ACTION_SUP_PREIN);
|
|
|
orderService.setActions(filterOrderRequest);
|
|
|
List<IoOrderResponse> list = orderService.filterList(filterOrderRequest);
|
|
|
PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(list);
|
|
|
return ResultVOUtils.page(pageInfo);
|
|
|
}
|
|
|
|
|
|
@GetMapping("/udiwms/inout/order/filterInvoice")
|
|
|
public BaseResponse filterInvoice(FilterOrderRequest filterOrderRequest) {
|
|
|
filterOrderRequest.setDealStatuses(Arrays.asList(2, 3));
|
|
|
filterOrderRequest.setStatuses(Arrays.asList(7, 5, 10));
|
|
|
String customerId = getCustomerId();
|
|
|
if (!customerId.equals("110")) {
|
|
|
filterOrderRequest.setFromCorp(customerId);
|
|
|
}
|
|
|
List<IoOrderResponse> list = orderService.filterList(filterOrderRequest);
|
|
|
PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(list);
|
|
|
return ResultVOUtils.page(pageInfo);
|
|
|
}
|
|
|
//切换单据清空单据信息
|
|
|
@AuthRuleAnnotation("")
|
|
|
@PostMapping("warehouse/inout/delmitBiz")
|
|
|
@Log(title = "单据管理", businessType = BusinessType.UPDATE)
|
|
|
public BaseResponse delmitBiz(@RequestBody AddOrderRequest addOrderRequest) {
|
|
|
|
|
|
IoOrderEntity orderEntity = orderService.findByBillNo(addOrderRequest.getBillNo());
|
|
|
// BaseResponse tempResponse = checkSubmitEnable(orderEntity);
|
|
|
// if (tempResponse != null)
|
|
|
// return tempResponse;
|
|
|
//校验单据是否已完成
|
|
|
int b = orderDetailBizService.deleteByOrderId(addOrderRequest.getBillNo());
|
|
|
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
//新增业务-立即提交
|
|
|
@RepeatSubmit()
|
|
|
@AuthRuleAnnotation("")
|
|
|
@PostMapping("warehouse/inout/submitBiz")
|
|
|
@Log(title = "单据管理", businessType = BusinessType.UPDATE)
|
|
|
public BaseResponse submitBiz(@RequestBody AddOrderRequest addOrderRequest) {
|
|
|
|
|
|
IoOrderEntity orderEntity = orderService.findByBillNo(addOrderRequest.getBillNo());
|
|
|
BaseResponse tempResponse = checkSubmitEnable(orderEntity);
|
|
|
if (tempResponse != null)
|
|
|
return tempResponse;
|
|
|
//校验单据是否已完成
|
|
|
List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(addOrderRequest.getBillNo());
|
|
|
|
|
|
if (CollUtil.isEmpty(orderDetailBizEntities)) {
|
|
|
return ResultVOUtils.error(500, "请先录入产品！");
|
|
|
}
|
|
|
|
|
|
BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
|
|
|
String vailKey = "";
|
|
|
for (IoOrderDetailBizEntity orderDetailBizEntity : orderDetailBizEntities) {
|
|
|
|
|
|
if (orderDetailBizEntity.getBindRlFk() == null) {
|
|
|
return ResultVOUtils.error(500, orderDetailBizEntity.getCoName() + "该产品未指定唯一耗材编码！");
|
|
|
}
|
|
|
if (StrUtil.isEmpty(orderDetailBizEntity.getSupId())) {
|
|
|
return ResultVOUtils.error(500, orderDetailBizEntity.getCoName() + "该产品未指定供应商！");
|
|
|
}
|
|
|
if (orderDetailBizEntity.getCount() == 0) {
|
|
|
return ResultVOUtils.error(500, orderDetailBizEntity.getCoName() + "产品数量不能为0！");
|
|
|
}
|
|
|
|
|
|
if (bussinessTypeEntity.getCheckWebNew() == 1 || bussinessTypeEntity.getCheckWebNew() == 3) {
|
|
|
if (StrUtil.isEmpty(orderDetailBizEntity.getBatchNo())
|
|
|
&& StrUtil.isEmpty(orderDetailBizEntity.getProductDate())
|
|
|
&& StrUtil.isEmpty(orderDetailBizEntity.getExpireDate())) {
|
|
|
return ResultVOUtils.error(500, orderDetailBizEntity.getCoName() + "三期不能全为空！");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
ioAddInoutService.dealBusProcess(orderEntity, bussinessTypeEntity);
|
|
|
return ResultVOUtils.success("提交成功！");
|
|
|
}
|
|
|
|
|
|
//新增扫码单据-立即提交
|
|
|
@RepeatSubmit()
|
|
|
@AuthRuleAnnotation("")
|
|
|
@PostMapping("warehouse/inout/submitCodes")
|
|
|
@Log(title = "单据管理", businessType = BusinessType.UPDATE)
|
|
|
public BaseResponse submitCodes(@RequestBody AddOrderRequest addOrderRequest) {
|
|
|
|
|
|
//校验单据是否已完成
|
|
|
List<IoOrderDetailCodeEntity> orderDetailCodeEntities = orderDetailCodeService.findByOrderId(addOrderRequest.getBillNo());
|
|
|
|
|
|
if (CollUtil.isEmpty(orderDetailCodeEntities)) {
|
|
|
return ResultVOUtils.error(500, "单据未扫码或扫码校验无法通过,提交失败,请检查后重新提交！");
|
|
|
}
|
|
|
IoOrderEntity orderEntity = orderService.findByBillNo(addOrderRequest.getBillNo());
|
|
|
orderEntity.setRemark(addOrderRequest.getRemark());
|
|
|
BaseResponse tempResponse = checkSubmitEnable(orderEntity);
|
|
|
if (tempResponse != null)
|
|
|
return tempResponse;
|
|
|
//todo 目前先去掉因为不能改变状态 有问题可以看一下这个方法
|
|
|
// if (orderEntity.getStatus() != ConstantStatus.ORDER_STATUS_TEMP_SAVE){
|
|
|
ioAddInoutService.dealProcess(orderEntity);
|
|
|
// }
|
|
|
|
|
|
|
|
|
//不需要手动校验，则走正常单据校验处理流程
|
|
|
if (!ioCheckInoutService.checkManual(orderEntity.getBillNo())) {
|
|
|
ioCheckInoutService.check(orderEntity.getBillNo());
|
|
|
}
|
|
|
return ResultVOUtils.success("提交成功,等待处理！");
|
|
|
}
|
|
|
|
|
|
|
|
|
//新增业务单据，新增扫码单据，等待校验-草稿保存
|
|
|
@RepeatSubmit()
|
|
|
@AuthRuleAnnotation("")
|
|
|
@PostMapping("warehouse/inout/saveOrderWeb")
|
|
|
@Log(title = "单据管理", businessType = BusinessType.UPDATE)
|
|
|
public BaseResponse saveOrderWeb(@RequestBody AddOrderRequest addOrderRequest) {
|
|
|
System.out.println(addOrderRequest.toString());
|
|
|
IoOrderEntity orderEntity = new IoOrderEntity();
|
|
|
if (StrUtil.isEmpty(addOrderRequest.getAction()))
|
|
|
return ResultVOUtils.error(500, "单据类型不能为空");
|
|
|
|
|
|
BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(addOrderRequest.getAction());
|
|
|
BasicCorpEntity basicCorpEntity;
|
|
|
//要是特殊往来信息没有就创建
|
|
|
if (bussinessTypeEntity.getCorpType() == ConstantStatus.CORP_TYPE_INPUT && bussinessTypeEntity.isGenUnit()) {
|
|
|
basicCorpEntity = basicCorpService.selectByName(orderEntity.getFromCorp());
|
|
|
if (basicCorpEntity == null) {
|
|
|
basicCorpEntity = new BasicCorpEntity();
|
|
|
basicCorpEntity.setErpId(CustomUtil.getUnitId());
|
|
|
basicCorpEntity.setCorpType(ConstantStatus.CORP_SICK);
|
|
|
basicCorpEntity.setOutType(ConstantStatus.CORP_SICK_SICK);
|
|
|
basicCorpEntity.setName(addOrderRequest.getFromCorp());
|
|
|
basicCorpEntity.setId(IdUtil.getSnowflakeNextId());
|
|
|
basicCorpService.insert(basicCorpEntity);
|
|
|
}
|
|
|
orderEntity.setFromCorp(basicCorpEntity.getErpId());
|
|
|
} else {
|
|
|
orderEntity.setFromCorp(addOrderRequest.getFromCorp());
|
|
|
}
|
|
|
orderEntity.setAction(addOrderRequest.getAction());
|
|
|
orderEntity.setMainAction(bussinessTypeEntity.getMainAction());
|
|
|
orderEntity.setRemark(addOrderRequest.getRemark());
|
|
|
orderEntity.setFromInvCode(addOrderRequest.getFromInvCode());
|
|
|
orderEntity.setDeptCode(addOrderRequest.getDeptCode());
|
|
|
orderEntity.setBillNo(addOrderRequest.getBillNo());
|
|
|
orderEntity.setInvCode(addOrderRequest.getInvCode());
|
|
|
orderService.updateByBillNo(orderEntity);
|
|
|
|
|
|
|
|
|
IoCodeTempEntity warehouseEntity = new IoCodeTempEntity();
|
|
|
warehouseEntity.setOrderId(orderEntity.getBillNo());
|
|
|
warehouseEntity.setAction(orderEntity.getAction());
|
|
|
warehouseEntity.setMainAction(orderEntity.getMainAction());
|
|
|
warehouseEntity.setDeptCode(orderEntity.getDeptCode());
|
|
|
warehouseEntity.setInvCode(orderEntity.getInvCode());
|
|
|
codeTempService.updateByOrderId(warehouseEntity);
|
|
|
return ResultVOUtils.success("保存成功！");
|
|
|
}
|
|
|
|
|
|
//待配货/待校验-立即提交
|
|
|
@RepeatSubmit()
|
|
|
@AuthRuleAnnotation("")
|
|
|
@PostMapping("warehouse/inout/submitOrderWeb")
|
|
|
@Log(title = "单据管理", businessType = BusinessType.UPDATE)
|
|
|
public BaseResponse submitOrderWeb(@RequestBody AddOrderRequest addOrderRequest) {
|
|
|
|
|
|
IoOrderEntity orderEntity = orderService.findByBillNo(addOrderRequest.getBillNo());
|
|
|
//补充备注
|
|
|
if(addOrderRequest.getRemark()!=null){
|
|
|
orderEntity.setRemark(addOrderRequest.getRemark());
|
|
|
}
|
|
|
BaseResponse tempResponse = checkSubmitEnable(orderEntity);
|
|
|
if (tempResponse != null)
|
|
|
return tempResponse;
|
|
|
|
|
|
//校验单据是否已完成
|
|
|
List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(addOrderRequest.getBillNo());
|
|
|
List<IoOrderDetailCodeEntity> orderDetailCodeEntities = orderDetailCodeService.findByOrderId(addOrderRequest.getBillNo());
|
|
|
|
|
|
if (CollUtil.isEmpty(orderDetailCodeEntities)) {
|
|
|
return ResultVOUtils.error(500, "单据还未扫码或和扫码校验存在异常无法提交！");
|
|
|
}
|
|
|
BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
|
|
|
if (checkInoutService.checkManual(addOrderRequest.getBillNo())) {
|
|
|
if (CollUtil.isNotEmpty(orderDetailBizEntities)) {
|
|
|
|
|
|
if (bussinessTypeEntity.getCheckWebNew() == 1) {
|
|
|
String errMsg = checkInoutService.bizOrderCheck(orderDetailBizEntities, orderDetailCodeEntities);
|
|
|
if (StrUtil.isNotEmpty(errMsg)) {
|
|
|
return ResultVOUtils.error(500, errMsg);
|
|
|
}
|
|
|
errMsg = checkInoutService.codeOrderCheck(orderDetailCodeEntities, orderDetailBizEntities);
|
|
|
if (StrUtil.isNotEmpty(errMsg)) {
|
|
|
return ResultVOUtils.error(500, errMsg);
|
|
|
}
|
|
|
saveOrderWeb(addOrderRequest);
|
|
|
orderEntity.setStatus(ORDER_STATUS_CHECK_PROCESS);
|
|
|
orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
|
|
|
orderService.update(orderEntity);
|
|
|
checkInoutService.check(addOrderRequest.getBillNo());
|
|
|
} else {
|
|
|
String errMsg = checkInoutService.bizNoPiCheck(orderDetailBizEntities, orderEntity);
|
|
|
if (StrUtil.isNotEmpty(errMsg)) {
|
|
|
return ResultVOUtils.error(500, errMsg);
|
|
|
}
|
|
|
orderDetailBizService.deleteByOrderId(addOrderRequest.getBillNo());
|
|
|
for (IoOrderDetailCodeEntity orderDetailCodeEntity : orderDetailCodeEntities) {
|
|
|
IoOrderDetailBizEntity orderDetailBizEntity = new IoOrderDetailBizEntity();
|
|
|
BeanUtils.copyProperties(orderDetailCodeEntity, orderDetailBizEntity);
|
|
|
orderDetailBizEntity.setId(null);
|
|
|
orderDetailBizEntity.setCount(IntUtil.value(orderDetailCodeEntity.getReCount()));
|
|
|
getSomeBiz(orderDetailBizEntities, orderDetailBizEntity);
|
|
|
orderDetailBizService.insert(orderDetailBizEntity);
|
|
|
}
|
|
|
saveOrderWeb(addOrderRequest);
|
|
|
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK);
|
|
|
orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
|
|
|
orderService.update(orderEntity);
|
|
|
ioAddInoutService.dealProcess(orderEntity);
|
|
|
checkInoutService.check(addOrderRequest.getBillNo());
|
|
|
}
|
|
|
|
|
|
|
|
|
} else {
|
|
|
return ResultVOUtils.error(500, "单据校验提交失败,请先录入业务单据！");
|
|
|
}
|
|
|
} else {
|
|
|
orderEntity.setStatus(ORDER_STATUS_CHECK_PROCESS);
|
|
|
ioAddInoutService.dealProcess(orderEntity);
|
|
|
checkInoutService.check(addOrderRequest.getBillNo());
|
|
|
return ResultVOUtils.success("提交成功！");
|
|
|
}
|
|
|
|
|
|
return ResultVOUtils.success("提交成功！");
|
|
|
}
|
|
|
|
|
|
|
|
|
// 待校验提交,以扫码结果提交
|
|
|
@RepeatSubmit()
|
|
|
@AuthRuleAnnotation("")
|
|
|
@PostMapping("warehouse/inout/codeResult/submitOrderWeb")
|
|
|
@Log(title = "单据管理", businessType = BusinessType.UPDATE)
|
|
|
public BaseResponse submitByCodeResult(@RequestBody AddOrderRequest addOrderRequest) {
|
|
|
|
|
|
IoOrderEntity orderEntity = orderService.findByBillNo(addOrderRequest.getBillNo());
|
|
|
BaseResponse tempResponse = checkSubmitEnable(orderEntity);
|
|
|
if (tempResponse != null)
|
|
|
return tempResponse;
|
|
|
|
|
|
//校验单据是否已完成
|
|
|
List<IoOrderDetailCodeEntity> orderDetailCodeEntities = orderDetailCodeService.findByOrderId(addOrderRequest.getBillNo());
|
|
|
if (CollUtil.isEmpty(orderDetailCodeEntities)) {
|
|
|
return ResultVOUtils.error(500, "单据还未扫码或和扫码校验存在异常无法提交！");
|
|
|
}
|
|
|
saveOrderWeb(addOrderRequest);
|
|
|
orderEntity.setStatus(ORDER_STATUS_CHECK_PROCESS);
|
|
|
orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
|
|
|
orderService.update(orderEntity);
|
|
|
checkInoutService.checkCodeResult(addOrderRequest.getBillNo());
|
|
|
return ResultVOUtils.success("提交成功！");
|
|
|
}
|
|
|
|
|
|
|
|
|
//待校验提交,以比对结果提交
|
|
|
@RepeatSubmit()
|
|
|
@AuthRuleAnnotation("")
|
|
|
@Transactional(rollbackFor = Exception.class)
|
|
|
@PostMapping("warehouse/inout/codeCheck/submitOrderWeb")
|
|
|
@Log(title = "单据管理", businessType = BusinessType.UPDATE)
|
|
|
public BaseResponse submitByCheckResult(@RequestBody AddOrderRequest addOrderRequest) {
|
|
|
|
|
|
IoOrderEntity orderEntity = orderService.findByBillNo(addOrderRequest.getBillNo());
|
|
|
BaseResponse tempResponse = checkSubmitEnable(orderEntity);
|
|
|
if (tempResponse != null)
|
|
|
return tempResponse;
|
|
|
|
|
|
//校验单据是否已完成
|
|
|
List<IoCodeResponse> codeEntities = codeTempService.findJoinByOrderId(addOrderRequest.getBillNo());
|
|
|
if (CollUtil.isEmpty(codeEntities)) {
|
|
|
return ResultVOUtils.error(500, "单据还未扫码或和扫码校验存在异常无法提交！");
|
|
|
}
|
|
|
|
|
|
List<IoCodeResponse> codeTempEntities = getCheckRusultCode(addOrderRequest.getBillNo(), codeEntities);
|
|
|
for (IoCodeResponse codeTempEntity : codeTempEntities) {
|
|
|
if (IntUtil.value(codeTempEntity.getCheckStatus()) == 2) {
|
|
|
return ResultVOUtils.error(501, "存在多余条码，请先剔除后重新提交！");
|
|
|
}
|
|
|
}
|
|
|
codeTempService.deleteByBillNo(addOrderRequest.getBillNo());
|
|
|
for (IoCodeResponse codeResponse : codeTempEntities) {
|
|
|
if (IntUtil.value(codeResponse.getCheckStatus()) == 0) {
|
|
|
IoCodeTempEntity codeTempEntity = new IoCodeTempEntity();
|
|
|
BeanUtil.copyProperties(codeResponse, codeTempEntity);
|
|
|
codeTempService.insert(codeTempEntity);
|
|
|
}
|
|
|
}
|
|
|
orderEntity.setStatus(ORDER_STATUS_CHECK_PROCESS);
|
|
|
ioAddInoutService.dealProcess(orderEntity);
|
|
|
checkInoutService.checkRightResult(addOrderRequest.getBillNo());
|
|
|
return ResultVOUtils.success("提交成功！");
|
|
|
|
|
|
}
|
|
|
|
|
|
public BaseResponse checkSubmitEnable(IoOrderEntity orderEntity) {
|
|
|
if (orderEntity == null) {
|
|
|
return ResultVOUtils.error(500, "提交失败，请先添加物资！");
|
|
|
}
|
|
|
|
|
|
if (orderEntity.getStatus() == ORDER_STATUS_CHECK_PROCESS || orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_PROCESS
|
|
|
|| orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_PROCESSING) {
|
|
|
return ResultVOUtils.error(500, "提交失败，单据正在处理，请稍后刷新查看！");
|
|
|
}
|
|
|
if (orderEntity.getStatus() != 1 && orderEntity.getStatus() != 3 && orderEntity.getStatus() != 4 && orderEntity.getStatus() != 6) {
|
|
|
return ResultVOUtils.error(500, "提交失败，单据已提交，请稍后刷新查看！");
|
|
|
}
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
@AuthRuleAnnotation("")
|
|
|
@GetMapping("admin/warehouse/inout/findCheckCode")
|
|
|
public BaseResponse findCheckCode(FilterCodeRequest filterCodeRequest) {
|
|
|
//校验单据是否已完成
|
|
|
List<IoCodeResponse> codeTempEntities = codeTempService.findJoinByOrderId(filterCodeRequest.getOrderId());
|
|
|
List<IoCodeResponse> codeEntities = getCheckRusultCode(filterCodeRequest.getOrderId(), codeTempEntities);
|
|
|
PageSimpleResponse<IoCodeResponse> pageSimpleResponse = new PageSimpleResponse<>();
|
|
|
pageSimpleResponse.setTotal(0l);
|
|
|
pageSimpleResponse.setList(codeEntities);
|
|
|
return ResultVOUtils.success(pageSimpleResponse);
|
|
|
}
|
|
|
|
|
|
|
|
|
public List<IoCodeTempEntity> getOtherCode(String billNo, List<IoCodeTempEntity> codeEntities) {
|
|
|
List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(billNo);
|
|
|
|
|
|
for (IoOrderDetailBizEntity bizEntity : orderDetailBizEntities) {
|
|
|
bizEntity.setCheckSuccess(false);
|
|
|
bizEntity.setScanCount(0);
|
|
|
}
|
|
|
for (IoCodeTempEntity codeTempEntity : codeEntities) {
|
|
|
codeTempEntity.setCheckSuccess(false);
|
|
|
}
|
|
|
List<IoCodeTempEntity> otherCodes = new ArrayList<>();
|
|
|
for (IoCodeTempEntity codeEntity : codeEntities) {
|
|
|
for (IoOrderDetailBizEntity bizEntity : orderDetailBizEntities) {
|
|
|
if (checkId(bizEntity, codeEntity) == null
|
|
|
&& checkBatchNo(bizEntity, codeEntity) == null
|
|
|
&& checkProductDate(bizEntity, codeEntity) == null
|
|
|
&& checkExpireDate(bizEntity, codeEntity) == null) {
|
|
|
int curCount = IntUtil.value(codeEntity.getReCount()) + bizEntity.getScanCount();
|
|
|
if (bizEntity.getCount() < curCount) {
|
|
|
otherCodes.add(codeEntity);
|
|
|
} else {
|
|
|
bizEntity.setScanCount(curCount);
|
|
|
}
|
|
|
codeEntity.setCheckSuccess(true);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if (!codeEntity.isCheckSuccess()) {
|
|
|
otherCodes.add(codeEntity);
|
|
|
}
|
|
|
}
|
|
|
return otherCodes;
|
|
|
}
|
|
|
|
|
|
public List<IoCodeResponse> getCheckRusultCode(String billNo, List<IoCodeResponse> codeEntities) {
|
|
|
List<IoOrderDetailCodeEntity> orderDetailCodeEntities = orderDetailCodeService.findByOrderId(billNo);
|
|
|
List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(billNo);
|
|
|
List<IoOrderCheckResultResponse> orderCheckResultResponses = ioCheckInoutService.combineCheck(orderDetailBizEntities, orderDetailCodeEntities);
|
|
|
if (CollUtil.isNotEmpty(orderCheckResultResponses)) {
|
|
|
for (IoOrderCheckResultResponse orderCheckResultResponse : orderCheckResultResponses) {
|
|
|
for (IoCodeResponse codeTempEntity : codeEntities) {
|
|
|
if (IntUtil.value(codeTempEntity.getRelId()) == IntUtil.value(orderCheckResultResponse.getBindRlFk())
|
|
|
&& (StrUtil.nullToEmpty(codeTempEntity.getBatchNo()).equals(StrUtil.nullToEmpty(orderCheckResultResponse.getBBatchNo()))
|
|
|
|| StrUtil.nullToEmpty(codeTempEntity.getBatchNo()).equals(StrUtil.nullToEmpty(orderCheckResultResponse.getSBatchNo())
|
|
|
))) {
|
|
|
if (orderCheckResultResponse.getCount() < 1) {
|
|
|
codeTempEntity.setCheckStatus(1);
|
|
|
} else if (orderCheckResultResponse.getCount() < orderCheckResultResponse.getScanCount()) {
|
|
|
codeTempEntity.setCheckStatus(2);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
// List<IoCodeTempEntity> otherCodes = getOtherCode(billNo, codeEntities);
|
|
|
// for (IoCodeTempEntity codeTempEntity : otherCodes) {
|
|
|
// boolean isTure = false;
|
|
|
// for (IoCodeTempEntity codeEntity : codeEntities) {
|
|
|
// if (IntUtil.value(codeTempEntity.getId()) != IntUtil.value(codeEntity.getId())) {
|
|
|
// if (StrUtil.nullToEmpty(codeTempEntity.getBatchNo()).equals(StrUtil.nullToEmpty(codeEntity.getBatchNo()))) {
|
|
|
// codeEntity.setCheckStatus(2);
|
|
|
// isTure = true;
|
|
|
// }
|
|
|
// } else {
|
|
|
// if (IntUtil.value(codeTempEntity.getReCount()) != IntUtil.value(codeEntity.getReCount()) || isTure) {
|
|
|
// codeEntity.setCheckStatus(2);
|
|
|
// isTure = true;
|
|
|
// }
|
|
|
// }
|
|
|
// }
|
|
|
// if (!isTure)
|
|
|
// codeTempEntity.setCheckStatus(1);
|
|
|
// }
|
|
|
return codeEntities;
|
|
|
}
|
|
|
|
|
|
|
|
|
//带配货-立即提交
|
|
|
@RepeatSubmit()
|
|
|
@AuthRuleAnnotation("")
|
|
|
@PostMapping("warehouse/inout/waitAllocate/submitOrderWeb")
|
|
|
@Log(title = "单据管理", businessType = BusinessType.UPDATE)
|
|
|
public BaseResponse submitWaitAllocateWeb(@RequestBody AddOrderRequest addOrderRequest) {
|
|
|
|
|
|
//校验单据是否已完成
|
|
|
IoOrderEntity orderEntity = orderService.findByBillNo(addOrderRequest.getBillNo());
|
|
|
BaseResponse tempResponse = checkSubmitEnable(orderEntity);
|
|
|
if (tempResponse != null)
|
|
|
return tempResponse;
|
|
|
|
|
|
List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(addOrderRequest.getBillNo());
|
|
|
List<IoOrderDetailCodeEntity> orderDetailCodeEntities = orderDetailCodeService.findByOrderId(addOrderRequest.getBillNo());
|
|
|
|
|
|
if (CollUtil.isEmpty(orderDetailCodeEntities)) {
|
|
|
return ResultVOUtils.error(500, "单据还未扫码或和扫码校验存在异常无法提交！");
|
|
|
}
|
|
|
String errMsg = checkInoutService.bizNoPiCheck(orderDetailBizEntities, orderEntity);
|
|
|
if (StrUtil.isNotEmpty(errMsg)) {
|
|
|
return ResultVOUtils.error(500, errMsg);
|
|
|
}
|
|
|
orderDetailBizService.deleteByOrderId(addOrderRequest.getBillNo());
|
|
|
for (IoOrderDetailCodeEntity orderDetailCodeEntity : orderDetailCodeEntities) {
|
|
|
IoOrderDetailBizEntity orderDetailBizEntity = new IoOrderDetailBizEntity();
|
|
|
BeanUtils.copyProperties(orderDetailCodeEntity, orderDetailBizEntity);
|
|
|
orderDetailBizEntity.setCount(IntUtil.value(orderDetailCodeEntity.getReCount()));
|
|
|
orderDetailBizEntity.setId(null);
|
|
|
getSomeBiz(orderDetailBizEntities, orderDetailBizEntity);
|
|
|
orderDetailBizService.insert(orderDetailBizEntity);
|
|
|
}
|
|
|
saveOrderWeb(addOrderRequest);
|
|
|
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK);
|
|
|
orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
|
|
|
orderService.update(orderEntity);
|
|
|
|
|
|
ioAddInoutService.dealProcess(orderEntity);
|
|
|
checkInoutService.check(addOrderRequest.getBillNo());
|
|
|
return ResultVOUtils.success("提交成功！");
|
|
|
}
|
|
|
|
|
|
|
|
|
public void getSomeBiz(List<IoOrderDetailBizEntity> orderDetailBizEntities, IoOrderDetailBizEntity resutBizEntity) {
|
|
|
for (IoOrderDetailBizEntity orderDetailBizEntity : orderDetailBizEntities) {
|
|
|
if (orderDetailBizEntity.getBindRlFk().longValue() == resutBizEntity.getBindRlFk().longValue()) {
|
|
|
resutBizEntity.setCertCode(orderDetailBizEntity.getCertCode());
|
|
|
resutBizEntity.setPrice(orderDetailBizEntity.getPrice());
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
@Resource
|
|
|
IoCodeService codeService;
|
|
|
|
|
|
//未校验单据删除
|
|
|
@AuthRuleAnnotation("")
|
|
|
@PostMapping("udiwms/inout/order/delete")
|
|
|
@Log(title = "单据管理", businessType = BusinessType.DELETE)
|
|
|
public BaseResponse deletById(@RequestBody DeleteRequest deleteRequest) {
|
|
|
IoOrderEntity orderEntity = orderService.findByBillNo(deleteRequest.getBillNo());
|
|
|
if (orderEntity.getStatus() != 1 && orderEntity.getStatus() != 3 && orderEntity.getStatus() != 4 && orderEntity.getStatus() != 6 && orderEntity.getStatus() != 10) {
|
|
|
return ResultVOUtils.error(500, "单据已提交无法删除！");
|
|
|
}
|
|
|
orderService.deleteByBillNo(deleteRequest.getBillNo());
|
|
|
orderDetailBizService.deleteByOrderId(deleteRequest.getBillNo());
|
|
|
orderDetailCodeService.deleteByOrderId(deleteRequest.getBillNo());
|
|
|
codeTempService.deleteByBillNo(deleteRequest.getBillNo());
|
|
|
codeService.deleteCodeByOrderId(deleteRequest.getBillNo());
|
|
|
return ResultVOUtils.success("删除成功！");
|
|
|
}
|
|
|
|
|
|
|
|
|
//已验收单据删除、单据编辑删除等
|
|
|
@AuthRuleAnnotation("")
|
|
|
@PostMapping("udiwms/inout/order/finish/delete")
|
|
|
@Log(title = "单据管理", businessType = BusinessType.DELETE)
|
|
|
public BaseResponse deleteById(@RequestBody DeleteRequest deleteRequest) {
|
|
|
List<String> delBillNos = new ArrayList<>();
|
|
|
if (CollUtil.isNotEmpty(deleteRequest.getBillNos())) {
|
|
|
delBillNos.addAll(deleteRequest.getBillNos());
|
|
|
} else {
|
|
|
delBillNos.add(deleteRequest.getBillNo());
|
|
|
}
|
|
|
orderService.deleteInvByBillNo(delBillNos);
|
|
|
for (String billNo : delBillNos) {
|
|
|
orderService.deleteByBillNo(billNo);
|
|
|
orderDetailBizService.deleteByOrderId(billNo);
|
|
|
orderDetailCodeService.deleteByOrderId(billNo);
|
|
|
codeTempService.deleteByBillNo(billNo);
|
|
|
codeService.deleteCodeByOrderId(billNo);
|
|
|
}
|
|
|
return ResultVOUtils.success("删除成功！");
|
|
|
}
|
|
|
|
|
|
|
|
|
//单据编辑，条码减一
|
|
|
@AuthRuleAnnotation("")
|
|
|
@PostMapping("udiwms/inout/code/finish/delete")
|
|
|
@Log(title = "单据管理", businessType = BusinessType.DELETE)
|
|
|
public BaseResponse deleteCodeById(@RequestBody IoCodeEntity codeEntity) {
|
|
|
orderService.deleteInvCode(codeEntity.getOrderId(), codeEntity.getCode());
|
|
|
return ResultVOUtils.success("删除成功！");
|
|
|
}
|
|
|
|
|
|
//已验收单据撤回
|
|
|
@RepeatSubmit()
|
|
|
@AuthRuleAnnotation("")
|
|
|
@GetMapping("/udiwms/inout/order/received/rollback")
|
|
|
@Log(title = "单据管理", businessType = BusinessType.UPDATE)
|
|
|
public BaseResponse rollbackOrder(String billNo) {
|
|
|
if (StrUtil.isBlank(billNo)) {
|
|
|
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
|
|
|
}
|
|
|
|
|
|
IoOrderEntity orderEntity = orderService.findByBillNo(billNo);
|
|
|
if (orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_AUDITED) {
|
|
|
if (StrUtil.isNotEmpty(orderEntity.getSupplementNo()) || StrUtil.isNotEmpty(orderEntity.getUllageSupNo())) {
|
|
|
return ResultVOUtils.error(500, "单据已补单，无法撤回！");
|
|
|
}
|
|
|
if (orderEntity.getSyncStatus() != null && orderEntity.getSyncStatus() == 1) {
|
|
|
return ResultVOUtils.error(500, "单据已同步，无法撤回！");
|
|
|
}
|
|
|
boolean result = orderService.rollbackOrder(billNo);
|
|
|
if (result) {
|
|
|
return ResultVOUtils.success();
|
|
|
}
|
|
|
return ResultVOUtils.error(ResultEnum.NOT_NETWORK, "撤回失败");
|
|
|
} else if (orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_CHECK_REW) {
|
|
|
|
|
|
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_SUCCESS);
|
|
|
orderService.update(orderEntity);
|
|
|
return ResultVOUtils.success("撤回成功！");
|
|
|
|
|
|
} else if (orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_CHECK_SUCCESS) {
|
|
|
if (StrUtil.isBlank(billNo)) {
|
|
|
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
|
|
|
}
|
|
|
boolean result = orderService.rollbackUnReOrder(billNo);
|
|
|
if (result) {
|
|
|
return ResultVOUtils.success("撤回成功！");
|
|
|
}
|
|
|
return ResultVOUtils.error(ResultEnum.NOT_NETWORK, "撤回失败");
|
|
|
}
|
|
|
return ResultVOUtils.error(ResultEnum.NOT_NETWORK, "撤回失败");
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
//已校验单据撤回到等待处理
|
|
|
@RepeatSubmit()
|
|
|
@AuthRuleAnnotation("")
|
|
|
@GetMapping("/udiwms/inout/order/unReceive/rollback")
|
|
|
@Log(title = "单据管理", businessType = BusinessType.UPDATE)
|
|
|
public BaseResponse rollUnReceivebackOrder(String billNo) {
|
|
|
if (StrUtil.isBlank(billNo)) {
|
|
|
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
|
|
|
}
|
|
|
boolean result = orderService.rollbackUnReOrder(billNo);
|
|
|
if (result) {
|
|
|
return ResultVOUtils.success("撤回成功！");
|
|
|
}
|
|
|
return ResultVOUtils.error(ResultEnum.NOT_NETWORK, "撤回失败");
|
|
|
}
|
|
|
|
|
|
//待校验撤回草稿
|
|
|
@RepeatSubmit()
|
|
|
@AuthRuleAnnotation("")
|
|
|
@GetMapping("/udiwms/inout/order/waitCheck/rollback")
|
|
|
@Log(title = "单据管理", businessType = BusinessType.UPDATE)
|
|
|
public BaseResponse rollUnCheckOrder(String billNo) {
|
|
|
if (StrUtil.isBlank(billNo)) {
|
|
|
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
|
|
|
}
|
|
|
boolean result = orderService.rollUnCheckOrder(billNo);
|
|
|
if (result) {
|
|
|
return ResultVOUtils.success("撤回成功！");
|
|
|
}
|
|
|
return ResultVOUtils.error(ResultEnum.NOT_NETWORK, "撤回失败");
|
|
|
}
|
|
|
|
|
|
|
|
|
//手持终端获取未处理业务单据进行校验
|
|
|
@AuthRuleAnnotation("")
|
|
|
@GetMapping("/udiwms/erpOrder/filter")
|
|
|
public BaseResponse filterErpOrder(FilterOrderRequest filterOrderRequest,
|
|
|
BindingResult bindingResult) {
|
|
|
|
|
|
if (bindingResult.hasErrors()) {
|
|
|
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
|
|
|
}
|
|
|
if (StrUtil.isEmpty(filterOrderRequest.getAction()))
|
|
|
return ResultVOUtils.error(500, "单据类型不能为空！");
|
|
|
List<IoOrderResponse> orderResponses = orderService.filterList(filterOrderRequest);
|
|
|
List<PdaBusOrderResponse> erpOrderResponses = new ArrayList<>();
|
|
|
if (CollUtil.isNotEmpty(orderResponses)) {
|
|
|
for (IoOrderResponse orderResponse : orderResponses) {
|
|
|
PdaBusOrderResponse pdaBusOrderResponse = new PdaBusOrderResponse();
|
|
|
BeanUtils.copyProperties(orderResponse, pdaBusOrderResponse);
|
|
|
FilterOrderDetailBizRequest filterOrderDetailBizRequest = new FilterOrderDetailBizRequest();
|
|
|
filterOrderDetailBizRequest.setOrderIdFk(orderResponse.getBillNo());
|
|
|
List<IoOrderDetailBizResponse> orderDetailBizEntities = orderDetailBizService.filterList(filterOrderDetailBizRequest);
|
|
|
pdaBusOrderResponse.setOrderDetailBizResponses(orderDetailBizEntities);
|
|
|
erpOrderResponses.add(pdaBusOrderResponse);
|
|
|
}
|
|
|
}
|
|
|
PageInfo<IoOrderResponse> pageInfo;
|
|
|
pageInfo = new PageInfo<>(orderResponses);
|
|
|
PageSimpleResponse<PdaBusOrderResponse> pageSimpleResponse = new PageSimpleResponse<>();
|
|
|
pageSimpleResponse.setTotal(pageInfo.getTotal());
|
|
|
pageSimpleResponse.setList(erpOrderResponses);
|
|
|
return ResultVOUtils.success(pageSimpleResponse);
|
|
|
}
|
|
|
|
|
|
@Resource
|
|
|
EntrustReceService entrustReceService;
|
|
|
@Resource
|
|
|
InvBusUserService invBusUserService;
|
|
|
|
|
|
//手持终端下载扫码单据进行审核
|
|
|
@AuthRuleAnnotation("")
|
|
|
@GetMapping("/udiwms/inout/order/download")
|
|
|
public BaseResponse downloadOrder(FilterOrderRequest filterOrderRequest,
|
|
|
BindingResult bindingResult) {
|
|
|
|
|
|
if (bindingResult.hasErrors()) {
|
|
|
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
|
|
|
}
|
|
|
Long userId = null;
|
|
|
if (filterOrderRequest.getWmsUserId() != null) {
|
|
|
userId = filterOrderRequest.getWmsUserId();
|
|
|
} else userId = getUserId();
|
|
|
|
|
|
List<EntrustReceEntity> entrustReceEntities;
|
|
|
List<InvBusUserEntity> warehouseUserEntities = null;
|
|
|
IoOrderEntity stockOrderEntity = orderService.findByBillNo(filterOrderRequest.getBillNo());
|
|
|
if (stockOrderEntity == null) {
|
|
|
return ResultVOUtils.error(500, "单据未找到！");
|
|
|
} else if (stockOrderEntity.getStatus() == ConstantStatus.ORDER_STATUS_CHECK_SUCCESS) {
|
|
|
|
|
|
//1.校验是否为委托验收人
|
|
|
if (!stockOrderEntity.isEntrustEnd()) {
|
|
|
BasicEntrustRecRequest basicEntrustRecRequest = new BasicEntrustRecRequest();
|
|
|
basicEntrustRecRequest.setAction(stockOrderEntity.getAction());
|
|
|
basicEntrustRecRequest.setEntrustUser(userId);
|
|
|
basicEntrustRecRequest.setCurInv(stockOrderEntity.getInvCode());
|
|
|
entrustReceEntities = entrustReceService.filterEntrustRec(basicEntrustRecRequest);
|
|
|
} else {
|
|
|
return ResultVOUtils.error(500, "单据已委托验收完成！");
|
|
|
}
|
|
|
|
|
|
//2.校验是否为用户所属单据类型
|
|
|
if (StrUtil.isNotEmpty(stockOrderEntity.getDeptCode())) {
|
|
|
FilterInvBusUserRequest filterInvBusUserRequest = new FilterInvBusUserRequest();
|
|
|
filterInvBusUserRequest.setSubInvCode(stockOrderEntity.getInvCode());
|
|
|
filterInvBusUserRequest.setUserId(userId + "");
|
|
|
filterInvBusUserRequest.setScAction(stockOrderEntity.getAction());
|
|
|
warehouseUserEntities = invBusUserService.filterInvBusUser(filterInvBusUserRequest);
|
|
|
}
|
|
|
|
|
|
if (CollUtil.isEmpty(warehouseUserEntities) && CollUtil.isEmpty(entrustReceEntities)) {
|
|
|
return ResultVOUtils.error(500, "权限不足，无法验收！");
|
|
|
}
|
|
|
} else if (stockOrderEntity.getStatus() == ConstantStatus.ORDER_STATUS_AUDITED) {
|
|
|
return ResultVOUtils.error(500, "单据已审核！");
|
|
|
} else {
|
|
|
return ResultVOUtils.error(500, "非未审核单据！");
|
|
|
}
|
|
|
|
|
|
List<IoOrderResponse> orderEntityList = orderService.filterList(filterOrderRequest);
|
|
|
PageInfo<IoOrderResponse> pageInfo;
|
|
|
pageInfo = new PageInfo<>(orderEntityList);
|
|
|
PageSimpleResponse<IoOrderResponse> pageSimpleResponse = new PageSimpleResponse<>();
|
|
|
pageSimpleResponse.setTotal(pageInfo.getTotal());
|
|
|
pageSimpleResponse.setList(orderEntityList);
|
|
|
return ResultVOUtils.success(pageSimpleResponse);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 单据编辑页面查询单据接口
|
|
|
*
|
|
|
* @param billNo
|
|
|
* @return
|
|
|
*/
|
|
|
@GetMapping("udiwms/inout/order/filterOrderTrace")
|
|
|
public BaseResponse filterOrderTrace(String billNo) {
|
|
|
if (StrUtil.isBlank(billNo)) {
|
|
|
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
|
|
|
}
|
|
|
//只用于单据维护 加了状态判断了
|
|
|
List<IoOrderEntity> list = orderService.filterOrderTrace(billNo);
|
|
|
List<IoOrderResponse> responses = orderService.findResponse(list);
|
|
|
return ResultVOUtils.success(responses);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 批量修改单据信息
|
|
|
*
|
|
|
* @return
|
|
|
*/
|
|
|
@PostMapping("/udiwms/inout/order/updateOrderInfo")
|
|
|
@Log(title = "单据管理", businessType = BusinessType.UPDATE)
|
|
|
public BaseResponse updateOrderInfo(@RequestBody OrderEditRequest orderEditRequest) {
|
|
|
if (null == orderEditRequest || CollUtil.isEmpty(orderEditRequest.getOrderIds())) {
|
|
|
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
|
|
|
}
|
|
|
orderService.updateOrderInfo(orderEditRequest);
|
|
|
return ResultVOUtils.success();
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 查询上传单据
|
|
|
*
|
|
|
* @param uploadOrderRequest
|
|
|
* @return
|
|
|
*/
|
|
|
@GetMapping("/udiwms/inout/order/upload/filter")
|
|
|
public BaseResponse filterUploadOrder(FilterUploadOrderRequest uploadOrderRequest) {
|
|
|
List<IoOrderResponse> list = orderService.filterUploadOrderList(uploadOrderRequest);
|
|
|
PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(list);
|
|
|
return ResultVOUtils.page(pageInfo);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 上传单据到第三方系统
|
|
|
*
|
|
|
* @param billNo
|
|
|
* @return
|
|
|
*/
|
|
|
@RepeatSubmit()
|
|
|
@GetMapping("/udiwms/inout/order/submitToThrSys")
|
|
|
public BaseResponse submitToThrSys(@RequestParam("billNo") String billNo) {
|
|
|
if (StrUtil.isBlank(billNo)) {
|
|
|
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
|
|
|
}
|
|
|
return orderService.submitToThrSys(billNo);
|
|
|
}
|
|
|
|
|
|
@PostMapping("/udiwms/inout/order/updateOrderDetailBiz")
|
|
|
@Log(title = "单据管理", businessType = BusinessType.UPDATE)
|
|
|
public BaseResponse updateOrderDetailBiz(@RequestBody IoOrderDetailBizEntity ioOrderDetailBizEntity) {
|
|
|
if (null == ioOrderDetailBizEntity) {
|
|
|
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
|
|
|
}
|
|
|
// ioOrderDetailBizEntity.setCheckFileName(ioOrderDetailBizEntity.getCheckFileName().substring(0,ioOrderDetailBizEntity.getCheckFileName().length() - 4));
|
|
|
orderDetailBizService.updateOrderDetailBiz(ioOrderDetailBizEntity);
|
|
|
return ResultVOUtils.success();
|
|
|
}
|
|
|
|
|
|
@Resource
|
|
|
SpGetHttpClient spGetHttpClient;
|
|
|
|
|
|
@PostMapping("/udiwms/inout/order/updateOrder")
|
|
|
@Log(title = "单据管理", businessType = BusinessType.UPDATE)
|
|
|
public BaseResponse updateOrder(@RequestBody IoOrderEntity ioOrderEntity) {
|
|
|
|
|
|
ioOrderEntity.setUpdateTime(new Date());
|
|
|
orderService.updateByBillNo(ioOrderEntity);
|
|
|
|
|
|
if (IntUtil.value(ioOrderEntity.getCheckStatus()) != 0) {
|
|
|
IoOrderEntity orderEntity = new IoOrderEntity();
|
|
|
orderEntity.setBillNo(ioOrderEntity.getBillNo());
|
|
|
orderEntity.setCheckStatus(1);
|
|
|
spGetHttpClient.updateCheckStatus(orderEntity, getUserId() + "");
|
|
|
}
|
|
|
return ResultVOUtils.success();
|
|
|
}
|
|
|
|
|
|
|
|
|
@Resource
|
|
|
GennerOrderUtils gennerOrderUtils;
|
|
|
@Resource
|
|
|
InvWarehouseService invWarehouseService;
|
|
|
|
|
|
@RepeatSubmit()
|
|
|
@AuthRuleAnnotation("")
|
|
|
@PostMapping("/udiwms/stock/order/change")
|
|
|
public BaseResponse stockOrderChange(@RequestBody AddOrderChangeRequest addOrderChangeRequest) {
|
|
|
|
|
|
AuthAdmin authAdmin = getUser();
|
|
|
IoOrderEntity originOrder = orderService.findByBillNo(addOrderChangeRequest.getOrderId());
|
|
|
IoOrderEntity newOrder = new IoOrderEntity();
|
|
|
List<IoCodeEntity> originCodes = codeService.findByOrderId(originOrder.getBillNo());
|
|
|
newOrder.setCreateTime(new Date());
|
|
|
newOrder.setFromCorp(addOrderChangeRequest.getFromCorp());
|
|
|
|
|
|
newOrder.setFromInvCode(addOrderChangeRequest.getFromInvCode());
|
|
|
if (addOrderChangeRequest.getFromInvCode() != null) {
|
|
|
InvWarehouseEntity fromInv = invWarehouseService.findByInvSubByCode(addOrderChangeRequest.getFromInvCode());
|
|
|
newOrder.setFromDeptCode(fromInv.getParentId());
|
|
|
}
|
|
|
|
|
|
newOrder.setCreateUser(authAdmin.getId() + "");
|
|
|
newOrder.setUpdateUser(authAdmin.getId() + "");
|
|
|
InvWarehouseEntity invWarehouseEntity = invWarehouseService.findByInvSubByCode(addOrderChangeRequest.getInvCode());
|
|
|
newOrder.setInvCode(addOrderChangeRequest.getInvCode());
|
|
|
newOrder.setDeptCode(invWarehouseEntity.getParentId());
|
|
|
newOrder.setCorpOrderId(CustomUtil.getId() + "x");
|
|
|
|
|
|
BasicBussinessTypeEntity basicBussinessTypeEntity = basicBussinessTypeService.findByAction(addOrderChangeRequest.getAction());
|
|
|
newOrder.setAction(addOrderChangeRequest.getAction());
|
|
|
newOrder.setMainAction(basicBussinessTypeEntity.getMainAction());
|
|
|
|
|
|
newOrder.setExportStatus(0); //设置导出状态为未导出
|
|
|
newOrder.setDealStatus(ConstantStatus.ORDER_DEAL_DRAFT);//设置单据未草稿状态
|
|
|
newOrder.setStatus(ConstantStatus.ORDER_STATUS_TEMP_SAVE); //设置验收状态为未验收
|
|
|
newOrder.setFromType(ConstantStatus.FROM_COPY);
|
|
|
newOrder.setOrderType(2);
|
|
|
BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(addOrderChangeRequest.getAction());
|
|
|
String orderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(bussinessTypeEntity.getPrefix()), "yyyyMMdd"));
|
|
|
String supplementOrderNo = orderNo;
|
|
|
newOrder.setBillNo(supplementOrderNo);
|
|
|
newOrder.setReplicateNo(null); //新单据的复制单号置空
|
|
|
originOrder.setReplicateNo(orderNo);
|
|
|
List<IoCodeTempEntity> supplementCodes = new ArrayList<>();
|
|
|
|
|
|
List<IoCodeEntity> products = addOrderChangeRequest.getProducts();
|
|
|
List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(originOrder.getBillNo());
|
|
|
// 计算出两个集合之间产品批次号组成的差异
|
|
|
List<IoOrderDetailBizEntity> IoStatDayEntityList = orderDetailBizEntities.stream()
|
|
|
.filter(comment -> products.stream()
|
|
|
.anyMatch(p -> Objects.equals(p.getBatchNo(), comment.getBatchNo()) // 使用 Objects.equals 来进行非空判断
|
|
|
&& Objects.equals(p.getRelId(), comment.getBindRlFk())))
|
|
|
.collect(Collectors.toList());
|
|
|
//生成业务单
|
|
|
if (CollUtil.isNotEmpty(IoStatDayEntityList)) {
|
|
|
for (IoOrderDetailBizEntity orderDetailBizEntity : IoStatDayEntityList) {
|
|
|
orderDetailBizEntity.setOrderIdFk(newOrder.getBillNo());
|
|
|
orderDetailBizEntity.setId(IdUtil.getSnowflakeNextId());
|
|
|
orderDetailBizService.insert(orderDetailBizEntity);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
originCodes.forEach(
|
|
|
code -> {
|
|
|
//复制选中的产品
|
|
|
for (IoCodeEntity product : products) {
|
|
|
if (product.getRelId().equals(code.getRelId())) {
|
|
|
if ((StrUtil.isNotBlank(product.getBatchNo()) && StrUtil.isNotBlank(code.getBatchNo()) && product.getBatchNo().equals(code.getBatchNo()))
|
|
|
|| (StrUtil.isBlank(product.getBatchNo()) && StrUtil.isBlank(code.getBatchNo()))) {
|
|
|
IoCodeTempEntity supplementCode = new IoCodeTempEntity();
|
|
|
BeanUtil.copyProperties(code, supplementCode);
|
|
|
supplementCode.setInvCode(newOrder.getInvCode());
|
|
|
supplementCode.setDeptCode(newOrder.getDeptCode());
|
|
|
supplementCode.setOrderId(newOrder.getBillNo());
|
|
|
supplementCode.setCorpOrderId(newOrder.getCorpOrderId());
|
|
|
//查询补单设置
|
|
|
supplementCode.setAction(newOrder.getAction());
|
|
|
supplementCode.setMainAction(newOrder.getMainAction());
|
|
|
supplementCode.setUpdateTime(new Date());
|
|
|
supplementCode.setCreateTime(new Date());
|
|
|
supplementCode.setId(null);
|
|
|
supplementCodes.add(supplementCode);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
);
|
|
|
newOrder.setUpdateTime(new Date());
|
|
|
orderService.insertOrder(newOrder);
|
|
|
codeTempService.insertBatch(supplementCodes);
|
|
|
orderService.update(originOrder);
|
|
|
|
|
|
ioAddInoutService.dealProcess(newOrder);
|
|
|
//不需要手动校验，则走正常单据校验处理流程
|
|
|
if (!ioCheckInoutService.checkManual(newOrder.getBillNo())) {
|
|
|
ioCheckInoutService.check(newOrder.getBillNo());
|
|
|
}
|
|
|
|
|
|
return ResultVOUtils.success();
|
|
|
}
|
|
|
|
|
|
@GetMapping("/udiwms/inout/order/getUserBean")
|
|
|
public BaseResponse getUserBean() {
|
|
|
AuthAdmin userBean = customerService.getUserBean();
|
|
|
return ResultVOUtils.success(userBean);
|
|
|
}
|
|
|
|
|
|
@AuthRuleAnnotation("")
|
|
|
@GetMapping("/udiwms/inout/order/filterInvoiceList")
|
|
|
public BaseResponse filterInvoiceList(FilterOrderRequest filterOrderRequest) {
|
|
|
|
|
|
//这个不等于空表示要查询发票对应的单据
|
|
|
if (filterOrderRequest.getInvoiceEncode() != null) {
|
|
|
//查询发票详情
|
|
|
QueryWrapper<IoOrderInvoiceEntity> ew = new QueryWrapper<IoOrderInvoiceEntity>();
|
|
|
ew.eq("invoiceEncode", filterOrderRequest.getInvoiceEncode());
|
|
|
List<IoOrderInvoiceEntity> ioOrderInvoiceEntity = orderInvoiceService.list(ew);
|
|
|
List<String> orderIds = ioOrderInvoiceEntity.stream().map(IoOrderInvoiceEntity::getOrderIdFk).collect(Collectors.toList());
|
|
|
filterOrderRequest.setOrderIds(orderIds);
|
|
|
if (CollectionUtils.isEmpty(orderIds)) {
|
|
|
PageInfo<IoOrderResponse> pageInfo = new PageInfo<>();
|
|
|
return ResultVOUtils.page(pageInfo);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
if (StrUtil.isNotBlank(filterOrderRequest.getStatusType())) {
|
|
|
orderService.setFilterStatus(filterOrderRequest);
|
|
|
}
|
|
|
if (StrUtil.isNotBlank(filterOrderRequest.getVueType())) {
|
|
|
orderService.setActions(filterOrderRequest);
|
|
|
}
|
|
|
|
|
|
if (StrUtil.isNotEmpty(filterOrderRequest.getSupInoivceSearch())) {
|
|
|
orderService.setInvoiceFiltes(filterOrderRequest);
|
|
|
}
|
|
|
if (filterOrderRequest.getSourceLocalType() != null) {
|
|
|
if (filterOrderRequest.getSourceLocalType() == 1) {
|
|
|
filterOrderRequest.setSourceTypes(Arrays.asList(1, 2, 3, 4, 5));
|
|
|
} else {
|
|
|
filterOrderRequest.setSourceTypes(Arrays.asList(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17));
|
|
|
}
|
|
|
}
|
|
|
String customerId = getCustomerId();
|
|
|
if (!customerId.equals("110")) {
|
|
|
filterOrderRequest.setFromCorp(customerId);
|
|
|
}
|
|
|
List<IoOrderResponse> list = orderService.getfilterOrderList(filterOrderRequest);
|
|
|
|
|
|
for (IoOrderResponse ioOrderResponse : list) {
|
|
|
if (ioOrderResponse.getCheckStatus() == null) {
|
|
|
ioOrderResponse.setCheckStatus(0 + "");
|
|
|
}
|
|
|
orderInvoiceService.findRegStausByBillNo(ioOrderResponse);
|
|
|
}
|
|
|
if (filterOrderRequest.getInvoiceEncode() == null) {
|
|
|
//查询已被登记的单据
|
|
|
List<IoOrderInvoiceEntity> ioOrderInvoiceEntity = orderInvoiceService.list();
|
|
|
//已被选择的单据做标记
|
|
|
if (ioOrderInvoiceEntity != null && ioOrderInvoiceEntity.size() > 0) {
|
|
|
for (IoOrderResponse ioOrderResponse : list) {
|
|
|
for (IoOrderInvoiceEntity orderInvoiceEntity : ioOrderInvoiceEntity) {
|
|
|
if (ioOrderResponse.getBillNo().equals(orderInvoiceEntity.getOrderIdFk())) {
|
|
|
ioOrderResponse.setCheckType(true);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(list);
|
|
|
return ResultVOUtils.page(pageInfo);
|
|
|
}
|
|
|
|
|
|
|
|
|
public String checkId(IoOrderDetailBizEntity bizEntity, IoCodeTempEntity codeEntity) {
|
|
|
|
|
|
if (bizEntity.getBindRlFk().longValue() == codeEntity.getRelId().longValue()) {
|
|
|
return null;
|
|
|
} else {
|
|
|
return "产品ID不匹配";
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public String checkBatchNo(IoOrderDetailBizEntity bizEntity, IoCodeTempEntity codeEntity) {
|
|
|
|
|
|
if (StrUtil.nullToEmpty(bizEntity.getBatchNo()).equals(StrUtil.nullToEmpty(codeEntity.getBatchNo()))) {
|
|
|
return null;
|
|
|
} else {
|
|
|
return bizEntity.getCoName() + "批次号不匹配";
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public String checkProductDate(IoOrderDetailBizEntity bizEntity, IoCodeTempEntity codeEntity) {
|
|
|
if (StrUtil.nullToEmpty(bizEntity.getProductDate()).equals(StrUtil.nullToEmpty(codeEntity.getProduceDate()))) {
|
|
|
return null;
|
|
|
} else {
|
|
|
return bizEntity.getCoName() + "生产日期不匹配";
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public String checkExpireDate(IoOrderDetailBizEntity bizEntity, IoCodeTempEntity codeEntity) {
|
|
|
if (StrUtil.nullToEmpty(bizEntity.getExpireDate()).equals(StrUtil.nullToEmpty(codeEntity.getExpireDate()))) {
|
|
|
return null;
|
|
|
} else {
|
|
|
return bizEntity.getCoName() + "失效日期不匹配";
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public String checkCount(IoOrderDetailBizEntity bizEntity, IoCodeTempEntity codeEntity) {
|
|
|
if (bizEntity.getCount() == codeEntity.getReCount()) {
|
|
|
return null;
|
|
|
}
|
|
|
return bizEntity.getCoName() + "数量不匹配！";
|
|
|
}
|
|
|
|
|
|
}
|
