Merge branch 'master' of http://10.153.19.25:10101/r/ERP_override

guoyujie

38 分钟以前 d5bb894f9be2e0a3b62d475b60b44f2ab138528c

 north-glass-erp/src/main/java/com/example/erp/service/mm/FinishedGoodsInventoryService.java

@@ -8,14 +8,18 @@
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;
@@ -27,6 +31,7 @@
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;

@Service
@DS("mm")
@@ -44,6 +49,8 @@
    OrderMapper orderMapper;
    @Autowired
    SysErrorService sysErrorService;
    @Autowired
    LogService logService;

    public Map<String, Object> defaultDateFinishedGoodsInventory(Integer pageNum, Integer pageSize, FinishedGoodsInventory finishedGoodsInventory) {
        Integer offset = (pageNum - 1) * pageSize;
@@ -62,18 +69,22 @@
        return map;
    }

    public Boolean addSelectWarehousing(Map<String,Object> object) {
        boolean saveState = true;
    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 = "";
@@ -84,64 +95,79 @@
            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);
            List<FlowCard> flowCardlist = JSONArray.parseArray(JSONObject.toJSONString(object.get("flowCard")), FlowCard.class);
            if (!flowCardlist.isEmpty()){
                //获取单号
                String oddNumber= orderNumberSetting("入库");
                for (FlowCard flowCard : flowCardlist) {
                    //获取单号
                    String oddNumber= orderNumberSetting("入库");
                    //添加出入库记录
                    finishedOperateLogMapper.insertIntFinishedOperateLog(flowCard,userName,oddNumber);
                    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());

                    /*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(),flowCard.getInventoryQuantity());
                        //判断订单是否全部入库
                        if (ordersum == (ordernumbersum + flowCard.getInventoryQuantity())) {
                            //修改订单表入库状态
                            finishedGoodsInventoryMapper.updateOrderWarehousingState(flowCard.getOrder().getOrderId(),2);
                        }
                    } else {
                        if (finishedGoodsInventoryMapper.insertFinishedGoodsInventory(flowCard, storageRegion, remark)) {
                    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(),flowCard.getInventoryQuantity());
                            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 {
                            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{
                return false;
                TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
                return "false2";
            }

        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e.toString());
            sysError.setError(e+Arrays.toString(e.getStackTrace()));
            sysError.setFunc("addSelectWarehousing");
            sysErrorService.insert(sysError);
            saveState = false;
            saveState = "false";

        }

@@ -159,8 +185,8 @@
    }


    public Boolean addDeliveryDetail(Map<String,Object> object) {
        boolean saveState = true;
    public String addDeliveryDetail(Map<String,Object> object) {
        String saveState = "true";
        //设置回滚点
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
        try {
@@ -172,57 +198,18 @@
            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()){
                for (OrderDetail orderDetail : orderDetaillist) {
                    //获取单号
                    String oddNumber= orderNumberSetting("出库");
                    //添加出入库记录
                    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;
                    }

                    /*System.out.println("订单总数:" + ordersum + "订单库存数：" + orderNumberdsum + "准备出库数量" +
                            orderDetail.getWarehouseNum()+ "发货数量" + orderDetail.getDeliveryDetail().getQuantity()+ "发货总数" +
                            deliverysum+ "已发数量" + deliverydetailsum);*/
                    if (finishedGoodsInventorycount > 0) {
                        if(orderDetail.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 (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);
                        saveState = false;
                    }
                if(!Objects.equals(deliveryDetailLogic(orderDetaillist, savePoint, userName), "true")) {
                    return deliveryDetailLogic(orderDetaillist, savePoint, userName);
                }
            }

@@ -230,10 +217,10 @@
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e.toString());
            sysError.setError(e+Arrays.toString(e.getStackTrace()));
            sysError.setFunc("addDeliveryDetail");
            sysErrorService.insert(sysError);
            saveState = false;
            saveState = "false";

        }
        return saveState;
@@ -263,6 +250,12 @@
            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()){
@@ -284,7 +277,7 @@
                    //修改原订单明细表发货数量
                    finishedGoodsInventoryMapper.updateOutOrderNumberConut(orderDetail.getFinishedGoodsInventory().getOrderId(),orderDetail.getFinishedGoodsInventory().getOrderNumber(), Math.toIntExact(orderDetail.getQuantity()));
                    //修改调拨新订单明细表发货数量
                    finishedGoodsInventoryMapper.updateIntOrderNumberConut(orderDetail.getOrderId(),orderDetail.getOrderNumber(), Math.toIntExact(orderDetail.getQuantity()));
                    finishedGoodsInventoryMapper.updateIntOrderNumberConut(orderDetail.getOrderId(),orderDetail.getOrderNumber(), orderDetail.getQuantity());
                    if (newordersum==newordernumbersum+orderDetail.getQuantity()){
                        //修改订单表入库状态
                        finishedGoodsInventoryMapper.updateOrderWarehousingState(orderDetail.getOrderId(),2);
@@ -300,7 +293,7 @@
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e.toString());
            sysError.setError(e+Arrays.toString(e.getStackTrace()));
            sysError.setFunc("updateFinishedGoodsInventoryAllocate");
            sysErrorService.insert(sysError);
            saveState = false;
@@ -357,6 +350,12 @@
            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()){
@@ -383,7 +382,7 @@
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e.toString());
            sysError.setError(e+Arrays.toString(e.getStackTrace()));
            sysError.setFunc("updateFinishedGoodsInventoryTakeOut");
            sysErrorService.insert(sysError);
            saveState = false;
@@ -466,7 +465,7 @@
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e.toString());
            sysError.setError(e+Arrays.toString(e.getStackTrace()));
            sysError.setFunc("updateFinishedGoodsInventoryRework");
            sysErrorService.insert(sysError);
            saveState = false;
@@ -490,6 +489,10 @@
            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()){
@@ -499,21 +502,24 @@
                        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.toString());
            sysError.setError(e+Arrays.toString(e.getStackTrace()));
            sysError.setFunc("updateFinishedGoodsInventoryToExamine");
            sysErrorService.insert(sysError);
            saveState = false;
@@ -536,11 +542,18 @@
            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,"已作废");

                }
@@ -550,7 +563,7 @@
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e.toString());
            sysError.setError(e+Arrays.toString(e.getStackTrace()));
            sysError.setFunc("cancelFinishedGoodsInventoryToExamine");
            sysErrorService.insert(sysError);
            saveState = false;
@@ -584,7 +597,7 @@
        return map;
    }

    public Map<String, Object> getSelectFinishedOperateLogReport(Integer pageNum, Integer pageSize, List<String> selectDate, FinishedOperateLog finishedOperateLog) {
    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();
@@ -598,8 +611,8 @@
        }

        Map<String, Object> map = new HashMap<>();
        map.put("data", finishedOperateLogMapper.getSelectFinishedOperateLogReport(offset, pageSize,startDate, endDate, finishedOperateLog));
        map.put("total", finishedOperateLogMapper.getSelectFinishedOperateLogReportPageTotal(offset, pageSize,startDate, endDate, finishedOperateLog));
        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);
@@ -608,107 +621,67 @@
    }


    public Boolean cancelFinishedGoodsInventoryStorage(Map<String,Object> object) {
        boolean saveState = true;
    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()){
                for (FinishedOperateLog finishedOperateLog : finishedOperateLogslist) {
                    Integer ordersum = finishedGoodsInventoryMapper.findOrderQuantity(finishedOperateLog.getOrderId());
                    Integer ordernumbersum = finishedGoodsInventoryMapper.findOrderNumberdsum(finishedOperateLog.getOrderId());

                    if(Objects.equals(finishedOperateLog.getOperateType(), "入库")){
                        //修改记录表
                        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);
                        }

                    }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(),0);
                        //修改订单明细表库内数量
                        finishedGoodsInventoryMapper.updateIntOrderNumberConut(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(),finishedOperateLog.getQuantity());
                        //修改订单表发货状态
                        finishedGoodsInventoryMapper.updateDeliveryDeliveryState(finishedOperateLog.getOrderId(),1);
                        //判断订单是否全部发货
                        if (ordernumbersum-finishedOperateLog.getQuantity()==0) {
                            //修改订单表发货状态
                            finishedGoodsInventoryMapper.updateOrderDeliveryState(finishedOperateLog.getOrderId(),1);

                        }
                        if (ordersum==finishedOperateLog.getQuantity()+ordernumbersum) {
                            //修改订单表发货状态
                            finishedGoodsInventoryMapper.updateOrderDeliveryState(finishedOperateLog.getOrderId(),0);
                        }

                    }

                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.toString());
            sysError.setError(e+Arrays.toString(e.getStackTrace()));
            sysError.setFunc("cancelFinishedGoodsInventoryStorage");
            sysErrorService.insert(sysError);
            saveState = false;
            saveState = "false";

        }
        return saveState;

    }

    public List<FinishedOperateLogDTO> exportFinishedOperateLogReport(List<LocalDate> dates) {
        return finishedOperateLogMapper.exportFinishedOperateLogReport(dates);
    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()==0){
            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.updateIntOrderNumberConut(orderDetail.getOrderId(),orderDetail.getOrderNumber(),Integer.parseInt(orderDetail.getQuantity().toString()));
                    finishedGoodsInventoryMapper.updateOrderNumberConut(orderDetail.getOrderId(),orderDetail.getOrderNumber(),orderDetail.getQuantity());
                }
                finishedGoodsInventoryMapper.updateOrderWarehousingState(orderId,2);
            }
@@ -718,7 +691,7 @@
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e.toString());
            sysError.setError(e+Arrays.toString(e.getStackTrace()));
            sysError.setFunc("oneClickStorage");
            sysErrorService.insert(sysError);
            saveState = false;
@@ -727,6 +700,29 @@

        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;
    }


@@ -762,9 +758,169 @@
    }


    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";
    }
}