package com.xiaopeng.map.service.serviceimpl;
|
|
|
import cn.hutool.core.collection.CollUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.google.common.collect.ImmutableMap;
|
import com.xiaopeng.api.dto.operation.ElectronicFenceAddDto;
|
import com.xiaopeng.api.dto.operation.ElectronicFenceUpdateDto;
|
import com.xiaopeng.api.model.map.XpGeoFencingPolygon;
|
import com.xiaopeng.api.model.map.XpGeoFencingProhibitedPolygon;
|
import com.xiaopeng.api.model.operation.*;
|
import com.xiaopeng.api.query.operation.ElectronicPageListQuery;
|
import com.xiaopeng.common.core.domain.R;
|
import com.xiaopeng.common.core.exception.ServiceException;
|
import com.xiaopeng.common.core.utils.DateUtils;
|
import com.xiaopeng.common.core.utils.StringUtils;
|
import com.xiaopeng.common.core.utils.bean.BeanUtils;
|
import com.xiaopeng.common.core.web.page.PageInfo;
|
import com.xiaopeng.map.constant.I18nKeyConstant;
|
import com.xiaopeng.map.job.base.QuartzManager;
|
import com.xiaopeng.map.job.base.TimeJobType;
|
import com.xiaopeng.map.job.jobs.ElectronicEffectJob;
|
import com.xiaopeng.map.mangodb.service.XpGeoFencingPolygonService;
|
import com.xiaopeng.map.mapper.XpElectronicFenceAreaMapper;
|
import com.xiaopeng.map.mapper.XpElectronicFenceMapper;
|
import com.xiaopeng.map.mapper.XpPointMapper;
|
import com.xiaopeng.map.mapper.XpRegionMapper;
|
import com.xiaopeng.map.event.FenceChangedEvent;
|
import com.xiaopeng.map.service.XpElectronicFenceAreaService;
|
import com.xiaopeng.map.service.XpElectronicFenceService;
|
import com.xiaopeng.map.service.XpPointService;
|
import com.xiaopeng.map.utils.OperationStrategyIndex;
|
import com.xiaopeng.map.utils.GDMapGeocodingUtil;
|
import com.xiaopeng.map.utils.PolygonOverlapService;
|
import lombok.extern.slf4j.Slf4j;
|
import net.sourceforge.pinyin4j.PinyinHelper;
|
import org.apache.shardingsphere.transaction.annotation.ShardingSphereTransactionType;
|
import org.apache.shardingsphere.transaction.core.TransactionType;
|
import org.locationtech.jts.geom.Coordinate;
|
import org.locationtech.jts.geom.GeometryFactory;
|
import org.locationtech.jts.geom.LinearRing;
|
import org.locationtech.jts.geom.Polygon;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.ApplicationEventPublisher;
|
import org.springframework.data.geo.Point;
|
import org.springframework.data.mongodb.core.MongoTemplate;
|
import org.springframework.data.mongodb.core.geo.GeoJsonPolygon;
|
import org.springframework.data.mongodb.core.query.Criteria;
|
import org.springframework.data.mongodb.core.query.Query;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.annotation.Resource;
|
import java.time.LocalDateTime;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 电子围栏 服务实现类
|
* </p>
|
*
|
* @author liu
|
* @since 2026-02-03
|
*/
|
@Service
|
@Slf4j
|
public class XpElectronicFenceServiceImpl extends ServiceImpl<XpElectronicFenceMapper, XpElectronicFence> implements XpElectronicFenceService {
|
|
@Resource
|
private PolygonOverlapService polygonOverlapService;
|
@Resource
|
private XpElectronicFenceAreaMapper xpElectronicFenceAreaMapper;
|
@Autowired
|
private MongoTemplate mongoTemplate;
|
@Autowired
|
private XpPointMapper xpPointMapper;
|
|
@Autowired
|
private XpPointService xpPointService;
|
|
@Resource
|
private XpGeoFencingPolygonService xpGeoFencingPolygonService;
|
|
@Autowired
|
private XpRegionMapper xpRegionMapper;
|
@Autowired
|
private GDMapGeocodingUtil gdMapGeocodingUtil;
|
@Resource
|
private XpElectronicFenceAreaService xpElectronicFenceAreaService;
|
@Autowired
|
private ApplicationEventPublisher applicationEventPublisher;
|
|
@Override
|
public PageInfo<XpElectronicFence> pageList(ElectronicPageListQuery query) {
|
if (query == null) {
|
return new PageInfo<>();
|
}
|
normalizeProhibitedAreaCountFilter(query);
|
PageInfo<XpElectronicFence> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
|
List<XpElectronicFence> list = this.baseMapper.pageList(pageInfo, query);
|
if (list.isEmpty()) {
|
return new PageInfo<>();
|
}
|
List<Long> electronicIds = list.stream().map(XpElectronicFence::getId).collect(Collectors.toList());
|
Map<Long, List<XpElectronicFenceArea>> electronicFenceAreaMap = xpElectronicFenceAreaMapper.selectList(new LambdaQueryWrapper<XpElectronicFenceArea>()
|
.in(XpElectronicFenceArea::getElectronicId, electronicIds)).stream()
|
.collect(Collectors.groupingBy(XpElectronicFenceArea::getElectronicId));
|
for (XpElectronicFence xpElectronicFence : list) {
|
List<XpElectronicFenceArea> xpElectronicFenceAreas = electronicFenceAreaMap.get(xpElectronicFence.getId());
|
if (xpElectronicFenceAreas != null) {
|
xpElectronicFence.setOperatingAreaCount(xpElectronicFenceAreas.stream().filter(xpElectronicFenceArea -> xpElectronicFenceArea.getAreaType() == 1).count());
|
xpElectronicFence.setProhibitedAreaCount(xpElectronicFenceAreas.stream().filter(xpElectronicFenceArea -> xpElectronicFenceArea.getAreaType() == 2).count());
|
} else {
|
xpElectronicFence.setOperatingAreaCount(0L);
|
xpElectronicFence.setProhibitedAreaCount(0L);
|
}
|
}
|
pageInfo.setRecords(list);
|
return pageInfo;
|
}
|
|
private void normalizeProhibitedAreaCountFilter(ElectronicPageListQuery query) {
|
Integer prohibitedAreaCountMin = query.getProhibitedAreaCountMin();
|
Integer prohibitedAreaCountMax = query.getProhibitedAreaCountMax();
|
if (prohibitedAreaCountMin != null || prohibitedAreaCountMax != null) {
|
if (prohibitedAreaCountMin != null && prohibitedAreaCountMax != null) {
|
int min = Math.min(prohibitedAreaCountMin, prohibitedAreaCountMax);
|
int max = Math.max(prohibitedAreaCountMin, prohibitedAreaCountMax);
|
if (min < 0) {
|
clearAreaFilter(query);
|
return;
|
}
|
query.setProhibitedAreaCountMin(min);
|
query.setProhibitedAreaCountMax(max);
|
query.setElectronicAreaId(null);
|
return;
|
}
|
if (prohibitedAreaCountMin != null) {
|
if (prohibitedAreaCountMin < 0) {
|
clearAreaFilter(query);
|
return;
|
}
|
query.setElectronicAreaId(null);
|
return;
|
}
|
if (prohibitedAreaCountMax < 0) {
|
clearAreaFilter(query);
|
return;
|
}
|
query.setElectronicAreaId(null);
|
return;
|
}
|
|
String electronicAreaId = query.getElectronicAreaId();
|
if (StringUtils.isEmpty(electronicAreaId)) {
|
return;
|
}
|
try {
|
if (electronicAreaId.contains(",")) {
|
String[] parts = electronicAreaId.split(",");
|
if (parts.length != 2) {
|
clearAreaFilter(query);
|
return;
|
}
|
int left = Integer.parseInt(parts[0].trim());
|
int right = Integer.parseInt(parts[1].trim());
|
int min = Math.min(left, right);
|
int max = Math.max(left, right);
|
if (min < 0) {
|
clearAreaFilter(query);
|
return;
|
}
|
query.setProhibitedAreaCountMin(min);
|
query.setProhibitedAreaCountMax(max);
|
query.setElectronicAreaId(null);
|
return;
|
}
|
int threshold = Integer.parseInt(electronicAreaId.trim());
|
if (threshold < 0 || threshold == Integer.MAX_VALUE) {
|
clearAreaFilter(query);
|
return;
|
}
|
query.setProhibitedAreaCountMin(threshold + 1);
|
query.setProhibitedAreaCountMax(null);
|
query.setElectronicAreaId(null);
|
} catch (Exception e) {
|
clearAreaFilter(query);
|
}
|
}
|
|
private void clearAreaFilter(ElectronicPageListQuery query) {
|
query.setElectronicAreaId(null);
|
query.setProhibitedAreaCountMin(null);
|
query.setProhibitedAreaCountMax(null);
|
}
|
|
public static String getPinyinInitials(String chinese) {
|
StringBuilder pinyinInitials = new StringBuilder();
|
for (char c : chinese.toCharArray()) {
|
// 获取拼音数组（多音字会返回多个拼音）
|
String[] pinyinArray = PinyinHelper.toHanyuPinyinStringArray(c);
|
if (pinyinArray != null && pinyinArray.length > 0) {
|
// 取第一个拼音的首字母
|
pinyinInitials.append(pinyinArray[0].charAt(0));
|
}
|
}
|
return pinyinInitials.toString();
|
}
|
|
@Override
|
@Transactional
|
@ShardingSphereTransactionType(TransactionType.BASE)
|
public R addElectronic(ElectronicFenceAddDto dto) {
|
validateElectronicNameUnique(dto.getElectronicName(), null);
|
// 获取现有的运营区域（areaType=1）
|
LambdaQueryWrapper<XpElectronicFenceArea> xpElectronicFenceAreaLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
xpElectronicFenceAreaLambdaQueryWrapper.eq(XpElectronicFenceArea::getAreaType, 1);
|
xpElectronicFenceAreaLambdaQueryWrapper.eq(XpElectronicFenceArea::getAreaStatus, 1);
|
List<XpElectronicFenceArea> existingOperationAreas = xpElectronicFenceAreaMapper.selectList(xpElectronicFenceAreaLambdaQueryWrapper);
|
|
// 获取待添加的新区域
|
List<XpElectronicFenceArea> newElectronicFenceAreas = dto.getElectronicFenceAreas();
|
|
|
// 检查新区域与现有运营区域是否有重叠
|
for (XpElectronicFenceArea newArea : newElectronicFenceAreas) {
|
//处理围栏闭合
|
String[] split = newArea.getFencePoints().split(",");
|
if (!split[0].equals(split[split.length - 1])) {
|
newArea.setFencePoints(newArea.getFencePoints() + "," + split[0]);
|
}
|
if (newArea.getAreaType() == 1) { // 只检查运营区域
|
for (XpElectronicFenceArea existingArea : existingOperationAreas) {
|
if (polygonOverlapService.checkPolygonOverlap(
|
newArea.getFencePoints(),
|
existingArea.getFencePoints())) {
|
throw new ServiceException(
|
"运营区域{}与现有运营区域{}发生重叠",
|
I18nKeyConstant.AREA_OVERLAP_ERROR,
|
new Object[]{existingArea.getAreaName(), existingArea.getAreaName()}
|
);
|
}
|
}
|
}
|
}
|
|
// 保存主表数据
|
XpElectronicFence xpElectronicFence = new XpElectronicFence();
|
BeanUtils.copyProperties(dto, xpElectronicFence);
|
LocalDateTime now = LocalDateTime.now();
|
int targetStatus = resolveFenceStatus(dto.getStatus(), dto.getEffectType(), dto.getEffectTime(), now);
|
xpElectronicFence.setStatus(targetStatus);
|
if (targetStatus == 2 && dto.getEffectType() != null && dto.getEffectType() == 1) {
|
xpElectronicFence.setEffectTime(now);
|
}
|
|
//根据经纬度获取当前城市code
|
XpElectronicFenceArea xpElectronicFenceArea = dto.getElectronicFenceAreas().get(0);
|
String[] split = xpElectronicFenceArea.getFencePoints().split(",");
|
Coordinate[] coordinates = new Coordinate[split.length + 1];
|
for (int i = 0; i < split.length; i++) {
|
String[] split1 = split[i].split("_");
|
coordinates[i] = new Coordinate(Double.parseDouble(split1[0]), Double.parseDouble(split1[1]));
|
}
|
org.locationtech.jts.geom.Point point = calculateCentroid(coordinates);
|
Map<String, String> geocode = gdMapGeocodingUtil.geocode(point.getX() + "", point.getY() + "");
|
if (null == geocode) {
|
return R.fail("经纬度转换城市code失败");
|
}
|
String cityCode = geocode.get("cityCode");
|
dto.setCityCode(cityCode);
|
xpElectronicFence.setCityCode(dto.getCityCode());
|
// 生成围栏id 规则：城市首字母-类型简写-4位自增流水号（如 SZ-OP-001），支持复制；数据停用或删除后，流水号不回收
|
XpRegion xpRegion = xpRegionMapper.selectOne(new LambdaQueryWrapper<XpRegion>()
|
.eq(XpRegion::getCode, dto.getCityCode()));
|
String name = xpRegion.getName();
|
this.save(xpElectronicFence);
|
// 根据城市中文名，截取前两位的首字母并且大写
|
// 截取前两个字符
|
String prefix = name.substring(0, 2);
|
// 获取拼音首字母并大写
|
String result = getPinyinInitials(prefix).toUpperCase();
|
xpElectronicFence.setElectronicNumber(result + "-OP-" + String.format("%04d", xpElectronicFence.getId()));
|
if (dto.getStatus() == 1) {
|
registerEffectJobIfNeeded(xpElectronicFence.getId(), targetStatus, dto.getEffectType(), dto.getEffectTime(), now);
|
registerFailureJobIfNeeded(xpElectronicFence.getId(), dto.getFailureType(), dto.getFailureTime(), now);
|
}
|
this.updateById(xpElectronicFence);
|
if (xpElectronicFence.getStatus() == 2) {
|
// 设置电子围栏ID并保存区域数据
|
for (XpElectronicFenceArea area : newElectronicFenceAreas) {
|
area.setElectronicId(xpElectronicFence.getId());
|
area.setAreaStatus(1);
|
area.setArea(area.getArea());
|
area.setCityCode(dto.getCityCode());
|
xpElectronicFenceAreaMapper.insert(area);
|
}
|
|
} else {
|
// 设置电子围栏ID并保存区域数据
|
for (XpElectronicFenceArea area : newElectronicFenceAreas) {
|
area.setElectronicId(xpElectronicFence.getId());
|
area.setAreaStatus(2);
|
area.setArea(area.getArea());
|
area.setCityCode(dto.getCityCode());
|
xpElectronicFenceAreaMapper.insert(area);
|
|
}
|
}
|
|
if (xpElectronicFence.getStatus() == 1 || xpElectronicFence.getStatus() == 2) {
|
for (XpElectronicFenceArea newElectronicFenceArea : newElectronicFenceAreas) {
|
if (newElectronicFenceArea.getAreaType() == 1
|
&& newElectronicFenceArea.getAreaStatus() == 1) {
|
XpGeoFencingPolygon xpGeoFencingPolygon = new XpGeoFencingPolygon();
|
xpGeoFencingPolygon.setFenceId(String.valueOf(xpElectronicFence.getId()));
|
xpGeoFencingPolygon.setName(xpElectronicFence.getElectronicName());
|
xpGeoFencingPolygon.setAreaId(String.valueOf(newElectronicFenceArea.getId()));
|
xpGeoFencingPolygon.setCityCode(xpElectronicFence.getCityCode());
|
xpGeoFencingPolygon.setOperationStrategy(xpElectronicFence.getOperationStrategy());
|
// 将围栏点转换为GeoJSON多边形
|
GeoJsonPolygon geoJsonPolygon = convertToGeoJsonPolygon(newElectronicFenceArea.getFencePoints());
|
xpGeoFencingPolygon.setPoints(geoJsonPolygon);
|
mongoTemplate.insert(xpGeoFencingPolygon);
|
}
|
if (newElectronicFenceArea.getAreaType() == 2
|
&& newElectronicFenceArea.getAreaStatus() == 1) {
|
XpGeoFencingProhibitedPolygon xpGeoFencingProhibitedPolygon = new XpGeoFencingProhibitedPolygon();
|
xpGeoFencingProhibitedPolygon.setFenceId(String.valueOf(xpElectronicFence.getId()));
|
xpGeoFencingProhibitedPolygon.setName(xpElectronicFence.getElectronicName());
|
xpGeoFencingProhibitedPolygon.setAreaId(String.valueOf(newElectronicFenceArea.getId()));
|
// 将围栏点转换为GeoJSON多边形
|
GeoJsonPolygon geoJsonPolygon = convertToGeoJsonPolygon(newElectronicFenceArea.getFencePoints());
|
xpGeoFencingProhibitedPolygon.setPoints(geoJsonPolygon);
|
mongoTemplate.save(xpGeoFencingProhibitedPolygon);
|
}
|
}
|
}
|
|
return R.ok();
|
}
|
|
@Override
|
@Transactional
|
@ShardingSphereTransactionType(TransactionType.BASE)
|
public R editElectronic(ElectronicFenceUpdateDto dto) {
|
validateElectronicNameUnique(dto.getElectronicName(), dto.getId());
|
// 获取现有的运营区域（areaType=1），排除当前正在编辑的电子围栏
|
LambdaQueryWrapper<XpElectronicFenceArea> xpElectronicFenceAreaLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
xpElectronicFenceAreaLambdaQueryWrapper.eq(XpElectronicFenceArea::getAreaType, 1);
|
xpElectronicFenceAreaLambdaQueryWrapper.eq(XpElectronicFenceArea::getAreaStatus, 1);
|
xpElectronicFenceAreaLambdaQueryWrapper.ne(XpElectronicFenceArea::getElectronicId, dto.getId());
|
List<XpElectronicFenceArea> existingOperationAreas = xpElectronicFenceAreaMapper.selectList(xpElectronicFenceAreaLambdaQueryWrapper);
|
|
// 获取待更新的区域
|
List<XpElectronicFenceArea> updatedElectronicFenceAreas = dto.getElectronicFenceAreas();
|
|
// 检查更新后的区域与现有运营区域是否有重叠
|
for (XpElectronicFenceArea updatedArea : updatedElectronicFenceAreas) {
|
//处理围栏闭合
|
String[] split = updatedArea.getFencePoints().split(",");
|
if (!split[0].equals(split[split.length - 1])) {
|
updatedArea.setFencePoints(updatedArea.getFencePoints() + "," + split[0]);
|
}
|
if (updatedArea.getAreaType() == 1) { // 只检查运营区域
|
for (XpElectronicFenceArea existingArea : existingOperationAreas) {
|
if (polygonOverlapService.checkPolygonOverlap(
|
updatedArea.getFencePoints(),
|
existingArea.getFencePoints())) {
|
List<String> res = new ArrayList<>();
|
res.add(updatedArea.getAreaName());
|
res.add(existingArea.getAreaName());
|
throw new ServiceException(
|
"运营区域{}与现有运营区域{}发生重叠，请编辑已有的运营区域",
|
I18nKeyConstant.AREA_OVERLAP_ERROR,
|
res.toArray()
|
);
|
}
|
}
|
}
|
}
|
|
XpElectronicFence electronicFence = this.getById(dto.getId());
|
Integer status = electronicFence.getStatus();
|
String oldOperationStrategy = electronicFence.getOperationStrategy();
|
String newOperationStrategy = dto.getOperationStrategy();
|
|
|
// 更新主表数据
|
XpElectronicFence xpElectronicFence = new XpElectronicFence();
|
BeanUtils.copyProperties(dto, xpElectronicFence);
|
LocalDateTime now = LocalDateTime.now();
|
int targetStatus = resolveFenceStatus(dto.getStatus(), dto.getEffectType(), dto.getEffectTime(), now);
|
xpElectronicFence.setStatus(targetStatus);
|
if (targetStatus == 2 && dto.getEffectType() != null && dto.getEffectType() == 1) {
|
xpElectronicFence.setEffectTime(now);
|
}
|
if (dto.getStatus() == 1 || dto.getStatus() == 2) {
|
registerEffectJobIfNeeded(xpElectronicFence.getId(), targetStatus, dto.getEffectType(), dto.getEffectTime(), now);
|
registerFailureJobIfNeeded(xpElectronicFence.getId(), dto.getFailureType(), dto.getFailureTime(), now);
|
} else {
|
QuartzManager.removeJob((ElectronicEffectJob.effect + xpElectronicFence.getId()).toUpperCase(), TimeJobType.ELECTRONIC_EFFECT);
|
QuartzManager.removeJob((ElectronicEffectJob.failure + xpElectronicFence.getId()).toUpperCase(), TimeJobType.ELECTRONIC_FAILURE);
|
}
|
//根据经纬度获取当前城市code
|
XpElectronicFenceArea electronicFenceArea = dto.getElectronicFenceAreas().get(0);
|
String[] split = electronicFenceArea.getFencePoints().split(",");
|
Coordinate[] coordinates = new Coordinate[split.length];
|
for (int i = 0; i < split.length; i++) {
|
String[] split1 = split[i].split("_");
|
coordinates[i] = new Coordinate(Double.parseDouble(split1[0]), Double.parseDouble(split1[1]));
|
}
|
org.locationtech.jts.geom.Point point = calculateCentroid(coordinates);
|
Map<String, String> geocode = gdMapGeocodingUtil.geocode(point.getX() + "", point.getY() + "");
|
if (null == geocode) {
|
return R.fail("经纬度转换城市code失败");
|
}
|
String cityCode = geocode.get("cityCode");
|
dto.setCityCode(cityCode);
|
xpElectronicFence.setCityCode(dto.getCityCode());
|
|
this.updateById(xpElectronicFence);
|
|
// 禁行区（areaType=2）差异删除：对比原有禁行区与本次编辑入参禁行区（按id）
|
List<XpElectronicFenceArea> existingProhibitedAreas = xpElectronicFenceAreaService.lambdaQuery()
|
.eq(XpElectronicFenceArea::getElectronicId, dto.getId())
|
.eq(XpElectronicFenceArea::getAreaType, 2)
|
.list();
|
Set<Long> incomingProhibitedIds = updatedElectronicFenceAreas.stream()
|
.filter(a -> a != null && a.getAreaType() != null && a.getAreaType() == 2 && a.getId() != null)
|
.map(XpElectronicFenceArea::getId)
|
.collect(Collectors.toSet());
|
List<Long> toDeleteProhibitedIds = existingProhibitedAreas.stream()
|
.map(XpElectronicFenceArea::getId)
|
.filter(id -> id != null && !incomingProhibitedIds.contains(id))
|
.collect(Collectors.toList());
|
if (!toDeleteProhibitedIds.isEmpty()) {
|
// 逻辑删除MySQL禁行区
|
xpElectronicFenceAreaService.removeByIds(toDeleteProhibitedIds);
|
// 同步删除Mongo禁行区多边形
|
List<String> toDeleteAreaIdStrings = toDeleteProhibitedIds.stream().map(String::valueOf).collect(Collectors.toList());
|
Query delMongoQuery = new Query();
|
delMongoQuery.addCriteria(Criteria.where("fenceId").is(String.valueOf(dto.getId())));
|
delMongoQuery.addCriteria(Criteria.where("areaId").in(toDeleteAreaIdStrings));
|
mongoTemplate.remove(delMongoQuery, XpGeoFencingProhibitedPolygon.class);
|
}
|
// 删除旧的区域数据，然后保存新的区域数据
|
mongoTemplate.remove(new Query(Criteria.where("fenceId").is(String.valueOf(dto.getId()))), XpGeoFencingPolygon.class);
|
if (xpElectronicFence.getStatus() == 2) {
|
// 设置电子围栏ID并保存区域数据
|
for (XpElectronicFenceArea area : updatedElectronicFenceAreas) {
|
area.setElectronicId(xpElectronicFence.getId());
|
if (area.getAreaType() == null || area.getAreaType() == 1) {
|
area.setAreaStatus(1);
|
}
|
area.setArea(area.getArea());
|
area.setCityCode(dto.getCityCode());
|
if (null != area.getId()) {
|
xpElectronicFenceAreaService.updateById(area);
|
} else {
|
xpElectronicFenceAreaService.save(area);
|
}
|
}
|
} else {
|
// 设置电子围栏ID并保存区域数据
|
for (XpElectronicFenceArea area : updatedElectronicFenceAreas) {
|
area.setElectronicId(xpElectronicFence.getId());
|
if (area.getAreaType() == null || area.getAreaType() == 1) {
|
area.setAreaStatus(2);
|
}
|
area.setArea(area.getArea());
|
area.setCityCode(dto.getCityCode());
|
if (null != area.getId()) {
|
xpElectronicFenceAreaService.updateById(area);
|
} else {
|
xpElectronicFenceAreaService.save(area);
|
}
|
}
|
}
|
if (dto.getStatus() == 1 || dto.getStatus() == 2) {
|
for (XpElectronicFenceArea newElectronicFenceArea : updatedElectronicFenceAreas) {
|
if (newElectronicFenceArea.getAreaType() == 1
|
&& newElectronicFenceArea.getAreaStatus() == 1) {
|
// 先查询出mongo里围栏相同的数据 如果有 那么更新数据
|
Query query = new Query();
|
query.addCriteria(Criteria.where("fenceId").is(String.valueOf(xpElectronicFence.getId())));
|
query.addCriteria(Criteria.where("areaId").is(String.valueOf(newElectronicFenceArea.getId())));
|
XpGeoFencingPolygon old = mongoTemplate.findOne(query, XpGeoFencingPolygon.class);
|
if (old == null) {
|
XpGeoFencingPolygon xpGeoFencingPolygon = new XpGeoFencingPolygon();
|
xpGeoFencingPolygon.setFenceId(String.valueOf(xpElectronicFence.getId()));
|
xpGeoFencingPolygon.setName(xpElectronicFence.getElectronicName());
|
xpGeoFencingPolygon.setCityCode(cityCode);
|
xpGeoFencingPolygon.setAreaId(String.valueOf(newElectronicFenceArea.getId()));
|
xpGeoFencingPolygon.setOperationStrategy(xpElectronicFence.getOperationStrategy());
|
// 将围栏点转换为GeoJSON多边形
|
GeoJsonPolygon geoJsonPolygon = convertToGeoJsonPolygon(newElectronicFenceArea.getFencePoints());
|
xpGeoFencingPolygon.setPoints(geoJsonPolygon);
|
mongoTemplate.save(xpGeoFencingPolygon);
|
} else {
|
// 如果存在，则更新已有文档
|
old.setFenceId(String.valueOf(xpElectronicFence.getId()));
|
old.setName(xpElectronicFence.getElectronicName());
|
old.setCityCode(cityCode);
|
old.setAreaId(String.valueOf(newElectronicFenceArea.getId()));
|
old.setOperationStrategy(xpElectronicFence.getOperationStrategy());
|
// 将围栏点转换为GeoJSON多边形
|
GeoJsonPolygon geoJsonPolygon = convertToGeoJsonPolygon(newElectronicFenceArea.getFencePoints());
|
old.setPoints(geoJsonPolygon);
|
// 执行更新操作
|
mongoTemplate.save(old); // save() 会根据 _id 自动判断是插入还是更新
|
}
|
|
}
|
if (newElectronicFenceArea.getAreaType() == 2
|
&& newElectronicFenceArea.getAreaStatus() == 1) {
|
// 先查询出mongo里围栏相同的数据 如果有 那么更新数据
|
Query query = new Query();
|
query.addCriteria(Criteria.where("fenceId").is(String.valueOf(xpElectronicFence.getId())));
|
query.addCriteria(Criteria.where("areaId").is(String.valueOf(newElectronicFenceArea.getId())));
|
XpGeoFencingProhibitedPolygon old = mongoTemplate.findOne(query, XpGeoFencingProhibitedPolygon.class);
|
if (old == null) {
|
XpGeoFencingProhibitedPolygon xpGeoFencingProhibitedPolygon = new XpGeoFencingProhibitedPolygon();
|
xpGeoFencingProhibitedPolygon.setFenceId(String.valueOf(xpElectronicFence.getId()));
|
xpGeoFencingProhibitedPolygon.setName(xpElectronicFence.getElectronicName());
|
xpGeoFencingProhibitedPolygon.setAreaId(String.valueOf(newElectronicFenceArea.getId()));
|
// 将围栏点转换为GeoJSON多边形
|
GeoJsonPolygon geoJsonPolygon = convertToGeoJsonPolygon(newElectronicFenceArea.getFencePoints());
|
xpGeoFencingProhibitedPolygon.setPoints(geoJsonPolygon);
|
mongoTemplate.save(xpGeoFencingProhibitedPolygon);
|
} else {
|
old.setFenceId(String.valueOf(xpElectronicFence.getId()));
|
old.setName(xpElectronicFence.getElectronicName());
|
old.setAreaId(String.valueOf(newElectronicFenceArea.getId()));
|
// 将围栏点转换为GeoJSON多边形
|
GeoJsonPolygon geoJsonPolygon = convertToGeoJsonPolygon(newElectronicFenceArea.getFencePoints());
|
old.setPoints(geoJsonPolygon);
|
mongoTemplate.save(old);
|
}
|
} else if (newElectronicFenceArea.getAreaType() == 2
|
&& newElectronicFenceArea.getId() != null) {
|
Query query = new Query();
|
query.addCriteria(Criteria.where("fenceId").is(String.valueOf(xpElectronicFence.getId())));
|
query.addCriteria(Criteria.where("areaId").is(String.valueOf(newElectronicFenceArea.getId())));
|
mongoTemplate.remove(query, XpGeoFencingProhibitedPolygon.class);
|
}
|
}
|
}
|
// 判断区域下的所有运营点位是否处于运营区域内 如果不是则更新为测试点位
|
List<Long> areaIds = updatedElectronicFenceAreas.stream().map(XpElectronicFenceArea::getId).collect(Collectors.toList());
|
LambdaQueryWrapper<XpPoint> pointLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
pointLambdaQueryWrapper.in(XpPoint::getElectronicAreaId, areaIds).eq(XpPoint::getPointType, 1);
|
List<XpPoint> xpPoints = xpPointMapper.selectList(pointLambdaQueryWrapper);
|
if (!xpPoints.isEmpty()) {
|
List<Long> electronicAreaId = xpPoints.stream().map(XpPoint::getElectronicAreaId).distinct().collect(Collectors.toList());
|
if (!electronicAreaId.isEmpty()) {
|
Map<Long, XpElectronicFenceArea> longXpElectronicFenceAreaMap = updatedElectronicFenceAreas
|
.stream().collect(Collectors.toMap(XpElectronicFenceArea::getId, e -> e));
|
for (XpPoint xpPoint : xpPoints) {
|
XpElectronicFenceArea xpElectronicFenceArea = longXpElectronicFenceAreaMap.get(xpPoint.getElectronicAreaId());
|
|
if (xpElectronicFenceArea != null) {
|
String fencePoints = xpElectronicFenceArea.getFencePoints();
|
Double pointLat = xpPoint.getPointLat();
|
Double pointLon = xpPoint.getPointLon();
|
// 判断这个点位有没有处于当前区域 由多个经纬度点构成的面里
|
if (fencePoints != null && !fencePoints.trim().isEmpty() &&
|
pointLat != null && pointLon != null) {
|
boolean isInside = isPointInPolygon(fencePoints, pointLon, pointLat);
|
// 如果点不在区域内，更新为测试点位
|
if (!isInside) {
|
xpPoint.setPointType(2); //
|
log.info("点位ID: {} 经纬度: ({}, {}) 不在电子围栏区域内，已更新为测试点位",
|
xpPoint.getId(), pointLon, pointLat);
|
UpdateWrapper<XpPoint> xpPointUpdateWrapper = new UpdateWrapper<>();
|
xpPointUpdateWrapper.eq("id", xpPoint.getId());
|
xpPointUpdateWrapper.set("point_type", 2);
|
xpPointMapper.update(xpPoint, xpPointUpdateWrapper);
|
}
|
}
|
}
|
}
|
}
|
}
|
// 围栏从已停用(3)改为启用中(2)时：同步启用点位需校验点位在运营区内且不在禁行区内
|
Integer newFenceStatus = xpElectronicFence.getStatus();
|
if (status != null && status == 3 && newFenceStatus != null && newFenceStatus == 2) {
|
XpElectronicFenceArea operationAreaToEnable = xpElectronicFenceAreaService.lambdaQuery()
|
.eq(XpElectronicFenceArea::getElectronicId, dto.getId())
|
.eq(XpElectronicFenceArea::getAreaType, 1)
|
.orderByDesc(XpElectronicFenceArea::getId)
|
.last("limit 1")
|
.one();
|
if (operationAreaToEnable == null || operationAreaToEnable.getId() == null) {
|
log.warn("围栏启用同步启用点位跳过：未查询到运营区 fenceId={}", dto.getId());
|
} else {
|
Long operationAreaIdToEnable = operationAreaToEnable.getId();
|
LambdaQueryWrapper<XpPoint> pendingEnableQuery = new LambdaQueryWrapper<>();
|
pendingEnableQuery.eq(XpPoint::getElectronicAreaId, operationAreaIdToEnable)
|
.eq(XpPoint::getPointType, 1)
|
.eq(XpPoint::getOperationStatus, 3);
|
List<XpPoint> pendingEnablePoints = xpPointMapper.selectList(pendingEnableQuery);
|
int pendingCount = pendingEnablePoints == null ? 0 : pendingEnablePoints.size();
|
if (pendingCount == 0) {
|
log.info("围栏启用同步启用点位：无待启用点位 fenceId={}, operationAreaId={}", dto.getId(), operationAreaIdToEnable);
|
} else {
|
String fenceId = String.valueOf(dto.getId());
|
List<Long> enableIds = new ArrayList<>();
|
for (XpPoint pointItem : pendingEnablePoints) {
|
if (pointItem == null || pointItem.getId() == null) {
|
continue;
|
}
|
Double lon = pointItem.getPointLon();
|
Double lat = pointItem.getPointLat();
|
if (lon == null || lat == null) {
|
continue;
|
}
|
try {
|
boolean inOperatingArea = xpGeoFencingPolygonService.isInFence(lon, lat, fenceId, "operating_area");
|
if (!inOperatingArea) {
|
continue;
|
}
|
boolean inProhibitedArea = xpGeoFencingPolygonService.isInFence(lon, lat, fenceId, "prohibited_area");
|
if (inProhibitedArea) {
|
continue;
|
}
|
} catch (Exception e) {
|
log.error("围栏启用同步启用点位校验失败 fenceId={}, pointId={}", dto.getId(), pointItem.getId(), e);
|
throw new ServiceException("系统异常", I18nKeyConstant.SYSTEM_EXCEPTION);
|
}
|
enableIds.add(pointItem.getId());
|
}
|
if (CollUtil.isNotEmpty(enableIds)) {
|
xpPointService.lambdaUpdate()
|
.in(XpPoint::getId, enableIds)
|
.eq(XpPoint::getOperationStatus, 3)
|
.set(XpPoint::getOperationStatus, 2)
|
.update();
|
}
|
log.info("围栏启用同步启用点位完成 fenceId={}, pendingCount={}, enableCount={}, skipCount={}",
|
dto.getId(), pendingCount, enableIds.size(), Math.max(0, pendingCount - enableIds.size()));
|
}
|
}
|
}
|
|
// 围栏改为已停用(3)时：将围栏下启用中点位(operation_status=2)更新为已停用(operation_status=3)
|
if (newFenceStatus != null && newFenceStatus == 3) {
|
XpElectronicFenceArea operationAreaToDisable = xpElectronicFenceAreaService.lambdaQuery()
|
.eq(XpElectronicFenceArea::getElectronicId, dto.getId())
|
.eq(XpElectronicFenceArea::getAreaType, 1)
|
.orderByDesc(XpElectronicFenceArea::getId)
|
.last("limit 1")
|
.one();
|
if (operationAreaToDisable == null || operationAreaToDisable.getId() == null) {
|
log.warn("围栏停用同步停用点位跳过：未查询到运营区 fenceId={}", dto.getId());
|
} else {
|
Long operationAreaIdToDisable = operationAreaToDisable.getId();
|
boolean updated = xpPointService.lambdaUpdate()
|
.eq(XpPoint::getElectronicAreaId, operationAreaIdToDisable)
|
.eq(XpPoint::getPointType, 1)
|
.eq(XpPoint::getOperationStatus, 2)
|
.set(XpPoint::getOperationStatus, 3)
|
.update();
|
log.info("围栏停用同步停用点位完成 fenceId={}, operationAreaId={}, updated={}",
|
dto.getId(), operationAreaIdToDisable, updated);
|
}
|
}
|
|
OperationStrategyIndex oldIndex = OperationStrategyIndex.parse(oldOperationStrategy);
|
OperationStrategyIndex newIndex = OperationStrategyIndex.parse(newOperationStrategy);
|
boolean needAutoDisableByUnion = !oldIndex.equalsNormalized(newIndex);
|
List<Long> addPointIds = normalizePointIds(dto.getAddPointIdList());
|
List<Long> delPointIds = normalizePointIds(dto.getDelPointIdList());
|
List<Long> disablePointIds = normalizePointIds(dto.getDisablePointIdList());
|
boolean needPointHandling = CollUtil.isNotEmpty(addPointIds)
|
|| CollUtil.isNotEmpty(delPointIds)
|
|| CollUtil.isNotEmpty(disablePointIds);
|
boolean needFenceAreaIds = needPointHandling || needAutoDisableByUnion;
|
XpElectronicFenceArea operationArea = xpElectronicFenceAreaService.lambdaQuery()
|
.eq(XpElectronicFenceArea::getElectronicId, dto.getId())
|
.eq(XpElectronicFenceArea::getAreaType, 1)
|
.orderByDesc(XpElectronicFenceArea::getId)
|
.last("limit 1")
|
.one();
|
Long operationAreaId = operationArea == null ? null : operationArea.getId();
|
if (needPointHandling && operationAreaId == null) {
|
throw new ServiceException("运营区域不存在", I18nKeyConstant.POINT_ELECTRONIC_AREA_NOT_EXIST);
|
}
|
|
if (CollUtil.isNotEmpty(addPointIds)) {
|
if (operationAreaId == null) {
|
throw new ServiceException("运营区域不存在", I18nKeyConstant.POINT_ELECTRONIC_AREA_NOT_EXIST);
|
}
|
xpPointService.lambdaUpdate()
|
.in(XpPoint::getId, addPointIds)
|
.set(XpPoint::getElectronicAreaId, operationAreaId)
|
.set(XpPoint::getVerificationStatus, 1)
|
.update();
|
}
|
|
if (CollUtil.isNotEmpty(disablePointIds)) {
|
// operation_status: 3=已停用
|
xpPointService.lambdaUpdate()
|
.in(XpPoint::getId, disablePointIds)
|
.eq(XpPoint::getElectronicAreaId, operationAreaId)
|
.set(XpPoint::getOperationStatus, 3)
|
.update();
|
}
|
|
if (CollUtil.isNotEmpty(delPointIds)) {
|
// operation_status: 4=已失效
|
xpPointService.lambdaUpdate()
|
.in(XpPoint::getId, delPointIds)
|
.eq(XpPoint::getElectronicAreaId, operationAreaId)
|
.set(XpPoint::getOperationStatus, 4)
|
.update();
|
}
|
|
// 围栏运营时间缩短校验：若缩短后点位时间段不在新范围内，则更新为已停用(operation_status=3)
|
if (true) {
|
LambdaQueryWrapper<XpPoint> pointQuery = new LambdaQueryWrapper<>();
|
pointQuery.eq(XpPoint::getElectronicAreaId, operationAreaId)
|
.eq(XpPoint::getPointType, 1)
|
.eq(XpPoint::getOperationType, 2);
|
List<XpPoint> points = xpPointMapper.selectList(pointQuery);
|
if (points != null && !points.isEmpty()) {
|
List<Long> disablePointIdList = new ArrayList<>();
|
for (XpPoint pointItem : points) {
|
if (pointItem == null) {
|
continue;
|
}
|
if (pointItem.getOperationStatus() != null && pointItem.getOperationStatus() == 4) {
|
continue;
|
}
|
String effectiveTimePeriod = pointItem.getEffectiveTimePeriod();
|
if (effectiveTimePeriod == null || effectiveTimePeriod.isEmpty()) {
|
continue;
|
}
|
List<OperationStrategyIndex.TimeInterval> pointIntervals = OperationStrategyIndex.parsePointEffectiveTimePeriod(effectiveTimePeriod);
|
if (pointIntervals.isEmpty()) {
|
continue;
|
}
|
boolean shouldDisable = !newIndex.isPointScheduleWithin(pointIntervals);
|
if (shouldDisable && pointItem.getId() != null) {
|
disablePointIdList.add(pointItem.getId());
|
}
|
}
|
if (!disablePointIdList.isEmpty()) {
|
for (Long l : disablePointIdList) {
|
XpPoint xpPoint = xpPointMapper.selectById(l);
|
if(xpPoint.getOperationStatus()!=4){
|
xpPoint.setOperationStatus(3);
|
xpPoint.setVerificationStatus(5);
|
xpPointMapper.updateById(xpPoint);
|
}
|
|
}
|
}
|
}
|
}
|
// 发布围栏变更事件，事务提交后异步触发 ADC 推送
|
applicationEventPublisher.publishEvent(
|
new FenceChangedEvent(this, xpElectronicFence.getId(), xpElectronicFence.getStatus()));
|
return R.ok();
|
|
}
|
|
@Override
|
public void validateElectronicNameUnique(String electronicName, Long excludeId) {
|
if (!StringUtils.hasText(electronicName)) {
|
return;
|
}
|
long count = this.lambdaQuery()
|
.eq(XpElectronicFence::getElectronicName, electronicName)
|
.ne(excludeId != null, XpElectronicFence::getId, excludeId)
|
.count();
|
if (count > 0) {
|
throw new ServiceException("围栏名称已存在", I18nKeyConstant.FENCE_NAME_EXISTS);
|
}
|
}
|
|
private static List<Long> normalizePointIds(List<Long> ids) {
|
if (CollUtil.isEmpty(ids)) {
|
return Collections.emptyList();
|
}
|
return ids.stream().filter(Objects::nonNull).distinct().collect(Collectors.toList());
|
}
|
|
private int resolveFenceStatus(Integer requestedStatus, Integer effectType, LocalDateTime effectTime, LocalDateTime now) {
|
if (requestedStatus == null) {
|
return 0;
|
}
|
if (requestedStatus == 0) {
|
return 0;
|
}
|
if (requestedStatus == 3) {
|
return 3;
|
}
|
if (effectType != null && effectType == 1) {
|
return 2;
|
}
|
if (effectTime != null && !effectTime.isAfter(now)) {
|
return 2;
|
}
|
return 1;
|
}
|
|
private void registerEffectJobIfNeeded(Long electronicId, Integer targetStatus, Integer effectType,
|
LocalDateTime effectTime, LocalDateTime now) {
|
QuartzManager.removeJob((ElectronicEffectJob.effect + electronicId).toUpperCase(), TimeJobType.ELECTRONIC_EFFECT);
|
if (targetStatus != 1 || effectType == null || effectType == 1 || effectTime == null || !effectTime.isAfter(now)) {
|
return;
|
}
|
Map<String, ? extends Object> effectMaps =
|
new ImmutableMap.Builder<String, Long>()
|
.put("type", 1L)
|
.put("id", electronicId)
|
.build();
|
QuartzManager.addJob(
|
ElectronicEffectJob.class,
|
(ElectronicEffectJob.effect + electronicId).toUpperCase(),
|
TimeJobType.ELECTRONIC_EFFECT,
|
DateUtils.localDateTimeToDate(effectTime),
|
effectMaps
|
);
|
}
|
|
/**
|
* 失效
|
* @param electronicId
|
* @param failureType
|
* @param failureTime
|
* @param now
|
*/
|
private void registerFailureJobIfNeeded(Long electronicId, Integer failureType, LocalDateTime failureTime, LocalDateTime now) {
|
QuartzManager.removeJob((ElectronicEffectJob.failure + electronicId).toUpperCase(), TimeJobType.ELECTRONIC_FAILURE);
|
if (failureType == null || failureType != 2 || failureTime == null || failureTime.isBefore(now)) {
|
return;
|
}
|
Map<String, ? extends Object> failureMaps =
|
new ImmutableMap.Builder<String, Long>()
|
.put("type", 2L)
|
.put("id", electronicId)
|
.build();
|
QuartzManager.addJob(
|
ElectronicEffectJob.class,
|
(ElectronicEffectJob.failure + electronicId).toUpperCase(),
|
TimeJobType.ELECTRONIC_FAILURE,
|
DateUtils.localDateTimeToDate(failureTime),
|
failureMaps
|
);
|
}
|
|
/**
|
* 判断点是否在多边形内
|
*
|
* @param fencePointsStr 多边形顶点字符串，格式：经度_维度,经度_维度
|
* @param pointLon 待检测点的经度
|
* @param pointLat 待检测点的纬度
|
* @return true表示在多边形内，false表示在多边形外
|
*/
|
private boolean isPointInPolygon(String fencePointsStr, double pointLon, double pointLat) {
|
if (fencePointsStr == null || fencePointsStr.trim().isEmpty()) {
|
return false;
|
}
|
|
// 解析多边形顶点
|
String[] pointPairs = fencePointsStr.split(",");
|
List<double[]> polygonVertices = new ArrayList<>();
|
|
for (String pointPair : pointPairs) {
|
String[] lngLat = pointPair.trim().split("_");
|
if (lngLat.length >= 2) {
|
try {
|
double longitude = Double.parseDouble(lngLat[0]);
|
double latitude = Double.parseDouble(lngLat[1]);
|
polygonVertices.add(new double[]{longitude, latitude});
|
} catch (NumberFormatException e) {
|
log.error("解析多边形顶点坐标失败: {}", pointPair, e);
|
return false;
|
}
|
}
|
}
|
|
if (polygonVertices.size() < 3) {
|
return false; // 至少需要3个点才能构成多边形
|
}
|
|
return isPointInPolygon(polygonVertices, pointLon, pointLat);
|
}
|
|
/**
|
* 使用射线法判断点是否在多边形内
|
*
|
* @param polygonVertices 多边形顶点列表
|
* @param pointLon 待检测点的经度
|
* @param pointLat 待检测点的纬度
|
* @return true表示在多边形内，false表示在多边形外
|
*/
|
private boolean isPointInPolygon(List<double[]> polygonVertices, double pointLon, double pointLat) {
|
int n = polygonVertices.size();
|
boolean inside = false;
|
|
// 射线法判断点是否在多边形内
|
double x = pointLon, y = pointLat;
|
|
for (int i = 0, j = n - 1; i < n; j = i++) {
|
double xi = polygonVertices.get(i)[0], yi = polygonVertices.get(i)[1];
|
double xj = polygonVertices.get(j)[0], yj = polygonVertices.get(j)[1];
|
|
// 判断当前边是否与水平射线相交
|
boolean intersect = ((yi > y) != (yj > y)) &&
|
(x < (xj - xi) * (y - yi) / (yj - yi) + xi);
|
|
if (intersect) {
|
inside = !inside;
|
}
|
}
|
|
return inside;
|
}
|
|
/**
|
* 将围栏点字符串转换为GeoJsonPolygon
|
* 格式：经度_维度,经度_维度
|
*/
|
@Override
|
public GeoJsonPolygon convertToGeoJsonPolygon(String fencePointsStr) {
|
if (fencePointsStr == null || fencePointsStr.trim().isEmpty()) {
|
return null;
|
}
|
|
// 分割多个点对
|
String[] pointPairs = fencePointsStr.split(",");
|
List<Point> points = new ArrayList<>();
|
|
for (String pointPair : pointPairs) {
|
String[] lngLat = pointPair.trim().split("_");
|
if (lngLat.length >= 2) {
|
try {
|
double longitude = Double.parseDouble(lngLat[0]);
|
double latitude = Double.parseDouble(lngLat[1]);
|
points.add(new Point(longitude, latitude)); // Point 构造函数是 (x, y) -> (longitude, latitude)
|
} catch (NumberFormatException e) {
|
log.error("解析经纬度坐标失败: {}", pointPair, e);
|
throw new IllegalArgumentException("经纬度格式错误: " + pointPair);
|
}
|
}
|
}
|
|
// 如果没有足够的点构成多边形，至少需要3个点
|
if (points.size() < 3) {
|
throw new IllegalArgumentException("围栏点数量不足，至少需要3个点构成多边形");
|
}
|
|
// 确保多边形是闭合的（如果最后一个点不等于第一个点，则添加第一个点）
|
if (!points.get(0).equals(points.get(points.size() - 1))) {
|
points.add(points.get(0)); // 添加第一个点作为最后一个点，闭合多边形
|
}
|
|
return new GeoJsonPolygon(points);
|
}
|
|
/**
|
* 检查新添加的区域之间是否有重叠
|
*/
|
private boolean hasOverlapWithinNewAreas(List<XpElectronicFenceArea> newAreas) {
|
for (int i = 0; i < newAreas.size(); i++) {
|
XpElectronicFenceArea area1 = newAreas.get(i);
|
if (area1.getAreaType() != 1) continue; // 只检查运营区域
|
|
for (int j = i + 1; j < newAreas.size(); j++) {
|
XpElectronicFenceArea area2 = newAreas.get(j);
|
if (area2.getAreaType() == 1) {
|
if (polygonOverlapService.checkPolygonOverlap(
|
area1.getFencePoints(),
|
area2.getFencePoints())) {
|
return true;
|
}
|
}
|
}
|
}
|
return false;
|
}
|
|
/**
|
* @return
|
*/
|
@Override
|
public List<XpElectronicFence> getAvailableList() {
|
return lambdaQuery().eq(XpElectronicFence::getStatus, 2).list(); //查询已启用的围栏
|
}
|
|
@Override
|
public List<XpElectronicFence> getList(ElectronicPageListQuery query) {
|
LambdaQueryWrapper<XpElectronicFence> queryWrapper = new LambdaQueryWrapper<>();
|
queryWrapper.like(query.getCityCode() != null, XpElectronicFence::getCityCode, query.getCityCode());
|
return list(queryWrapper);
|
}
|
|
@Override
|
@Transactional
|
@ShardingSphereTransactionType(TransactionType.BASE)
|
public void expireFence(Long electronicId) {
|
if (electronicId == null) {
|
return;
|
}
|
XpElectronicFence electronicFence = this.getById(electronicId);
|
if (electronicFence == null || electronicFence.getStatus() == null) {
|
return;
|
}
|
Integer status = electronicFence.getStatus();
|
if (status != 1 && status != 2) {
|
return;
|
}
|
electronicFence.setStatus(3);
|
this.updateById(electronicFence);
|
|
List<XpElectronicFenceArea> electronicFenceAreaList = xpElectronicFenceAreaService.lambdaQuery()
|
.eq(XpElectronicFenceArea::getElectronicId, electronicId)
|
.list();
|
if (CollUtil.isEmpty(electronicFenceAreaList)) {
|
return;
|
}
|
for (XpElectronicFenceArea electronicFenceArea : electronicFenceAreaList) {
|
electronicFenceArea.setAreaStatus(2);
|
}
|
xpElectronicFenceAreaService.updateBatchById(electronicFenceAreaList);
|
}
|
|
|
/**
|
* 计算围栏中心点
|
*
|
* @param coordinates
|
* @return
|
*/
|
private org.locationtech.jts.geom.Point calculateCentroid(Coordinate[] coordinates) {
|
// 1. 判空校验
|
if (coordinates == null || coordinates.length == 0) {
|
throw new ServiceException("坐标数组不能为空");
|
}
|
|
// 2. 过滤掉 null 坐标点
|
Coordinate[] validCoords = Arrays.stream(coordinates)
|
.filter(Objects::nonNull)
|
.toArray(Coordinate[]::new);
|
|
// 3. LinearRing 至少需要 4 个点（首尾相同），且必须闭合
|
if (validCoords.length < 4) {
|
throw new ServiceException("有效坐标点不足，至少需要4个点");
|
}
|
|
// 4. 确保首尾坐标相同（闭合）
|
Coordinate first = validCoords[0];
|
Coordinate last = validCoords[validCoords.length - 1];
|
if (!first.equals2D(last)) {
|
// 自动补上闭合点
|
validCoords = Arrays.copyOf(validCoords, validCoords.length + 1);
|
validCoords[validCoords.length - 1] = new Coordinate(first.x, first.y);
|
}
|
|
GeometryFactory factory = new GeometryFactory();
|
LinearRing ring = factory.createLinearRing(validCoords);
|
Polygon polygon = factory.createPolygon(ring);
|
org.locationtech.jts.geom.Point centroid = polygon.getCentroid();
|
System.out.println("中心点经度: " + centroid.getX());
|
System.out.println("中心点纬度: " + centroid.getY());
|
return centroid;
|
}
|
}
|
