DAL-DAZHOU-JOIN-API/src/main/java/com/steerinfo/dil/service/impl/TmstruckWeightResultServiceImpl.java

package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.mapper.TmstrainWeightResultMapper;
import com.steerinfo.dil.mapper.TmstruckReceiptResultMapper;
import com.steerinfo.dil.mapper.UtilsMapper;
import com.steerinfo.dil.model.TmstrainWeightResult;
import com.steerinfo.dil.model.TmstruckReceiptResult;
import com.steerinfo.dil.model.TmstruckWeightResult;
import com.steerinfo.dil.mapper.TmstruckWeightResultMapper;
import com.steerinfo.dil.service.ITmstruckWeightResultService;
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.text.SimpleDateFormat;
import java.util.Date;
import java.math.BigDecimal;

import java.util.List;
import java.util.Map;

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

    @Autowired
    TmstruckWeightResultMapper tmstruckWeightResultMapper;

    @Autowired
    UtilsServiceImpl utilsService;

    @Autowired
    UtilsMapper utilsMapper;

    @Autowired
    TmstruckReceiptResultMapper tmstruckReceiptResultMapper;

    @Autowired
    TmstrainWeightResultMapper tmstrainWeightResultMapper;

    /**
     * 接收计量实绩信息
     *      "orderNumber":"WYSDD2021091000000002",
     *      "resultTareCalculateNumber":"1号汽车衡",
     *      "resultCrossCalculateNumber":"1号汽车衡",
     *      "resultTareWeight":40.00,
     *      "resultCrossWeight":40.00,
     *      "resultNetWeight":0,
     *      "resultTareWeightTime":"2021-09-10 09:05:22",
     *      "resultCrossWeightTime":"2021-09-10 09:05:22",
     *      "resultPoundNo":"Bd123456780",
     *      "materialId":40
     * @param mapList
     * @return
     */
    @Override
    @Transactional
    public String receiveTmsTruckWeightResult(List<Map<String, Object>> mapList){
        //遍历列表
        StringBuilder sb = new StringBuilder();
        for (Map<String, Object> map : mapList) {
            sb.append(" ");
            String resultTareCalculateNumber = (String) map.get("resultTareCalculateNumber");
            //如果计量衡名字中含有铁专线 则代表是轨道衡 走轨道衡路线
            if(resultTareCalculateNumber.contains("铁专线")){
                sb.append(addTrainWeightResult(map));
            }else {
                //走汽车衡
                sb.append(addTruckWeightResult(map));
            }
        }
        return sb.toString();
    }

    /**
     * 添加汽车衡计量实绩
     * @param map
     * @return
     */
    public String addTruckWeightResult(Map<String, Object> map) {
        //通过运输订单号查询计量实绩Id
        Map<String, Object> stringObjectMap = tmstruckWeightResultMapper.selectWeightIdByOrderId(map);
        if(stringObjectMap == null){
            //如果都有净重了 通过传来的运输订单号 与 物资ID查询计重实绩ID
            stringObjectMap = tmstruckWeightResultMapper.selectTotalIdByOrderNo(map);
            if(stringObjectMap == null){
                return map.get("orderNumber") + "没有此订单信息或物资信息(" + map.get("materialId") + ")错误";
            }
        }
        map.putAll(stringObjectMap);
        TmstruckWeightResult tmstruckWeightResult = null;
        try {
            tmstruckWeightResult = generateWeightResult(map);
        } catch (Exception e) {
            return e.getMessage();
        }
        tmstruckWeightResultMapper.updateByPrimaryKeySelective(tmstruckWeightResult);
        //推送数据
        utilsService.pushMesToWebsocket((String) stringObjectMap.get("capacityNumber"), "计量");
        return map.get("orderNumber") + "成功";
    }


    /**
     * 生成汽运计量实体类
     * @param map
     * @return
     */
    public TmstruckWeightResult generateWeightResult(Map<String, Object> map) throws Exception {
        TmstruckWeightResult tmstruckWeightResult = new TmstruckWeightResult();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        tmstruckWeightResult.setId(DataChange.dataToBigDecimal(map.get("weightTaskResultId")));
        BigDecimal orderType = DataChange.dataToBigDecimal(map.get("orderTypee"));
        //磅单号
        tmstruckWeightResult.setResultPoundNo((String) map.get("resultPoundNo"));
        String resultCrossWeightTime = (String) map.get("resultCrossWeightTime");
        tmstruckWeightResult.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
        //如果是采购订单 先计毛再计皮
        if("5678".contains(orderType.toString()) || orderType.intValue() == 12 || orderType.intValue() == 14){
            //如果毛重数据为空 则是第一次计量为毛重  此时第一次计量时间放皮重时间里面
            if(resultCrossWeightTime == null || resultCrossWeightTime.length() == 0){
                //设置毛重时间
                String firstTime = (String) map.get("resultTareWeightTime");
                tmstruckWeightResult.setResultGrossWeightTime(sdf.parse(firstTime));
                //添加毛重汽车衡
                Integer tareId = tmstruckWeightResultMapper.selectTruckCalculateId((String) map.get("resultTareCalculateNumber"));
                if(tareId == null){
                    throw new Exception("没有此计量衡：" + map.get("resultTareCalculateNumber"));
                }
                tmstruckWeightResult.setResultGrossPlaceId(new BigDecimal(tareId));
                //设置毛重
                BigDecimal resultTareWeight = DataChange.dataToBigDecimal(map.get("resultTareWeight"));
                tmstruckWeightResult.setResultGrossWeight(resultTareWeight);
                tmstruckWeightResult.setInsertTime(new Date());
                tmstruckWeightResult.setInsertUsername("admin");
                //更新订单中路段顺序号
                map.put("segmentSqe", map.get("grossSegmentSqe")); //毛重路段顺序
                utilsService.updateOrderLineSequence(map);
            }else {
                addWeightResult(tmstruckWeightResult, map); //添加计量实绩数据
                //更新订单中路段顺序号
                map.put("segmentSqe", map.get("tareSegmentSqe")); //皮重路段顺序
                utilsService.updateOrderLineSequence(map);
                String orderNumber = (String) map.get("orderNumber");
                //如果是采购订单 计皮后自动完成签收
                //查询是此订单是否已签收过
                Integer check = utilsMapper.checkoutReceipt(orderNumber);
                if(check == null){
                    autoReceipt(orderNumber);
                }
            }
        }else{
            addWeightResult(tmstruckWeightResult, map); //添加计量实绩数据
            // 更新订单中路段顺序号,如果毛重时间为空则为计皮：也就是销售第一次计皮，反之有毛重时间则为计毛
            if(resultCrossWeightTime == null || resultCrossWeightTime.length() == 0){
                map.put("segmentSqe", map.get("tareSegmentSqe")); //皮重路段顺序
            }else{
                map.put("segmentSqe", map.get("grossSegmentSqe")); //毛重路段顺序
            }
            utilsService.updateOrderLineSequence(map);
        }
        return tmstruckWeightResult;
    }

    /**
     * 添加计量实绩添加数据
     * @param tmstruckWeightResult
     * @param map
     * @return
     */
    public void addWeightResult(TmstruckWeightResult tmstruckWeightResult, Map<String, Object> map) throws Exception{
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //设置皮重汽车衡
        String resultTareCalculateNumber = (String) map.get("resultTareCalculateNumber");
        if(resultTareCalculateNumber != null){
            if(!"".equals(resultTareCalculateNumber)){
                Integer tareId = tmstruckWeightResultMapper.selectTruckCalculateId(resultTareCalculateNumber);
                if(tareId == null){
                    throw new Exception("没有此皮重汽车衡：" + map.get("resultTareCalculateNumber"));
                }
                tmstruckWeightResult.setResultTarePlaceId(new BigDecimal(tareId));
            }
        }

        //设置毛重汽车衡
        String resultCrossCalculateNumber = (String) map.get("resultCrossCalculateNumber");
        if(resultCrossCalculateNumber != null){
            if(!"".equals(resultCrossCalculateNumber)){
                Integer crossId = tmstruckWeightResultMapper.selectTruckCalculateId(resultCrossCalculateNumber);
                if(crossId == null){
                    throw new Exception("没有此毛重汽车衡：" + map.get("resultCrossCalculateNumber"));
                }
                tmstruckWeightResult.setResultGrossPlaceId(new BigDecimal(crossId));
            }
        }
        //毛重
        if(map.get("resultCrossWeight") != null){
            tmstruckWeightResult.setResultGrossWeight(DataChange.dataToBigDecimal(map.get("resultCrossWeight")));
        }
        //皮重
        if(map.get("resultTareWeight") != null){
            tmstruckWeightResult.setResultTareWeight(DataChange.dataToBigDecimal(map.get("resultTareWeight")));
        }
        //净重
        if(map.get("resultNetWeight") != null){
            tmstruckWeightResult.setResultNetWeight(DataChange.dataToBigDecimal(map.get("resultNetWeight")));
        }
        //设置皮重时间
        if(map.get("resultTareWeightTime") != null){
            String resultTareWeightTime = (String) map.get("resultTareWeightTime");
            if(!"".equals(resultTareWeightTime)){
                tmstruckWeightResult.setResultTareWeightTime(sdf.parse(resultTareWeightTime));
            }
        }
        //设置毛重时间
        if(map.get("resultCrossWeightTime") != null){
            String resultGrossWeightTime = (String) map.get("resultCrossWeightTime");
            if(!"".equals(resultGrossWeightTime)){
                tmstruckWeightResult.setResultGrossWeightTime(sdf.parse(resultGrossWeightTime));
            }
        }
        tmstruckWeightResult.setUpdateTime(new Date());
        tmstruckWeightResult.setUpdateUsername("admin");
    }

    /**
     * 自动签收
     * @return
     */
    public void autoReceipt(String orderNumber){
        TmstruckReceiptResult tmstruckReceiptResult = new TmstruckReceiptResult();
        //通过运输订单号查询总实绩ID
        BigDecimal resultTotalId = utilsMapper.getTotalIdByOrderNumber(orderNumber);
        tmstruckReceiptResult.setResultTotalId(resultTotalId);
        tmstruckReceiptResult.setStatus(new BigDecimal(1));
        tmstruckReceiptResult.setInsertUsername("admin");
        tmstruckReceiptResult.setInsertTime(new Date());
        tmstruckReceiptResultMapper.updateByTotalResultId(tmstruckReceiptResult);
        System.out.println(orderNumber + "收货成功");
    }

    /**
     * 添加火车计量实绩
     * @param map
     * @return
     */
    public String addTrainWeightResult(Map<String, Object> map){
        //通过采购订单号和车皮号 查询火运总实绩ID和物资ID
        Map<String, Object> totalIdAndMateMap = tmstrainWeightResultMapper.getResultIdByPurNoAndWagonNo(map);
        if(totalIdAndMateMap == null){
            return "采购订单号"+ map.get("purchaseOrderNo")+"或车皮信息"+ map.get("orderNumber")+"错误";
        }
        if(totalIdAndMateMap.get("resultTotalId") == null){
            return "采购订单号"+ map.get("purchaseOrderNo")+"或车皮信息"+ map.get("orderNumber")+"错误";
        }
        map.putAll(totalIdAndMateMap);
        TmstrainWeightResult tmstrainWeightResult = null;
        try {
            tmstrainWeightResult = generateTrainWeightResult(map);
        } catch (Exception e) {
            return e.getMessage(); //捕获异常信息
        }
        tmstrainWeightResultMapper.insertSelective(tmstrainWeightResult);
        return map.get("orderNumber") + "成功";
    }

    /**
     * 生成火运计量实体
     * @param map
     * @return
     */
    public TmstrainWeightResult generateTrainWeightResult(Map<String, Object> map) throws Exception {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        TmstrainWeightResult tmstrainWeightResult = new TmstrainWeightResult();
        tmstrainWeightResult.setResultId(tmstrainWeightResultMapper.selectMaxId());
        //磅单号
        tmstrainWeightResult.setResultPoundNo((String) map.get("resultPoundNo"));
        //添加火运总实绩ID
        tmstrainWeightResult.setResultTotalId(DataChange.dataToBigDecimal(map.get("resultTotalId")));
        //设置物资ID
        tmstrainWeightResult.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
        //如果没有计毛时间 则是第一次计量
        String resultCrossWeightTime = (String) map.get("resultCrossWeightTime");
        if(resultCrossWeightTime == null || resultCrossWeightTime.length() == 0){
            //设置毛重时间
            String firstTime = (String) map.get("resultTareWeightTime");
            tmstrainWeightResult.setResultGrossWeightTime(sdf.parse(firstTime));
            //添加毛重汽车衡
            Integer tareId = tmstruckWeightResultMapper.selectTruckCalculateId((String) map.get("resultTareCalculateNumber"));
            if(tareId == null){
                throw new Exception("没有此计量衡：" + map.get("resultTareCalculateNumber"));
            }
            tmstrainWeightResult.setResultGrossPlaceId(new BigDecimal(tareId));
            //设置毛重
            BigDecimal resultTareWeight = DataChange.dataToBigDecimal(map.get("resultTareWeight"));
            tmstrainWeightResult.setResultGrossWeight(resultTareWeight);
            tmstrainWeightResult.setInsertTime(new Date());
            tmstrainWeightResult.setInsertUsername("admin");
        }else {
            //设置皮重汽车衡
            Integer tareId = tmstruckWeightResultMapper.selectTruckCalculateId((String) map.get("resultTareCalculateNumber"));
            if(tareId == null){
                throw new Exception("没有此计量衡：" + map.get("resultTareCalculateNumber"));
            }
            tmstrainWeightResult.setResultTarePlaceId(new BigDecimal(tareId));
            //设置毛重汽车衡
            Integer crossId = tmstruckWeightResultMapper.selectTruckCalculateId((String) map.get("resultCrossCalculateNumber"));
            if(crossId == null){
                throw new Exception("没有此计量衡：" + map.get("resultCrossCalculateNumber"));
            }
            tmstrainWeightResult.setResultGrossPlaceId(new BigDecimal(crossId));
            //毛重
            BigDecimal resultCrossWeight = DataChange.dataToBigDecimal(map.get("resultCrossWeight"));
            tmstrainWeightResult.setResultGrossWeight(resultCrossWeight);
            //皮重
            BigDecimal resultTareWeight = DataChange.dataToBigDecimal(map.get("resultTareWeight"));
            tmstrainWeightResult.setResultTareWeight(resultTareWeight);
            //净重
            tmstrainWeightResult.setResultNetWeight(DataChange.dataToBigDecimal(map.get("resultNetWeight")));
            //设置皮重时间
            String resultTareWeightTime = (String) map.get("resultTareWeightTime");
            tmstrainWeightResult.setResultTareWeightTime(sdf.parse(resultTareWeightTime));
            //设置毛重时间
            String resultGrossWeightTime = (String) map.get("resultCrossWeightTime");
            tmstrainWeightResult.setResultGrossWeightTime(sdf.parse(resultGrossWeightTime));
            tmstrainWeightResult.setUpdateTime(new Date());
            tmstrainWeightResult.setUpdateUsername("admin");
        }
        return tmstrainWeightResult;
    }


}