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

chenlu

2024-06-07 2f640b1038fa331954f78ed1f4317212cf5bb34d

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

@@ -3,16 +3,21 @@
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.dynamic.datasource.annotation.DS;
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.Order;
import com.example.erp.entity.sd.OrderDetail;
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.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.text.SimpleDateFormat;
@@ -21,6 +26,7 @@

@Service
@DS("mm")
@Transactional(rollbackFor = Exception.class)
public class FinishedGoodsInventoryService {
    @Autowired
    FinishedGoodsInventoryMapper finishedGoodsInventoryMapper;
@@ -28,6 +34,8 @@
    FinishedOperateLogMapper finishedOperateLogMapper;
    @Autowired
    BasicWarehouseTypeMapper basicWarehouseTypeMapper;
    @Autowired
    SysErrorService sysErrorService;

    public Map<String, Object> defaultDateFinishedGoodsInventory(Integer pageNum, Integer pageSize, FinishedGoodsInventory finishedGoodsInventory) {
        Integer offset = (pageNum - 1) * pageSize;
@@ -37,36 +45,37 @@
        return map;
    }

    public Map<String, Object> getseletwarehousing(Integer pageNum, Integer pageSize, FlowCard flowCard) {
    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.getseletwarehousing(offset, pageSize, flowCard));
        map.put("total", finishedGoodsInventoryMapper.getseletwarehousingPageTotal(offset, pageSize, flowCard));
        map.put("data", finishedGoodsInventoryMapper.getSelectWarehousing(offset, pageSize, flowCard));
        map.put("total", finishedGoodsInventoryMapper.getSelectWarehousingPageTotal(offset, pageSize, flowCard));

        return map;
    }

    public Boolean addseletwarehousing(Map<String,Object> object) {
        Boolean isinsert=false;
    public Boolean addSelectWarehousing(Map<String,Object> object) {
        boolean saveState = true;
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
        try {
            //定义前端传输的数据
            String storageRegion = "";
            String remark = "";
            if (object.get("remark") != null) {
                remark = object.get("remark").toString();
            }
            if (object.get("storageRegion") != null) {
                storageRegion = object.get("storageRegion").toString();
            }

        //定义前端传输的数据
        String storageRegion = "";
        String remark = "";
        if (object.get("remark") != null) {
            remark = object.get("remark").toString();
        }
        if (object.get("storageRegion") != null) {
            storageRegion = object.get("storageRegion").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();
        }
            String userName = "";
            String userId = "";
            if (object.get("userName") != null) {
                userName = object.get("userName").toString();
            }
            if (object.get("userId") != null) {
                userId = object.get("userId").toString();
            }

            //获取对象集合循环进行新增修改
            List<FlowCard> flowCardlist = JSONArray.parseArray(JSONObject.toJSONString(object.get("flowcard")), FlowCard.class);
@@ -76,17 +85,18 @@
                    String oddNumber= orderNumberSetting("入库");
                    //添加出入库记录
                    finishedOperateLogMapper.insertIntFinishedOperateLog(flowCard,userName,oddNumber);
                    System.out.println(flowCard.getOrder().getOrderId());
                    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());
                    /*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());
                        //判断订单是否全部入库
@@ -94,94 +104,127 @@
                            //修改订单表入库状态
                            finishedGoodsInventoryMapper.updateOrderWarehousingState(flowCard.getOrder().getOrderId(),2);
                        }
                        isinsert=true;
                    } else {
                        if (finishedGoodsInventoryMapper.insertFinishedGoodsInventory(flowCard, storageRegion, remark)) {
                            //修改流程卡表入库数量
                            finishedGoodsInventoryMapper.updateflowcard(flowCard);
                            //修改订单明细表入库数量
                            finishedGoodsInventoryMapper.updateIntOrderNumberConut(flowCard.getOrder().getOrderId(),flowCard.getOrderNumber(),flowCard.getInventoryQuantity());
                            //修改订单表入库状态
                            finishedGoodsInventoryMapper.updateOrderWarehousingState(flowCard.getOrder().getOrderId(),1);
                            isinsert=true;
                        } else {
                            isinsert= false;
                            if (ordersum == (ordernumbersum + flowCard.getInventoryQuantity())) {
                                //修改订单表入库状态
                                finishedGoodsInventoryMapper.updateOrderWarehousingState(flowCard.getOrder().getOrderId(),2);
                            }else{
                                //修改订单表入库状态
                                finishedGoodsInventoryMapper.updateOrderWarehousingState(flowCard.getOrder().getOrderId(),1);
                            }


                        }
                    }
                }
                return isinsert;
            }else{
                return false;
            }

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

        }

        return saveState;

    }


    public Map<String, Object> getseletdeliveryDetail(Integer pageNum, Integer pageSize, OrderDetail orderDetail) {
    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.getseletdeliveryDetail(offset, pageSize, orderDetail));
        map.put("total", finishedGoodsInventoryMapper.getseletdeliveryDetailPageTotal(offset, pageSize, orderDetail));
        map.put("data", finishedGoodsInventoryMapper.getSelectDeliveryDetail(offset, pageSize, orderDetail));
        map.put("total", finishedGoodsInventoryMapper.getSelectDeliveryDetailPageTotal(offset, pageSize, orderDetail));
        return map;
    }


    public Boolean adddeliveryDetail(Map<String,Object> object) {
        Boolean isinsert=false;
        String userName = "";
        String userId = "";
        if (object.get("userName") != null) {
            userName = object.get("userName").toString();
        }
        if (object.get("userId") != null) {
            userId = object.get("userId").toString();
        }
        //获取对象集合循环进行新增修改
        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());
                System.out.println("数据3:"+finishedGoodsInventorycount);
                Integer finishedGoodsInventorybycount=finishedGoodsInventoryMapper.finishedGoodsInventorybycount(orderDetail.getDeliveryDetail().getOrderId(),orderDetail.getDeliveryDetail().getOrderNumber());
                Integer ordersum = finishedGoodsInventoryMapper.findOrderQuantity(orderDetail.getDeliveryDetail().getOrderId());
                Integer ordernumbersum = finishedGoodsInventoryMapper.findOrderNumberdsum(orderDetail.getDeliveryDetail().getOrderId());
    public Boolean addDeliveryDetail(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();
            }
            //获取对象集合循环进行新增修改
            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());

                System.out.println("订单总数:" + ordersum + "订单剩余数量：" + ordernumbersum + "准备出库数量" + orderDetail.getWarehouseNum()+ "库存数量" + finishedGoodsInventorybycount);
                if (finishedGoodsInventorycount > 0) {
                    if(Objects.equals(finishedGoodsInventorybycount, orderDetail.getWarehouseNum())){
                        System.out.println(123);
                        //修改库存表出库数量
                        //finishedGoodsInventoryMapper.updateInventoryquantityavailable(orderDetail);
                        //修改发货明细表状态
                        finishedGoodsInventoryMapper.updateDeliveryDetailState(orderDetail,0);
                        //修改订单明细表发货数量
                        finishedGoodsInventoryMapper.updateOutOrderNumberConut(orderDetail.getDeliveryDetail().getOrderId(),orderDetail.getDeliveryDetail().getOrderNumber(),orderDetail.getWarehouseNum());
                        //修改订单表发货状态
                        finishedGoodsInventoryMapper.updateOrderDeliveryState(orderDetail.getDeliveryDetail().getOrderId(),1);
                        //判断订单是否全部发货
                        if (0 == (ordernumbersum - orderDetail.getWarehouseNum())) {
                            //修改订单表发货状态
                            finishedGoodsInventoryMapper.updateOrderDeliveryState(orderDetail.getDeliveryDetail().getOrderId(),2);
                        }
                        isinsert=true;

                    Integer ordersum = finishedGoodsInventoryMapper.findOrderQuantity(orderDetail.getDeliveryDetail().getOrderId());
                    Integer orderDeliveryQuantitySum = finishedGoodsInventoryMapper.findOrderDeliveryQuantitySum(orderDetail.getDeliveryDetail().getOrderId());

                    Integer deliverysum = finishedGoodsInventoryMapper.findDeliveryQuantity(orderDetail.getDeliveryDetail().getDeliveryId());
                    Integer deliverydetailsum = finishedGoodsInventoryMapper.findDeliverydetailsum(orderDetail.getDeliveryDetail().getDeliveryId(),0);
                    if(deliverydetailsum==null){
                        deliverydetailsum=0;
                    }

                } else {
                    isinsert=false;
                    /*System.out.println("订单总数:" + ordersum + "订单已发数量：" + orderDeliveryQuantitySum + "准备出库数量" +
                            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 (ordersum == (orderDeliveryQuantitySum + orderDetail.getWarehouseNum())) {
                                //修改订单表发货状态
                                finishedGoodsInventoryMapper.updateOrderDeliveryState(orderDetail.getDeliveryDetail().getOrderId(),2);
                            }
                            if (deliverysum==deliverydetailsum+orderDetail.getDeliveryDetail().getQuantity()) {
                                //修改发货表状态
                                finishedGoodsInventoryMapper.updateDeliveryDeliveryState(orderDetail.getDeliveryDetail().getDeliveryId(),2);
                            }
                        }

                    }
                }
            }
            return isinsert;
        }else{
            return false;

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

        }


        return saveState;

    }

@@ -196,57 +239,67 @@
    }

    public Boolean updateFinishedGoodsInventoryAllocate(Map<String,Object> object) {
        Boolean isinsert=false;
        String userName = "";
        String userId = "";
        if (object.get("userName") != null) {
            userName = object.get("userName").toString();
        }
        if (object.get("userId") != null) {
            userId = object.get("userId").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());

                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(), Math.toIntExact(orderDetail.getQuantity()));
                if (newordersum==newordernumbersum+orderDetail.getQuantity()){
                    //修改订单表入库状态
                    finishedGoodsInventoryMapper.updateOrderWarehousingState(orderDetail.getOrderId(),2);
                }
                if (Objects.equals(oldordersum, oldordernumbersum)){
                    //修改订单表入库状态
                    finishedGoodsInventoryMapper.updateOrderWarehousingState(orderDetail.getFinishedGoodsInventory().getOrderId(),1);
                }
                isinsert=true;
        boolean saveState = true;
        //设置回滚点
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
        try {
            String userName = "";
            String userId = "";
            if (object.get("userName") != null) {
                userName = object.get("userName").toString();
            }
            return isinsert;
        }else{
            return false;
        }
            if (object.get("userId") != null) {
                userId = object.get("userId").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());

                    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(), Math.toIntExact(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.toString());
            sysError.setFunc("saveOrder");
            sysErrorService.insert(sysError);
            saveState = false;

        }
        return saveState;


    }

    public Map<String, Object> getselectAllocateFinishedOperateLog(Integer pageNum, Integer pageSize,List<String> selectDate, FinishedOperateLog finishedOperateLog) {
    public Map<String, Object> getSelectAllocateFinishedOperateLog(Integer pageNum, Integer pageSize,List<String> selectDate, FinishedOperateLog finishedOperateLog) {
        Integer offset = (pageNum - 1) * pageSize;

        String endDate = LocalDate.now().toString();
@@ -271,60 +324,63 @@
    }

    public Boolean updateFinishedGoodsInventoryTakeOut(Map<String,Object> object) {
        Boolean isinsert=false;
        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.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);
                }
                isinsert=true;
        boolean saveState = true;
        //设置回滚点
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
        try {
            String userName = "";
            String userId = "";
            if (object.get("userName") != null) {
                userName = object.get("userName").toString();
            }
            return isinsert;
        }else{
            return false;
        }
            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.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.toString());
            sysError.setFunc("saveOrder");
            sysErrorService.insert(sysError);
            saveState = false;

        }
        return saveState;

    }

   /* public Map<String, Object> getselectTakeOutFinishedOperateLog(Integer pageNum, Integer pageSize, FinishedOperateLog finishedOperateLog) {
        Integer offset = (pageNum - 1) * pageSize;
        Map<String, Object> map = new HashMap<>();
        map.put("data", finishedOperateLogMapper.getselectAllocateFinishedOperateLog(offset, pageSize, finishedOperateLog));
        map.put("total", finishedOperateLogMapper.getselectAllocateFinishedOperateLogPageTotal(offset, pageSize, finishedOperateLog));
        return map;
    }*/

    public Map<String, Object> getSelectOperateRecord(Integer pageNum, Integer pageSize, List<String> selectDate, FinishedOperateLog finishedOperateLog) {
        Integer offset = (pageNum-1)*pageSize;
@@ -351,89 +407,272 @@


    public Boolean updateFinishedGoodsInventoryRework(Map<String,Object> object) {
        Boolean isinsert=false;
        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);
                }
                isinsert=true;
        boolean saveState = true;
        //设置回滚点
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
        try {
            String userName = "";
            String userId = "";
            if (object.get("userName") != null) {
                userName = object.get("userName").toString();
            }
            return isinsert;
        }else{
            return false;
        }
            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.toString());
            sysError.setFunc("saveOrder");
            sysErrorService.insert(sysError);
            saveState = false;

        }
        return saveState;

    }


    public Boolean updateFinishedGoodsInventoryToExamine(Map<String,Object> object,String type) {
        Boolean isinsert=false;
        String userName = "";
        String userId = "";
        if (object.get("userName") != null) {
            userName = object.get("userName").toString();
        }
        if (object.get("userId") != null) {
            userId = object.get("userId").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()));
                } else if (Objects.equals(type, "反审")) {
                    //审核修改领出记录
                    finishedOperateLogMapper.updateToExamine(finishedOperateLog,userName,"未审核");
                    //审核修改库存数量
                    finishedGoodsInventoryMapper.updateInventoryInventoryInt(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(),Math.toIntExact(finishedOperateLog.getQuantity()));
                }


                isinsert=true;
        boolean saveState = true;
        //设置回滚点
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
        try {
            String userName = "";
            String userId = "";
            if (object.get("userName") != null) {
                userName = object.get("userName").toString();
            }
            return isinsert;
        }else{
            return false;
            if (object.get("userId") != null) {
                userId = object.get("userId").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()));
                    } else if (Objects.equals(type, "反审")) {
                        //审核修改领出记录
                        finishedOperateLogMapper.updateToExamine(finishedOperateLog,userName,"未审核");
                        //审核修改库存数量
                        finishedGoodsInventoryMapper.updateInventoryInventoryInt(finishedOperateLog.getOrderId(),finishedOperateLog.getOperationNumber(),Math.toIntExact(finishedOperateLog.getQuantity()));
                    }

                }
            }

        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e.toString());
            sysError.setFunc("saveOrder");
            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();
            }
            //获取对象集合循环进行新增修改
            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()));
                    finishedOperateLogMapper.updateFinishedOperateLogState(finishedOperateLog,"已作废");

                }
            }

        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e.toString());
            sysError.setFunc("saveOrder");
            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(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));
        map.put("total", finishedOperateLogMapper.getSelectFinishedOperateLogReportPageTotal(offset, pageSize,startDate, endDate, finishedOperateLog));
        List<String> list = new ArrayList<>();
        list.add(startDate);
        list.add(endDate);
        map.put("selectDate",list);
        return map;
    }


    public Boolean cancelFinishedGoodsInventoryStorage(Map<String,Object> object) {
        boolean saveState = true;
        //设置回滚点
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
        try {

            //获取对象集合循环进行新增修改
            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);
                        //修改流程卡表入库数量
                        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);
                        }

                    }

                }
            }

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

        }
        return saveState;

    }

    public List<FinishedOperateLogDTO> exportFinishedOperateLogReport(List<LocalDate> dates) {
        return finishedOperateLogMapper.exportFinishedOperateLogReport(dates);
    }