2025.8.14 1. 新增文件导入场景信息接口 2. 新增导出接口文档接口

feiyu02

2025-08-14 f373bbf83d9d2a7e5f96118d7dcd658c9fea8bc8

2025.8.14
1. 新增文件导入场景信息接口
2. 新增导出接口文档接口

 src/main/kotlin/cn/flightfeather/supervision/business/autooutput/datasource/AopDataSource.kt

@@ -29,8 +29,10 @@
     * è®¾ç½®æ•°æ®æº
     */
    fun setResource(topTaskGuid: String?, sceneType: Int, districtName: String?, townCode: String?) {
        val config = AopDataConfig(topTaskGuid = topTaskGuid, sceneType = sceneType, districtName = districtName,
            townCode = townCode)
        val config = AopDataConfig(
            topTaskGuid = topTaskGuid, sceneType = sceneType, districtName = districtName,
            townCode = townCode
        )
        evaluationScene.config = config
        val check = aopSceneTypeCheck.checkSceneType(sceneType)
        if (check.first) {
@@ -60,8 +62,10 @@
    fun setResource(subtask: Subtask) {
        val scene = aopDbMapper.scenseMapper.selectByPrimaryKey(subtask.scenseid)
        val sceneType = scene.typeid?.toInt()
        val config = AopDataConfig(topTaskGuid = subtask.tguid, sceneType = sceneType,
            districtName = subtask.districtname, townCode = subtask.towncode)
        val config = AopDataConfig(
            topTaskGuid = subtask.tguid, sceneType = sceneType,
            districtName = subtask.districtname, townCode = subtask.towncode
        )
        evaluationScene.config = config
//        val check = aopSceneTypeCheck.checkSceneType(sceneType)
        this.mode = 0
@@ -84,6 +88,7 @@
                    } while (evaluationScene.gotoNextSubTask())
                }
            }

            1 -> {
                userSourceList.forEachIndexed { i, user ->
                    evaluationScene.clear()
@@ -109,6 +114,7 @@
                    callback(i, evaluationScene)
                }
            }

            1 -> {
                userSourceList.forEachIndexed { i, user ->
                    evaluationScene.clear()
@@ -188,6 +194,7 @@
                dGuid = scene.value?.guid
            })
        }

        //巡查任务信息
        var subTaskIndex = 0
        val subTask = InfoProxy<Subtask> {_,_ ->
@@ -220,12 +227,15 @@
                Constant.SceneType.TYPE1.value -> {
                    aopDbMapper.sceneConstructionSiteMapper.selectByPrimaryKey(scene.value?.guid)
                }

                Constant.SceneType.TYPE2.value -> {
                    aopDbMapper.sceneWharfMapper.selectByPrimaryKey(scene.value?.guid)
                }

                Constant.SceneType.TYPE3.value -> {
                    aopDbMapper.sceneMixingPlantMapper.selectByPrimaryKey(scene.value?.guid)
                }

                Constant.SceneType.TYPE14.value -> {
                    aopDbMapper.sceneStorageYardMapper.selectByPrimaryKey(scene.value?.guid)
                }
@@ -233,9 +243,11 @@
                Constant.SceneType.TYPE5.value -> {
                    aopDbMapper.restaurantBaseInfoMapper.selectByPrimaryKey(userInfoTZ.value?.guid)
                }

                Constant.SceneType.TYPE6.value -> {
                    aopDbMapper.vehicleBaseInfoMapper.selectByPrimaryKey(userInfoTZ.value?.guid)
                }

                else -> null
            }
        }
@@ -289,6 +301,14 @@
                createCriteria()
                    .andEqualTo("tasktypeid", 99)
                    .andEqualTo("scensetypeid", scene.value?.typeid)
                and(createCriteria().orEqualTo("provincecode", scene.value?.provincecode).orIsNull("provincecode"))
                and(createCriteria().orEqualTo("citycode", scene.value?.citycode).orIsNull("citycode"))
                and(createCriteria().orEqualTo("districtcode", scene.value?.districtcode).orIsNull("districtcode"))
                and(createCriteria().orEqualTo("towncode", scene.value?.towncode).orIsNull("towncode"))
                orderBy("towncode").desc()
                    .orderBy("districtcode").desc()
                    .orderBy("citycode").desc()
                    .orderBy("provincecode").desc()
            })
            if (rule.isNotEmpty()) {
                this@EvaluationScene.baseRule.value = rule[0]
@@ -378,9 +398,12 @@
                orderBy("planstarttime").desc()
            })
            if (r.isNotEmpty()) {
                val thisMonth = LocalDateTime.ofInstant(subTask.value?.planstarttime?.toInstant(), ZoneId.systemDefault())
                val thisMonth =
                    LocalDateTime.ofInstant(subTask.value?.planstarttime?.toInstant(), ZoneId.systemDefault())
                    .withDayOfMonth(1).toLocalDate()
                val lastMonth = LocalDateTime.ofInstant(r[0]?.planstarttime?.toInstant(), ZoneId.systemDefault()).withDayOfMonth(1).toLocalDate()
                val lastMonth =
                    LocalDateTime.ofInstant(r[0]?.planstarttime?.toInstant(), ZoneId.systemDefault()).withDayOfMonth(1)
                        .toLocalDate()
                if (lastMonth.plusMonths(1).isEqual(thisMonth)) {
                    last.subTask.value = r[0]
                }
@@ -458,7 +481,8 @@
                if (defaultValue != null) {
                    return defaultValue
                } else if (!fetched && _value == null) {
                    _value = if (cacheMap.containsKey(key) && LocalDateTime.now().minusDays(1).isBefore(cacheTimeStamp)) {
                    _value =
                        if (cacheMap.containsKey(key) && LocalDateTime.now().minusDays(1).isBefore(cacheTimeStamp)) {
                        cacheMap[key]
                    } else {
                        cacheTimeStamp = LocalDateTime.now()

 src/main/kotlin/cn/flightfeather/supervision/business/import/SceneImport.kt

@@ -3,8 +3,10 @@
import cn.flightfeather.supervision.common.exception.BizException
import cn.flightfeather.supervision.common.utils.Constant
import cn.flightfeather.supervision.common.utils.ExcelUtil
import cn.flightfeather.supervision.domain.ds1.entity.Scense
import cn.flightfeather.supervision.domain.ds1.entity.*
import cn.flightfeather.supervision.domain.ds1.repository.RegionRep
import cn.flightfeather.supervision.lightshare.vo.SceneDetail
import com.google.gson.Gson
import org.apache.poi.ss.usermodel.CellType
import org.springframework.stereotype.Component
import java.io.InputStream
@@ -17,9 +19,10 @@
class SceneImport(
    private val regionRep: RegionRep,
) {
    // åœºæ™¯å…±æœ‰ä¿¡æ¯
    private val headers =
        listOf(
            ExcelUtil.MyHeader("编号（若不填写，则按照顺序自动添加）", CellType.NUMERIC),
            ExcelUtil.MyHeader("编号（可省略）", CellType.NUMERIC, true),
            ExcelUtil.MyHeader("名称", CellType.STRING),
            ExcelUtil.MyHeader("类型", CellType.STRING),
            ExcelUtil.MyHeader("地址", CellType.STRING),
@@ -33,14 +36,36 @@
            ExcelUtil.MyHeader("联系电话", CellType.STRING)
        )

    // å·¥åœ°ä¿¡æ¯
    private val headersType1 = listOf(
        ExcelUtil.MyHeader("工程类型", CellType.STRING),
        ExcelUtil.MyHeader("建设状态", CellType.STRING),
        ExcelUtil.MyHeader("施工阶段", CellType.STRING),
        ExcelUtil.MyHeader("开工时间", CellType.STRING),
        ExcelUtil.MyHeader("完工时间", CellType.STRING),
        ExcelUtil.MyHeader("剩余工期", CellType.STRING),
        ExcelUtil.MyHeader("占地面积", CellType.NUMERIC),
        ExcelUtil.MyHeader("施工面积", CellType.NUMERIC),
        ExcelUtil.MyHeader("每月施工面积", CellType.NUMERIC),
        ExcelUtil.MyHeader("业主单位", CellType.STRING),
        ExcelUtil.MyHeader("业主单位联系人", CellType.STRING),
        ExcelUtil.MyHeader("业主单位联系电话", CellType.STRING),
        ExcelUtil.MyHeader("施工单位", CellType.STRING),
        ExcelUtil.MyHeader("施工单位联系人", CellType.STRING),
        ExcelUtil.MyHeader("施工单位联系电话", CellType.STRING),
        ExcelUtil.MyHeader("安全员", CellType.STRING),
        ExcelUtil.MyHeader("安全员电话", CellType.STRING),
    )

    /**
     * é€šè¿‡æ–‡ä»¶è¯»å–场景信息
     */
    fun readFromFile(file: InputStream): List<Scense> {
        val result = mutableListOf<Scense>()
    fun readFromFile(file: InputStream): List<SceneDetail> {
        val result = mutableListOf<SceneDetail>()
        try {
            ExcelUtil.readXLXS(file, headers) {
                val data = Scense().apply {
                val data = SceneDetail().apply {
                    scense = Scense().apply {
                    guid = null
                    name = it.getCell(1)?.stringCellValue?.trim()
                    typeid = null
@@ -65,19 +90,53 @@
                    updatedate = Date()
                    extension1 = "1"
                    extension2 = null
                    index = it.getCell(5)?.stringCellValue?.trim()?.toInt()
                        index = it.getCell(0)?.numericCellValue?.toInt()
                    remark = null
                }
                data.typeid = Constant.SceneType.getByName(data.type)?.value?.toByte()
                    ?: throw BizException(errorStr(it.rowNum + 1, 2, "场景类型不存在"))
                data.provincecode = regionRep.findProvince(data.provincename)?.provincecode
                    ?: throw BizException(errorStr(it.rowNum + 1, 6, "省份错误或系统未曾配置"))
                data.citycode = regionRep.findCity(data.cityname)?.citycode
                    ?: throw BizException(errorStr(it.rowNum + 1, 7, "城市错误或系统未曾配置"))
                data.districtcode = regionRep.findDistrict(data.districtname)?.districtcode
                    ?: throw BizException(errorStr(it.rowNum + 1, 8, "区县错误或系统未曾配置"))
                data.towncode = regionRep.findTown(data.townname)?.towncode
                    ?: throw BizException(errorStr(it.rowNum + 1, 9, "街镇错误或系统未曾配置"))
                    scense?.typeid = Constant.SceneType.getByName(scense?.type)?.value?.toByte()
                        ?: throw BizException(errorStr(it.rowNum + 1, 3, "场景类型不存在"))
                    scense?.provincecode = regionRep.findProvince(scense?.provincename)?.provincecode
                        ?: throw BizException(errorStr(it.rowNum + 1, 7, "省份错误或系统未曾配置"))
                    scense?.citycode = regionRep.findCity(scense?.cityname)?.citycode
                        ?: throw BizException(errorStr(it.rowNum + 1, 8, "城市错误或系统未曾配置"))
                    scense?.districtcode = regionRep.findDistrict(scense?.districtname)?.districtcode
                        ?: throw BizException(errorStr(it.rowNum + 1, 9, "区县错误或系统未曾配置"))
                    scense?.towncode = regionRep.findTown(scense?.townname)?.towncode
                        ?: throw BizException(errorStr(it.rowNum + 1, 10, "街镇错误或系统未曾配置"))

                    when (scense?.typeid.toString()) {
                        Constant.SceneType.TYPE1.value -> {
                            subScene = SceneConstructionSite().apply {
                                csProjectType = it.getCell(12)?.stringCellValue?.trim()
                                csStatus = it.getCell(13)?.stringCellValue?.trim()
                                siExtension1 = it.getCell(14)?.stringCellValue?.trim()
                                csStartTime = it.getCell(15)?.stringCellValue?.trim()
                                csEndTime = it.getCell(16)?.stringCellValue?.trim()
                                csLeftTime = it.getCell(17)?.stringCellValue?.trim()
                                csFloorSpace = it.getCell(18)?.numericCellValue?.toString()
                                csConstructionArea = it.getCell(19)?.numericCellValue?.toString()
                                csConstructionAreaPerMonth = it.getCell(20)?.numericCellValue?.toString()
                                csEmployerUnit = it.getCell(21)?.stringCellValue?.trim()
                                csEmployerContacts = it.getCell(22)?.stringCellValue?.trim()
                                csEmployerContactsTel = it.getCell(23)?.stringCellValue?.trim()
                                csConstructionUnit = it.getCell(24)?.stringCellValue?.trim()
                                csConstructionContacts = it.getCell(25)?.stringCellValue?.trim()
                                csConstructionContactsTel = it.getCell(26)?.stringCellValue?.trim()
                                csSecurityOfficer = it.getCell(27)?.stringCellValue?.trim()
                                csSecurityOfficerTel = it.getCell(28)?.stringCellValue?.trim()
                            }
                        }
                        Constant.SceneType.TYPE2.value -> {

                        }
                        Constant.SceneType.TYPE3.value -> {

                        }
                        Constant.SceneType.TYPE14.value -> {

                        }
                    }
                }

                result.add(data)
            }

 src/main/kotlin/cn/flightfeather/supervision/common/api2word/JavaConfig.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,47 @@
package cn.flightfeather.supervision.common.api2word;

import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.client.RestTemplate;

import javax.net.ssl.SSLContext;
import java.nio.charset.StandardCharsets;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;

/**
 * Created by XiuYin.Cui on 2018/6/21.
 */
@Configuration
public class JavaConfig {

    @Bean
    public RestTemplate restTemplate() throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
        TrustStrategy acceptingTrustStrategy = (X509Certificate[] chain, String authType) -> true;
        SSLContext sslContext = org.apache.http.ssl.SSLContexts.custom()
                .loadTrustMaterial(null, acceptingTrustStrategy)
                .build();
        SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(sslContext);
        CloseableHttpClient httpClient = HttpClients.custom()
                .setSSLSocketFactory(csf)
                .build();
        HttpComponentsClientHttpRequestFactory requestFactory =
                new HttpComponentsClientHttpRequestFactory();
        requestFactory.setHttpClient(httpClient);

        //60s
        requestFactory.setConnectTimeout(60 * 1000);
        requestFactory.setReadTimeout(60 * 1000);
        RestTemplate restTemplate = new RestTemplate(requestFactory);
        restTemplate.getMessageConverters().set(1, new StringHttpMessageConverter(StandardCharsets.UTF_8));
        return restTemplate;
    }
}

 src/main/kotlin/cn/flightfeather/supervision/common/api2word/model/ModelAttr.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,107 @@
package cn.flightfeather.supervision.common.api2word.model;

import org.apache.commons.lang3.StringUtils;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

/**
 * è¿”回属性
 *
 * @author kevin
 */
public class ModelAttr implements Serializable {

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Boolean getRequire() {
        return require;
    }

    public void setRequire(Boolean require) {
        this.require = require;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public List<ModelAttr> getProperties() {
        return properties;
    }

    public void setProperties(List<ModelAttr> properties) {
        this.properties = properties;
    }

    public boolean isCompleted() {
        return isCompleted;
    }

    public void setCompleted(boolean isCompleted) {
        this.isCompleted = isCompleted;
    }

    public static long getSerialversionuid() {
        return serialVersionUID;
    }

    private static final long serialVersionUID = -4074067438450613643L;

    /**
     * ç±»å
     */
    private String className = StringUtils.EMPTY;
    /**
     * å±žæ€§å
     */
    private String name = StringUtils.EMPTY;
    /**
     * ç±»åž‹
     */
    private String type = StringUtils.EMPTY;
    /**
     * æ˜¯å¦å¿…å¡«
     */
    private Boolean require = false;
    /**
     * å±žæ€§æè¿°
     */
    private String description;
    /**
     * åµŒå¥—属性列表
     */
    private List<ModelAttr> properties = new ArrayList<>();

    /**
     * æ˜¯å¦åŠ è½½å®Œæˆï¼Œé¿å…å¾ªçŽ¯å¼•ç”¨
     */
    private boolean isCompleted = false;
}

 src/main/kotlin/cn/flightfeather/supervision/common/api2word/model/Request.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,87 @@
package cn.flightfeather.supervision.common.api2word.model;

import java.io.Serializable;

/**
 * Created by XiuYin.Cui on 2018/1/11.
 */
public class Request implements Serializable{

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getParamType() {
        return paramType;
    }

    public void setParamType(String paramType) {
        this.paramType = paramType;
    }

    public Boolean getRequire() {
        return require;
    }

    public void setRequire(Boolean require) {
        this.require = require;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }

    public ModelAttr getModelAttr() {
        return modelAttr;
    }

    public void setModelAttr(ModelAttr modelAttr) {
        this.modelAttr = modelAttr;
    }

    /**
     * å‚数名
     */
    private String name;

    /**
     * æ•°æ®ç±»åž‹
     */
    private String type;

    /**
     * å‚数类型
     */
    private String paramType;

    /**
     * æ˜¯å¦å¿…å¡«
     */
    private Boolean require;

    /**
     * è¯´æ˜Ž
     */
    private String remark;

    /**
     * å¤æ‚对象引用
     */
    private ModelAttr modelAttr;
}

 src/main/kotlin/cn/flightfeather/supervision/common/api2word/model/Response.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,48 @@
package cn.flightfeather.supervision.common.api2word.model;

import java.io.Serializable;

/**
 * Created by XiuYin.Cui on 2018/1/11.
 */
public class Response implements Serializable{

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }

    /**
     * è¿”回参数
     */
    private String description;

    /**
     * å‚数名
     */
    private String name;

    /**
     * å¤‡æ³¨
     */
    private String remark;
}

 src/main/kotlin/cn/flightfeather/supervision/common/api2word/model/Table.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,163 @@
package cn.flightfeather.supervision.common.api2word.model;

import java.util.List;

/**
 * Created by XiuYin.Cui on 2018/1/11.
 */
public class Table {

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getTag() {
        return tag;
    }

    public void setTag(String tag) {
        this.tag = tag;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getRequestForm() {
        return requestForm;
    }

    public void setRequestForm(String requestForm) {
        this.requestForm = requestForm;
    }

    public String getResponseForm() {
        return responseForm;
    }

    public void setResponseForm(String responseForm) {
        this.responseForm = responseForm;
    }

    public String getRequestType() {
        return requestType;
    }

    public void setRequestType(String requestType) {
        this.requestType = requestType;
    }

    public List<Request> getRequestList() {
        return requestList;
    }

    public void setRequestList(List<Request> requestList) {
        this.requestList = requestList;
    }

    public List<Response> getResponseList() {
        return responseList;
    }

    public void setResponseList(List<Response> responseList) {
        this.responseList = responseList;
    }

    public String getRequestParam() {
        return requestParam;
    }

    public void setRequestParam(String requestParam) {
        this.requestParam = requestParam;
    }

    public String getResponseParam() {
        return responseParam;
    }

    public void setResponseParam(String responseParam) {
        this.responseParam = responseParam;
    }

    public ModelAttr getModelAttr() {
        return modelAttr;
    }

    public void setModelAttr(ModelAttr modelAttr) {
        this.modelAttr = modelAttr;
    }

    /**
     * å¤§æ ‡é¢˜
     */
    private String title;
    /**
     * å°æ ‡é¢˜
     */
    private String tag;
    /**
     * url
     */
    private String url;

    /**
     * æè¿°
     */
    private String description;

    /**
     * è¯·æ±‚参数格式
     */
    private String requestForm;

    /**
     * å“åº”参数格式
     */
    private String responseForm;

    /**
     * è¯·æ±‚方式
     */
    private String requestType;

    /**
     * è¯·æ±‚体
     */
    private List<Request> requestList;

    /**
     * è¿”回体
     */
    private List<Response> responseList;

    /**
     * è¯·æ±‚参数
     */
    private String requestParam;

    /**
     * è¿”回参数
     */
    private String responseParam;

    /**
     * è¿”回属性列表
     */
    private ModelAttr modelAttr = new ModelAttr();
}

 src/main/kotlin/cn/flightfeather/supervision/common/api2word/utils/JsonUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,66 @@
package cn.flightfeather.supervision.common.api2word.utils;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;

import java.io.IOException;
import java.util.List;

/**
 * @author cuixiuyin
 * @Date: 2018/11/05
 */

public class JsonUtils {

    private static ObjectMapper objectMapper = new ObjectMapper();

    static {
        objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
        objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true);
        objectMapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
    }

    public static <T> T readValue(String jsonStr, Class<T> clazz) throws IOException {
        return objectMapper.readValue(jsonStr, clazz);
    }

    public static <T> List<T> readListValue(String jsonStr, Class<T> clazz) throws IOException {
        JavaType javaType = objectMapper.getTypeFactory().constructParametricType(List.class, clazz);
        return objectMapper.readValue(jsonStr, javaType);
    }

    public static ArrayNode readArray(String jsonStr) throws IOException {
        JsonNode node = objectMapper.readTree(jsonStr);
        if (node.isArray()) {
            return (ArrayNode) node;
        }
        return null;
    }

    public static JsonNode readNode(String jsonStr) throws IOException {
        return objectMapper.readTree(jsonStr);
    }

    public static String writeJsonStr(Object obj) throws JsonProcessingException {
        return objectMapper.writeValueAsString(obj);
    }

    public static ObjectNode createObjectNode() {
        return objectMapper.createObjectNode();
    }

    public static ArrayNode createArrayNode() {
        return objectMapper.createArrayNode();
    }

}

 src/main/kotlin/cn/flightfeather/supervision/common/api2word/utils/MenuUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,25 @@
package cn.flightfeather.supervision.common.api2word.utils;

/**
 * @author : cuixiuyin
 * @date : 2019/8/31
 */
public class MenuUtils {

    public static Integer count = 0;
    public static String menuStr = "null";

    public static boolean isMenu(String tags) {
        if (menuStr.equals(tags)) {
            count++;
        } else {
            menuStr = tags;
            count = 0;
        }
        if (count == 0) {
            return true;
        } else {
            return false;
        }
    }
}

 src/main/kotlin/cn/flightfeather/supervision/common/api2word/utils/ModelAttrUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,72 @@
package cn.flightfeather.supervision.common.api2word.utils;


import cn.flightfeather.supervision.common.api2word.model.ModelAttr;
import org.apache.commons.lang3.StringUtils;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

/**
 * @author ivenhan
 * @Date: 2020/10/15
 */

public class ModelAttrUtils {

    // å°è£…schema - properties下某个具体property对象
    public static ModelAttr propertyModelAttr(Map<String, Map<String, Object>> property) {
        ModelAttr modeAttr = new ModelAttr();

        Map<String, Object> modeProperties = (Map<String, Object>) property.get("properties");
        ArrayList modeRequired = (ArrayList) property.get("required");
        List<ModelAttr> attrList = new ArrayList<>();

        if (modeProperties != null) {
            Iterator<Entry<String, Object>> mIt = modeProperties.entrySet().iterator();

            //解析属性
            while (mIt.hasNext()) {
                Entry<String, Object> mEntry = mIt.next();
                Map<String, Object> attrInfoMap = (Map<String, Object>) mEntry.getValue();
                ModelAttr child = new ModelAttr();
                child.setName(mEntry.getKey());
                child.setType((String) attrInfoMap.get("type"));
                if (attrInfoMap.get("format") != null) {
                    child.setType(child.getType() + "(" + attrInfoMap.get("format") + ")");
                }
                child.setType(StringUtils.defaultIfBlank(child.getType(), "object"));

                Object ref = attrInfoMap.get("$ref");
                Object items = attrInfoMap.get("items");

                if (items != null && ((Map) items).get("$ref") == null) {
                    ModelAttr refModel = propertyModelAttr((Map<String, Map<String, Object>>)items);
                    if (refModel != null) {
                        child.setProperties(refModel.getProperties());
                    }
                    child.setType(child.getType());
                }

                child.setDescription((String) attrInfoMap.get("description"));

                child.setRequire(false);
                if (modeRequired != null && modeRequired.contains(mEntry.getKey())) {
                    child.setRequire(true);
                }

                attrList.add(child);
            }
        }

        Object title = property.get("title");
        Object description = property.get("description");
        modeAttr.setClassName(title == null ? "" : title.toString());
        modeAttr.setDescription(description == null ? "" : description.toString());
        modeAttr.setProperties(attrList);
        return modeAttr;
    }
}

 src/main/kotlin/cn/flightfeather/supervision/common/api2word/utils/RequestUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,29 @@
package cn.flightfeather.supervision.common.api2word.utils;

import com.fasterxml.jackson.core.JsonProcessingException;

import java.util.Map;


/**
 * @author : ivenhan
 * @date : 2020/10/16
 */
public class RequestUtils {

    public static void validateRequestKey(Map<String, Map> content) throws JsonProcessingException {
        Map<String, Map> applicationJSON = content.get("application/json");
        if (applicationJSON == null) {
            throw new JsonProcessingException("content字段 ç¼ºå°‘ application/json å­—段") {};
        }

        Map<String, Map> schema = applicationJSON.get("schema");
        if (schema == null) {
            throw new JsonProcessingException("content字段 application/json ç¼ºå°‘ schema å­—段") {};
        }

        if (schema.get("type") == null) {
            throw new JsonProcessingException("content字段 application/json å­—段 schema å­—段 ç¼ºå°‘ type字段") {};
        }
    }
}

 src/main/kotlin/cn/flightfeather/supervision/common/api2word/utils/ResponseUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,44 @@
package cn.flightfeather.supervision.common.api2word.utils;

import com.fasterxml.jackson.core.JsonProcessingException;

import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * @author : ivenhan
 * @date : 2020/10/16
 */
public class ResponseUtils {

    public static void validateResponseKey(Map<String, Map> content) throws JsonProcessingException {
        Map<String, Map> applicationJSON = content.get("application/json");
        if (applicationJSON == null) {
            throw new JsonProcessingException("content å­—段缺少 application/json å­—段") {};
        }

        Map<String, Map> schema = applicationJSON.get("schema");
        if (schema == null) {
            throw new JsonProcessingException("content å­—段 application/json å­—段 ç¼ºå°‘ schema å­—段") {};
        }

        if (schema.get("type") == null) {
            throw new JsonProcessingException("content å­—段 application/json å­—段 schema å­—段 ç¼ºå°‘ type字段") {};
        }

        Map items = schema.get("items");
        Map properties = schema.get("properties");
        if (items == null && properties == null) {
            throw new JsonProcessingException("content å­—段 application/json å­—段 schema å­—段 ç¼ºå°‘  properties æˆ–者 items å­—段") {};
        }


        Set<Entry<String, Map>> contentValues = content.entrySet();

        int size = contentValues.size();
        if ((applicationJSON.get("examples") != null && size > 2) || (applicationJSON.get("examples") == null && size > 1) ) {
            throw new JsonProcessingException("content å­—段存在除 application/json æˆ–者 examples å­—段之外的其他字段") {};
        }
    }
}

 src/main/kotlin/cn/flightfeather/supervision/common/exception/BizException.kt

@@ -5,9 +5,9 @@
 */
class BizException : Exception {
    constructor():super()
    constructor(message: String) : super(message)
    constructor(message: String, cause: Throwable?) : super(message, cause)
    constructor(message: String?) : super(message)
    constructor(message: String?, cause: Throwable?) : super(message, cause)
    constructor(cause: Throwable?) : super(cause)
    constructor(message: String, cause: Throwable?, enableSuppression: Boolean, writableStackTrace: Boolean)
    constructor(message: String?, cause: Throwable?, enableSuppression: Boolean, writableStackTrace: Boolean)
            : super(message, cause, enableSuppression, writableStackTrace)
}

 src/main/kotlin/cn/flightfeather/supervision/common/utils/ExcelUtil.kt

@@ -36,6 +36,7 @@
    class MyHeader(
        var name: String,
        val type: CellType,
        val ignore: Boolean = false
    )

    private fun cellTypeName(type: CellType): String = when (type) {
@@ -74,8 +75,8 @@
        iterator.forEach {
            // æ£€æŸ¥å½“前行每个单元格类型是否与表头定义匹配
            headers.forEachIndexed { i, h ->
                val t = it.getCell(i + 1).cellType
                if (t != CellType.BLANK || t != h.type) {
                val t = it.getCell(i)?.cellType ?: CellType.BLANK
                if (t != CellType.BLANK && !h.ignore && t != h.type) {
                    throw BizException("第${it.rowNum + 1}行，第${i + 1}列单元格格式错误，应该为${cellTypeName(h.type)}")
                }
            }

 src/main/kotlin/cn/flightfeather/supervision/config/CorsConfig.kt

@@ -2,10 +2,12 @@

import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.Profile
import org.springframework.web.cors.CorsConfiguration
import org.springframework.web.cors.UrlBasedCorsConfigurationSource
import org.springframework.web.filter.CorsFilter

@Profile("dev", "test")
@Configuration
class CorsConfig {


 src/main/kotlin/cn/flightfeather/supervision/domain/ds1/entity/SceneConstructionSite.java

@@ -5,6 +5,7 @@
import io.swagger.annotations.ApiModelProperty;

import javax.persistence.*;
import java.util.Date;

@Table(name = "sm_t_scene_construction_site")
@JsonInclude(JsonInclude.Include.NON_NULL)
@@ -26,10 +27,10 @@
    private String csProjectType;

    /**
     * æ–½å·¥é˜¶æ®µ
     * å»ºè®¾çŠ¶æ€
     */
    @Column(name = "CS_Status")
    @ApiModelProperty("施工阶段")
    @ApiModelProperty("建设状态")
    private String csStatus;

    /**
@@ -129,6 +130,9 @@
    @Column(name = "CS_Security_Officer_Tel")
    @ApiModelProperty("安全员电话")
    private String csSecurityOfficerTel;

    @Column(name = "CS_Update_Time")
    private Date csUpdateTime;

    @Column(name = "SI_Extension1")
    private String siExtension1;
@@ -448,6 +452,14 @@
        this.csSecurityOfficerTel = csSecurityOfficerTel;
    }

    public Date getCsUpdateTime() {
        return csUpdateTime;
    }

    public void setCsUpdateTime(Date csUpdateTime) {
        this.csUpdateTime = csUpdateTime;
    }

    /**
     * @return SI_Extension1
     */

 src/main/kotlin/cn/flightfeather/supervision/domain/ds1/repository/RegionRep.kt

@@ -39,25 +39,25 @@
    }

    fun findProvince(name: String?): Province? {
        return findCache(name) {
        return findCache("Province$name") {
            provinceMapper.selectOne(Province().apply { provincename = name })
        }
    }

    fun findCity(name: String?): City? {
        return findCache(name) {
        return findCache("City$name") {
            cityMapper.selectOne(City().apply { cityname = name })
        }
    }

    fun findDistrict(name: String?): District? {
        return findCache(name) {
        return findCache("District$name") {
            districtMapper.selectOne(District().apply { districtname = name })
        }
    }

    fun findTown(name: String?): Town? {
        return findCache(name) {
        return findCache("Town$name") {
            townMapper.selectOne(Town().apply { townname = name })
        }
    }

 src/main/kotlin/cn/flightfeather/supervision/domain/ds1/repository/SceneRep.kt

@@ -1,10 +1,11 @@
package cn.flightfeather.supervision.domain.ds1.repository

import cn.flightfeather.supervision.common.exception.BizException
import cn.flightfeather.supervision.common.utils.Constant
import cn.flightfeather.supervision.common.utils.UUIDGenerator
import cn.flightfeather.supervision.domain.ds1.entity.Scense
import cn.flightfeather.supervision.domain.ds1.mapper.ScenseMapper
import cn.flightfeather.supervision.domain.ds1.mapper.UserinfoMapper
import cn.flightfeather.supervision.domain.ds1.entity.*
import cn.flightfeather.supervision.domain.ds1.mapper.*
import com.google.gson.Gson
import org.springframework.stereotype.Repository
import tk.mybatis.mapper.entity.Example
import java.util.*
@@ -17,6 +18,11 @@
    private val scenseMapper: ScenseMapper,
    private val userinfoMapper: UserinfoMapper,
    private val subTaskRep: SubTaskRep,
    val sceneConstructionSiteMapper: SceneConstructionSiteMapper,
    val sceneDeviceMapper: SceneDeviceMapper,
    val sceneMixingPlantMapper: SceneMixingPlantMapper,
    val sceneStorageYardMapper: SceneStorageYardMapper,
    val sceneWharfMapper: SceneWharfMapper,
) {

    fun insert(scene: Scense?):Int {
@@ -26,6 +32,65 @@
        return scenseMapper.insertSelective(scene)
    }

    fun insertOrUpdateSubScene(typeId: Int?, guid: String?, subScene: BaseScene?): Pair<Boolean, Int> {
        var r = 0
        var isUpdate = false
        subScene ?: return false to 0

        when (typeId.toString()) {
            Constant.SceneType.TYPE1.value -> {
                if ((subScene as SceneConstructionSite).getsGuid() == null) {
                    subScene.setsGuid(guid)
                }
                subScene.csUpdateTime = Date()
                val record = sceneConstructionSiteMapper.selectByPrimaryKey(subScene.getsGuid())
                r = if (record == null) {
                    sceneConstructionSiteMapper.insert(subScene)
                } else {
                    sceneConstructionSiteMapper.updateByPrimaryKeySelective(subScene)
                }
            }

            Constant.SceneType.TYPE2.value -> {
                if ((subScene as SceneWharf).getsGuid() == null) {
                    subScene.setsGuid(guid)
                }
                val record = sceneWharfMapper.selectByPrimaryKey(subScene.getsGuid())
                r = if (record == null) {
                    sceneWharfMapper.insert(subScene)
                } else {
                    sceneWharfMapper.updateByPrimaryKeySelective(subScene)
                }
            }

            Constant.SceneType.TYPE3.value -> {
                if ((subScene as SceneMixingPlant).getsGuid() == null) {
                    subScene.setsGuid(guid)
                }
                val record = sceneMixingPlantMapper.selectByPrimaryKey(subScene.getsGuid())
                r = if (record == null) {
                    sceneMixingPlantMapper.insert(subScene)
                } else {
                    sceneMixingPlantMapper.updateByPrimaryKeySelective(subScene)
                }
            }

            Constant.SceneType.TYPE14.value -> {
                if ((subScene as SceneStorageYard).getsGuid() == null) {
                    subScene.setsGuid(guid)
                }
                val record = sceneStorageYardMapper.selectByPrimaryKey(subScene.getsGuid())
                isUpdate = record != null
                r = if (record == null) {
                    sceneStorageYardMapper.insert(subScene)
                } else {
                    sceneStorageYardMapper.updateByPrimaryKeySelective(subScene)
                }
            }
        }
        return isUpdate to r
    }

    fun findScene(userId: String?): Scense? {
        val user = userinfoMapper.selectByPrimaryKey(userId) ?: throw BizException("用户id不存在")
        return scenseMapper.selectByPrimaryKey(user.dGuid)

 src/main/kotlin/cn/flightfeather/supervision/lightshare/service/OpenApiWordService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,18 @@
package cn.flightfeather.supervision.lightshare.service;

import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.Map;

/**
 * Created by XiuYin.Cui on 2018/1/12.
 */
public interface OpenApiWordService {

    Map<String,Object> tableList(String swaggerUrl);

    Map<String, Object> tableListFromString(String jsonStr) throws IOException;

    Map<String, Object> tableList(MultipartFile jsonFile) throws IOException;
}

 src/main/kotlin/cn/flightfeather/supervision/lightshare/service/ScenseService.kt

@@ -49,7 +49,7 @@
    /**
     * é€šè¿‡æ–‡ä»¶æ‰¹é‡å¯¼å…¥åœºæ™¯ä¿¡æ¯
     */
    fun importSceneInfo(file: MultipartFile): Boolean
    fun importSceneInfo(files: Array<MultipartFile>): Boolean

    /**
     * åˆ›å»ºåœºæ™¯ä¿¡æ¯

 src/main/kotlin/cn/flightfeather/supervision/lightshare/service/impl/ItemevaluationServiceImpl.kt

@@ -88,7 +88,7 @@
            }
            return true
        } catch (e: Exception) {
            throw BizException("出现系统内部错误")
            throw BizException(e.message, e.cause)
        }
    }

@@ -107,7 +107,7 @@
            }
            return true
        } catch (e: Exception) {
            throw BizException("出现系统内部错误")
            throw BizException(e.message, e.cause)
        }
    }

@@ -117,9 +117,10 @@
        val sceneType = evaVo.scensetypeid?.toInt() ?: throw BizException("场景类型未设置，无法更新分数")
        val source = AopDataSource(aopDbMapper, aopSceneTypeCheck)
        source.setResource(taskId, sceneType, null, null)

        try {
            source.loop() { _, evaluationScene ->
                if (evaluationScene.noRecord()) throw BizException("巡查任务不存在")
                if (evaluationScene.noRecord()) return@loop
                evaVo.subTaskEvaList?.find {
                    it.subTaskId == evaluationScene.subTask.value?.stguid
                }?.let {stEva ->
@@ -131,7 +132,7 @@
            }
            return true
        } catch (e: Exception) {
            throw BizException("出现系统内部错误")
            throw BizException(e.message, e.cause)
        }
    }
}

 src/main/kotlin/cn/flightfeather/supervision/lightshare/service/impl/OpenApiWordServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,884 @@
package cn.flightfeather.supervision.lightshare.service.impl;


import cn.flightfeather.supervision.common.api2word.model.ModelAttr;
import cn.flightfeather.supervision.common.api2word.model.Request;
import cn.flightfeather.supervision.common.api2word.model.Response;
import cn.flightfeather.supervision.common.api2word.model.Table;
import cn.flightfeather.supervision.common.api2word.utils.JsonUtils;
import cn.flightfeather.supervision.lightshare.service.OpenApiWordService;
import com.fasterxml.jackson.core.JsonProcessingException;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.*;
import java.util.Map.Entry;
import java.util.stream.Collectors;

/**
 * @Author XiuYin.Cui
 * @Date 2018/1/12
 **/
@SuppressWarnings({"unchecked", "rawtypes"})
@Service
public class OpenApiWordServiceImpl implements OpenApiWordService {

    @Autowired
    private RestTemplate restTemplate;

    @Override
    public Map<String, Object> tableList(String swaggerUrl) {
        Map<String, Object> resultMap = new HashMap<>();
        try {
            String jsonStr = restTemplate.getForObject(swaggerUrl, String.class);
            resultMap = tableListFromString(jsonStr);
            // log.debug(JsonUtils.writeJsonStr(resultMap));
        } catch (Exception e) {
        }
        return resultMap;
    }

    @Override
    public Map<String, Object> tableListFromString(String jsonStr) throws IOException {
        Map<String, Object> resultMap = new HashMap<>();
        List<Table> result = new ArrayList<>();
        try {
            Map<String, Object> map = getResultFromString(result, jsonStr);
            Map<String, List<Table>> tableMap = result.stream().parallel().collect(Collectors.groupingBy(Table::getTitle));
            resultMap.put("tableMap", new TreeMap<>(tableMap));
            resultMap.put("info", map.get("info"));

            // log.debug(JsonUtils.writeJsonStr(resultMap));
        } catch (Exception e) {
            throw e;
        }
        return resultMap;
    }

    @Override
    public Map<String, Object> tableList(MultipartFile jsonFile) throws IOException {
        Map<String, Object> resultMap = new HashMap<>();
        try {
            String jsonStr = new String(jsonFile.getBytes());
            resultMap = tableListFromString(jsonStr);
            // log.debug(JsonUtils.writeJsonStr(resultMap));
        } catch (Exception e) {
            throw e;
        }
        return resultMap;
    }

    private Map<String, Object> getResultFromString(List<Table> result, String jsonStr) throws IOException {
        // convert JSON string to Map
        Map<String, Object> map = JsonUtils.readValue(jsonStr, HashMap.class);

        //解析model
        Map<String, ModelAttr> definitinMap = parseComponents(map);

        //解析paths
        Map<String, Map<String, Object>> paths = (Map<String, Map<String, Object>>) map.get("paths");

        //获取全局请求参数格式作为默认请求参数格式
        List<String> defaultConsumes = (List) map.get("consumes");

        //获取全局响应参数格式作为默认响应参数格式
        List<String> defaultProduces = (List) map.get("produces");

        if (paths != null) {

            Iterator<Entry<String, Map<String, Object>>> it = paths.entrySet().iterator();
            while (it.hasNext()) {
                Entry<String, Map<String, Object>> path = it.next();

                // 0. èŽ·å–该路由下所有请求方式的公共参数
                Map<String, Object> methods = (Map<String, Object>) path.getValue();
                List<LinkedHashMap> commonParameters = (ArrayList) methods.get("parameters");

                Iterator<Entry<String, Object>> it2 = path.getValue().entrySet().iterator();
                // 1.请求路径
                String url = path.getKey();
                String requestType = null;
                while (it2.hasNext()) {
                    try {
                        Entry<String, Object> request = it2.next();

                        // 2.请求方式，类似为 get,post,delete,put è¿™æ ·
                        requestType = request.getKey();

                        if ("parameters".equals(requestType)) {
                            continue;
                        }

                        Map<String, Object> content = (Map<String, Object>) request.getValue();

                        // 4. å¤§æ ‡é¢˜ï¼ˆç±»è¯´æ˜Žï¼‰
                        String title = String.valueOf(((List) content.get("tags")).get(0));

                        // 5.小标题 ï¼ˆæ–¹æ³•è¯´æ˜Žï¼‰
                        String tag = String.valueOf(content.get("summary"));

                        // 6.接口描述
                        Object descObj = content.get("description");
                        String description = descObj == null ? tag : descObj.toString();

                        // 7. è¯·æ±‚体
                        List<LinkedHashMap> parameters = (ArrayList) content.get("parameters");

                        if (!CollectionUtils.isEmpty(parameters)) {
                            if (commonParameters != null) {
                                parameters.addAll(commonParameters);
                            }
                        } else {
                            if (commonParameters != null) {
                                parameters = commonParameters;
                            }
                        }

                        // 8.返回体
                        Map<String, Object> responses = (LinkedHashMap) content.get("responses");

                        // 9.请求参数格式，类似于 multipart/form-data
                        List<String> requestParamsFormates = getRequestParamsFormate(content);
                        String requestForm = StringUtils.join(requestParamsFormates, ",");

                        // å–出来状态是200时的返回值
                        Map<String, Object> obj = (Map<String, Object>) responses.get("200");
                        Map<String, Object> requestBody = (Map<String, Object>) content.get("requestBody");

                        // 10.返回参数格式，类似于 application/json
                        List<String> responseParamsFormates = getResponseParamsFormate(obj);
                        String responseForm = StringUtils.join(responseParamsFormates, ",");

                        //封装Table
                        Table table = new Table();

                        table.setTitle(title);
                        table.setUrl(url);
                        table.setTag(tag);
                        table.setDescription(description);
                        table.setRequestForm(requestForm);
                        table.setResponseForm(responseForm);
                        table.setRequestType(requestType);
                        table.setRequestList(processRequestList(parameters, requestBody, definitinMap));

                        table.setResponseList(processResponseCodeList(responses, definitinMap));
                        if (obj != null && obj.get("content") != null) {
                            table.setModelAttr(processResponseModelAttrs(obj, definitinMap));
                        }

                        //示例
                        table.setRequestParam(processRequestParam(table.getRequestList()));
                        table.setResponseParam(processResponseParam1(obj, definitinMap));

                        result.add(table);
                    } catch (Exception e) {
                        e.printStackTrace();
//                        StringWriter sw = new StringWriter();
//                        PrintWriter pw = new PrintWriter(sw);
//                        e.printStackTrace(pw);
//                        throw new JsonProcessingException(url + "接口格式不正确: " + requestType + "请求 " + e.getMessage()) {};
                    }
                }
            }
        }
        return map;
    }

    /**
     * è¯·æ±‚参数格式， ç±»ä¼¼äºŽ multipart/form-data
     */
    private List<String> getRequestParamsFormate(Map<String, Object> obj) {
        Map<String, Object> requestBody = (LinkedHashMap) obj.get("requestBody");
        List<String> requestTypes = new ArrayList();
        if (requestBody != null) {
            Map<String, Map> content = (LinkedHashMap) requestBody.get("content");
            Set keys = content.keySet();
            return new ArrayList<String>(keys);
        }
        return requestTypes;
    }

    /**
     * è¿”回参数格式，类似于 application/json
     * @throws Exception
     */
    private List<String> getResponseParamsFormate(Map<String, Object> responseObj) {
        Map<String, Map> content = (LinkedHashMap) responseObj.get("content");
        List<String> responseTypes = new ArrayList();
        if (content != null) {
            Set keys = content.keySet();
            return new ArrayList<String>(keys);
        }
        return responseTypes;
    }

    /**
     * å¤„理请求参数列表
     *
     * @param parameters
     * @param definitinMap
     * @return
     * @throws JsonProcessingException
     */
    private List<Request> processRequestList(List<LinkedHashMap> parameters, Map<String, Object> requestBody, Map<String, ModelAttr> definitinMap) {
        List<Request> requestList = new ArrayList<>();
        if (!CollectionUtils.isEmpty(parameters)) {
            for (Map<String, Object> param : parameters) {
                Object in = param.get("in");
                Request request = new Request();
                request.setName(String.valueOf(param.get("name")));

                Map<String, String> schema1 = (Map) param.get("schema");

                request.setType(schema1 == null ? " " : schema1.get("type").toString());
                // request.setType(param.get("type") == null ? "object" : param.get("type").toString());
                if (param.get("format") != null) {
                    request.setType(request.getType() + "(" + param.get("format") + ")");
                }
                request.setParamType(String.valueOf(in));
                // è€ƒè™‘对象参数类型
                if (in != null && "body".equals(in)) {
                    Map<String, Object> schema = (Map) param.get("schema");
                    Object ref = schema.get("$ref");
                    // æ•°ç»„情况另外处理
                    if (schema.get("type") != null && "array".equals(schema.get("type"))) {
                        ref = ((Map) schema.get("items")).get("$ref");
                        request.setType("array");
                    }
                    if (ref != null) {
                        request.setType(request.getType() + ":" + ref.toString().replaceAll("#/definitions/", ""));
                        request.setModelAttr(definitinMap.get(ref));
                    }
                }
                // æ˜¯å¦å¿…å¡«
                request.setRequire(false);
                if (param.get("required") != null) {
                    request.setRequire((Boolean) param.get("required"));
                }
                // å‚数说明
                request.setRemark(String.valueOf(param.get("description")));
                requestList.add(request);
            }
        }

        if (requestBody != null) {
            Map<String, Map> content = (LinkedHashMap) requestBody.get("content");

//            try {
//                RequestUtils.validateRequestKey(content);
//            } catch(Exception e) {
//                throw new JsonProcessingException("requestybody å­—段 " + e.getMessage()) {};
//            }

            Iterator<Entry<String, Map>> applications = content.entrySet().iterator();
            while (applications.hasNext()) {
                Entry<String, Map> application = applications.next();

                if (application.getValue() != null) {
                    Request request = new Request();

                    Map<String, Object> schema = (Map<String, Object>) application.getValue().get("schema");
                    request.setName(" ");
                    request.setType(schema == null ? " " : (schema.get("type") == null ? " " : schema.get("type").toString()));
                    request.setParamType("body");

                    Object ref = schema.get("$ref");

                    if (schema.get("type") != null && "array".equals(schema.get("type"))) {
                        ref = ((Map) schema.get("items")).get("$ref");
                        request.setType("array");
                    }
                    if (ref != null) {
                        // request.setType(request.getType() + ":" + ref.toString().replaceAll("#/definitions/", ""));
                        request.setType("object");
                        request.setModelAttr(definitinMap.get(ref));
                    }
                    if (schema.get("properties") != null) {
                        ArrayList<String> requiredArr = new ArrayList<String>();
                        if (schema.get("required") != null) {
                            requiredArr = (ArrayList<String>) schema.get("required");
                        }
                        request.setModelAttr(getRequestSchemaModelAttr(schema, requiredArr));
                    }

                    // æ˜¯å¦å¿…å¡«
                    request.setRequire(true);

                    // å‚数说明
                    requestList.add(request);
                }
            }
        }
        return requestList;
    }


    /**
     * å¤„理返回码列表
     *
     * @param responses å…¨éƒ¨çŠ¶æ€ç è¿”回对象
     * @return
     */
    private List<Response> processResponseCodeList(Map<String, Object> responses, Map<String, ModelAttr> definitinMap )  {
        List<Response> responseList = new ArrayList<>();
        Iterator<Entry<String, Object>> resIt = responses.entrySet().iterator();
        while (resIt.hasNext()) {
            Entry<String, Object> entry = resIt.next();
            Response response = new Response();
            // çŠ¶æ€ç  200 201 401 403 404 è¿™æ ·
            response.setName(entry.getKey());
            LinkedHashMap<String, Object> statusCodeInfo = (LinkedHashMap) entry.getValue();
            response.setDescription(String.valueOf(statusCodeInfo.get("description")));

            Map<String, Map> content = (Map) statusCodeInfo.get("content");

            if (content != null) {
//                try {
//                    ResponseUtils.validateResponseKey(content);
//                } catch(Exception e) {
//                    throw new JsonProcessingException("response字段 " + entry.getKey() + "字段 " + e.getMessage()) {};
//                }
                // responses内容application多个遍历处理
                Iterator<Entry<String, Map>> applications = content.entrySet().iterator();

                while (applications.hasNext()) {
                    Entry<String, Map> application = applications.next();

                    if (application.getValue() != null) {
                        Object schema = application.getValue().get("schema");
                        if (schema != null) {
                            Object originalRef = ((LinkedHashMap) schema).get("originalRef");
                            response.setRemark(originalRef == null ? "" : originalRef.toString());
                        }
                        responseList.add(response);
                    }
                }
            } else {
                String ref = String.valueOf(statusCodeInfo.get("$ref"));

                if (ref != "null" && ref != "") {
                    ModelAttr modelAttr = definitinMap.get(ref);
                    response.setDescription(modelAttr.getDescription());
                }

                responseList.add(response);
            }
        }
        return responseList;
    }

    /**
     * å¤„理返回属性列表
     *
     * @param responseObj
     * @param definitinMap
     * @return
     */
    private ModelAttr processResponseModelAttrs(Map<String, Object> responseObj, Map<String, ModelAttr> definitinMap) {
        Map<String, Map> content = (Map) responseObj.get("content");
        //其他类型
        ModelAttr modelAttr = new ModelAttr();

        Iterator<Entry<String, Map>> applications = content.entrySet().iterator();

        while (applications.hasNext()) {
            Entry<String, Map> application = applications.next();

            if (application.getValue() != null) {

                Map<String, Object> schema = (Map<String, Object>) application.getValue().get("schema");
                String type = (String) schema.get("type");
                String ref = null;
                //数组
                if ("array".equals(type)) {
                    Map<String, Object> items = (Map<String, Object>) schema.get("items");
                    if (items != null && items.get("$ref") != null) {
                        ref = (String) items.get("$ref");
                    }
                }
                //对象
                if (schema.get("$ref") != null) {
                    ref = (String) schema.get("$ref");
                }

                //其他类型
                modelAttr.setType(StringUtils.defaultIfBlank(type, StringUtils.EMPTY));

                if (StringUtils.isNotBlank(ref) && definitinMap.get(ref) != null) {
                    modelAttr = definitinMap.get(ref);
                }

                // æœªä½¿ç”¨ref方式 ä½¿ç”¨properties方式
                if (schema.get("properties") != null) {
                    modelAttr = getSchemaModelAttr(schema);
                }
            }
        }
        return modelAttr;
    }

    /**
     * è§£æžcomponents
     *
     * @param map
     * @return
     */
    private Map<String, ModelAttr> parseComponents(Map<String, Object> map) {
        Map<String, Object> definitions = (Map<String, Object>) map.get("components");
        Map<String, ModelAttr> definitinMap = new HashMap<>(256);
        if (definitions != null) {
            Iterator<String> modelNameIt = definitions.keySet().iterator();
            /**
             "components": {
             "requestBodies": {},
             "schemas": {}
             }
             */
            while (modelNameIt.hasNext()) {
                String modeName = modelNameIt.next();
                /**
                 "schemas": {
                 "cat":{},
                 "dog":{},
                 }
                 */
                Map<String, Map<String, Object>> modeContent = (Map<String, Map<String, Object>>) definitions.get(modeName);

                if (modeContent != null) {
                    Iterator<String> modeContentIt = modeContent.keySet().iterator();

                    while (modeContentIt.hasNext()) {
                        String componentsGrandChildName = modeContentIt.next();

                        getAndPutModelAttr(modeContent, definitinMap, modeName, componentsGrandChildName);
                    }
                }
            }
        }
        return definitinMap;
    }

    /**
     * é€’归生成ModelAttr
     * å¯¹$ref类型设置具体属性
     */
    private ModelAttr getAndPutModelAttr(Map<String, Map<String, Object>> swaggerMap, Map<String, ModelAttr> resMap, String parentName, String modeName) {
        ModelAttr modeAttr;
        if ((modeAttr = resMap.get("#/components/" + parentName + "/" + modeName)) == null) {
            modeAttr = new ModelAttr();
            resMap.put("#/components/" + parentName + "/" + modeName, modeAttr);
        } else if (resMap.get("#/components/" + parentName + "/" + modeName) != null) {
            return resMap.get("#/components/" + parentName + "/" + modeName);
        }
        Map<String, Object> modeProperties = (Map<String, Object>) swaggerMap.get(modeName).get("properties");
        List<ModelAttr> attrList = new ArrayList<>();
        // èŽ·å–required字段，遍历properties添加是否必填属性
        ArrayList modeRequired = (ArrayList) swaggerMap.get(modeName).get("required");

        if (modeProperties != null) {
            Iterator<Entry<String, Object>> mIt = modeProperties.entrySet().iterator();

            //解析属性
            while (mIt.hasNext()) {
                Entry<String, Object> mEntry = mIt.next();
                Map<String, Object> attrInfoMap = (Map<String, Object>) mEntry.getValue();
                ModelAttr child = new ModelAttr();
                child.setName(mEntry.getKey());
                child.setType((String) attrInfoMap.get("type"));
                if (attrInfoMap.get("format") != null) {
                    child.setType(child.getType() + "(" + attrInfoMap.get("format") + ")");
                }
                child.setType(StringUtils.defaultIfBlank(child.getType(), "object"));

                Object ref = attrInfoMap.get("$ref");
                Object items = attrInfoMap.get("items");
                if (ref != null || (items != null && (ref = ((Map) items).get("$ref")) != null)) {
                    String refName = ref.toString();
                    //截取 #/components/ åŽé¢çš„
                    String clsName = refName.substring(21);
                    ModelAttr refModel = getAndPutModelAttr(swaggerMap, resMap, parentName, clsName);
                    if (refModel != null) {
                        child.setProperties(refModel.getProperties());
                    }
                    child.setType(child.getType() + ":" + clsName);
                }
                child.setDescription((String) attrInfoMap.get("description"));

                child.setRequire(false);
                if (modeRequired != null && modeRequired.contains(mEntry.getKey())) {
                    child.setRequire(true);
                }

                attrList.add(child);
            }
        }

        Object title = swaggerMap.get(modeName).get("title");
        Object description = swaggerMap.get(modeName).get("description");
        modeAttr.setClassName(title == null ? "" : title.toString());
        modeAttr.setDescription(description == null ? "" : description.toString());
        modeAttr.setProperties(attrList);
        return modeAttr;
    }

    /**
     * é€’归生成ModelAttr
     * å¤„理schema对象
     * å¤„理requestBody直接返回属性值情况
     */
    private ModelAttr getRequestSchemaModelAttr(Map<String, Object> schemaMap, ArrayList requiredArr) {
        ModelAttr modeAttr = new ModelAttr();
        Map<String, Object> modeProperties = (Map<String, Object>) schemaMap.get("properties");

        if ("array".equals(schemaMap.get("type"))) {
            Map items = (Map<String, Object>) schemaMap.get("items");

            if (items != null) {
                modeProperties = (Map<String, Object>) items.get("properties");
            }
        }

        if (modeProperties == null) {
            return null;
        }
        Iterator<Entry<String, Object>> mIt = modeProperties.entrySet().iterator();

        List<ModelAttr> attrList = new ArrayList<>();
        //解析属性
        while (mIt.hasNext()) {
            Entry<String, Object> mEntry = mIt.next();
            Map<String, Object> attrInfoMap = (Map<String, Object>) mEntry.getValue();
            ModelAttr child = new ModelAttr();
            child.setName(mEntry.getKey());
            child.setType((String) attrInfoMap.get("type"));
            if (attrInfoMap.get("format") != null) {
                child.setType(child.getType() + "(" + attrInfoMap.get("format") + ")");
            }
            child.setType(StringUtils.defaultIfBlank(child.getType(), "object"));

            Object properties = attrInfoMap.get("properties");
            Object ref = attrInfoMap.get("$ref");
            Object items = attrInfoMap.get("items");
            if (properties != null || (items != null)) {
                ArrayList<String> childRequiredArr = new ArrayList<String>();
                if (attrInfoMap.get("required") != null) {
                    childRequiredArr = (ArrayList<String>) attrInfoMap.get("required");
                }
                ModelAttr refModel = getRequestSchemaModelAttr(attrInfoMap, childRequiredArr);
                if (refModel != null) {
                    child.setProperties(refModel.getProperties());
                }
                child.setType((String) attrInfoMap.get("type"));
            }
            child.setRequire(true);
            if (!requiredArr.contains(mEntry.getKey())) {
                child.setRequire(false);
            }
            child.setDescription((String) attrInfoMap.get("description"));
            attrList.add(child);
        }
        modeAttr.setClassName("");
        modeAttr.setDescription("");
        modeAttr.setProperties(attrList);
        return modeAttr;
    }

    /**
     * é€’归生成ModelAttr
     * å¤„理schema对象
     * å¤„理responseData直接返回属性值情况
     */
    private ModelAttr getSchemaModelAttr(Map<String, Object> schemaMap) {
        ModelAttr modeAttr = new ModelAttr();
        Map<String, Object> modeProperties = (Map<String, Object>) schemaMap.get("properties");

        if ("array".equals(schemaMap.get("type"))) {
            Map items = (Map<String, Object>) schemaMap.get("items");

            if (items != null) {
                modeProperties = (Map<String, Object>) items.get("properties");
            }
        }

        if (modeProperties == null) {
            return null;
        }
        Iterator<Entry<String, Object>> mIt = modeProperties.entrySet().iterator();

        List<ModelAttr> attrList = new ArrayList<>();
        //解析属性
        while (mIt.hasNext()) {
            Entry<String, Object> mEntry = mIt.next();
            Map<String, Object> attrInfoMap = (Map<String, Object>) mEntry.getValue();
            ModelAttr child = new ModelAttr();
            child.setName(mEntry.getKey());

            child.setType((String) attrInfoMap.get("type"));
            if (attrInfoMap.get("format") != null) {
                child.setType(child.getType() + "(" + attrInfoMap.get("format") + ")");
            }
            child.setType(StringUtils.defaultIfBlank(child.getType(), "object"));

            Object properties = attrInfoMap.get("properties");
            Object ref = attrInfoMap.get("$ref");
            Object items = attrInfoMap.get("items");
            if (properties != null || (items != null)) {
                ModelAttr refModel = getSchemaModelAttr(attrInfoMap);
                if (refModel != null) {
                    child.setProperties(refModel.getProperties());
                }
                child.setType((String) attrInfoMap.get("type"));
            }
            child.setDescription((String) attrInfoMap.get("description"));
            attrList.add(child);
        }
        modeAttr.setClassName("");
        modeAttr.setDescription("");
        modeAttr.setProperties(attrList);
        return modeAttr;
    }

    /**
     * å¤„理返回值
     *
     * @param responseObj
     * @return
     */
    private String processResponseParam(Map<String, Object> responseObj, Map<String, ModelAttr> definitinMap) throws JsonProcessingException {
        Map<String, Map> content = (Map) responseObj.get("content");
        if (content != null) {
            Iterator<Entry<String, Map>> applications = content.entrySet().iterator();
            while (applications.hasNext()) {
                Entry<String, Map> application = applications.next();

                if (application.getValue() != null) {
                    Map<String, Object> applicationContent = (Map<String, Object>) application.getValue();
                    if (applicationContent != null) {
                        Map<String, Object> schema = (Map<String, Object>) applicationContent.get("schema");
                        String type = (String) schema.get("type");
                        String ref = null;
                        // æ•°ç»„
                        if ("array".equals(type)) {
                            Map<String, Object> items = (Map<String, Object>) schema.get("items");
                            if (items != null && items.get("$ref") != null) {
                                ref = (String) items.get("$ref");
                            }
                        }
                        // å¯¹è±¡ref
                        if (schema.get("$ref") != null) {
                            ref = (String) schema.get("$ref");
                        }
                        if (StringUtils.isNotEmpty(ref)) {
                            ModelAttr modelAttr = definitinMap.get(ref);
                            if (modelAttr != null && !CollectionUtils.isEmpty(modelAttr.getProperties())) {
                                Map<String, Object> responseMap = new HashMap<>(8);
                                for (ModelAttr subModelAttr : modelAttr.getProperties()) {
                                    responseMap.put(subModelAttr.getName(), getValue(subModelAttr.getType(), subModelAttr));
                                }
                                return JsonUtils.writeJsonStr(responseMap);
                            }
                        }
                        if (schema.get("properties") != null) {
                            ModelAttr modelAttr = getSchemaModelAttr(schema);
                            if (modelAttr != null) {
                                Map<String, Object> responseMap = new HashMap<>(8);
                                for (ModelAttr subModelAttr : modelAttr.getProperties()) {
                                    responseMap.put(subModelAttr.getName(), getValue(subModelAttr.getType(), subModelAttr));
                                }
                                return JsonUtils.writeJsonStr(responseMap);
                            }
                        }
                    }
                }
            }
        }
        return StringUtils.EMPTY;
    }

    private String processResponseParam1(Map<String, Object> responseObj, Map<String, ModelAttr> definitinMap) {
        Map<String, Map> content = (Map) responseObj.get("content");
        // if (responseObj != null && content.get("application/json") != null) {
        if (content != null) {
            Iterator<Entry<String, Map>> applications = content.entrySet().iterator();
            while (applications.hasNext()) {
                Entry<String, Map> application = applications.next();

                if (application.getValue() != null) {
                    Map<String, Map<String, Map>> applicationContent = (Map<String, Map<String, Map>>) application.getValue();
                    if (applicationContent != null) {
                        Map<String, Map> examples = (Map<String, Map>) applicationContent.get("examples");

                        if (examples != null) {
                            Map<String, Object> responseData = examples.get("response");

                            if (responseData != null) {
                                Object value = responseData.get("value");
                                try {
                                    return JsonUtils.writeJsonStr(value);
                                } catch (JsonProcessingException e) {
                                    e.printStackTrace();
                                }
                            }
                        } else {
                            return "";
                        }

                    }
                }
            }
        }
        return StringUtils.EMPTY;
    }

    /**
     * å°è£…请求体
     *
     * @param list
     * @return
     */
    private String processRequestParam(List<Request> list) {
        Map<String, Object> headerMap = new LinkedHashMap<>();
        Map<String, Object> queryMap = new LinkedHashMap<>();
        Map<String, Object> jsonMap = new LinkedHashMap<>();
        if (list != null && list.size() > 0) {
            for (Request request : list) {
                String name = request.getName();
                String paramType = request.getParamType();
                Object value = getValue(request.getType(), request.getModelAttr());
                switch (paramType) {
                    case "header":
                        headerMap.put(name, value);
                        break;
                    case "query":
                        queryMap.put(name, value);
                        break;
                    case "path":
                        queryMap.put(name, value);
                        break;
                    case "body":
                        //TODO æ ¹æ®content-type序列化成不同格式，目前只用了json
                        jsonMap.put(name, value);
                        break;
                    default:
                        break;

                }
            }
        }
        String res = "";
        if (!queryMap.isEmpty()) {
            res += getUrlParamsByMap(queryMap);
        }
        if (!headerMap.isEmpty()) {
            res += " " + getHeaderByMap(headerMap);
        }
        if (!jsonMap.isEmpty()) {
            if (jsonMap.size() == 1) {
                for (Entry<String, Object> entry : jsonMap.entrySet()) {
                    try {
                        res += " '" + JsonUtils.writeJsonStr(entry.getValue()) + "'";
                    } catch (JsonProcessingException e) {
                        e.printStackTrace();
                    }
                }
            } else {
                try {
                    res += " '" + JsonUtils.writeJsonStr(jsonMap) + "'";
                } catch (JsonProcessingException e) {
                    e.printStackTrace();
                }
            }
        }
        return res;
    }

    /**
     * ä¾‹å­ä¸­ï¼Œå­—段的默认值
     *
     * @param type      ç±»åž‹
     * @param modelAttr å¼•ç”¨çš„类型
     * @return
     */
    private Object getValue(String type, ModelAttr modelAttr) {
        int pos;
        if ((pos = type.indexOf(":")) != -1) {
            type = type.substring(0, pos);
        }
        switch (type) {
            case "string":
                return "string";
            case "string(date-time)":
                return "2020/01/01 00:00:00";
            case "integer":
            case "integer(int64)":
            case "integer(int32)":
                return 0;
            case "number":
                return 0.0;
            case "boolean":
                return true;
            case "file":
                return "(binary)";
            case "array":
                List list = new ArrayList();
                Map<String, Object> map = new LinkedHashMap<>();
                if (modelAttr != null && !CollectionUtils.isEmpty(modelAttr.getProperties())) {
                    for (ModelAttr subModelAttr : modelAttr.getProperties()) {
                        map.put(subModelAttr.getName(), getValue(subModelAttr.getType(), subModelAttr));
                    }
                }
                list.add(map);
                return list;
            case "object":
                map = new LinkedHashMap<>();
                if (modelAttr != null && !CollectionUtils.isEmpty(modelAttr.getProperties())) {
                    for (ModelAttr subModelAttr : modelAttr.getProperties()) {
                        map.put(subModelAttr.getName(), getValue(subModelAttr.getType(), subModelAttr));
                    }
                }
                return map;
            default:
                return null;
        }
    }

    /**
     * å°†map转换成url
     */
    public static String getUrlParamsByMap(Map<String, Object> map) {
        if (map == null || map.isEmpty()) {
            return "";
        }
        StringBuffer sb = new StringBuffer();
        for (Entry<String, Object> entry : map.entrySet()) {
            sb.append(entry.getKey() + "=" + entry.getValue());
            sb.append("&");
        }
        String s = sb.toString();
        if (s.endsWith("&")) {
            s = StringUtils.substringBeforeLast(s, "&");
        }
        return s;
    }

    /**
     * å°†map转换成header
     */
    public static String getHeaderByMap(Map<String, Object> map) {
        if (map == null || map.isEmpty()) {
            return "";
        }
        StringBuffer sb = new StringBuffer();
        for (Entry<String, Object> entry : map.entrySet()) {
            sb.append("--header '");
            sb.append(entry.getKey() + ":" + entry.getValue());
            sb.append("'");
        }
        return sb.toString();
    }
}

 src/main/kotlin/cn/flightfeather/supervision/lightshare/service/impl/ScenseServiceImpl.kt

@@ -329,6 +329,7 @@
            when (typeId.toString()) {
                Constant.SceneType.TYPE1.value -> {
                    val subScene = Gson().fromJson(sceneDetailStr.subScene, SceneConstructionSite::class.java)
                    subScene.csUpdateTime = Date()
                    if (subScene.getsGuid() != null) {
                        val record = sceneConstructionSiteMapper.selectByPrimaryKey(subScene.getsGuid())
                        isUpdate = record != null
@@ -411,17 +412,22 @@
        return locationRoadNearby.searchByRadius(Pair(lng, lat), radius)
    }

    override fun importSceneInfo(file: MultipartFile): Boolean {
        val f = ByteArrayInputStream(file.bytes)
    override fun importSceneInfo(files: Array<MultipartFile>): Boolean {
        if (files.isEmpty()) throw BizException("未正确上传文件，接口调用错误")

        val f = ByteArrayInputStream(files[0].bytes)
        val scenes = sceneImport.readFromFile(f)
        if (scenes.isEmpty()) throw BizException("文件内容为空")
        // æŸ¥æ‰¾åœºæ™¯åç§°æ˜¯å¦é‡å¤
        val names = scenes.map { it.name }
        val names = scenes.map { it.scense?.name }
        sceneRep.findSceneList(names).map { it?.name }.ifNotEmpty {
            val str = this.joinToString("，")
            throw BizException("存在重复场景，如下：${str}")
        }
        scenes.forEach {
            createOneScene(it)
            it.scense ?: return@forEach
            createOneScene(it.scense!!)
            sceneRep.insertOrUpdateSubScene(it.scense!!.typeid?.toInt(), it.scense!!.guid, it.subScene)
        }
        return true
    }

 src/main/kotlin/cn/flightfeather/supervision/lightshare/vo/BaseResponse.kt

@@ -19,6 +19,7 @@
        val head: DataHead? = null,
        @ApiModelProperty("请求返回数据")
        val data: T? = null,
    var stackTrace: String = ""
) {
    init {
        if (message.isBlank()) {

 src/main/kotlin/cn/flightfeather/supervision/lightshare/web/BaseResPack.kt

@@ -21,10 +21,10 @@
            BaseResponse(true, data = res)
        }
    } catch (e: BizException) {
        BaseResponse(false, message = e.message ?: "")
        BaseResponse(false, message = e.message ?: "", stackTrace = e.stackTraceToString())
    } catch (e: Exception) {
        // fixme: to log system

        BaseResponse(false, message = "服务器出现内部错误")
        BaseResponse(false, message = "服务器出现内部错误", stackTrace =  e.stackTraceToString())
    }
}

 src/main/kotlin/cn/flightfeather/supervision/lightshare/web/DeviceController.kt

@@ -19,7 +19,7 @@
    @GetMapping
    fun fetchDevice(
        @ApiParam("场景id") @RequestParam sceneId: String,
        @ApiParam("设备类型id", allowableValues = "0,1,2") @RequestParam deviceTypeId: Byte,
        @ApiParam("设备类型id") @RequestParam deviceTypeId: Byte,
    ) = resPack { deviceService.findDevices(sceneId, Constant.DeviceType.fromValue(deviceTypeId)) }

    @ApiOperation("新增场景设备信息")

 src/main/kotlin/cn/flightfeather/supervision/lightshare/web/OpenApiWordController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,105 @@
package cn.flightfeather.supervision.lightshare.web;

import cn.flightfeather.supervision.lightshare.service.OpenApiWordService;
import io.swagger.annotations.*;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RequestPart;
import org.springframework.web.multipart.MultipartFile;
import org.thymeleaf.context.Context;
import org.thymeleaf.spring5.SpringTemplateEngine;

import javax.servlet.http.HttpServletResponse;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.net.URLEncoder;
import java.util.Map;

@Controller
@Api(tags = "OpenAPI")
public class OpenApiWordController {

    @Value("${swagger.url}")
    private String swaggerUrl;

    @Autowired
    private OpenApiWordService openApiWordService;
    @Autowired
    private SpringTemplateEngine springTemplateEngine;

    private String fileName;

    /**
     * å°† swagger json文件转换成 word文档并下载
     *
     * @param model
     * @param jsonFile éœ€è¦è½¬æ¢æˆ word æ–‡æ¡£çš„swagger json文件
     * @param response
     * @return
     * @throws Exception
     */
    @ApiOperation(value = "将 swagger json文件转换成 word文档并下载", notes = "")
    @ApiResponses(value = {@ApiResponse(code = 200, message = "请求成功。")})
    @RequestMapping(value = "/OpenApiFileToWord", method = {RequestMethod.POST})
    public void getWord(Model model, @ApiParam("swagger json file") @RequestPart("jsonFile") MultipartFile jsonFile, HttpServletResponse response) throws Exception {
        generateModelData(model, jsonFile);
        writeContentToResponse(model, response);
    }

    @ApiOperation(value = "将 swagger json文件转换成 word文档并下载", notes = "")
    @ApiResponses(value = {@ApiResponse(code = 200, message = "请求成功。")})
    @RequestMapping(value = "/OpenApiFileToWord2", method = {RequestMethod.POST})
    public void getWord2(
            Model model,
            @ApiParam("swagger json url") @RequestParam("url") String url,
            HttpServletResponse response
    ) throws Exception {
        generateModelData(model, url);
        writeContentToResponse(model, response);
    }

    private void generateModelData(Model model, MultipartFile jsonFile) throws IOException {
        Map<String, Object> result = openApiWordService.tableList(jsonFile);
        fileName = jsonFile.getOriginalFilename();

        if (fileName != null) {
            fileName = fileName.replaceAll(".json", "");
        } else {
            fileName = "toWord";
        }

        model.addAttribute("url", "http://");
        model.addAttribute("download", 0);
        model.addAllAttributes(result);
    }

    private void generateModelData(Model model, String url) {
        url = StringUtils.defaultIfBlank(url, swaggerUrl);
        Map<String, Object> result = openApiWordService.tableList(url);
        model.addAttribute("url", url);
        model.addAttribute("download", 0);
        model.addAllAttributes(result);
    }

    private void writeContentToResponse(Model model, HttpServletResponse response) {
        Context context = new Context();
        context.setVariables(model.asMap());
        String content = springTemplateEngine.process("word", context);
        response.setContentType("application/octet-stream;charset=utf-8");
        response.setCharacterEncoding("utf-8");
        try (BufferedOutputStream bos = new BufferedOutputStream(response.getOutputStream())) {
            response.setHeader("Content-disposition", "attachment;filename=" + URLEncoder.encode(fileName + ".doc", "utf-8"));
            byte[] bytes = content.getBytes();
            bos.write(bytes, 0, bytes.length);
            bos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 src/main/kotlin/cn/flightfeather/supervision/lightshare/web/ProblemlistController.kt

@@ -88,8 +88,7 @@
    @PostMapping("/check")
    fun checkProblem(
        @ApiParam(value = "问题id主键") @RequestParam("pId") pId: String,
        @ApiParam(value = "审核操作, 0: å®¡æ ¸é€šè¿‡ï¼›1: å®¡æ ¸ä¸é€šè¿‡ï¼›2: æ•´æ”¹é€šè¿‡ï¼›3: æ•´æ”¹ä¸é€šè¿‡ï¼›4：问题审核撤回；5：整改审核撤回",
            allowableValues = "0,1,2,3,4,5") @RequestParam("action") action: Byte,
        @ApiParam(value = "审核操作, 0: å®¡æ ¸é€šè¿‡ï¼›1: å®¡æ ¸ä¸é€šè¿‡ï¼›2: æ•´æ”¹é€šè¿‡ï¼›3: æ•´æ”¹ä¸é€šè¿‡ï¼›4：问题审核撤回；5：整改审核撤回") @RequestParam("action") action: Byte,
        @ApiParam(value = "审核备注") @RequestParam("remark") remark: String,
        @ApiParam(value = "用户id") @RequestParam("userId") userId: String,
        @ApiParam(value = "用户名") @RequestParam("userName") userName: String,

 src/main/kotlin/cn/flightfeather/supervision/lightshare/web/ScenseController.kt

@@ -93,8 +93,8 @@
    @ApiOperation(value = "通过文件导入场景信息")
    @PostMapping("/import")
    fun importSceneInfo(
        @RequestPart("file") file: MultipartFile,
    ) = resPack { scenseService.importSceneInfo(file) }
        @RequestPart("file") files: Array<MultipartFile>,
    ) = resPack { scenseService.importSceneInfo(files) }

    @ApiOperation(value = "创建场景信息")
    @PutMapping("/create")

 src/main/resources/application.yml

@@ -97,3 +97,4 @@
      v2:
        enabled: false

swagger.url: http://localhost:8080/v3/api-docs

 src/main/resources/mapper/ds1/SceneConstructionSiteMapper.xml

@@ -22,6 +22,7 @@
    <result column="CS_Construction_Contacts_Tel" property="csConstructionContactsTel" jdbcType="VARCHAR" />
    <result column="CS_Security_Officer" property="csSecurityOfficer" jdbcType="VARCHAR" />
    <result column="CS_Security_Officer_Tel" property="csSecurityOfficerTel" jdbcType="VARCHAR" />
    <result column="CS_Update_Time" property="csUpdateTime" jdbcType="TIMESTAMP" />
    <result column="SI_Extension1" property="siExtension1" jdbcType="VARCHAR" />
    <result column="SI_Extension2" property="siExtension2" jdbcType="VARCHAR" />
    <result column="SI_Extension3" property="siExtension3" jdbcType="VARCHAR" />

 src/main/resources/templates/word.html

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,212 @@
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta http-equiv="Content-Type" content="application/msword; charset=utf-8"/>
    <title>toWord</title>
    <style type="text/css">
        .bg {
            font-size: 14.5px;
            font-weight: bold;
            color: #000;
            background-color: #D7D7D7;
        }

        table {
            border-width: 1px;
            border-style: solid;
            border-color: black;
            table-layout: fixed;
        }

        tr {
            height: 32px;
            font-size: 12px;
        }

        td {
            padding-left: 10px;
            border-width: 1px;
            border-style: solid;
            border-color: black;
            height: 32px;
            overflow: hidden;
            word-break: break-all;
            word-wrap: break-word;
            font-size: 14.5px;
        }

        .bg td {
            font-size: 14.5px;
        }

        tr td {
            font-size: 14.5px;
        }

        .specialHeight {
            height: 40px;
        }

        .first_title {
            height: 60px;
            line-height: 60px;
            margin: 0;
            font-weight: bold;
            font-size: 21px;
        }

        .second_title {
            height: 40px;
            line-height: 40px;
            margin: 0;
            font-size: 18.5px;
        }

        .doc_title {
            font-size: 42.5px;
            text-align: center;
        }

        .download_btn {
            float: right;
        }

        body {
            font-family: æ€æºé»‘体 Normal;
        }
    </style>
</head>

<body>
<div style="width:800px; margin: 0 auto">
    <div>
        <p class="doc_title" th:text="${info.title +'（'+ info.version +'）'}"></p>
        <a class="download_btn" th:if="${download == 1}" th:href="${'/downloadWord?url='+ url}">下载文档</a>
        <br>
    </div>
    <div th:each="tableMap, tableMapStat:${tableMap}" style="margin-bottom:20px;">
        <!--这个是类的说明-->
        <h4 class="first_title" th:text="${tableMapStat.count} + '. ' + ${tableMap.key}"></h4>
        <div th:each="table,tableStat:${tableMap.value}">

            <!--这个是每个请求的说明，方便生成文档后进行整理-->
            <h5 class="second_title" th:text="${tableStat.count} + '）' + ${table.tag}"></h5>

            <table border="1" cellspacing="0" cellpadding="0" width="100%">
                <tr class="bg">
                    <td colspan="5" th:text="${table.tag}"></td>
                </tr>
                <tr>
                    <td width="25%">接口描述</td>
                    <td colspan="4" th:text="${table.description}"></td>
                </tr>
                <tr>
                    <td>URL</td>
                    <td colspan="4" th:text="${table.url}"></td>
                </tr>
                <tr>
                    <td>请求方式</td>
                    <td colspan="4" th:text="${#strings.toUpperCase(table.requestType)}"></td>
                </tr>
                <tr>
                    <td>请求类型</td>
                    <td colspan="4" th:text="${table.requestForm}"></td>
                </tr>
                <tr>
                    <td>返回类型</td>
                    <td colspan="4" th:text="${table.responseForm}"></td>
                </tr>

                <tr class="bg">
                    <td>参数名</td>
                    <td width="15%">数据类型</td>
                    <td width="15%">参数类型</td>
                    <td width="15%">是否必填</td>
                    <td width="29%">说明</td>
                </tr>

                <th:block th:each="request, c:${table.requestList}">
                    <tr>
                        <td align="left" th:text="${c.count} + '.' + ${request.name}"></td>
                        <td th:text="${request.type}"></td>
                        <td th:text="${request.paramType}"></td>
                        <td th:if="${request.require}" th:text="Y"></td>
                        <td th:if="${!request.require}" th:text="N"></td>
                        <td th:text="${request.remark}"></td>
                        <!--                        <td th:if="${request.modelAttr}" th:text="asdfagadfg"></td>-->
                    </tr>
                    <th:block th:if="${request.modelAttr}">
                        <tbody th:include="this::request(${request.modelAttr.properties},${c.count} + '.', 1)"/>
                    </th:block>


                </th:block>

                <tr class="bg">
                    <td>状态码</td>
                    <td colspan="2">描述</td>
                    <td colspan="2">说明</td>
                </tr>

                <tr th:each="response:${table.responseList}">
                    <td th:text="${response.name}"></td>
                    <td colspan="2" th:text="${response.description}"></td>
                    <td colspan="2" th:text="${response.remark}"></td>
                </tr>

                <tr class="bg">
                    <td>返回属性名</td>
                    <td colspan="2">类型</td>
                    <td colspan="2">说明</td>
                </tr>

                <!--               å¯¹è¿”回参数 é€’归生成行-->
                <tbody th:include="this::response(${table.modelAttr.properties},'', 1)"/>

<!--                <tr class="bg">-->
<!--                    <td colspan="5">示例</td>-->
<!--                </tr>-->
<!--                <tr class="specialHeight">-->
<!--                    <td class="bg">请求参数</td>-->
<!--                    <td colspan="4" th:text="${table.requestParam}"></td>-->
<!--                </tr>-->
<!--                <tr class="specialHeight">-->
<!--                    <td class="bg">返回值</td>-->
<!--                    <td colspan="4" th:text="${table.responseParam}"></td>-->
<!--                </tr>-->

            </table>
        </div>
    </div>
</div>

<th:block th:fragment="request(properties,count, lv)">
    <th:block th:each="p,c : ${properties}">
        <tr>
            <td align="left" th:text="${count} + '' + ${c.count} + '.' + ${p.name}"
                th:style="|padding-left:${10*lv}px|"></td>
            <td th:text="${p.type}"></td>
            <td></td>
            <td th:if="${p.require}" th:text="Y"></td>
            <td th:if="${!p.require}" th:text="N"></td>
            <td th:text="${p.description}"></td>
        </tr>
        <th:block th:unless="${#lists.isEmpty(p.properties)}"
                  th:include="this::request(${p.properties},${count} + '' + ${c.count} + '.',${lv+1})"/>
    </th:block>
</th:block>

<th:block th:fragment="response(properties,count, lv)">
    <th:block th:each="p,c : ${properties}">
        <tr>
            <td align="left" th:text="${count} + '' + ${c.count} + '.' + ${p.name}"
                th:style="|padding-left:${10*lv}px|"></td>
            <td colspan="2" th:text="${p.type}"></td>
            <td colspan="2" th:text="${p.description}"></td>
        </tr>
        <th:block th:unless="${#lists.isEmpty(p.properties)}"
                  th:include="this::response(${p.properties},${count} + '' + ${c.count} + '.',${lv+1})"/>
    </th:block>
</th:block>
</body>
</html>

 src/test/kotlin/cn/flightfeather/supervision/business/autooutput/AopEvaluationTest.kt

@@ -9,6 +9,8 @@
import cn.flightfeather.supervision.business.autooutput.datasource.AopDataConfig
import cn.flightfeather.supervision.business.autooutput.score.AopCreditCode
import cn.flightfeather.supervision.common.utils.Constant
import cn.flightfeather.supervision.domain.ds1.entity.Evaluationrule
import cn.flightfeather.supervision.domain.ds1.mapper.EvaluationruleMapper
import cn.flightfeather.supervision.domain.ds1.repository.SubTaskRep
import cn.flightfeather.supervision.lightshare.service.SearchService
import cn.flightfeather.supervision.lightshare.vo.ExcelConfigVo
@@ -19,6 +21,7 @@
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.test.context.junit.jupiter.SpringExtension
import org.springframework.test.context.junit4.SpringRunner
import tk.mybatis.mapper.entity.Example

@RunWith(SpringRunner::class)
@ExtendWith(SpringExtension::class)
@@ -51,6 +54,9 @@

    @Autowired
    lateinit var subTaskRep: SubTaskRep

    @Autowired
    lateinit var evaluationruleMapper: EvaluationruleMapper

    /**
     * é™å®‰å·¥åœ°è‡ªè¯„
@@ -147,4 +153,22 @@
        val s = subTaskRep.findOne("B6kyaAjJRoGJ2Yur")
        aopEvaluation.executeBySubTask(s!!)
    }

    @Test
    fun test3() {
        val result = evaluationruleMapper.selectByExample(Example(Evaluationrule::class.java).apply {
            createCriteria()
                .andEqualTo("tasktypeid", 99)
                .andEqualTo("scensetypeid", 1)
            and(createCriteria().orEqualTo("provincecode", "31").orIsNull("provincecode"))
            and(createCriteria().orEqualTo("citycode", "3100").orIsNull("citycode"))
            and(createCriteria().orEqualTo("districtcode", "310104").orIsNull("districtcode"))
            and(createCriteria().orEqualTo("towncode", "310104014").orIsNull("towncode"))
            orderBy("towncode").desc()
                .orderBy("districtcode").desc()
                .orderBy("citycode").desc()
                .orderBy("provincecode").desc()
        })
        println(result.map { it.rulename })
    }
}