DIL-DAZHOU-WMS2/src/main/java/com/steerinfo/dil/service/impl/WmspGridMaterialServiceImpl.java

package com.steerinfo.dil.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.google.common.primitives.Bytes;
import com.google.gson.JsonObject;
import com.steerinfo.dil.feign.JoinFeign;
import com.steerinfo.dil.mapper.*;
import com.steerinfo.dil.model.*;
import com.steerinfo.dil.service.IWmspGridMaterialService;
import com.steerinfo.dil.util.DataChange;
import com.steerinfo.dil.util.EASUtil;
import com.steerinfo.dil.vo.OutBoundMaterialDetailedInfo;
import io.swagger.models.auth.In;
import org.apache.shiro.crypto.hash.Hash;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.RequestParam;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * WmspGridMaterial服务实现：
 * @author generator
 * @version 1.0-SNAPSHORT 2021-09-08 06:02
 * 类描述
 * 修订历史：
 * 日期：2021-09-08
 * 作者：generator
 * 参考：
 * 描述：WmspGridMaterial服务实现
 * @see null
 * @Copyright 湖南视拓信息技术股份有限公司. All rights reserved.
 */
@Service
public class WmspGridMaterialServiceImpl  implements IWmspGridMaterialService {

    @Autowired
    private WmspGridMaterialMapper wmspGridMaterialMapper;
    @Autowired
    private RmsStackingMapper rmsStackingMapper;
    @Autowired
    private RmsPwarehouseGridMapper rmsPwarehouseGridMapper;
    @Autowired
    private WmspRestackScanResultMapper wmspRestackScanResultMapper;
    @Autowired
    private WmspRestackMakeResultMapper wmspRestackMakeResultMapper;
    @Autowired
    private WmspCheckWarehouseMapper wmspCheckWarehouseMapper;
    @Autowired
    private WmspInboundResultMapper wmspInboundResultMapper;
    @Autowired
    private WmspInboundEasMapper  wmspInboundEasMapper;
    @Autowired
    private EASUtil easUtil;
    @Autowired
    private JoinFeign joinFeign;

    //新增
    @Override
    public int insertSelective(WmspGridMaterial wmspGridMaterial) {
//        long id;
//        BigDecimal MAXid=wmspGridMaterial.getGmId();
//        if (MAXid==null){
//            id=1;
//        }else {
//            id=MAXid.longValue()+1;
//        }
//        wmspGridMaterial.setGmId(new BigDecimal(id));
        return wmspGridMaterialMapper.insertSelective(wmspGridMaterial);
    }

    //更新
    @Override
    public int updateByPrimaryKeySelective(WmspGridMaterial wmspGridMaterial) {
        return wmspGridMaterialMapper.updateByPrimaryKeySelective(wmspGridMaterial);
    }
    //查询实时库存数据
    @Override
    public List<Map<String, Object>> selectGridMaterial(Map<String, Object> mapval,String warehouseId,String time) {
        //        通过当前时间获得前一个月的时间
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar cal= Calendar.getInstance();
//        根据前端床过来的time的数值进行时间区间的判断
        if (time.equals("1")){
            cal.add(Calendar.MONTH, -1);
        }else if (time.equals("2")){
            cal.add(Calendar.DATE, -15);
        }

        long date2 = cal.getTimeInMillis();
        String newDate=simpleDateFormat.format(new Date(date2));
        mapval.put("warehouseId",warehouseId);
        List<Map<String ,Object>> list1 = wmspGridMaterialMapper.selectGridMaterial(mapval);
        mapval.put("newDate",newDate);
        List<Map<String ,Object>> list2 = wmspGridMaterialMapper.getGridMaterialAgeList(mapval);
        mapval.clear();
        for (Map<String,Object> map1:list1){
            Integer status = 0;
            for (Map<String,Object> map2:list2){
                String onlyCode1 = (String) map1.get("materialOnlyCode");
                String onlyCode2 = (String) map2.get("onlyCode");
//                当两个onlyeCode相等时，设置状态
                if (onlyCode1.equals(onlyCode2)){
//                    设置状态为入库预警超过界限
                    status = 1;
                }
            }
            map1.put("status",status);
        }
        return list1;
    }
    //根据仓储网格统计数据
    @Override
    public Long countByGmId() {
        return wmspGridMaterialMapper.countByGmId();
    }

    @Override
    public List<Map<String, Object>> selectInboundTimeAndThreshold(BigDecimal gridId)  {
        return  wmspGridMaterialMapper.selectInboundTimeAndThreshold(gridId);
    }


    @Override
    public Integer insertWmspGridMaterial(WmspGridMaterial wmspGridMaterial) {
        return wmspGridMaterialMapper.insertSelective(wmspGridMaterial);
    }

    @Override
    public List<Map<String, Object>> selectGridMaterialListByGridId(Map<String, Object> mapval) {
        return wmspGridMaterialMapper.selectGridMaterialListByGridId(mapval);
    }

    @Override
    public int updateRmsMaterialSteelDemotion(Map<String, Object> map) {
        String gridId = map.get("gridId").toString();
        BigDecimal materialSteelId = wmspGridMaterialMapper.selectMaterialSteelIdByGridId(new BigDecimal(gridId));
        map.put("materialSteelId",materialSteelId);
        //逻辑删除物资钢材表的这个钢材数据并修改其质量是否合格状态
        wmspGridMaterialMapper.updateRmsMaterialSteelDemotion(map);
        //逻辑删除物资为当前钢材的钢材仓库网格物资存放关系表数据(用对象）
        WmspGridMaterial wmspGridMaterial = new WmspGridMaterial();
        wmspGridMaterial.setGridId(new BigDecimal(gridId));
        wmspGridMaterial.setDeleted(new BigDecimal(0));
        wmspGridMaterialMapper.updateByPrimaryKeySelective(wmspGridMaterial);
        //逻辑删除入库作业实绩以及相关联的所有表数据
        //通过钢材Id获取入库作业实绩Id
        BigDecimal inboundId = wmspGridMaterialMapper.selectInboundIdByMaterialSteelId(materialSteelId);
        //通过入库实绩ID逻辑删除库管员纠正吊牌实绩数据
        wmspGridMaterialMapper.updateInboundCorrectByInboundId(inboundId);
        //通过入库实绩ID逻辑删除行车工吊装入库实绩数据
        wmspGridMaterialMapper.updateInboundDrivingByInboundId(inboundId);
        //通过入库实绩ID逻辑删除吊钢工扫描吊牌实绩数据
        wmspGridMaterialMapper.updateInboundScanByInboundId(inboundId);
        //通过入库实绩ID逻辑删除系统/库管员选择垛位实绩数据
        return wmspGridMaterialMapper.updateInboundStackByInboundId(inboundId);
    }

    /**
     * 创建实时库存
     * @param item
     * @param houseGrid
     */
    @Override
    public void initInsertWmspGridMaterial(Map<String, Object> item, BigDecimal houseGrid) {
          /*
            插入一条网格物资中间表
             */
        WmspGridMaterial wmspGridMaterial = new WmspGridMaterial();
        //设置主键ID
        wmspGridMaterial.setGmId(wmspGridMaterialMapper.getCount());
        wmspGridMaterial.setGridId(houseGrid);
        wmspGridMaterial.setGmNumber(new BigDecimal(1));
        wmspGridMaterial.setStandardDataId(new BigDecimal(1));
        //设置网格物资表里面的物资ID
        BigDecimal materialId= DataChange.dataToBigDecimal(item.get("materialId"));
        wmspGridMaterial.setMaterialId(materialId);
        //设置逻辑删除字段
        wmspGridMaterial.setDeleted(new BigDecimal(0));
        //设置常规字段
        wmspGridMaterial.setInsertUsername("admin");
        wmspGridMaterial.setInsertTime(new Date());
        wmspGridMaterial.setUpdateUsername("admin");
        wmspGridMaterial.setInsertUpdateRemark("无");
        wmspGridMaterial.setStatus(new BigDecimal(2));
        insertWmspGridMaterial(wmspGridMaterial);
    }

    @Override
    public Map<String, Object> getReboundScanResultByResultMaterial(String material,String materialOnlyCode) {
        return wmspGridMaterialMapper.getReboundScanResultByResultMaterial(material,materialOnlyCode);
    }

    //修改实时库存(倒垛)

    /**
     * 所需要参数：原来的仓储网格id，修改后的垛位
     * @param map
     * @return
     */
    @Override
    public int updateWmspGridMaterial(List<Map<String, Object>> map,String restackMake) {
        int CC=0;
        int MN=0;
        int CX=0;
        int i =0;
        //获取物资唯一编码
//        List<Map<String,Object>> contents=(List<Map<String, Object>>) map.get("contents");
        for (Map<String,Object> map1:map) {
            String content =(String) map1.get("contents");
            //截取
            String[] split = content.split("-");
            String materialOnlyCode = split[7];
            //获取原来的垛位，修改垛位剩余物资数量
            //根据物资唯一编码查找原来垛位的仓储网格id
            BigDecimal GirdId = wmspGridMaterialMapper.slelectGridIdByMaterialOnlyCode(materialOnlyCode);
            //根据物资唯一编码和物资编码去查找物资现存仓存网格
            List<Map<String,Object>> list = wmspGridMaterialMapper.selectGmIdByMaterialOnlyCode(GirdId);
            Map<String,Object> stringObjectMap = list.get(0);
            BigDecimal gmId = DataChange.dataToBigDecimal(stringObjectMap.get("gmId"));
            WmspGridMaterial wmspGridMaterial=new WmspGridMaterial();
            wmspGridMaterial.setGmId(gmId);
            //设置为删除且锁定的状态
            wmspGridMaterial.setDeleted(new BigDecimal(1));
            wmspGridMaterial.setStatus(new BigDecimal(1));
            wmspGridMaterialMapper.updateByPrimaryKeySelective(wmspGridMaterial);
            //获取垛位id

            BigDecimal stackingId = DataChange.dataToBigDecimal(map1.get("stackingId"));
            //根据最新的垛位
            //计算仓储网格id
            //获取物资数
             MN=rmsStackingMapper.selectMaterialNumber(map1);
             //计算层次号
             CC=(MN)/24+1;
             //计算层序号
             CX=(MN)%24+1;
             //根据原来的仓储网格id查询仓库id
            BigDecimal warehouseId = DataChange.dataToBigDecimal(stringObjectMap.get("warehouseId"));
            Map<String,Object> map2=new HashMap<>();
            map2.put("gradationNumber",CC);
            map2.put("sequenceNumber",CX);
            map2.put("stackingID",stackingId);
            map2.put("warehouseId",warehouseId);
            BigDecimal GridId = rmsPwarehouseGridMapper.selectGridId(map2);
            BigDecimal gmNumber =(BigDecimal) stringObjectMap.get("gmNumber");
            BigDecimal weight = (BigDecimal) stringObjectMap.get("weight");
            BigDecimal materialId =(BigDecimal) stringObjectMap.get("materialId");
            //新增实时库存
            wmspGridMaterial.setGmId(wmspGridMaterialMapper.getCount());
            wmspGridMaterial.setGridId(GridId);
            wmspGridMaterial.setMaterialId(materialId);
            wmspGridMaterial.setGmNumber(gmNumber);
            wmspGridMaterial.setGmWeight(weight);
            wmspGridMaterial.setInsertTime(new Date());
            wmspGridMaterial.setInsertUsername("admin");
            wmspGridMaterial.setDeleted(new BigDecimal(0));
            wmspGridMaterial.setStatus(new BigDecimal(2));
            wmspGridMaterial.setStandardDataId(new BigDecimal(1));
            wmspGridMaterialMapper.insertSelective(wmspGridMaterial);
//            逻辑删除之间的物资的实时库存


//        4、改变当前订单中已经稽核的吊牌的状态，改为已倒垛
//            根据吊牌扫描结果查找对应的吊牌扫描实绩Id
            List<Map<String,Object>> list1=wmspRestackScanResultMapper.getResultId(new BigDecimal(content));
            BigDecimal resultId =(BigDecimal) list1.get(0).get("resultId");
            WmspRestackScanResult wmspRestackScanResult = new WmspRestackScanResult();
            wmspRestackScanResult.setResultId(resultId);
            wmspRestackScanResult.setStatus(new BigDecimal(1));
            i += wmspRestackScanResultMapper.updateByPrimaryKeySelective(wmspRestackScanResult);

            //        3、将当前订单的总数量减去上面当前订单中已经稽核的吊牌
            WmspRestackMakeResult wmspRestackMakeResult = new WmspRestackMakeResult();
            wmspRestackMakeResult.setResultId(new BigDecimal(restackMake));

            BigDecimal quantity=wmspRestackMakeResultMapper.getQuantity(restackMake);
//            将当前订单的总数量减一
            wmspRestackMakeResult.setQuantity(quantity.subtract(new BigDecimal(1)));
            i += wmspRestackMakeResultMapper.updateByPrimaryKeySelective(wmspRestackMakeResult);
            //            判断当前订单的总数量是否小于或等于0
            if (quantity.compareTo(new BigDecimal(1))==-1){
//                当存在时直接结束当前循环
//                当这个订单完成之后，将这个订单下扫描的所有的物资的倒垛状态改变
                List<Map<String, Object>> maps = wmspRestackMakeResultMapper.getScanResultList(restackMake);
                int j=0;
//                遍历所有的吊牌，并改变其状态
                for (Map<String,Object> map3:maps){
                    BigDecimal resultIds = (BigDecimal)map3.get("resultId");
//                    创建扫描实体类
                    WmspRestackScanResult wmspRestackScanResult1 =new WmspRestackScanResult();
                    wmspRestackScanResult1.setResultId(resultIds);
                    wmspRestackScanResult1.setStatus(new BigDecimal(2));
                    j +=wmspRestackScanResultMapper.updateByPrimaryKeySelective(wmspRestackScanResult1);
                }
            }
        }

        return i;
    }

    public List<Map<String, Object>> getMaterialTypeList(String warehouseid, BigDecimal stackingId, BigDecimal gradtionNumber) {
        return wmspGridMaterialMapper.getMaterialTypeList(warehouseid,stackingId,gradtionNumber);
    }

//    新增库存盘点实绩
    @Override
    public int insertStockTaking(String warehouseId, String materialCode, Integer quantity) {
//        根据仓库id和物资类型编码，查询当前的今日库存以及今天入库和出库数量
        List<Map<String,Object>> list= wmspGridMaterialMapper.getStockTakingList(warehouseId,materialCode);
//        遍历list，得到list的个数
        int count =list.size();
//        调用插入库存盘点实绩接口
//        创建库存盘点实绩类
        WmspCheckWarehouse wmspCheckWarehouse = new WmspCheckWarehouse();
//        添加仓库id
        wmspCheckWarehouse.setWarehouseId(new BigDecimal(warehouseId));
//        添加物资ID
        BigDecimal materialId = wmspGridMaterialMapper.getMaterialIds(materialCode);

        wmspCheckWarehouse.setMaterialId(materialId);
//        添加实际数量
        wmspCheckWarehouse.setElectronicsMaterialAmount(new BigDecimal(count));
//        添加盘点数量
        wmspCheckWarehouse.setRealMaterialAmount(new BigDecimal(quantity));
//        添加盈亏数
        Integer checkProfitloss = count - quantity;
        wmspCheckWarehouse.setCheckProfitloss(new BigDecimal(checkProfitloss));

        wmspCheckWarehouse.setInsertTime(new Date());

        wmspCheckWarehouse.setInsertUsername("admin");
//        查找当前盘点库存实绩表的最大Id
        BigDecimal checkId = wmspCheckWarehouseMapper.getMaxId();
        if (checkId==null){
            checkId = new BigDecimal(1);
        }
        wmspCheckWarehouse.setCheckId(checkId);
        int result = wmspCheckWarehouseMapper.insertSelective(wmspCheckWarehouse);

        return result;
    }

    @Override
    public List<Map<String, Object>> getStockTakingList() {

        return wmspCheckWarehouseMapper.getStockTakingList();
    }

    @Override
    public List<Map<String, Object>> getSteelMaterialList(Map<String,Object> map) {
        return wmspCheckWarehouseMapper.getSteelMaterialList(map);
    }

    @Override
    public List<Map<String, Object>> getSteelWarehouseList(Map<String, Object> mapVal) {
        return wmspCheckWarehouseMapper.getSteelWarehouseList(mapVal);
    }

    @Override
    public List<Map<String, Object>> getSteelMaterialModelList(Map<String,Object> map) {
        return wmspCheckWarehouseMapper.getSteelMaterialModelList(map);
    }
    @Override
    public int deleteGridMaterial(List<OutBoundMaterialDetailedInfo> thisMaterialDetailedInfos) {
        return wmspGridMaterialMapper.deleteGridMaterial(thisMaterialDetailedInfos,new Date());
    }

    @Override
    public int  insertReserved(String warehouseId,
                               String materialCode,
                               String materialSpecification,
                               String materialModel,
                               Integer quantity,
                               String actuallyWeight,
                               String materialTheWeight,
                               String remark) {
//        设置状态为预留转入库
        Integer status = 1;
//        根据前端传过来的物资型号，物资规格查询当前实时库存中的物资id
        List<Map<String,Object>> materialIdList=wmspGridMaterialMapper.getMaterialIdes(warehouseId,materialCode,materialSpecification,materialModel,status);
        for (Map<String,Object> map:materialIdList){}
        //        当数量小于零的时候
        if (quantity<=0){
            return 0;
        }else if (quantity>materialIdList.size()){
            //        当数量大于查询到的数量
            return -1;
        }else{
            int count = 0;
        //遍历materialList
            //创建金蝶报文
            BigDecimal inboundEasId = wmspInboundEasMapper.inboundEasId();
            Map<String, Object> head = new HashMap<>();
            head.put("number",inboundEasId);
            head.put("status","ADD");
            //事务类型--完工合格入库024
            head.put("transactionTypeNumber","024");
            //获取当前日期
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
            //业务日期-当天
            head.put("bizDate",simpleDateFormat.format(new Date()));
            //产品类别--钢材产成品001
            head.put("productTypeNumber","001");
            //库存组织--物资仓储站
            head.put("StorageOrgUnitNumber","DG001.20.06.02");
            if(DataChange.dataToBigDecimal(warehouseId).intValue() == 3){
                head.put("costCenterOrgUnitNumber","DG001.19.07");
            }else if(DataChange.dataToBigDecimal(warehouseId).intValue() == 2){
                head.put("costCenterOrgUnitNumber","DG001.19.06");
            }else if(DataChange.dataToBigDecimal(warehouseId).intValue() == 1){
                head.put("costCenterOrgUnitNumber","DG001.19.05");
            }
            head.put("adminOrgUnitNumber","DG001.19.00");
            List<Map<String,Object>> entries = new ArrayList<>();
            Map<String, Object> entry = new HashMap<>();
            entry.put("InvUpdateTypeNumber","001");
            entry.put("materialNum",materialCode);
            entry.put("asstQty",quantity);
            entry.put("wareHouseNumber","WZCCZ-CP-002");
            entry.put("poundwei",actuallyWeight);
            entry.put("remark",remark);
            entry.put("qty",materialTheWeight);
            entries.add(entry);
            Map<String,Object> input = new HashMap<>();
            input.put("head",head);
            input.put("entries",entries);
            //获取其他信息
            Map<String,Object> totalMap = easUtil.getTotalMap();
            totalMap.put("input",input);
            System.out.println(totalMap);
            JSONObject json = new JSONObject(totalMap);
            String resultMap = joinFeign.toInboundResultEas(totalMap);
            //JSONObject responseJson = new JSONObject(resultMap);
            System.out.println(resultMap);
            //根据当前时间获取早班、夜班、中班
            //新入库上传金蝶实体类
            WmspInboundEas wmspInboundEas = new WmspInboundEas();
            wmspInboundEas.setId(inboundEasId);
            wmspInboundEas.setInboundEasNo("TOEAS" + inboundEasId);
            wmspInboundEas.setInsertTime(new Date());
            wmspInboundEas.setMaterialActuallyWeight(new BigDecimal(actuallyWeight));
            wmspInboundEas.setMaterialNum(new BigDecimal(quantity));
            wmspInboundEas.setMaterialTheroticalWeight(new BigDecimal(materialTheWeight));
            wmspInboundEas.setInsertUsername(remark);
            wmspInboundEas.setInsertUpdateRemark(json.toString());
            wmspInboundEas.setUpdateUsername(resultMap);
            wmspInboundEas.setWarehouseId(new BigDecimal(warehouseId));
            wmspInboundEas.setDeleted(new BigDecimal(0));
            wmspInboundEasMapper.insertSelective(wmspInboundEas);
            for (int i =0;i<quantity;i++){
                Map<String,Object> map =materialIdList.get(i);
                BigDecimal inboundId=(BigDecimal) map.get("inboundId");
//            创建入库实体类
                WmspInboundResult wmspInboundResult = new WmspInboundResult();
                wmspInboundResult.setInboundId(inboundId);
                wmspInboundResult.setInboundIscomplete(new BigDecimal(2));
                wmspInboundResult.setInboundOnlyValue(inboundEasId);
                wmspInboundResult.setIsupload(new BigDecimal(1));
//            修改入库实绩
                count += wmspInboundResultMapper.updateByPrimaryKeySelective(wmspInboundResult);
            }
            return count;
        }
    }


    @Override
    public BigDecimal getTheoreticalByInfo(String warehouseId,
                                           String  materialCode,
                                           String materialSpecification,
                                           String materialModel,
                                           Integer status,
                                           Integer num) {
        //根据物资信息查询理重(规格、型号)
        List<Map<String,Object>> materialIdList =wmspGridMaterialMapper.getMaterialIdes(warehouseId,materialCode,materialSpecification,materialModel,status);
        BigDecimal sumTheoreticalWeight = new BigDecimal(0);
        //遍历数组，获取理重
        if(num > materialIdList.size()){
            return new BigDecimal(-1);
        }
        for(int i=0; i<num;i++){
            Map<String,Object> map =materialIdList.get(i);
            BigDecimal theoreticalWeight = DataChange.dataToBigDecimal(map.get("theoreticalWeight"));
            sumTheoreticalWeight = sumTheoreticalWeight.add(theoreticalWeight);
        }
        return sumTheoreticalWeight.divide(new BigDecimal(1000),3,4);
    }

    @Override
    public int insertInbounds(String warehouseId, String materialCode, String materialSpecification, String materialModel, Integer quantity) {
//        设置状态为入库转预留
        Integer status = 2;
        //        根据前端传过来的物资型号，物资规格查询当前实时库存中的物资id
        List<Map<String,Object>> materialIdList=wmspGridMaterialMapper.getMaterialIdesNoTime(warehouseId,materialCode,materialSpecification,materialModel,status);
        //List<Map<String,Object>> materialIdList=wmspGridMaterialMapper.getMaterialIdes(warehouseId,materialCode,materialSpecification,materialModel,status);
//        当数量小于零的时候
        if (quantity<=0){
            return 0;
        }else if (quantity>materialIdList.size()){
            //        当数量大于查询到的数量
            return -1;
        }else{
            int count = 0;
//        遍历materialList
            for (int i =0;i<quantity;i++){
                Map<String,Object> map =materialIdList.get(i);
                BigDecimal inboundId=(BigDecimal) map.get("inboundId");
//            创建入库实体类
                WmspInboundResult wmspInboundResult = new WmspInboundResult();
                wmspInboundResult.setInboundId(inboundId);
                wmspInboundResult.setInboundIscomplete(new BigDecimal(1));
                wmspInboundResult.setIsupload(new BigDecimal(0));
                wmspInboundResult.setInsertTime(new Date());
//            修改入库实绩
                count += wmspInboundResultMapper.updateByPrimaryKeySelective(wmspInboundResult);
            }
            return count;
        }
    }

//    修改实时库存
    @Override
    public int updateWmspGridMaterials(List<Map<String, Object>> list, String restackMake) {
//        map表示查询当前订单下的所有已经稽核但是未倒垛的物资包括物资唯一id、物资实时库存主键以及目标垛位
//        restackMake是当前订单编号
        int CC=0;
        int MN=0;
        int CX=0;
        int i =0;
//        遍历物资
        for(int j= 0; j<list.size();){
            Map<String ,Object> map = list.get(j);
//            2.计算物资在新垛位的目标层序
            BigDecimal stackingId = (BigDecimal) map.get("stackingId");
            //根据最新的垛位
            //计算仓储网格id
            HashMap map1 = new HashMap();
            map1.put("stackingId",stackingId);
            //获取物资数
            MN=rmsStackingMapper.selectMaterialNumber(map1);
            //计算层次号
            CC=(MN)/24+1;
            //计算层序号
            CX=(MN)%24+1;
//            3.修改物资的实时库存
//            创建仓储网格实体类
            RmsPwarehouseGrid rmsPwarehouseGrid = new RmsPwarehouseGrid();
            rmsPwarehouseGrid.setGridId((BigDecimal) map.get("gridId"));
            rmsPwarehouseGrid.setStackingId(stackingId);
            rmsPwarehouseGrid.setGridGradationNumber(new BigDecimal(CC));
            rmsPwarehouseGrid.setGridSequenceNumber(new BigDecimal(CX));
            rmsPwarehouseGridMapper.updateByPrimaryKeySelective(rmsPwarehouseGrid);

//            3.修改倒垛单的数量
//            创建倒垛实绩表
            WmspRestackMakeResult wmspRestackMakeResult = new WmspRestackMakeResult();
            BigDecimal quantitys = (BigDecimal) map.get("quantity");
            BigDecimal quantity = quantitys.subtract(new BigDecimal(1));
            wmspRestackMakeResult.setQuantity(quantity);
            wmspRestackMakeResult.setResultId((BigDecimal) map.get("restackId"));
            wmspRestackMakeResultMapper.updateByPrimaryKeySelective(wmspRestackMakeResult);
//            4.判断当前倒垛单剩余数量是否小于等于0(小于则修改所有的符合条件的倒垛单状态),并且逻辑删除当前倒垛单

            if (quantity.compareTo(new BigDecimal(0))==0){
//                  当数量小于零的时候,将所有的入库扫描的实绩状态都变成已倒垛
//                  查询该订单下的所有未倒垛的的物资
                List<Map<String,Object>> list1 = wmspRestackScanResultMapper.getResultId((BigDecimal) map.get("restackId"));
//                  创建入库扫描实体类
                for (Map<String,Object> map2:list1){
                    BigDecimal resultId = (BigDecimal) map2.get("resultId");
                    WmspRestackScanResult wmspRestackScanResult = new WmspRestackScanResult();
                    wmspRestackScanResult.setResultId(resultId);
                    wmspRestackMakeResult.setResultStatus(new BigDecimal(1));
                    wmspRestackScanResultMapper.updateByPrimaryKeySelective(wmspRestackScanResult);
                }

//                将该订单的状态变为已完成
                WmspRestackMakeResult wmspRestackMakeResult1 = new WmspRestackMakeResult();
                wmspRestackMakeResult1.setResultId((BigDecimal) map.get("restackId"));
                wmspRestackMakeResult1.setResultStatus(new BigDecimal(1));
                wmspRestackMakeResultMapper.updateByPrimaryKeySelective(wmspRestackMakeResult1);
            }
            i++;
            j++;
        }
        return i;
    }

    @Override
    public List<Map<String, Object>> getGridMaterialAgeList(Map<String,Object> mapVal,Integer warehouseId) {
//        通过当前时间获得前一个月的时间
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar cal= Calendar.getInstance();
        cal.add(Calendar.MONTH, -1);
        long date2 = cal.getTimeInMillis();
        String newDate=simpleDateFormat.format(new Date(date2));
        mapVal.put("warehouseId",warehouseId);
        mapVal.put("newDate",newDate);
        List<Map<String, Object>> list =wmspGridMaterialMapper.getGridMaterialAgeList(mapVal);
        return list;
    }


}