代码优化

linwe

2024-07-22 748fc948fff5b0034dbea1110fabf11d22573e14

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

@@ -18,18 +18,21 @@

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
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.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.BeanUtil;
import org.springblade.core.tool.utils.ObjectUtil;
import org.springblade.core.tool.utils.SpringUtil;
import org.springblade.modules.category.entity.CategoryEntity;
import org.springblade.modules.category.service.ICategoryService;
import org.springblade.modules.doorplateAddress.entity.DoorplateAddressEntity;
import org.springblade.modules.doorplateAddress.service.IDoorplateAddressService;
import org.springblade.modules.grid.entity.GridEntity;
@@ -37,35 +40,27 @@
import org.springblade.modules.grid.mapper.GridMapper;
import org.springblade.modules.grid.service.IGridRangeService;
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.ExportPlaceExcel;
import org.springblade.modules.place.excel.ImportPlaceExcel;
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.mapper.PlaceMapper;
import org.springblade.modules.place.service.*;
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.Region;
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;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
@@ -92,6 +87,9 @@
   private IPlaceRelService placeRelService;

   @Autowired
   private IPlaceDoorService placeDoorService;

   @Autowired
   private IDoorplateAddressService doorplateAddressService;

   @Autowired
@@ -99,9 +97,6 @@

   @Autowired
   private IGridRangeService gridRangeService;

   @Autowired
   private IGridmanService gridmanService;

   @Autowired
   private GridMapper gridMapper;
@@ -122,7 +117,10 @@
   @Override
   public IPage<PlaceVO> selectPlacePage(IPage<PlaceVO> page, PlaceVO place) {
      // 公共参数设置
      CommonParamSet commonParamSet = new CommonParamSet().invoke(PlaceVO.class,place);
      CommonParamSet commonParamSet = new CommonParamSet().invoke(PlaceVO.class, place);
      if (StringUtils.isNotBlank(place.getPoiCodes())) {
         place.setPoiCodeList(Arrays.asList(place.getPoiCodes().split(",")));
      }
      List<PlaceVO> placeVOS = baseMapper.selectPlacePage(page,
         place,
         commonParamSet.getGridCodeList(),
@@ -167,6 +165,8 @@
         if (null != one) {
            placeVO.setId(one.getId());
         } else {
            // 扫码来的默认绑定本身
            placeVO.setHouseCodeBinds(placeVO.getHouseCode());
            // 新增，地址表中没有或者地址表中有场所表中没有的（是房屋的），扫码进来的
            save(placeVO);
         }
@@ -174,6 +174,8 @@
         bindUserHandle(placeVO);
         // 设置完善状态
         setPlaceStatus(placeVO);
         // 房屋编号绑定处理
         houseCodeBindHandle(placeVO);
         // 更新场所信息
         flag = updateById(placeVO);
      } else {
@@ -193,37 +195,99 @@
         // 新增场所信息
         flag = save(placeVO);
      }
      // 获取请求头中的角色别名
      String roleName = SpringUtils.getRequestParam("roleName");
      placeVO.setRoleName(roleName);
      // 保存场所详情及任务信息
      savePlaceExtAndTaskInfo(placeVO);
      // 场所标签信息绑定(更新，调整）
      placeLabelBind(placeVO);
      // 网格绑定
      gridBind(placeVO);
      // 网格编号绑定场所-新
      gridCodeBind(placeVO);
      // 警务网格绑定
      jwGridCodeBind(placeVO);
      // 房屋编号绑定
//      houseCodeBind(placeVO);
      // 保存从业人员
      savePlacePractitioner(placeVO);
      // 判断是否校园
      if (placeVO.getLabel().startsWith("16010")) {
         // 校园的新增一个主体用户和一个通用用户
         addSchoolUser(placeVO);
      }
      // 返回结果
      return flag;
   }


   /**
    * 保存从业人员
    *
    * @param placeVO
    */
   private void savePlacePractitioner(PlaceVO placeVO) {
      if (placeVO.getPlacePractitioner() != null) {
         IPlacePractitionerService practitionerService = SpringUtil.getBean(IPlacePractitionerService.class);
         // 查询对应已存在的租户
         QueryWrapper<PlacePractitionerEntity> wrapper = new QueryWrapper<>();
         wrapper.eq("place_id", placeVO.getId()).eq("is_deleted", 0);
         List<PlacePractitionerEntity> oldList = practitionerService.list(wrapper);
         // 取出从业人员信息
         List<PlacePractitionerEntity> placePractitionerList = placeVO.getPlacePractitioner();
         for (PlacePractitionerEntity placePractitionerEntity : placePractitionerList) {
            placePractitionerEntity.setPlaceId(placeVO.getId());
         }
         // 申明新增，修改，删除集合
         List<PlacePractitionerEntity> newList = new ArrayList<>();
         List<PlacePractitionerEntity> addList = new ArrayList<>();
         List<PlacePractitionerEntity> updateList = new ArrayList<>();
         List<PlacePractitionerEntity> removeList = new ArrayList<>();
         // 遍历设置数据
         for (PlacePractitionerEntity placePractitionerEntity : placePractitionerList) {
            if (null == placePractitionerEntity.getId()) {
               // 新增
               addList.add(placePractitionerEntity);
            } else {
               newList.add(placePractitionerEntity);
            }
         }
         // 遍历去差集，判断是新增还是删除还是更新
         // 取旧数据和新提交数据差集--删除
         removeList = oldList.stream().filter(vo -> !newList.stream().map(e ->
            e.getId()).collect(Collectors.toList()).contains(vo.getId())).collect(Collectors.toList());
         // 取旧数据和新提交数据交集--更新
         updateList = newList.stream().filter(vo -> oldList.stream().map(e ->
            e.getId()).collect(Collectors.toList()).contains(vo.getId())).collect(Collectors.toList());

         // 批量新增
         if (addList.size() > 0) {
            practitionerService.saveBatch(addList);
         }
         // 批量修改
         if (updateList.size() > 0) {
            practitionerService.updateBatchById(updateList);
         }
         // 批量删除
         if (removeList.size() > 0) {
            practitionerService.removeBatchByIds(removeList);
         }
      }
   }

   /**
    * 设置场所的source 来源
    *
    * @param placeVO
    */
   public void setSource(PlaceVO placeVO) {
      if (null!=placeVO.getSource()){
      if (null != placeVO.getSource()) {
         placeVO.setSource(placeVO.getSource());
      }else {
      } else {
         // 查询该houseCode 是否存在地址总表，如果是，赋值 1，否则2
         QueryWrapper<DoorplateAddressEntity> wrapper = new QueryWrapper<>();
         wrapper.eq("address_code",placeVO.getHouseCode());
         wrapper.eq("address_code", placeVO.getHouseCode());
         DoorplateAddressEntity one = doorplateAddressService.getOne(wrapper);
         if (null!=one){
         if (null != one) {
            placeVO.setSource(1);
         }else {
         } else {
            placeVO.setSource(2);
         }
      }
@@ -234,6 +298,7 @@
    *
    * @param placeVO
    */
   @Override
   public void jwGridCodeBind(PlaceVO placeVO) {
      if (!Strings.isBlank(placeVO.getLng())) {
         String point = "'POINT(" + placeVO.getLng() + " " + placeVO.getLat() + ")'";
@@ -282,18 +347,69 @@
   }

   /**
    * 房屋绑定
    * 房屋绑定处理
    * @param placeEntity
    */
   public void houseCodeBindHandle(PlaceEntity placeEntity) {
      PlaceVO placeVO = new PlaceVO();
      placeVO.setId(placeEntity.getId());
      placeVO.setHouseCodeBinds(placeEntity.getHouseCodeBinds());
      // 绑定
      houseCodeBindHandle(placeVO);
   }

   /**
    * 房屋绑定处理
    *
    * @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) {
   public void houseCodeBindHandle(PlaceVO placeVO) {
      if (!Strings.isBlank(placeVO.getHouseCodeBinds())) {
         List<String> list = Arrays.asList(placeVO.getHouseCodeBinds().split(","));
         // 先删除原有的绑定
         QueryWrapper<PlaceDoorEntity> removeQw = new QueryWrapper<>();
         removeQw.eq("place_id", placeVO.getId());
         // 删除
         placeDoorService.remove(removeQw);
         // 遍历更新
         for (String houseCode : list) {
            // 查询是否已存在关联关系
            QueryWrapper<PlaceDoorEntity> wrapper = new QueryWrapper<>();
            wrapper.eq("house_code", houseCode);
            // 查询
            List<PlaceDoorEntity> placeDoorEntityList = placeDoorService.list(wrapper);
            if (placeDoorEntityList.size() > 0) {
               // 该houseCode 已被绑定
//            errorList.add(houseCode);
               for (PlaceDoorEntity placeDoorEntity : placeDoorEntityList) {
                  placeDoorEntity.setPlaceId(placeVO.getId());
                  // 更新
                  placeDoorService.updateById(placeDoorEntity);
               }
            } else {
               PlaceDoorEntity placeDoorEntity = new PlaceDoorEntity();
               placeDoorEntity.setHouseCode(houseCode);
               placeDoorEntity.setPlaceId(placeVO.getId());
               // 对应插入到关联关系表中
               placeDoorService.save(placeDoorEntity);
            }
         }
         // 处理原场所表houseCode 绑定数据-- 暂不处理原数据的删除
//      handlePlaceOne(list,placeVO);
      }
   }

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

      }
      if (longs.size() > 0) {
         // 删除对应的详情
         removePlaceExt(longs);
         // 删除对应的标签绑定信息
         removePlaceLabel(longs);
         // 删除对应的场所门牌绑定关系信息
         removePlaceDoor(longs);
      }
   }

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

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

   /**
@@ -396,10 +488,15 @@
    * @param placeVO
    */
   public void gridmanPositionHandle(PlaceVO placeVO) {
      if (placeVO.getRoleName().equals("网格员")) {
      if (!Strings.isBlank(placeVO.getRoleName()) && placeVO.getRoleName().equals("wgy")) {
         // 判断网格员，查询对应网格人对应的网格id
         Integer gridId = gridmanService.getGridIdByUserId(AuthUtil.getUserId());
         if (null != gridId) {
         GridEntity grid = gridService.getGridByUserId(AuthUtil.getUserId());
         if (null != grid) {
            // 场所编号绑定
            placeVO.setGridCode(grid.getGridCode());
            placeVO.setGridId(grid.getId());
            // 更新场所网格绑定信息
            updateById(placeVO);
            // 判断关联关系表是否存在
            QueryWrapper<GridRangeEntity> wrapper = new QueryWrapper<>();
            wrapper.eq("house_code", placeVO.getHouseCode());
@@ -408,12 +505,14 @@
               // 新增
               GridRangeEntity gridRangeEntity = new GridRangeEntity();
               gridRangeEntity.setHouseCode(placeVO.getHouseCode());
               gridRangeEntity.setGridId(gridId);
               gridRangeEntity.setGridId(grid.getId());
               gridRangeEntity.setGridCode(grid.getGridCode());
               // 插入
               gridRangeService.save(gridRangeEntity);
            } else {
               // 修改绑定
               one.setGridId(gridId);
               one.setGridId(grid.getId());
               one.setGridCode(grid.getGridCode());
               // 修改
               gridRangeService.updateById(one);
            }
@@ -433,6 +532,7 @@
         if (null != grid && !Strings.isBlank(grid.getGridCode())) {
            // 场所编号绑定
            placeVO.setGridCode(grid.getGridCode());
            placeVO.setGridId(grid.getId());
            // 更新场所信息
            updateById(placeVO);
         }
@@ -440,19 +540,25 @@
   }

   /**
    * 民警角色位置绑定
    * 其他角色时位置绑定
    *
    * @param placeVO
    */
   private void policePositionHandle(PlaceVO placeVO) {
   @Override
   public void policePositionHandle(PlaceVO placeVO) {
      // 是民警且位置信息存在
      if (placeVO.getRoleName().equals("民警") && !Strings.isBlank(placeVO.getLng())) {
      if (!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);
            // 场所编号绑定
            placeVO.setGridCode(gridEntity.getGridCode());
            placeVO.setGridId(gridEntity.getId());
            // 更新场所信息
            updateById(placeVO);
            // 判断关联关系表是否存在
            QueryWrapper<GridRangeEntity> wrapper = new QueryWrapper<>();
            wrapper.eq("house_code", placeVO.getHouseCode());
@@ -462,11 +568,13 @@
               GridRangeEntity gridRangeEntity = new GridRangeEntity();
               gridRangeEntity.setHouseCode(placeVO.getHouseCode());
               gridRangeEntity.setGridId(gridEntity.getId());
               gridRangeEntity.setGridCode(gridEntity.getGridCode());
               // 插入
               gridRangeService.save(gridRangeEntity);
            } else {
               // 修改绑定
               one.setGridId(gridEntity.getId());
               one.setGridCode(gridEntity.getGridCode());
               // 修改
               gridRangeService.updateById(one);
            }
@@ -491,6 +599,7 @@
            if (null != gridEntity && !Strings.isBlank(gridEntity.getGridCode())) {
               // 场所编号绑定
               placeVO.setGridCode(gridEntity.getGridCode());
               placeVO.setGridId(gridEntity.getId());
               // 更新场所信息
               updateById(placeVO);
            }
@@ -612,6 +721,48 @@
   }

   /**
    * 新增校方主体账号和通用账号
    *
    * @param placeVO
    * @return
    */
   @Transactional(rollbackFor = Exception.class)
   public void addSchoolUser(PlaceVO placeVO) {
      User newUser = new User();
      // 查询账号是否存在，存在则不创建
      long count = userService.count(Wrappers.<User>lambdaQuery()
         .eq(User::getAccount, placeVO.getPlaceName() + "主体"));
      // 如果用户不存在，则新增一个用户
      if (StringUtils.isNotBlank(placeVO.getPlaceName()) && count <= 0) {
         newUser.setAccount(placeVO.getPlaceName() + "主体");
         newUser.setName(placeVO.getPlaceName() + "-主体");
         newUser.setRealName(placeVO.getPlaceName() + "-主体");
         // 社区群众部门
         newUser.setDeptId("1727979636479037441");
         // 校园主体，
         newUser.setRoleId("1780786647371706370");
         // 默认密码为 123456
         newUser.setPassword("123456");
         // 设置机构
         // 用户新增
         newUser.setId(null);
         boolean submit = userService.submit(newUser);
         placeVO.setPrincipalAccount(newUser.getId());
         // 校园通用
         newUser.setId(null);
         newUser.setPassword("123456");
         newUser.setRoleId("1780786746076262402");
         newUser.setAccount(placeVO.getPlaceName() + "通用");
         newUser.setName(placeVO.getPlaceName() + "-通用");
         newUser.setRealName(placeVO.getPlaceName() + "-通用");
         boolean submit2 = userService.submit(newUser);
         placeVO.setUniversalAccount(newUser.getId());
         // 更新场所信息
         updateById(placeVO);
      }
   }

   /**
    * 场所负责人和用户绑定
    *
    * @param placeVO
@@ -623,18 +774,9 @@
         placeVO.setPrincipal(placeVO.getPrincipal());
         placeVO.setPrincipalPhone(placeVO.getPrincipalPhone());
         //根据手机号查询库里的数据
         User userParams = new User();
         userParams.setPhone(placeVO.getPrincipalPhone());
         userParams.setIsDeleted(0);
         User user = userService.getOne(Condition.getQueryWrapper(userParams));
         if (null == user) {
            User userParams1 = new User();
            userParams1.setAccount(placeVO.getPrincipalPhone());
            userParams1.setIsDeleted(0);
            user = userService.getOne(Condition.getQueryWrapper(userParams1));
         }

         if (null != user) {
         List<User> list = userService.getUserListByPhoneOrAccount(placeVO.getPrincipalPhone());
         if (list.size() > 0) {
            User user = list.get(0);
            //如果用户存在，则该用户id绑定场所
            placeVO.setPrincipalUserId(user.getId());
            newUser = user;
@@ -676,14 +818,48 @@
   @Transactional(rollbackFor = Exception.class)
   public void savePlaceExtAndTaskInfo(PlaceVO placeVO) {
      PlaceExtEntity placeExtEntity = new PlaceExtEntity();
      placeExtEntity.setPlaceId(placeVO.getId());
      // 判断是否已存在，已存在则不新增
      QueryWrapper<PlaceExtEntity> wrapper = new QueryWrapper<>();
      wrapper.eq("is_deleted", 0)
         .eq("place_id", placeVO.getId());
      PlaceExtEntity extServiceOne = placeExtService.getOne(wrapper);
      if (null == extServiceOne) {
         // 判断是否有传
         if (placeVO.getPlaceExtEntity() != null) {
            placeExtEntity = placeVO.getPlaceExtEntity();
         }
         placeExtEntity.setPlaceId(placeVO.getId());
         // 默认给待完善状态
         placeExtEntity.setConfirmFlag(4);
         placeExtEntity.setCreateTime(new Date());
         placeExtEntity.setUpdateTime(new Date());
         placeExtEntity.setCreateUser(AuthUtil.getUserId());
         placeExtEntity.setUpdateUser(AuthUtil.getUserId());
         // 新增场所详情
         placeExtService.save(placeExtEntity);
      } else {
         if (placeVO.getPlaceExtEntity() != null) {
            placeExtService.updateById(placeVO.getPlaceExtEntity());
         }
      }
   }

   /**
    * 保存场所详情信息
    *
    * @param placeEntity
    */
   @Transactional(rollbackFor = Exception.class)
   public void savePlaceExtInfo(PlaceEntity placeEntity) {
      PlaceExtEntity placeExtEntity = new PlaceExtEntity();
      placeExtEntity.setPlaceId(placeEntity.getId());
      // 判断是否已存在，已存在则不新增
      QueryWrapper<PlaceExtEntity> wrapper = new QueryWrapper<>();
      wrapper.eq("is_deleted", 0)
         .eq("place_id", placeEntity.getId());
      PlaceExtEntity one = placeExtService.getOne(wrapper);
      if (null == one) {
         placeExtEntity.setPlaceId(placeVO.getId());
         placeExtEntity.setPlaceId(placeEntity.getId());
         // 默认给待完善状态
         placeExtEntity.setConfirmFlag(4);
         placeExtEntity.setCreateTime(new Date());
@@ -783,6 +959,13 @@
            QueryWrapper<PlaceExtEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("is_deleted", 0).eq("place_id", placeVO.getId());
            placeVO.setPlaceExtEntity(placeExtService.getOne(queryWrapper));
            // 查询从业人员
            IPlacePractitionerService placePractitionerService = SpringUtils.getBean(IPlacePractitionerService.class);
            List<PlacePractitionerEntity> entityList = placePractitionerService.list(Wrappers.<PlacePractitionerEntity>lambdaQuery()
               .eq(PlacePractitionerEntity::getPlaceId, placeVO.getId()));
            placeVO.setPlacePractitioner(entityList);
            // 查询绑定的房屋
            placeVO.setHouseBindList(baseMapper.getHouseBindMap(placeVO.getHouseCodeBinds()));
         }
      } else {
         // 查询地址编码信息（社区派出所相关信息）
@@ -811,28 +994,207 @@
    * @param isCovered
    */
   @Override
   public void importPlace(List<PlaceExcel> data, Boolean isCovered) {
      for (PlaceExcel placeExcel : data) {
   public String importPlace(List<ImportPlaceExcel> data, Boolean isCovered) {
      int totalNum = data.size();
      int importNum = 0;
      int updateNum = 0;
      int errorNum = 0;
      for (ImportPlaceExcel placeExcel : data) {
         if (Strings.isBlank(placeExcel.getPlaceName()) || Strings.isBlank(placeExcel.getHouseCode())){
            errorNum++;
            continue;
         }
         PlaceEntity placeEntity = Objects.requireNonNull(BeanUtil.copy(placeExcel, PlaceEntity.class));
         Long userId = updateUser(placeExcel);
         // 九小场所类型处理
         if (!Strings.isBlank(placeExcel.getNineType())) {
            placeEntity.setIsNine(1);
            placeEntity.setNineType(Integer.parseInt(placeExcel.getNineType()));
         }
         // 阵地类型处理
         if (!Strings.isBlank(placeExcel.getFrontType())) {
            placeEntity.setIsFront(1);
            placeEntity.setFrontType(Integer.parseInt(placeExcel.getFrontType()));
         }
         // 无诈类别
         if (!Strings.isBlank(placeExcel.getNoExplosionCategory())){
            placeEntity.setNoExplosionCategory(Integer.parseInt(placeExcel.getNoExplosionCategory()));
         }
         // 三级单位
         if (!Strings.isBlank(placeExcel.getThreeFireProtection())){
            if (placeExcel.getThreeFireProtection().equals("是")){
               placeEntity.setThreeFireProtection(1);
            }
            if (placeExcel.getThreeFireProtection().equals("否")){
               placeEntity.setThreeFireProtection(2);
            }
         }
         String[] split = placeExcel.getHouseCode().split(",");
         placeEntity.setHouseCode(split[0]);
         placeEntity.setHouseCodeBinds(placeExcel.getHouseCode());
         placeEntity.setPrincipalUserId(userId);
         // houseCode 关联处理 来源 1：地址总表  2：国控采集 3：商超
         houseCodeHandle(placeExcel, placeEntity);
         // 网格绑定处理
         importGridHandle(placeExcel, placeEntity);
         // 判断是否存在，不存在则插入，否则不操作
         QueryWrapper<PlaceEntity> wrapper = new QueryWrapper<>();
         wrapper.eq("is_deleted", 0)
            .eq("house_code", placeExcel.getHouseCode());
         PlaceEntity one = getOne(wrapper);
         if (null == one) {
            Long userId = updateUser(placeExcel);
            // 插入场所
            PlaceEntity placeEntity = new PlaceEntity();
            placeEntity.setHouseCode(placeExcel.getHouseCode());
            placeEntity.setPrincipalUserId(userId);
            placeEntity.setPrincipal(placeExcel.getName());
            placeEntity.setPrincipalPhone(placeExcel.getPhoneNumber());
            placeEntity.setCreateTime(new Date());
            placeEntity.setCreateUser(AuthUtil.getUserId());
            placeEntity.setUpdateTime(new Date());
            placeEntity.setUpdateUser(AuthUtil.getUserId());
            //一个一个插入，防止同一个表中有相同的数据
            // 新增
            save(placeEntity);
            importNum++;
            // 保存详情
            savePlaceExt(placeEntity,placeExcel);
            // 场所标签信息处理
            if (!Strings.isBlank(placeExcel.getLabelCode())) {
               PlaceVO placeVO = new PlaceVO();
               placeVO.setId(placeEntity.getId());
               placeVO.setLabel(placeExcel.getLabelCode());
               // 处理
               placeLabelBind(placeVO);
            }
            // 房屋编号绑定处理
            houseCodeBindHandle(placeEntity);
         } else {
            updateNum++;
            // 是否覆盖更新
            if (isCovered) {
               // 更新场所
               placeEntity.setId(one.getId());
               // 更新
               updateById(placeEntity);
               importNum++;
               // 场所标签信息处理
               if (!Strings.isBlank(placeExcel.getLabelCode())) {
                  PlaceVO placeVO = new PlaceVO();
                  placeVO.setId(one.getId());
                  placeVO.setLabel(placeExcel.getLabelCode());
                  // 处理
                  placeLabelBind(placeVO);
               }
            }
         }
      }
      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 placeEntity
    * @param placeExcel
    */
   @Transactional(rollbackFor = Exception.class)
   public void savePlaceExt(PlaceEntity placeEntity, ImportPlaceExcel placeExcel) {
      PlaceVO placeVO = new PlaceVO();
      placeVO.setId(placeEntity.getId());
      PlaceExtEntity placeExtEntity = new PlaceExtEntity();
      placeExtEntity.setLegalPerson(placeExcel.getLegalPerson());
      placeExtEntity.setLegalTel(placeExcel.getLegalTel());
      placeExtEntity.setLegalIdCard(placeExcel.getLegalIdCard());
      // 设置详情
      placeVO.setPlaceExtEntity(placeExtEntity);
      // 保存详情
      savePlaceExtAndTaskInfo(placeVO);
   }

   /**
    *
    * @param placeExcel
    * @param placeEntity
    */
   public void houseCodeHandle(ImportPlaceExcel placeExcel, PlaceEntity placeEntity) {
      if (!Strings.isBlank(placeExcel.getHouseCode())) {
         placeEntity.setSource(1);
         // 设置经纬度及地址
         DoorplateAddressEntity doorplateAddressEntity
            = doorplateAddressService.getOne(Wrappers.<DoorplateAddressEntity>lambdaQuery()
            .eq(DoorplateAddressEntity::getAddressCode, placeExcel.getHouseCode()).last("limit 1"));
         if (null!=doorplateAddressEntity){
            placeEntity.setLng(doorplateAddressEntity.getX());
            placeEntity.setLat(doorplateAddressEntity.getY());
            placeEntity.setLocation(doorplateAddressEntity.getAddressName());
            placeEntity.setBuildingCode(doorplateAddressEntity.getBuildingCode());
            placeEntity.setAoiCode(doorplateAddressEntity.getAoiCode());
         }
      } else {
         placeEntity.setSource(2);
         // 并生成36位的houseCode
         placeEntity.setHouseCode(IdUtils.getIdBy36());
      }
   }

   /**
    * 导入是网格数据绑定处理
    *
    * @param placeExcel
    * @param placeEntity
    */
   private void importGridHandle(ImportPlaceExcel placeExcel, PlaceEntity placeEntity) {
      if (Strings.isNotBlank(placeExcel.getCommunityName()) && Strings.isNotBlank(placeExcel.getGridName())) {
         // 查询对应的网格信息
         GridEntity gridEntity = gridService.getGridInfoByParam(placeExcel.getCommunityName(), placeExcel.getGridName());
         if (null != gridEntity) {
            // 设置场所范围
            placeEntity.setGridId(gridEntity.getId());
            placeEntity.setGridCode(gridEntity.getGridCode());
            // 更新网格范围绑定
            GridRangeEntity gridRangeEntity = new GridRangeEntity();
            gridRangeEntity.setGridId(gridEntity.getId());
            gridRangeEntity.setGridCode(gridEntity.getGridCode());
            gridRangeEntity.setHouseCode(placeEntity.getHouseCode());
            UpdateWrapper<GridRangeEntity> updateWrapper = new UpdateWrapper<>();
            updateWrapper.eq("house_code", placeEntity.getHouseCode());
            gridRangeService.update(gridRangeEntity, updateWrapper);
         }
      } else if (StringUtils.isNotBlank(placeEntity.getLat()) && StringUtils.isNotBlank(placeEntity.getLng())) {
         // 点落面
         setGridInfo(placeEntity);
      }
   }

   /**
    * 设置警格网格信息
    *
    * @param placeEntity
    */
   public void setGridInfo(PlaceEntity placeEntity) {
      // 根据位置设置网格，警格编号
      IGridService gridService = SpringUtils.getBean(IGridService.class);
      IPoliceAffairsGridService policeAffairsGridService = SpringUtils.getBean(IPoliceAffairsGridService.class);
      String point = "'POINT(" + placeEntity.getLng() + " " + placeEntity.getLat() + ")'";
      // 点坐标解析网格
      List<GridEntity> gridEntityList = gridService.spatialAnalysis(point);
      if (gridEntityList.size() > 0) {
         GridEntity gridEntity = gridEntityList.get(0);
         // 设置场所范围
         placeEntity.setGridId(gridEntity.getId());
         placeEntity.setGridCode(gridEntity.getGridCode());
         // 更新网格范围绑定
         GridRangeEntity gridRangeEntity = new GridRangeEntity();
         gridRangeEntity.setGridId(gridEntity.getId());
         gridRangeEntity.setGridCode(gridEntity.getGridCode());
         gridRangeEntity.setHouseCode(placeEntity.getHouseCode());
         UpdateWrapper<GridRangeEntity> updateWrapper = new UpdateWrapper<>();
         updateWrapper.eq("house_code", placeEntity.getHouseCode());
         gridRangeService.update(gridRangeEntity, updateWrapper);
      }
      // 点坐标解析警格
      List<PoliceAffairsGridEntity> policeAffairsGridEntityList = policeAffairsGridService.spatialAnalysis(point);
      if (policeAffairsGridEntityList.size() > 0) {
         PoliceAffairsGridEntity policeAffairsGridEntity = policeAffairsGridEntityList.get(0);
         placeEntity.setJwGridCode(policeAffairsGridEntity.getJwGridCode());
      }
   }

@@ -842,12 +1204,12 @@
    * @param placeExcel
    * @return
    */
   public Long updateUser(PlaceExcel placeExcel) {
      if (!Strings.isBlank(placeExcel.getPhoneNumber()) &&
         !Strings.isBlank(placeExcel.getName())) {
   public Long updateUser(ImportPlaceExcel placeExcel) {
      if (!Strings.isBlank(placeExcel.getPrincipal()) &&
         !Strings.isBlank(placeExcel.getPrincipalPhone())) {
         PlaceVO placeVO = new PlaceVO();
         placeVO.setPhone(placeExcel.getPhoneNumber());
         placeVO.setUsername(placeExcel.getName());
         placeVO.setPrincipal(placeExcel.getPrincipal());
         placeVO.setPrincipalPhone(placeExcel.getPrincipalPhone());
         // 更新场所负责人
         User user = bindUserHandle(placeVO);
         // 返回
@@ -866,8 +1228,8 @@
      if (!Strings.isBlank(placeExcel.getPhoneNumber()) &&
         !Strings.isBlank(placeExcel.getName())) {
         PlaceVO placeVO = new PlaceVO();
         placeVO.setPhone(placeExcel.getPhoneNumber());
         placeVO.setUsername(placeExcel.getName());
         placeVO.setPrincipalPhone(placeExcel.getPhoneNumber());
         placeVO.setPrincipal(placeExcel.getName());
         // 更新场所负责人
         User user = bindUserHandle(placeVO);
         // 返回
@@ -908,12 +1270,20 @@
            placeEntity.setSource(3);
            //一个一个插入，防止同一个表中有相同的数据
            save(placeEntity);
            // 插入详情
            savePlaceExtInfo(placeEntity);
            // 插入标签关系表
            savPlaceLabelBind(placeExcel, placeEntity);
            // 插入关联数据表
            PlaceRelEntity placeRelEntity = new PlaceRelEntity();
            placeRelEntity.setPlaceId(placeEntity.getId());
            placeRelEntity.setStreetName(placeExcel.getStreetName());
            QueryWrapper<Region> wrapper = new QueryWrapper<>();
            wrapper.eq("name", placeExcel.getCommunityName());
            Region region = SpringUtils.getBean(IRegionService.class).getOne(wrapper);
            if (null != region) {
               placeRelEntity.setCommunityCode(region.getCode());
            }
            placeRelEntity.setCommunityName(placeExcel.getCommunityName());
            placeRelEntity.setGridName(placeExcel.getGridName());
            placeRelEntity.setBuildingName(placeExcel.getBuildingName());
@@ -940,6 +1310,8 @@
            placeEntity.setUpdateUser(AuthUtil.getUserId());
            //一个一个插入，防止同一个表中有相同的数据
            updateById(placeEntity);
            // 插入详情
            savePlaceExtInfo(placeEntity);
         }
      }
   }
@@ -951,11 +1323,19 @@
    */
   public void savPlaceLabelBind(PlaceAndRelExcel placeExcel, PlaceEntity placeEntity) {
      if (!Strings.isBlank(placeExcel.getLabelCode())) {
         PlaceVO placeVO = new PlaceVO();
         placeVO.setId(placeEntity.getId());
         placeVO.setLabel(placeExcel.getLabelCode());
         // 插入标签
         placeLabelBind(placeVO);
         // 匹配标签
         QueryWrapper<CategoryEntity> wrapper = new QueryWrapper<>();
         wrapper.eq("level", 3).eq("category_name", placeExcel.getLabelCode()).eq("is_deleted", 0);
         // 查询
         List<CategoryEntity> list = SpringUtils.getBean(ICategoryService.class).list(wrapper);
         if (list.size() > 0) {
            PlaceVO placeVO = new PlaceVO();
            CategoryEntity categoryEntity = list.get(0);
            placeVO.setLabel(categoryEntity.getCategoryNo());
            placeVO.setId(placeEntity.getId());
            // 插入标签
            placeLabelBind(placeVO);
         }
      }
   }

@@ -1131,6 +1511,8 @@
      removePlaceExt(longs);
      // 删除对应的标签绑定信息
      removePlaceLabel(longs);
      // 删除对应的门牌绑定信息
      removePlaceDoor(longs);
      // 返回
      return removeByIds;
   }
@@ -1146,6 +1528,9 @@
         PlaceEntity placeEntity = getById(id);
         if (null != placeEntity.getPrincipalUserId()) {
            User user = userService.getById(placeEntity.getPrincipalUserId());
            if (ObjectUtil.isEmpty(user)) {
               return;
            }
            // 查询场所判断是否还绑定有其他的场所
            QueryWrapper<PlaceEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("is_deleted", 0).eq("principal_user_id", user.getId());
@@ -1211,6 +1596,19 @@
   }

   /**
    * 删除对应的门牌绑定信息
    *
    * @param longs
    */
   public void removePlaceDoor(List<Long> longs) {
      for (Long id : longs) {
         QueryWrapper<PlaceDoorEntity> wrapper = new QueryWrapper<>();
         wrapper.eq("place_id", id);
         placeDoorService.remove(wrapper);
      }
   }

   /**
    * 九小场所档案
    *
    * @param page
@@ -1219,86 +1617,72 @@
    */
   @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());
         }
      }
//      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());
//         }
//      }
      CommonParamSet commonParamSet = new CommonParamSet().invoke(PlaceVO.class, place);

      List<String> strings = new ArrayList<>();
      if (null!=place.getNineType()){
      if (null != place.getNineType()) {
         QueryWrapper<DictBiz> queryWrapper = new QueryWrapper<>();
         queryWrapper.eq("is_deleted",0).eq("dict_key",place.getNineType()).eq("code","nineType");
         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){
         if (list.size() == 0) {
            strings.add(place.getNineType().toString());
         }else {
         } else {
            strings = list.stream().map(DictBiz::getDictKey).collect(Collectors.toList());
         }
      }
      List<PlaceVO> placeVOS = baseMapper.selectNinePlacePage(page, place, gridCodeList, regionChildCodesList, isAdministrator,strings);
      List<PlaceVO> placeVOS = baseMapper.selectNinePlacePage(page, place, commonParamSet.getGridCodeList(),
         commonParamSet.getRegionChildCodesList(), commonParamSet.getIsAdministrator(), 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());
         }
      }
      CommonParamSet commonParamSet = new CommonParamSet<>().invoke(PlaceVO.class, place);
      List<String> strings = new ArrayList<>();
      if (null!=place.getNineType()){
      if (null != place.getNineType()) {
         QueryWrapper<DictBiz> queryWrapper = new QueryWrapper<>();
         queryWrapper.eq("is_deleted",0).eq("dict_key",place.getNineType()).eq("code","nineType");
         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){
         if (list.size() == 0) {
            strings.add(place.getNineType().toString());
         }else {
         } else {
            strings = list.stream().map(DictBiz::getDictKey).collect(Collectors.toList());
         }
      }
      List<NinePlaceExcel> aa = baseMapper.export(place, gridCodeList, regionChildCodesList, isAdministrator,strings);
      List<NinePlaceExcel> aa = baseMapper.export(place,
         commonParamSet.getGridCodeList(),
         commonParamSet.getRegionChildCodesList(),
         commonParamSet.getIsAdministrator(),
         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) {
@@ -1343,4 +1727,133 @@
      }
      return null;
   }

   /**
    * 场所综治网格处理
    */
   @Override
   public Object placeGridCodeHandle() {
      // 查询 综治网格为空的数据
      List<PlaceEntity> list = baseMapper.getPlaceNotGridCode();
      // 遍历
      for (PlaceEntity placeEntity : list) {
         if (!Strings.isBlank(placeEntity.getLng())) {
            // 空间分析
            //点坐标解析
            String point = "'POINT(" + placeEntity.getLng() + " " + placeEntity.getLat() + ")'";
            //String point = "'POINT(" + villageInfoExcel.getLatitude() + " " + villageInfoExcel.getLongitude() +")'";
            List<GridEntity> gridEntityList = gridService.spatialAnalysis(point);
            if (gridEntityList.size() > 0) {
               GridEntity gridEntity = gridEntityList.get(0);
               placeEntity.setGridCode(gridEntity.getGridCode());
               // 更新
               updateById(placeEntity);
            }
         }
      }
      return null;
   }

   /**
    * 场所二维码绑定处理
    */
   @Override
   @Transactional(rollbackFor = Exception.class)
   public Object placeDoorBindHandle() {
      // 查询对应未的场所 house_code_binds 为空，source = 1 的
      List<PlaceEntity> list = baseMapper.selectPlaceNotDoorBindList();
      // 遍历
      for (PlaceEntity placeEntity : list) {
         // 更新
         placeEntity.setHouseCodeBinds(placeEntity.getHouseCode());
         updateById(placeEntity);
         // 查询绑定关系是否已存在
         QueryWrapper<PlaceDoorEntity> wrapper = new QueryWrapper<>();
         wrapper.eq("house_code", placeEntity.getHouseCode()).eq("place_id", placeEntity.getId());
         // 查询
         PlaceDoorEntity one = placeDoorService.getOne(wrapper);
         if (null == one) {
            // 新增
            PlaceDoorEntity placeDoorEntity = new PlaceDoorEntity();
            placeDoorEntity.setPlaceId(placeEntity.getId());
            placeDoorEntity.setHouseCode(placeEntity.getHouseCode());
            placeDoorService.save(placeDoorEntity);
         }
      }
      return null;
   }

   /**
    * 企业商超列表查询
    */
   @Override
   public IPage<PlaceVO> selectMallPage(IPage<PlaceVO> page, PlaceVO place) {
      // 公共参数设置
      CommonParamSet commonParamSet = new CommonParamSet().invoke(PlaceVO.class, place);
      List<PlaceVO> placeVOS = baseMapper.selectMallPage(page,
         place,
         commonParamSet.getGridCodeList(),
         commonParamSet.getRegionChildCodesList(),
         commonParamSet.getIsAdministrator());
      // 返回
      return page.setRecords(placeVOS);
   }

   /**
    * 查询所有场所数据
    *
    * @return
    */
   @Override
   public List<PlaceVO> getAllList(int i, int size) {
      return baseMapper.getAllList(i, size);
   }

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

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

   /**
    * 导出场所信息
    * @param place
    * @return
    */
   @Override
   public List<ExportPlaceExcel> exportPlaceList(PlaceVO place) {
      // 公共参数设置
      CommonParamSet commonParamSet = new CommonParamSet().invoke(PlaceVO.class, place);
      return baseMapper.exportPlaceList(place,
         commonParamSet.getGridCodeList(),
         commonParamSet.getRegionChildCodesList(),
         commonParamSet.getIsAdministrator()
      );
   }

   /**
    *  查询附近场所
    * @param lat
    * @param lng
    * @return
    */
   @Override
   public List<PlaceVO> getNearbyPlaceList(String lat, String lng) {
      return baseMapper.getNearbyPlaceList(lat, lng);
   }
}