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

package com.steerinfo.dil.service.impl;

import com.alibaba.druid.support.json.JSONUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.steerinfo.dil.util.newFileTool;
import com.google.gson.JsonObject;
import com.steerinfo.dil.feign.AmsFeign;
import com.steerinfo.dil.mapper.*;
import com.steerinfo.dil.model.*;
import com.steerinfo.dil.service.IAmsSaleOrderService;
import com.steerinfo.dil.util.DataChange;
import com.steerinfo.dil.util.MyException;
import com.sun.org.apache.bcel.internal.generic.NEW;
import io.swagger.models.auth.In;
import org.apache.ibatis.executor.loader.ResultLoader;
import org.apache.shiro.crypto.hash.Hash;
import org.assertj.core.internal.bytebuddy.implementation.FieldAccessor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import springfox.documentation.spring.web.json.Json;

import javax.xml.crypto.Data;
import java.io.IOException;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

import static java.util.stream.Collectors.toList;

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


    @Autowired
    private AmsSaleOrderMapper amsSaleOrderMapper;
    @Autowired
    AmsSaleMaterialMapper amsSaleMaterialMapper;
    @Autowired
    RmsConsigneeMapper rmsConsigneeMapper;
    @Autowired
    AmsSaleTrucknoMaterialMapper amsSaleTrucknoMaterialMapper;
    @Autowired
    AmsSaleOrderCarrierMapper amsSaleOrderCarrierMapper;
    @Autowired
    OmstruckOrderMapper omstruckOrderMapper;
    @Autowired
    RmsMaterialMapper rmsMaterialMapper;
    @Autowired
    private TmstrainPleaseApproveResultMapper tmstrainPleaseApproveResultMapper;
    @Autowired
    RmstrainArrivalSendMapper rmstrainArrivalSendMapper;
    @Autowired
    OmstrainOrderMapper omstrainOrderMapper;
    @Autowired
    AmsFeign amsFeign;

    Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * 查询销售订单
     * @param saleOrderId
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Map<String, Object> getSaleOrder(BigDecimal saleOrderId) {
        List<Map<String,Object>> entries = amsSaleOrderMapper.getMaterialMessages(saleOrderId);
        Map<String,Object> head = amsSaleOrderMapper.getSaleOrderMessage(saleOrderId);
        // 单价
        BigDecimal taxPrice = (BigDecimal) head.get("unitPrice");
        // 税率
        String taxRate = (String) head.get("tax");
        // 收款客户
        String customer = (String) head.get("customer");
        for (Map<String, Object> entry : entries) {
            // 物流销售订单分录主键
            BigDecimal stEntryId = (BigDecimal) entry.get("stEntryId");
            // 是否磅重（0：磅重，1：理重）
            BigDecimal isPoundSale = (BigDecimal) entry.get("isPoundSale");
            // 长度
            BigDecimal forChangdu = (BigDecimal) entry.get("forChangdu");
            // 物资数量
            BigDecimal assistQty = (BigDecimal) entry.get("materialNumber");
            entry.put("assistQty",assistQty.toString());
            entry.remove("materialNumber");
            entry.put("taxPrice",taxPrice.toString());
            entry.put("taxRate",taxRate);
            entry.put("customer",customer);
            entry.replace("stEntryId",stEntryId.toString());
            entry.put("isTheory",isPoundSale.toString());
            entry.replace("forChangdu", forChangdu == null ? "" : forChangdu.toString());
        }
        Map<String,Object> input = new HashMap<>();
        head.remove("unitPrice");
        head.remove("tax");
        head.remove("customer");
        head.put("isFillCarNum","1");
        head.put("isCp","0");
        input.put("head",head);
        input.put("entries",entries);
        return input;
    }

    /**
     * 修改销售订单
     * @param mapVal
     * @return
     */
    @Transactional
    @Override
    public int operationSaleOrder(Map<String, Object> mapVal) {
        System.out.println("-----------------------------" + new Date() + "销售订单对接接口" + "-----------------------------");
        JSONObject jsonObject = new JSONObject(mapVal);
        logger.info(jsonObject.toString());
        System.out.println("-----------------------------" + new Date() + "销售订单对接接口" + "-----------------------------");
        //try {
        //    newFileTool.newFile(jsonObject.toString(),"销售订单");
        //} catch (IOException e) {
        //    e.printStackTrace();
        //}
        int result = 0;
        // 审批状态
        String orderStatus = (String) mapVal.get("orderStatus");
        // 得到销售订单号
        String saleNumber = (String) mapVal.get("saleNumber");
        Map<String,Object> map = new HashMap<>();
        map.put("saleNumber",saleNumber);
        // 判断是删除还是非删除
        String closeStatus = (String) mapVal.get("closeStatus");
        List<AmsSaleOrder> amsSaleOrders = amsSaleOrderMapper.selectByParameters(map);
        // 关闭分录
        Object closeEntryId = mapVal.get("closeEntryId");
        // 反关闭分录
        Object unCloseEntryId = mapVal.get("unCloseEntryId");
        // 关闭原因
        Object reason = mapVal.get("reason");
        // 是否整单
        Object wholeOrder = mapVal.get("wholeOrder");
        // 关闭副产品整个订单
        if (closeStatus.equals("-1") && "1".equals(wholeOrder) && amsSaleOrders.size() != 0 && amsSaleOrders.get(0) != null) {
            AmsSaleOrder amsSaleOrder = amsSaleOrders.get(0);
            amsSaleOrder.setDeleted(new BigDecimal(2));
            if (reason != null) {
                amsSaleOrder.setInsertUpdateRemark(reason.toString());
            }
            result += amsSaleMaterialMapper.closeAllSaleMaterial(amsSaleOrder.getSaleOrderId());
            result += amsSaleOrderMapper.updateByPrimaryKeySelective(amsSaleOrder);
            List<Map<String, Object>> warehouseList = amsSaleOrderMapper.getWareHouse(amsSaleOrder.getSaleOrderId());
            if (warehouseList != null && warehouseList.size() != 0 && warehouseList.get(0) != null) {
                Object warehouse = warehouseList.get(0).get("warehouse");
                if (warehouse != null && "副产品库".equals(warehouse)) {
                    result += amsSaleOrderMapper.closeOrderNotIn(amsSaleOrder.getSaleOrderId());
                }
            }
            //如果是钢材订单
            if(amsSaleOrder.getSaleType().intValue() == 1){
                //获取该钢材销售订单下所有的运输订单ID，状态
                result += amsSaleOrderMapper.closeOrderNotIn(amsSaleOrder.getSaleOrderId());

            }
        }
        // 关闭单个分录订单
        if (closeStatus.equals("-1") && wholeOrder.equals("0")) {
            if (closeEntryId != null) {
                Map<String, Object> easMap = new HashMap<>();
                easMap.put("easPrimaryId", closeEntryId);
                List<AmsSaleMaterial> amsSaleMaterials = amsSaleMaterialMapper.selectByParameters(easMap);
                if (amsSaleMaterials != null && amsSaleMaterials.size() != 0 && amsSaleMaterials.get(0) != null) {
                    AmsSaleMaterial amsSaleMaterial = amsSaleMaterials.get(0);
                    //amsSaleMaterial.setDeleted(new BigDecimal(0));
                    //result += amsSaleMaterialMapper.updateByPrimaryKeySelective(amsSaleMaterial);
                    BigDecimal saleMaterialId = amsSaleMaterial.getSaleMaterialId();
                    //调用自己关闭分录服务接口--运单id,车序号id,理由,物流分录id
                    Map<String, Object> closeEntryMap = omstruckOrderMapper.selecrCloseEntryMes(saleMaterialId);
                    closeEntryMap.put("reason","金蝶关闭分录,物流同步关闭");
                    closeEntryMap.put("closeEntryFlag",1);
                    //判断该分录有没有运单
                    try {
                        amsFeign.closeSteelMaterialId(closeEntryMap);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        // 反关闭整单
        if (closeStatus.equals("-2") && "1".equals(wholeOrder)) {
            AmsSaleOrder amsSaleOrder = amsSaleOrders.get(0);
            amsSaleOrder.setDeleted(new BigDecimal(0));
            BigDecimal saleOrderId = amsSaleOrder.getSaleOrderId();
            if (reason != null) {
                amsSaleOrder.setInsertUpdateRemark(reason.toString());
            }
            // 反关闭销售订单下的所有分录
            result += amsSaleMaterialMapper.openAllSaleMaterial(saleOrderId);
            //反关闭这个销售订单下面被关闭的运单
            try {
                List<Map<String,Object>> orderMapList = amsSaleOrderMapper.selectOrderList(saleOrderId);
                for (Map<String,Object> orderMap :orderMapList) {
                    OmstruckOrder omstruckOrder = new OmstruckOrder();
                    if(orderMap.get("factoryResultId") != null) {
                        omstruckOrder.setOrderId(DataChange.dataToBigDecimal(orderMap.get("orderId")));
                        omstruckOrder.setInsertUpdateRemark("金蝶反关闭整单,物流同步反关闭销售订单下的整单");
                        omstruckOrder.setOrderStatus(new BigDecimal(5));
                        omstruckOrder.setUpdateTime(new Date());
                        omstruckOrder.setUpdateUsername("金蝶");
                        result += omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
                    }else{
                        omstruckOrder.setOrderId(DataChange.dataToBigDecimal(orderMap.get("orderId")));
                        omstruckOrder.setInsertUpdateRemark("金蝶反关闭整单,物流同步反关闭销售订单下的整单");
                        omstruckOrder.setOrderStatus(new BigDecimal(4));
                        omstruckOrder.setUpdateUsername("金蝶");
                        result += omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
                    }

                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            result += amsSaleOrderMapper.updateByPrimaryKeySelective(amsSaleOrder);
        }
        // 反关闭单个分录订单
        if (closeStatus.equals("-2") && wholeOrder.equals("0")) {
            if (unCloseEntryId != null) {
                Map<String, Object> easMap = new HashMap<>();
                easMap.put("easPrimaryId", unCloseEntryId);
                List<AmsSaleMaterial> amsSaleMaterials = amsSaleMaterialMapper.selectByParameters(easMap);
                if (amsSaleMaterials != null && amsSaleMaterials.size() != 0 && amsSaleMaterials.get(0) != null) {
                    AmsSaleMaterial amsSaleMaterial = amsSaleMaterials.get(0);
                    //result += amsSaleMaterialMapper.unCloseSaleMaterial(amsSaleMaterial.getSaleMaterialId());
                    BigDecimal saleMaterialId = amsSaleMaterial.getSaleMaterialId();
                    //判断该分录有没有运单
                    try {
                        amsFeign.adverseCloseSaleMaterialByEas(saleMaterialId);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        if (closeStatus.equals("0")) {
            AmsSaleOrder amsSaleOrder = amsSaleOrders.get(0);
            amsSaleOrder.setDeleted(new BigDecimal(1));
            result += amsSaleOrderMapper.updateByPrimaryKeySelective(amsSaleOrder);
            //反审的订单需将下面的运输订单关闭
            try {
                amsSaleOrderMapper.reverseApprovalOrder(amsSaleOrder.getSaleOrderId());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (orderStatus.equals("4") && closeStatus.equals("1")){
            AmsSaleOrder amsSaleOrder = amsSaleOrders.get(0);
            amsSaleOrder.setSaleOrderStatus(new BigDecimal(4));
            amsSaleOrder.setDeleted(new BigDecimal(0));
            result += amsSaleOrderMapper.updateByPrimaryKeySelective(amsSaleOrder);
            BigDecimal saleOrderId = amsSaleOrder.getSaleOrderId();
            // 如果是财务审批后，将不可作业的运输订单改为已接收状态
            //反关闭这个销售订单下面被关闭的运单
            try {
                List<Map<String,Object>> orderMapList = amsSaleOrderMapper.selectOrderList(saleOrderId);
                for (Map<String,Object> orderMap :orderMapList) {
                    OmstruckOrder omstruckOrder = new OmstruckOrder();
                    if(orderMap.get("factoryResultId") != null) {
                        omstruckOrder.setOrderId(DataChange.dataToBigDecimal(orderMap.get("orderId")));
                        omstruckOrder.setInsertUpdateRemark("金蝶反关闭整单,物流同步反关闭销售订单下的整单");
                        omstruckOrder.setOrderStatus(new BigDecimal(5));
                        omstruckOrder.setUpdateTime(new Date());
                        omstruckOrder.setUpdateUsername("金蝶");
                        result += omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
                    }else{
                        omstruckOrder.setOrderId(DataChange.dataToBigDecimal(orderMap.get("orderId")));
                        omstruckOrder.setInsertUpdateRemark("金蝶反关闭整单,物流同步反关闭销售订单下的整单");
                        omstruckOrder.setOrderStatus(new BigDecimal(4));
                        omstruckOrder.setUpdateUsername("金蝶");
                        result += omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
                    }

                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (orderStatus.equals("2") && closeStatus.equals("1")){
            // 得到账户余额
            String saleAccountBalance = (String) mapVal.get("saleAccountBalance");
            // 得到当前订单金额
            String saleCurrentOrderAmount = (String) mapVal.get("saleCurrentOrderAmount");
            // 得到历史订单金额
            String saleHistoricalOrderAmount = (String) mapVal.get("saleHistoricalOrderAmount");
            // 得到订单备注
            String saleRemark = (String) mapVal.get("saleRemark");
            // 得到是否自提
            String isSelfMention = (String) mapVal.get("isSelfMention");
            // 得到收货单位
            String receiveUnit = (String) mapVal.get("receiveUnit");
            // 得到收货单位名称
            String receiveUnitName = (String) mapVal.get("receiveUnitName");
            // 得到订单日期
            String saleOrderBizDateStr = (String) mapVal.get("saleOrderBizDate");
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            BigDecimal receiveId = amsSaleOrderMapper.getReceiveId(receiveUnit);
            // 如果不存则自己增收获单位
            if (receiveId == null) {
                RmsConsignee rmsConsignee = new RmsConsignee();
                BigDecimal consigneeId = rmsConsigneeMapper.getConsigneeId();
                rmsConsignee.setConsigneeId(consigneeId);
                rmsConsignee.setConsigneeCode(receiveUnit);
                rmsConsignee.setConsigneeCompanyName(receiveUnitName);
                rmsConsignee.setDeleted(new BigDecimal(0));
                rmsConsignee.setInsertTime(new Date());
                rmsConsignee.setInsertUsername("销售订单");
                rmsConsignee.setInsertUpdateRemark("通过销售订单自增");
                rmsConsigneeMapper.insertSelective(rmsConsignee);
            }
            // 得到发货单位
            String shipperUnit = (String) mapVal.get("shipperUnit");
            BigDecimal shipperId = amsSaleOrderMapper.getShipperId(shipperUnit);
            // 得到收款客户
            String saleOrderReceiveCustomer = (String) mapVal.get("receiveCustomer");
            // 得到物资信息
            List<Map<String, Object>> mapList = (List<Map<String, Object>>) mapVal.get("mapList");
            // 如果不存在则自己新增(使用金蝶销售订单号)
            if (amsSaleOrders.size() == 0) {
                AmsSaleOrder amsSaleOrder = new AmsSaleOrder();
                BigDecimal saleOrderId = amsSaleOrderMapper.getSaleOrderId();
                amsSaleOrder.setSaleOrderId(saleOrderId);
                amsSaleOrder.setSaleNumber(saleNumber);
                amsSaleOrder.setDeleted(new BigDecimal(0));
                amsSaleOrder.setUpdateTime(new Date());
                amsSaleOrder.setInsertUsername("admin");
                amsSaleOrder.setInsertUpdateRemark("金蝶采集销售订单");
                amsSaleOrder.setUpdateUsername("admin");
                amsSaleOrder.setReceiveId(receiveId);
                amsSaleOrder.setShipperId(shipperId);
                // 订单日期
                try {
                    Date saleOrderBizDate = sdf.parse(saleOrderBizDateStr);
                    amsSaleOrder.setInsertTime(saleOrderBizDate);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                if (shipperUnit.equals("四川达兴能源有限责任公司") && receiveUnitName.equals("四川省达州钢铁集团有限责任公司")) {
                    amsSaleOrder.setCloseStatus(new BigDecimal(0));
                }
                if (isSelfMention != null) {
                    if (isSelfMention.equals("CARRY")) {
                        amsSaleOrder.setSaleOrderIsselfMention("是");
                    } else {
                        amsSaleOrder.setSaleOrderIsselfMention("否");
                    }
                }
                amsSaleOrder.setSaleOrderTax("13%");
                amsSaleOrder.setSaleUnitPrice(new BigDecimal(4000));
                amsSaleOrder.setSaleRemark(saleRemark);
                amsSaleOrder.setSaleOrderReceiveCustomer(saleOrderReceiveCustomer);
                amsSaleOrder.setSaleAccountBalance(new BigDecimal(saleAccountBalance));
                amsSaleOrder.setSaleCurrentOrderAmount(new BigDecimal(saleCurrentOrderAmount));
                if (saleHistoricalOrderAmount != null && saleHistoricalOrderAmount.length() != 0) {
                    amsSaleOrder.setSaleHistoricalOrderAmount(new BigDecimal(saleHistoricalOrderAmount));
                }
                amsSaleOrder.setSaleOrderStatus(new BigDecimal(2));
                // 遍历物资分录，新增销售订单与物资中间表
                for (Map<String, Object> materialMap : mapList) {
                    AmsSaleMaterial amsSaleMaterial = new AmsSaleMaterial();
                    BigDecimal saleMaterialId = amsSaleMaterialMapper.getSaleMaterialId();
                    amsSaleMaterial.setSaleMaterialId(saleMaterialId);
                    amsSaleMaterial.setSaleOrderId(saleOrderId);
                    // 仓库编码
                    Object warehouseNum = materialMap.get("warehouseNum");
                    // 仓库名称
                    Object warehouseName = materialMap.get("warehouseName");
                    // 物资理重
                    Object meterWeight = materialMap.get("meterWeight");
                    // 得到物资编码
                    String materialCode = (String) materialMap.get("materialCode");
                    if (warehouseName != null) {
                        amsSaleMaterial.setSaleWarehouse(warehouseName.toString());
                        //得到物资名称
                        String materialName = amsSaleOrderCarrierMapper.getMaterialName(materialCode);
                        // 如果是副产品仓库，则给自提订单自动匹配承运商
                        if (warehouseName.equals("副产品库") && "是".equals(amsSaleOrder.getSaleOrderIsselfMention()) || "钒渣".equals(materialName) && "是".equals(amsSaleOrder.getSaleOrderIsselfMention()) ) {
                            AmsSaleOrderCarrier amsSaleOrderCarrier = amsSaleOrderCarrierMapper.getAmsSaleOrderCarrier(saleOrderId);
                            BigDecimal carrierId = amsSaleOrderCarrierMapper.findCarrierByConsignee(receiveUnitName);
                            if (amsSaleOrderCarrier == null) {
                                amsSaleOrderCarrier = new AmsSaleOrderCarrier();
                                amsSaleOrderCarrier.setSaleOrderCarrierId(amsSaleOrderCarrierMapper.selectMaxId());
                                amsSaleOrderCarrier.setCarrierId(amsSaleOrderCarrierMapper.selectMaxId());
                                amsSaleOrderCarrier.setSaleOrderId(saleOrderId);
                                amsSaleOrderCarrier.setCarrierId(carrierId);
                                amsSaleOrderCarrier.setDeleted(new BigDecimal(0));
                                amsSaleOrderCarrier.setInsertTime(new Date());
                                amsSaleOrderCarrier.setInsertUsername("自动匹配");
                                amsSaleOrderCarrier.setInsertUpdateRemark("自提订单自动匹配");
                                result += amsSaleOrderCarrierMapper.insertSelective(amsSaleOrderCarrier);
                            }
                            else {
                                amsSaleOrderCarrier.setCarrierId(carrierId);
                                result += amsSaleOrderCarrierMapper.updateByPrimaryKeySelective(amsSaleOrderCarrier);
                            }
                        }
                    }
                    BigDecimal materialId = amsSaleMaterialMapper.getMaterialId(materialCode);
                    Integer materialCount = amsSaleMaterialMapper.getMaterialCount(materialId);
                    RmsMaterial rmsMaterial = new RmsMaterial();
                    rmsMaterial.setMaterialId(materialId);
                    if (materialCount == null) {
                        materialCount = new Integer(0);
                    }
                    rmsMaterial.setMaterialCount(new BigDecimal(materialCount + 1));
                    rmsMaterialMapper.updateByPrimaryKeySelective(rmsMaterial);
                    // 得到金蝶分录主键
                    String easPrimaryId = (String) materialMap.get("easPrimaryId");
                    // 得到物资重量
                    String materialWeight = (String) materialMap.get("materialNumber");
                    // 得到物资件数
                    String materialNumber = (String) materialMap.get("assistQty");
                    // 得到计量单位
                    String materialUnit = (String) materialMap.get("materialUnit");
                    amsSaleMaterial.setEasPrimaryId(easPrimaryId);
                    amsSaleMaterial.setMaterialId(materialId);
                    amsSaleMaterial.setInsertTime(new Date());
                    amsSaleMaterial.setInsertUsername("金蝶");
                    amsSaleMaterial.setMeterWeight(DataChange.dataToBigDecimal(meterWeight));
                    amsSaleMaterial.setInsertUpdateRemark("采集金蝶销售订单");
                    if (materialWeight != null && !"".equals(materialWeight)) {
                        amsSaleMaterial.setMaterialWeight(new BigDecimal(materialWeight));
                    }
                    if (materialNumber != null && !"".equals(materialNumber)) {
                        amsSaleMaterial.setMaterialNumber(new BigDecimal(materialNumber));
                    }
                    result += amsSaleMaterialMapper.insertSelective(amsSaleMaterial);
                }
                result += amsSaleOrderMapper.insertSelective(amsSaleOrder);
            } else {
                AmsSaleOrder amsSaleOrder = amsSaleOrders.get(0);
                if(amsSaleOrder != null && amsSaleOrder.getSaleType() != null && amsSaleOrder.getSaleType().intValue() == 1) {
                    try{
                        new Thread( new Runnable() {
                            public void run(){
                                //查询销售订单车序号表是否存在上一个运输订单号，如果存在，调用钢材继续装派单接口
                                List<Map<String,Object>> saleOrders = amsSaleOrderMapper.selectPreviousOrderNumber(amsSaleOrder.getSaleOrderId());
                                for (Map<String,Object> temp:saleOrders){
                                    temp.putAll(amsSaleOrderMapper.selectOrderDetails(temp));
                                }
                                if(saleOrders != null && saleOrders.size() > 0){
                                    amsFeign.continueSteelOrder(saleOrders);
                                }
                            }
                        }).start();
                    }catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                amsSaleOrder.setSaleNumber(saleNumber);
                amsSaleOrder.setSaleAccountBalance(new BigDecimal(saleAccountBalance));
                amsSaleOrder.setSaleCurrentOrderAmount(new BigDecimal(saleCurrentOrderAmount));
                amsSaleOrder.setSaleRemark(saleRemark);
                amsSaleOrder.setDeleted(new BigDecimal(0));
                amsSaleOrder.setUpdateTime(new Date());
                amsSaleOrder.setShipperId(shipperId);
                amsSaleOrder.setReceiveId(receiveId);
                if (isSelfMention != null) {
                    if (isSelfMention.equals("CARRY")) {
                        amsSaleOrder.setSaleOrderIsselfMention("是");
                    } else {
                        amsSaleOrder.setSaleOrderIsselfMention("否");
                    }
                }
                if (saleHistoricalOrderAmount != null && saleHistoricalOrderAmount.length() != 0) {
                    amsSaleOrder.setSaleHistoricalOrderAmount(new BigDecimal(saleHistoricalOrderAmount));
                }
                amsSaleOrder.setSaleOrderStatus(new BigDecimal(orderStatus));
                //获取销售订单下的分录id--获取物流分录id
                //判断单据来源是金蝶还是物流
                List<String> wuliuStIds  = amsSaleMaterialMapper.getMaterialEasList(saleNumber);
                //查询该销售订单下的所有物资分录
                List<String> EasIds = new ArrayList<>();
                for (Map<String, Object> materialMap : mapList) {
                    // 得到中间表主键id
                    String saleMaterialId = (String) materialMap.get("saleMaterialId");
                    // 得到金蝶分录id
                    String easPrimaryId = (String) materialMap.get("easPrimaryId");
                    Map<String,Object> resultMap = new HashMap<>();
                    resultMap.put("easPrimaryId",easPrimaryId);
                    AmsSaleMaterial amsSaleMaterial;
                    // 得到物资重量
                    String materialWeight = (String) materialMap.get("materialNumber");
                    // 得到物资件数
                    String materialNumber = (String) materialMap.get("assistQty");
                    // 如果有物流系统销售订单物资表主键：认定是走物流新增的销售订单（通过物流系统主键进行查询）
                    if (saleMaterialId != null && (!saleMaterialId.equals("null")) && !saleMaterialId.equals("")) {
                        amsSaleMaterial = amsSaleMaterialMapper.selectByPrimaryKey(new BigDecimal(saleMaterialId));
                        Object meterWeight = materialMap.get("meterWeight");
                        Object forChangdu = materialMap.get("forChangdu");
                        EasIds.add(saleMaterialId);
                        if(forChangdu != null && !"".equals(forChangdu.toString())){
                            amsSaleMaterial.setSteelMeter(DataChange.dataToBigDecimal(forChangdu));
                        }
                        if (meterWeight != null && !"".equals(meterWeight.toString())) {
                            amsSaleMaterial.setMeterWeight(DataChange.dataToBigDecimal(meterWeight));
                        }
                        else {
                            Double weightDouble = new Double(materialNumber);
                            BigDecimal liWeight = new BigDecimal( weightDouble/amsSaleMaterial.getMaterialNumber().doubleValue() * 1000);
                            amsSaleMaterial.setMeterWeight(liWeight);
                        }
                        // 同步修改车序号物资表
                        resultMap.put("materialId",saleMaterialId);
                        List<AmsSaleTrucknoMaterial> amsSaleTrucknoMaterials = amsSaleTrucknoMaterialMapper.selectByParameters(resultMap);
                        AmsSaleTrucknoMaterial amsSaleTrucknoMaterial = amsSaleTrucknoMaterials.get(0);
                        amsSaleTrucknoMaterial.setSaleOrderMaterialNumber(new BigDecimal(materialNumber));
                        amsSaleTrucknoMaterial.setInsertUpdateRemark("在金蝶做修改");
                        amsSaleTrucknoMaterialMapper.updateByPrimaryKeySelective(amsSaleTrucknoMaterial);
                    }
                    // 否则认定是走金蝶新增的销售订单（通过金蝶分录id进行查询）
                    else {
                        List<AmsSaleMaterial> amsSaleMaterials = amsSaleMaterialMapper.selectByParameters(resultMap);
                        amsSaleMaterial = amsSaleMaterials.get(0);
                        amsSaleMaterial.setInsertUsername("金蝶");
                        amsSaleMaterial.setInsertUpdateRemark("采集金蝶销售订单");
                    }
                    // 得到物资编码
                    String materialCode = (String) materialMap.get("materialCode");
                    // 得到计量单位
                    String materialUnit = (String) materialMap.get("materialUnit");
                    if (materialWeight != null && !"".equals(materialWeight)) {
                        amsSaleMaterial.setMaterialWeight(new BigDecimal(materialWeight));
                    }
                    if (materialNumber != null && !
                            "".equals(materialNumber)) {
                        amsSaleMaterial.setMaterialNumber(new BigDecimal(materialNumber));
                    }
                    BigDecimal materialId = amsSaleMaterialMapper.getMaterialId(materialCode);
                    amsSaleMaterial.setEasPrimaryId(easPrimaryId);
                    amsSaleMaterial.setSaleOrderId(amsSaleOrder.getSaleOrderId());
                    amsSaleMaterial.setMaterialId(materialId);
                    amsSaleMaterial.setInsertTime(new Date());
                    result += amsSaleMaterialMapper.updateByPrimaryKeySelective(amsSaleMaterial);
                }
                if(amsSaleOrder.getSaleType() != null && amsSaleOrder.getSaleType().intValue() == 1 && EasIds.size() < wuliuStIds.size()){
                    //只有当金蝶传过来的分录小于物流这边的金蝶分录时，才进行此处判断
                    //遍历物流存在的数组,如果wuliu有的金蝶没有，那就将物流没有的给隐藏调
                    //将物流这边的金蝶分录集合变成set
                    Set<String> set = new HashSet<String>(wuliuStIds);
                    //遍历金蝶分录数组
                    for(String easId:EasIds){
                            // 若是集合里有相同的就删掉，若是没有就将值添加到集合
                            if (set.contains(easId))
                            {
                                set.remove(easId);
                            } else
                            {
                                set.add(easId);
                            }
                    }
                    List<String> chaEasIds = new ArrayList<>(set);
                    //遍历数组将这里面的分录删掉
                    for (String easId:chaEasIds){
                        //物理删除该分录
                        result += amsSaleMaterialMapper.deleteSaleMaterialByEasId(easId);
                        result += amsSaleMaterialMapper.deleteAstmBystId(easId);

                    }
                    System.out.println(chaEasIds);
                }
                result += amsSaleOrderMapper.updateByPrimaryKeySelective(amsSaleOrder);
            }
        }
        return result;
    }

    @Override
    @Transactional
    public int testContinue(Map<String, Object> map){
        try{
            new Thread( new Runnable() {
                public void run(){
                    //查询销售订单车序号表是否存在上一个运输订单号，如果存在，调用钢材继续装派单接口
                    List<Map<String,Object>> saleOrders=amsSaleOrderMapper.selectPreviousOrderNumber(DataChange.dataToBigDecimal(map.get("saleOrderId")));
                    for (Map<String,Object> temp:saleOrders){
                        temp.putAll(amsSaleOrderMapper.selectOrderDetails(temp));
                    }
                    if(saleOrders != null && saleOrders.size() > 0){
                        amsFeign.continueSteelOrder(saleOrders);
                    }
                }
            }).start();
        }catch (Exception e) {
            e.printStackTrace();
        }
        return 1;
    }
    /**
     * 通过运单id得到车牌号
     * @param saleOrderMaterialId
     * @return
     */
    @Override
    public Map<String,Object> findCarNumberByOrderId(BigDecimal saleOrderMaterialId) {
        Map<String, Object> head = omstruckOrderMapper.findCarNumberByOrderId(saleOrderMaterialId);
        //根据车序号表查询销售订单表是否自提
        String isWithdrawal = amsSaleOrderMapper.getWithdrawal(saleOrderMaterialId);
        if("是".equals(isWithdrawal)){
            head.replace("forwarder","自提");
        }
        List<Map<String,Object>> entries = omstruckOrderMapper.findEntriesByOrderId(saleOrderMaterialId);
        //遍历数组 en
        Map<String,Object> input = new HashMap<>();
        input.put("entries",entries);
        input.put("head",head);
        return input;
    }


    @Override
    public Map<String, Object> findCarNumberByOrderList(List<Map<String, Object>> mapList) {
        List<Map<String,Object>> entries = new ArrayList<>();
        //遍历车序号数组,获取车序号ID
        for(Map<String,Object> map : mapList){
            BigDecimal saleOrderMaterialId = new BigDecimal((Integer) map.get("saleOrderMaterialId")) ;
            //根据车序号ID去查询车牌号、承运商以及分录ID
            List<Map<String,Object>> head = omstruckOrderMapper.finCarAndCarrierAndEntries(saleOrderMaterialId);
            entries.addAll(head);
        }
        Map<String,Object> input = new HashMap<>();
        input.put("entries",entries);
        return input;
    }




    //添加内转钢材到异地库
    //审核以后回传
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public int addInwardSteelOrder(Map<String,Object> map) throws Exception {
        System.out.println("-----------------------------" + new Date() + "内转异地库对接接口" + "-----------------------------");
        System.out.println(map);
        System.out.println("-----------------------------" + new Date() + "内转异地库对接接口" + "-----------------------------");
        int result=0;
       //输出json数据。
        String json= JSON.toJSONString(map);
        System.out.println(json);
        //获取订单状态
        String orderStatus = (String) map.get("orderStatus");
        String easPrimaryId=null;
        //设置是否反审核状态
        String closeStatus =(String) map.get("closeStatus");
        //是否整单
        Object wholeOrder = map.get("wholeOrder");
        // 得到单据编号
        String saleNumber = (String) map.get("saleNumber");
        //获取调出组织部门
        String transferOutInventoryOrg =(String) map.get("TransferOutInventorOrg");
        //获取调入组织部门
        String transferInInventoryOrg =(String) map.get("TransferInInventorOrg");
        //获取调出部门
        String transferOutDep =(String) map.get("TransferOutDep");
        //获取调入部门
        String transferInDep =(String) map.get("TransferInDep");
        // 得到订单日期
        String saleOrderBizDateStr = (String) map.get("saleOrderBizDate");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //获取销售摘要
        String saleRemark = (String) map.get("saleRemark");
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //设置是否为车皮
        String whetherTheCar =(String) map.get("whetherTheCar");
        //业务日期
        String businessDate =(String) map.get("businessDate");
        //获取业务类型
        String businessType =(String) map.get("businessType");
        //判断销售订单是否存在
        BigDecimal saleOrderNumber = amsSaleOrderMapper.selectAmsSaleOrderNum(saleNumber);
        if (saleOrderNumber==null&&transferInDep==null){
            return 1;
        }
        //如果销售订单不存在
        if (saleOrderNumber==null){
            AmsSaleOrder amsSaleOrder = new AmsSaleOrder();
            BigDecimal saleOrderId = amsSaleOrderMapper.getSaleOrderId();
            //新增销售订单主键
            amsSaleOrder.setSaleOrderId(saleOrderId);
            //新增单据编码
            amsSaleOrder.setSaleNumber(saleNumber);
            //根据发货单位查找id
            String shipperName="四川省达州钢铁集团有限责任公司";
            BigDecimal shipperId = amsSaleOrderMapper.getShipperId(shipperName);
            amsSaleOrder.setShipperId(DataChange.dataToBigDecimal(shipperId));
            // 订单日期
            try {
                Date saleOrderBizDate = sdf.parse(saleOrderBizDateStr);
                amsSaleOrder.setInsertTime(saleOrderBizDate);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            //业务日期
            try {
                Date BusinessDate = sdf.parse(businessDate);
                amsSaleOrder.setBusinessDate(BusinessDate);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            amsSaleOrder.setWhetherTheCar(whetherTheCar);
            amsSaleOrder.setSaleRemark(saleRemark);
            amsSaleOrder.setSaleOrderStatus(new BigDecimal(4));
            //销售订单类型：内转钢材到异地库
            amsSaleOrder.setSaleType(new BigDecimal(4));
            amsSaleOrder.setTransferInDep(transferInDep);
            amsSaleOrder.setTransferOutDep(transferOutDep);
            amsSaleOrder.setDeleted(new BigDecimal(0));
            amsSaleOrder.setCloseStatus(new BigDecimal(0));
            amsSaleOrder.setTransferInInventoryOrg(transferInInventoryOrg);
            amsSaleOrder.setTransferOutInventoryOrg(transferOutInventoryOrg);
            amsSaleOrder.setBusinessType(businessType);
            amsSaleOrder.setInsertUsername("金蝶");
            amsSaleOrder.setInsertUpdateRemark("采集金蝶库存调拨单");
            result += amsSaleOrderMapper.insertSelective(amsSaleOrder);
            //得到物资信息
            List<Map<String, Object>> mapList = (List<Map<String, Object>>) map.get("mapList");
            for (Map<String,Object> materialMap:mapList){
                AmsSaleMaterial amsSaleMaterial = new AmsSaleMaterial();
                BigDecimal saleMaterialId = amsSaleMaterialMapper.getSaleMaterialId();
                amsSaleMaterial.setSaleMaterialId(saleMaterialId);
                amsSaleMaterial.setSaleOrderId(saleOrderId);
                String materialWeight =(String) materialMap.get("materialNumber");
                // 辅助数量
                Object auxiliaryQuantity = materialMap.get("AuxiliaryQuantity");
                // 物资重量
                Object meterWeight = materialMap.get("meterWeight");
                Object steelMeter = materialMap.get("steelMeter");
                if (steelMeter!=null) {
                    amsSaleMaterial.setSteelMeter(DataChange.dataToBigDecimal(steelMeter));
                }
                if (materialWeight != null && !"".equals(materialWeight)) {
                    amsSaleMaterial.setMaterialWeight(new BigDecimal(materialWeight));
                }
                //设置调出仓库
                Object transferOutOfWarehouse = materialMap.get("TransferOutOfWarehouse");
                amsSaleMaterial.setTransferOutOfWarehouse((String) transferOutOfWarehouse);
                //设置调入仓库
                Object transferInOfWarehouse = materialMap.get("TransferInOfWarehouse");
                amsSaleMaterial.setTransferInOfWarehouse((String) transferInOfWarehouse);
                //设置调入计划日期
                String transferInPlanDate =(String) materialMap.get("TransferInPlanDate");
                try {
                    Date transferInPlanDate1 = sdf.parse(transferInPlanDate);
                     amsSaleMaterial.setTransferInPlanDate(transferInPlanDate1);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                // 得到金蝶分录主键
                 easPrimaryId = (String) materialMap.get("easPrimaryId");
                //设置调出计划日期
                String transferOutPlanDate =(String) materialMap.get("TransferOutPlanDate");
                try {
                    Date transferOutPlanDate2 = sdf.parse(transferOutPlanDate);
                    amsSaleMaterial.setTransferOutPlanDate(transferOutPlanDate2);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                //是否磅重交货
                Object isPoundSale = materialMap.get("isPoundSale");
                if (isPoundSale!=null){
                    amsSaleMaterial.setIsPoundSale(DataChange.dataToBigDecimal(isPoundSale));
                }
                //设置是否控制数量
                Object controlQuailty = materialMap.get("ControlQuantity");
                amsSaleMaterial.setControlQuantity((String) controlQuailty);
                //设置库存类型
                Object inventoryType = materialMap.get("InventoryType");
                amsSaleMaterial.setInventoryType((String) inventoryType);
                //设置库存状态
                Object inventoryStatus = materialMap.get("InventoryStatus");
                amsSaleMaterial.setInventoryStatus((String) inventoryStatus);
                // 得到物资编码
                String materialCode = (String) materialMap.get("materialCode");
                BigDecimal materialId = amsSaleMaterialMapper.getMaterialId(materialCode);
                Integer materialCount = amsSaleMaterialMapper.getMaterialCount(materialId);
                RmsMaterial rmsMaterial = new RmsMaterial();
                rmsMaterial.setMaterialId(materialId);
                if (materialCount == null) {
                    materialCount = new Integer(0);
                }
                rmsMaterial.setMaterialCount(new BigDecimal(materialCount + 1));
                rmsMaterialMapper.updateByPrimaryKeySelective(rmsMaterial);
                // 得到计量单位
                amsSaleMaterial.setEasPrimaryId(easPrimaryId);
                amsSaleMaterial.setMaterialId(materialId);
                //设置辅助数量
                amsSaleMaterial.setMaterialNumber(DataChange.dataToBigDecimal(auxiliaryQuantity));
                amsSaleMaterial.setInsertTime(new Date());
                amsSaleMaterial.setInsertUsername("金蝶");
                amsSaleMaterial.setMeterWeight(DataChange.dataToBigDecimal(meterWeight));
                amsSaleMaterial.setInsertUpdateRemark("采集金蝶库存调拨单");
                if (materialWeight != null && !"".equals(materialWeight)) {
                    amsSaleMaterial.setMaterialWeight(new BigDecimal(materialWeight));
                }
                result += amsSaleMaterialMapper.insertSelective(amsSaleMaterial);
                //设置发站
                Object toTheStation = map.get("toTheStation");
                TmstrainPleaseApproveResult tmstrainPleaseApproveResult=new TmstrainPleaseApproveResult();
                BigDecimal maxId = tmstrainPleaseApproveResultMapper.getMaxId();
                tmstrainPleaseApproveResult.setResultId(maxId);
                tmstrainPleaseApproveResult.setResultPleasePlanNo(DataChange.generateEightDigitsNumber("WLQCH",maxId.intValue()));
                tmstrainPleaseApproveResult.setRailPlanId(saleMaterialId);
                //查找到站是否存在到站表
                BigDecimal sendStation = rmstrainArrivalSendMapper.getSendStation((String) toTheStation);
                //到站不存在
                if (sendStation==null){
                    //新增到站
                    BigDecimal toStationMaxId = rmstrainArrivalSendMapper.getMaxId();
                    RmstrainArrivalSend rmstrainArrivalSend=new RmstrainArrivalSend();
                    rmstrainArrivalSend.setArrivalId(toStationMaxId);
                    rmstrainArrivalSend.setArrivalName((String) toTheStation);
                    rmstrainArrivalSend.setInsertTime(new Date());
                    rmstrainArrivalSend.setInsertUsername("金蝶");
                    rmstrainArrivalSend.setInsertUpdateRemark("金蝶回传数据");
                    result += rmstrainArrivalSendMapper.insertSelective(rmstrainArrivalSend);
                    tmstrainPleaseApproveResult.setToTheStationId(toStationMaxId);
                }else {
                    //到站存在
                    tmstrainPleaseApproveResult.setToTheStationId(sendStation);
                }
                tmstrainPleaseApproveResult.setResultType(new BigDecimal(4));
                tmstrainPleaseApproveResult.setInsertTime(new Date());
                tmstrainPleaseApproveResult.setInsertUpdateRemark("金蝶回传");
                result += tmstrainPleaseApproveResultMapper.insertSelective(tmstrainPleaseApproveResult);
            }
        }else {
//            throw new Exception("暂不支持修改库存调拨单");
            //此处判断主要是针对销售订单已经存在
            AmsSaleOrder amsSaleOrder=new AmsSaleOrder();
            //此处判断订单状态为反审核
            if (closeStatus.equals("0")&&orderStatus.equals("5")) {
                //删除销售订单以及销售订单分录（没有下游单据的）
                int i=0;
                List<Map<String, Object>> mapList = amsSaleOrderMapper.selectAmssaleOrderId(saleNumber);
                BigDecimal selectAreadyUse = amsSaleOrderMapper.selectAreadyUse(saleNumber);
                if (selectAreadyUse==null) {
                    for (Map<String, Object> IdMap : mapList) {
                        BigDecimal saleMaterialId = DataChange.dataToBigDecimal(IdMap.get("saleMaterialId"));
                        i+= amsSaleMaterialMapper.deleteByPrimaryKey(saleMaterialId);
                    }
                   i+= amsSaleOrderMapper.deleteByPrimaryKey(saleOrderNumber);
                   return i;
                }else {
                    return -1;
                }
            }
            if (orderStatus.equals("2")){
                amsSaleOrder.setSaleOrderId(saleOrderNumber);
                amsSaleOrder.setCloseStatus(new BigDecimal(1));
                amsSaleOrderMapper.updateByPrimaryKeySelective(amsSaleOrder);
            }
            // 关闭单个分录订单
            if (closeStatus.equals("-1") && wholeOrder.equals("0")) {
                Object closeEntryId = map.get("closeEntryId");
                if (closeEntryId != null) {
                    Map<String, Object> easMap = new HashMap<>();
                    easMap.put("easPrimaryId", closeEntryId);
                    List<AmsSaleMaterial> amsSaleMaterials = amsSaleMaterialMapper.selectByParameters(easMap);
                    if (amsSaleMaterials != null && amsSaleMaterials.size() != 0) {
                        AmsSaleMaterial amsSaleMaterial = amsSaleMaterials.get(0);
                        amsSaleMaterial.setDeleted(new BigDecimal(0));
                        result += amsSaleMaterialMapper.updateByPrimaryKeySelective(amsSaleMaterial);
                    }
                }
            }
            // 反关闭整单
            if (closeStatus.equals("-2") && "1".equals(wholeOrder)) {
                amsSaleOrder.setDeleted(new BigDecimal(0));
                Object reason = map.get("reason");
                BigDecimal saleOrderId = amsSaleOrder.getSaleOrderId();
                if (reason != null) {
                    amsSaleOrder.setInsertUpdateRemark(reason.toString());
                }
                // 反关闭销售订单下的所有分录
                result += amsSaleMaterialMapper.openAllSaleMaterial(saleOrderId);
                result += amsSaleOrderMapper.updateByPrimaryKeySelective(amsSaleOrder);
            }
            // 反关闭单个分录订单
            if (closeStatus.equals("-2") && wholeOrder.equals("0")) {
                Object unCloseEntryId = map.get("unCloseEntryId");
                if (unCloseEntryId != null) {
                    Map<String, Object> easMap = new HashMap<>();
                    easMap.put("easPrimaryId", unCloseEntryId);
                    List<AmsSaleMaterial> amsSaleMaterials = amsSaleMaterialMapper.selectByParameters(easMap);
                    if (amsSaleMaterials != null && amsSaleMaterials.size() != 0) {
                        AmsSaleMaterial amsSaleMaterial = amsSaleMaterials.get(0);
                        result += amsSaleMaterialMapper.unCloseSaleMaterial(amsSaleMaterial.getSaleMaterialId());

                    }
                }
            }
            //编辑销售订单主键
            amsSaleOrder.setSaleOrderId(saleOrderNumber);
            //新增单据编码
            amsSaleOrder.setSaleNumber(saleNumber);
            // 订单日期
            try {
                Date saleOrderBizDate = sdf.parse(saleOrderBizDateStr);
                amsSaleOrder.setInsertTime(saleOrderBizDate);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            //业务日期
            try {
                Date BusinessDate = sdf2.parse(businessDate);
                amsSaleOrder.setBusinessDate(BusinessDate);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            amsSaleOrder.setWhetherTheCar(whetherTheCar);
            amsSaleOrder.setSaleRemark(saleRemark);
            amsSaleOrder.setSaleOrderStatus(new BigDecimal(2));
            //销售订单类型：内转钢材到异地库
            amsSaleOrder.setSaleType(new BigDecimal(4));
            amsSaleOrder.setTransferInDep(transferInDep);
            amsSaleOrder.setTransferOutDep(transferOutDep);
            amsSaleOrder.setDeleted(new BigDecimal(0));
            amsSaleOrder.setTransferInInventoryOrg(transferInInventoryOrg);
            amsSaleOrder.setTransferOutInventoryOrg(transferOutInventoryOrg);
            amsSaleOrder.setBusinessType(businessType);
            result += amsSaleOrderMapper.updateByPrimaryKeySelective(amsSaleOrder);
            Object toTheStation = map.get("toTheStation");
            //根据销售订单id查找是否存在该请车实绩
            BigDecimal resultId = tmstrainPleaseApproveResultMapper.selectResultId(saleOrderNumber);
            TmstrainPleaseApproveResult tmstrainPleaseApproveResult=new TmstrainPleaseApproveResult();
            tmstrainPleaseApproveResult.setResultId(resultId);
            tmstrainPleaseApproveResult.setRailPlanId(saleOrderNumber);
            //查找到站是否存在到站表
            BigDecimal sendStation = rmstrainArrivalSendMapper.getSendStation((String) toTheStation);
            //到站不存在
            if (sendStation==null){
                //新增到站
                BigDecimal toStationMaxId = rmstrainArrivalSendMapper.getMaxId();
                RmstrainArrivalSend rmstrainArrivalSend=new RmstrainArrivalSend();
                rmstrainArrivalSend.setArrivalId(toStationMaxId);
                rmstrainArrivalSend.setArrivalName((String) toTheStation);
                rmstrainArrivalSend.setInsertTime(new Date());
                rmstrainArrivalSend.setInsertUsername("金蝶");
                rmstrainArrivalSend.setInsertUpdateRemark("金蝶回传数据");
                result += rmstrainArrivalSendMapper.insertSelective(rmstrainArrivalSend);
            }else {
                //到站存在
                tmstrainPleaseApproveResult.setToTheStationId(sendStation);
            }
            tmstrainPleaseApproveResult.setResultType(new BigDecimal(4));
            tmstrainPleaseApproveResult.setInsertTime(new Date());
            tmstrainPleaseApproveResult.setInsertUpdateRemark("金蝶回传");
            result += tmstrainPleaseApproveResultMapper.updateByPrimaryKeySelective(tmstrainPleaseApproveResult);
            //修改销售订单子表
        }
        return result;
    }

    //根据运输订单号和车牌号
    @Override
    public List<Map<String, Object>> selectSaleSteelOrder(Map<String,Object> map) {
        List<Map<String, Object>> mapList = amsSaleOrderMapper.selectSaleSteelOrder(map);
        if (mapList.size()==0){
             return null;
        }
        for (Map<String,Object> map1:mapList){
            String materialName =(String) map1.get("materialName");
            if (materialName.contains("盘螺")){
                map1.put("materialType","盘螺");
            }else if (materialName.contains("盘圆")||materialName.contains("盘元")){
                map1.put("materialType","盘圆");
            }else if (materialName.contains("螺纹")){
                map1.put("materialType","螺纹钢");
            }
            //根据物资id查找炉批号
            BigDecimal materialId =DataChange.dataToBigDecimal(map1.get("materialId"));
            BigDecimal orderId =DataChange.dataToBigDecimal( map1.get("orderId"));
            List<Map<String,Object>> materialFurnaceNumber = amsSaleOrderMapper.selectMaterialFurnaceNumber(materialId,orderId);
            StringBuilder sb = new StringBuilder();
            for (Map<String, Object> luHaoMap : materialFurnaceNumber) {
                sb.append(luHaoMap.get("materialFurnaceNumber"));
                sb.append("-");
                sb.append(luHaoMap.get("materialNum"));
                sb.append("/");
            }
            if(materialFurnaceNumber.size() > 0){
                sb.deleteCharAt(sb.length() - 1);
                map1.put("materialFurnaceNumber",materialFurnaceNumber);
            }
            //接口发送日期
            map1.put("sendTime",new Date());
        }
        return mapList;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public int receiveOrderResult(Map<String, Object> map) throws Exception {
        int result=0;
        OmstrainOrder omstrainOrder = new OmstrainOrder();
        //获取运输订单号
        Object orderNumber = map.get("orderNumber");
        //获取备注-如果是异常情况，填写备注。
        Object remark = map.get("remark");
        if (remark!=null){
            omstrainOrder.setAcceptRemark((String) remark);
        }
        //接收车皮号
        Object wagonNo = map.get("wagonNo");
        BigDecimal orderId = omstrainOrderMapper.selectOrderIdBywagonNoAndOrderNumber((String) orderNumber, (String) wagonNo);
        if (orderId==null){
            throw new Exception("提示回传车皮号与运输订单号不匹配");
        }
        //根据运输订单号查找id
        omstrainOrder.setOrderId(orderId);
        //接收是否收货(0为未收货，1为已收货)
        Object receviceOrNot = map.get("receviceOrNot");
        omstrainOrder.setIsAccept(DataChange.dataToBigDecimal(receviceOrNot));
        //接收时间
        String receviceTime2 =(String) map.get("receviceTime");
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            Date receviceTime = sdf2.parse(receviceTime2);
            omstrainOrder.setIsAcceptTime(receviceTime);
        } catch (ParseException e) {
            e.printStackTrace();
        }
       result = omstrainOrderMapper.updateByPrimaryKeySelective(omstrainOrder);
        return result;
    }




}