Merge branch 'developer' into hive2.0

Helius

2022-05-27 4351e71d782741143a98f86f6648acd16689165f

 zq-erp/src/main/java/com/matrix/system/activity/action/ActivitySignAwardSetAction.java

@@ -1,30 +1,30 @@
package com.matrix.system.activity.action;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.matrix.core.constance.MatrixConstance;
import com.matrix.core.pojo.AjaxResult;
import com.matrix.core.tools.StringUtils;
import com.matrix.system.activity.dto.ActivitiesListDto;
import com.matrix.system.activity.dto.AddSignAwardSetDto;
import com.matrix.system.activity.dto.BeCloseDto;
import com.matrix.system.activity.dto.BeReadyDto;
import com.matrix.system.activity.dto.CouponDto;
import com.matrix.system.activity.dto.DelRowDto;
import com.matrix.system.activity.dto.GoodsDto;
import com.matrix.system.activity.dto.SignForUpdateDto;
import com.matrix.system.activity.dto.SignReceiveListDto;
import com.matrix.system.activity.dto.UpdateSignAwardSetDto;
import com.matrix.core.tools.WebUtil;
import com.matrix.system.activity.dao.ActivitySignAwardSetDao;
import com.matrix.system.activity.dto.*;
import com.matrix.system.activity.entity.ActivitySignAwardSet;
import com.matrix.system.activity.service.ActivitySignAwardSetService;
import com.matrix.system.activity.vo.ActivitiesListVo;
import com.matrix.system.activity.vo.CouponVo;
import com.matrix.system.activity.vo.GoodsVo;
import com.matrix.system.activity.vo.SignReceiveListVo;
import com.matrix.system.activity.vo.*;
import com.matrix.system.common.bean.SysUsers;
import com.matrix.system.hive.action.util.QueryUtil;
import com.matrix.system.shopXcx.bean.ShopActivities;
import com.matrix.system.shopXcx.dao.ShopActivitiesDao;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.*;

/**
 * @description 奖品设置表
@@ -37,6 +37,370 @@

   @Autowired
   private ActivitySignAwardSetService activitySignAwardSetService;
   @Autowired
   private ShopActivitiesDao shopActivitiesDao;
   @Autowired
   private ActivitySignAwardSetDao activitySignAwardSetDao;

   /**
    * 马上创建转盘抽奖
    */
   @PostMapping(value = "/createLuckyDrawSet")
   public @ResponseBody
   AjaxResult createLuckyDrawSet() {
      //获取当前登录人员信息
      SysUsers user = WebUtil.getSessionAttribute(MatrixConstance.LOGIN_KEY);
      Long companyId = user.getCompanyId();
      //签到活动的唯一性
      List<ShopActivities> shopActivitiesDone = shopActivitiesDao.selectOneByCompanyIdAndActType(companyId,ShopActivities.ACTIVITIES_TYPE_LUCKYDRAW);
      if(CollUtil.isNotEmpty(shopActivitiesDone)){
         return new AjaxResult(AjaxResult.STATUS_FAIL, "转盘抽奖已经创建，请去活动管理菜单查看");
      }
      return new AjaxResult(AjaxResult.STATUS_SUCCESS, "");
   }

   /**
    * 新增转盘抽奖
    */
   @PostMapping(value = "/addLuckyDrawSet")
   public @ResponseBody
   AjaxResult addLuckyDrawSet(@RequestBody AddLuckyDrawSetDto addLuckyDrawSetDto) {
      //获取当前登录人员信息
      SysUsers user = WebUtil.getSessionAttribute(MatrixConstance.LOGIN_KEY);
      Long companyId = user.getCompanyId();
      //转盘抽奖活动的唯一性
      List<ShopActivities> shopActivitiesDone = shopActivitiesDao.selectOneByCompanyIdAndActType(companyId,ShopActivities.ACTIVITIES_TYPE_LUCKYDRAW);
      if(CollUtil.isNotEmpty(shopActivitiesDone)){
         return new AjaxResult(AjaxResult.STATUS_FAIL, "转盘抽奖只能创建一次");
      }

      //新增活动主表信息
      ShopActivities shopActivities = new ShopActivities();
      shopActivities.setActName(addLuckyDrawSetDto.getActName());
      shopActivities.setActCode(addLuckyDrawSetDto.getActCode());
      shopActivities.setIsStart(ShopActivities.ACTIVITIES_STATUS_CLOSE);
      shopActivities.setActType(ShopActivities.ACTIVITIES_TYPE_LUCKYDRAW);
      shopActivities.setActStatus(ShopActivities.ACTSTATUS_STATUS_RELEASE);
      shopActivities.setActBeginTime(addLuckyDrawSetDto.getBeginTime());
      shopActivities.setActEndTime(addLuckyDrawSetDto.getEndTime());
      shopActivities.setCompanyId(companyId);
      shopActivities.setCreateBy(user.getSuName());
      shopActivities.setUpdateBy(user.getSuName());
      //将基本信息转换成JSON字符串存储到活动主表的act_content字段
      LuckyDrawBasicJsonDto luckyDrawBasicJsonDto = addLuckyDrawSetDto.getLuckyDrawBasicJsonDto();
      String json= JSON.toJSONString(luckyDrawBasicJsonDto);
      shopActivities.setActContent(json);
      int insert = shopActivitiesDao.insert(shopActivities);
      if(insert > 0){
         //新增活动奖品信息
         List<ActivitySignAwardSet> activitySignAwardSets = addLuckyDrawSetDto.getLuckyDrawAwardSets();
         if(CollUtil.isNotEmpty(activitySignAwardSets)) {
            for(ActivitySignAwardSet activitySignAwardSet : activitySignAwardSets) {
               activitySignAwardSet.setCreateBy(user.getSuName());
               activitySignAwardSet.setCreateTime(new Date());
               activitySignAwardSet.setUpdateTime(new Date());
               activitySignAwardSet.setUpdateBy(user.getSuName());
               activitySignAwardSet.setCompanyId(companyId);
               activitySignAwardSet.setActivityId(shopActivities.getId());
               activitySignAwardSet.setAwardState(ActivitySignAwardSet.AWARDSTATE_WORK);
               activitySignAwardSetDao.insert(activitySignAwardSet);
            }
            //生成中奖顺序

            Long actId = shopActivities.getId();
            List<ActivitySignAwardSet> activitySignAwardSetList = activitySignAwardSetDao
                  .selectActivitySignAwardSetByActIDAndCompanyIdAndAwardType(actId, companyId, ActivitySignAwardSet.AWARDSTATE_WORK,ActivitySignAwardSet.AWARDRULE_CUMULATIVEDAY);
            if(CollUtil.isNotEmpty(activitySignAwardSetList)){
               String awrdList = getAwrdList(activitySignAwardSets).toString();
               ShopActivities shopActivitiesAward = shopActivitiesDao.selectById(actId);
               String actContent = shopActivitiesAward.getActContent();
               LuckyDrawAwardCodeListVo luckyDrawAwardCodeListVo = JSON.parseObject(actContent, LuckyDrawAwardCodeListVo.class);
               luckyDrawAwardCodeListVo.setAwardLine(awrdList);
               luckyDrawAwardCodeListVo.setAwrdLineIndex(0);
               String awardJson= JSON.toJSONString(luckyDrawAwardCodeListVo);
               shopActivitiesAward.setActContent(awardJson);
               shopActivitiesDao.updateByModel(shopActivitiesAward);
            }
         }
      }else{
         return new AjaxResult(AjaxResult.STATUS_FAIL, "保存失败");
      }
      return new AjaxResult(AjaxResult.STATUS_SUCCESS, "保存成功");
   }

   //所有奖品ID后的集合
   public List getAwrdList(List<ActivitySignAwardSet> activitySignAwardSets){
      //插入所有奖品ID后的集合
      LinkedList awardIdFinalList = new LinkedList<>();
      if(CollUtil.isNotEmpty(activitySignAwardSets)){
         //总数
         int maxCount = 0;
         HashMap<Long, ActivitySignAwardSet> integerStringHashMap = new HashMap<>();
         for(ActivitySignAwardSet activitySignAwardSet : activitySignAwardSets){
            //总共派发数量
            int awardInventoryCnt = activitySignAwardSet.getAwardInventoryCnt();
            integerStringHashMap.put(activitySignAwardSet.getId(),activitySignAwardSet);
            maxCount = maxCount + awardInventoryCnt;
         }
         HashMap<Long, ActivitySignAwardSet> sortHashMap = sortHashMap(integerStringHashMap,2);
         HashMap<Long, ActivitySignAwardSet> sortHashMapAec = sortHashMap(integerStringHashMap,1);
         //获取奖品最多的ID
         Long maxAwardIds = sortHashMap.keySet().stream().findFirst().get();
         Long minAwardIds = sortHashMapAec.keySet().stream().findFirst().get();
         //获取最大长度的奖品集合
         List awardIdList = new LinkedList<Long>();
         for(int i = 0; i< maxCount ; i++){
            awardIdList.add(maxAwardIds);
         }

         Iterator<Map.Entry<Long, ActivitySignAwardSet>> entries = sortHashMap.entrySet().iterator();
         //插入奖品
         while (entries.hasNext()) {
            Map.Entry<Long, ActivitySignAwardSet> entry = entries.next();
            ActivitySignAwardSet activitySignAwardSetDone = entry.getValue();
            int awardInventoryCnt = activitySignAwardSetDone.getAwardInventoryCnt();
            Long awardIdNew = entry.getKey();
            if(awardIdNew != maxAwardIds){
               //分段之后的List
               List splitLists = getSplitList(awardInventoryCnt, awardIdList);
               for(int j = 0; j<awardInventoryCnt; j++){
                  List splitList = (List) splitLists.get(j);
                  //中间插入对应的奖品ID，如果和maxAwardIds相同，则索引+1
                  List<Long> listInsert = getListInsert(maxAwardIds, awardIdNew, splitList);
                  if(minAwardIds == awardIdNew){
                     awardIdFinalList.addAll(listInsert);
                  }
               }
            }
         }
      }
      return awardIdFinalList;
   }

   //中间插入对应的奖品ID，如果和maxAwardIds相同，则索引+1
   public static List<Long> getListInsert(Long awardOld,Long awardNew,List splitList){
      //中间位置索引
      LinkedList<Integer> indexs = new LinkedList<>();
      int groupFlag = splitList.size() % 2 == 0 ? (splitList.size() / 2) : (splitList.size() / 2 + 1);
      for(int j = groupFlag-1; j < splitList.size();j++){
         if(splitList.get(j) == awardOld){
            indexs.add(j);
         }
      }
      if(CollUtil.isNotEmpty(indexs)){
         splitList.set(indexs.get(0),awardNew);
      }else{
         splitList.add(groupFlag,awardNew);
      }
      return splitList;
   }

   //等份平分数组，最后剩余的添加到倒数第二个集合中
   public static List<List<Long>> getSplitList(int splitNum, List<Long> list) {
      LinkedList<List<Long>> splitList = new LinkedList<>();
      // groupFlag >= 1
      int groupFlag = list.size() % splitNum == 0 ? (list.size() / splitNum) : (list.size() / splitNum);
      if(groupFlag * splitNum < list.size()){
         for (int j = 1; j <= splitNum +1; j++) {
            if ((j * groupFlag) <= list.size() ) {
               splitList.add(list.subList(j * groupFlag - groupFlag, j * groupFlag));
            } else if ((j * groupFlag) > list.size()) {
               splitList.add(list.subList(j * groupFlag - groupFlag, list.size()));
            }
         }
      }else if(groupFlag * splitNum > list.size()){
         for (int j = 1; j < splitNum; j++) {
            if ((j * groupFlag) <= list.size() ) {
               splitList.add(list.subList(j * groupFlag - groupFlag, j * groupFlag));
            } else if ((j * groupFlag) > list.size()) {
               splitList.add(list.subList(j * groupFlag - groupFlag, list.size()));
            }
         }
      }else{
         for (int j = 1; j <= splitNum; j++) {
            if ((j * groupFlag) <= list.size() ) {
               splitList.add(list.subList(j * groupFlag - groupFlag, j * groupFlag));
            } else if ((j * groupFlag) > list.size()) {
               splitList.add(list.subList(j * groupFlag - groupFlag, list.size()));
            }
         }
      }
      return splitList;
   }


   //对于奖品排序 1:升序进行排,2是倒序就是o2-o1
   public static HashMap<Long, ActivitySignAwardSet> sortHashMap(HashMap<Long, ActivitySignAwardSet> map,int type) {
      // 首先拿到 map 的键值对集合
      Set<Map.Entry<Long, ActivitySignAwardSet>> entrySet = map.entrySet();
      // 将 set 集合转为 List 集合，为什么，为了使用工具类的排序方法
      List<Map.Entry<Long, ActivitySignAwardSet>> list = new ArrayList<Map.Entry<Long, ActivitySignAwardSet>>(entrySet);
      // 使用 Collections 集合工具类对 list 进行排序，排序规则使用匿名内部类来实现
      Collections.sort(list, new Comparator<Map.Entry<Long, ActivitySignAwardSet>>() {
         @Override
         public int compare(Map.Entry<Long, ActivitySignAwardSet> o1, Map.Entry<Long, ActivitySignAwardSet> o2) {
            if(type == 2){
               //按照要求根据 升序进行排,如果是倒序就是o2-o1
               return o2.getValue().getAwardInventoryCnt() - o1.getValue().getAwardInventoryCnt();
            }
            return o1.getValue().getAwardInventoryCnt() - o2.getValue().getAwardInventoryCnt();
         }
      });
      //创建一个新的有序的 HashMap 子类的集合
      LinkedHashMap<Long, ActivitySignAwardSet> linkedHashMap = new LinkedHashMap<Long, ActivitySignAwardSet>();
      //将 List 中的数据存储在 LinkedHashMap 中
      for (Map.Entry<Long, ActivitySignAwardSet> entry : list) {
         linkedHashMap.put(entry.getKey(), entry.getValue());
      }
      //返回结果
      return linkedHashMap;
   }

   /**
    *进入修改
    */
   @ApiOperation(value = "进入修改")
   @PostMapping(value = "/findLuckyDrawForUpdate")
   public @ResponseBody
   AjaxResult findLuckyDrawForUpdate(@RequestBody LuckyDrawForUpdateDto luckyDrawForUpdateDto) {
      //设置用户公司ID
      QueryUtil.setQueryLimitCom(luckyDrawForUpdateDto);
      Long actId = luckyDrawForUpdateDto.getActId();
      AjaxResult result= AjaxResult.buildSuccessInstance("查询成功");
      //获取对应的活动主表信息和对应的奖品设置信息
      AddLuckyDrawSetVo addLuckyDrawSetVo = new AddLuckyDrawSetVo();
      ShopActivities shopActivity = shopActivitiesDao.selectById(actId);
      if(ObjectUtil.isNotEmpty(shopActivity)) {
         addLuckyDrawSetVo.setId(actId);
         addLuckyDrawSetVo.setActName(shopActivity.getActName());
         addLuckyDrawSetVo.setActCode(shopActivity.getActCode());
         addLuckyDrawSetVo.setBeginTime(shopActivity.getActBeginTime());
         addLuckyDrawSetVo.setEndTime(shopActivity.getActEndTime());

         String actContent = shopActivity.getActContent();
         LuckyDrawBasicJsonVo luckyDrawBasicJsonVo = JSON.parseObject(actContent, LuckyDrawBasicJsonVo.class);
         addLuckyDrawSetVo.setLuckyDrawBasicJsonVo(luckyDrawBasicJsonVo);

         Map<String, Object> columnMap = new HashMap<String, Object>();
         columnMap.put("activity_id", actId);
         columnMap.put("company_id", luckyDrawForUpdateDto.getCompanyId());
         List<ActivitySignAwardSet> activityAwardSets = activitySignAwardSetDao.selectByMap(columnMap);
         addLuckyDrawSetVo.setActivityluckyDrawSets(activityAwardSets);
      }
      result.putInMap("addLuckyDrawSetVo", addLuckyDrawSetVo);
      return result;
   }
   /**
    * 保存
    */
   @PostMapping(value = "/updateLuckyDrawSet")
   public @ResponseBody
   AjaxResult updateLuckyDrawSet(@RequestBody UpdateLuckyDrawSetDto updateLuckyDrawSetDto) {
      //获取当前登录人员信息
      QueryUtil.setQueryLimitCom(updateLuckyDrawSetDto);
      SysUsers user = WebUtil.getSessionAttribute(MatrixConstance.LOGIN_KEY);
      Long actId = updateLuckyDrawSetDto.getActMainId();
      Long companyId = user.getCompanyId();
      ShopActivities shopActivity = shopActivitiesDao.selectById(actId);
      //更新活动主表信息
      shopActivity.setActName(updateLuckyDrawSetDto.getActName());
      shopActivity.setActCode(updateLuckyDrawSetDto.getActCode());
      shopActivity.setActBeginTime(updateLuckyDrawSetDto.getBeginTime());
      shopActivity.setActEndTime(updateLuckyDrawSetDto.getEndTime());
      shopActivity.setCompanyId(companyId);
      shopActivity.setCreateBy(user.getSuName());
      shopActivity.setUpdateBy(user.getSuName());
      //将基本信息转换成JSON字符串存储到活动主表的act_content字段
      LuckyDrawBasicJsonDto luckyDrawBasicJsonDto = updateLuckyDrawSetDto.getLuckyDrawBasicJsonDto();
      String json=JSON.toJSONString(luckyDrawBasicJsonDto);
      shopActivity.setActContent(json);
      shopActivitiesDao.updateByModel(shopActivity);
      /**
       * 比较两个奖品名单，多的新增，减少的更新为已失效，不变的更新
       */
      //原有的奖品
      ArrayList<Long> arrayListOld = new ArrayList<>();
      Map<String, Object> columnMap = new HashMap<String, Object>();
      columnMap.put("activity_id", actId);
      columnMap.put("company_id", updateLuckyDrawSetDto.getCompanyId());
      List<ActivitySignAwardSet> activitySignAwardSetOld = activitySignAwardSetDao.selectByMap(columnMap);
      if(CollUtil.isNotEmpty(activitySignAwardSetOld)) {
         for(ActivitySignAwardSet activitySignAwardSetUpdate : activitySignAwardSetOld) {
            Long actSubid = activitySignAwardSetUpdate.getId();
            arrayListOld.add(actSubid);
         }
      }
      //修改后的奖品
      List<ActivitySignAwardSet> activitySignAwardSetsUpdate = updateLuckyDrawSetDto.getActivityAwardSets();
      ArrayList<Long> arrayListUpdate = new ArrayList<>();
      if(CollUtil.isNotEmpty(activitySignAwardSetsUpdate)) {
         for(ActivitySignAwardSet activitySignAwardSetUpdate : activitySignAwardSetsUpdate) {
            Long actSubid = activitySignAwardSetUpdate.getId();
            //如果ID为空则新增，不为空则修改
            if(ObjectUtil.isEmpty(actSubid)) {
               activitySignAwardSetUpdate.setCreateBy(user.getSuName());
               activitySignAwardSetUpdate.setCreateTime(new Date());
               activitySignAwardSetUpdate.setUpdateTime(new Date());
               activitySignAwardSetUpdate.setUpdateBy(user.getSuName());
               activitySignAwardSetUpdate.setCompanyId(companyId);
               activitySignAwardSetUpdate.setActivityId(actId);
               activitySignAwardSetUpdate.setAwardState(ActivitySignAwardSet.AWARDSTATE_WORK);
               activitySignAwardSetDao.insert(activitySignAwardSetUpdate);
            }else {
               activitySignAwardSetUpdate.setAwardState(ActivitySignAwardSet.AWARDSTATE_WORK);
               activitySignAwardSetDao.updateById(activitySignAwardSetUpdate);
               arrayListUpdate.add(actSubid);
            }
         }
      }
      //比较获取原来的比现在多出来的奖品，修改状态为失效
      boolean removeAll = arrayListOld.removeAll(arrayListUpdate);
      if(removeAll && CollUtil.isNotEmpty(arrayListOld)) {
         for(long id : arrayListOld) {
            ActivitySignAwardSet activitySignAwardSetDel = activitySignAwardSetDao.selectById(id);
            activitySignAwardSetDel.setAwardState(ActivitySignAwardSet.AWARDSTATE_UNWORK);
            activitySignAwardSetDao.updateById(activitySignAwardSetDel);
         }
      }

      //生成中奖顺序
      List<ActivitySignAwardSet> activitySignAwardSetList = activitySignAwardSetDao
            .selectActivitySignAwardSetByActIDAndCompanyIdAndAwardType(actId, companyId, ActivitySignAwardSet.AWARDSTATE_WORK,ActivitySignAwardSet.AWARDRULE_CUMULATIVEDAY);
      if(CollUtil.isNotEmpty(activitySignAwardSetList)){
         String awrdList = getAwrdList(activitySignAwardSetList).toString();
         ShopActivities shopActivitiesAward = shopActivitiesDao.selectById(actId);
         String actContent = shopActivitiesAward.getActContent();
         LuckyDrawAwardCodeListVo luckyDrawAwardCodeListVo = JSON.parseObject(actContent, LuckyDrawAwardCodeListVo.class);
         luckyDrawAwardCodeListVo.setAwardLine(awrdList);
         luckyDrawAwardCodeListVo.setAwrdLineIndex(0);
         String awardJson= JSON.toJSONString(luckyDrawAwardCodeListVo);
         shopActivitiesAward.setActContent(awardJson);
         shopActivitiesDao.updateByModel(shopActivitiesAward);
      }
      return new AjaxResult(AjaxResult.STATUS_SUCCESS, "保存成功");
   }

   public IPage<ActivitiesListVo> findActivitiesList(Page<ActivitiesListVo> page,
                                         ActivitiesListDto activitiesListDto) {
      return shopActivitiesDao.findActivitiesList(page,activitiesListDto);
   }

   /**
    * 马上创建签到活动
    */
   @PostMapping(value = "/createSignAwardSet")
   public @ResponseBody
   AjaxResult createSignAwardSet() {
      //获取当前登录人员信息
      SysUsers user = WebUtil.getSessionAttribute(MatrixConstance.LOGIN_KEY);
      Long companyId = user.getCompanyId();
      //签到活动的唯一性
      List<ShopActivities> shopActivitiesDone = shopActivitiesDao.selectOneByCompanyIdAndActType(companyId,ShopActivities.ACTIVITIES_TYPE_SIGN);
      if(CollUtil.isNotEmpty(shopActivitiesDone)){
         return new AjaxResult(AjaxResult.STATUS_FAIL, "签到活动已经创建，请去活动管理菜单查看");
      }
      return new AjaxResult(AjaxResult.STATUS_SUCCESS, "");
   }

   /**
    * 新增签到活动