fanli-server.git

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