package com.iamberry.rst.service.cm; import com.doudian.open.api.order_logisticsAdd.OrderLogisticsAddRequest; import com.doudian.open.api.order_logisticsAdd.OrderLogisticsAddResponse; import com.doudian.open.api.order_logisticsAdd.param.OrderLogisticsAddParam; import com.doudian.open.core.AccessTokenBuilder; import com.github.pagehelper.PageHelper; import com.iamberry.app.tool.util.AES; 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.*; import com.iamberry.rst.faces.product.ProductService; import com.iamberry.rst.faces.sys.SysConfigService; 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.DouyinConfig; import com.iamberry.rst.util.PageUtil; import com.iamberry.rst.util.TaobaoConfig; import com.iamberry.wechat.tools.DateTimeUtil; import com.iamberry.wechat.tools.HttpClient431Util; import com.iamberry.wechat.tools.payUtil.StringUtil; import com.jd.open.api.sdk.JdException; import com.jd.open.api.sdk.domain.order.OrderShipmentService.response.shipment.OperatorResult; import com.taobao.api.ApiException; import com.taobao.api.DefaultTaobaoClient; import com.taobao.api.TaobaoClient; import com.taobao.api.request.AlibabaAscpLogisticsOfflineSendRequest; import com.taobao.api.response.AlibabaAscpLogisticsOfflineSendResponse; 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.dao.DuplicateKeyException; 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(SalesOrderServiceImpl.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; @Autowired private SysConfigService sysConfigService; @Autowired private LogisticsInfoService logisticsInfoService; private static String jdOrderDomain = "http://jd-order.iamberry.com:8088/watero"; /** * 缓存订单项的前缀 */ public static String CACHE_ORDER_ITEM_NAME = null; static { Map 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(rollbackFor = {Exception.class}, isolation = Isolation.REPEATABLE_READ) public int addOrder(SalesOrder salesOrder, String desr) { // 2019年12月27日15:49:16新增快递策略 分配物流方式 List listS = new ArrayList<>(); listS.add(salesOrder); setStrategyLogistics(listS); try { salesOrderMapper.addSalesOrder(salesOrder); for (SalesOrderItem item : salesOrder.getSalesOrderItemList()) { item.setItemOrderId(salesOrder.getSalesId()); } salesOrderMapper.addOrderItemList(salesOrder.getSalesOrderItemList()); //添加操作跟踪记录 OrderTracking orderTracking = new OrderTracking(); //默认用户爱贝源自动拉取订单 orderTracking.setAdminId(10135); orderTracking.setSalesDealCode(salesOrder.getSalesDealCode()); orderTracking.setTrackingDesc(desr); salesOrderService.addTracking(orderTracking); } catch (DuplicateKeyException e) { // 修改 logger.error("【淘宝订单】订单存在，无法添加"); return 1; } return 1; } @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 getSalesOrderListConcise(SalesOrder salesOrder){ return salesOrderMapper.getSalesOrderListConcise(salesOrder); } @Override public List getOrderItemListBySalesId(Integer itemOrderId) { return salesOrderMapper.getOrderItemListBySalesId(itemOrderId); } @Override public List getSalesOrderByIds(Integer[] salesIds){ return salesOrderMapper.getSalesOrderByIds(salesIds); } @Override public List 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 salesOrderItemList = salesOrderMapper.listSalesOrderItem(salesOrderItem); List 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 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 salesOrderItemList = salesOrderMapper.listSalesOrderItem(soi); List updateSalesOrderItemList = new ArrayList<>(); List 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 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 list) { return salesOrderMapper.addSalesOrderList(list); } @Override public List listSalesOrder(SalesOrder salesOrder) { return salesOrderMapper.listSalesOrder(salesOrder); } @Override public Integer listSalesOrderNum(SalesOrder salesOrder) { return salesOrderMapper.listSalesOrderNum(salesOrder); } /** * 获取订单的订单项，首先从REDIS中获取，如果没有获取到，尝试从数据库获取 * @param salesId * @return */ private List listOrderItem(Integer salesId) { String key = CACHE_ORDER_ITEM_NAME + salesId; List 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 list = salesOrderMapper.listSalesOrderItem(salesOrderItem); // 缓存 String key = CACHE_ORDER_ITEM_NAME + salesId; RedisUtils.put(key, list); RedisUtils.expire(key,DateTimeUtil.addDay(1)); } @Override public PagedResult listSalesOrderPage(int pageNO, int pageSize, SalesOrder salesOrder, boolean isTotalNum) { // 初始化页面分页的数据 salesOrder.setStartOrderNO((pageNO-1) * pageSize); salesOrder.setEndOrderNO(pageSize); //查询订单列表信息 List orderList = salesOrderMapper.listSalesOrderNew(salesOrder); orderList.forEach((so) -> { List 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 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 listWaitPrintOrderNum(Integer salesWarehouseId) { return salesOrderMapper.listWaitPrintOrderNum(salesWarehouseId); } @Override public PagedResult listAwaitSendSalesOrderPage(int pageNO, int pageSize, SalesOrder salesOrder, boolean isTotalNum) { PageHelper.startPage(pageNO, pageSize, isTotalNum); //查询订单列表信息 List orderList = salesOrderMapper.listAwaitSendSalesOrderPage(salesOrder); return PageUtil.getPage(orderList); } @Override @Transactional public boolean addOrderAndItem(SalesOrder salesOrder, List 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 list) { calculationTotal(salesOrder,list); if (salesOrder.getSalesMainOrderId() != null) { salesOrder.setSalesPayMoney(0); } //添加订单数据 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 listOrder) { // 订单项拆分完成，直接返回 if (oginerOrder.getSalesOrderItemList().size() <= 0) { return; } List listDownsingleRuleInfo = salesOrderService.listDownsingleRule(); if(listDownsingleRuleInfo.size() < 1){ listOrder.add(oginerOrder); return; } // 拆单，比较的是数量和产品 Map 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(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 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 listItem = salesOrder.getSalesOrderItemList(); salesOrder.setSalesOrderItemList(null); List list = new ArrayList<>(); for (int i = 0;i 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,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 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 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 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 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 listSalesOrder){ if(listSalesOrder.size() > 0){ //查询所有快递策略 DeliveryStrategy deliveryStrategy = new DeliveryStrategy(); deliveryStrategy.setStrategyStatus(1); List 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 listSalesOrderItem(SalesOrderItem salesOrderItem) { return salesOrderMapper.listSalesOrderItem(salesOrderItem); } @Override public Integer updateOrderList(JSONArray orderList, List list) { List salesOrders = new ArrayList(); //订单号相同时，判断状态，发货状态，物流公司，物流单号等是否相同，如果有一个不同，则需添加到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 list) { List salesOrders = new ArrayList(); //订单号相同时，判断状态，发货状态，物流公司，物流单号等是否相同，如果有一个不同，则需添加到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 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 itemList = new ArrayList(); 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 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 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 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 itemList = new ArrayList(); 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 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 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 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 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 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 list) { return salesOrderMapper.updateOrderListIsDownload(list); } @Override public Integer updateSalesOrderByDealCode(SalesOrder salesOrder) { return salesOrderMapper.updateSalesOrderByDealCode(salesOrder); } @Override public List getLogisticsInfo(LogisticsInfo logisticsInfo) { return salesOrderMapper.getLogisticsInfo(logisticsInfo); } @Override public List 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 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 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 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 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 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 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 listOrderitem = salesOrderService.listSalesOrderItem(salesOrderItem); // 查询维修编号,并根据维修编号对应的处理结果判断是否从不良品中出库 boolean isDefectiveProduct = false; if (temp.getSalesQuality() == 1) { // 凡是（付费维修-维修完成）、（免费维修-维修完成）、（机器无故障，原机退回）都走不良品 List 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 listOrderitem = salesOrderService.listSalesOrderItem(salesOrderItem); // // for(SalesOrderItem item : listOrderitem){ // List 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 listOrderitem = salesOrderService.listSalesOrderItem(salesOrderItem); // for(SalesOrderItem item : listOrderitem){ // List 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 getDeliverNum(SalesOrder salesOrder) { return salesOrderMapper.getDeliverNum(salesOrder); } @Override public List getNotSendDate() { return salesOrderMapper.getNotSendDate(); } @Override public List salesOrderListAndItem(SalesOrder salesOrder) { return salesOrderMapper.salesOrderListAndItem(salesOrder); } @Override public PagedResult salesOrderListAndItemPage(int pageNO, int pageSize, SalesOrder salesOrder, boolean isTotalNum) { PageHelper.startPage(pageNO, pageSize, isTotalNum); List list = salesOrderMapper.salesOrderListAndItem(salesOrder); return PageUtil.getPage(list); } @Override public List 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 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 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 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 listOrderCorrectInfo(Integer orderId) { return salesOrderMapper.listOrderCorrectInfo(orderId); } @Override public OrderWarehouse selectAdminWarehouse(Integer adminId) { return salesOrderMapper.selectAdminWarehouse(adminId); } @Override public List listOrderWarehouse() { return salesOrderMapper.listOrderWarehouse(); } @Transactional @Override public List salesOrderAndItemStat(SalesOrder salesOrder) { return salesOrderMapper.salesOrderAndItemStat(salesOrder); } @Transactional @Override public Integer splitOrder(String mainOrderId, List salesOrderList,Integer adminId) { /** * 1.查询以前的所有订单 * 2.通过比对，余下删除的订单集合orderList * 3.给订单项赋值，并且删除该订单的订单项，新增订单项 * 4.删除orderList */ Integer flag = 0; String salesCode = ""; SalesOrder mainOrder = new SalesOrder(); mainOrder.setSalesDealCode(mainOrderId); List orderList = salesOrderService.salesOrderListAndItem(mainOrder); salesCode = orderList.get(0).getSalesDealCode(); SalesOrder or = new SalesOrder(); or.setSalesMainOrderId(orderList.get(0).getSalesId()); //该订单为主订单 List sonSalesOrderList = salesOrderService.salesOrderListAndItem(or); orderList.addAll(sonSalesOrderList); for (SalesOrder salesOrder:salesOrderList) { //orderList还有的订单，最后做删除 for (int j=0;j 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 listSmsSignatureInfo(SmsSignatureInfo smsSignatureInfo) { return salesOrderMapper.listSmsSignatureInfo(smsSignatureInfo); } @Override public List 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 listSalesOrderByAddr(SalesOrder salesOrder) { return salesOrderMapper.listSalesOrderByAddr(salesOrder); } @Override public List listSublistCount(Integer salesId) { return salesOrderMapper.listSublistCount(salesId); } @Override public List 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 listDistributionNum(OrderStatisticsInfo orderStatisticsInfo) { return salesOrderMapper.listDistributionNum(orderStatisticsInfo); } @Override public List listSendNum(OrderStatisticsInfo orderStatisticsInfo) { return salesOrderMapper.listSendNum(orderStatisticsInfo); } @Override public List listCargoInfo(CargoInfo cargoInfo) { return salesOrderMapper.listCargoInfo(cargoInfo); } @Override public List listPlaySingleNum(OrderStatisticsInfo orderStatisticsInfo) { return salesOrderMapper.listPlaySingleNum(orderStatisticsInfo); } @Override public List listOutboundNum(OrderStatisticsInfo orderStatisticsInfo) { return salesOrderMapper.listOutboundNum(orderStatisticsInfo); } @Override public List listDistributionInvalidNum(OrderStatisticsInfo orderStatisticsInfo) { return salesOrderMapper.listDistributionInvalidNum(orderStatisticsInfo); } @Override public List listSendInvalidNum(OrderStatisticsInfo orderStatisticsInfo) { return salesOrderMapper.listSendInvalidNum(orderStatisticsInfo); } @Override public List listDeliveryLogisticsNum(OrderStatisticsInfo orderStatisticsInfo) { return salesOrderMapper.listDeliveryLogisticsNum(orderStatisticsInfo); } @Override public List orderAfterCaseDate() { return salesOrderMapper.orderAfterCaseDate(); } @Override public List getPickingOrders(OrderStatisticsInfo orderStatisticsInfo) { return salesOrderMapper.getPickingOrders(orderStatisticsInfo); } @Override public List getCheckOrders(OrderStatisticsInfo orderStatisticsInfo) { return salesOrderMapper.getCheckOrders(orderStatisticsInfo); } @Override public Integer addTracking(OrderTracking orderTracking) { return salesOrderMapper.addTracking(orderTracking); } @Override public List listTracking(String salesDealCode) { return salesOrderMapper.listTracking(salesDealCode); } @Override public List 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 selectStrategyProduct(Integer strategyId) { return salesOrderMapper.selectStrategyProduct(strategyId); } @Override public List selectStrategyColor(Integer strategyId) { return salesOrderMapper.selectStrategyColor(strategyId); } @Override public List selectStrategyStore(Integer strategyId) { return salesOrderMapper.selectStrategyStore(strategyId); } @Override @Transactional(rollbackFor = {Exception.class}, isolation = Isolation.REPEATABLE_READ) public int printOrder(List 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() + "向小亚通发货失败，请查询订单状态"); } SalesOrder salesOrder = salesOrderService.getSalesOrderByIdConcise(o.getSalesId()); if (salesOrder.getSalesBatchId().startsWith("ST")) { // 淘宝订单发货 List salesOrderItemList = salesOrderService.getOrderItemListBySalesId(o.getSalesId()); String oid = ""; int size = salesOrderItemList.size() - 1; for (int i = 0; i < salesOrderItemList.size(); i++) { oid += salesOrderItemList.get(i).getItemOtherId(); if (i != (size)) { oid += ","; } } TaobaoClient client = new DefaultTaobaoClient(TaobaoConfig.TAOBAO_URL, TaobaoConfig.appkey, TaobaoConfig.secret); AlibabaAscpLogisticsOfflineSendRequest req = new AlibabaAscpLogisticsOfflineSendRequest(); req.setTid(salesOrder.getSalesExOrderId()); req.setSubTid(oid); List list2 = new ArrayList(); AlibabaAscpLogisticsOfflineSendRequest.TopConsignPkgRequest obj3 = new AlibabaAscpLogisticsOfflineSendRequest.TopConsignPkgRequest(); list2.add(obj3); obj3.setOutSid(o.getSalesPostNum()); // 兼容 LogisticsInfo info = logisticsInfoService.getLogisticsNameByRSTCode(salesOrder.getSalesPostFirm()); obj3.setCompanyCode(info.getLogisticsEfastCode()); req.setConsignPkgs(list2); try { Integer salesStoreId = salesOrder.getSalesStoreId(); String token = null; if (salesStoreId == TaobaoConfig.STORE_ID_IAMBERRY) { token = (String) TaobaoConfig.getToken().get("token"); } else if (salesStoreId == TaobaoConfig.STORE_ID_METAPURE) { token = (String) TaobaoConfig.getMetaureToken().get("token"); } else { throw new RuntimeException("淘宝店铺未授权"); } AlibabaAscpLogisticsOfflineSendResponse rsp = client.execute(req, token); logger.info("淘宝订单发货,外部订单id：{}，接口response:{}", salesOrder.getSalesExOrderId(), rsp.getBody()); } catch (ApiException e) { logger.error("淘宝订单发货异常,外部订单id：{} 异常信息：",salesOrder.getSalesExOrderId(), e); throw new RuntimeException(e); } } //京东订单发货 if (salesOrder.getSalesBatchId().startsWith("JT")) { try { // 后台拆分的订单不处理(mainOrderId为null，说明是主单) if (salesOrder.getSalesMainOrderId() == null) { Map params = new HashMap<>(); params.put("orderId", salesOrder.getSalesExOrderId()); params.put("logiCoprId", logisticsInfoService.getLogisticsNameByRSTCode(salesOrder.getSalesPostFirm()).getLogisticsXytCode()); params.put("logiNo", o.getSalesPostNum()); params.put("code", AES.encrypt(salesOrder.getSalesOrderId())); params.put("storeId", String.valueOf(salesOrder.getSalesStoreId())); String result = HttpClient431Util.doPost(params, jdOrderDomain + "/jingdong/orderShipment"); if (StringUtil.isNotEmpty(result)) { OperatorResult operatorResult = com.alibaba.fastjson.JSONObject.parseObject(result, OperatorResult.class); if (operatorResult.getSuccess()) { logger.info("京东发货回传请求成功：result=SUCCESS:{}, MSG:{}", operatorResult.getSuccess(), operatorResult.getChineseErrCode()); } else { logger.info("京东发货回传请求失败：订单号：{}, code:{}, error:{}, MSG:{}", salesOrder.getSalesOrderId(), operatorResult.getErrorCode(), operatorResult.getEnglishErrCode(), operatorResult.getChineseErrCode()); throw new RuntimeException("京东发货回传请求失败：" + operatorResult.getErrorCode()); } } else { logger.info("京东发货回传请求错误：{}", result); throw new RuntimeException("京东发货回传请求失败"); } } } catch (JdException e) { throw new RuntimeException(e); } catch (Exception e) { throw new RuntimeException(e); } } // 抖音订单发货 if (salesOrder.getSalesBatchId().startsWith("DY")) { try { Integer salesStoreId = salesOrder.getSalesStoreId(); Long shopId; // 映射到抖音的shopId,保存的地方在DouyinTask中 if (salesStoreId == 148) { shopId = DouyinConfig.DOUYIN_IAMBERRY_SHOP_ID; } else if (salesStoreId == 172) { shopId = DouyinConfig.DOUYIN_METAPURE_SHOP_ID; } else if(salesStoreId == 202) { shopId = 187079746L; } else { throw new RuntimeException("未映射到抖音店铺，系统出小差啦~"); } // 判断是否是赠品，后台拆分的订单不处理(mainOrderId为null，说明是主单) if (salesOrder.getSalesMainOrderId() == null) { // 查询系统快递公司信息 LogisticsInfo logisticsInfo = logisticsInfoService.getLogisticsNameByRSTCode(salesOrder.getSalesPostFirm()); OrderLogisticsAddParam param = new OrderLogisticsAddParam(); param.setOrderId(salesOrder.getSalesExOrderId()); param.setLogisticsCode(salesOrder.getSalesPostNum()); param.setCompany(logisticsInfo.getLogisticsName()); // 这里抖音的快递公司编码和系统快递100的一样，就先不调用抖音的了 param.setCompanyCode(logisticsInfo.getLogisticsOnehundredCode()); OrderLogisticsAddRequest request = new OrderLogisticsAddRequest(); request.setParam(param); OrderLogisticsAddResponse response = request.execute(AccessTokenBuilder.build(shopId)); if (response.isSuccess()) { logger.info("抖音发货回传请求成功"); } else if ("50002".equals(response.getCode())) { logger.info("抖音发货回传请求失败：订单已发货，不允许再次执行发货。"); } else { logger.info("抖音发货回传请求错误：{}", response.getMsg()); throw new RuntimeException("抖音发货回传请求失败"); } } } catch (Exception e) { logger.error("抖音订单发货失败，外部订单id：" + salesOrder.getSalesExOrderId() + " 异常信息：", e); throw new RuntimeException(e); } } // 添加订单追踪信息 OrderTracking orderTracking = new OrderTracking(); orderTracking.setAdminId(currAdmin); orderTracking.setSalesDealCode(o.getSalesDealCode()); orderTracking.setTrackingDesc("打印订单"); salesOrderService.addTracking(orderTracking); }); return list.size(); } @Override public List testListSalesOrder() { List 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 testListOther(SalesOrder data) { List 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 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.getSalesStoreId() != 40){ salesOrder.setSalesAmount(salesAmount); salesOrder.setSalesPayMoney(salesPayMoney); } } }