仓库逻辑改变仓库详情的逻辑都改成仓库表(第一次更新)

dev_unify
qyt 9 months ago
parent c96d76d1b3
commit bbf9d799c1

@ -44,7 +44,7 @@ import com.glxp.api.service.collect.RelCodeBatchService;
import com.glxp.api.service.inout.*;
import com.glxp.api.service.inout.impl.IoCodeService;
import com.glxp.api.service.inv.*;
import com.glxp.api.service.inv.impl.InvProductDetailService;
import com.glxp.api.service.inv.impl.InvProductServiceNew;
import com.glxp.api.service.purchase.SupCertService;
import com.glxp.api.service.purchase.SupProductService;
import com.glxp.api.service.system.SystemParamConfigService;
@ -94,7 +94,7 @@ public class IoCodeTempController extends BaseController {
@Resource
InvPreinProductDetailService invPreinProductDetailService;
@Resource
InvProductDetailService invProductDetailService;
InvProductServiceNew invProductDetailService;
@Resource
IoCodeLostService codeLostService;
@Resource
@ -1406,7 +1406,7 @@ public class IoCodeTempController extends BaseController {
// return ResultVOUtils.error(500, "当前库存不足不允许0库存出库");
// }
} else {
int count = invProductDetailService.vailStockCount(codeTempEntity.getRelId(), codeTempEntity.getBatchNo(), codeTempEntity.getSupId(), codeTempEntity.getDeptCode(), codeTempEntity.getInvCode(), null);
int count = invProductDetailService.vailStockCount(codeTempEntity.getRelId(), codeTempEntity.getBatchNo(), codeTempEntity.getSupId(), codeTempEntity.getDeptCode(), codeTempEntity.getInvCode(), null,false);
if (count <= 0) {
if (count == -1) {

@ -63,23 +63,23 @@ public class InvMAOrderDetailController {
}
return invMAOrderDetailService.addOrderDetail(invMAOrderDetailEntity);
}
/**
*
*
* @param invProductIds
* @return
*/
@PostMapping("/inv/MA/order/detail/batchAddDetail")
public BaseResponse batchAddDetail(@RequestBody AddInvMAOrderDetailRequest addMAOrderDetailRequest, BindingResult bindingResult) {
if (bindingResult.hasErrors()) {
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
}
if (null == addMAOrderDetailRequest || CollUtil.isEmpty(addMAOrderDetailRequest.getInvProductIds()) || StrUtil.isBlank(addMAOrderDetailRequest.getOrderIdFk())) {
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, "参数不能为空!");
}
return invMAOrderDetailService.batchAddDetail(addMAOrderDetailRequest);
}
//TODO 120241022 养护记录注释
// /**
// * 选中库存详情批量添加养护记录详情
// *
// * @param invProductIds
// * @return
// */
// @PostMapping("/inv/MA/order/detail/batchAddDetail")
// public BaseResponse batchAddDetail(@RequestBody AddInvMAOrderDetailRequest addMAOrderDetailRequest, BindingResult bindingResult) {
// if (bindingResult.hasErrors()) {
// return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
// }
// if (null == addMAOrderDetailRequest || CollUtil.isEmpty(addMAOrderDetailRequest.getInvProductIds()) || StrUtil.isBlank(addMAOrderDetailRequest.getOrderIdFk())) {
// return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, "参数不能为空!");
// }
// return invMAOrderDetailService.batchAddDetail(addMAOrderDetailRequest);
// }
/**
*

@ -10,9 +10,7 @@ import com.glxp.api.constant.BusinessType;
import com.glxp.api.controller.BaseController;
import com.glxp.api.entity.auth.AuthAdmin;
import com.glxp.api.entity.basic.UdiEntity;
import com.glxp.api.entity.inout.IoCodeTempEntity;
import com.glxp.api.entity.inv.InvPreinDetailEntity;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.req.inv.FilterInvPreinDetailRequest;
import com.glxp.api.req.inv.FilterInvPreinRequest;
import com.glxp.api.req.inv.FilterInvProductDetailRequest;
@ -20,12 +18,10 @@ import com.glxp.api.req.system.DeleteRequest;
import com.glxp.api.res.inv.InvPreinDetailResponse;
import com.glxp.api.res.inv.InvPreinOrderResponse;
import com.glxp.api.service.auth.CustomerService;
import com.glxp.api.service.inv.InvPreProductDetailService;
import com.glxp.api.service.inv.InvPreinDetailService;
import com.glxp.api.service.inv.InvPreinOrderService;
import com.glxp.api.util.udi.FilterUdiUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.regexp.RE;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

@ -11,7 +11,6 @@ import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.common.util.ResultVOUtils;
import com.glxp.api.constant.BusinessType;
import com.glxp.api.controller.BaseController;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.entity.inv.InvProductEntity;
import com.glxp.api.req.inv.FilterInvProductDetailRequest;
import com.glxp.api.req.inv.FilterInvProductRequest;
@ -23,9 +22,11 @@ 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.inv.InvProductService;
import com.glxp.api.service.inv.impl.InvProductDetailService;
import com.glxp.api.service.inv.impl.InvProductServiceNew;
import com.glxp.api.util.udi.FilterUdiUtils;
import com.glxp.api.vo.basic.InvProductNewVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
@ -46,7 +47,7 @@ public class InvProductController extends BaseController {
@Resource
private InvProductService invProductService;
@Resource
private InvProductDetailService invProductDetailService;
private InvProductServiceNew invProductServiceNew;
@Resource
private WarehouseUserService warehouseUserService;
@Resource
@ -131,21 +132,21 @@ public class InvProductController extends BaseController {
if (!"".equals(filterInvProductDetailRequest.getOrderBy())) {
filterInvProductDetailRequest.setOrderBy("updateTime");
}
List<InvProductDetailEntity> invProductDetailEntities = invProductDetailService.filterInvProductDetailList(filterInvProductDetailRequest);
PageInfo<InvProductDetailEntity> pageInfo = new PageInfo<>(invProductDetailEntities);
List<com.glxp.api.vo.basic.InvProductNewVo> invProductDetailEntities = invProductServiceNew.filterInvProductDetailList(filterInvProductDetailRequest);
PageInfo<InvProductNewVo> pageInfo = new PageInfo<>(invProductDetailEntities);
List<InvProductDetailResponse> list = new ArrayList<>();
if (CollUtil.isNotEmpty(invProductDetailEntities)) {
invProductDetailEntities.forEach(invProductDetailEntity -> {
InvProductDetailResponse response = new InvProductDetailResponse();
BeanUtil.copyProperties(invProductDetailEntity, response);
BeanUtils.copyProperties(invProductDetailEntity, response);
//设置单据类型名称等单据相关参数
invProductDetailService.setOrderInfo(response);
invProductServiceNew.setOrderInfo(response);
list.add(response);
});
}
//根据单据日期排序
// //根据单据日期排序
// list.sort((o1, o2) -> {
// long o1OrderTime = DateUtil.parseDate(o1.getOrderTime()).getTime();
// long o2OrderTime = DateUtil.parseDate(o2.getOrderTime()).getTime();
@ -190,7 +191,7 @@ public class InvProductController extends BaseController {
detailRequest.setBatchNo(invProductEntity.getBatchNo());
}
invProductService.deleteById(id);
invProductDetailService.deleteInvProductDetail(detailRequest);
// invProductServiceNew.deleteInvProductDetail(detailRequest);
return ResultVOUtils.success("删除成功");
} else {
return ResultVOUtils.error(500, "删除失败");
@ -275,7 +276,7 @@ public class InvProductController extends BaseController {
if (StrUtil.isEmpty(filterInvProductDetailRequest.getInvCode())) {
return ResultVOUtils.error(500, "当前仓库号不能为空");
}
int count = invProductDetailService.vailStockCount(Long.parseLong(filterInvProductDetailRequest.getRelId()), filterInvProductDetailRequest.getBatchNo(), filterInvProductDetailRequest.getSupId(), filterInvProductDetailRequest.getDeptCode(), filterInvProductDetailRequest.getInvCode(), null);
int count = invProductServiceNew.vailStockCount(Long.parseLong(filterInvProductDetailRequest.getRelId()), filterInvProductDetailRequest.getBatchNo(), filterInvProductDetailRequest.getSupId(), filterInvProductDetailRequest.getDeptCode(), filterInvProductDetailRequest.getInvCode(), null,false);
return ResultVOUtils.success(count);
}

@ -1,15 +1,20 @@
package com.glxp.api.controller.inv;
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.PageInfo;
import com.glxp.api.annotation.AuthRuleAnnotation;
import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.common.util.ResultVOUtils;
import com.glxp.api.dao.inout.IoCodeDao;
import com.glxp.api.entity.basic.UdiEntity;
import com.glxp.api.entity.basic.UdiProductEntity;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.entity.inout.IoCodeEntity;
import com.glxp.api.entity.inv.InvProductEntity;
import com.glxp.api.req.basic.FilterUdiRelRequest;
import com.glxp.api.req.inout.FilterCodeRequest;
import com.glxp.api.req.inout.FilterOrderRequest;
import com.glxp.api.req.inv.FilterCodeTraceRequest;
import com.glxp.api.req.inv.FilterInvProductDetailRequest;
@ -20,17 +25,15 @@ import com.glxp.api.res.inv.UdiTraceResponse;
import com.glxp.api.service.basic.UdiProductService;
import com.glxp.api.service.basic.UdiRelevanceService;
import com.glxp.api.service.inout.IoOrderService;
import com.glxp.api.service.inv.impl.InvProductDetailService;
import com.glxp.api.util.DateUtil;
import com.glxp.api.service.inv.impl.InvProductServiceNew;
import com.glxp.api.util.MsDateUtil;
import com.glxp.api.util.udi.FilterUdiUtils;
import com.glxp.api.vo.basic.InvProductNewVo;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.stream.Collectors;
@RestController
@ -42,10 +45,12 @@ public class UdiTraceController {
@Resource
UdiProductService udiProductService;
@Resource
InvProductDetailService invProductDetailService;
@Resource
IoOrderService orderService;
@Resource
InvProductServiceNew invProductServiceNew;
@Resource
IoCodeDao ioCodeDao;
//TODO 20241017 先把这个接口注释了
@AuthRuleAnnotation("")
@GetMapping("udiwarehouse/trace/filter")
public BaseResponse list(FilterCodeTraceRequest filterCodeTraceRequest) {
@ -61,21 +66,21 @@ public class UdiTraceController {
return ResultVOUtils.error(500, "耗材字典不存在此产品!");
}
List<UdiProductEntity> udiInfoEntities = udiProductService.findByUuids(udiInfoBean.getUuid());
FilterInvProductDetailRequest filterInvProductDetailRequest = new FilterInvProductDetailRequest();
FilterCodeRequest filterCodeRequest = new FilterCodeRequest();
if (udiInfoEntities != null && udiInfoEntities.size() > 1) {
filterInvProductDetailRequest.setRelId(udiInfoBean.getId() + "");
filterInvProductDetailRequest.setBatchNo(udiEntity.getBatchNo());
filterCodeRequest.setRelId(udiInfoBean.getId() + "");
filterCodeRequest.setBatchNo(udiEntity.getBatchNo());
} else {
filterInvProductDetailRequest.setCode(filterCodeTraceRequest.getCode());
filterCodeRequest.setCode(filterCodeTraceRequest.getCode());
}
filterInvProductDetailRequest.setSupId(filterCodeTraceRequest.getSupId());
List<InvProductDetailEntity> invProductDetailEntities = invProductDetailService.filterInvProductDetailList(filterInvProductDetailRequest);
// IoCodeEntity;
filterCodeRequest.setSupId(filterCodeTraceRequest.getSupId());
List<IoCodeEntity> invProductDetailEntities = ioCodeDao.filterCodeList(filterCodeRequest);
if (invProductDetailEntities.size() > 0) {
Map<String, String> filterMap = new HashMap<>();
for (InvProductDetailEntity invProductDetailEntity : invProductDetailEntities) {
for (IoCodeEntity invProductDetailEntity : invProductDetailEntities) {
filterMap.put(invProductDetailEntity.getOrderId(), invProductDetailEntity.getOrderId());
}
List<String> orderIds = new ArrayList<>();
@ -103,12 +108,12 @@ public class UdiTraceController {
udiTraceResponse.setOrderId(item.getBillNo());
udiTraceResponse.setBillTypeName(item.getBillTypeName());
udiTraceResponse.setFromCorp(item.getFromName());
udiTraceResponse.setActDate(DateUtil.formatDate(item.getCreateTime()));
udiTraceResponse.setActDate(MsDateUtil.formatDate(item.getCreateTime()));
if (finalUdiRelevance != null) {
udiTraceResponse.setYlqxzcrbarmc(finalUdiRelevance.getYlqxzcrbarmc());
udiTraceResponse.setCpmctymc(finalUdiRelevance.getCpmctymc());
udiTraceResponse.setGgxh(finalUdiRelevance.getGgxh());
InvProductDetailEntity invProductDetailEntity = invProductDetailEntities.get(0);
IoCodeEntity invProductDetailEntity = invProductDetailEntities.get(0);
udiTraceResponse.setBatchNo(invProductDetailEntity.getBatchNo());
udiTraceResponse.setProduceDate(invProductDetailEntity.getProduceDate());
udiTraceResponse.setExpireDate(invProductDetailEntity.getExpireDate());
@ -130,14 +135,16 @@ public class UdiTraceController {
}
// TODO 20241017先把这个接口注释了
@AuthRuleAnnotation("")
@GetMapping("spms/inv/products/order/trace")
public BaseResponse filterOrderTrace(FilterCodeTraceRequest filterCodeTraceRequest) {
if (filterCodeTraceRequest.getCode() == null) {
return ResultVOUtils.success();
}
System.out.println(filterCodeTraceRequest+"---------------------------------------------");
System.out.println(filterCodeTraceRequest + "---------------------------------------------");
UdiEntity udiEntity = FilterUdiUtils.getUdi(filterCodeTraceRequest.getCode());
if (udiEntity == null) {
return ResultVOUtils.error(500, "无效条码");
@ -146,7 +153,7 @@ public class UdiTraceController {
if (udiInfoBean == null) {
return ResultVOUtils.error(500, "耗材字典不存在此产品!");
}
List<InvProductDetailEntity> mInvProductDetailEntities = new ArrayList<>();
List<IoCodeEntity> mInvProductDetailEntities = new ArrayList<>();
//判断是否多级包装
List<UdiProductEntity> udiInfoEntities = udiProductService.findByUuids(udiInfoBean.getUuid());
@ -159,58 +166,52 @@ public class UdiTraceController {
for (UdiRelevanceResponse udiRelevanceResponse : udiRelevanceResponses) {
//假设条码不完整
FilterInvProductDetailRequest filterInvProductDetailRequest = new FilterInvProductDetailRequest();
filterInvProductDetailRequest.setCode(filterCodeTraceRequest.getCode());
filterInvProductDetailRequest.setSupId(filterCodeTraceRequest.getSupId());
List<InvProductDetailEntity> temps = invProductDetailService.filterInvProductDetailList(filterInvProductDetailRequest);
FilterCodeRequest filterCodeRequest = new FilterCodeRequest();
filterCodeRequest.setCode(filterCodeTraceRequest.getCode());
filterCodeRequest.setSupId(filterCodeTraceRequest.getSupId());
List<IoCodeEntity> temps = ioCodeDao.filterCodeList(filterCodeRequest);
if (CollUtil.isNotEmpty(temps)) {
Map<String, List<InvProductDetailEntity>> filterMaps = temps.stream().collect(Collectors.groupingBy(InvProductDetailEntity::getBatchNo));
Map<String, List<IoCodeEntity>> filterMaps = temps.stream().collect(Collectors.groupingBy(IoCodeEntity::getBatchNo));
if (filterMaps.size() > 0) {
for (String bacthNo : filterMaps.keySet()) {
filterInvProductDetailRequest = new FilterInvProductDetailRequest();
filterInvProductDetailRequest.setRelId(udiRelevanceResponse.getId() + "");
filterInvProductDetailRequest.setBatchNo(bacthNo);
List<InvProductDetailEntity> invProductDetailEntities = invProductDetailService.filterInvProductDetailList(filterInvProductDetailRequest);
filterCodeRequest = new FilterCodeRequest();
filterCodeRequest.setRelId(udiRelevanceResponse.getId() + "");
filterCodeRequest.setBatchNo(bacthNo);
List<IoCodeEntity> invProductDetailEntities = ioCodeDao.filterCodeList(filterCodeRequest);
if (CollUtil.isNotEmpty(invProductDetailEntities)) {
mInvProductDetailEntities.addAll(invProductDetailEntities);
}
}
}
} else {
filterInvProductDetailRequest = new FilterInvProductDetailRequest();
filterInvProductDetailRequest.setRelId(udiRelevanceResponse.getId() + "");
filterInvProductDetailRequest.setBatchNo(udiEntity.getBatchNo());
List<InvProductDetailEntity> invProductDetailEntities = invProductDetailService.filterInvProductDetailList(filterInvProductDetailRequest);
filterCodeRequest = new FilterCodeRequest();
filterCodeRequest.setRelId(udiRelevanceResponse.getId() + "");
filterCodeRequest.setBatchNo(udiEntity.getBatchNo());
List<IoCodeEntity> invProductDetailEntities = ioCodeDao.filterCodeList(filterCodeRequest);
if (CollUtil.isNotEmpty(invProductDetailEntities)) {
mInvProductDetailEntities.addAll(invProductDetailEntities);
}
}
}
}
} else {
//单级包装
FilterInvProductDetailRequest filterInvProductDetailRequest = new FilterInvProductDetailRequest();
filterInvProductDetailRequest.setCode(filterCodeTraceRequest.getCode());
filterInvProductDetailRequest.setSupId(filterCodeTraceRequest.getSupId());
List<InvProductDetailEntity> invProductDetailEntities = invProductDetailService.filterInvProductDetailList(filterInvProductDetailRequest);
FilterCodeRequest filterCodeRequest = new FilterCodeRequest();
filterCodeRequest.setCode(filterCodeTraceRequest.getCode());
filterCodeRequest.setSupId(filterCodeTraceRequest.getSupId());
List<IoCodeEntity> invProductDetailEntities = ioCodeDao.selectList(new QueryWrapper<IoCodeEntity>()
.likeRight("code", filterCodeTraceRequest.getCode())
.eq(StrUtil.isNotEmpty(filterCodeRequest.getSupId()), "supId", filterCodeRequest.getSupId()));// List<IoCodeEntity> invProductDetailEntities = invProductServiceNew.filterInvProductDetailList(filterCodeRequest);
if (CollUtil.isNotEmpty(invProductDetailEntities)) {
mInvProductDetailEntities.addAll(invProductDetailEntities);
}
}
if (mInvProductDetailEntities.size() > 0) {
Map<String, String> filterMap = new HashMap<>();
for (InvProductDetailEntity invProductDetailEntity : mInvProductDetailEntities) {
for (IoCodeEntity invProductDetailEntity : mInvProductDetailEntities) {
filterMap.put(invProductDetailEntity.getOrderId(), invProductDetailEntity.getOrderId());
}
List<String> orderIds = new ArrayList<>();
@ -222,6 +223,7 @@ public class UdiTraceController {
filterOrderRequest.setPage(filterCodeTraceRequest.getPage());
filterOrderRequest.setLimit(filterCodeTraceRequest.getLimit());
List<IoOrderResponse> orderEntities = orderService.filterList(filterOrderRequest);
Collections.sort(orderEntities, Comparator.comparing(IoOrderResponse::getCreateTime));
PageInfo<IoOrderResponse> pageInfo;
pageInfo = new PageInfo<>(orderEntities);
PageSimpleResponse<IoOrderResponse> pageSimpleResponse = new PageSimpleResponse<>();

@ -2,9 +2,16 @@ package com.glxp.api.dao.inv;
import com.glxp.api.dao.BaseMapperPlus;
import com.glxp.api.entity.inv.InvPreInProductDetailEntity;
import com.glxp.api.req.inv.FilterInvPlaceRequest;
import com.glxp.api.req.inv.FilterInvPreProductDetailRequest;
import com.glxp.api.req.inv.FilterInvPreinProductRequest;
import com.glxp.api.req.inv.FilterInvProductDetailRequest;
import com.glxp.api.res.inout.IoOrderResponse;
import com.glxp.api.res.inv.InvPlaceDetailResponse;
import com.glxp.api.res.inv.InvPreinProductResponse;
import com.glxp.api.vo.basic.InvProductNewVo;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@ -22,6 +29,8 @@ public interface InvPreInProductDetailDao extends BaseMapperPlus<InvPreInProduct
*/
List<InvPreInProductDetailEntity> filterPreProductDetailList(FilterInvPreProductDetailRequest filterInvPreProductDetailRequest);
List<InvPreinProductResponse> findGroupBySpace(FilterInvPreinProductRequest filterInvPreinProductRequest);
/**
*
*
@ -29,4 +38,31 @@ public interface InvPreInProductDetailDao extends BaseMapperPlus<InvPreInProduct
* @return
*/
boolean deleteInvPreProductDetail(FilterInvProductDetailRequest detailRequest);
List<InvPlaceDetailResponse> getInvProductInfo(FilterInvPlaceRequest filterInvPlaceRequest);
void batchBindSpace(@Param("ids") List<Integer> ids, @Param("invSpaceCode") String invSpaceCode);
List<IoOrderResponse> getInvPlaceOrderList(FilterInvPlaceRequest filterInvPlaceRequest);
Integer getInventoryQuantity(@Param("code") String code, @Param("invCode") String invCode);
//用货架查询
List<InvPlaceDetailResponse> filterSpaceList(FilterInvPlaceRequest filterInvPlaceOrderRequest);
List<InvPlaceDetailResponse> findByGroupCode(@Param("invCode") String invCode, @Param("code") String code);
List<InvPreInProductDetailEntity> findBySpaceList(@Param("spaceList") List<String> spaceList);
InvProductNewVo selectLastInBatch(@Param("relId") String relId, @Param("batchNo") String batchNo, @Param("mainAction") String mainAction);
InvProductNewVo selectFirstInBatch(@Param("relId") String relId, @Param("batchNo") String batchNo, @Param("mainAction") String mainAction);
Integer selectCountByInBatch(@Param("relId") String relId, @Param("batchNo") String batchNo,@Param("inBatchNo") String inBatchNo, @Param("mainAction") String mainAction);
InvProductNewVo selectNextInBatch(@Param("relId") String relId, @Param("batchNo") String batchNo, @Param("mainAction") String mainAction, @Param("inBatchNo") String inBatchNo);
}

@ -2,8 +2,15 @@ package com.glxp.api.dao.inv;
import com.glxp.api.dao.BaseMapperPlus;
import com.glxp.api.entity.inv.InvPreProductDetailEntity;
import com.glxp.api.req.inv.FilterInvPlaceRequest;
import com.glxp.api.req.inv.FilterInvPreProductDetailRequest;
import com.glxp.api.req.inv.FilterInvPreinProductRequest;
import com.glxp.api.req.inv.FilterInvProductDetailRequest;
import com.glxp.api.res.inout.IoOrderResponse;
import com.glxp.api.res.inv.InvPlaceDetailResponse;
import com.glxp.api.res.inv.InvPreinProductResponse;
import com.glxp.api.vo.basic.InvProductNewVo;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@ -12,6 +19,9 @@ import java.util.List;
*/
public interface InvPreProductDetailDao extends BaseMapperPlus<InvPreProductDetailDao, InvPreProductDetailEntity, InvPreProductDetailEntity> {
List<InvPreinProductResponse> findGroupBySpace(FilterInvPreinProductRequest filterInvPreinProductRequest);
/**
*
*
@ -27,4 +37,28 @@ public interface InvPreProductDetailDao extends BaseMapperPlus<InvPreProductDeta
* @return
*/
boolean deleteInvPreProductDetail(FilterInvProductDetailRequest detailRequest);
List<InvPlaceDetailResponse> getInvProductInfo(FilterInvPlaceRequest filterInvPlaceRequest);
void batchBindSpace(@Param("ids") List<Integer> ids, @Param("invSpaceCode") String invSpaceCode);
List<IoOrderResponse> getInvPlaceOrderList(FilterInvPlaceRequest filterInvPlaceRequest);
Integer getInventoryQuantity(@Param("code") String code,@Param("invCode") String invCode);
//用货架查询
List<InvPlaceDetailResponse> filterSpaceList(FilterInvPlaceRequest filterInvPlaceOrderRequest);
List<InvPlaceDetailResponse> findByGroupCode(@Param("invCode") String invCode, @Param("code") String code);
InvProductNewVo selectLastInBatch(@Param("relId") String relId, @Param("batchNo") String batchNo, @Param("mainAction") String mainAction);
InvProductNewVo selectFirstInBatch(@Param("relId") String relId, @Param("batchNo") String batchNo, @Param("mainAction") String mainAction);
Integer selectCountByInBatch(@Param("relId") String relId, @Param("batchNo") String batchNo,@Param("inBatchNo") String inBatchNo, @Param("mainAction") String mainAction);
InvProductNewVo selectNextInBatch(@Param("relId") String relId, @Param("batchNo") String batchNo, @Param("mainAction") String mainAction, @Param("inBatchNo") String inBatchNo);
}

@ -1,65 +0,0 @@
package com.glxp.api.dao.inv;
import com.glxp.api.dao.BaseMapperPlus;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.req.inv.FilterInvPlaceRequest;
import com.glxp.api.req.inv.FilterInvProductDetailRequest;
import com.glxp.api.res.inv.BindInvSpaceRequest;
import com.glxp.api.res.inv.InvPlaceDetailResponse;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface InvProductDetailDao extends BaseMapperPlus<InvProductDetailDao, InvProductDetailEntity, InvProductDetailEntity> {
/**
*
*
* @param filterInvProductDetailRequest
* @return
*/
List<InvProductDetailEntity> filterInvProductDetailList(FilterInvProductDetailRequest filterInvProductDetailRequest);
/**
*
*
* @param detailRequest
* @return
*/
boolean deleteInvProductDetail(FilterInvProductDetailRequest detailRequest);
/**
*
*
* @param filterInvPlaceRequest
* @return
*/
List<InvPlaceDetailResponse> selectPlaceDetailList(FilterInvPlaceRequest filterInvPlaceRequest);
/**
*
*
* @param ids
* @param invSpaceCode
*/
void batchBindSpace(@Param("ids") List<Integer> ids, @Param("invSpaceCode") String invSpaceCode);
/**
* UDI
*
* @param bindInvSpaceRequest
* @return
*/
InvProductDetailEntity selectByInvAndCode(BindInvSpaceRequest bindInvSpaceRequest);
/**
* ID
*
* @param code
* @return
*/
List<String> selectSupIdByCode(@Param("code") String code);
}

@ -0,0 +1,119 @@
package com.glxp.api.dao.inv;
import com.glxp.api.dao.BaseMapperPlus;
import com.glxp.api.vo.basic.InvProductNewVo;
import com.glxp.api.entity.inv.InvProductEntity;
import com.glxp.api.req.inv.FilterInvPlaceRequest;
import com.glxp.api.req.inv.FilterInvProductDetailRequest;
import com.glxp.api.req.inv.FilterInvProductRequest;
import com.glxp.api.res.inout.IoOrderResponse;
import com.glxp.api.res.inv.BindInvSpaceRequest;
import com.glxp.api.res.inv.InvPlaceDetailResponse;
import com.glxp.api.res.inv.InvProductResponse;
import com.glxp.api.vo.basic.InvProductNewVo;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.math.BigDecimal;
import java.util.List;
@Mapper
public interface InvProductNewDao extends BaseMapperPlus<InvProductNewDao, InvProductNewVo, InvProductNewVo> {
/**
*
*
* @param filterInvProductDetailRequest
* @return
*/
List<InvProductNewVo> filterInvProductDetailList(FilterInvProductDetailRequest filterInvProductDetailRequest);
List<InvProductResponse> findGroupBySpace(FilterInvProductRequest filterInvProductRequest);
/**
*
*
* @param detailRequest
* @return
*/
boolean deleteInvProductDetail(FilterInvProductDetailRequest detailRequest);
/**
*
*
* @param filterInvPlaceRequest
* @return
*/
List<InvPlaceDetailResponse> selectPlaceDetailList(FilterInvPlaceRequest filterInvPlaceRequest);
/**
*
*
* @param ids
* @param invSpaceCode
*/
void batchBindSpace(@Param("ids") List<Integer> ids, @Param("invSpaceCode") String invSpaceCode);
/**
* UDI
*
* @param bindInvSpaceRequest
* @return
*/
InvProductNewVo selectByInvAndCode(BindInvSpaceRequest bindInvSpaceRequest);
//TODO 120241022 先解开注释这个是要用码查的肯定查不到
/**
* ID(20241017===)
*
* @param code
* @return
*/
List<String> selectSupIdByCode(@Param("code") String code);
// /**
// * 查询盘点单的码(20241017===没用到注释了)
// *
// * @param invCode
// * @param invSpaceCode
// * @param relId
// * @param batchNo
// * @return
// */
// List<String> selectCountOrderCodes(@Param("invCode") String invCode, @Param("invSpaceCode") String invSpaceCode, @Param("relId") Long relId, @Param("batchNo") String batchNo);
// /**
// * 查询库存摆放的产品详情数据(20241017===没用到注释了)
// *
// * @param filterInvPlaceRequest
// * @return
// */
// List<InvPlaceDetailResponse> getInvProductInfo(FilterInvPlaceRequest filterInvPlaceRequest);
/**
*
*
* @param filterInvPlaceRequest
* @return
*/
List<IoOrderResponse> getInvPlaceOrderList(FilterInvPlaceRequest filterInvPlaceRequest);
Integer getInventoryQuantity(@Param("code") String code, @Param("invCode") String invCode);
//用货架查询
List<InvPlaceDetailResponse> filterSpaceList(FilterInvPlaceRequest filterInvPlaceOrderRequest);
List<InvPlaceDetailResponse> findByGroupCode(@Param("invCode") String invCode, @Param("code") String code, @Param("isCheckSpace") Boolean isCheckSpace);
InvProductNewVo selectLastInBatch(@Param("relId") String relId, @Param("batchNo") String batchNo, @Param("invCode") String invCode, @Param("mainAction") String mainAction);
InvProductNewVo selectFirstInBatch(@Param("relId") String relId, @Param("batchNo") String batchNo, @Param("invCode") String invCode, @Param("mainAction") String mainAction);
Integer selectCountByInBatch(@Param("relId") String relId, @Param("batchNo") String batchNo, @Param("invCode") String invCode, @Param("inBatchNo") String inBatchNo, @Param("mainAction") String mainAction);
InvProductNewVo selectNextInBatch(@Param("relId") String relId, @Param("batchNo") String batchNo, @Param("invCode") String invCode, @Param("mainAction") String mainAction, @Param("inBatchNo") String inBatchNo);
List<InvProductNewVo> selectOrderInfo(@Param(("orderIdFk")) String orderIdFk,@Param(("price")) BigDecimal price);
}

@ -128,5 +128,8 @@ public class InvProductDetailResponse {
*/
private String orderTime;
private String invSpaceName;
private BigDecimal price;
}

@ -1,5 +1,6 @@
package com.glxp.api.service.auth;
import com.baomidou.mybatisplus.extension.service.IService;
import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.entity.auth.InvSpace;
import com.glxp.api.req.auth.FilterInvSpaceRequest;
@ -16,7 +17,7 @@ public interface InvSpaceService {
* @return
*/
List<InvSpaceResponse> filterList(FilterInvSpaceRequest filterInvSpaceRequest);
InvSpace findByCode(String invCode, String spaceCode);
/**
*
*

@ -3,6 +3,7 @@ package com.glxp.api.service.auth.impl;
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.PageHelper;
import com.glxp.api.common.enums.ResultEnum;
import com.glxp.api.common.res.BaseResponse;
@ -44,6 +45,17 @@ public class InvSpaceServiceImpl implements InvSpaceService {
return invSpaceDao.filterList(filterInvSpaceRequest);
}
@Override
public InvSpace findByCode(String invCode, String spaceCode) {
if (StrUtil.isEmpty(invCode) || StrUtil.isEmpty(spaceCode))
return null;
List<InvSpace> invSpaces = invSpaceDao.selectList(new QueryWrapper<InvSpace>()
.eq("invWarehouseCode", invCode).eq("code", spaceCode).last("limit 1"));
if (CollUtil.isNotEmpty(invSpaces))
return invSpaces.get(0);
return null;
}
@Override
public BaseResponse addSpace(InvSpace invSpace) {
BaseResponse verifyResult = verifySpaceParams(invSpace);

@ -13,7 +13,7 @@ import com.glxp.api.constant.ConstantStatus;
import com.glxp.api.dao.inout.IoOrderDetailCodeDao;
import com.glxp.api.entity.basic.*;
import com.glxp.api.entity.inout.*;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.vo.basic.InvProductNewVo;
import com.glxp.api.entity.system.SystemParamConfigEntity;
import com.glxp.api.exception.JsonException;
import com.glxp.api.req.basic.FilterCompanyProductRelevanceRequest;
@ -23,7 +23,7 @@ import com.glxp.api.req.udims.PostUdimsOrderRequest;
import com.glxp.api.res.basic.UdiRelevanceResponse;
import com.glxp.api.service.basic.*;
import com.glxp.api.service.inout.impl.IoCodeService;
import com.glxp.api.service.inv.impl.InvProductDetailService;
import com.glxp.api.service.inv.impl.InvProductServiceNew;
import com.glxp.api.service.system.SystemParamConfigService;
import com.glxp.api.util.CustomUtil;
import com.glxp.api.util.DateUtil;
@ -61,7 +61,7 @@ public class IoAddInoutService {
@Resource
UdiRelevanceService udiRelevanceService;
@Resource
InvProductDetailService invProductDetailService;
InvProductServiceNew invProductServiceNew;
@Resource
BasicCorpService basicCorpService;
@Resource
@ -696,7 +696,8 @@ public class IoAddInoutService {
} else
return null;
}
@Resource
IoCodeLostService codeLostService;
public String checkOriginCode(IoCodeTempEntity warehouseEntity) {
UdiEntity udiEntity = FilterUdiUtils.getUdi(warehouseEntity.getCode());
@ -706,16 +707,16 @@ public class IoAddInoutService {
if (udiRelevanceResponse == null) {
return "耗材字典不存在此产品";
}
InvProductDetailEntity invProductDetailEntity = invProductDetailService.sortFindByCode(warehouseEntity.getCode());
if (invProductDetailEntity != null) {
IoCodeLostEntity codeLostEntity = codeLostService.findByCode(warehouseEntity.getCode());
if (codeLostEntity != null) {
if (StrUtil.isEmpty(warehouseEntity.getBatchNo())) {
warehouseEntity.setBatchNo(invProductDetailEntity.getBatchNo());
warehouseEntity.setBatchNo(codeLostEntity.getBatchNo());
}
if (StrUtil.isEmpty(warehouseEntity.getProduceDate())) {
warehouseEntity.setProduceDate(invProductDetailEntity.getProduceDate());
warehouseEntity.setProduceDate(codeLostEntity.getProduceDate());
}
if (StrUtil.isEmpty(warehouseEntity.getExpireDate())) {
warehouseEntity.setExpireDate(invProductDetailEntity.getExpireDate());
warehouseEntity.setExpireDate(codeLostEntity.getExpireDate());
}
}

@ -11,18 +11,18 @@ import com.glxp.api.entity.auth.InvWarehouseEntity;
import com.glxp.api.entity.basic.BasicBusTypePreEntity;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.inout.*;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.service.auth.InvWarehouseService;
import com.glxp.api.service.basic.IBasicBusTypePreService;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
import com.glxp.api.service.inout.impl.IoCodeService;
import com.glxp.api.service.inout.impl.IoOrderInvoiceService;
import com.glxp.api.service.inv.impl.InvProductDetailService;
import com.glxp.api.service.inv.impl.InvProductServiceNew;
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.vo.basic.InvProductNewVo;
import org.springframework.beans.BeanUtils;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
@ -43,7 +43,7 @@ public class IoChangeInoutService {
@Resource
IoOrderService orderService;
@Resource
InvProductDetailService invProductDetailService;
InvProductServiceNew invProductServiceNew;
@Resource
IBasicBussinessTypeService basicBussinessTypeService;
@Resource
@ -81,60 +81,26 @@ public class IoChangeInoutService {
public void changeBusOrder(IoOrderEntity orderEntity) {
}
//普通出入库单据流转
public void genNewOrder(IoOrderEntity orderEntity, List<InvProductDetailEntity> invProductDetailEntities) {
//TODO 120241022 之前关于详情表的删除修改操作去了
// //普通出入库单据流转
public void genNewOrder(IoOrderEntity orderEntity) {
if (orderEntity.getFromType() == ConstantStatus.FROM_UDISP && (orderEntity.getOutChangeEnable() != null && !orderEntity.getOutChangeEnable())) {
return;
}
BasicBusTypePreEntity basicBusTypePreEntity = basicBusTypePreService.findByOriginAction(orderEntity.getAction());
List<IoCodeEntity> codeEnttities = codeService.findByOrderId(orderEntity.getBillNo());
if (basicBusTypePreEntity.getSupplementAll()) {//全量补单
invProductDetailService.insertList(invProductDetailEntities);
buildInOrder(basicBusTypePreEntity, codeEnttities, orderEntity, false);
} else { //缺量补单
List<IoCodeEntity> inList = new ArrayList<>();
for (IoCodeEntity warehouseEntity : codeEnttities) {
Integer invCount = getInvCount(warehouseEntity);
Integer count = warehouseEntity.getMyReCount();
if (invCount > 0) {//仓库已存在该产品
if (count > invCount) { //当前数量>结余数量,说明该产品是无序列号或者是多级包装
if (count > invCount) { //该产品实际数量大于结余数量,说明是多级包装,直接补
inList.add(warehouseEntity);
} else if (warehouseEntity.getSerialNo() == null) { //无序列号(多级包装无序列号的已在上一步被排除),补齐数量
int lea = count - invCount;
warehouseEntity.setCount(lea / (count)); //
inList.add(warehouseEntity);
}
}
} else { //结余数量《=0直接补
inList.add(warehouseEntity);
}
InvProductDetailEntity invProductDetailEntity = filterInvByCode(invProductDetailEntities, warehouseEntity.getCode());
invProductDetailService.insert(invProductDetailEntity);
}
buildInOrder(basicBusTypePreEntity, inList, orderEntity, false);
}
buildInOrder(basicBusTypePreEntity, codeEnttities, orderEntity, false);
}
public InvProductDetailEntity filterInvByCode(List<InvProductDetailEntity> invProductDetailEntities, String
code) {
for (InvProductDetailEntity invProductDetailEntity : invProductDetailEntities) {
if (invProductDetailEntity.getCode().equals(code)) {
return invProductDetailEntity;
}
}
return null;
}
//计算当前库存数量
public int getInvCount(IoCodeEntity codeEntity) {
List<InvProductDetailEntity> resultLists = invProductDetailService.selectByUnique(codeEntity.getRelId(), codeEntity.getBatchNo(), codeEntity.getSupId(), codeEntity.getDeptCode(), codeEntity.getInvCode());
List<InvProductNewVo> resultLists = invProductServiceNew.selectByUnique(codeEntity.getRelId(), codeEntity.getBatchNo(), codeEntity.getSupId(), codeEntity.getDeptCode(), codeEntity.getInvCode());
int invCount = 0;
if (CollUtil.isNotEmpty(resultLists)) {
for (InvProductDetailEntity invProductDetailEntity : resultLists) {
for (InvProductNewVo invProductDetailEntity : resultLists) {
if (invProductDetailEntity.getMainAction().equals(ConstantType.TYPE_OUT)) {
invCount = invCount - invProductDetailEntity.getReCount();
} else {

@ -1,31 +1,19 @@
package com.glxp.api.service.inout;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.glxp.api.constant.Constant;
import com.glxp.api.constant.ConstantStatus;
import com.glxp.api.constant.ConstantType;
import com.glxp.api.entity.auth.InvWarehouseEntity;
import com.glxp.api.entity.basic.BasicBusTypePreEntity;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.basic.UdiRelevanceEntity;
import com.glxp.api.entity.inout.IoCodeEntity;
import com.glxp.api.entity.inout.IoCodeTempEntity;
import com.glxp.api.entity.inout.IoOrderDetailResultEntity;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.entity.inv.*;
import com.glxp.api.entity.system.SystemParamConfigEntity;
import com.glxp.api.service.auth.InvWarehouseService;
import com.glxp.api.service.basic.IBasicBusTypePreService;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
import com.glxp.api.service.inout.impl.IoCodeService;
import com.glxp.api.service.inv.*;
import com.glxp.api.service.inv.impl.InvProductDetailService;
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.service.inv.impl.InvProductServiceNew;
import com.glxp.api.vo.basic.InvProductNewVo;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
@ -40,7 +28,7 @@ public class IoGenInvService {
@Resource
InvProductService invProductService;
@Resource
InvProductDetailService invProductDetailService;
InvProductServiceNew invProductServiceNew;
@Resource
InvPreinOrderService invPreinOrderService;
@Resource
@ -104,30 +92,31 @@ public class IoGenInvService {
invProductEntity.setUpdateTime(new Date());
invProductService.update(invProductEntity);
}
//生成库存码详情
List<InvProductDetailEntity> invProductDetailEntities = new ArrayList<>();
for (IoCodeEntity codeEntity : codeEnttities) {
InvProductDetailEntity invProductDetailEntity = new InvProductDetailEntity();
BeanUtils.copyProperties(codeEntity, invProductDetailEntity);
invProductDetailEntity.setRelId(codeEntity.getRelId());
invProductDetailEntity.setUpdateTime(new Date());
invProductDetailEntity.setId(null);
invProductDetailEntity.setPurchaseType(ConstantStatus.PRUCHASE_COMMON);
if (invProductDetailEntity.getMainAction().equals(ConstantType.TYPE_PUT)) {
invProductDetailEntity.setInCount(invProductDetailEntity.getReCount());
} else if (invProductDetailEntity.getMainAction().equals(ConstantType.TYPE_OUT)) {
invProductDetailEntity.setOutCount(invProductDetailEntity.getReCount());
}
invProductDetailEntities.add(invProductDetailEntity);
}
//TODO 120241022 之前关于详情表的删除修改操作去了
// //生成库存码详情
// List<InvProductNewVo> invProductDetailEntities = new ArrayList<>();
// for (IoCodeEntity codeEntity : codeEnttities) {
// InvProductNewVo invProductDetailEntity = new InvProductNewVo();
// BeanUtils.copyProperties(codeEntity, invProductDetailEntity);
// invProductDetailEntity.setRelIdFk(codeEntity.getRelId());
// invProductDetailEntity.setUpdateTime(new Date());
// invProductDetailEntity.setId(null);
// invProductDetailEntity.setPurchaseType(ConstantStatus.PRUCHASE_COMMON);
// if (invProductDetailEntity.getMainAction().equals(ConstantType.TYPE_PUT)) {
// invProductDetailEntity.setInCount(invProductDetailEntity.getReCount());
// } else if (invProductDetailEntity.getMainAction().equals(ConstantType.TYPE_OUT)) {
// invProductDetailEntity.setOutCount(invProductDetailEntity.getReCount());
// }
//
// invProductDetailEntities.add(invProductDetailEntity);
// }
BasicBusTypePreEntity basicBusTypePreEntity = basicBusTypePreService.findByOriginAction(orderEntity.getAction());
if (basicBusTypePreEntity != null) { //进行单据流转
ioChangeInoutService.genNewOrder(orderEntity, invProductDetailEntities);
} else { //生成库存结束
invProductDetailService.insertList(invProductDetailEntities);
ioChangeInoutService.genNewOrder(orderEntity);
}
// else { //生成库存结束
// invProductDetailService.insertList(invProductDetailEntities);
// }
}

@ -40,16 +40,14 @@ import com.glxp.api.res.inout.OrderNoResult;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
import com.glxp.api.service.inout.*;
import com.glxp.api.service.inv.*;
import com.glxp.api.service.inv.impl.InvProductDetailService;
import com.glxp.api.service.inv.impl.InvProductServiceNew;
import com.glxp.api.service.system.SyncUploadDataBustypeService;
import com.glxp.api.util.DateUtil;
import com.glxp.api.util.GennerOrderUtils;
import com.glxp.api.util.IntUtil;
import com.glxp.api.util.OrderNoTypeBean;
import com.glxp.api.util.udi.UdiCalCountUtil;
import com.glxp.api.vo.basic.InvProductNewVo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@ -78,7 +76,7 @@ public class IoOrderServiceImpl implements IoOrderService {
@Resource
InvPreinDetailService preinDetailService;
@Resource
InvProductDetailService invProductDetailService;
InvProductServiceNew invProductServiceNew;
@Resource
InvProductService invProductService;
@Resource
@ -260,17 +258,17 @@ public class IoOrderServiceImpl implements IoOrderService {
}
} else {
//删除普通库存
List<InvProductDetailEntity> invProductDetailEntities = invProductDetailService.selectByOrderIdFk(billNo);
List<InvProductNewVo> invProductDetailEntities = invProductServiceNew.selectByOrderIdFk(billNo);
if (CollUtil.isNotEmpty(invProductDetailEntities)) {
for (InvProductDetailEntity invProductDetailEntity : invProductDetailEntities) {
for (InvProductNewVo invProductNewVo : invProductDetailEntities) {
//更新库存
InvProductEntity invProductEntity = invProductService.selectByUnique(invProductDetailEntity.getRelId(), invProductDetailEntity.getBatchNo(), invProductDetailEntity.getSupId(), invProductDetailEntity.getDeptCode(), invProductDetailEntity.getInvCode(), invProductDetailEntity.getPrice());
InvProductEntity invProductEntity = invProductService.selectByUnique(invProductNewVo.getRelIdFk(), invProductNewVo.getBatchNo(), invProductNewVo.getSupId(), invProductNewVo.getDeptCode(), invProductNewVo.getInvCode(), invProductNewVo.getPrice());
if (invProductEntity != null) {
if (ConstantType.TYPE_PUT.equals(invProductDetailEntity.getMainAction())) {
int count = invProductEntity.getInCount() - invProductDetailEntity.getReCount();
if (ConstantType.TYPE_PUT.equals(invProductNewVo.getMainAction())) {
int count = invProductEntity.getInCount() - invProductNewVo.getReCount();
invProductEntity.setInCount(count);
} else if (ConstantType.TYPE_OUT.equals(invProductDetailEntity.getMainAction())) {
int count = invProductEntity.getOutCount() - invProductDetailEntity.getReCount();
} else if (ConstantType.TYPE_OUT.equals(invProductNewVo.getMainAction())) {
int count = invProductEntity.getOutCount() - invProductNewVo.getReCount();
invProductEntity.setOutCount(count);
}
@ -279,8 +277,8 @@ public class IoOrderServiceImpl implements IoOrderService {
invProductService.update(invProductEntity);
}
}
//删除库存详情
invProductDetailService.deleteByOrderId(billNo);
// //删除库存详情
// invProductServiceNew.deleteByOrderId(billNo);
}
}
}
@ -390,27 +388,28 @@ public class IoOrderServiceImpl implements IoOrderService {
}
invPreProductService.update(invProductEntity);
} else { //普通库存
InvProductDetailEntity invProductDetailEntity = invProductDetailService.selectByCode(billNo, code);
if (invProductDetailEntity != null) {
int count = invProductDetailEntity.getCount() - 1;
if (count == 0) {
invProductDetailService.deleteById(invProductDetailEntity.getId());
} else {
//更新详情表
invProductDetailEntity.setCount(count);
int reCount = udiCalCountUtil.getActCount(invProductDetailEntity.getNameCode());
invProductDetailEntity.setReCount(invProductDetailEntity.getReCount() - reCount);
invProductDetailService.update(invProductDetailEntity);
}
}
InvProductNewVo invProductNewVo = invProductServiceNew.selectByCode(billNo, code,null);
//TODO 120241022 之前关于详情表的删除修改操作去了
// if (invProductNewVo != null) {
// int count = invProductNewVo.getCount() - 1;
// if (count == 0) {
// invProductServiceNew.deleteById(invProductNewVo.getId());
// } else {
// //更新详情表
// invProductNewVo.setCount(count);
// int reCount = udiCalCountUtil.getActCount(invProductNewVo.getNameCode());
// invProductNewVo.setReCount(invProductNewVo.getReCount() - reCount);
// invProductServiceNew.update(invProductNewVo);
// }
// }
//更新产品表
InvProductEntity invProductEntity = invProductService.selectByUnique(invProductDetailEntity.getRelId(), invProductDetailEntity.getBatchNo(), invProductDetailEntity.getSupId(), invProductDetailEntity.getDeptCode(), invProductDetailEntity.getInvCode());
InvProductEntity invProductEntity = invProductService.selectByUnique(invProductNewVo.getRelIdFk(), invProductNewVo.getBatchNo(), invProductNewVo.getSupId(), invProductNewVo.getDeptCode(), invProductNewVo.getInvCode());
if (invProductEntity != null) {
if (ConstantType.TYPE_PUT.equals(invProductDetailEntity.getMainAction())) {
int inCount = invProductEntity.getInCount() - invProductDetailEntity.getReCount();
if (ConstantType.TYPE_PUT.equals(invProductNewVo.getMainAction())) {
int inCount = invProductEntity.getInCount() - invProductNewVo.getReCount();
invProductEntity.setInCount(inCount);
} else if (ConstantType.TYPE_OUT.equals(invProductDetailEntity.getMainAction())) {
int outCount = invProductEntity.getOutCount() - invProductDetailEntity.getReCount();
} else if (ConstantType.TYPE_OUT.equals(invProductNewVo.getMainAction())) {
int outCount = invProductEntity.getOutCount() - invProductNewVo.getReCount();
invProductEntity.setOutCount(outCount);
}
invProductEntity.setReCount(invProductEntity.getInCount() - invProductEntity.getOutCount());
@ -491,23 +490,23 @@ public class IoOrderServiceImpl implements IoOrderService {
invPreProductDetailService.deleteByOrderId(billNo);
}
} else {
List<InvProductDetailEntity> invProductDetailEntities = invProductDetailService.selectByOrderIdFk(billNo);
List<InvProductNewVo> invProductDetailEntities = invProductServiceNew.selectByOrderIdFk(billNo);
if (CollUtil.isNotEmpty(invProductDetailEntities)) {
for (InvProductDetailEntity invProductDetailEntity : invProductDetailEntities) {
InvProductEntity invProductEntity = invProductService.selectByUnique(invProductDetailEntity.getRelId(), invProductDetailEntity.getBatchNo(), invProductDetailEntity.getSupId(),
invProductDetailEntity.getDeptCode(), invProductDetailEntity.getInvCode());
for (InvProductNewVo invProductNewVo : invProductDetailEntities) {
InvProductEntity invProductEntity = invProductService.selectByUnique(invProductNewVo.getRelIdFk(), invProductNewVo.getBatchNo(), invProductNewVo.getSupId(),
invProductNewVo.getDeptCode(), invProductNewVo.getInvCode());
if (ConstantType.TYPE_PUT.equals(invProductDetailEntity.getMainAction())) {
int count = invProductEntity.getInCount() - invProductDetailEntity.getReCount();
if (ConstantType.TYPE_PUT.equals(invProductNewVo.getMainAction())) {
int count = invProductEntity.getInCount() - invProductNewVo.getReCount();
invProductEntity.setInCount(count);
} else if (ConstantType.TYPE_OUT.equals(invProductDetailEntity.getMainAction())) {
int count = invProductEntity.getOutCount() - invProductDetailEntity.getReCount();
} else if (ConstantType.TYPE_OUT.equals(invProductNewVo.getMainAction())) {
int count = invProductEntity.getOutCount() - invProductNewVo.getReCount();
invProductEntity.setOutCount(count);
}
invProductEntity.setReCount(invProductEntity.getInCount() - invProductEntity.getOutCount());
invProductService.update(invProductEntity);
}
invProductDetailService.deleteByOrderId(billNo);
// invProductServiceNew.deleteByOrderId(billNo);
}
}

@ -37,13 +37,13 @@ public interface InvMAOrderDetailService {
*/
BaseResponse delete(Integer id);
/**
*
*
* @param addMAOrderDetailRequest
* @return
*/
BaseResponse batchAddDetail(AddInvMAOrderDetailRequest addMAOrderDetailRequest);
// /**
// * 根据库存详情批量添加养护详情记录
// *
// * @param addMAOrderDetailRequest
// * @return
// */
// BaseResponse batchAddDetail(AddInvMAOrderDetailRequest addMAOrderDetailRequest);
/**
*

@ -1,8 +1,6 @@
package com.glxp.api.service.inv;
import com.glxp.api.entity.inv.InvPreInProductDetailEntity;
import com.glxp.api.entity.inv.InvPreProductDetailEntity;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.req.inv.FilterInvPreProductDetailRequest;
import com.glxp.api.req.inv.FilterInvProductDetailRequest;
import com.glxp.api.res.inv.InvPreProductDetailResponse;

@ -1,8 +1,6 @@
package com.glxp.api.service.inv;
import com.glxp.api.entity.inv.InvPreProductEntity;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.entity.inv.InvProductEntity;
import com.glxp.api.req.inv.FilterInvPreProductRequest;
import com.glxp.api.res.inv.InvPreProductResponse;

@ -10,10 +10,10 @@ import com.glxp.api.common.util.ResultVOUtils;
import com.glxp.api.constant.ConstantType;
import com.glxp.api.dao.inv.DeviceReceiveOrderDetailDao;
import com.glxp.api.dao.inv.InvProductDao;
import com.glxp.api.dao.inv.InvProductDetailDao;
import com.glxp.api.dao.inv.InvProductNewDao;
import com.glxp.api.entity.basic.UdiEntity;
import com.glxp.api.entity.inv.DeviceReceiveOrderDetailEntity;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.vo.basic.InvProductNewVo;
import com.glxp.api.entity.inv.InvProductEntity;
import com.glxp.api.req.inv.AddDeviceReceiveOrderDetailRequest;
import com.glxp.api.req.inv.FilterDeviceReceiveOrderDetailRequest;
@ -37,7 +37,7 @@ public class DeviceReceiveOrderDetailServiceImpl implements DeviceReceiveOrderDe
@Resource
private DeviceReceiveOrderDetailDao deviceReceiveOrderDetailDao;
@Resource
private InvProductDetailDao invProductDetailDao;
private InvProductNewDao invProductNewDao;
@Resource
private InvProductDao invProductDao;
@ -56,105 +56,106 @@ public class DeviceReceiveOrderDetailServiceImpl implements DeviceReceiveOrderDe
});
return list;
}
//TODO 120241022 添加设备领用记录详情先注释 因为逻辑里面很多用码进行处理
@Override
public BaseResponse addOrderDetail(AddDeviceReceiveOrderDetailRequest addDetailRequest) {
if (null == addDetailRequest || StrUtil.isBlank(addDetailRequest.getOrderIdFk())) {
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
}
if (StrUtil.isBlank(addDetailRequest.getCode()) && CollUtil.isEmpty(addDetailRequest.getInvProductIds())) {
return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, "请添加领用设备!");
}
if (StrUtil.isNotBlank(addDetailRequest.getCode())) {
//通过条码添加
//解析此条码,判断此条码是否已经存在
UdiEntity udi = FilterUdiUtils.getUdi(addDetailRequest.getCode());
if (StrUtil.isNotBlank(udi.getSerialNo())) {
//条码为完整码,查询此条码在当前领用记录中是否存在,如果存在则无法添加
FilterDeviceReceiveOrderDetailRequest detailRequest = new FilterDeviceReceiveOrderDetailRequest();
detailRequest.setOrderIdFk(addDetailRequest.getOrderIdFk());
detailRequest.setCode(addDetailRequest.getCode());
List<DeviceReceiveOrderDetailResponse> list = deviceReceiveOrderDetailDao.filterList(detailRequest);
if (CollUtil.isNotEmpty(list)) {
return ResultVOUtils.error(ResultEnum.DATA_REPEAT, "条码重复!");
}
}
//设置库存详情查询参数
FilterInvProductDetailRequest invProductDetailRequest = new FilterInvProductDetailRequest();
invProductDetailRequest.setCode(addDetailRequest.getCode());
//判断是否有选入的仓库信息,如果没有,说明此条码仅存在一条仓库信息,直接使用即可
if (StrUtil.isNotBlank(addDetailRequest.getInvCode())) {
invProductDetailRequest.setDeptCode(addDetailRequest.getDeptCode());
invProductDetailRequest.setInvCode(addDetailRequest.getInvCode());
invProductDetailRequest.setInvSpaceCode(addDetailRequest.getInvSpaceCode());
}
//查询库存详情
List<InvProductDetailEntity> invProductDetailEntities = invProductDetailDao.filterInvProductDetailList(invProductDetailRequest);
InvProductDetailEntity invProductDetailEntity = invProductDetailEntities.get(0);
DeviceReceiveOrderDetailEntity orderDetail = getDeviceReceiveOrderDetailEntity(addDetailRequest.getOrderIdFk(), addDetailRequest.getCode(), invProductDetailEntity);
deviceReceiveOrderDetailDao.insert(orderDetail);
} else {
//通过选库存添加
//查询选中的库存信息
for (String invProductId : addDetailRequest.getInvProductIds()) {
InvProductEntity invProductEntity = invProductDao.selectById(invProductId);
//查询库存详情
FilterInvProductDetailRequest filterInvProductDetailRequest = new FilterInvProductDetailRequest();
filterInvProductDetailRequest.setRelId(String.valueOf(invProductEntity.getRelIdFk()));
filterInvProductDetailRequest.setBatchNo(invProductEntity.getBatchNo());
filterInvProductDetailRequest.setDeptCode(invProductEntity.getDeptCode());
filterInvProductDetailRequest.setInvCode(invProductEntity.getInvCode());
List<InvProductDetailEntity> invProductDetailEntities = invProductDetailDao.filterInvProductDetailList(filterInvProductDetailRequest);
//计算出在仓库中的设备
//提取库存详情中不同的码
List<String> codesList = invProductDetailEntities.stream().map(InvProductDetailEntity::getCode).distinct().collect(Collectors.toList());
//初始化所有码数量集合
Map<String, Integer> codeMap = new HashMap<>(codesList.size());
codesList.forEach(code -> codeMap.put(code, 0));
//计算库存详情中的码明细,得出所有存在于库存中的码
for (InvProductDetailEntity invProductDetailEntity : invProductDetailEntities) {
Integer count = codeMap.get(invProductDetailEntity.getCode());
if (invProductDetailEntity.getMainAction().equals(ConstantType.TYPE_PUT)) {
//入库,数量 +1
count = count + 1;
} else {
//出库, 数量 -1
count = count - 1;
}
codeMap.put(invProductDetailEntity.getCode(), count);
}
//根据计算得出的,所有存在于库存中的码明细,生成设备领用记录详情
for (String code : codeMap.keySet()) {
if (codeMap.get(code) > 0) {
//查找此条码对应的库存详情数据,根据此库存详情数据,查找仓库货位等信息
InvProductDetailEntity invProductDetailEntity = new InvProductDetailEntity();
for (InvProductDetailEntity detailEntity : invProductDetailEntities) {
if (detailEntity.getCode().equals(code)) {
invProductDetailEntity = detailEntity;
break;
}
}
//此条码存在于库存中,解析条码生成设备领用记录详情
Integer count = codeMap.get(code);
if (count > 1) {
for (int i = 0; i < count; i++) {
DeviceReceiveOrderDetailEntity orderDetail = getDeviceReceiveOrderDetailEntity(addDetailRequest.getOrderIdFk(), code, invProductDetailEntity);
//插入设备领用记录详情
deviceReceiveOrderDetailDao.insert(orderDetail);
}
} else {
DeviceReceiveOrderDetailEntity orderDetail = getDeviceReceiveOrderDetailEntity(addDetailRequest.getOrderIdFk(), code, invProductDetailEntity);
deviceReceiveOrderDetailDao.insert(orderDetail);
}
}
}
}
}
return ResultVOUtils.success("添加成功!");
return null;
// if (null == addDetailRequest || StrUtil.isBlank(addDetailRequest.getOrderIdFk())) {
// return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
// }
// if (StrUtil.isBlank(addDetailRequest.getCode()) && CollUtil.isEmpty(addDetailRequest.getInvProductIds())) {
// return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, "请添加领用设备!");
// }
// if (StrUtil.isNotBlank(addDetailRequest.getCode())) {
// //通过条码添加
// //解析此条码,判断此条码是否已经存在
// UdiEntity udi = FilterUdiUtils.getUdi(addDetailRequest.getCode());
// if (StrUtil.isNotBlank(udi.getSerialNo())) {
// //条码为完整码,查询此条码在当前领用记录中是否存在,如果存在则无法添加
// FilterDeviceReceiveOrderDetailRequest detailRequest = new FilterDeviceReceiveOrderDetailRequest();
// detailRequest.setOrderIdFk(addDetailRequest.getOrderIdFk());
// detailRequest.setCode(addDetailRequest.getCode());
// List<DeviceReceiveOrderDetailResponse> list = deviceReceiveOrderDetailDao.filterList(detailRequest);
// if (CollUtil.isNotEmpty(list)) {
// return ResultVOUtils.error(ResultEnum.DATA_REPEAT, "条码重复!");
// }
// }
//
// //设置库存详情查询参数
// FilterInvProductDetailRequest invProductDetailRequest = new FilterInvProductDetailRequest();
// invProductDetailRequest.setCode(addDetailRequest.getCode());
//
// //判断是否有选入的仓库信息,如果没有,说明此条码仅存在一条仓库信息,直接使用即可
// if (StrUtil.isNotBlank(addDetailRequest.getInvCode())) {
// invProductDetailRequest.setDeptCode(addDetailRequest.getDeptCode());
// invProductDetailRequest.setInvCode(addDetailRequest.getInvCode());
// invProductDetailRequest.setInvSpaceCode(addDetailRequest.getInvSpaceCode());
// }
// //查询库存详情
// List<InvProductNewVo> invProductDetailEntities = invProductNewDao.filterInvProductDetailList(invProductDetailRequest);
// InvProductNewVo invProductNewVo = invProductDetailEntities.get(0);
// DeviceReceiveOrderDetailEntity orderDetail = getDeviceReceiveOrderDetailEntity(addDetailRequest.getOrderIdFk(), addDetailRequest.getCode(), invProductNewVo);
// deviceReceiveOrderDetailDao.insert(orderDetail);
// } else {
// //通过选库存添加
// //查询选中的库存信息
// for (String invProductId : addDetailRequest.getInvProductIds()) {
// InvProductEntity invProductEntity = invProductDao.selectById(invProductId);
// //查询库存详情
// FilterInvProductDetailRequest filterInvProductDetailRequest = new FilterInvProductDetailRequest();
// filterInvProductDetailRequest.setRelId(String.valueOf(invProductEntity.getRelIdFk()));
// filterInvProductDetailRequest.setBatchNo(invProductEntity.getBatchNo());
// filterInvProductDetailRequest.setDeptCode(invProductEntity.getDeptCode());
// filterInvProductDetailRequest.setInvCode(invProductEntity.getInvCode());
// List<InvProductNewVo> invProductDetailEntities = invProductNewDao.filterInvProductDetailList(filterInvProductDetailRequest);
// //计算出在仓库中的设备
// //提取库存详情中不同的码
// List<String> codesList = invProductDetailEntities.stream().map(InvProductNewVo::getCode).distinct().collect(Collectors.toList());
// //初始化所有码数量集合
// Map<String, Integer> codeMap = new HashMap<>(codesList.size());
// codesList.forEach(code -> codeMap.put(code, 0));
// //计算库存详情中的码明细,得出所有存在于库存中的码
// for (InvProductNewVo invProductNewVo : invProductDetailEntities) {
// Integer count = codeMap.get(invProductNewVo.getCode());
// if (invProductNewVo.getMainAction().equals(ConstantType.TYPE_PUT)) {
// //入库,数量 +1
// count = count + 1;
// } else {
// //出库, 数量 -1
// count = count - 1;
// }
// codeMap.put(invProductNewVo.getCode(), count);
// }
//
// //根据计算得出的,所有存在于库存中的码明细,生成设备领用记录详情
// for (String code : codeMap.keySet()) {
// if (codeMap.get(code) > 0) {
// //查找此条码对应的库存详情数据,根据此库存详情数据,查找仓库货位等信息
// InvProductNewVo invProductNewVo = new InvProductNewVo();
// for (InvProductNewVo detailEntity : invProductDetailEntities) {
// if (detailEntity.getCode().equals(code)) {
// invProductNewVo = detailEntity;
// break;
// }
// }
//
// //此条码存在于库存中,解析条码生成设备领用记录详情
// Integer count = codeMap.get(code);
// if (count > 1) {
// for (int i = 0; i < count; i++) {
// DeviceReceiveOrderDetailEntity orderDetail = getDeviceReceiveOrderDetailEntity(addDetailRequest.getOrderIdFk(), code, invProductNewVo);
// //插入设备领用记录详情
// deviceReceiveOrderDetailDao.insert(orderDetail);
// }
// } else {
// DeviceReceiveOrderDetailEntity orderDetail = getDeviceReceiveOrderDetailEntity(addDetailRequest.getOrderIdFk(), code, invProductNewVo);
// deviceReceiveOrderDetailDao.insert(orderDetail);
// }
// }
// }
// }
// }
// return ResultVOUtils.success("添加成功!");
}
/**
@ -162,16 +163,16 @@ public class DeviceReceiveOrderDetailServiceImpl implements DeviceReceiveOrderDe
*
* @param orderIdFk
* @param code
* @param invProductDetailEntity
* @param invProductNewVo
* @return
*/
private static DeviceReceiveOrderDetailEntity getDeviceReceiveOrderDetailEntity(String orderIdFk, String code, InvProductDetailEntity invProductDetailEntity) {
private static DeviceReceiveOrderDetailEntity getDeviceReceiveOrderDetailEntity(String orderIdFk, String code, InvProductNewVo invProductNewVo) {
//此条码数量为多个,生成多条养护记录
UdiEntity udi = FilterUdiUtils.getUdi(code);
DeviceReceiveOrderDetailEntity orderDetail = new DeviceReceiveOrderDetailEntity();
orderDetail.setOrderIdFk(orderIdFk);
orderDetail.setOriginCode(code);
orderDetail.setRelId(invProductDetailEntity.getRelId());
orderDetail.setRelId(invProductNewVo.getRelIdFk());
orderDetail.setNameCode(udi.getUdi());
orderDetail.setBatchNo(udi.getBatchNo());
orderDetail.setProductionDate(udi.getProduceDate());
@ -227,7 +228,7 @@ public class DeviceReceiveOrderDetailServiceImpl implements DeviceReceiveOrderDe
//查询此条码是否在库存中存在
FilterInvProductDetailRequest filterInvProductDetailRequest = new FilterInvProductDetailRequest();
filterInvProductDetailRequest.setCode(code);
List<InvProductDetailEntity> invProductDetailEntities = invProductDetailDao.filterInvProductDetailList(filterInvProductDetailRequest);
List<InvProductNewVo> invProductDetailEntities = invProductNewDao.filterInvProductDetailList(filterInvProductDetailRequest);
if (CollUtil.isNotEmpty(invProductDetailEntities)) {
if (invProductDetailEntities.size() > 1) {
return ResultVOUtils.error(ResultEnum.DATA_REPEAT, "此设备记录存在于多个仓库,请选择此设备当前所处仓库!");

@ -22,7 +22,7 @@ import com.glxp.api.dao.inout.IoOrderDao;
import com.glxp.api.dao.inv.InvCountCodesDao;
import com.glxp.api.dao.inv.InvCountOrderDao;
import com.glxp.api.dao.inv.InvCountOrderDetailDao;
import com.glxp.api.dao.inv.InvProductDetailDao;
import com.glxp.api.dao.inv.InvProductNewDao;
import com.glxp.api.entity.auth.AuthAdmin;
import com.glxp.api.entity.basic.BasicBusTypeChangeEntity;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
@ -32,7 +32,7 @@ import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.entity.inv.InvCountCodesEntity;
import com.glxp.api.entity.inv.InvCountOrderDetailEntity;
import com.glxp.api.entity.inv.InvCountOrderEntity;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.vo.basic.InvProductNewVo;
import com.glxp.api.req.inv.*;
import com.glxp.api.res.inv.InvCountOrderResponse;
import com.glxp.api.service.auth.CustomerService;
@ -71,7 +71,7 @@ public class InvCountOrderServiceImpl implements InvCountOrderService {
@Resource
private CustomerService customerService;
@Resource
private InvProductDetailDao invProductDetailDao;
private InvProductNewDao invProductNewDao;
@Resource
private BasicBusTypeChangeDao busTypeChangeDao;
@Resource
@ -356,7 +356,7 @@ public class InvCountOrderServiceImpl implements InvCountOrderService {
}
return null;
}
//TODO 120241022 获取入库或出库的条码列表 要用code做逻辑处理
/**
*
*
@ -365,92 +365,93 @@ public class InvCountOrderServiceImpl implements InvCountOrderService {
* @return
*/
private List<IoCodeTempEntity> getOrderCodes(InvCountOrderEntity invCountOrder, String type) {
//构造库存详情查询参数
FilterInvProductDetailRequest invProductDetailRequest = new FilterInvProductDetailRequest();
invProductDetailRequest.setDeptCode(invCountOrder.getDeptCode());
invProductDetailRequest.setInvCode(invCountOrder.getInvCode());
//锁库存,查询库存更新时间早于或等于盘点单创建时间的数据
invProductDetailRequest.setUpdateTime(DateUtil.toDateStr(invCountOrder.getCreateTime(), "yyyy-MM-dd HH:mm:ss"));
//判断是否是按货位盘点的单据,如果是,则查询库存详情的参数需要添加货位
invProductDetailRequest.setInvSpaceCode(invCountOrder.getInvSpaceCode());
//查询盘点单据详情
FilterInvCountOrderDetailRequest countOrderDetailRequest = new FilterInvCountOrderDetailRequest();
countOrderDetailRequest.setOrderIdFk(invCountOrder.getOrderId());
countOrderDetailRequest.setStatus(type.equals("in") ? 1 : 0);
List<InvCountOrderDetailEntity> detailList = invCountOrderDetailDao.filterList(countOrderDetailRequest);
List<IoCodeTempEntity> codeList = new ArrayList<>();
//查找条码列表
if (type.equals("in")) {
log.info("开始生成盘盈单据码明细");
//查找盘盈条码列表
detailList.forEach(invCountOrderDetailEntity -> {
invProductDetailRequest.setRelId(String.valueOf(invCountOrderDetailEntity.getRelId()));
invProductDetailRequest.setBatchNo(invProductDetailRequest.getBatchNo());
List<InvProductDetailEntity> invProductDetailEntities = invProductDetailDao.filterInvProductDetailList(invProductDetailRequest);
//查询盘点码明细
FilterInvCountCodesRequest countCodesRequest = new FilterInvCountCodesRequest();
countCodesRequest.setOrderIdFk(invCountOrder.getOrderId());
countCodesRequest.setRelId(String.valueOf(invCountOrderDetailEntity.getRelId()));
countCodesRequest.setBatchNo(invCountOrderDetailEntity.getBatchNo());
List<String> countCodeList = invCountCodesDao.selectCodes(countCodesRequest);
List<String> invProductDetailCodes = invProductDetailEntities.stream().map(InvProductDetailEntity::getCode).collect(Collectors.toList());
List<String> profitCodes = CollUtil.subtractToList(countCodeList, invProductDetailCodes);
if (CollUtil.isNotEmpty(invProductDetailCodes) && CollUtil.isEmpty(profitCodes)) {
/**
*
*
*/
IoCodeTempEntity codeTempEntity = buildCodeTempEntity(invCountOrder, countCodeList.get(0), invCountOrderDetailEntity);
codeList.add(codeTempEntity);
} else {
for (String code : profitCodes) {
if (!verifyCodeExist(codeList, code)) {
//生成码明细
IoCodeTempEntity codeTempEntity = buildCodeTempEntity(invCountOrder, code, invCountOrderDetailEntity);
codeList.add(codeTempEntity);
}
}
}
});
log.info("盘盈单据码明细生成成功");
} else {
log.info("开始生成盘亏单据码明细");
detailList.forEach(invCountOrderDetailEntity -> {
invProductDetailRequest.setRelId(String.valueOf(invCountOrderDetailEntity.getRelId()));
invProductDetailRequest.setBatchNo(invCountOrderDetailEntity.getBatchNo());
//查询库存详情
List<InvProductDetailEntity> invProductDetailEntities = invProductDetailDao.filterInvProductDetailList(invProductDetailRequest);
//查询盘点码明细
FilterInvCountCodesRequest countCodesRequest = new FilterInvCountCodesRequest();
countCodesRequest.setOrderIdFk(invCountOrder.getOrderId());
countCodesRequest.setRelId(String.valueOf(invCountOrderDetailEntity.getRelId()));
countCodesRequest.setBatchNo(invCountOrderDetailEntity.getBatchNo());
List<String> countCodeList = invCountCodesDao.selectCodes(countCodesRequest);
List<String> invProductDetailCodes = invProductDetailEntities.stream().map(InvProductDetailEntity::getCode).collect(Collectors.toList());
List<String> lossCodes = CollUtil.subtractToList(invProductDetailCodes, countCodeList);
if (CollUtil.isNotEmpty(countCodeList) && CollUtil.isEmpty(lossCodes)) {
//盘点的码不为空,但是盘点数量和库存数量不一样,比对差集结果为空,说明是同一个条码,数量不同,直接根据盘亏数量计算生成一个扫码单据的码明细
//生成码详情
IoCodeTempEntity codeTempEntity = buildCodeTempEntity(invCountOrder, countCodeList.get(0), invCountOrderDetailEntity);
codeList.add(codeTempEntity);
} else {
for (InvProductDetailEntity invProductDetailEntity : invProductDetailEntities) {
if (!countCodeList.contains(invProductDetailEntity.getCode()) && !verifyCodeExist(codeList, invProductDetailEntity.getCode())) {
InvCountOrderDetailEntity orderDetailEntity = new InvCountOrderDetailEntity();
orderDetailEntity.setRelId(invCountOrderDetailEntity.getRelId());
orderDetailEntity.setStatus(0);
IoCodeTempEntity codeTempEntity = buildCodeTempEntity(invCountOrder, invProductDetailEntity.getCode(), orderDetailEntity);
codeList.add(codeTempEntity);
}
}
}
});
log.info("盘亏单据码名称生成成功");
}
return codeList;
return null;
// //构造库存详情查询参数
// FilterInvProductDetailRequest invProductDetailRequest = new FilterInvProductDetailRequest();
// invProductDetailRequest.setDeptCode(invCountOrder.getDeptCode());
// invProductDetailRequest.setInvCode(invCountOrder.getInvCode());
// //锁库存,查询库存更新时间早于或等于盘点单创建时间的数据
// invProductDetailRequest.setUpdateTime(DateUtil.toDateStr(invCountOrder.getCreateTime(), "yyyy-MM-dd HH:mm:ss"));
// //判断是否是按货位盘点的单据,如果是,则查询库存详情的参数需要添加货位
// invProductDetailRequest.setInvSpaceCode(invCountOrder.getInvSpaceCode());
//
// //查询盘点单据详情
// FilterInvCountOrderDetailRequest countOrderDetailRequest = new FilterInvCountOrderDetailRequest();
// countOrderDetailRequest.setOrderIdFk(invCountOrder.getOrderId());
// countOrderDetailRequest.setStatus(type.equals("in") ? 1 : 0);
// List<InvCountOrderDetailEntity> detailList = invCountOrderDetailDao.filterList(countOrderDetailRequest);
//
// List<IoCodeTempEntity> codeList = new ArrayList<>();
// //查找条码列表
// if (type.equals("in")) {
// log.info("开始生成盘盈单据码明细");
// //查找盘盈条码列表
// detailList.forEach(invCountOrderDetailEntity -> {
// invProductDetailRequest.setRelId(String.valueOf(invCountOrderDetailEntity.getRelId()));
// invProductDetailRequest.setBatchNo(invProductDetailRequest.getBatchNo());
// List<InvProductNewVo> invProductDetailEntities = invProductNewDao.filterInvProductDetailList(invProductDetailRequest);
// //查询盘点码明细
// FilterInvCountCodesRequest countCodesRequest = new FilterInvCountCodesRequest();
// countCodesRequest.setOrderIdFk(invCountOrder.getOrderId());
// countCodesRequest.setRelId(String.valueOf(invCountOrderDetailEntity.getRelId()));
// countCodesRequest.setBatchNo(invCountOrderDetailEntity.getBatchNo());
// List<String> countCodeList = invCountCodesDao.selectCodes(countCodesRequest);
// List<String> invProductDetailCodes = invProductDetailEntities.stream().map(InvProductNewVo::getCode).collect(Collectors.toList());
// List<String> profitCodes = CollUtil.subtractToList(countCodeList, invProductDetailCodes);
// if (CollUtil.isNotEmpty(invProductDetailCodes) && CollUtil.isEmpty(profitCodes)) {
// /**
// * 盘点条码不为空,且库存条码也不为空,但是计算的条码差集为空
// * 说明盘点的条码和库存的条码是相同的条码,直接根据盘盈数量计算出扫码数量,生成一个条码即可
// */
// IoCodeTempEntity codeTempEntity = buildCodeTempEntity(invCountOrder, countCodeList.get(0), invCountOrderDetailEntity);
// codeList.add(codeTempEntity);
// } else {
// for (String code : profitCodes) {
// if (!verifyCodeExist(codeList, code)) {
// //生成码明细
// IoCodeTempEntity codeTempEntity = buildCodeTempEntity(invCountOrder, code, invCountOrderDetailEntity);
// codeList.add(codeTempEntity);
// }
// }
// }
// });
// log.info("盘盈单据码明细生成成功");
// } else {
// log.info("开始生成盘亏单据码明细");
//
// detailList.forEach(invCountOrderDetailEntity -> {
// invProductDetailRequest.setRelId(String.valueOf(invCountOrderDetailEntity.getRelId()));
// invProductDetailRequest.setBatchNo(invCountOrderDetailEntity.getBatchNo());
// //查询库存详情
// List<InvProductNewVo> invProductDetailEntities = invProductNewDao.filterInvProductDetailList(invProductDetailRequest);
// //查询盘点码明细
// FilterInvCountCodesRequest countCodesRequest = new FilterInvCountCodesRequest();
// countCodesRequest.setOrderIdFk(invCountOrder.getOrderId());
// countCodesRequest.setRelId(String.valueOf(invCountOrderDetailEntity.getRelId()));
// countCodesRequest.setBatchNo(invCountOrderDetailEntity.getBatchNo());
// List<String> countCodeList = invCountCodesDao.selectCodes(countCodesRequest);
// List<String> invProductDetailCodes = invProductDetailEntities.stream().map(InvProductNewVo::getCode).collect(Collectors.toList());
// List<String> lossCodes = CollUtil.subtractToList(invProductDetailCodes, countCodeList);
// if (CollUtil.isNotEmpty(countCodeList) && CollUtil.isEmpty(lossCodes)) {
// //盘点的码不为空,但是盘点数量和库存数量不一样,比对差集结果为空,说明是同一个条码,数量不同,直接根据盘亏数量计算生成一个扫码单据的码明细
// //生成码详情
// IoCodeTempEntity codeTempEntity = buildCodeTempEntity(invCountOrder, countCodeList.get(0), invCountOrderDetailEntity);
// codeList.add(codeTempEntity);
// } else {
// for (InvProductNewVo invProductNewVo : invProductDetailEntities) {
// if (!countCodeList.contains(invProductNewVo.getCode()) && !verifyCodeExist(codeList, invProductNewVo.getCode())) {
// InvCountOrderDetailEntity orderDetailEntity = new InvCountOrderDetailEntity();
// orderDetailEntity.setRelId(invCountOrderDetailEntity.getRelId());
// orderDetailEntity.setStatus(0);
// IoCodeTempEntity codeTempEntity = buildCodeTempEntity(invCountOrder, invProductNewVo.getCode(), orderDetailEntity);
// codeList.add(codeTempEntity);
// }
// }
// }
// });
// log.info("盘亏单据码名称生成成功");
// }
// return codeList;
}
/**
@ -526,7 +527,7 @@ public class InvCountOrderServiceImpl implements InvCountOrderService {
*/
if (countStatus.equals("loss")) {
log.info("生成盘亏单据条码供应商信息,条码信息:{}", codeTemp.getCode());
List<String> supIds = invProductDetailDao.selectSupIdByCode(codeTemp.getCode());
List<String> supIds = invProductNewDao.selectSupIdByCode(codeTemp.getCode());
if (CollUtil.isNotEmpty(supIds) && supIds.size() == 1) {
//此产品在库存中存在且只绑定了一个供应商若绑定了多个供应商则不填供应商ID字段生成单据之后会进入异常单据页面由操作人员手动指定供应商
codeTemp.setSupId(supIds.get(0));

@ -17,6 +17,7 @@ import com.glxp.api.req.inv.FilterInvProductDetailRequest;
import com.glxp.api.res.inv.InvMAOrderDetailResponse;
import com.glxp.api.service.inv.InvMAOrderDetailService;
import com.glxp.api.util.udi.FilterUdiUtils;
import com.glxp.api.vo.basic.InvProductNewVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@ -35,7 +36,7 @@ public class InvMAOrderDetailServiceImpl implements InvMAOrderDetailService {
@Resource
private InvMAOrderDao invMAOrderDao;
@Resource
private InvProductDetailDao invProductDetailDao;
private InvProductNewDao invProductNewDao;
@Resource
private InvProductDao invProductDao;
@Resource
@ -88,7 +89,7 @@ public class InvMAOrderDetailServiceImpl implements InvMAOrderDetailService {
filterInvProductDetailRequest.setInvSpaceCode(maOrder.getInvSpaceCode());
filterInvProductDetailRequest.setProductionDate(udi.getProduceDate());
filterInvProductDetailRequest.setExpireDate(udi.getExpireDate());
List<InvProductDetailEntity> invProductDetailEntities = invProductDetailDao.filterInvProductDetailList(filterInvProductDetailRequest);
List<InvProductNewVo> invProductDetailEntities = invProductNewDao.filterInvProductDetailList(filterInvProductDetailRequest);
if (CollUtil.isNotEmpty(invProductDetailEntities)) {
log.info("库存中存在,添加到库存养护记录详情中");
//设置养护状态为未养护
@ -100,7 +101,7 @@ public class InvMAOrderDetailServiceImpl implements InvMAOrderDetailService {
invMAOrderDetailEntity.setProductionDate(udi.getProduceDate());
invMAOrderDetailEntity.setExpireDate(udi.getExpireDate());
invMAOrderDetailEntity.setNameCode(udi.getUdi());
invMAOrderDetailEntity.setRelId(invProductDetailEntities.get(0).getRelId());
invMAOrderDetailEntity.setRelId(invProductDetailEntities.get(0).getRelIdFk());
if (null != invMAExplanationEntity) {
invMAOrderDetailEntity.setRemark(invMAExplanationEntity.getText());
}
@ -126,81 +127,81 @@ public class InvMAOrderDetailServiceImpl implements InvMAOrderDetailService {
return ResultVOUtils.success();
}
@Override
public BaseResponse batchAddDetail(AddInvMAOrderDetailRequest addMAOrderDetailRequest) {
//查询库存养护记录说明
InvMAExplanationEntity invMAExplanationEntity = invMAExplanationDao.selectByStatus(1);
//遍历库存ID查找库存详情的条码信息生成库存养护记录详情
addMAOrderDetailRequest.getInvProductIds().forEach(invProductId -> {
//查询库存信息
InvProductEntity invProductEntity = invProductDao.selectById(invProductId);
//查询库存详情码信息
FilterInvProductDetailRequest detailRequest = new FilterInvProductDetailRequest();
detailRequest.setRelId(String.valueOf(invProductEntity.getRelIdFk()));
detailRequest.setBatchNo(invProductEntity.getBatchNo());
detailRequest.setDeptCode(invProductEntity.getDeptCode());
detailRequest.setInvCode(invProductEntity.getInvCode());
List<InvProductDetailEntity> invProductDetailEntities = invProductDetailDao.filterInvProductDetailList(detailRequest);
//提取去重后的码集合
List<String> codeList = invProductDetailEntities.stream().map(InvProductDetailEntity::getCode).distinct().collect(Collectors.toList());
//初始化码数量计算集合数据
Map<String, Integer> codeMap = new HashMap<>(codeList.size());
codeList.forEach(code -> codeMap.put(code, 0));
//计算当前在库存中的码明细
for (InvProductDetailEntity invProductDetailEntity : invProductDetailEntities) {
UdiEntity udi = FilterUdiUtils.getUdi(invProductDetailEntity.getCode());
if (StrUtil.isNotBlank(udi.getSerialNo())) {
//有序列号产品,根据产品数量计算即可
Integer count = codeMap.get(invProductDetailEntity.getCode());
if (invProductDetailEntity.getMainAction().equals(ConstantType.TYPE_OUT)) {
//出库
count = count - 1;
} else {
//入库
count = count + 1;
}
codeMap.put(invProductDetailEntity.getCode(), count);
} else {
//无序列号产品条码,直接查询库存,使用此库存信息计算出养护数量
int count = invProductEntity.getInCount() - invProductEntity.getOutCount();
codeMap.put(invProductDetailEntity.getCode(), count);
}
}
//根据库存中的码明细,生成库存养护记录详情
for (String code : codeMap.keySet()) {
if (codeMap.get(code) > 0) {
//获取库存详情
InvProductDetailEntity invProductDetailEntity = null;
for (InvProductDetailEntity detailEntity : invProductDetailEntities) {
if (detailEntity.getCode().equals(code)) {
invProductDetailEntity = detailEntity;
break;
}
}
//生成库存养护记录详情
InvMAOrderDetailEntity maOrderDetail = new InvMAOrderDetailEntity();
maOrderDetail.setOrderIdFk(addMAOrderDetailRequest.getOrderIdFk());
maOrderDetail.setCode(invProductDetailEntity.getCode());
maOrderDetail.setRelId(invProductDetailEntity.getRelId());
UdiEntity udi = FilterUdiUtils.getUdi(invProductDetailEntity.getCode());
maOrderDetail.setNameCode(udi.getUdi());
maOrderDetail.setProductionDate(udi.getProduceDate());
maOrderDetail.setExpireDate(udi.getExpireDate());
maOrderDetail.setBatchNo(udi.getBatchNo());
maOrderDetail.setCount(codeMap.get(code));
maOrderDetail.setMaStatus(0);
maOrderDetail.setDeviceStatus(1);
maOrderDetail.setCreateTime(new Date());
if (null != invMAExplanationEntity) {
maOrderDetail.setRemark(invMAExplanationEntity.getText());
}
invMAOrderDetailDao.insert(maOrderDetail);
}
}
});
return ResultVOUtils.success("添加成功");
}
// @Override
// public BaseResponse batchAddDetail(AddInvMAOrderDetailRequest addMAOrderDetailRequest) {
// //查询库存养护记录说明
// InvMAExplanationEntity invMAExplanationEntity = invMAExplanationDao.selectByStatus(1);
// //遍历库存ID查找库存详情的条码信息生成库存养护记录详情
// addMAOrderDetailRequest.getInvProductIds().forEach(invProductId -> {
// //查询库存信息
// InvProductEntity invProductEntity = invProductDao.selectById(invProductId);
// //查询库存详情码信息
// FilterInvProductDetailRequest detailRequest = new FilterInvProductDetailRequest();
// detailRequest.setRelId(String.valueOf(invProductEntity.getRelIdFk()));
// detailRequest.setBatchNo(invProductEntity.getBatchNo());
// detailRequest.setDeptCode(invProductEntity.getDeptCode());
// detailRequest.setInvCode(invProductEntity.getInvCode());
// List<InvProductNewVo> invProductDetailEntities = invProductNewDao.filterInvProductDetailList(detailRequest);
// //提取去重后的码集合
// List<String> codeList = invProductDetailEntities.stream().map(InvProductNewVo::getCode).distinct().collect(Collectors.toList());
// //初始化码数量计算集合数据
// Map<String, Integer> codeMap = new HashMap<>(codeList.size());
// codeList.forEach(code -> codeMap.put(code, 0));
// //计算当前在库存中的码明细
// for (InvProductNewVo invProductNewVo : invProductDetailEntities) {
// UdiEntity udi = FilterUdiUtils.getUdi(invProductNewVo.getCode());
// if (StrUtil.isNotBlank(udi.getSerialNo())) {
// //有序列号产品,根据产品数量计算即可
// Integer count = codeMap.get(invProductNewVo.getCode());
// if (invProductNewVo.getMainAction().equals(ConstantType.TYPE_OUT)) {
// //出库
// count = count - 1;
// } else {
// //入库
// count = count + 1;
// }
// codeMap.put(invProductNewVo.getCode(), count);
// } else {
// //无序列号产品条码,直接查询库存,使用此库存信息计算出养护数量
// int count = invProductEntity.getInCount() - invProductEntity.getOutCount();
// codeMap.put(invProductNewVo.getCode(), count);
// }
// }
//
// //根据库存中的码明细,生成库存养护记录详情
// for (String code : codeMap.keySet()) {
// if (codeMap.get(code) > 0) {
// //获取库存详情
// InvProductNewVo invProductNewVo = null;
// for (InvProductNewVo detailEntity : invProductDetailEntities) {
// if (detailEntity.getCode().equals(code)) {
// invProductNewVo = detailEntity;
// break;
// }
// }
// //生成库存养护记录详情
// InvMAOrderDetailEntity maOrderDetail = new InvMAOrderDetailEntity();
// maOrderDetail.setOrderIdFk(addMAOrderDetailRequest.getOrderIdFk());
// maOrderDetail.setCode(invProductNewVo.getCode());
// maOrderDetail.setRelId(invProductNewVo.getRelId());
// UdiEntity udi = FilterUdiUtils.getUdi(invProductNewVo.getCode());
// maOrderDetail.setNameCode(udi.getUdi());
// maOrderDetail.setProductionDate(udi.getProduceDate());
// maOrderDetail.setExpireDate(udi.getExpireDate());
// maOrderDetail.setBatchNo(udi.getBatchNo());
// maOrderDetail.setCount(codeMap.get(code));
// maOrderDetail.setMaStatus(0);
// maOrderDetail.setDeviceStatus(1);
// maOrderDetail.setCreateTime(new Date());
// if (null != invMAExplanationEntity) {
// maOrderDetail.setRemark(invMAExplanationEntity.getText());
// }
// invMAOrderDetailDao.insert(maOrderDetail);
// }
// }
// });
// return ResultVOUtils.success("添加成功");
// }
@Override
public BaseResponse update(InvMAOrderDetailEntity invMAOrderDetailEntity) {

@ -9,8 +9,8 @@ import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.common.util.ResultVOUtils;
import com.glxp.api.dao.auth.InvSpaceDao;
import com.glxp.api.dao.auth.InvWarehouseDao;
import com.glxp.api.dao.inv.InvProductDetailDao;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.dao.inv.InvProductNewDao;
import com.glxp.api.vo.basic.InvProductNewVo;
import com.glxp.api.req.inv.FilterInvPlaceRequest;
import com.glxp.api.res.inv.BindInvSpaceRequest;
import com.glxp.api.res.inv.InvPlaceDetailResponse;
@ -30,7 +30,7 @@ import java.util.stream.Collectors;
public class InvPlaceServiceImpl implements InvPlaceService {
@Resource
private InvProductDetailDao invProductDetailDao;
private InvProductNewDao invProductNewDao;
@Resource
private InvWarehouseDao invWarehouseDao;
@Resource
@ -44,23 +44,23 @@ public class InvPlaceServiceImpl implements InvPlaceService {
if (null != filterInvPlaceRequest.getPage() && null != filterInvPlaceRequest.getLimit()) {
PageHelper.offsetPage((filterInvPlaceRequest.getPage() - 1) * filterInvPlaceRequest.getLimit(), filterInvPlaceRequest.getLimit());
}
return invProductDetailDao.selectPlaceDetailList(filterInvPlaceRequest);
return invProductNewDao.selectPlaceDetailList(filterInvPlaceRequest);
}
@Override
public void bindInvSpace(BindInvSpaceRequest bindInvSpaceRequest) {
//查询仓库的部门ID
String deptCode = invWarehouseDao.selectParentIdByCode(bindInvSpaceRequest.getInvCode());
List<InvProductDetailEntity> list = invProductDetailDao.selectList(new QueryWrapper<InvProductDetailEntity>()
List<InvProductNewVo> list = invProductNewDao.selectList(new QueryWrapper<InvProductNewVo>()
.select("id")
.eq("deptCode", deptCode)
.eq("invCode", bindInvSpaceRequest.getInvCode())
.in("code", bindInvSpaceRequest.getCodeArray())
);
if (CollUtil.isNotEmpty(list)) {
List<Integer> ids = list.stream().map(InvProductDetailEntity::getId).collect(Collectors.toList());
List<Integer> ids = list.stream().map(InvProductNewVo::getId).collect(Collectors.toList());
log.info("本次绑定货位的库存详情数量为:{} 条", ids.size());
invProductDetailDao.batchBindSpace(ids, bindInvSpaceRequest.getInvSpaceCode());
invProductNewDao.batchBindSpace(ids, bindInvSpaceRequest.getInvSpaceCode());
} else {
log.info("绑定货位列表查询无数据");
}
@ -72,12 +72,12 @@ public class InvPlaceServiceImpl implements InvPlaceService {
String deptCode = invWarehouseDao.selectParentIdByCode(bindInvSpaceRequest.getInvCode());
bindInvSpaceRequest.setDeptCode(deptCode);
//查询此库存详情的信息
InvProductDetailEntity invProductDetailEntity = invProductDetailDao.selectByInvAndCode(bindInvSpaceRequest);
if (null == invProductDetailEntity) {
InvProductNewVo invProductNewVo = invProductNewDao.selectByInvAndCode(bindInvSpaceRequest);
if (null == invProductNewVo) {
return ResultVOUtils.error(ResultEnum.DATA_ERROR, "此货物非当前仓库物品,无法绑定货位");
}
if (StrUtil.isNotBlank(invProductDetailEntity.getInvSpaceCode()) && !bindInvSpaceRequest.getInvSpaceCode().equals(invProductDetailEntity.getInvSpaceCode())) {
String invSpaceName = invSpaceDao.selectNameByCode(invProductDetailEntity.getDeptCode(), invProductDetailEntity.getInvCode(), invProductDetailEntity.getInvSpaceCode());
if (StrUtil.isNotBlank(invProductNewVo.getInvSpaceCode()) && !bindInvSpaceRequest.getInvSpaceCode().equals(invProductNewVo.getInvSpaceCode())) {
String invSpaceName = invSpaceDao.selectNameByCode(invProductNewVo.getDeptCode(), invProductNewVo.getInvCode(), invProductNewVo.getInvSpaceCode());
return ResultVOUtils.error(ResultEnum.DATA_REPEAT, "此货物已绑定 " + invSpaceName + " 货位,是否重新绑定?");
}
return ResultVOUtils.success();

@ -12,12 +12,9 @@ import com.glxp.api.dao.inout.IoOrderDao;
import com.glxp.api.dao.inv.InvPreProductDetailDao;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.entity.inv.InvPreInProductDetailEntity;
import com.glxp.api.entity.inv.InvPreProductDetailEntity;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.req.inv.FilterInvPreProductDetailRequest;
import com.glxp.api.req.inv.FilterInvProductDetailRequest;
import com.glxp.api.req.system.DeleteRequest;
import com.glxp.api.res.inv.InvPreProductDetailResponse;
import com.glxp.api.service.inv.InvPreProductDetailService;
import com.glxp.api.util.DateUtil;

@ -6,19 +6,10 @@ import com.github.pagehelper.PageHelper;
import com.glxp.api.constant.ConstantStatus;
import com.glxp.api.constant.ConstantType;
import com.glxp.api.dao.inv.InvPreinDetailDao;
import com.glxp.api.dao.inv.InvPreinOrderDao;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.entity.inv.InvPreProductDetailEntity;
import com.glxp.api.entity.inv.InvPreinDetailEntity;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.req.inv.FilterInvPreProductDetailRequest;
import com.glxp.api.req.inv.FilterInvPreinDetailRequest;
import com.glxp.api.req.inv.FilterInvPreinProductRequest;
import com.glxp.api.res.inv.InvPreProductDetailResponse;
import com.glxp.api.res.inv.InvPreinDetailResponse;
import com.glxp.api.service.inv.InvPreinDetailService;
import com.glxp.api.util.DateUtil;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@ -1,180 +0,0 @@
package com.glxp.api.service.inv.impl;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.PageHelper;
import com.glxp.api.constant.ConstantType;
import com.glxp.api.dao.basic.BasicBussinessTypeDao;
import com.glxp.api.dao.basic.UdiProductDao;
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.util.DateUtil;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.List;
@Service
@Transactional(rollbackFor = Exception.class)
public class InvProductDetailService extends ServiceImpl<InvProductDetailDao, InvProductDetailEntity> {
@Resource
private InvProductDetailDao invProductDetailDao;
@Resource
private BasicBussinessTypeDao bussinessTypeDao;
@Resource
private IoOrderDao orderDao;
@Resource
private UdiProductDao udiProductDao;
public int insert(InvProductDetailEntity invProductDetailEntity) {
invProductDetailEntity.setId(null);
if (invProductDetailEntity.getMainAction().equals(ConstantType.TYPE_PUT)) {
invProductDetailEntity.setInCount(invProductDetailEntity.getReCount());
} else if (invProductDetailEntity.getMainAction().equals(ConstantType.TYPE_OUT)) {
invProductDetailEntity.setOutCount(invProductDetailEntity.getReCount());
}
return invProductDetailDao.insert(invProductDetailEntity);
}
public List<InvProductDetailEntity> selectByOrderIdFk(String billNo) {
if (StrUtil.isEmpty(billNo))
return null;
List<InvProductDetailEntity> invProductDetailEntities = invProductDetailDao.selectList(new QueryWrapper<InvProductDetailEntity>().eq("orderId", billNo));
return invProductDetailEntities;
}
public InvProductDetailEntity selectByCode(String billNo, String code) {
List<InvProductDetailEntity> invProductDetailEntities = invProductDetailDao.selectList
(new QueryWrapper<InvProductDetailEntity>().eq("code", code).eq("orderId", billNo));
if (CollUtil.isNotEmpty(invProductDetailEntities))
return invProductDetailEntities.get(0);
else
return null;
}
public int deleteByOrderId(String billNo) {
return invProductDetailDao.delete(new QueryWrapper<InvProductDetailEntity>().eq("orderId", billNo));
}
public int deleteById(Integer id) {
return invProductDetailDao.deleteById(id);
}
public int update(InvProductDetailEntity invProductDetailEntity) {
if (invProductDetailEntity.getMainAction().equals(ConstantType.TYPE_PUT)) {
invProductDetailEntity.setInCount(invProductDetailEntity.getReCount());
} else if (invProductDetailEntity.getMainAction().equals(ConstantType.TYPE_OUT)) {
invProductDetailEntity.setOutCount(invProductDetailEntity.getReCount());
}
return invProductDetailDao.updateById(invProductDetailEntity);
}
public List<InvProductDetailEntity> selectByUnique(Long relId, String batchNo, String supId, String deptCode, String invCode) {
return invProductDetailDao.selectList(new QueryWrapper<InvProductDetailEntity>().eq("relId", relId).eq(StrUtil.isNotEmpty(batchNo), "batchNo", batchNo)
.isNull(StrUtil.isEmpty(batchNo), "batchNo").eq("supId", supId).eq("deptCode", deptCode).eq("invCode", invCode));
}
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;
}
public boolean insertList(List<InvProductDetailEntity> invProductDetailEntities) {
return invProductDetailDao.insertBatch(invProductDetailEntities);
}
public List<InvProductDetailEntity> filterInvProductDetailList(FilterInvProductDetailRequest filterInvProductDetailRequest) {
if (null == filterInvProductDetailRequest) {
return Collections.emptyList();
}
if (null != filterInvProductDetailRequest.getPage() && null != filterInvProductDetailRequest.getLimit()) {
PageHelper.offsetPage((filterInvProductDetailRequest.getPage() - 1) * filterInvProductDetailRequest.getLimit(), filterInvProductDetailRequest.getLimit());
}
return invProductDetailDao.filterInvProductDetailList(filterInvProductDetailRequest);
}
public boolean deleteInvProductDetail(FilterInvProductDetailRequest detailRequest) {
return invProductDetailDao.deleteInvProductDetail(detailRequest);
}
public void setOrderInfo(InvProductDetailResponse response) {
//查询DI层级根据DI层级设置数量取值
Integer packLevel = udiProductDao.selectPackLevel(response.getNameCode());
//设置出入库中文及出入库数量
if (null != packLevel && packLevel != 1) {
//多级包装
if (response.getMainAction().equals(ConstantType.TYPE_OUT)) {
response.setMainActionStr("出库");
response.setOutCount(response.getReCount());
} else {
response.setMainActionStr("入库");
response.setInCount(response.getReCount());
}
} else {
//单层包装
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()));
if (busType != null)
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"));
}
public int vailStockCount(Long relId, String batchNo, String supId, String deptCode, String invCode, String invSpaceCode) {
if (relId == null) {
return 0;
}
List<InvProductDetailEntity> datas =
invProductDetailDao.selectList(new QueryWrapper<InvProductDetailEntity>().eq("relId", relId).eq(StrUtil.isNotEmpty(batchNo), "batchNo", batchNo)
.isNull(StrUtil.isEmpty(batchNo), "batchNo").eq(StrUtil.isNotEmpty(supId), "supId", supId).eq("deptCode", deptCode).eq("invCode", invCode).eq(StrUtil.isNotEmpty(invSpaceCode), "invSpaceCode", invSpaceCode));
int count = 0;
if (CollUtil.isNotEmpty(datas)) {
for (InvProductDetailEntity invProductDetailEntity : datas) {
if (invProductDetailEntity.getMainAction().equals(ConstantType.TYPE_PUT))
count = count + invProductDetailEntity.getReCount();
else {
count = count - invProductDetailEntity.getReCount();
}
}
}
return count;
}
}

@ -0,0 +1,307 @@
package com.glxp.api.service.inv.impl;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.PageHelper;
import com.glxp.api.constant.ConstantType;
import com.glxp.api.dao.basic.BasicBussinessTypeDao;
import com.glxp.api.dao.basic.UdiProductDao;
import com.glxp.api.dao.inout.IoOrderDao;
import com.glxp.api.dao.inout.IoOrderDetailBizDao;
import com.glxp.api.dao.inv.InvPreInProductDetailDao;
import com.glxp.api.dao.inv.InvPreProductDetailDao;
import com.glxp.api.dao.inv.InvProductDao;
import com.glxp.api.dao.inv.InvProductNewDao;
import com.glxp.api.entity.auth.InvSpace;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.inout.IoOrderDetailBizEntity;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.entity.inv.InvProductEntity;
import com.glxp.api.req.inv.FilterInvProductDetailRequest;
import com.glxp.api.res.inv.InvPlaceDetailResponse;
import com.glxp.api.res.inv.InvProductDetailResponse;
import com.glxp.api.service.auth.InvSpaceService;
import com.glxp.api.util.IntUtil;
import com.glxp.api.util.MsDateUtil;
import com.glxp.api.vo.basic.InvProductNewVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.Collections;
import java.util.List;
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class InvProductServiceNew extends ServiceImpl<InvProductNewDao, InvProductNewVo> {
@Resource
private InvProductNewDao invProductNewDao;
@Resource
private BasicBussinessTypeDao bussinessTypeDao;
@Resource
private IoOrderDao orderDao;
@Resource
private UdiProductDao udiProductDao;
// public int insert(InvProductNewVo InvProductNewVo) {
// InvProductNewVo.setId(null);
// if (InvProductNewVo.getMainAction().equals(ConstantType.TYPE_PUT)) {
// InvProductNewVo.setInCount(InvProductNewVo.getReCount());
// } else if (InvProductNewVo.getMainAction().equals(ConstantType.TYPE_OUT)) {
// InvProductNewVo.setOutCount(InvProductNewVo.getReCount());
// }
// return invProductNewDao.insert(InvProductNewVo);
// }
public List<InvProductNewVo> selectByOrderIdFk(String billNo) {
if (StrUtil.isEmpty(billNo))
return null;
List<InvProductNewVo> invProductDetailEntities = invProductNewDao.selectOrderInfo(billNo,null);
return invProductDetailEntities;
}
public InvProductNewVo selectByCode(String billNo, String code, BigDecimal price) {
List<InvProductNewVo> invProductDetailEntities = invProductNewDao.selectOrderInfo(billNo,price);
if (CollUtil.isNotEmpty(invProductDetailEntities)) {
for (InvProductNewVo InvProductNewVo : invProductDetailEntities) {
if (IntUtil.value(InvProductNewVo.getReCount()) > 0) {
return InvProductNewVo;
}
}
return invProductDetailEntities.get(0);
} else
return null;
}
//
// public int deleteByOrderId(String billNo) {
// return invProductNewDao.delete(new QueryWrapper<InvProductNewVo>().eq("orderId", billNo));
// }
// public int deleteById(Integer id) {
// return invProductNewDao.deleteById(id);
// }
//
//
// public int update(InvProductNewVo InvProductNewVo) {
//
// if (InvProductNewVo.getMainAction().equals(ConstantType.TYPE_PUT)) {
// InvProductNewVo.setInCount(InvProductNewVo.getReCount());
// } else if (InvProductNewVo.getMainAction().equals(ConstantType.TYPE_OUT)) {
// InvProductNewVo.setOutCount(InvProductNewVo.getReCount());
// }
//
// return invProductNewDao.updateById(InvProductNewVo);
// }
public List<InvProductNewVo> selectByUnique(Long relId, String batchNo, String supId, String deptCode, String invCode) {
return invProductNewDao.selectList(new QueryWrapper<InvProductNewVo>().eq("relId", relId).eq(StrUtil.isNotEmpty(batchNo), "batchNo", batchNo)
.isNull(StrUtil.isEmpty(batchNo), "batchNo").eq(supId != null, "supId", supId).eq(deptCode != null, "deptCode", deptCode).eq(invCode != null, "invCode", invCode));
}
//TODO 120241022 之前是code去查库存详情 现在没有码了先注释逻辑 看下引用的地方要不要注释了
public InvProductNewVo sortFindByCode(String code) {
return null;
// List<InvProductNewVo> invProductDetailEntities = invProductNewDao.selectList(new QueryWrapper<InvProductNewVo>().eq("code", code).orderByDesc("id"));
// if (CollUtil.isNotEmpty(invProductDetailEntities))
// return invProductDetailEntities.get(0);
// else
// return null;
}
// public boolean insertList(List<InvProductNewVo> invProductDetailEntities) {
// return invProductNewDao.insertBatch(invProductDetailEntities);
// }
public List<InvProductNewVo> filterInvProductDetailList(FilterInvProductDetailRequest filterInvProductDetailRequest) {
if (null == filterInvProductDetailRequest) {
return Collections.emptyList();
}
if (null != filterInvProductDetailRequest.getPage() && null != filterInvProductDetailRequest.getLimit()) {
PageHelper.offsetPage((filterInvProductDetailRequest.getPage() - 1) * filterInvProductDetailRequest.getLimit(), filterInvProductDetailRequest.getLimit());
}
return invProductNewDao.filterInvProductDetailList(filterInvProductDetailRequest);
}
// public boolean deleteInvProductDetail(FilterInvProductDetailRequest detailRequest) {
// return invProductNewDao.deleteInvProductDetail(detailRequest);
// }
@Resource
InvSpaceService invSpaceService;
public void setOrderInfo(InvProductDetailResponse response) {
//查询DI层级根据DI层级设置数量取值
Integer packLevel = udiProductDao.selectPackLevel(response.getNameCode());
//设置出入库中文及出入库数量
if (null != packLevel && packLevel != 1) {
//多级包装
if (response.getMainAction().equals(ConstantType.TYPE_OUT)) {
response.setMainActionStr("出库");
response.setOutCount(response.getReCount());
} else {
response.setMainActionStr("入库");
response.setInCount(response.getReCount());
}
} else {
//单层包装
if (response.getMainAction().equals(ConstantType.TYPE_OUT)) {
response.setMainActionStr("出库");
response.setOutCount(response.getCount());
} else {
response.setMainActionStr("入库");
response.setInCount(response.getCount());
}
}
InvSpace invSpace = invSpaceService.findByCode(response.getInvCode(), response.getInvSpaceCode());
if (invSpace != null)
response.setInvSpaceName(invSpace.getName());
//设置单据类型名称
BasicBussinessTypeEntity busType = bussinessTypeDao.selectOne(new QueryWrapper<BasicBussinessTypeEntity>().select("name").eq("action", response.getAction()));
if (busType != null)
response.setActionName(busType.getName());
//设置单据日期
IoOrderEntity order = orderDao.selectOne(new QueryWrapper<IoOrderEntity>().select("createTime").eq("billNo", response.getOrderId()));
if (order != null)
response.setOrderTime(MsDateUtil.toDateStr(order.getCreateTime(), "yyyy-MM-dd HH:mm:ss"));
}
/**
*
*/
public int vailStockCount(Long relId, String batchNo, String supId, String deptCode, String invCode, String invSpaceCode, Boolean vailBatchNo) {
if (relId == null) {
return 0;
}
List<InvProductNewVo> datas = null;
if (vailBatchNo || StrUtil.isNotEmpty(batchNo)) {
datas =
invProductNewDao.selectList(new QueryWrapper<InvProductNewVo>().eq("relIdFk", relId).eq(StrUtil.isNotEmpty(batchNo), "batchNo", batchNo)
.eq(StrUtil.isNotEmpty(supId), "supId", supId).eq(StrUtil.isNotEmpty(deptCode), "deptCode", deptCode).eq("invCode", invCode)
.eq(StrUtil.isNotEmpty(invSpaceCode), "invSpaceCode", invSpaceCode)
.and(StrUtil.isEmpty(batchNo), i -> i.isNull("batchNo").or().eq("batchNo", ""))
);
} else {
datas =
invProductNewDao.selectList(new QueryWrapper<InvProductNewVo>().eq("relIdFk", relId)
.eq(StrUtil.isNotEmpty(supId), "supId", supId).eq(StrUtil.isNotEmpty(deptCode), "deptCode", deptCode).eq("invCode", invCode)
.eq(StrUtil.isNotEmpty(invSpaceCode), "invSpaceCode", invSpaceCode)
);
}
log.error("校验入账库存日志打印:" + relId + "," + batchNo + "," + supId + "," + deptCode + "," + invCode + "," + invSpaceCode);
// 因为直接用库存表了 不需要做入库和出库的清算了 直接获取reCount
int count = 0;
if (CollUtil.isNotEmpty(datas)) {
for (InvProductNewVo invProductNewVo : datas) {
count += invProductNewVo.getReCount();
// if (invProductEntity.getMainAction().equals(ConstantType.TYPE_PUT))
// count = count + invProductEntity.getReCount();
// else {
// count = count - invProductEntity.getReCount();
// }
}
}
return count;
}
// public int vailStockCountByCode(String deptCode, String invCode, String invSpaceCode, String code) {
// List<InvProductNewVo> datas =
// invProductNewDao.selectList(new QueryWrapper<InvProductNewVo>().eq("deptCode", deptCode).eq("invCode", invCode)
// .eq(StrUtil.isNotEmpty(invSpaceCode), "invSpaceCode", invSpaceCode)
// .eq("code", code)
// );
//
// int count = 0;
// if (CollUtil.isNotEmpty(datas)) {
// for (InvProductNewVo InvProductNewVo : datas) {
// if (InvProductNewVo.getMainAction().equals(ConstantType.TYPE_PUT))
// count = count + InvProductNewVo.getReCount();
// else {
// count = count - InvProductNewVo.getReCount();
// }
// }
// }
// return count;
// }
public List<InvPlaceDetailResponse> findByGroupCode(String invCode, String code, Boolean isCheckSpace) {
if (StrUtil.isNotEmpty(invCode) && StrUtil.isNotEmpty(code)) {
List<InvPlaceDetailResponse> datas =
invProductNewDao.findByGroupCode(invCode, code, isCheckSpace);
return datas;
}
return null;
}
@Resource
InvPreInProductDetailDao invPreInProductDetailDao;
@Resource
InvPreProductDetailDao invPreProductDetailDao;
public InvProductNewVo selectLastInBatch(BasicBussinessTypeEntity bussinessTypeEntity, String relId, String batchNo, String invCode, String mainAction) {
if (bussinessTypeEntity.isScanPreIn()) { //校验预验收库存
return invPreInProductDetailDao.selectLastInBatch(relId, batchNo, mainAction);
} else if (bussinessTypeEntity.isAdvancePreIn()) { //校验寄售库存
return invPreProductDetailDao.selectLastInBatch(relId, batchNo, mainAction);
} else {
return invProductNewDao.selectLastInBatch(relId, batchNo, invCode, mainAction);
}
}
public InvProductNewVo selectFirstInBatch(BasicBussinessTypeEntity bussinessTypeEntity, String relId, String batchNo, String invCode, String mainAction) {
if (bussinessTypeEntity.isScanPreIn()) { //校验预验收库存
return invPreInProductDetailDao.selectFirstInBatch(relId, batchNo, mainAction);
} else if (bussinessTypeEntity.isAdvancePreIn()) { //校验寄售库存
return invPreProductDetailDao.selectFirstInBatch(relId, batchNo, mainAction);
} else {
return invProductNewDao.selectFirstInBatch(relId, batchNo, invCode, mainAction);
}
}
public Integer selectCountByInBatch(String relId, String batchNo, BasicBussinessTypeEntity bussinessTypeEntity, String inBatchNo, String invCode, String mainAction) {
if (bussinessTypeEntity.isScanPreIn()) { //校验预验收库存
return invPreInProductDetailDao.selectCountByInBatch(relId, batchNo, inBatchNo, mainAction);
} else if (bussinessTypeEntity.isAdvancePreIn()) { //校验寄售库存
return invPreProductDetailDao.selectCountByInBatch(relId, batchNo, inBatchNo, mainAction);
} else {
return invProductNewDao.selectCountByInBatch(relId, batchNo, invCode, inBatchNo, mainAction);
}
}
public InvProductNewVo selectNextInBatch(BasicBussinessTypeEntity bussinessTypeEntity, String relId, String batchNo, String invCode, String mainAction, String inBatchNo) {
if (bussinessTypeEntity.isScanPreIn()) { //校验预验收库存
return invPreInProductDetailDao.selectNextInBatch(relId, batchNo, mainAction, inBatchNo);
} else if (bussinessTypeEntity.isAdvancePreIn()) { //校验寄售库存
return invPreProductDetailDao.selectNextInBatch(relId, batchNo, mainAction, inBatchNo);
} else {
return invProductNewDao.selectNextInBatch(relId, batchNo, invCode, mainAction, inBatchNo);
}
}
}

@ -0,0 +1,724 @@
package com.glxp.api.util;
import cn.hutool.core.date.DateTime;
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;
import java.lang.management.ManagementFactory;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.*;
@Slf4j
public class MsDateUtil extends DateUtils {
private static String[] parsePatterns = {
"yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM-dd HH", "yyyy-MM",
"yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM/dd HH", "yyyy/MM",
"yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM.dd HH", "yyyy.MM",
"yyyy年MM月dd日", "yyyy年MM月dd日 HH时mm分ss秒", "yyyy年MM月dd日 HH时mm分", "yyyy年MM月dd日 HH时", "yyyy年MM月",
"yyyy"};
/**
* yyyy-MM-dd
*/
public static String formatDate(Date date) {
return formatDate(date, "yyyy-MM-dd");
}
/**
* yyyy-MM-dd pattern"yyyy-MM-dd" "HH:mm:ss" "E"
*/
public static String formatDate(long dateTime, String pattern) {
return formatDate(new Date(dateTime), pattern);
}
/**
* yyyy-MM-dd pattern"yyyy-MM-dd" "HH:mm:ss" "E"
*/
public static String formatDate(Date date, String pattern) {
String formatDate = null;
if (date != null) {
// if (StringUtils.isNotBlank(pattern)) {
// formatDate = DateFormatUtils.format(date, pattern);
// } else {
// formatDate = DateFormatUtils.format(date, "yyyy-MM-dd");
// }
if (StringUtils.isBlank(pattern)) {
pattern = "yyyy-MM-dd";
}
formatDate = FastDateFormat.getInstance(pattern).format(date);
}
return formatDate;
}
/**
* yyyy-MM-dd HH:mm:ss
*/
public static String formatDateTime(Date date) {
Date currentTime = date;
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateString = formatter.format(currentTime);
return dateString;
}
public static String formateExpireTime(String str) {
try {
Date date = MsDateUtil.parseDate(str, "yyyyMMdd");
return formatDate(date, "yyyy-MM-dd");
} catch (ParseException e) {
e.printStackTrace();
}
return str;
}
public static Long parseDateExpire(String str) {
try {
return MsDateUtil.parseDate(str, "yyyyMMdd").getTime();
} catch (ParseException e) {
e.printStackTrace();
}
return 0l;
}
/**
* yyyy-MM-dd
*/
public static String getDate() {
return getDate("yyyy-MM-dd");
}
/**
* yyyy-MM-dd pattern"yyyy-MM-dd" "HH:mm:ss" "E"
*/
public static String getDate(String pattern) {
// return DateFormatUtils.format(new Date(), pattern);
return FastDateFormat.getInstance(pattern).format(new Date());
}
public static String getDiFormat(String originDate) {
Date date = parseDate(originDate);
return FastDateFormat.getInstance("yyMMdd").format(date);
}
/**
*
*
* @param pattern yyyy-MM-dd pattern"yyyy-MM-dd" "HH:mm:ss" "E"
* @param amont
* @param type Calendar(Calendar.HOURCalendar.MINUTECalendar.SECOND)
* @return
*/
public static String getDate(String pattern, int amont, int type) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date());
calendar.add(type, amont);
// return DateFormatUtils.format(calendar.getTime(), pattern);
return FastDateFormat.getInstance(pattern).format(calendar.getTime());
}
/**
* HH:mm:ss
*/
public static String getTime() {
return formatDate(new Date(), "HH:mm:ss");
}
/**
* yyyy-MM-dd HH:mm:ss
*/
public static String getDateTime() {
return formatDate(new Date(), "yyyy-MM-dd HH:mm:ss");
}
/**
* yyyy
*/
public static String getYear() {
return formatDate(new Date(), "yyyy");
}
/**
* MM
*/
public static String getMonth() {
return formatDate(new Date(), "MM");
}
/**
* dd
*/
public static String getDay() {
return formatDate(new Date(), "dd");
}
/**
* E
*/
public static String getWeek() {
return formatDate(new Date(), "E");
}
/**
* see to DateUtils#parsePatterns
*/
public static Date parseDate(Object str) {
if (str == null) {
return null;
}
try {
return parseDate(str.toString(), parsePatterns);
} catch (ParseException e) {
return null;
}
}
/**
*
*
* @param date
* @return
*/
public static long pastDays(Date date) {
long t = System.currentTimeMillis() - date.getTime();
return t / (24 * 60 * 60 * 1000);
}
/**
*
*
* @param date
* @return
*/
public static long pastHour(Date date) {
long t = System.currentTimeMillis() - date.getTime();
return t / (60 * 60 * 1000);
}
/**
*
*
* @param date
* @return
*/
public static long pastMinutes(Date date) {
long t = System.currentTimeMillis() - date.getTime();
return t / (60 * 1000);
}
/**
*
*
* @param date
* @return
*/
public static long pastSecnod(Date date) {
long t = System.currentTimeMillis() - date.getTime();
return t / (1000);
}
/**
*
*
* @param before
* @param after
* @return
*/
public static double getDistanceOfTwoDate(Date before, Date after) {
long beforeTime = before.getTime();
long afterTime = after.getTime();
return (afterTime - beforeTime) / (1000 * 60 * 60 * 24);
}
/**
*
*
* @param date
* @return
*/
public static int getMonthHasDays(Date date) {
// String yyyyMM = new SimpleDateFormat("yyyyMM").format(date);
String yyyyMM = FastDateFormat.getInstance("yyyyMM").format(date);
String year = yyyyMM.substring(0, 4);
String month = yyyyMM.substring(4, 6);
String day31 = ",01,03,05,07,08,10,12,";
String day30 = "04,06,09,11";
int day = 0;
if (day31.contains(month)) {
day = 31;
} else if (day30.contains(month)) {
day = 30;
} else {
int y = Integer.parseInt(year);
if ((y % 4 == 0 && (y % 100 != 0)) || y % 400 == 0) {
day = 29;
} else {
day = 28;
}
}
return day;
}
/**
*
*
* @param date
* @return
*/
public static int getWeekOfYear(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
return cal.get(Calendar.WEEK_OF_YEAR);
}
/**
* 2015-11-3 00:00:00.000
*
* @param date
* @return
*/
public static Date getOfDayFirst(Date date) {
if (date == null) {
return null;
}
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.HOUR, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTime();
}
/**
* 2015-11-3 23:59:59.999
*
* @param date
* @return
*/
public static Date getOfDayLast(Date date) {
if (date == null) {
return null;
}
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.HOUR, 23);
calendar.set(Calendar.MINUTE, 59);
calendar.set(Calendar.SECOND, 59);
calendar.set(Calendar.MILLISECOND, 999);
return calendar.getTime();
}
/**
*
*
* @param
* @return
*/
public static Date getServerStartDate() {
long time = ManagementFactory.getRuntimeMXBean().getStartTime();
return new Date(time);
}
/**
*
*
* @param dateString 2018-01-01 ~ 2018-01-31
* @return new Date[]{2018-01-01, 2018-01-31}
*/
public static Date[] parseDateBetweenString(String dateString) {
Date beginDate = null;
Date endDate = null;
if (StringUtils.isNotBlank(dateString)) {
String[] ss = StringUtils.split(dateString, "~");
if (ss != null && ss.length == 2) {
String begin = StringUtils.trim(ss[0]);
String end = StringUtils.trim(ss[1]);
if (StringUtils.isNoneBlank(begin, end)) {
try {
beginDate = DateUtils.parseDate(begin);
endDate = DateUtils.parseDate(end);
} catch (ParseException e) {
e.printStackTrace();
}
}
}
}
return new Date[]{beginDate, endDate};
}
public static final int SECONDS_IN_DAY = 60 * 60 * 24;
public static final long MILLIS_IN_DAY = 1000L * SECONDS_IN_DAY;
public static boolean isSameDayOfMillis(final long ms1, final long ms2) {
final long interval = ms1 - ms2;
return interval < MILLIS_IN_DAY
&& interval > -1L * MILLIS_IN_DAY
&& toDay(ms1) == toDay(ms2);
}
private static long toDay(long millis) {
return (millis + TimeZone.getDefault().getOffset(millis)) / MILLIS_IN_DAY;
}
/**
*
*
* @param date
* @param hour
* @return
*/
public static String addDateMinut(Date date, int hour) {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(Calendar.HOUR, hour);// 24小时制
date = cal.getTime();
cal = null;
return format.format(date);
}
/**
*
*
* @param date
* @param hour
* @return DATE
*/
public static Date addDate(Date date, int hour) {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(Calendar.HOUR, hour);// 24小时制
date = cal.getTime();
cal = null;
return date;
}
/**
*
*
* @param date1 1
* @param date2 2
* @return 1 date1>date2;-1 date1<date2;0 date1=date2
*/
public static int compareDate(String date1, String date2) {
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
Date dt1 = df.parse(date1);
Date dt2 = df.parse(date2);
if (dt1.getTime() > dt2.getTime()) {
return 1;
} else if (dt1.getTime() < dt2.getTime()) {
return -1;
} else {
return 0;
}
} catch (Exception exception) {
exception.printStackTrace();
}
return 0;
}
/**
*
*
* @return
*/
public static Map getYesterdayRange() {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Map condition = new HashMap();
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.MILLISECOND, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.HOUR_OF_DAY, 0);
condition.put("endDate", df.format(calendar.getTime()));
calendar.set(Calendar.HOUR_OF_DAY, -24);
condition.put("startDate", df.format(calendar.getTime()));
return condition;
}
/**
*
*
* @return
*/
public static Map getDaySevenRange() {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Map condition = new HashMap();
Calendar calendar = Calendar.getInstance();
calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
calendar.set(Calendar.HOUR_OF_DAY, 24);
condition.put("endDate", df.format(calendar.getTime()));
calendar.set(Calendar.HOUR_OF_DAY, -168);
condition.put("startDate", df.format(calendar.getTime()));
return condition;
}
/**
*
*
* @return
*/
public static Map getDayTRange() {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Map condition = new HashMap();
Calendar calendar = Calendar.getInstance();
calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
calendar.set(Calendar.HOUR_OF_DAY, 24);
condition.put("endDate", df.format(calendar.getTime()));
calendar.set(Calendar.HOUR_OF_DAY, -720);
condition.put("startDate", df.format(calendar.getTime()));
return condition;
}
/**
*
*
* @return
*/
public static Map getYearTRange() {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Map condition = new HashMap();
Calendar calendar = Calendar.getInstance();
calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
calendar.set(Calendar.HOUR_OF_DAY, 24);
condition.put("endDate", df.format(calendar.getTime()));
calendar.set(Calendar.HOUR_OF_DAY, -8640);
condition.put("startDate", df.format(calendar.getTime()));
return condition;
}
public static Map getDayRange(int day) {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Map condition = new HashMap();
Calendar calendar = Calendar.getInstance();
calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
calendar.set(Calendar.HOUR_OF_DAY, 24);
condition.put("endDate", df.format(calendar.getTime()));
calendar.set(Calendar.HOUR_OF_DAY, -(24 * day));
condition.put("startDate", df.format(calendar.getTime()));
return condition;
}
public static long timeToStamp(String mydate) throws Exception {
final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
final Date datetime = sdf.parse(mydate);//将你的日期转换为时间戳
final long time = datetime.getTime();
System.out.println(mydate + "转换后是:" + time);
return time;
}
public static long getStartTime(String startTime) {
final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
final Date datetime;//将你的日期转换为时间戳
try {
datetime = sdf.parse(formatDate(new Date()) + " " + startTime);
final long time = datetime.getTime();
long curTime = System.currentTimeMillis();
if (curTime - time > 0) {
return 24 * 60 * 60 * 1000 - (curTime - time);
} else
return time - curTime;
} catch (ParseException e) {
e.printStackTrace();
}
return 0;
}
public static String getBeforeDay(String actDate, int hour) {
try {
long time = timeToStamp(actDate);
long move = hour * 1000 * 60 * 60;
time = time - move;
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = new Date(time);
String res = simpleDateFormat.format(date);
return res;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public static Date getBeforeDay(Date actDate, int hour) {
try {
long time = actDate.getTime();
long move = hour * 1000 * 60 * 60;
time = time - move;
return new Date(time);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public static String formatExpireTime(String str) {
try {
Date date = MsDateUtil.parseDate(str, "yyyyMMdd");
return formatDate(date, "yyyy-MM-dd");
} catch (ParseException e) {
e.printStackTrace();
}
return str;
}
public static Date fromDate(IoOrderEntity orderEntity) {
Date time = null;
if (orderEntity.getAuditTime() != null) {
time = orderEntity.getAuditTime();
} else {
time = orderEntity.getCreateTime();
}
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;
}
/**
*
*
* @param expireDate yyMMdd
* @param time , yyMMdd
* @return
*/
public static boolean compareExpire(String expireDate, String time) {
if (StrUtil.isBlank(time)) {
time = MsDateUtil.getDate("yyMMdd");
}
long t1 = Long.parseLong(expireDate);
long t2 = Long.parseLong(time);
return t2 > t1;
}
/**
*
*
* @param time
* @param hour
* @return
*/
public static Date getAfterDay(Date date, int hour) {
try {
long time = date.getTime();
long move = hour * 1000 * 60 * 60;
time = time + move;
return new Date(time);
} catch (Exception e) {
log.error("向后推迟时间异常", e);
}
return null;
}
/**
*
*
* @param date
* @return
*/
public static boolean isMonthStart(Date date) {
if (null == date) {
return false;
}
DateTime monthStart = cn.hutool.core.date.DateUtil.beginOfMonth(date);
return monthStart.toString("yyyy-MM-dd").equals(formatDate(date, "yyyy-MM-dd"));
}
/**
*
*
* @param date
* @return
*/
public static boolean isQuarterStart(Date date) {
if (null == date) {
return false;
}
DateTime quarterStart = cn.hutool.core.date.DateUtil.beginOfQuarter(date);
return quarterStart.toString("yyyy-MM-dd").equals(formatDate(date, "yyyy-MM-dd"));
}
/**
*
*
* @param date
* @return
*/
public static boolean isYearStart(Date date) {
if (null == date) {
return false;
}
DateTime yearStart = cn.hutool.core.date.DateUtil.beginOfYear(date);
return yearStart.toString("yyyy-MM-dd").equals(formatDate(date, "yyyy-MM-dd"));
}
public static Date timeProcess(Date date, Integer timeCount) {
if (date == null || timeCount == null) {
String errorMessage = "日期和时间数量不能为空";
System.out.println(errorMessage);
throw new IllegalArgumentException(errorMessage);
}
if (timeCount < 0) {
String errorMessage = "时间数量不能为负数";
System.out.println(errorMessage);
throw new IllegalArgumentException(errorMessage);
}
Calendar rightNow = Calendar.getInstance();
rightNow.setTime(date);
rightNow.add(Calendar.HOUR, timeCount);
Date dt1 = rightNow.getTime();
return dt1;
}
public static Date localToDate(LocalDateTime localDateTime) {
if (localDateTime == null)
return null;
// 将LocalDateTime转换为ZonedDateTime需要指定时区
ZonedDateTime zonedDateTime = localDateTime.atZone(ZoneId.systemDefault());
// 使用ZonedDateTime的toInstant()方法转换为Instant然后调用Date.from(Instant)获取Date
return Date.from(zonedDateTime.toInstant());
}
}

@ -1,4 +1,4 @@
package com.glxp.api.entity.inv;
package com.glxp.api.vo.basic;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
@ -10,28 +10,28 @@ import java.math.BigDecimal;
import java.util.Date;
@Data
@TableName(value = "inv_product_detail")
public class InvProductDetailEntity {
@TableName("inv_product")
public class InvProductNewVo {
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
/**
* UDI
*/
@TableField(value = "code")
private String code;
// /**
// * UDI码
// */
// @TableField(value = "code")
// private String code;
/**
*
*/
@TableField(value = "orderId")
private String orderId;
// /**
// * 订单号外键
// */
// @TableField(value = "orderId")
// private String orderId;
/**
* ID
*/
@TableField(value = "relId")
private Long relId;
@TableField(value = "relIdFk")
private Long relIdFk;
/**
*
@ -48,8 +48,8 @@ public class InvProductDetailEntity {
/**
*
*/
@TableField(value = "produceDate")
private String produceDate;
@TableField(value = "productionDate")
private String productionDate;
/**
*
@ -57,11 +57,11 @@ public class InvProductDetailEntity {
@TableField(value = "expireDate")
private String expireDate;
/**
*
*/
@TableField(value = "serialNo")
private String serialNo;
// /**
// * 序列号
// */
// @TableField(value = "serialNo")
// private String serialNo;
/**
*
@ -69,25 +69,26 @@ public class InvProductDetailEntity {
@TableField(value = "supId")
private String supId;
/**
*
*/
@TableField(value = "`count`")
private int count;
// /**
// * 扫码数量
// */
// @TableField(value = "`count`")
// private Integer count;
/**
*
*/
@TableField(value = "reCount")
private int reCount;
private Integer reCount;
@TableField(value = "inCount")
private int inCount;
private Integer inCount;
@TableField(value = "outCount")
private int outCount;
private Integer outCount;
/**
*
*/
@ -106,11 +107,11 @@ public class InvProductDetailEntity {
@TableField(value = "invSpaceCode")
private String invSpaceCode;
/**
*
*/
@TableField(value = "purchaseType")
private Integer purchaseType;
// /**
// * 采购类型
// */
// @TableField(value = "purchaseType")
// private Integer purchaseType;
/**
*
@ -118,10 +119,12 @@ public class InvProductDetailEntity {
@TableField(value = "updateTime")
private Date updateTime;
@TableField(value = "mainAction")
@TableField(value = "mainAction",select = false)
private String mainAction;
@TableField(value = "action")
private String action;
// @TableField(value = "action")
// private String action;
/**
*
*/
@ -132,6 +135,4 @@ public class InvProductDetailEntity {
*/
@TableField(value = "inBatchNo")
private String inBatchNo;
}

@ -6,7 +6,7 @@
from inv_prein_product_detail
<where>
<if test="code != null and code != ''">
AND code = #{code}
AND code like concat('%', #{code}, '%')
</if>
<if test="mainAction != null and mainAction != ''">
AND mainAction = #{mainAction}
@ -41,6 +41,9 @@
<if test="batchNo == null and batchNo == ''">
AND batchNo is null
</if>
<if test="price != null">
AND price = #{price}
</if>
<if test="productIdList != null and productIdList.size() != 0">
AND relId in
<foreach collection="productIdList" item="item" index="index" open="(" close=")" separator=",">
@ -50,17 +53,101 @@
<if test="updateTime != null and updateTime != ''">
AND updateTime <![CDATA[ <= ]]> #{updateTime}
</if>
<if test="startTime != null and startTime != '' and endTime != null and endTime != ''">
AND date_format(updateTime, '%Y-%m-%d') between date_format(#{startTime}, '%Y-%m-%d') and
date_format(#{endTime}, '%Y-%m-%d')
</if>
</where>
<choose>
<when test="(orderBy!=null ) and (sort=='desc' or sort=='asc')">
order by ${orderBy} ${sort}
<when test="(orderBy != null) and (sort == 'desc' or sort == 'asc')">
order by ${orderBy} ${sort}
</when>
<otherwise>
ORDER BY updateTime DESC
</otherwise>
</choose>
</select>
<select id="findGroupBySpace" resultType="com.glxp.api.res.inv.InvPreinProductResponse">
select ipp.id,
ipp.nameCode,
bp.cpmctymc,
ipp.relId,
bp.ggxh,
ipp.batchNo,
ipp.produceDate,
ipp.expireDate,
bp.ylqxzcrbarmc,
bp.zczbhhzbapzbh,
ipp.inCount,
ipp.outCount,
ipp.reCount,
basic_corp.name supName,
ipp.supId,
auth_dept.name deptName,
auth_warehouse.name invName,
as.name spaceName,
ipp.deptCode,
ipp.invCode
from inv_prein_product_detail ipp
inner join basic_udirel on ipp.relId = basic_udirel.id
inner join basic_products bp on basic_udirel.uuid = bp.uuid
left join basic_corp on ipp.supId = basic_corp.erpId
left join auth_dept on auth_dept.code = ipp.deptCode
left join auth_warehouse on auth_warehouse.code = ipp.invCode
left join auth_space `as` on ipp.code = `as`.code
<where>
<if test="cpmctymc != null and cpmctymc != ''">
AND bp.cpmctymc like concat('%', #{cpmctymc}, '%')
</if>
<if test="nameCode != null and nameCode != ''">
AND ipp.nameCode like concat('%', #{nameCode}, '%')
</if>
<if test="relIdFk != null and relIdFk != ''">
AND ipp.relId = #{relIdFk}
</if>
<if test="ggxh != null and ggxh != ''">
AND bp.ggxh like concat('%', #{ggxh}, '%')
</if>
<if test="batchNo != null and batchNo != ''">
AND ipp.batchNo like concat('%', #{batchNo}, '%')
</if>
<if test="productionDate != null and productionDate != ''">
AND ipp.produceDate = #{productionDate}
</if>
<if test="expireDate != null and expireDate != ''">
AND ipp.expireDate = #{expireDate}
</if>
<if test="ylqxzcrbarmc != null and ylqxzcrbarmc != ''">
AND bp.ylqxzcrbarmc like concat('%', #{ylqxzcrbarmc}, '%')
</if>
<if test="zczbhhzbapzbh != null and zczbhhzbapzbh != ''">
AND bp.zczbhhzbapzbh like concat('%', #{zczbhhzbapzbh}, '%')
</if>
<if test="supId != null and supId != ''">
AND ipp.supId = #{supId}
</if>
<if test="deptCode != null and deptCode != ''">
AND ipp.deptCode = #{deptCode}
</if>
<if test="invCode != null and invCode != ''">
AND ipp.invCode = #{invCode}
</if>
<if test="spaceCode != null and spaceCode != ''">
AND ipp.invSpaceCode = #{spaceCode}
</if>
<if test="invCodes != null and invCodes.size() != 0">
AND ipp.invCode in
<foreach collection="invCodes" item="item" index="index" open="(" close=")" separator=",">
#{item}
</foreach>
</if>
</where>
GROUP BY ipp.relId, ipp.batchNo
order by ipp.updateTime desc
</select>
<delete id="deleteInvPreProductDetail">
@ -84,4 +171,270 @@
</if>
</where>
</delete>
<select id="getInvProductInfo" resultType="com.glxp.api.res.inv.InvPlaceDetailResponse">
select ipd.code,
ipd.relId,
ipd.batchNo,
ipd.serialNo,
ipd.invSpaceCode,
ipd.invCode,
bp.cpmctymc productName,
bp.ggxh,
bp.measname,
bp.zczbhhzbapzbh,
bp.manufactory,
(select name from auth_space s where s.code = ipd.invSpaceCode) invSpaceName,
(select name from basic_corp bc where bc.erpId = ipd.supId) supName
from inv_prein_product_detail ipd
left join basic_udirel bu on bu.id = ipd.relId
left join basic_products bp on bp.uuid = bu.uuid
<where>
<if test="invCode != null and invCode != ''">
AND ipd.invCode = #{invCode}
</if>
<if test="invSpaceCode != null and invSpaceCode != ''">
AND ipd.invSpaceCode = #{invSpaceCode}
</if>
<if test="code != null and code != ''">
AND ipd.code = #{code}
</if>
<if test="orderId != null and orderId != ''">
AND ipd.orderId = #{orderId}
</if>
</where>
group by ipd.id
</select>
<update id="batchBindSpace">
update inv_prein_product_detail
set invSpaceCode = #{invSpaceCode}
where id in
<foreach collection="ids" index="index" item="item" open="(" close=")" separator=",">
#{item}
</foreach>
</update>
<select id="getInvPlaceOrderList" resultType="com.glxp.api.res.inout.IoOrderResponse">
select ipd.orderId billNo,
(select name from basic_bussiness_type where action = o.action) billTypeName,
o.mainAction,
o.fromCorp,
o.corpOrderId,
o.fromType,
o.createTime,
o.auditTime,
(select employeeName from auth_user where id = o.reviewUser) reviewUserName
from inv_prein_product_detail ipd
left join io_order o on ipd.orderId = o.billNo
<where>
<if test="invCode != null and invCode != ''">
AND ipd.invCode = #{invCode}
</if>
<if test="orderId != null and orderId != ''">
AND ipd.orderId like concat('%', #{orderId}, '%')
</if>
</where>
group by ipd.orderId
</select>
<select id="getInventoryQuantity" resultType="java.lang.Integer">
SELECT ifnull(SUM(inCount), 0) - ifnull(SUM(outCount), 0)
FROM inv_prein_product_detail ipd
WHERE CODE = #{code}
and invCode = #{invCode}
and (invSpaceCode is null or invSpaceCode = '')
</select>
<select id="filterSpaceList" resultType="com.glxp.api.res.inv.InvPlaceDetailResponse">
SELECT t1.nameCode,
t1.relId,
(SELECT NAME FROM auth_dept WHERE auth_dept.`code` = t1.deptCode) AS deptName,
(SELECT NAME FROM auth_warehouse WHERE auth_warehouse.`code` = t1.invCode) AS invName,
(SELECT NAME FROM auth_space WHERE auth_space.`code` = t1.invSpaceCode) AS invSpaceName,
SUM(t1.reCount) as count,
bp.cpmctymc as productName,
bp.ggxh,
t1.batchNo,
t1.produceDate as productionDate,
t1.expireDate,
bp.measname,
bp.zczbhhzbapzbh,
bp.ylqxzcrbarmc,
bp.manufactory,
(SELECT `name` FROM basic_corp WHERE erpId = t1.supId) supName
FROM inv_prein_product_detail t1
LEFT JOIN basic_udirel bu ON bu.id = t1.relId
LEFT JOIN basic_products bp ON bp.uuid = bu.uuid
<where>
<if test="code != null and code != ''">
AND t1.code = #{code}
and t1.invSpaceCode IS NOT NULL
and t1.invSpaceCode != ''
</if>
<if test="invSpaceCode != null and invSpaceCode != ''">
AND t1.invSpaceCode = #{invSpaceCode}
</if>
</where>
GROUP BY CODE,
invSpaceCode
</select>
<select id="findByGroupCode" resultType="com.glxp.api.res.inv.InvPlaceDetailResponse">
select pd.id,
pd.code,
pd.relId,
pd.batchNo,
pd.produceDate productionDate,
pd.expireDate,
bp.ggxh,
bp.cpmctymc productName,
bp.zczbhhzbapzbh,
bp.ylqxzcrbarmc,
bp.nameCode,
bp.manufactory,
pd.invSpaceCode,
pd.invCode,
ad.name deptName,
aw.name invName,
sp.name invSpaceName,
ifnull(sum(pd.inCount), 0) as inCount,
ifnull(sum(pd.outCount), 0) as outCount,
pd.inCount - pd.outCount as reCount
from inv_prein_product_detail pd
left join basic_udirel bu on pd.relId = bu.id
left join basic_products bp on bp.uuid = bu.uuid
left join auth_dept ad on pd.deptCode = ad.code
left join auth_warehouse aw on pd.invCode = aw.code
left join auth_space sp on pd.invSpaceCode = sp.code
and sp.invStorageCode = pd.deptCode and sp.invWarehouseCode = pd.invCode
<where>
<if test="invCode != null and invCode != ''">
AND pd.invCode = #{invCode}
</if>
<if test="code != null and code != ''">
AND pd.code = #{code}
</if>
</where>
group by pd.invSpaceCode
</select>
<select id="findBySpaceList" resultType="com.glxp.api.entity.inv.InvPreInProductDetailEntity">
select pd.id,
pd.code,
pd.relId,
pd.batchNo,
pd.produceDate,
pd.expireDate,
pd.invSpaceCode,
pd.deptCode,
pd.invCode,
pd.supId,
pd.nameCode,
pd.invSpaceCode,
ifnull(sum(pd.count), 0) as count,
ifnull(sum(pd.inCount), 0) as inCount,
ifnull(sum(pd.outCount), 0) as outCount,
ifnull(sum(pd.reCount), 0) as reCount
from inv_prein_product_detail pd
<where>
reCount > 0
<if test="spaceList != null and spaceList.size() != 0">
AND pd.invSpaceCode in
<foreach collection="spaceList" item="item" index="index" open="(" close=")" separator=",">
#{item}
</foreach>
</if>
</where>
group by code
</select>
<select id="selectLastInBatch" resultType="com.glxp.api.vo.basic.InvProductNewVo">
select *
from inv_prein_product_detail
<where>
<if test="relId != null and relId != ''">
AND relId = #{relId}
</if>
<if test="mainAction != null and mainAction != ''">
AND mainAction = #{mainAction}
</if>
<if test="batchNo != null and batchNo != ''">
AND batchNo = #{batchNo}
</if>
<if test="batchNo == null or batchNo == ''">
AND batchNo is null
</if>
</where>
order by inBatchNo desc
limit 1;
</select>
<select id="selectFirstInBatch" resultType="com.glxp.api.vo.basic.InvProductNewVo">
select *
from inv_prein_product_detail
<where>
<if test="relId != null and relId != ''">
AND relId = #{relId}
</if>
<if test="mainAction != null and mainAction != ''">
AND mainAction = #{mainAction}
</if>
<if test="batchNo != null and batchNo != ''">
AND batchNo = #{batchNo}
</if>
<if test="batchNo == null or batchNo == ''">
AND batchNo is null
</if>
</where>
order by inBatchNo
limit 1;
</select>
<select id="selectCountByInBatch" resultType="java.lang.Integer">
select sum(reCount)
from inv_prein_product_detail
<where>
<if test="relId != null and relId != ''">
AND relId = #{relId}
</if>
<if test="inBatchNo != null and inBatchNo != ''">
AND inBatchNo = #{inBatchNo}
</if>
<if test="mainAction != null and mainAction != ''">
AND mainAction = #{mainAction}
</if>
<if test="batchNo != null and batchNo != ''">
AND batchNo = #{batchNo}
</if>
<if test="batchNo == null or batchNo == ''">
AND batchNo is null
</if>
</where>
</select>
<select id="selectNextInBatch" resultType="com.glxp.api.vo.basic.InvProductNewVo">
select *
from inv_prein_product_detail
<where>
<if test="relId != null and relId != ''">
AND relId = #{relId}
</if>
<if test="mainAction != null and mainAction != ''">
AND mainAction = #{mainAction}
</if>
<if test="batchNo != null and batchNo != ''">
AND batchNo = #{batchNo}
</if>
<if test="batchNo == null or batchNo == ''">
AND batchNo is null
</if>
and inBatchNo > #{inBatchNo}
LIMIT 1
</where>
</select>
</mapper>

@ -1,12 +1,95 @@
<?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.inv.InvPreProductDetailDao">
<select id="findGroupBySpace" resultType="com.glxp.api.res.inv.InvPreinProductResponse">
select ipp.id,
ipp.nameCode,
bp.cpmctymc,
ipp.relId,
bp.ggxh,
ipp.batchNo,
ipp.produceDate,
ipp.expireDate,
bp.ylqxzcrbarmc,
bp.zczbhhzbapzbh,
ipp.inCount,
ipp.outCount,
ipp.reCount,
basic_corp.name supName,
ipp.supId,
auth_dept.name deptName,
auth_warehouse.name invName,
as.name spaceName,
ipp.deptCode,
ipp.invCode
from inv_pre_product_detail ipp
inner join basic_udirel on ipp.relId = basic_udirel.id
inner join basic_products bp on basic_udirel.uuid = bp.uuid
left join basic_corp on ipp.supId = basic_corp.erpId
left join auth_dept on auth_dept.code = ipp.deptCode
left join auth_warehouse on auth_warehouse.code = ipp.invCode
left join auth_space `as` on ipp.code = `as`.code
<where>
<if test="cpmctymc != null and cpmctymc != ''">
AND bp.cpmctymc like concat('%', #{cpmctymc}, '%')
</if>
<if test="nameCode != null and nameCode != ''">
AND ipp.nameCode like concat('%', #{nameCode}, '%')
</if>
<if test="relIdFk != null and relIdFk != ''">
AND ipp.relId = #{relIdFk}
</if>
<if test="ggxh != null and ggxh != ''">
AND bp.ggxh like concat('%', #{ggxh}, '%')
</if>
<if test="batchNo != null and batchNo != ''">
AND ipp.batchNo like concat('%', #{batchNo}, '%')
</if>
<if test="productionDate != null and productionDate != ''">
AND ipp.produceDate = #{productionDate}
</if>
<if test="expireDate != null and expireDate != ''">
AND ipp.expireDate = #{expireDate}
</if>
<if test="ylqxzcrbarmc != null and ylqxzcrbarmc != ''">
AND bp.ylqxzcrbarmc like concat('%', #{ylqxzcrbarmc}, '%')
</if>
<if test="zczbhhzbapzbh != null and zczbhhzbapzbh != ''">
AND bp.zczbhhzbapzbh like concat('%', #{zczbhhzbapzbh}, '%')
</if>
<if test="supId != null and supId != ''">
AND ipp.supId = #{supId}
</if>
<if test="deptCode != null and deptCode != ''">
AND ipp.deptCode = #{deptCode}
</if>
<if test="invCode != null and invCode != ''">
AND ipp.invCode = #{invCode}
</if>
<if test="spaceCode != null and spaceCode != ''">
AND ipp.invSpaceCode = #{spaceCode}
</if>
<if test="invCodes != null and invCodes.size() != 0">
AND ipp.invCode in
<foreach collection="invCodes" item="item" index="index" open="(" close=")" separator=",">
#{item}
</foreach>
</if>
</where>
GROUP BY ipp.relId, ipp.batchNo
order by ipp.updateTime desc
</select>
<select id="filterPreProductDetailList" resultType="com.glxp.api.entity.inv.InvPreProductDetailEntity">
select *
from inv_pre_product_detail
<where>
<if test="code != null and code != ''">
AND code = #{code}
AND code like concat('%', #{code}, '%')
</if>
<if test="price != null">
AND price = #{price}
</if>
<if test="mainAction != null and mainAction != ''">
AND mainAction = #{mainAction}
@ -50,12 +133,16 @@
<if test="updateTime != null and updateTime != ''">
AND updateTime <![CDATA[ <= ]]> #{updateTime}
</if>
<if test="startTime != null and startTime != '' and endTime != null and endTime != ''">
AND date_format(updateTime, '%Y-%m-%d') between date_format(#{startTime}, '%Y-%m-%d') and
date_format(#{endTime}, '%Y-%m-%d')
</if>
</where>
<choose>
<when test="(orderBy!=null ) and (sort=='desc' or sort=='asc')">
order by ${orderBy} ${sort}
<when test="(orderBy != null) and (sort == 'desc' or sort == 'asc')">
order by ${orderBy} ${sort}
</when>
<otherwise>
ORDER BY updateTime DESC
@ -84,4 +171,236 @@
</if>
</where>
</delete>
<select id="getInvProductInfo" resultType="com.glxp.api.res.inv.InvPlaceDetailResponse">
select ipd.code,
ipd.relId,
ipd.batchNo,
ipd.serialNo,
ipd.invSpaceCode,
ipd.invCode,
bp.cpmctymc productName,
bp.ggxh,
bp.measname,
bp.zczbhhzbapzbh,
bp.manufactory,
(select name from auth_space s where s.code = ipd.invSpaceCode) invSpaceName,
(select name from basic_corp bc where bc.erpId = ipd.supId) supName
from inv_pre_product_detail ipd
left join basic_udirel bu on bu.id = ipd.relId
left join basic_products bp on bp.uuid = bu.uuid
<where>
<if test="invCode != null and invCode != ''">
AND ipd.invCode = #{invCode}
</if>
<if test="invSpaceCode != null and invSpaceCode != ''">
AND ipd.invSpaceCode = #{invSpaceCode}
</if>
<if test="code != null and code != ''">
AND ipd.code = #{code}
</if>
<if test="orderId != null and orderId != ''">
AND ipd.orderId = #{orderId}
</if>
</where>
group by ipd.id
</select>
<update id="batchBindSpace">
update inv_pre_product_detail
set invSpaceCode = #{invSpaceCode}
where id in
<foreach collection="ids" index="index" item="item" open="(" close=")" separator=",">
#{item}
</foreach>
</update>
<select id="getInvPlaceOrderList" resultType="com.glxp.api.res.inout.IoOrderResponse">
select ipd.orderId billNo,
(select name from basic_bussiness_type where action = o.action) billTypeName,
o.mainAction,
o.fromCorp,
o.corpOrderId,
o.fromType,
o.createTime,
o.auditTime,
(select employeeName from auth_user where id = o.reviewUser) reviewUserName
from inv_pre_product_detail ipd
left join io_order o on ipd.orderId = o.billNo
<where>
<if test="invCode != null and invCode != ''">
AND ipd.invCode = #{invCode}
</if>
<if test="orderId != null and orderId != ''">
AND ipd.orderId like concat('%', #{orderId}, '%')
</if>
</where>
group by ipd.orderId
</select>
<select id="getInventoryQuantity" resultType="java.lang.Integer">
SELECT ifnull(SUM(inCount), 0) - ifnull(SUM(outCount), 0)
FROM inv_pre_product_detail ipd
WHERE CODE = #{code}
and invCode = #{invCode}
and (invSpaceCode is null or invSpaceCode = '')
</select>
<select id="filterSpaceList" resultType="com.glxp.api.res.inv.InvPlaceDetailResponse">
SELECT t1.nameCode,
t1.relId,
(SELECT NAME FROM auth_dept WHERE auth_dept.`code` = t1.deptCode) AS deptName,
(SELECT NAME FROM auth_warehouse WHERE auth_warehouse.`code` = t1.invCode) AS invName,
(SELECT NAME FROM auth_space WHERE auth_space.`code` = t1.invSpaceCode) AS invSpaceName,
SUM(t1.reCount) as count,
bp.cpmctymc as productName,
bp.ggxh,
t1.batchNo,
t1.produceDate as productionDate,
t1.expireDate,
bp.measname,
bp.zczbhhzbapzbh,
bp.ylqxzcrbarmc,
bp.manufactory,
(SELECT `name` FROM basic_corp WHERE erpId = t1.supId) supName
FROM inv_pre_product_detail t1
LEFT JOIN basic_udirel bu ON bu.id = t1.relId
LEFT JOIN basic_products bp ON bp.uuid = bu.uuid
<where>
<if test="code != null and code != ''">
AND t1.code = #{code}
</if>
<if test="invSpaceCode != null and invSpaceCode != ''">
AND t1.invSpaceCode = #{invSpaceCode}
</if>
</where>
GROUP BY CODE,
invSpaceCode
</select>
<select id="findByGroupCode" resultType="com.glxp.api.res.inv.InvPlaceDetailResponse">
select pd.id,
pd.code,
pd.relId,
pd.batchNo,
pd.produceDate productionDate,
pd.expireDate,
bp.ggxh,
bp.cpmctymc productName,
bp.zczbhhzbapzbh,
bp.ylqxzcrbarmc,
bp.nameCode,
bp.manufactory,
pd.invSpaceCode,
pd.invCode,
ad.name deptName,
aw.name invName,
sp.name invSpaceName,
ifnull(sum(pd.inCount), 0) as inCount,
ifnull(sum(pd.outCount), 0) as outCount,
pd.inCount - pd.outCount as reCount
from inv_pre_product_detail pd
left join basic_udirel bu on pd.relId = bu.id
left join basic_products bp on bp.uuid = bu.uuid
left join auth_dept ad on pd.deptCode = ad.code
left join auth_warehouse aw on pd.invCode = aw.code
left join auth_space sp on pd.invSpaceCode = sp.code
and sp.invStorageCode = pd.deptCode and sp.invWarehouseCode = pd.invCode
<where>
<if test="invCode != null and invCode != ''">
AND pd.invCode = #{invCode}
</if>
<if test="code != null and code != ''">
AND pd.code = #{code}
</if>
</where>
group by pd.invSpaceCode
</select>
<select id="selectLastInBatch" resultType="com.glxp.api.vo.basic.InvProductNewVo">
select *
from inv_pre_product_detail
<where>
<if test="relId != null and relId != ''">
AND relId = #{relId}
</if>
<if test="mainAction != null and mainAction != ''">
AND mainAction = #{mainAction}
</if>
<if test="batchNo != null and batchNo != ''">
AND batchNo = #{batchNo}
</if>
<if test="batchNo == null or batchNo == ''">
AND batchNo is null
</if>
</where>
order by inBatchNo desc
limit 1;
</select>
<select id="selectFirstInBatch" resultType="com.glxp.api.vo.basic.InvProductNewVo">
select *
from inv_pre_product_detail
<where>
<if test="relId != null and relId != ''">
AND relId = #{relId}
</if>
<if test="mainAction != null and mainAction != ''">
AND mainAction = #{mainAction}
</if>
<if test="batchNo != null and batchNo != ''">
AND batchNo = #{batchNo}
</if>
<if test="batchNo == null or batchNo == ''">
AND batchNo is null
</if>
</where>
order by inBatchNo
limit 1;
</select>
<select id="selectCountByInBatch" resultType="java.lang.Integer">
select sum(reCount)
from inv_pre_product_detail
<where>
<if test="relId != null and relId != ''">
AND relId = #{relId}
</if>
<if test="inBatchNo != null and inBatchNo != ''">
AND inBatchNo = #{inBatchNo}
</if>
<if test="mainAction != null and mainAction != ''">
AND mainAction = #{mainAction}
</if>
<if test="batchNo != null and batchNo != ''">
AND batchNo = #{batchNo}
</if>
<if test="batchNo == null or batchNo == ''">
AND batchNo is null
</if>
</where>
</select>
<select id="selectNextInBatch" resultType="com.glxp.api.vo.basic.InvProductNewVo">
select *
from inv_pre_product_detail
<where>
<if test="relId != null and relId != ''">
AND relId = #{relId}
</if>
<if test="mainAction != null and mainAction != ''">
AND mainAction = #{mainAction}
</if>
<if test="batchNo != null and batchNo != ''">
AND batchNo = #{batchNo}
</if>
<if test="batchNo == null or batchNo == ''">
AND batchNo is null
</if>
and inBatchNo > #{inBatchNo}
LIMIT 1
</where>
</select>
</mapper>

@ -0,0 +1,556 @@
<?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.inv.InvProductNewDao">
<select id="findGroupBySpace" resultType="com.glxp.api.res.inv.InvProductResponse">
select ipp.id,
ipp.nameCode,
bp.cpmctymc,
ipp.relIdFk as relId,
bp.ggxh,
bp.measname,
ipp.batchNo,
ipp.productionDate as produceDate,
ipp.expireDate,
bp.ylqxzcrbarmc,
bp.zczbhhzbapzbh,
bp.bzgg,
inCount,
outCount,
reCount,
basic_corp.name supName,
ipp.supId,
auth_dept.name deptName,
auth_warehouse.name invName,
as.name spaceName,
ipp.deptCode,
ipp.invCode,
ipp.invSpaceCode,
<!-- ipp.code as code,-->
bp.productsType,
bp.levelUnit,
bp.prepnUnit,
bp.prepnSpec,
bp.specialCode,
bp.storageCondition,
bp.transportCondition,
bp.indate,
bp.useAttribute,
bp.packMatrial,
bp.majorType,
bp.majorStatus,
bp.physicType,
bp.medicareType
from inv_product ipp
inner join basic_udirel on ipp.relIdFk = basic_udirel.id
inner join basic_products bp on basic_udirel.uuid = bp.uuid
left join basic_corp on ipp.supId = basic_corp.erpId
left join auth_dept on auth_dept.code = ipp.deptCode
left join auth_warehouse on auth_warehouse.code = ipp.invCode
left join auth_space `as` on ipp.invSpaceCode = `as`.code
<where>
<if test="cpmctymc != null and cpmctymc != ''">
AND bp.cpmctymc like concat('%', #{cpmctymc}, '%')
</if>
<if test="nameCode != null and nameCode != ''">
AND ipp.nameCode like concat('%', #{nameCode}, '%')
</if>
<if test="relIdFk != null and relIdFk != ''">
AND ipp.relIdFk = #{relIdFk}
</if>
<if test="productsType != null ">
AND bp.productsType = #{productsType}
</if>
<if test="ggxh != null and ggxh != ''">
AND bp.ggxh like concat('%', #{ggxh}, '%')
</if>
<if test="batchNo != null and batchNo != ''">
AND ipp.batchNo like concat('%', #{batchNo}, '%')
</if>
<if test="productionDate != null and productionDate != ''">
AND ipp.productionDate = #{productionDate}
</if>
<if test="expireDate != null and expireDate != ''">
AND ipp.expireDate = #{expireDate}
</if>
<if test="ylqxzcrbarmc != null and ylqxzcrbarmc != ''">
AND bp.ylqxzcrbarmc like concat('%', #{ylqxzcrbarmc}, '%')
</if>
<if test="zczbhhzbapzbh != null and zczbhhzbapzbh != ''">
AND bp.zczbhhzbapzbh like concat('%', #{zczbhhzbapzbh}, '%')
</if>
<if test="supId != null and supId != ''">
AND ipp.supId = #{supId}
</if>
<if test="deptCode != null and deptCode != ''">
AND ipp.deptCode = #{deptCode}
</if>
<if test="invCode != null and invCode != ''">
AND ipp.invCode = #{invCode}
</if>
<if test="invSpaceCode != null and invSpaceCode != ''">
AND ipp.invSpaceCode = #{invSpaceCode}
</if>
<if test="invCodes != null and invCodes.size() != 0">
AND ipp.invCode in
<foreach collection="invCodes" item="item" index="index" open="(" close=")" separator=",">
#{item}
</foreach>
</if>
</where>
GROUP BY ipp.relIdFk, ipp.batchNo
order by ipp.updateTime desc
</select>
<select id="filterInvProductDetailList" resultType="com.glxp.api.vo.basic.InvProductNewVo"
parameterType="com.glxp.api.req.inv.FilterInvProductDetailRequest">
select *
from inv_product
<where>
<!-- <if test="code != null and code != ''">-->
<!-- AND code like concat('%', #{code}, '%')-->
<!-- </if>-->
<!-- <if test="mainAction != null and mainAction != ''">-->
<!-- AND mainAction = #{mainAction}-->
<!-- </if>-->
<!-- <if test="action != null and action != ''">-->
<!-- AND action = #{action}-->
<!-- </if>-->
<if test="supId != null and supId != ''">
and supId = #{supId}
</if>
<if test="relId != null and relId != ''">
AND relIdFk = #{relId}
</if>
<if test="nameCode != null and nameCode != ''">
AND nameCode like concat('%', #{nameCode}, '%')
</if>
<!-- <if test="orderId != null and orderId != ''">-->
<!-- AND orderId = #{orderId}-->
<!-- </if>-->
<if test="deptCode != null and deptCode != ''">
AND deptCode = #{deptCode}
</if>
<if test="invCode != null and invCode != ''">
AND invCode = #{invCode}
</if>
<if test="invSpaceCode != null and invSpaceCode != ''">
AND invSpaceCode = #{invSpaceCode}
</if>
<if test="batchNo != null and batchNo != ''">
AND batchNo = #{batchNo}
</if>
<if test="batchNo == null or batchNo == ''">
AND batchNo is null
</if>
<if test="price != null">
AND price = #{price}
</if>
<if test="price == null">
AND price is null
</if>
<if test="productionDate != null and productionDate != ''">
AND productionDate = #{productionDate}
</if>
<if test="expireDate != null and expireDate != ''">
AND expireDate = #{expireDate}
</if>
<if test="productIdList != null and productIdList.size() != 0">
AND relIdFk in
<foreach collection="productIdList" item="item" index="index" open="(" close=")" separator=",">
#{item}
</foreach>
</if>
<if test="updateTime != null and updateTime != ''">
AND updateTime <![CDATA[ <= ]]> #{updateTime}
</if>
<if test="startTime != null and startTime != '' and endTime != null and endTime != ''">
AND date_format(updateTime, '%Y-%m-%d') between date_format(#{startTime}, '%Y-%m-%d') and
date_format(#{endTime}, '%Y-%m-%d')
</if>
</where>
<choose>
<when test="(orderBy != null) and (sort == 'desc' or sort == 'asc')">
order by ${orderBy} ${sort}
</when>
<otherwise>
ORDER BY updateTime DESC
</otherwise>
</choose>
</select>
<delete id="deleteInvProductDetail">
delete
from inv_product
<where>
<if test="relId != null and relId != ''">
AND relIdFk = #{relId}
</if>
<if test="batchNo != null and batchNo != '' and batchNo != 'empty'">
AND batchNo = #{batchNo}
</if>
<if test="batchNo == 'empty'">
AND batchNo is null
</if>
<if test="supId != null and supId != ''">
AND supId = #{supId}
</if>
<if test="invCode != null and invCode != ''">
AND invCode = #{invCode}
</if>
</where>
</delete>
<select id="selectPlaceDetailList" resultType="com.glxp.api.res.inv.InvPlaceDetailResponse">
select pd.id,
<!-- pd.code,-->
pd.relIdFk as relId,
pd.batchNo,
pd.productionDate as productionDate,
pd.expireDate,
bp.ggxh,
bp.cpmctymc productName,
bp.zczbhhzbapzbh,
bp.ylqxzcrbarmc,
bp.nameCode,
bp.manufactory,
ad.name deptName,
aw.name invName,
sp.name invSpaceName
from inv_product pd
left join basic_udirel bu on pd.relIdFk = bu.id
left join basic_products bp on bp.uuid = bu.uuid
left join auth_dept ad on pd.deptCode = ad.code
left join auth_warehouse aw on pd.invCode = aw.code
left join auth_space sp on pd.invSpaceCode = sp.code
and sp.invStorageCode = pd.deptCode and sp.invWarehouseCode = pd.invCode
<where>
<if test="deptCode != null and deptCode != ''">
AND pd.deptCode = #{deptCode}
</if>
<if test="invCode != null and invCode != ''">
AND pd.invCode = #{invCode}
</if>
<if test="invSpaceCode != null and invSpaceCode != ''">
AND pd.invSpaceCode = #{invSpaceCode}
</if>
<if test="invSpaceCode == null or invSpaceCode == ''">
AND (pd.invSpaceCode is null or pd.invSpaceCode = '')
</if>
</where>
<!-- group by pd.code-->
</select>
<select id="findByGroupCode" resultType="com.glxp.api.res.inv.InvPlaceDetailResponse">
select pd.id,
pd.code,
pd.relIdFk as relId,
pd.batchNo,
pd.productionDate productionDate,
pd.expireDate,
bp.ggxh,
bp.cpmctymc productName,
bp.zczbhhzbapzbh,
bp.ylqxzcrbarmc,
bp.nameCode,
bp.manufactory,
pd.invSpaceCode,
pd.invCode,
ad.name deptName,
aw.name invName,
sp.name invSpaceName,
inCount,
outCount,
reCount
from inv_product pd
left join basic_udirel bu on pd.relIdFk = bu.id
left join basic_products bp on bp.uuid = bu.uuid
left join auth_dept ad on pd.deptCode = ad.code
left join auth_warehouse aw on pd.invCode = aw.code
left join auth_space sp on pd.invSpaceCode = sp.code
and sp.invStorageCode = pd.deptCode and sp.invWarehouseCode = pd.invCode
<where>
<if test="invCode != null and invCode != ''">
AND pd.invCode = #{invCode}
</if>
<!-- <if test="code != null and code != ''">-->
<!-- AND pd.code = #{code}-->
<!-- </if>-->
<if test="isCheckSpace != null and isCheckSpace == true">
AND (pd.invSpaceCode is not null or pd.invSpaceCode != '')
</if>
</where>
group by pd.invSpaceCode
</select>
<update id="batchBindSpace">
update inv_product
set invSpaceCode = #{invSpaceCode}
where id in
<foreach collection="ids" index="index" item="item" open="(" close=")" separator=",">
#{item}
</foreach>
</update>
<select id="selectByInvAndCode" resultType="com.glxp.api.vo.basic.InvProductNewVo">
select *
from inv_product
where deptCode = #{deptCode}
and invCode = #{invCode}
<!-- and code = #{code}-->
limit 1
</select>
<select id="selectSupIdByCode" resultType="java.lang.String">
select supId
from inv_product_detail
where code = #{code}
</select>
<select id="selectCountOrderCodes" resultType="java.lang.String">
select distinct code
from inv_product_detail
<where>
<if test="invCode != null and invCode != ''">
AND invCode = #{invCode}
</if>
<if test="invSpaceCode != null and invSpaceCode != ''">
AND invSpaceCode = #{invSpaceCode}
</if>
<if test="relId != null">
AND relIdFk = #{relId}
</if>
<if test="batchNo != null and batchNo != ''">
AND batchNo = #{batchNo}
</if>
</where>
</select>
<select id="getInvProductInfo" resultType="com.glxp.api.res.inv.InvPlaceDetailResponse">
select ipd.code,
ipd.relId,
ipd.batchNo,
ipd.serialNo,
ipd.invSpaceCode,
ipd.invCode,
bp.cpmctymc productName,
bp.ggxh,
bp.measname,
bp.zczbhhzbapzbh,
bp.manufactory,
(select name from auth_space s where s.code = ipd.invSpaceCode) invSpaceName,
(select name from basic_corp bc where bc.erpId = ipd.supId) supName
from inv_product_detail ipd
left join basic_udirel bu on bu.id = ipd.relId
left join basic_products bp on bp.uuid = bu.uuid
<where>
<if test="invCode != null and invCode != ''">
AND ipd.invCode = #{invCode}
</if>
<if test="invSpaceCode != null and invSpaceCode != ''">
AND ipd.invSpaceCode = #{invSpaceCode}
</if>
<if test="code != null and code != ''">
AND ipd.code = #{code}
</if>
<if test="orderId != null and orderId != ''">
AND ipd.orderId = #{orderId}
</if>
</where>
group by ipd.id
</select>
<select id="getInvPlaceOrderList" resultType="com.glxp.api.res.inout.IoOrderResponse">
select odr.orderIdFk billNo,
(select name from basic_bussiness_type where action = o.action) billTypeName,
o.mainAction,
o.fromCorp,
o.corpOrderId,
o.fromType,
o.createTime,
o.auditTime,
(select employeeName from auth_user where id = o.reviewUser) reviewUserName
from io_order_detail_biz odr
left join io_order o on o.billNo = odr.orderIdFk
<where>
<if test="invCode != null and invCode != ''">
AND odr.invCode = #{invCode}
</if>
<if test="orderId != null and orderId != ''">
AND odr.orderIdFk like concat('%', #{orderId}, '%')
</if>
</where>
group by odr.orderIdFk
</select>
<select id="getInventoryQuantity" resultType="java.lang.Integer">
SELECT reCount
FROM inv_product ipd
WHERE invCode = #{invCode}
and (invSpaceCode is null or invSpaceCode = '')
</select>
<select id="filterSpaceList" resultType="com.glxp.api.res.inv.InvPlaceDetailResponse">
SELECT t1.nameCode,
t1.relIdFk as relId,
(SELECT NAME FROM auth_dept WHERE auth_dept.`code` = t1.deptCode) AS deptName,
(SELECT NAME FROM auth_warehouse WHERE auth_warehouse.`code` = t1.invCode) AS invName,
(SELECT NAME FROM auth_space WHERE auth_space.`code` = t1.invSpaceCode) AS invSpaceName,
<include refid="inOrOutcount"/> as count,
bp.cpmctymc as productName,
bp.ggxh,
t1.batchNo,
t1.productionDate as produceDate as productionDate,
t1.expireDate,
bp.measname,
bp.zczbhhzbapzbh,
bp.ylqxzcrbarmc,
bp.manufactory,
(SELECT `name` FROM basic_corp WHERE erpId = t1.supId) supName
FROM inv_product t1
LEFT JOIN basic_udirel bu ON bu.id = t1.relIdFk
LEFT JOIN basic_products bp ON bp.uuid = bu.uuid
<where>
<!-- <if test="code != null and code != ''">-->
<!-- AND t1.code = #{code}-->
<!-- </if>-->
<if test="invSpaceCode != null and invSpaceCode != ''">
AND t1.invSpaceCode = #{invSpaceCode}
</if>
</where>
GROUP BY invSpaceCode
</select>
<select id="selectLastInBatch" resultType="com.glxp.api.vo.basic.InvProductNewVo">
select <include refid="selectInvPreProduct"/>
from inv_product
<where>
<if test="relId != null and relId != ''">
AND relIdFk = #{relId}
</if>
<if test="invCode != null and invCode != ''">
AND invCode = #{invCode}
</if>
<!-- <if test="mainAction != null and mainAction != ''">-->
<!-- AND mainAction = #{mainAction}-->
<!-- </if>-->
<if test="batchNo != null and batchNo != ''">
AND batchNo = #{batchNo}
</if>
<if test="batchNo == null or batchNo == ''">
AND batchNo is null
</if>
</where>
order by inBatchNo desc
limit 1;
</select>
<select id="selectFirstInBatch" resultType="com.glxp.api.vo.basic.InvProductNewVo">
select <include refid="selectInvPreProduct"/>
from inv_product
<where>
<if test="relId != null and relId != ''">
AND relIdFk = #{relId}
</if>
<if test="invCode != null and invCode != ''">
AND invCode = #{invCode}
</if>
<!-- <if test="mainAction != null and mainAction != ''">-->
<!-- AND mainAction = #{mainAction}-->
<!-- </if>-->
<if test="batchNo != null and batchNo != ''">
AND batchNo = #{batchNo}
</if>
<if test="batchNo == null or batchNo == ''">
AND batchNo is null
</if>
</where>
order by inBatchNo
limit 1;
</select>
<select id="selectCountByInBatch" resultType="java.lang.Integer">
select
<include refid="inOrOutcount"/>
from inv_product
<where>
<if test="relId != null and relId != ''">
AND relIdFk = #{relId}
</if>
<if test="invCode != null and invCode != ''">
AND invCode = #{invCode}
</if>
<if test="inBatchNo != null and inBatchNo != ''">
AND inBatchNo = #{inBatchNo}
</if>
<!-- <if test="mainAction != null and mainAction != ''">-->
<!-- AND mainAction = #{mainAction}-->
<!-- </if>-->
<if test="batchNo != null and batchNo != ''">
AND batchNo = #{batchNo}
</if>
<if test="batchNo == null or batchNo == ''">
AND batchNo is null
</if>
</where>
</select>
<select id="selectNextInBatch" resultType="com.glxp.api.vo.basic.InvProductNewVo">
select <include refid="selectInvPreProduct"/>
from inv_product
<where>
<if test="relId != null and relId != ''">
AND relIdFk = #{relId}
</if>
<if test="invCode != null and invCode != ''">
AND invCode = #{invCode}
</if>
<!-- <if test="mainAction != null and mainAction != ''">-->
<!-- AND mainAction = #{mainAction}-->
<!-- </if>-->
<if test="batchNo != null and batchNo != ''">
AND batchNo = #{batchNo}
</if>
<if test="batchNo == null or batchNo == ''">
AND batchNo is null
</if>
and inBatchNo > #{inBatchNo}
LIMIT 1
</where>
</select>
<sql id="selectInvPreProduct">
*
</sql>
<sql id="inOrOutcount">
<choose>
<when test="mainAction =='WareHouseOut'.toString() ">
outCount
</when>
<when test="mainAction =='WareHouseIn'.toString() ">
inCount
</when>
</choose>
</sql>
<select id="selectOrderInfo" resultType="com.glxp.api.vo.basic.InvProductNewVo">
select t1.deptCode,t1.invCode,t1.mainAction,t2.* from io_order t1 inner join io_order_detail_biz t2 on t1.billNo = t2.orderIdFk
<where>
t2.orderIdFk = #{orderIdFk}
<if test="price != null and price != ''">
AND t2.price = #{price}
</if>
</where>
</select>
</mapper>

@ -1,154 +0,0 @@
<?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.inv.InvProductDetailDao">
<select id="filterInvProductDetailList" resultType="com.glxp.api.entity.inv.InvProductDetailEntity"
parameterType="com.glxp.api.req.inv.FilterInvProductDetailRequest">
select *
from inv_product_detail
<where>
<if test="code != null and code != ''">
AND code = #{code}
</if>
<if test="mainAction != null and mainAction != ''">
AND mainAction = #{mainAction}
</if>
<if test="action != null and action != ''">
AND action = #{action}
</if>
<if test="supId != null and supId != ''">
and supId = #{supId}
</if>
<if test="relId != null and relId != ''">
AND relId = #{relId}
</if>
<if test="nameCode != null and nameCode != ''">
AND nameCode like concat('%', #{nameCode}, '%')
</if>
<if test="orderId != null and orderId != ''">
AND orderId = #{orderId}
</if>
<if test="deptCode != null and deptCode != ''">
AND deptCode = #{deptCode}
</if>
<if test="invCode != null and invCode != ''">
AND invCode = #{invCode}
</if>
<if test="invSpaceCode != null and invSpaceCode != ''">
AND invSpaceCode = #{invSpaceCode}
</if>
<if test="batchNo != null and batchNo != ''">
AND batchNo = #{batchNo}
</if>
<if test="batchNo == null and batchNo == ''">
AND batchNo is null
</if>
<if test="productionDate != null and productionDate != ''">
AND produceDate = #{productionDate}
</if>
<if test="expireDate != null and expireDate != ''">
AND expireDate = #{expireDate}
</if>
<if test="productIdList != null and productIdList.size() != 0">
AND relId in
<foreach collection="productIdList" item="item" index="index" open="(" close=")" separator=",">
#{item}
</foreach>
</if>
<if test="updateTime != null and updateTime != ''">
AND updateTime <![CDATA[ <= ]]> #{updateTime}
</if>
</where>
<choose>
<when test="(orderBy!=null ) and (sort=='desc' or sort=='asc')">
order by ${orderBy} ${sort}
</when>
<otherwise>
ORDER BY updateTime DESC
</otherwise>
</choose>
</select>
<delete id="deleteInvProductDetail">
delete
from inv_product_detail
<where>
<if test="relId != null and relId != ''">
AND relId = #{relId}
</if>
<if test="batchNo != null and batchNo != '' and batchNo != 'empty'">
AND batchNo = #{batchNo}
</if>
<if test="batchNo == 'empty'">
AND batchNo is null
</if>
<if test="supId != null and supId != ''">
AND supId = #{supId}
</if>
<if test="invCode != null and invCode != ''">
AND invCode = #{invCode}
</if>
</where>
</delete>
<select id="selectPlaceDetailList" resultType="com.glxp.api.res.inv.InvPlaceDetailResponse">
select pd.id,
pd.code,
pd.relId,
pd.batchNo,
pd.produceDate productionDate,
pd.expireDate,
bp.ggxh,
bp.cpmctymc productName,
bp.zczbhhzbapzbh,
bp.ylqxzcrbarmc,
bp.nameCode,
ad.name deptName,
aw.name invName,
sp.name invSpaceName
from inv_product_detail pd
left join basic_udirel bu on pd.relId = bu.id
left join basic_products bp on bp.uuid = bu.uuid
left join auth_dept ad on pd.deptCode = ad.code
left join auth_warehouse aw on pd.invCode = aw.code
left join auth_space sp on pd.invSpaceCode = sp.code
and sp.invStorageCode = pd.deptCode and sp.invWarehouseCode = pd.invCode
<where>
<if test="deptCode != null and deptCode != ''">
AND pd.deptCode = #{deptCode}
</if>
<if test="invCode != null and invCode != ''">
AND pd.invCode = #{invCode}
</if>
<if test="invSpaceCode != null and invSpaceCode != ''">
AND pd.invSpaceCode = #{invSpaceCode}
</if>
</where>
</select>
<update id="batchBindSpace">
update inv_product_detail
set invSpaceCode = #{invSpaceCode}
where id in
<foreach collection="ids" index="index" item="item" open="(" close=")" separator=",">
#{item}
</foreach>
</update>
<select id="selectByInvAndCode" resultType="com.glxp.api.entity.inv.InvProductDetailEntity">
select *
from inv_product_detail
where deptCode = #{deptCode}
and invCode = #{invCode}
and code = #{code}
limit 1
</select>
<select id="selectSupIdByCode" resultType="java.lang.String">
select supId
from inv_product_detail
where code = #{code}
</select>
</mapper>
Loading…
Cancel
Save