后端调用arcgis服务实现图形的编辑、删除、分割、操作回退功能

package com.dzp.gistest.service;

import com.fasterxml.jackson.databind.JsonNode;
import com.google.common.base.Joiner;
import com.dzp.gistest.core.exceptions.BussinessException;
import com.dzp.gistest.core.exceptions.GlobalException;
import com.dzp.gistest.ghjc.common.model.*;
import com.dzp.gistest.ghjc.common.service.*;
import com.dzp.gistest.ArcgisQueryUtils;
import com.dzp.gistest.vo.ArcgisEditParam;
import com.dzp.gistest.vo.ArcgisEditResponse;
import com.dzp.gistest.EditType;
import com.dzp.gistest.LayerNameEnum;
import com.dzp.gistest.constants.ArcgisConfig;
import com.dzp.gistest.constants.FeatureOperationLogResultEnum;
import com.dzp.gistest.constants.OperateDataSourceEnum;
import com.dzp.gistest.repository.FeatureOperationRecordRepository;
import com.dzp.gistest.service.FeatureOperationRecordService;
import com.dzp.gistest.vo.*;
import com.dzp.gistest.utils.jackson.JacksonUtils;
import com.dzp.gistest.utils.spring.BeanUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;


@Service
@Slf4j
public class FeatureOperationRecordServiceImpl implements FeatureOperationRecordService {
    /**
     * featureOperationLog. 业务操作服务.
     */
    @Resource
    FeatureOperationRecordRepository featureoperationlogRepository;
    /**
     * 图形操作日志表(FeatureOperationLog)业务操作服务.
     */
    @Resource
    FeatureOperationLogService featureOperationLogService;
    /**
     * 图形记录表(OperationGeometryLog)业务操作服务.
     */
    @Resource
    OperationGeometryLogService operationGeometryLogService;
    @Resource
    ArcgisConfig arcgisConfig;
    


    

    

	/**
     * 保存新增要素操作记录
     *
     * @param editType
     * @param featureClassName
     * @param gisFeature
     * @return
     */
    private void saveAddFeatureOperationLog(String featureClassName, GisFeature gisFeature, OperateDataSourceEnum dataSourceEnum) {
        FeatureOperationLog featureOperationLog = createFeatureOperationLog(EditType.ADD, featureClassName, gisFeature, dataSourceEnum);
        FeatureOperationLog operationLog = featureOperationLogService.saveOrUpdate(featureOperationLog);
        OperationGeometryLog operationGeometryLog = createOperationGeometryLog(EditType.ADD, featureClassName, operationLog.getId(), gisFeature);
        operationGeometryLogService.save(operationGeometryLog);
    }

    /**
     * 创建要素操作记录
     *
     * @param editType
     * @param featureClassName
     * @param gisFeature
     * @return
     */
    private FeatureOperationLog createFeatureOperationLog(EditType editType, String featureClassName, GisFeature gisFeature, OperateDataSourceEnum dataSourceEnum) {
        LayerNameEnum layerNameEnum = LayerNameEnum.getEnumByLayerName(featureClassName);
        FeatureOperationLog featureOperationLog = new FeatureOperationLog();
        featureOperationLog.setEditType(editType.getCode());
        featureOperationLog.setTableName(featureClassName);
        featureOperationLog.setDataSource(dataSourceEnum.getCode());
        Object code = gisFeature.getProperties().get(layerNameEnum.getFieldCode());
        if (code != null) {
            featureOperationLog.setCode(code + "");
        }
        Object name = gisFeature.getProperties().get(layerNameEnum.getFieldName());
        if (name != null) {
            featureOperationLog.setName(name + "");
        }
        return featureOperationLog;
    }

    /**
     * 创建要素操作记录
     *
     * @param editType
     * @param featureClassName
     * @param jsonNode
     * @return
     */
    private FeatureOperationLog createFeatureOperationLog(EditType editType, String featureClassName, JsonNode jsonNode, OperateDataSourceEnum dataSourceEnum) {
        LayerNameEnum layerNameEnum = LayerNameEnum.getEnumByLayerName(featureClassName);
        FeatureOperationLog featureOperationLog = new FeatureOperationLog();
        featureOperationLog.setEditType(editType.getCode());
        featureOperationLog.setTableName(featureClassName);
        featureOperationLog.setDataSource(dataSourceEnum.getCode());
        JsonNode attributes = jsonNode.get("attributes");
        if (attributes.get(layerNameEnum.getFieldCode()) != null) {
            featureOperationLog.setCode(attributes.get(layerNameEnum.getFieldCode()).asText());
        }
        if (attributes.get(layerNameEnum.getFieldName()) != null) {
            featureOperationLog.setName(attributes.get(layerNameEnum.getFieldName()).asText());
        }
        return featureOperationLog;
    }

    /**
     * 创建要素操作记录明细
     *
     * @return
     */
    private OperationGeometryLog createOperationGeometryLog(EditType editType, String featureClassName, String operationId, GisFeature gisFeature) {
        Map attributes = gisFeature.getProperties();
        OperationGeometryLog operationGeometryLog = new OperationGeometryLog();
        operationGeometryLog.setEditType(editType.getCode());
        operationGeometryLog.setOperationId(operationId);
        LayerNameEnum layerNameEnum = LayerNameEnum.getEnumByLayerName(featureClassName);
        operationGeometryLog.setGeometry(gisFeature.getWktGeometry());
        operationGeometryLog.setAttributes(JacksonUtils.objectToJson(attributes));
        Object code = gisFeature.getProperties().get(layerNameEnum.getFieldCode());
        if (code != null) {
            operationGeometryLog.setCode(code + "");
        }
        Object name = gisFeature.getProperties().get(layerNameEnum.getFieldName());
        if (name != null) {
            operationGeometryLog.setName(name + "");
        }
        return operationGeometryLog;
    }

    /**
     * 创建要素操作记录明细
     *
     * @return
     */
    private OperationGeometryLog createOperationGeometryLog(EditType editType, String featureClassName, String operationId, JsonNode jsonNode) {
        JsonNode attributes = jsonNode.get("attributes");
        OperationGeometryLog operationGeometryLog = new OperationGeometryLog();
        operationGeometryLog.setEditType(editType.getCode());
        operationGeometryLog.setOperationId(operationId);
        LayerNameEnum layerNameEnum = LayerNameEnum.getEnumByLayerName(featureClassName);
        operationGeometryLog.setGeometry(ArcgisQueryUtils.esriGeometryToWkt(jsonNode.get("geometry")));
        operationGeometryLog.setAttributes(JacksonUtils.objectToJson(attributes));
        JsonNode code = attributes.get(layerNameEnum.getFieldCode());
        if (code != null) {
            operationGeometryLog.setCode(code.asText());
        }
        JsonNode name = attributes.get(layerNameEnum.getFieldName());
        if (name != null) {
            operationGeometryLog.setName(name.asText());
        }
        return operationGeometryLog;
    }


    
    public ArcgisEditResponse addFeature(String featureClassName, GisFeature gisFeature, OperateDataSourceEnum dataSourceEnum) {
        if (StringUtils.isEmpty(featureClassName)) {
            throw new BussinessException("-1", "目标图层不能为空!");
        }
        String url = arcgisConfig.getFeatureRequestUrl(featureClassName);
        Map esriGeometry = ArcgisQueryUtils.wktToEsriGeometryJson(gisFeature.getWktGeometry());
        Map<String, Object> param = new HashMap<>();
        param.put("geometry", esriGeometry);
        param.put("attributes", gisFeature.getProperties());
        ArcgisEditParam arcgisEditParam = new ArcgisEditParam();
        List list = Arrays.asList(param);
        arcgisEditParam.setAdds(JacksonUtils.objectToJson(list));
        ArcgisEditResponse response = ArcgisQueryUtils.sendEditRequest(url, arcgisEditParam);
        saveAddFeatureOperationLog(featureClassName, gisFeature, dataSourceEnum);
        return response;
    }


    
    public ArcgisEditResponse addFeatures(String featureClassName, List<GisFeature> gisFeatures, OperateDataSourceEnum dataSourceEnum) {
        ArcgisEditResponse response = null;
        for (GisFeature gisFeature : gisFeatures) {
            response = addFeature(featureClassName, gisFeature, dataSourceEnum);
        }
        return response;
    }

    
    public ArcgisEditResponse deleteFeature(String featureClassName, String uuid, OperateDataSourceEnum dataSourceEnum) throws Exception {
        if (StringUtils.isEmpty(featureClassName)) {
            throw new BussinessException("-1", "目标图层不能为空!");
        }
        if (StringUtils.isEmpty(uuid)) {
            throw new BussinessException("-1", "参数不能为空");
        }
        LayerNameEnum layerNameEnum = LayerNameEnum.getEnumByLayerName(featureClassName);
        JsonNode jsonNode = ArcgisQueryUtils.queryByObjectids(arcgisConfig.getMapRequestUrl(featureClassName), uuid);
        //1、删除属性相关数据
        if (featureClassName.equals(LayerNameEnum.FWM.getLayerName())) {
            String code = jsonNode.get("features").get(0).get("attributes").get(layerNameEnum.getFieldCode()).asText();
            //删除属性表数据,自然幢、逻辑幢、房屋相关联属性表数据
            deleteRelationZrzInfo(code);
        }
        Map<String, Object> arcgisEditParam = new HashMap<>();
        arcgisEditParam.put("adds", jsonNode.get("features"));
        //2、图形入历史表
        ArcgisEditResponse addResponse = ArcgisQueryUtils.sendEditRequest(arcgisConfig.getFeatureRequestUrl(layerNameEnum.getLsLayerName()), arcgisEditParam);
        if (!addResponse.getAddResults().get(0).isSuccess()) {
            throw new BussinessException("-1", "gis请求处理失败");
        }
        //3、删除图形
        arcgisEditParam = new HashMap<>();
        arcgisEditParam.put("deletes", uuid);
        ArcgisEditResponse delResponse = ArcgisQueryUtils.sendEditRequest(arcgisConfig.getFeatureRequestUrl(featureClassName), arcgisEditParam);
        if (!delResponse.getDeleteResults().get(0).isSuccess()) {
            throw new BussinessException("-1", "gis请求处理失败");
        }
        //4、记录删除操作记录
        saveDelFeatureOperationLog(jsonNode.get("features").get(0), featureClassName, dataSourceEnum);
        return delResponse;
    }

    /**
     * 删除关联自然幢属性数据
     *
     * @param zrzcode
     */
    private void deleteRelationZrzInfo(String zrzcode) {
        
    }


    private void saveDelFeatureOperationLog(JsonNode delJsonNode, String featureClassName, OperateDataSourceEnum dataSourceEnum) {
        FeatureOperationLog featureOperationLog = createFeatureOperationLog(EditType.DEL, featureClassName, delJsonNode, dataSourceEnum);
        FeatureOperationLog operationLog = featureOperationLogService.save(featureOperationLog);
        OperationGeometryLog operationGeometryLog = createOperationGeometryLog(EditType.DEL, featureClassName, operationLog.getId(), delJsonNode);
        operationGeometryLogService.save(operationGeometryLog);
    }


    
    public ArcgisEditResponse deleteFeatures(String featureClassName, List<String> uuids, OperateDataSourceEnum dataSourceEnum) throws Exception {
        ArcgisEditResponse response = null;
        for (String uuid : uuids) {
            response = deleteFeature(featureClassName, uuid, dataSourceEnum);
        }
        return response;
    }

    
    public ArcgisEditResponse updateFeature(String featureClassName, GisFeature gisFeature, OperateDataSourceEnum dataSourceEnum) throws Exception {
        if (StringUtils.isEmpty(featureClassName)) {
            throw new BussinessException("-1", "目标图层不能为空!");
        }
        if (StringUtils.isEmpty(gisFeature.getUuid())) {
            throw new BussinessException("-1", "参数不能为空");
        }
        if (StringUtils.isEmpty(gisFeature.getWktGeometry())) {
            throw new BussinessException("-1", "参数不能为空");
        }
        JsonNode jsonNode = ArcgisQueryUtils.queryByObjectids(arcgisConfig.getMapRequestUrl(featureClassName), gisFeature.getUuid());
        Map<String, Object> arcgisEditParam = new HashMap<>();
        JsonNode features = jsonNode.get("features");
        arcgisEditParam.put("adds", features);
        //将需要更新的数据,写入历史表
        ArcgisEditResponse addResponse = ArcgisQueryUtils.sendEditRequest(arcgisConfig.getFeatureRequestUrl(LayerNameEnum.getEnumByLayerName(featureClassName).getLsLayerName()), arcgisEditParam);
        if (!addResponse.getAddResults().get(0).isSuccess()) {
            throw new BussinessException("-1", "gis请求处理失败");
        }
        //然后更新
        List<HashMap> list = JacksonUtils.jsonToList(JacksonUtils.objectToJson(features), HashMap.class);
        for (HashMap map : list) {
            map.put("geometry", ArcgisQueryUtils.wktToEsriGeometryJson(gisFeature.getWktGeometry()));
        }
        arcgisEditParam = new HashMap<>();
        arcgisEditParam.put("updates", list);
        ArcgisEditResponse updateResponse = ArcgisQueryUtils.sendEditRequest(arcgisConfig.getFeatureRequestUrl(LayerNameEnum.getEnumByLayerName(featureClassName).getLayerName()), arcgisEditParam);
        if (!updateResponse.getUpdateResults().get(0).isSuccess()) {
            throw new BussinessException("-1", "gis请求处理失败");
        }
        saveUpdateFeatureOperationLog(features.get(0), featureClassName, gisFeature, dataSourceEnum);
        return updateResponse;
    }

    private void saveUpdateFeatureOperationLog(JsonNode delFeature, String featureClassName, GisFeature addGisFeature, OperateDataSourceEnum dataSourceEnum) {
        FeatureOperationLog featureOperationLog = createFeatureOperationLog(EditType.UPDATE, featureClassName, delFeature, dataSourceEnum);
        FeatureOperationLog operationLog = featureOperationLogService.saveOrUpdate(featureOperationLog);
        List<OperationGeometryLog> logs = new ArrayList<>();
        //记录日志
        //删除的
        OperationGeometryLog operationGeometryLog = createOperationGeometryLog(EditType.DEL, featureClassName, operationLog.getId(), delFeature);
        logs.add(operationGeometryLog);
        //新增的
        operationGeometryLog = createOperationGeometryLog(EditType.ADD, featureClassName, operationLog.getId(), addGisFeature);
        logs.add(operationGeometryLog);
        operationGeometryLogService.saveAll(logs);
    }

    
    public ArcgisEditResponse updateFeatures(String featureClassName, List<GisFeature> gisFeatures, OperateDataSourceEnum dataSourceEnum) throws Exception {
        ArcgisEditResponse response = null;
        for (GisFeature gisFeature : gisFeatures) {
            response = updateFeature(featureClassName, gisFeature, dataSourceEnum);
        }
        return response;
    }

    /**
     * 分割图形
     *
     * @param featureClassName 目标图层名称
     * @param uuid             分割的图形id
     * @param gisFeatures      分割出的图形信息
     * @return
     */
    
    public ArcgisEditResponse clipFeatures(String featureClassName, String uuid, List<GisFeature> gisFeatures, OperateDataSourceEnum dataSourceEnum) throws Exception {
        JsonNode jsonNode = ArcgisQueryUtils.queryByObjectids(arcgisConfig.getMapRequestUrl(featureClassName), uuid);
        Map<String, Object> arcgisEditParam = new HashMap<>();
        arcgisEditParam.put("adds", jsonNode.get("features"));
        //将需要删除的数据,写入历史表
        ArcgisEditResponse addResponse = ArcgisQueryUtils.sendEditRequest(arcgisConfig.getFeatureRequestUrl(LayerNameEnum.getEnumByLayerName(featureClassName).getLsLayerName()), arcgisEditParam);
        if (!addResponse.getAddResults().get(0).isSuccess()) {
            throw new BussinessException("-1", "gis请求处理失败");
        }
        arcgisEditParam = new HashMap<>();
        //删除
        arcgisEditParam.put("deletes", uuid);
        List<Map> adds = new ArrayList<>();
        for (GisFeature gisFeature : gisFeatures) {
            //写入分割后的图形
            Map esriGeometry = ArcgisQueryUtils.wktToEsriGeometryJson(gisFeature.getWktGeometry());
            Map<String, Object> param = new HashMap<>();
            param.put("geometry", esriGeometry);
            param.put("attributes", gisFeature.getProperties());
            adds.add(param);
        }
        arcgisEditParam.put("adds", adds);
        ArcgisEditResponse response = ArcgisQueryUtils.sendEditRequest(arcgisConfig.getFeatureRequestUrl(featureClassName), arcgisEditParam);
        if (!response.getDeleteResults().get(0).isSuccess()) {
            throw new BussinessException("-1", "gis请求处理失败");
        }
        saveClipFeatureOperationLog(featureClassName, jsonNode.get("features").get(0), gisFeatures, dataSourceEnum);
        return response;
    }

    private void saveClipFeatureOperationLog(String featureClassName, JsonNode delJsonNode, List<GisFeature> addGisFeatures, OperateDataSourceEnum dataSourceEnum) {
        FeatureOperationLog featureOperationLog = createFeatureOperationLog(EditType.CLIP, featureClassName, delJsonNode, dataSourceEnum);
        FeatureOperationLog operationLog = featureOperationLogService.saveOrUpdate(featureOperationLog);
        List<OperationGeometryLog> logs = new ArrayList<>();
        //记录日志
        addGisFeatures.forEach(gisFeature -> {
            OperationGeometryLog operationGeometryLog = createOperationGeometryLog(EditType.ADD, featureClassName, operationLog.getId(), gisFeature);
            logs.add(operationGeometryLog);
        });
        OperationGeometryLog operationGeometryLog = createOperationGeometryLog(EditType.DEL, featureClassName, operationLog.getId(), delJsonNode);
        logs.add(operationGeometryLog);
        operationGeometryLogService.saveAll(logs);
    }

    
    public ArcgisEditResponse mergeFeatures(String featureClassName, List<String> uuids, GisFeature gisFeature, OperateDataSourceEnum dataSourceEnum) throws Exception {
        JsonNode jsonNode = ArcgisQueryUtils.queryByObjectids(arcgisConfig.getMapRequestUrl(featureClassName), Joiner.on(",").join(uuids));
        Map<String, Object> arcgisEditParam = new HashMap<>();
        arcgisEditParam.put("adds", jsonNode.get("features"));
        //将需要删除的数据,写入历史表
        ArcgisEditResponse addResponse = ArcgisQueryUtils.sendEditRequest(arcgisConfig.getFeatureRequestUrl(LayerNameEnum.getEnumByLayerName(featureClassName).getLsLayerName()), arcgisEditParam);
        if (!addResponse.getAddResults().get(0).isSuccess()) {
            throw new BussinessException("-1", "gis请求处理失败");
        }

        arcgisEditParam = new HashMap<>();
        arcgisEditParam.put("deletes", Joiner.on(",").join(uuids));
        List<Map> adds = new ArrayList<>();
        //写入合并后的图形
        Map esriGeometry = ArcgisQueryUtils.wktToEsriGeometryJson(gisFeature.getWktGeometry());
        Map<String, Object> param = new HashMap<>();
        param.put("geometry", esriGeometry);
        param.put("attributes", gisFeature.getProperties());
        adds.add(param);
        arcgisEditParam.put("adds", adds);
        ArcgisEditResponse response = ArcgisQueryUtils.sendEditRequest(arcgisConfig.getFeatureRequestUrl(featureClassName), arcgisEditParam);
        if (!response.getDeleteResults().get(0).isSuccess()) {
            throw new BussinessException("-1", "gis请求处理失败");
        }
        saveMergeFeatureOperationLog(featureClassName, gisFeature, jsonNode.get("features"), dataSourceEnum);
        return response;
    }

    private void saveMergeFeatureOperationLog(String featureClassName, GisFeature addGisFeature, JsonNode delFeatures, OperateDataSourceEnum dataSourceEnum) {
        FeatureOperationLog featureOperationLog = createFeatureOperationLog(EditType.MERGE, featureClassName, addGisFeature, dataSourceEnum);
        FeatureOperationLog operationLog = featureOperationLogService.saveOrUpdate(featureOperationLog);
        List<OperationGeometryLog> logs = new ArrayList<>();
        //记录日志
        delFeatures.forEach(jsonNode -> {
            OperationGeometryLog operationGeometryLog = createOperationGeometryLog(EditType.DEL, featureClassName, operationLog.getId(), jsonNode);
            logs.add(operationGeometryLog);
        });
        OperationGeometryLog operationGeometryLog = createOperationGeometryLog(EditType.ADD, featureClassName, operationLog.getId(), addGisFeature);
        logs.add(operationGeometryLog);
        operationGeometryLogService.saveAll(logs);
    }

    
 

   

    
    

    
    public JsonNode findFeaturesByFeatureids(List<Long> featureids, String layerName) throws Exception {
        LayerNameEnum layerNameEnum = LayerNameEnum.getEnumByLayerName(layerName);
        if (layerNameEnum == null) {
            throw new BussinessException("-1", "图层名称错误");
        }
        JsonNode jsonNode = ArcgisQueryUtils.queryByObjectids(arcgisConfig.getMapRequestUrl(layerName), Joiner.on(",").join(featureids));
        return jsonNode;
    }

    /**
     * 回退操作记录
     *
     * @param featureOperationLogId
     */
    
    public void huitui(String featureOperationLogId) throws Exception {
        FeatureOperationLog featureOperationLog = featureOperationLogService.findById(featureOperationLogId);
        if (featureOperationLog == null) {
            throw new BussinessException("-1", "数据不存在");
        }
        String editType = featureOperationLog.getEditType();
        
        if (EditType.ADD.getCode().equals(editType)) {
            //新增回退,那就是删除,直接删除即可
            List<JsonNode> features = queryFeaturesByCode(featureOperationLog.getCode(), featureOperationLog.getTableName());
            if (features == null || features.size() == 0) {
                throw new BussinessException("-1", "图形已被删除,无需回退");
            }
            if (features.size() > 1) {
                throw new BussinessException("-1", "回退失败,找到多条图形数据");
            }
            deleteFeature(featureOperationLog.getTableName(), features.get(0).get("attributes").get("OBJECTID").asText(), OperateDataSourceEnum.HUITUI);
        } else if (EditType.UPDATE.getCode().equals(editType)) {
            //更新回退
            List<JsonNode> features = queryFeaturesByCode(featureOperationLog.getCode(), featureOperationLog.getTableName());
            if (features == null || features.size() == 0) {
                throw new BussinessException("-1", "图形已被删除,无需回退");
            }
            if (features.size() > 1) {
                throw new BussinessException("-1", "回退失败,找到多条图形数据");
            }
            OperationGeometryLog operationGeometryLog = operationGeometryLogService.findAllByOperationId(featureOperationLogId).get(0);
            GisFeature gisFeature = new GisFeature();
            gisFeature.setWktGeometry(operationGeometryLog.getGeometry());
            JsonNode attributes = features.get(0).get("attributes");
            gisFeature.setUuid(attributes.get("OBJECTID").asText());
            gisFeature.setProperties(JacksonUtils.jsonToObject(operationGeometryLog.getAttributes(), HashMap.class));
            updateFeature(featureOperationLog.getTableName(), gisFeature, OperateDataSourceEnum.HUITUI);
        } else if (EditType.DEL.getCode().equals(editType)) {
            
            //删除回退
            OperationGeometryLog operationGeometryLog = operationGeometryLogService.findAllByOperationId(featureOperationLogId).get(0);
            List<JsonNode> features = queryFeaturesByCode(featureOperationLog.getCode(), featureOperationLog.getTableName());
            if (features != null && features.size() > 1) {
                throw new BussinessException("-1", "回退失败,找到多条图形数据");
            }
            if (features != null && features.size() == 1) {
                //删除原来的
                JsonNode attributes = features.get(0).get("attributes");
                deleteFeature(featureOperationLog.getTableName(), attributes.get("OBJECTID").asText(), OperateDataSourceEnum.HUITUI);
            }
            //然后新增
            GisFeature gisFeature = new GisFeature();
            gisFeature.setWktGeometry(operationGeometryLog.getGeometry());
            gisFeature.setProperties(JacksonUtils.jsonToObject(operationGeometryLog.getAttributes(), HashMap.class));
            addFeature(featureOperationLog.getTableName(), gisFeature, OperateDataSourceEnum.HUITUI);
        }
    }

    





    /**
     * 拼装错误信息
     *
     * @param message 错误信息
     * @return
     */
    private CheckResult setErrorMessage(String message, String uuid) {
        CheckResult checkResult = new CheckResult();
        MassgeObject massgeObject = new MassgeObject();
        List<MassgeObject> massgeObjects = new ArrayList<>();
        GisFeature feature = new GisFeature();
        feature.setUuid(uuid);
        massgeObject.setStr_Massage(message);
        massgeObject.setGisFeature(feature);
        massgeObjects.add(massgeObject);
        checkResult.setFailMsg(massgeObjects);
        checkResult.setResult(false);
        return checkResult;
    }

    /**
     * 自然幢要素数据移表
     *
     * @param features                需要入库的自然幢数据
     * @param sourceLayerNameEnum     原始要素图层
     * @param targetLayerNameEnum     目标要素图层
     * @param deleteSourceFeatureFlag 入库完成后,是否需要删除原始数据
     * @throws Exception
     */
    public void transferFeature(JsonNode features, LayerNameEnum sourceLayerNameEnum, LayerNameEnum targetLayerNameEnum, boolean deleteSourceFeatureFlag) {
        //先获取要素
        if (features == null || features.size() == 0) {
            return;
        }
        //把要素移入目标库
        Map<String, Object> arcgisEditParam = new HashMap<>();
        arcgisEditParam.put("adds", features);
        //将需要删除的数据,写入历史表
        ArcgisEditResponse addResponse = ArcgisQueryUtils.sendEditRequest(arcgisConfig.getFeatureRequestUrl(targetLayerNameEnum.getLayerName()), arcgisEditParam);
        if (!addResponse.getAddResults().get(0).isSuccess()) {
            throw new BussinessException("-1", "gis请求处理失败");
        }
        if (deleteSourceFeatureFlag) {
            //删除原库数据
            arcgisEditParam = new HashMap<>();
            List<String> objectids = new ArrayList<>();
            features.forEach(feature -> {
                objectids.add(feature.get("attributes").get("OBJECTID").asText());
            });
            arcgisEditParam.put("deletes", Joiner.on(",").join(objectids));
            ArcgisQueryUtils.sendEditRequest(arcgisConfig.getFeatureRequestUrl(sourceLayerNameEnum.getLayerName()), arcgisEditParam);
        }

    }

    /**
     * 数据入历史库
     *
     * @param features
     * @param sourceLayerNameEnum
     * @param dataSourceEnum
     */
    public void transferFeatureToHistory(JsonNode features, LayerNameEnum sourceLayerNameEnum, OperateDataSourceEnum dataSourceEnum) {
        if (features == null || features.size() == 0) {
            return;
        }
        //把要素移入目标库
        Map<String, Object> arcgisEditParam = new HashMap<>();
        arcgisEditParam.put("adds", features);
        //将需要删除的数据,写入历史表
        ArcgisEditResponse addResponse = ArcgisQueryUtils.sendEditRequest(arcgisConfig.getFeatureRequestUrl(sourceLayerNameEnum.getLsLayerName()), arcgisEditParam);
        if (!addResponse.getAddResults().get(0).isSuccess()) {
            throw new BussinessException("-1", "gis请求处理失败");
        }
        //删除原库数据
        arcgisEditParam = new HashMap<>();
        List<String> objectids = new ArrayList<>();
        features.forEach(feature -> {
            objectids.add(feature.get("attributes").get("OBJECTID").asText());
        });
        arcgisEditParam.put("deletes", Joiner.on(",").join(objectids));
        ArcgisQueryUtils.sendEditRequest(arcgisConfig.getFeatureRequestUrl(sourceLayerNameEnum.getLayerName()), arcgisEditParam);
        if (dataSourceEnum != null) {
            Iterator<JsonNode> iterator = features.iterator();
            while (iterator.hasNext()) {
                JsonNode feature = iterator.next();
                saveDelFeatureOperationLog(feature, sourceLayerNameEnum.getLayerName(), dataSourceEnum);
            }
        }
    }
}
        
package com.dzp.gistest.common.constants;

import com.dzp.gistestexceptions.BussinessException;
import com.dzp.gistest.LayerNameEnum;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration
@Data
@PropertySource(value = {"classpath:config.properties"})
public class ArcgisConfig {

    @Value("${arcgis.baseUrl}")
    private String baseUrl;
    @Value("${arcgis.zsWorkspace}")
    private String zsWorkspace;
    @Value("${arcgis.wkWorkspace}")
    private String wkWorkspace;

    @Value("${arcgis.lsWorkspace}")
    private String lsWorkspace;

    @Value("${arcgis.bakWorkspace}")
    private String bakWorkspace;
    @Value("${arcgis.index.fwm}")
    private String fwmIdx;
    @Value("${arcgis.index.fwmWk}")
    private String fwmWkIdx;
    @Value("${arcgis.index.fwmLs}")
    private String fwmLsIdx;

    @Value("${arcgis.index.zd}")
    private String zdIdx;
    @Value("${arcgis.index.zdWk}")
    private String zdWkIdx;
    @Value("${arcgis.index.zdLs}")
    private String zdLsIdx;

    /**
     * 房屋面Mapserver地址
     *
     * @return
     */
    public String getFwmMapServerUrl() {
        return getMapServerUrl(this.zsWorkspace, this.fwmIdx);
    }

    /**
     * 房屋面FeatureServer地址
     *
     * @return
     */
    public String getFwmFeatureServerUrl() {
        return getFeatureServerUrl(this.zsWorkspace, this.fwmIdx);
    }

    /**
     * 房屋面历史Mapserver地址
     *
     * @return
     */
    public String getFwmWkMapServerUrl() {
        return getMapServerUrl(this.wkWorkspace, this.fwmWkIdx);
    }

    public String getFwmLsMapServerUrl() {
        return getMapServerUrl(this.lsWorkspace, this.fwmLsIdx);
    }

    /**
     * 房屋面历史FeatureServer地址
     *
     * @return
     */
    public String getFwmWkFeatureServerUrl() {
        return getFeatureServerUrl(this.wkWorkspace, this.fwmWkIdx);
    }

    public String getFwmLsFeatureServerUrl() {
        return getFeatureServerUrl(this.lsWorkspace, this.fwmLsIdx);
    }


    public String getZdMapServerUrl() {
        return getMapServerUrl(this.bakWorkspace, this.zdIdx);
    }

    

    public String getMapServerUrl(String workspace, String index) {
        return this.baseUrl + "/" + workspace + "/MapServer/" + index;
    }

    public String getFeatureServerUrl(String workspace, String index) {
        return this.baseUrl + "/" + workspace + "/FeatureServer/" + index;
    }


    public String getMapRequestUrl(String layerName) {
        if (layerName.equals(LayerNameEnum.FWM.getLayerName())) {
            return this.getFwmMapServerUrl() + "/query";
        } else if (layerName.equals(LayerNameEnum.FWM_WK.getLayerName())) {
            return this.getFwmWkMapServerUrl() + "/query";
        } else if (layerName.equals(LayerNameEnum.FWM_LS.getLayerName())) {
            return this.getFwmLsMapServerUrl() + "/query";
        }else if (layerName.equals(LayerNameEnum.ZD.getLayerName())) {
            return this.getZdMapServerUrl() + "/query";
        } else if (layerName.equals(LayerNameEnum.ZD_WK.getLayerName())) {
            return this.getZdWkMapServerUrl() + "/query";
        } else if (layerName.equals(LayerNameEnum.ZD_LS.getLayerName())) {
            return this.getZdLsMapServerUrl() + "/query";
        }

        throw new BussinessException("-1", "该图层不支持修改");
    }


    public String getFeatureRequestUrl(String layerName) {
        if (layerName.equals(LayerNameEnum.FWM.getLayerName())) {
            return this.getFwmFeatureServerUrl() + "/applyEdits";
        } else if (layerName.equals(LayerNameEnum.FWM_WK.getLayerName())) {
            return this.getFwmWkFeatureServerUrl() + "/applyEdits";
        } else if (layerName.equals(LayerNameEnum.FWM_LS.getLayerName())) {
            return this.getFwmLsFeatureServerUrl() + "/applyEdits";
        }else if (layerName.equals(LayerNameEnum.ZD.getLayerName())) {
            return this.getZdFeatureServerUrl() + "/applyEdits";
        } else if (layerName.equals(LayerNameEnum.ZD_WK.getLayerName())) {
            return this.getZdWkFeatureServerUrl() + "/applyEdits";
        } else if (layerName.equals(LayerNameEnum.ZD_LS.getLayerName())) {
            return this.getZdLsFeatureServerUrl() + "/query";
        }
        throw new BussinessException("-1", "该图层不支持修改");
    }



}

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值