淘宝转链接口更新

admin

2025-02-25 30d8e227e8d823b6c38c3b9c90ac2df03b63befe

 fanli/src/main/java/com/yeshi/fanli/job/order/taobao/UpdateOrderJob.java

@@ -1,609 +1,516 @@
package com.yeshi.fanli.job.order.taobao;



import java.math.BigDecimal;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Date;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;



import javax.annotation.Resource;



import org.springframework.scheduling.annotation.Scheduled;

import org.springframework.stereotype.Component;



import com.yeshi.fanli.dto.taobao.WeiQuanOrderResult;

import com.yeshi.fanli.entity.bus.user.LostOrder;

import com.yeshi.fanli.entity.bus.user.Order;

import com.yeshi.fanli.entity.order.CommonOrder;

import com.yeshi.fanli.entity.taobao.TaoBaoOrder;

import com.yeshi.fanli.entity.taobao.TaoBaoWeiQuanOrder;

import com.yeshi.fanli.log.LogHelper;

import com.yeshi.fanli.service.inter.common.DataMonitorService;

import com.yeshi.fanli.service.inter.order.CommonOrderService;

import com.yeshi.fanli.service.inter.order.LostOrderService;

import com.yeshi.fanli.service.inter.order.OrderProcessService;

import com.yeshi.fanli.service.inter.order.OrderService;

import com.yeshi.fanli.service.inter.taobao.TaoBaoOrderService;

import com.yeshi.fanli.service.inter.taobao.TaoBaoUnionConfigService;

import com.yeshi.fanli.service.inter.taobao.TaoBaoWeiQuanOrderService;

import com.yeshi.fanli.util.CMQManager;

import com.yeshi.fanli.util.Constant;

import com.yeshi.fanli.util.RedisManager;

import com.yeshi.fanli.util.StringUtil;

import com.yeshi.fanli.util.TaoBaoConstant;

import com.yeshi.fanli.util.TimeUtil;

import com.yeshi.fanli.util.taobao.TaoBaoOrderUtil;

import com.yeshi.fanli.util.taobao.TaoKeOrderApiUtil;



//从淘宝爬去订单更新

@Component

public class UpdateOrderJob {



   public UpdateOrderJob() {

      System.out.println("初始化:UpdateOrderJob");

   }



   @Resource

   private OrderProcessService orderProcessService;



   @Resource

   private TaoBaoOrderUtil taoBaoOrderUtil;



   @Resource

   private TaoBaoOrderService taoBaoOrderService;



   @Resource

   private TaoBaoUnionConfigService taoBaoUnionConfigService;



   @Resource

   private TaoBaoWeiQuanOrderService taoBaoWeiQuanOrderService;



   @Resource

   private DataMonitorService dataMonitorService;



   @Resource

   private RedisManager redisManager;



   @Resource

   private LostOrderService lostOrderService;



   @Resource

   private OrderService orderService;



   @Resource

   private CommonOrderService commonOrderService;



   /**

    * 新版获取普通订单

    * 
    * @param startTime

    * @param span

    * @return

    */

   private static List<TaoBaoOrder> getCommonOrder(long startTime, int span) {

      int page = 1;

      String startTimeStr = TimeUtil.getGernalTime(startTime, "yyyy-MM-dd HH:mm:ss");

      List<TaoBaoOrder> orderList = TaoKeOrderApiUtil.getTaoBaoAllOrder(startTimeStr, span, page,

            TaoBaoConstant.TAOBAO_AUTH_APPKEY, TaoBaoConstant.TAOBAO_AUTH_APPSECRET);

      while (orderList.size() == 100 * page) {

         page++;

         List<TaoBaoOrder> tempOrderList = TaoKeOrderApiUtil.getTaoBaoAllOrder(startTimeStr, span, page,

               TaoBaoConstant.TAOBAO_AUTH_APPKEY, TaoBaoConstant.TAOBAO_AUTH_APPSECRET);

         if (tempOrderList != null && tempOrderList.size() > 0)

            orderList.addAll(tempOrderList);

      }

      return orderList;

   }



   /**

    * 获取第三方普通订单

    * 
    * @param startTime

    * @param span

    * @return

    */

   private static List<TaoBaoOrder> getThirdCommonOrder(long startTime, int span) {

      int page = 1;

      String startTimeStr = TimeUtil.getGernalTime(startTime, "yyyy-MM-dd HH:mm:ss");

      List<TaoBaoOrder> orderList = TaoKeOrderApiUtil.getTaoBaoThirdAllOrder(startTimeStr, span, page,

            TaoBaoConstant.TAOBAO_AUTH_APPKEY, TaoBaoConstant.TAOBAO_AUTH_APPSECRET);

      while (orderList.size() == 100 * page) {

         page++;

         List<TaoBaoOrder> tempOrderList = TaoKeOrderApiUtil.getTaoBaoThirdAllOrder(startTimeStr, span, page,

               TaoBaoConstant.TAOBAO_AUTH_APPKEY, TaoBaoConstant.TAOBAO_AUTH_APPSECRET);

         if (tempOrderList != null && tempOrderList.size() > 0)

            orderList.addAll(tempOrderList);

      }

      return orderList;

   }



   /**

    * 获取某个区间段的订单

    * 
    * @param startTime

    * @param endTime

    * @return

    */

   public static List<TaoBaoOrder> getCommonOrder(long startTime, long endTime) {

      List<TaoBaoOrder> orderList = new ArrayList<>();

      long span = (endTime - startTime) % 1000 == 0 ? (endTime - startTime) / 1000 : (endTime - startTime) / 1000 + 1;

      int count = (int) (span / 1200);

      if (span % 1200 != 0)

         count++;

      for (int i = 0; i < count; i++) {

         long startT = startTime + i * 1200 * 1000L;

         int s = 1200;

         if (endTime < startT + 1200 * 1000L) {

            s = (int) ((endTime - startT) / 1000) + 1;

            if (s < 60)

               s = 60;

         }

         List<TaoBaoOrder> tempOrderList = getCommonOrder(startT, s);

         if (tempOrderList != null && tempOrderList.size() > 0)

            orderList.addAll(tempOrderList);

      }

      return orderList;

   }



   /**

    * 爬取三方订单

    * 
    * @param startTime

    * @param endTime

    * @return

    */

   public static List<TaoBaoOrder> getThirdCommonOrder(long startTime, long endTime) {

      List<TaoBaoOrder> orderList = new ArrayList<>();

      long span = (endTime - startTime) % 1000 == 0 ? (endTime - startTime) / 1000 : (endTime - startTime) / 1000 + 1;

      int count = (int) (span / 1200);

      if (span % 1200 != 0)

         count++;

      for (int i = 0; i < count; i++) {

         long startT = startTime + i * 1200 * 1000L;

         int s = 1200;

         if (endTime < startT + 1200 * 1000L) {

            s = (int) ((endTime - startT) / 1000) + 1;

            if (s < 60)

               s = 60;

         }

         List<TaoBaoOrder> tempOrderList = getThirdCommonOrder(startT, s);

         if (tempOrderList != null && tempOrderList.size() > 0)

            orderList.addAll(tempOrderList);

      }

      return orderList;

   }



   /**

    * 按天获取普通订单（新版）

    * 
    * @param date

    * @return

    */

   public List<TaoBaoOrder> getCommonOrderByDay(Date date) {

      List<TaoBaoOrder> orderList = new ArrayList<>();

      // 将一天分成12段

      for (int i = 0; i < 72; i++) {

         List<TaoBaoOrder> tempOrderList = getCommonOrder(date.getTime() + 1000 * 60 * 20L * i, 1200);

         if (tempOrderList != null && tempOrderList.size() > 0)

            orderList.addAll(tempOrderList);

      }

      return orderList;

   }



   public void updateOrder(long startTime, long endTime) {

      // 老版本处理方式

      // List<TaoBaoUnionConfig> configList =

      // taoBaoUnionConfigService.getConfigByTypeCache(PidUser.TYPE_FANLI_ANDROID);

      // List<TaoBaoOrder> orderList = new ArrayList<>();

      // try {

      // orderList = TaoBaoOrderUtil.getOrderList(startTime, endTime,

      // configList.get(0));

      // } catch (TaoBaoOrderException e2) {

      // try {

      // LogHelper.errorDetailInfo(e2);

      // } catch (Exception e) {

      // e.printStackTrace();

      // }

      // }

      // List<TaoBaoOrder> thirdOrderList = new ArrayList<>();

      // try {

      // thirdOrderList = TaoBaoOrderUtil.getThirdServiceOrderList(startTime,

      // endTime, configList.get(0));

      // } catch (TaoBaoOrderException e2) {

      // try {

      // LogHelper.errorDetailInfo(e2);

      // } catch (Exception e) {

      // e.printStackTrace();

      // }

      // }

      // if (thirdOrderList != null && thirdOrderList.size() > 0)

      // orderList.addAll(thirdOrderList);

      // 新版本处理方式

      List<TaoBaoOrder> orderList = getCommonOrder(startTime, endTime);

      List<TaoBaoOrder> tempOrderList2 = getThirdCommonOrder(startTime, endTime);

      if (tempOrderList2 != null && tempOrderList2.size() > 0)

         orderList.addAll(tempOrderList2);



      LogHelper.orderInfo("正在执行订单爬取结束，共有订单:" + orderList.size());

      addOrder(orderList);

      try {

         Thread.sleep(10000);

      } catch (InterruptedException e) {

         e.printStackTrace();

      }

   }



   public static List<TaoBaoOrder> mixTaoBaoOrder(List<TaoBaoOrder> commonOrderList, List<TaoBaoOrder> sorderList) {

      Map<String, List<TaoBaoOrder>> commonMap = TaoBaoOrderUtil.classifyTaoBaoOrderByOrderId(commonOrderList);

      Map<String, List<TaoBaoOrder>> sMap = TaoBaoOrderUtil.classifyTaoBaoOrderByOrderId(sorderList);

      // 获取订单交集

      Iterator<String> its = commonMap.keySet().iterator();

      List<String> commonOrderIdList = new ArrayList<>();

      List<String> sOrderIdList = new ArrayList<>();

      while (its.hasNext()) {

         String orderId = its.next();

         commonOrderIdList.add(orderId);

      }

      its = sMap.keySet().iterator();

      while (its.hasNext()) {

         String orderId = its.next();

         sOrderIdList.add(orderId);

      }



      // 求交集

      commonOrderIdList.retainAll(sOrderIdList);



      List<TaoBaoOrder> orderList = new ArrayList<>();



      for (String orderId : commonOrderIdList) {

         List<TaoBaoOrder> list = commonMap.get(orderId);

         String specialId = sMap.get(orderId).get(0).getSpecialId();

         String relationId = sMap.get(orderId).get(0).getRelationId();

         for (TaoBaoOrder to : list) {

            to.setSpecialId(specialId);

            to.setRelationId(relationId);

            orderList.add(to);

         }

      }



      return orderList;

   }



   public void addOrder(List<TaoBaoOrder> orderList) {



      if (orderList != null)

         for (int i = 0; i < orderList.size(); i++) {

            // 移除会员运营ID与渠道专属订单

            if (orderList.get(i).getAdPositionName().contains("会员运营")

                  || orderList.get(i).getAdPositionName().contains("渠道专属")) {

               if (orderList.get(i).getAdPositionName().contains("会员运营")) {// 处理订单申诉

                  Order order = orderService.findOrderByOrderIdAndType(orderList.get(i).getOrderId(),

                        Order.ORDER_TYPE_TAOBAO);

                  if (order != null && order.getBeizhu().contains("补单")) {// 不排除补单的情况



                  } else {

                     orderList.remove(i);

                     i--;

                     break;

                  }

               } else {

                  orderList.remove(i);

                  i--;

               }

            }

         }



      try {

         taoBaoOrderService.addTaoBaoOrderList(orderList);

      } catch (Exception e) {

         LogHelper.errorDetailInfo(e);



      }



      try {

         Map<String, List<TaoBaoOrder>> map = TaoBaoOrderUtil.classifyTaoBaoOrderByOrderId(orderList);

         if (map != null) {

            Iterator<String> its = map.keySet().iterator();

            while (its.hasNext()) {

               String key = its.next();

               List<TaoBaoOrder> orders = map.get(key);

               String redisKey = "addorderqueue-" + key;

               // redis做频率限制

               try {

                  if (!StringUtil.isNullOrEmpty(redisManager.getCommonString(redisKey))) {

                     continue;

                  }



               } catch (Exception e) {



               }



               CMQManager.getInstance().addTaoBaoOrderMsg(key);



               try {

                  // 6小时内不再处理

                  redisManager.cacheCommonString(redisKey, "1", 60 * 60 * 6);

               } catch (Exception e) {



               }

            }

         }

      } catch (Exception e) {

         LogHelper.errorDetailInfo(e);

      }

   }



   // 每15分钟爬取一次

   @Scheduled(cron = "0 0/15 * * * ? ")

   public void doJob1() {

      if (!Constant.IS_TASK)

         return;

      long currentTime = System.currentTimeMillis() - 1000 * 60;

      String h = TimeUtil.getGernalTime(currentTime, "HH");

      String m = TimeUtil.getGernalTime(currentTime, "mm");

      int mm = Integer.parseInt(h) * 60 + Integer.parseInt(m);

      int pos = mm / 15;

      if (pos >= 90)

         pos = 89;

      long startTime = TimeUtil.convertToTimeTemp(TimeUtil.getGernalTime(currentTime, "yyyy-MM-dd"), "yyyy-MM-dd")

            - (1000 * 60 * 60 * 24L * (90 - pos));

      long endTime = startTime + 1000 * 60 * 60 * 24L;

      LogHelper.orderInfo("正在执行订单爬取...");

      updateOrder(startTime, endTime);

   }



   // 淘宝推广订单 每隔3分13秒执行一次

   @Scheduled(cron = "13 0/3 * * * ? ")

   public void doJob6() {

      if (!Constant.IS_TASK)

         return;

      long endTime = System.currentTimeMillis() - 1000 * 60;

      updateOrder(endTime - 1000 * 60 * 20L, endTime);

   }



   // 返利

   @Scheduled(cron = "0 0/5 * * * ? ")

   public void doJob2() {

      if (!Constant.IS_TASK)

         return;

      doTaoBaoWeiQuanOrder(2);

      orderProcessService.fanli();

   }



   // 每月25号9点执行返利

   @Scheduled(cron = "0 0 9 25 * ? ")

   public void doJob3() {

      if (!Constant.IS_TASK)

         return;

      orderProcessService.fanliInvaiteAndShare();

   }



   private void doTaoBaoWeiQuanOrder(int day) {



      for (int i = 0; i < day; i++) {

         List<TaoBaoWeiQuanOrder> orderList = new ArrayList<>();



         // 按照维权发起时间查询

         WeiQuanOrderResult result = TaoKeOrderApiUtil

               .getTaoBaoSpecialWeiQuanOrderList(new Date(TimeUtil.convertToTimeTemp(

                     TimeUtil.getGernalTime(System.currentTimeMillis() - 1000 * 60 * 60 * 24L * i, "yyyy-MM-dd"),

                     "yyyy-MM-dd")), 1, 1, false);

         orderList.addAll(result.orderList);

         // 第三方

         result = TaoKeOrderApiUtil.getTaoBaoSpecialWeiQuanOrderList(new Date(TimeUtil.convertToTimeTemp(

               TimeUtil.getGernalTime(System.currentTimeMillis() - 1000 * 60 * 60 * 24L * i, "yyyy-MM-dd"),

               "yyyy-MM-dd")), 1, 1, true);

         orderList.addAll(result.orderList);



         result = TaoKeOrderApiUtil.getTaoBaoRelationWeiQuanOrderList(new Date(TimeUtil.convertToTimeTemp(

               TimeUtil.getGernalTime(System.currentTimeMillis() - 1000 * 60 * 60 * 24L * i, "yyyy-MM-dd"),

               "yyyy-MM-dd")), 1, 1, false);

         orderList.addAll(result.orderList);



         // 第三方

         result = TaoKeOrderApiUtil.getTaoBaoRelationWeiQuanOrderList(new Date(TimeUtil.convertToTimeTemp(

               TimeUtil.getGernalTime(System.currentTimeMillis() - 1000 * 60 * 60 * 24L * i, "yyyy-MM-dd"),

               "yyyy-MM-dd")), 1, 1, true);

         orderList.addAll(result.orderList);



         /**

          * 按照维权完成时间查询

          */



         result = TaoKeOrderApiUtil.getTaoBaoSpecialWeiQuanOrderList(new Date(TimeUtil.convertToTimeTemp(

               TimeUtil.getGernalTime(System.currentTimeMillis() - 1000 * 60 * 60 * 24L * i, "yyyy-MM-dd"),

               "yyyy-MM-dd")), 3, 1, false);

         orderList.addAll(result.orderList);

         // 第三方

         result = TaoKeOrderApiUtil.getTaoBaoSpecialWeiQuanOrderList(new Date(TimeUtil.convertToTimeTemp(

               TimeUtil.getGernalTime(System.currentTimeMillis() - 1000 * 60 * 60 * 24L * i, "yyyy-MM-dd"),

               "yyyy-MM-dd")), 3, 1, true);

         orderList.addAll(result.orderList);



         result = TaoKeOrderApiUtil.getTaoBaoRelationWeiQuanOrderList(new Date(TimeUtil.convertToTimeTemp(

               TimeUtil.getGernalTime(System.currentTimeMillis() - 1000 * 60 * 60 * 24L * i, "yyyy-MM-dd"),

               "yyyy-MM-dd")), 3, 1, false);

         orderList.addAll(result.orderList);



         // 第三方

         result = TaoKeOrderApiUtil.getTaoBaoRelationWeiQuanOrderList(new Date(TimeUtil.convertToTimeTemp(

               TimeUtil.getGernalTime(System.currentTimeMillis() - 1000 * 60 * 60 * 24L * i, "yyyy-MM-dd"),

               "yyyy-MM-dd")), 3, 1, true);

         orderList.addAll(result.orderList);



         for (TaoBaoWeiQuanOrder order : orderList)

            taoBaoWeiQuanOrderService.addWeiQuanOrder(order);// 添加维权订单到数据库

         // 处理维权订单

         orderProcessService.weiQuanOrder(orderList);

      }



   }



   // 维权订单处理-处理最近60天的

   // 30分钟一次

   @Scheduled(cron = "0 0/30 * * * ? ")

   public void doTaoBaoWeiQuan() {

      if (!Constant.IS_TASK)

         return;

      doTaoBaoWeiQuanOrder(5);

   }



   // 每6个小时执行一次

   @Scheduled(cron = "0 0 0/6 * * ? ")

   public void doLostOrder() {

      if (!Constant.IS_TASK)

         return;

      lostOrderService.processFail();

   }



   // 每2分钟执行一次

   @Scheduled(cron = "0 0/2 * * * ? ")

   public void addLostOrder() {

      if (!Constant.IS_TASK)

         return;

      LogHelper.test("处理丢失订单");

      List<LostOrder> list = lostOrderService.listByStateAndResultCode(LostOrder.STATE_PASS,

            LostOrder.RESULT_CODE_VERFING, 1, 50);

      if (list != null)

         for (LostOrder lo : list) {

            List<TaoBaoOrder> taoBaoOrderList = taoBaoOrderService.getTaoBaoOrderByOrderId(lo.getOrderId());

            // 清除频率限制

            if (taoBaoOrderList != null && taoBaoOrderList.size() > 0) {

               String key = "addorderqueue-" + lo.getOrderId();

               redisManager.removeCommonString(key);

               addOrder(taoBaoOrderList);

               LogHelper.test("自动处理淘宝订单:" + lo.getOrderId());

            }

         }

   }



   /**

    * 处理淘宝结算订单,30fen执行一次

    */

   @Scheduled(cron = "30 0 0/1 * * ? ")

   public void doSettleOrders() {

      if (!Constant.IS_TASK)

         return;

      // 处理3-15天前的订单，每天跑一次

      Calendar ca = Calendar.getInstance();

      int hour = ca.get(Calendar.HOUR_OF_DAY);



      long startTime = TimeUtil.convertToTimeTemp(

            TimeUtil.getGernalTime(ca.getTimeInMillis() - 1000 * 60 * 60 * 24 * 3L, "yyyy-MM-dd"), "yyyy-MM-dd")

            - hour * (1000 * 60 * 60 * 12L);

      long endTime = startTime + 1000 * 60 * 60 * 12L;

      List<TaoBaoOrder> orderList = TaoKeOrderApiUtil.getTaoBaoSettleOrders(startTime, endTime, false);

      List<TaoBaoOrder> tempOrderList = TaoKeOrderApiUtil.getTaoBaoSettleOrders(startTime, endTime, true);

      if (tempOrderList != null && tempOrderList.size() > 0)

         orderList.addAll(tempOrderList);

      addOrder(orderList);

   }



   /**

    * 13分钟更新最近13分钟的结算数据

    */

   @Scheduled(cron = "0 0/13 * * * ? ")

   public void doSettleOrdersToday() {

      if (!Constant.IS_TASK)

         return;

      // 处理3-15天前的订单，每天跑一次

      Calendar ca = Calendar.getInstance();

      long startTime = ca.getTimeInMillis() - 1000 * 60 * 5L - 1000 * 60 * 13L;

      long endTime = startTime + 1000 * 60 * 13L;

      List<TaoBaoOrder> orderList = TaoKeOrderApiUtil.getTaoBaoSettleOrders(startTime, endTime, false);

      List<TaoBaoOrder> tempOrderList = TaoKeOrderApiUtil.getTaoBaoSettleOrders(startTime, endTime, true);

      if (tempOrderList != null && tempOrderList.size() > 0)

         orderList.addAll(tempOrderList);

      addOrder(orderList);

   }



   /**

    * 更新本地订单（凌晨25分更新）

    */

   @Scheduled(cron = "25 0 0 * * ? ")

   public void doLocalTaoBaoOrder() {

      if (!Constant.IS_TASK)

         return;

      // 处理3-15天前的订单，每天跑一次

      Long startTime = System.currentTimeMillis() - 1000 * 60 * 60 * 24 * 60L;

      Long endTime = startTime + 1000 * 60 * 60 * 24 * 48L;

      List<CommonOrder> commonOrderList = commonOrderService.listBySourceTypeAndStateAndThirdCrateTime(

            Constant.SOURCE_TYPE_TAOBAO, CommonOrder.STATE_FK, startTime, endTime, 1, 500);

      Set<String> orderIds = new HashSet<>();

      for (CommonOrder co : commonOrderList) {

         orderIds.add(co.getOrderNo());

      }



      for (Iterator<String> its = orderIds.iterator(); its.hasNext();) {

         String orderId = its.next();

         List<TaoBaoOrder> orderList = taoBaoOrderService.getTaoBaoOrderByOrderId(orderId);

         Map<String, List<TaoBaoOrder>> orders = new HashMap<>();

         orders.put(orderId, orderList);

         orderProcessService.processOrder(orders);

      }

   }



   /**

    * 更新最近的本地单(30分钟更新一次)

    */



   @Scheduled(cron = "0 0/30 * * * ? ")

   public void doLatestLocalTaoBaoOrder() {

      if (!Constant.IS_TASK)

         return;

      Long endTime = System.currentTimeMillis() - 1000 * 60 * 10L;

      Long startTime = endTime - 1000 * 60 * 60 * 12L;

      updateLocalTaoBaoOrder(startTime, endTime, 1, 2000);



   }



   public void updateLocalTaoBaoOrder(Long startTime, Long endTime, int page, int count) {

      List<TaoBaoOrder> list = taoBaoOrderService.listBySettlementTime(startTime, endTime, page, count);

      Set<String> orderIds = new HashSet<>();

      for (TaoBaoOrder co : list) {

         orderIds.add(co.getOrderId());

      }



      for (Iterator<String> its = orderIds.iterator(); its.hasNext();) {

         String orderId = its.next();

         // 查询是否有处于订单付款状态的单

         List<CommonOrder> commonOrderList = commonOrderService

               .listBySourceTypeAndOrderId(Constant.SOURCE_TYPE_TAOBAO, orderId);

         boolean update = false;

         if (commonOrderList != null)

            for (CommonOrder co : commonOrderList) {

               if (co.getState() == CommonOrder.STATE_FK && co.getPayment().compareTo(new BigDecimal(0)) > 0) {

                  update = true;

                  break;

               }

            }



         if (update) {

            List<TaoBaoOrder> orderList = taoBaoOrderService.getTaoBaoOrderByOrderId(orderId);

            Map<String, List<TaoBaoOrder>> orders = new HashMap<>();

            orders.put(orderId, orderList);

            orderProcessService.processOrder(orders);

         }

      }

   }



   @Scheduled(cron = "30 13 3 * * ? ")

   public void doLatest5DayLocalTaoBaoOrder() {

      if (!Constant.IS_TASK)

         return;

      Long endTime = System.currentTimeMillis() - 1000 * 60 * 60 * 12L;

      Long startTime = endTime - 1000 * 60 * 60 * 24 * 5L;

      long count = taoBaoOrderService.countBySettlementTime(startTime, endTime);

      int pageSize = 100;

      long page = count % pageSize == 0 ? count / pageSize : count / pageSize + 1;

      for (int i = 0; i < page; i++) {

         updateLocalTaoBaoOrder(startTime, endTime, i + 1, pageSize);

      }

   }



}

package com.yeshi.fanli.job.order.taobao;

import com.xxl.job.core.biz.model.ReturnT;
import com.xxl.job.core.handler.annotation.XxlJob;
import com.yeshi.fanli.dto.taobao.WeiQuanOrderResult;
import com.yeshi.fanli.entity.bus.user.LostOrder;
import com.yeshi.fanli.entity.bus.user.Order;
import com.yeshi.fanli.entity.order.CommonOrder;
import com.yeshi.fanli.entity.taobao.TaoBaoOrder;
import com.yeshi.fanli.entity.taobao.TaoBaoWeiQuanOrder;
import com.yeshi.fanli.log.LogHelper;
import com.yeshi.fanli.service.inter.order.CommonOrderService;
import com.yeshi.fanli.service.inter.order.LostOrderService;
import com.yeshi.fanli.service.inter.order.OrderProcessService;
import com.yeshi.fanli.service.inter.order.OrderService;
import com.yeshi.fanli.service.inter.order.tb.TaoBaoOrderService;
import com.yeshi.fanli.service.inter.order.tb.TaoBaoWeiQuanOrderService;
import com.yeshi.fanli.util.Constant;
import com.yeshi.fanli.util.RedisKeyEnum;
import com.yeshi.fanli.util.RedisManager;
import com.yeshi.fanli.util.StringUtil;
import com.yeshi.fanli.util.mq.rabbit.RabbitmqManager;
import com.yeshi.fanli.util.taobao.TaoBaoOrderUtil;
import com.yeshi.fanli.util.taobao.TaoKeOrderApiUtil;
import org.springframework.stereotype.Component;
import org.yeshi.utils.TimeUtil;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.*;

//从淘宝爬去订单更新
@Component
public class UpdateOrderJob {

    public UpdateOrderJob() {
        System.out.println("初始化:UpdateOrderJob");
    }

    @Resource
    private OrderProcessService orderProcessService;
    @Resource
    private TaoBaoOrderService taoBaoOrderService;
    @Resource
    private TaoBaoWeiQuanOrderService taoBaoWeiQuanOrderService;

    @Resource
    private RedisManager redisManager;

    @Resource
    private LostOrderService lostOrderService;

    @Resource
    private OrderService orderService;

    @Resource
    private CommonOrderService commonOrderService;

    @Resource
    private RabbitmqManager rabbitmqManager;


    /**
     * 新版获取普通订单
     *
     * @param startTime
     * @param span
     * @return
     */
    private static List<TaoBaoOrder> getCommonOrder(long startTime, int span) {
        List<TaoBaoOrder> totalList = new ArrayList<>();
        List<TaoBaoOrder> orderList = TaoKeOrderApiUtil.getTaoBaoCommonOrderList(startTime, startTime + span * 1000L,
                1);
        if (orderList != null && orderList.size() > 0)
            totalList.addAll(orderList);

        orderList = TaoKeOrderApiUtil.getTaoBaoCommonOrderList(startTime, startTime + span * 1000L, 2);
        if (orderList != null && orderList.size() > 0)
            totalList.addAll(orderList);

        orderList = TaoKeOrderApiUtil.getTaoBaoCommonOrderList(startTime, startTime + span * 1000L, 3);
        if (orderList != null && orderList.size() > 0)
            totalList.addAll(orderList);
        // 移除重复交易号的订单

        return totalList;
    }

    /**
     * 获取某个区间段的订单
     *
     * @param startTime
     * @param endTime
     * @return
     */
    public static List<TaoBaoOrder> getCommonOrder(long startTime, long endTime) {
        List<TaoBaoOrder> totalList = new ArrayList<>();
        List<TaoBaoOrder> orderList = TaoKeOrderApiUtil.getTaoBaoCommonOrderList(startTime, endTime, 1);
        if (orderList != null && orderList.size() > 0)
            totalList.addAll(orderList);

        orderList = TaoKeOrderApiUtil.getTaoBaoCommonOrderList(startTime, endTime, 2);
        if (orderList != null && orderList.size() > 0)
            totalList.addAll(orderList);

        orderList = TaoKeOrderApiUtil.getTaoBaoCommonOrderList(startTime, endTime, 3);
        if (orderList != null && orderList.size() > 0)
            totalList.addAll(orderList);
        // 移除重复交易号的订单

        return totalList;
    }

    /**
     * 按天获取普通订单（新版）
     *
     * @param date
     * @return
     */
    public List<TaoBaoOrder> getCommonOrderByDay(Date date) {
        List<TaoBaoOrder> orderList = new ArrayList<>();
        // 将一天分成12段
        for (int i = 0; i < 72; i++) {
            List<TaoBaoOrder> tempOrderList = getCommonOrder(date.getTime() + 1000 * 60 * 20L * i, 1200);
            if (tempOrderList != null && tempOrderList.size() > 0)
                orderList.addAll(tempOrderList);
        }
        return orderList;
    }

    public void updateOrder(long startTime, long endTime) {
        List<TaoBaoOrder> orderList = getCommonOrder(startTime, endTime);
        LogHelper.orderInfo("常规订单共有订单:" + orderList.size());
        addOrder(orderList);
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static List<TaoBaoOrder> mixTaoBaoOrder(List<TaoBaoOrder> commonOrderList, List<TaoBaoOrder> sorderList) {
        Map<String, List<TaoBaoOrder>> commonMap = TaoBaoOrderUtil.classifyTaoBaoOrderByOrderId(commonOrderList);
        Map<String, List<TaoBaoOrder>> sMap = TaoBaoOrderUtil.classifyTaoBaoOrderByOrderId(sorderList);
        // 获取订单交集
        Iterator<String> its = commonMap.keySet().iterator();
        List<String> commonOrderIdList = new ArrayList<>();
        List<String> sOrderIdList = new ArrayList<>();
        while (its.hasNext()) {
            String orderId = its.next();
            commonOrderIdList.add(orderId);
        }
        its = sMap.keySet().iterator();
        while (its.hasNext()) {
            String orderId = its.next();
            sOrderIdList.add(orderId);
        }

        // 求交集
        commonOrderIdList.retainAll(sOrderIdList);

        List<TaoBaoOrder> orderList = new ArrayList<>();

        for (String orderId : commonOrderIdList) {
            List<TaoBaoOrder> list = commonMap.get(orderId);
            String specialId = sMap.get(orderId).get(0).getSpecialId();
            String relationId = sMap.get(orderId).get(0).getRelationId();
            for (TaoBaoOrder to : list) {
                to.setSpecialId(specialId);
                to.setRelationId(relationId);
                orderList.add(to);
            }
        }

        return orderList;
    }

    public void addOrder(List<TaoBaoOrder> orderList) {

        if (orderList != null)
            for (int i = 0; i < orderList.size(); i++) {
                LogHelper.orderInfo("常规订单爬取:" + orderList.get(i).getOrderId());
                // 移除会员运营ID与渠道专属订单
                if (orderList.get(i).getAdPositionName().contains("会员运营")
                        || orderList.get(i).getAdPositionName().contains("渠道专属")) {
                    if (orderList.get(i).getAdPositionName().contains("会员运营")) {// 处理订单申诉
                        Order order = orderService.findOrderByOrderIdAndType(orderList.get(i).getOrderId(),
                                Order.ORDER_TYPE_TAOBAO);
                        if (order != null && order.getBeizhu().contains("补单")) {// 不排除补单的情况

                        } else {
                            orderList.remove(i);
                            i--;
                            break;
                        }
                    } else {
                        orderList.remove(i);
                        i--;
                    }
                }
            }

        try {
            taoBaoOrderService.addTaoBaoOrderList(orderList);
        } catch (Exception e) {
            LogHelper.errorDetailInfo(e);
        }

        try {
            Map<String, List<TaoBaoOrder>> map = TaoBaoOrderUtil.classifyTaoBaoOrderByOrderId(orderList);
            if (map != null) {
                Iterator<String> its = map.keySet().iterator();
                while (its.hasNext()) {
                    String key = its.next();
                    String redisKey = RedisKeyEnum.getRedisKey(RedisKeyEnum.addOrderQueue, key);
                    // redis做频率限制
                    try {
                        if (!StringUtil.isNullOrEmpty(redisManager.getCommonString(redisKey))) {
                            continue;
                        }

                    } catch (Exception e) {

                    }

                    rabbitmqManager.addTaoBaoOrderMsg(key);

                    try {
                        // 6小时内不再处理
                        redisManager.cacheCommonString(redisKey, "1", 60 * 60 * 6);
                    } catch (Exception e) {

                    }
                }
            }
        } catch (Exception e) {
            LogHelper.errorDetailInfo(e);
        }
    }

    private void doTaoBaoWeiQuanOrder(int day) {

        for (int i = 0; i < day; i++) {
            List<TaoBaoWeiQuanOrder> orderList = new ArrayList<>();

            // 按照维权发起时间查询
            WeiQuanOrderResult result = TaoKeOrderApiUtil
                    .getTaoBaoSpecialWeiQuanOrderList(new Date(TimeUtil.convertToTimeTemp(
                            TimeUtil.getGernalTime(System.currentTimeMillis() - 1000 * 60 * 60 * 24L * i, "yyyy-MM-dd"),
                            "yyyy-MM-dd")), 1, 1, false);
            orderList.addAll(result.orderList);
            // 第三方
            result = TaoKeOrderApiUtil.getTaoBaoSpecialWeiQuanOrderList(new Date(TimeUtil.convertToTimeTemp(
                    TimeUtil.getGernalTime(System.currentTimeMillis() - 1000 * 60 * 60 * 24L * i, "yyyy-MM-dd"),
                    "yyyy-MM-dd")), 1, 1, true);
            orderList.addAll(result.orderList);

            result = TaoKeOrderApiUtil.getTaoBaoRelationWeiQuanOrderList(new Date(TimeUtil.convertToTimeTemp(
                    TimeUtil.getGernalTime(System.currentTimeMillis() - 1000 * 60 * 60 * 24L * i, "yyyy-MM-dd"),
                    "yyyy-MM-dd")), 1, 1, false);
            orderList.addAll(result.orderList);

            // 第三方
            result = TaoKeOrderApiUtil.getTaoBaoRelationWeiQuanOrderList(new Date(TimeUtil.convertToTimeTemp(
                    TimeUtil.getGernalTime(System.currentTimeMillis() - 1000 * 60 * 60 * 24L * i, "yyyy-MM-dd"),
                    "yyyy-MM-dd")), 1, 1, true);
            orderList.addAll(result.orderList);

            /**
             * 按照维权完成时间查询
             */

            result = TaoKeOrderApiUtil.getTaoBaoSpecialWeiQuanOrderList(new Date(TimeUtil.convertToTimeTemp(
                    TimeUtil.getGernalTime(System.currentTimeMillis() - 1000 * 60 * 60 * 24L * i, "yyyy-MM-dd"),
                    "yyyy-MM-dd")), 3, 1, false);
            orderList.addAll(result.orderList);
            // 第三方
            result = TaoKeOrderApiUtil.getTaoBaoSpecialWeiQuanOrderList(new Date(TimeUtil.convertToTimeTemp(
                    TimeUtil.getGernalTime(System.currentTimeMillis() - 1000 * 60 * 60 * 24L * i, "yyyy-MM-dd"),
                    "yyyy-MM-dd")), 3, 1, true);
            orderList.addAll(result.orderList);

            result = TaoKeOrderApiUtil.getTaoBaoRelationWeiQuanOrderList(new Date(TimeUtil.convertToTimeTemp(
                    TimeUtil.getGernalTime(System.currentTimeMillis() - 1000 * 60 * 60 * 24L * i, "yyyy-MM-dd"),
                    "yyyy-MM-dd")), 3, 1, false);
            orderList.addAll(result.orderList);

            // 第三方
            result = TaoKeOrderApiUtil.getTaoBaoRelationWeiQuanOrderList(new Date(TimeUtil.convertToTimeTemp(
                    TimeUtil.getGernalTime(System.currentTimeMillis() - 1000 * 60 * 60 * 24L * i, "yyyy-MM-dd"),
                    "yyyy-MM-dd")), 3, 1, true);
            orderList.addAll(result.orderList);

            for (TaoBaoWeiQuanOrder order : orderList)
                taoBaoWeiQuanOrderService.addWeiQuanOrder(order);// 添加维权订单到数据库
            // 处理维权订单
            orderProcessService.weiQuanOrder(orderList);
        }

    }

    public void updateLocalTaoBaoOrder(Long startTime, Long endTime, int page, int count) {
        List<TaoBaoOrder> list = taoBaoOrderService.listBySettlementTime(startTime, endTime, page, count);
        Set<String> orderIds = new HashSet<>();
        for (TaoBaoOrder co : list) {
            orderIds.add(co.getOrderId());
        }
        for (Iterator<String> its = orderIds.iterator(); its.hasNext(); ) {
            String orderId = its.next();
            // 查询是否有处于订单付款状态的单
            List<CommonOrder> commonOrderList = commonOrderService
                    .listBySourceTypeAndOrderId(Constant.SOURCE_TYPE_TAOBAO, orderId);
            boolean update = false;
            if (commonOrderList != null)
                for (CommonOrder co : commonOrderList) {
                    if (co.getState() == CommonOrder.STATE_FK && co.getPayment().compareTo(new BigDecimal(0)) > 0) {
                        update = true;
                        break;
                    }
                }
            if (update) {
                List<TaoBaoOrder> orderList = taoBaoOrderService.getTaoBaoOrderByOrderId(orderId);
                Map<String, List<TaoBaoOrder>> orders = new HashMap<>();
                orders.put(orderId, orderList);
                orderProcessService.processOrder(orders);
            }
        }
    }

    @XxlJob("updateTaoBaoCommonOrderHandler")
    public ReturnT<String> updateTaoBaoCommonOrder(String param) throws Exception {
        if ("1".equalsIgnoreCase(param)) {// 更新近20分钟内的单
            pullLatestCommonOrder();
        } else if ("1day".equalsIgnoreCase(param)) {// 爬取最近1天的订单(30分钟一次)
            pullLatestDayCommonOrder();
        } else if ("3day".equalsIgnoreCase(param)) {
            pullLatest3DayCommonOrder();
        }
        return ReturnT.SUCCESS;
    }


    /**
     * 处理淘宝订单
     *
     * @param param 订单号
     * @return
     * @throws Exception
     */
    @XxlJob("processTaoBaoOrder")
    public ReturnT<String> processTaoBaoOrder(String param) throws Exception {
        String[] orderIds = param.split(",");
        if (orderIds == null || orderIds.length == 0)
            throw new Exception("订单不存在");

        for (String orderId : orderIds) {
            List<TaoBaoOrder> orderList = taoBaoOrderService.getTaoBaoOrderByOrderId(orderId);
            if (orderList == null || orderList.size() == 0)
                continue;
            orderProcessService.processOrder(TaoBaoOrderUtil.classifyTaoBaoOrderByOrderId(orderList));
        }
        return ReturnT.SUCCESS;
    }

    // 淘宝推广订单 每隔1分执行一次
    private void pullLatestCommonOrder() {
        LogHelper.job("pullLatestCommonOrder");
        Date systemDate =new Date(); //TaoKeApiUtil.getTaoBaoSystemTime();
        long endTime = systemDate != null ? systemDate.getTime() : System.currentTimeMillis();
        updateOrder(endTime - 1000 * 60 * 20L, endTime);
    }

    // 爬取最近一天的常规订单（30分钟一次）
    private void pullLatestDayCommonOrder() {
        LogHelper.job("pullLatestCommonOrder");
        Date systemDate = new Date();//TaoKeApiUtil.getTaoBaoSystemTime();
        long endTime = systemDate != null ? systemDate.getTime() : System.currentTimeMillis();
        updateOrder(endTime - 1000 * 60 * 60 * 24L, endTime);
    }

    // 爬取最近三天的常规订单（6个小时一次）
    private void pullLatest3DayCommonOrder() {
        LogHelper.job("pullLatestCommonOrder");
        Date systemDate = new Date();//TaoKeApiUtil.getTaoBaoSystemTime();
        long endTime = systemDate != null ? systemDate.getTime() : System.currentTimeMillis();
        updateOrder(endTime - 1000 * 60 * 60 * 24 * 3L, endTime);
    }

    // 5分钟执行一次
    @XxlJob("ownBuyFanLiHandler")
    public ReturnT<String> ownBuyFanLi(String param) throws Exception {
        LogHelper.job("处理返利到账前置");
        try {
            doTaoBaoWeiQuanOrder(2);
        } catch (Exception e) {
            LogHelper.errorDetailInfo(e);
        }
        LogHelper.job("开始处理返利");
        orderProcessService.fanli();
        return ReturnT.SUCCESS;
    }

    @XxlJob("taoBaoWeiQuanOrderHandler")
    public ReturnT<String> doTaoBaoWeiQuan(String param) throws Exception {
        LogHelper.job("维权订单爬取");
        doTaoBaoWeiQuanOrder(5);
        return ReturnT.SUCCESS;
    }

    // 处理找回订单
    @XxlJob("doLostOrderHandler")
    public ReturnT<String> doLostOrder(String param) throws Exception {
        if ("fail".equalsIgnoreCase(param)) {// 更新最近的本地单(30分钟更新一次)
            doFailLostOrder();
        } else if ("success".equalsIgnoreCase(param)) {// 处理最近5天的本地订单
            addLostOrder();
        }
        return ReturnT.SUCCESS;
    }

    // 处理订单找回失败的情况 每6个小时执行一次
    private void doFailLostOrder() {
        LogHelper.job("处理丢失订单自动找回失败的情况");
        lostOrderService.processFail();
    }

    // 每2分钟执行一次
    private void addLostOrder() {
        LogHelper.job("处理丢失订单");
        List<LostOrder> list = lostOrderService.listByStateAndResultCode(LostOrder.STATE_PASS,
                LostOrder.RESULT_CODE_VERFING, 1, 50);
        if (list != null)
            for (LostOrder lo : list) {
                List<TaoBaoOrder> taoBaoOrderList = taoBaoOrderService.getTaoBaoOrderByOrderId(lo.getOrderId());
                // 清除频率限制
                if (taoBaoOrderList != null && taoBaoOrderList.size() > 0) {
                    String key = RedisKeyEnum.getRedisKey(RedisKeyEnum.addOrderQueue, lo.getOrderId());

                    redisManager.removeCommonString(key);
                    addOrder(taoBaoOrderList);
                    LogHelper.test("自动处理淘宝订单:" + lo.getOrderId());
                }
            }
    }

    // 处理淘宝本地订单
    @XxlJob("doLocalTaoBaoOrder")
    public ReturnT<String> updatePDDOrder(String param) throws Exception {
        if ("1".equalsIgnoreCase(param)) {// 更新最近的本地单(30分钟更新一次)
            doLatestLocalTaoBaoOrder();
        } else if ("5day".equalsIgnoreCase(param)) {// 处理最近5天的本地订单
            doLatest5DayLocalTaoBaoOrder();
        }
        return ReturnT.SUCCESS;
    }


    @XxlJob("order-updateTaoBaoOrderByOrderId")
    public ReturnT<String> updateTaoBaoOrderByOrderId(String param) throws Exception {
        List<TaoBaoOrder> orderList = taoBaoOrderService.getTaoBaoOrderByOrderId(param);
        Map<String, List<TaoBaoOrder>> orders = new HashMap<>();
        orders.put(param, orderList);
        orderProcessService.processOrder(orders);
        return ReturnT.SUCCESS;
    }


    /**
     * 更新最近的本地单(30分钟更新一次)
     */
    private void doLatestLocalTaoBaoOrder() {
        Long endTime = System.currentTimeMillis() - 1000 * 60 * 10L;
        Long startTime = endTime - 1000 * 60 * 60 * 12L;
        updateLocalTaoBaoOrder(startTime, endTime, 1, 2000);
    }

    /**
     * 处理最近5天的本地订单
     */
    private void doLatest5DayLocalTaoBaoOrder() {
        LogHelper.job("doLatest5DayLocalTaoBaoOrder");
        Long endTime = System.currentTimeMillis() - 1000 * 60 * 60 * 12L;
        Long startTime = endTime - 1000 * 60 * 60 * 24 * 5L;
        long count = taoBaoOrderService.countBySettlementTime(startTime, endTime);
        int pageSize = 100;
        long page = count % pageSize == 0 ? count / pageSize : count / pageSize + 1;
        for (int i = 0; i < page; i++) {
            updateLocalTaoBaoOrder(startTime, endTime, i + 1, pageSize);
        }
    }

    // 淘宝商家跑路订单 每月25号12点处理上月的
    @XxlJob("doTaoBaoSellerNotPayOrderHandler")
    public ReturnT<String> doSellerNotPayOrder(String param) throws Exception {
        LogHelper.job("doSellerNotPayOrder");
        Calendar calender = Calendar.getInstance();
        long endTime = TimeUtil.convertToTimeTemp(TimeUtil.getGernalTime(calender.getTimeInMillis(), "yyyy-MM"),
                "yyyy-MM");
        calender.add(Calendar.MONTH, -1);
        long startTime = TimeUtil.convertToTimeTemp(TimeUtil.getGernalTime(calender.getTimeInMillis(), "yyyy-MM"),
                "yyyy-MM");
        // 商家未付款
        List<TaoBaoOrder> orderList = taoBaoOrderService.listByStateAndCreateTime("订单成功", new Date(startTime),
                new Date(endTime));

        if (orderList != null)
            for (TaoBaoOrder order : orderList)
                try {
                    orderProcessService.doTaoBaoSellerNotPaid(order);
                } catch (Exception e) {
                    LogHelper.errorDetailInfo(e);
                }
        return ReturnT.SUCCESS;
    }

}