/*
|
* Copyright (c) 2018-2028, Chill Zhuang All rights reserved.
|
*
|
* Redistribution and use in source and binary forms, with or without
|
* modification, are permitted provided that the following conditions are met:
|
*
|
* Redistributions of source code must retain the above copyright notice,
|
* this list of conditions and the following disclaimer.
|
* Redistributions in binary form must reproduce the above copyright
|
* notice, this list of conditions and the following disclaimer in the
|
* documentation and/or other materials provided with the distribution.
|
* Neither the name of the dreamlu.net developer nor the names of its
|
* contributors may be used to endorse or promote products derived from
|
* this software without specific prior written permission.
|
* Author: Chill 庄骞 (smallchill@163.com)
|
*/
|
package org.springblade.modules.place.service.impl;
|
|
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.node.TreeStringNode;
|
import org.springblade.common.param.CommonParamSet;
|
import org.springblade.common.utils.IdUtils;
|
import org.springblade.common.utils.SpringUtils;
|
import org.springblade.core.secure.utils.AuthUtil;
|
import org.springblade.core.tool.utils.BeanUtil;
|
import org.springblade.core.tool.utils.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;
|
import org.springblade.modules.grid.entity.GridRangeEntity;
|
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.house.entity.HouseholdEntity;
|
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.ImportPlaceExcel;
|
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.police.entity.PoliceAffairsGridEntity;
|
import org.springblade.modules.police.service.IPoliceAffairsGridService;
|
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.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.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 场所表 服务实现类
|
*
|
* @author BladeX
|
* @since 2023-10-28
|
*/
|
@Service
|
public class PlaceServiceImpl extends ServiceImpl<PlaceMapper, PlaceEntity> implements IPlaceService {
|
@Autowired
|
private IUserService userService;
|
|
@Autowired
|
private IPlacePoiLabelService placePoiLabelService;
|
|
@Autowired
|
private IPlaceExtService placeExtService;
|
|
@Autowired
|
private IPlaceRelService placeRelService;
|
|
@Autowired
|
private IPlaceDoorService placeDoorService;
|
|
@Autowired
|
private IDoorplateAddressService doorplateAddressService;
|
|
@Autowired
|
private IGridService gridService;
|
|
@Autowired
|
private IGridRangeService gridRangeService;
|
|
@Autowired
|
private GridMapper gridMapper;
|
|
@Autowired
|
private IHouseholdService householdService;
|
|
@Autowired
|
private IDictBizService dictBizService;
|
|
/**
|
* 自定义列表查询
|
*
|
* @param page
|
* @param place
|
* @return
|
*/
|
@Override
|
public IPage<PlaceVO> selectPlacePage(IPage<PlaceVO> page, PlaceVO place) {
|
// 公共参数设置
|
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
|
*/
|
@Override
|
public List<TreeStringNode> selectPlaceNodeList(Long userId) {
|
return baseMapper.selectPlaceNodeList(userId.toString());
|
}
|
|
/**
|
* 场所信息自定义新增/修改
|
*
|
* @param placeVO
|
* @return
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Boolean addOrUpdate(PlaceVO placeVO) {
|
boolean flag = false;
|
placeVO.setUpdateUser(AuthUtil.getUserId());
|
placeVO.setUpdateTime(new Date());
|
// 查看是否包含houseCode,如果有，则更新
|
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());
|
PlaceEntity one = getOne(wrapper);
|
if (null != one) {
|
placeVO.setId(one.getId());
|
} else {
|
// 扫码来的默认绑定本身
|
placeVO.setHouseCodeBinds(placeVO.getHouseCode());
|
// 新增，地址表中没有或者地址表中有场所表中没有的（是房屋的），扫码进来的
|
save(placeVO);
|
}
|
// 绑定用户信息
|
bindUserHandle(placeVO);
|
// 设置完善状态
|
setPlaceStatus(placeVO);
|
// 房屋编号绑定处理
|
houseCodeBindHandle(placeVO);
|
// 更新场所信息
|
flag = updateById(placeVO);
|
} 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);
|
}
|
// 获取请求头中的角色别名
|
String roleName = SpringUtils.getRequestParam("roleName");
|
placeVO.setRoleName(roleName);
|
// 保存场所详情及任务信息
|
savePlaceExtAndTaskInfo(placeVO);
|
// 场所标签信息绑定(更新，调整）
|
placeLabelBind(placeVO);
|
// 网格绑定
|
gridBind(placeVO);
|
// 警务网格绑定
|
jwGridCodeBind(placeVO);
|
// 保存从业人员
|
savePlacePractitioner(placeVO);
|
// 判断是否校园
|
if (placeVO.getLabel().startsWith("1601")) {
|
// 校园的新增一个主体用户和一个通用用户
|
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()) {
|
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
|
*/
|
@Override
|
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 placeEntity
|
*/
|
public void houseCodeBindHandle(PlaceEntity placeEntity) {
|
PlaceVO placeVO = new PlaceVO();
|
placeVO.setId(placeEntity.getId());
|
placeVO.setHouseCodeBinds(placeEntity.getHouseCodeBinds());
|
// 绑定
|
houseCodeBindHandle(placeVO);
|
}
|
|
/**
|
* 房屋绑定处理
|
*
|
* @param placeVO
|
*/
|
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);
|
PlaceEntity one = getOne(wrapper);
|
if (null != one) {
|
longs.add(one.getId());
|
// 删除对应的单个编号的场所
|
removeById(one.getId());
|
}
|
}
|
}
|
if (longs.size() > 0) {
|
// 删除对应的详情
|
removePlaceExt(longs);
|
// 删除对应的标签绑定信息
|
removePlaceLabel(longs);
|
// 删除对应的场所门牌绑定关系信息
|
removePlaceDoor(longs);
|
}
|
}
|
|
/**
|
* 设置场所完善状态
|
*
|
* @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())
|
&& !Strings.isBlank(placeVO.getPrincipalIdCard())
|
) {
|
// 已完善
|
placeVO.setStatus(2);
|
} else {
|
// 未完善
|
placeVO.setStatus(1);
|
}
|
}
|
|
/**
|
* 网格绑定
|
*
|
* @param placeVO
|
*/
|
public void gridBind(PlaceVO placeVO) {
|
// 判断角色，如果是网格员则直接使用网格员的网格id,如果是民警则采用点落面的方式进行获取网格的id
|
// if (!Strings.isBlank(placeVO.getRoleName()) && placeVO.getRoleName().equals("wgy")) {
|
// // 网格员角色位置绑定
|
// gridmanPositionHandle(placeVO);
|
// }
|
// 都是通过点落面方式，不区分角色
|
policePositionHandle(placeVO);
|
}
|
|
/**
|
* 网格编号绑定
|
*
|
* @param placeVO
|
*/
|
public void gridCodeBind(PlaceVO placeVO) {
|
// 判断角色，如果是网格员则直接使用网格员的网格id,如果是民警则采用点落面的方式进行获取网格的id
|
if (!Strings.isBlank(placeVO.getRoleName())) {
|
// 网格员场所网格编号绑定-新
|
gridmanGridCodePositionHandle(placeVO);
|
}
|
// 民警角色时通过位置绑定网格-新
|
policeGridCodePositionHandle(placeVO);
|
}
|
|
/**
|
* 网格员角色位置绑定-grid_id
|
*
|
* @param placeVO
|
*/
|
public void gridmanPositionHandle(PlaceVO placeVO) {
|
if (!Strings.isBlank(placeVO.getRoleName()) && placeVO.getRoleName().equals("wgy")) {
|
// 判断网格员，查询对应网格人对应的网格id
|
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());
|
GridRangeEntity one = gridRangeService.getOne(wrapper);
|
if (null == one) {
|
// 新增
|
GridRangeEntity gridRangeEntity = new GridRangeEntity();
|
gridRangeEntity.setHouseCode(placeVO.getHouseCode());
|
gridRangeEntity.setGridId(grid.getId());
|
gridRangeEntity.setGridCode(grid.getGridCode());
|
// 插入
|
gridRangeService.save(gridRangeEntity);
|
} else {
|
// 修改绑定
|
one.setGridId(grid.getId());
|
one.setGridCode(grid.getGridCode());
|
// 修改
|
gridRangeService.updateById(one);
|
}
|
}
|
}
|
}
|
|
/**
|
* 网格员角色位置绑定-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());
|
placeVO.setGridId(grid.getId());
|
// 更新场所信息
|
updateById(placeVO);
|
}
|
}
|
}
|
|
/**
|
* 其他角色时位置绑定
|
*
|
* @param placeVO
|
*/
|
@Override
|
public void policePositionHandle(PlaceVO placeVO) {
|
// 是民警且位置信息存在
|
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());
|
GridRangeEntity one = gridRangeService.getOne(wrapper);
|
if (null == one) {
|
// 新增
|
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);
|
}
|
}
|
}
|
}
|
|
/**
|
* 民警角色时通过位置绑定网格
|
*
|
* @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());
|
placeVO.setGridId(gridEntity.getId());
|
// 更新场所信息
|
updateById(placeVO);
|
}
|
}
|
}
|
}
|
|
/**
|
* 场所标签信息绑定入库
|
*
|
* @param placeVO
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
public void placeLabelBind(PlaceVO placeVO) {
|
// 先查询对于的场所是否已有标签信息
|
// 查询对应已存在的从业人员
|
QueryWrapper<PlacePoiLabel> wrapper = new QueryWrapper<>();
|
wrapper.eq("place_id", placeVO.getId());
|
List<PlacePoiLabel> oldList = placePoiLabelService.list(wrapper);
|
if (oldList.size() > 0) {
|
// 先将老的全部删除，然后批量插入
|
QueryWrapper<PlacePoiLabel> queryWrapper = new QueryWrapper<>();
|
queryWrapper.eq("place_id", placeVO.getId());
|
boolean remove = placePoiLabelService.remove(queryWrapper);
|
if (remove) {
|
// 批量新增
|
savePlaceLabel(placeVO);
|
}
|
} else {
|
savePlaceLabel(placeVO);
|
}
|
}
|
|
/**
|
* 插入场所标签信息
|
*
|
* @param placeVO
|
*/
|
public void savePlaceLabel(PlaceVO placeVO) {
|
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 (labelCode.length() > 4) {
|
// 小类
|
PlacePoiLabel min = new PlacePoiLabel();
|
min.setPlaceId(placeVO.getId());
|
min.setPoiCode(Integer.parseInt(labelCode));
|
min.setType(3);
|
if (!Strings.isBlank(placeVO.getColor())) {
|
min.setColor(placeVO.getColor());
|
}
|
placePoiLabelService.save(min);
|
}
|
}
|
}
|
}
|
|
/**
|
* 新增校方主体账号和通用账号
|
*
|
* @param placeVO
|
* @return
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
public User addSchoolUser(PlaceVO placeVO) {
|
User newUser = new User();
|
if (StringUtils.isNotBlank(placeVO.getPlaceName())) {
|
// placeVO.setPrincipal(placeVO.getPrincipal());
|
// placeVO.setPrincipalPhone(placeVO.getPrincipalPhone());
|
//如果用户不存在，则新增一个用户
|
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);
|
//绑定id
|
// placeVO.setPrincipalUserId(newUser.getId());
|
//给人员打上场所负责人的标签
|
// baseMapper.saveUserLabel(newUser.getId(), 1002);
|
}
|
return newUser;
|
}
|
|
/**
|
* 场所负责人和用户绑定
|
*
|
* @param placeVO
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
public User bindUserHandle(PlaceVO placeVO) {
|
User newUser = new User();
|
if (null != placeVO.getPrincipalPhone() && !placeVO.getPrincipalPhone().equals("")) {
|
placeVO.setPrincipal(placeVO.getPrincipal());
|
placeVO.setPrincipalPhone(placeVO.getPrincipalPhone());
|
//根据手机号查询库里的数据
|
List<User> list = userService.getUserListByPhoneOrAccount(placeVO.getPrincipalPhone());
|
if (list.size() > 0) {
|
User user = list.get(0);
|
//如果用户存在，则该用户id绑定场所
|
placeVO.setPrincipalUserId(user.getId());
|
newUser = user;
|
// 判断用户是否包含了居民角色,不包含则需更新
|
if (!user.getRoleId().contains("1717429059648606209")) {
|
user.setRoleId(user.getRoleId() + ",1717429059648606209");
|
//更新
|
userService.updateById(user);
|
}
|
} else {
|
//如果用户不存在，则新增一个用户
|
newUser.setAccount(placeVO.getPrincipalPhone());
|
newUser.setPhone(placeVO.getPrincipalPhone());
|
newUser.setName(placeVO.getPrincipal());
|
newUser.setRealName(placeVO.getPrincipal());
|
// 社区群众部门
|
newUser.setDeptId("1727979636479037441");
|
// 目前暂定居民角色，
|
newUser.setRoleId("1717429059648606209");
|
//默认密码为 123456
|
newUser.setPassword("123456");
|
// 设置机构
|
// 用户新增
|
boolean submit = userService.submit(newUser);
|
//绑定id
|
placeVO.setPrincipalUserId(newUser.getId());
|
//给人员打上场所负责人的标签
|
baseMapper.saveUserLabel(newUser.getId(), 1002);
|
}
|
}
|
return newUser;
|
}
|
|
/**
|
* 保存场所详情及任务信息
|
*
|
* @param placeVO
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
public void savePlaceExtAndTaskInfo(PlaceVO placeVO) {
|
PlaceExtEntity placeExtEntity = new PlaceExtEntity();
|
// 判断是否已存在，已存在则不新增
|
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(placeEntity.getId());
|
// 默认给待完善状态
|
placeExtEntity.setConfirmFlag(4);
|
placeExtEntity.setCreateTime(new Date());
|
placeExtEntity.setUpdateTime(new Date());
|
placeExtEntity.setCreateUser(AuthUtil.getUserId());
|
placeExtEntity.setUpdateUser(AuthUtil.getUserId());
|
// 新增场所详情
|
placeExtService.save(placeExtEntity);
|
}
|
}
|
|
/**
|
* 历史场所挂接处理-临时
|
*
|
* @param place
|
* @return
|
*/
|
@Override
|
public Object historyPlaceHandle(PlaceVO place) {
|
// 查询所有的场所（手机号不为空）
|
List<PlaceVO> list = baseMapper.getPlaceNotNullPhone();
|
// 遍历
|
for (PlaceVO placeVO : list) {
|
User user = bindUserHandle(placeVO);
|
if (null != user) {
|
placeVO.setPrincipalUserId(user.getId());
|
//更新场所用户id绑定
|
baseMapper.updatePlaceEntity(placeVO);
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 历史场所标签挂接处理-临时
|
*
|
* @param place
|
* @return
|
*/
|
@Override
|
@Transactional
|
public Object historyPlaceLabelHandle(PlaceVO place) {
|
// 查询所有的场所
|
List<PlaceVO> list = baseMapper.getAllHistoryPlace();
|
// 遍历
|
for (PlaceVO placeVO : list) {
|
if (null != placeVO.getLabel()) {
|
String[] split = placeVO.getLabel().split(",");
|
for (String s : split) {
|
PlacePoiLabel placePoiLabel = new PlacePoiLabel();
|
placePoiLabel.setPlaceId(placeVO.getId());
|
placePoiLabel.setPoiCode(Integer.parseInt(s));
|
placePoiLabelService.save(placePoiLabel);
|
}
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 场所表 自定义详情查询
|
*
|
* @param place
|
* @return
|
*/
|
@Override
|
public PlaceVO getDetail(PlaceVO place) {
|
// 查询场所信息
|
PlaceVO placeVO = baseMapper.getDetail(place);
|
// 门牌信息
|
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 (placeVO.getPlacePoiLabelVOList().size() > 0) {
|
PlacePoiLabelVO placePoiLabelVO = placeVO.getPlacePoiLabelVOList().get(0);
|
if (!Strings.isBlank(placePoiLabelVO.getColor())) {
|
placeVO.setColor(placePoiLabelVO.getColor());
|
}
|
}
|
// 查询地址门牌信息
|
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));
|
// 查询从业人员
|
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 {
|
// 查询地址编码信息（社区派出所相关信息）
|
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.setHouseCode(addressEntity.getAddressCode());
|
placeVO.setLng(addressEntity.getX());
|
placeVO.setLat(addressEntity.getY());
|
placeVO.setLocation(addressEntity.getAddressName());
|
}
|
}
|
}
|
// 返回
|
return placeVO;
|
}
|
|
/**
|
* 场所数据到导入
|
*
|
* @param data
|
* @param isCovered
|
*/
|
@Override
|
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) {
|
// 新增
|
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()));
|
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.isBlank(placeExcel.getCommunityName()) &&
|
!Strings.isBlank(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);
|
}
|
}
|
}
|
|
/**
|
* 更新用户信息
|
*
|
* @param placeExcel
|
* @return
|
*/
|
public Long updateUser(ImportPlaceExcel placeExcel) {
|
if (!Strings.isBlank(placeExcel.getPrincipal()) &&
|
!Strings.isBlank(placeExcel.getPrincipalPhone())) {
|
PlaceVO placeVO = new PlaceVO();
|
placeVO.setPrincipal(placeExcel.getPrincipal());
|
placeVO.setPrincipalPhone(placeExcel.getPrincipalPhone());
|
// 更新场所负责人
|
User user = bindUserHandle(placeVO);
|
// 返回
|
return user.getId();
|
}
|
return null;
|
}
|
|
/**
|
* 更新用户信息
|
*
|
* @param placeExcel
|
* @return
|
*/
|
public Long updateUser(PlaceAndRelExcel placeExcel) {
|
if (!Strings.isBlank(placeExcel.getPhoneNumber()) &&
|
!Strings.isBlank(placeExcel.getName())) {
|
PlaceVO placeVO = new PlaceVO();
|
placeVO.setPrincipalPhone(placeExcel.getPhoneNumber());
|
placeVO.setPrincipal(placeExcel.getName());
|
// 更新场所负责人
|
User user = bindUserHandle(placeVO);
|
// 返回
|
return user.getId();
|
}
|
return null;
|
}
|
|
/**
|
* 场所(商超)导入
|
*
|
* @param data
|
* @param isCovered
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void importAndRelPlace(List<PlaceAndRelExcel> data, Boolean isCovered) {
|
for (PlaceAndRelExcel placeExcel : data) {
|
// 判断是否存在，不存在则插入，否则不操作
|
PlaceEntity one = baseMapper.getPlaceAndRelInfo(placeExcel);
|
if (null == one) {
|
Long userId = updateUser(placeExcel);
|
// 插入场所
|
PlaceEntity placeEntity = new PlaceEntity();
|
placeEntity.setPlaceName(placeExcel.getPlaceName());
|
placeEntity.setLocation(placeExcel.getAddress());
|
placeEntity.setPrincipalUserId(userId);
|
placeEntity.setPrincipal(placeExcel.getName());
|
placeEntity.setPrincipalPhone(placeExcel.getPhoneNumber());
|
placeEntity.setPrincipalUserId(userId);
|
placeEntity.setCreateTime(new Date());
|
placeEntity.setCreateUser(AuthUtil.getUserId());
|
placeEntity.setUpdateTime(new Date());
|
placeEntity.setUpdateUser(AuthUtil.getUserId());
|
// 并生成36位的houseCode
|
placeEntity.setHouseCode(IdUtils.getIdBy36());
|
// 商超数据
|
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());
|
placeRelEntity.setDoorplateNum(placeExcel.getDoorplateNum());
|
placeRelEntity.setFloor(placeExcel.getFloor());
|
placeRelEntity.setCreateTime(new Date());
|
placeRelEntity.setCreateUser(AuthUtil.getUserId());
|
placeRelEntity.setUpdateTime(new Date());
|
placeRelEntity.setUpdateUser(AuthUtil.getUserId());
|
// 新增
|
placeRelService.save(placeRelEntity);
|
} else {
|
// 只更新商铺信息
|
Long userId = updateUser(placeExcel);
|
// 插入场所
|
PlaceEntity placeEntity = new PlaceEntity();
|
placeEntity.setId(one.getId());
|
placeEntity.setPlaceName(placeExcel.getPlaceName());
|
placeEntity.setLocation(placeExcel.getAddress());
|
placeEntity.setPrincipalUserId(userId);
|
placeEntity.setCreateTime(new Date());
|
placeEntity.setCreateUser(AuthUtil.getUserId());
|
placeEntity.setUpdateTime(new Date());
|
placeEntity.setUpdateUser(AuthUtil.getUserId());
|
//一个一个插入，防止同一个表中有相同的数据
|
updateById(placeEntity);
|
// 插入详情
|
savePlaceExtInfo(placeEntity);
|
}
|
}
|
}
|
|
/**
|
* 插入标签关系表
|
*
|
* @param placeExcel
|
*/
|
public void savPlaceLabelBind(PlaceAndRelExcel placeExcel, PlaceEntity placeEntity) {
|
if (!Strings.isBlank(placeExcel.getLabelCode())) {
|
// 匹配标签
|
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);
|
}
|
}
|
}
|
|
/**
|
* 场所数据处理-用户信息（场所负责人信息写入到场所表）
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Object placeUserHandle() {
|
// 查询出有用户id 的场所
|
List<PlaceEntity> list = baseMapper.getHasUserIdPlaceList();
|
// 遍历
|
for (PlaceEntity placeEntity : list) {
|
// 查询对应的用户信息
|
User user = userService.getById(placeEntity.getPrincipalUserId());
|
if (null != user) {
|
// 设置场所负责人，手机号
|
if (null != user.getRealName() && !user.getRealName().equals("")) {
|
placeEntity.setPrincipal(user.getRealName());
|
}
|
if (null != user.getPhone() && !user.getPhone().equals("")) {
|
placeEntity.setPrincipalPhone(user.getPhone());
|
}
|
// 更新场所信息
|
updateById(placeEntity);
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 自定义修改
|
*
|
* @param placeVO
|
* @return
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean updatePlace(PlaceVO placeVO) {
|
boolean flag = false;
|
// 修改场所信息
|
flag = updateById(placeVO);
|
// 修改标签绑定信息
|
// 返回
|
return flag;
|
}
|
|
/**
|
* 场所标签数据处理
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Object placeLabelHandle() {
|
// 查询所有的标签绑定
|
List<PlacePoiLabel> list = placePoiLabelService.getPlacePoiLabelList();
|
// 遍历
|
for (PlacePoiLabel placePoiLabel : list) {
|
// 处理单个
|
String labelCode = placePoiLabel.getPoiCode().toString();
|
// 切割成三个，分别是大类，中类，小类
|
String bigString = labelCode.substring(0, 2);
|
String midString = labelCode.substring(0, 4);
|
// 大类
|
PlacePoiLabel big = new PlacePoiLabel();
|
big.setPlaceId(placePoiLabel.getPlaceId());
|
big.setPoiCode(Integer.parseInt(bigString));
|
big.setType(1);
|
// 保存前先判断
|
QueryWrapper<PlacePoiLabel> queryWrapper = new QueryWrapper<>();
|
queryWrapper.eq("place_id", placePoiLabel.getPlaceId()).eq("poi_code", Integer.parseInt(bigString));
|
PlacePoiLabel one = placePoiLabelService.getOne(queryWrapper);
|
if (null == one) {
|
placePoiLabelService.save(big);
|
}
|
// 中类
|
PlacePoiLabel mid = new PlacePoiLabel();
|
mid.setPlaceId(placePoiLabel.getPlaceId());
|
mid.setPoiCode(Integer.parseInt(midString));
|
mid.setType(2);
|
// 保存前先判断
|
QueryWrapper<PlacePoiLabel> wrapper = new QueryWrapper<>();
|
wrapper.eq("place_id", placePoiLabel.getPlaceId()).eq("poi_code", Integer.parseInt(midString));
|
PlacePoiLabel two = placePoiLabelService.getOne(wrapper);
|
if (null == two) {
|
placePoiLabelService.save(mid);
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 历史场所详情数据处理
|
*
|
* @param place
|
* @return
|
*/
|
@Override
|
public Object historyPlaceExtHandle(PlaceVO place) {
|
// 查询所有的场所数据（除去详情表已有的）
|
List<PlaceEntity> list = baseMapper.getPlaceListByNoExt();
|
// 遍历更新
|
for (PlaceEntity placeEntity : list) {
|
QueryWrapper<PlaceExtEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.eq("place_id", placeEntity.getId()).eq("is_deleted", 0);
|
PlaceExtEntity one = placeExtService.getOne(queryWrapper);
|
if (null == one) {
|
// 新增
|
PlaceExtEntity placeExtEntity = new PlaceExtEntity();
|
if (null != placeEntity.getPrincipalUserId()) {
|
// 待审核
|
placeExtEntity.setConfirmFlag(1);
|
} else {
|
// 待完善
|
placeExtEntity.setConfirmFlag(4);
|
}
|
placeExtEntity.setPlaceId(placeEntity.getId());
|
// 插入
|
placeExtService.save(placeExtEntity);
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 商超数据处理
|
*
|
* @return
|
*/
|
@Override
|
public Object placeAndRelHandle() {
|
// 查询未处理的商超数据
|
List<PlaceEntity> placeEntityList = baseMapper.placeAndRelHandle();
|
// 处理
|
for (PlaceEntity placeEntity : placeEntityList) {
|
if (Strings.isBlank(placeEntity.getHouseCode())) {
|
// 并生成36位的houseCode
|
placeEntity.setHouseCode(IdUtils.getIdBy36());
|
// 商超数据
|
placeEntity.setSource(3);
|
// 更新
|
updateById(placeEntity);
|
}
|
}
|
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);
|
// 删除对应的门牌绑定信息
|
removePlaceDoor(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 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
|
* @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());
|
// }
|
// }
|
CommonParamSet commonParamSet = new CommonParamSet().invoke(PlaceVO.class, place);
|
|
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, commonParamSet.getGridCodeList(),
|
commonParamSet.getRegionChildCodesList(), commonParamSet.getIsAdministrator(), strings);
|
// 返回
|
return page.setRecords(placeVOS);
|
}
|
|
@Override
|
public List<NinePlaceExcel> export(PlaceVO place) {
|
CommonParamSet commonParamSet = new CommonParamSet<>().invoke(PlaceVO.class, place);
|
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,
|
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) {
|
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;
|
}
|
|
/**
|
* 场所综治网格处理
|
*/
|
@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);
|
}
|
}
|
