场所记录查询过滤调整，binlog 解析调整

zhongrj

2024-02-23 1af3f0036d8a0ede8f97ecb2075bee43109a4977

 src/main/java/org/springblade/modules/place/service/impl/PlaceServiceImpl.java

@@ -18,12 +18,18 @@

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
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.cache.SysCache;
import org.springblade.common.node.TreeStringNode;
import org.springblade.common.param.CommonParamSet;
import org.springblade.common.utils.IdUtils;
import org.springblade.common.utils.SpringUtils;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.utils.SpringUtil;
import org.springblade.modules.doorplateAddress.entity.DoorplateAddressEntity;
import org.springblade.modules.doorplateAddress.service.IDoorplateAddressService;
import org.springblade.modules.grid.entity.GridEntity;
@@ -33,18 +39,29 @@
import org.springblade.modules.grid.service.IGridService;
import org.springblade.modules.grid.service.IGridmanService;
import org.springblade.modules.grid.vo.GridVO;
import org.springblade.modules.house.entity.HouseholdEntity;
import org.springblade.modules.house.entity.UserHouseLabelEntity;
import org.springblade.modules.house.service.IHouseholdService;
import org.springblade.modules.place.entity.*;
import org.springblade.modules.place.excel.NinePlaceExcel;
import org.springblade.modules.place.excel.PlaceAndRelExcel;
import org.springblade.modules.place.excel.PlaceExcel;
import org.springblade.modules.place.service.IPlaceExtService;
import org.springblade.modules.place.service.IPlacePoiLabelService;
import org.springblade.modules.place.service.IPlaceRelService;
import org.springblade.modules.place.vo.PlaceCheckVO;
import org.springblade.modules.place.vo.PlacePoiLabelVO;
import org.springblade.modules.place.vo.PlaceVO;
import org.springblade.modules.place.mapper.PlaceMapper;
import org.springblade.modules.place.service.IPlaceService;
import org.springblade.modules.police.entity.PoliceAffairsGridEntity;
import org.springblade.modules.police.service.IPoliceAffairsGridService;
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.IRegionService;
import org.springblade.modules.system.service.IUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@@ -52,6 +69,7 @@
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 场所表 服务实现类
@@ -86,45 +104,37 @@
   private IGridmanService gridmanService;

   @Autowired
   private IDeptService deptService;
   private GridMapper gridMapper;

   @Autowired
   private GridMapper gridMapper;
   private IHouseholdService householdService;

   @Autowired
   private IDictBizService dictBizService;

   /**
    * 自定义列表查询
    *
    * @param page
    * @param place
    * @return
    */
   @Override
   public IPage<PlaceVO> selectPlacePage(IPage<PlaceVO> page, PlaceVO place) {
      Dept dept = deptService.getById(AuthUtil.getDeptId());
      if (null!=dept){
         place.setRegionCode(dept.getRegionCode());
      }
      List<String> list = new ArrayList<>();
      if (null!=place.getRoleName() && !place.getRoleName().equals("")){
         if (place.getRoleName().equals("网格员")){
            // 查询对应的房屋地址code
            list = gridService.getAddressCodeListByUserId(AuthUtil.getUserId());
         }
      }
      List<PlaceVO> placeVOS = baseMapper.selectPlacePage(page, place, list);
      // 遍历
      for (PlaceVO placeVO : placeVOS) {
         // 设置对应的网格名称
         GridVO gridVO = gridService.getGridDetailByHouseCode(placeVO.getHouseCode());
         if (null!= gridVO){
            placeVO.setGridName(gridVO.getGridName());
         }
      }
      // 公共参数设置
      CommonParamSet commonParamSet = new CommonParamSet().invoke(PlaceVO.class,place);
      List<PlaceVO> placeVOS = baseMapper.selectPlacePage(page,
         place,
         commonParamSet.getGridCodeList(),
         commonParamSet.getRegionChildCodesList(),
         commonParamSet.getIsAdministrator());
      // 返回
      return page.setRecords(placeVOS);
   }

   /**
    * 查询场所集合信息
    *
    * @param userId
    * @return
    */
@@ -135,6 +145,7 @@

   /**
    * 场所信息自定义新增/修改
    *
    * @param placeVO
    * @return
    */
@@ -145,74 +156,210 @@
      placeVO.setUpdateUser(AuthUtil.getUserId());
      placeVO.setUpdateTime(new Date());
      // 查看是否包含houseCode,如果有，则更新
      if (!Strings.isBlank(placeVO.getHouseCode())){
      if (!Strings.isBlank(placeVO.getHouseCode())) {
         setSource(placeVO);
         // 比对是否1km 范围内(现场)采集
         setIsScene(placeVO);
         // 更新,先查询场所信息
         QueryWrapper<PlaceEntity> wrapper = new QueryWrapper<>();
         wrapper.eq("is_deleted",0).eq("house_code",placeVO.getHouseCode());
         wrapper.eq("is_deleted", 0).eq("house_code", placeVO.getHouseCode());
         PlaceEntity one = getOne(wrapper);
         if (null!=one) {
         if (null != one) {
            placeVO.setId(one.getId());
         } else {
            // 新增，地址表中没有或者地址表中有场所表中没有的（是房屋的），扫码进来的
            save(placeVO);
         }
         // 设置来源( 1：地址总表  2：国控采集),扫码采集
         placeVO.setSource(1);
         // 绑定用户信息
         bindUserHandle(placeVO);
         // 设置完善状态
         setPlaceStatus(placeVO);
         // 更新场所信息
         flag = updateById(placeVO);
         // 保存场所详情及任务信息
         savePlaceExtAndTaskInfo(placeVO);
         // 场所标签信息绑定(更新，调整）
         placeLabelBind(placeVO);
         // 网格绑定
         gridBind(placeVO);
      }else {
      } else {
         // 设置基础数据
         placeVO.setCreateUser(AuthUtil.getUserId());
         placeVO.setCreateTime(new Date());
         // 比对是否1km 范围内(现场)采集
         setIsSceneNotHouseCode(placeVO);
         // 设置来源( 1：地址总表  2：国控采集)
         placeVO.setSource(2);
         // 并生成36位的houseCode
         placeVO.setHouseCode(IdUtils.getIdBy36());
         // 绑定用户信息
         bindUserHandle(placeVO);
         // 设置完善状态
         setPlaceStatus(placeVO);
         // 新增场所信息
         flag = save(placeVO);
         // 保存场所详情及任务信息
         savePlaceExtAndTaskInfo(placeVO);
         // 场所标签信息绑定
         placeLabelBind(placeVO);
         // 网格绑定
         gridBind(placeVO);
      }
      // 位置绑定，通过定位去匹配所在网格
      // 保存场所详情及任务信息
      savePlaceExtAndTaskInfo(placeVO);
      // 场所标签信息绑定(更新，调整）
      placeLabelBind(placeVO);
      // 网格绑定
      gridBind(placeVO);
      // 网格编号绑定场所-新
      gridCodeBind(placeVO);
      // 警务网格绑定
      jwGridCodeBind(placeVO);
      // 房屋编号绑定
//      houseCodeBind(placeVO);
      // 返回结果
      return flag;
   }

   /**
    * 设置场所的source 来源
    * @param placeVO
    */
   public void setSource(PlaceVO placeVO) {
      if (null!=placeVO.getSource()){
         placeVO.setSource(placeVO.getSource());
      }else {
         // 查询该houseCode 是否存在地址总表，如果是，赋值 1，否则2
         QueryWrapper<DoorplateAddressEntity> wrapper = new QueryWrapper<>();
         wrapper.eq("address_code",placeVO.getHouseCode());
         DoorplateAddressEntity one = doorplateAddressService.getOne(wrapper);
         if (null!=one){
            placeVO.setSource(1);
         }else {
            placeVO.setSource(2);
         }
      }
   }

   /**
    * 警务网格绑定
    *
    * @param placeVO
    */
   public void jwGridCodeBind(PlaceVO placeVO) {
      if (!Strings.isBlank(placeVO.getLng())) {
         String point = "'POINT(" + placeVO.getLng() + " " + placeVO.getLat() + ")'";
         // 点落面警务网格
         List<PoliceAffairsGridEntity> policeAffairsGridEntities
            = SpringUtil.getBean(IPoliceAffairsGridService.class).spatialAnalysis(point);
         if (policeAffairsGridEntities.size() > 0) {
            // 设置警务网格并更新
            placeVO.setJwGridCode(policeAffairsGridEntities.get(0).getJwGridCode());
            // 更新
            updateById(placeVO);
         }
      }
   }

   /**
    * 设置是否现场采集（1km 范围内）
    *
    * @param placeVO
    */
   public void setIsScene(PlaceVO placeVO) {
      if (!Strings.isBlank(placeVO.getX()) && !Strings.isBlank(placeVO.getLng())) {
         Integer placeEntity = baseMapper.comparisonPosition(placeVO);
         if (placeEntity == 1) {
            placeVO.setIsScene(1);
         } else {
            placeVO.setIsScene(2);
         }
      }
   }

   /**
    * 设置是否现场采集（1km 范围内）,非地址总表数据
    *
    * @param placeVO
    */
   public void setIsSceneNotHouseCode(PlaceVO placeVO) {
      if (!Strings.isBlank(placeVO.getX()) && !Strings.isBlank(placeVO.getLng())) {
         boolean flag = baseMapper.comparisonPositionNotHouseCode(placeVO);
         if (flag) {
            placeVO.setIsScene(1);
         } else {
            placeVO.setIsScene(2);
         }
      }
   }

   /**
    * 房屋绑定
    *
    * @param placeVO
    */
   public void houseCodeBind(PlaceVO placeVO) {
      String houseCode = placeVO.getHouseCode();
      List<String> list = Arrays.asList(houseCode.split(","));
      if (list.size() > 1) {
         // 处理对应的绑定房屋数据
         List<Long> longs = new ArrayList<>();
         // 把其他单个的场所数据删除
         for (String code : list) {
            // 先查询对应的场所id
            QueryWrapper<PlaceEntity> wrapper = new QueryWrapper<>();
            wrapper.eq("house_code", code).eq("is_deleted", 0);
            PlaceEntity one = getOne(wrapper);
            if (null != one) {
               longs.add(one.getId());
               // 删除对应的单个编号的场所
               removeById(one.getId());
            }
         }
         if (longs.size() > 0) {
            // 删除对应的详情
            removePlaceExt(longs);
            // 删除对应的标签绑定信息
            removePlaceLabel(longs);
         }
      } else {
         // 一对一,暂时不处理，后续考虑需加绑定关系表
      }
   }

   /**
    * 设置场所完善状态
    *
    * @param placeVO
    */
   private void setPlaceStatus(PlaceVO placeVO) {
      if (!Strings.isBlank(placeVO.getPrincipal())
         && !Strings.isBlank(placeVO.getPrincipalPhone())
         && !Strings.isBlank(placeVO.getLocation())
         && !Strings.isBlank(placeVO.getPlaceName())
         && !Strings.isBlank(placeVO.getImageUrls())
      ) {
         // 已完善
         placeVO.setStatus(2);
      } else {
         // 未完善
         placeVO.setStatus(1);
      }
   }

   /**
    * 网格绑定
    *
    * @param placeVO
    */
   public void gridBind(PlaceVO placeVO) {
      if (null!=placeVO.getGridId()){
      if (null != placeVO.getGridId()) {
         // 判断关联关系表是否存在
         QueryWrapper<GridRangeEntity> wrapper = new QueryWrapper<>();
         wrapper.eq("house_code",placeVO.getHouseCode());
         wrapper.eq("house_code", placeVO.getHouseCode());
         GridRangeEntity one = gridRangeService.getOne(wrapper);
         if (null==one){
         if (null == one) {
            // 新增
            GridRangeEntity gridRangeEntity = new GridRangeEntity();
            gridRangeEntity.setHouseCode(placeVO.getHouseCode());
            gridRangeEntity.setGridId(placeVO.getGridId());
            // 插入
            gridRangeService.save(gridRangeEntity);
         }else {
         } else {
            // 修改绑定
            one.setGridId(placeVO.getGridId());
            // 修改
            gridRangeService.updateById(one);
         }
      }else {
      } else {
         // 判断角色，如果是网格员则直接使用网格员的网格id,如果是民警则采用点落面的方式进行获取网格的id
         if (!Strings.isBlank(placeVO.getRoleName())) {
            // 网格员角色位置绑定
@@ -224,17 +371,36 @@
   }

   /**
    * 网格员角色位置绑定
    * 网格编号绑定
    *
    * @param placeVO
    */
   private void gridmanPositionHandle(PlaceVO placeVO) {
   public void gridCodeBind(PlaceVO placeVO) {
      // 无网格编号时
      if (Strings.isBlank(placeVO.getGridCode())) {
         // 判断角色，如果是网格员则直接使用网格员的网格id,如果是民警则采用点落面的方式进行获取网格的id
         if (!Strings.isBlank(placeVO.getRoleName())) {
            // 网格员场所网格编号绑定-新
            gridmanGridCodePositionHandle(placeVO);
            // 民警角色时通过位置绑定网格-新
            policeGridCodePositionHandle(placeVO);
         }
      }
   }

   /**
    * 网格员角色位置绑定-grid_id
    *
    * @param placeVO
    */
   public void gridmanPositionHandle(PlaceVO placeVO) {
      if (placeVO.getRoleName().equals("网格员")) {
         // 判断网格员，查询对应网格人对应的网格id
         Integer gridId = gridmanService.getGridIdByUserId(AuthUtil.getUserId());
         if (null != gridId) {
            // 判断关联关系表是否存在
            QueryWrapper<GridRangeEntity> wrapper = new QueryWrapper<>();
            wrapper.eq("grid_id", gridId).eq("house_code", placeVO.getHouseCode());
            wrapper.eq("house_code", placeVO.getHouseCode());
            GridRangeEntity one = gridRangeService.getOne(wrapper);
            if (null == one) {
               // 新增
@@ -243,9 +409,9 @@
               gridRangeEntity.setGridId(gridId);
               // 插入
               gridRangeService.save(gridRangeEntity);
            }else {
            } else {
               // 修改绑定
               one.setGridId(placeVO.getGridId());
               one.setGridId(gridId);
               // 修改
               gridRangeService.updateById(one);
            }
@@ -254,20 +420,40 @@
   }

   /**
    * 网格员角色位置绑定-grid_code
    *
    * @param placeVO
    */
   public void gridmanGridCodePositionHandle(PlaceVO placeVO) {
      if (placeVO.getRoleName().equals("网格员")) {
         // 判断网格员，查询对应网格人对应的网格
         GridEntity grid = gridService.getGridByUserId(AuthUtil.getUserId());
         if (null != grid && !Strings.isBlank(grid.getGridCode())) {
            // 场所编号绑定
            placeVO.setGridCode(grid.getGridCode());
            // 更新场所信息
            updateById(placeVO);
         }
      }
   }

   /**
    * 民警角色位置绑定
    *
    * @param placeVO
    */
   private void policePositionHandle(PlaceVO placeVO) {
      // 是民警且位置信息存在
      if (placeVO.getRoleName().equals("民警") && !Strings.isBlank(placeVO.getLng())) {
         //点坐标解析
         String point = "'POINT(" + placeVO.getLng() + " " + placeVO.getLat() +")'";
         String point = "'POINT(" + placeVO.getLng() + " " + placeVO.getLat() + ")'";
//         String point = "'POINT(" + villageInfoExcel.getLatitude() + " " + villageInfoExcel.getLongitude() +")'";
         GridEntity gridEntity = gridMapper.spatialAnalysis(point);
         if (null != gridEntity) {
         List<GridEntity> gridEntityList = gridMapper.spatialAnalysis(point);
         if (gridEntityList.size() > 0) {
            GridEntity gridEntity = gridEntityList.get(0);
            // 判断关联关系表是否存在
            QueryWrapper<GridRangeEntity> wrapper = new QueryWrapper<>();
            wrapper.eq("grid_id", gridEntity.getId()).eq("house_code", placeVO.getHouseCode());
            wrapper.eq("house_code", placeVO.getHouseCode());
            GridRangeEntity one = gridRangeService.getOne(wrapper);
            if (null == one) {
               // 新增
@@ -276,9 +462,9 @@
               gridRangeEntity.setGridId(gridEntity.getId());
               // 插入
               gridRangeService.save(gridRangeEntity);
            }else {
            } else {
               // 修改绑定
               one.setGridId(placeVO.getGridId());
               one.setGridId(gridEntity.getId());
               // 修改
               gridRangeService.updateById(one);
            }
@@ -287,7 +473,32 @@
   }

   /**
    * 民警角色时通过位置绑定网格
    *
    * @param placeVO
    */
   private void policeGridCodePositionHandle(PlaceVO placeVO) {
      // 是民警且位置信息存在
      if (placeVO.getRoleName().equals("民警") && !Strings.isBlank(placeVO.getLng())) {
         //点坐标解析
         String point = "'POINT(" + placeVO.getLng() + " " + placeVO.getLat() + ")'";
//         String point = "'POINT(" + villageInfoExcel.getLatitude() + " " + villageInfoExcel.getLongitude() +")'";
         List<GridEntity> gridEntityList = gridMapper.spatialAnalysis(point);
         if (gridEntityList.size() > 0) {
            GridEntity gridEntity = gridEntityList.get(0);
            if (null != gridEntity && !Strings.isBlank(gridEntity.getGridCode())) {
               // 场所编号绑定
               placeVO.setGridCode(gridEntity.getGridCode());
               // 更新场所信息
               updateById(placeVO);
            }
         }
      }
   }

   /**
    * 场所标签信息绑定入库
    *
    * @param placeVO
    */
   @Transactional(rollbackFor = Exception.class)
@@ -295,96 +506,118 @@
      // 先查询对于的场所是否已有标签信息
      // 查询对应已存在的从业人员
      QueryWrapper<PlacePoiLabel> wrapper = new QueryWrapper<>();
      wrapper.eq("place_id",placeVO.getId());
      wrapper.eq("place_id", placeVO.getId());
      List<PlacePoiLabel> oldList = placePoiLabelService.list(wrapper);
      if (oldList.size()>0){
      if (oldList.size() > 0) {
         // 先将老的全部删除，然后批量插入
         QueryWrapper<PlacePoiLabel> queryWrapper = new QueryWrapper<>();
         queryWrapper.eq("place_id",placeVO.getId());
         queryWrapper.eq("place_id", placeVO.getId());
         boolean remove = placePoiLabelService.remove(queryWrapper);
         if (remove){
         if (remove) {
            // 批量新增
            savePlaceLabel(placeVO);
         }
      }else {
      } else {
         savePlaceLabel(placeVO);
      }
   }

   /**
    * 插入场所标签信息
    *
    * @param placeVO
    */
   public void savePlaceLabel(PlaceVO placeVO) {
      // 批量新增
      List<String> labelList = Arrays.asList(placeVO.getLabel().split(","));
      if (labelList.size()>1){
         // 只处理小类
         // 遍历
         labelList.forEach(labelId -> {
      if (!Strings.isBlank(placeVO.getLabel())) {
         // 批量新增
         List<String> labelList = Arrays.asList(placeVO.getLabel().split(","));
         if (labelList.size() > 1) {
            // 只处理小类
            // 遍历
            labelList.forEach(labelId -> {
               // 处理小类
               if (labelId.length() > 4) {
                  // 切割成三个，分别是大类，中类，小类
                  String bigString = labelId.substring(0, 2);
                  String midString = labelId.substring(0, 4);
                  // 大类
                  PlacePoiLabel big = new PlacePoiLabel();
                  big.setPlaceId(placeVO.getId());
                  big.setPoiCode(Integer.parseInt(bigString));
                  big.setType(1);
                  if (!Strings.isBlank(placeVO.getColor())) {
                     big.setColor(placeVO.getColor());
                  }
                  placePoiLabelService.save(big);
                  // 中类
                  PlacePoiLabel mid = new PlacePoiLabel();
                  mid.setPlaceId(placeVO.getId());
                  mid.setPoiCode(Integer.parseInt(midString));
                  mid.setType(2);
                  if (!Strings.isBlank(placeVO.getColor())) {
                     mid.setColor(placeVO.getColor());
                  }
                  placePoiLabelService.save(mid);
                  // 小类
                  PlacePoiLabel min = new PlacePoiLabel();
                  min.setPlaceId(placeVO.getId());
                  min.setPoiCode(Integer.parseInt(labelId));
                  min.setType(3);
                  if (!Strings.isBlank(placeVO.getColor())) {
                     min.setColor(placeVO.getColor());
                  }
                  placePoiLabelService.save(min);
               }
            });
         } else {
            // 处理单个
            String labelCode = labelList.get(0);
            // 切割成三个，分别是大类，中类，小类
            String bigString = labelCode.substring(0, 2);
            String midString = labelCode.substring(0, 4);
            // 大类
            PlacePoiLabel big = new PlacePoiLabel();
            big.setPlaceId(placeVO.getId());
            big.setPoiCode(Integer.parseInt(bigString));
            big.setType(1);
            if (!Strings.isBlank(placeVO.getColor())) {
               big.setColor(placeVO.getColor());
            }
            placePoiLabelService.save(big);
            // 中类
            PlacePoiLabel mid = new PlacePoiLabel();
            mid.setPlaceId(placeVO.getId());
            mid.setPoiCode(Integer.parseInt(midString));
            mid.setType(2);
            if (!Strings.isBlank(placeVO.getColor())) {
               mid.setColor(placeVO.getColor());
            }
            placePoiLabelService.save(mid);
            // 处理小类
            if (labelId.length()>4) {
               // 切割成三个，分别是大类，中类，小类
               String bigString = labelId.substring(0,2);
               String midString = labelId.substring(0,4);
               // 大类
               PlacePoiLabel big = new PlacePoiLabel();
               big.setPlaceId(placeVO.getId());
               big.setPoiCode(Integer.parseInt(bigString));
               big.setType(1);
               placePoiLabelService.save(big);
               // 中类
               PlacePoiLabel mid = new PlacePoiLabel();
               mid.setPlaceId(placeVO.getId());
               mid.setPoiCode(Integer.parseInt(midString));
               mid.setType(2);
               placePoiLabelService.save(mid);
            if (labelCode.length() > 4) {
               // 小类
               PlacePoiLabel min = new PlacePoiLabel();
               min.setPlaceId(placeVO.getId());
               min.setPoiCode(Integer.parseInt(labelId));
               min.setPoiCode(Integer.parseInt(labelCode));
               min.setType(3);
               if (!Strings.isBlank(placeVO.getColor())) {
                  min.setColor(placeVO.getColor());
               }
               placePoiLabelService.save(min);
            }
         });
      }else {
         // 处理单个
         String labelCode = labelList.get(0);
         // 切割成三个，分别是大类，中类，小类
         String bigString = labelCode.substring(0, 2);
         String midString = labelCode.substring(0, 4);
         // 大类
         PlacePoiLabel big = new PlacePoiLabel();
         big.setPlaceId(placeVO.getId());
         big.setPoiCode(Integer.parseInt(bigString));
         big.setType(1);
         placePoiLabelService.save(big);
         // 中类
         PlacePoiLabel mid = new PlacePoiLabel();
         mid.setPlaceId(placeVO.getId());
         mid.setPoiCode(Integer.parseInt(midString));
         mid.setType(2);
         placePoiLabelService.save(mid);
         // 处理小类
         if (labelCode.length() > 4) {
            // 小类
            PlacePoiLabel min = new PlacePoiLabel();
            min.setPlaceId(placeVO.getId());
            min.setPoiCode(Integer.parseInt(labelCode));
            min.setType(3);
            placePoiLabelService.save(min);
         }
      }
   }

   /**
    * 场所负责人和用户绑定
    *
    * @param placeVO
    */
   @Transactional(rollbackFor = Exception.class)
   public User bindUserHandle(PlaceVO placeVO) {
      User newUser = new User();
      if (null!=placeVO.getPrincipalPhone() && !placeVO.getPrincipalPhone().equals("")) {
      if (null != placeVO.getPrincipalPhone() && !placeVO.getPrincipalPhone().equals("")) {
         placeVO.setPrincipal(placeVO.getPrincipal());
         placeVO.setPrincipalPhone(placeVO.getPrincipalPhone());
         //根据手机号查询库里的数据
@@ -392,19 +625,19 @@
         userParams.setPhone(placeVO.getPrincipalPhone());
         userParams.setIsDeleted(0);
         User user = userService.getOne(Condition.getQueryWrapper(userParams));
         if (null==user){
         if (null == user) {
            User userParams1 = new User();
            userParams1.setAccount(placeVO.getPrincipalPhone());
            userParams1.setIsDeleted(0);
            user = userService.getOne(Condition.getQueryWrapper(userParams1));
         }

         if (null!=user) {
         if (null != user) {
            //如果用户存在，则该用户id绑定场所
            placeVO.setPrincipalUserId(user.getId());
            newUser = user;
            // 判断用户是否包含了居民角色,不包含则需更新
            if (!user.getRoleId().contains("1717429059648606209")){
            if (!user.getRoleId().contains("1717429059648606209")) {
               user.setRoleId(user.getRoleId() + ",1717429059648606209");
               //更新
               userService.updateById(user);
@@ -427,7 +660,7 @@
            //绑定id
            placeVO.setPrincipalUserId(newUser.getId());
            //给人员打上场所负责人的标签
            baseMapper.saveUserLabel(newUser.getId(),1002);
            baseMapper.saveUserLabel(newUser.getId(), 1002);
         }
      }
      return newUser;
@@ -435,6 +668,7 @@

   /**
    * 保存场所详情及任务信息
    *
    * @param placeVO
    */
   @Transactional(rollbackFor = Exception.class)
@@ -443,8 +677,8 @@
      placeExtEntity.setPlaceId(placeVO.getId());
      // 判断是否已存在，已存在则不新增
      QueryWrapper<PlaceExtEntity> wrapper = new QueryWrapper<>();
      wrapper.eq("is_deleted",0)
         .eq("place_id",placeVO.getId());
      wrapper.eq("is_deleted", 0)
         .eq("place_id", placeVO.getId());
      PlaceExtEntity one = placeExtService.getOne(wrapper);
      if (null == one) {
         placeExtEntity.setPlaceId(placeVO.getId());
@@ -461,6 +695,7 @@

   /**
    * 历史场所挂接处理-临时
    *
    * @param place
    * @return
    */
@@ -471,7 +706,7 @@
      // 遍历
      for (PlaceVO placeVO : list) {
         User user = bindUserHandle(placeVO);
         if (null!=user){
         if (null != user) {
            placeVO.setPrincipalUserId(user.getId());
            //更新场所用户id绑定
            baseMapper.updatePlaceEntity(placeVO);
@@ -482,6 +717,7 @@

   /**
    * 历史场所标签挂接处理-临时
    *
    * @param place
    * @return
    */
@@ -492,7 +728,7 @@
      List<PlaceVO> list = baseMapper.getAllHistoryPlace();
      // 遍历
      for (PlaceVO placeVO : list) {
         if (null!=placeVO.getLabel()){
         if (null != placeVO.getLabel()) {
            String[] split = placeVO.getLabel().split(",");
            for (String s : split) {
               PlacePoiLabel placePoiLabel = new PlacePoiLabel();
@@ -507,6 +743,7 @@

   /**
    * 场所表 自定义详情查询
    *
    * @param place
    * @return
    */
@@ -514,37 +751,49 @@
   public PlaceVO getDetail(PlaceVO place) {
      // 查询场所信息
      PlaceVO placeVO = baseMapper.getDetail(place);
      if (null!= place.getAddressType() && place.getAddressType()==4){
         if (null != placeVO) {
      // 门牌信息
      if (null != placeVO) {
         if (null != place.getAddressType() && place.getAddressType() == 4) {
            // 查询地址编码信息（社区派出所相关信息）
            DoorplateAddressEntity addressEntity = placeRelService.getDoorplateAddressEntity(placeVO);
            placeVO.setDoorplateAddressEntity(addressEntity);
            // 查询网格信息
            // 查询网格信息--商超
            placeVO.setGrid(gridService.getGridDetailByParam(placeVO));
         }
      }else {
         if (null != placeVO) {
            if (null != placeVO.getHouseCode() && !placeVO.getHouseCode().equals("")) {
               place.setHouseCode(placeVO.getHouseCode());
         } else {
            // 管理后台查询赋值颜色
            if (placeVO.getPlacePoiLabelVOList().size() > 0) {
               PlacePoiLabelVO placePoiLabelVO = placeVO.getPlacePoiLabelVOList().get(0);
               if (!Strings.isBlank(placePoiLabelVO.getColor())) {
                  placeVO.setColor(placePoiLabelVO.getColor());
               }
            }
            // 查询门牌地址信息
            if (null != place.getHouseCode() && !place.getHouseCode().equals("")) {
               QueryWrapper<DoorplateAddressEntity> wrapper = new QueryWrapper<>();
               wrapper.eq("address_code", place.getHouseCode());
               List<DoorplateAddressEntity> list = doorplateAddressService.list(wrapper);
               if (list.size() > 0) {
                  placeVO.setDoorplateAddressEntity(list.get(0));
                  placeVO.setNeiCode(list.get(0).getNeiCode());
               }
               // 查询网格数据
               GridVO gridVO = gridService.getGridDetailByHouseCode(place.getHouseCode());
               if (null!= gridVO) {
                  placeVO.setGrid(gridVO);
                  place.setGridId(gridVO.getId());
               }
            } else {
               // 通过定位点落面分析网格位置，反向推出社区派出所相关数据

            // 查询地址门牌信息
            QueryWrapper<DoorplateAddressEntity> wrapper = new QueryWrapper<>();
            wrapper.eq("address_code", placeVO.getHouseCode());
            List<DoorplateAddressEntity> list = doorplateAddressService.list(wrapper);
            if (list.size() > 0) {
               placeVO.setDoorplateAddressEntity(list.get(0));
               placeVO.setNeiCode(list.get(0).getNeiCode());
            }
            // 查询场所对应的网格数据
            placeVO.setGrid(gridService.getPlaceGridDetailByHouseCode(placeVO.getHouseCode()));
            // 设置详情信息
            QueryWrapper<PlaceExtEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("is_deleted", 0).eq("place_id", placeVO.getId());
            placeVO.setPlaceExtEntity(placeExtService.getOne(queryWrapper));
         }
      } else {
         // 查询地址编码信息（社区派出所相关信息）
         if (!Strings.isBlank(place.getHouseCode())) {
            QueryWrapper<DoorplateAddressEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("address_code", place.getHouseCode());
            DoorplateAddressEntity addressEntity = doorplateAddressService.getOne(queryWrapper);
            if (null != addressEntity) {
               placeVO = new PlaceVO();
               placeVO.setDoorplateAddressEntity(addressEntity);
               placeVO.setLng(addressEntity.getX());
               placeVO.setLat(addressEntity.getY());
               placeVO.setLocation(addressEntity.getAddressName());
            }
         }
      }
@@ -554,6 +803,7 @@

   /**
    * 场所数据到导入
    *
    * @param data
    * @param isCovered
    */
@@ -562,10 +812,10 @@
      for (PlaceExcel placeExcel : data) {
         // 判断是否存在，不存在则插入，否则不操作
         QueryWrapper<PlaceEntity> wrapper = new QueryWrapper<>();
         wrapper.eq("is_deleted",0)
            .eq("house_code",placeExcel.getHouseCode());
         wrapper.eq("is_deleted", 0)
            .eq("house_code", placeExcel.getHouseCode());
         PlaceEntity one = getOne(wrapper);
         if (null == one){
         if (null == one) {
            Long userId = updateUser(placeExcel);
            // 插入场所
            PlaceEntity placeEntity = new PlaceEntity();
@@ -585,6 +835,7 @@

   /**
    * 更新用户信息
    *
    * @param placeExcel
    * @return
    */
@@ -604,6 +855,7 @@

   /**
    * 更新用户信息
    *
    * @param placeExcel
    * @return
    */
@@ -623,6 +875,7 @@

   /**
    * 场所(商超)导入
    *
    * @param data
    * @param isCovered
    */
@@ -632,7 +885,7 @@
      for (PlaceAndRelExcel placeExcel : data) {
         // 判断是否存在，不存在则插入，否则不操作
         PlaceEntity one = baseMapper.getPlaceAndRelInfo(placeExcel);
         if (null == one){
         if (null == one) {
            Long userId = updateUser(placeExcel);
            // 插入场所
            PlaceEntity placeEntity = new PlaceEntity();
@@ -653,7 +906,7 @@
            //一个一个插入，防止同一个表中有相同的数据
            save(placeEntity);
            // 插入标签关系表
            savPlaceLabelBind(placeExcel,placeEntity);
            savPlaceLabelBind(placeExcel, placeEntity);
            // 插入关联数据表
            PlaceRelEntity placeRelEntity = new PlaceRelEntity();
            placeRelEntity.setPlaceId(placeEntity.getId());
@@ -669,7 +922,7 @@
            placeRelEntity.setUpdateUser(AuthUtil.getUserId());
            // 新增
            placeRelService.save(placeRelEntity);
         }else {
         } else {
            // 只更新商铺信息
            Long userId = updateUser(placeExcel);
            // 插入场所
@@ -690,10 +943,11 @@

   /**
    * 插入标签关系表
    *
    * @param placeExcel
    */
   public void savPlaceLabelBind(PlaceAndRelExcel placeExcel,PlaceEntity placeEntity) {
      if (!Strings.isBlank(placeExcel.getLabelCode())){
   public void savPlaceLabelBind(PlaceAndRelExcel placeExcel, PlaceEntity placeEntity) {
      if (!Strings.isBlank(placeExcel.getLabelCode())) {
         PlaceVO placeVO = new PlaceVO();
         placeVO.setId(placeEntity.getId());
         placeVO.setLabel(placeExcel.getLabelCode());
@@ -714,7 +968,7 @@
      for (PlaceEntity placeEntity : list) {
         // 查询对应的用户信息
         User user = userService.getById(placeEntity.getPrincipalUserId());
         if (null!=user) {
         if (null != user) {
            // 设置场所负责人，手机号
            if (null != user.getRealName() && !user.getRealName().equals("")) {
               placeEntity.setPrincipal(user.getRealName());
@@ -731,6 +985,7 @@

   /**
    * 自定义修改
    *
    * @param placeVO
    * @return
    */
@@ -758,8 +1013,8 @@
         // 处理单个
         String labelCode = placePoiLabel.getPoiCode().toString();
         // 切割成三个，分别是大类，中类，小类
         String bigString = labelCode.substring(0,2);
         String midString = labelCode.substring(0,4);
         String bigString = labelCode.substring(0, 2);
         String midString = labelCode.substring(0, 4);
         // 大类
         PlacePoiLabel big = new PlacePoiLabel();
         big.setPlaceId(placePoiLabel.getPlaceId());
@@ -767,9 +1022,9 @@
         big.setType(1);
         // 保存前先判断
         QueryWrapper<PlacePoiLabel> queryWrapper = new QueryWrapper<>();
         queryWrapper.eq("place_id",placePoiLabel.getPlaceId()).eq("poi_code",Integer.parseInt(bigString));
         queryWrapper.eq("place_id", placePoiLabel.getPlaceId()).eq("poi_code", Integer.parseInt(bigString));
         PlacePoiLabel one = placePoiLabelService.getOne(queryWrapper);
         if (null==one) {
         if (null == one) {
            placePoiLabelService.save(big);
         }
         // 中类
@@ -779,9 +1034,9 @@
         mid.setType(2);
         // 保存前先判断
         QueryWrapper<PlacePoiLabel> wrapper = new QueryWrapper<>();
         wrapper.eq("place_id",placePoiLabel.getPlaceId()).eq("poi_code",Integer.parseInt(midString));
         wrapper.eq("place_id", placePoiLabel.getPlaceId()).eq("poi_code", Integer.parseInt(midString));
         PlacePoiLabel two = placePoiLabelService.getOne(wrapper);
         if (null==two) {
         if (null == two) {
            placePoiLabelService.save(mid);
         }
      }
@@ -790,6 +1045,7 @@

   /**
    * 历史场所详情数据处理
    *
    * @param place
    * @return
    */
@@ -800,15 +1056,15 @@
      // 遍历更新
      for (PlaceEntity placeEntity : list) {
         QueryWrapper<PlaceExtEntity> queryWrapper = new QueryWrapper<>();
         queryWrapper.eq("place_id",placeEntity.getId()).eq("is_deleted",0);
         queryWrapper.eq("place_id", placeEntity.getId()).eq("is_deleted", 0);
         PlaceExtEntity one = placeExtService.getOne(queryWrapper);
         if (null==one){
         if (null == one) {
            // 新增
            PlaceExtEntity placeExtEntity = new PlaceExtEntity();
            if (null!=placeEntity.getPrincipalUserId()){
            if (null != placeEntity.getPrincipalUserId()) {
               // 待审核
               placeExtEntity.setConfirmFlag(1);
            }else {
            } else {
               // 待完善
               placeExtEntity.setConfirmFlag(4);
            }
@@ -822,6 +1078,7 @@

   /**
    * 商超数据处理
    *
    * @return
    */
   @Override
@@ -830,7 +1087,7 @@
      List<PlaceEntity> placeEntityList = baseMapper.placeAndRelHandle();
      // 处理
      for (PlaceEntity placeEntity : placeEntityList) {
         if (Strings.isBlank(placeEntity.getHouseCode())){
         if (Strings.isBlank(placeEntity.getHouseCode())) {
            // 并生成36位的houseCode
            placeEntity.setHouseCode(IdUtils.getIdBy36());
            // 商超数据
@@ -841,4 +1098,246 @@
      }
      return null;
   }

   /**
    * 根据编号集合查询对应的场所（按颜色区分近多少天没有发过任务的场所）
    *
    * @param stringList
    * @param tableName
    * @return
    */
   @Override
   public List<PlaceVO> getPlaceListByParam(List<String> stringList, String tableName) {
      return baseMapper.getPlaceListByParam(stringList, tableName);
   }

   /**
    * 删除
    *
    * @param longs
    * @return
    */
   @Override
   @Transactional(rollbackFor = Exception.class)
   public boolean removePlace(List<Long> longs) {
      // 删除场所负责人对应的用户
      removeUser(longs);
      // 删除
      boolean removeByIds = removeByIds(longs);
      // 删除对应的详情
      removePlaceExt(longs);
      // 删除对应的标签绑定信息
      removePlaceLabel(longs);
      // 返回
      return removeByIds;
   }

   /**
    * 删除场所负责人对应的用户
    *
    * @param longs
    */
   public void removeUser(List<Long> longs) {
      // 遍历
      for (Long id : longs) {
         PlaceEntity placeEntity = getById(id);
         if (null != placeEntity.getPrincipalUserId()) {
            User user = userService.getById(placeEntity.getPrincipalUserId());
            // 查询场所判断是否还绑定有其他的场所
            QueryWrapper<PlaceEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("is_deleted", 0).eq("principal_user_id", user.getId());
            List<PlaceEntity> placeEntityList = list(queryWrapper);
            // 如果没有（1个 当前的还没有删除）
            if (placeEntityList.size() == 1) {
               // 判断角色
               if (!Strings.isBlank(user.getRoleId())) {
                  // 判断是否还绑定其他的房屋，如果有，则不操作用户
                  QueryWrapper<HouseholdEntity> wrapper = new QueryWrapper<>();
                  wrapper.eq("is_deleted", 0).eq("associated_user_id", user.getId());
                  List<HouseholdEntity> householdEntityList = householdService.list(wrapper);
                  // 即没有房屋和场所了就删除对应的居民角色
                  if (householdEntityList.size() == 0) {
                     List<String> stringList = Arrays.asList(user.getRoleId().split(","));
                     // 查看当前用户的角色是否只有一个
                     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 longs
    */
   public void removePlaceExt(List<Long> longs) {
      for (Long id : longs) {
         QueryWrapper<PlaceExtEntity> wrapper = new QueryWrapper<>();
         wrapper.eq("place_id", id);
         placeExtService.remove(wrapper);
      }
   }

   /**
    * 删除对应的标签绑定信息
    *
    * @param longs
    */
   public void removePlaceLabel(List<Long> longs) {
      for (Long id : longs) {
         QueryWrapper<PlacePoiLabel> wrapper = new QueryWrapper<>();
         wrapper.eq("place_id", id);
         placePoiLabelService.remove(wrapper);
      }
   }

   /**
    * 九小场所档案
    *
    * @param page
    * @param place
    * @return
    */
   @Override
   public IPage<PlaceVO> selectNinePlacePage(IPage<PlaceVO> page, PlaceVO place) {
      String roleName = SpringUtils.getRequestParam("roleName");
      String communityCode = SpringUtils.getRequestParam("communityCode");
      if (!Strings.isBlank(communityCode)){
         // 校验社区编号是否合规
         if(null!=SpringUtils.getBean(IRegionService.class).getById(communityCode)) {
            place.setCommunityCode(communityCode);
         }
      }
      List<String> regionChildCodesList = SysCache.getRegionChildCodesByDeptId(AuthUtil.getDeptId());
      Integer isAdministrator = AuthUtil.isAdministrator()==true?1:2;
      // 网格编号集合
      List<String> gridCodeList = new ArrayList<>();
      // 民警角色
      if (!Strings.isBlank(roleName)){
         place.setRoleName(roleName);
         if(roleName.equals("mj")) {
            regionChildCodesList = SpringUtil.getBean(IPoliceAffairsGridService.class).getCommunityCodeListByUserId(AuthUtil.getUserId());
         }
         if (roleName.equals("wgy")) {
            gridCodeList = SpringUtil.getBean(IGridService.class).getGridListByUserId(AuthUtil.getUserId());
         }
      }
      List<String> strings = new ArrayList<>();
      if (null!=place.getNineType()){
         QueryWrapper<DictBiz> queryWrapper = new QueryWrapper<>();
         queryWrapper.eq("is_deleted",0).eq("dict_key",place.getNineType()).eq("code","nineType");
         // 先查询当前
         DictBiz one = dictBizService.getOne(queryWrapper);
         // 查询本身和子集的key
         List<DictBiz> list = dictBizService.getList("nineType", one.getId());
         if (list.size()==0){
            strings.add(place.getNineType().toString());
         }else {
            strings = list.stream().map(DictBiz::getDictKey).collect(Collectors.toList());
         }
      }
      List<PlaceVO> placeVOS = baseMapper.selectNinePlacePage(page, place, gridCodeList, regionChildCodesList, isAdministrator,strings);
      // 返回
      return page.setRecords(placeVOS);
   }

   @Override
   public List<NinePlaceExcel> export(PlaceVO place) {
      String roleName = SpringUtils.getRequestParam("roleName");
      String communityCode = SpringUtils.getRequestParam("communityCode");
      if (!Strings.isBlank(communityCode)){
         // 校验社区编号是否合规
         if(null!=SpringUtils.getBean(IRegionService.class).getById(communityCode)) {
            place.setCommunityCode(communityCode);
         }
      }
      List<String> regionChildCodesList = SysCache.getRegionChildCodesByDeptId(AuthUtil.getDeptId());
      Integer isAdministrator = AuthUtil.isAdministrator()==true?1:2;
      // 网格编号集合
      List<String> gridCodeList = new ArrayList<>();
      // 民警角色
      if (!Strings.isBlank(roleName)){
         place.setRoleName(roleName);
         if(roleName.equals("mj")) {
            regionChildCodesList = SpringUtil.getBean(IPoliceAffairsGridService.class).getCommunityCodeListByUserId(AuthUtil.getUserId());
         }
         if (roleName.equals("wgy")) {
            gridCodeList = SpringUtil.getBean(IGridService.class).getGridListByUserId(AuthUtil.getUserId());
         }
      }
      List<String> strings = new ArrayList<>();
      if (null!=place.getNineType()){
         QueryWrapper<DictBiz> queryWrapper = new QueryWrapper<>();
         queryWrapper.eq("is_deleted",0).eq("dict_key",place.getNineType()).eq("code","nineType");
         // 先查询当前
         DictBiz one = dictBizService.getOne(queryWrapper);
         // 查询本身和子集的key
         List<DictBiz> list = dictBizService.getList("nineType", one.getId());
         if (list.size()==0){
            strings.add(place.getNineType().toString());
         }else {
            strings = list.stream().map(DictBiz::getDictKey).collect(Collectors.toList());
         }
      }
      List<NinePlaceExcel> aa = baseMapper.export(place, gridCodeList, regionChildCodesList, isAdministrator,strings);
      IDictBizService bean = SpringUtils.getBean(IDictBizService.class);
      List<DictBiz> nineType = bean.list(Wrappers.<DictBiz>lambdaQuery().eq(DictBiz::getCode, "nineType").eq(DictBiz::getIsDeleted, 0));
      for (NinePlaceExcel ninePlaceExcel : aa) {
         for (DictBiz dictBiz : nineType) {
            if (StringUtils.isNotBlank(ninePlaceExcel.getNineType()) && ninePlaceExcel.getNineType().equals(dictBiz.getDictKey())) {
               if (ninePlaceExcel.getNineType().contains("10,11,12")) {
                  ninePlaceExcel.setNineType("小学校（幼儿园、校外培训机构）- " + dictBiz.getDictValue());
               } else if (ninePlaceExcel.getNineType().contains("13,14,15")) {
                  ninePlaceExcel.setNineType("小医院（诊所、养老院）- " + dictBiz.getDictValue());
               } else {
                  ninePlaceExcel.setNineType(dictBiz.getDictValue());
               }
            }
         }
      }
      return aa;
   }

   /**
    * 场所警务网格处理
    */
   @Override
   public Object placeJwGridCodeHandle() {
      // 查询 警务网格为空的数据
      List<PlaceEntity> list = baseMapper.getPlaceNotJwGridCode();
      // 遍历
      for (PlaceEntity placeEntity : list) {
         if (!Strings.isBlank(placeEntity.getLng())) {
            // 空间分析
            //点坐标解析
            String point = "'POINT(" + placeEntity.getLng() + " " + placeEntity.getLat() + ")'";
            //String point = "'POINT(" + villageInfoExcel.getLatitude() + " " + villageInfoExcel.getLongitude() +")'";
            List<PoliceAffairsGridEntity> policeAffairsGridEntities
               = SpringUtil.getBean(IPoliceAffairsGridService.class).spatialAnalysis(point);
            if (policeAffairsGridEntities.size() > 0) {
               PoliceAffairsGridEntity policeAffairsGridEntity = policeAffairsGridEntities.get(0);
               placeEntity.setJwGridCode(policeAffairsGridEntity.getJwGridCode());
               // 更新
               updateById(placeEntity);
            }
         }
      }
      return null;
   }
}