订单bug，分享爆款自购修改

admin

2019-07-11 3824cbcaec6e6c67418d5280a53e9c2fedeef6f9

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

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



import java.io.Serializable;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

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

@@ -14,14 +11,14 @@


import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import org.yeshi.utils.DateUtil;

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.service.inter.config.ConfigService;

import com.yeshi.fanli.service.inter.msg.UserOrderMsgNotificationService;

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

@@ -34,14 +31,18 @@
   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;



   @Transactional

   @Override

   public int addLostOrder(LostOrder lostOrder) {

      String orderId = lostOrder.getOrderId();

@@ -51,8 +52,8 @@
         type = 1;

      }



      // 查询是否提交

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

      // 订单是否已申诉

      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;

@@ -64,23 +65,32 @@
         }

      }



      // 订单已存在

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

         return -5;



      // 次数限制

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

      String countMax = configService.get("order_appeal_count_day");

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

@@ -94,9 +104,7 @@
            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());

@@ -109,7 +117,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();

      }

@@ -145,119 +186,96 @@
      }

      lostOrder.setHandleTime(System.currentTimeMillis());

      lostOrder.setResultCode(LostOrder.RESULT_CODE_VERFING);

      lostOrderDao.update(lostOrder);

      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, Order.ORDER_TYPE_TAOBAO);

            if (order != null)

               // 添加通知

               userOrderMsgNotificationService.orderFoundSuccess(lo.getUserInfo().getId(), lo.getOrderId(),

                     order.getMoney(), 1, new Date(lo.getHandleTime()));

         }

      }

   }



   @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(), null, 1,

                  new Date(order.getHandleTime()));

         }

   }



   @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(), null, 1,

                  new Date(order.getHandleTime()));

         }

   }



   @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

@@ -282,156 +300,27 @@
   public long countQuery(String key, Integer state, Integer handleType) {

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

   }

	
	


   @Override

   public List<Map<String, Object>> countLostNum( Integer dateType, Integer resultCode, 
         String year, String startTime, String endTime) throws Exception {

		
      List<Map<String, Object>> list = lostOrderMapper.countLostNum(dateType, resultCode, year, startTime, endTime);

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

         return null;

      } 
		
      switch (dateType){

         case 1: // 按天处理

            return dayFactory(startTime, endTime, list);

         case 2: // 按月处理

            return monthFactory(list);

         case 3: 
            return yearFactory(list);

         default: 
            return null;

      }

   }

	
	
   @Override

   public List<Map<String, Object>> countAppealMoney( Integer dateType, String year, String startTime, 
   public List<Map<String, Object>> countLostNum(Integer dateType, Integer resultCode, String year, String startTime,

         String endTime) throws Exception {

		
      List<Map<String, Object>> list = lostOrderMapper.countAppealMoney(dateType, year, startTime, endTime);

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

         return null;

      } 
		
      switch (dateType){

         case 1: // 按天处理

            return dayFactory(startTime, endTime, list);

         case 2: // 按月处理

            return monthFactory(list);

         case 3: 
            return yearFactory(list);

         default: 
            return null;

      }

   }

	
   public List<Map<String, Object>> dayFactory(String startTime, String endTime, List<Map<String, Object>> list) throws Exception {



      List<Map<String, Object>> listObject = new ArrayList<Map<String, Object>>();



      if (startTime.equals(endTime)) {



         Map<String, Object> map = list.get(0);

         Object total = map.get("showValue");

         if (total == null) {

            map.put("showValue", 0);

         }

         listObject.add(map);

         return listObject;

      }



      String plusDay = "";

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

         if (i == 0) {

            plusDay = startTime;

         } else {

            plusDay = DateUtil.plusDay(i, startTime);

         }



         Map<String, Object> mapObject = new HashMap<String, Object>();

         Object total = null;



         for (int j = 0; j < list.size(); j++) {

            Map<String, Object> map = list.get(j);

            Object createDate = map.get("showDate");

            String month = createDate.toString();

            if (plusDay.equalsIgnoreCase(month)) {

               total = map.get("showValue");

               break;

            }

         }



         if (total == null) {

            total = 0;

         }

         mapObject.put("showValue", total);



         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

         SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd");

         Date parseDate = sdf.parse(plusDay.toString());



         mapObject.put("showDate", sdf2.format(parseDate));



         listObject.add(mapObject);



         if (plusDay.equals(endTime)) {

            break; // 时间结束

         }

      }



      return listObject;

      return lostOrderMapper.countLostNum(dateType, resultCode, year, startTime, endTime);

   }



   public List<Map<String, Object>> monthFactory(List<Map<String, Object>> list) {



      List<Map<String, Object>> listObject = new ArrayList<Map<String, Object>>();

      // 12 个月处理

      for (int i = 1; i <= 12; i++) {

         Map<String, Object> mapObject = new HashMap<String, Object>();

         Object total = null;



         for (int j = 0; j < list.size(); j++) {

            Map<String, Object> map = list.get(j);

            Object createDate = map.get("showDate");

            String month = createDate.toString();

            if ((i + "").equalsIgnoreCase(month) || i == Integer.parseInt(month)) {

               total = map.get("total");

               break;

            }

         }



         if (total == null) {

            total = 0;

         }

         mapObject.put("total", total);



         mapObject.put("showDate", i + "月");



         listObject.add(mapObject);

      }

      return listObject;

   @Override

   public List<Map<String, Object>> countAppealMoney(Integer dateType, String year, String startTime, String endTime)

         throws Exception {

      return lostOrderMapper.countAppealMoney(dateType, year, startTime, endTime);

   }



   public List<Map<String, Object>> yearFactory(List<Map<String, Object>> list) {



      List<Map<String, Object>> listObject = new ArrayList<Map<String, Object>>();



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

         Map<String, Object> map = list.get(i);

         Object total = map.get("total");



         if (total == null) {

            total = 0;

         }

         map.put("total", total);



         listObject.add(map);

      }



      return listObject;

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

   }



}