Merge remote-tracking branch 'origin/div' into div

admin

2020-04-13 dd5b15229cb15459fa7c31ccea77dac28cbfafbd

 fanli/src/main/java/com/yeshi/fanli/service/impl/user/vip/UserVIPInfoServiceImpl.java

@@ -1,9 +1,5 @@
package com.yeshi.fanli.service.impl.user.vip;



import java.math.BigDecimal;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

@@ -17,18 +13,12 @@
import org.yeshi.utils.DateUtil;



import com.yeshi.fanli.dao.mybatis.user.vip.UserVIPInfoMapper;

import com.yeshi.fanli.dto.msg.MsgOtherVIPDTO;

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

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

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

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

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

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

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

import com.yeshi.fanli.entity.bus.user.vip.UserVIPInfo;

import com.yeshi.fanli.entity.bus.user.vip.UserVIPPreInfo;

import com.yeshi.fanli.entity.integral.IntegralDetail;

import com.yeshi.fanli.entity.shop.BanLiShopOrder;

import com.yeshi.fanli.entity.system.ConfigKeyEnum;

import com.yeshi.fanli.entity.system.SystemCoupon.CouponTypeEnum;

import com.yeshi.fanli.exception.user.vip.UserVIPInfoException;

import com.yeshi.fanli.service.inter.config.ConfigService;

@@ -41,11 +31,13 @@
import com.yeshi.fanli.service.inter.user.UserSystemCouponService;

import com.yeshi.fanli.service.inter.user.integral.IntegralDetailService;

import com.yeshi.fanli.service.inter.user.invite.ThreeSaleSerivce;

import com.yeshi.fanli.service.inter.user.invite.UserInviteValidNumService;

import com.yeshi.fanli.service.inter.user.msg.UserAccountMsgNotificationService;

import com.yeshi.fanli.service.inter.user.vip.UserVIPInfoService;

import com.yeshi.fanli.service.inter.user.vip.UserVIPPreInfoService;

import com.yeshi.fanli.service.inter.user.vip.UserVipConfigService;

import com.yeshi.fanli.util.Constant;

import com.yeshi.fanli.util.TimeUtil;

import com.yeshi.fanli.util.StringUtil;



@Service

public class UserVIPInfoServiceImpl implements UserVIPInfoService {

@@ -87,9 +79,15 @@
   @Lazy

   @Resource

   private UserSystemCouponService userSystemCouponService;

	


   @Resource

   private UserVIPPreInfoService userVIPPreInfoService;



   @Resource

   private UserAccountMsgNotificationService userAccountMsgNotificationService;

	
   @Resource

   private UserInviteValidNumService userInviteValidNumService;



   @Override

   @Transactional(rollbackFor = Exception.class)

@@ -107,162 +105,17 @@
      userVIPInfoMapper.insert(info);

   }



   @Transactional(rollbackFor = Exception.class)

   @Override

   public void passVIPApply(Long uid) throws UserVIPInfoException {

      UserVIPInfo userVIPInfo = userVIPInfoMapper.selectByPrimaryKeyForUpdate(uid);

      if (userVIPInfo == null) {

         throw new UserVIPInfoException(1, "用户信息不存在");

      }

      if (userVIPInfo.getState() != UserVIPInfo.STATE_VERIFING) {

         throw new UserVIPInfoException(2, "申请未处于审核状态");

      }



      if (!verifyConform(uid))

         throw new UserVIPInfoException(1, "系统验证：不满足升级条件");



      UserVIPInfo info = new UserVIPInfo();

      info.setId(userVIPInfo.getId());

      info.setSuccessTime(new Date());

      info.setState(UserVIPInfo.STATE_SUCCESS);

      info.setUpdateTime(new Date());

      userVIPInfoMapper.updateByPrimaryKeySelective(info);



      // 下级的超级会员 不脱离

      userInviteSeparateService.updateInvalidByBossId(uid);



      // 额外信息

      UserInfoExtra userInfoExtra = userInfoExtraService.getByUidForUpdate(uid);

      if (userInfoExtra == null)

         throw new UserVIPInfoException(1, "用户信息不存在");



      // 添加金币

      IntegralDetail detail = new IntegralDetail();

      detail.setTitle("升级VIP福利");

      detail.setUid(uid);

      detail.setMoney(Constant.VIP_COLDCOIN_NUM);

      detail.setCreateTime(new Date());

      detail.setUniqueKey("VIP-" + uid);

      integralDetailService.insertSelective(detail);

      userInfoExtraService.addGoldCoinByUid(uid, Constant.VIP_COLDCOIN_NUM);



      try {

         // 奖励券

         BigDecimal percent = new BigDecimal(configService.get(ConfigKeyEnum.exchangeRebatePercent.getKey()));

         for (int i = 0; i < Constant.VIP_COUPON_REWARD_NUM; i++) {

            userSystemCouponService.insertUserCoupon(uid, CouponTypeEnum.rebatePercentCoupon.name(),

                  UserSystemCoupon.SOURCE_SYSTEM_PUSH, percent, false);

         }



         // 赠送免单券

         for (int i = 0; i < Constant.VIP_COUPON_GIVEFREE_NUM; i++) {

            userSystemCouponService.insertUserCoupon(uid, CouponTypeEnum.freeCouponGive.name(),

                  UserSystemCoupon.SOURCE_SYSTEM_PUSH, null, false);

         }

      } catch (Exception e) {

         throw new UserVIPInfoException(1, "券赠送失败");

      }



      // 消息

      MsgOtherVIPDTO msgOther = new MsgOtherVIPDTO();

      msgOther.setContent1("恭喜你，已成为超级会员");

      msgOther.setContent2("满足升级条件");

      msgOther.setContent3(TimeUtil.formatDateDot(new Date()));

      userOtherMsgNotificationService.passVIPApplyMsg(uid, "返利奖励券和、赠送免单券和金币请到我的-福利中心中查看", msgOther);



      // 通知上级

      callBoss(uid);

   }



   /**

    * 通知上级脱离关系

    * 
    * @param uid

    */

   @Transactional

   private void callBoss(Long uid) {

      // 是否存在上级

      ThreeSale threeSale = threeSaleSerivce.getMyBoss(uid);

      if (threeSale == null)

         return;

      // 上级是否为会员

      Long bossId = threeSale.getBoss().getId();

      UserVIPInfo bossVIP = userVIPInfoMapper.selectByPrimaryKeyForUpdate(bossId);

      if (bossVIP != null && bossVIP.getState() != null && bossVIP.getState() == UserVIPInfo.STATE_SUCCESS)

         return;



      // 之前插入记录失效

      userInviteSeparateService.updateStateByWorkerIdAndBossId(uid, bossId, UserInviteSeparate.STATE_INVALID);



      // 限制时间

      int limitDays = Integer.parseInt(configService.get(ConfigKeyEnum.inviteSeparateLimitDays.getKey()));

      UserInviteSeparate inviteSeparate = new UserInviteSeparate();

      inviteSeparate.setBossId(bossId);

      inviteSeparate.setWorkerId(uid);

      inviteSeparate.setState(UserInviteSeparate.STATE_INIT);

      inviteSeparate.setEndTime(DateUtil.plusDayDate(limitDays, new Date()));

      inviteSeparate.setCreateTime(new Date());

      inviteSeparate.setUpdateTime(new Date());

      userInviteSeparateService.insertSelective(inviteSeparate);



      UserInfo userInfo = userInfoService.selectByPKey(uid);

      // 消息

      MsgOtherVIPDTO msgboss = new MsgOtherVIPDTO();

      msgboss.setContent1(userInfo.getNickName() + " " + uid);

      msgboss.setContent2("于" + TimeUtil.formatDateDot(new Date()) + "成功升级成为超级会员");

      msgboss.setContent3("今日起" + limitDays + "天内，你未能成为超级会员将会与其脱离邀请关系 ");

      userOtherMsgNotificationService.teamVIPCallBoss(bossId, "如有疑问请联系我的-人工客服", msgboss);

   }



   @Transactional(rollbackFor = Exception.class)

   @Override

   public void rejectVIPApply(Long uid, String reason) throws UserVIPInfoException {

      UserVIPInfo userInfo = userVIPInfoMapper.selectByPrimaryKeyForUpdate(uid);

      if (userInfo == null) {

         throw new UserVIPInfoException(1, "用户信息不存在");

      }

      if (userInfo.getState() != UserVIPInfo.STATE_VERIFING) {

         throw new UserVIPInfoException(2, "申请未处于审核状态");

      }



      UserVIPInfo info = new UserVIPInfo();

      info.setId(userInfo.getId());

      info.setState(UserVIPInfo.STATE_INVALID);

      info.setUpdateTime(new Date());

      userVIPInfoMapper.updateByPrimaryKeySelective(info);



      // 消息

      MsgOtherVIPDTO msgOther = new MsgOtherVIPDTO();

      msgOther.setContent1("很抱歉，未通过超级会员申请");

      msgOther.setContent2("未满足超级会员升级条件或疑似出现违规 ");

      userOtherMsgNotificationService.rejectVIPApply(uid, "如有疑问请联系我的-人工客服", msgOther);

   }



   @Transactional(rollbackFor = Exception.class)

   @Override

   public void applyVIP(Long uid) throws UserVIPInfoException {

      UserVIPInfo userInfo = userVIPInfoMapper.selectByPrimaryKeyForUpdate(uid);

      if (userInfo == null) {

         userInfo = new UserVIPInfo();

         userInfo.setId(uid);

         addUserVIPInfo(userInfo);

      }



      if (userInfo.getState() != UserVIPInfo.STATE_INVALID)

         throw new UserVIPInfoException(2, "已经申请过");



      UserVIPInfo info = new UserVIPInfo();

      info.setId(userInfo.getId());

      info.setApplyTime(new Date());

      info.setState(UserVIPInfo.STATE_VERIFING);

      info.setUpdateTime(new Date());

      userVIPInfoMapper.updateByPrimaryKeySelective(info);

   }



   @Override

   public boolean isVIP(Long uid) {

      return isVIP(uid, System.currentTimeMillis());

   }



   @Override

   public boolean isVIP(Long uid, Long time) {

      UserVIPInfo userInfo = userVIPInfoMapper.selectByPrimaryKey(uid);

      if (userInfo != null && userInfo.getState() == UserVIPInfo.STATE_SUCCESS)

      if (userInfo != null && userInfo.getState() == UserVIPInfo.STATE_SUCCESS

            && userInfo.getSuccessTime().getTime() < time)

         return true;

      else

         return false;

@@ -294,86 +147,6 @@
      return map;

   }



   @Override

   public boolean verifyConform(Long uid) {

      if (uid == null || uid <= 0)

         return false;



      UserInfoExtra extra = userInfoExtraService.getUserInfoExtra(uid);

      if (extra == null)

         return false;



      // 1、直接粉丝（从 2020 年 1 月 1 日起直接粉丝产生有效订单）

      BigDecimal payMoney = new BigDecimal(userVipConfigService.getValueByKey("require_order_pay"));

//      long teamNum = hongBaoV2CountService.countValidOrderTeamUserByUid(uid,

//            TimeUtil.convertDateToTemp(Constant.VIP_ONLINE_TIME), payMoney);

      long teamNum = 0L;

      long vipBegin = TimeUtil.convertDateToTemp(Constant.VIP_ONLINE_TIME);

      List<ThreeSale> listThreeSale = threeSaleSerivce.getValidWorkerIdsByTime(uid, vipBegin);

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

         for (ThreeSale three: listThreeSale) {

            UserInfo worker = three.getWorker();

            if (worker == null || worker.getId() == null) {

               continue;

            }

            // 1、邀请关系成功后；2、单（分享 + 自购）实付款大于1元

            long countValid = hongBaoV2CountService.countValidOrderByUidAndTime(worker.getId(), three.getSucceedTime(), payMoney);

            if (countValid > 0) {

               teamNum ++;

            }

         }

      }

		
		
		
		
		


      // 区分老用户和新用户

      String limtDate = userVipConfigService.getValueByKey("vip_execute_time");

      Date executeDate = null;

      try {

         SimpleDateFormat format = new SimpleDateFormat("yyyy-mm-dd");

         executeDate = format.parse(limtDate);

      } catch (ParseException e) {

         e.printStackTrace();

      }

      if (executeDate == null)

         return false;



      if (extra.getFirstLoginTime() == null || extra.getFirstLoginTime().getTime() < executeDate.getTime()) {

         long limitNum = Long.parseLong(userVipConfigService.getValueByKey("require_invite_num_old_user"));

         if (teamNum < limitNum)

            return false;

      } else {

         long limitNum = Long.parseLong(userVipConfigService.getValueByKey("require_invite_num_new_user"));

         if (teamNum < limitNum)

            return false;

      }



      // 2、累计自购返利≥100 元（从注册板栗快省起）；

      BigDecimal fanMoney = new BigDecimal(userVipConfigService.getValueByKey("require_fan_money"));

      BigDecimal purchase = hongBaoV2CountService.getRewardMoneyBySelf(uid);

      if (purchase.compareTo(fanMoney) < 0)

         return false;



      // 3、累计金币≥10000 枚（从注册板栗快省起）；

      BigDecimal goldCoin = integralDetailService.getCumulativeMoney(uid);

      BigDecimal limitGoldCoin = new BigDecimal(userVipConfigService.getValueByKey("require_gold_coin"));

      if (goldCoin.compareTo(limitGoldCoin) < 0)

         return false;



      // 4、使用红包≥1 次

      List<Integer> list = new ArrayList<Integer>();

      list.add(BanLiShopOrder.STATE_SUCCESS);

      long useHongBao = banLiShopOrderService.countByUidAndState(uid, list);

      long limitHongBao = Long.parseLong(userVipConfigService.getValueByKey("require_shop_buy"));

      if (useHongBao < limitHongBao)

         return false;



      // 符合条件

      return true;

   }



   @Override

   public List<UserVIPInfo> listQuery(int page, int count, String key, Integer state) {

@@ -385,85 +158,224 @@
      return userVIPInfoMapper.countQuery(key, state);

   }



   @Override



   @Transactional(rollbackFor = Exception.class)

   public void inviteSeparate(Long workerId, Long bossId) {

      if (workerId == null || bossId == null)

         return;



      // 查询记录

      UserInviteSeparate userInviteSeparate = userInviteSeparateService.selectByWorkerIdAndBossId(workerId, bossId);

      if (userInviteSeparate == null)

         return;



      // 是否存在邀请关系

      ThreeSale threeSale = threeSaleSerivce.getMyBoss(workerId);

      if (threeSale == null)

         return;

      Long bossIdExist = threeSale.getBoss().getId();

      if (bossIdExist == null || bossId.longValue() != bossIdExist.longValue())

         return;



      // 上级会员情况

      boolean separate = false;

      UserVIPInfo userVIPInfo = userVIPInfoMapper.selectByPrimaryKey(bossId);

      if (userVIPInfo != null && userVIPInfo.getState() != null

            && userVIPInfo.getState() == UserVIPInfo.STATE_SUCCESS) {

         if (userInviteSeparate.getEndTime().getTime() < userVIPInfo.getSuccessTime().getTime()) {

            separate = true; // 结束时间已经超过

         }

      } else {

         separate = true; // 上级非会员

   @Override

   public void applyVIP(Long uid) throws UserVIPInfoException {

      UserVIPPreInfo latestProcess = userVIPPreInfoService.getLatestProcessInfo(uid);

      if (latestProcess == null || latestProcess.getProcess() != UserVIPPreInfo.PROCESS_2) {

         throw new UserVIPInfoException(1, "请先升级为高级会员");

      }



      if (!separate) {

         // 未脱离

         userInviteSeparateService.updateStateByWorkerIdAndBossId(workerId, bossId,

               UserInviteSeparate.STATE_INVALID);

      } else {

         // 脱离关系

         userInviteSeparateService.updateStateByWorkerIdAndBossId(workerId, bossId,

               UserInviteSeparate.STATE_SUCCESS);

      if (!verifyVip(uid))

         throw new UserVIPInfoException(1, "不满足升级条件");



         // 脱离邀请关系

         threeSaleSerivce.inviteSeparate(workerId, bossId);

      UserVIPInfo userInfo = userVIPInfoMapper.selectByPrimaryKeyForUpdate(uid);

      if (userInfo == null) {

         userInfo = new UserVIPInfo();

         userInfo.setId(uid);

         addUserVIPInfo(userInfo);

      }



         int limitDays = Integer.parseInt(configService.get(ConfigKeyEnum.inviteSeparateLimitDays.getKey()));

         // 消息

         UserInfo userInfo = userInfoService.selectByPKey(workerId);

         MsgOtherVIPDTO msgboss = new MsgOtherVIPDTO();

         msgboss.setContent1(userInfo.getNickName() + workerId + "于"

               + TimeUtil.formatDateDot(userInviteSeparate.getCreateTime()) + "成功升级成为超级会员 ");

         msgboss.setContent2("很遗憾，你未能在" + limitDays + "天升级为超级会员 ");

         msgboss.setContent3("已与其脱离邀请关系");

         userOtherMsgNotificationService.teamSplitCallBoss(bossId, "如有疑问请联系我的-人工客服", msgboss);

      if (userInfo.getState() != UserVIPInfo.STATE_INVALID)

         throw new UserVIPInfoException(2, "系统已收到你的超级会员升级申请，将会尽快完成审核");



      UserVIPInfo info = new UserVIPInfo();

      info.setId(userInfo.getId());

      info.setApplyTime(new Date());

      info.setState(UserVIPInfo.STATE_VERIFING);

      info.setUpdateTime(new Date());

      userVIPInfoMapper.updateByPrimaryKeySelective(info);

   }



   @Transactional(rollbackFor = Exception.class)

   @Override

   public void passVIPApply(Long uid) throws UserVIPInfoException {

      UserVIPInfo userVIPInfo = userVIPInfoMapper.selectByPrimaryKeyForUpdate(uid);

      if (userVIPInfo == null) {

         throw new UserVIPInfoException(1, "用户信息不存在");

      }

      if (userVIPInfo.getState() != UserVIPInfo.STATE_VERIFING) {

         throw new UserVIPInfoException(2, "申请未处于审核状态");

      }



      UserVIPPreInfo latestProcess = userVIPPreInfoService.getLatestProcessInfo(uid);

      if (latestProcess == null || latestProcess.getProcess() != UserVIPPreInfo.PROCESS_2) {

         throw new UserVIPInfoException(1, "该用户还不是高级会员");

      }



      if (!verifyVip(uid))

         throw new UserVIPInfoException(1, "系统验证：不满足升级条件");



      // 额外信息

      UserInfoExtra userInfoExtra = userInfoExtraService.getByUidForUpdate(uid);

      if (userInfoExtra == null)

         throw new UserVIPInfoException(1, "用户信息不存在");



      Date upgradeTime = new Date();

      // 通过超级会员

      UserVIPInfo info = new UserVIPInfo();

      info.setId(userVIPInfo.getId());

      info.setSuccessTime(upgradeTime);

      info.setState(UserVIPInfo.STATE_SUCCESS);

      info.setUpdateTime(upgradeTime);

      userVIPInfoMapper.updateByPrimaryKeySelective(info);



      try {

         // 赠送免单券

         String giveCoupon = userVipConfigService.getValueByKey("vip_pre_10_gift_givefree_coupon");

         if (!StringUtil.isNullOrEmpty(giveCoupon)) {

            int num = Integer.parseInt(giveCoupon);

            userSystemCouponService.freeCouponWin(uid, CouponTypeEnum.freeCouponGive,

                  UserSystemCoupon.SOURCE_SYSTEM_PUSH, num, true);

         }

      } catch (Exception e) {

         throw new UserVIPInfoException(1, "券赠送失败");

      }

		
      try {

         // 升级消息

         UserVIPPreInfo pre1 = userVIPPreInfoService.getVipByProcess(uid, UserVIPPreInfo.PROCESS_2);

         int days = DateUtil.daysBetween(pre1.getCreateTime(), new Date());

         userAccountMsgNotificationService.vipUpgradeSuccess(uid, days);

			
         // 升级提醒上级

         userVIPPreInfoService.remindBoss(uid, "超级会员", getPassItem(uid), upgradeTime, false);

      } catch (Exception e) {

         e.printStackTrace();

      }

   }





   /**

    * 验证是否符合VIP

    * @param uid

    * @return

    */

   private boolean verifyVip(Long uid) {

      // 邀请订单

      long countZiGou = hongBaoV2CountService.counOrderByUidAndOrderType(uid, Constant.VIP_ORDER_PAY,

   private String getPassItem(Long uid) {

      // 自购订单

      long doneZiGou = hongBaoV2CountService.counOrderByUidAndOrderType(uid, Constant.VIP_ORDER_PAY,

            HongBaoV2.TYPE_ZIGOU);

      // 邀请订单

      long countShare = hongBaoV2CountService.counOrderByUidAndOrderType(uid, Constant.VIP_ORDER_PAY,

      // 分享订单

      long doneShare = hongBaoV2CountService.counOrderByUidAndOrderType(uid, Constant.VIP_ORDER_PAY,

            HongBaoV2.TYPE_SHARE_GOODS);

      // 队员

      long firstTeam = threeSaleSerivce.countFirstTeam(uid, 1);

      long secondTeam = threeSaleSerivce.countSecondTeam(uid, 1);

      if (countZiGou >= Constant.VIP_PROCESS_3_ZIGOU || countShare >= Constant.VIP_PROCESS_3_SHARE

            || (firstTeam >= Constant.VIP_PROCESS_3_TEAM && secondTeam >= Constant.VIP_PROCESS_3_TEAM_SECOND)) {

         UserVIPPreInfo latestProcess = userVIPPreInfoService.getLatestProcessInfo(uid);

         if (latestProcess == null || latestProcess.getProcess() != UserVIPPreInfo.PROCESS_2) {

            userVIPPreInfoService.verifyVipPreInfo(uid, false);

         } 
         return true;

      } 
      return false;

		
      // 有效粉丝

      int doneFirst = 0;

      int doneSecond = 0;

      UserInviteValidNum userInviteValidNum = userInviteValidNumService.selectByPrimaryKey(uid);

      if (userInviteValidNum != null) {

         doneFirst = userInviteValidNum.getNumFirst() == null ? 0 : userInviteValidNum.getNumFirst();

         doneSecond = userInviteValidNum.getNumSecond() == null ? 0 : userInviteValidNum.getNumSecond();

      }



      long limitZiGou = 0;

      String zigou = userVipConfigService.getValueByKey("vip_pre_10_zigou_order_count");

      if (!StringUtil.isNullOrEmpty(zigou)) {

         limitZiGou = Long.parseLong(zigou);

      }

		
      long limitShare = 0;

      String share = userVipConfigService.getValueByKey("vip_pre_10_share_order_count");

      if (!StringUtil.isNullOrEmpty(share)) {

         limitShare = Long.parseLong(share);

      }

		
      long limitFirst = 0;

      String first = userVipConfigService.getValueByKey("vip_pre_10_first_level_team_count");

      if (!StringUtil.isNullOrEmpty(first)) {

         limitFirst = Long.parseLong(first);

      }

		
      long limitSecond = 0;

      String second = userVipConfigService.getValueByKey("vip_pre_10_second_level_team_count");

      if (!StringUtil.isNullOrEmpty(second)) {

         limitSecond = Long.parseLong(second);

      }

		
      String item = "";

      if (doneZiGou >= limitZiGou) {

         item = "返利订单";

      } else if (doneShare >= limitShare) {

         item = "分享订单";

      } else if (doneFirst >= limitFirst && doneSecond >= limitSecond) {

         item = "邀请粉丝";

      }

      return item;

   }

   

	
   /**

    * 验证是否符合VIP

    * @param uid

    * @return

    */

   private boolean verifyVip(Long uid) {

      // 自购订单

      long doneZiGou = hongBaoV2CountService.counOrderByUidAndOrderType(uid, Constant.VIP_ORDER_PAY,

            HongBaoV2.TYPE_ZIGOU);

      // 分享订单

      long doneShare = hongBaoV2CountService.counOrderByUidAndOrderType(uid, Constant.VIP_ORDER_PAY,

            HongBaoV2.TYPE_SHARE_GOODS);

		
      // 有效粉丝

      int doneFirst = 0;

      int doneSecond = 0;

      UserInviteValidNum userInviteValidNum = userInviteValidNumService.selectByPrimaryKey(uid);

      if (userInviteValidNum != null) {

         doneFirst = userInviteValidNum.getNumFirst() == null ? 0 : userInviteValidNum.getNumFirst();

         doneSecond = userInviteValidNum.getNumSecond() == null ? 0 : userInviteValidNum.getNumSecond();

      }



      long limitZiGou = 0;

      String zigou = userVipConfigService.getValueByKey("vip_pre_10_zigou_order_count");

      if (!StringUtil.isNullOrEmpty(zigou)) {

         limitZiGou = Long.parseLong(zigou);

      }

		
      long limitShare = 0;

      String share = userVipConfigService.getValueByKey("vip_pre_10_share_order_count");

      if (!StringUtil.isNullOrEmpty(share)) {

         limitShare = Long.parseLong(share);

      }

		
      long limitFirst = 0;

      String first = userVipConfigService.getValueByKey("vip_pre_10_first_level_team_count");

      if (!StringUtil.isNullOrEmpty(first)) {

         limitFirst = Long.parseLong(first);

      }

		
      long limitSecond = 0;

      String second = userVipConfigService.getValueByKey("vip_pre_10_second_level_team_count");

      if (!StringUtil.isNullOrEmpty(second)) {

         limitSecond = Long.parseLong(second);

      }

		
      if (doneZiGou >= limitZiGou || doneShare >= limitShare || (doneFirst >= limitFirst && doneSecond >= limitSecond)) {

         return true;

      }

      return false;

   }



   @Transactional(rollbackFor = Exception.class)

   @Override

   public void rejectVIPApply(Long uid, String reason) throws UserVIPInfoException {

      UserVIPInfo userInfo = userVIPInfoMapper.selectByPrimaryKeyForUpdate(uid);

      if (userInfo == null) {

         throw new UserVIPInfoException(1, "用户信息不存在");

      }

      if (userInfo.getState() != UserVIPInfo.STATE_VERIFING) {

         throw new UserVIPInfoException(2, "申请未处于审核状态");

      }



      UserVIPInfo info = new UserVIPInfo();

      info.setId(userInfo.getId());

      info.setState(UserVIPInfo.STATE_INVALID);

      info.setUpdateTime(new Date());

      userVIPInfoMapper.updateByPrimaryKeySelective(info);



      // 消息

      userAccountMsgNotificationService.vipUpgradeFail(uid, reason);

   }



}