工作项目-推广活动

表字段的冗余对于字段的查询有很重要的作用,能节省查询时间

表设计

ver1.0

ver2.0 (暂定)

在ver1.0设计的基础上 , 因为需求变更 , 经过多次讨论 , 完善出如下表

/**
 * author:xiaoLiu
 * Description:队长表设计
 */
@Entity
@Table(name = "wc_group")
public class GroupEntity {
    @Id
    @Column(columnDefinition = "char(32) comment '队伍id'")
    private String id;
    @Column(nullable = false, columnDefinition = "varchar(255) comment '活动ID'")
    private String channelId;
    @DateTimeFormat(pattern = "yyyy-MM-dd hh:mm:ss")
    private Date endTime;
    @Column(columnDefinition = "tinyint(2)  comment '队伍的状态 ,0未完成,1满足要求(暂停),3已被拉黑 '")
    private Integer status;
    @Column(columnDefinition = "char(11) comment '推荐人电话'")
    private String phone;
    @Column(columnDefinition = "varchar(255) comment 'csID'")
    private String csId;
    @DateTimeFormat(pattern = "yyyy-MM-dd hh:mm:ss")
    private Date createdTime;
    @Column(columnDefinition = "int(4) comment '当前处于奖品等级的人数'")
    private Integer levelNumber;}

/**
 * author:xiaoLiu
 * Description:队伍成员表设计
 */
@Entity
@Table(name = "wc_group_record")
public class GroupRecordEntity extends BaseEntity {

    //    @Column( columnDefinition = "datetime  comment '队伍的过期日期,首次创建有时间")

    @Column(columnDefinition = "char(32) comment '队伍id'")
    private String teamId;

    @Column(columnDefinition = "char(11) comment '推荐人电话,只有被推荐的人才有'")
    private String recommendPhone;

//    @Column(columnDefinition = "varchar(36) comment '推荐人openid,只有被推荐的人才有'")
//    private String recommendOpenId;

    @Column(columnDefinition = "varchar(255) comment '外部联系人id , 也就是被推荐人企业微信id'")
    private String externalId;

    @Column(columnDefinition = "varchar(255) comment '客服的id'")
    private String csId;

    @Column(columnDefinition = "varchar(255) comment '用户头像'")
    private String avatar;

    @Column(columnDefinition = "varchar(255) comment '名称'")
    private String name;}


//wc_group_record 队伍满足要求发放奖励设计
/**
 * author:xiaoLiu
 * Description:
 */
@Entity
    @Table(name = "wc_group_gift_record")
public class GroupGiftRecordEntity extends BaseEntity {

    @Column(columnDefinition = "char(32) comment '队伍id'")
    private String teamId;

    @Column(columnDefinition = "char(32) comment '订单号'")
    private String tradeNo;

    @Column(columnDefinition = "char(36) comment '满足奖励队伍成员记录的id'")
    private String groupRecordId;

    @Column(columnDefinition = "int(8) comment '赠送金额'")
    private Integer amount;
    @Column(columnDefinition = "int(4) comment '队伍发放奖励的类型 null 金额 0 洗车 1 停车 2 洗车和停车'")
    private Integer sendType;
}

/**
 * author:xiaoLiu
 * Description:活动信息维护表设计
 */

@Entity
@Table(name = "wc_group_info")
public class GroupInfoEntity extends BaseEntity {
//    @Id
//    @Column(nullable = false,columnDefinition = "varchar(255) comment '活动ID'")
//    private String id;
    @Column(nullable = false,columnDefinition = "varchar(255) comment '渠道ID'")
    private String channelId;

    @Column(nullable = false,columnDefinition = "varchar(255) comment '队伍名称'")
    private String groupName;

    @Column(nullable = false,columnDefinition = "int(8) comment '要求人数'")
    private Integer personNumber;

    @Column(nullable = false,columnDefinition = "int(8) comment '队伍最大限制数'")
    private Integer maxNumber;

    @Column(nullable = false,columnDefinition = "int(8) comment '活动最多赠送金额(元)'")
    private Integer maxAmount;

    @Column(nullable = false,columnDefinition = "tinyint(2) comment '活动状态1开启 0 暂停'")
    private Integer status;

    @Column(columnDefinition = "int(8) comment '基础奖励,赠送金额 元'")
    private Integer amount;

//    @Column(columnDefinition = "int(4) comment '赠送优惠券的类型,0洗车,1停车 , 2 洗车和停车'")
//    private Integer couponType;

    private Integer validHour;

    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date experDate;

    @Column(columnDefinition = "text(0) comment '头部描述'")
    private String  headDescript;

    @Column(columnDefinition = "text(0) comment '尾部描述'")
    private String tailDescript;

    @Transient
    private String remainer;}
/**
 * author:xiaoLiu
 * Description:活动特殊奖品表设计
 */
@Entity
@Table( name = "wc_group_gift_rule")

public class GroupGiftRuleEntity extends BaseEntity {

    @Column(columnDefinition = "int(4)  comment'人数要求'")
    @NotNull(message = "人数要求不能为空")
    private Integer requirePersonNumber;

    @Column(columnDefinition = "int(4)  comment'奖品类型'")
    @NotNull(message = "奖品类型不能为空")
    private Integer type;


    @Column(columnDefinition = "varchar(255) comment'奖品名称'")
    @NotEmpty(message = "奖品名称不能为空")
    private String rewardName;

    private Integer remainder;

    @Min(value = 0,message = "奖品初始数量>=0")
    private int initNum;

    private String groupInfoId;

业务逻辑

后台活动的维护

/**
 * author:xiaoLiu
 * Description:
 */
@RestController
@RequestMapping("/xxxx")
public class GroupInfoController {
    
    @Autowired
    private GroupInfoService groupInfoService;
    Logger log = LoggerFactory.getLogger(GroupInfoController.class);

    @RequestMapping("/getGroupInfo")
    public BaseResponse getGroupInfo(GroupInfoEntity groupInfoEntity) {
        log.info("[拼团信息]获取拼团信息");
        return groupInfoService.getGroupInfo(groupInfoEntity);
    }

    @RequestMapping("/del")
    public BaseResponse delGroupInfo(GroupInfoEntity groupInfoEntity) {
        log.info("[拼团信息]删除拼团信息");
        return groupInfoService.delGroupInfo(groupInfoEntity);
    }

    @RequestMapping("/updateGroupInfo")
    public BaseResponse updateGroupInfo(GroupInfoEntity groupInfoEntity) {
        log.info("[拼团信息]修改拼团信息");
        return groupInfoService.updateGroupInfo(groupInfoEntity);
    }

    @RequestMapping("/addGroupInfo")
    public BaseResponse addGroupInfo(GroupInfoEntity groupInfoEntity) {
        log.info("[拼团信息]添加拼团信息");
        return groupInfoService.addGroupInfo(groupInfoEntity);
    }

    @RequestMapping("/page")
    public Page<GroupInfoEntity> page(GroupInfoQueryParam param, Pageable pageable) {
        log.info("[拼团信息]分页查询");
        return groupInfoService.page(param,pageable);
    }

    @RequestMapping("/changeStatus")
    public BaseResponse changeStatus(String id) {
        log.info("[拼团信息]修改状态");
        return groupInfoService.changeStatus(id);
    }
    @RequestMapping("/list")
    public BaseResponse list(String id) {
        log.info("[奖品列表]奖品列表展示");
        return groupInfoService.list(id);
    }
    @RequestMapping("/storeGroupInfoId")
    public BaseResponse storeGroupInfoId(@RequestParam(name = "id") String id,HttpServletRequest request) {
        request.getSession().setAttribute("groupInfoId",id);
        log.info("[奖品列表]存储队伍信息的奖品id");
        return BaseResponse.ok("success,id is {}",id);
    }

    @RequestMapping("/saveReward")
    public BaseResponse saveReward(@Validated GroupGiftRuleEntity groupGiftRuleEntity, BindingResult br, HttpServletRequest request) {
        log.info("[奖品列表]奖品列表展示");
        if (br.hasErrors()) {
            String msg = br.getAllErrors()
                    .stream()
                    .map(DefaultMessageSourceResolvable::getDefaultMessage)
                    .collect(Collectors.joining(","));
            return BaseResponse.fail(msg);
        }
        return groupInfoService.saveReward(groupGiftRuleEntity,request);
    }

    @RequestMapping("/getRewardInfo")
    public BaseResponse getRewardInfo(String id) {
        log.info("[奖品列表]获取特定奖品信息");
        return groupInfoService.getRewardInfo(id);
    }

    @RequestMapping("/delReward")
    public BaseResponse delReward(String id, HttpServletRequest request) {
        log.info("[奖品列表]删除特定奖品信息");
        return groupInfoService.delReward(id,request);
    }
}

//实现类
/**
 * author:xiaoLiu
 * Description:
 */
@Service
public class GroupInfoServiceImpl implements GroupInfoService {
    @Autowired
    private GroupInfoRepository groupInfoRepository;
    @Autowired
    private GroupRepository groupRepository;
    @Autowired
    private GroupGiftRuleRepository groupGiftRuleRepository;
    @Autowired
    private StringRedisTemplate redisTemplate;
    Logger log = LoggerFactory.getLogger(GroupInfoServiceImpl.class);

    @Override
    public BaseResponse getGroupInfo(GroupInfoEntity groupInfoEntity) {

        GroupInfoEntity entity = groupInfoRepository.findById(groupInfoEntity.getId());
        return BaseResponse.ok("success", entity);
    }

    @Override
    public BaseResponse delGroupInfo(GroupInfoEntity groupInfoEntity) {
        //查找是否有关联奖品
        List<GroupGiftRuleEntity> giftRuleEntities = groupGiftRuleRepository.findByGroupInfoId(groupInfoEntity.getId());
        if (giftRuleEntities.size() > 0) {
            return BaseResponse.fail("请先删除自己设置的奖品");
        }

        GroupInfoEntity infoEntity = groupInfoRepository.findById(groupInfoEntity.getId());
        List<GroupEntity> list = groupRepository.findByChannelId(infoEntity.getChannelId());
        if(list.size()>0){
            groupRepository.save(list);
            return BaseResponse.fail("删除失败,原因是有队伍与他关联 , 请重新生成活动配置信息");
        }
        groupInfoRepository.delete(groupInfoEntity.getId());
        return BaseResponse.ok("success");
    }

    @Override
    public BaseResponse updateGroupInfo(GroupInfoEntity groupInfoEntity) {
        //原始记录
        GroupInfoEntity entity = groupInfoRepository.findById(groupInfoEntity.getId());
        //更新记录
        BeanUtil.copyProperties(groupInfoEntity, entity, true);
        Integer maxAmount = entity.getMaxAmount();
       if(maxAmount==-1){
           log.info("删除库存记录");
           BoundHashOperations<String, Object, Object> ops = redisTemplate.boundHashOps(Constant.GROUP_AMOUNT);
           Object remainer = redisTemplate.opsForHash().get(Constant.GROUP_AMOUNT, groupInfoEntity.getChannelId());
           log.info("redis hash值{}",ops.toString() );
           log.info("redis 库存值{}", remainer);
           if(Objects.nonNull(remainer)){
               redisTemplate.opsForHash().delete(Constant.GROUP_AMOUNT,groupInfoEntity.getChannelId());
           }
       }
        groupInfoRepository.save(entity);
        return BaseResponse.ok("success", entity);
    }

    @Override
    public BaseResponse addGroupInfo(GroupInfoEntity groupInfoEntity) {
        groupInfoEntity.setStatus(0);
        GroupInfoEntity save = groupInfoRepository.save(groupInfoEntity);
        return BaseResponse.ok("success", save);
    }

    @Override
    public Page<GroupInfoEntity> page(GroupInfoQueryParam param, Pageable pageable) {
        Page<GroupInfoEntity> page = groupInfoRepository.page(param, pageable);
        List<GroupInfoEntity> content = page.getContent();
        content.forEach(e->{
            Object remainer = redisTemplate.opsForHash().get(Constant.GROUP_AMOUNT, e.getChannelId());
            if(Objects.nonNull(remainer)){
                e.setRemainer(remainer.toString());
            }else {e.setRemainer("还未生成库存");}
        });
        return new PageResult<>(content,pageable,page.getTotalElements());
    }

    @Override
    public BaseResponse changeStatus(String id) {
        GroupInfoEntity infoEntity = groupInfoRepository.findById(id);
        if (infoEntity.getStatus() == 1) {
            infoEntity.setStatus(0);
            List<GroupEntity> groupRecordEntities = groupRepository.findAllByZero(infoEntity.getChannelId());
            //暂停
            groupRecordEntities.forEach(e -> e.setStatus(1));
            groupRepository.save(groupRecordEntities);
        } else {
            infoEntity.setStatus(1);
            List<GroupEntity> groupRecordEntities = groupRepository.findAllByOne(infoEntity.getChannelId());
            //进行
            groupRecordEntities.forEach(e -> e.setStatus(0));
            //再次开启的时候,所有队伍过期时间同步
            List<GroupEntity> groupEntityList = groupRepository.findByChannelId(infoEntity.getChannelId());
            groupEntityList.forEach(e->{
                if(e.getEndTime().before(infoEntity.getExperDate())){
                    //有效时间
                    Calendar instance = Calendar.getInstance();
                    instance.add(Calendar.HOUR, infoEntity.getValidHour());
                    Date validDate = instance.getTime();
                    //活动暂停时间
                    Date experDate = infoEntity.getExperDate();
                    if (validDate.after(experDate)) {
                        e.setEndTime(experDate);
                    } else {
                        e.setEndTime(validDate);
                    }
                }
            });
            groupRepository.save(groupEntityList);
            groupRepository.save(groupRecordEntities);
        }
        groupInfoRepository.save(infoEntity);
        return BaseResponse.ok("success");
    }

    @Override
    public BaseResponse list(String id) {
        List<GroupGiftRuleEntity> list = groupGiftRuleRepository.list(id);
        GroupInfoEntity infoEntity = groupInfoRepository.findById(id);
        for (GroupGiftRuleEntity entity : list) {
            Object remainter = redisTemplate.opsForHash().get("GroupReward-" + infoEntity.getChannelId(), entity.getRewardName());
            if (Objects.nonNull(remainter)) {
                entity.setRemainder(Integer.valueOf(remainter.toString()));
            }
        }
        groupGiftRuleRepository.save(list);
        return BaseResponse.ok("查询成功", list);
    }

    @Override
    public BaseResponse saveReward(GroupGiftRuleEntity groupGiftRuleEntity, HttpServletRequest request) {
        GroupGiftRuleEntity entity;
        Object groupInfoId = request.getSession().getAttribute("groupInfoId");
        if (Objects.nonNull(groupGiftRuleEntity.getId())) {
            //更新
            entity = groupGiftRuleRepository.findOne(groupGiftRuleEntity.getId());
            entity.setRequirePersonNumber(groupGiftRuleEntity.getRemainder());
            entity.setRewardName(groupGiftRuleEntity.getRewardName());
            entity.setInitNum(groupGiftRuleEntity.getInitNum());
            entity.setType(groupGiftRuleEntity.getType());
            entity = groupGiftRuleRepository.save(entity);
            return BaseResponse.ok("成功", entity);
        } else {
            //新增
            groupGiftRuleEntity.setGroupInfoId(groupInfoId.toString());
            entity = groupGiftRuleRepository.save(groupGiftRuleEntity);
        }
        GroupInfoEntity infoEntity = groupInfoRepository.findById(groupInfoId.toString());
        log.info("[队伍奖品]redis中{}库存初始值为{}", infoEntity.getChannelId(), entity.getInitNum());
        redisTemplate.opsForHash().increment("GroupReward-" + infoEntity.getChannelId(), entity.getRewardName(), entity.getInitNum());
        return BaseResponse.ok("成功", entity);
    }

    @Override
    public BaseResponse getRewardInfo(String id) {
        GroupGiftRuleEntity giftRuleEntity = groupGiftRuleRepository.findOne(id);
        return BaseResponse.ok("success", giftRuleEntity);
    }

    @Override
    public BaseResponse delReward(String id, HttpServletRequest request) {
        Object groupInfoId = request.getSession().getAttribute("groupInfoId");
        GroupInfoEntity infoEntity = groupInfoRepository.findById(groupInfoId.toString());
        GroupGiftRuleEntity entity = groupGiftRuleRepository.findOne(id);
        groupGiftRuleRepository.delete(id);
        log.info("删除活动{}中redis奖品{}对应的库存数量", infoEntity.getChannelId(), entity.getInitNum());
        redisTemplate.opsForHash().delete("GroupReward-" + infoEntity.getChannelId(), entity.getRewardName());
        return BaseResponse.fail("删除成功");
    }
}

后台活动维护展示

后台队伍成员的展示

/**
 * author:xiaoLiu
 * Description:
 */
@RestController
@RequestMapping("**/xxxx")
public class GroupRecordController {
    
    @Autowired
    private GroupRecordService groupRecordService;
    Logger log = LoggerFactory.getLogger(GroupRecordController.class);


    @RequestMapping("/page")
    public Page<GroupRecordDTO> page(GroupRecordQueryParam param, Pageable pageable) {
        log.info("[队伍记录]分页查询");
        return groupRecordService.page(param,pageable);
    }

    @RequestMapping("/groupDetailPage")
    public Page<GroupRecordDTO> groupDetailPage(GroupRecordQueryParam param, Pageable pageable,HttpServletRequest request) {
        log.info("[队伍详情]分页查询");
        Object teamId = request.getSession().getAttribute("teamId");
        param.setTeamId(teamId.toString());
        return groupRecordService.groupDetailPage(param,pageable);
    }
    @RequestMapping(value = "/storeTeamId")
    public BaseResponse strore(HttpServletRequest request, @RequestParam String teamId) {
        request.getSession().setAttribute("teamId", teamId);
        return BaseResponse.ok("success",teamId)   ;
    }

    @RequestMapping(value = "/toBlackPhone")
    public BaseResponse toBlackPhone(@RequestParam String teamId) {
        return  groupRecordService.toBlackPhone(teamId);
    }
    @RequestMapping(value = "/toWhitePhone")
    public BaseResponse toWhitePhone(@RequestParam String teamId) {
        return  groupRecordService.toWhitePhone(teamId);
    }

    @RequestMapping("/pay")
    public BaseResponse pay(String id) {
        log.info("[队伍记录]补偿");
        return groupRecordService.pay(id);
    }

    @RequestMapping("/getAllAmount")
    public Integer getAllAmount(String channelId) {
        log.info("[队伍赠送金额查询]");
        return groupRecordService.getAllAmount(channelId);
    }

}
//实现类
/**
 * author:xiaoLiu
 * Description:
 */
@Service
public class GroupRecordServiceImpl implements GroupRecordService {
    @Autowired
    private GroupRecordRepository groupRecordRepository;
    @Autowired
    private GroupInfoRepository groupInfoRepository;
    @Autowired
    private GroupRepository groupRepository;
    @Autowired
    private RedisUtils redisUtils;
    @Autowired
    private GroupGiftRecordRepository groupGiftRecordRepository;

    Logger log = LoggerFactory.getLogger(GroupRecordServiceImpl.class);

    @Override
    public Page<GroupRecordDTO> page(GroupRecordQueryParam param, Pageable pageable) {
        if(Objects.isNull(param.getGreaterThanNumber())){
            param.setGreaterThanNumber(0);
        }
        Page<Object[]> page = groupRepository.page(param, pageable);
        List<Object[]> content = page.getContent();
        List<GroupRecordDTO> newContent = Lists.newArrayListWithCapacity(content.size());
        content.forEach(e->{
            GroupRecordDTO groupRecordDTO = new GroupRecordDTO(e);
            newContent.add(groupRecordDTO);
        });
        return new PageResult<>(newContent, pageable, page.getTotalElements());
    }

    @Override
    public Page<GroupRecordDTO> groupDetailPage(GroupRecordQueryParam param, Pageable pageable) {
        Page<GroupRecordEntity> page = groupRecordRepository.groupDetailPage(param, pageable);
        List<GroupRecordEntity> content = page.getContent();
        List<GroupRecordDTO> newContent = new ArrayList<>(content.size());
        content.forEach(e -> {
            GroupRecordDTO groupRecordDTO = new GroupRecordDTO();
            BeanUtil.copyProperties(e, groupRecordDTO, true);
            groupRecordDTO.setTradeNo("");
            GroupGiftRecordEntity giftRecordEntity = groupGiftRecordRepository.findByGroupRecordId(e.getId());
            if (Objects.nonNull(giftRecordEntity)) {
                String tradeNo = giftRecordEntity.getTradeNo();
                Date createdTime = giftRecordEntity.getCreatedTime();
                groupRecordDTO.setTradeNo(tradeNo);
                groupRecordDTO.setCreatedTime(createdTime);
            }
            groupRecordDTO.setId(e.getId());
            newContent.add(groupRecordDTO);
        });
        return new PageResult<>(newContent, pageable, page.getTotalElements());
    }

    @Override
    @Transactional
    public BaseResponse pay(String id) {
        GroupGiftRecordEntity giftRecordEntity = groupGiftRecordRepository.findByGroupRecordId(id);
        GroupEntity groupEntity = groupRepository.findOne(giftRecordEntity.getTeamId());
        GroupInfoEntity infoEntity = groupInfoRepository.findByChannelId(groupEntity.getChannelId());

        boolean notLock = redisUtils.setIfAbsent("GroupTradeNo", id, 3); //加锁
        if (!notLock) {
            log.info("有并发请求，休眠3s", id);
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                log.error("线程休眠失败", e);
            }
        }
        if (Objects.nonNull(giftRecordEntity.getTradeNo())) {
            return BaseResponse.fail("订单号存在,补偿操作不合法");
        }
        String tradeNo = UUIDUtils.get32UUID();
        giftRecordEntity.setTradeNo(tradeNo);
        giftRecordEntity.setAmount(infoEntity.getAmount());
        //请求会员中心赠送余额
//        try {
//            Map<String, Object> param = Maps.newHashMapWithExpectedSize(2);
//            param.put("mobile", groupEntity.getPhone());
//            param.put("source", 5);
//            param.put("tradeBusiness", 1);
//            param.put("amount", infoEntity.getAmount() * 100);
//            param.put("tradeNo", tradeNo);
//            log.info("开始请求会员中心,参数{}", param);
//            Map map = restTemplateUtils.postByMap(param, Map.class, PartnerAccess.WASH_CAR, UserCenterUrl.PRESENT_AMOUNT.getUrl());
//            log.info("会员中心响应参数{}", map);
//            if (Constant.RESPONSE_CODE_SUCCESS.equals(map.get("code").toString())) {
//                giftRecordEntity.setTradeNo(tradeNo);
//            } else {
//                log.error("会员中心请求失败,msg{}", map);
//            }
//        } catch (Exception e) {
//            log.error("会员中心异常:", e);
//        }
        return BaseResponse.ok("success");
    }

    @Override
    public Integer getAllAmount(String channelId) {
        GroupInfoEntity infoEntity = groupInfoRepository.findByChannelId(channelId);
        Integer actaulNumber = groupGiftRecordRepository.countByChannelId(channelId);
        int sum = actaulNumber * infoEntity.getAmount();
        return sum;
    }

    @Override
    public BaseResponse toBlackPhone(String teamId) {
        if (StringUtils.isBlank(teamId)) {
            return BaseResponse.fail("拉黑失败,队伍id异常");
        }
        GroupEntity groupEntity = groupRepository.findOne(teamId);
        groupEntity.setStatus(2);
        GroupEntity save = groupRepository.save(groupEntity);
        return BaseResponse.ok("成功拉黑",save);
    }

    @Override
    public BaseResponse toWhitePhone(String teamId) {
        if (StringUtils.isBlank(teamId)) {
            return BaseResponse.fail("拉黑解除失败,队伍id异常");
        }
        GroupEntity groupEntity = groupRepository.findOne(teamId);
        GroupInfoEntity infoEntity = groupInfoRepository.findByChannelId(groupEntity.getChannelId());
        Integer status = infoEntity.getStatus();
        if(status==1){
            groupEntity.setStatus(0);
        }else {
            groupEntity.setStatus(1);
        }
        GroupEntity save = groupRepository.save(groupEntity);
        return BaseResponse.ok("成功解除拉黑",save);
    }
}

后台队伍成员展示

推广加人赠送

    private void saveGroupRecordTeam(String state, String externalUserID, String userID) {
        String[] channelAndPhone = state.split("[,]");
        String channelId = channelAndPhone[0];
        String recommendPhone = channelAndPhone[1];
        GroupInfoEntity infoEntity = groupInfoRepository.findByChannelId(channelId);
        if (Objects.isNull(infoEntity)) {
            log.info("没有该活动Id{}", channelId);
            return;
        }
        List<GroupEntity> entities = groupRepository.findByPhoneAndChannelId(recommendPhone, channelId);
        if (infoEntity.getStatus() == 0 || infoEntity.getExperDate().before(new Date())) {
            log.info("活动已经截止,该队伍全部暂停");
            entities.forEach(e -> e.setStatus(1));
            groupRepository.save(entities);
            return;
        }

        Integer queNumber = 0;
        Integer spareNumber = 0;
        log.info("查找推荐电话{}的推荐队伍{}", recommendPhone, entities);
        if (entities.size() > 0) {
            //查看队伍
            for (GroupEntity entity : entities) {
                log.info("此时队伍{}的状态为{}", entity.getId(), entity.getStatus());
                if (entity.getStatus() != 0) {
                    queNumber++;
                    continue;
                }//队伍csId 与当前二维码csid不一致
//                if (!entity.getCsId().equals(userID)) {
//                    log.info("加入的csID与队伍csID不匹配 ,不是合法队伍");
//                    continue;
//                }
                List<GroupRecordEntity> entityList = groupRecordRepository.findByRecommendPhoneAndTeamId(recommendPhone, entity.getId());
                if (entityList.contains(externalUserID)) {
                    log.info("该兄弟已经添加过 ,不能入队");
                    continue;
                }
                Integer countByExternalId = groupRecordRepository.countByExternalId(externalUserID);
                if (countByExternalId > 0) {
                    log.info("该兄弟助力过别的队伍 ,不能入队");
                    return;
                }
                if (spareNumber > 0) {
                    entity.setStatus(2);
                    groupRepository.save(entity);
                    log.info("将多余队伍设置为过期,参数{}", entity);
                    continue;
                }
                if (!entity.getEndTime().before(new Date()) && infoEntity.getStatus() == 1) {
                    //统计之前队伍人数
                    Integer count = groupRecordRepository.countByRecommendPhoneAndTeamId(recommendPhone, entity.getId());
                    //人数要求
                    Integer personNumber = infoEntity.getPersonNumber();
                    //下一个人与要求人数取模 == 0
                    int number = (count + 1) % personNumber;
                    if (number == 0 && count + 1 <= infoEntity.getMaxNumber()) {
                        log.info("满足人数要求");
                        if (remainer(channelId, infoEntity, entities)) return;
                        GroupRecordEntity recordEntity = getGroupRecordEntity(externalUserID, userID, recommendPhone, entity);
                        //加锁
                        lockAndSendGift(channelId, infoEntity, entity, count, recordEntity);
//                        sendSpecialGift(infoEntity, entity, count);
                        spareNumber++;
                    } else if (number != 0 && count + 1 < infoEntity.getMaxNumber()) {
                        log.info("不满足人数要求");
                        GroupRecordEntity recordEntity = getGroupRecordEntity(externalUserID, userID, recommendPhone, entity);
                        log.info("只生成队伍成员记录,实体{}", recordEntity);
//                        sendSpecialGift(infoEntity, entity, count);
                        spareNumber++;
                    } else if (count + 1 >= infoEntity.getMaxNumber()) {
                        //将队伍置为1
                        log.info("队伍超过限制人数 , 拒绝参与,队伍完成");
                        entity.setStatus(1);
                        groupRepository.save(entity);
                    }
                } else {
                    entity.setStatus(1);
                    groupRepository.save(entity);
                    log.info("发现过期队伍,将队伍设置为暂停,参数{}", entity);
                }
            }
            if (entities.size() == queNumber) {
                log.info("推荐的队伍不满足status=0条件,不创建新的队伍");
//                saveGroup1(channelId, recommendPhone, userID);//生成队伍
//                saveGroupRecordTeam(state, externalUserID, userID);//递归
            }
        } else {
            log.info("没有找到推荐的队伍,不创建新的队伍");
//            saveGroup1(channelId, recommendPhone, userID);//生成队伍
//            saveGroupRecordTeam(state, externalUserID, userID);//递归
        }
    }

    private void lockAndSendGift(String channelId, GroupInfoEntity infoEntity, GroupEntity entity, Integer count, GroupRecordEntity recordEntity) {
        Object actualNum = redisTemplate.opsForHash().get(Constant.TUIGUANG_PERSON_LOCK + channelId, entity.getId());
        if (Objects.nonNull(actualNum)) {
            actualNum = redisTemplate.opsForHash().increment(Constant.TUIGUANG_PERSON_LOCK + channelId, entity.getId(), 1);
        }
        Integer num = Integer.valueOf(actualNum.toString());
        if (num <= infoEntity.getMaxNumber()) {
            log.info("生成队伍成员记录,并发放基本奖励,实体{},此时redis人数为{}", recordEntity,num);
            sendGiftAndRecord(recordEntity, infoEntity, entity);
            if (num == infoEntity.getMaxNumber()) {
                log.info("队伍==限制人数 ,队伍完成");
                entity.setStatus(1);
                groupRepository.save(entity);
            }
        }
    }

    private boolean remainer(String channelId, GroupInfoEntity infoEntity, List<GroupEntity> entities) {
        String key = Constant.GROUP_AMOUNT;
        if (Objects.isNull(redisTemplate.opsForHash().get(key, channelId))) {
            //1.第一次入参
            redisTemplate.opsForHash().put(key, channelId, infoEntity.getMaxAmount() + "");
        }
        //2. 参数减法
        Long decr = Long.valueOf(redisTemplate.opsForHash().increment(key, channelId, -infoEntity.getAmount()));
        if (decr < 0) {
            log.info("活动已送出最大金额{},该队伍暂停", infoEntity.getMaxAmount());
            entities.forEach(e -> e.setStatus(1));
            groupRepository.save(entities);
            return true;
        }
        return false;
    }

//    /**
//     * @Description: 发放特别奖励
//     * @Param:
//     * @return:
//     * @Author: xiaoLiu
//     * @Date: 2020/8/13
//     */
//    private void sendSpecialGift(GroupInfoEntity infoEntity, GroupEntity entity, Integer count) {
//        //分段发送奖励
//        List<GroupGiftRuleEntity> giftRuleEntities = groupGiftRuleRepository.findByGroupInfoId(infoEntity.getId());
//        if (giftRuleEntities.size() > 0) {
//            log.info("开始发放分段奖励");
//            for (int i = 0; i < giftRuleEntities.size(); i++) {
//                Integer requirePersonNumber = giftRuleEntities.get(i).getRequirePersonNumber();
//                if (count+1 - requirePersonNumber == 0) {
//                    //修改当前队伍的段位
//                    entity.setLevelNumber(requirePersonNumber);
//                    groupRepository.save(entity);
//                    boolean sendReward = sendFactory.getSendReward(giftRuleEntities.get(i).getType());
//                    if (sendReward) {
//                        log.info("{}发放成功",giftRuleEntities.get(i).getRewardName());
//                    } else {
//                        log.info("{}发放失败",giftRuleEntities.get(i).getRewardName());
//                    }
//                    break;
//                }
//            }
//        }
//    }

    /**
     * @Description: 获取队伍记录
     * @Param:
     * @return:
     * @Author: xiaoLiu
     * @Date: 2020/8/7
     */
    private GroupRecordEntity getGroupRecordEntity(String externalUserID, String userID, String recommendPhone, GroupEntity entity) {
        WXCustomerEntity customerEntity = wxCustomerRepository.findByExternalUserIdAndCsUserId(externalUserID, userID);
        GroupRecordEntity recordEntity = new GroupRecordEntity();
        recordEntity.setRecommendPhone(recommendPhone);
        recordEntity.setExternalId(externalUserID);
        recordEntity.setTeamId(entity.getId());
        recordEntity.setName(customerEntity.getName());
        recordEntity.setAvatar(customerEntity.getAvatar());
        recordEntity.setCsId(userID);
        groupRecordRepository.save(recordEntity);
        return recordEntity;
    }

    /**
     * @Description:人数满足改变状态并检查数据
     * @Param:
     * @return:
     * @Author: xiaoLiu
     * @Date: 2020/8/6
     */
    private void sendGiftAndRecord(GroupRecordEntity groupRecordEntity, GroupInfoEntity infoEntity, GroupEntity entity) {
        GroupGiftRecordEntity giftRecordEntity = new GroupGiftRecordEntity();
        giftRecordEntity.setGroupRecordId(groupRecordEntity.getId());
        giftRecordEntity.setTeamId(entity.getId());
        //赠送金额大于0的时候开始请求
        if (infoEntity.getAmount() > 0) {
            giftRecordEntity.setAmount(infoEntity.getAmount());
            //完成拼团人数要求 , 请求会员中心赠送余额
            String tradeNo = UUIDUtils.get32UUID();
            try {
                Map<String, Object> param = Maps.newHashMapWithExpectedSize(2);
                param.put("mobile", entity.getPhone());
                param.put("source", 5);
                param.put("tradeBusiness", 1);
                param.put("amount", infoEntity.getAmount() * 100);
                param.put("tradeNo", tradeNo);
                log.info("开始请求会员中心,参数{}", param);
                Map map = restTemplateUtils.postByMap(param, Map.class, PartnerAccess.WASH_CAR, UserCenterUrl.PRESENT_AMOUNT.getUrl());
                log.info("会员中心响应参数{}", map);
                if (Constant.RESPONSE_CODE_SUCCESS.equals(map.get("code").toString())) {
                    giftRecordEntity.setTradeNo(tradeNo);
                    Map<String, Object> parkParam = Maps.newHashMapWithExpectedSize(2);
                    String telPhone = entity.getPhone().substring(0, 3) + "****" + entity.getPhone().substring(7, 11);
//                    GroupOpenIdPhoneEntity openIdPhoneEntity = groupOpenIdPhoneRepository.findTopByPhoneNumber(entity.getPhone());
//                    String url = "xxxxxxx";
                    parkParam.put("telNumber", entity.getPhone());
                    StringBuilder stringBuilder = new StringBuilder();
                    stringBuilder.append("亲爱的用户")
                            .append(telPhone).append("xxx").append(infoEntity.getPersonNumber())
   .append("xxxxx").append(infoEntity.getAmount())
                            .append("xxxx");
//                    stringBuilder.append(",详情请点击查看:" + url + "?openId=" + openIdPhoneEntity.getOpenId());
                    stringBuilder.append("xxxxx");
                    parkParam.put("preContent", stringBuilder.toString());
                    log.info("请求封装参数{}", parkParam);
                    //创建短信通知用户
                    Map parkingResultMap = restTemplateUtils.postByMap(parkParam, Map.class, PartnerAccess.PARKING_SMS, "xxxxxxxx");
                    log.info("响应参数{}", parkingResultMap);
                    //                Map resMap = restTemplateUtils.get("xxxxxx" + entity.getPhone() + "&amount=" + infoEntity.getAmount() + "&num=" + infoEntity.getPersonNumber(), Map.class);
                    if (Objects.nonNull(parkingResultMap.get("flag")) && "1".equals(parkingResultMap.get("flag").toString())) {
                        log.info("短信通知成功");
                    } else {
                        log.info("通知失败");
                    }
                } else {
                    log.error("会员中心请求失败,msg{}", map);
                }
            } catch (Exception e) {
                log.error("会员中心异常:", e);
            }
        }
//        //赠送优惠券
//        if(Objects.nonNull(infoEntity.getCouponType())){
//            switch (infoEntity.getCouponType()) {
//                case 0:
//                    //todo 发放洗车券
//                    break;
//                case 1:
//                    //todo 发放停车券
//                    break;
//                case 2:
//                    // todo 发放洗车和停车券
//                    break;
//            }
//        }
        groupGiftRecordRepository.save(giftRecordEntity);

    }

    /**
     * @Description:队伍满时生成新的队伍
     * @Param:
     * @return:
     * @Author: xiaoLiu
     * @Date: 2020/8/6
     */
    private GroupEntity saveGroup1(String channelId, String recommendPhone, String userID) {
        Map<String, Object> map = Maps.newHashMapWithExpectedSize(2);
        map.put("phoneNumber", recommendPhone);
        map.put("ID", channelId);
        WXCSUserEntity wxcsUserEntity = wxcsUserRepository.findByCsUserId(userID);
        GroupEntity groupEntity = saveGroup(map, wxcsUserEntity);
        return groupEntity;
    }

二维码生成

利用企微API调用即可生成二维码,只是个性化需求不一样而已

赏

小劉感谢您的赞赏

微信