淘宝转链接口更新

admin

2025-02-25 30d8e227e8d823b6c38c3b9c90ac2df03b63befe

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

@@ -1,527 +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.stereotype.Component;



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.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.OrderMoneySettleService;

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.service.inter.taobao.TaoBaoUnionConfigService;

import com.yeshi.fanli.util.CMQManager;

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 org.yeshi.utils.TimeUtil;

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

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

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



//从淘宝爬去订单更新

@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;





    /**

     * 新版获取普通订单

     *

     * @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) {



                    }



                    CMQManager.getInstance().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 = 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 = 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 = 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;

    }



}

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;
    }

}