2.1需求

yujian

2020-05-09 7e7db2fa55a9a3af46d4fd8ede0dee147f101d64

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

@@ -1,7 +1,10 @@
package com.yeshi.fanli.service.impl.order;



import java.io.Serializable;

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;



@@ -9,15 +12,20 @@


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



@@ -28,14 +36,21 @@
   private OrderService orderService;



   @Resource

   private LostOrderDao lostOrderDao;



   @Resource

   private PidOrderDao pidOrderDao;

   private HongBaoOrderService hongBaoOrderService;



   @Resource

   private LostOrderMapper lostOrderMapper;



   @Resource

   private ConfigService configService;



   @Resource

   private UserOrderMsgNotificationService userOrderMsgNotificationService;



   @Resource

   private TaoBaoPunishOrderService taoBaoPunishOrderService;



   @Transactional

   @Override

   public int addLostOrder(LostOrder lostOrder) {

      String orderId = lostOrder.getOrderId();

@@ -45,33 +60,53 @@
         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;

      // 是否处于违规订单中

      if (type == 1) {

         int count = taoBaoPunishOrderService.countByTradeParentId(orderId);

         if (count > 0) {

            return -1001;

         }

      }



      // 订单是否已申诉

      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 (pidOrderDao.list("from PidOrder p where p.orderId=?", new Serializable[] { orderId }).size() > 0)

      // 是否为分享赚订单

      if (hongBaoOrderService.countByOrderNoAndHongBaoType(orderId, HongBaoV2.TYPE_SHARE_GOODS, type) > 0)

         return -5;



      // 次数限制

      long count = lostOrderMapper.countTodayAppeal(lostOrder.getUserInfo().getId());

      String countMax = configService.get(ConfigKeyEnum.orderAppealCountDay.getKey());

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

            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();

@@ -85,10 +120,8 @@
            lostOrderReadLock.lock();

            lostOrderwriteLock.unlock();

         }

         lostOrder.setState(0);

         lostOrder.setHandleTime(0L);

         lostOrder.setCreateTime(System.currentTimeMillis());

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



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

         if (or != null) {

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

            if (b) {

@@ -100,7 +133,40 @@
         } else {

            lostOrder.setJudge("不匹配");

         }

         lostOrderDao.save(lostOrder);



         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();

      }

@@ -135,119 +201,150 @@
         lostOrder.setState(2);

      }

      lostOrder.setHandleTime(System.currentTimeMillis());

      lostOrderDao.update(lostOrder);

      lostOrder.setResultCode(LostOrder.RESULT_CODE_VERFING);

      lostOrderMapper.updateByPrimaryKeySelective(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;

      lostOrderMapper.updateByPrimaryKeySelective(lostOrder);

   }



   @Override

   public LostOrder getOne(long id) {

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

      return lostOrderMapper.selectByPrimaryKey(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 });

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

   }



   @Override

   public long getLostOrderCountByUid(Long uid) {

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

            new Serializable[] { uid });

      return lostOrderMapper.countAllByUid(uid);

   }



   @Transactional

   @Override

   public void processSuceess(String orderId) {

   public void processSuceess(String orderId, int orderType) {

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

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

      List<LostOrder> list = lostOrderMapper.selectByOrderIdAndType(orderId, orderType);

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

         return;

      for (LostOrder lo : list) {

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

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

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

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

   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天还未处理成功就视为该订单申诉失败

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

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

      LostOrder lostOrder = new LostOrder();

      lostOrder.setId(id);

      lostOrderDao.delete(lostOrder);

      lostOrderMapper.deleteByPrimaryKey(id);

   }



   @Override

   public void deleteLostOrderByUid(long uid) {

      lostOrderDao.update("delete from LostOrder lo where lo.userInfo.id=?", new Serializable[] { 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) {

      return lostOrderMapper.listQuery(start, count, key, state, handleType, type);

   }



   @Override

   public long countQuery(String key, Integer state, Integer handleType, Integer type) {

      return lostOrderMapper.countQuery(key, state, handleType, type);

   }



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

   }



}