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

package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.feign.OmsFeign;
import com.steerinfo.dil.mapper.*;
import com.steerinfo.dil.model.TmstruckUnloadResult;
import com.steerinfo.dil.service.ITmstruckUnloadResultService;
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 javax.xml.crypto.Data;
import java.math.BigDecimal;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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

    @Autowired
    private TmstruckUnloadResultMapper tmstruckUnloadResultMapper;


    @Autowired
    private TmstruckReceiveResultServiceImpl tmstruckReceiveResultService;

    @Autowired
    private TmstruckLoadResultMapper tmstruckLoadResultMapper;

    @Autowired
    private UtilsServiceImpl utilsService;

    @Autowired
    private TmstruckMeasureCommissionServiceImpl tmstruckMeasureCommissionService;


    @Autowired
    OmsFeign omsFeign;

    @Autowired
    UtilsMapper utilsMapper;

    @Autowired
    TmstruckLeaveFactoryResultServiceImpl tmstruckLeaveFactoryResultService;
    @Autowired
    TmstruckTimeTaskResultServiceImpl tmstruckTimeTaskResultService;
    @Autowired
    TmstruckTimeTaskResultMapper tmstruckTimeTaskResultMapper;

    @Autowired
    private RulesServiceImpl rulesService;
    /**
     * 新增卸货实绩
     * 总实绩ID、卸货点
     * @param map
     * @return
     */
    @Override
    public int addUnloadResult(Map<String, Object> map) {
        TmstruckUnloadResult tmstruckUnloadResult = new TmstruckUnloadResult();
        //生成主键ID
        BigDecimal maxId = tmstruckUnloadResultMapper.selectMaxId();
        tmstruckUnloadResult.setId(maxId);
        //插入实绩总表ID
        tmstruckUnloadResult.setResultTotalId(DataChange.dataToBigDecimal(map.get("resultTotalId")));
        // 添加路段顺序号
        tmstruckUnloadResult.setSegmentSqe(DataChange.dataToBigDecimal(map.get("segmentSqe")));
        //插入卸货点 通过总实绩ID查询卸货点
        tmstruckUnloadResult.setResultUnloadPlaceId(tmstruckUnloadResultMapper.getUnloadPointId(map));
        //新增卸车实绩
        return tmstruckUnloadResultMapper.insertSelective(tmstruckUnloadResult);
    }

    /**
     * 查询所有卸货实绩
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getUnloadResult(Map<String, Object> map) {
        Integer orderType = (Integer) map.get("orderTypee");
        switch (orderType){
            case 1:

                break;
            case 2:

                break;
            case 3:

                break;
            case 4:

                break;
            case 5:
            case 6:
            case 7:
            case 8:
            case 17:
            case 18:
                return tmstruckUnloadResultMapper.getCGUnloadResult(map); //apiId:103
            case 9:
                return tmstruckUnloadResultMapper.getImportedDomesticNzUnloadResult(map); //apiId:355
            case 10:
            case 20:
            case 15:
            case 16:
            case 23:
            case 24:
                return tmstruckUnloadResultMapper.getImportedDomesticNzUnload2Result(map); //apiId:356
            case 11:
                String con = (String) map.get("con");
                if (con!=null){
                    map.put("con","%"+con+"%");
                }
                return tmstruckUnloadResultMapper.getInFactoryUnloadResult(map); //apiId:360
            case 12:
            case 13:
            case 14:
            case 19:
            case 100:
                return  tmstruckUnloadResultMapper.getSporadicSuppliesUnloadResult(map);//apiId:389
        }
        return null;
    }

    /**
     * 更新卸货实绩内容 扫码人员扫码后获取信息传输数据给接口
     * @param map
     * @return
     */
    @Override
    @Transactional
    public int updateUnloadResult(Map<String, Object> map) throws Exception {
        //通过运输订单号查询订单类型
        String orderNumber = (String) map.get("orderNumber");
        //通过订单号查询订单类型 及总实绩Id
        Map<String, Object> mesMap = utilsMapper.getOrderTypeByOrderNumber(orderNumber);
        if(mesMap==null){
            return -5;
        }
        //卸货时查询是否含有净重
        BigDecimal totalId = DataChange.dataToBigDecimal(mesMap.get("totalId"));
        Integer netWeight = tmstruckUnloadResultMapper.getNetWeightByTotalId(totalId);

        int orderType = DataChange.dataToBigDecimal(mesMap.get("orderType")).intValue();
        //判断是不是内转
        if(orderType == 11 || orderType == 15 || orderType == 16 || orderType == 25){
            //根据运输订单id查询需求里面的备注
            String requireRemark = utilsMapper.getRequireRemark(DataChange.dataToBigDecimal(mesMap.get("orderId")));
            //如果是内转新增卸货实绩
            Integer sqe = utilsMapper.getLineSequenceByOrderNumber((String) map.get("orderNumber"));
            sqe = sqe == null ? 1 : sqe +1;
            map.put("resultId",tmstruckUnloadResultMapper.selectMaxId());
            map.put("Sqe",sqe);
            map.put("totalId",totalId);
            TmstruckUnloadResult tmstruckUnloadResult = generateUnload(map);
            try{
                Integer resultId=tmstruckUnloadResultMapper.checkMaterialIdUnload(totalId, DataChange.dataToBigDecimal(map.get("materialId")));
                if(orderType == 11 && resultId != null){
                    //如果已经存在，根据主键更新
                    tmstruckUnloadResult.setResultId(new BigDecimal(resultId));
                    tmstruckUnloadResultMapper.updateByPrimaryKeySelective(tmstruckUnloadResult);
                }else{
                    //不存在，插入
                    tmstruckUnloadResultMapper.insertSelective(tmstruckUnloadResult);
                }
            }catch (Exception e){
                e.printStackTrace();
                //出现异常，插入
                tmstruckUnloadResultMapper.insertSelective(tmstruckUnloadResult);
            }
            //更新路段顺序号
            //内转只要是卸货都直接关闭订单 事务跨服务更改同表同一行数据 不能调用 会锁行
            //如果没有净重更新路段顺序号需要继续回皮 有就结束订单
            if(netWeight == 0 && orderType != 25){
                mesMap.put("orderLineSequence",sqe);
                if(requireRemark != null && "不需要过磅".equals(requireRemark)) {
                    omsFeign.closeInwardOrder(DataChange.dataToBigDecimal(mesMap.get("orderId")).intValue(), sqe, null);
                }else{
                    utilsService.updateOrderLineSqeByOrderNumber(mesMap);
                }
            } else {
                omsFeign.closeInwardOrder(DataChange.dataToBigDecimal(mesMap.get("orderId")).intValue(), sqe, null);
            }
            //卸货成功后推送消息给websocket
            utilsService.pushMesToWebsocket((String) mesMap.get("capacityNumber"), "卸货");
            //根据运输订单查找需求备注
            BigDecimal orderId = DataChange.dataToBigDecimal(mesMap.get("orderId"));
            Map<String,Object>  remarkMap=tmstruckTimeTaskResultMapper.selectInwardDueTimeByOrderId(orderId);
            String remark =(String) remarkMap.get("remark");
            if (remark != null && remark.contains("计时") && orderType != 25){
                 map.put("inwardTypes",3);
                 tmstruckTimeTaskResultService.addTimeTaskResult(map);
            }
            return 1;
        }
        //如果是零星多拼订单 需要查询这个物资是否已经卸过了
        if(orderType == 12 || orderType == 13||orderType==19){
            mesMap.put("updateLoadResult", 1); //需要路段顺序号查询
            Integer checkMaterial = tmstruckUnloadResultMapper.checkMaterialIdUnload(DataChange.dataToBigDecimal(mesMap.get("totalId")), DataChange.dataToBigDecimal(map.get("materialId")));
            if(checkMaterial != null){
                return -2;  //已卸过此物资
            }
            if (orderType==19){
                //发送计量委托
                Map<String,Object> sporadicMap=new HashMap<>();
                sporadicMap.put("orderId",DataChange.dataToBigDecimal(mesMap.get("orderId")).intValue());
                sporadicMap.put("materialId",DataChange.dataToBigDecimal(map.get("materialId")));
                int i = tmstruckMeasureCommissionService.addSporadicOddMeasureCommission(sporadicMap);
                if (i==0){
                    return -4;
                }
            }
        }
        Map<String, Object> dataMap = tmstruckUnloadResultMapper.selectUnloadMesByOrderNo(mesMap);
        if(dataMap == null){
            return -3;  //该订单没有卸货作业
        }
        //获取该实绩的路段顺序号
        BigDecimal segmentSqe = DataChange.dataToBigDecimal(dataMap.get("segmentSqe"));
        //获取订单的路段顺序号
        BigDecimal orderSegmentSqe = DataChange.dataToBigDecimal(mesMap.get("orderSegmentSqe"));
        if(segmentSqe.intValue() > (orderSegmentSqe.intValue() + 1)){
            return -6;
        }
        map.putAll(dataMap);
        updateUnloadResultBy(map);//更新卸货实绩

        if(netWeight == 0 || (netWeight == 1 && (orderType == 10 || orderType == 20||orderType==19))){ //如果没有净重 则更新路段顺序号  有则不更新
            //路段顺序号 + 1
            map.put("orderId", mesMap.get("orderId"));
            utilsService.updateOrderLineSequence(map);
        }
        switch (orderType){
            case 5:
            case 6:
            case 7:
            case 8:
            case 9:
            case 10:
            case 12:
            case 17:
            case 18:
            case 20:
                tmstruckReceiveResultService.addReceiveResult(DataChange.dataToBigDecimal(map.get("resultTotalId"))); //新增完卸车实绩后新增一条收货实绩
                break;
        }
        //卸货成功后推送消息给websocket
        utilsService.pushMesToWebsocket((String) mesMap.get("capacityNumber"), "卸货");
        return 1;
    }

    /*
    内转物流新增卸货实绩
     */
    private TmstruckUnloadResult generateUnload(Map<String, Object> map) {
        TmstruckUnloadResult tmstruckUnloadResult = new TmstruckUnloadResult();
        tmstruckUnloadResult.setResultId(DataChange.dataToBigDecimal(map.get("resultId")));
        tmstruckUnloadResult.setResultTotalId(DataChange.dataToBigDecimal(map.get("totalId")));
        tmstruckUnloadResult.setSegmentSqe(DataChange.dataToBigDecimal(map.get("Sqe")));
        //添加卸货点
        if(map.get("warehouseId") !=null){
            tmstruckUnloadResult.setResultUnloadPlaceId(DataChange.dataToBigDecimal(map.get("warehouseId")));
        }
        if(map.get("personnelSsoId") !=null){
            //通过SSo主键查询人员管理主键
            Integer personnelId = utilsMapper.getPersonnelIdBySsoId((String)map.get("personnelSsoId"));
            if(personnelId !=null){
                tmstruckUnloadResult.setUnloaderId(new BigDecimal(personnelId));
            }
        }
        //判断物资是否为空
        if(map.get("materialId") != null){
            tmstruckUnloadResult.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
        }
        //添加卸货时间
        tmstruckUnloadResult.setResultEndTime(new Date());
        //确认卸货设为同意
        tmstruckUnloadResult.setUnloadStatus("同意");
        tmstruckUnloadResult.setInsertTime(new Date());
        tmstruckUnloadResult.setInsertUsername("admin");
        return tmstruckUnloadResult;


    }


    /**
     * 扫码确认卸货 更新卸货实绩
     *  运输订单号
     *  卸货时间
     *  卸货地点
     * @param map
     * @return
     */
    public int updateUnloadResultBy(Map<String, Object> map){
        TmstruckUnloadResult tmstruckUnloadResult = new TmstruckUnloadResult();
        tmstruckUnloadResult.setResultId(DataChange.dataToBigDecimal(map.get("resultId")));
        // 修改卸货点
        if(map.get("warehouseId") != null){
            tmstruckUnloadResult.setResultUnloadPlaceId(DataChange.dataToBigDecimal(map.get("warehouseId")));
        }
        if(map.get("personnelSsoId") != null){
            //通过SSo主键查询人员管理主键
            Integer personnelId = utilsMapper.getPersonnelIdBySsoId((String) map.get("personnelSsoId"));
            if(personnelId != null){
                tmstruckUnloadResult.setUnloaderId(new BigDecimal(personnelId));
            }
        }
        //判断物资id是否为空
        if (map.get("materialId") != null){
            tmstruckUnloadResult.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
        }
        if (map.get("unloadNumber")!=null){
            tmstruckUnloadResult.setUnloadNumber(DataChange.dataToBigDecimal(map.get("unloadNumber")));
        }
        //获得卸货时间
        tmstruckUnloadResult.setResultEndTime(new Date());
        //扫码后确认卸货所以卸货状态码为  同意
        tmstruckUnloadResult.setUnloadStatus("同意");
        tmstruckUnloadResult.setInsertTime(new Date());
        tmstruckUnloadResult.setInsertUsername("admin");
        //新增卸车实绩内容
        return tmstruckUnloadResultMapper.updateByPrimaryKeySelective(tmstruckUnloadResult);
    }


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

    //根据运输订单查找装车实绩id
    @Override
    public Map<String, Object> selectLoadResultIdByOrderNumber(String orderNumber) {
        return tmstruckUnloadResultMapper.selectUnloadResultIdByOrderNumber(orderNumber);
    }


    //零星物资判断物资是否需要多次计量，并发送计量委托
    @Override
    public int materialIdIsNorWeight(Map<String, Object> map) {
        //获取订单id
        String orderNumber =(String) map.get("orderNumber");
        List<Map<String, Object>> maps = tmstruckUnloadResultMapper.selectMaterialForUnload(orderNumber);
        for (Map<String,Object> map1:maps){
            BigDecimal materialId =(BigDecimal) map1.get("materialId");
            BigDecimal orderId =(BigDecimal) map1.get("orderId");
            Map<String,Object> map2=new HashMap<>();
            map2.put("materialId",materialId);
            map2.put("orderId",orderId);
            //判断物资是否被计量
            Integer integer = tmstruckUnloadResultMapper.selectUnloadMaterialId(map2);
            if (integer==0){
                //调用计量实绩接口,发送计量委托
                tmstruckMeasureCommissionService.addLXMeasureCommission(map2);
            }
        }
        return 2;
    }

    //内转物流新增卸车实绩
    @Override
    public int addUnloadresultForconverted(Map<String, Object> map) {
        TmstruckUnloadResult tmstruckUnloadResult=new TmstruckUnloadResult();
        //设置主键id
        BigDecimal maxId = tmstruckUnloadResultMapper.selectMaxId();
        tmstruckUnloadResult.setId(maxId);
        //获取开始时间
        Date startTime =(Date) map.get("startTime");
        //获取运输订单号
        String OrderNumber=map.get("OrderNumber").toString();

        //绑定总实绩id
        Map<String,Object> map2=tmstruckLoadResultMapper.selectLoadResultIdByOrderNumber(OrderNumber);
        BigDecimal  reultTotalId=(BigDecimal)map2.get("resultTotalId");
        //设置总实绩id
        tmstruckUnloadResult.setResultTotalId(reultTotalId);
        tmstruckUnloadResult.setResultStartTime(startTime);
        //获取用户id
        Integer personnelId=(Integer)map.get("personnelId");
        String personnelName= tmstruckLoadResultMapper.selectPersonNameByPersonnelId(personnelId);
        tmstruckUnloadResult.setInsertTime(new Date());
        tmstruckUnloadResult.setInsertUsername(personnelName);
        int i=tmstruckUnloadResultMapper.insertSelective(tmstruckUnloadResult);
        return i;
    }


}