DAL-TMS-TRUCK-API/src/main/java/com/steerinfo/dil/service/impl/TmstruckLoadResultServiceImpl.java

package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.feign.WMSFeign;
import com.steerinfo.dil.feign.WmshBoundFeign;
import com.steerinfo.dil.mapper.TmstruckEnfactoryResultMapper;
import com.steerinfo.dil.mapper.TmstruckLoadResultMapper;
import com.steerinfo.dil.mapper.TmstruckReturnResultMapper;
import com.steerinfo.dil.model.TmstruckLoadResult;
import com.steerinfo.dil.service.ITmstruckLoadResultService;
import com.steerinfo.dil.util.DataChange;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

/**
 * TmstruckLoadResult服务实现：
 * @author generator
 * @version 1.0-SNAPSHORT 2021-09-02 10:38
 * 类描述
 * 修订历史：
 * 日期：2021-09-02
 * 作者：generator
 * 参考：
 * 描述：TmstruckLoadResult服务实现
 * @see null
 * @Copyright 湖南视拓信息技术股份有限公司. All rights reserved.
 */
@Service(value = "tmstruckLoadResultService")
public class TmstruckLoadResultServiceImpl implements ITmstruckLoadResultService {

    @Autowired
    private TmstruckLoadResultMapper tmstruckLoadResultMapper;

    @Autowired
    private TmstruckEnfactoryResultMapper tmstruckEnfactoryResultMapper;

    @Autowired
    private TmstruckReturnResultMapper tmstruckReturnResultMapper;

    @Autowired
    private UtilsServiceImpl utilsService;

    @Autowired
    private WmshBoundFeign wmshBoundFeign;

    @Autowired
    private WMSFeign wmsFeign;


    /**
     * 查询所有装车实绩
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getAllLoadResult(Map<String, Object> map) {
        Integer orderType = (Integer) map.get("orderTypee");
        switch (orderType) {
            case 1:
            case 2:
            case 3:
            case 4:
                map.put("status", 0);
                return tmstruckLoadResultMapper.getXSLoadResult(map);
            case 5:
                break;
            case 6:
                break;
            case 7:
                break;
            case 8:
                return tmstruckLoadResultMapper.getCGJKLoadResult(map);
            case 9:

                break;
            case 10:

                break;
            case 11:
        }
        return null;
    }


    /**
     * 新增采购装车实绩
     * @param map  resultMeasuredTonnage ：计量吨位  portId：港口ID
     *             resultLoadStartTime：装车时间 resultIsclear：是否清场
     */
    @Transactional
    public int addCGLoadResult(Map<String,Object> map){
        //通过运输订单号 或 运单Id 查询实绩总表ID  此方法在 进厂作业mapper中
        Integer totalId = tmstruckEnfactoryResultMapper.selectOrderIdByCpAndOn(map);
        // 新增装车实绩
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        //添加主键Id
        tmstruckLoadResult.setResultId(tmstruckLoadResultMapper.selectMaxId());
        //新增计量吨位 装车所装的重量
        BigDecimal resultMeasuredTonnage = DataChange.dataToBigDecimal(map.get("resultMeasuredTonnage"));
        tmstruckLoadResult.setResultMeasuredTonnage(resultMeasuredTonnage);
        tmstruckLoadResult.setStatus(new BigDecimal(0));
        tmstruckLoadResult.setResultTotalId(new BigDecimal(totalId));
        String resultIsclear = (String) (map.get("resultIsclear"));
        tmstruckLoadResult.setResultIsclear(resultIsclear);
        tmstruckLoadResult.setResultLoadStartTime(new Date((long) map.get("resultLoadStartTime")));
        tmstruckLoadResult.setInsertUpdateRemark((String) map.get("insertUpdateRemark"));
        Object portId = map.get("portId"); //获取港口
        if(portId != null){
            //通过订单ID获取批次Id
            BigDecimal batchId = tmstruckLoadResultMapper.getBatchIdByOrderId(DataChange.dataToBigDecimal(map.get("orderId")));
            if(batchId != null){
                Map<String, Object> hashMap = new HashMap<>();
                hashMap.put("batchId", batchId);
                hashMap.put("portId", portId);
                hashMap.put("resultTonnage",resultMeasuredTonnage);
                hashMap.put("isClean", resultIsclear);
                wmshBoundFeign.addResult(hashMap);
                // 通过港口ID查询仓库表中的港存库ID
                BigDecimal warehouseId = tmstruckLoadResultMapper.getWarehouseIdByPortId(DataChange.dataToBigDecimal(portId));
                tmstruckLoadResult.setLoadingId(warehouseId); // 添加装货点为港口
            }
        }
        int i = tmstruckLoadResultMapper.insertSelective(tmstruckLoadResult);
        //修改订单状态为执行中 1
        int i1 = utilsService.updateOrderStatus(map, 1);
        //修改运力状态为执行中 1
//        int i2 = utilsService.updateCapacityStatus(map, 1);
        return i + i1;
    }


    /**
     * 生成销售装车实绩（虚拟装车实绩）
     * @param map
     * @return
     */
    public int addLoadResult(Map<String, Object> map){
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        //添加主键Id
        tmstruckLoadResult.setResultId(tmstruckLoadResultMapper.selectMaxId());
        //添加物资Id
        tmstruckLoadResult.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
        //添加总实绩ID
        tmstruckLoadResult.setResultTotalId(DataChange.dataToBigDecimal(map.get("resultTotalId")));
        return tmstruckLoadResultMapper.insertSelective(tmstruckLoadResult);
    }

    /**
     * 修改销售装车实绩  （如果是多种物资【多拼】，通过物资Id和运输订单号来确定唯一的装车实绩进行修改）
     * @param map 物资唯一编码  运输订单号
     * @return
     */
    public int addXSLoadResult(Map<String, Object> map){
        //通过物资唯一编码查找物资Id
        BigDecimal materialId = tmstruckLoadResultMapper.getMaterialIdByMaterialCode((String) map.get("materialCode"));
        //通过运输订单号查找总实绩ID
        Integer resultTotalId = tmstruckEnfactoryResultMapper.selectOrderIdByCpAndOn(map);
        //通过总实绩ID与物资ID查找装车实绩主键ID
        Integer resultId = tmstruckLoadResultMapper.getLoadResultIdByMIdAndTotalId(resultTotalId, materialId.intValue());
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        tmstruckLoadResult.setStatus(new BigDecimal(0)); // 添加状态0:正常
        //添加主键
        tmstruckLoadResult.setResultId(new BigDecimal(resultId));
        //新增计量吨位 装车所装的重量
        tmstruckLoadResult.setResultMeasuredTonnage(DataChange.dataToBigDecimal(map.get("resultMeasuredTonnage")));
        //获取扫描实绩最小Id  添加扫描开始时间
        Integer scanId = tmstruckLoadResultMapper.getMinScanIdByOrderNum(map);
        Map timeMap = tmstruckLoadResultMapper.selectLoadTimeByResultId(scanId);
        Date resultLoadStartTime = (Date) timeMap.get("loadTime");
        tmstruckLoadResult.setResultLoadStartTime(resultLoadStartTime);
        //添加扫描结束时间
        Date resultLoadEndTime = new Date();
        tmstruckLoadResult.setResultLoadEndTime(resultLoadEndTime);
        //添加装车实绩时长  ----  计算装车时长
        long time = (resultLoadEndTime.getTime() - resultLoadStartTime.getTime()) / 60000; // 分钟
        tmstruckLoadResult.setResultLoadDuration(new BigDecimal(time));
        //添加装卸工Id
        tmstruckLoadResult.setLoaderId(new BigDecimal(1));
        //添加备注
        tmstruckLoadResult.setInsertUpdateRemark((String) map.get("insertUpdateRemark"));
        //新增出库实绩
//        wmsFeign.insertOutBoundResult(map);
        return tmstruckLoadResultMapper.insertSelective(tmstruckLoadResult);
    }

    /**
     * 修改装车作业
     *
     * @param tmstruckLoadResult
     * @return
     */
    @Override
    public int updateLoadResult(TmstruckLoadResult tmstruckLoadResult) {
        return tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
    }

    /**
     * 通过ID查询装车实绩
     *
     * @param resultId
     * @return
     */
    @Override
    public List<Map<String, Object>> getLoadResultById(Integer resultId) {
        return tmstruckLoadResultMapper.getLoadResultById(resultId);
    }

    /**
     * 逻辑删除装车实绩 状态 1
     * @param resultId
     * @return
     */
    @Override
    public int deleteLoadResult(Integer resultId) {
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        tmstruckLoadResult.setResultId(new BigDecimal(resultId));
        tmstruckLoadResult.setStatus(new BigDecimal(1));
        return tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
    }

    /**
     * 修改装车作业点 多个装车点随机分配给多个装车实绩
     * @param mapList
     * @return
     */
    @Override
    public int updateLoadingId(List<Map<String, Object>> mapList) {
        int i = 0;
        //获取所有装车实绩ID
        for (Map<String, Object> map : mapList) {
            TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
            //通过传过来的物资ID（一个订单中物资ID唯一） 和订单Id 寻找装车实绩ID
            Integer resultIdList = tmstruckLoadResultMapper.getLoadResultIdList(map);
            tmstruckLoadResult.setResultId(new BigDecimal(resultIdList));
            //获取算出来的装车点
            tmstruckLoadResult.setLoadingId(DataChange.dataToBigDecimal(map.get("loadingId")));
            i += tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
        }
        return i;
    }

    /**
     * 查询销售合同装车实绩
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> selectLoadResultForSale(Map<String, Object> map) {
        return tmstruckLoadResultMapper.selectLoadResultForSale(map);
    }

    //内转物流，新增装车实绩
    @Override
    public int addLoadResultForconverted(Map<String, Object> map) {
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        //设置主键id
        tmstruckLoadResult.setResultId(tmstruckLoadResultMapper.selectMaxId());
        //获取开始时间
        Date startTime = (Date) map.get("startTime");
        //获取运输订单号
        String OrderNumber = map.get("OrderNumber").toString();
        Map<String, Object> Map = new HashMap<>();
        Map.put("OrderNumber", OrderNumber);
        //通过运输订单号查找物资id
        List<Map<String, Object>> materialIdList = tmstruckLoadResultMapper.selectMaterialIdByOrderNumber(Map);
        //设置物资id
        for (int i = 0; i < materialIdList.size(); i++) {
            Map<String, Object> map1 = materialIdList.get(i);
            Integer materialId = (Integer) map1.get("materialId");
            tmstruckLoadResult.setMaterialId(new BigDecimal(materialId));
        }
        //绑定总实绩id
        Map<String, Object> map2 = tmstruckReturnResultMapper.getResultTotalIdByOrderNumber(OrderNumber);
        BigDecimal reultTotalId = (BigDecimal) map2.get("resultTotalId");
        //设置总实绩id
        tmstruckLoadResult.setResultTotalId(reultTotalId);
        tmstruckLoadResult.setResultLoadStartTime(startTime);
        //获取用户id
        Integer personnelId = (Integer) map.get("personnelId");
        String personnelName = tmstruckLoadResultMapper.selectPersonNameByPersonnelId(personnelId);
        tmstruckLoadResult.setInsertTime(new Date());
        tmstruckLoadResult.setInsertUsername(personnelName);
        int i = tmstruckLoadResultMapper.insertSelective(tmstruckLoadResult);
        return i;
    }

    //内转物流,修改装车实绩
    @Override
    public int updateLoadResultForconverted(Map<String, Object> map) {
        //获取装车实绩id
        //通过运输订单号查找装车实绩
        String orderNumber = (String) map.get("orderNumber");
        Map<String, Object> map1 = tmstruckLoadResultMapper.selectLoadResultIdByOrderNumber(orderNumber);
        //获取结束时间
        Integer LoadResultId = (Integer) map1.get("loadResultId");
        Date endTime = (Date) map.get("endTime");
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        //根据主键id设置装车结束时间
        tmstruckLoadResult.setResultId(new BigDecimal(LoadResultId));
        tmstruckLoadResult.setResultLoadEndTime(endTime);
        //获取装车开始时间
        Date startTime = (Date) map1.get("startTime");
        //开始时间
        long LoadstartTime = startTime.getTime();
        long LoadendTime = endTime.getTime();
        long time = LoadendTime - LoadstartTime;
        long l = time / 1000;
        //设置标准时长
        tmstruckLoadResult.setResultLoadDuration(new BigDecimal(l));
        int i = tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
        return i;
    }

    @Override
    public Map<String, Object> getLoadResultIdForOrderNumber(String orderNumber) {
        return tmstruckLoadResultMapper.selectLoadResultIdByOrderNumber(orderNumber);
    }

    /**
     * 内转物流汽车装货实绩展示
     *
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> selectLoadResultForConverted(Map<String, Object> map) {
        return tmstruckLoadResultMapper.selectLoadResultForConverted(map);
    }


    /**
     * 根据实绩id渲染数据
     *
     * @param resultId
     * @return
     */
    @Override
    public List<Map<String, Object>> selectLoadResultByResultId(Integer resultId) {
        return tmstruckLoadResultMapper.selectLoadResultByResultId(resultId);
    }

    /**
     * 内转物流新增装车实绩(火车卸货后装车，装车点固定为达州站）
     *
     * @param map
     * @return
     */
    @Override
    public int addLoadResultForConverted(Map<String, Object> map) {
        Integer personnelId = (Integer) map.get("personnelId");
        String personnelName = tmstruckLoadResultMapper.selectPersonNameByPersonnelId(personnelId);
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        tmstruckLoadResult.setResultId(tmstruckLoadResultMapper.selectMaxId());
        //获取车牌号，物资id以及总实绩id
        String capacityNumber = (String) map.get("capacityNumber");
        Map<String, Object> map1 = tmstruckLoadResultMapper.selectMaterialIdAndCapacityId(capacityNumber);
        BigDecimal materialId = (BigDecimal) map1.get("materialId");
        BigDecimal resultTotalId = (BigDecimal) map1.get("resultTotalId");
        tmstruckLoadResult.setMaterialId(materialId);
        tmstruckLoadResult.setResultTotalId(resultTotalId);
        tmstruckLoadResult.setInsertTime(new Date());
        //获取装货点
        Integer arrivalId = (Integer) map.get("arrivalId");
        tmstruckLoadResult.setLoadingId(DataChange.dataToBigDecimal(arrivalId));
        Date insertTime = (Date) map.get("insertTime");
        tmstruckLoadResult.setInsertTime(insertTime);
        Integer tonnage = (Integer) map.get("tonnage");
        tmstruckLoadResult.setResultMeasuredTonnage(DataChange.dataToBigDecimal(tonnage));
        tmstruckLoadResult.setInsertUsername(personnelName);
        return tmstruckLoadResultMapper.insertSelective(tmstruckLoadResult);
    }

    @Override
    public int addLoadResultForSale(Map<String, Object> map) {
        //新增装车实绩
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        //新增id
        tmstruckLoadResult.setResultId(tmstruckLoadResultMapper.selectMaxId());
        //通过运输订单号查找物资
        List<Map<String, Object>> materialList = tmstruckLoadResultMapper.selectMaterialIdByOrderNumber(map);
        for (int i = 0; i < materialList.size(); i++) {
            Map<String, Object> map3 = materialList.get(i);
            BigDecimal materialId = (BigDecimal) map3.get("materialId");
            tmstruckLoadResult.setMaterialId(materialId);
            if (tmstruckLoadResultMapper.selectMaterialTypeByMaterialId(materialId.intValue())==2) {
                List list = tmstruckLoadResultMapper.selectResultIdByOrderNumber((String) map.get("orderNumber"));
                //查询最大id和最小id
                Integer maxResultId = (Integer) Collections.max(list);
                Integer minResultId = (Integer) Collections.min(list);
                //根据最大id查找扫描时间
                Map map1 = tmstruckLoadResultMapper.selectLoadTimeByResultId(minResultId);
                Date startdate = (Date) map1.get("loadTime");
                Integer loaderId = tmstruckLoadResultMapper.selecLoadIdByresultId(minResultId);
                //根据最小id查找扫描时间
                Map map2 = tmstruckLoadResultMapper.selectLoadTimeByResultId(maxResultId);
                Date endDate = (Date) map2.get("loadTime");
                tmstruckLoadResult.setResultLoadStartTime(startdate);
                tmstruckLoadResult.setResultLoadEndTime(endDate);
                //开始时间
                long startTime = startdate.getTime();
                long endTime = endDate.getTime();
                long time = endTime - startTime;
                long l = time / 1000;
                tmstruckLoadResult.setResultLoadDuration(new BigDecimal(l));
                tmstruckLoadResult.setLoaderId(new BigDecimal(loaderId));
                //新增出库实绩
                wmsFeign.insertOutBoundResult(map);
                //水渣，焦炭装车
            }else if (tmstruckLoadResultMapper.selectMaterialTypeByMaterialId(materialId.intValue())==7
                    &&tmstruckLoadResultMapper.selectMaterialTypeByMaterialId(materialId.intValue())==8){
                //新增水渣，焦炭装车实绩
                //获取结束时间
                Integer LoadResultId = (Integer) map.get("loadResultId");
                Date endTime = (Date) map.get("endTime");
                //根据主键id设置装车结束时间
                tmstruckLoadResult.setResultId(new BigDecimal(LoadResultId));
                tmstruckLoadResult.setResultLoadEndTime(endTime);
                //获取装车开始时间
                Date startTime = (Date) map.get("startTime");
                //开始时间
                long LoadstartTime = startTime.getTime();
                long LoadendTime = endTime.getTime();
                long time = LoadendTime - LoadstartTime;
                long l = time / 1000;
                //设置标准时长
                tmstruckLoadResult.setResultLoadDuration(new BigDecimal(l));
            }

        }
        int i=tmstruckLoadResultMapper.insertSelective(tmstruckLoadResult);
        return i;
}

}