gyzz/openerp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
ecd62dcfb0
openerp/jshERP-boot/src/main/java/com/jsh/erp/service/DepotItemService.java

1413 lines
74 KiB
Java
Raw Normal View History

优化service的目录结构
2025-02-24 23:08:06 +08:00
package com.jsh.erp.service;
vue版本上线
2021-04-07 23:53:57 +08:00
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.jsh.erp.constants.BusinessConstants;
import com.jsh.erp.constants.ExceptionConstants;
import com.jsh.erp.datasource.entities.*;
import com.jsh.erp.datasource.mappers.*;
import com.jsh.erp.datasource.vo.DepotItemStockWarningCount;
import com.jsh.erp.datasource.vo.DepotItemVo4Stock;
增加批次商品选择
2021-09-29 01:17:20 +08:00
import com.jsh.erp.datasource.vo.DepotItemVoBatchNumberList;
优化首页的统计接口，提高查询速度
2024-04-27 00:58:11 +08:00
import com.jsh.erp.datasource.vo.InOutPriceVo;
vue版本上线
2021-04-07 23:53:57 +08:00
import com.jsh.erp.exception.BusinessRunTimeException;
import com.jsh.erp.exception.JshException;
import com.jsh.erp.utils.StringUtil;
1、解决组织递归bug，2、解决月份最后一天bug
2021-06-08 22:00:51 +08:00
import com.jsh.erp.utils.Tools;
vue版本上线
2021-04-07 23:53:57 +08:00
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.math.BigDecimal;
给单据保存中增加更新成本价的逻辑
2024-05-22 00:56:03 +08:00
import java.util.*;
vue版本上线
2021-04-07 23:53:57 +08:00
@Service
public class DepotItemService {
private Logger logger = LoggerFactory.getLogger(DepotItemService.class);
private final static String TYPE = "入库";
private final static String SUM_TYPE = "number";
private final static String IN = "in";
private final static String OUT = "out";
@Resource
private DepotItemMapper depotItemMapper;
@Resource
private DepotItemMapperEx depotItemMapperEx;
@Resource
private MaterialService materialService;
@Resource
private MaterialExtendService materialExtendService;
@Resource
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
private SerialNumberMapperEx serialNumberMapperEx;
@Resource
private DepotHeadService depotHeadService;
vue版本上线
2021-04-07 23:53:57 +08:00
@Resource
private DepotHeadMapper depotHeadMapper;
@Resource
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
private SerialNumberService serialNumberService;
vue版本上线
2021-04-07 23:53:57 +08:00
@Resource
private UserService userService;
@Resource
private SystemConfigService systemConfigService;
@Resource
优化商品库存查询逻辑，在没有选择仓库的时候过滤出当前有权限的仓库
2023-03-07 22:06:10 +08:00
private DepotService depotService;
@Resource
修改获取批次商品列表信息的接口的查询逻辑
2023-04-01 23:26:07 +08:00
private UnitService unitService;
给首页的金额进行权限控制
2022-10-23 17:09:48 +08:00
@Resource
vue版本上线
2021-04-07 23:53:57 +08:00
private MaterialCurrentStockMapper materialCurrentStockMapper;
@Resource
给单据保存中增加更新成本价的逻辑
2024-05-22 00:56:03 +08:00
private MaterialCurrentStockMapperEx materialCurrentStockMapperEx;
@Resource
vue版本上线
2021-04-07 23:53:57 +08:00
private LogService logService;
public DepotItem getDepotItem(long id)throws Exception {
DepotItem result=null;
try{
result=depotItemMapper.selectByPrimaryKey(id);
}catch(Exception e){
JshException.readFail(logger, e);
}
return result;
}
public List<DepotItem> getDepotItem()throws Exception {
DepotItemExample example = new DepotItemExample();
example.createCriteria().andDeleteFlagNotEqualTo(BusinessConstants.DELETE_FLAG_DELETED);
List<DepotItem> list=null;
try{
list=depotItemMapper.selectByExample(example);
}catch(Exception e){
JshException.readFail(logger, e);
}
return list;
}
public List<DepotItem> select(String name, Integer type, String remark, int offset, int rows)throws Exception {
List<DepotItem> list=null;
try{
list=depotItemMapperEx.selectByConditionDepotItem(name, type, remark, offset, rows);
}catch(Exception e){
JshException.readFail(logger, e);
}
return list;
}
public Long countDepotItem(String name, Integer type, String remark) throws Exception{
Long result =null;
try{
result=depotItemMapperEx.countsByDepotItem(name, type, remark);
}catch(Exception e){
JshException.readFail(logger, e);
}
return result;
}
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
public int insertDepotItem(JSONObject obj, HttpServletRequest request)throws Exception {
DepotItem depotItem = JSONObject.parseObject(obj.toJSONString(), DepotItem.class);
int result =0;
try{
result=depotItemMapper.insertSelective(depotItem);
}catch(Exception e){
JshException.readFail(logger, e);
}
return result;
}
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
public int updateDepotItem(JSONObject obj, HttpServletRequest request)throws Exception {
DepotItem depotItem = JSONObject.parseObject(obj.toJSONString(), DepotItem.class);
int result =0;
try{
result=depotItemMapper.updateByPrimaryKeySelective(depotItem);
}catch(Exception e){
JshException.readFail(logger, e);
}
return result;
}
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
public int deleteDepotItem(Long id, HttpServletRequest request)throws Exception {
int result =0;
try{
result=depotItemMapper.deleteByPrimaryKey(id);
}catch(Exception e){
JshException.writeFail(logger, e);
}
return result;
}
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
public int batchDeleteDepotItem(String ids, HttpServletRequest request)throws Exception {
List<Long> idList = StringUtil.strToLongList(ids);
DepotItemExample example = new DepotItemExample();
example.createCriteria().andIdIn(idList);
int result =0;
try{
result=depotItemMapper.deleteByExample(example);
}catch(Exception e){
JshException.writeFail(logger, e);
}
return result;
}
public int checkIsNameExist(Long id, String name)throws Exception {
DepotItemExample example = new DepotItemExample();
example.createCriteria().andIdNotEqualTo(id).andDeleteFlagNotEqualTo(BusinessConstants.DELETE_FLAG_DELETED);
List<DepotItem> list =null;
try{
list=depotItemMapper.selectByExample(example);
}catch(Exception e){
JshException.readFail(logger, e);
}
return list==null?0:list.size();
}
给根据仓库和商品查询单据列表接口增加是否出入库管理的开关
2023-12-11 00:18:26 +08:00
public List<DepotItemVo4DetailByTypeAndMId> findDetailByDepotIdsAndMaterialIdList(String depotIds, Boolean forceFlag, Boolean inOutManageFlag, String sku, String batchNumber,
给单据保存中增加更新成本价的逻辑
2024-05-22 00:56:03 +08:00
String number, String beginTime, String endTime, Long mId, Integer offset, Integer rows)throws Exception {
优化采购统计和销售统计的查询逻辑
2023-03-09 21:37:13 +08:00
Long depotId = null;
优化商品库存流水记录的接口，增加仓库参数
2022-05-28 17:27:57 +08:00
if(StringUtil.isNotEmpty(depotIds)) {
优化采购统计和销售统计的查询逻辑
2023-03-09 21:37:13 +08:00
depotId = Long.parseLong(depotIds);
vue版本上线
2021-04-07 23:53:57 +08:00
}
优化采购统计和销售统计的查询逻辑
2023-03-09 21:37:13 +08:00
List<Long> depotList = depotService.parseDepotList(depotId);
Long[] depotIdArray = StringUtil.listToLongArray(depotList);
vue版本上线
2021-04-07 23:53:57 +08:00
List<DepotItemVo4DetailByTypeAndMId> list =null;
try{
给根据仓库和商品查询单据列表接口增加是否出入库管理的开关
2023-12-11 00:18:26 +08:00
list = depotItemMapperEx.findDetailByDepotIdsAndMaterialIdList(depotIdArray, forceFlag, inOutManageFlag, sku, batchNumber, number, beginTime, endTime, mId, offset, rows);
vue版本上线
2021-04-07 23:53:57 +08:00
}catch(Exception e){
JshException.readFail(logger, e);
}
return list;
}
给根据仓库和商品查询单据列表接口增加是否出入库管理的开关
2023-12-11 00:18:26 +08:00
public Long findDetailByDepotIdsAndMaterialIdCount(String depotIds, Boolean forceFlag, Boolean inOutManageFlag, String sku, String batchNumber,
给商品库存流水接口增加查询字段
2023-02-22 22:36:58 +08:00
String number, String beginTime, String endTime, Long mId)throws Exception {
优化采购统计和销售统计的查询逻辑
2023-03-09 21:37:13 +08:00
Long depotId = null;
优化商品库存流水记录的接口，增加仓库参数
2022-05-28 17:27:57 +08:00
if(StringUtil.isNotEmpty(depotIds)) {
优化采购统计和销售统计的查询逻辑
2023-03-09 21:37:13 +08:00
depotId = Long.parseLong(depotIds);
vue版本上线
2021-04-07 23:53:57 +08:00
}
优化采购统计和销售统计的查询逻辑
2023-03-09 21:37:13 +08:00
List<Long> depotList = depotService.parseDepotList(depotId);
Long[] depotIdArray = StringUtil.listToLongArray(depotList);
vue版本上线
2021-04-07 23:53:57 +08:00
Long result =null;
try{
给根据仓库和商品查询单据列表接口增加是否出入库管理的开关
2023-12-11 00:18:26 +08:00
result = depotItemMapperEx.findDetailByDepotIdsAndMaterialIdCount(depotIdArray, forceFlag, inOutManageFlag, sku, batchNumber, number, beginTime, endTime, mId);
vue版本上线
2021-04-07 23:53:57 +08:00
}catch(Exception e){
JshException.readFail(logger, e);
}
return result;
}
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
public int insertDepotItemWithObj(DepotItem depotItem)throws Exception {
int result =0;
try{
result = depotItemMapper.insertSelective(depotItem);
}catch(Exception e){
JshException.writeFail(logger, e);
}
return result;
}
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
public int updateDepotItemWithObj(DepotItem depotItem)throws Exception {
int result =0;
try{
result = depotItemMapper.updateByPrimaryKeySelective(depotItem);
}catch(Exception e){
JshException.writeFail(logger, e);
}
return result;
}
public List<DepotItem> getListByHeaderId(Long headerId)throws Exception {
List<DepotItem> list =null;
try{
DepotItemExample example = new DepotItemExample();
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
example.createCriteria().andHeaderIdEqualTo(headerId).andDeleteFlagNotEqualTo(BusinessConstants.DELETE_FLAG_DELETED);
vue版本上线
2021-04-07 23:53:57 +08:00
list = depotItemMapper.selectByExample(example);
}catch(Exception e){
JshException.readFail(logger, e);
}
return list;
}
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
/**
* 查询当前单据中指定商品的明细信息
* @param headerId
* @param meId
* @return
* @throws Exception
*/
public DepotItem getItemByHeaderIdAndMaterial(Long headerId, Long meId)throws Exception {
DepotItem depotItem = new DepotItem();
try{
DepotItemExample example = new DepotItemExample();
example.createCriteria().andHeaderIdEqualTo(headerId).andMaterialExtendIdEqualTo(meId).andDeleteFlagNotEqualTo(BusinessConstants.DELETE_FLAG_DELETED);
List<DepotItem> list = depotItemMapper.selectByExample(example);
if(list!=null && list.size()>0) {
depotItem = list.get(0);
}
}catch(Exception e){
JshException.readFail(logger, e);
}
return depotItem;
}
/**
* 查询被关联订单中指定商品的明细信息
解决删除采购订单关联的请购单状态不变的bug
2024-04-23 23:05:20 +08:00
* @param linkStr
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
* @param meId
* @return
* @throws Exception
*/
解决删除采购订单关联的请购单状态不变的bug
2024-04-23 23:05:20 +08:00
public DepotItem getPreItemByHeaderIdAndMaterial(String linkStr, Long meId, Long linkId)throws Exception {
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
DepotItem depotItem = new DepotItem();
try{
解决删除采购订单关联的请购单状态不变的bug
2024-04-23 23:05:20 +08:00
DepotHead depotHead = depotHeadService.getDepotHead(linkStr);
解决bug：解决其它入库单据中的再次保存的空指针异常
2024-05-15 22:22:34 +08:00
if(null!=depotHead && null!=depotHead.getId()) {
DepotItemExample example = new DepotItemExample();
example.createCriteria().andHeaderIdEqualTo(depotHead.getId()).andMaterialExtendIdEqualTo(meId).andIdEqualTo(linkId).andDeleteFlagNotEqualTo(BusinessConstants.DELETE_FLAG_DELETED);
List<DepotItem> list = depotItemMapper.selectByExample(example);
if(list!=null && list.size()>0) {
depotItem = list.get(0);
}
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
}
}catch(Exception e){
JshException.readFail(logger, e);
}
return depotItem;
}
vue版本上线
2021-04-07 23:53:57 +08:00
public List<DepotItemVo4WithInfoEx> getDetailList(Long headerId)throws Exception {
List<DepotItemVo4WithInfoEx> list =null;
try{
list = depotItemMapperEx.getDetailList(headerId);
}catch(Exception e){
JshException.readFail(logger, e);
}
return list;
}
给进销存统计报表另外增加查询接口
2024-07-14 23:14:13 +08:00
public List<DepotItemVo4WithInfoEx> getInOutStock(String materialParam, List<Long> categoryIdList, String endTime, Integer offset, Integer rows)throws Exception {
vue版本上线
2021-04-07 23:53:57 +08:00
List<DepotItemVo4WithInfoEx> list =null;
try{
给进销存统计报表另外增加查询接口
2024-07-14 23:14:13 +08:00
list = depotItemMapperEx.getInOutStock(materialParam, categoryIdList, endTime, offset, rows);
vue版本上线
2021-04-07 23:53:57 +08:00
}catch(Exception e){
JshException.readFail(logger, e);
}
return list;
}
给进销存统计报表另外增加查询接口
2024-07-14 23:14:13 +08:00
public int getInOutStockCount(String materialParam, List<Long> categoryIdList, String endTime)throws Exception {
vue版本上线
2021-04-07 23:53:57 +08:00
int result=0;
try{
给进销存统计报表另外增加查询接口
2024-07-14 23:14:13 +08:00
result = depotItemMapperEx.getInOutStockCount(materialParam, categoryIdList, endTime);
vue版本上线
2021-04-07 23:53:57 +08:00
}catch(Exception e){
JshException.readFail(logger, e);
}
return result;
}
完善报表接口返回字段，增加品牌和制造商
2024-10-09 00:48:34 +08:00
public List<DepotItemVo4WithInfoEx> getListWithBuyOrSale(String materialParam, String billType,
给报表的接口增加商品类别的查询参数
2025-01-14 00:18:33 +08:00
String beginTime, String endTime, String[] creatorArray, Long organId, String[] organArray, List<Long> categoryList, List<Long> depotList, Boolean forceFlag, Integer offset, Integer rows)throws Exception {
优化采购统计和销售统计报表的查询条件
2022-05-04 21:50:24 +08:00
List<DepotItemVo4WithInfoEx> list =null;
try{
给报表的接口增加商品类别的查询参数
2025-01-14 00:18:33 +08:00
list = depotItemMapperEx.getListWithBuyOrSale(materialParam, billType, beginTime, endTime, creatorArray, organId, organArray, categoryList, depotList, forceFlag, offset, rows);
优化采购统计和销售统计报表的查询条件
2022-05-04 21:50:24 +08:00
}catch(Exception e){
JshException.readFail(logger, e);
}
return list;
}
完善报表接口返回字段，增加品牌和制造商
2024-10-09 00:48:34 +08:00
public int getListWithBuyOrSaleCount(String materialParam, String billType,
给报表的接口增加商品类别的查询参数
2025-01-14 00:18:33 +08:00
String beginTime, String endTime, String[] creatorArray, Long organId, String[] organArray, List<Long> categoryList, List<Long> depotList, Boolean forceFlag)throws Exception {
优化采购统计和销售统计报表的查询条件
2022-05-04 21:50:24 +08:00
int result=0;
try{
给报表的接口增加商品类别的查询参数
2025-01-14 00:18:33 +08:00
result = depotItemMapperEx.getListWithBuyOrSaleCount(materialParam, billType, beginTime, endTime, creatorArray, organId, organArray, categoryList, depotList, forceFlag);
优化采购统计和销售统计报表的查询条件
2022-05-04 21:50:24 +08:00
}catch(Exception e){
JshException.readFail(logger, e);
}
return result;
}
解决采购入库统计的计算bug
2025-04-01 15:54:01 +08:00
public BigDecimal buyOrSale(String type, String subType, Long meId, String beginTime, String endTime,
给采购、销售、零售统计接口增加供应商、客户的查询条件
2023-04-10 23:37:49 +08:00
String[] creatorArray, Long organId, String [] organArray, List<Long> depotList, Boolean forceFlag, String sumType) throws Exception{
vue版本上线
2021-04-07 23:53:57 +08:00
BigDecimal result= BigDecimal.ZERO;
try{
if (SUM_TYPE.equals(sumType)) {
解决采购入库统计的计算bug
2025-04-01 15:54:01 +08:00
result= depotItemMapperEx.buyOrSaleNumber(type, subType, meId, beginTime, endTime, creatorArray, organId, organArray, depotList, forceFlag, sumType);
vue版本上线
2021-04-07 23:53:57 +08:00
} else {
解决采购入库统计的计算bug
2025-04-01 15:54:01 +08:00
result= depotItemMapperEx.buyOrSalePrice(type, subType, meId, beginTime, endTime, creatorArray, organId, organArray, depotList, forceFlag, sumType);
vue版本上线
2021-04-07 23:53:57 +08:00
}
}catch(Exception e){
JshException.readFail(logger, e);
}
return result;
解决出入库统计报表计算的bug
2024-04-15 13:52:58 +08:00
}
public BigDecimal buyOrSalePriceTotal(String type, String subType, String materialParam, String beginTime, String endTime,
给报表的接口增加商品类别的查询参数
2025-01-14 00:18:33 +08:00
String[] creatorArray, Long organId, String [] organArray, List<Long> categoryList, List<Long> depotList, Boolean forceFlag) throws Exception{
解决出入库统计报表计算的bug
2024-04-15 13:52:58 +08:00
BigDecimal result= BigDecimal.ZERO;
try{
给报表的接口增加商品类别的查询参数
2025-01-14 00:18:33 +08:00
result= depotItemMapperEx.buyOrSalePriceTotal(type, subType, materialParam, beginTime, endTime, creatorArray, organId, organArray, categoryList, depotList, forceFlag);
解决出入库统计报表计算的bug
2024-04-15 13:52:58 +08:00
}catch(Exception e){
JshException.readFail(logger, e);
}
return result;
vue版本上线
2021-04-07 23:53:57 +08:00
}
/**
优化首页的统计接口，提高查询速度
2024-04-27 00:58:11 +08:00
* 统计采购、销售、零售的总金额列表
* @param beginTime
* @param endTime
vue版本上线
2021-04-07 23:53:57 +08:00
* @return
* @throws Exception
*/
优化首页的统计接口，提高查询速度
2024-04-27 00:58:11 +08:00
public List<InOutPriceVo> inOrOutPriceList(String beginTime, String endTime) throws Exception{
List<InOutPriceVo> result = new ArrayList<>();
优化首页统计
2021-11-09 00:35:48 +08:00
try{
给接口移除角色类型的参数逻辑
2023-11-18 21:22:17 +08:00
String [] creatorArray = depotHeadService.getCreatorArray();
将系统参数表的金额审核启用标记字段改为强审核标记字段
2023-03-17 23:05:03 +08:00
Boolean forceFlag = systemConfigService.getForceApprovalFlag();
优化首页的统计接口，提高查询速度
2024-04-27 00:58:11 +08:00
result = depotItemMapperEx.inOrOutPriceList(beginTime, endTime, creatorArray, forceFlag);
优化首页统计
2021-11-09 00:35:48 +08:00
}catch(Exception e){
JshException.readFail(logger, e);
}
return result;
}
vue版本上线
2021-04-07 23:53:57 +08:00
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
public void saveDetials(String rows, Long headerId, String actionType, HttpServletRequest request) throws Exception{
vue版本上线
2021-04-07 23:53:57 +08:00
//查询单据主表信息
DepotHead depotHead =depotHeadMapper.selectByPrimaryKey(headerId);
优化序列号逻辑，主要针对退货和编辑页面的接口
2022-09-07 23:44:25 +08:00
//删除序列号和回收序列号
deleteOrCancelSerialNumber(actionType, depotHead, headerId);
vue版本上线
2021-04-07 23:53:57 +08:00
//删除单据的明细
deleteDepotItemHeadId(headerId);
JSONArray rowArr = JSONArray.parseArray(rows);
单据校验
2021-05-31 01:09:14 +08:00
if (null != rowArr && rowArr.size()>0) {
针对组装单、拆卸单校验是否存在组合件和普通子件
2023-02-08 23:27:38 +08:00
//针对组装单、拆卸单校验是否存在组合件和普通子件
checkAssembleWithMaterialType(rowArr, depotHead.getSubType());
vue版本上线
2021-04-07 23:53:57 +08:00
for (int i = 0; i < rowArr.size(); i++) {
DepotItem depotItem = new DepotItem();
JSONObject rowObj = JSONObject.parseObject(rowArr.getString(i));
depotItem.setHeaderId(headerId);
String barCode = rowObj.getString("barCode");
MaterialExtend materialExtend = materialExtendService.getInfoByBarCode(barCode);
解决单据录入的时候，商品条码被修改的bug
2023-08-28 22:05:15 +08:00
if(materialExtend == null) {
throw new BusinessRunTimeException(ExceptionConstants.MATERIAL_BARCODE_IS_NOT_EXIST_CODE,
String.format(ExceptionConstants.MATERIAL_BARCODE_IS_NOT_EXIST_MSG, barCode));
}
vue版本上线
2021-04-07 23:53:57 +08:00
depotItem.setMaterialId(materialExtend.getMaterialId());
depotItem.setMaterialExtendId(materialExtend.getId());
depotItem.setMaterialUnit(rowObj.getString("unit"));
优化批次和序列号商品的入库和出库校验
2022-05-22 22:30:49 +08:00
Material material= materialService.getMaterial(depotItem.getMaterialId());
给组装拆卸、调拨单增加校验
2022-09-09 01:24:00 +08:00
if (BusinessConstants.ENABLE_SERIAL_NUMBER_ENABLED.equals(material.getEnableSerialNumber()) ||
BusinessConstants.ENABLE_BATCH_NUMBER_ENABLED.equals(material.getEnableBatchNumber())) {
//组装拆卸单不能选择批号或序列号商品
if(BusinessConstants.SUB_TYPE_ASSEMBLE.equals(depotHead.getSubType()) ||
BusinessConstants.SUB_TYPE_DISASSEMBLE.equals(depotHead.getSubType())) {
throw new BusinessRunTimeException(ExceptionConstants.MATERIAL_ASSEMBLE_SELECT_ERROR_CODE,
String.format(ExceptionConstants.MATERIAL_ASSEMBLE_SELECT_ERROR_MSG, barCode));
}
//调拨单不能选择批号或序列号商品（该场景走出库和入库单）
if(BusinessConstants.SUB_TYPE_TRANSFER.equals(depotHead.getSubType())) {
throw new BusinessRunTimeException(ExceptionConstants.MATERIAL_TRANSFER_SELECT_ERROR_CODE,
String.format(ExceptionConstants.MATERIAL_TRANSFER_SELECT_ERROR_MSG, barCode));
}
给盘点增加商品选择的过滤
2022-09-23 00:00:39 +08:00
//盘点业务不能选择批号或序列号商品（该场景走出库和入库单）
if(BusinessConstants.SUB_TYPE_CHECK_ENTER.equals(depotHead.getSubType())
||BusinessConstants.SUB_TYPE_REPLAY.equals(depotHead.getSubType())) {
throw new BusinessRunTimeException(ExceptionConstants.MATERIAL_STOCK_CHECK_ERROR_CODE,
String.format(ExceptionConstants.MATERIAL_STOCK_CHECK_ERROR_MSG, barCode));
}
给组装拆卸、调拨单增加校验
2022-09-09 01:24:00 +08:00
}
给商品和单据增加序列号和批次字段
2021-09-28 00:28:23 +08:00
if (StringUtil.isExist(rowObj.get("snList"))) {
depotItem.setSnList(rowObj.getString("snList"));
优化序列号和批次商品的逻辑
2021-09-29 19:44:59 +08:00
if(StringUtil.isExist(rowObj.get("depotId"))) {
校验：序列号单据录入中，商品条码数量与序列号不一致
2023-02-09 00:26:15 +08:00
String [] snArray = depotItem.getSnList().split(",");
int operNum = rowObj.getInteger("operNumber");
if(snArray.length == operNum) {
Long depotId = rowObj.getLong("depotId");
给序列号增加入库单价字段
2024-04-08 00:49:29 +08:00
BigDecimal inPrice = BigDecimal.ZERO;
if (StringUtil.isExist(rowObj.get("unitPrice"))) {
inPrice = rowObj.getBigDecimal("unitPrice");
}
校验：序列号单据录入中，商品条码数量与序列号不一致
2023-02-09 00:26:15 +08:00
serialNumberService.addSerialNumberByBill(depotHead.getType(), depotHead.getSubType(),
给序列号增加入库单价字段
2024-04-08 00:49:29 +08:00
depotHead.getNumber(), materialExtend.getMaterialId(), depotId, inPrice, depotItem.getSnList());
校验：序列号单据录入中，商品条码数量与序列号不一致
2023-02-09 00:26:15 +08:00
} else {
throw new BusinessRunTimeException(ExceptionConstants.DEPOT_HEAD_SN_NUMBERE_FAILED_CODE,
String.format(ExceptionConstants.DEPOT_HEAD_SN_NUMBERE_FAILED_MSG, barCode));
}
优化序列号和批次商品的逻辑
2021-09-29 19:44:59 +08:00
}
优化批次和序列号商品的入库和出库校验
2022-05-22 22:30:49 +08:00
} else {
给批号和序列号增加限制判断（入库或者出库）
2022-07-11 21:31:58 +08:00
//入库或出库
完善单据保存的时候的判断逻辑：如果开启出入库管理，则在采购销售相关单据情况下则跳过判断
2023-12-05 23:36:48 +08:00
if (BusinessConstants.DEPOTHEAD_TYPE_IN.equals(depotHead.getType()) ||
给批号和序列号增加限制判断（入库或者出库）
2022-07-11 21:31:58 +08:00
BusinessConstants.DEPOTHEAD_TYPE_OUT.equals(depotHead.getType())) {
//序列号不能为空
完善单据保存的时候的判断逻辑：如果开启出入库管理，则在采购销售相关单据情况下则跳过判断
2023-12-05 23:36:48 +08:00
if (BusinessConstants.ENABLE_SERIAL_NUMBER_ENABLED.equals(material.getEnableSerialNumber())) {
//如果开启出入库管理，并且类型等于采购、采购退货、销售、销售退货，则跳过
if(systemConfigService.getInOutManageFlag() &&
(BusinessConstants.SUB_TYPE_PURCHASE.equals(depotHead.getSubType())
||BusinessConstants.SUB_TYPE_PURCHASE_RETURN.equals(depotHead.getSubType())
||BusinessConstants.SUB_TYPE_SALES.equals(depotHead.getSubType())
||BusinessConstants.SUB_TYPE_SALES_RETURN.equals(depotHead.getSubType()))) {
//跳过
} else {
throw new BusinessRunTimeException(ExceptionConstants.MATERIAL_SERIAL_NUMBERE_EMPTY_CODE,
String.format(ExceptionConstants.MATERIAL_SERIAL_NUMBERE_EMPTY_MSG, barCode));
}
给批号和序列号增加限制判断（入库或者出库）
2022-07-11 21:31:58 +08:00
}
优化批次和序列号商品的入库和出库校验
2022-05-22 22:30:49 +08:00
}
给商品和单据增加序列号和批次字段
2021-09-28 00:28:23 +08:00
}
if (StringUtil.isExist(rowObj.get("batchNumber"))) {
解决序列号和批号出库的时候bug
2022-05-24 23:22:51 +08:00
depotItem.setBatchNumber(rowObj.getString("batchNumber"));
优化批次和序列号商品的入库和出库校验
2022-05-22 22:30:49 +08:00
} else {
给批号和序列号增加限制判断（入库或者出库）
2022-07-11 21:31:58 +08:00
//入库或出库
if(BusinessConstants.DEPOTHEAD_TYPE_IN.equals(depotHead.getType()) ||
BusinessConstants.DEPOTHEAD_TYPE_OUT.equals(depotHead.getType())) {
//批号不能为空
if (BusinessConstants.ENABLE_BATCH_NUMBER_ENABLED.equals(material.getEnableBatchNumber())) {
完善单据保存的时候的判断逻辑：如果开启出入库管理，则在采购销售相关单据情况下则跳过判断
2023-12-05 23:36:48 +08:00
//如果开启出入库管理，并且类型等于采购、采购退货、销售、销售退货，则跳过
if(systemConfigService.getInOutManageFlag() &&
(BusinessConstants.SUB_TYPE_PURCHASE.equals(depotHead.getSubType())
||BusinessConstants.SUB_TYPE_PURCHASE_RETURN.equals(depotHead.getSubType())
||BusinessConstants.SUB_TYPE_SALES.equals(depotHead.getSubType())
||BusinessConstants.SUB_TYPE_SALES_RETURN.equals(depotHead.getSubType()))) {
//跳过
} else {
throw new BusinessRunTimeException(ExceptionConstants.DEPOT_HEAD_BATCH_NUMBERE_EMPTY_CODE,
String.format(ExceptionConstants.DEPOT_HEAD_BATCH_NUMBERE_EMPTY_MSG, barCode));
}
给批号和序列号增加限制判断（入库或者出库）
2022-07-11 21:31:58 +08:00
}
优化批次和序列号商品的入库和出库校验
2022-05-22 22:30:49 +08:00
}
给商品和单据增加序列号和批次字段
2021-09-28 00:28:23 +08:00
}
if (StringUtil.isExist(rowObj.get("expirationDate"))) {
depotItem.setExpirationDate(rowObj.getDate("expirationDate"));
}
if (StringUtil.isExist(rowObj.get("sku"))) {
depotItem.setSku(rowObj.getString("sku"));
}
增加关联明细id字段，解决明细中重复商品进行批次发货遇到的问题
2022-05-28 22:36:33 +08:00
if (StringUtil.isExist(rowObj.get("linkId"))) {
depotItem.setLinkId(rowObj.getLong("linkId"));
}
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
//以下进行单位换算
更新计量单位为多单位
2024-12-18 00:02:06 +08:00
Unit unitInfo = materialService.findUnit(materialExtend.getMaterialId()); //查询多单位信息
vue版本上线
2021-04-07 23:53:57 +08:00
if (StringUtil.isExist(rowObj.get("operNumber"))) {
depotItem.setOperNumber(rowObj.getBigDecimal("operNumber"));
String unit = rowObj.get("unit").toString();
BigDecimal oNumber = rowObj.getBigDecimal("operNumber");
if (StringUtil.isNotEmpty(unitInfo.getName())) {
String basicUnit = unitInfo.getBasicUnit(); //基本单位
解决多单位商品导入的bug
2021-12-03 21:52:53 +08:00
if (unit.equals(basicUnit)) { //如果等于基本单位
vue版本上线
2021-04-07 23:53:57 +08:00
depotItem.setBasicNumber(oNumber); //数量一致
给多单位再增加两个副单位
2021-12-01 00:58:54 +08:00
} else if (unit.equals(unitInfo.getOtherUnit())) { //如果等于副单位
给计量单位表修改比例的字段类型，给系统参数表增加金额审核启用标记，给单据增加来源字段
2023-03-09 00:01:50 +08:00
depotItem.setBasicNumber(oNumber.multiply(unitInfo.getRatio())); //数量乘以比例
给多单位再增加两个副单位
2021-12-01 00:58:54 +08:00
} else if (unit.equals(unitInfo.getOtherUnitTwo())) { //如果等于副单位2
给计量单位表修改比例的字段类型，给系统参数表增加金额审核启用标记，给单据增加来源字段
2023-03-09 00:01:50 +08:00
depotItem.setBasicNumber(oNumber.multiply(unitInfo.getRatioTwo())); //数量乘以比例
给多单位再增加两个副单位
2021-12-01 00:58:54 +08:00
} else if (unit.equals(unitInfo.getOtherUnitThree())) { //如果等于副单位3
给计量单位表修改比例的字段类型，给系统参数表增加金额审核启用标记，给单据增加来源字段
2023-03-09 00:01:50 +08:00
depotItem.setBasicNumber(oNumber.multiply(unitInfo.getRatioThree())); //数量乘以比例
解决计算成本价的时候空指针异常
2024-06-06 23:29:43 +08:00
} else {
depotItem.setBasicNumber(oNumber); //数量一致
vue版本上线
2021-04-07 23:53:57 +08:00
}
} else {
depotItem.setBasicNumber(oNumber); //其他情况
}
}
解决删除采购订单关联的请购单状态不变的bug
2024-04-23 23:05:20 +08:00
//如果数量+已完成数量>原订单数量，给出预警(判断前提是存在关联订单|关联请购单)
String linkStr = StringUtil.isNotEmpty(depotHead.getLinkNumber())? depotHead.getLinkNumber(): depotHead.getLinkApply();
if (StringUtil.isNotEmpty(linkStr) && StringUtil.isExist(rowObj.get("preNumber")) && StringUtil.isExist(rowObj.get("finishNumber"))) {
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
if("add".equals(actionType)) {
//在新增模式进行状态赋值
BigDecimal preNumber = rowObj.getBigDecimal("preNumber");
BigDecimal finishNumber = rowObj.getBigDecimal("finishNumber");
优化订单分批出入库的状态计算逻辑
2022-05-17 00:04:35 +08:00
if(depotItem.getOperNumber().add(finishNumber).compareTo(preNumber)>0) {
给系统参数表增加超出关联单据启用标记
2023-05-10 23:44:24 +08:00
if(!systemConfigService.getOverLinkBillFlag()) {
throw new BusinessRunTimeException(ExceptionConstants.DEPOT_HEAD_NUMBER_NEED_EDIT_FAILED_CODE,
String.format(ExceptionConstants.DEPOT_HEAD_NUMBER_NEED_EDIT_FAILED_MSG, barCode));
}
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
}
} else if("update".equals(actionType)) {
解决销售订单转采购订单的时候已转数量计算的bug
2022-10-20 23:05:37 +08:00
//当前单据的类型
String currentSubType = depotHead.getSubType();
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
//在更新模式进行状态赋值
String unit = rowObj.get("unit").toString();
解决删除采购订单关联的请购单状态不变的bug
2024-04-23 23:05:20 +08:00
Long preHeaderId = depotHeadService.getDepotHead(linkStr).getId();
解决bug：解决其它入库单据中的再次保存的空指针异常
2024-05-15 22:22:34 +08:00
if(null!=preHeaderId) {
//前一个单据的数量
BigDecimal preNumber = getPreItemByHeaderIdAndMaterial(linkStr, depotItem.getMaterialExtendId(), depotItem.getLinkId()).getOperNumber();
//除去此单据之外的已入库|已出库
BigDecimal realFinishNumber = getRealFinishNumber(currentSubType, depotItem.getMaterialExtendId(), depotItem.getLinkId(), preHeaderId, headerId, unitInfo, unit);
解决采购退货单丢失linkId导致空指针报错（增加提示）
2024-06-14 22:27:13 +08:00
if(preNumber!=null) {
if (depotItem.getOperNumber().add(realFinishNumber).compareTo(preNumber) > 0) {
if (!systemConfigService.getOverLinkBillFlag()) {
throw new BusinessRunTimeException(ExceptionConstants.DEPOT_HEAD_NUMBER_NEED_EDIT_FAILED_CODE,
String.format(ExceptionConstants.DEPOT_HEAD_NUMBER_NEED_EDIT_FAILED_MSG, barCode));
}
解决bug：解决其它入库单据中的再次保存的空指针异常
2024-05-15 22:22:34 +08:00
}
解决采购退货单丢失linkId导致空指针报错（增加提示）
2024-06-14 22:27:13 +08:00
} else {
throw new BusinessRunTimeException(ExceptionConstants.DEPOT_ITEM_PRE_BILL_IS_CHANGE_CODE,
ExceptionConstants.DEPOT_ITEM_PRE_BILL_IS_CHANGE_MSG);
给系统参数表增加超出关联单据启用标记
2023-05-10 23:44:24 +08:00
}
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
}
给采购和销售单据支持分批操作
2021-09-25 22:09:36 +08:00
}
}
vue版本上线
2021-04-07 23:53:57 +08:00
if (StringUtil.isExist(rowObj.get("unitPrice"))) {
零售或销售单价低于最低售价，进行提示
2022-07-11 22:32:15 +08:00
BigDecimal unitPrice = rowObj.getBigDecimal("unitPrice");
depotItem.setUnitPrice(unitPrice);
if(materialExtend.getLowDecimal()!=null) {
//零售或销售单价低于最低售价，进行提示
if("零售".equals(depotHead.getSubType()) || "销售".equals(depotHead.getSubType())) {
if (unitPrice.compareTo(materialExtend.getLowDecimal()) < 0) {
throw new BusinessRunTimeException(ExceptionConstants.DEPOT_HEAD_UNIT_PRICE_LOW_CODE,
String.format(ExceptionConstants.DEPOT_HEAD_UNIT_PRICE_LOW_MSG, barCode));
}
}
}
vue版本上线
2021-04-07 23:53:57 +08:00
}
解决零售单据没有赋值采购价的bug
2022-10-07 19:13:22 +08:00
//如果是销售出库、销售退货、零售出库、零售退货则给采购单价字段赋值（如果是批次商品，则要根据批号去找之前的入库价）
if(BusinessConstants.SUB_TYPE_SALES.equals(depotHead.getSubType()) ||
BusinessConstants.SUB_TYPE_SALES_RETURN.equals(depotHead.getSubType()) ||
BusinessConstants.SUB_TYPE_RETAIL.equals(depotHead.getSubType()) ||
BusinessConstants.SUB_TYPE_RETAIL_RETURN.equals(depotHead.getSubType())) {
给销售单据存储的采购价增加移动平均价的切换
2024-06-11 00:22:28 +08:00
boolean moveAvgPriceFlag = systemConfigService.getMoveAvgPriceFlag();
BigDecimal currentUnitPrice = materialCurrentStockMapperEx.getCurrentUnitPriceByMId(materialExtend.getMaterialId());
解决多单位商品的移动平均价计算的bug
2024-09-21 00:53:16 +08:00
currentUnitPrice = unitService.parseUnitPriceByUnit(currentUnitPrice, unitInfo, depotItem.getMaterialUnit());
给销售单据存储的采购价增加移动平均价的切换
2024-06-11 00:22:28 +08:00
BigDecimal unitPrice = moveAvgPriceFlag? currentUnitPrice: materialExtend.getPurchaseDecimal();
depotItem.setPurchaseUnitPrice(unitPrice);
修改逻辑：销售出库单（如果是批次商品，则要根据批号去找之前的采购价）
2022-10-06 13:28:33 +08:00
if(StringUtil.isNotEmpty(depotItem.getBatchNumber())) {
解决不同商品的批号重复导致采购价获取错误的bug
2024-04-07 15:20:57 +08:00
depotItem.setPurchaseUnitPrice(getDepotItemByBatchNumber(depotItem.getMaterialExtendId(),depotItem.getBatchNumber()).getUnitPrice());
修改逻辑：销售出库单（如果是批次商品，则要根据批号去找之前的采购价）
2022-10-06 13:28:33 +08:00
}
给单据明细增加采购单价字段
2022-10-02 16:57:05 +08:00
}
vue版本上线
2021-04-07 23:53:57 +08:00
if (StringUtil.isExist(rowObj.get("taxUnitPrice"))) {
depotItem.setTaxUnitPrice(rowObj.getBigDecimal("taxUnitPrice"));
}
if (StringUtil.isExist(rowObj.get("allPrice"))) {
depotItem.setAllPrice(rowObj.getBigDecimal("allPrice"));
}
if (StringUtil.isExist(rowObj.get("depotId"))) {
depotItem.setDepotId(rowObj.getLong("depotId"));
} else {
初步增加请购单
2024-04-19 22:56:31 +08:00
if(!BusinessConstants.SUB_TYPE_PURCHASE_APPLY.equals(depotHead.getSubType())
&& !BusinessConstants.SUB_TYPE_PURCHASE_ORDER.equals(depotHead.getSubType())
给订单去除仓库
2021-09-23 22:44:13 +08:00
&& !BusinessConstants.SUB_TYPE_SALES_ORDER.equals(depotHead.getSubType())) {
throw new BusinessRunTimeException(ExceptionConstants.DEPOT_HEAD_DEPOT_FAILED_CODE,
String.format(ExceptionConstants.DEPOT_HEAD_DEPOT_FAILED_MSG));
}
vue版本上线
2021-04-07 23:53:57 +08:00
}
if(BusinessConstants.SUB_TYPE_TRANSFER.equals(depotHead.getSubType())) {
if (StringUtil.isExist(rowObj.get("anotherDepotId"))) {
优化调拨出库单据的仓库判断
2021-08-22 18:16:12 +08:00
if(rowObj.getLong("anotherDepotId").equals(rowObj.getLong("depotId"))) {
throw new BusinessRunTimeException(ExceptionConstants.DEPOT_HEAD_ANOTHER_DEPOT_EQUAL_FAILED_CODE,
String.format(ExceptionConstants.DEPOT_HEAD_ANOTHER_DEPOT_EQUAL_FAILED_MSG));
} else {
depotItem.setAnotherDepotId(rowObj.getLong("anotherDepotId"));
}
vue版本上线
2021-04-07 23:53:57 +08:00
} else {
throw new BusinessRunTimeException(ExceptionConstants.DEPOT_HEAD_ANOTHER_DEPOT_FAILED_CODE,
String.format(ExceptionConstants.DEPOT_HEAD_ANOTHER_DEPOT_FAILED_MSG));
}
}
if (StringUtil.isExist(rowObj.get("taxRate"))) {
depotItem.setTaxRate(rowObj.getBigDecimal("taxRate"));
}
if (StringUtil.isExist(rowObj.get("taxMoney"))) {
depotItem.setTaxMoney(rowObj.getBigDecimal("taxMoney"));
}
if (StringUtil.isExist(rowObj.get("taxLastMoney"))) {
depotItem.setTaxLastMoney(rowObj.getBigDecimal("taxLastMoney"));
}
if (StringUtil.isExist(rowObj.get("mType"))) {
depotItem.setMaterialType(rowObj.getString("mType"));
}
if (StringUtil.isExist(rowObj.get("remark"))) {
depotItem.setRemark(rowObj.getString("remark"));
}
//出库时判断库存是否充足
if(BusinessConstants.DEPOTHEAD_TYPE_OUT.equals(depotHead.getType())){
解决bug：批次商品进行销售出库的时候，数量超出库存确出库了，而且没开负库存
2024-05-15 00:53:31 +08:00
String stockMsg = material.getName() + "-" + barCode;
优化库存查询逻辑，直接查库存表
2023-08-06 22:43:35 +08:00
BigDecimal stock = getCurrentStockByParam(depotItem.getDepotId(),depotItem.getMaterialId());
给出库单据中对于sku商品换个方式计算库存
2022-05-21 23:48:11 +08:00
if(StringUtil.isNotEmpty(depotItem.getSku())) {
//对于sku商品要换个方式计算库存
stock = getSkuStockByParam(depotItem.getDepotId(),depotItem.getMaterialExtendId(),null,null);
}
解决bug：批次商品进行销售出库的时候，数量超出库存确出库了，而且没开负库存
2024-05-15 00:53:31 +08:00
if(StringUtil.isNotEmpty(depotItem.getBatchNumber())) {
//对于批次商品要换个方式计算库存
stock = getOneBatchNumberStock(depotItem.getDepotId(), barCode, depotItem.getBatchNumber());
stockMsg += "-批号" + depotItem.getBatchNumber();
}
解决批次商品又是多单位的情况下，退货遇到库存不足的bug
2024-11-14 22:21:07 +08:00
BigDecimal thisRealNumber = depotItem.getBasicNumber()==null?BigDecimal.ZERO:depotItem.getBasicNumber();
if(StringUtil.isNotEmpty(depotItem.getBatchNumber())) {
//对于批次商品，直接使用当前填写的数量
thisRealNumber = depotItem.getOperNumber()==null?BigDecimal.ZERO:depotItem.getOperNumber();
}
if(!systemConfigService.getMinusStockFlag() && stock.compareTo(thisRealNumber)<0){
vue版本上线
2021-04-07 23:53:57 +08:00
throw new BusinessRunTimeException(ExceptionConstants.MATERIAL_STOCK_NOT_ENOUGH_CODE,
解决bug：批次商品进行销售出库的时候，数量超出库存确出库了，而且没开负库存
2024-05-15 00:53:31 +08:00
String.format(ExceptionConstants.MATERIAL_STOCK_NOT_ENOUGH_MSG, stockMsg));
vue版本上线
2021-04-07 23:53:57 +08:00
}
//出库时处理序列号
if(!BusinessConstants.SUB_TYPE_TRANSFER.equals(depotHead.getSubType())) {
优化批次和序列号商品的入库和出库校验
2022-05-22 22:30:49 +08:00
//判断商品是否开启序列号，开启的售出序列号，未开启的跳过
vue版本上线
2021-04-07 23:53:57 +08:00
if(BusinessConstants.ENABLE_SERIAL_NUMBER_ENABLED.equals(material.getEnableSerialNumber())) {
完善单据保存的时候的判断逻辑：如果开启出入库管理，则在采购销售相关单据情况下则跳过判断
2023-12-05 23:36:48 +08:00
//如果开启出入库管理，并且类型等于采购、采购退货、销售、销售退货，则跳过
if(systemConfigService.getInOutManageFlag() &&
(BusinessConstants.SUB_TYPE_PURCHASE.equals(depotHead.getSubType())
||BusinessConstants.SUB_TYPE_PURCHASE_RETURN.equals(depotHead.getSubType())
||BusinessConstants.SUB_TYPE_SALES.equals(depotHead.getSubType())
||BusinessConstants.SUB_TYPE_SALES_RETURN.equals(depotHead.getSubType()))) {
//跳过
} else {
//售出序列号，获得当前操作人
User userInfo = userService.getCurrentUser();
serialNumberService.checkAndUpdateSerialNumber(depotItem, depotHead.getNumber(), userInfo, StringUtil.toNull(depotItem.getSnList()));
}
vue版本上线
2021-04-07 23:53:57 +08:00
}
}
}
this.insertDepotItemWithObj(depotItem);
//更新当前库存
优化库存逻辑和单据sku
2021-07-28 23:13:37 +08:00
updateCurrentStock(depotItem);
给单据保存中增加更新成本价的逻辑
2024-05-22 00:56:03 +08:00
//更新当前成本价
updateCurrentUnitPrice(depotItem);
录入采购、销售、零售单据的时候自动更新对应商品的价格
2022-09-18 18:51:36 +08:00
//更新商品的价格
完善单价录入的时候更新商品的价格的逻辑
2024-02-23 17:32:15 +08:00
updateMaterialExtendPrice(materialExtend.getId(), depotHead.getSubType(), depotHead.getBillType(), rowObj);
vue版本上线
2021-04-07 23:53:57 +08:00
}
给单据的保存和查询相关接口增加其它入库和其它出库的关联逻辑
2023-12-05 00:23:40 +08:00
//如果关联单据号非空则更新订单的状态,单据类型：采购入库单、销售出库单、盘点复盘单、其它入库单、其它出库单
解决采购入库单状态bug
2021-11-05 23:40:04 +08:00
if(BusinessConstants.SUB_TYPE_PURCHASE.equals(depotHead.getSubType())
增加盘点单据状态变化的逻辑
2022-05-25 23:26:20 +08:00
|| BusinessConstants.SUB_TYPE_SALES.equals(depotHead.getSubType())
给单据的保存和查询相关接口增加其它入库和其它出库的关联逻辑
2023-12-05 00:23:40 +08:00
|| BusinessConstants.SUB_TYPE_REPLAY.equals(depotHead.getSubType())
|| BusinessConstants.SUB_TYPE_OTHER.equals(depotHead.getSubType())) {
解决采购入库单状态bug
2021-11-05 23:40:04 +08:00
if(StringUtil.isNotEmpty(depotHead.getLinkNumber())) {
优化订单分批出入库的状态计算逻辑
2022-05-17 00:04:35 +08:00
//单据状态:是否全部完成 2-全部完成 3-部分完成（针对订单的分批出入库）
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
String billStatus = getBillStatusByParam(depotHead, depotHead.getLinkNumber(), "normal");
changeBillStatus(depotHead.getLinkNumber(), billStatus);
解决采购入库单状态bug
2021-11-05 23:40:04 +08:00
}
给采购和销售单据支持分批操作
2021-09-25 22:09:36 +08:00
}
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
//当前单据类型为采购订单的逻辑
增加销售订单与采购订单的关联
2022-05-18 00:21:15 +08:00
if(BusinessConstants.SUB_TYPE_PURCHASE_ORDER.equals(depotHead.getSubType())) {
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
//如果关联单据号非空则更新订单的状态,此处针对销售订单转采购订单的场景
增加销售订单与采购订单的关联
2022-05-18 00:21:15 +08:00
if(StringUtil.isNotEmpty(depotHead.getLinkNumber())) {
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
String billStatus = getBillStatusByParam(depotHead, depotHead.getLinkNumber(), "normal");
changeBillPurchaseStatus(depotHead.getLinkNumber(), billStatus);
}
//如果关联单据号非空则更新订单的状态,此处针对请购单转采购订单的场景
if(StringUtil.isNotEmpty(depotHead.getLinkApply())) {
String billStatus = getBillStatusByParam(depotHead, depotHead.getLinkApply(), "apply");
changeBillStatus(depotHead.getLinkApply(), billStatus);
增加销售订单与采购订单的关联
2022-05-18 00:21:15 +08:00
}
}
单据校验
2021-05-31 01:09:14 +08:00
} else {
throw new BusinessRunTimeException(ExceptionConstants.DEPOT_HEAD_ROW_FAILED_CODE,
String.format(ExceptionConstants.DEPOT_HEAD_ROW_FAILED_MSG));
vue版本上线
2021-04-07 23:53:57 +08:00
}
}
优化订单分批出入库的状态计算逻辑
2022-05-17 00:04:35 +08:00
/**
* 判断单据的状态
* 通过数组对比：原单据的商品和商品数量（汇总） 与 分批操作后单据的商品和商品数量（汇总）
* @param depotHead
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
* @param linkStr
优化订单分批出入库的状态计算逻辑
2022-05-17 00:04:35 +08:00
* @return
*/
解决序列号和批号出库的时候bug
2022-05-24 23:22:51 +08:00
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
public String getBillStatusByParam(DepotHead depotHead, String linkStr, String linkType) {
优化订单分批出入库的状态计算逻辑
2022-05-17 00:04:35 +08:00
String res = BusinessConstants.BILLS_STATUS_SKIPED;
//获取原单据的商品和商品数量（汇总）
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
List<DepotItemVo4MaterialAndSum> linkList = depotItemMapperEx.getLinkBillDetailMaterialSum(linkStr);
优化订单分批出入库的状态计算逻辑
2022-05-17 00:04:35 +08:00
//获取分批操作后单据的商品和商品数量（汇总）
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
List<DepotItemVo4MaterialAndSum> batchList = depotItemMapperEx.getBatchBillDetailMaterialSum(linkStr, linkType, depotHead.getType());
优化订单分批出入库的状态计算逻辑
2022-05-17 00:04:35 +08:00
//将分批操作后的单据的商品和商品数据构造成Map
Map<Long, BigDecimal> materialSumMap = new HashMap<>();
for(DepotItemVo4MaterialAndSum materialAndSum : batchList) {
materialSumMap.put(materialAndSum.getMaterialExtendId(), materialAndSum.getOperNumber());
}
for(DepotItemVo4MaterialAndSum materialAndSum : linkList) {
解决订单中商品数量为0，转出入库单据时候状态为部分完成的bug
2023-01-06 22:44:51 +08:00
//过滤掉原单里面有数量为0的商品
if(materialAndSum.getOperNumber().compareTo(BigDecimal.ZERO) != 0) {
BigDecimal materialSum = materialSumMap.get(materialAndSum.getMaterialExtendId());
if (materialSum != null) {
给系统参数表增加超出关联单据启用标记
2023-05-10 23:44:24 +08:00
if (materialSum.compareTo(materialAndSum.getOperNumber()) < 0) {
解决订单中商品数量为0，转出入库单据时候状态为部分完成的bug
2023-01-06 22:44:51 +08:00
res = BusinessConstants.BILLS_STATUS_SKIPING;
}
} else {
优化订单分批出入库的状态计算逻辑
2022-05-17 00:04:35 +08:00
res = BusinessConstants.BILLS_STATUS_SKIPING;
}
}
}
return res;
}
给采购和销售单据支持分批操作
2021-09-25 22:09:36 +08:00
/**
* 更新单据状态
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
* @param linkStr
给采购和销售单据支持分批操作
2021-09-25 22:09:36 +08:00
* @param billStatus
*/
解决序列号和批号出库的时候bug
2022-05-24 23:22:51 +08:00
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
public void changeBillStatus(String linkStr, String billStatus) {
给采购和销售单据支持分批操作
2021-09-25 22:09:36 +08:00
DepotHead depotHeadOrders = new DepotHead();
depotHeadOrders.setStatus(billStatus);
DepotHeadExample example = new DepotHeadExample();
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
List<String> linkNoList = StringUtil.strToStringList(linkStr);
example.createCriteria().andNumberIn(linkNoList);
给采购和销售单据支持分批操作
2021-09-25 22:09:36 +08:00
try{
depotHeadMapper.updateByExampleSelective(depotHeadOrders, example);
}catch(Exception e){
logger.error("异常码[{}],异常提示[{}],异常[{}]",
ExceptionConstants.DATA_WRITE_FAIL_CODE,ExceptionConstants.DATA_WRITE_FAIL_MSG,e);
throw new BusinessRunTimeException(ExceptionConstants.DATA_WRITE_FAIL_CODE,
ExceptionConstants.DATA_WRITE_FAIL_MSG);
}
}
增加销售订单与采购订单的关联
2022-05-18 00:21:15 +08:00
/**
* 更新单据状态,此处针对销售订单转采购订单的场景
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
* @param linkStr
增加销售订单与采购订单的关联
2022-05-18 00:21:15 +08:00
* @param billStatus
*/
解决序列号和批号出库的时候bug
2022-05-24 23:22:51 +08:00
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
public void changeBillPurchaseStatus(String linkStr, String billStatus) {
增加销售订单与采购订单的关联
2022-05-18 00:21:15 +08:00
DepotHead depotHeadOrders = new DepotHead();
depotHeadOrders.setPurchaseStatus(billStatus);
DepotHeadExample example = new DepotHeadExample();
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
List<String> linkNoList = StringUtil.strToStringList(linkStr);
example.createCriteria().andNumberIn(linkNoList);
增加销售订单与采购订单的关联
2022-05-18 00:21:15 +08:00
try{
depotHeadMapper.updateByExampleSelective(depotHeadOrders, example);
}catch(Exception e){
logger.error("异常码[{}],异常提示[{}],异常[{}]",
ExceptionConstants.DATA_WRITE_FAIL_CODE,ExceptionConstants.DATA_WRITE_FAIL_MSG,e);
throw new BusinessRunTimeException(ExceptionConstants.DATA_WRITE_FAIL_CODE,
ExceptionConstants.DATA_WRITE_FAIL_MSG);
}
}
修改逻辑：销售出库单（如果是批次商品，则要根据批号去找之前的采购价）
2022-10-06 13:28:33 +08:00
/**
* 根据批号查询单据明细信息
解决不同商品的批号重复导致采购价获取错误的bug
2024-04-07 15:20:57 +08:00
* @param materialExtendId
修改逻辑：销售出库单（如果是批次商品，则要根据批号去找之前的采购价）
2022-10-06 13:28:33 +08:00
* @param batchNumber
* @return
*/
解决不同商品的批号重复导致采购价获取错误的bug
2024-04-07 15:20:57 +08:00
public DepotItem getDepotItemByBatchNumber(Long materialExtendId, String batchNumber) {
List<DepotItem> depotItemList = depotItemMapperEx.getDepotItemByBatchNumber(materialExtendId, batchNumber);
修改逻辑：销售出库单（如果是批次商品，则要根据批号去找之前的采购价）
2022-10-06 13:28:33 +08:00
if(null != depotItemList && depotItemList.size() > 0){
解决零售单据没有赋值采购价的bug
2022-10-07 19:13:22 +08:00
return depotItemList.get(0);
} else {
return new DepotItem();
修改逻辑：销售出库单（如果是批次商品，则要根据批号去找之前的采购价）
2022-10-06 13:28:33 +08:00
}
}
vue版本上线
2021-04-07 23:53:57 +08:00
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
public void deleteDepotItemHeadId(Long headerId)throws Exception {
try{
解决实时库存计算的bug
2021-10-23 21:30:55 +08:00
//1、查询删除前的单据明细
List<DepotItem> depotItemList = getListByHeaderId(headerId);
//2、删除单据明细
DepotItemExample example = new DepotItemExample();
example.createCriteria().andHeaderIdEqualTo(headerId);
vue版本上线
2021-04-07 23:53:57 +08:00
depotItemMapper.deleteByExample(example);
解决实时库存计算的bug
2021-10-23 21:30:55 +08:00
//3、计算删除之后单据明细中商品的库存
for(DepotItem depotItem : depotItemList){
updateCurrentStock(depotItem);
}
vue版本上线
2021-04-07 23:53:57 +08:00
}catch(Exception e){
JshException.writeFail(logger, e);
}
}
优化序列号逻辑，主要针对退货和编辑页面的接口
2022-09-07 23:44:25 +08:00
/**
* 删除序列号和回收序列号
* @param actionType
* @throws Exception
*/
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
public void deleteOrCancelSerialNumber(String actionType, DepotHead depotHead, Long headerId) throws Exception {
if(actionType.equals("update")) {
User userInfo = userService.getCurrentUser();
if(BusinessConstants.DEPOTHEAD_TYPE_IN.equals(depotHead.getType())){
//入库逻辑
String number = depotHead.getNumber();
SerialNumberExample example = new SerialNumberExample();
example.createCriteria().andInBillNoEqualTo(number);
serialNumberService.deleteByExample(example);
} else if(BusinessConstants.DEPOTHEAD_TYPE_OUT.equals(depotHead.getType())){
//出库逻辑
DepotItemExample example = new DepotItemExample();
example.createCriteria().andHeaderIdEqualTo(headerId).andDeleteFlagNotEqualTo(BusinessConstants.DELETE_FLAG_DELETED);
List<DepotItem> depotItemList = depotItemMapper.selectByExample(example);
if(null != depotItemList && depotItemList.size() > 0){
for (DepotItem depotItem : depotItemList){
if(StringUtil.isNotEmpty(depotItem.getSnList())){
serialNumberService.cancelSerialNumber(depotItem.getMaterialId(), depotHead.getNumber(), (depotItem.getBasicNumber() == null ? 0 : depotItem.getBasicNumber()).intValue(), userInfo);
}
}
}
}
}
}
针对组装单、拆卸单校验是否存在组合件和普通子件
2023-02-08 23:27:38 +08:00
/**
* 针对组装单、拆卸单校验是否存在组合件和普通子件
* @param rowArr
* @param subType
*/
public void checkAssembleWithMaterialType(JSONArray rowArr, String subType) {
if(BusinessConstants.SUB_TYPE_ASSEMBLE.equals(subType) ||
BusinessConstants.SUB_TYPE_DISASSEMBLE.equals(subType)) {
if(rowArr.size() > 1) {
JSONObject firstRowObj = JSONObject.parseObject(rowArr.getString(0));
JSONObject secondRowObj = JSONObject.parseObject(rowArr.getString(1));
String firstMaterialType = firstRowObj.getString("mType");
String secondMaterialType = secondRowObj.getString("mType");
if(!"组合件".equals(firstMaterialType) || !"普通子件".equals(secondMaterialType)) {
throw new BusinessRunTimeException(ExceptionConstants.DEPOT_HEAD_CHECK_ASSEMBLE_EMPTY_CODE,
String.format(ExceptionConstants.DEPOT_HEAD_CHECK_ASSEMBLE_EMPTY_MSG));
}
} else {
throw new BusinessRunTimeException(ExceptionConstants.DEPOT_HEAD_CHECK_ASSEMBLE_EMPTY_CODE,
String.format(ExceptionConstants.DEPOT_HEAD_CHECK_ASSEMBLE_EMPTY_MSG));
}
}
}
录入采购、销售、零售单据的时候自动更新对应商品的价格
2022-09-18 18:51:36 +08:00
/**
* 更新商品的价格
* @param meId
* @param subType
* @param rowObj
*/
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
完善单价录入的时候更新商品的价格的逻辑
2024-02-23 17:32:15 +08:00
public void updateMaterialExtendPrice(Long meId, String subType, String billType, JSONObject rowObj) throws Exception {
给系统参数表增加更新单价启用标记，默认开启
2023-03-21 22:22:54 +08:00
if(systemConfigService.getUpdateUnitPriceFlag()) {
if (StringUtil.isExist(rowObj.get("unitPrice"))) {
BigDecimal unitPrice = rowObj.getBigDecimal("unitPrice");
MaterialExtend materialExtend = new MaterialExtend();
materialExtend.setId(meId);
if(BusinessConstants.SUB_TYPE_PURCHASE.equals(subType)) {
materialExtend.setPurchaseDecimal(unitPrice);
}
if(BusinessConstants.SUB_TYPE_SALES.equals(subType)) {
materialExtend.setWholesaleDecimal(unitPrice);
}
if(BusinessConstants.SUB_TYPE_RETAIL.equals(subType)) {
materialExtend.setCommodityDecimal(unitPrice);
}
完善单价录入的时候更新商品的价格的逻辑
2024-02-23 17:32:15 +08:00
//其它入库-生产入库的情况更新采购单价
if(BusinessConstants.SUB_TYPE_OTHER.equals(subType)) {
if(BusinessConstants.BILL_TYPE_PRODUCE_IN.equals(billType)) {
materialExtend.setPurchaseDecimal(unitPrice);
}
}
给系统参数表增加更新单价启用标记，默认开启
2023-03-21 22:22:54 +08:00
materialExtendService.updateMaterialExtend(materialExtend);
录入采购、销售、零售单据的时候自动更新对应商品的价格
2022-09-18 18:51:36 +08:00
}
}
}
vue版本上线
2021-04-07 23:53:57 +08:00
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
给报表的接口增加商品类别的查询参数
2025-01-14 00:18:33 +08:00
public List<DepotItemStockWarningCount> findStockWarningCount(Integer offset, Integer rows, String materialParam, List<Long> depotList, List<Long> categoryList) {
vue版本上线
2021-04-07 23:53:57 +08:00
List<DepotItemStockWarningCount> list = null;
try{
给报表的接口增加商品类别的查询参数
2025-01-14 00:18:33 +08:00
list =depotItemMapperEx.findStockWarningCount(offset, rows, materialParam, depotList, categoryList);
vue版本上线
2021-04-07 23:53:57 +08:00
}catch(Exception e){
JshException.readFail(logger, e);
}
return list;
}
给报表的接口增加商品类别的查询参数
2025-01-14 00:18:33 +08:00
vue版本上线
2021-04-07 23:53:57 +08:00
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
给报表的接口增加商品类别的查询参数
2025-01-14 00:18:33 +08:00
public int findStockWarningCountTotal(String materialParam, List<Long> depotList, List<Long> categoryList) {
vue版本上线
2021-04-07 23:53:57 +08:00
int result = 0;
try{
给报表的接口增加商品类别的查询参数
2025-01-14 00:18:33 +08:00
result =depotItemMapperEx.findStockWarningCountTotal(materialParam, depotList, categoryList);
vue版本上线
2021-04-07 23:53:57 +08:00
}catch(Exception e){
JshException.readFail(logger, e);
}
return result;
}
优化库存逻辑和单据sku
2021-07-28 23:13:37 +08:00
/**
* 库存统计-sku
* @param depotId
* @param meId
* @param beginTime
* @param endTime
* @return
*/
优化商品库存查询逻辑，在没有选择仓库的时候过滤出当前有权限的仓库
2023-03-07 22:06:10 +08:00
public BigDecimal getSkuStockByParam(Long depotId, Long meId, String beginTime, String endTime) throws Exception {
将系统参数表的金额审核启用标记字段改为强审核标记字段
2023-03-17 23:05:03 +08:00
Boolean forceFlag = systemConfigService.getForceApprovalFlag();
修改库存统计的计算逻辑，根据出入库管理开关进行判断
2023-12-06 00:31:53 +08:00
Boolean inOutManageFlag = systemConfigService.getInOutManageFlag();
优化商品库存查询逻辑，在没有选择仓库的时候过滤出当前有权限的仓库
2023-03-07 22:06:10 +08:00
List<Long> depotList = depotService.parseDepotList(depotId);
给sku商品的库存计算增加盘点的数量
2023-05-22 22:25:46 +08:00
//盘点复盘后数量的变动
BigDecimal stockCheckSum = depotItemMapperEx.getSkuStockCheckSumByDepotList(depotList, meId, forceFlag, beginTime, endTime);
修改库存统计的计算逻辑，根据出入库管理开关进行判断
2023-12-06 00:31:53 +08:00
DepotItemVo4Stock stockObj = depotItemMapperEx.getSkuStockByParamWithDepotList(depotList, meId, forceFlag, inOutManageFlag, beginTime, endTime);
优化库存逻辑和单据sku
2021-07-28 23:13:37 +08:00
BigDecimal stockSum = BigDecimal.ZERO;
if(stockObj!=null) {
BigDecimal inTotal = stockObj.getInTotal();
BigDecimal transfInTotal = stockObj.getTransfInTotal();
BigDecimal assemInTotal = stockObj.getAssemInTotal();
BigDecimal disAssemInTotal = stockObj.getDisAssemInTotal();
BigDecimal outTotal = stockObj.getOutTotal();
BigDecimal transfOutTotal = stockObj.getTransfOutTotal();
BigDecimal assemOutTotal = stockObj.getAssemOutTotal();
BigDecimal disAssemOutTotal = stockObj.getDisAssemOutTotal();
stockSum = inTotal.add(transfInTotal).add(assemInTotal).add(disAssemInTotal)
.subtract(outTotal).subtract(transfOutTotal).subtract(assemOutTotal).subtract(disAssemOutTotal);
}
给sku商品的库存计算增加盘点的数量
2023-05-22 22:25:46 +08:00
return stockCheckSum.add(stockSum);
优化库存逻辑和单据sku
2021-07-28 23:13:37 +08:00
}
vue版本上线
2021-04-07 23:53:57 +08:00
/**
优化进销存统计接口
2021-12-07 00:26:08 +08:00
* 库存统计-单仓库
vue版本上线
2021-04-07 23:53:57 +08:00
* @param depotId
* @param mId
* @param beginTime
* @param endTime
* @return
*/
优化商品库存查询逻辑，在没有选择仓库的时候过滤出当前有权限的仓库
2023-03-07 22:06:10 +08:00
public BigDecimal getStockByParam(Long depotId, Long mId, String beginTime, String endTime) throws Exception {
List<Long> depotList = depotService.parseDepotList(depotId);
优化进销存统计接口
2021-12-07 00:26:08 +08:00
return getStockByParamWithDepotList(depotList, mId, beginTime, endTime);
}
/**
* 库存统计-多仓库
* @param depotList
* @param mId
* @param beginTime
* @param endTime
* @return
*/
给系统参数表增加库存审核启用标记
2023-03-16 22:41:07 +08:00
public BigDecimal getStockByParamWithDepotList(List<Long> depotList, Long mId, String beginTime, String endTime) throws Exception {
将系统参数表的金额审核启用标记字段改为强审核标记字段
2023-03-17 23:05:03 +08:00
Boolean forceFlag = systemConfigService.getForceApprovalFlag();
修改库存统计的计算逻辑，根据出入库管理开关进行判断
2023-12-06 00:31:53 +08:00
Boolean inOutManageFlag = systemConfigService.getInOutManageFlag();
vue版本上线
2021-04-07 23:53:57 +08:00
//初始库存
优化进销存统计接口
2021-12-07 00:26:08 +08:00
BigDecimal initStock = materialService.getInitStockByMidAndDepotList(depotList, mId);
vue版本上线
2021-04-07 23:53:57 +08:00
//盘点复盘后数量的变动
将系统参数表的金额审核启用标记字段改为强审核标记字段
2023-03-17 23:05:03 +08:00
BigDecimal stockCheckSum = depotItemMapperEx.getStockCheckSumByDepotList(depotList, mId, forceFlag, beginTime, endTime);
修改库存统计的计算逻辑，根据出入库管理开关进行判断
2023-12-06 00:31:53 +08:00
DepotItemVo4Stock stockObj = depotItemMapperEx.getStockByParamWithDepotList(depotList, mId, forceFlag, inOutManageFlag, beginTime, endTime);
优化库存逻辑和单据sku
2021-07-28 23:13:37 +08:00
BigDecimal stockSum = BigDecimal.ZERO;
if(stockObj!=null) {
BigDecimal inTotal = stockObj.getInTotal();
BigDecimal transfInTotal = stockObj.getTransfInTotal();
BigDecimal assemInTotal = stockObj.getAssemInTotal();
BigDecimal disAssemInTotal = stockObj.getDisAssemInTotal();
BigDecimal outTotal = stockObj.getOutTotal();
BigDecimal transfOutTotal = stockObj.getTransfOutTotal();
BigDecimal assemOutTotal = stockObj.getAssemOutTotal();
BigDecimal disAssemOutTotal = stockObj.getDisAssemOutTotal();
stockSum = inTotal.add(transfInTotal).add(assemInTotal).add(disAssemInTotal)
.subtract(outTotal).subtract(transfOutTotal).subtract(assemOutTotal).subtract(disAssemOutTotal);
}
return initStock.add(stockCheckSum).add(stockSum);
vue版本上线
2021-04-07 23:53:57 +08:00
}
/**
优化进销存统计报表的查询速度
2021-12-07 22:47:06 +08:00
* 统计时间段内的入库和出库数量-多仓库
优化进销存统计接口
2021-12-07 00:26:08 +08:00
* @param depotList
vue版本上线
2021-04-07 23:53:57 +08:00
* @param mId
* @param beginTime
* @param endTime
* @return
*/
给系统参数表增加库存审核启用标记
2023-03-16 22:41:07 +08:00
public Map<String, BigDecimal> getIntervalMapByParamWithDepotList(List<Long> depotList, Long mId, String beginTime, String endTime) throws Exception {
将系统参数表的金额审核启用标记字段改为强审核标记字段
2023-03-17 23:05:03 +08:00
Boolean forceFlag = systemConfigService.getForceApprovalFlag();
修改库存统计的计算逻辑，根据出入库管理开关进行判断
2023-12-06 00:31:53 +08:00
Boolean inOutManageFlag = systemConfigService.getInOutManageFlag();
优化进销存统计报表的查询速度
2021-12-07 22:47:06 +08:00
Map<String,BigDecimal> intervalMap = new HashMap<>();
BigDecimal inSum = BigDecimal.ZERO;
BigDecimal outSum = BigDecimal.ZERO;
//盘点复盘后数量的变动
将系统参数表的金额审核启用标记字段改为强审核标记字段
2023-03-17 23:05:03 +08:00
BigDecimal stockCheckSum = depotItemMapperEx.getStockCheckSumByDepotList(depotList, mId, forceFlag, beginTime, endTime);
修改库存统计的计算逻辑，根据出入库管理开关进行判断
2023-12-06 00:31:53 +08:00
DepotItemVo4Stock stockObj = depotItemMapperEx.getStockByParamWithDepotList(depotList, mId, forceFlag, inOutManageFlag, beginTime, endTime);
优化库存逻辑和单据sku
2021-07-28 23:13:37 +08:00
if(stockObj!=null) {
BigDecimal inTotal = stockObj.getInTotal();
BigDecimal transfInTotal = stockObj.getTransfInTotal();
BigDecimal assemInTotal = stockObj.getAssemInTotal();
BigDecimal disAssemInTotal = stockObj.getDisAssemInTotal();
优化进销存统计报表的查询速度
2021-12-07 22:47:06 +08:00
inSum = inTotal.add(transfInTotal).add(assemInTotal).add(disAssemInTotal);
优化库存逻辑和单据sku
2021-07-28 23:13:37 +08:00
BigDecimal outTotal = stockObj.getOutTotal();
BigDecimal transfOutTotal = stockObj.getTransfOutTotal();
BigDecimal assemOutTotal = stockObj.getAssemOutTotal();
BigDecimal disAssemOutTotal = stockObj.getDisAssemOutTotal();
解决库存计算的bug
2021-12-08 01:35:57 +08:00
outSum = outTotal.add(transfOutTotal).add(assemOutTotal).add(disAssemOutTotal);
优化库存逻辑和单据sku
2021-07-28 23:13:37 +08:00
}
优化进销存统计报表的查询速度
2021-12-07 22:47:06 +08:00
if(stockCheckSum.compareTo(BigDecimal.ZERO)>0) {
inSum = inSum.add(stockCheckSum);
} else {
//盘点复盘数量为负数代表出库
outSum = outSum.subtract(stockCheckSum);
}
intervalMap.put("inSum", inSum);
intervalMap.put("outSum", outSum);
return intervalMap;
vue版本上线
2021-04-07 23:53:57 +08:00
}
/**
* 根据单据明细来批量更新当前库存
* @param depotItem
*/
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
优化商品库存查询逻辑，在没有选择仓库的时候过滤出当前有权限的仓库
2023-03-07 22:06:10 +08:00
public void updateCurrentStock(DepotItem depotItem) throws Exception {
优化库存逻辑和单据sku
2021-07-28 23:13:37 +08:00
updateCurrentStockFun(depotItem.getMaterialId(), depotItem.getDepotId());
vue版本上线
2021-04-07 23:53:57 +08:00
if(depotItem.getAnotherDepotId()!=null){
优化库存逻辑和单据sku
2021-07-28 23:13:37 +08:00
updateCurrentStockFun(depotItem.getMaterialId(), depotItem.getAnotherDepotId());
vue版本上线
2021-04-07 23:53:57 +08:00
}
}
给单据保存中增加更新成本价的逻辑
2024-05-22 00:56:03 +08:00
/**
* 根据单据明细来批量更新当前成本价
* @param depotItem
*/
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
public void updateCurrentUnitPrice(DepotItem depotItem) throws Exception {
Boolean forceFlag = systemConfigService.getForceApprovalFlag();
Boolean inOutManageFlag = systemConfigService.getInOutManageFlag();
更新计量单位为多单位
2024-12-18 00:02:06 +08:00
//查询多单位信息
解决多单位商品的移动平均价计算的bug
2024-09-21 00:53:16 +08:00
Unit unitInfo = materialService.findUnit(depotItem.getMaterialId());
给单据保存中增加更新成本价的逻辑
2024-05-22 00:56:03 +08:00
List<DepotItemVo4DetailByTypeAndMId> itemList = findDetailByDepotIdsAndMaterialIdList(null, forceFlag, inOutManageFlag, depotItem.getSku(),
depotItem.getBatchNumber(), null, null, null, depotItem.getMaterialId(), null, null);
Collections.reverse(itemList); //倒序之后变成按时间从前往后排序
BigDecimal currentNumber = BigDecimal.ZERO;
BigDecimal currentUnitPrice = BigDecimal.ZERO;
BigDecimal currentAllPrice = BigDecimal.ZERO;
for(DepotItemVo4DetailByTypeAndMId item: itemList) {
解决计算成本价的时候空指针异常
2024-06-06 23:29:43 +08:00
BigDecimal basicNumber = item.getBnum()!=null?item.getBnum():BigDecimal.ZERO;
解决移动平均价遇到负库存情况下的bug
2024-11-07 18:09:47 +08:00
//数量*单价 另外计算新的成本价
BigDecimal allPrice = unitService.parseAllPriceByUnit(item.getAllPrice()!=null?item.getAllPrice():BigDecimal.ZERO, unitInfo, item.getMaterialUnit());
if(basicNumber.compareTo(BigDecimal.ZERO)!=0 && allPrice.compareTo(BigDecimal.ZERO)!=0) {
//入库
if (BusinessConstants.DEPOTHEAD_TYPE_IN.equals(item.getType())) {
//零售退货、销售退货
if (BusinessConstants.SUB_TYPE_RETAIL_RETURN.equals(item.getSubType()) || BusinessConstants.SUB_TYPE_SALES_RETURN.equals(item.getSubType())) {
//数量*当前的成本单价
currentNumber = currentNumber.add(basicNumber);
currentAllPrice = currentAllPrice.add(basicNumber.multiply(currentUnitPrice));
} else {
currentAllPrice = currentAllPrice.add(allPrice);
currentNumber = currentNumber.add(basicNumber);
//只有当前库存总金额和当前库存数量都大于0才计算移动平均价
if (currentAllPrice.compareTo(BigDecimal.ZERO) > 0 && currentNumber.compareTo(BigDecimal.ZERO) > 0) {
currentUnitPrice = currentAllPrice.divide(currentNumber, 2, BigDecimal.ROUND_HALF_UP);
} else {
currentUnitPrice = item.getUnitPrice();
}
解决修正成本的接口的bug
2024-05-24 23:55:29 +08:00
}
完善单据保存中增加更新成本价的逻辑
2024-05-23 23:29:32 +08:00
}
解决移动平均价遇到负库存情况下的bug
2024-11-07 18:09:47 +08:00
//出库
if (BusinessConstants.DEPOTHEAD_TYPE_OUT.equals(item.getType())) {
//采购退货
if (BusinessConstants.SUB_TYPE_PURCHASE_RETURN.equals(item.getSubType())) {
currentAllPrice = currentAllPrice.add(allPrice);
currentNumber = currentNumber.add(basicNumber);
//只有当前库存总金额和当前库存数量都大于0才计算移动平均价
if (currentAllPrice.compareTo(BigDecimal.ZERO) > 0 && currentNumber.compareTo(BigDecimal.ZERO) > 0) {
currentUnitPrice = currentAllPrice.divide(currentNumber, 2, BigDecimal.ROUND_HALF_UP);
} else {
currentUnitPrice = item.getUnitPrice();
}
} else {
currentNumber = currentNumber.add(basicNumber);
//数量*当前的成本单价
currentAllPrice = currentAllPrice.add(basicNumber.multiply(currentUnitPrice));
解决修正成本的接口的bug
2024-05-24 23:55:29 +08:00
}
完善单据保存中增加更新成本价的逻辑
2024-05-23 23:29:32 +08:00
}
解决移动平均价遇到负库存情况下的bug
2024-11-07 18:09:47 +08:00
//防止单价金额溢出
if(currentUnitPrice.compareTo(BigDecimal.valueOf(100000000))>0 || currentUnitPrice.compareTo(BigDecimal.valueOf(-100000000))<0) {
currentUnitPrice = BigDecimal.ZERO;
}
临时修改单据逻辑，防止单价金额溢出
2024-11-02 23:02:47 +08:00
}
给单据保存中增加更新成本价的逻辑
2024-05-22 00:56:03 +08:00
}
//更新实时库存中的当前单价
materialCurrentStockMapperEx.updateUnitPriceByMId(currentUnitPrice, depotItem.getMaterialId());
}
vue版本上线
2021-04-07 23:53:57 +08:00
/**
* 根据商品和仓库来更新当前库存
* @param mId
* @param dId
*/
优化商品库存查询逻辑，在没有选择仓库的时候过滤出当前有权限的仓库
2023-03-07 22:06:10 +08:00
public void updateCurrentStockFun(Long mId, Long dId) throws Exception {
给订单去除仓库
2021-09-23 22:44:13 +08:00
if(mId!=null && dId!=null) {
MaterialCurrentStockExample example = new MaterialCurrentStockExample();
example.createCriteria().andMaterialIdEqualTo(mId).andDepotIdEqualTo(dId)
.andDeleteFlagNotEqualTo(BusinessConstants.DELETE_FLAG_DELETED);
List<MaterialCurrentStock> list = materialCurrentStockMapper.selectByExample(example);
MaterialCurrentStock materialCurrentStock = new MaterialCurrentStock();
materialCurrentStock.setMaterialId(mId);
materialCurrentStock.setDepotId(dId);
materialCurrentStock.setCurrentNumber(getStockByParam(dId,mId,null,null));
if(list!=null && list.size()>0) {
Long mcsId = list.get(0).getId();
materialCurrentStock.setId(mcsId);
materialCurrentStockMapper.updateByPrimaryKeySelective(materialCurrentStock);
} else {
materialCurrentStockMapper.insertSelective(materialCurrentStock);
}
vue版本上线
2021-04-07 23:53:57 +08:00
}
}
给采购和销售单据支持分批操作
2021-09-25 22:09:36 +08:00
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
增加关联明细id字段，解决明细中重复商品进行批次发货遇到的问题
2022-05-28 22:36:33 +08:00
public BigDecimal getFinishNumber(Long meId, Long id, Long headerId, Unit unitInfo, String materialUnit, String linkType) {
Long linkId = id;
给采购和销售单据支持分批操作
2021-09-25 22:09:36 +08:00
String goToType = "";
DepotHead depotHead =depotHeadMapper.selectByPrimaryKey(headerId);
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
String linkStr = depotHead.getNumber(); //订单号
增加销售订单与采购订单的关联
2022-05-18 00:21:15 +08:00
if("purchase".equals(linkType)) {
优化已经完成明细的接口，增加退货单的相关逻辑
2022-09-15 01:04:01 +08:00
//针对以销定购的情况
增加销售订单与采购订单的关联
2022-05-18 00:21:15 +08:00
if(BusinessConstants.SUB_TYPE_SALES_ORDER.equals(depotHead.getSubType())) {
goToType = BusinessConstants.SUB_TYPE_PURCHASE_ORDER;
}
给单据的保存和查询相关接口增加其它入库和其它出库的关联逻辑
2023-12-05 00:23:40 +08:00
} else if("other".equals(linkType)) {
//采购入库、采购退货、销售出库、销售退货都转其它入库
if(BusinessConstants.SUB_TYPE_PURCHASE.equals(depotHead.getSubType())
|| BusinessConstants.SUB_TYPE_PURCHASE_RETURN.equals(depotHead.getSubType())
|| BusinessConstants.SUB_TYPE_SALES.equals(depotHead.getSubType())
|| BusinessConstants.SUB_TYPE_SALES_RETURN.equals(depotHead.getSubType())) {
goToType = BusinessConstants.SUB_TYPE_OTHER;
}
完善单据明细列表接口
2023-12-05 22:10:13 +08:00
} else if("basic".equals(linkType)) {
优化已经完成明细的接口，增加退货单的相关逻辑
2022-09-15 01:04:01 +08:00
//采购订单转采购入库
优化单据明细的查询条件
2022-05-19 00:12:37 +08:00
if(BusinessConstants.SUB_TYPE_PURCHASE_ORDER.equals(depotHead.getSubType())) {
goToType = BusinessConstants.SUB_TYPE_PURCHASE;
}
优化已经完成明细的接口，增加退货单的相关逻辑
2022-09-15 01:04:01 +08:00
//销售订单转销售出库
优化单据明细的查询条件
2022-05-19 00:12:37 +08:00
if(BusinessConstants.SUB_TYPE_SALES_ORDER.equals(depotHead.getSubType())) {
goToType = BusinessConstants.SUB_TYPE_SALES;
增加销售订单与采购订单的关联
2022-05-18 00:21:15 +08:00
}
优化已经完成明细的接口，增加退货单的相关逻辑
2022-09-15 01:04:01 +08:00
//采购入库转采购退货
if(BusinessConstants.SUB_TYPE_PURCHASE.equals(depotHead.getSubType())) {
goToType = BusinessConstants.SUB_TYPE_PURCHASE_RETURN;
}
//销售出库转销售退货
if(BusinessConstants.SUB_TYPE_SALES.equals(depotHead.getSubType())) {
goToType = BusinessConstants.SUB_TYPE_SALES_RETURN;
}
给采购和销售单据支持分批操作
2021-09-25 22:09:36 +08:00
}
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
String noType = "normal";
完善关联请购单中的数量计算逻辑
2024-04-23 00:54:24 +08:00
if(BusinessConstants.SUB_TYPE_PURCHASE_APPLY.equals(depotHead.getSubType())) {
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
noType = "apply";
}
BigDecimal count = depotItemMapperEx.getFinishNumber(meId, linkId, linkStr, noType, goToType);
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
//根据多单位情况进行数量的转换
给计量单位表修改比例的字段类型，给系统参数表增加金额审核启用标记，给单据增加来源字段
2023-03-09 00:01:50 +08:00
if(materialUnit.equals(unitInfo.getOtherUnit()) && unitInfo.getRatio()!=null && unitInfo.getRatio().compareTo(BigDecimal.ZERO)!=0) {
count = count.divide(unitInfo.getRatio(),2,BigDecimal.ROUND_HALF_UP);
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
}
给计量单位表修改比例的字段类型，给系统参数表增加金额审核启用标记，给单据增加来源字段
2023-03-09 00:01:50 +08:00
if(materialUnit.equals(unitInfo.getOtherUnitTwo()) && unitInfo.getRatioTwo()!=null && unitInfo.getRatioTwo().compareTo(BigDecimal.ZERO)!=0) {
count = count.divide(unitInfo.getRatioTwo(),2,BigDecimal.ROUND_HALF_UP);
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
}
给计量单位表修改比例的字段类型，给系统参数表增加金额审核启用标记，给单据增加来源字段
2023-03-09 00:01:50 +08:00
if(materialUnit.equals(unitInfo.getOtherUnitThree()) && unitInfo.getRatioThree()!=null && unitInfo.getRatioThree().compareTo(BigDecimal.ZERO)!=0) {
count = count.divide(unitInfo.getRatioThree(),2,BigDecimal.ROUND_HALF_UP);
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
}
return count;
}
/**
解决销售订单转采购订单的时候已转数量计算的bug
2022-10-20 23:05:37 +08:00
* 除去此单据之外的已入库|已出库|已转采购
* @param currentSubType
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
* @param meId
增加关联明细id字段，解决明细中重复商品进行批次发货遇到的问题
2022-05-28 22:36:33 +08:00
* @param linkId
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
* @param preHeaderId
* @param currentHeaderId
* @param unitInfo
* @param materialUnit
* @return
*/
@Transactional(value = "transactionManager", rollbackFor = Exception.class)
解决销售订单转采购订单的时候已转数量计算的bug
2022-10-20 23:05:37 +08:00
public BigDecimal getRealFinishNumber(String currentSubType, Long meId, Long linkId, Long preHeaderId, Long currentHeaderId, Unit unitInfo, String materialUnit) {
String goToType = currentSubType;
解决分批出入库状态切换的bug
2022-05-07 18:23:43 +08:00
DepotHead depotHead =depotHeadMapper.selectByPrimaryKey(preHeaderId);
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
String linkStr = depotHead.getNumber(); //订单号
String linkType = "normal";
完善关联请购单中的数量计算逻辑
2024-04-23 00:54:24 +08:00
if(BusinessConstants.SUB_TYPE_PURCHASE_APPLY.equals(depotHead.getSubType())) {
完善关联请购单中的数量计算逻辑
2024-04-23 00:44:25 +08:00
linkType = "apply";
}
BigDecimal count = depotItemMapperEx.getRealFinishNumber(meId, linkId, linkStr, linkType, currentHeaderId, goToType);
解决多单位商品，大单位时分批出库的时候的bug
2022-04-27 23:48:42 +08:00
//根据多单位情况进行数量的转换
给计量单位表修改比例的字段类型，给系统参数表增加金额审核启用标记，给单据增加来源字段
2023-03-09 00:01:50 +08:00
if(materialUnit.equals(unitInfo.getOtherUnit()) && unitInfo.getRatio()!=null && unitInfo.getRatio().compareTo(BigDecimal.ZERO)!=0) {
count = count.divide(unitInfo.getRatio(),2,BigDecimal.ROUND_HALF_UP);
解决多单位商品，大单位时分批出库的时候的bug
2022-04-27 23:48:42 +08:00
}
给计量单位表修改比例的字段类型，给系统参数表增加金额审核启用标记，给单据增加来源字段
2023-03-09 00:01:50 +08:00
if(materialUnit.equals(unitInfo.getOtherUnitTwo()) && unitInfo.getRatioTwo()!=null && unitInfo.getRatioTwo().compareTo(BigDecimal.ZERO)!=0) {
count = count.divide(unitInfo.getRatioTwo(),2,BigDecimal.ROUND_HALF_UP);
解决多单位商品，大单位时分批出库的时候的bug
2022-04-27 23:48:42 +08:00
}
给计量单位表修改比例的字段类型，给系统参数表增加金额审核启用标记，给单据增加来源字段
2023-03-09 00:01:50 +08:00
if(materialUnit.equals(unitInfo.getOtherUnitThree()) && unitInfo.getRatioThree()!=null && unitInfo.getRatioThree().compareTo(BigDecimal.ZERO)!=0) {
count = count.divide(unitInfo.getRatioThree(),2,BigDecimal.ROUND_HALF_UP);
解决多单位商品，大单位时分批出库的时候的bug
2022-04-27 23:48:42 +08:00
}
给采购和销售单据支持分批操作
2021-09-25 22:09:36 +08:00
return count;
}
增加批次商品选择
2021-09-29 01:17:20 +08:00
解决获取批次商品列表信息接口的bug
2023-12-15 00:11:56 +08:00
public List<DepotItemVoBatchNumberList> getBatchNumberList(String number, String name, Long depotId, String barCode,
String batchNumber, Boolean forceFlag, Boolean inOutManageFlag) throws Exception {
修改获取批次商品列表信息的接口的查询逻辑
2023-04-01 23:26:07 +08:00
List<DepotItemVoBatchNumberList> reslist = new ArrayList<>();
解决获取批次商品列表信息接口的bug
2023-12-15 00:11:56 +08:00
List<DepotItemVoBatchNumberList> list = depotItemMapperEx.getBatchNumberList(StringUtil.toNull(number), name,
depotId, barCode, batchNumber, forceFlag, inOutManageFlag);
修改获取批次商品列表信息的接口的查询逻辑
2023-04-01 23:26:07 +08:00
for(DepotItemVoBatchNumberList bn: list) {
if(bn.getTotalNum()!=null && bn.getTotalNum().compareTo(BigDecimal.ZERO)>0) {
bn.setExpirationDateStr(Tools.parseDateToStr(bn.getExpirationDate()));
if(bn.getUnitId()!=null) {
Unit unit = unitService.getUnit(bn.getUnitId());
String commodityUnit = bn.getCommodityUnit();
bn.setTotalNum(unitService.parseStockByUnit(bn.getTotalNum(), unit, commodityUnit));
}
reslist.add(bn);
}
}
return reslist;
增加批次商品选择
2021-09-29 01:17:20 +08:00
}
优化商品导入，提高速度
2022-05-13 18:25:57 +08:00
解决bug：批次商品进行销售出库的时候，数量超出库存确出库了，而且没开负库存
2024-05-15 00:53:31 +08:00
/**
* 查询某个批号的商品库存
* @param depotId
* @param barCode
* @param batchNumber
* @return
* @throws Exception
*/
public BigDecimal getOneBatchNumberStock(Long depotId, String barCode, String batchNumber) throws Exception {
BigDecimal totalNum = BigDecimal.ZERO;
Boolean forceFlag = systemConfigService.getForceApprovalFlag();
Boolean inOutManageFlag = systemConfigService.getInOutManageFlag();
List<DepotItemVoBatchNumberList> list = depotItemMapperEx.getBatchNumberList(null, null,
depotId, barCode, batchNumber, forceFlag, inOutManageFlag);
if(list!=null && list.size()>0) {
DepotItemVoBatchNumberList bn = list.get(0);
totalNum = bn.getTotalNum();
if(bn.getTotalNum()!=null && bn.getTotalNum().compareTo(BigDecimal.ZERO)>0) {
if(bn.getUnitId()!=null) {
Unit unit = unitService.getUnit(bn.getUnitId());
String commodityUnit = bn.getCommodityUnit();
totalNum = unitService.parseStockByUnit(bn.getTotalNum(), unit, commodityUnit);
}
}
}
return totalNum;
}
优化商品导入，提高速度
2022-05-13 18:25:57 +08:00
public Long getCountByMaterialAndDepot(Long mId, Long depotId) {
return depotItemMapperEx.getCountByMaterialAndDepot(mId, depotId);
}
给单据增加接口：Excel导入明细
2023-05-12 00:47:49 +08:00
完善订单明细导入中库存的计算逻辑
2023-05-23 23:29:21 +08:00
public JSONObject parseMapByExcelData(String barCodes, List<Map<String, String>> detailList, String prefixNo) throws Exception {
给单据增加接口：Excel导入明细
2023-05-12 00:47:49 +08:00
JSONObject map = new JSONObject();
单据明细导入：校验条码是否存在
2023-05-14 22:40:59 +08:00
JSONArray arr = new JSONArray();
List<MaterialVo4Unit> list = depotItemMapperEx.getBillItemByParam(barCodes);
Map<String, MaterialVo4Unit> materialMap = new HashMap<>();
优化单据明细导入接口的逻辑
2023-11-13 00:26:32 +08:00
Map<String, Long> depotMap = new HashMap<>();
单据明细导入：校验条码是否存在
2023-05-14 22:40:59 +08:00
for (MaterialVo4Unit material: list) {
materialMap.put(material.getmBarCode(), material);
}
优化单据明细导入接口的逻辑
2023-11-13 00:26:32 +08:00
JSONArray depotArr = depotService.findDepotByCurrentUser();
for (Object depotObj: depotArr) {
if(depotObj!=null) {
JSONObject depotObject = JSONObject.parseObject(depotObj.toString());
depotMap.put(depotObject.getString("depotName"), depotObject.getLong("id"));
}
}
单据明细导入：校验条码是否存在
2023-05-14 22:40:59 +08:00
for (Map<String, String> detailMap: detailList) {
JSONObject item = new JSONObject();
String barCode = detailMap.get("barCode");
优化订单中明细的excel导入
2023-05-23 22:03:01 +08:00
if(StringUtil.isNotEmpty(barCode)) {
MaterialVo4Unit m = materialMap.get(barCode);
if(m!=null) {
优化单据明细导入接口的逻辑
2023-11-13 00:26:32 +08:00
//判断仓库是否存在
String depotName = detailMap.get("depotName");
if(StringUtil.isNotEmpty(depotName)) {
if(depotMap.get(depotName)!=null) {
item.put("depotName", depotName);
item.put("depotId", depotMap.get(depotName));
} else {
throw new BusinessRunTimeException(ExceptionConstants.DEPOT_ITEM_DEPOTNAME_IS_NOT_EXIST_CODE,
String.format(ExceptionConstants.DEPOT_ITEM_DEPOTNAME_IS_NOT_EXIST_MSG, depotName));
}
}
优化订单中明细的excel导入
2023-05-23 22:03:01 +08:00
item.put("barCode", barCode);
item.put("name", m.getName());
item.put("standard", m.getStandard());
if(StringUtil.isNotEmpty(m.getModel())) {
item.put("model", m.getModel());
完善单据明细导入接口的逻辑
2023-05-12 19:53:08 +08:00
}
优化订单中明细的excel导入
2023-05-23 22:03:01 +08:00
if(StringUtil.isNotEmpty(m.getColor())) {
item.put("color", m.getColor());
}
if(StringUtil.isNotEmpty(m.getSku())) {
item.put("sku", m.getSku());
}
完善订单明细导入中库存的计算逻辑
2023-05-23 23:29:21 +08:00
BigDecimal stock = BigDecimal.ZERO;
if(StringUtil.isNotEmpty(m.getSku())){
stock = getSkuStockByParam(null, m.getMeId(),null,null);
} else {
优化库存查询逻辑，直接查库存表
2023-08-06 22:43:35 +08:00
stock = getCurrentStockByParam(null, m.getId());
完善订单明细导入中库存的计算逻辑
2023-05-23 23:29:21 +08:00
}
优化订单中明细的excel导入
2023-05-23 22:03:01 +08:00
item.put("stock", stock);
item.put("unit", m.getCommodityUnit());
BigDecimal operNumber = BigDecimal.ZERO;
BigDecimal unitPrice = BigDecimal.ZERO;
BigDecimal taxRate = BigDecimal.ZERO;
if(StringUtil.isNotEmpty(detailMap.get("num"))) {
operNumber = new BigDecimal(detailMap.get("num"));
}
if(StringUtil.isNotEmpty(detailMap.get("unitPrice"))) {
unitPrice = new BigDecimal(detailMap.get("unitPrice"));
} else {
if("CGDD".equals(prefixNo)) {
unitPrice = m.getPurchaseDecimal();
} else if("XSDD".equals(prefixNo)) {
unitPrice = m.getWholesaleDecimal();
}
}
if(StringUtil.isNotEmpty(detailMap.get("taxRate"))) {
taxRate = new BigDecimal(detailMap.get("taxRate"));
}
String remark = detailMap.get("remark");
item.put("operNumber", operNumber);
item.put("unitPrice", unitPrice);
BigDecimal allPrice = BigDecimal.ZERO;
if(unitPrice!=null && unitPrice.compareTo(BigDecimal.ZERO)!=0) {
allPrice = unitPrice.multiply(operNumber);
}
BigDecimal taxMoney = BigDecimal.ZERO;
if(taxRate.compareTo(BigDecimal.ZERO) != 0) {
taxMoney = taxRate.multiply(allPrice).divide(BigDecimal.valueOf(100), 2, BigDecimal.ROUND_HALF_UP);
}
BigDecimal taxLastMoney = allPrice.add(taxMoney);
item.put("allPrice", allPrice);
item.put("taxRate", taxRate);
item.put("taxMoney", taxMoney);
item.put("taxLastMoney", taxLastMoney);
item.put("remark", remark);
arr.add(item);
} else {
throw new BusinessRunTimeException(ExceptionConstants.DEPOT_ITEM_BARCODE_IS_NOT_EXIST_CODE,
String.format(ExceptionConstants.DEPOT_ITEM_BARCODE_IS_NOT_EXIST_MSG, barCode));
给单据增加接口：Excel导入明细
2023-05-12 00:47:49 +08:00
}
}
}
单据明细导入：校验条码是否存在
2023-05-14 22:40:59 +08:00
map.put("rows", arr);
给单据增加接口：Excel导入明细
2023-05-12 00:47:49 +08:00
return map;
}
从接口实现销售价每个客户不同的价格
2023-06-11 18:47:07 +08:00
public BigDecimal getLastUnitPriceByParam(Long organId, Long meId, String prefixNo) {
String type = "";
String subType = "";
if("XSDD".equals(prefixNo)) {
type = "其它";
subType = "销售订单";
} else if("XSCK".equals(prefixNo)) {
type = "出库";
subType = "销售";
} else if("XSTH".equals(prefixNo)) {
type = "入库";
subType = "销售退货";
} else if("QTCK".equals(prefixNo)) {
type = "出库";
subType = "其它";
}
return depotItemMapperEx.getLastUnitPriceByParam(organId, meId, type, subType);
}
优化库存查询逻辑，直接查库存表
2023-08-06 22:43:35 +08:00
public BigDecimal getCurrentStockByParam(Long depotId, Long mId) {
解决实时库存查询为null的bug
2023-08-11 18:49:05 +08:00
BigDecimal stock = depotItemMapperEx.getCurrentStockByParam(depotId, mId);
return stock!=null? stock: BigDecimal.ZERO;
优化库存查询逻辑，直接查库存表
2023-08-06 22:43:35 +08:00
}
vue版本上线
2021-04-07 23:53:57 +08:00
}
Reference in New Issue Copy Permalink