package com.example.erp.service.mm;
|
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.dynamic.datasource.annotation.DS;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.example.erp.dto.mm.FinishedOperateLogDTO;
|
import com.example.erp.entity.mm.FinishedGoodsInventory;
|
import com.example.erp.entity.mm.FinishedOperateLog;
|
import com.example.erp.entity.pp.FlowCard;
|
import com.example.erp.entity.sd.Delivery;
|
import com.example.erp.entity.sd.DeliveryDetail;
|
import com.example.erp.entity.sd.Order;
|
import com.example.erp.entity.sd.OrderDetail;
|
import com.example.erp.entity.userInfo.Log;
|
import com.example.erp.entity.userInfo.SysError;
|
import com.example.erp.mapper.mm.BasicWarehouseTypeMapper;
|
import com.example.erp.mapper.mm.FinishedGoodsInventoryMapper;
|
import com.example.erp.mapper.mm.FinishedOperateLogMapper;
|
import com.example.erp.mapper.sd.OrderDetailMapper;
|
import com.example.erp.mapper.sd.OrderMapper;
|
import com.example.erp.service.userInfo.LogService;
|
import com.example.erp.service.userInfo.SysErrorService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.transaction.interceptor.TransactionAspectSupport;
|
|
import java.sql.SQLException;
|
import java.sql.Wrapper;
|
import java.text.SimpleDateFormat;
|
import java.time.LocalDate;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@Service
|
@DS("mm")
|
@Transactional(rollbackFor = Exception.class)
|
public class FinishedGoodsInventoryService {
|
@Autowired
|
FinishedGoodsInventoryMapper finishedGoodsInventoryMapper;
|
@Autowired
|
FinishedOperateLogMapper finishedOperateLogMapper;
|
@Autowired
|
BasicWarehouseTypeMapper basicWarehouseTypeMapper;
|
@Autowired
|
OrderDetailMapper orderDetailMapper;
|
@Autowired
|
OrderMapper orderMapper;
|
@Autowired
|
SysErrorService sysErrorService;
|
@Autowired
|
LogService logService;
|
|
public Map<String, Object> defaultDateFinishedGoodsInventory(Integer pageNum, Integer pageSize, FinishedGoodsInventory finishedGoodsInventory) {
|
Integer offset = (pageNum - 1) * pageSize;
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", finishedGoodsInventoryMapper.defaultfinishedGoods(offset, pageSize, finishedGoodsInventory));
|
map.put("total", finishedGoodsInventoryMapper.getPageTotal(offset, pageSize, finishedGoodsInventory));
|
return map;
|
}
|
|
public Map<String, Object> getSelectWarehousing(Integer pageNum, Integer pageSize, FlowCard flowCard) {
|
Integer offset = (pageNum - 1) * pageSize;
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", finishedGoodsInventoryMapper.getSelectWarehousing(offset, pageSize, flowCard));
|
map.put("total", finishedGoodsInventoryMapper.getSelectWarehousingPageTotal(offset, pageSize, flowCard));
|
|
return map;
|
}
|
|
public String addSelectWarehousing(Map<String,Object> object) {
|
String saveState = "true";
|
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
|
try {
|
//定义前端传输的数据
|
String storageRegion = "";
|
String remark = "";
|
String container = "";
|
if (object.get("remark") != null) {
|
remark = object.get("remark").toString();
|
}
|
if (object.get("storageRegion") != null) {
|
storageRegion = object.get("storageRegion").toString();
|
}
|
if (object.get("container") != null) {
|
container = object.get("container").toString();
|
}
|
|
String userName = "";
|
String userId = "";
|
if (object.get("userName") != null) {
|
userName = object.get("userName").toString();
|
}
|
if (object.get("userId") != null) {
|
userId = object.get("userId").toString();
|
}
|
Log log = new Log();
|
log.setOperator(userName);
|
log.setOperatorId(userId);
|
log.setContent(object.toString());
|
log.setFunction("addSelectWarehousing入库");
|
logService.saveLog(log);
|
|
//获取对象集合循环进行新增修改
|
List<FlowCard> flowCardlist = JSONArray.parseArray(JSONObject.toJSONString(object.get("flowCard")), FlowCard.class);
|
if (!flowCardlist.isEmpty()){
|
//获取单号
|
String oddNumber= orderNumberSetting("入库");
|
for (FlowCard flowCard : flowCardlist) {
|
//添加出入库记录
|
finishedOperateLogMapper.insertIntFinishedOperateLog(flowCard,userName,oddNumber,container);
|
Integer finishedGoodsInventorycount = finishedGoodsInventoryMapper.findOrderNumberdcount(flowCard.getOrder().getOrderId(),flowCard.getOrderNumber());
|
Integer ordersum = finishedGoodsInventoryMapper.findOrderQuantity(flowCard.getOrder().getOrderId());
|
Integer ordernumbersum = finishedGoodsInventoryMapper.findOrderNumberdsum(flowCard.getOrder().getOrderId());
|
FlowCard flowCard1=finishedGoodsInventoryMapper.findFlowCard(flowCard);
|
//判断库存数是否大于未入库数
|
if(flowCard1.getReceivedQuantity()+flowCard.getInventoryQuantity()<=flowCard1.getInventoryQuantity()){
|
/*System.out.println("订单总数:" + ordersum + "已入库数量：" + ordernumbersum + "准备入库数量" + flowCard.getInventoryQuantity());*/
|
if (finishedGoodsInventorycount > 0) {
|
//修改库存表入库数量
|
finishedGoodsInventoryMapper.updateInventory(flowCard,storageRegion, remark);
|
//修改流程卡表入库数量
|
finishedGoodsInventoryMapper.updateflowcard(flowCard);
|
//修改订单表入库状态
|
finishedGoodsInventoryMapper.updateOrderWarehousingState(flowCard.getOrder().getOrderId(),1);
|
//修改订单明细表入库数量
|
finishedGoodsInventoryMapper.updateIntOrderNumberConut(flowCard.getOrder().getOrderId(),flowCard.getOrderNumber(), Long.valueOf(flowCard.getInventoryQuantity()));
|
//判断订单是否全部入库
|
if (ordersum == (ordernumbersum + flowCard.getInventoryQuantity())) {
|
//修改订单表入库状态
|
finishedGoodsInventoryMapper.updateOrderWarehousingState(flowCard.getOrder().getOrderId(),2);
|
}
|
} else {
|
if (finishedGoodsInventoryMapper.insertFinishedGoodsInventory(flowCard, storageRegion, remark)) {
|
//修改流程卡表入库数量
|
finishedGoodsInventoryMapper.updateflowcard(flowCard);
|
//修改订单明细表入库数量
|
finishedGoodsInventoryMapper.updateIntOrderNumberConut(flowCard.getOrder().getOrderId(),flowCard.getOrderNumber(), Long.valueOf(flowCard.getInventoryQuantity()));
|
if (ordersum == (ordernumbersum + flowCard.getInventoryQuantity())) {
|
//修改订单表入库状态
|
finishedGoodsInventoryMapper.updateOrderWarehousingState(flowCard.getOrder().getOrderId(),2);
|
}else{
|
//修改订单表入库状态
|
finishedGoodsInventoryMapper.updateOrderWarehousingState(flowCard.getOrder().getOrderId(),1);
|
}
|
|
|
}
|
}
|
}else{
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
return "false1";
|
}
|
|
|
}
|
}else{
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
return "false2";
|
}
|
|
} catch (Exception e) {
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
//将异常传入数据库
|
SysError sysError = new SysError();
|
sysError.setError(e+Arrays.toString(e.getStackTrace()));
|
sysError.setFunc("addSelectWarehousing");
|
sysErrorService.insert(sysError);
|
saveState = "false";
|
|
}
|
|
return saveState;
|
|
}
|
|
|
public Map<String, Object> getSelectDeliveryDetail(Integer pageNum, Integer pageSize, OrderDetail orderDetail) {
|
Integer offset = (pageNum - 1) * pageSize;
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", finishedGoodsInventoryMapper.getSelectDeliveryDetail(offset, pageSize, orderDetail));
|
map.put("total", finishedGoodsInventoryMapper.getSelectDeliveryDetailPageTotal(offset, pageSize, orderDetail));
|
return map;
|
}
|
|
|
public String addDeliveryDetail(Map<String,Object> object) {
|
String saveState = "true";
|
//设置回滚点
|
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
|
try {
|
String userName = "";
|
String userId = "";
|
if (object.get("userName") != null) {
|
userName = object.get("userName").toString();
|
}
|
if (object.get("userId") != null) {
|
userId = object.get("userId").toString();
|
}
|
Log log = new Log();
|
log.setOperator(userName);
|
log.setOperatorId(userId);
|
log.setContent(object.toString());
|
log.setFunction("addDeliveryDetail出库");
|
logService.saveLog(log);
|
//获取对象集合循环进行新增修改
|
List<OrderDetail> orderDetaillist = JSONArray.parseArray(JSONObject.toJSONString(object.get("orderDetail")), OrderDetail.class);
|
if (!orderDetaillist.isEmpty()){
|
|
if(!Objects.equals(deliveryDetailLogic(orderDetaillist, savePoint, userName), "true")) {
|
return deliveryDetailLogic(orderDetaillist, savePoint, userName);
|
}
|
}
|
|
} catch (Exception e) {
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
//将异常传入数据库
|
SysError sysError = new SysError();
|
sysError.setError(e+Arrays.toString(e.getStackTrace()));
|
sysError.setFunc("addDeliveryDetail");
|
sysErrorService.insert(sysError);
|
saveState = "false";
|
|
}
|
return saveState;
|
|
}
|
|
public Map<String, Object> getSelectAllocate(Integer pageNum, Integer pageSize, OrderDetail orderDetail) {
|
Integer offset = (pageNum - 1) * pageSize;
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", finishedGoodsInventoryMapper.getSelectAllocate(offset, pageSize, orderDetail));
|
map.put("total", finishedGoodsInventoryMapper.getSelectAllocatePageTotal(offset, pageSize, orderDetail));
|
map.put("type", basicWarehouseTypeMapper.getBasicWarehouseTypeTakeOut());
|
map.put("types", basicWarehouseTypeMapper.getBasicWarehouseTypeRework());
|
return map;
|
}
|
|
public Boolean updateFinishedGoodsInventoryAllocate(Map<String,Object> object) {
|
boolean saveState = true;
|
//设置回滚点
|
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
|
try {
|
String userName = "";
|
String userId = "";
|
if (object.get("userName") != null) {
|
userName = object.get("userName").toString();
|
}
|
if (object.get("userId") != null) {
|
userId = object.get("userId").toString();
|
}
|
Log log = new Log();
|
log.setOperator(userName);
|
log.setOperatorId(userId);
|
log.setContent(object.toString());
|
log.setFunction("updateFinishedGoodsInventoryAllocate调拨");
|
logService.saveLog(log);
|
//获取对象集合循环进行新增修改
|
List<OrderDetail> orderDetaillist = JSONArray.parseArray(JSONObject.toJSONString(object.get("orderDetail")), OrderDetail.class);
|
if (!orderDetaillist.isEmpty()){
|
for (OrderDetail orderDetail : orderDetaillist) {
|
Integer oldordersum = finishedGoodsInventoryMapper.findOrderQuantity(orderDetail.getFinishedGoodsInventory().getOrderId());
|
Integer oldordernumbersum = finishedGoodsInventoryMapper.findOrderNumberdsum(orderDetail.getFinishedGoodsInventory().getOrderId());
|
|
Integer newordersum = finishedGoodsInventoryMapper.findOrderQuantity(orderDetail.getOrderId());
|
Integer newordernumbersum = finishedGoodsInventoryMapper.findOrderNumberdsum(orderDetail.getOrderId());
|
|
//获取单号
|
String oddNumber= orderNumberSetting("调拨");
|
//添加调拨记录
|
finishedOperateLogMapper.insertFinishedOperateLogAllocate(orderDetail,userName,oddNumber);
|
//修改原订单的库存数量
|
finishedGoodsInventoryMapper.updateInventoryquantityAllocateOut(orderDetail.getFinishedGoodsInventory().getOrderId(),orderDetail.getFinishedGoodsInventory().getOrderNumber(), Math.toIntExact(orderDetail.getQuantity()));
|
//修改调拨后订单的库存数量
|
finishedGoodsInventoryMapper.updateInventoryquantityAllocateInt(orderDetail.getOrderId(),orderDetail.getOrderNumber(), Math.toIntExact(orderDetail.getQuantity()));
|
//修改原订单明细表发货数量
|
finishedGoodsInventoryMapper.updateOutOrderNumberConut(orderDetail.getFinishedGoodsInventory().getOrderId(),orderDetail.getFinishedGoodsInventory().getOrderNumber(), Math.toIntExact(orderDetail.getQuantity()));
|
//修改调拨新订单明细表发货数量
|
finishedGoodsInventoryMapper.updateIntOrderNumberConut(orderDetail.getOrderId(),orderDetail.getOrderNumber(), orderDetail.getQuantity());
|
if (newordersum==newordernumbersum+orderDetail.getQuantity()){
|
//修改订单表入库状态
|
finishedGoodsInventoryMapper.updateOrderWarehousingState(orderDetail.getOrderId(),2);
|
}
|
if (Objects.equals(oldordersum, oldordernumbersum)){
|
//修改订单表入库状态
|
finishedGoodsInventoryMapper.updateOrderWarehousingState(orderDetail.getFinishedGoodsInventory().getOrderId(),1);
|
}
|
}
|
}
|
|
} catch (Exception e) {
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
//将异常传入数据库
|
SysError sysError = new SysError();
|
sysError.setError(e+Arrays.toString(e.getStackTrace()));
|
sysError.setFunc("updateFinishedGoodsInventoryAllocate");
|
sysErrorService.insert(sysError);
|
saveState = false;
|
|
}
|
return saveState;
|
|
|
}
|
|
public Map<String, Object> getSelectAllocateFinishedOperateLog(Integer pageNum, Integer pageSize,List<String> selectDate, FinishedOperateLog finishedOperateLog) {
|
Integer offset = (pageNum - 1) * pageSize;
|
|
String endDate = LocalDate.now().toString();
|
String startDate = LocalDate.now().minusDays(15).toString();
|
if(selectDate !=null && selectDate.size()==2){
|
if(!selectDate.get(0).isEmpty()){
|
startDate = selectDate.get(0);
|
}
|
if(!selectDate.get(1).isEmpty()){
|
endDate = selectDate.get(1);
|
}
|
}
|
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", finishedOperateLogMapper.getselectAllocateFinishedOperateLog(offset, pageSize,startDate,endDate, finishedOperateLog));
|
map.put("total", finishedOperateLogMapper.getselectAllocateFinishedOperateLogPageTotal(offset, pageSize,startDate,endDate, finishedOperateLog));
|
List<String> list = new ArrayList<>();
|
list.add(startDate);
|
list.add(endDate);
|
map.put("selectDate",list);
|
return map;
|
}
|
|
public Boolean updateFinishedGoodsInventoryTakeOut(Map<String,Object> object) {
|
boolean saveState = true;
|
//设置回滚点
|
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
|
try {
|
String userName = "";
|
String userId = "";
|
if (object.get("userName") != null) {
|
userName = object.get("userName").toString();
|
}
|
if (object.get("userId") != null) {
|
userId = object.get("userId").toString();
|
}
|
|
String operateType = "";
|
String remarks = "";
|
if (object.get("remarks") != null) {
|
remarks = object.get("remarks").toString();
|
}
|
if (object.get("operateType") != null) {
|
operateType = object.get("operateType").toString();
|
}
|
Log log = new Log();
|
log.setOperator(userName);
|
log.setOperatorId(userId);
|
log.setContent(object.toString());
|
log.setFunction("updateFinishedGoodsInventoryTakeOut领出");
|
logService.saveLog(log);
|
//获取对象集合循环进行新增修改
|
List<OrderDetail> orderDetaillist = JSONArray.parseArray(JSONObject.toJSONString(object.get("orderDetail")), OrderDetail.class);
|
if (!orderDetaillist.isEmpty()){
|
for (OrderDetail orderDetail : orderDetaillist) {
|
Integer oldordersum = finishedGoodsInventoryMapper.findOrderQuantity(orderDetail.getFinishedGoodsInventory().getOrderId());
|
Integer oldordernumbersum = finishedGoodsInventoryMapper.findOrderNumberdsum(orderDetail.getFinishedGoodsInventory().getOrderId());
|
|
//获取单号
|
String oddNumber= orderNumberSetting("领出");
|
//添加领出记录
|
finishedOperateLogMapper.insertFinishedOperateLogTakeOut(orderDetail,userName,oddNumber,operateType,remarks);
|
//修改库存数量
|
finishedGoodsInventoryMapper.updateInventoryquantityOut(orderDetail.getFinishedGoodsInventory().getOrderId(),orderDetail.getFinishedGoodsInventory().getOrderNumber(), Math.toIntExact(orderDetail.getQuantity()));
|
//修改订单明细表数量
|
finishedGoodsInventoryMapper.updateOutOrderNumberConut(orderDetail.getFinishedGoodsInventory().getOrderId(),orderDetail.getFinishedGoodsInventory().getOrderNumber(), Math.toIntExact(orderDetail.getQuantity()));
|
if (Objects.equals(oldordersum, oldordernumbersum)){
|
//修改订单表入库状态
|
finishedGoodsInventoryMapper.updateOrderWarehousingState(orderDetail.getFinishedGoodsInventory().getOrderId(),1);
|
}
|
}
|
}
|
|
} catch (Exception e) {
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
//将异常传入数据库
|
SysError sysError = new SysError();
|
sysError.setError(e+Arrays.toString(e.getStackTrace()));
|
sysError.setFunc("updateFinishedGoodsInventoryTakeOut");
|
sysErrorService.insert(sysError);
|
saveState = false;
|
|
}
|
return saveState;
|
|
}
|
|
|
public Map<String, Object> getSelectOperateRecord(Integer pageNum, Integer pageSize, List<String> selectDate, FinishedOperateLog finishedOperateLog) {
|
Integer offset = (pageNum-1)*pageSize;
|
String endDate = LocalDate.now().toString();
|
String startDate = LocalDate.now().minusDays(15).toString();
|
if(selectDate !=null && selectDate.size()==2){
|
if(!selectDate.get(0).isEmpty()){
|
startDate = selectDate.get(0);
|
}
|
if(!selectDate.get(1).isEmpty()){
|
endDate = selectDate.get(1);
|
}
|
}
|
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", finishedOperateLogMapper.getSelectOperateRecord(offset, pageSize,startDate, endDate, finishedOperateLog));
|
map.put("total", finishedOperateLogMapper.getSelectOperateRecordLogPageTotal(offset, pageSize,startDate, endDate, finishedOperateLog));
|
List<String> list = new ArrayList<>();
|
list.add(startDate);
|
list.add(endDate);
|
map.put("selectDate",list);
|
return map;
|
}
|
|
|
public Boolean updateFinishedGoodsInventoryRework(Map<String,Object> object) {
|
boolean saveState = true;
|
//设置回滚点
|
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
|
try {
|
String userName = "";
|
String userId = "";
|
if (object.get("userName") != null) {
|
userName = object.get("userName").toString();
|
}
|
if (object.get("userId") != null) {
|
userId = object.get("userId").toString();
|
}
|
|
String operateType = "";
|
String remarks = "";
|
if (object.get("remarks") != null) {
|
remarks = object.get("remarks").toString();
|
}
|
if (object.get("operateType") != null) {
|
operateType = object.get("operateType").toString();
|
}
|
//获取对象集合循环进行新增修改
|
List<OrderDetail> orderDetaillist = JSONArray.parseArray(JSONObject.toJSONString(object.get("orderDetail")), OrderDetail.class);
|
if (!orderDetaillist.isEmpty()){
|
for (OrderDetail orderDetail : orderDetaillist) {
|
Integer oldordersum = finishedGoodsInventoryMapper.findOrderQuantity(orderDetail.getFinishedGoodsInventory().getOrderId());
|
Integer oldordernumbersum = finishedGoodsInventoryMapper.findOrderNumberdsum(orderDetail.getFinishedGoodsInventory().getOrderId());
|
|
//获取单号
|
String oddNumber= orderNumberSetting("返工");
|
//添加领出记录
|
finishedOperateLogMapper.insertFinishedOperateLogRework(orderDetail,userName,oddNumber,operateType,remarks);
|
//修改库存数量
|
finishedGoodsInventoryMapper.updateInventoryquantityOut(orderDetail.getFinishedGoodsInventory().getOrderId(),orderDetail.getFinishedGoodsInventory().getOrderNumber(), Math.toIntExact(orderDetail.getQuantity()));
|
//修改订单明细表数量
|
finishedGoodsInventoryMapper.updateOutOrderNumberConut(orderDetail.getFinishedGoodsInventory().getOrderId(),orderDetail.getFinishedGoodsInventory().getOrderNumber(), Math.toIntExact(orderDetail.getQuantity()));
|
if (Objects.equals(oldordersum, oldordernumbersum)){
|
//修改订单表入库状态
|
finishedGoodsInventoryMapper.updateOrderWarehousingState(orderDetail.getFinishedGoodsInventory().getOrderId(),1);
|
}
|
}
|
}
|
|
} catch (Exception e) {
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
//将异常传入数据库
|
SysError sysError = new SysError();
|
sysError.setError(e+Arrays.toString(e.getStackTrace()));
|
sysError.setFunc("updateFinishedGoodsInventoryRework");
|
sysErrorService.insert(sysError);
|
saveState = false;
|
|
}
|
return saveState;
|
|
}
|
|
|
public Boolean updateFinishedGoodsInventoryToExamine(Map<String,Object> object,String type) {
|
boolean saveState = true;
|
//设置回滚点
|
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
|
try {
|
String userName = "";
|
String userId = "";
|
if (object.get("userName") != null) {
|
userName = object.get("userName").toString();
|
}
|
if (object.get("userId") != null) {
|
userId = object.get("userId").toString();
|
}
|
Log log = new Log();
|
log.setOperator(userName);
|
log.setOperatorId(userId);
|
log.setContent(object.toString());
|
//获取对象集合循环进行新增修改
|
List<FinishedOperateLog> finishedOperateLogslist = JSONArray.parseArray(JSONObject.toJSONString(object.get("orderDetail")), FinishedOperateLog.class);
|
if (!finishedOperateLogslist.isEmpty()){
|
for (FinishedOperateLog finishedOperateLog : finishedOperateLogslist) {
|
if(Objects.equals(type, "审核")){
|
//审核修改领出记录
|
finishedOperateLogMapper.updateToExamine(finishedOperateLog,userName,"已审核");
|
//审核修改库存数量
|
finishedGoodsInventoryMapper.updateInventoryInventoryOut(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(),Math.toIntExact(finishedOperateLog.getQuantity()));
|
log.setFunction("updateFinishedGoodsInventoryToExamine审核");
|
} else if (Objects.equals(type, "反审")) {
|
//审核修改领出记录
|
finishedOperateLogMapper.updateToExamine(finishedOperateLog,userName,"未审核");
|
//审核修改库存数量
|
finishedGoodsInventoryMapper.updateInventoryInventoryInt(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(),Math.toIntExact(finishedOperateLog.getQuantity()));
|
log.setFunction("updateFinishedGoodsInventoryToExamine反审");
|
}
|
|
}
|
}
|
logService.saveLog(log);
|
|
} catch (Exception e) {
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
//将异常传入数据库
|
SysError sysError = new SysError();
|
sysError.setError(e+Arrays.toString(e.getStackTrace()));
|
sysError.setFunc("updateFinishedGoodsInventoryToExamine");
|
sysErrorService.insert(sysError);
|
saveState = false;
|
|
}
|
return saveState;
|
|
}
|
|
public Boolean cancelFinishedGoodsInventoryToExamine(Map<String,Object> object) {
|
boolean saveState = true;
|
//设置回滚点
|
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
|
try {
|
String userName = "";
|
String userId = "";
|
if (object.get("userName") != null) {
|
userName = object.get("userName").toString();
|
}
|
if (object.get("userId") != null) {
|
userId = object.get("userId").toString();
|
}
|
Log log = new Log();
|
log.setOperator(userName);
|
log.setOperatorId(userId);
|
log.setContent(object.toString());
|
log.setFunction("cancelFinishedGoodsInventoryToExamine作废");
|
logService.saveLog(log);
|
//获取对象集合循环进行新增修改
|
List<FinishedOperateLog> finishedOperateLogslist = JSONArray.parseArray(JSONObject.toJSONString(object.get("orderDetail")), FinishedOperateLog.class);
|
if (!finishedOperateLogslist.isEmpty()){
|
for (FinishedOperateLog finishedOperateLog : finishedOperateLogslist) {
|
finishedGoodsInventoryMapper.updateInventoryquantityInt(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(), Math.toIntExact(finishedOperateLog.getQuantity()));
|
finishedGoodsInventoryMapper.updateIntOrderNumberConut(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(), Long.valueOf(finishedOperateLog.getQuantity()));
|
finishedOperateLogMapper.updateFinishedOperateLogState(finishedOperateLog,"已作废");
|
|
}
|
}
|
|
} catch (Exception e) {
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
//将异常传入数据库
|
SysError sysError = new SysError();
|
sysError.setError(e+Arrays.toString(e.getStackTrace()));
|
sysError.setFunc("cancelFinishedGoodsInventoryToExamine");
|
sysErrorService.insert(sysError);
|
saveState = false;
|
|
}
|
return saveState;
|
|
}
|
|
|
public Map<String, Object> getSelectStorageRecord(Integer pageNum, Integer pageSize, List<String> selectDate,String type, FinishedOperateLog finishedOperateLog) {
|
Integer offset = (pageNum-1)*pageSize;
|
String endDate = LocalDate.now().toString();
|
String startDate = LocalDate.now().minusDays(15).toString();
|
if(selectDate !=null && selectDate.size()==2){
|
if(!selectDate.get(0).isEmpty()){
|
startDate = selectDate.get(0);
|
}
|
if(!selectDate.get(1).isEmpty()){
|
endDate = selectDate.get(1);
|
}
|
}
|
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", finishedOperateLogMapper.getSelectStorageRecord(offset, pageSize,startDate, endDate,type, finishedOperateLog));
|
map.put("total", finishedOperateLogMapper.getSelectStorageRecordLogPageTotal(offset, pageSize,startDate, endDate,type, finishedOperateLog));
|
List<String> list = new ArrayList<>();
|
list.add(startDate);
|
list.add(endDate);
|
map.put("selectDate",list);
|
return map;
|
}
|
|
public Map<String, Object> getSelectFinishedOperateLogReport(String type,Integer pageNum, Integer pageSize, List<String> selectDate, FinishedOperateLog finishedOperateLog) {
|
Integer offset = (pageNum-1)*pageSize;
|
String endDate = LocalDate.now().toString();
|
String startDate = LocalDate.now().minusDays(15).toString();
|
if(selectDate !=null && selectDate.size()==2){
|
if(!selectDate.get(0).isEmpty()){
|
startDate = selectDate.get(0);
|
}
|
if(!selectDate.get(1).isEmpty()){
|
endDate = selectDate.get(1);
|
}
|
}
|
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", finishedOperateLogMapper.getSelectFinishedOperateLogReport(offset, pageSize,startDate, endDate, finishedOperateLog,type));
|
map.put("total", finishedOperateLogMapper.getSelectFinishedOperateLogReportPageTotal(offset, pageSize,startDate, endDate, finishedOperateLog,type));
|
List<String> list = new ArrayList<>();
|
list.add(startDate);
|
list.add(endDate);
|
map.put("selectDate",list);
|
return map;
|
}
|
|
|
public String cancelFinishedGoodsInventoryStorage(Map<String,Object> object) {
|
String saveState = "true";
|
//设置回滚点
|
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
|
try {
|
Log log = new Log();
|
log.setOperatorId(object.get("userId").toString());
|
log.setOperator(object.get("userName").toString());
|
log.setContent(object.toString());
|
//获取对象集合循环进行新增修改
|
List<FinishedOperateLog> finishedOperateLogslist = JSONArray.parseArray(JSONObject.toJSONString(object.get("orderDetail")), FinishedOperateLog.class);
|
if (!finishedOperateLogslist.isEmpty()){
|
if(!Objects.equals(cancelDeliveryDetailLogic(finishedOperateLogslist, savePoint, object.get("userName").toString(), log), "true")){
|
return cancelDeliveryDetailLogic(finishedOperateLogslist,savePoint,object.get("userName").toString(),log);
|
}
|
}
|
logService.saveLog(log);
|
|
} catch (Exception e) {
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
//将异常传入数据库
|
SysError sysError = new SysError();
|
sysError.setError(e+Arrays.toString(e.getStackTrace()));
|
sysError.setFunc("cancelFinishedGoodsInventoryStorage");
|
sysErrorService.insert(sysError);
|
saveState = "false";
|
|
}
|
return saveState;
|
|
}
|
|
public List<FinishedOperateLogDTO> exportFinishedOperateLogReport(List<LocalDate> dates,String type) {
|
return finishedOperateLogMapper.exportFinishedOperateLogReport(dates,type);
|
}
|
|
|
public Boolean oneClickStorage(String orderId,String userName) {
|
boolean saveState = true;
|
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
|
Log log = new Log();
|
log.setContent(orderId);
|
log.setOperator(userName);
|
log.setFunction("oneClickStorage入库:"+orderId);
|
logService.saveLog(log);
|
try {
|
String oddNumber= orderNumberSetting("入库");
|
Order order = orderMapper.selectOne(new QueryWrapper<Order>().eq("order_id",orderId));
|
if(order.getWarehousing()!=2){
|
List<OrderDetail> orderDetailList=finishedGoodsInventoryMapper.getSelectOrderDetail(orderId);
|
for (OrderDetail orderDetail:orderDetailList){
|
FinishedGoodsInventory finishedGoodsInventory = finishedGoodsInventoryMapper.findOrderNumberd(orderDetail.getOrderId(),orderDetail.getOrderNumber());
|
if(finishedGoodsInventory!=null){
|
finishedOperateLogMapper.updateOrderFinishedOperateLog(orderDetail,userName,oddNumber);
|
//修改库存表入库数量
|
finishedGoodsInventoryMapper.updateOrderInventory(orderDetail);
|
}else{
|
finishedGoodsInventoryMapper.insertOrderFinishedGoodsInventory(orderDetail);
|
}
|
finishedOperateLogMapper.insertOrderFinishedOperateLog(orderDetail,userName,oddNumber);
|
finishedGoodsInventoryMapper.updateOrderNumberConut(orderDetail.getOrderId(),orderDetail.getOrderNumber(),orderDetail.getQuantity());
|
}
|
finishedGoodsInventoryMapper.updateOrderWarehousingState(orderId,2);
|
}
|
|
|
} catch (Exception e) {
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
//将异常传入数据库
|
SysError sysError = new SysError();
|
sysError.setError(e+Arrays.toString(e.getStackTrace()));
|
sysError.setFunc("oneClickStorage");
|
sysErrorService.insert(sysError);
|
saveState = false;
|
|
}
|
|
return saveState;
|
|
}
|
|
public Map<String, Object> getSelectStorageRecordPint(Integer pageNum, Integer pageSize, List<String> selectDate, FinishedOperateLog finishedOperateLog) {
|
Integer offset = (pageNum-1)*pageSize;
|
String endDate = LocalDate.now().toString();
|
String startDate = LocalDate.now().minusDays(15).toString();
|
if(selectDate !=null && selectDate.size()==2){
|
if(!selectDate.get(0).isEmpty()){
|
startDate = selectDate.get(0);
|
}
|
if(!selectDate.get(1).isEmpty()){
|
endDate = selectDate.get(1);
|
}
|
}
|
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", finishedOperateLogMapper.getSelectStorageRecordPint(offset, pageSize,startDate, endDate, finishedOperateLog));
|
map.put("total", finishedOperateLogMapper.getSelectStorageRecordPintPageTotal(offset, pageSize,startDate, endDate, finishedOperateLog));
|
List<String> list = new ArrayList<>();
|
list.add(startDate);
|
list.add(endDate);
|
map.put("selectDate",list);
|
return map;
|
}
|
|
|
|
|
|
|
|
public String orderNumberSetting(String type) {
|
//根据类型自动生成不同的操作单号
|
String alias="";
|
if(Objects.equals(type, "入库")){
|
alias="RK";
|
}else if(Objects.equals(type, "出库")){
|
alias="CK";
|
}else if(Objects.equals(type, "调拨")){
|
alias="DB";
|
}else if(Objects.equals(type, "领出")){
|
alias="LC";
|
}else if(Objects.equals(type, "返工")){
|
alias="FG";
|
}
|
//查询当天的最大数量
|
Integer maximum=finishedOperateLogMapper.getmaximum(type);
|
//设置两位不够补0
|
String formattedNumber = String.format("%02d", maximum+1);
|
//格式化当前日期
|
Date currentDate = new Date();
|
SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
|
String formattedDate = dateFormat.format(currentDate);
|
String oddNumbers = alias+formattedDate+formattedNumber;
|
return oddNumbers;
|
}
|
|
|
public Map<String, Object> getSelectPrintSv(Map<String, Object> object) {
|
Map<String, Object> map = new HashMap<>();
|
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();//最终结果
|
List<FinishedOperateLog> finishedOperateLogList = JSONArray.parseArray(JSONObject.toJSONString(object.get("printList")), FinishedOperateLog.class);
|
if (!finishedOperateLogList.isEmpty()) {
|
Set<String> processedProcessIds = new HashSet<>();
|
for (FinishedOperateLog finishedOperateLog : finishedOperateLogList) {
|
String OrderId = finishedOperateLog.getOrderId();
|
String Remarks = finishedOperateLog.getRemarks();
|
|
// 检查是否已经处理过该 OrderId，如果处理过则跳过
|
if (processedProcessIds.contains(OrderId) && processedProcessIds.contains(Remarks)) {
|
continue;
|
}
|
|
Map<String, Object> itemmap = new HashMap<>();
|
itemmap.put("detail", finishedOperateLogMapper.getPrimaryListLimt(finishedOperateLog.getOrderId(),finishedOperateLog.getProcessId(),finishedOperateLog.getRemarks()));
|
|
List<Map<String, Object>> detailList = finishedOperateLogMapper.getDetailList(finishedOperateLog.getOrderId(),finishedOperateLog.getProcessId(),finishedOperateLog.getRemarks());
|
itemmap.put("detailList", detailList);
|
|
list.add(itemmap);
|
|
processedProcessIds.add(OrderId);
|
processedProcessIds.add(Remarks);
|
}
|
}
|
map.put("data", list);
|
return map;
|
}
|
|
|
public String deliveryDetailLogic(List<OrderDetail> list,Object savePoint,String userName) {
|
for (OrderDetail orderDetail : list) {
|
//获取单号
|
String oddNumber= orderNumberSetting("出库");
|
OrderDetail orderDetailNew= finishedGoodsInventoryMapper.findOrderDetailNumberd(orderDetail.getDeliveryDetail().getOrderId(),orderDetail.getDeliveryDetail().getOrderNumber());
|
//添加出入库记录
|
finishedOperateLogMapper.insertOutFinishedOperateLog(orderDetail,userName,oddNumber);
|
Integer finishedGoodsInventorycount = finishedGoodsInventoryMapper.findOrderNumberdcount(orderDetail.getDeliveryDetail().getOrderId(),orderDetail.getDeliveryDetail().getOrderNumber());
|
|
|
Integer ordersum = finishedGoodsInventoryMapper.findOrderQuantity(orderDetail.getDeliveryDetail().getOrderId());
|
Integer orderNumberdsum = finishedGoodsInventoryMapper.findOrderNumberdsum(orderDetail.getDeliveryDetail().getOrderId());
|
|
Integer deliverysum = finishedGoodsInventoryMapper.findDeliveryQuantity(orderDetail.getDeliveryDetail().getDeliveryId());
|
Integer deliverydetailsum = finishedGoodsInventoryMapper.findDeliverydetailsum(orderDetail.getDeliveryDetail().getDeliveryId(),0);
|
if(deliverydetailsum==null){
|
deliverydetailsum=0;
|
}
|
|
DeliveryDetail deliveryDetail=finishedGoodsInventoryMapper.findDeliverydetail(orderDetail.getDeliveryDetail().getOrderId(),orderDetail.getDeliveryDetail().getOrderNumber(),orderDetail.getDeliveryDetail().getDeliveryId());
|
/*System.out.println("订单总数:" + ordersum + "订单库存数：" + orderNumberdsum + "准备出库数量" +
|
orderDetail.getWarehouseNum()+ "发货数量" + orderDetail.getDeliveryDetail().getQuantity()+ "发货总数" +
|
deliverysum+ "已发数量" + deliverydetailsum);*/
|
//判断发货单的库存是否存在
|
if (finishedGoodsInventorycount > 0) {
|
//判断发货单是否已出库
|
if(deliveryDetail==null){
|
if(orderDetailNew.getWarehouseNum()>=orderDetail.getDeliveryDetail().getQuantity()){
|
//修改库存表库存数量
|
finishedGoodsInventoryMapper.updateInventoryInventoryOut(orderDetail.getDeliveryDetail().getOrderId(),orderDetail.getDeliveryDetail().getOrderNumber(),orderDetail.getDeliveryDetail().getQuantity());
|
//修改发货明细表状态
|
finishedGoodsInventoryMapper.updateDeliveryDetailState(orderDetail.getDeliveryDetail().getOrderId(),orderDetail.getDeliveryDetail().getOrderNumber(),orderDetail.getDeliveryDetail().getDeliveryId(),0);
|
//修改发货表状态
|
finishedGoodsInventoryMapper.updateDeliveryDeliveryState(orderDetail.getDeliveryDetail().getDeliveryId(),1);
|
//修改订单明细表发货数量
|
finishedGoodsInventoryMapper.updateOutOrderNumberConut(orderDetail.getDeliveryDetail().getOrderId(),orderDetail.getDeliveryDetail().getOrderNumber(),orderDetail.getDeliveryDetail().getQuantity());
|
//修改订单表发货状态
|
finishedGoodsInventoryMapper.updateOrderDeliveryState(orderDetail.getDeliveryDetail().getOrderId(),1);
|
//判断订单是否全部发货
|
if (Objects.equals(orderNumberdsum, orderDetail.getWarehouseNum())) {
|
//if (ordersum == (orderDeliveryQuantitySum + orderDetail.getWarehouseNum())) {
|
//修改订单表发货状态
|
finishedGoodsInventoryMapper.updateOrderDeliveryState(orderDetail.getDeliveryDetail().getOrderId(),2);
|
}
|
if (deliverysum==deliverydetailsum+orderDetail.getDeliveryDetail().getQuantity()) {
|
//修改发货表状态
|
finishedGoodsInventoryMapper.updateDeliveryDeliveryState(orderDetail.getDeliveryDetail().getDeliveryId(),2);
|
}
|
}else{
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
return "false3";
|
}
|
}else{
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
return "false1";
|
}
|
|
|
}else{
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
return "false2";
|
}
|
}
|
return "true";
|
}
|
|
public String cancelDeliveryDetailLogic(List<FinishedOperateLog> finishedOperateLogslist,Object savePoint,String userName,Log log) {
|
for (FinishedOperateLog finishedOperateLog : finishedOperateLogslist) {
|
Integer ordersum = finishedGoodsInventoryMapper.findOrderQuantity(finishedOperateLog.getOrderId());
|
Integer ordernumbersum = finishedGoodsInventoryMapper.findOrderNumberdsum(finishedOperateLog.getOrderId());
|
Integer deliverysum = finishedGoodsInventoryMapper.findDeliveryQuantity(finishedOperateLog.getOperationOrderNumber());
|
Integer deliverydetailsum = finishedGoodsInventoryMapper.findDeliverydetailsum(finishedOperateLog.getOperationOrderNumber(),1);
|
|
if(Objects.equals(finishedOperateLog.getOperateType(), "入库")){
|
Delivery delivery = finishedGoodsInventoryMapper.findOrderDelivery(finishedOperateLog.getOrderId());
|
if(delivery==null){
|
//修改记录表
|
finishedOperateLogMapper.updateFinishedOperateLogState(finishedOperateLog,"已作废");
|
//修改库存表入库数量
|
finishedGoodsInventoryMapper.updateInventoryOut(finishedOperateLog);
|
if(finishedOperateLog.getProcessId()!=null){
|
//修改流程卡表入库数量
|
finishedGoodsInventoryMapper.updateflowcardOut(finishedOperateLog);
|
}
|
|
//修改订单明细表入库数量
|
finishedGoodsInventoryMapper.updateOutOrderNumberConut(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(),finishedOperateLog.getQuantity());
|
//判断订单是否全部入库
|
if (Objects.equals(ordersum, ordernumbersum)) {
|
//修改订单表入库状态
|
finishedGoodsInventoryMapper.updateOrderWarehousingState(finishedOperateLog.getOrderId(),1);
|
}
|
if (ordernumbersum-finishedOperateLog.getQuantity()==0) {
|
//修改订单表入库状态
|
finishedGoodsInventoryMapper.updateOrderWarehousingState(finishedOperateLog.getOrderId(),0);
|
}
|
log.setFunction("cancelFinishedGoodsInventoryStorage入库");
|
}else{
|
return "false1";
|
}
|
|
|
|
}else if(Objects.equals(finishedOperateLog.getOperateType(), "出库")){
|
//修改记录表
|
finishedOperateLogMapper.updateFinishedOperateLogState(finishedOperateLog,"已作废");
|
//修改库存表库存数量
|
finishedGoodsInventoryMapper.updateInventoryInventoryInt(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(),finishedOperateLog.getQuantity());
|
//修改发货明细表状态
|
finishedGoodsInventoryMapper.updateDeliveryDetailState(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(),finishedOperateLog.getOperationOrderNumber(),1);
|
//修改发货表状态
|
finishedGoodsInventoryMapper.updateDeliveryDeliveryState(finishedOperateLog.getOperationOrderNumber(),1);
|
//修改订单明细表库内数量
|
finishedGoodsInventoryMapper.updateIntOrderNumberConut(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(), Long.valueOf(finishedOperateLog.getQuantity()));
|
//修改订单表发货状态
|
finishedGoodsInventoryMapper.updateOrderDeliveryState(finishedOperateLog.getOrderId(),1);
|
//判断订单是否全部发货
|
if (ordersum==finishedOperateLog.getQuantity()+ordernumbersum){
|
//修改订单表发货状态
|
finishedGoodsInventoryMapper.updateOrderDeliveryState(finishedOperateLog.getOrderId(),0);
|
|
}
|
if (deliverysum==finishedOperateLog.getQuantity()+deliverydetailsum) {
|
//修改发货表状态
|
finishedGoodsInventoryMapper.updateDeliveryDeliveryState(finishedOperateLog.getOperationOrderNumber(),0);
|
}
|
log.setFunction("cancelFinishedGoodsInventoryStorage出库");
|
|
}
|
|
}
|
return "true";
|
}
|
}
|
