住户导入去除手机号校验

zhongrj

2024-05-24 81afe3df5e2802bd1d7e32b25c6dd7151da8b45e

 src/main/java/org/springblade/modules/house/service/impl/HouseholdServiceImpl.java

@@ -16,32 +16,42 @@
 */
package org.springblade.modules.house.service.impl;

import cn.hutool.core.util.IdcardUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import liquibase.repackaged.org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.util.Strings;
import org.springblade.common.constant.CommonConstant;
import org.springblade.common.node.TreeIntegerNode;
import org.springblade.common.node.TreeStringNode;
import org.springblade.core.mp.support.Condition;
import org.springblade.common.param.CommonParamSet;
import org.springblade.common.utils.NodeTreeUtil;
import org.springblade.common.utils.SpringUtils;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.utils.BeanUtil;
import org.springblade.core.tool.utils.Func;
import org.springblade.modules.grid.service.IGridService;
import org.springblade.modules.house.entity.HouseRentalEntity;
import org.springblade.modules.house.entity.HouseholdEntity;
import org.springblade.modules.house.entity.UserHouseLabelEntity;
import org.springblade.modules.house.excel.HouseHoldExcel;
import org.springblade.modules.house.excel.ExportHouseholdExcel;
import org.springblade.modules.house.excel.HouseTenantExcel;
import org.springblade.modules.house.excel.ImportHouseholdExcel;
import org.springblade.modules.house.mapper.HouseholdMapper;
import org.springblade.modules.house.service.IHouseRentalService;
import org.springblade.modules.house.service.IHouseService;
import org.springblade.modules.house.service.IHouseholdService;
import org.springblade.modules.house.service.IUserHouseLabelService;
import org.springblade.modules.house.vo.HouseholdLabelVO;
import org.springblade.modules.house.vo.HouseholdOtherVO;
import org.springblade.modules.house.vo.HouseholdVO;
import org.springblade.modules.label.entity.LabelEntity;
import org.springblade.modules.label.service.ILabelService;
import org.springblade.modules.place.entity.PlaceEntity;
import org.springblade.modules.place.service.IPlaceService;
import org.springblade.modules.system.entity.Dept;
import org.springblade.modules.system.entity.DictBiz;
import org.springblade.modules.system.entity.User;
import org.springblade.modules.system.service.IDeptService;
import org.springblade.modules.system.service.IDictBizService;
import org.springblade.modules.system.service.IUserService;
import org.springframework.beans.factory.annotation.Autowired;
@@ -49,6 +59,8 @@
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StopWatch;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

@@ -71,27 +83,55 @@
   private IUserService userService;

   @Autowired
   private IDeptService deptService;
   private IPlaceService placeService;

   @Autowired
   private IPlaceService placeService;
   private IHouseRentalService iHouseRentalService;


   @Override
   public IPage<HouseholdVO> selectHouseholdPage(IPage<HouseholdVO> page, HouseholdVO household) {
      StopWatch stopWatch = new StopWatch();
      stopWatch.start();
      Dept dept = deptService.getById(AuthUtil.getDeptId());
      if (null!=dept){
         household.setRegionCode(dept.getRegionCode());
      CommonParamSet commonParamSet = new CommonParamSet().invoke(HouseholdVO.class, household);

//      List<String> regionChildCodesList = SysCache.getRegionChildCodesByDeptId(AuthUtil.getDeptId());
//      Integer isAdministrator = AuthUtil.isAdministrator()==true?1:2;
      // 重点人员与关注人员
      if (Objects.nonNull(household.getLabelType())) {
         extracted(household);
      }
      List<HouseholdVO> householdVOS = baseMapper.selectHouseholdPage(page, household);
      List<HouseholdVO> householdVOS = baseMapper.selectHouseholdPage(page, household, commonParamSet.getIsAdministrator(),
         commonParamSet.getRegionChildCodesList(), commonParamSet.getGridCodeList());
      stopWatch.stop();
      System.out.println("selectHouseholdPage:" + stopWatch.getTotalTimeMillis());
//      System.out.println("selectHouseholdPage:" + stopWatch.getTotalTimeMillis());
      return page.setRecords(householdVOS);
   }

   /**
    * 重点人员与关注人员
    * @param household
    */
   private void extracted(HouseholdVO household) {
      ILabelService iLabelService = SpringUtils.getBean(ILabelService.class);
      if (CommonConstant.NUMBER_ONE.equals(household.getLabelType())) {
         List<LabelEntity> list = iLabelService.list(Wrappers.<LabelEntity>lambdaQuery().eq(LabelEntity::getParentId, 103));
         List<Integer> collect = list.stream().map(item ->
            item.getId()
         ).collect(Collectors.toList());
         household.setLabelIdList(collect);
      } else if (CommonConstant.NUMBER_TWO.equals(household.getLabelType())) {
         List<LabelEntity> list = iLabelService.list(Wrappers.<LabelEntity>lambdaQuery().eq(LabelEntity::getParentId, 1032));
         List<Integer> collect = list.stream().map(item ->
            item.getId()
         ).collect(Collectors.toList());
         household.setLabelIdList(collect);
      }
   }

   /**
    * 查询房屋集合信息
    *
    * @param userId
    * @return
    */
@@ -102,6 +142,7 @@

   /**
    * 查询房屋人员情况
    *
    * @param code
    * @return
    */
@@ -117,13 +158,14 @@

   /**
    * 处理字典
    *
    * @param householdList
    */
   private void handleDictBiz(List<HouseholdVO> householdList) {
      if (householdList.size()>0){
      if (householdList.size() > 0) {
         // 查询角色关系字典
         List<DictBiz> dictBizList = dictBizService.getList("roleRelation");
         if (dictBizList.size()>0) {
         List<DictBiz> dictBizList = dictBizService.getList("roleRelation", null);
         if (dictBizList.size() > 0) {
            // 遍历
            for (HouseholdVO householdVO : householdList) {
               if (null != householdVO.getRelationship()) {
@@ -140,6 +182,7 @@

   /**
    * 住户 自定义新增或修改
    *
    * @param household
    * @return
    */
@@ -149,6 +192,10 @@
      boolean flag = false;
      household.setUpdateTime(new Date());
      household.setUpdateUser(AuthUtil.getUserId());
      if (!Strings.isBlank(household.getRoleName()) && household.getRoleName().equals("居民")) {
         // 待审核
         household.setConfirmFlag(0);
      }
      if (null != household.getId()) {
         // 更新
         flag = updateById(household);
@@ -171,10 +218,11 @@

   /**
    * 更新用户标签信息
    *
    * @param household
    */
   public void updateUserLabelInfo(HouseholdVO household) {
      if (household.getHouseholdLabelList().size()>0){
      if (household.getHouseholdLabelList().size() > 0) {
         List<HouseholdLabelVO> householdLabelList = household.getHouseholdLabelList();
         for (HouseholdLabelVO householdLabelVO : householdLabelList) {
            if (!Strings.isBlank(household.getHouseCode())) {
@@ -189,11 +237,12 @@

   /**
    * 更新用户信息
    *
    * @param household
    */
   public void updateUserInfo(HouseholdEntity household) {
      // 判断用户是否为业主，如果是业主，则新增
      if (null!=household.getRelationship() && household.getRelationship()==1){
      if (null != household.getRelationship() && household.getRelationship() == 1) {
         // 如果为业主
         // 新增用户
         bindUserHandle(household);
@@ -202,29 +251,23 @@

   /**
    * 业主和用户绑定
    *
    * @param
    */
   public User bindUserHandle(HouseholdEntity householdEntity) {
      User newUser = new User();
      if (null!=householdEntity.getPhoneNumber() && !householdEntity.getPhoneNumber().equals("")) {
      if (null != householdEntity.getPhoneNumber() && !householdEntity.getPhoneNumber().equals("")) {
         //根据手机号查询库里的数据
         User userParams = new User();
         userParams.setPhone(householdEntity.getPhoneNumber());
         User user = userService.getOne(Condition.getQueryWrapper(userParams));
         if (null==user) {
            User userParams1 = new User();
            userParams1.setAccount(householdEntity.getPhoneNumber());
            userParams1.setIsDeleted(0);
            user = userService.getOne(Condition.getQueryWrapper(userParams1));
         }
         if (null!=user) {
         List<User> list = userService.getUserListByPhoneOrAccount(householdEntity.getPhoneNumber());
         if (list.size()>0) {
            User user = list.get(0);
            //如果用户存在，则该用户id绑定场所
            householdEntity.setAssociatedUserId(user.getId());
            //更新住户信息
            updateById(householdEntity);
            newUser = user;
            // 判断用户是否包含了居民角色,不包含则需更新
            if (!user.getRoleId().contains("1717429059648606209")){
            if (!user.getRoleId().contains("1717429059648606209")) {
               user.setRoleId(user.getRoleId() + ",1717429059648606209");
               //更新
               userService.updateById(user);
@@ -255,6 +298,7 @@

   /**
    * 住户 自定义查询详情
    *
    * @param household
    * @return
    */
@@ -263,34 +307,214 @@
      return baseMapper.getHouseholdListById(household);
   }

   /**
    * 导出住户信息
    * @param household
    * @return
    */
   @Override
   public List<HouseHoldExcel> export(HouseholdVO household) {
      List<HouseHoldExcel> userHouseHoldExcels = baseMapper.export(household);
   public List<ExportHouseholdExcel> export(HouseholdVO household) {
      CommonParamSet commonParamSet = new CommonParamSet().invoke(HouseholdVO.class, household);
      // 重点人员与关注人员
      if (Objects.nonNull(household.getLabelType())) {
         extracted(household);
      }
      List<ExportHouseholdExcel> userHouseHoldExcels = baseMapper.export(household,
         commonParamSet.getIsAdministrator(),
         commonParamSet.getRegionChildCodesList(),
         commonParamSet.getGridCodeList()
      );
      return userHouseHoldExcels;
   }


   /**
    * 导入住户数据
    *
    * @param data
    * @param isCovered
    */
   @Override
   @Transactional(rollbackFor = Exception.class)
   public void importUserHouseHold(List<HouseHoldExcel> data, Boolean isCovered) {
      data.forEach(houseHoldExcel -> {
         HouseholdEntity houseHoldEntity = Objects.requireNonNull(BeanUtil.copy(houseHoldExcel, HouseholdEntity.class));
         this.save(houseHoldEntity);
      });
   public String importUserHouseHold(List<ImportHouseholdExcel> data, Boolean isCovered, String isTenant) {
      IHouseService houseService = SpringUtils.getBean(IHouseService.class);
      int totalNum = data.size();
      int importNum = 0;
      int updateNum = 0;
      int errorNum = 0;
      for (ImportHouseholdExcel houseHoldExcel : data) {
         HouseholdEntity householdEntity = Objects.requireNonNull(BeanUtil.copy(houseHoldExcel, HouseholdEntity.class));
         // 判断姓名，手机号
         if (Strings.isBlank(householdEntity.getName())
            || Strings.isBlank(householdEntity.getHouseCode())
         ) {
            errorNum++;
            continue;
         }
         // 查询库中是否已存在
         QueryWrapper<HouseholdEntity> wrapper = new QueryWrapper<>();
         wrapper.eq("house_code", householdEntity.getHouseCode())
            .eq("is_deleted", 0)
            .eq("name", householdEntity.getName());
         HouseholdEntity one = this.getOne(wrapper);
         // 与角色关系
         if (!Strings.isBlank(houseHoldExcel.getRelationship())) {
            householdEntity.setRelationship(Integer.parseInt(houseHoldExcel.getRelationship()));
            // 如果是业主，则需要往用户表插入用户
            if (householdEntity.getRelationship() == 1) {
               houseService.saveOrUpdateUser(householdEntity);
            }
         }
         // 判断是否租户导入
         if (StringUtils.isNotBlank(isTenant)) {
            householdEntity.setRelationship(18);
            HouseRentalEntity houseRentalEntity = iHouseRentalService.getOne(Wrappers.<HouseRentalEntity>lambdaQuery()
               .eq(HouseRentalEntity::getHouseCode, householdEntity.getHouseCode()));
            if (houseRentalEntity != null) {
               householdEntity.setHousingRentalId(houseRentalEntity.getId());
            } else {
               // 新建出租屋
               HouseRentalEntity houseRentalEntity1 = new HouseRentalEntity();
               houseRentalEntity1.setHouseCode(householdEntity.getHouseCode());
               houseRentalEntity1.setHouseStatus(1);
               houseRentalEntity1.setAuditStatus(0);
               houseRentalEntity1.setRentalUse(4);
               houseRentalEntity1.setTenantRelationship(1);
               houseRentalEntity1.setRentalTime(new Date());
               houseRentalEntity1.setDueTime(new Date());
               houseRentalEntity1.setTerminationTime(new Date());
               iHouseRentalService.save(houseRentalEntity1);
               householdEntity.setHousingRentalId(houseRentalEntity1.getId());
               // errorNum++;
               // continue;
            }
         }
         /// 是否主要联系人
         if (!Strings.isBlank(houseHoldExcel.getIsPrimaryContact())) {
            householdEntity.setIsPrimaryContact(Integer.parseInt(houseHoldExcel.getIsPrimaryContact()));
         }
         // 居住状态
         if (!Strings.isBlank(houseHoldExcel.getResidentialStatus())) {
            householdEntity.setResidentialStatus(Integer.parseInt(houseHoldExcel.getResidentialStatus()));
         }
         // 性别
         if (!Strings.isBlank(houseHoldExcel.getGender())) {
            householdEntity.setGender(Short.parseShort(houseHoldExcel.getGender()));
         }
         // 居民身份证
         if (!Strings.isBlank(houseHoldExcel.getIdCard())) {
            if (IdcardUtil.isValidCard(houseHoldExcel.getIdCard())) {
               // 身份证类型为居民身份证
               householdEntity.setCardType(111);
            }
         }
         // 党员
         if (!Strings.isBlank(houseHoldExcel.getPartyEmber())) {
            householdEntity.setPartyEmber(Integer.parseInt(houseHoldExcel.getPartyEmber()));
         }
         // 民族
         if (!Strings.isBlank(houseHoldExcel.getEthnicity())) {
            householdEntity.setEthnicity(Integer.parseInt(houseHoldExcel.getEthnicity()));
         }
         // 学历
         if (!Strings.isBlank(houseHoldExcel.getEducation())) {
            householdEntity.setEducation(Integer.parseInt(houseHoldExcel.getEducation()));
         }
         // 健康状况
         if (!Strings.isBlank(houseHoldExcel.getHealthStatus())) {
            householdEntity.setHealthStatus(Integer.parseInt(houseHoldExcel.getHealthStatus()));
         }
         // 工作状态
         if (!Strings.isBlank(houseHoldExcel.getWorkStatus())) {
            householdEntity.setWorkStatus(Integer.parseInt(houseHoldExcel.getWorkStatus()));
         }
         // 外出时间
         if (!Strings.isBlank(houseHoldExcel.getGoOutTime())) {
            try {
               Date date = new SimpleDateFormat("yyyy-MM-dd").parse(houseHoldExcel.getGoOutTime());
               householdEntity.setGoOutTime(date);
            } catch (ParseException e) {
               e.printStackTrace();
            }
         }
         // 婚姻状态
         if (!Strings.isBlank(houseHoldExcel.getMaritalStatus())) {
            householdEntity.setMaritalStatus(Integer.parseInt(houseHoldExcel.getMaritalStatus()));
         }

         if (one==null){
            // 新增
            this.save(householdEntity);
            importNum++;
            // 处理标签
            handleLabel(householdEntity,houseHoldExcel);
         }else {
            updateNum++;
            if (isCovered){
               // 覆盖更新
               householdEntity.setId(one.getId());
               // 更新
               updateById(householdEntity);
               importNum++;
               // 处理标签
               handleLabel(householdEntity,houseHoldExcel);
            }
         }
      }
      StringBuilder builder = new StringBuilder("导入完成!");
      builder.append("其中本次表格共有 ").append(totalNum).append(" 条数据，")
         .append("成功导入 ").append(importNum).append(" 条数据。");
      if (updateNum>0) {
         builder.append("其中有 ").append(updateNum).append(" 条数据已存在。");
      }
      if (errorNum>0){
         builder.append("共有 ").append(errorNum).append(" 条数据由于无姓名或门牌地址编码信息未导入!");
      }
      return builder.toString();
   }

   /**
    * 标签处理
    * @param householdEntity
    * @param houseHoldExcel
    */
   public void handleLabel(HouseholdEntity householdEntity, ImportHouseholdExcel houseHoldExcel) {
      if (!Strings.isBlank(houseHoldExcel.getLabelName())){
         // 查询对应的label集合信息
         List<UserHouseLabelEntity> userHouseLabelList = userHouseLabelService.getLabelList(houseHoldExcel.getLabelName());
         if (userHouseLabelList.size()>0){
            for (UserHouseLabelEntity userHouseLabelEntity : userHouseLabelList) {
               userHouseLabelEntity.setHouseCode(householdEntity.getHouseCode());
               userHouseLabelEntity.setHouseholdId(householdEntity.getId());
               userHouseLabelEntity.setUserId(householdEntity.getAssociatedUserId());
               userHouseLabelEntity.setLableType(1);
               userHouseLabelEntity.setColor("green");
               userHouseLabelService.saveOrUpdateHouseholdLabel(userHouseLabelEntity);
            }
         }
      }
   }

   /**
    * 住户审核统计
    *
    * @param userId
    * @return
    */
   @Override
   public Integer statistics(Long userId,String neiCode) {
      return baseMapper.statistics(userId,neiCode);
   public Integer statistics(Long userId, String neiCode, Integer confirmFlag) {
      HouseholdVO householdVO = new HouseholdVO();
      householdVO.setConfirmFlag(confirmFlag);
      householdVO.setCommunityCode(neiCode);
      CommonParamSet commonParamSet = new CommonParamSet().invoke(HouseholdVO.class, householdVO);

      return baseMapper.statistics(householdVO, commonParamSet.getIsAdministrator(),
         commonParamSet.getRegionChildCodesList(), commonParamSet.getGridCodeList());
   }

   /**
    * 住户对应物业，网格，公安负责人查询
    *
    * @param household
    * @return
    */
@@ -331,6 +555,7 @@

   /**
    * 住户业主信息处理，将业主人员插入到用户表
    *
    * @return
    */
   @Override
@@ -341,18 +566,18 @@
      for (HouseholdEntity householdEntity : householdEntityList) {
         // 根据手机号查询对应账号和手机号的用户信息
         List<User> userList = userService.getUserListByPhoneOrAccount(householdEntity.getPhoneNumber());
         if (userList.size()>0){
         if (userList.size() > 0) {
            User user = userList.get(0);
            householdEntity.setAssociatedUserId(user.getId());
            // 更新
            updateById(householdEntity);
            // 判断用户是否包含了居民角色,不包含则需更新
            if (!user.getRoleId().contains("1717429059648606209")){
            if (!user.getRoleId().contains("1717429059648606209")) {
               user.setRoleId(user.getRoleId() + ",1717429059648606209");
               //更新
               userService.updateById(user);
            }
         }else {
         } else {
            // 插入用户信息
            //如果用户不存在，则新增一个用户
            User newUser = new User();
@@ -397,39 +622,46 @@

   /**
    * 同时删除对应的用户信息
    *
    * @param idList
    */
   public void removeHouseholdUser(List<Long> idList) {
      for (Long id : idList) {
         HouseholdEntity householdEntity = getById(id);
         // 如果是业主
         if (householdEntity.getRelationship()==1){
         if (null!= householdEntity.getRelationship() && householdEntity.getRelationship() == 1) {
            // 查询对应的用户
            User user = userService.getById(householdEntity.getAssociatedUserId());
            // 判断角色
            if (!Strings.isBlank(user.getRoleId())){
               List<String> stringList = Arrays.asList(user.getRoleId().split(","));
               // 查询场所
               QueryWrapper<PlaceEntity> queryWrapper = new QueryWrapper<>();
               queryWrapper.eq("is_deleted",0).eq("principal_user_id",user.getId());
               List<PlaceEntity> placeEntityList = placeService.list(queryWrapper);
               if (stringList.size()>1){
                  // 查询是否对应有场所负责人，如果有则不删除，如果没有则删除对应的角色
                  List<String> arrayList = new ArrayList<>();
                  if (placeEntityList.size()==0){
                     for (String roleId : stringList) {
                        if (!roleId.equals("1717429059648606209")){
                           arrayList.add(roleId);
            // 判断是否还绑定其他的房屋，如果有，则不操作用户
            QueryWrapper<HouseholdEntity> wrapper = new QueryWrapper<>();
            wrapper.eq("is_deleted", 0).eq("associated_user_id", user.getId());
            List<HouseholdEntity> householdEntityList = list(wrapper);
            if (householdEntityList.size() == 1) {
               // 判断角色
               if (!Strings.isBlank(user.getRoleId())) {
                  List<String> stringList = Arrays.asList(user.getRoleId().split(","));
                  // 查询场所
                  QueryWrapper<PlaceEntity> queryWrapper = new QueryWrapper<>();
                  queryWrapper.eq("is_deleted", 0).eq("principal_user_id", user.getId());
                  List<PlaceEntity> placeEntityList = placeService.list(queryWrapper);
                  // 即没有房屋和场所了就删除对应的居民角色
                  if (placeEntityList.size() == 0) {
                     // 查看当前用户的角色是否只有一个
                     if (stringList.size() > 1) {
                        // 查询是否对应有场所负责人，如果有则不删除，如果没有则删除对应的角色
                        List<String> arrayList = new ArrayList<>();
                        for (String roleId : stringList) {
                           if (!roleId.equals("1717429059648606209")) {
                              arrayList.add(roleId);
                           }
                        }
                        user.setRoleId(StringUtils.join(arrayList, ","));
                        // 更新用户
                        userService.updateById(user);
                     } else {
                        // 删除当前用户
                        userService.removeById(user.getId());
                     }
                  }
                  user.setRoleId(StringUtils.join(arrayList, ","));
                  // 更新用户
                  userService.updateById(user);
               }else {
                  // 查询是否对应有场所负责人，如果有则不删除，如果没有则删除对应的用户
                  if (placeEntityList.size()==0){
                     userService.removeById(user.getId());
                  }
               }
            }
@@ -439,23 +671,25 @@

   /**
    * 删除住户标签信息
    *
    * @param idList
    */
   public void removeHouseholdLabel(List<Long> idList) {
      for (Long id : idList) {
         QueryWrapper<UserHouseLabelEntity> wrapper = new QueryWrapper<>();
         wrapper.eq("household_id",id);
         wrapper.eq("household_id", id);
         userHouseLabelService.remove(wrapper);
      }
   }

   @Override
   public List<HouseholdVO> getAllHouseHold(HouseholdVO household) {
      return  baseMapper.getAllHouseHold(household);
      return baseMapper.getAllHouseHold(household);
   }

   /**
    * 住户列表查询
    *
    * @param household
    * @return
    */
@@ -464,13 +698,117 @@
      List<HouseholdVO> householdVOS = baseMapper.selectHouseholdList(household);
      // 遍历
      for (HouseholdVO householdVO : householdVOS) {
         if (householdVO.getHouseholdLabelList().size()>0){
         if (householdVO.getHouseholdLabelList().size() > 0) {
            List<String> labelNameList = householdVO.getHouseholdLabelList().stream().map(householdLabelVO -> householdLabelVO.getLabelName())
               .collect(Collectors.toList());
            householdVO.setLabelName(String.join(",",labelNameList));
            householdVO.setLabelName(String.join(",", labelNameList));
         }
      }
      // 返回
      return  householdVOS;
      return householdVOS;
   }

   @Override
   public IPage<HouseholdVO> getKeynotePersonnelPage(IPage<HouseholdVO> page, HouseholdVO household) {
      // StopWatch stopWatch = new StopWatch();
      // stopWatch.start();
      // Dept dept = deptService.getById(AuthUtil.getDeptId());
      // if (null!=dept){
      //    household.setRegionCode(dept.getRegionCode());
      // }
      List<HouseholdVO> householdVOS = baseMapper.getKeynotePersonnelPage(page, household);
      // stopWatch.stop();
      // System.out.println("selectHouseholdPage:" + stopWatch.getTotalTimeMillis());
      return page.setRecords(householdVOS);
   }

   /**
    * 根据人员标签编号集合查询对应的住户（按颜色区分近多少天没有发过任务的住户）
    *
    * @param list
    * @return
    */
   @Override
   public List<HouseholdVO> getHouseholdListByParam(List<Integer> list) {
      return baseMapper.getHouseholdListByParam(list);
   }

   @Override
   public List<TreeIntegerNode> getlabelStatistics(HouseholdVO household) {
      Map<Integer, TreeIntegerNode> labelTreeList = baseMapper.getlabelStatistics(household);
      List<TreeIntegerNode> nodeTree = NodeTreeUtil.getNodeTree(labelTreeList);
      nodeTree.forEach(node -> recursion(node));
      return nodeTree;
   }

   private void recursion(TreeIntegerNode node) {
      if (node.getChildren() != null && node.getChildren().size() > 0) {
         if (node.getId().equals(1030)) {
            int sum = node.getChildren().stream().mapToInt(TreeIntegerNode::getCount).sum();
            node.setCount(sum);
         }
         if (node.getId().equals(1031)) {
            int sum = node.getChildren().stream().mapToInt(TreeIntegerNode::getCount).sum();
            node.setCount(sum);
         }
         node.getChildren().forEach(node2 -> recursion(node2));
      } else {
         node.setChildren(null);
      }
   }

   /**
    * 通过小区id查询用户
    * @param householdVO
    * @param page
    * @return
    */
   @Override
   public IPage<HouseholdVO> getUserInfoByDistrictIds(HouseholdVO householdVO, IPage<HouseholdVO> page) {
      List<String> list = Func.toStrList(householdVO.getDistrictIds());
      List<HouseholdVO> userInfoByDistrictIds = baseMapper.getUserInfoByDistrictIds(list, householdVO, page);
      return page.setRecords(userInfoByDistrictIds);
   }

   /**
    * 查询住户对应的社区编号
    * @param id
    * @return
    */
   @Override
   public String getCommunityCode(Long id) {
      return baseMapper.getCommunityCode(id);
   }

   /**
    * 查询所有住户总数
    * @return
    */
   @Override
   public int getAllListTotal() {
      return baseMapper.getAllListTotal();
   }

   /**
    * 查询对应的住户集合
    *
    * @param i
    * @param size
    * @return
    */
   @Override
   public List<HouseholdVO> getAllList(int i, int size) {
      return baseMapper.getAllList(i, size);
   }

   @Override
   public List<HouseTenantExcel> exportTenant(HouseholdVO household) {
      CommonParamSet commonParamSet = new CommonParamSet().invoke(HouseholdVO.class, household);
      List<HouseTenantExcel> houseTenantExcels = baseMapper.exportTenant(household,
         commonParamSet.getIsAdministrator(),
         commonParamSet.getRegionChildCodesList(),
         commonParamSet.getGridCodeList()
      );
      return houseTenantExcels;
   }
}