Merge remote-tracking branch 'origin/master'

linwe

2024-05-15 fe81eb39c7402082f54e6aaee491efbcbb1aa50a

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

@@ -16,26 +16,50 @@
 */
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.common.param.CommonParamSet;
import org.springblade.common.utils.NodeTreeUtil;
import org.springblade.common.utils.SpringUtils;
import org.springblade.core.log.exception.ServiceException;
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.house.entity.HouseholdEntity;
import org.springblade.modules.house.excel.HouseHoldExcel;
import org.springblade.modules.house.entity.UserHouseLabelEntity;
import org.springblade.modules.house.excel.ImportHouseholdExcel;
import org.springblade.modules.house.mapper.HouseholdMapper;
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.DictBiz;
import org.springblade.modules.system.entity.User;
import org.springblade.modules.system.service.IDictBizService;
import org.springblade.modules.system.service.IUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
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;

/**
 * 住户 服务实现类
@@ -47,15 +71,60 @@
public class HouseholdServiceImpl extends ServiceImpl<HouseholdMapper, HouseholdEntity> implements IHouseholdService {

   @Autowired
   private IUserHouseLabelService userHouseLabelService;

   @Autowired
   private IDictBizService dictBizService;

   @Autowired
   private IUserService userService;

   @Autowired
   private IPlaceService placeService;

   @Override
   public IPage<HouseholdVO> selectHouseholdPage(IPage<HouseholdVO> page, HouseholdVO household) {
      return page.setRecords(baseMapper.selectHouseholdPage(page, household));
      StopWatch stopWatch = new StopWatch();
      stopWatch.start();
      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, commonParamSet.getIsAdministrator(),
         commonParamSet.getRegionChildCodesList(), commonParamSet.getGridCodeList());
      stopWatch.stop();
//      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
    */
@@ -66,6 +135,7 @@

   /**
    * 查询房屋人员情况
    *
    * @param code
    * @return
    */
@@ -81,13 +151,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()) {
@@ -104,41 +175,123 @@

   /**
    * 住户 自定义新增或修改
    *
    * @param household
    * @return
    */
   @Override
   public boolean saveOrUpdateHousehold(HouseholdEntity household) {
      // 判断添加人是否房屋业主
      Long count = count(Wrappers.<HouseholdEntity>lambdaQuery()
         .eq(HouseholdEntity::getHouseCode, household.getHouseCode())
         .eq(HouseholdEntity::getAssociatedUserId, AuthUtil.getUserId())
         .eq(HouseholdEntity::getRelationship, 1));
      if (count == 0) {
         return false;
      }
   @Transactional(rollbackFor = Exception.class)
   public boolean saveOrUpdateHousehold(HouseholdVO household) {
      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);
         // 更新用户信息
         updateUserInfo(household);
         // 更新标签信息
         updateUserLabelInfo(household);
      } else {
         // 往用户表中插入数据
         // 通过手机号判断
         if (!Strings.isBlank(household.getPhoneNumber())) {
            //判断用户是否存在
         }
         // 新增
         household.setCreateTime(new Date());
         household.setCreateUser(AuthUtil.getUserId());
         flag = save(household);
         // 更新用户信息
         updateUserInfo(household);
         // 更新标签信息
         updateUserLabelInfo(household);
      }
      return flag;
   }

   /**
    * 更新用户标签信息
    *
    * @param household
    */
   public void updateUserLabelInfo(HouseholdVO household) {
      if (household.getHouseholdLabelList().size() > 0) {
         List<HouseholdLabelVO> householdLabelList = household.getHouseholdLabelList();
         for (HouseholdLabelVO householdLabelVO : householdLabelList) {
            if (!Strings.isBlank(household.getHouseCode())) {
               householdLabelVO.setHouseCode(household.getHouseCode());
            }
            householdLabelVO.setHouseholdId(household.getId());
            // 先删除对应绑定的信息
            userHouseLabelService.saveOrUpdateHouseholdLabel(householdLabelVO);
         }
      }
   }

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

   /**
    * 业主和用户绑定
    *
    * @param
    */
   public User bindUserHandle(HouseholdEntity householdEntity) {
      User newUser = new User();
      if (null != householdEntity.getPhoneNumber() && !householdEntity.getPhoneNumber().equals("")) {
         //根据手机号查询库里的数据
         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")) {
               user.setRoleId(user.getRoleId() + ",1717429059648606209");
               //更新
               userService.updateById(user);
            }
         } else {
            //如果用户不存在，则新增一个用户
            newUser.setAccount(householdEntity.getPhoneNumber());
            newUser.setPhone(householdEntity.getPhoneNumber());
            newUser.setName(householdEntity.getName());
            newUser.setRealName(householdEntity.getName());
            // 社区群众部门
            newUser.setDeptId("1727979636479037441");
            // 目前暂定居民角色，
            newUser.setRoleId("1717429059648606209");
            //默认密码为 123456
            newUser.setPassword("123456");
            // 设置机构
            // 用户新增
            boolean submit = userService.submit(newUser);
            //绑定id
            householdEntity.setAssociatedUserId(newUser.getId());
            //更新住户信息
            updateById(householdEntity);
         }
      }
      return newUser;
   }

   /**
    * 住户 自定义查询详情
    *
    * @param household
    * @return
    */
@@ -148,33 +301,171 @@
   }

   @Override
   public List<HouseHoldExcel> export(HouseholdVO household) {
      List<HouseHoldExcel> userHouseHoldExcels = baseMapper.export(household);
   public List<ImportHouseholdExcel> export(HouseholdVO household) {
      List<ImportHouseholdExcel> userHouseHoldExcels = baseMapper.export(household);
      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) {
      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.getPhoneNumber())){
            errorNum ++;
            continue;
         }
         // 查询库中是否已存在
         QueryWrapper<HouseholdEntity> wrapper = new QueryWrapper<>();
         wrapper.eq("house_code", householdEntity.getHouseCode())
            .eq("is_deleted", 0)
            .eq("phone_number", householdEntity.getPhoneNumber())
            .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 (!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(" 条数据，")
         .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) {
      return baseMapper.statistics(userId);
   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
    */
@@ -197,19 +488,266 @@
   @Override
   public Object getHouseHoldStatistics(String code, String roleType) {
      Map<String, Object> objectObjectHashMap = new HashMap<>();
      if (roleType.equals("1")) {
         List<Map<String, Object>> result = baseMapper.getHouseHoldStatistics(code, AuthUtil.getUserId());
         List<Map<String, Object>> result1 = baseMapper.getHouseHoldStatisticsAge(code, AuthUtil.getUserId());
      if (roleType.equals("2")) {
         List<Map<String, Object>> result = baseMapper.getHouseHoldStatistics(code, null, roleType);
         List<Map<String, Object>> result1 = baseMapper.getHouseHoldStatisticsAge(code, null, roleType);
         objectObjectHashMap.put("gender", result);
         objectObjectHashMap.put("age", result1);
         return objectObjectHashMap;
      } else {
         List<Map<String, Object>> result = baseMapper.getHouseHoldStatistics(code, null);
         List<Map<String, Object>> result1 = baseMapper.getHouseHoldStatisticsAge(code, null);
         List<Map<String, Object>> result = baseMapper.getHouseHoldStatistics(code, AuthUtil.getUserId(), roleType);
         List<Map<String, Object>> result1 = baseMapper.getHouseHoldStatisticsAge(code, AuthUtil.getUserId(), roleType);
         objectObjectHashMap.put("gender", result);
         objectObjectHashMap.put("age", result1);
         return objectObjectHashMap;
      }

   }

   /**
    * 住户业主信息处理，将业主人员插入到用户表
    *
    * @return
    */
   @Override
   public Object userHandle() {
      // 查询所有未入库的业主信息
      List<HouseholdEntity> householdEntityList = baseMapper.getNotInsertUserHousehold();
      // 批量入用户库
      for (HouseholdEntity householdEntity : householdEntityList) {
         // 根据手机号查询对应账号和手机号的用户信息
         List<User> userList = userService.getUserListByPhoneOrAccount(householdEntity.getPhoneNumber());
         if (userList.size() > 0) {
            User user = userList.get(0);
            householdEntity.setAssociatedUserId(user.getId());
            // 更新
            updateById(householdEntity);
            // 判断用户是否包含了居民角色,不包含则需更新
            if (!user.getRoleId().contains("1717429059648606209")) {
               user.setRoleId(user.getRoleId() + ",1717429059648606209");
               //更新
               userService.updateById(user);
            }
         } else {
            // 插入用户信息
            //如果用户不存在，则新增一个用户
            User newUser = new User();
            newUser.setAccount(householdEntity.getPhoneNumber());
            newUser.setPhone(householdEntity.getPhoneNumber());
            newUser.setName(householdEntity.getName());
            newUser.setRealName(householdEntity.getName());
            // 社区群众部门
            newUser.setDeptId("1727979636479037441");
            // 目前暂定居民角色，
            newUser.setRoleId("1717429059648606209");
            //默认密码为 123456
            newUser.setPassword("123456");
            // 用户新增
            boolean submit = userService.submit(newUser);
            // 更新绑定用户信息
            householdEntity.setAssociatedUserId(newUser.getId());
            // 更新
            updateById(householdEntity);
         }
      }
      return null;
   }

   /**
    * 住户 删除
    */
   @Override
   @Transactional(rollbackFor = Exception.class)
   public boolean removeHousehold(String ids) {
      List<Long> idList = Func.toLongList(ids);
      // 同时删除当前住户对应的标签
      removeHouseholdLabel(idList);
      // 同时删除对应的用户信息
      removeHouseholdUser(idList);
      // 删除住户信息
      boolean removeByIds = removeByIds(idList);
      // 返回
      return removeByIds;
   }


   /**
    * 同时删除对应的用户信息
    *
    * @param idList
    */
   public void removeHouseholdUser(List<Long> idList) {
      for (Long id : idList) {
         HouseholdEntity householdEntity = getById(id);
         // 如果是业主
         if (null!= householdEntity.getRelationship() && householdEntity.getRelationship() == 1) {
            // 查询对应的用户
            User user = userService.getById(householdEntity.getAssociatedUserId());
            // 判断是否还绑定其他的房屋，如果有，则不操作用户
            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());
                     }
                  }
               }
            }
         }
      }
   }

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

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

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