iamberry-common-parent/watero-rst-service/src/main/java/com/iamberry/rst/service/cm/SalesOrderServiceImpl.java

package com.iamberry.rst.service.cm;

import com.github.pagehelper.PageHelper;
import com.iamberry.redis.RedisUtils;
import com.iamberry.rst.core.cm.SalesOrder;
import com.iamberry.rst.core.cm.SalesOrderItem;
import com.iamberry.rst.core.cm.StoreInfo;
import com.iamberry.rst.core.dm.SupplierProduct;
import com.iamberry.rst.core.fm.ComplaintDetectInfo;
import com.iamberry.rst.core.fm.InventoryInfo;
import com.iamberry.rst.core.fm.InventoryLog;
import com.iamberry.rst.core.order.*;
import com.iamberry.rst.core.page.PagedResult;
import com.iamberry.rst.core.sys.Admin;
import com.iamberry.rst.core.sys.SysConfig;
import com.iamberry.rst.core.tools.LogisticsInfo;
import com.iamberry.rst.faces.address.AddressService;
import com.iamberry.rst.faces.cm.InventoryService;
import com.iamberry.rst.faces.cm.SalesOrderService;
import com.iamberry.rst.faces.cm.StoreInfoService;
import com.iamberry.rst.faces.order.EfastOrderService;
import com.iamberry.rst.faces.order.OrderBatchService;
import com.iamberry.rst.faces.order.OrderSyncLogService;
import com.iamberry.rst.faces.order.OrderWarehouseService;
import com.iamberry.rst.faces.product.ProductService;
import com.iamberry.rst.service.cm.mapper.SalesOrderMapper;
import com.iamberry.rst.service.dm.mapper.SupplierProductMapper;
import com.iamberry.rst.service.fm.mapper.ComplaintDetectInfoMapper;
import com.iamberry.rst.service.fm.mapper.InventoryLogMapper;
import com.iamberry.rst.service.fm.mapper.InventoryMapper;
import com.iamberry.rst.service.order.mapper.DeliveryStrategyMapper;
import com.iamberry.rst.service.order.mapper.ProvincesLogisticsMapper;
import com.iamberry.rst.service.product.mapper.ProductMapper;
import com.iamberry.rst.service.sys.mapper.SysConfigMapper;
import com.iamberry.rst.util.PageUtil;
import com.iamberry.wechat.tools.DateTimeUtil;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;

import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * Created by liuzhiwei on 2017/10/31.
 */
@Service
public class SalesOrderServiceImpl implements SalesOrderService {

    private static Logger logger = LoggerFactory.getLogger(CustomerServiceImpl.class);

    @Autowired
    private SalesOrderMapper salesOrderMapper;
    @Autowired
    private ProductService productService;
    @Autowired
    private StoreInfoService storeInfoService;
    @Autowired
    private EfastOrderService efastOrderService;
    @Autowired
    private SalesOrderService salesOrderService;
    @Autowired
    private SysConfigMapper sysConfigMapper;
    @Autowired
    private AddressService addressService;
    @Autowired
    private ProvincesLogisticsMapper provincesLogisticsMapper;
    @Autowired
    private ProductMapper productMapper;
    @Autowired
    private InventoryMapper inventoryMapper;
    @Autowired
    private InventoryLogMapper inventoryLogMapper;
    @Autowired
    private ComplaintDetectInfoMapper complaintDetectInfoMapper;
    @Autowired
    private OrderWarehouseService orderWarehouseService;
    @Autowired
    private InventoryService inventoryService;
    @Autowired
    private SupplierProductMapper supplierProductMapper;
    @Autowired
    private OrderBatchService orderBatchService;
    @Autowired
    private DeliveryStrategyMapper deliveryStrategyMapper;
    @Autowired
    private OrderSyncLogService orderSyncLogService;

    /**
     * 缓存订单项的前缀
     */
    public static String CACHE_ORDER_ITEM_NAME = null;
    static {
        Map<String,String> map = System.getenv();
        if ("iZ94klno8qrZ".equalsIgnoreCase(map.get("COMPUTERNAME"))) {
            CACHE_ORDER_ITEM_NAME = "RST_ORDER_ITEM_";
        } else {
            CACHE_ORDER_ITEM_NAME = "adv_ORDER_ITEM_";
        }
    }

    @Override
    public Integer addSalesOrder(SalesOrder salesOrder) {
        return salesOrderMapper.addSalesOrder(salesOrder);
    }

    @Override
    @Transactional
    public Integer addSalesOrderManual(SalesOrder salesOrder) {
        salesOrderMapper.addSalesOrder(salesOrder);

        return null;
    }

    @Override
    public SalesOrder getSalesOrderById(Integer salesId) {
        return salesOrderMapper.getSalesOrderById(salesId);
    }
    @Override
    public SalesOrder getSalesOrderByIdConcise(Integer salesId) {
        return salesOrderMapper.getSalesOrderByIdConcise(salesId);
    }

    @Override
    public List<SalesOrder> getSalesOrderListConcise(SalesOrder salesOrder){
        return salesOrderMapper.getSalesOrderListConcise(salesOrder);
    }

    @Override
    public List<SalesOrderItem> getOrderItemListBySalesId(Integer itemOrderId) {
        return salesOrderMapper.getOrderItemListBySalesId(itemOrderId);
    }


    @Override
    public List<SalesOrder> getSalesOrderByIds(Integer[] salesIds){
        return salesOrderMapper.getSalesOrderByIds(salesIds);
    }

    @Override
    public  List<SalesOrder>  getSonSalesOrderBySaleId(Integer salesId) {
        return salesOrderMapper.getSonSalesOrderBySaleId(salesId);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class}, isolation = Isolation.REPEATABLE_READ)
    public Integer updateSalesOrder(SalesOrder salesOrder) {
        Integer res = salesOrderMapper.updateSalesOrder(salesOrder);
        if (res == null || res <= 0) {
            return 0;
        }

        // 确认订单需要填入产品成本价格
        if(salesOrder.getSalesStatus() != null && salesOrder.getSalesStatus() == 1){
            SalesOrderItem salesOrderItem = new SalesOrderItem();
            salesOrderItem.setItemOrderId(salesOrder.getSalesId());
            List<SalesOrderItem> salesOrderItemList = salesOrderMapper.listSalesOrderItem(salesOrderItem);
            List<SalesOrderItem> newSalesOrderItem = new ArrayList<>();
            for (SalesOrderItem soi:salesOrderItemList) {
                SupplierProduct supplierProduct = supplierProductMapper.getSupplierProductByColorId(soi.getItemColorId());
                if(supplierProduct != null){
                    SalesOrderItem newSalesOrder = new SalesOrderItem();
                    newSalesOrder.setItemCost(supplierProduct.getSpCost());
                    newSalesOrder.setItemCostTotal(supplierProduct.getSpCost() * soi.getItemNum());
                    newSalesOrder.setItemId(soi.getItemId());
                    newSalesOrderItem.add(newSalesOrder);
                }else{
                    throw  new RuntimeException("确认订单失败-未查询到该产品（"+ soi.getItemProductName() +"-"+ soi.getItemProductColor() +"）的成本价格");
                }
            }
            for (SalesOrderItem soi : newSalesOrderItem) {
                Integer flag = salesOrderMapper.updateOrderItemObj(soi);
                if(flag < 1){
                    throw  new RuntimeException("确认订单失败-修改产品项的成本价格失败");
                }
            }
        }

        // 作废订单时需要返还库存
        if(salesOrder.getSalesStatus() != null && salesOrder.getSalesStatus() == 3){
            // 如果已出库则返还库存
            SalesOrder so = salesOrderMapper.getSalesOrderById(salesOrder.getSalesId());
            if(so.getSalesDeliver() == 2){
                SalesOrderItem salesOrderItem = new SalesOrderItem();
                salesOrderItem.setItemOrderId(so.getSalesId());
                List<SalesOrderItem> listOrderitem = salesOrderService.listSalesOrderItem(salesOrderItem);
                for (SalesOrderItem soi:listOrderitem) {
                    InventoryInfo inventoryInfo2 = new InventoryInfo();
                    //良品数量
                    inventoryInfo2.setInventoryGoodProductNum(soi.getItemNum());
                    inventoryInfo2.setInventoryProductBar(soi.getItemColorBar());
                    inventoryInfo2.setWarehouseId(so.getSalesWarehouseId());
                    //类型1.采购 2.发货 3.次品
                    inventoryInfo2.setLogType(1);
                    inventoryInfo2.setInventoryRecentRecord("作废订单返还库存-作废订单号:"+ so.getSalesDealCode());
                    inventoryService.addInventory(inventoryInfo2);
                }
            }
        }
        return 1;
    }

    @Override
    public Integer update(SalesOrder salesOrder) {
        return  salesOrderMapper.updateSalesOrder(salesOrder);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class}, isolation = Isolation.REPEATABLE_READ)
    public Integer updateOrderInfo(SalesOrder salesOrder) {
        int flag = 0;
        if(salesOrder.getSalesId()==null){
            throw new RuntimeException("订单ID不存在！");
        }
        // 处理订单项
        Date nowTime = new Date();
        for (SalesOrderItem addItem:salesOrder.getSalesOrderItemList()) {
            if(addItem.getItemNum() > 0 && addItem.getItemColorId() > 0){
                ProductColor productColor = productService.getProduceColor(addItem.getItemColorId());
                if(productColor == null){
                    throw new RuntimeException("删除订单项失败-查询商品失败");
                }
                ////产品id
                addItem.setItemProductId(productColor.getColorProductId());
                addItem.setItemColorId(productColor.getColorId());
                addItem.setItemProductType(productColor.getProductType());
                addItem.setItemProductName(productColor.getProductName());
                addItem.setItemProductPic(productColor.getColorPicture());
                addItem.setItemProductColor(productColor.getColorName());
                addItem.setItemColorBar(productColor.getColorBar());
                addItem.setItemCreateTime(nowTime);
                addItem.setItemIsSource(1);
                addItem.setItemOrderId(salesOrder.getSalesId());
                //成本价
                SupplierProduct supplierProduct = supplierProductMapper.getSupplierProductByColorId(addItem.getItemColorId());
                if(supplierProduct != null){
                    addItem.setItemCost(supplierProduct.getSpCost());
                    addItem.setItemCostTotal(supplierProduct.getSpCost() * addItem.getItemNum());
                }else{
                    throw  new RuntimeException("确认订单失败-未查询到该产品（"+ addItem.getItemProductName() +"-"+ addItem.getItemProductColor() +"）的成本价格");
                }
            } else {
                throw new RuntimeException("添加订单项失败(订单产品不能为空)！");
            }
        }

        // 处理订单项，如果是新增的就新增，如果是原有的，则修改，否则删除
        SalesOrderItem soi = new SalesOrderItem();
        soi.setItemOrderId(salesOrder.getSalesId());
        List<SalesOrderItem> salesOrderItemList = salesOrderMapper.listSalesOrderItem(soi);
        List<SalesOrderItem> updateSalesOrderItemList = new ArrayList<>();
        List<SalesOrderItem> deleteSalesOrderItemList = new ArrayList<>();

        for (SalesOrderItem oldSoi:salesOrderItemList) {
            boolean isHave = false;
            int deleteId = 0;
            SalesOrderItem updateItem = null;
            for (int i = 0; i < salesOrder.getSalesOrderItemList().size(); i++) {
                SalesOrderItem temp = salesOrder.getSalesOrderItemList().get(i);
                if(Objects.equals(temp.getItemId(), oldSoi.getItemId())){
                    isHave = true;
                    deleteId = i;
                    updateItem = temp;
                    break;
                }
            }
            if(isHave){
                updateSalesOrderItemList.add(updateItem);
                salesOrder.getSalesOrderItemList().remove(deleteId);
            }else{
                deleteSalesOrderItemList.add(oldSoi);
            }
        }

        // 删除订单项
        for (SalesOrderItem deleteId:deleteSalesOrderItemList) {
            if (salesOrderMapper.delOrderItemByItemId(deleteId.getItemId()) <= 0) {
                throw new RuntimeException("修改订单失败！");
            }
        }

        // 批量修改订单项
        if(updateSalesOrderItemList.size() > 0) {
            for (SalesOrderItem salesOrderItem : updateSalesOrderItemList) {
                flag = salesOrderMapper.updateOrderItemObj(salesOrderItem);
            }
        }

        // 批量添加订单项数据
        if(salesOrder.getSalesOrderItemList() != null && salesOrder.getSalesOrderItemList().size() > 0){
            if (salesOrderMapper.addOrderItemList(salesOrder.getSalesOrderItemList()) <= 0) {
                throw new RuntimeException("增加订单项失败！");
            }
        }

        //计算价格
        List<SalesOrderItem> nowSalesOrderItemList = salesOrderMapper.listSalesOrderItem(soi);
        calculationTotal(salesOrder,nowSalesOrderItemList);

        //修改订单
        if (salesOrderMapper.updateSalesOrder(salesOrder) <= 0) {
            throw new RuntimeException("修改订单失败！");
        }

        // 更新Redis缓存
        cacheOrderItem(salesOrder.getSalesId());
        return flag;
    }

    @Override
    public Integer addSalesOrderList(List<SalesOrder> list) {
        return salesOrderMapper.addSalesOrderList(list);
    }

    @Override
    public List<SalesOrder> listSalesOrder(SalesOrder salesOrder) {
        return salesOrderMapper.listSalesOrder(salesOrder);
    }

    @Override
    public Integer listSalesOrderNum(SalesOrder salesOrder) {
        return salesOrderMapper.listSalesOrderNum(salesOrder);
    }

    /**
     * 获取订单的订单项，首先从REDIS中获取，如果没有获取到，尝试从数据库获取
     * @param salesId
     * @return
     */
    private List<SalesOrderItem> listOrderItem(Integer salesId) {
        String key = CACHE_ORDER_ITEM_NAME + salesId;
        List<SalesOrderItem> list = RedisUtils.list(key, SalesOrderItem.class);
        if (list == null) {
            cacheOrderItem(salesId);
            list = RedisUtils.list(key, SalesOrderItem.class);
        }
        return list;
    }

    /**
     * 更新缓存订单项（从数据库获取一次）
     * @param salesId
     */
    private void cacheOrderItem(Integer salesId) {
        // 查询数据库的数据
        SalesOrderItem salesOrderItem = new SalesOrderItem();
        salesOrderItem.setItemOrderId(salesId);
        List<SalesOrderItem> list = salesOrderMapper.listSalesOrderItem(salesOrderItem);
        // 缓存
        String key = CACHE_ORDER_ITEM_NAME + salesId;
        RedisUtils.put(key, list);
        RedisUtils.expire(key,DateTimeUtil.addDay(1));
    }

    @Override
    public PagedResult<SalesOrder> listSalesOrderPage(int pageNO, int pageSize, SalesOrder salesOrder, boolean isTotalNum) {
        // 初始化页面分页的数据
        salesOrder.setStartOrderNO((pageNO-1) * pageSize);
        salesOrder.setEndOrderNO(pageSize);
        //查询订单列表信息
        List<SalesOrder> orderList = salesOrderMapper.listSalesOrderNew(salesOrder);
        orderList.forEach((so) -> {
            List<SalesOrderItem> salesOrderItemList = listOrderItem(so.getSalesId());
            salesOrderItemList.forEach((item) -> {
                //判断是否包含净水机 1是 2否
                if(item.getColorIsMachine() != null){
                    if(item.getColorIsMachine() == 1){
                        so.setIsDevelop(1);
                    }else{
                        so.setIsDevelop(2);
                    }
                }else{
                    so.setIsDevelop(1);
                }
            });
            so.setSalesOrderItemList(salesOrderItemList);
        });
        PagedResult<SalesOrder> result = PageUtil.getPage(orderList);
        // 查询分页的数据
        int count = salesOrderMapper.listSalesOrderNum(salesOrder);
        result.setTotal(count);
        if(count%pageSize==0){
            count=count/pageSize;
        } else{
            count=count/pageSize+1;
        }
        result.setPages(count);
        result.setPageNo(pageNO);
        result.setPageSize(pageSize);
        return result;
    }

    @Override
    public List<PostInfo> listWaitPrintOrderNum(Integer salesWarehouseId) {
        return salesOrderMapper.listWaitPrintOrderNum(salesWarehouseId);
    }

    @Override
    public PagedResult<SalesOrder> listAwaitSendSalesOrderPage(int pageNO, int pageSize, SalesOrder salesOrder, boolean isTotalNum) {
        PageHelper.startPage(pageNO, pageSize, isTotalNum);
        //查询订单列表信息
        List<SalesOrder> orderList = salesOrderMapper.listAwaitSendSalesOrderPage(salesOrder);
        return PageUtil.getPage(orderList);
    }

    @Override
    @Transactional
    public boolean addOrderAndItem(SalesOrder salesOrder, List<SalesOrderItem> list) throws Exception {
        if (list == null || list.size() == 0) {
            throw new RuntimeException("获取订单信息出错！");
        }
        SalesOrder verifyOrder = new SalesOrder();
        verifyOrder.setSalesOrderId(salesOrder.getSalesOrderId());
        //查询该订单是否存在，如果存在，不需要再次添加到订单中
        int count = salesOrderMapper.getOrderInfoCount(verifyOrder);
        if (count > 0) {
            return true;
        }
        //添加订单数据
        calculationTotal(salesOrder,list);
        try {
            int orderNum = salesOrderMapper.addSalesOrder(salesOrder);
            if (orderNum <= 0) {
                throw new RuntimeException("获取订单信息出错！");
            }
        } catch (Exception e) {
            return true;
        }

        for (SalesOrderItem item : list) {
            item.setItemOrderId(salesOrder.getSalesId());
        }
        //批量添加订单项数据
        int itemNum = salesOrderMapper.addOrderItemList(list);
        if (itemNum <= 0) {
            throw new RuntimeException("获取订单信息出错！");
        }
        return true;
    }

    @Override
    @Transactional
    public SalesOrder addOrderAndIteminfo(SalesOrder salesOrder, List<SalesOrderItem> list) {
        calculationTotal(salesOrder,list);

        //添加订单数据
        int orderNum = salesOrderMapper.addSalesOrder(salesOrder);
        if (orderNum <= 0) {
            return salesOrder;
        }
        for (SalesOrderItem item : list) {
            item.setItemOrderId(salesOrder.getSalesId());
        }
        //批量添加订单项数据
        int itemNum = salesOrderMapper.addOrderItemList(list);
        if (itemNum <= 0) {
            return salesOrder;
        }

        this.cacheOrderItem(salesOrder.getSalesId());
        return salesOrder;
    }

    @Override
    public void parseOrder(SalesOrder oginerOrder, List<SalesOrder> listOrder) {
        // 订单项拆分完成，直接返回
        if (oginerOrder.getSalesOrderItemList().size() <= 0) {
            return;
        }

        List<DownsingleRuleInfo> listDownsingleRuleInfo = salesOrderService.listDownsingleRule();
        if(listDownsingleRuleInfo.size() < 1){
            listOrder.add(oginerOrder);
            return;
        }

        // 拆单，比较的是数量和产品
        Map<String, SalesOrderItem> itemMap = new HashMap<>(oginerOrder.getSalesOrderItemList().size());
        for (SalesOrderItem item : oginerOrder.getSalesOrderItemList()) {
            SalesOrderItem itemTwo = new SalesOrderItem();
            BeanUtils.copyProperties(item,itemTwo);
            itemMap.put(item.getItemColorBar(), itemTwo);
        }

        // 遍历拆单规则
        int ruleCount = 0;
        for (DownsingleRuleInfo rule : listDownsingleRuleInfo) {
            // 一个拆单规则
            int count = 0;
            for (DownsingleRuleItemInfo item : rule.getDownsingleRuleItemList()) {
                if (itemMap.get(item.getDownsingleItemBar()) != null) {
                    if (item.getDownsingleItemNum() <= itemMap.get(item.getDownsingleItemBar()).getItemNum()) {
                        count ++;
                    }
                }
            }
            if (count == rule.getDownsingleRuleItemList().size()) {
                // 满足拆单条件
                SalesOrder newOrder = new SalesOrder();
                BeanUtils.copyProperties(oginerOrder,newOrder);
                newOrder.setSalesOrderItemList(new ArrayList<SalesOrderItem>(count));
                for (DownsingleRuleItemInfo item : rule.getDownsingleRuleItemList()) {
                    SalesOrderItem temp = new SalesOrderItem();
                    BeanUtils.copyProperties(itemMap.get(item.getDownsingleItemBar()),temp);
                    temp.setItemNum(item.getDownsingleItemNum());
                    newOrder.getSalesOrderItemList().add(temp);
                }
                listOrder.add(newOrder);

                // 继续递归
                for (DownsingleRuleItemInfo item : rule.getDownsingleRuleItemList()) {
                    if (item.getDownsingleItemNum().equals(itemMap.get(item.getDownsingleItemBar()).getItemNum())) {
                        // 数量和拆单规则相同，则删除原订单的订单项
                        /*oginerOrder.getSalesOrderItemList().remove(itemMap.get(item.getDownsingleItemBar()));*/
                        for(int i = 0;i<oginerOrder.getSalesOrderItemList().size();i++){
                            if(oginerOrder.getSalesOrderItemList().get(i).getItemColorBar() .equals(item.getDownsingleItemBar())){
                                oginerOrder.getSalesOrderItemList().remove(i);
                            }
                        }
                    } else {
//                        SalesOrderItem orderItem = itemMap.get(item.getDownsingleItemBar());
                        SalesOrderItem orderItem = new SalesOrderItem();
                        BeanUtils.copyProperties(itemMap.get(item.getDownsingleItemBar()),orderItem);
                        int oldCount = orderItem.getItemNum();
                        /*orderItem.setItemNum(oldCount - item.getDownsingleItemNum());*/
                        for(int i = 0;i<oginerOrder.getSalesOrderItemList().size();i++){
                            if(oginerOrder.getSalesOrderItemList().get(i).getItemColorBar() .equals(item.getDownsingleItemBar())){
                                oginerOrder.getSalesOrderItemList().get(i).setItemNum(oldCount - item.getDownsingleItemNum());
                            }
                        }
                    }
                }
                salesOrderService.parseOrder(oginerOrder, listOrder);
                break;
            } else {
                // 不满足, 继续下一个规则
                // 如果是最后一个拆单规则，则不拆单
                if ((ruleCount + 1) == listDownsingleRuleInfo.size()) {
                    if (oginerOrder.getSalesOrderItemList().size() > 0) {
                        listOrder.add(oginerOrder);
                    }
                }
            }
            ruleCount++;
        }
    }


    @Override
    @Transactional(rollbackFor = {Exception.class, SQLException.class}, isolation = Isolation.REPEATABLE_READ)
    public boolean addRstOrderAndIteminfo(SalesOrder salesOrder){
        //总支付金额
        Integer salesPayMoney = 0;
        for (SalesOrderItem soi : salesOrder.getSalesOrderItemList()) {
            if(soi.getItemProductDiscount() != null){
                Integer differenceNumber = soi.getItemNum()*soi.getItemProductDiscount() - soi.getItemTotal();
                differenceNumber = Math.abs(differenceNumber);  //绝对值
                if(soi.getItemProductDiscount() == 0 || soi.getItemProductDiscount() == 1 || differenceNumber > 1){
                    Double dis = Double.valueOf(soi.getItemTotal())/soi.getItemNum();
                    soi.setItemProductDiscount(dis.intValue());
                }
            }else{
                Double dis = Double.valueOf(soi.getItemTotal())/soi.getItemNum();
                soi.setItemProductDiscount(dis.intValue());
            }
            salesPayMoney += soi.getItemTotal();
        }

        //合并订单项-------------statr
        List<SalesOrderItem> listItem = salesOrder.getSalesOrderItemList();
        salesOrder.setSalesOrderItemList(null);
        List<SalesOrderItem> list = new ArrayList<>();
        for (int i = 0;i<listItem.size();i++){
            if(i < listItem.size() - 1 ){
                for(int j = 0;j<listItem.size();j++){
                    if (i != j){
                        if(listItem.get(i).getItemColorBar().equals(listItem.get(j).getItemColorBar())){
                            listItem.get(i).setItemNum(listItem.get(i).getItemNum()+listItem.get(j).getItemNum());
                        }
                    }
                }
            }
            boolean bl = true;
            for (SalesOrderItem salesOrderItem : list){
                if(salesOrderItem.getItemColorBar().equals(listItem.get(i).getItemColorBar())){
                    bl = false;
                }
            }
            if(bl){
                list.add(listItem.get(i));
            }
        }
        //合并订单项----------------------end
        //匹配拆单规则 分割订单-------------state
        List<SalesOrder> listSalesOrder = new ArrayList<>();
        salesOrder.setSalesOrderItemList(list);
        salesOrderService.parseOrder(salesOrder, listSalesOrder);
        //匹配拆单规则 分割订单-------------end
        boolean msg = false;

        /*根据省份来分配物流公司*/
        /*salesOrderService.setProvincesLogistics(listSalesOrder);*/
        /*根据快递策略来分配物流公司*/
        setStrategyLogistics(listSalesOrder);

        /*查询成本*/
        for (SalesOrder so:listSalesOrder) {
            for (SalesOrderItem soi:so.getSalesOrderItemList()) {
                SupplierProduct supplierProduct = supplierProductMapper.getSupplierProductByColorId(soi.getItemColorId());
                if(supplierProduct != null){
                    soi.setItemCost(supplierProduct.getSpCost());
                    soi.setItemCostTotal(supplierProduct.getSpCost() * soi.getItemNum());
                }else{
                    throw  new RuntimeException("确认订单失败-未查询到该产品（"+ soi.getItemProductName() +"-"+ soi.getItemProductColor() +"）的成本价格");
                }
            }
        }

        for (int i = 0; i < listSalesOrder.size() ; i++) {
            boolean isLastItem = false;
            if((i+1) >= listSalesOrder.size()){
                isLastItem = true;
            }
            SalesOrder so = listSalesOrder.get(i);
            for (int j = 0; j < so.getSalesOrderItemList().size(); j++) {
                SalesOrderItem soi = so.getSalesOrderItemList().get(j);
                if((j+1) >= so.getSalesOrderItemList().size() && isLastItem){
                    soi.setItemTotal(salesPayMoney);
                    if(salesPayMoney > 0){
                        soi.setItemProductDiscount(salesPayMoney/soi.getItemNum());
                    }
                }else{
                    Integer total = soi.getItemNum()*soi.getItemProductDiscount();
                    soi.setItemTotal(total);
                    salesPayMoney -= total;
                }
            }
        }

        //判断主从订单--------------------state
        if (listSalesOrder.size() > 0){
            SalesOrder mainOrder = null;
            for (int s = 0;s < listSalesOrder.size();s++){
                if(mainOrder == null){
                    for(int i = 0;i<listSalesOrder.get(s).getSalesOrderItemList().size();i++){
                        int isMachine = salesOrderService.getIsMachine(listSalesOrder.get(s).getSalesOrderItemList().get(i).getItemColorBar());
                        if( isMachine == 1){//1：水机 2：其它产品 0:未查到
                            mainOrder = listSalesOrder.get(s);
                            listSalesOrder.remove(s);
                            break;
                        }
                    }
                }
            }
            if(mainOrder == null){//如果不存有水机的订单则默认第一个订单为主订单
                mainOrder = listSalesOrder.get(0);
                listSalesOrder.remove(0);
            }
            //判断主从订单--------------------end

             msg = salesOrderService.addRstOrderinfo(mainOrder,listSalesOrder,null);
        }
        return msg;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class}, isolation = Isolation.REPEATABLE_READ)
    public boolean addRstOrderinfo(SalesOrder mainOrder,List<SalesOrder> listSalesOrder,String[] detectIds) {
        // 查询交易号的数量
        Integer flag = salesOrderMapper.getOrderBySalesDealCodeNum(mainOrder.getSalesDealCode());
        if(flag > 0){
            throw new RuntimeException("交易号("+ mainOrder.getSalesDealCode() +")重复，请重新生成交易号！");
        }
        if(mainOrder.getSalesAddressPostcode() == null){
            throw new RuntimeException("未获取到邮政编码信息，请检查地址信息！");
        }
        if(mainOrder.getSalesCreateTime() == null){
            /*保证时间与以前一样*/
            mainOrder.setSalesCreateTime(mainOrder.getSalesOrderItemList().get(0).getItemCreateTime());
        }
        // 计算金额
        calculationTotal(mainOrder,mainOrder.getSalesOrderItemList());

        // 2019年12月27日15:49:16新增快递策略 分配物流方式
        List<SalesOrder> listS = new ArrayList<>();
        listS.add(mainOrder);
        setStrategyLogistics(listS);
        // 子订单根据快递策略分配物流方式
        setStrategyLogistics(listSalesOrder);

        if(mainOrder.getSalesDeliver() == null){
            mainOrder.setSalesDeliver(1);
        }

        // 保存订单信息
        int res = salesOrderMapper.addSalesOrder(mainOrder);
        if (res <= 0) {
            throw new RuntimeException("添加订单出错,请核查内容");
        }
        for (SalesOrderItem item : mainOrder.getSalesOrderItemList()) {
            item.setItemOrderId(mainOrder.getSalesId());
        }
        // 批量添加订单项数据
        res = salesOrderMapper.addOrderItemList(mainOrder.getSalesOrderItemList());
        if (res <= 0) {
            throw  new RuntimeException("添加订单出错，保存订单项失败");
        }
        // 保存子订单的内容
        if(listSalesOrder.size() > 0){
            for (int i = 0;i<listSalesOrder.size();i++){
                // 生产交易号
                listSalesOrder.get(i).setSalesDealCode(listSalesOrder.get(i).getSalesDealCode()+"-"+(i+1));
                if(listSalesOrder.get(i).getSalesOrderId() != null && !"".equals(listSalesOrder.get(i).getSalesOrderId())){
                    listSalesOrder.get(i).setSalesOrderId(listSalesOrder.get(i).getSalesOrderId()+"-"+(i+1));
                }
                // 主订单id
                if(listSalesOrder.get(i).getSalesDeliver() == null){
                    listSalesOrder.get(i).setSalesDeliver(1);
                }

                listSalesOrder.get(i).setSalesMainOrderId(mainOrder.getSalesId());
                listSalesOrder.get(i).setSalesId(null);
                calculationTotal(listSalesOrder.get(i),listSalesOrder.get(i).getSalesOrderItemList());
                res = salesOrderMapper.addSalesOrder(listSalesOrder.get(i));
                if (res <= 0) {
                    throw  new RuntimeException("添加子订单出错");
                }
                for (SalesOrderItem item : listSalesOrder.get(i).getSalesOrderItemList()) {
                    item.setItemOrderId(listSalesOrder.get(i).getSalesId());
                }
                // 批量添加订单项数据
                res = salesOrderMapper.addOrderItemList(listSalesOrder.get(i).getSalesOrderItemList());
                if (res <= 0) {
                    throw  new RuntimeException("添加子订单出错，保存订单项失败");
                }
            }
        }
        // 修为维修记录为已下单
        if(detectIds != null && detectIds.length > 0){
            for(String detectId : detectIds){
                ComplaintDetectInfo detectInfo = new ComplaintDetectInfo();
                detectInfo.setDetectId(Integer.valueOf(detectId));
                detectInfo.setDetectPlaceorder(2);
                detectInfo.setSalesOrderId(mainOrder.getSalesOrderId());
                complaintDetectInfoMapper.updateDetectById(detectInfo);
            }
        }
        // 缓存订单项
        cacheOrderItem(mainOrder.getSalesId());
        return true;
    }

    /**
     * 根据省份来分配物流公司
     * @param listSalesOrder
     * @return
     */
    @Override
    public void setProvincesLogistics(List<SalesOrder> listSalesOrder){
        for (SalesOrder salesOrder:listSalesOrder) {
            boolean flag = false;
            for (SalesOrderItem salesOrderItem:salesOrder.getSalesOrderItemList()) {
                ProductColor productColor = productService.getColorByBar(salesOrderItem.getItemColorBar());
                if(productColor.getColorIsMachine() == 1){
                    flag = true;
                }
            }
            if(flag){
                String addresses[] = salesOrder.getSalesAddressInfo().split("-");
                if(addresses == null || addresses.length < 3){
                    addresses = salesOrder.getSalesAddressInfo().split(" ");
                }
                if(addresses == null || addresses.length < 3){
                    addresses = salesOrder.getSalesAddressInfo().split("_");
                }
                if(addresses == null || addresses.length < 3){
                    break;
                }
                String provincesStr = addresses[0];
                provincesStr = provincesStr.substring(0,2);

                ProvincesLogistics provincesLogistics = new ProvincesLogistics();
                provincesLogistics.setProvince(provincesStr);
                List<ProvincesLogistics> provincesLogisticsList = provincesLogisticsMapper.getProvincesLogisticsList(provincesLogistics);
                if(provincesLogisticsList == null || provincesLogisticsList.size() < 1){
                    /*未查到地址*/
                    break;
                }
                //设置快递公司
                provincesLogistics = provincesLogisticsList.get(0);
                if(provincesLogistics.getLogisticsRstCode() != null){
                    salesOrder.setSalesPostFirm(provincesLogistics.getLogisticsRstCode());
                }
            }
        }
    }
    /**
     * 根据快递策略来分配物流公司
     * @param listSalesOrder
     * @return
     */
    public void setStrategyLogistics(List<SalesOrder> listSalesOrder){
        if(listSalesOrder.size() > 0){
        //查询所有快递策略
        DeliveryStrategy deliveryStrategy = new DeliveryStrategy();
        deliveryStrategy.setStrategyStatus(1);
        List<DeliveryStrategy> trategyList = deliveryStrategyMapper.getPriorityList(deliveryStrategy);
        for (SalesOrder salesOrder:listSalesOrder) {
            for(DeliveryStrategy strategy : trategyList){
                if(salesOrder.getSalesCompanyId().equals(strategy.getStrategyCompanyId())){

                    //判断店铺
                    boolean isMeet1 = false;
                    if(strategy.getStrategyStoreId() == 0){
                        isMeet1 = true;
                    }else{
                        for(StrategyStore strategyStore : strategy.getListStrategyStore()){
                            if (salesOrder.getSalesStoreId() == null) {
                                LoggerFactory.getLogger(SalesOrderServiceImpl.class).info("订单店铺为空");
                            }
                            if (strategyStore.getStoreId() == null) {
                                LoggerFactory.getLogger(SalesOrderServiceImpl.class).info("策略店铺为空");
                            }
                            if(salesOrder.getSalesStoreId().equals(strategyStore.getStoreId())){
                                isMeet1 = true;
                            }
                        }
                    }
                    //判断产品、颜色
                    boolean isMeet3 = false;
                        for(SalesOrderItem salesOrderItem : salesOrder.getSalesOrderItemList()){
                            boolean isProduct = false;
                            for(StrategyColor strategyColor : strategy.getListStrategyColor()){
                                if(strategyColor.getProductId() == 0 || strategyColor.getProductId().equals(salesOrderItem.getItemProductId())){
                                    if(strategyColor.getColorId() == 0 ||salesOrderItem.getItemColorId().equals(strategyColor.getColorId())){
                                        isProduct = true;
                                        break;
                                    }
                                }
                            }
                            if(!isProduct){
                                isMeet3 = false;
                                break;
                            }else{
                                isMeet3 = true;
                            }
                        }
                    if(isMeet1  && isMeet3){
                        salesOrder.setSalesPostFirm(strategy.getStrategyPostFirm());
                        return;
                    }
                }
            }
        }
        }
    }
    @Override
    public List<SalesOrderItem> listSalesOrderItem(SalesOrderItem salesOrderItem) {
        return salesOrderMapper.listSalesOrderItem(salesOrderItem);
    }

    @Override
    public Integer updateOrderList(JSONArray orderList, List<SalesOrder> list) {
        List<SalesOrder> salesOrders = new ArrayList<SalesOrder>();
        //订单号相同时，判断状态，发货状态，物流公司，物流单号等是否相同，如果有一个不同，则需添加到salesOrders中进行同步
        for (int i = 0;i < orderList.size();i++) {
            JSONObject orderInfo = orderList.getJSONObject(i);
            for (SalesOrder salesOrder : list) {
                if (orderInfo.get("order_sn").equals(salesOrder.getSalesOrderId())
                        && !(orderInfo.getInt("order_status") == salesOrder.getSalesStatus()
                        && orderInfo.getInt("shipping_status") == salesOrder.getSalesShippingStatus()
                        && orderInfo.getInt("pay_status") == salesOrder.getSalesPayStatus()
                        && orderInfo.getInt("process_status") == salesOrder.getSalesProcessStatus()
                        && orderInfo.getInt("is_send") == salesOrder.getSalesIsSend()
                        && orderInfo.getInt("is_locked") == salesOrder.getSalesIsLocked()
                        && orderInfo.getInt("is_separate") == salesOrder.getSalesIsSeparate()
                        && orderInfo.getString("shipping_name").equals(salesOrder.getSalesPostFirm())
                        && orderInfo.getString("invoice_no").equals(salesOrder.getSalesPostNum())
                )) {
                    SalesOrder order = new SalesOrder();
                    order.setSalesId(salesOrder.getSalesId());
                    order.setSalesStatus(orderInfo.getInt("order_status"));
                    order.setSalesShippingStatus(orderInfo.getInt("shipping_status"));
                    order.setSalesPayStatus(orderInfo.getInt("pay_status"));
                    order.setSalesProcessStatus(orderInfo.getInt("process_status"));
                    order.setSalesIsSend(orderInfo.getInt("is_send"));
                    order.setSalesIsLocked(orderInfo.getInt("is_locked"));
                    order.setSalesIsSeparate(orderInfo.getInt("is_separate"));
                    order.setSalesPostFirm(orderInfo.getString("shipping_name"));
                    order.setSalesPostNum(orderInfo.getString("invoice_no"));
                    salesOrders.add(order);
                }
            }
        }
        if (salesOrders != null && salesOrders.size() > 0) {
            //批量修改订单状态等信息
            return salesOrderMapper.updateOrderList(salesOrders);
        } else {
            return 1;
        }
    }

    @Override
    public Integer updateReturnOrderList(JSONArray orderList, List<SalesOrder> list) {
        List<SalesOrder> salesOrders = new ArrayList<SalesOrder>();
        //订单号相同时，判断状态，发货状态，物流公司，物流单号等是否相同，如果有一个不同，则需添加到salesOrders中进行同步
        for (int i = 0;i < orderList.size();i++) {
            JSONObject orderInfo = orderList.getJSONObject(i);
            for (SalesOrder salesOrder : list) {
                if (orderInfo.get("relating_order_sn").equals(salesOrder.getSalesOrderId())) {
                    SalesOrder order = new SalesOrder();
                    switch (orderInfo.getInt("process_type")) {
                        case 1://退货
                            order.setSalesOrderStatus(3);
                            break;
                        case 4://换货
                            order.setSalesOrderStatus(2);
                            break;
                        default:
                            order.setSalesOrderStatus(3);
                            break;
                    }
                    order.setSalesId(salesOrder.getSalesId());
                    salesOrders.add(order);
                }
            }
        }
        //批量修改订单状态等信息
        return salesOrderMapper.updateOrderList(list);
    }

    @Override
    public void addSalesOrderList(JSONObject obj) throws Exception{
        if (obj == null) {
            return;
        }
        JSONArray orderList = obj.getJSONArray("list");
        if (orderList == null || orderList.size() == 0) {
            return;
        }

        String endTime = sysConfigMapper.getSysConfig(1);

        for (int i = 0;i < orderList.size();i++) {
            JSONObject order = orderList.getJSONObject(i);
            //获取订单详情
            JSONObject orderInfo = null;
            try{
                orderInfo = efastOrderService.getOrderFormEfast(order.getString("deal_code"));
            }catch (Exception e){
                logger.info("获取订单失败；异常编号：505;失败原因："+ e.getMessage() +"--获取失败订单号：" + orderList.getJSONObject(i).getString("deal_code"));
            }
            if (orderInfo == null) {
                continue;
            }
            if (!orderInfo.has("orders")) {
                continue;
            }
            //获取订单项集合
            JSONArray itemArray = orderInfo.getJSONArray("orders");
            if (itemArray == null || itemArray.size() == 0) {
                continue;
            }
            SalesOrder salesOrder = new SalesOrder();
            salesOrder.setSalesOrderId(order.getString("order_sn"));//订单编号
            salesOrder.setSalesDealCode(order.getString("deal_code"));//交易号
            salesOrder.setSalesOrderStatus(1);//订单状态
            salesOrder.setSalesShippingStatus(order.getInt("shipping_status"));//发货状态 0：未发货，1：已发货，3：备货中
            salesOrder.setSalesPayStatus(order.getInt("pay_status"));//是否付款 0：未付款，2：已付款
            salesOrder.setSalesProcessStatus(order.getInt("process_status"));//单据状态
            salesOrder.setSalesIsSend(order.getInt("is_send"));//是否通知配货
            salesOrder.setSalesIsLocked(order.getInt("is_locked"));//是否锁定
            salesOrder.setSalesIsSeparate(order.getInt("is_separate"));//是否缺货
            salesOrder.setSalesStatus(order.getInt("order_status"));//订单状态 0：未确认，1：已确认，2：挂起，3：作废
            salesOrder.setSalesPostFirm(order.getString("shipping_name").trim());//快递方式代码
            salesOrder.setSalesPostNum(order.getString("invoice_no").trim());//快递单号
            salesOrder.setSalesOpenId(order.getString("mobile").trim());//唯一标识
            salesOrder.setSalesPayType(efastOrderService.getPayType(order.getString("pay_name").trim()));//支付方式
            salesOrder.setSalesPayTime(new Date(order.getLong("pay_time")*1000));//支付时间
            salesOrder.setSalesUserRemark(order.getString("postscript"));//买家留言
            salesOrder.setSalesAdminRemark(order.getString("to_buyer"));//商家留言
            salesOrder.setSalesAmount((int)(order.getDouble("order_amount")*100));//应付款
            salesOrder.setSalesPayMoney((int)(order.getDouble("money_paid")*100));//已付款
            salesOrder.setSalesAddressName(order.getString("consignee").trim());//收货人
            String mobile = order.getString("mobile").replaceAll("[\\u00A0]+", "").trim();
            salesOrder.setSalesAddressTel(mobile);//收货人电话
            salesOrder.setSalesAddressInfo(order.getString("address").replaceAll(" ","-"));//收货地址
            salesOrder.setSalesShippingFee((int)(order.getDouble("shipping_fee")*100));//邮费
            salesOrder.setSalesCreateTime(DateTimeUtil.parse(order.getString("create_time"),"yyyy-MM-dd HH:mm:ss"));//创建时间
            if (order.getInt("shipping_status") == 1) {
                if(order.has("delivery_time")){
                    salesOrder.setSalesSendTime(DateTimeUtil.parse(order.getString("delivery_time"),"yyyy-MM-dd HH:mm:ss"));//发货时间
                }else{
                    salesOrder.setSalesSendTime(new Date());//发货时间
                }
            }
            salesOrder.setSalesDiscountMoney(salesOrder.getSalesAmount() - salesOrder.getSalesPayMoney());//优惠金额
            salesOrder.setSalesPledgeMoney(0);//押金金额
            salesOrder.setSalesRemainDeposit(0);//待提取金额
            salesOrder.setSalesSendType(2);//发货方式，默认为物流发货
            salesOrder.setSalesSalesTime(salesOrder.getSalesCreateTime());//订购时间
            salesOrder.setSalesWaitMoney(0);//待付金额
            salesOrder.setSalesLastMoney(salesOrder.getSalesPayMoney());//本次支付金额
            salesOrder.setSalesPayNumber("0000");//支付尾号
            salesOrder.setSalesType(1);//订单类型

            endTime = order.getString("create_time"); //获取

            //查询店铺信息
            StoreInfo storeInfo = new StoreInfo();
            storeInfo.setStoreEfast(order.getString("sd_id"));
            List<StoreInfo> storeList = storeInfoService.listStore(storeInfo);
            int storeId = 0;
            int companyId = 0;
            if (storeList != null && storeList.size() > 0) {
                storeInfo = storeList.get(0);
                storeId = storeInfo.getStoreId();
                companyId = storeInfo.getCompanyId();
            }
            salesOrder.setSalesStoreId(storeId);//店铺id
            salesOrder.setSalesCompanyId(companyId);//销售公司id
            List<SalesOrderItem> itemList = new ArrayList<SalesOrderItem>();
            for (int j = 0;j < itemArray.size();j++) {
                ProductColor color = new ProductColor();
                JSONObject itemJson = itemArray.getJSONObject(j);
                SalesOrderItem item = new SalesOrderItem();
                color.setColorBar(itemJson.getString("goods_sn"));
                List<ProductColor> colorList = productService.listproductAndColor(color);
                if (colorList != null && colorList.size() > 0) {
                    color = colorList.get(0);
                    item.setItemColorBar(itemJson.getString("goods_sn"));//商品69码
                    item.setItemNum(itemJson.getInt("goods_number"));//商品数量
                    item.setItemCreateTime(salesOrder.getSalesCreateTime());
                    item.setItemColorId(color.getColorId());
                    item.setItemProductColor(color.getColorName());
                    item.setItemProductDiscount(color.getColorDiscount());
                    item.setItemProductId(color.getColorProductId());
                    item.setItemProductName(color.getProductName());
                    item.setItemProductPic(color.getColorPicture());
                    item.setItemProductType(color.getProductType());
                    item.setItemProductPrice(color.getColorPrice());
                    item.setItemIsSource(1);
                    itemList.add(item);
                }
//                else {
//                    //获取配件信息
//                    FittingsInfo fittingsInfo = new FittingsInfo();
//                    fittingsInfo.setFittingsBar(itemJson.getString("goods_sn"));
//                    List<FittingsInfo> Fittings = fittingsInfoMapper.listFittings(fittingsInfo);
//                    if (Fittings == null || Fittings.size() == 0) {
//                        continue;
//                    }
//                    fittingsInfo = Fittings.get(0);
//                    item.setItemColorBar(itemJson.getString("goods_sn"));//商品69码
//                    item.setItemNum(itemJson.getInt("goods_number"));//商品数量
//                    item.setItemCreateTime(salesOrder.getSalesCreateTime());
//                    item.setItemColorId(fittingsInfo.getFittingsId());
//                    item.setItemProductColor(fittingsInfo.getFittingsName());
//                    item.setItemProductDiscount(fittingsInfo.getFittingsDiscount());
//                    item.setItemProductId(fittingsInfo.getProductId());
//                    item.setItemProductName(fittingsInfo.getFittingsName());
//                    item.setItemProductPic("");
//                    item.setItemProductType(0);
//                    item.setItemProductPrice(fittingsInfo.getFittingsPrice());
//                    item.setItemIsSource(2);
//                    itemList.add(item);
//                }
            }
            //添加订单和订单项
            try{
                salesOrderService.addOrderAndItem(salesOrder,itemList);
            }catch (Exception e){
                logger.info("添加订单失败，异常编号：505;失败原因：+"+ e.getMessage() +"Efast编号："+ salesOrder.getSalesOrderId());
            }
        }
        SysConfig sysConfig = new SysConfig(1,endTime);
        sysConfigMapper.updateSysConfig(sysConfig);
    }

    @Override
    @Transactional
    public boolean syncEfastOrder(JSONObject orderInfo) throws Exception {
        if (orderInfo == null) {
            throw  new RuntimeException("获取Efast订单信息出错！");
        }
        if (!orderInfo.has("orders")) {
            throw  new RuntimeException("获取Efast订单信息出错！");
        }
        //获取订单项集合
        JSONArray itemArray = orderInfo.getJSONArray("orders");
        if (itemArray == null || itemArray.size() == 0) {
            throw  new RuntimeException("获取Efast订单信息出错！");
        }

        SalesOrder salesOrder = new SalesOrder();
        salesOrder.setSalesOrderId(orderInfo.getString("order_sn"));//订单编号
        salesOrder.setSalesDealCode(orderInfo.getString("deal_code"));//交易号
        salesOrder.setSalesOrderStatus(1);//订单状态
        salesOrder.setSalesShippingStatus(orderInfo.getInt("shipping_status"));//发货状态 0：未发货，1：已发货，3：备货中
        salesOrder.setSalesPayStatus(orderInfo.getInt("pay_status"));//是否付款 0：未付款，2：已付款
        salesOrder.setSalesProcessStatus(orderInfo.getInt("process_status"));//单据状态
        salesOrder.setSalesIsSend(orderInfo.getInt("is_send"));//是否通知配货
        salesOrder.setSalesIsLocked(orderInfo.getInt("is_locked"));//是否锁定
        salesOrder.setSalesIsSeparate(orderInfo.getInt("is_separate"));//是否缺货
        salesOrder.setSalesStatus(orderInfo.getInt("order_status"));//订单状态 0：未确认，1：已确认，2：挂起，3：作废
        salesOrder.setSalesPostFirm(new String(orderInfo.getString("shipping_name")).trim());//快递方式代码
        salesOrder.setSalesPostNum(new String(orderInfo.getString("invoice_no")).trim());//快递单号
        salesOrder.setSalesOpenId(orderInfo.getString("mobile").trim());//唯一标识
        salesOrder.setSalesPayType(efastOrderService.getPayType(orderInfo.getString("pay_name").trim()));//支付方式
        salesOrder.setSalesPayTime(new Date(orderInfo.getLong("pay_time")*1000));//支付时间
        salesOrder.setSalesUserRemark(orderInfo.getString("postscript"));//买家留言
        salesOrder.setSalesAdminRemark(orderInfo.getString("to_buyer"));//商家留言
        salesOrder.setSalesAmount((int)(orderInfo.getDouble("order_amount")*100));//应付款
        salesOrder.setSalesPayMoney((int)(orderInfo.getDouble("money_paid")*100));//已付款
        salesOrder.setSalesAddressName(orderInfo.getString("consignee"));//收货人
        String mobile = orderInfo.getString("mobile").replaceAll("[\\u00A0]+", "");
        salesOrder.setSalesAddressTel(mobile.trim());//收货人电话
        salesOrder.setSalesAddressInfo(orderInfo.getString("address").replaceAll(" ","-"));//收货地址
        salesOrder.setSalesShippingFee((int)(orderInfo.getDouble("shipping_fee")*100));//邮费
        salesOrder.setSalesCreateTime(new Date(orderInfo.getLong("pay_time")*1000));//创建时间
        if (orderInfo.getInt("shipping_status") == 1) {
            if(orderInfo.has("delivery_time")){
                salesOrder.setSalesSendTime(DateTimeUtil.parse(orderInfo.getString("delivery_time"),"yyyy-MM-dd HH:mm:ss"));//发货时间
            }else{
                salesOrder.setSalesSendTime(new Date());//发货时间
            }
        }
        salesOrder.setSalesDiscountMoney(salesOrder.getSalesAmount() - salesOrder.getSalesPayMoney());//优惠金额
        salesOrder.setSalesPledgeMoney(0);//押金金额
        salesOrder.setSalesRemainDeposit(0);//待提取金额
        salesOrder.setSalesSendType(2);//发货方式，默认为物流发货
        salesOrder.setSalesSalesTime(salesOrder.getSalesCreateTime());//订购时间
        salesOrder.setSalesWaitMoney(0);//待付金额
        salesOrder.setSalesLastMoney(salesOrder.getSalesPayMoney());//本次支付金额
        salesOrder.setSalesPayNumber("0000");//支付尾号
        salesOrder.setSalesType(1);//订单类型
        //查询店铺信息
        StoreInfo storeInfo = new StoreInfo();
        if (orderInfo.has("sd_id")) {
            storeInfo.setStoreEfast(orderInfo.getString("sd_id"));
        } else {
            storeInfo.setStoreEfast("1");
        }

        List<StoreInfo> storeList = storeInfoService.listStore(storeInfo);
        int storeId = 0;
        int companyId = 0;
        if (storeList != null && storeList.size() > 0) {
            storeInfo = storeList.get(0);
            storeId = storeInfo.getStoreId();
            companyId = storeInfo.getCompanyId();
        }
        salesOrder.setSalesStoreId(storeId);//店铺id
        salesOrder.setSalesCompanyId(companyId);//销售公司id

        List<SalesOrderItem> itemList = new ArrayList<SalesOrderItem>();
        for (int j = 0;j < itemArray.size();j++) {
            ProductColor color = new ProductColor();
            JSONObject itemJson = itemArray.getJSONObject(j);
            SalesOrderItem item = new SalesOrderItem();
            color.setColorBar(itemJson.getString("goods_barcode"));
            List<ProductColor> colorList = productService.listproductAndColor(color);
            if (colorList != null && colorList.size() > 0) {
                color = colorList.get(0);
                item.setItemColorBar(itemJson.getString("goods_barcode"));//商品69码
                item.setItemNum(itemJson.getInt("goods_number"));//商品数量
                item.setItemCreateTime(salesOrder.getSalesCreateTime());
                item.setItemColorId(color.getColorId());
                item.setItemProductColor(color.getColorName());
                item.setItemProductDiscount(color.getColorDiscount());
                item.setItemProductId(color.getColorProductId());
                item.setItemProductName(color.getProductName());
                item.setItemProductPic(color.getColorPicture());
                item.setItemProductType(color.getProductType());
                item.setItemProductPrice(color.getColorPrice());
                item.setItemIsSource(1);
                itemList.add(item);
            }
//            else {
//                //获取配件信息
//                FittingsInfo fittingsInfo = new FittingsInfo();
//                fittingsInfo.setFittingsBar(itemJson.getString("goods_barcode"));
//                List<FittingsInfo> Fittings = fittingsInfoMapper.listFittings(fittingsInfo);
//                if (Fittings == null || Fittings.size() == 0) {
//                    continue;
//                }
//                fittingsInfo = Fittings.get(0);
//                item.setItemColorBar(itemJson.getString("goods_barcode"));//商品69码
//                item.setItemNum(itemJson.getInt("goods_number"));//商品数量
//                item.setItemCreateTime(salesOrder.getSalesCreateTime());
//                item.setItemColorId(fittingsInfo.getFittingsId());
//                item.setItemProductColor(fittingsInfo.getFittingsName());
//                item.setItemProductDiscount(fittingsInfo.getFittingsDiscount());
//                item.setItemProductId(fittingsInfo.getProductId());
//                item.setItemProductName(fittingsInfo.getFittingsName());
//                item.setItemProductPic("");
//                item.setItemProductType(0);
//                item.setItemProductPrice(fittingsInfo.getFittingsPrice());
//                item.setItemIsSource(2);
//                itemList.add(item);
//            }
        }
        boolean flag = salesOrderService.addOrderAndItem(salesOrder,itemList);
        if (flag) {
            return true;
        } else {
            throw  new RuntimeException("添加订单项出错！");
        }
    }

    @Override
    public Integer getOrderInfoCount(SalesOrder salesOrder) {
        return salesOrderMapper.getOrderInfoCount(salesOrder);
    }

    @Override
    public List<SalesOrder> listOrderExcel(SalesOrder salesOrder) {
        return salesOrderMapper.listOrderExcel(salesOrder);
    }

    @Override
    public Integer listOrderExcelNum(SalesOrder salesOrder) {
        return salesOrderMapper.listOrderExcelNum(salesOrder);
    }

    @Override
    public Integer delOrder(String orderId) {
        return salesOrderMapper.delOrder(orderId);
    }

    @Override
    @Transactional
    public Integer delSalesOrder(Integer id) {
        //查询出库状态判断是否需要返还库存
        SalesOrder so = salesOrderMapper.getSalesOrderById(id);
        if(so.getSalesDeliver() == 2){
            SalesOrderItem salesOrderItem = new SalesOrderItem();
            salesOrderItem.setItemOrderId(so.getSalesId());
            List<SalesOrderItem> listOrderitem = salesOrderService.listSalesOrderItem(salesOrderItem);
            for (SalesOrderItem soi:listOrderitem) {
                InventoryInfo inventoryInfo2 = new InventoryInfo();
                inventoryInfo2.setInventoryGoodProductNum(soi.getItemNum());    //良品数量
                inventoryInfo2.setInventoryProductBar(soi.getItemColorBar());
                inventoryInfo2.setWarehouseId(so.getSalesWarehouseId());
                inventoryInfo2.setLogType(1);   //类型1.采购 2.发货 3.次品
                inventoryInfo2.setQualityType(1);   //产品质量类型 1良品 2 不良品
                inventoryInfo2.setInventoryRecentRecord("删除订单返还库存-删除订单号:"+ so.getSalesDealCode());
                inventoryService.addInventory(inventoryInfo2);
            }
        }
        //判断是否绑定维修信息，并解除绑定
        if(so != null){
            //查询封装售后维修编号
            List<ComplaintDetectInfo> listDetect  = complaintDetectInfoMapper.listComplaintDetectBySalesId(so.getSalesOrderId());
            if(listDetect != null && listDetect.size() > 0){
                for (ComplaintDetectInfo info: listDetect){
                    ComplaintDetectInfo detectInfo = new ComplaintDetectInfo();
                    detectInfo.setDetectId(info.getDetectId());
                    detectInfo.setDetectPlaceorder(1);
                    detectInfo.setSalesOrderId("");
                    complaintDetectInfoMapper.updateDetectById(detectInfo);
                }
            }
        }

        // 检查客诉是否使用订单，如果有使用订单，无法删除
        salesOrderMapper.delOrderItem(id);
        salesOrderMapper.delSalesOrder(id);
        return 1;
    }
    @Override
    public Integer updateOrderItem(SalesOrderItem salesOrderItem) {
        return salesOrderMapper.updateOrderItem(salesOrderItem);
    }

    @Override
    public SalesOrder getSalesOrderByLogistics(SalesOrder salesOrder) {
        return salesOrderMapper.getSalesOrderByLogistics(salesOrder);
    }

    @Override
    public Integer updateOrderListIsDownload(List<SalesOrder> list) {
        return salesOrderMapper.updateOrderListIsDownload(list);
    }

    @Override
    public Integer updateSalesOrderByDealCode(SalesOrder salesOrder) {
        return salesOrderMapper.updateSalesOrderByDealCode(salesOrder);
    }

    @Override
    public List<LogisticsInfo> getLogisticsInfo(LogisticsInfo logisticsInfo) {
        return salesOrderMapper.getLogisticsInfo(logisticsInfo);
    }

    @Override
    public List<DownsingleRuleInfo> listDownsingleRule() {
        return salesOrderMapper.listDownsingleRule();
    }

    @Override
    public Integer getIsMachine(String colorBar) {
        return salesOrderMapper.getIsMachine(colorBar);
    }

    @Override
    public Integer getOrderBySalesDealCodeNum(String code) {
        return salesOrderMapper.getOrderBySalesDealCodeNum(code);
    }

    @Override
    public Integer listSalesOrderAndItemNum(SalesOrder salesOrder) {
        return salesOrderMapper.listSalesOrderAndItemNum(salesOrder);
    }

    @Override
    public List<SalesOrder> listSalesOrderAndItem(SalesOrder salesOrder) {
        return salesOrderMapper.listSalesOrderAndItem(salesOrder);
    }

    @Override
    public Integer getSalesOrderNum(SalesOrder salesOrder) {
        return salesOrderMapper.getSalesOrderNum(salesOrder);
    }


    @Transactional
    @Override
    public Integer listConfirmSalesOrderByBatch(String salesBatchId) {
        Integer flag = 0;
        SalesOrder salesOrder = new SalesOrder();
        salesOrder.setSalesBatchId(salesBatchId);
        List<SalesOrder> salesOrderList = salesOrderMapper.listSalesOrder(salesOrder);
        if(salesOrderList == null || salesOrderList.size() < 1){
            throw  new RuntimeException("查询订单失败！");
        }

        for (SalesOrder so:salesOrderList){
            flag = salesOrderService.confirmSalesOrder(so.getSalesId());
        }
        return flag;
    }

    @Override
    public Integer noticeDistribution(SalesOrder salesOrder,Integer adminId) {
        // 检查订单是否已经有了配送方式,如果没有不允许通知配货 -- 移到controller中自己添加
//        SalesOrder temp = salesOrderMapper.getSalesOrderById(salesOrder.getSalesId());
//        if (temp == null || temp.getSalesPostFirm() == null || temp.getSalesPostFirm().isEmpty()) {
//            return 0;
//        }
        int msg = salesOrderMapper.noticeDistribution(salesOrder);
        if(msg > 0){
            //添加操作跟踪信息
            OrderTracking orderTracking = new OrderTracking();
            orderTracking.setAdminId(adminId);
            orderTracking.setSalesDealCode(salesOrder.getSalesDealCode());
            orderTracking.setTrackingDesc("通知配货");
            salesOrderService.addTracking(orderTracking);
        }
        return msg;
    }

    @Transactional
    @Override
    public Integer confirmSalesOrder(Integer saleId) {
         /*
        *  查询订单
        *  查询订单项
        *  删除订单
        *  修改查询的订单状态
        *  添加订单
        */
        if(saleId == null ){
            throw  new RuntimeException("确认订单失败-订单id异常！");
        }

        SalesOrder salesOrder = salesOrderMapper.getSalesOrderById(saleId);
        if(salesOrder == null){
            throw  new RuntimeException("确认订单失败-订单异常！");
        }

        Integer flag = 0;
        SalesOrderItem salesOrderItem = new SalesOrderItem();
        salesOrderItem.setItemOrderId(salesOrder.getSalesId());
        List<SalesOrderItem> salesOrderItemList = salesOrderMapper.listSalesOrderItem(salesOrderItem);
        if(salesOrderItemList == null || salesOrderItemList.size()<1){
            throw  new RuntimeException("确认订单失败-查询订单项失败！");
        }
        salesOrder.setSalesOrderItemList(salesOrderItemList);

        flag = salesOrderMapper.delOrderById(salesOrder.getSalesId());
        if(flag < 1){
            throw  new RuntimeException("确认订单失败-删除订单失败！");
        }

        flag = salesOrderMapper.delOrderItem(salesOrder.getSalesId());
        if(flag < 1){
            throw  new RuntimeException("确认订单失败-删除订单项失败！");
        }

        //1：确认 状态
        salesOrder.setSalesStatus(1);
        boolean fl = salesOrderService.addRstOrderAndIteminfo(salesOrder);
        if(!fl){
            throw  new RuntimeException("确认订单失败-添加订单失败！");
        }
        return flag;
    }
    @Override
    public Integer distributionExpress(SalesOrder salesOrder) {
        return salesOrderMapper.distributionExpress(salesOrder);
    }
    @Override
    public Integer listSalesPostFirm(SalesOrder salesOrder,Integer adminId) {
        int msg = salesOrderMapper.listSalesPostFirm(salesOrder);
        if(msg > 0){
            List<SalesOrder> listOrder = salesOrderMapper.listSalesOrderByBatchId(salesOrder.getSalesBatchId());
            for(SalesOrder prder : listOrder){
                //添加操作跟踪信息
                OrderTracking orderTracking = new OrderTracking();
                orderTracking.setAdminId(adminId);
                orderTracking.setSalesDealCode(prder.getSalesDealCode());
                orderTracking.setTrackingDesc("分配快递方式（批次-"+ salesOrder.getSalesPostFirm() +"）");
                salesOrderService.addTracking(orderTracking);
            }
        }
        return msg;
    }

    @Override
    public Integer listSalesPostFirmByIds(SalesOrder salesOrder,Integer adminId) {
        int msg = salesOrderMapper.listSalesPostFirmByIds(salesOrder);
        if(msg > 0){
            List<SalesOrder> listOrder = salesOrderMapper.listSalesOrderBySalesIds(salesOrder);
            for(SalesOrder prder : listOrder) {
                //添加操作跟踪信息
                OrderTracking orderTracking = new OrderTracking();
                orderTracking.setAdminId(adminId);
                orderTracking.setSalesDealCode(prder.getSalesDealCode());
                orderTracking.setTrackingDesc("分配物流方式（单个-"+prder.getSalesPostFirm()+")");
                salesOrderService.addTracking(orderTracking);
            }
        }

        return msg;
    }

    @Override
    @Transactional
    public SalesOrder getSalesOrderByPostNum(String postNum) {
        return salesOrderMapper.getSalesOrderByPostNum(postNum);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class}, isolation = Isolation.REPEATABLE_READ)
    public synchronized Integer updateDeliver(SalesOrder salesOrder) {
        //修改出库状态
        int flag = salesOrderMapper.updateDeliver(salesOrder);
        if(flag < 1){
            throw new RuntimeException("操作失败,订单出/入库失败，请联系技术人员核查。");
        }
        SalesOrder temp = salesOrderMapper.getSalesOrderById(salesOrder.getSalesId());
        if (temp.getSalesQuality() == 2) {
            // 指定发良品

        } else if (temp.getSalesQuality() == 3) {
            // 指定发不良品
        } else {
            // 系统自动判断
        }
        // 是否原机退回
        boolean isMachineRetuen = false;
        if (temp.getSalesQuality() == 1) {
            ComplaintDetectInfo complaintDetectInfo = new ComplaintDetectInfo();
            complaintDetectInfo.setSalesOrderId(salesOrder.getSalesOrderId());
            List<ComplaintDetectInfo> complaintDetectInfoList = complaintDetectInfoMapper.listComplaintDetectByOrderId(complaintDetectInfo);
            if(complaintDetectInfoList != null && complaintDetectInfoList.size() > 0) {
                ComplaintDetectInfo cdinfo = complaintDetectInfoList.get(0);
                int state = cdinfo.getDetectState();
                if (state == 33 || state == 39) {
                    isMachineRetuen = true;
                }
            }
            if (isMachineRetuen) {
                // 减去售后仓库不良品
                ComplaintDetectInfo cdinfo = complaintDetectInfoList.get(0);
                InventoryInfo inventoryInfo1 = new InventoryInfo();
                inventoryInfo1.setInventoryDefectiveProductNum(1);
                inventoryInfo1.setInventoryProductColorId(cdinfo.getProductColorId());
                inventoryInfo1.setWarehouseId(salesOrder.getSalesWarehouseId());
                // 产品质量类型 1良品 2 不良品
                inventoryInfo1.setQualityType(2);
                inventoryInfo1.setInventoryRecentRecord("维修机器-原机返回(维修ID:" + cdinfo.getDetectNumber() + ")");
                flag = inventoryService.minusInventory(inventoryInfo1);
                if (flag < 1) {
                    throw new RuntimeException("出库失败。维修库存调整失败");
                }
                return flag;
            }
        }

        // 正常库存出库（包含正常销售与售后）
        SalesOrder so = salesOrderMapper.getSalesOrderById(salesOrder.getSalesId());
        SalesOrderItem salesOrderItem = new SalesOrderItem();
        salesOrderItem.setItemOrderId(so.getSalesId());
        List<SalesOrderItem> listOrderitem = salesOrderService.listSalesOrderItem(salesOrderItem);
        // 查询维修编号,并根据维修编号对应的处理结果判断是否从不良品中出库
        boolean isDefectiveProduct = false;
        if (temp.getSalesQuality() == 1) {
            // 凡是（付费维修-维修完成）、（免费维修-维修完成）、（机器无故障，原机退回）都走不良品
            List<ComplaintDetectInfo> listDetect  = complaintDetectInfoMapper.listComplaintDetectBySalesId(so.getSalesOrderId());
            if (listDetect != null && !listDetect.isEmpty()) {
                int result = listDetect.get(0).getDetectState();
                if (result == 32 ||result == 33 || result == 36 || result == 37 || result == 39) {
                    isDefectiveProduct = true;
                }
            }
        } else if (temp.getSalesQuality() == 2) {
            // 良品
            isDefectiveProduct = false;
        } else if (temp.getSalesQuality() == 3) {
            // 不良品
            isDefectiveProduct = true;
        }
        if(salesOrder.getSalesDeliver() == 2){
            // 标记出库，修改库存
            // 如果已出库则返还库存
            for (SalesOrderItem soi:listOrderitem) {
                InventoryInfo inventoryInfo2 = new InventoryInfo();
                inventoryInfo2.setInventoryProductBar(soi.getItemColorBar());
                inventoryInfo2.setWarehouseId(so.getSalesWarehouseId());
                //类型1.采购 2.发货 3.次品
                inventoryInfo2.setLogType(2);
                //产品质量类型 1良品 2 不良品
                if (isDefectiveProduct) {
                    inventoryInfo2.setInventoryDefectiveProductNum(soi.getItemNum());
                    inventoryInfo2.setQualityType(2);
                } else {
                    inventoryInfo2.setInventoryGoodProductNum(soi.getItemNum());
                    inventoryInfo2.setQualityType(1);
                }
                inventoryInfo2.setInventoryRecentRecord("出库-订单号:"+ so.getSalesDealCode());
                inventoryService.minusInventory(inventoryInfo2);
            }
        }
        return flag;
    }

    //减少库存
//    @Transactional
//    @Override
//    public boolean updateInventory(Integer salesId,Integer salesWarehouseId){
//        OrderWarehouse orderWarehouse = orderWarehouseService.getOrderWarehouseById(salesWarehouseId);
//        if(orderWarehouse == null){
//            throw new RuntimeException("【出库】更新库存失败，查询仓库信息失败。");
//        }
//        String warehouseName = orderWarehouse.getWarehouseName();
//
//        SalesOrderItem salesOrderItem = new SalesOrderItem();
//        salesOrderItem.setItemOrderId(salesId);
//        List<SalesOrderItem> listOrderitem = salesOrderService.listSalesOrderItem(salesOrderItem);
//
//        for(SalesOrderItem item : listOrderitem){
//            List<ProductCombinatInfo> listproduct = productMapper.combinatList(item.getItemProductId());
//            if(listproduct.size() > 0){
//                for(ProductCombinatInfo combinatInfo : listproduct){
//                    invIne(item,orderWarehouse,combinatInfo);
//                }
//            }else{
//                invIne(item,orderWarehouse,null);
//            }
//
//        }
//        return true;
//    }

//    public void invIne(SalesOrderItem item,OrderWarehouse orderWarehouse,ProductCombinatInfo combinatInfo){
//        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        Integer combinatItemNum;
//        if(combinatInfo == null ){
//            combinatItemNum = 1;
//        }else{
//            combinatItemNum = combinatInfo.getCombinatItemNum();
//            item.setItemColorBar(productService.getProduceColor(combinatInfo.getCombinatItemColorId()).getColorBar());
//        }
//        InventoryInfo infos = inventoryMapper.getByInventoryByBar(item.getItemColorBar(),orderWarehouse.getWarehouseId());
//        if(infos != null){
//            if(infos.getInventoryGoodProductNum() >= (item.getItemNum() * combinatItemNum)){
//                infos.setInventoryGoodProductNum(infos.getInventoryGoodProductNum() - (item.getItemNum() * combinatItemNum));
//                infos.setInventoryRecentRecord(sdf.format(new Date())+"出库"+item.getItemNum()+"件,订单号："+item.getSalesOrderId());
//                Integer flag =  inventoryMapper.updateById(infos);
//                if(flag < 1){
//                    throw new RuntimeException("【出库】更新库存失败，库存修改失败。");
//                }
//                //添加日志
//                InventoryLog inventoryLog = new InventoryLog();
//                inventoryLog.setLogProductName(infos.getInventoryProductName());
//                inventoryLog.setLogProductBar(infos.getInventoryProductBar());
//                inventoryLog.setLogRemainingNum(item.getItemNum() * combinatItemNum);
//                inventoryLog.setLogType(2);
//                inventoryLog.setLogOperationType(2);
//                inventoryLog.setLogDesc(sdf.format(new Date())+"待发货标记出库"+item.getItemNum()+"件,订单号："+item.getSalesOrderId());
//                inventoryLog.setLogQualityType(1);
//                inventoryLog.setLogWarehouseId(orderWarehouse.getWarehouseId());
//                flag = inventoryLogMapper.insert(inventoryLog);
//                if(flag < 1){
//                    throw new RuntimeException("【出库】更新库存失败，增加库存记录失败。");
//                }
//            }else{
//                throw new RuntimeException("【出库】更新库存失败，"+ orderWarehouse.getWarehouseName() +"["+ item.getItemProductName()+ "("+ item.getItemProductColor() +")" +"]库存不足。");
//            }
//        }else{
//            throw new RuntimeException("【出库】更新库存失败，未查询到库存信息，请确认“"+ orderWarehouse.getWarehouseName() +"”是否有该产品["+ item.getItemProductName()+ "("+ item.getItemProductColor() +")" +"]库存信息。");
//        }
//    }
    //标记未出库时返还库存
//    @Transactional
//    @Override
//    public boolean returnInventory(Integer salesId,Integer salesWarehouseId){
//        OrderWarehouse orderWarehouse = orderWarehouseService.getOrderWarehouseById(salesWarehouseId);
//        if(orderWarehouse == null){
//            throw new RuntimeException("【返还库存】更新库存失败，查询仓库信息失败。");
//        }
//        String warehouseName = orderWarehouse.getWarehouseName();
//
//        SalesOrderItem salesOrderItem = new SalesOrderItem();
//        salesOrderItem.setItemOrderId(salesId);
//        List<SalesOrderItem> listOrderitem = salesOrderService.listSalesOrderItem(salesOrderItem);
//        for(SalesOrderItem item : listOrderitem){
//            List<ProductCombinatInfo> listproduct = productMapper.combinatList(item.getItemProductId());
//            if(listOrderitem.size() > 0){
//                for(ProductCombinatInfo combinatInfo : listproduct){
//                    invTwo(item,orderWarehouse,combinatInfo);
//                }
//            }else{
//                invTwo(item,orderWarehouse,null);
//            }
//        }
//        return true;
//    }

//    private void invTwo(SalesOrderItem item,OrderWarehouse orderWarehouse,ProductCombinatInfo combinatInfo){
//        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        Integer combinatItemNum;
//        if(combinatInfo == null ){
//            combinatItemNum = 1;
//        }else{
//            combinatItemNum = combinatInfo.getCombinatItemNum();
//            item.setItemColorBar(productService.getProduceColor(combinatInfo.getCombinatItemColorId()).getColorBar());
//        }
//        InventoryInfo info = inventoryMapper.getByInventoryByBar(item.getItemColorBar(),orderWarehouse.getWarehouseId());
//        if(info != null){
//            info.setInventoryGoodProductNum(info.getInventoryGoodProductNum() + (item.getItemNum() * combinatItemNum));
//            info.setInventoryRecentRecord(sdf.format(new Date())+"删除/作废/标记未出库时订单返还库存"+(item.getItemNum() * combinatItemNum)+"件,订单号："+item.getSalesOrderId());
//            Integer flag = inventoryMapper.updateById(info);
//            if(flag < 1){
//                throw new RuntimeException("【返还库存】更新库存失败，库存修改失败。");
//            }
//            //添加日志
//            InventoryLog inventoryLog = new InventoryLog();
//            inventoryLog.setLogProductName(info.getInventoryProductName());
//            inventoryLog.setLogProductBar(info.getInventoryProductBar());
//            inventoryLog.setLogRemainingNum((item.getItemNum() * combinatItemNum));
//            inventoryLog.setLogType(1);
//            inventoryLog.setLogOperationType(1);
//            inventoryLog.setLogDesc(sdf.format(new Date())+"删除/作废/标记未出库时订单返还库存"+(item.getItemNum() * combinatItemNum)+"件,订单号："+item.getSalesOrderId());
//            inventoryLog.setLogQualityType(1);
//            inventoryLog.setLogWarehouseId(orderWarehouse.getWarehouseId());
//            flag = inventoryLogMapper.insert(inventoryLog);
//            if(flag < 1){
//                throw new RuntimeException("【返还库存】更新库存失败，增加库存记录失败。");
//            }
//        }else{
//            throw new RuntimeException("【返还库存】更新库存失败，未查询到库存信息，请确认“"+ orderWarehouse.getWarehouseName() +"”是否有该产品["+ item.getItemProductName()+ "("+ item.getItemProductColor() +")" +"]库存信息。");
//        }
//    }
    @Override
    public List<SalesOrderItem> getDeliverNum(SalesOrder salesOrder) {
        return salesOrderMapper.getDeliverNum(salesOrder);
    }

    @Override
    public List<Date> getNotSendDate() {
        return salesOrderMapper.getNotSendDate();
    }

    @Override
    public List<SalesOrder> salesOrderListAndItem(SalesOrder salesOrder) {
        return salesOrderMapper.salesOrderListAndItem(salesOrder);
    }

    @Override
    public PagedResult<SalesOrder> salesOrderListAndItemPage(int pageNO, int pageSize, SalesOrder salesOrder, boolean isTotalNum) {
        PageHelper.startPage(pageNO, pageSize, isTotalNum);
        List<SalesOrder> list =  salesOrderMapper.salesOrderListAndItem(salesOrder);
        return PageUtil.getPage(list);
    }

    @Override
    public List<SalesOrderItem> selectSalesOrderItemList(Integer salesId) {
        return salesOrderMapper.selectSalesOrderItemList(salesId);
    }

    @Transactional
    @Override
    public Boolean addCorrectInfo(OrderCorrectInfo orderCorrectInfo, String arrayItem, Admin admin) {
        //添加更新信息
        orderCorrectInfo.setAdminId(admin.getAdminId());
        if(salesOrderMapper.addCorrectInfo(orderCorrectInfo) < 1){
            throw  new RuntimeException("更正订单-订单异常！");
        }
        //封装订单项数据
        JSONArray jsonArray = JSONArray.fromObject(arrayItem);
        List salesOrderItemList = ((List)JSONArray.toCollection(jsonArray, SalesOrderItem.class));
        for(Object temp : salesOrderItemList){
            SalesOrderItem salesOrderItem = (SalesOrderItem) temp;
            //查询订单项原数量
            SalesOrderItem orderItem = salesOrderMapper.getSalesOrderItem(salesOrderItem.getItemId());
            OrderCorrectItem orderCorrectItem = new OrderCorrectItem();
            orderCorrectItem.setCorrectId(orderCorrectInfo.getCorrectId());
            orderCorrectItem.setOrderItemId(salesOrderItem.getItemId());
            orderCorrectItem.setItemProductColor(salesOrderItem.getItemProductColor());
            orderCorrectItem.setItemProductName(salesOrderItem.getItemProductName());
            orderCorrectItem.setCorrectNum(salesOrderItem.getItemNum());
            orderCorrectItem.setOldNum(orderItem.getItemNum());
            if(orderItem.getItemNum().intValue() != salesOrderItem.getItemNum().intValue()){
                //查询订单判断是否已出库
                SalesOrder so = salesOrderMapper.getSalesOrderById(orderCorrectInfo.getItemOrderId());
                if(so.getSalesDeliver() == 2){
                    //查询是否是组合产品
                    List<ProductCombinatInfo> listproduct = productMapper.combinatList(salesOrderItem.getItemProductId());
                    if(listproduct.size() > 0){
                        for(ProductCombinatInfo combinatInfo : listproduct){
                            correctInv(orderItem,salesOrderItem,so.getSalesWarehouseId(),combinatInfo);
                        }
                    }else{
                        correctInv(orderItem,salesOrderItem,so.getSalesWarehouseId(),null);
                    }


                }
                //修改订单项数量
                orderItem.setItemNum(salesOrderItem.getItemNum());
                if(salesOrderMapper.updateOrderItemById(orderItem) < 1){
                    throw  new RuntimeException("更正订单-修改订单项数量失败！");
                }
                if(salesOrderMapper.addCorrectItem(orderCorrectItem) < 1){
                    throw  new RuntimeException("更正订单-添加记录失败！");
                }
            }
        }
        return true;
    }

    private void correctInv(SalesOrderItem orderItem,SalesOrderItem salesOrderItem,Integer warehouseId,ProductCombinatInfo combinatInfo){
        //返还库存
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Integer combinatItemNum;
        if(combinatInfo == null ){
            combinatItemNum = 0;
        }else{
            combinatItemNum = combinatInfo.getCombinatItemNum();
            orderItem.setItemColorBar(productService.getProduceColor(combinatInfo.getCombinatItemColorId()).getColorBar());
        }
        InventoryInfo info = inventoryMapper.getByInventoryByBar(orderItem.getItemColorBar(),warehouseId);
        //添加日志
        InventoryLog inventoryLog = new InventoryLog();
        inventoryLog.setLogProductName(info.getInventoryProductName());
        inventoryLog.setLogProductBar(info.getInventoryProductBar());
        inventoryLog.setLogOperationType(1);
        inventoryLog.setLogQualityType(1);
        inventoryLog.setLogWarehouseId(warehouseId);
        if(orderItem.getItemNum() > salesOrderItem.getItemNum()){//原数量大于更正后数量

            info.setInventoryGoodProductNum(info.getInventoryGoodProductNum() + ((orderItem.getItemNum()  * combinatItemNum) - (salesOrderItem.getItemNum()  * combinatItemNum)));
            info.setInventoryRecentRecord(sdf.format(new Date())+"更正订单返还库存："+(orderItem.getItemNum() - salesOrderItem.getItemNum())+"件");
            inventoryLog.setLogRemainingNum((orderItem.getItemNum()  * combinatItemNum) - (salesOrderItem.getItemNum() * combinatItemNum));
            inventoryLog.setLogType(2);
            inventoryLog.setLogDesc(sdf.format(new Date())+"更正订单返还库存："+(orderItem.getItemNum() - salesOrderItem.getItemNum())+"件");
        }else if(orderItem.getItemNum() < salesOrderItem.getItemNum()){

            if(info.getInventoryGoodProductNum() > ((salesOrderItem.getItemNum()  * combinatItemNum) - (orderItem.getItemNum() * combinatItemNum))){
                info.setInventoryGoodProductNum(info.getInventoryGoodProductNum() - ((salesOrderItem.getItemNum() * combinatItemNum) - (orderItem.getItemNum() * combinatItemNum)));
                info.setInventoryRecentRecord(sdf.format(new Date())+"更正订单减少库存："+((salesOrderItem.getItemNum() * combinatItemNum) - (orderItem.getItemNum() * combinatItemNum))+"件");
                inventoryLog.setLogRemainingNum(((salesOrderItem.getItemNum() * combinatItemNum) - (orderItem.getItemNum() * combinatItemNum)));
                inventoryLog.setLogType(1);
                inventoryLog.setLogDesc(sdf.format(new Date())+"更正订单减少库存："+((salesOrderItem.getItemNum() * combinatItemNum) - (orderItem.getItemNum() * combinatItemNum))+"件");
            }else{
                throw  new RuntimeException("更正订单-减少库存修改订单项数量失败！");
            }

        }
        inventoryMapper.updateById(info);
        inventoryLogMapper.insert(inventoryLog);
    }
    //更正订单时返还库存
    public boolean returnInventoryByItemId(Integer itemId){
        SalesOrderItem salesOrderItem = new SalesOrderItem();
        salesOrderItem.setItemId(itemId);
        List<SalesOrderItem> listOrderitem = salesOrderService.listSalesOrderItem(salesOrderItem);
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        for(SalesOrderItem item : listOrderitem){
            SalesOrder so = salesOrderMapper.getSalesOrderById(item.getItemOrderId());
            InventoryInfo info = inventoryMapper.getByInventoryByBar(item.getItemColorBar(),so.getSalesWarehouseId());
            if(info != null){
                info.setInventoryGoodProductNum(info.getInventoryGoodProductNum() + item.getItemNum());
                info.setInventoryRecentRecord(sdf.format(new Date())+"删除/作废订单返还库存："+item.getItemNum()+"件");
                inventoryMapper.updateById(info);
                //添加日志
                InventoryLog inventoryLog = new InventoryLog();
                inventoryLog.setLogProductName(info.getInventoryProductName());
                inventoryLog.setLogProductBar(info.getInventoryProductBar());
                inventoryLog.setLogRemainingNum(item.getItemNum());
                inventoryLog.setLogType(1);
                inventoryLog.setLogOperationType(1);
                inventoryLog.setLogDesc(sdf.format(new Date())+"删除/作废订单返还库存："+item.getItemNum()+"件");
                inventoryLog.setLogQualityType(1);
                inventoryLog.setLogWarehouseId(1);
                inventoryLogMapper.insert(inventoryLog);
            }

        }
        return true;
    }

    @Override
    public Integer addCorrectItem(OrderCorrectItem orderCorrectItem) {
        return salesOrderMapper.addCorrectItem(orderCorrectItem);
    }

    @Override
    public OrderCorrectInfo getOrderCorrectInfo(Integer correctId) {
        return salesOrderMapper.getOrderCorrectInfo(correctId);
    }

    @Override
    public List<OrderCorrectItem> listOrderCorrectItem(Integer correctId) {
        return salesOrderMapper.listOrderCorrectItem(correctId);
    }

    @Override
    public SalesOrderItem getSalesOrderItem(Integer itemId) {
        return salesOrderMapper.getSalesOrderItem(itemId);
    }

    @Override
    public Integer updateOrderItemById(SalesOrderItem salesOrderItem) {
        return salesOrderMapper.updateOrderItemById(salesOrderItem);
    }

    @Override
    public List<OrderCorrectInfo> listOrderCorrectInfo(Integer orderId) {
        return salesOrderMapper.listOrderCorrectInfo(orderId);
    }

    @Override
    public OrderWarehouse selectAdminWarehouse(Integer adminId) {
        return salesOrderMapper.selectAdminWarehouse(adminId);
    }

    @Override
    public List<OrderWarehouse> listOrderWarehouse() {
        return salesOrderMapper.listOrderWarehouse();
    }

    @Transactional
    @Override
    public List<SalesOrder> salesOrderAndItemStat(SalesOrder salesOrder) {
        return salesOrderMapper.salesOrderAndItemStat(salesOrder);
    }

    @Transactional
    @Override
    public Integer splitOrder(String mainOrderId, List<SalesOrder> salesOrderList,Integer adminId) {
        /**
         * 1.查询以前的所有订单
         * 2.通过比对，余下删除的订单集合orderList
         * 3.给订单项赋值，并且删除该订单的订单项，新增订单项
         * 4.删除orderList
         */

        Integer flag = 0;
        String salesCode = "";

        SalesOrder mainOrder = new SalesOrder();
        mainOrder.setSalesDealCode(mainOrderId);
        List<SalesOrder> orderList = salesOrderService.salesOrderListAndItem(mainOrder);
        salesCode = orderList.get(0).getSalesDealCode();

        SalesOrder or = new SalesOrder();
        or.setSalesMainOrderId(orderList.get(0).getSalesId());
        //该订单为主订单
        List<SalesOrder> sonSalesOrderList = salesOrderService.salesOrderListAndItem(or);
        orderList.addAll(sonSalesOrderList);

        for (SalesOrder salesOrder:salesOrderList) {
            //orderList还有的订单，最后做删除
            for (int j=0;j<orderList.size();j++){
                if(salesOrder.getSalesDealCode().equals(orderList.get(j).getSalesDealCode())){
                    orderList.remove(j);
                }
            }
            //以前的订单并且已发货之后无法做任何操作
            if(salesOrder.getSalesId() != null && salesOrder.getSalesShippingStatus() > 0){
                continue;
            }
            //订单项赋值
            for (SalesOrderItem itemSaleItem:salesOrder.getSalesOrderItemList()) {
                ProductColor productColor = productMapper.getProductBySku(itemSaleItem.getItemColorBar());
                itemSaleItem.setItemProductId(productColor.getColorProductId());
                itemSaleItem.setItemProductColor(productColor.getColorName());
                itemSaleItem.setColorAbbreviation(productColor.getColorAbbreviation());
                itemSaleItem.setProductAbbreviation(productColor.getColorAbbreviation());
                itemSaleItem.setItemIsSource(1);
                //itemSaleItem.setItemProductDiscount(productColor.getColorDiscount());
                itemSaleItem.setItemProductPrice(itemSaleItem.getItemProductDiscount());
                itemSaleItem.setItemProductPic(productColor.getColorPicture());
                itemSaleItem.setItemProductName(productColor.getProductName());
                itemSaleItem.setItemProductType(productColor.getProductType());
                itemSaleItem.setItemColorId(productColor.getColorId());
                 /*查询成本*/
                SupplierProduct supplierProduct = supplierProductMapper.getSupplierProductByColorId(itemSaleItem.getItemColorId());
                if(supplierProduct != null){
                    itemSaleItem.setItemCost(supplierProduct.getSpCost());
                    itemSaleItem.setItemCostTotal(supplierProduct.getSpCost() * itemSaleItem.getItemNum());
                }else{
                    throw  new RuntimeException("确认订单失败-未查询到该产品（"+ itemSaleItem.getItemProductName() +"-"+ itemSaleItem.getItemProductColor() +"）的成本价格");
                }

                if(salesOrder.getSalesId() != null){
                    itemSaleItem.setItemOrderId(salesOrder.getSalesId());
                }
            }

            Integer salesId = salesOrder.getSalesId();
            if(salesId == null){
                //添加订单和订单项
                salesOrderService.addOrderAndIteminfo(salesOrder,salesOrder.getSalesOrderItemList());

                //添加操作跟踪信息
                OrderTracking orderTracking = new OrderTracking();
                orderTracking.setAdminId(adminId);
                orderTracking.setSalesDealCode(salesOrder.getSalesDealCode());
                orderTracking.setTrackingDesc("拆分订单（由："+salesCode+"拆分出来）");
                salesOrderService.addTracking(orderTracking);
            }else{
                //其余全部做修改，删除订单项，添加新的订单项
                 flag = salesOrderMapper.delOrderItem(salesOrder.getSalesId());
                if(flag < 1){
                    throw new RuntimeException("删除订单项失败，订单交易号："+salesOrder.getSalesDealCode());
                }

                calculationTotal(null,salesOrder.getSalesOrderItemList());
                flag = salesOrderMapper.addOrderItemList(salesOrder.getSalesOrderItemList());
                if(flag < 1){
                    throw new RuntimeException("添加订单项失败，订单交易号："+salesOrder.getSalesDealCode());
                }
                this.cacheOrderItem(salesOrder.getSalesId());

                //添加操作跟踪信息
                OrderTracking orderTracking = new OrderTracking();
                orderTracking.setAdminId(adminId);
                orderTracking.setSalesDealCode(salesOrder.getSalesDealCode());
                orderTracking.setTrackingDesc("拆分订单");
                salesOrderService.addTracking(orderTracking);
            }
        }

        for (SalesOrder soDelete:orderList) {
            flag = salesOrderService.delSalesOrder(soDelete.getSalesId());
            if(flag < 1){
                throw new RuntimeException("删除订单失败，删除订单交易号："+soDelete.getSalesDealCode());
            }

            //添加操作跟踪信息 - 删除操作
            OrderTracking orderTracking = new OrderTracking();
            orderTracking.setAdminId(adminId);
            orderTracking.setSalesDealCode(orderTracking.getSalesDealCode());
            orderTracking.setTrackingDesc("拆分订单（删除处理");
            salesOrderService.addTracking(orderTracking);
        }
        return flag;
    }

    @Override
    public AfterrulesInfo getAfterrulesInfo(Integer storeId) {
        return salesOrderMapper.getAfterrulesInfo(storeId);
    }

    @Override
    public Integer updateOrderItemReturnNum(SalesOrderItem salesOrderItem) {
        return salesOrderMapper.updateOrderItemReturnNum(salesOrderItem);
    }

    @Override
    public List<SmsSignatureInfo> listSmsSignatureInfo(SmsSignatureInfo smsSignatureInfo) {
        return salesOrderMapper.listSmsSignatureInfo(smsSignatureInfo);
    }

    @Override
    public List<SmsTemplateInfo> listSmsTemplateInfo(SmsTemplateInfo smsTemplateInfo) {
        return salesOrderMapper.listSmsTemplateInfo(smsTemplateInfo);
    }

    @Override
    public SalesOrder getStatusNum(SalesOrder salesOrder) {
        return salesOrderMapper.getStatusNum(salesOrder);
    }

    @Override
    public SalesOrder getSalesOrderByOrderId(String salesOrderId) {
        return salesOrderMapper.getSalesOrderByOrderId(salesOrderId);
    }

    @Override
    public Integer updateOrderItemObj(SalesOrderItem salesOrderItem) {
        return salesOrderMapper.updateOrderItemObj(salesOrderItem);
    }

    @Override
    public Integer updateSalesOrderBySalesPostNum(SalesOrder salesOrder) {
        return salesOrderMapper.updateSalesOrderBySalesPostNum(salesOrder);
    }

    @Override
    public List<SalesOrder> listSalesOrderByAddr(SalesOrder salesOrder) {
        return salesOrderMapper.listSalesOrderByAddr(salesOrder);
    }

    @Override
    public List<SalesOrder> listSublistCount(Integer salesId) {
        return salesOrderMapper.listSublistCount(salesId);
    }

    @Override
    public List<LogisticsInfo> dayDeliveryNum(LogisticsInfo logisticsInfo) {
        return salesOrderMapper.dayDeliveryNum(logisticsInfo);
    }

    @Override
    public Integer addCargoInfo(CargoInfo cargoInfo) {
        return salesOrderMapper.addCargoInfo(cargoInfo);
    }

    @Override
    public CargoInfo getCargoInfo(CargoInfo cargoInfo) {
        return salesOrderMapper.getCargoInfo(cargoInfo);
    }

    @Override
    public Integer updateCargoInfo(CargoInfo cargoInfo) {
        return salesOrderMapper.updateCargoInfo(cargoInfo);
    }

    @Override
    public List<OrderStatisticsInfo> listDistributionNum(OrderStatisticsInfo orderStatisticsInfo) {
        return salesOrderMapper.listDistributionNum(orderStatisticsInfo);
    }

    @Override
    public List<OrderStatisticsInfo> listSendNum(OrderStatisticsInfo orderStatisticsInfo) {
        return salesOrderMapper.listSendNum(orderStatisticsInfo);
    }

    @Override
    public List<CargoInfo> listCargoInfo(CargoInfo cargoInfo) {
        return salesOrderMapper.listCargoInfo(cargoInfo);
    }

    @Override
    public List<OrderStatisticsInfo> listPlaySingleNum(OrderStatisticsInfo orderStatisticsInfo) {
        return salesOrderMapper.listPlaySingleNum(orderStatisticsInfo);
    }

    @Override
    public List<OrderStatisticsInfo> listOutboundNum(OrderStatisticsInfo orderStatisticsInfo) {
        return salesOrderMapper.listOutboundNum(orderStatisticsInfo);
    }

    @Override
    public List<OrderStatisticsInfo> listDistributionInvalidNum(OrderStatisticsInfo orderStatisticsInfo) {
        return salesOrderMapper.listDistributionInvalidNum(orderStatisticsInfo);
    }

    @Override
    public List<OrderStatisticsInfo> listSendInvalidNum(OrderStatisticsInfo orderStatisticsInfo) {
        return salesOrderMapper.listSendInvalidNum(orderStatisticsInfo);
    }

    @Override
    public List<OrderStatisticsInfo> listDeliveryLogisticsNum(OrderStatisticsInfo orderStatisticsInfo) {
        return salesOrderMapper.listDeliveryLogisticsNum(orderStatisticsInfo);
    }

    @Override
    public List<SalesOrder> orderAfterCaseDate() {
        return salesOrderMapper.orderAfterCaseDate();
    }

    @Override
    public List<OrderStatisticsInfo> getPickingOrders(OrderStatisticsInfo orderStatisticsInfo) {
        return salesOrderMapper.getPickingOrders(orderStatisticsInfo);
    }

    @Override
    public List<OrderStatisticsInfo> getCheckOrders(OrderStatisticsInfo orderStatisticsInfo) {
        return salesOrderMapper.getCheckOrders(orderStatisticsInfo);
    }

    @Override
    public Integer addTracking(OrderTracking orderTracking) {
        return salesOrderMapper.addTracking(orderTracking);
    }

    @Override
    public List<OrderTracking> listTracking(String salesDealCode) {
        return salesOrderMapper.listTracking(salesDealCode);
    }

    @Override
    public List<SalesOrder> listUpdateOrderShippingStatus() {
        return salesOrderMapper.listUpdateOrderShippingStatus();
    }

    @Override
    public Integer updateSalesOrderShippingStatus(SalesOrder salesOrder) {
        return salesOrderMapper.updateSalesOrderShippingStatus(salesOrder);
    }

    @Override
    public Integer addStrategyProduct(StrategyProduct strategyProduct) {
        return salesOrderMapper.addStrategyProduct(strategyProduct);
    }

    @Override
    public Integer addStrategyColor(StrategyColor strategyColor) {
        return salesOrderMapper.addStrategyColor(strategyColor);
    }

    @Override
    public Integer addStrategyStore(StrategyStore strategyStore) {
        return salesOrderMapper.addStrategyStore(strategyStore);
    }

    @Override
    public List<StrategyProduct> selectStrategyProduct(Integer strategyId) {
        return salesOrderMapper.selectStrategyProduct(strategyId);
    }

    @Override
    public List<StrategyColor> selectStrategyColor(Integer strategyId) {
        return salesOrderMapper.selectStrategyColor(strategyId);
    }

    @Override
    public List<StrategyStore> selectStrategyStore(Integer strategyId) {
        return salesOrderMapper.selectStrategyStore(strategyId);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class}, isolation = Isolation.REPEATABLE_READ)
    public int printOrder(List<SalesOrder> list, Integer currAdmin) {
        // 修改订单状态
        list.forEach(o -> {
            o.setSalesShippingStatus(1);
            o.setSalesSendTime(new Date());
            o.setSalesOldOrderStatus(11);
            // 修改订单状态
            if (salesOrderMapper.updateSalesOrder(o) <= 0) {
                throw new RuntimeException("订单" + o.getSalesId() + "发货失败，请查询订单状态");
            }
            // 小亚通订单，调用接口发货
            if (!orderSyncLogService.syncXYTOrderShip(new Integer[]{o.getSalesId()})) {
                throw new RuntimeException("订单" + o.getSalesId() + "向小亚通发货失败，请查询订单状态");
            }
            // 添加订单追踪信息
            OrderTracking orderTracking = new OrderTracking();
            orderTracking.setAdminId(currAdmin);
            orderTracking.setSalesDealCode(o.getSalesDealCode());
            orderTracking.setTrackingDesc("打印订单");
            salesOrderService.addTracking(orderTracking);
        });
        return list.size();
    }

    @Override
    public List<SalesOrder> testListSalesOrder() {
        List<SalesOrder> orders = salesOrderMapper.testListSalesOrder();
        /*for (SalesOrder order : orders) {
            SalesOrderItem item = new SalesOrderItem();
            item.setItemOrderId(order.getSalesId());
            order.setSalesOrderItemList(salesOrderMapper.listSalesOrderItem(item));
        }*/
        return orders;
    }

    @Override
    public List<SalesOrder> testListOther(SalesOrder data) {
        List<SalesOrder> orders = salesOrderMapper.testListOther(data);
        for (SalesOrder order : orders) {
            SalesOrderItem item = new SalesOrderItem();
            item.setItemOrderId(order.getSalesId());
            order.setSalesOrderItemList(salesOrderMapper.listSalesOrderItem(item));
        }
        return orders;
    }

    /***
     * 计算金额
     * @param salesOrder
     * @param salesOrderItemList
     */
    public void calculationTotal(SalesOrder salesOrder,List<SalesOrderItem> salesOrderItemList){
        Integer salesAmount=0,salesPayMoney=0;

        for (SalesOrderItem soi:salesOrderItemList) {
            if(soi.getItemTotal() == null || soi.getItemTotal() == 0){
                soi.setItemTotal(soi.getItemNum() * soi.getItemProductDiscount());
            }
            salesAmount += (soi.getItemNum() * soi.getItemProductPrice());
            salesPayMoney += soi.getItemTotal();
        }

        if(salesOrder != null){
            salesOrder.setSalesAmount(salesAmount);
            salesOrder.setSalesPayMoney(salesPayMoney);
        }
    }

}