Merge remote-tracking branch 'origin/master'

master
郑明梁 2 years ago
commit 8d6ae5b67b

@ -155,4 +155,41 @@ public class Constant {
public static final String LOGIN_FAIL = "Error";
//-------------前端页面查询单据列表标识类型------------------
/**
* -稿
*/
public static final String ORDER_STATUS_DRAFT = "draft";
/**
* -
*/
public static final String ORDER_STATUS_PROCESSED_ERROR = "processedError";
/**
* -稿
*/
public static final String ORDER_STATUS_NEW_ORDER = "newOrder";
/**
* -
*/
public static final String ORDER_STATUS_UN_CHECK = "unCheck";
/**
* -
*/
public static final String ORDER_STATUS_CHECKED_ERROR = "checkedError";
/**
* -
*/
public static final String ORDER_STATUS_CHECK_SUCCESS = "checkSuccess";
/**
* -
*/
public static final String ORDER_STATUS_AUDITED = "audited";
}

@ -10,7 +10,7 @@ public class ConstantStatus {
/**
* (稿
*/
public static final Integer ORDER_STATUS_TEMP_SAVE = -1;
public static final Integer ORDER_STATUS_TEMP_SAVE = 1;
/**
*
@ -47,6 +47,12 @@ public class ConstantStatus {
*/
public static final Integer ORDER_STATUS_AUDITED_REFUSED = 8;
/**
*
*/
public static final Integer ORDER_STATUS_PROCESSING = 9;
public static final Integer ORDER_STATUS_ADDITIONAL = 5; //补录单据
// public static final Integer ORDER_STATUS_RECEIVEED = 7;

@ -34,8 +34,7 @@ public class BaseController {
}
public Long getUserId() {
AuthAdmin authAdmin = getUser();
return authAdmin.getId();
return customerService.getUserId();
}
public String getCustomerId() {

@ -102,6 +102,7 @@ public class AuthUserController extends BaseController {
FilterNoSelectUserRequest filterNoSelectUserRequest = new FilterNoSelectUserRequest();
BeanUtils.copyProperties(filterInvLinkDataRequest, filterNoSelectUserRequest);
filterNoSelectUserRequest.setUserIds(userIds);
filterNoSelectUserRequest.setLocDeptCode(filterInvLinkDataRequest.getParentId());
List<AuthAdmin> hospitalUserList = authAdminService.selectNotSelectUser(filterNoSelectUserRequest);
PageInfo<AuthAdmin> authAdminPageInfo = new PageInfo<>(hospitalUserList);
PageSimpleResponse<AuthAdmin> authAdminPageSimpleResponse = new PageSimpleResponse<>();

@ -18,7 +18,6 @@ import com.glxp.api.req.basic.FilterBussinessTypeRequest;
import com.glxp.api.req.system.DeleteRequest;
import com.glxp.api.req.thrsys.FilterBasicThirdSysRequest;
import com.glxp.api.res.PageSimpleResponse;
import com.glxp.api.res.auth.InvBusUserResponse;
import com.glxp.api.res.auth.InvSubWarehouseResponse;
import com.glxp.api.res.auth.InvWarehouseThirdSysResponse;
import com.glxp.api.res.auth.WarehouseUserResponse;
@ -36,7 +35,6 @@ import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import javax.validation.Valid;
import java.util.*;
import java.util.stream.Collectors;
@RestController
public class InvWarehouseController extends BaseController {
@ -70,10 +68,6 @@ public class InvWarehouseController extends BaseController {
@GetMapping("spms/sub/inv/warehouse/filter")
public BaseResponse filterInvWarehouse(FilterInvSubWarehouseRequest filterInvSubWarehouseRequest) {
List<InvSubWarehouseResponse> responses = invWarehouseService.filterInvSubWarehouseResponse(filterInvSubWarehouseRequest);
// PageInfo<InvSubWarehouseResponse> pageInfo = new PageInfo<>(responses);
// PageSimpleResponse<InvSubWarehouseResponse> pageSimpleResponse = new PageSimpleResponse<>();
// pageSimpleResponse.setTotal(pageInfo.getTotal());
// pageSimpleResponse.setList(responses);
return ResultVOUtils.success(responses);
}
@ -90,7 +84,7 @@ public class InvWarehouseController extends BaseController {
AuthAdmin authAdmin = getUser();
filterInvWarehouseRequest.setUserId(authAdmin.getId());
if (StrUtil.isEmpty(filterInvWarehouseRequest.getDeptCode())) {
return ResultVOUtils.error(500, "部门编码不能为空");
return ResultVOUtils.error(500, "部门不能为空");
}
List<InvWarehouseEntity> invSubWarehouseEntities = invWarehouseService.filterGroupInvSub(filterInvWarehouseRequest);
return ResultVOUtils.success(invSubWarehouseEntities);
@ -105,12 +99,25 @@ public class InvWarehouseController extends BaseController {
@AuthRuleAnnotation("")
@GetMapping("spms/inv/warehouse/findByUser")
public BaseResponse findByUser(FilterInvWarehouseRequest filterInvWarehouseRequest) {
AuthAdmin authAdmin = getUser();
filterInvWarehouseRequest.setUserId(authAdmin.getId());
filterInvWarehouseRequest.setUserId(getUserId());
List<InvWarehouseEntity> invSubWarehouseEntities = invWarehouseService.filterGroupInvSub(filterInvWarehouseRequest);
return ResultVOUtils.success(invSubWarehouseEntities);
}
/**
* ID
*
* @return
*/
@GetMapping("spms/inv/warehouse/findInvListByUser")
public BaseResponse findInvListByUser() {
Long userId = getUserId();
if (null == userId) {
return ResultVOUtils.error(ResultEnum.LOGIN_VERIFY_FALL);
}
List<InvWarehouseEntity> list = invWarehouseService.findInvListByUser(userId);
return ResultVOUtils.success(list);
}
/**
* ()
@ -382,32 +389,10 @@ public class InvWarehouseController extends BaseController {
if (bindingResult.hasErrors()) {
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
}
filterInvLinkDataRequest.setUserName(filterInvLinkDataRequest.getKey());
List<WarehouseUserEntity> warehouseUserList = warehouseUserService.getWarehouseUserList(filterInvLinkDataRequest);
filterInvLinkDataRequest.setUserName(null);
filterInvLinkDataRequest.setEmployeeName(filterInvLinkDataRequest.getKey());
List<WarehouseUserEntity> warehouseUserList1 = warehouseUserService.getWarehouseUserList(filterInvLinkDataRequest);
PageInfo<WarehouseUserEntity> pageInfo = null;
if (warehouseUserList.size() != 0) {
pageInfo = new PageInfo<>(warehouseUserList);
} else if (warehouseUserList1.size() != 0) {
pageInfo = new PageInfo<>(warehouseUserList1);
} else {
pageInfo = new PageInfo<>(warehouseUserList);
}
List<WarehouseUserResponse> result = new ArrayList<>();
if (CollUtil.isNotEmpty(pageInfo.getList())) {
pageInfo.getList().forEach(warehouseUserEntity -> {
WarehouseUserResponse warehouseUserResponse = new WarehouseUserResponse();
BeanUtils.copyProperties(warehouseUserEntity, warehouseUserResponse);
warehouseUserResponse.setUserid(warehouseUserEntity.getUserid() + "");
result.add(warehouseUserResponse);
});
}
PageSimpleResponse<WarehouseUserResponse> response = new PageSimpleResponse<>();
response.setList(result);
PageInfo<WarehouseUserEntity> pageInfo = new PageInfo<>(warehouseUserList);
PageSimpleResponse<WarehouseUserEntity> response = new PageSimpleResponse<>();
response.setList(pageInfo.getList());
response.setTotal(pageInfo.getTotal());
return ResultVOUtils.success(response);
}

@ -11,6 +11,7 @@ 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.basic.BasicBussinessTypeEntity;
import com.glxp.api.req.basic.BusNoUserRequest;
import com.glxp.api.req.basic.BussinessTypeSaveRequest;
import com.glxp.api.req.basic.FilterBussinessTypeRequest;
import com.glxp.api.req.system.DeleteRequest;
@ -307,4 +308,23 @@ public class BasicBussinessTypeController extends BaseController {
return ResultVOUtils.success(list);
}
@AuthRuleAnnotation("")
@GetMapping("/udiwms/localBusType/filterUnUse")
public BaseResponse filterUnUse(BusNoUserRequest busNoUserRequest,
BindingResult bindingResult) {
if (bindingResult.hasErrors()) {
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
}
FilterBussinessTypeRequest bussinessTypeFilterRequest = new FilterBussinessTypeRequest();
bussinessTypeFilterRequest.setEnable(true);
List<BasicBussinessTypeEntity> bussinessTypeEntities;
bussinessTypeEntities = basicBussinessTypeService.selectIgnoreSelf(busNoUserRequest.getCurAction());
PageSimpleResponse<BasicBussinessTypeEntity> pageSimpleResponse = new PageSimpleResponse<>();
pageSimpleResponse.setList(bussinessTypeEntities);
return ResultVOUtils.success(pageSimpleResponse);
}
}

@ -0,0 +1,117 @@
package com.glxp.api.controller.basic;
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.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.basic.DlEntrustReceEntity;
import com.glxp.api.entity.basic.EntrustReceEntity;
import com.glxp.api.req.auth.BussinessTypeFilterRequest;
import com.glxp.api.req.basic.BasicEntrustRecRequest;
import com.glxp.api.req.basic.FilterBussinessTypeRequest;
import com.glxp.api.req.system.DeleteRequest;
import com.glxp.api.res.PageSimpleResponse;
import com.glxp.api.res.basic.EntrustReceResponse;
import com.glxp.api.service.auth.CustomerService;
import com.glxp.api.service.basic.EntrustReceService;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
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.Date;
import java.util.List;
@RestController
public class EntrustReceController extends BaseController {
@Resource
EntrustReceService entrustReceService;
@Resource
CustomerService customerService;
@Resource
private IBasicBussinessTypeService bussinessTypeService;
@GetMapping("/spms/entrust/rece/filter")
public BaseResponse getEntrustRece(BasicEntrustRecRequest basicExportStatusRequest) {
List<EntrustReceResponse> entrustReceEntities = entrustReceService.filterJoinEntrustRec(basicExportStatusRequest);
PageInfo<EntrustReceResponse> pageInfo;
pageInfo = new PageInfo<>(entrustReceEntities);
PageSimpleResponse<EntrustReceResponse> pageSimpleResponse = new PageSimpleResponse<>();
pageSimpleResponse.setTotal(pageInfo.getTotal());
pageSimpleResponse.setList(entrustReceEntities);
return ResultVOUtils.success(pageSimpleResponse);
}
//手持终端下载委托验收
@GetMapping("/spms/entrust/rece/downloads")
public BaseResponse downloadEntrust(BasicEntrustRecRequest basicExportStatusRequest) {
basicExportStatusRequest.setEntrustUser(getUserId());
List<DlEntrustReceEntity> entrustReceEntities = entrustReceService.downloadEntrustRec(basicExportStatusRequest);
PageInfo<DlEntrustReceEntity> pageInfo;
pageInfo = new PageInfo<>(entrustReceEntities);
PageSimpleResponse<DlEntrustReceEntity> pageSimpleResponse = new PageSimpleResponse<>();
pageSimpleResponse.setTotal(pageInfo.getTotal());
pageSimpleResponse.setList(entrustReceEntities);
return ResultVOUtils.success(pageSimpleResponse);
}
@GetMapping("/spms/entrust/rece/filterAllNoUse")
public BaseResponse filterAllNoUse(FilterBussinessTypeRequest bussinessTypeFilterRequest) {
bussinessTypeFilterRequest.setUserId(getUserId());
List<BasicBussinessTypeEntity> bussinessTypeEntities = bussinessTypeService.filterByUser(bussinessTypeFilterRequest);
return ResultVOUtils.success(bussinessTypeEntities);
}
@PostMapping("/spms/entrust/rece/add")
public BaseResponse aadEntrustRece(@RequestBody EntrustReceEntity entrustReceEntity) {
entrustReceEntity.setUserId(getUserId());
entrustReceEntity.setUpdateTime(new Date());
EntrustReceEntity temp = entrustReceService.findByUnique(entrustReceEntity.getAction(), entrustReceEntity.getEntrustUser());
if (temp != null) {
return ResultVOUtils.error(500, "已存在相同的委托验收");
}
int b = entrustReceService.insertEntrustRec(entrustReceEntity);
if (b > 0) {
return ResultVOUtils.success("添加成功!");
} else {
return ResultVOUtils.error(500, "添加失败!");
}
}
@PostMapping("/spms/entrust/rece/update")
public BaseResponse updateEntrustRece(@RequestBody EntrustReceEntity entrustReceEntity) {
entrustReceEntity.setUpdateTime(new Date());
int b = entrustReceService.updateEntrustRec(entrustReceEntity);
if (b > 0) {
return ResultVOUtils.success("添加成功!");
} else {
return ResultVOUtils.error(500, "添加失败!");
}
}
@PostMapping("/spms/entrust/rece/delete")
public BaseResponse deleteByStatus(@RequestBody DeleteRequest deleteRequest) {
boolean b = entrustReceService.deleteById(deleteRequest.getId());
if (b)
return ResultVOUtils.success("删除成功!");
else
return ResultVOUtils.error(500, "删除失败!");
}
}

@ -3,10 +3,8 @@ package com.glxp.api.controller.inout;
import cn.hutool.core.util.StrUtil;
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.constant.ConstantStatus;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.inout.IoCodeTempEntity;
import com.glxp.api.entity.inout.IoOrderDetailBizEntity;
@ -20,14 +18,12 @@ import com.glxp.api.res.inout.IoOrderResponse;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
import com.glxp.api.service.inout.*;
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 java.util.Date;
import java.util.List;
@ -43,6 +39,10 @@ public class IoOrderController {
private IoCodeTempService codeTempService;
@Resource
private IoCheckInoutService checkInoutService;
@Resource
IoOrderDetailBizService orderDetailBizService;
@Resource
IoOrderDetailCodeService orderDetailCodeService;
/**
*
@ -52,9 +52,9 @@ public class IoOrderController {
* @return
*/
@GetMapping("/udiwms/inout/order/filter")
public BaseResponse filterOrder(FilterOrderRequest filterOrderRequest, BindingResult bindingResult) {
if (bindingResult.hasErrors()) {
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
public BaseResponse filterOrder(FilterOrderRequest filterOrderRequest) {
if (StrUtil.isNotBlank(filterOrderRequest.getStatusType())) {
orderService.setFilterStatus(filterOrderRequest);
}
List<IoOrderResponse> list = orderService.filterList(filterOrderRequest);
PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(list);
@ -97,10 +97,6 @@ public class IoOrderController {
return ResultVOUtils.success("保存成功!");
}
@Resource
IoOrderDetailBizService orderDetailBizService;
@Resource
IoOrderDetailCodeService orderDetailCodeService;
//单据提交
@AuthRuleAnnotation("")
@ -132,4 +128,5 @@ public class IoOrderController {
}
}

@ -0,0 +1,101 @@
package com.glxp.api.controller.inout;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
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.constant.ConstantStatus;
import com.glxp.api.controller.BaseController;
import com.glxp.api.entity.auth.AuthAdmin;
import com.glxp.api.entity.basic.EntrustReceEntity;
import com.glxp.api.entity.inout.IoOrderDetailBizEntity;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.req.inout.ReviewFinishRequest;
import com.glxp.api.res.inout.AcceptOrderResponse;
import com.glxp.api.service.inout.IoAddInoutService;
import com.glxp.api.service.inout.IoCheckInoutService;
import com.glxp.api.service.inout.IoOrderDetailBizService;
import com.glxp.api.service.inout.IoOrderService;
import com.glxp.api.util.RedisUtil;
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 java.util.Date;
import java.util.List;
//单据验收
@Slf4j
@RestController
public class IoOrderReviewController extends BaseController {
@Resource
private RedisUtil redisUtil;
@Resource
IoOrderDetailBizService orderDetailBizService;
@Resource
IoOrderService orderService;
@Resource
IoCheckInoutService ioCheckInoutService;
//获取验收单据业务详情
@AuthRuleAnnotation("")
@GetMapping("/udiwms/stock/order/accept/getOrder")
public BaseResponse getAcceptOrder(String billNo) {
if (StrUtil.isBlank(billNo)) {
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
}
AcceptOrderResponse acceptOrderEntity = new AcceptOrderResponse();
acceptOrderEntity.setBillNo(billNo);
List<IoOrderDetailBizEntity> datas = (List<IoOrderDetailBizEntity>) redisUtil.get(ConstantStatus.REDIS_BILLNO + billNo);
if (CollUtil.isNotEmpty(datas)) {
acceptOrderEntity.setOrderDetailEntities(datas);
acceptOrderEntity.setExitAccept(true);
} else {
List<IoOrderDetailBizEntity> stockOrderDetailEntities = orderDetailBizService.findByOrderId(billNo);
acceptOrderEntity.setOrderDetailEntities(stockOrderDetailEntities);
acceptOrderEntity.setExitAccept(false);
}
return ResultVOUtils.success(acceptOrderEntity);
}
//前端直接验收完成
@AuthRuleAnnotation("")
@PostMapping("/spms/inout/order/web/updateStatus")
public BaseResponse webUpdateStatus(@RequestBody ReviewFinishRequest updateExportStatusRequest,
BindingResult bindingResult) {
if (bindingResult.hasErrors()) {
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
}
IoOrderEntity orderEntity = orderService.findByBillNo(updateExportStatusRequest.getOrderId());
if (orderEntity == null) {
return ResultVOUtils.error(500, "未找到该业务单据");
}
return updateReview(orderEntity);
}
public BaseResponse updateReview(IoOrderEntity orderEntity) {
AuthAdmin authAdmin = getUser();
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
orderEntity.setReviewUser(authAdmin.getId() + "");
orderEntity.setUpdateTime(new Date());
orderEntity.setAuditTime(new Date());
orderService.update(orderEntity);
redisUtil.del(ConstantStatus.REDIS_BILLNO + orderEntity.getBillNo());
redisUtil.del(ConstantStatus.REDIS_BILLNO_CODES + orderEntity.getBillNo());
//验收完成->进入流程
ioCheckInoutService.checkSecond(orderEntity);
return ResultVOUtils.success("更新成功");
}
}

@ -7,7 +7,6 @@ import com.github.pagehelper.PageInfo;
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.ConstantType;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.entity.inv.InvProductEntity;
import com.glxp.api.req.inv.FilterInvProductDetailRequest;
@ -19,6 +18,7 @@ import com.glxp.api.res.inv.InvProductPageResponse;
import com.glxp.api.res.inv.InvProductResponse;
import com.glxp.api.service.auth.CustomerService;
import com.glxp.api.service.auth.WarehouseUserService;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
import com.glxp.api.service.inv.InvProductDetailService;
import com.glxp.api.service.inv.InvProductService;
import com.glxp.api.util.udi.FilterUdiUtils;
@ -48,6 +48,8 @@ public class InvProductController {
private WarehouseUserService warehouseUserService;
@Resource
private CustomerService customerService;
@Resource
private IBasicBussinessTypeService bussinessTypeService;
/**
*
@ -98,13 +100,8 @@ public class InvProductController {
invProductDetailEntities.forEach(invProductDetailEntity -> {
InvProductDetailResponse response = new InvProductDetailResponse();
BeanUtil.copyProperties(invProductDetailEntity, response);
if (invProductDetailEntity.getMainAction().equals(ConstantType.TYPE_OUT)) {
response.setMainActionStr("出库");
response.setOutCount(invProductDetailEntity.getCount());
} else {
response.setMainActionStr("入库");
response.setInCount(invProductDetailEntity.getCount());
}
//设置单据类型名称等单据相关参数
invProductDetailService.setOrderInfo(response);
list.add(response);
});
}

@ -74,7 +74,7 @@ public interface AuthAdminDao {
*/
List<AuthAdmin> selectHospitalUser();
List<AuthAdmin> selectNotSelectUser(@Param("userIds") List<Long> userIds);
List<AuthAdmin> selectNotSelectUser(@Param("userIds") List<Long> userIds,@Param("locDeptCode") String locDeptCode);
List<AuthAdmin> selectAllocatedList(FilterAuthUserRequest filterAuthUserRequest);

@ -1,9 +1,7 @@
package com.glxp.api.dao.auth;
import com.glxp.api.dao.BaseMapperPlus;
import com.glxp.api.dao.inout.IoOrderDetailCodeDao;
import com.glxp.api.entity.auth.InvWarehouseEntity;
import com.glxp.api.entity.inout.IoOrderDetailCodeEntity;
import com.glxp.api.req.auth.FilterInvSubWarehouseRequest;
import com.glxp.api.req.auth.FilterInvWarehouseRequest;
import com.glxp.api.res.auth.InvSubWarehouseResponse;
@ -81,4 +79,11 @@ public interface InvSubWarehouseDao extends BaseMapperPlus<InvSubWarehouseDao, I
boolean updateTime(@Param("code") String code, @Param("updateTime") Date updateTime);
/**
* ID
*
* @param userId
* @return
*/
List<InvWarehouseEntity> selectInvListByUser(@Param("userId") Long userId);
}

@ -0,0 +1,31 @@
package com.glxp.api.dao.basic;
import com.glxp.api.dao.BaseMapperPlus;
import com.glxp.api.entity.basic.DlEntrustReceEntity;
import com.glxp.api.entity.basic.EntrustReceEntity;
import com.glxp.api.req.basic.BasicEntrustRecRequest;
import com.glxp.api.res.basic.EntrustReceResponse;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface EntrustReceDao extends BaseMapperPlus<EntrustReceDao, EntrustReceEntity, EntrustReceEntity> {
List<EntrustReceEntity> filterEntrustRec(BasicEntrustRecRequest basicEntrustRecRequest);
List<DlEntrustReceEntity> downloadEntrustRec(BasicEntrustRecRequest basicEntrustRecRequest);
List<EntrustReceResponse> filterJoinEntrustRec(BasicEntrustRecRequest basicEntrustRecRequest);
EntrustReceEntity findByUnique(@Param("action") String action, @Param("entrustUser") Long entrustUser);
boolean insertEntrustRec(EntrustReceEntity ioOrderStatusEntity);
boolean deleteById(String id);
boolean deleteAll();
}

@ -24,4 +24,13 @@ public interface IoOrderDao extends BaseMapperPlus<IoOrderDao, IoOrderEntity, Io
* @return
*/
List<IoOrderEntity> filterOrderList(FilterOrderRequest filterOrderRequest);
/**
*
*
* @return
*/
List<IoOrderEntity> selectSupplementOrderList();
}

@ -0,0 +1,14 @@
package com.glxp.api.entity.basic;
import lombok.Data;
@Data
public class DlEntrustReceEntity {
private Integer id;
private String action;
private String name;
private String mainAction;
}

@ -0,0 +1,116 @@
package com.glxp.api.entity.basic;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import org.apache.xpath.operations.Bool;
import java.util.Date;
@Data
@TableName(value = "basic_entrust_accept")
public class EntrustReceEntity {
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
/**
*
*/
@TableField(value = "`action`")
private String action;
/**
*
*/
@TableField(value = "curDept")
private String curDept;
/**
*
*/
@TableField(value = "curInv")
private String curInv;
/**
*
*/
@TableField(value = "userId")
private Long userId;
/**
*
*/
@TableField(value = "entrustDept")
private String entrustDept;
/**
*
*/
@TableField(value = "entrustInv")
private String entrustInv;
/**
*
*/
@TableField(value = "entrustAction")
private String entrustAction;
/**
*
*/
@TableField(value = "entrustUser")
private Long entrustUser;
/**
*
*/
@TableField(value = "finishRece")
private Boolean finishRece;
/**
*
*/
@TableField(value = "updateTime")
private Date updateTime;
/**
*
*/
@TableField(value = "remark")
private String remark;
/**
*
*/
@TableField(value = "entrustEnd")
private Integer entrustEnd;
public static final String COL_ID = "id";
public static final String COL_ACTION = "action";
public static final String COL_CURDEPT = "curDept";
public static final String COL_CURINV = "curInv";
public static final String COL_USERID = "userId";
public static final String COL_ENTRUSTDEPT = "entrustDept";
public static final String COL_ENTRUSTINV = "entrustInv";
public static final String COL_ENTRUSTACTION = "entrustAction";
public static final String COL_ENTRUSTUSER = "entrustUser";
public static final String COL_FINISHRECE = "finishRece";
public static final String COL_UPDATETIME = "updateTime";
public static final String COL_REMARK = "remark";
public static final String COL_ENTRUSTEND = "entrustEnd";
}

@ -11,7 +11,7 @@ import java.math.BigDecimal;
@Data
@TableName(value = "io_order_detail_biz")
public class IoOrderDetailBizEntity {
@TableId(value = "id", type = IdType.INPUT)
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
/**

@ -11,7 +11,7 @@ import java.math.BigDecimal;
@Data
@TableName(value = "io_order_detail_code")
public class IoOrderDetailCodeEntity {
@TableId(value = "id", type = IdType.INPUT)
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
/**

@ -11,7 +11,7 @@ import java.math.BigDecimal;
@Data
@TableName(value = "io_order_detail_result")
public class IoOrderDetailResultEntity {
@TableId(value = "id", type = IdType.INPUT)
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
/**

@ -11,7 +11,7 @@ import java.util.Date;
@Data
@TableName(value = "inv_product_detail")
public class InvProductDetailEntity {
@TableId(value = "id", type = IdType.INPUT)
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
/**
@ -98,12 +98,6 @@ public class InvProductDetailEntity {
@TableField(value = "invSpaceCode")
private String invSpaceCode;
/**
*
*/
@TableField(value = "originCode")
private String originCode;
/**
*
*/

@ -14,6 +14,7 @@ public class FilterInvLinkDataRequest extends ListPageRequest {
private String userName;
private String employeeName;
private Long listUser[];
private String parentId;
}

@ -10,4 +10,5 @@ public class FilterNoSelectUserRequest extends ListPageRequest {
List<Long> userIds;
private String locDeptCode;
}

@ -0,0 +1,23 @@
package com.glxp.api.req.basic;
import com.glxp.api.util.page.ListPageRequest;
import lombok.Data;
import java.util.Date;
@Data
public class BasicEntrustRecRequest extends ListPageRequest {
private Integer id;
private String action;
private String entrustInv;
private Long entrustUser;
private String userId;
private Date updateTime;
private String curInv;
private String lastUpdateTime;
private String entrustSubInv;
private String invWarehouseCode;
private String name;
}

@ -0,0 +1,10 @@
package com.glxp.api.req.basic;
import lombok.Data;
@Data
public class BusNoUserRequest {
private String curAction;
}

@ -68,6 +68,11 @@ public class FilterBussinessTypeRequest extends ListPageRequest {
*/
private String locInvCode;
/**
*
*/
private String invCode;
/**
*
*/

@ -3,6 +3,8 @@ package com.glxp.api.req.inout;
import com.glxp.api.util.page.ListPageRequest;
import lombok.Data;
import java.util.List;
@Data
public class FilterOrderRequest extends ListPageRequest {
@ -113,4 +115,27 @@ public class FilterOrderRequest extends ListPageRequest {
*/
private String invCode;
private String igNoreBillNo;
/**
*
* 稿draft
* processedError
* unCheck
* checkedError
* checkSuccess
* audited
*/
private String statusType;
/**
*
*/
private List<Integer> statuses;
/**
*
*/
private List<Integer> dealStatuses;
}

@ -0,0 +1,13 @@
package com.glxp.api.req.inout;
import lombok.Data;
@Data
public class ReviewFinishRequest {
private String orderId;
private Integer exportStatus;
private Integer checkStatus;
private String stockOrderId;
private Integer entrustId;
private boolean entrust;
}

@ -61,11 +61,6 @@ public class FilterInvProductDetailRequest extends ListPageRequest {
*/
private String invSpaceCode;
/**
*
*/
private String originCode;
/**
*
*/

@ -18,7 +18,7 @@ public class WarehouseUserResponse {
/**
* id
*/
private String userid;
private Long userid;
/**
* /

@ -0,0 +1,62 @@
package com.glxp.api.res.basic;
import lombok.Data;
import java.util.Date;
@Data
public class EntrustReceResponse {
private Integer id;
private String action;
private String entrustInv;
private Long entrustUser;
private String userId;
private String entrustAction;
private Date updateTime;
private String remark;
private boolean finishRece;
private String curName;
private String entrustName;
/**
*
*/
private String employeeName;
/**
*
*/
private String entrustInvName;
/**
*
*/
private String curInv;
/**
*
*/
private String curInvName;
/**
*
*/
private String entrustSubInv;
/**
*
*/
private String invWarehouseCode;
/**
*
*/
private String invWarehouseName;
/**
*
*/
private String entrustSubInvName;
}

@ -0,0 +1,22 @@
package com.glxp.api.res.inout;
import com.glxp.api.entity.inout.IoOrderDetailBizEntity;
import lombok.Data;
import java.util.List;
@Data
public class AcceptOrderResponse {
private String billNo;
private String code;
private boolean isExitAccept;
private boolean finishAccept;
private List<IoOrderDetailBizEntity> orderDetailEntities;
}

@ -201,6 +201,10 @@ public class IoOrderResponse {
private String fromName;
//是否可以补单
private boolean enableSupplementOrder;
public String getFromName() {
if (StrUtil.isNotEmpty(fromCorpName))

@ -82,11 +82,6 @@ public class InvProductDetailResponse {
*/
private String invSpaceCode;
/**
*
*/
private String originCode;
/**
*
*/
@ -107,6 +102,11 @@ public class InvProductDetailResponse {
*/
private String action;
/**
*
*/
private String actionName;
/**
*
*/
@ -121,4 +121,9 @@ public class InvProductDetailResponse {
*
*/
private Integer outCount;
/**
*
*/
private String orderTime;
}

@ -7,4 +7,102 @@ import lombok.Data;
*/
@Data
public class InvProductResponse {
private Integer id;
/**
* DI
*/
private String nameCode;
/**
*
*/
private String cpmctymc;
/**
* ID
*/
private String relIdFk;
/**
*
*/
private String ggxh;
/**
*
*/
private String batchNo;
/**
*
*/
private String productionDate;
/**
*
*/
private String expireDate;
/**
*
*/
private String ylqxzcrbarmc;
/**
*
*/
private String zczbhhzbapzbh;
/**
*
*/
private Integer inCount;
/**
*
*/
private Integer outCount;
/**
*
*/
private Integer reCount;
/**
* ID
*/
private String customerId;
/**
*
*/
private String supName;
/**
* ID
*/
private String supId;
/**
*
*/
private String deptName;
/**
*
*/
private String invName;
/**
*
*/
private String deptCode;
/**
*
*/
private String invCode;
}

@ -72,4 +72,11 @@ public interface InvWarehouseService {
*/
List<InvSubWarehouseResponse> filterSubInvList(FilterInvWarehouseRequest filterInvWarehouseRequest);
/**
* ID
*
* @param userId
* @return
*/
List<InvWarehouseEntity> findInvListByUser(Long userId);
}

@ -140,7 +140,7 @@ public class AuthAdminServiceImpl implements AuthAdminService {
int offset = (filterNoSelectUserRequest.getPage() - 1) * filterNoSelectUserRequest.getLimit();
PageHelper.offsetPage(offset, filterNoSelectUserRequest.getLimit());
}
return authAdminDao.selectNotSelectUser(filterNoSelectUserRequest.getUserIds());
return authAdminDao.selectNotSelectUser(filterNoSelectUserRequest.getUserIds(),filterNoSelectUserRequest.getLocDeptCode());
}

@ -207,4 +207,9 @@ public class InvWarehouseServiceImpl implements InvWarehouseService {
public List<InvSubWarehouseResponse> filterSubInvList(FilterInvWarehouseRequest filterInvWarehouseRequest) {
return invSubWarehouseDao.filterSubInvList(filterInvWarehouseRequest);
}
@Override
public List<InvWarehouseEntity> findInvListByUser(Long userId) {
return invSubWarehouseDao.selectInvListByUser(userId);
}
}

@ -0,0 +1,32 @@
package com.glxp.api.service.basic;
import com.glxp.api.entity.basic.DlEntrustReceEntity;
import com.glxp.api.entity.basic.EntrustReceEntity;
import com.glxp.api.req.basic.BasicEntrustRecRequest;
import com.glxp.api.res.basic.EntrustReceResponse;
import java.util.List;
public interface EntrustReceService {
EntrustReceEntity findById(Integer id);
List<EntrustReceEntity> filterEntrustRec(BasicEntrustRecRequest basicEntrustRecRequest);
EntrustReceEntity findByUnique(String action, Long entrustUser);
List<DlEntrustReceEntity> downloadEntrustRec(BasicEntrustRecRequest basicEntrustRecRequest);
List<EntrustReceResponse> filterJoinEntrustRec(BasicEntrustRecRequest basicEntrustRecRequest);
int insertEntrustRec(EntrustReceEntity entrustReceEntity);
boolean replaceEntrustRec(EntrustReceEntity entrustReceEntity);
boolean deleteById(String id);
boolean deleteAll();
int updateEntrustRec(EntrustReceEntity warehouseEntity);
}

@ -108,4 +108,6 @@ public interface IBasicBussinessTypeService {
* @return
*/
boolean checkBusTypeNameExists(String name, Integer id);
List<BasicBussinessTypeEntity> selectIgnoreSelf(String action);
}

@ -22,6 +22,8 @@ public interface UdiRlSupService {
UdiRlSupEntity findByUdiRlIdUnitFk(String udiRlIdFk, String unitFk);
List<UdiRlSupEntity> findByUdiRlId(String udiRlIdFk);
UdiRlSupEntity findCompanyProductRelevanceByProductUuid(UdiRlSupEntity udiRlSupEntity);
List<UdiRlSupEntity> getCompanyProductRelevance(FilterCompanyProductRelevanceRequest filterCompanyProductRelevanceRequest);

@ -182,6 +182,12 @@ public class BasicBussinessTypeServiceImpl implements IBasicBussinessTypeService
return true;
}
@Override
public List<BasicBussinessTypeEntity> selectIgnoreSelf(String action) {
List<BasicBussinessTypeEntity> list = basicBussinessTypeDao.selectList(new QueryWrapper<BasicBussinessTypeEntity>().ne("action", action));
return list;
}
/**
* /
*

@ -0,0 +1,115 @@
package com.glxp.api.service.basic.impl;
import cn.hutool.core.collection.CollUtil;
import com.github.pagehelper.PageHelper;
import com.glxp.api.dao.auth.InvSubWarehouseDao;
import com.glxp.api.dao.basic.EntrustReceDao;
import com.glxp.api.entity.basic.DlEntrustReceEntity;
import com.glxp.api.entity.basic.EntrustReceEntity;
import com.glxp.api.req.basic.BasicEntrustRecRequest;
import com.glxp.api.res.basic.EntrustReceResponse;
import com.glxp.api.service.basic.EntrustReceService;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.List;
@Service
public class EntrustReceServiceImpl implements EntrustReceService {
@Resource
EntrustReceDao entrustReceDao;
@Resource
private InvSubWarehouseDao invSubWarehouseDao;
@Override
public EntrustReceEntity findById(Integer id) {
BasicEntrustRecRequest basicEntrustRecRequest = new BasicEntrustRecRequest();
basicEntrustRecRequest.setId(id);
List<EntrustReceEntity> entrustReceEntities = entrustReceDao.filterEntrustRec(basicEntrustRecRequest);
if (CollUtil.isNotEmpty(entrustReceEntities)) {
return entrustReceEntities.get(0);
}
return null;
}
@Override
public List<EntrustReceEntity> filterEntrustRec(BasicEntrustRecRequest basicEntrustRecRequest) {
if (basicEntrustRecRequest == null) {
return Collections.emptyList();
}
if (basicEntrustRecRequest.getPage() != null) {
int offset = (basicEntrustRecRequest.getPage() - 1) * basicEntrustRecRequest.getLimit();
PageHelper.offsetPage(offset, basicEntrustRecRequest.getLimit());
}
return entrustReceDao.filterEntrustRec(basicEntrustRecRequest);
}
@Override
public EntrustReceEntity findByUnique(String action, Long entrustUser) {
return entrustReceDao.findByUnique(action, entrustUser);
}
@Override
public List<DlEntrustReceEntity> downloadEntrustRec(BasicEntrustRecRequest basicEntrustRecRequest) {
if (basicEntrustRecRequest == null) {
return Collections.emptyList();
}
if (basicEntrustRecRequest.getPage() != null) {
int offset = (basicEntrustRecRequest.getPage() - 1) * basicEntrustRecRequest.getLimit();
PageHelper.offsetPage(offset, basicEntrustRecRequest.getLimit());
}
return entrustReceDao.downloadEntrustRec(basicEntrustRecRequest);
}
@Override
public List<EntrustReceResponse> filterJoinEntrustRec(BasicEntrustRecRequest basicEntrustRecRequest) {
if (basicEntrustRecRequest == null) {
return Collections.emptyList();
}
if (basicEntrustRecRequest.getPage() != null) {
int offset = (basicEntrustRecRequest.getPage() - 1) * basicEntrustRecRequest.getLimit();
PageHelper.offsetPage(offset, basicEntrustRecRequest.getLimit());
}
List<EntrustReceResponse> entrustReceResponses = entrustReceDao.filterJoinEntrustRec(basicEntrustRecRequest);
if (CollUtil.isNotEmpty(entrustReceResponses)) {
//查询当前分库名称和委托验收分库名称
entrustReceResponses.forEach(entrustReceResponse -> {
String invWarehouseName = invSubWarehouseDao.selectNameByCode(entrustReceResponse.getInvWarehouseCode());//查询当前分库名称
entrustReceResponse.setInvWarehouseName(invWarehouseName);
String entrustSubInvName = invSubWarehouseDao.selectNameByCode(entrustReceResponse.getEntrustSubInv());
entrustReceResponse.setEntrustSubInvName(entrustSubInvName);
});
}
return entrustReceResponses;
}
@Override
public int insertEntrustRec(EntrustReceEntity entrustReceEntity) {
return entrustReceDao.insert(entrustReceEntity);
}
@Override
public boolean replaceEntrustRec(EntrustReceEntity entrustReceEntity) {
return entrustReceDao.insertEntrustRec(entrustReceEntity);
}
@Override
public boolean deleteById(String id) {
return entrustReceDao.deleteById(id);
}
@Override
public boolean deleteAll() {
return entrustReceDao.deleteAll();
}
@Override
public int updateEntrustRec(EntrustReceEntity entrustReceEntity) {
return entrustReceDao.updateById(entrustReceEntity);
}
}

@ -83,6 +83,14 @@ public class UdiRlSupServiceImpl implements UdiRlSupService {
return null;
}
@Override
public List<UdiRlSupEntity> findByUdiRlId(String udiRlIdFk) {
FilterCompanyProductRelevanceRequest filterCompanyProductRelevanceRequest = new FilterCompanyProductRelevanceRequest();
filterCompanyProductRelevanceRequest.setUdiRlIdFk(udiRlIdFk);
List<UdiRlSupEntity> companyProductRelevanceEntities = udiRlSupDao.filterCompanyProductRelevance(filterCompanyProductRelevanceRequest);
return companyProductRelevanceEntities;
}
@Override
public UdiRlSupEntity findCompanyProductRelevanceByProductUuid(UdiRlSupEntity udiRlSupEntity) {
return udiRlSupDao.findCompanyProductRelevanceByProductUuid(udiRlSupEntity);

@ -1,30 +1,47 @@
package com.glxp.api.service.inout;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
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.Constant;
import com.glxp.api.constant.ConstantStatus;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.basic.BasicCorpEntity;
import com.glxp.api.entity.basic.UdiEntity;
import com.glxp.api.entity.basic.UdiRlSupEntity;
import com.glxp.api.entity.inout.IoCodeEntity;
import com.glxp.api.entity.inout.IoCodeTempEntity;
import com.glxp.api.entity.inout.IoOrderDetailCodeEntity;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.entity.system.SystemParamConfigEntity;
import com.glxp.api.req.basic.CompanyProductRelevanceRequest;
import com.glxp.api.req.basic.FilterCompanyProductRelevanceRequest;
import com.glxp.api.req.inout.FilterOrderRequest;
import com.glxp.api.req.inout.PdaCodeEntity;
import com.glxp.api.req.inout.PostOrderRequest;
import com.glxp.api.res.basic.UdiRelevanceResponse;
import com.glxp.api.service.basic.BasicCorpService;
import com.glxp.api.service.basic.UdiRelevanceService;
import com.glxp.api.service.basic.UdiRlSupService;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
import com.glxp.api.service.inv.InvProductDetailService;
import com.glxp.api.service.inv.InvProductService;
import com.glxp.api.service.system.SystemParamConfigService;
import com.glxp.api.util.CustomUtil;
import com.glxp.api.util.DateUtil;
import com.glxp.api.util.GennerOrderUtils;
import com.glxp.api.util.OrderNoTypeBean;
import com.glxp.api.util.udi.FilterUdiUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
@Service
@ -39,11 +56,266 @@ public class IoAddInoutService {
@Resource
IoCodeService codeService;
@Resource
IoCodeTempService codeTempService;
@Resource
UdiRlSupService udiRlSupService;
@Resource
IoOrderDetailCodeService orderDetailCodeService;
@Resource
UdiRelevanceService udiRelevanceService;
@Resource
InvProductDetailService invProductDetailService;
@Resource
BasicCorpService basicCorpService;
@Resource
IoCheckInoutService ioCheckInoutService;
@Resource
SystemParamConfigService systemParamConfigService;
//新增单据处理
public void dealProcess(IoOrderEntity orderEntity) {
orderEntity.setRemark("正在处理!");
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_PROCESSING);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
List<IoOrderEntity> orderEntities = orderService.isExitRepeat(orderEntity.getCorpOrderId(), orderEntity.getBillNo());
if (CollUtil.isNotEmpty(orderEntities)) {
orderEntity.setRemark("单据重复上传");
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
return;
}
BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
if (bussinessTypeEntity == null) {
orderEntity.setRemark("单据类型不存在");
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
return;
}
if (StrUtil.isEmpty(orderEntity.getFromCorp()) && StrUtil.isEmpty(orderEntity.getFromInvCode())) {
orderEntity.setRemark("未选择往来单位");
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
return;
} else if (StrUtil.isNotEmpty(orderEntity.getFromCorp())) {
if (bussinessTypeEntity.getCorpType() == ConstantStatus.CORP_TYPE_INPUT && bussinessTypeEntity.isGenUnit()) {
BasicCorpEntity 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(orderEntity.getFromCorp());
}
orderEntity.setFromCorp(basicCorpEntity.getErpId());
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
basicCorpService.insertBasicUnitMaintain(basicCorpEntity);
}
}
if (StrUtil.isEmpty(orderEntity.getInvCode())) {
orderEntity.setRemark("未选择当前仓库信息");
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
return;
}
List<IoCodeTempEntity> filterList = codeTempService.findByOrderId(orderEntity.getBillNo());
List<IoCodeTempEntity> insertList = new ArrayList<>();
for (int j = 0; j < filterList.size(); j++) {
IoCodeTempEntity warehouseEntity = filterList.get(j);
String result = checkOrderRepeatCode(warehouseEntity, filterList);
if (result == null) {
insertList.add(warehouseEntity);
} else {
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
insertList.clear();
return;
}
//三期校验
String checkOriginMsg = checkOriginCode(warehouseEntity);
if (StrUtil.isNotEmpty(checkOriginMsg)) {
orderEntity.setRemark("checkOriginMsg");
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);
insertList.clear();
return;
}
//产品是否已维护已关联
if ((warehouseEntity.getRelId() == null)) {
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderEntity.setRemark("udi码" + warehouseEntity.getCode() + "上传时对照数据丢失,请选择对!");
orderService.update(orderEntity);
return;
}
//产品是否指定供应商
if (StrUtil.isEmpty(warehouseEntity.getSupId())) {
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderEntity.setRemark("udi码" + warehouseEntity.getCode() + "未指定供应商!");
orderService.update(orderEntity);
return;
}
//校验是否是当前供应商
if (bussinessTypeEntity.getCorpType() == ConstantStatus.CORP_TYPE_OUT) {
UdiRlSupEntity udiRlSupEntity = udiRlSupService.findByUdiRlIdUnitFk(warehouseEntity.getRelId() + "", orderEntity.getFromCorp());
if (udiRlSupEntity == null) {
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderEntity.setRemark("udi码" + warehouseEntity.getCode() + "当前供应商不存在此配送产品");
orderService.update(orderEntity);
return;
}
}
//产品是否可以以使用单元入库
UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectGroupById(warehouseEntity.getRelId());
if (udiRelevanceResponse == null) {
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderEntity.setRemark("udi码" + warehouseEntity.getCode() + "该产品信息未维护");
orderService.update(orderEntity);
return;
} else if (!udiRelevanceResponse.getUseDy() && udiRelevanceResponse.getDiType() == ConstantStatus.DITYPE_SYDY) {
orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
orderEntity.setUpdateTime(new Date());
orderEntity.setRemark("udi码" + warehouseEntity.getCode() + "该产品不允许以使用单元入库");
orderService.update(orderEntity);
return;
}
}
if (CollUtil.isNotEmpty(insertList)) {
//临时表转正式表
List<IoCodeEntity> ioCodeEntities = new ArrayList<>();
for (IoCodeTempEntity codeTempEntity : insertList) {
IoCodeEntity codeEntity = new IoCodeEntity();
BeanUtils.copyProperties(codeTempEntity, codeEntity);
ioCodeEntities.add(codeEntity);
}
codeService.insertBatch(ioCodeEntities);
//生成扫码单据详情
if (!orderDetailCodeService.isExit(orderEntity.getBillNo())) {
for (IoCodeTempEntity codeTempEntity : insertList) {
genOrderDetailCode(orderEntity, codeTempEntity);
}
}
codeTempService.deleteByBillNo(orderEntity.getBillNo());
//进行单据校验
ioCheckInoutService.check(orderEntity.getBillNo());
}
}
//生成扫码单据详情
public void genOrderDetailCode(IoOrderEntity orderEntity, IoCodeTempEntity codeTempEntity) {
List<IoOrderDetailCodeEntity> ioOrderDetailCodeEntities = orderDetailCodeService.findByOrderId(orderEntity.getBillNo());
UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectGroupById(codeTempEntity.getRelId());
if (CollUtil.isEmpty(ioOrderDetailCodeEntities)) {
orderDetailCodeService.insert(buildEntity(orderEntity, codeTempEntity, udiRelevanceResponse));
} else {
ioOrderDetailCodeEntities.forEach(orderDetailCodeEntity ->
{
if (orderDetailCodeEntity.getBindRlFk().longValue() == udiRelevanceResponse.getId().longValue() && orderDetailCodeEntity.getBatchNo().equals(codeTempEntity.getBatchNo())) {
orderDetailCodeEntity.setCount(orderDetailCodeEntity.getCount() + codeTempEntity.getCount());
orderDetailCodeEntity.setReCount(orderDetailCodeEntity.getReCount() + codeTempEntity.getReCount());
orderDetailCodeService.update(orderDetailCodeEntity);
} else {
orderDetailCodeService.insert(buildEntity(orderEntity, codeTempEntity, udiRelevanceResponse));
}
});
}
}
//平衡补单
public BaseResponse supplementOrder(String orderId) {
IoOrderEntity order = orderService.findByBillNo(orderId);
BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(order.getAction());
if (StrUtil.isBlank(bussinessTypeEntity.getSupplementOrderType())) {
return ResultVOUtils.error(ResultEnum.valueOf("此类型单据不可补单"));
}
IoOrderEntity supplementOrder = new IoOrderEntity();
BeanUtil.copyProperties(order, supplementOrder);
//生成补单单号,互填单号
String supplementOrderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(bussinessTypeEntity.getPrefix()), "yyyyMMdd"));
supplementOrder.setSupplementNo(orderId);
order.setSupplementNo(supplementOrderNo);
supplementOrder.setBillNo(supplementOrderNo);
supplementOrder.setCorpOrderId(CustomUtil.getId() + "x");
//修改状态
SystemParamConfigEntity systemParamConfigEntity = systemParamConfigService.selectByParamKey("additional_auto_submit");
if ("1".equals(systemParamConfigEntity.getParamValue())) {
supplementOrder.setStatus(ConstantStatus.ORDER_STATUS_PROCESS); //设置状态为补录单据
} else {
supplementOrder.setStatus(ConstantStatus.ORDER_STATUS_ADDITIONAL); //设置状态为补录单据
}
//交换往来信息
supplementOrder.setFromDeptCode(order.getDeptCode());
supplementOrder.setFromInvCode(order.getInvCode());
supplementOrder.setInvCode(order.getFromInvCode());
supplementOrder.setDeptCode(order.getFromDeptCode());
supplementOrder.setFromType(ConstantStatus.FROM_PEACE_CHANGE);
//设置往来信息
BasicBussinessTypeEntity supplementType = basicBussinessTypeService.findByAction(bussinessTypeEntity.getSupplementOrderType());
supplementOrder.setMainAction(supplementType.getMainAction());
supplementOrder.setAction(supplementType.getAction());
//复制码表
List<IoCodeEntity> codes = codeService.findByOrderId(orderId);
List<IoCodeTempEntity> supplementCodes = new ArrayList<>();
codes.forEach(
code -> {
IoCodeTempEntity supplementCode = new IoCodeTempEntity();
BeanUtil.copyProperties(code, supplementCode);
supplementCode.setId(null);
supplementCode.setInvCode(order.getFromInvCode());
supplementCode.setDeptCode(order.getFromDeptCode());
supplementCode.setOrderId(supplementOrderNo);
supplementCode.setAction(supplementType.getAction());
supplementCode.setMainAction(supplementType.getMainAction());
supplementCodes.add(supplementCode);
}
);
//更新数据
orderService.insertOrder(supplementOrder);
orderService.update(order);
codeTempService.insertBatch(supplementCodes);
dealProcess(supplementOrder);
return ResultVOUtils.success();
}
//手持终端上传生成扫码单据
public void creatOrderByPda(PostOrderRequest postOrderRequest) {
@ -196,28 +468,62 @@ public class IoAddInoutService {
return null;
}
//查询本单是否有重复条码
public String checkOrderRepeatCode(IoCodeTempEntity codeEntity, List<IoCodeTempEntity> filterList) {
int count = 0;
if (filterList != null) {
for (IoCodeTempEntity temp : filterList) {
if (temp.getCode().equals(codeEntity.getCode())) {
count = count + 1;
}
}
}
if (count > 1) {
return codeEntity.getCode() + "条码重复";
} else
return null;
}
//生成扫码单据详情
public void genOrderDetailCode(IoOrderEntity orderEntity, IoCodeTempEntity codeTempEntity) {
List<IoOrderDetailCodeEntity> ioOrderDetailCodeEntities = orderDetailCodeService.findByOrderId(orderEntity.getBillNo());
UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectGroupById(codeTempEntity.getRelId());
if (CollUtil.isEmpty(ioOrderDetailCodeEntities)) {
orderDetailCodeService.insert(buildEntity(orderEntity, codeTempEntity, udiRelevanceResponse));
} else {
ioOrderDetailCodeEntities.forEach(orderDetailCodeEntity ->
{
if (orderDetailCodeEntity.getBindRlFk().longValue() == udiRelevanceResponse.getId().longValue() && orderDetailCodeEntity.getBatchNo().equals(codeTempEntity.getBatchNo())) {
orderDetailCodeEntity.setCount(orderDetailCodeEntity.getCount() + codeTempEntity.getCount());
orderDetailCodeEntity.setReCount(orderDetailCodeEntity.getReCount() + codeTempEntity.getReCount());
orderDetailCodeService.update(orderDetailCodeEntity);
} else {
orderDetailCodeService.insert(buildEntity(orderEntity, codeTempEntity, udiRelevanceResponse));
}
});
public String checkOriginCode(IoCodeTempEntity warehouseEntity) {
UdiEntity udiEntity = FilterUdiUtils.getUdi(warehouseEntity.getCode());
//校验条码的完整性
String errMsg = "";
UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByNameCode(udiEntity.getUdi());
if (udiRelevanceResponse == null) {
return "耗材字典不存在此产品";
}
InvProductDetailEntity invProductDetailEntity = invProductDetailService.sortFindByCode(warehouseEntity.getCode());
if (invProductDetailEntity != null) {
if (StrUtil.isEmpty(warehouseEntity.getBatchNo())) {
warehouseEntity.setBatchNo(invProductDetailEntity.getBatchNo());
}
if (StrUtil.isEmpty(warehouseEntity.getProduceDate())) {
warehouseEntity.setProduceDate(invProductDetailEntity.getProduceDate());
}
if (StrUtil.isEmpty(warehouseEntity.getExpireDate())) {
warehouseEntity.setExpireDate(invProductDetailEntity.getExpireDate());
}
}
if (StrUtil.isEmpty(warehouseEntity.getBatchNo()) && !udiRelevanceResponse.getAllowNoBatch()) {
errMsg = errMsg + ",批次号";
}
if (StrUtil.isEmpty(warehouseEntity.getProduceDate()) && !udiRelevanceResponse.getAllowNoProduct()) {
errMsg = errMsg + ",生产日期";
}
if (StrUtil.isEmpty(warehouseEntity.getExpireDate()) && !udiRelevanceResponse.getAllowNoExpire()) {
errMsg = errMsg + ",失效日期";
}
if (StrUtil.isNotEmpty(errMsg)) {
return "UDI码" + warehouseEntity.getCode() + "产品三期缺失请补齐" + errMsg.substring(1) + "";
}
return null;
}
IoOrderDetailCodeEntity buildEntity(IoOrderEntity orderEntity, IoCodeTempEntity codeTempEntity, UdiRelevanceResponse udiRelevanceResponse) {
IoOrderDetailCodeEntity ioOrderDetailCodeEntity = new IoOrderDetailCodeEntity();
ioOrderDetailCodeEntity.setOrderIdFk(orderEntity.getBillNo());
@ -240,4 +546,5 @@ public class IoAddInoutService {
return ioOrderDetailCodeEntity;
}
}

@ -137,12 +137,14 @@ public class IoCheckInoutService {
//生成业务单据
IoOrderDetailBizEntity orderDetailBizEntity = new IoOrderDetailBizEntity();
BeanUtils.copyProperties(orderDetailCodeEntity, orderDetailBizEntity);
orderDetailBizEntity.setId(null);
orderDetailBizService.insert(orderDetailBizEntity);
//生成单据结果
IoOrderDetailResultEntity orderDetailResultEntity = new IoOrderDetailResultEntity();
BeanUtils.copyProperties(orderDetailCodeEntity, orderDetailResultEntity);
orderDetailResultEntity.setId(null);
orderDetailResultService.insert(orderDetailResultEntity);
});
@ -152,6 +154,7 @@ public class IoCheckInoutService {
for (IoCodeTempEntity codeTempEntity : codeTempEntities) {
IoCodeEntity codeEnttity = new IoCodeEntity();
BeanUtils.copyProperties(codeTempEntity, codeEnttity);
codeEnttity.setId(null);
codeService.insert(codeEnttity);
}
codeTempService.deleteByBillNo(orderEntity.getBillNo());
@ -168,7 +171,7 @@ public class IoCheckInoutService {
List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(orderEntity.getBillNo());
if (CollUtil.isEmpty(orderDetailCodeEntities)) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_FAIL);
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK);
orderEntity.setUpdateTime(new Date());
orderEntity.setErrMsg("校验失败,扫码详情为空!");
orderService.update(orderEntity);
@ -176,12 +179,13 @@ public class IoCheckInoutService {
}
if (CollUtil.isEmpty(orderDetailBizEntities)) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_FAIL);
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK);
orderEntity.setUpdateTime(new Date());
orderEntity.setErrMsg("校验失败,业务详情为空!");
orderService.update(orderEntity);
return;
}
String errMsg = "";
//正向校验
for (IoOrderDetailBizEntity bizEntity : orderDetailBizEntities) {
@ -242,6 +246,7 @@ public class IoCheckInoutService {
for (IoOrderDetailBizEntity orderDetailBizEntity : orderDetailBizEntities) {
IoOrderDetailResultEntity orderDetailResultEntity = new IoOrderDetailResultEntity();
BeanUtils.copyProperties(orderDetailBizEntity, orderDetailResultEntity);
orderDetailResultEntity.setId(null);
orderDetailResultEntity.setReCount(orderDetailBizEntity.getScanCount());
orderDetailResultService.insert(orderDetailResultEntity);
}
@ -329,43 +334,46 @@ public class IoCheckInoutService {
//二次校验
public void checkSecond(IoOrderEntity orderEntity) {
BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
if (bussinessTypeEntity.isSecCheckEnable()) {
if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_UDIMS) {
if (!bussinessTypeEntity.isSecCheckUdims()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_WEBNEW) {
if (!bussinessTypeEntity.isSecCheckWebNew()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PDAED) {
if (!bussinessTypeEntity.isSecCheckPdaEd()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PDAUN) {
if (!bussinessTypeEntity.isSecCheckPdaUn()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PC) {
if (!bussinessTypeEntity.isSecCheckPc()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_CHANGE) {
if (!bussinessTypeEntity.isSecCheckChange()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PEACE_CHANGE) {
if (!bussinessTypeEntity.isSecCheckBalance()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_COPY) {
if (!bussinessTypeEntity.isSecCheckCopy()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
if (orderEntity.getStatus() != ConstantStatus.ORDER_STATUS_AUDITED) {
if (bussinessTypeEntity.isSecCheckEnable()) {
if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_UDIMS) {
if (!bussinessTypeEntity.isSecCheckUdims()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_WEBNEW) {
if (!bussinessTypeEntity.isSecCheckWebNew()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PDAED) {
if (!bussinessTypeEntity.isSecCheckPdaEd()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PDAUN) {
if (!bussinessTypeEntity.isSecCheckPdaUn()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PC) {
if (!bussinessTypeEntity.isSecCheckPc()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_CHANGE) {
if (!bussinessTypeEntity.isSecCheckChange()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_PEACE_CHANGE) {
if (!bussinessTypeEntity.isSecCheckBalance()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else if (orderEntity.getFromType().intValue() == ConstantStatus.FROM_COPY) {
if (!bussinessTypeEntity.isSecCheckCopy()) {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
}
} else {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
} else {
orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
}
if (orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_AUDITED) {
orderEntity.setUpdateTime(new Date());
orderService.update(orderEntity);

@ -140,6 +140,7 @@ public class IoGenInvService {
{
InvPreinDetailEntity invPreinDetailEntity = new InvPreinDetailEntity();
BeanUtils.copyProperties(codeEntity, invPreinDetailEntity);
invPreinDetailEntity.setId(null);
invPreinDetailEntities.add(invPreinDetailEntity);
});
@ -235,9 +236,13 @@ public class IoGenInvService {
if (targetBustypeEntity.getCorpType() == ConstantStatus.CORP_TYPE_OUT) {
outOrder.setCustomerId(corpName);
outOrder.setFromCorp(corpName);
outOrder.setFromInvCode(null);
outOrder.setFromDeptCode(null);
} else {
outOrder.setCustomerId(Constant.SYSTEM_CUSTOMER_ID);
outOrder.setFromInvCode(bussinessChangeTypeEntity.getDefaultInvCode());
outOrder.setFromDeptCode(bussinessChangeTypeEntity.getDefaultDeptCode());
outOrder.setFromCorp(null);
}
outOrder.setCorpOrderId(CustomUtil.getId() + "x");
InvWarehouseEntity invWarehouseEntity = invWarehouseService.findByInvSubByCode(bussinessChangeTypeEntity.getInvCode());
@ -262,16 +267,20 @@ public class IoGenInvService {
for (IoCodeEntity warehouseEntity : temps) {
IoCodeTempEntity codeTempEntity = new IoCodeTempEntity();
BeanUtils.copyProperties(warehouseEntity, codeTempEntity);
codeTempEntity.setOrderId(outOrder.getBillNo());
codeTempEntity.setId(null);
codeTempEntity.setOrderId(outOrder.getBillNo());
codeTempEntity.setAction(outOrder.getAction());
codeTempEntity.setMainAction(outOrder.getMainAction());
codeTempEntities.add(codeTempEntity);
}
codeTempService.insertBatch(codeTempEntities);
addInoutService.dealProcess(outOrder);
}
}
@Resource
IoAddInoutService addInoutService;
//计算当前库存数量
public int getInvCount(IoCodeEntity codeEntity) {

@ -37,4 +37,6 @@ public interface IoOrderDetailCodeService {
int deleteByOrderId(String orderId);
public List<IoOrderDetailCodeEntity> checkOrderList(String orderId);
boolean isExit(String orderId);
}

@ -11,6 +11,10 @@ public interface IoOrderService {
List<IoOrderEntity> selectAll();
List<IoOrderEntity> findAll(FilterOrderRequest filterOrderRequest);
List<IoOrderEntity> isExitRepeat(String corpOrderId, String billNo);
IoOrderEntity findById(String orderId);
IoOrderEntity findByBillNo(String billNO);
@ -42,4 +46,19 @@ public interface IoOrderService {
* @return
*/
List<IoOrderEntity> filterOrderList(FilterOrderRequest filterOrderRequest);
List<IoOrderEntity> selectSupplementOrderList();
/**
*
*/
List<IoOrderResponse> checkSupplementOrder(List<IoOrderEntity> orderEntities);
/**
*
*
* @param filterOrderRequest
*/
void setFilterStatus(FilterOrderRequest filterOrderRequest);
}

@ -25,6 +25,7 @@ public class IoCodeServiceImpl implements IoCodeService {
@Override
public int insert(IoCodeEntity codeEnttity) {
codeEnttity.setId(null);
return ioCodeDao.insert(codeEnttity);
}

@ -28,6 +28,7 @@ public class IoCodeTempServiceImpl implements IoCodeTempService {
@Override
public int insert(IoCodeTempEntity codeEnttity) {
codeEnttity.setId(null);
return ioCodeTempDao.insert(codeEnttity);
}

@ -29,6 +29,7 @@ public class IoOrderDetailBizServiceImpl implements IoOrderDetailBizService {
@Override
public int insert(IoOrderDetailBizEntity orderDetailBizEntity) {
orderDetailBizEntity.setId(null);
return ioOrderDetailBizDao.insert(orderDetailBizEntity);
}

@ -25,6 +25,10 @@ public class IoOrderDetailCodeServiceImpl implements IoOrderDetailCodeService {
@Resource
IoOrderDetailCodeDao ioOrderDetailCodeDao;
@Resource
IoOrderDetailBizService orderDetailBizService;
@Resource
IoCheckInoutService checkInoutService;
@Override
public List<IoOrderDetailCodeEntity> findByOrderId(String orderId) {
@ -38,6 +42,7 @@ public class IoOrderDetailCodeServiceImpl implements IoOrderDetailCodeService {
@Override
public int insert(IoOrderDetailCodeEntity orderDetailCodeEntity) {
orderDetailCodeEntity.setId(null);
return ioOrderDetailCodeDao.insert(orderDetailCodeEntity);
}
@ -68,11 +73,6 @@ public class IoOrderDetailCodeServiceImpl implements IoOrderDetailCodeService {
}
@Resource
IoOrderDetailBizService orderDetailBizService;
@Resource
IoCheckInoutService checkInoutService;
@Override
public List<IoOrderDetailCodeEntity> checkOrderList(String orderId) {
@ -81,4 +81,9 @@ public class IoOrderDetailCodeServiceImpl implements IoOrderDetailCodeService {
checkInoutService.codeOrderCheck(orderDetailCodeEntities, orderDetailBizEntities);
return orderDetailCodeEntities;
}
@Override
public boolean isExit(String orderId) {
return ioOrderDetailCodeDao.exists(new QueryWrapper<IoOrderDetailCodeEntity>().eq("orderIdFk", orderId));
}
}

@ -26,6 +26,7 @@ public class IoOrderDetailResultServiceImpl implements IoOrderDetailResultServic
@Override
public int insert(IoOrderDetailResultEntity orderDetailResultEntity) {
orderDetailResultEntity.setId(null);
return orderDetailResultDao.insert(orderDetailResultEntity);
}

@ -1,8 +1,15 @@
package com.glxp.api.service.inout.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.pagehelper.PageHelper;
import com.glxp.api.constant.Constant;
import com.glxp.api.constant.ConstantStatus;
import com.glxp.api.dao.basic.BasicBussinessTypeDao;
import com.glxp.api.dao.inout.IoOrderDao;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.req.inout.FilterOrderRequest;
import com.glxp.api.res.inout.IoOrderResponse;
@ -10,6 +17,8 @@ import com.glxp.api.service.inout.IoOrderService;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
@ -18,12 +27,38 @@ public class IoOrderServiceImpl implements IoOrderService {
@Resource
private IoOrderDao orderDao;
@Resource
BasicBussinessTypeDao basicBussinessTypeDao;
@Override
public List<IoOrderEntity> selectAll() {
return orderDao.selectList();
}
@Override
public List<IoOrderEntity> findAll(FilterOrderRequest filterOrderRequest) {
QueryWrapper<IoOrderEntity> queryWrapper = new QueryWrapper<IoOrderEntity>()
.eq(StrUtil.isNotEmpty(filterOrderRequest.getCustomerId()), "customerId", filterOrderRequest.getCustomerId())
.eq(StrUtil.isNotBlank(filterOrderRequest.getCorpOrderId()), "corpOrderId", filterOrderRequest.getCorpOrderId())
.eq(StrUtil.isNotBlank(filterOrderRequest.getBillNo()), "billNo", filterOrderRequest.getBillNo())
.ne(StrUtil.isNotEmpty(filterOrderRequest.getIgNoreBillNo()), "billNo", filterOrderRequest.getIgNoreBillNo());
return orderDao.selectList(queryWrapper);
}
@Override
public List<IoOrderEntity> isExitRepeat(String corpOrderId, String billNo) {
List<Integer> filterStatus = new ArrayList<>();
filterStatus.add(ConstantStatus.ORDER_DEAL_POST);
filterStatus.add(ConstantStatus.ORDER_DEAL_CHECK);
return orderDao.selectList(new QueryWrapper<IoOrderEntity>()
.eq("corpOrderId", corpOrderId)
.ne("billNo", billNo)
.in("dealStatus", filterStatus)
);
}
@Override
public IoOrderEntity findById(String orderId) {
return orderDao.selectById(orderId);
@ -36,6 +71,7 @@ public class IoOrderServiceImpl implements IoOrderService {
@Override
public int insertOrder(IoOrderEntity orderEntity) {
orderEntity.setId(null);
return orderDao.insert(orderEntity);
}
@ -92,4 +128,71 @@ public class IoOrderServiceImpl implements IoOrderService {
return orderDao.filterOrderList(filterOrderRequest);
}
@Override
public List<IoOrderEntity> selectSupplementOrderList() {
return orderDao.selectSupplementOrderList();
}
@Override
public List<IoOrderResponse> checkSupplementOrder(List<IoOrderEntity> orderEntities) {
if (CollUtil.isEmpty(orderEntities)) {
return Collections.emptyList();
}
List<IoOrderResponse> result = new ArrayList<>();
orderEntities.forEach(orderEntity -> {
IoOrderResponse response = new IoOrderResponse();
BeanUtil.copyProperties(orderEntity, response);
if (orderEntity.getStatus().equals(ConstantStatus.ORDER_STATUS_AUDITED) && checkBusTypeSupplementOrder(orderEntity)
&& StrUtil.isEmpty(orderEntity.getSupplementNo())) {
response.setEnableSupplementOrder(true);
}
result.add(response);
});
return result;
}
@Override
public void setFilterStatus(FilterOrderRequest filterOrderRequest) {
switch (filterOrderRequest.getStatusType()) {
case Constant.ORDER_STATUS_DRAFT:
filterOrderRequest.setStatuses(Arrays.asList(1, 2));
filterOrderRequest.setDealStatuses(Arrays.asList(1));
break;
case Constant.ORDER_STATUS_PROCESSED_ERROR:
filterOrderRequest.setStatuses(Arrays.asList(4));
filterOrderRequest.setDealStatuses(Arrays.asList(2));
break;
case Constant.ORDER_STATUS_NEW_ORDER:
filterOrderRequest.setStatuses(Arrays.asList(1, 2, 4));
filterOrderRequest.setDealStatuses(Arrays.asList(1, 2));
break;
case Constant.ORDER_STATUS_UN_CHECK:
filterOrderRequest.setStatuses(Arrays.asList(3));
filterOrderRequest.setDealStatuses(Arrays.asList(2));
break;
case Constant.ORDER_STATUS_CHECKED_ERROR:
filterOrderRequest.setStatuses(Arrays.asList(6));
filterOrderRequest.setDealStatuses(Arrays.asList(2));
break;
case Constant.ORDER_STATUS_CHECK_SUCCESS:
filterOrderRequest.setStatuses(Arrays.asList(5, 8));
filterOrderRequest.setDealStatuses(Arrays.asList(2));
break;
case Constant.ORDER_STATUS_AUDITED:
filterOrderRequest.setStatuses(Arrays.asList(7));
filterOrderRequest.setDealStatuses(Arrays.asList(3));
break;
default:
break;
}
}
boolean checkBusTypeSupplementOrder(IoOrderEntity orderEntity) {
BasicBussinessTypeEntity supplementOrderType = basicBussinessTypeDao.selectOne(new QueryWrapper<BasicBussinessTypeEntity>().eq("action", orderEntity.getAction()));
if (supplementOrderType != null) {
return true;
}
return false;
}
}

@ -2,6 +2,7 @@ package com.glxp.api.service.inv;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.req.inv.FilterInvProductDetailRequest;
import com.glxp.api.res.inv.InvProductDetailResponse;
import java.util.List;
@ -11,6 +12,8 @@ public interface InvProductDetailService {
List<InvProductDetailEntity> selectByUnique(Long relId, String batchNo, String supId, String deptCode, String invCode);
InvProductDetailEntity sortFindByCode(String code);
boolean insertList(List<InvProductDetailEntity> invProductDetailEntities);
/**
@ -22,4 +25,11 @@ public interface InvProductDetailService {
List<InvProductDetailEntity> filterInvProductDetailList(FilterInvProductDetailRequest filterInvProductDetailRequest);
boolean deleteInvProductDetail(FilterInvProductDetailRequest detailRequest);
/**
*
*
* @param response
*/
void setOrderInfo(InvProductDetailResponse response);
}

@ -17,6 +17,7 @@ public class InvPreinOrderServiceImpl implements InvPreinOrderService {
@Override
public void insert(InvPreinOrderEntity invPreinOrderEntity) {
invPreinOrderEntity.setId(null);
invPreinOrderDao.insert(invPreinOrderEntity);
}

@ -1,11 +1,19 @@
package com.glxp.api.service.inv.impl;
import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.pagehelper.PageHelper;
import com.glxp.api.constant.ConstantType;
import com.glxp.api.dao.basic.BasicBussinessTypeDao;
import com.glxp.api.dao.inout.IoOrderDao;
import com.glxp.api.dao.inv.InvProductDetailDao;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.req.inv.FilterInvProductDetailRequest;
import com.glxp.api.res.inv.InvProductDetailResponse;
import com.glxp.api.service.inv.InvProductDetailService;
import com.glxp.api.util.DateUtil;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@ -18,10 +26,16 @@ import java.util.List;
public class InvProductDetailServiceImpl implements InvProductDetailService {
@Resource
InvProductDetailDao invProductDetailDao;
private InvProductDetailDao invProductDetailDao;
@Resource
private BasicBussinessTypeDao bussinessTypeDao;
@Resource
private IoOrderDao orderDao;
@Override
public int insert(InvProductDetailEntity invProductDetailEntity) {
invProductDetailEntity.setId(null);
return invProductDetailDao.insert(invProductDetailEntity);
}
@ -30,6 +44,15 @@ public class InvProductDetailServiceImpl implements InvProductDetailService {
return invProductDetailDao.selectList(new QueryWrapper<InvProductDetailEntity>().eq("relId", relId).eq("batchNo", batchNo).eq("supId", supId).eq("deptCode", deptCode).eq("invCode", invCode));
}
@Override
public InvProductDetailEntity sortFindByCode(String code) {
List<InvProductDetailEntity> invProductDetailEntities = invProductDetailDao.selectList(new QueryWrapper<InvProductDetailEntity>().eq("code", code).orderByDesc("id"));
if (CollUtil.isNotEmpty(invProductDetailEntities))
return invProductDetailEntities.get(0);
else
return null;
}
@Override
public boolean insertList(List<InvProductDetailEntity> invProductDetailEntities) {
return invProductDetailDao.insertBatch(invProductDetailEntities);
@ -50,4 +73,22 @@ public class InvProductDetailServiceImpl implements InvProductDetailService {
public boolean deleteInvProductDetail(FilterInvProductDetailRequest detailRequest) {
return invProductDetailDao.deleteInvProductDetail(detailRequest);
}
@Override
public void setOrderInfo(InvProductDetailResponse response) {
//设置出入库中文及出入库数量
if (response.getMainAction().equals(ConstantType.TYPE_OUT)) {
response.setMainActionStr("出库");
response.setOutCount(response.getCount());
} else {
response.setMainActionStr("入库");
response.setInCount(response.getCount());
}
//设置单据类型名称
BasicBussinessTypeEntity busType = bussinessTypeDao.selectOne(new QueryWrapper<BasicBussinessTypeEntity>().select("name").eq("action", response.getAction()));
response.setActionName(busType.getName());
//设置单据日期
IoOrderEntity order = orderDao.selectOne(new QueryWrapper<IoOrderEntity>().select("createTime").eq("billNo", response.getOrderId()));
response.setOrderTime(DateUtil.toDateStr(order.getCreateTime(), "yyyy-MM-dd HH:mm:ss"));
}
}

@ -23,6 +23,7 @@ public class InvProductServiceImpl implements InvProductService {
@Override
public int insert(InvProductEntity invProductEntity) {
invProductEntity.setId(null);
return invProductDao.insert(invProductEntity);
}

@ -0,0 +1,80 @@
package com.glxp.api.task;
import cn.hutool.core.collection.CollUtil;
import com.glxp.api.dao.schedule.ScheduledDao;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.entity.system.ScheduledEntity;
import com.glxp.api.entity.system.SystemParamConfigEntity;
import com.glxp.api.req.system.ScheduledRequest;
import com.glxp.api.res.inout.IoOrderResponse;
import com.glxp.api.service.inout.IoAddInoutService;
import com.glxp.api.service.inout.IoOrderService;
import com.glxp.api.service.system.SystemParamConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
*
*/
@Slf4j
@Component
@EnableScheduling
public class SupplementOrderTask implements SchedulingConfigurer {
@Resource
ScheduledDao scheduledDao;
@Resource
IoOrderService orderService;
@Resource
SystemParamConfigService systemParamConfigService;
@Resource
IoAddInoutService addInoutService;
@Override
public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
taskRegistrar.addTriggerTask(() -> process(),
triggerContext -> {
ScheduledRequest scheduledRequest = new ScheduledRequest();
scheduledRequest.setCronName("supplementOrderTask");
ScheduledEntity scheduledEntity = scheduledDao.findScheduled(scheduledRequest);
if (scheduledEntity == null) {
log.error("定时任务未配置,请注意!");
return null;
}
String cron = scheduledEntity.getCron();
return new CronTrigger(cron).nextExecutionTime(triggerContext);
});
}
private void process() {
SystemParamConfigEntity systemParamConfigEntity = systemParamConfigService.selectByParamKey("supplement_order_interval");
if (!"0".equals(systemParamConfigEntity.getParamValue())) {
log.info("开始扫描需要平衡补单数据");
//计数器
AtomicInteger counter = new AtomicInteger(0);
List<IoOrderEntity> orderEntities = orderService.selectSupplementOrderList();
if (CollUtil.isNotEmpty(orderEntities)) {
List<IoOrderResponse> orderResponses = orderService.checkSupplementOrder(orderEntities);
for (IoOrderResponse orderResponse : orderResponses) {
if (orderResponse.isEnableSupplementOrder()) {
//此单据可以补单
addInoutService.supplementOrder(orderResponse.getBillNo());
counter.addAndGet(1);
}
}
}
log.info("平衡补单,此次补单数量为:{}", counter.get());
}
}
}

@ -1,6 +1,8 @@
package com.glxp.api.util;
import cn.hutool.core.util.StrUtil;
import com.glxp.api.entity.inout.IoOrderEntity;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateUtils;
import org.apache.commons.lang3.time.FastDateFormat;
@ -11,6 +13,7 @@ import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
@Slf4j
public class DateUtil extends DateUtils {
private static String[] parsePatterns = {
@ -579,4 +582,26 @@ public class DateUtil extends DateUtils {
}
return time;
}
/**
* Date
*
* @param date
* @return
*/
public static String toDateStr(Date date, String format) {
if (null != date) {
try {
//如果未指定格式,则使用默认格式
if (StrUtil.isBlank(format)) {
format = "yyyy-MM-dd HH:mm:ss";
}
return cn.hutool.core.date.DateUtil.date(date).toString(format);
} catch (Exception e) {
log.error("日期类型转字符串异常,日期参数:{}, 格式:{}, 异常信息:{}", date, format, e);
}
}
log.error("日期类型转字符串异常,日期数据为空");
return null;
}
}

@ -4,9 +4,9 @@ server:
spring:
datasource:
driver-class-name: com.p6spy.engine.spy.P6SpyDriver
jdbc-url: jdbc:p6spy:mysql://127.0.0.1:3306/udi_wms?allowMultiQueries=true&serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
jdbc-url: jdbc:p6spy:mysql://192.168.0.66:3364/udi_wms?allowMultiQueries=true&serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
username: root
password: 123456
password: Glxp@6066
hikari:
connection-timeout: 60000
maximum-pool-size: 60

@ -181,7 +181,9 @@
from auth_user
<where>
userFlag != 0
<if test="locDeptCode != null and '' != locDeptCode">
AND locDeptCode = #{locDeptCode}
</if>
<if test="userIds != null and userIds.size() != 0">
and id not in

@ -329,4 +329,16 @@
</where>
GROUP BY a.code
</select>
<select id="selectInvListByUser" resultType="com.glxp.api.entity.auth.InvWarehouseEntity">
select auth_warehouse.code,
auth_warehouse.name,
auth_warehouse.parentId,
auth_warehouse.parentCode,
auth_dept.name warehouseName
from auth_warehouse
inner join auth_dept on auth_warehouse.parentId = auth_dept.code
inner join auth_warehouse_user on auth_warehouse.code = auth_warehouse_user.code
where userId = #{userId}
</select>
</mapper>

@ -9,11 +9,15 @@
<result column="userId" jdbcType="BIGINT" property="userid"/>
<result column="userName" jdbcType="VARCHAR" property="username"/>
<result column="isDirector" javaType="boolean" property="isDirector"/>
</resultMap>
<sql id="Base_Column_List">
<!--@mbg.generated-->
id, code, userId, userName, isDirector,locSubInvCode
id,
code,
userId,
userName,
isDirector,
locSubInvCode
</sql>
<select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
<!--@mbg.generated-->
@ -26,32 +30,32 @@
select *
from auth_warehouse_user
<where>
<if test="userIds != null and userIds.size()!=0">
and id in
<if test="userIds != null and userIds.size() != 0">
and id in
<foreach collection="userIds" item="item" open="(" separator="," close=")">
#{item}
</foreach>
</if>
</where>
</select>
<delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
<!--@mbg.generated-->
delete from auth_warehouse_user
delete
from auth_warehouse_user
where id = #{id,jdbcType=INTEGER}
</delete>
<delete id="deleteByCodeAndId">
<!--@mbg.generated-->
delete from auth_warehouse_user
where userid = #{id} and code=#{code}
delete
from auth_warehouse_user
where userid = #{id}
and code = #{code}
</delete>
<insert id="insert" keyColumn="id" keyProperty="id"
parameterType="com.glxp.api.entity.auth.WarehouseUserEntity" useGeneratedKeys="true">
<!--@mbg.generated-->
insert into auth_warehouse_user (code, userId, userName, isDirector
)
values (#{code,jdbcType=VARCHAR}, #{userid,jdbcType=BIGINT}, #{username,jdbcType=VARCHAR}, #{isDirector}
)
insert into auth_warehouse_user (code, userId, userName, isDirector)
values (#{code,jdbcType=VARCHAR}, #{userid,jdbcType=BIGINT}, #{username,jdbcType=VARCHAR}, #{isDirector})
</insert>
<insert id="insertSelective" keyColumn="id" keyProperty="id"
parameterType="com.glxp.api.entity.auth.WarehouseUserEntity" useGeneratedKeys="true">
@ -102,10 +106,9 @@
<update id="updateByPrimaryKey" parameterType="com.glxp.api.entity.auth.WarehouseUserEntity">
<!--@mbg.generated-->
update auth_warehouse_user
set code = #{code,jdbcType=VARCHAR},
userId = #{userid,jdbcType=BIGINT},
userName = #{username,jdbcType=VARCHAR}
isDirector = #{isDirector}
set code = #{code,jdbcType=VARCHAR},
userId = #{userid,jdbcType=BIGINT},
userName = #{username,jdbcType=VARCHAR} isDirector = #{isDirector}
where id = #{id,jdbcType=INTEGER}
</update>
<update id="updateBatch" parameterType="java.util.List">
@ -167,12 +170,11 @@
<insert id="batchInsert" keyColumn="id" keyProperty="id" parameterType="map" useGeneratedKeys="true">
<!--@mbg.generated-->
insert into auth_warehouse_user
(code, userId, userName, isDirector)
(code, userId, userName, isDirector)
values
<foreach collection="list" item="item" separator=",">
(#{item.code,jdbcType=VARCHAR}, #{item.userid,jdbcType=BIGINT}, #{item.username,jdbcType=VARCHAR},
#{item.isDirector}
)
#{item.isDirector})
</foreach>
</insert>
<insert id="insertOrUpdate" keyColumn="id" keyProperty="id"
@ -204,8 +206,8 @@
id = #{id,jdbcType=INTEGER},
</if>
code = #{code,jdbcType=VARCHAR},
userId = #{userid,jdbcType=BIGINT},
userName = #{username,jdbcType=VARCHAR},
userId = #{userid,jdbcType=BIGINT},
userName = #{username,jdbcType=VARCHAR},
</trim>
</insert>
<insert id="insertOrUpdateSelective" keyColumn="id" keyProperty="id"
@ -265,7 +267,8 @@
where code = #{code}
</select>
<select id="selectListkey" resultType="com.glxp.api.entity.auth.WarehouseUserEntity" parameterType="com.glxp.api.req.auth.FilterInvLinkDataRequest">
<select id="selectListkey" resultType="com.glxp.api.entity.auth.WarehouseUserEntity"
parameterType="com.glxp.api.req.auth.FilterInvLinkDataRequest">
select auth_warehouse_user.*, auth_user.employeeName
from auth_warehouse_user
inner join auth_user on auth_user.id = auth_warehouse_user.userId
@ -279,13 +282,17 @@
<if test="employeeName != '' and employeeName != null">
AND auth_user.employeeName = #{employeeName}
</if>
<if test="key != '' and key != null">
AND (auth_user.employeeName = #{key} or auth_warehouse_user.userName = #{key})
</if>
</where>
</select>
<select id="filterList" parameterType="com.glxp.api.req.auth.FilterInvUserRequest"
resultType="com.glxp.api.entity.auth.WarehouseUserEntity">
SELECT * FROM auth_warehouse_user
SELECT *
FROM auth_warehouse_user
<where>
<if test="id != '' and id != null">
AND id = #{id}
@ -296,11 +303,12 @@
<if test="userid != null">
and userId = #{userid}
</if>
<if test="lastUpdateTime!=null and lastUpdateTime!=''">
<![CDATA[ and DATE_FORMAT(updateTime, '%Y-%m-%d %H:%i:%S')>= DATE_FORMAT(#{lastUpdateTime}, '%Y-%m-%d %H:%i:%S') ]]>
<if test="lastUpdateTime != null and lastUpdateTime != ''">
<![CDATA[
and DATE_FORMAT(updateTime, '%Y-%m-%d %H:%i:%S') >= DATE_FORMAT(#{lastUpdateTime}, '%Y-%m-%d %H:%i:%S')
]]>
</if>
</where>
</select>
<select id="selectCodeByUser" resultType="java.lang.String">

@ -181,11 +181,12 @@
from basic_bussiness_type
where mainAction = #{mainAction}
and corpType = 3
and (supplementOrderType is null or supplementOrderType = '')
and (supplementOrderType is null
or supplementOrderType = '')
</select>
<select id="selectByUser" resultType="com.glxp.api.entity.basic.BasicBussinessTypeEntity">
select *
select basic_bussiness_type.*
from basic_bussiness_type
inner join auth_user_bustype on basic_bussiness_type.action = auth_user_bustype.scAction
<where>

@ -0,0 +1,165 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.glxp.api.dao.basic.EntrustReceDao">
<select id="filterEntrustRec" parameterType="com.glxp.api.req.basic.BasicEntrustRecRequest"
resultType="com.glxp.api.entity.basic.EntrustReceEntity">
select *
from basic_entrust_accept
<where>
<if test="id != '' and id != null">
and id = #{id}
</if>
<if test="action != null">
and `action` = #{action}
</if>
<if test="entrustInv != null">
and entrustInv = #{entrustInv}
</if>
<if test="entrustUser != '' and entrustUser != null">
and entrustUser = #{entrustUser}
</if>
<if test="userId != null">
and userId = #{userId}
</if>
<if test="curInv != null">
and curInv = #{curInv}
</if>
<if test="entrustSubInv != null">
and entrustSubInv = #{entrustSubInv}
</if>
<if test="invWarehouseCode != null">
and invWarehouseCode = #{invWarehouseCode}
</if>
<if test="lastUpdateTime != null and lastUpdateTime != ''">
<![CDATA[
and DATE_FORMAT(updateTime
, '%Y-%m-%d %H:%i:%S') >= DATE_FORMAT(#{lastUpdateTime}
, '%Y-%m-%d %H:%i:%S')
]]>
</if>
</where>
order by updateTime desc
</select>
<select id="findByUnique" parameterType="com.glxp.api.req.basic.BasicEntrustRecRequest"
resultType="com.glxp.api.entity.basic.EntrustReceEntity">
select *
from basic_entrust_accept
where `action` = #{action}
and `entrustUser` = #{entrustUser} limit 1
</select>
<select id="downloadEntrustRec" parameterType="com.glxp.api.req.basic.BasicEntrustRecRequest"
resultType="com.glxp.api.entity.basic.DlEntrustReceEntity">
select basic_entrust_accept.id,
b.name,
b.action,
b.mainAction
from basic_entrust_accept
INNER JOIN basic_bussiness_type b on a.action = b.action
LEFT JOIN auth_user on basic_entrust_accept.entrustUser = auth_user.id
<where>
<if test="id != '' and id != null">
and id = #{id}
</if>
<if test="action != null">
and basic_entrust_accept.action = #{action}
</if>
<if test="entrustInv != null">
and basic_entrust_accept.entrustInv = #{entrustInv}
</if>
<if test="entrustUser != '' and entrustUser != null">
and basic_entrust_accept.entrustUser = #{entrustUser}
</if>
<if test="userId != null">
and basic_entrust_accept.userId = #{userId}
</if>
<if test="lastUpdateTime != null and lastUpdateTime != ''">
<![CDATA[
and DATE_FORMAT(updateTime, '%Y-%m-%d %H:%i:%S') >= DATE_FORMAT(#{lastUpdateTime}, '%Y-%m-%d %H:%i:%S')
]]>
</if>
</where>
</select>
<select id="filterJoinEntrustRec" parameterType="com.glxp.api.req.basic.BasicEntrustRecRequest"
resultType="com.glxp.api.res.basic.EntrustReceResponse">
select basic_entrust_accept.*,
a.name as curName,
b.name as entrustName,
auth_user.employeeName,
c.name as entrustInvName,
d.name as curInvName
from basic_entrust_accept
LEFT JOIN basic_bussiness_type a on basic_entrust_accept.action = a.action
LEFT JOIN basic_bussiness_type b on basic_entrust_accept.entrustAction = b.action
LEFT JOIN auth_user on basic_entrust_accept.entrustUser = auth_user.id
LEFT JOIN auth_warehouse c on basic_entrust_accept.entrustInv = c.`code`
LEFT JOIN auth_warehouse d on basic_entrust_accept.curInv = d.`code`
<where>
<if test="id != '' and id != null">
and id = #{id}
</if>
<if test="action != null">
and action = #{action}
</if>
<if test="entrustInv != null">
and entrustInv = #{entrustInv}
</if>
<if test="entrustUser != '' and entrustUser != null">
and entrustUser = #{entrustUser}
</if>
<if test="userId != null">
and userId = #{userId}
</if>
<if test="curInv != null">
and curInv = #{curInv}
</if>
<if test="name != null and name != ''">
and a.name like concat('%'
, #{name}
, '%')
</if>
</where>
group by basic_entrust_accept.id
order by updateTime desc
</select>
<insert id="insertEntrustRec" keyProperty="id"
parameterType="com.glxp.api.entity.basic.EntrustReceEntity">
replace
INTO basic_entrust_accept(`action`,curDept, entrustInv, `entrustUser`, userId,
updateTime, remark,entrustAction,finishRece,curInv,entrustDept,entrustInv,entrustEnd)
values (
#{action},
#{entrustInv},
#{entrustUser},
#{userId},
#{updateTime},
#{remark},
#{entrustAction},
#{finishRece},
#{curInv},
#{entrustDept},
#{entrustInv},
#{entrustEnd}
)
</insert>
<delete id="deleteById" parameterType="Map">
DELETE
FROM basic_entrust_accept
WHERE id = #{id}
</delete>
<delete id="deleteAll" parameterType="Map">
DELETE
FROM basic_entrust_accept
</delete>
</mapper>

@ -118,8 +118,8 @@
<if test="unionCode != '' and unionCode != null">
and (
nameCode LIKE concat('%', #{unionCode}, '%')
or basic_udirel.ybbm LIKE concat('%', #{unionCode}, '%')
or basic_udirel.sptm LIKE concat('%', #{unionCode}, '%')
or basic_products.ybbm LIKE concat('%', #{unionCode}, '%')
or basic_products.sptm LIKE concat('%', #{unionCode}, '%')
)
</if>
<if test="thrPiId != '' and thrPiId != null">

@ -17,12 +17,21 @@
<if test="id != null and id != ''">
AND id = #{id}
</if>
<if test="action != null and action != ''">
AND action = #{action}
</if>
<if test="mainAction != null and mainAction != ''">
AND mainAction = #{mainAction}
</if>
<if test="billNo != null and billNo != ''">
AND billNo like concat('%', #{billNo}, '%')
</if>
<if test="corpOrderId != null and corpOrderId != ''">
AND corpOrderId = #{corpOrderId}
</if>
<if test="fromCorp != null and fromCorp != ''">
AND fromCorp = #{fromCorp}
</if>
<if test="deptCode != null and deptCode != ''">
AND deptCode = #{deptCode}
</if>
@ -30,13 +39,28 @@
AND invCode = #{invCode}
</if>
<if test="startTime != null and startTime != '' and endTime != null and endTime != ''">
AND createTime between #{startTime} and #{endTime}
AND date_format(createTime, '%Y-%m-%d') between date_format(#{startTime}, '%Y-%m-%d') and date_format(#{endTime}, '%Y-%m-%d')
</if>
<if test="startTime != null and startTime != ''">
AND createTime >= #{startTime}
<if test="startTime != null and startTime != '' and (endTime == null or endTime == '')">
AND date_format(createTime, '%Y-%m-%d') >= date_format(#{startTime}, '%Y-%m-%d')
</if>
<if test="endTime != null and endTime != ''">
AND createTime &lt;= #{endTime}
<if test="endTime != null and endTime != '' and (startTime == null or startTime == '')">
AND date_format(createTime, '%Y-%m-%d') &lt;= date_format(#{endTime}, '%Y-%m-%d')
</if>
<if test="statuses != null and statuses.size() != 0">
AND status in
<foreach collection="statuses" index="index" item="item" open="(" close=")" separator=",">
#{item}
</foreach>
</if>
<if test="dealStatuses != null and dealStatuses.size() != 0">
AND dealStatus in
<foreach collection="dealStatuses" index="index" item="item" open="(" close=")" separator=",">
#{item}
</foreach>
</if>
<if test="status != null">
AND status = #{status}
</if>
</where>
</select>
@ -76,14 +100,26 @@
AND deptCode = #{deptCode}
</if>
<if test="startTime != null and startTime != '' and endTime != null and endTime != ''">
AND createTime between #{startTime} and #{endTime}
AND date_format(createTime, '%Y-%m-%d') between date_format(#{startTime}, '%Y-%m-%d') and date_format(#{endTime}, '%Y-%m-%d')
</if>
<if test="startTime != null and startTime != ''">
AND createTime >= #{startTime}
<if test="startTime != null and startTime != '' and (endTime == null or endTime == '')">
AND date_format(createTime, '%Y-%m-%d') >= date_format(#{startTime}, '%Y-%m-%d')
</if>
<if test="endTime != null and endTime != ''">
AND createTime &lt;= #{endTime}
<if test="endTime != null and endTime != '' and (startTime == null or startTime == '')">
AND date_format(createTime, '%Y-%m-%d') &lt;= date_format(#{endTime}, '%Y-%m-%d')
</if>
</where>
</select>
<select id="selectSupplementOrderList" resultType="com.glxp.api.entity.inout.IoOrderEntity">
SELECT *
FROM io_order
WHERE (supplementNo IS NULL OR supplementNo = '')
AND `action` IN (SELECT `action`
FROM basic_bussiness_type
WHERE supplementOrderType IS NOT NULL
OR supplementOrderType
!= '')
</select>
</mapper>

@ -9,7 +9,7 @@
from inv_product_detail
<where>
<if test="code != null and code != ''">
AND originCode = #{code}
AND code = #{code}
</if>
<if test="mainAction != null and mainAction != ''">
AND mainAction = #{mainAction}
@ -38,9 +38,6 @@
<if test="invSpaceCode != null and invSpaceCode != ''">
AND invSpaceCode = #{invSpaceCode}
</if>
<if test="originCode != null and originCode != ''">
AND originCode = #{originCode}
</if>
<if test="batchNo != null and batchNo != ''">
AND batchNo = #{batchNo}
</if>

Loading…
Cancel
Save