淘宝转链接口更新

admin

2025-02-25 30d8e227e8d823b6c38c3b9c90ac2df03b63befe

 fanli/src/main/java/com/yeshi/fanli/service/impl/order/LostOrderServiceImpl.java

@@ -1,253 +1,370 @@
package com.yeshi.fanli.service.impl.order;



import java.io.Serializable;

import java.util.List;

import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;

import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;



import javax.annotation.Resource;



import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import org.yeshi.utils.NumberUtil;



import com.yeshi.fanli.dao.mybatis.order.LostOrderMapper;

import com.yeshi.fanli.dao.order.LostOrderDao;

import com.yeshi.fanli.dao.order.PidOrderDao;

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

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

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

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

import com.yeshi.fanli.util.Constant;

import com.yeshi.fanli.util.Utils;



@Service

public class LostOrderServiceImpl implements LostOrderService {



   @Resource

   private OrderService orderService;



   @Resource

   private LostOrderDao lostOrderDao;



   @Resource

   private PidOrderDao pidOrderDao;



   @Resource

   private LostOrderMapper lostOrderMapper;



   @Override

   public int addLostOrder(LostOrder lostOrder) {

      String orderId = lostOrder.getOrderId();

      Integer type = lostOrder.getType();

      if (type == null) { // 默认为淘宝订单

         lostOrder.setType(1);

         type = 1;

      }



      // 查询是否提交

      List<LostOrder> orderList = lostOrderMapper.selectByOrderId(orderId);

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

         if (orderList.get(0).getState() == 0) {

            return -2;

         } else {

            return -1;

         }

      }



      Order order = orderService.findOrderByOrderIdAndType(orderId, type);

      if (order != null) {

         return -3;

      }



      // 查询是否为分享赚订单

      if (pidOrderDao.list("from PidOrder p where p.orderId=?", new Serializable[] { orderId }).size() > 0)

         return -5;



      WriteLock lostOrderwriteLock = lostOrderLock.writeLock();

      ReadLock lostOrderReadLock = lostOrderLock.readLock();

      try {

         try {

            lostOrderwriteLock.lock();

            List<LostOrder> list = lostOrderDao.list(

                  "from LostOrder lo where lo.orderId= ? and lo.type = ? and (lo.state = 0 or lo.state = 1)", 0,

                  1, new Serializable[] { orderId, type });

            if (list.size() > 0) {

               LostOrder find = list.get(0);

               Integer state = find.getState();

               if (state == 0) {

                  return -2;

               } else if (state == 1) {

                  return -1;

               }

            }

         } finally {

            lostOrderReadLock.lock();

            lostOrderwriteLock.unlock();

         }

         lostOrder.setState(0);

         lostOrder.setHandleTime(0L);

         lostOrder.setCreateTime(System.currentTimeMillis());

         Order or = orderService.getSystemOrderByUid(Constant.TAOBAO, lostOrder.getUserInfo().getId());

         if (or != null) {

            boolean b = Utils.isUserOrder(or.getOrderId(), lostOrder.getOrderId());

            if (b) {

               lostOrder.setJudge("匹配");



            } else {

               lostOrder.setJudge("不匹配");

            }

         } else {

            lostOrder.setJudge("不匹配");

         }

         lostOrderDao.save(lostOrder);

      } finally {

         lostOrderReadLock.unlock();

      }

      return 0;

   }



   public void pass(LostOrder lostOrder) {

      Order order = new Order();

      order.setBeizhu("补单");

      order.setCreatetime(lostOrder.getCreateTime());

      order.setOrderId(lostOrder.getOrderId());

      order.setOrderType(lostOrder.getType());

      order.setState(1);

      order.setUserInfo(lostOrder.getUserInfo());

      try {

         boolean b = orderService.addOrder(order);

         if (b) {

            lostOrder.setRemake("处理成功");

            lostOrder.setState(1);

            lostOrder.setOrder(order);

         } else {

            lostOrder.setRemake("订单已存在!");

            lostOrder.setState(2);

         }

      } catch (Exception e) {

         e.printStackTrace();

         String message = e.getMessage();

         if (message.length() > 255) {

            message = message.substring(0, 255);

         }

         lostOrder.setRemake(e.getMessage());

         lostOrder.setState(2);

      }

      lostOrder.setHandleTime(System.currentTimeMillis());

      lostOrderDao.update(lostOrder);

   }



   public void reject(LostOrder lostOrder) {

      lostOrder.setHandleTime(System.currentTimeMillis());

      lostOrder.setState(2);

      lostOrderDao.update(lostOrder);

   }



   @Override

   public List<LostOrder> findLostOrderList(String key, int page) {

      List<LostOrder> list;

      if (key == null || "".equals(key.trim())) {

         list = lostOrderDao.list("from LostOrder lo order by id desc", (page - 1) * Constant.PAGE_SIZE,

               Constant.PAGE_SIZE, new Serializable[] {});

      } else {

         if (NumberUtil.isNumeric(key) && key.length() >= 18) {

            // long id = Long.parseLong(key);

            list = lostOrderDao.list("from LostOrder lo where lo.orderId like ? order by id desc",

                  (page - 1) * Constant.PAGE_SIZE, Constant.PAGE_SIZE, new Serializable[] { "%" + key + "%" });



         } else {



            list = lostOrderDao.list("from LostOrder lo where lo.userInfo.nickName like ? order by id desc",

                  (page - 1) * Constant.PAGE_SIZE, Constant.PAGE_SIZE, new Serializable[] { "%" + key + "%" });

         }



      }

      return list;

   }



   @Override

   public int getCount(String key) {

      int count = 0;

      if (key == null || "".equals(key.trim())) {

         count = (int) lostOrderDao.getCount("select count(*) from LostOrder");

      } else {



         if (NumberUtil.isNumeric(key) && key.length() >= 18) {

            // long id = Long.parseLong(key);

            count = (int) lostOrderDao.getCount("select count(*) from LostOrder lo where lo.orderId like ?",

                  new Serializable[] { "%" + key + "%" });

         } else {



            count = (int) lostOrderDao.getCount(

                  "select count(*) from LostOrder lo where lo.userInfo.nickName like ?",

                  new Serializable[] { "%" + key + "%" });

         }

      }

      return count;

   }



   @Override

   public LostOrder getOne(long id) {

      return lostOrderDao.find(LostOrder.class, id);

   }



   @Override

   public List<LostOrder> getLostOrderListByUid(Long uid, int page, int pageSize) {



      return lostOrderDao.list("from LostOrder lo where lo.userInfo.id=? order by lo.createTime desc",

            (page - 1) * pageSize, pageSize, new Serializable[] { uid });

   }



   @Override

   public long getLostOrderCountByUid(Long uid) {

      return lostOrderDao.getCount("select count(*)  from LostOrder lo where lo.userInfo.id=?",

            new Serializable[] { uid });

   }



   @Transactional

   @Override

   public void processSuceess(String orderId) {

      // 查询订单号是否在申诉列表中

      List<LostOrder> list = lostOrderMapper.selectByOrderId(orderId);

      if (list == null || list.size() == 0)

         return;

      for (LostOrder lo : list) {

         if (lo.getState() == 1 && lo.getResultCode() != null

               && lo.getResultCode() == LostOrder.RESULT_CODE_VERFING) {

            LostOrder update = new LostOrder();

            update.setId(lo.getId());

            update.setResultCode(LostOrder.RESULT_CODE_SUCCESS);

            lostOrderMapper.updateByPrimaryKeySelective(update);

         }

      }

   }



   @Override

   public void processFail(String orderId) {

      lostOrderDao.update("update LostOrder lo set lo.resultCode=? where lo.orderId=?",

            new Serializable[] { LostOrder.RESULT_CODE_FAIL, orderId });

   }



   @Override

   public void processFail() {

      // 订单申诉人工通过后，但是隔了3天还未处理成功就视为该订单申诉失败

      lostOrderDao.update(

            "update LostOrder lo set lo.resultCode=? where lo.state=1 and lo.resultCode=? and lo.handleTime<?",

            new Serializable[] { LostOrder.RESULT_CODE_FAIL, LostOrder.RESULT_CODE_VERFING,

                  System.currentTimeMillis() - 1000 * 60 * 60 * 24 * 3L });

   }



   @Override

   public void deleteLostOrder(long id) {

      LostOrder lostOrder = new LostOrder();

      lostOrder.setId(id);

      lostOrderDao.delete(lostOrder);

   }



   @Override

   public void deleteLostOrderByUid(long uid) {

      lostOrderDao.update("delete from LostOrder lo where lo.userInfo.id=?", new Serializable[] { uid });

   }



}

package com.yeshi.fanli.service.impl.order;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

import javax.annotation.Resource;

import com.yeshi.fanli.entity.SystemEnum;
import com.yeshi.fanli.entity.bus.user.UserInfo;
import com.yeshi.fanli.entity.taobao.TaoBaoWeiQuanOrder;
import com.yeshi.fanli.service.inter.order.tb.TaoBaoWeiQuanOrderService;
import com.yeshi.fanli.service.inter.user.UserInfoService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.yeshi.fanli.dao.mybatis.order.LostOrderMapper;
import com.yeshi.fanli.entity.bus.user.HongBaoV2;
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.order.HongBaoOrder;
import com.yeshi.fanli.entity.system.ConfigKeyEnum;
import com.yeshi.fanli.service.inter.config.ConfigService;
import com.yeshi.fanli.service.inter.order.HongBaoOrderService;
import com.yeshi.fanli.service.inter.order.LostOrderService;
import com.yeshi.fanli.service.inter.order.OrderService;
import com.yeshi.fanli.service.inter.order.msg.UserOrderMsgNotificationService;
import com.yeshi.fanli.service.inter.order.tb.TaoBaoPunishOrderService;
import com.yeshi.fanli.util.Constant;
import com.yeshi.fanli.util.Utils;

@Service
public class LostOrderServiceImpl implements LostOrderService {

    @Resource
    private OrderService orderService;

    @Resource
    private HongBaoOrderService hongBaoOrderService;

    @Resource
    private LostOrderMapper lostOrderMapper;

    @Resource
    private ConfigService configService;

    @Resource
    private UserOrderMsgNotificationService userOrderMsgNotificationService;

    @Resource
    private TaoBaoPunishOrderService taoBaoPunishOrderService;

    @Resource
    private UserInfoService userInfoService;

    @Resource
    private TaoBaoWeiQuanOrderService taoBaoWeiQuanOrderService;

    @Transactional
    @Override
    public int addLostOrder(LostOrder lostOrder) {
        String orderId = lostOrder.getOrderId();
        Integer type = lostOrder.getType();
        if (type == null) { // 默认为淘宝订单
            lostOrder.setType(1);
            type = 1;
        }

        // 是否处于违规订单中
        if (type == 1) {
            int count = taoBaoPunishOrderService.countByTradeParentId(orderId);
            if (count > 0) {
                return -1001;
            }
        }

        //是否处于维权订单中
        List<TaoBaoWeiQuanOrder> wqList = taoBaoWeiQuanOrderService.listByOrderId(orderId);
        if (wqList != null && wqList.size() > 0) {
            return -1002;
        }


        // 订单是否已申诉
        List<LostOrder> orderList = lostOrderMapper.selectByOrderIdAndType(orderId, type);
        if (orderList != null && orderList.size() > 0) {
            if (orderList.get(0).getState() == 0 || orderList.get(0).getResultCode() == LostOrder.RESULT_CODE_VERFING) {
                return -2;
            } else if (orderList.get(0).getState() == 1
                    && orderList.get(0).getResultCode() == LostOrder.RESULT_CODE_SUCCESS) {
                return -1;
            } else {
                return -6;
            }
        }

        // 订单已存在
        Order order = orderService.findOrderByOrderIdAndType(orderId, type);
        if (order != null) {
            return -3;
        }

        // 是否为分享赚订单
        if (hongBaoOrderService.countByOrderNoAndHongBaoType(orderId, HongBaoV2.TYPE_SHARE_GOODS, type) > 0)
            return -5;

        SystemEnum system = userInfoService.getUserSystem(lostOrder.getUserInfo().getId());

        // 次数限制
        long count = lostOrderMapper.countTodayAppeal(lostOrder.getUserInfo().getId());
        String countMax = configService.getValue(ConfigKeyEnum.orderAppealCountDay.getKey(), system);
        if (countMax != null && countMax.trim().length() > 0 && count >= Long.parseLong(countMax)) {
            return -7;
        }

        WriteLock lostOrderwriteLock = lostOrderLock.writeLock();
        ReadLock lostOrderReadLock = lostOrderLock.readLock();
        try {
            try {
                lostOrderwriteLock.lock();
                List<Integer> stateList = new ArrayList<>();
                stateList.add(0);
                stateList.add(1);
                List<LostOrder> list = lostOrderMapper.listByOrderIdAndTypeAndState(orderId, type, stateList);
                if (list.size() > 0) {
                    LostOrder find = list.get(0);
                    Integer state = find.getState();
                    if (state == 0) {
                        return -2;
                    } else if (state == 1) {
                        return -1;
                    }
                }
            } finally {
                lostOrderReadLock.lock();
                lostOrderwriteLock.unlock();
            }

            Order or = orderService.getSystemOrderByUid(type, lostOrder.getUserInfo().getId());
            if (or != null) {
                boolean b = Utils.isUserOrder(or.getOrderId(), lostOrder.getOrderId());
                if (b) {
                    lostOrder.setJudge("匹配");

                } else {
                    lostOrder.setJudge("不匹配");
                }
            } else {
                lostOrder.setJudge("不匹配");
            }

            try {
                Order addorder = new Order();
                addorder.setBeizhu("补单");
                addorder.setCreatetime(lostOrder.getCreateTime());
                addorder.setOrderId(lostOrder.getOrderId());
                addorder.setOrderType(lostOrder.getType());
                addorder.setState(1);
                addorder.setUserInfo(lostOrder.getUserInfo());

                boolean b = orderService.addOrder(addorder);
                if (b) {
                    lostOrder.setRemake("处理成功");
                    lostOrder.setState(LostOrder.STATE_PASS);
                    lostOrder.setOrder(order);
                } else {
                    lostOrder.setRemake("订单已存在!");
                    lostOrder.setState(LostOrder.STATE_REJECT);
                }
            } catch (Exception e) {
                e.printStackTrace();
                String message = e.getMessage();
                if (message.length() > 255) {
                    message = message.substring(0, 255);
                }
                lostOrder.setRemake(e.getMessage());
                lostOrder.setState(LostOrder.STATE_REJECT);
            }

            lostOrder.setResultCode(LostOrder.RESULT_CODE_VERFING);
            lostOrder.setHandleTime(System.currentTimeMillis());
            lostOrder.setCreateTime(System.currentTimeMillis());
            lostOrderMapper.insertSelective(lostOrder);

        } finally {
            lostOrderReadLock.unlock();
        }
        return 0;
    }

    public void pass(LostOrder lostOrder) {
        Order order = new Order();
        order.setBeizhu("补单");
        order.setCreatetime(lostOrder.getCreateTime());
        order.setOrderId(lostOrder.getOrderId());
        order.setOrderType(lostOrder.getType());
        order.setState(1);
        order.setUserInfo(lostOrder.getUserInfo());
        try {
            boolean b = orderService.addOrder(order);
            if (b) {
                lostOrder.setRemake("处理成功");
                lostOrder.setState(1);
                lostOrder.setOrder(order);
            } else {
                lostOrder.setRemake("订单已存在!");
                lostOrder.setState(2);
            }
        } catch (Exception e) {
            e.printStackTrace();
            String message = e.getMessage();
            if (message.length() > 255) {
                message = message.substring(0, 255);
            }
            lostOrder.setRemake(e.getMessage());
            lostOrder.setState(2);
        }
        lostOrder.setHandleTime(System.currentTimeMillis());
        lostOrder.setResultCode(LostOrder.RESULT_CODE_VERFING);
        lostOrderMapper.updateByPrimaryKeySelective(lostOrder);
    }

    public void reject(LostOrder lostOrder) {
        lostOrder.setHandleTime(System.currentTimeMillis());
        lostOrder.setState(2);
        lostOrderMapper.updateByPrimaryKeySelective(lostOrder);
    }

    @Override
    public LostOrder getOne(long id) {
        return lostOrderMapper.selectByPrimaryKey(id);
    }

    @Override
    public List<LostOrder> getLostOrderListByUid(Long uid, int page, int pageSize) {

        return lostOrderMapper.listByUidOrderByCreateTimeDesc(uid, (page - 1) * pageSize, pageSize);
    }

    @Override
    public long getLostOrderCountByUid(Long uid) {
        return lostOrderMapper.countAllByUid(uid);
    }

    @Transactional
    @Override
    public void processSuceess(String orderId, int orderType) {
        // 查询订单号是否在申诉列表中
        List<LostOrder> list = lostOrderMapper.selectByOrderIdAndType(orderId, orderType);
        if (list == null || list.size() == 0)
            return;
        for (LostOrder lo : list) {
            if (lo.getState() == LostOrder.STATE_PASS && lo.getResultCode() != null
                    && lo.getResultCode() == LostOrder.RESULT_CODE_VERFING) {
                LostOrder update = new LostOrder();
                update.setId(lo.getId());
                update.setResultCode(LostOrder.RESULT_CODE_SUCCESS);
                lostOrderMapper.updateByPrimaryKeySelective(update);
                Order order = orderService.findOrderByOrderIdAndType(orderId, orderType);

                List<HongBaoOrder> hongBaoOrderList = hongBaoOrderService.listDetailByOrderIdAndSourceType(orderId,
                        orderType);
                int goodsCount = 0;
                BigDecimal fanMoney = new BigDecimal(0);
                for (HongBaoOrder hongBaoOrder : hongBaoOrderList) {
                    if (hongBaoOrder.getCommonOrder().getState() != CommonOrder.STATE_SX) {
                        goodsCount += hongBaoOrder.getCommonOrder().getCount();
                        fanMoney = fanMoney.add(hongBaoOrder.getHongBaoV2().getMoney());
                    }
                }

                if (order != null)
                    userOrderMsgNotificationService.orderFoundSuccess(lo.getUserInfo().getId(), orderId, orderType,
                            Constant.TYPE_REBATE, order.getMoney(), fanMoney, goodsCount, new Date(lo.getCreateTime()));
            }
        }
    }

    @Override
    public void processFail(String orderId, int orderType) {
        List<LostOrder> list = lostOrderMapper.selectByOrderIdAndType(orderId, orderType);
        if (list != null)
            for (LostOrder order : list) {
                LostOrder update = new LostOrder();
                update.setId(order.getId());
                update.setResultCode(LostOrder.RESULT_CODE_FAIL);
                lostOrderMapper.updateByPrimaryKeySelective(update);
                // 添加通知
                userOrderMsgNotificationService.orderFoundFail(order.getUserInfo().getId(), order.getOrderId());
            }
    }

    @Override
    public void processFail() {
        // 订单申诉人工通过后，但是隔了3天还未处理成功就视为该订单申诉失败
        List<LostOrder> list = lostOrderMapper.listByMaxHandleTimeAndStateAndResultCode(
                System.currentTimeMillis() - 1000 * 60 * 60 * 24 * 3L, LostOrder.STATE_PASS,
                LostOrder.RESULT_CODE_VERFING);
        if (list != null)
            for (LostOrder order : list) {
                LostOrder update = new LostOrder();
                update.setId(order.getId());
                update.setResultCode(LostOrder.RESULT_CODE_FAIL);
                lostOrderMapper.updateByPrimaryKeySelective(update);
                // 添加通知
                userOrderMsgNotificationService.orderFoundFail(order.getUserInfo().getId(), order.getOrderId());
            }
    }

    @Override
    public void deleteLostOrder(long id) {
        lostOrderMapper.deleteByPrimaryKey(id);
    }

    @Override
    public void deleteLostOrderByUid(long uid) {

        lostOrderMapper.deleteByUid(uid);
    }

    @Override
    public Map<String, Object> countByUid(long uid) {
        return lostOrderMapper.countByUid(uid);
    }

    /**
     * 后端列表查询
     *
     * @param start
     * @param count
     * @param key
     * @return
     */
    @Override
    public List<LostOrder> listQuery(long start, int count, String key, Integer state, Integer handleType,
                                     Integer type, SystemEnum system) {
        return lostOrderMapper.listQuery(start, count, key, state, handleType, type, system);
    }

    @Override
    public long countQuery(String key, Integer state, Integer handleType, Integer type, SystemEnum system) {
        return lostOrderMapper.countQuery(key, state, handleType, type, system);
    }

    @Override
    public Integer countLostOrderNum(String preDay, int resultCode) {
        return lostOrderMapper.countLostOrderNum(preDay, resultCode);
    }

    @Override
    public BigDecimal countAppealMoney(String preDay) {
        return lostOrderMapper.countAppealMoney(preDay);
    }

    @Override
    public List<LostOrder> listByStateAndResultCode(int state, int resultCode, int page, int pageSize) {
        return lostOrderMapper.listByStateAndResultCode(state, resultCode, (page - 1) * pageSize, pageSize);
    }

    @Override
    public void saveLostOrder(LostOrder lostOrder) {
        lostOrderMapper.insertSelective(lostOrder);
    }

}