feat(web): swagger解析，以及数据导入(不包括用例导入)

kt-base/src/main/java/org/matrix/testNg/xml/reportXml/ReporterData.java

@@ -70,7 +70,7 @@ public class ReporterData {
 //            Map<Long, List<TestDataExecuteResult>> longListMap = ReporterUtils.userResultMap.get(1L);
 //            Set<Long> longs = longListMap.keySet();
 //            for (Long caseId : longs) {
-//                TestCase testCase = java.util.Optional.of(testCaseService.getById(caseId))
+//                Case testCase = java.util.Optional.of(testCaseService.getById(caseId))
 //                        .orElseThrow(() -> new GlobalException(String.format("没有找到id = %d 的TestCase", caseId)));
 //                testDataExecuteResults = ReporterUtils.resultMap.get(caseId);
 //                for (TestDataExecuteResult testDataExecuteResult : testDataExecuteResults) {

kt-database/src/main/java/org/matrix/entity/Case.java

+package org.matrix.entity;
+
+import com.baomidou.mybatisplus.annotation.FieldFill;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import org.matrix.entity.BaseEntity;
+
+/**
+ * <p>
+ * 测试用例表，测试的平台的主体数据
+ * </p>
+ *
+ * @author mry
+ * @since 2022-07-18
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@AllArgsConstructor
+@NoArgsConstructor
+@TableName(value = "test_case")
+@ApiModel(value = "TestCase对象", description = "测试用例")
+public class Case extends BaseEntity {
+
+    /**
+     * 名称
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("名称")
+    private String name;
+
+    /**
+     * 接口文档id
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("接口文档id")
+    private Long docId;
+
+    /**
+     * 参数详情(包括参数值)
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("参数详情(包括参数值)")
+    private String parameters;
+
+    /**
+     * 前置动作id
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("前置动作id")
+    private Long moveBefore;
+
+    /**
+     * 后置动作id
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("后置动作id")
+    private Long moveAfter;
+
+    /**
+     * 项目id
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("项目id")
+    private Long projectId;
+
+    /**
+     * 环境id
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("环境id")
+    private Long envId;
+
+}

kt-database/src/main/java/org/matrix/entity/InterfaceDoc.java

+package org.matrix.entity;
+
+import com.baomidou.mybatisplus.annotation.FieldFill;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import org.matrix.enums.SyncStatus;
+
+/**
+ * <p>
+ *
+ * </p>
+ *
+ * @author mry
+ * @since 2022-07-18
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@AllArgsConstructor
+@NoArgsConstructor
+@TableName(value = "kt_interface_doc")
+@ApiModel(value = "InterfaceDoc对象", description = "接口文档")
+public class InterfaceDoc extends BaseEntity {
+
+    /**
+     * 名称
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("名称")
+    private String summary;
+
+    /**
+     * 说明
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("说明")
+    private String des;
+
+    /**
+     * 请求方式
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("请求方式")
+    private String httpMethod;
+
+    /**
+     * 接口相对路径
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("接口相对路径")
+    private String pathUrl;
+
+    /**
+     * 参数详情(整段json)
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("参数详情(整段json)")
+    private String parameters;
+
+    /**
+     * 返回值信息(整段json)
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("返回值信息(整段json)")
+    private String responses;
+
+    /**
+     * 项目id
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("项目id")
+    private Long projectId;
+
+    /**
+     * 环境id
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("环境id")
+    private Long envId;
+
+    /**
+     * 分组id
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("分组id")
+    private Long interfaceGroupId;
+
+    /**
+     * 同步状态
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("同步状态")
+    private SyncStatus status;
+
+    /**
+     * 开发状态
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("开发状态")
+    private String devStatus;
+
+    /**
+     * 负责人
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("负责人")
+    private String dutyPeople;
+
+}

kt-database/src/main/java/org/matrix/entity/InterfaceGrouping.java

+package org.matrix.entity;
+
+import com.baomidou.mybatisplus.annotation.FieldFill;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+
+/**
+ * <p>
+ *
+ * </p>
+ *
+ * @author mry
+ * @since 2022-07-18
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@AllArgsConstructor
+@NoArgsConstructor
+@TableName(value = "kt_interface_grouping")
+@ApiModel(value = "InterfaceGrouping对象", description = "接口分组")
+public class InterfaceGrouping extends BaseEntity {
+
+    /**
+     * 名称（标签/分组(存在根目录)）
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("名称（标签/分组(存在根目录)）")
+    private String tag;
+
+    /**
+     * 说明
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("说明")
+    private String des;
+
+    /**
+     * 环境id
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("环境id")
+    private Long envId;
+
+    /**
+     * 项目id
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("项目id")
+    private Long projectId;
+
+    /**
+     * 前置操作id
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("前置操作id")
+    private Long moveBefore;
+
+    /**
+     * 后置操作id
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("后置操作id")
+    private Long moveAfter;
+
+    /**
+     * 父类id(根目录默认为0)
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("父类id(根目录默认为0)")
+    private Long interfaceGroupingId;
+
+}

kt-database/src/main/java/org/matrix/entity/MouldDoc.java

+package org.matrix.entity;
+
+import com.baomidou.mybatisplus.annotation.FieldFill;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import org.matrix.enums.SyncStatus;
+
+/**
+ * <p>
+ *
+ * </p>
+ *
+ * @author mry
+ * @since 2022-07-18
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@AllArgsConstructor
+@NoArgsConstructor
+@TableName(value = "kt_mould_doc")
+@ApiModel(value = "MouldDoc对象", description = "模型文档")
+public class MouldDoc extends BaseEntity {
+
+    /**
+     * 项目id
+     */
+    @ApiModelProperty("项目id")
+    private Long projectId;
+
+    /**
+     * 名称
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("名称")
+    private String objName;
+
+    /**
+     * 分组id
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("分组id")
+    private Long mouldGroupingId;
+
+    /**
+     * 备注
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("备注")
+    private String remarks;
+
+    /**
+     * 属性
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("属性")
+    private String attributeOutVo;
+
+    /**
+     * 同步状态
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("同步状态")
+    private SyncStatus status;
+
+}

kt-database/src/main/java/org/matrix/entity/MouldGrouping.java

+package org.matrix.entity;
+
+import com.baomidou.mybatisplus.annotation.FieldFill;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+
+/**
+ * <p>
+ *
+ * </p>
+ *
+ * @author mry
+ * @since 2022-07-18
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@AllArgsConstructor
+@NoArgsConstructor
+@TableName(value = "kt_mould_grouping")
+@ApiModel(value = "MouldGrouping对象", description = "模型分组")
+public class MouldGrouping extends BaseEntity {
+
+    /**
+     * 项目id
+     */
+    @ApiModelProperty("项目id")
+    private Long projectId;
+
+    /**
+     * 名称
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("名称")
+    private String name;
+
+    /**
+     * 父类id(默认为0)
+     */
+    @TableField(fill = FieldFill.UPDATE)
+    @ApiModelProperty("父类id(默认为0)")
+    private Long mouldId;
+
+}

kt-database/src/main/java/org/matrix/enums/SwaggerDataType.java

+package org.matrix.enums;
+
+import com.baomidou.mybatisplus.annotation.EnumValue;
+import com.fasterxml.jackson.annotation.JsonValue;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * swagger导入数据类型
+ *
+ * @author mruny
+ * @create 2022/7/19 16:03:33
+ */
+@AllArgsConstructor
+@Getter
+public enum SwaggerDataType {
+
+    /**
+     * 接口/文档
+     */
+    INTERFACE_DOC(0, "接口/文档"),
+
+    /**
+     * 数据模型
+     */
+    MOULD_DOC(1, "数据模型"),
+
+    /**
+     * 环境
+     */
+    ENV(2,"环境"),
+
+    /**
+     * 测试用例
+     */
+    TEST_CAST(3,"测试用例"),
+
+    /**
+     * 测试套件
+     */
+    TEST_SUITE(4,"测试套件");
+
+    @EnumValue
+    @JsonValue
+    private final int code;
+
+    /**
+     * 描述
+     */
+    private final String des;
+}

kt-database/src/main/java/org/matrix/enums/SyncStatus.java

+package org.matrix.enums;
+
+import com.baomidou.mybatisplus.annotation.EnumValue;
+import com.fasterxml.jackson.annotation.JsonValue;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * 同步状态
+ *
+ * @author mruny
+ * @create 2022/7/20 17:12:20
+ */
+@AllArgsConstructor
+@Getter
+public enum SyncStatus {
+
+    /**
+     * 覆盖
+     */
+    UPDATE(0, "更新"),
+
+    /**
+     * 新增
+     */
+    INSERT(1, "新增"),
+
+    /**
+     * 复制
+     */
+    COPY(2, "同时存在"),
+
+    /**
+     * 未同步
+     */
+    NO(3, "未同步"),
+
+    /**
+     * 上次忽略的
+     */
+    IGNORE(4,"上次忽略的"),
+
+    /**
+     * 上次导入不存在
+     */
+    OTHER(4, "上次导入不存在");
+
+    @EnumValue
+    @JsonValue
+    private final int code;
+
+    /**
+     * 描述
+     */
+    private final String des;
+}

kt-database/src/main/java/org/matrix/mapper/CaseMapper.java

+package org.matrix.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.matrix.entity.Case;
+import org.springframework.stereotype.Repository;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 11:25:28
+ */
+@Repository
+public interface CaseMapper extends BaseMapper<Case> {
+}

kt-database/src/main/java/org/matrix/mapper/InterfaceDocMapper.java

+package org.matrix.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.matrix.entity.InterfaceDoc;
+import org.springframework.stereotype.Repository;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 11:23:41
+ */
+@Repository
+public interface InterfaceDocMapper extends BaseMapper<InterfaceDoc> {
+}

kt-database/src/main/java/org/matrix/mapper/InterfaceGroupingMapper.java

+package org.matrix.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.matrix.entity.InterfaceGrouping;
+import org.springframework.stereotype.Repository;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 11:24:25
+ */
+@Repository
+public interface InterfaceGroupingMapper extends BaseMapper<InterfaceGrouping> {
+}

kt-database/src/main/java/org/matrix/mapper/MouldDocMapper.java

+package org.matrix.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.matrix.entity.MouldDoc;
+import org.springframework.stereotype.Repository;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 11:24:50
+ */
+@Repository
+public interface MouldDocMapper extends BaseMapper<MouldDoc> {
+}

kt-database/src/main/java/org/matrix/mapper/MouldGroupingMapper.java

+package org.matrix.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.matrix.entity.MouldGrouping;
+import org.springframework.stereotype.Repository;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 11:25:10
+ */
+@Repository
+public interface MouldGroupingMapper extends BaseMapper<MouldGrouping> {
+}

kt-database/src/main/java/org/matrix/service/ICaseService.java

+package org.matrix.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import org.matrix.entity.Case;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 11:28:08
+ */
+public interface ICaseService extends IService<Case> {
+}

kt-database/src/main/java/org/matrix/service/IEnvironmentService.java

@@ -3,6 +3,7 @@ package org.matrix.service;
 import com.baomidou.mybatisplus.core.conditions.Wrapper;
 import com.baomidou.mybatisplus.extension.service.IService;
 import org.matrix.entity.Environment;
+import org.matrix.vo.StatusCode;
 
 /**
  * <p>
@@ -20,4 +21,12 @@ public interface IEnvironmentService extends IService<Environment> {
      * @param wrappers
      */
     Boolean setIsDefaultByWrapper(Boolean isDefault, Wrapper wrappers);
+
+    /**
+     * swagger导入环境
+     *
+     * @param environment 环境对象
+     * @return 导入结果
+     */
+    StatusCode importEnv(Environment environment);
 }

kt-database/src/main/java/org/matrix/service/IInterfaceDocService.java

+package org.matrix.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import org.matrix.entity.InterfaceDoc;
+import org.matrix.vo.InterfaceVo;
+import org.matrix.vo.StatusCode;
+
+import java.util.List;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 11:26:10
+ */
+public interface IInterfaceDocService extends IService<InterfaceDoc> {
+    /**
+     * 导入接口文档
+     *
+     * @param interfaceVos 接口文档VO类
+     * @param projectId    项目id
+     * @param envId        环境id
+     * @param pattern      导入方式(1:同url覆盖,2:同url同组覆盖,3:同url不同步,4:同url同组不同步,5:同时保留)
+     * @param interfaceId  上级分组
+     * @param bool         是否导入测试用例
+     * @return 导入结果
+     */
+    StatusCode importInterfaceDoc(List<InterfaceVo> interfaceVos, Long projectId, Long envId, int pattern, Long interfaceId, boolean bool);
+}

kt-database/src/main/java/org/matrix/service/IInterfaceGroupingService.java

+package org.matrix.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import org.matrix.entity.InterfaceGrouping;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 11:26:46
+ */
+public interface IInterfaceGroupingService extends IService<InterfaceGrouping> {
+    /**
+     * 删除分组，以及分组下的所有
+     *
+     * @param id 接口分组主键id
+     */
+    void removeInterfaceGrouping(Long id);
+}

kt-database/src/main/java/org/matrix/service/IMouldDocService.java

+package org.matrix.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import org.matrix.entity.MouldDoc;
+import org.matrix.vo.StatusCode;
+
+import java.util.List;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 11:27:17
+ */
+public interface IMouldDocService extends IService<MouldDoc> {
+
+    /**
+     * 导入数据模型文档
+     *
+     * @param mouldDocs 数据模型文档对象集合
+     * @param projectId 项目id
+     * @param pattern   导入方式(1:同名覆盖,2:同名同组覆盖,3:同名不同步,4:同名同组不同步,5:同时保留)
+     * @param mouldId   上级分组
+     * @return 导入结果
+     */
+    StatusCode importMouldDoc(List<MouldDoc> mouldDocs, Long projectId, int pattern, Long mouldId);
+
+}

kt-database/src/main/java/org/matrix/service/IMouldGroupingService.java

+package org.matrix.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import org.matrix.entity.MouldGrouping;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 11:27:36
+ */
+public interface IMouldGroupingService extends IService<MouldGrouping> {
+
+    /**
+     * 删除分组，以及分组下的所有
+     *
+     * @param id 数据模型分组主键id
+     */
+    void removeMould(Long id);
+}

kt-database/src/main/java/org/matrix/service/impl/CaseServiceImpl.java

+package org.matrix.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.matrix.entity.Case;
+import org.matrix.mapper.CaseMapper;
+import org.matrix.service.ICaseService;
+import org.springframework.stereotype.Service;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 11:29:39
+ */
+@Service
+public class CaseServiceImpl extends ServiceImpl<CaseMapper, Case> implements ICaseService {
+}

kt-database/src/main/java/org/matrix/service/impl/EnvironmentServiceImpl.java

@@ -3,8 +3,12 @@ package org.matrix.service.impl;
 import com.baomidou.mybatisplus.core.conditions.Wrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import org.matrix.entity.Environment;
+import org.matrix.enums.SwaggerDataType;
+import org.matrix.exception.GlobalException;
 import org.matrix.mapper.EnvironmentMapper;
 import org.matrix.service.IEnvironmentService;
+import org.matrix.vo.StatusCode;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.util.Optional;
@@ -20,11 +24,32 @@ import java.util.Optional;
 @Service
 public class EnvironmentServiceImpl extends ServiceImpl<EnvironmentMapper, Environment> implements IEnvironmentService {
 
+    @Autowired
+    private EnvironmentMapper environmentMapper;
+
     @Override
     public Boolean setIsDefaultByWrapper(Boolean isDefault, Wrapper wrappers) {
         Environment environment = new Environment();
         environment.setIsDefault(isDefault);
         return Optional.of(this
-                .update(environment,wrappers)).get();
+                .update(environment, wrappers)).get();
+    }
+
+    @Override
+    public StatusCode importEnv(Environment environment) {
+        int saveNum = 0;
+        int updateNum = 0;
+        int ignoreNum = 0;
+        StatusCode statusCode = new StatusCode();
+        statusCode.setSwaggerDataType(SwaggerDataType.ENV);
+        if (environment != null && environment.getIp() != null) {
+            Integer integer = Optional.of(environmentMapper.insert(environment)).orElseThrow(() -> new GlobalException("添加失败"));
+            saveNum = saveNum + integer;
+        }
+        statusCode.setSaveNum(saveNum);
+        statusCode.setSaveNum(saveNum);
+        statusCode.setUpdateNum(updateNum);
+        statusCode.setIgnoreNum(ignoreNum);
+        return statusCode;
     }
 }

kt-database/src/main/java/org/matrix/service/impl/InterfaceDocServiceImpl.java

+package org.matrix.service.impl;
+
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.matrix.entity.InterfaceDoc;
+import org.matrix.entity.InterfaceGrouping;
+import org.matrix.enums.SwaggerDataType;
+import org.matrix.enums.SyncStatus;
+import org.matrix.exception.GlobalException;
+import org.matrix.mapper.InterfaceDocMapper;
+import org.matrix.mapper.InterfaceGroupingMapper;
+import org.matrix.service.ICaseService;
+import org.matrix.service.IInterfaceDocService;
+import org.matrix.vo.ImportInterfaceDoc;
+import org.matrix.vo.InterfaceVo;
+import org.matrix.vo.StatusCode;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 11:28:54
+ */
+@Service
+public class InterfaceDocServiceImpl extends ServiceImpl<InterfaceDocMapper, InterfaceDoc> implements IInterfaceDocService {
+
+    @Autowired
+    private InterfaceDocMapper interfaceDocMapper;
+
+    @Autowired
+    private InterfaceGroupingMapper interfaceGroupingMapper;
+
+    @Autowired
+    private ICaseService caseService;
+
+    @Override
+    public StatusCode importInterfaceDoc(List<InterfaceVo> interfaceVos, Long projectId, Long envId, int pattern, Long interfaceId, boolean bool) {
+        StatusCode statusCode;
+        switch (pattern) {
+            //1. 同名覆盖
+            case ImportInterfaceDoc.URL_OVERWRITE:
+                statusCode = nameOverwrite(interfaceVos, projectId, envId, interfaceId, bool);
+                break;
+            //2. 同名同组覆盖
+            case ImportInterfaceDoc.URL_GROUPING_OVERWRITE:
+                statusCode = nameGroupingOverwrite(interfaceVos, projectId, envId, interfaceId, bool);
+                break;
+            //3. 同名不覆盖
+            case ImportInterfaceDoc.NOT_URL_OVERWRITE:
+                statusCode = notNameOverwrite(interfaceVos, projectId, envId, interfaceId, bool);
+                break;
+            //4. 同名同组不覆盖
+            case ImportInterfaceDoc.NOT_URL_GROUPING_OVERWRITE:
+                statusCode = notNameGroupingOverwrite(interfaceVos, projectId, envId, interfaceId, bool);
+                break;
+            //5. 同时存在
+            case ImportInterfaceDoc.COEXIST:
+                statusCode = coexist(interfaceVos, projectId, envId, interfaceId, bool);
+                break;
+            default:
+                throw new GlobalException("请选择正确的导入类型");
+        }
+        return statusCode;
+    }
+
+    /**
+     * 1. 同url覆盖
+     *
+     * @param interfaceVos 接口文档Vo类
+     * @param projectId    项目id
+     * @param envId        环境id
+     * @param interfaceId  父级分组
+     * @return 导入情况
+     */
+    private StatusCode nameOverwrite(List<InterfaceVo> interfaceVos, Long projectId, Long envId, Long interfaceId, boolean bool) {
+        int saveNum = 0;
+        int updateNum = 0;
+        int ignoreNum = 0;
+        StatusCode statusCode = new StatusCode();
+        statusCode.setSwaggerDataType(SwaggerDataType.INTERFACE_DOC);
+        if (!CollectionUtils.isEmpty(interfaceVos)) {
+            //导入的接口       将当前导入的对象按照tag分组
+            Map<String, List<InterfaceVo>> tagMap = interfaceVos.stream()
+                    .filter(interfaceVo -> interfaceVo != null && interfaceVo.getTag() != null && !"".equals(interfaceVo.getTag()))
+                    .collect(Collectors.groupingBy(InterfaceVo::getTag));
+            //当前项目中所有的pathUrl(唯一的),同名的取第一个
+            List<InterfaceDoc> interfaceDocList = getDocByPathUrl(projectId);
+            if (!CollectionUtils.isEmpty(tagMap)) {
+                Set<String> tags = tagMap.keySet();
+                if (!CollectionUtils.isEmpty(tags)) {
+                    //tag 当前分组
+                    for (String tag : tags) {
+                        //判断分组是否存在，如果不存在就创建，存在就直接用存在的分组id(多个取第一个)
+                        Long groupingId = getInterfaceGroupingId(projectId, interfaceId, tag);
+                        //当前分组下的所有接口+tag
+                        List<InterfaceVo> interfaceVoList = tagMap.get(tag);
+                        for (InterfaceVo interfaceVo : interfaceVoList) {
+                            //当前分组下的接口
+                            InterfaceDoc interfaceDoc = interfaceVo.toInterfaceDoc();
+                            interfaceDoc.setEnvId(envId);
+                            interfaceDoc.setInterfaceGroupId(groupingId);
+                            interfaceDoc.setProjectId(projectId);
+                            //判断这条数据是否存在(当前项目,url)
+                            List<InterfaceDoc> interfaceDocs = Optional.ofNullable(interfaceDocMapper.selectList(Wrappers.lambdaQuery(InterfaceDoc.class)
+                                    .eq(InterfaceDoc::getProjectId, projectId)
+                                    .eq(InterfaceDoc::getPathUrl, interfaceDoc.getPathUrl()))).orElse(new ArrayList<>());
+                            //不为null说明存在这条pathUrl
+                            if (!CollectionUtils.isEmpty(interfaceDocs)) {
+                                //获取到这条数据的主键id，为了后面可以将id放到新的数据中
+                                Long id = interfaceDocs.get(0).getId();
+                                interfaceDoc.setId(id);
+                                //覆盖数据也就是更新
+                                Integer integer = Optional.of(interfaceDocMapper.updateById(interfaceDoc)).orElseThrow(() -> new GlobalException("修改失败"));
+                                //如果导入需要导入测试用例
+                                if (!bool) {
+
+                                }
+                                updateNum = updateNum + integer;
+                                //然后将查询到已经存在的数据删除掉，剩下的就是本次导入不存在，但是原始数据中存在的
+                                interfaceDocList.remove(interfaceDoc);
+                            } else {
+                                //不存在的话直接新增
+                                Integer integer = Optional.of(interfaceDocMapper.insert(interfaceDoc)).orElseThrow(() -> new GlobalException("添加失败"));
+                                saveNum = saveNum + integer;
+                            }
+                        }
+                    }
+                }
+            }
+            if (!CollectionUtils.isEmpty(interfaceDocList)) {
+                for (InterfaceDoc interfaceDoc : interfaceDocList) {
+                    interfaceDoc.setStatus(SyncStatus.OTHER);
+                    interfaceDocMapper.updateById(interfaceDoc);
+                }
+            }
+        }
+        statusCode.setSaveNum(saveNum);
+        statusCode.setUpdateNum(updateNum);
+        statusCode.setIgnoreNum(ignoreNum);
+        return statusCode;
+    }
+
+    /**
+     * 2. 同url同分组覆盖
+     *
+     * @param interfaceVos 接口文档Vo类
+     * @param projectId    项目id
+     * @param envId        环境id
+     * @param interfaceId  父级分组
+     * @return 导入情况
+     */
+    private StatusCode nameGroupingOverwrite(List<InterfaceVo> interfaceVos, Long projectId, Long envId, Long interfaceId, boolean bool) {
+        int saveNum = 0;
+        int updateNum = 0;
+        int ignoreNum = 0;
+        StatusCode statusCode = new StatusCode();
+        statusCode.setSwaggerDataType(SwaggerDataType.INTERFACE_DOC);
+        if (!CollectionUtils.isEmpty(interfaceVos)) {
+            //当前项目中存在的数据，同名同组的取第一个
+            List<InterfaceDoc> docByPathUrlAndGrouping = getDocByPathUrlAndGrouping(projectId);
+            //导入的数据根据tag分组
+            Map<String, List<InterfaceVo>> tagsMap = interfaceVos.stream()
+                    .filter(interfaceVo -> interfaceVo != null && interfaceVo.getTag() != null && !"".equals(interfaceVo.getTag()))
+                    .collect(Collectors.groupingBy(InterfaceVo::getTag));
+            if (!CollectionUtils.isEmpty(tagsMap)) {
+                Set<String> tags = tagsMap.keySet();
+                if (!CollectionUtils.isEmpty(tags)) {
+                    for (String tag : tags) {
+                        //判断分组是否存在，如果不存在就创建，存在就直接用存在的分组id(多个取第一个)
+                        Long groupingId = getInterfaceGroupingId(projectId, interfaceId, tag);
+                        //当前分组中的所有接口(导入的数据)
+                        List<InterfaceVo> interfaceVoList = tagsMap.get(tag);
+                        for (InterfaceVo interfaceVo : interfaceVoList) {
+                            //当前分组下的接口
+                            InterfaceDoc interfaceDoc = interfaceVo.toInterfaceDoc();
+                            interfaceDoc.setEnvId(envId);
+                            interfaceDoc.setInterfaceGroupId(groupingId);
+                            interfaceDoc.setProjectId(projectId);
+                            //判断这条数据是否存在(当前项目,分组,url)
+                            List<InterfaceDoc> interfaceDocs = Optional.ofNullable(interfaceDocMapper.selectList(Wrappers.lambdaQuery(InterfaceDoc.class)
+                                    .eq(InterfaceDoc::getProjectId, projectId)
+                                    .eq(InterfaceDoc::getPathUrl, interfaceDoc.getPathUrl())
+                                    .eq(InterfaceDoc::getInterfaceGroupId, interfaceDoc.getInterfaceGroupId()))).orElse(new ArrayList<>());
+                            //不为null说明存在这条pathUrl
+                            if (!CollectionUtils.isEmpty(interfaceDocs)) {
+                                //获取到这条数据的主键id，为了后面可以将id放到新的数据中
+                                Long id = interfaceDocs.get(0).getId();
+                                interfaceDoc.setId(id);
+                                //覆盖数据也就是更新
+                                Integer integer = Optional.of(interfaceDocMapper.updateById(interfaceDoc)).orElseThrow(() -> new GlobalException("修改失败"));
+                                updateNum = updateNum + integer;
+                                //然后将查询到已经存在的数据删除掉，剩下的就是本次导入不存在，但是原始数据中存在的
+                                docByPathUrlAndGrouping.remove(interfaceDoc);
+                            } else {
+                                //不存在的话直接新增
+                                Integer integer = Optional.of(interfaceDocMapper.insert(interfaceDoc)).orElseThrow(() -> new GlobalException("添加失败"));
+                                saveNum = saveNum + integer;
+                            }
+                        }
+
+                    }
+                }
+            }
+            if (!CollectionUtils.isEmpty(docByPathUrlAndGrouping)) {
+                for (InterfaceDoc interfaceDoc : docByPathUrlAndGrouping) {
+                    interfaceDoc.setStatus(SyncStatus.OTHER);
+                    interfaceDocMapper.updateById(interfaceDoc);
+                }
+            }
+        }
+        statusCode.setSaveNum(saveNum);
+        statusCode.setUpdateNum(updateNum);
+        statusCode.setIgnoreNum(ignoreNum);
+        return statusCode;
+    }
+
+    /**
+     * 3. 同url不覆盖
+     *
+     * @param interfaceVos 接口文档Vo类
+     * @param projectId    项目id
+     * @param envId        环境id
+     * @param interfaceId  父级分组
+     * @return 导入情况
+     */
+    private StatusCode notNameOverwrite(List<InterfaceVo> interfaceVos, Long projectId, Long envId, Long interfaceId, boolean bool) {
+        int saveNum = 0;
+        int updateNum = 0;
+        int ignoreNum = 0;
+        StatusCode statusCode = new StatusCode();
+        statusCode.setSwaggerDataType(SwaggerDataType.INTERFACE_DOC);
+        if (!CollectionUtils.isEmpty(interfaceVos)) {
+            //当前项目中所有的pathUrl(唯一的)
+            List<InterfaceDoc> interfaceDocList = getDocByPathUrl(projectId);
+            //导入的接口       将当前导入的对象按照tag分组
+            Map<String, List<InterfaceVo>> tagMap = interfaceVos.stream()
+                    .filter(interfaceVo -> interfaceVo != null && interfaceVo.getTag() != null && !"".equals(interfaceVo.getTag()))
+                    .collect(Collectors.groupingBy(InterfaceVo::getTag));
+            if (!CollectionUtils.isEmpty(tagMap)) {
+                Set<String> tags = tagMap.keySet();
+                if (!CollectionUtils.isEmpty(tags)) {
+                    //tag 当前分组
+                    for (String tag : tags) {
+                        //判断分组是否存在，如果不存在就创建，存在就直接用存在的分组id(多个取第一个)
+                        Long groupingId = getInterfaceGroupingId(projectId, interfaceId, tag);
+                        //当前分组下的所有接口+tag
+                        List<InterfaceVo> interfaceVoList = tagMap.get(tag);
+                        for (InterfaceVo interfaceVo : interfaceVoList) {
+                            //当前分组下的接口
+                            InterfaceDoc interfaceDoc = interfaceVo.toInterfaceDoc();
+                            interfaceDoc.setProjectId(projectId);
+                            //判断这条数据是否存在(当前项目,url)
+                            List<InterfaceDoc> interfaceDocs = Optional.ofNullable(interfaceDocMapper.selectList(Wrappers.lambdaQuery(InterfaceDoc.class)
+                                    .eq(InterfaceDoc::getProjectId, projectId)
+                                    .eq(InterfaceDoc::getPathUrl, interfaceDoc.getPathUrl()))).orElse(new ArrayList<>());
+                            //不为null说明存在这条pathUrl
+                            if (!CollectionUtils.isEmpty(interfaceDocs)) {
+                                //不做任何操作，忽略数量+1
+                                ignoreNum = ignoreNum + 1;
+                                //然后将查询到已经存在的数据删除掉，剩下的就是本次导入不存在，但是原始数据中存在的
+                                interfaceDocList.remove(interfaceDoc);
+                            } else {
+                                interfaceDoc.setEnvId(envId);
+                                interfaceDoc.setInterfaceGroupId(groupingId);
+                                //不存在的话直接新增
+                                Integer integer = Optional.of(interfaceDocMapper.insert(interfaceDoc)).orElseThrow(() -> new GlobalException("添加失败"));
+                                saveNum = saveNum + integer;
+                            }
+                        }
+                    }
+                }
+            }
+            if (!CollectionUtils.isEmpty(interfaceDocList)) {
+                for (InterfaceDoc interfaceDoc : interfaceDocList) {
+                    interfaceDoc.setStatus(SyncStatus.OTHER);
+                    interfaceDocMapper.updateById(interfaceDoc);
+                }
+            }
+        }
+        statusCode.setSaveNum(saveNum);
+        statusCode.setUpdateNum(updateNum);
+        statusCode.setIgnoreNum(ignoreNum);
+        return statusCode;
+    }
+
+    /**
+     * 4. 同url同分组不覆盖
+     *
+     * @param interfaceVos 接口文档Vo类
+     * @param projectId    项目id
+     * @param envId        环境id
+     * @param interfaceId  父级分组
+     * @return 导入情况
+     */
+    private StatusCode notNameGroupingOverwrite(List<InterfaceVo> interfaceVos, Long projectId, Long envId, Long interfaceId, boolean bool) {
+        int saveNum = 0;
+        int updateNum = 0;
+        int ignoreNum = 0;
+        StatusCode statusCode = new StatusCode();
+        statusCode.setSwaggerDataType(SwaggerDataType.INTERFACE_DOC);
+        if (!CollectionUtils.isEmpty(interfaceVos)) {
+            //导入的数据根据tag分组
+            Map<String, List<InterfaceVo>> tagsMap = interfaceVos.stream()
+                    .filter(interfaceVo -> interfaceVo != null && interfaceVo.getTag() != null && !"".equals(interfaceVo.getTag()))
+                    .collect(Collectors.groupingBy(InterfaceVo::getTag));
+            //当前项目中存在的数据，同名同组的取第一个
+            List<InterfaceDoc> docByPathUrlAndGrouping = getDocByPathUrlAndGrouping(projectId);
+            if (!CollectionUtils.isEmpty(tagsMap)) {
+                Set<String> tags = tagsMap.keySet();
+                if (!CollectionUtils.isEmpty(tags)) {
+                    for (String tag : tags) {
+                        //判断分组是否存在，如果不存在就创建，存在就直接用存在的分组id(多个取第一个)
+                        Long groupingId = getInterfaceGroupingId(projectId, interfaceId, tag);
+                        //当前分组中的所有接口(导入的数据)
+                        List<InterfaceVo> interfaceVoList = tagsMap.get(tag);
+                        for (InterfaceVo interfaceVo : interfaceVoList) {
+                            //当前分组下的接口
+                            InterfaceDoc interfaceDoc = interfaceVo.toInterfaceDoc();
+                            interfaceDoc.setEnvId(envId);
+                            interfaceDoc.setInterfaceGroupId(groupingId);
+                            interfaceDoc.setProjectId(projectId);
+                            //判断这条数据是否存在(当前项目,分组,url)
+                            List<InterfaceDoc> interfaceDocs = Optional.ofNullable(interfaceDocMapper.selectList(Wrappers.lambdaQuery(InterfaceDoc.class)
+                                    .eq(InterfaceDoc::getProjectId, projectId)
+                                    .eq(InterfaceDoc::getPathUrl, interfaceDoc.getPathUrl())
+                                    .eq(InterfaceDoc::getInterfaceGroupId, interfaceDoc.getInterfaceGroupId()))).orElse(new ArrayList<>());
+                            //不为null说明存在这条pathUrl
+                            if (!CollectionUtils.isEmpty(interfaceDocs)) {
+                                //不做任何操作，忽略数量+1
+                                ignoreNum = ignoreNum + 1;
+                                //然后将查询到已经存在的数据删除掉，剩下的就是本次导入不存在，但是原始数据中存在的
+                                docByPathUrlAndGrouping.remove(interfaceDoc);
+                            } else {
+                                //不存在的话直接新增
+                                Integer integer = Optional.of(interfaceDocMapper.insert(interfaceDoc)).orElseThrow(() -> new GlobalException("添加失败"));
+                                saveNum = saveNum + integer;
+                            }
+                        }
+
+                    }
+                }
+            }
+            if (!CollectionUtils.isEmpty(docByPathUrlAndGrouping)) {
+                for (InterfaceDoc interfaceDoc : docByPathUrlAndGrouping) {
+                    interfaceDoc.setStatus(SyncStatus.OTHER);
+                    interfaceDocMapper.updateById(interfaceDoc);
+                }
+            }
+        }
+        statusCode.setSaveNum(saveNum);
+        statusCode.setUpdateNum(updateNum);
+        statusCode.setIgnoreNum(ignoreNum);
+        return statusCode;
+    }
+
+    /**
+     * 5. 同时存在
+     *
+     * @param interfaceVos 接口文档Vo类
+     * @param projectId    项目id
+     * @param envId        环境id
+     * @param interfaceId  父级分组
+     * @return 导入情况
+     */
+    private StatusCode coexist(List<InterfaceVo> interfaceVos, Long projectId, Long envId, Long interfaceId, boolean bool) {
+        int saveNum = 0;
+        int updateNum = 0;
+        int ignoreNum = 0;
+        StatusCode statusCode = new StatusCode();
+        statusCode.setSwaggerDataType(SwaggerDataType.INTERFACE_DOC);
+        if (interfaceVos.size() != 0) {
+            //当前项目中所有的接口文档
+            List<InterfaceDoc> interfaceDocList = Optional.of(interfaceDocMapper.selectList(Wrappers.lambdaQuery(InterfaceDoc.class)
+                    .eq(InterfaceDoc::getProjectId, projectId))).orElse(new ArrayList<>());
+            //取出key : url value : 接口文档对象
+            Map<String, List<InterfaceDoc>> urlsMap = interfaceDocList.stream()
+                    .filter(interfaceDoc -> interfaceDoc != null && interfaceDoc.getPathUrl() != null && !"".equals(interfaceDoc.getPathUrl()))
+                    .collect(Collectors.groupingBy(InterfaceDoc::getPathUrl));
+            //存在的不同Url的接口
+            List<InterfaceDoc> list = new ArrayList<>();
+            if (!CollectionUtils.isEmpty(urlsMap)) {
+                Set<String> pathUrls = urlsMap.keySet();
+                if (!CollectionUtils.isEmpty(pathUrls)) {
+                    for (String pathUrl : pathUrls) {
+                        InterfaceDoc interfaceDoc = urlsMap.get(pathUrl).get(0);
+                        list.add(interfaceDoc);
+                    }
+                }
+            }
+            //导入的数据
+            Map<String, List<InterfaceVo>> tagsMap = interfaceVos.stream()
+                    .filter(interfaceVo -> interfaceVo != null && interfaceVo.getTag() != null && !"".equals(interfaceVo.getTag()))
+                    .collect(Collectors.groupingBy(InterfaceVo::getTag));
+            if (!CollectionUtils.isEmpty(tagsMap)) {
+                Set<String> tags = tagsMap.keySet();
+                if (!CollectionUtils.isEmpty(tags)) {
+                    for (String tag : tags) {
+                        Long groupingId = getInterfaceGroupingId(projectId, interfaceId, tag);
+                        //tag分组下的所有接口
+                        List<InterfaceVo> interfaceVoList = tagsMap.get(tag);
+                        for (InterfaceVo interfaceVo : interfaceVoList) {
+                            InterfaceDoc interfaceDoc = interfaceVo.toInterfaceDoc();
+                            interfaceDoc.setInterfaceGroupId(groupingId);
+                            interfaceDoc.setProjectId(projectId);
+                            interfaceDoc.setStatus(SyncStatus.COPY);
+                            interfaceDoc.setEnvId(envId);
+                            //todo 负责人，以及开发状态未添加
+                            Integer integer = Optional.of(interfaceDocMapper.insert(interfaceDoc)).orElseThrow(() -> new GlobalException("添加失败"));
+                            saveNum = saveNum + integer;
+                            //操作数据库中存在的接口
+                            for (InterfaceDoc doc : list) {
+                                //如果url相同就设置成未同步
+                                if (doc.getPathUrl().equals(interfaceDoc.getPathUrl())) {
+                                    list.remove(doc);
+                                    doc.setStatus(SyncStatus.NO);
+                                    interfaceDocMapper.updateById(doc);
+                                    break;
+                                }
+                            }
+                        }
+                        //剩下的就是当前存在，但是导入的数据中不存在的
+                        if (list.size() != 0) {
+                            for (InterfaceDoc interfaceDoc : list) {
+                                interfaceDoc.setStatus(SyncStatus.OTHER);
+                                interfaceDocMapper.updateById(interfaceDoc);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        statusCode.setSaveNum(saveNum);
+        statusCode.setUpdateNum(updateNum);
+        statusCode.setIgnoreNum(ignoreNum);
+        return statusCode;
+    }
+
+    /**
+     * 获取分组id
+     *
+     * @param projectId           项目id
+     * @param interfaceGroupingId 分组
+     * @param tag                 分组名称
+     * @return 分组的主键id
+     */
+    private Long getInterfaceGroupingId(Long projectId, Long interfaceGroupingId, String tag) {
+        Long id;
+        //查询分组是否存在
+        List<InterfaceGrouping> interfaceGroupings = Optional.of(interfaceGroupingMapper.selectList(Wrappers.lambdaQuery(InterfaceGrouping.class)
+                .eq(InterfaceGrouping::getProjectId, projectId)
+                .eq(InterfaceGrouping::getInterfaceGroupingId, interfaceGroupingId)
+                .eq(InterfaceGrouping::getTag, tag))).orElse(new ArrayList<>());
+        if (interfaceGroupings.size() != 0) {
+            InterfaceGrouping interfaceGrouping = interfaceGroupings.get(0);
+            id = interfaceGrouping.getId();
+        } else {
+            //添加接口分组
+            InterfaceGrouping interfaceGrouping = new InterfaceGrouping();
+            interfaceGrouping.setInterfaceGroupingId(interfaceGroupingId);
+            interfaceGrouping.setProjectId(projectId);
+            interfaceGrouping.setTag(tag);
+            interfaceGroupingMapper.insert(interfaceGrouping);
+            id = interfaceGroupingMapper.selectList(Wrappers.lambdaQuery(InterfaceGrouping.class)
+                    .eq(InterfaceGrouping::getProjectId, projectId)
+                    .eq(InterfaceGrouping::getInterfaceGroupingId, interfaceGroupingId)
+                    .eq(InterfaceGrouping::getTag, tag)).get(0).getId();
+        }
+        return id;
+    }
+
+    /**
+     * 当前项目中的根据pathUrl去重，取第一个
+     *
+     * @param projectId 项目id
+     * @return 唯一pathUrl的接口集合
+     */
+    public List<InterfaceDoc> getDocByPathUrl(Long projectId) {
+        List<InterfaceDoc> list = new ArrayList<>();
+        //当前项目中的所有接口
+        List<InterfaceDoc> interfaceDocs = Optional.ofNullable(interfaceDocMapper.selectList(Wrappers.lambdaQuery(InterfaceDoc.class)
+                .eq(InterfaceDoc::getProjectId, projectId))).orElse(new ArrayList<>());
+        //根据pathUrl取出独一份pathUrl的接口
+        if (!CollectionUtils.isEmpty(interfaceDocs)) {
+            Map<String, List<InterfaceDoc>> pathUrlMap = interfaceDocs.stream()
+                    .filter(interfaceDoc -> interfaceDoc != null && interfaceDoc.getPathUrl() != null && !"".equals(interfaceDoc.getPathUrl()))
+                    .collect(Collectors.groupingBy(InterfaceDoc::getPathUrl));
+            if (!CollectionUtils.isEmpty(pathUrlMap)) {
+                Set<String> pathUrls = pathUrlMap.keySet();
+                if (!CollectionUtils.isEmpty(pathUrls)) {
+                    for (String pathUrl : pathUrls) {
+                        InterfaceDoc interfaceDoc = pathUrlMap.get(pathUrl).get(0);
+                        list.add(interfaceDoc);
+                    }
+                }
+            }
+        }
+        return list;
+    }
+
+    /**
+     * 当前项目中同url同分组的数据
+     *
+     * @param projectId 项目id
+     * @return 唯一pathUrl的接口集合
+     */
+    public List<InterfaceDoc> getDocByPathUrlAndGrouping(Long projectId) {
+        List<InterfaceDoc> list = new ArrayList<>();
+        //项目中存在的数据
+        List<InterfaceDoc> interfaceDocs = Optional.ofNullable(interfaceDocMapper.selectList(Wrappers.lambdaQuery(InterfaceDoc.class)
+                .eq(InterfaceDoc::getProjectId, projectId))).orElse(new ArrayList<>());
+        //找到分组以及pathUrl都相同的数据
+        if (!CollectionUtils.isEmpty(interfaceDocs)) {
+            Map<String, List<InterfaceDoc>> pathUrlMap = interfaceDocs.stream()
+                    .filter(interfaceDoc -> interfaceDoc != null && interfaceDoc.getPathUrl() != null && !"".equals(interfaceDoc.getPathUrl()))
+                    .collect(Collectors.groupingBy(InterfaceDoc::getPathUrl));
+            if (!CollectionUtils.isEmpty(pathUrlMap)) {
+                Set<String> pathUrls = pathUrlMap.keySet();
+                if (!CollectionUtils.isEmpty(pathUrls)) {
+                    for (String pathUrl : pathUrls) {
+                        List<InterfaceDoc> interfaceDocList = pathUrlMap.get(pathUrl);
+                        //url 与 分组 都相同的
+                        Map<Long, List<InterfaceDoc>> groupingMap = interfaceDocList.stream()
+                                .filter(interfaceDoc -> interfaceDoc != null && interfaceDoc.getInterfaceGroupId() != null)
+                                .collect(Collectors.groupingBy(InterfaceDoc::getInterfaceGroupId));
+                        if (!CollectionUtils.isEmpty(groupingMap)) {
+                            Set<Long> longs = groupingMap.keySet();
+                            if (!CollectionUtils.isEmpty(longs)) {
+                                for (Long aLong : longs) {
+                                    List<InterfaceDoc> urlGroupings = groupingMap.get(aLong);
+                                    //只取第一条
+                                    if (!CollectionUtils.isEmpty(urlGroupings)) {
+                                        list.add(urlGroupings.get(0));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return list;
+    }
+}
\ No newline at end of file

kt-database/src/main/java/org/matrix/service/impl/InterfaceGroupingServiceImpl.java

+package org.matrix.service.impl;
+
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.matrix.entity.InterfaceDoc;
+import org.matrix.entity.InterfaceGrouping;
+import org.matrix.mapper.InterfaceDocMapper;
+import org.matrix.mapper.InterfaceGroupingMapper;
+import org.matrix.service.IInterfaceGroupingService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 11:29:05
+ */
+@Service
+public class InterfaceGroupingServiceImpl extends ServiceImpl<InterfaceGroupingMapper, InterfaceGrouping> implements IInterfaceGroupingService {
+
+    @Autowired
+    private InterfaceGroupingMapper interfaceGroupingMapper;
+
+    @Autowired
+    private InterfaceDocMapper interfaceDocMapper;
+
+    @Override
+    public void removeInterfaceGrouping(Long id) {
+        //删除当前分组下的接口文档
+        List<InterfaceDoc> interfaceDocs = Optional.ofNullable(interfaceDocMapper.selectList(Wrappers.lambdaQuery(InterfaceDoc.class)
+                .eq(InterfaceDoc::getInterfaceGroupId, id))).orElse(new ArrayList<>());
+        if (interfaceDocs.size() != 0) {
+            interfaceDocMapper.deleteBatchIds(interfaceDocs);
+        }
+        recursionInterface(id);
+        //最后删除当前分组
+        interfaceGroupingMapper.deleteById(id);
+    }
+
+    /**
+     * 递归处理当前分组下的分组
+     *
+     * @param id 当前分组id
+     */
+    public void recursionInterface(Long id) {
+        //找到当前分组下的子分组
+        List<InterfaceGrouping> interfaceGroupings = Optional.ofNullable(interfaceGroupingMapper.selectList(Wrappers.lambdaQuery(InterfaceGrouping.class)
+                .eq(InterfaceGrouping::getInterfaceGroupingId, id))).orElse(new ArrayList<>());
+        //是否存在子分组，如果不存在就不做任何操作，如果存在进入下一层
+        if (interfaceGroupings.size() != 0) {
+            //找到当前分组下的每个子类分组
+            for (InterfaceGrouping interfaceGrouping : interfaceGroupings) {
+                //删除子类分组中的数据模型
+                Long groupingId = interfaceGrouping.getId();
+                List<InterfaceGrouping> recursionsInterfaces = Optional.ofNullable(interfaceGroupingMapper.selectList(Wrappers.lambdaQuery(InterfaceGrouping.class)
+                        .eq(InterfaceGrouping::getInterfaceGroupingId, groupingId))).orElse(new ArrayList<>());
+                if (recursionsInterfaces.size() != 0) {
+                    interfaceDocMapper.deleteBatchIds(recursionsInterfaces);
+                }
+                recursionInterface(groupingId);
+                //删除当前分组下的接口
+                List<InterfaceDoc> interfaceDocs = Optional.ofNullable(interfaceDocMapper.selectList(Wrappers.lambdaQuery(InterfaceDoc.class)
+                        .eq(InterfaceDoc::getInterfaceGroupId, groupingId))).orElse(new ArrayList<>());
+                if (interfaceDocs.size() != 0) {
+                    interfaceDocMapper.deleteBatchIds(interfaceDocs);
+                }
+            }
+        }
+    }
+
+}

kt-database/src/main/java/org/matrix/service/impl/MouldDocServiceImpl.java

+package org.matrix.service.impl;
+
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.matrix.entity.MouldDoc;
+import org.matrix.entity.MouldGrouping;
+import org.matrix.enums.SwaggerDataType;
+import org.matrix.enums.SyncStatus;
+import org.matrix.exception.GlobalException;
+import org.matrix.mapper.MouldDocMapper;
+import org.matrix.mapper.MouldGroupingMapper;
+import org.matrix.service.IMouldDocService;
+import org.matrix.vo.ImportMouldDoc;
+import org.matrix.vo.StatusCode;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 11:29:15
+ */
+@Service
+public class MouldDocServiceImpl extends ServiceImpl<MouldDocMapper, MouldDoc> implements IMouldDocService {
+
+    @Autowired
+    private MouldDocMapper mouldDocMapper;
+
+    @Autowired
+    private MouldGroupingMapper mouldGroupingMapper;
+
+    @Override
+    public StatusCode importMouldDoc(List<MouldDoc> mouldDocs, Long projectId, int pattern, Long mouldId) {
+        StatusCode statusCode;
+        switch (pattern) {
+            //1. 同名覆盖
+            case ImportMouldDoc.NAME_OVERWRITE:
+                statusCode = nameOverwrite(mouldDocs, projectId, mouldId);
+                break;
+            //2. 同名同组覆盖
+            case ImportMouldDoc.NAME_GROUPING_OVERWRITE:
+                statusCode = nameGroupingOverwrite(mouldDocs, projectId, mouldId);
+                break;
+            //3. 同名不覆盖
+            case ImportMouldDoc.NOT_NAME_OVERWRITE:
+                statusCode = notNameOverwrite(mouldDocs, projectId, mouldId);
+                break;
+            //4. 同名同组不覆盖
+            case ImportMouldDoc.NOT_NAME_GROUPING_OVERWRITE:
+                statusCode = notNameGroupingOverwrite(mouldDocs, projectId, mouldId);
+                break;
+            //5. 同时存在
+            case ImportMouldDoc.COEXIST:
+                statusCode = coexist(mouldDocs, projectId, mouldId);
+                break;
+            default:
+                throw new GlobalException("请选择正确的导入类型");
+        }
+        return statusCode;
+    }
+
+    /**
+     * 1. 同名覆盖
+     *
+     * @param mouldDocs swagger导入的数据模型集合
+     * @param projectId 项目id
+     * @param mouldId   分组Id(导入时选择导入到哪个分组中)
+     * @return 导入结果
+     */
+    public StatusCode nameOverwrite(List<MouldDoc> mouldDocs, Long projectId, Long mouldId) {
+        int saveNum = 0;
+        int updateNum = 0;
+        int ignoreNum = 0;
+        StatusCode statusCode = new StatusCode();
+        statusCode.setSwaggerDataType(SwaggerDataType.MOULD_DOC);
+        if (mouldDocs.size() != 0) {
+            List<Long> longList = getIdList(projectId);
+            Long groupingId = getGroupingId(mouldId, projectId);
+            for (MouldDoc mouldDoc : mouldDocs) {
+                //将分组加到对象中
+                mouldDoc.setMouldGroupingId(groupingId);
+                mouldDoc.setProjectId(projectId);
+                //找到可以覆盖的
+                List<MouldDoc> mouldDocList = Optional.of(mouldDocMapper.selectList(Wrappers.lambdaQuery(MouldDoc.class)
+                        .eq(MouldDoc::getObjName, mouldDoc.getObjName())
+                        .eq(MouldDoc::getProjectId, projectId))).orElse(new ArrayList<>());
+                //覆盖第一个
+                if (mouldDocList.size() != 0) {
+                    //如果存在就覆盖第一个
+                    Long mouldDocId = mouldDocList.get(0).getId();
+                    mouldDoc.setId(mouldDocId);
+                    mouldDoc.setStatus(SyncStatus.UPDATE);
+                    Integer integer = Optional.of(mouldDocMapper.updateById(mouldDoc)).orElseThrow(() -> new GlobalException("修改数据模型失败"));
+                    updateNum = updateNum + integer;
+                    longList.remove(mouldDoc.getId());
+                } else {
+                    mouldDoc.setStatus(SyncStatus.INSERT);
+                    //如果不存在就直接添加
+                    Integer integer = Optional.of(mouldDocMapper.insert(mouldDoc)).orElseThrow(() -> new GlobalException("添加数据模型失败"));
+                    saveNum = saveNum + integer;
+                }
+            }
+            updateStatusNo(longList);
+        }
+        statusCode.setSaveNum(saveNum);
+        statusCode.setUpdateNum(updateNum);
+        statusCode.setIgnoreNum(ignoreNum);
+        return statusCode;
+    }
+
+    /**
+     * 2. 同名同组覆盖
+     *
+     * @param mouldDocs swagger导入的数据模型集合
+     * @param projectId 项目id
+     * @param mouldId   分组Id(导入时选择导入到哪个分组中)
+     * @return 导入结果
+     */
+    public StatusCode nameGroupingOverwrite(List<MouldDoc> mouldDocs, Long projectId, Long mouldId) {
+        int saveNum = 0;
+        int updateNum = 0;
+        int ignoreNum = 0;
+        StatusCode statusCode = new StatusCode();
+        statusCode.setSwaggerDataType(SwaggerDataType.MOULD_DOC);
+        if (mouldDocs.size() != 0) {
+            List<Long> longList = getIdList(projectId);
+            Long groupingId = getGroupingId(mouldId, projectId);
+            for (MouldDoc mouldDoc : mouldDocs) {
+                //将新的分组存入到数据中
+                mouldDoc.setProjectId(projectId);
+                mouldDoc.setMouldGroupingId(groupingId);
+                //找到可以覆盖的
+                List<MouldDoc> mouldDocList = Optional.of(mouldDocMapper.selectList(Wrappers.lambdaQuery(MouldDoc.class)
+                        .eq(MouldDoc::getObjName, mouldDoc.getObjName())
+                        .eq(MouldDoc::getProjectId, projectId)
+                        .eq(MouldDoc::getMouldGroupingId, mouldDoc.getMouldGroupingId()))).orElse(new ArrayList<>());
+                //覆盖第一个
+                if (mouldDocList.size() != 0) {
+                    //如果存在就覆盖第一个
+                    Long mouldDocId = mouldDocList.get(0).getId();
+                    mouldDoc.setId(mouldDocId);
+                    mouldDoc.setStatus(SyncStatus.UPDATE);
+                    Integer integer = Optional.of(mouldDocMapper.updateById(mouldDoc)).orElseThrow(() -> new GlobalException("修改数据模型失败"));
+                    updateNum = updateNum + integer;
+                } else {
+                    mouldDoc.setStatus(SyncStatus.INSERT);
+                    //如果不存在就直接添加
+                    Integer integer = Optional.of(mouldDocMapper.insert(mouldDoc)).orElseThrow(() -> new GlobalException("添加数据模型失败"));
+                    saveNum = saveNum + integer;
+                }
+            }
+            updateStatusNo(longList);
+        }
+        statusCode.setSaveNum(saveNum);
+        statusCode.setUpdateNum(updateNum);
+        statusCode.setIgnoreNum(ignoreNum);
+        return statusCode;
+    }
+
+    /**
+     * 3. 同名不覆盖
+     *
+     * @param mouldDocs swagger导入的数据模型集合
+     * @param projectId 项目id
+     * @param mouldId   分组Id(导入时选择导入到哪个分组中)
+     * @return 导入结果
+     */
+    public StatusCode notNameOverwrite(List<MouldDoc> mouldDocs, Long projectId, Long mouldId) {
+        int saveNum = 0;
+        int updateNum = 0;
+        int ignoreNum = 0;
+        StatusCode statusCode = new StatusCode();
+        statusCode.setSwaggerDataType(SwaggerDataType.MOULD_DOC);
+        if (mouldDocs.size() != 0) {
+            List<Long> longList = getIdList(projectId);
+            Long groupingId = getGroupingId(mouldId, projectId);
+            for (MouldDoc mouldDoc : mouldDocs) {
+                //将新的分组存入到数据中
+                mouldDoc.setMouldGroupingId(groupingId);
+                mouldDoc.setProjectId(projectId);
+                //找到可以不做任何操作的
+                List<MouldDoc> mouldDocList = Optional.of(mouldDocMapper.selectList(Wrappers.lambdaQuery(MouldDoc.class)
+                        .eq(MouldDoc::getObjName, mouldDoc.getObjName())
+                        .eq(MouldDoc::getProjectId, projectId))).orElse(new ArrayList<>());
+                //忽略数+1
+                if (mouldDocList.size() != 0) {
+                    ignoreNum = ignoreNum + 1;
+                } else {
+                    //如果不存在就直接添加
+                    Integer integer = Optional.of(mouldDocMapper.insert(mouldDoc)).orElseThrow(() -> new GlobalException("添加数据模型失败"));
+                    saveNum = saveNum + integer;
+                }
+            }
+            updateStatusNo(longList);
+        }
+        statusCode.setSaveNum(saveNum);
+        statusCode.setUpdateNum(updateNum);
+        statusCode.setIgnoreNum(ignoreNum);
+        return statusCode;
+    }
+
+    /**
+     * 4. 同名同组不覆盖
+     *
+     * @param mouldDocs swagger导入的数据模型集合
+     * @param projectId 项目id
+     * @param mouldId   分组Id(导入时选择导入到哪个分组中)
+     * @return 导入结果
+     */
+    public StatusCode notNameGroupingOverwrite(List<MouldDoc> mouldDocs, Long projectId, Long mouldId) {
+        int saveNum = 0;
+        int updateNum = 0;
+        int ignoreNum = 0;
+        StatusCode statusCode = new StatusCode();
+        statusCode.setSwaggerDataType(SwaggerDataType.MOULD_DOC);
+        if (mouldDocs.size() != 0) {
+            List<Long> longList = getIdList(projectId);
+            Long groupingId = getGroupingId(mouldId, projectId);
+            for (MouldDoc mouldDoc : mouldDocs) {
+                //将新的分组存入到数据中
+                mouldDoc.setMouldGroupingId(groupingId);
+                mouldDoc.setProjectId(projectId);
+                //找到可以不做任何操作的
+                List<MouldDoc> mouldDocList = Optional.of(mouldDocMapper.selectList(Wrappers.lambdaQuery(MouldDoc.class)
+                        .eq(MouldDoc::getObjName, mouldDoc.getObjName())
+                        .eq(MouldDoc::getProjectId, projectId)
+                        .eq(MouldDoc::getMouldGroupingId, mouldDoc.getMouldGroupingId()))).orElse(new ArrayList<>());
+                //忽略数+1
+                if (mouldDocList.size() != 0) {
+                    ignoreNum = ignoreNum + 1;
+                    //上次忽略的
+                    for (MouldDoc doc : mouldDocList) {
+                        doc.setStatus(SyncStatus.IGNORE);
+                        Integer integer = Optional.of(mouldDocMapper.updateById(doc)).orElseThrow(() -> new GlobalException("修改失败"));
+                        ignoreNum = ignoreNum + integer;
+                    }
+                } else {
+                    //如果不存在就直接添加
+                    Integer integer = Optional.of(mouldDocMapper.insert(mouldDoc)).orElseThrow(() -> new GlobalException("添加数据模型失败"));
+                    saveNum = saveNum + integer;
+                }
+            }
+            updateStatusNo(longList);
+        }
+        statusCode.setSaveNum(saveNum);
+        statusCode.setUpdateNum(updateNum);
+        statusCode.setIgnoreNum(ignoreNum);
+        return statusCode;
+    }
+
+    /**
+     * 5. 同名时保留两者
+     *
+     * @param mouldDocs swagger导入的数据模型集合
+     * @param mouldId   分组Id(导入时选择导入到哪个分组中)
+     * @param projectId 项目id
+     * @return 导入结果
+     */
+    public StatusCode coexist(List<MouldDoc> mouldDocs, Long projectId, Long mouldId) {
+        int saveNum = 0;
+        int updateNum = 0;
+        int ignoreNum = 0;
+        StatusCode statusCode = new StatusCode();
+        statusCode.setSwaggerDataType(SwaggerDataType.MOULD_DOC);
+        if (mouldDocs.size() != 0) {
+            //当前项目中的所有数据模型
+            List<MouldDoc> mouldDocList = Optional.ofNullable(mouldDocMapper.selectList(Wrappers.lambdaQuery(MouldDoc.class)
+                    .eq(MouldDoc::getProjectId, projectId))).orElse(new ArrayList<>());
+            //按照名称分组
+            Map<String, List<MouldDoc>> collect = mouldDocList.stream()
+                    .filter(mouldDoc -> mouldDoc != null && mouldDoc.getObjName() != null && !"".equals(mouldDoc.getObjName()))
+                    .collect(Collectors.groupingBy(MouldDoc::getObjName));
+            //存在的不同名称的数据模型(如果同名取第一个)
+            List<MouldDoc> list = new ArrayList<>();
+            //每组取第一个
+            if (!CollectionUtils.isEmpty(collect)) {
+                Set<String> objNames = collect.keySet();
+                if (!CollectionUtils.isEmpty(objNames)) {
+                    for (String objName : objNames) {
+                        MouldDoc mouldDoc = collect.get(objName).get(0);
+                        list.add(mouldDoc);
+                    }
+                }
+            }
+            Long groupingId = getGroupingId(mouldId, projectId);
+            //存数据,并且将数据库中同名的数据模型修改未未同步
+            for (MouldDoc mouldDoc : mouldDocs) {
+                mouldDoc.setMouldGroupingId(groupingId);
+                mouldDoc.setProjectId(projectId);
+                mouldDoc.setStatus(SyncStatus.COPY);
+                Integer integer = Optional.of(mouldDocMapper.insert(mouldDoc)).orElseThrow(() -> new GlobalException("添加数据模型失败"));
+                saveNum = saveNum + integer;
+                //操作数据库中存在的数据模型
+                for (MouldDoc doc : list) {
+                    //如果同名，就将库存中的同名数据模型修改为未同步
+                    if (mouldDoc.getObjName().equals(doc.getObjName())) {
+                        list.remove(doc);
+                        doc.setStatus(SyncStatus.NO);
+                        mouldDocMapper.updateById(doc);
+                        break;
+                    }
+                }
+            }
+            //剩下的就是当前存在，但是导入的数据中不存在的
+            if (list.size() != 0) {
+                for (MouldDoc mouldDoc : list) {
+                    mouldDoc.setStatus(SyncStatus.OTHER);
+                    mouldDocMapper.updateById(mouldDoc);
+                }
+            }
+        }
+        statusCode.setSaveNum(saveNum);
+        statusCode.setUpdateNum(updateNum);
+        statusCode.setIgnoreNum(ignoreNum);
+        return statusCode;
+    }
+
+    /**
+     * 获取分组的主键id
+     *
+     * @param mouldId   父级分组id
+     * @param projectId 项目id
+     * @return 当前加入的Schemas分组的主键id
+     */
+    private Long getGroupingId(Long mouldId, Long projectId) {
+        Long id;
+        //当前是不是0无所谓，只需要根据mouldId查出当前分组的主键id就可以，如果存在取第一个，如果不存在就创建
+        List<MouldGrouping> mouldGroupings = Optional.of(mouldGroupingMapper.selectList(Wrappers.lambdaQuery(MouldGrouping.class)
+                .eq(MouldGrouping::getMouldId, mouldId)
+                .eq(MouldGrouping::getProjectId, projectId)
+                .eq(MouldGrouping::getName, "Schemas"))).orElse(new ArrayList<>());
+        //如果分组存在,就直接将数据模行放入到分组中
+        if (mouldGroupings.size() != 0) {
+            MouldGrouping mouldGrouping = mouldGroupings.get(0);
+            id = mouldGrouping.getId();
+        } else {
+            //不存在的话就在当前选择的位置新建分组
+            MouldGrouping mouldGrouping = new MouldGrouping();
+            mouldGrouping.setMouldId(mouldId);
+            mouldGrouping.setProjectId(projectId);
+            mouldGrouping.setName("Schemas");
+            mouldGroupingMapper.insert(mouldGrouping);
+            //新建之后查询出分组，获取到分组的id
+            id = mouldGroupingMapper.selectList(Wrappers.lambdaQuery(MouldGrouping.class)
+                    .eq(MouldGrouping::getMouldId, mouldId)
+                    .eq(MouldGrouping::getProjectId, projectId)
+                    .eq(MouldGrouping::getName, "Schemas")).get(0).getId();
+        }
+        return id;
+    }
+
+    /**
+     * 将未涉及到的数据模型都变成: 上次导入不存在
+     *
+     * @param longList 未涉及到的数据模型的主键id集合
+     */
+    public void updateStatusNo(List<Long> longList) {
+        //未涉及到的数据模型都变成未同步
+        if (longList.size() != 0) {
+            for (Long id : longList) {
+                MouldDoc mouldDoc = mouldDocMapper.selectById(id);
+                mouldDoc.setStatus(SyncStatus.OTHER);
+                mouldDocMapper.updateById(mouldDoc);
+            }
+        }
+    }
+
+    /**
+     * 获取当前项目中所有的数据模型的主键id集合
+     *
+     * @param projectId 项目id
+     * @return 当前项目中所有的数据模型的主键id集合
+     */
+    private List<Long> getIdList(Long projectId) {
+        //当前项目中的所有数据模型
+        List<MouldDoc> list = Optional.ofNullable(mouldDocMapper.selectList(Wrappers.lambdaQuery(MouldDoc.class)
+                .eq(MouldDoc::getProjectId, projectId))).orElse(new ArrayList<>());
+        //将主键id整理到集合中
+        List<Long> longList = new ArrayList<>();
+        if (list.size() != 0) {
+            for (MouldDoc mouldDoc : list) {
+                Long id = mouldDoc.getId();
+                longList.add(id);
+            }
+        }
+        return longList;
+    }
+
+}

kt-database/src/main/java/org/matrix/service/impl/MouldGroupingServiceImpl.java

+package org.matrix.service.impl;
+
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.matrix.entity.MouldDoc;
+import org.matrix.entity.MouldGrouping;
+import org.matrix.mapper.MouldDocMapper;
+import org.matrix.mapper.MouldGroupingMapper;
+import org.matrix.service.IMouldGroupingService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 11:29:29
+ */
+@Service
+public class MouldGroupingServiceImpl extends ServiceImpl<MouldGroupingMapper, MouldGrouping> implements IMouldGroupingService {
+
+    @Autowired
+    private MouldGroupingMapper mouldGroupingMapper;
+
+    @Autowired
+    private MouldDocMapper mouldDocMapper;
+
+    @Override
+    public void removeMould(Long id) {
+        //删除当前分组下的数据模型
+        List<MouldDoc> mouldDocs = Optional.ofNullable(mouldDocMapper.selectList(Wrappers.lambdaQuery(MouldDoc.class)
+                .eq(MouldDoc::getMouldGroupingId, id))).orElse(new ArrayList<>());
+        if (mouldDocs.size() != 0) {
+            mouldDocMapper.deleteBatchIds(mouldDocs);
+        }
+        recursionMould(id);
+        //最后删除当前分组
+        mouldGroupingMapper.deleteById(id);
+    }
+
+    /**
+     * 递归处理当前分组下的分组
+     *
+     * @param id 当前分组id
+     */
+    public void recursionMould(Long id) {
+        //找到当前分组下的子分组
+        List<MouldGrouping> mouldGroupings = Optional.ofNullable(mouldGroupingMapper.selectList(Wrappers.lambdaQuery(MouldGrouping.class)
+                .eq(MouldGrouping::getMouldId, id))).orElse(new ArrayList<>());
+        //是否存在子分组，如果不存在就不做任何操作，如果存在进入下一层
+        if (mouldGroupings.size() != 0) {
+            //找到当前分组下的每个子类分组
+            for (MouldGrouping mouldGrouping : mouldGroupings) {
+                //删除子类分组中的数据模型
+                Long groupingId = mouldGrouping.getId();
+                List<MouldGrouping> recursionsMoulds = Optional.ofNullable(mouldGroupingMapper.selectList(Wrappers.lambdaQuery(MouldGrouping.class)
+                        .eq(MouldGrouping::getMouldId, groupingId))).orElse(new ArrayList<>());
+                if (recursionsMoulds.size() != 0) {
+                    mouldDocMapper.deleteBatchIds(recursionsMoulds);
+                }
+                recursionMould(groupingId);
+                //删除当前分组下的接口
+                List<MouldDoc> mouldDocs = Optional.ofNullable(mouldDocMapper.selectList(Wrappers.lambdaQuery(MouldDoc.class)
+                        .eq(MouldDoc::getMouldGroupingId, groupingId))).orElse(new ArrayList<>());
+                if (mouldDocs.size() != 0) {
+                    mouldDocMapper.deleteBatchIds(mouldDocs);
+                }
+            }
+        }
+    }
+
+}

kt-database/src/main/java/org/matrix/vo/ImportInterfaceDoc.java

+package org.matrix.vo;
+
+/**
+ * 接口导入方式
+ *
+ * @author mruny
+ * @create 2022/7/27 13:19:17
+ */
+public class ImportInterfaceDoc {
+
+    /**
+     * 1. 同url覆盖
+     */
+    public static final int URL_OVERWRITE = 1;
+
+    /**
+     * 2. 同url同组覆盖
+     */
+    public static final int URL_GROUPING_OVERWRITE = 2;
+
+    /**
+     * 3. 同url不覆盖
+     */
+    public static final int NOT_URL_OVERWRITE = 3;
+
+    /**
+     * 4. 同rul同组不覆盖
+     */
+    public static final int NOT_URL_GROUPING_OVERWRITE = 4;
+
+    /**
+     * 5. 同时存在
+     */
+    public static final int COEXIST = 5;
+
+}

kt-database/src/main/java/org/matrix/vo/ImportMouldDoc.java

+package org.matrix.vo;
+
+/**
+ * 数据模型导入方式
+ *
+ * @author mruny
+ * @create 2022/7/19 14:23:03
+ */
+public class ImportMouldDoc {
+
+    /**
+     * 1. 同名覆盖
+     */
+    public static final int NAME_OVERWRITE = 1;
+
+    /**
+     * 2. 同名同组覆盖
+     */
+    public static final int NAME_GROUPING_OVERWRITE = 2;
+
+    /**
+     * 3. 同名不覆盖
+     */
+    public static final int NOT_NAME_OVERWRITE = 3;
+
+    /**
+     * 4. 同名同组不覆盖
+     */
+    public static final int NOT_NAME_GROUPING_OVERWRITE = 4;
+
+    /**
+     * 5. 同时存在
+     */
+    public static final int COEXIST = 5;
+
+}

kt-database/src/main/java/org/matrix/vo/InterfaceVo.java

+package org.matrix.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import org.matrix.entity.InterfaceDoc;
+import org.springframework.beans.BeanUtils;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 15:53:34
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@AllArgsConstructor
+@NoArgsConstructor
+public class InterfaceVo extends InterfaceDoc {
+
+    private String tag;
+
+    public InterfaceDoc toInterfaceDoc() {
+        InterfaceDoc interfaceDoc = new InterfaceDoc();
+        BeanUtils.copyProperties(this, interfaceDoc);
+        return interfaceDoc;
+    }
+}

kt-database/src/main/java/org/matrix/vo/StatusCode.java

+package org.matrix.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.matrix.enums.SwaggerDataType;
+
+/**
+ * 导入状态
+ *
+ * @author mruny
+ * @create 2022/7/19 16:02:06
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class StatusCode {
+
+    /**
+     * swagger导入数据类型
+     */
+    private SwaggerDataType swaggerDataType;
+
+    /**
+     * 新增数量
+     */
+    private Integer saveNum;
+
+    /**
+     * 修改数量
+     */
+    private Integer updateNum;
+
+    /**
+     * 忽略数量
+     */
+    private Integer ignoreNum;
+
+}

kt-database/src/main/java/org/matrix/vo/swaggerEntityVo/AttributeInVo.java

@@ -26,10 +26,10 @@ public class AttributeInVo {
     @ApiModelProperty("描述")
     private String description;
 
-    @ApiModelProperty("格式，可能为null")
+    @ApiModelProperty("格式")
     private String format;
 
-    @ApiModelProperty("枚举，可能为null")
+    @ApiModelProperty("枚举")
     private List<String> enumType;
 
     @ApiModelProperty("map类型出现的情况")

kt-database/src/main/java/org/matrix/vo/swaggerEntityVo/definitionsEntity/DefinitionsVo.java

@@ -18,6 +18,9 @@ import lombok.NoArgsConstructor;
 @ApiModel("DefinitionsVo对象，以及对象中的属性及具体信息")
 public class DefinitionsVo {
 
+    @ApiModelProperty("id")
+    private Long identifierId;
+
     @ApiModelProperty("对象名称")
     private String objName;
 

kt-database/src/main/java/org/matrix/vo/swaggerEntityVo/responsesEntity/ResponsesVo.java → kt-database/src/main/java/org/matrix/vo/swaggerEntityVo/responsesEntity/ResponseVo.java

@@ -16,7 +16,7 @@ import lombok.NoArgsConstructor;
 @AllArgsConstructor
 @NoArgsConstructor
 @ApiModel("response返回值信息")
-public class ResponsesVo {
+public class ResponseVo {
 
     @ApiModelProperty("状态码")
     private String code;

kt-database/src/main/java/org/matrix/vo/swaggerEntityVo/swaggerEntity/PathVo.java

@@ -6,7 +6,7 @@ import io.swagger.annotations.ApiModelProperty;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
-import org.matrix.vo.swaggerEntityVo.responsesEntity.ResponsesVo;
+import org.matrix.vo.swaggerEntityVo.responsesEntity.ResponseVo;
 
 import java.util.List;
 
@@ -19,6 +19,12 @@ import java.util.List;
 @ApiModel("PathVo接口信息")
 public class PathVo {
 
+    @ApiModelProperty("id")
+    private Long identifierId;
+
+    @ApiModelProperty("tagId")
+    private Long tagId;
+
     @ApiModelProperty("url地址")
     private String pathUrl;
 
@@ -29,13 +35,13 @@ public class PathVo {
     private String summary;
 
     @ApiModelProperty("类名，标签")
-    private JSONArray tags;
+    private String tags;
 
     @ApiModelProperty("入参")
     private JSONArray parameters;
 
     @ApiModelProperty("返回值")
-    private List<ResponsesVo> responses;
+    private List<ResponseVo> responses;
 
     @ApiModelProperty("operationId")
     private String operationId;

kt-database/src/main/java/org/matrix/vo/swaggerEntityVo/swaggerEntity/TagSummary.java

@@ -19,8 +19,11 @@ import java.util.List;
 @ApiModel("TagSummary一级标签与二级标签")
 public class TagSummary {
 
+    @ApiModelProperty("id")
+    private Long identifierId;
+
     @ApiModelProperty("一级标签")
-    private JSONArray tag;
+    private String tag;
 
     @ApiModelProperty("二级标签以及swagger具体信息")
     private List<PathVo> paths;

kt-user/src/main/java/org/matrix/local/entity/config/MessageConfig.java

@@ -20,7 +20,7 @@ public class MessageConfig {
     /**
      * 可接收的类型
      */
-    @ApiModelProperty(value = "可接收的类型,等同与对应数据的java类名",example = "['Action','Environment','TestCase']")
+    @ApiModelProperty(value = "可接收的类型,等同与对应数据的java类名",example = "['Action','Environment','Case']")
     private List<String> available;
 
 }

kt-web/src/main/java/org/matrix/autotest/controller/CaseController.java

+package org.matrix.autotest.controller;
+
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.matrix.entity.Case;
+import org.matrix.service.ICaseService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author mruny
+ * @create 2022/8/2 10:39:01
+ */
+@CrossOrigin
+@RestController
+@RequestMapping("/cases")
+@Api(tags = "对用例Case的基本操作")
+public class CaseController {
+
+    @Autowired
+    private ICaseService caseService;
+
+    @ApiOperation("查询所有当前项目中的测试用例")
+    @GetMapping
+    public ResponseEntity<List<Case>> findCase(@RequestParam Long projectId) {
+        List<Case> cases = Optional.ofNullable(caseService.list(Wrappers.lambdaQuery(Case.class)
+                .eq(Case::getProjectId, projectId))).orElse(new ArrayList<>());
+        return ResponseEntity.ok(cases);
+    }
+
+    @ApiOperation("根据主键id查询测试用例")
+    @GetMapping("/id")
+    public ResponseEntity<Case> findByIdCase(@RequestParam Long id) {
+        Case aCase = Optional.ofNullable(caseService.getById(id)).orElse(new Case());
+        return ResponseEntity.ok(aCase);
+    }
+
+//    @ApiOperation("根据测试用例所在的接口查询")
+//    @GetMapping("/")
+}

kt-web/src/main/java/org/matrix/autotest/controller/InterfaceDocController.java

+package org.matrix.autotest.controller;
+
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiModelProperty;
+import io.swagger.annotations.ApiOperation;
+import org.matrix.entity.InterfaceDoc;
+import org.matrix.exception.GlobalException;
+import org.matrix.service.IInterfaceDocService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author mruny
+ * @create 2022/8/1 10:11:52
+ */
+@CrossOrigin
+@RestController
+@RequestMapping("/interfaceDocs")
+@Api(tags = "对接口文档InterfaceDoc的基本操作")
+public class InterfaceDocController {
+
+    @Autowired
+    private IInterfaceDocService interfaceDocService;
+
+    @ApiOperation("根据id删除接口文档")
+    @DeleteMapping("/{id}")
+    public ResponseEntity<String> removeInterfaceDoc(@PathVariable Long id) {
+        interfaceDocService.removeById(id);
+        return ResponseEntity.ok(String.format("删除成功，删除的接口文档id为: %d", id));
+    }
+
+    @ApiModelProperty("添加接口文档")
+    @PostMapping
+    public ResponseEntity<InterfaceDoc> insertInterfaceDoc(@RequestBody InterfaceDoc interfaceDoc) {
+        return Optional.of(interfaceDocService.save(interfaceDoc)).orElseThrow(() -> new GlobalException("添加失败"))
+                ? ResponseEntity.ok(interfaceDoc)
+                : ResponseEntity.status(HttpStatus.BAD_REQUEST).body(interfaceDoc);
+    }
+
+    @ApiOperation("修改接口文档")
+    @PutMapping
+    public ResponseEntity<InterfaceDoc> updateInterfaceDoc(@RequestBody InterfaceDoc interfaceDoc) {
+        return Optional.of(interfaceDocService.updateById(interfaceDoc)).orElseThrow(() -> new GlobalException("添加失败"))
+                ? ResponseEntity.ok(interfaceDoc)
+                : ResponseEntity.status(HttpStatus.BAD_REQUEST).body(interfaceDoc);
+    }
+
+    @ApiOperation("查询当前项目下所有接口文档")
+    @GetMapping
+    public ResponseEntity<List<InterfaceDoc>> findInterfaceDoc(@RequestParam(required = false,defaultValue = "1") Long projectId) {
+        List<InterfaceDoc> interfaceDocList = Optional.ofNullable(interfaceDocService.list(Wrappers.lambdaQuery(InterfaceDoc.class)
+                .eq(InterfaceDoc::getProjectId, projectId))).orElse(new ArrayList<>());
+        return ResponseEntity.ok(interfaceDocList);
+    }
+
+    @ApiOperation("根据主键id查询接口文档")
+    @GetMapping("/id")
+    public ResponseEntity<InterfaceDoc> findByIdInterfaceDoc(@RequestParam Long id) {
+        InterfaceDoc interfaceDoc = Optional.ofNullable(interfaceDocService.getById(id)).orElse(new InterfaceDoc());
+        return ResponseEntity.ok(interfaceDoc);
+    }
+
+    @ApiOperation("根据分组id查询接口文档")
+    @GetMapping("/groupingId")
+    public ResponseEntity<List<InterfaceDoc>> findByGroupingIdInterfaceDoc(@RequestParam Long groupingId) {
+        List<InterfaceDoc> interfaceDocList = Optional.ofNullable(interfaceDocService.list(Wrappers.lambdaQuery(InterfaceDoc.class)
+                .eq(InterfaceDoc::getInterfaceGroupId, groupingId))).orElse(new ArrayList<>());
+        return ResponseEntity.ok(interfaceDocList);
+    }
+
+}

kt-web/src/main/java/org/matrix/autotest/controller/InterfaceGroupingController.java

+package org.matrix.autotest.controller;
+
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.matrix.entity.InterfaceGrouping;
+import org.matrix.exception.GlobalException;
+import org.matrix.service.IInterfaceGroupingService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author mruny
+ * @create 2022/8/1 10:12:10
+ */
+@CrossOrigin
+@RestController
+@RequestMapping("/interfaceGroupings")
+@Api(tags = "对接口文档分组InterfaceGrouping的基本操作")
+public class InterfaceGroupingController {
+
+    @Autowired
+    private IInterfaceGroupingService interfaceGroupingService;
+
+    @ApiOperation("添加接口分组")
+    @PostMapping
+    public ResponseEntity<InterfaceGrouping> insertInterfaceGrouping(@RequestBody InterfaceGrouping interfaceGrouping) {
+        return Optional.of(interfaceGroupingService.save(interfaceGrouping)).orElseThrow(() -> new GlobalException("添加失败"))
+                ? ResponseEntity.ok(interfaceGrouping)
+                : ResponseEntity.status(HttpStatus.BAD_REQUEST).body(interfaceGrouping);
+    }
+
+    @ApiOperation("修改接口分组")
+    @PutMapping
+    public ResponseEntity<InterfaceGrouping> updateInterfaceGrouping(@RequestBody InterfaceGrouping interfaceGrouping) {
+        return Optional.of(interfaceGroupingService.updateById(interfaceGrouping)).orElseThrow(() -> new GlobalException("添加失败"))
+                ? ResponseEntity.ok(interfaceGrouping)
+                : ResponseEntity.status(HttpStatus.BAD_REQUEST).body(interfaceGrouping);
+    }
+
+    @ApiOperation("查询当前项目下所有接口分组")
+    @GetMapping
+    public ResponseEntity<List<InterfaceGrouping>> findInterfaceGrouping(@RequestParam Long projectId) {
+        List<InterfaceGrouping> interfaceGroupings = Optional.ofNullable(interfaceGroupingService.list(Wrappers.lambdaQuery(InterfaceGrouping.class)
+                .eq(InterfaceGrouping::getProjectId, projectId))).orElse(new ArrayList<>());
+        return ResponseEntity.ok(interfaceGroupings);
+    }
+
+    @ApiOperation("根据主键id查询接口分组")
+    @GetMapping("/id")
+    public ResponseEntity<InterfaceGrouping> findByIdInterfaceGrouping(@RequestParam Long id) {
+        InterfaceGrouping interfaceGrouping = Optional.ofNullable(interfaceGroupingService.getById(id)).orElse(new InterfaceGrouping());
+        return ResponseEntity.ok(interfaceGrouping);
+    }
+
+    @ApiOperation("根据接口分组主键id删除分组以及分组下的接口文档")
+    @DeleteMapping("/{id}")
+    public ResponseEntity<String> removeInterfaceGrouping(@PathVariable Long id) {
+        interfaceGroupingService.removeInterfaceGrouping(id);
+        return ResponseEntity.ok(String.format("删除成功,删除的接口分组id为: %d", id));
+    }
+}

kt-web/src/main/java/org/matrix/autotest/controller/MouldDocController.java

+package org.matrix.autotest.controller;
+
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.matrix.entity.MouldDoc;
+import org.matrix.exception.GlobalException;
+import org.matrix.service.IMouldDocService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 13:35:36
+ */
+@CrossOrigin
+@RestController
+@RequestMapping("/mouldDocs")
+@Api(tags = "对数据模型MouldDoc的基本操作")
+public class MouldDocController {
+
+    @Autowired
+    private IMouldDocService mouldDocService;
+
+    @ApiOperation("根据主键id删除数据模型")
+    @DeleteMapping("/{id}")
+    public ResponseEntity<String> removeMouldDoc(@PathVariable Long id) {
+        mouldDocService.removeById(id);
+        return ResponseEntity.ok(String.format("删除成功,删除的数据模型id为: %d", id));
+    }
+
+    @ApiOperation("添加数据模型")
+    @PostMapping
+    public ResponseEntity<MouldDoc> insertMouldDoc(@RequestBody MouldDoc mouldDoc) {
+        return Optional.of(mouldDocService.save(mouldDoc)).orElseThrow(() -> new GlobalException("添加失败"))
+                ? ResponseEntity.ok(mouldDoc)
+                : ResponseEntity.status(HttpStatus.BAD_REQUEST).body(mouldDoc);
+    }
+
+    @ApiOperation("修改数据模型")
+    @PutMapping
+    public ResponseEntity<MouldDoc> updateMouldDoc(@RequestBody MouldDoc mouldDoc) {
+        return Optional.of(mouldDocService.updateById(mouldDoc)).orElseThrow(() -> new GlobalException("修改失败"))
+                ? ResponseEntity.ok(mouldDoc)
+                : ResponseEntity.status(HttpStatus.BAD_REQUEST).body(mouldDoc);
+    }
+
+    @ApiOperation("查询当前项目下所有数据模型")
+    @GetMapping
+    public ResponseEntity<List<MouldDoc>> findMouldDoc(@RequestParam Long projectId) {
+        List<MouldDoc> mouldDocList = Optional.ofNullable(mouldDocService.list(Wrappers.lambdaQuery(MouldDoc.class)
+                .eq(MouldDoc::getProjectId, projectId))).orElse(new ArrayList<>());
+        return ResponseEntity.ok(mouldDocList);
+    }
+
+    @ApiOperation("根据主键id数据模型")
+    @GetMapping("/id")
+    public ResponseEntity<MouldDoc> findByIdMouldDoc(@RequestParam Long id) {
+        MouldDoc mouldDoc = Optional.ofNullable(mouldDocService.getById(id)).orElse(new MouldDoc());
+        return ResponseEntity.ok(mouldDoc);
+    }
+
+    @ApiOperation("根据分组id查询数据模型")
+    @GetMapping("/groupingId")
+    public ResponseEntity<List<MouldDoc>> findByGroupingIdMouldDoc(@RequestParam Long groupingId) {
+        List<MouldDoc> mouldDocList = Optional.ofNullable(mouldDocService.list(Wrappers.lambdaQuery(MouldDoc.class)
+                .eq(MouldDoc::getMouldGroupingId, groupingId))).orElse(new ArrayList<>());
+        return ResponseEntity.ok(mouldDocList);
+    }
+
+}

kt-web/src/main/java/org/matrix/autotest/controller/MouldGroupingController.java

+package org.matrix.autotest.controller;
+
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.matrix.entity.MouldGrouping;
+import org.matrix.exception.GlobalException;
+import org.matrix.service.IMouldGroupingService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author mruny
+ * @create 2022/7/18 13:15:08
+ */
+@CrossOrigin
+@RestController
+@RequestMapping("/mouldGroupings")
+@Api(tags = "对数据模型分组MouldGrouping的基本操作")
+public class MouldGroupingController {
+
+    @Autowired
+    private IMouldGroupingService mouldGroupingService;
+
+    @PostMapping
+    @ApiOperation("新增数据模型分组")
+    public ResponseEntity<MouldGrouping> insertMouldGrouping(@RequestBody MouldGrouping mouldGrouping) {
+        return Optional.of(mouldGroupingService.save(mouldGrouping)).orElseThrow(() -> new GlobalException("添加失败"))
+                ? ResponseEntity.ok(mouldGrouping)
+                : ResponseEntity.status(HttpStatus.BAD_REQUEST).body(mouldGrouping);
+    }
+
+    @PutMapping
+    @ApiOperation("修改数据模型分组")
+    public ResponseEntity<MouldGrouping> updateMouldGrouping(@RequestBody MouldGrouping mouldGrouping) {
+        return Optional.of(mouldGroupingService.updateById(mouldGrouping)).orElseThrow(() -> new GlobalException("修改失败"))
+                ? ResponseEntity.ok(mouldGrouping)
+                : ResponseEntity.status(HttpStatus.BAD_REQUEST).body(mouldGrouping);
+    }
+
+    @GetMapping
+    @ApiOperation("查询当前项目下所有数据模型分组")
+    public ResponseEntity<List<MouldGrouping>> findMouldGrouping(@RequestParam Long projectId) {
+
+
+        List<MouldGrouping> mouldGroupings = Optional.of(mouldGroupingService.list(Wrappers.lambdaQuery(MouldGrouping.class)
+                .eq(MouldGrouping::getProjectId, projectId))).orElse(new ArrayList<>());
+        return ResponseEntity.ok(mouldGroupings);
+    }
+
+    @ApiOperation("根据主键id查询数据模型分组")
+    @GetMapping("/id")
+    public ResponseEntity<MouldGrouping> findByMouldGrouping(@RequestParam Long id) {
+        MouldGrouping mouldGrouping = Optional.ofNullable(mouldGroupingService.getById(id)).orElse(new MouldGrouping());
+        return ResponseEntity.ok(mouldGrouping);
+    }
+
+    @ApiOperation("根据数据模型分组主键id，删除分组以及分组下的数据模型")
+    @DeleteMapping("/{id}")
+    @Transactional(rollbackFor = Exception.class)
+    public ResponseEntity<String> removeMouldGrouping(@PathVariable Long id) {
+        mouldGroupingService.removeMould(id);
+        return ResponseEntity.ok(String.format("删除成功,删除的模型分组id为: %d", id));
+    }
+
+}

kt-web/src/main/java/org/matrix/autotest/controller/SwaggerController.java → kt-web/src/main/java/org/matrix/autotest/controller/SwaggerHandleController.java

@@ -5,16 +5,26 @@ import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
+import org.matrix.entity.Environment;
+import org.matrix.entity.MouldDoc;
+import org.matrix.exception.GlobalException;
+import org.matrix.service.IEnvironmentService;
+import org.matrix.service.IInterfaceDocService;
+import org.matrix.service.IMouldDocService;
+import org.matrix.vo.InterfaceVo;
+import org.matrix.vo.StatusCode;
 import org.matrix.vo.swaggerEntityVo.AttributeInVo;
 import org.matrix.vo.swaggerEntityVo.definitionsEntity.AttributeOutVo;
 import org.matrix.vo.swaggerEntityVo.definitionsEntity.DefinitionsVo;
 import org.matrix.vo.swaggerEntityVo.definitionsEntity.PropertiesVo;
 import org.matrix.vo.swaggerEntityVo.responsesEntity.CodeStatusVo;
-import org.matrix.vo.swaggerEntityVo.responsesEntity.ResponsesVo;
+import org.matrix.vo.swaggerEntityVo.responsesEntity.ResponseVo;
 import org.matrix.vo.swaggerEntityVo.swaggerEntity.PathVo;
 import org.matrix.vo.swaggerEntityVo.swaggerEntity.SwaggerOuter;
 import org.matrix.vo.swaggerEntityVo.swaggerEntity.TagSummary;
-import org.matrix.exception.GlobalException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.CollectionUtils;
 import org.springframework.web.bind.annotation.*;
 
@@ -39,7 +49,75 @@ import java.util.stream.Collectors;
 @RestController
 @RequestMapping("/swaggers")
 @Api(tags = "swagger解析")
-public class SwaggerController {
+public class SwaggerHandleController {
+
+    @Autowired
+    private IMouldDocService mouldDocService;
+
+    @Autowired
+    private IInterfaceDocService interfaceDocService;
+
+    @Autowired
+    private IEnvironmentService environmentService;
+
+    public static long i = 0;
+
+    /**
+     * 导入环境
+     *
+     * @param environment 环境对象
+     * @return 数据导入情况
+     */
+    @ApiOperation("导入环境")
+    @PostMapping("/environment")
+    public ResponseEntity<StatusCode> insertEnv(@RequestBody Environment environment) {
+        StatusCode statusCode = environmentService.importEnv(environment);
+        return ResponseEntity.ok(statusCode);
+    }
+
+    /**
+     * 导入数据模型
+     *
+     * @param mouldDocs 数据模型对象
+     * @param projectId 项目id
+     * @param pattern   导入类型
+     * @param mouldId   上级分组
+     * @return 数据导入情况
+     */
+    @ApiOperation("导入数据模型")
+    @Transactional(rollbackFor = Exception.class)
+    @PostMapping("/mouldDoc/{projectId}/{pattern}/{mouldId}")
+    public ResponseEntity<StatusCode> insertMouldDoc(@RequestBody List<MouldDoc> mouldDocs,
+                                                     @PathVariable Long projectId,
+                                                     @PathVariable int pattern,
+                                                     @PathVariable Long mouldId) {
+        StatusCode statusCode = mouldDocService.importMouldDoc(mouldDocs, projectId, pattern, mouldId);
+        return ResponseEntity.ok(statusCode);
+    }
+
+    /**
+     * 导入接口文档
+     *
+     * @param interfaceVos 接口文档Vo类
+     * @param projectId    项目id
+     * @param pattern      导入方式
+     * @param interfaceId  上级分组
+     * @param envId        环境id
+     * @param bool         是否导入测试用例
+     * @return 导入结果
+     */
+    @ApiOperation("导入接口文档")
+    @Transactional(rollbackFor = Exception.class)
+    @PostMapping("/interfaceDoc/{projectId}/{envId}/{pattern}/{interfaceId}/{bool}")
+    public ResponseEntity<StatusCode> insertInterfaceDoc(@RequestBody List<InterfaceVo> interfaceVos,
+                                                         @PathVariable Long projectId,
+                                                         @PathVariable int pattern,
+                                                         @PathVariable Long interfaceId,
+                                                         @PathVariable Long envId,
+                                                         @PathVariable boolean bool) {
+        StatusCode statusCode = interfaceDocService.importInterfaceDoc(interfaceVos, projectId, envId, pattern, interfaceId, bool);
+        return ResponseEntity.ok(statusCode);
+    }
 
     /**
      * 解析swaggerJson
@@ -49,7 +127,7 @@ public class SwaggerController {
     public JSONObject handleSwagger(@RequestParam String url) {
         String loadJson = loadJson(url);
         SwaggerOuter json = new SwaggerOuter();
-        if (loadJson != null && !"".equals(loadJson)){
+        if (loadJson != null && !"".equals(loadJson)) {
             JSONObject swaggerJson = JSONObject.parseObject(loadJson);
             String host = String.valueOf(swaggerJson.get("host"));
             json.setHost(host);
@@ -68,24 +146,30 @@ public class SwaggerController {
                     if (!CollectionUtils.isEmpty(methodSets)) {
                         for (String httpMethod : methodSets) {
                             PathVo pathVo = new PathVo();
+                            i = i + 1L;
+                            pathVo.setIdentifierId(i);
                             JSONObject methodJson = pathJson.getJSONObject(httpMethod);
                             JSONArray tags = methodJson.getJSONArray("tags");
+                            String tag = null;
+                            if (!CollectionUtils.isEmpty(tags)) {
+                                tag = tags.getString(0);
+                            }
                             String summary = methodJson.getString("summary");
                             JSONArray parameters = methodJson.getJSONArray("parameters");
-                            List<ResponsesVo> responsesVos = handleResponse(methodJson);
+                            List<ResponseVo> responseVos = handleResponse(methodJson);
                             String operationId = methodJson.getString("operationId");
                             String deprecated = methodJson.getString("deprecated");
                             JSONArray consumes = methodJson.getJSONArray("consumes");
                             JSONArray produces = methodJson.getJSONArray("produces");
                             JSONArray security = methodJson.getJSONArray("security");
-                            pathVo.setTags(tags);
+                            pathVo.setTags(tag);
                             pathVo.setHttpMethod(httpMethod);
                             pathVo.setPathUrl(pathUrl);
                             pathVo.setSummary(summary);
                             pathVo.setOperationId(operationId);
                             pathVo.setConsumes(consumes);
                             pathVo.setParameters(parameters);
-                            pathVo.setResponses(responsesVos);
+                            pathVo.setResponses(responseVos);
                             pathVo.setDeprecated(deprecated);
                             pathVo.setSecurity(security);
                             pathVo.setProduces(produces);
@@ -93,25 +177,24 @@ public class SwaggerController {
                         }
                     }
                 }
-            }
                 List<TagSummary> tagSummaryList = new ArrayList<>();
                 //stream取出key:tags,value:summary
-            Map<JSONArray, List<PathVo>> collect = list.stream()
+                Map<String, List<PathVo>> collect = list.stream()
                         .filter(pathVo -> pathVo != null && pathVo.getTags() != null)
                         .collect(Collectors.groupingBy(PathVo::getTags));
-            Set<JSONArray> tags = collect.keySet();
-            for (JSONArray tag : tags) {
+                Set<String> tags = collect.keySet();
+                for (String tag : tags) {
+                    i = i + 1L;
                     TagSummary tagSummary = new TagSummary();
                     List<PathVo> pathVos = collect.get(tag);
+                    tagSummary.setIdentifierId(i);
                     tagSummary.setTag(tag);
-                for (PathVo pathVO : pathVos) {
-                    pathVO.setTags(null);
-                }
                     tagSummary.setPaths(pathVos);
                     tagSummaryList.add(tagSummary);
                 }
                 json.setTagSummaryList(tagSummaryList);
             }
+        }
         return JSONObject.parseObject(JSON.toJSONString(json));
     }
 
@@ -143,16 +226,16 @@ public class SwaggerController {
     /**
      * 处理responses中的数据
      */
-    public List<ResponsesVo> handleResponse(JSONObject methodJson) {
-        List<ResponsesVo> list = new ArrayList<>();
+    public List<ResponseVo> handleResponse(JSONObject methodJson) {
+        List<ResponseVo> list = new ArrayList<>();
         JSONObject responses = methodJson.getJSONObject("responses");
         if (responses != null) {
             //所有状态码
             Set<String> codes = responses.keySet();
             for (String code : codes) {
-                ResponsesVo responsesVo = new ResponsesVo();
+                ResponseVo responseVo = new ResponseVo();
                 JSONObject responseInside = responses.getJSONObject(code);
-                responsesVo.setCode(code);
+                responseVo.setCode(code);
                 CodeStatusVo codeStatusVo = new CodeStatusVo();
                 //获取描述
                 String description = responseInside.getString("description");
@@ -163,10 +246,10 @@ public class SwaggerController {
                     codeStatusVo.setAttributeInVo(attributeInVo);
                 } else {
                     //非200时状态码
-                    responsesVo.setCodeStatusVo(codeStatusVo);
+                    responseVo.setCodeStatusVo(codeStatusVo);
                 }
-                responsesVo.setCodeStatusVo(codeStatusVo);
-                list.add(responsesVo);
+                responseVo.setCodeStatusVo(codeStatusVo);
+                list.add(responseVo);
             }
         }
         return list;
@@ -185,8 +268,10 @@ public class SwaggerController {
             Set<String> objNames = definitions.keySet();
             //获取到每个对象
             for (String objName : objNames) {
+                i = i + 1L;
                 //List内的最外层结构
                 DefinitionsVo definitionsVo = new DefinitionsVo();
+                definitionsVo.setIdentifierId(i);
                 //definitionsVo的内部是attributeVo
                 AttributeOutVo attributeOutVo = new AttributeOutVo();
                 //根据对象名称可以取到，所有对象内部的信息，包括对象的类型type，properties，对象名称title，以及描述description

kt-web/src/main/resources/application-local.yml

@@ -15,12 +15,12 @@ spring:
           driverClassName: com.mysql.cj.jdbc.Driver
           url: jdbc:mysql://127.0.0.1:3306/key_stone?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
           username: root
-          password: ldf3291369
+          password: root
         zentao:
           driverClassName: com.mysql.cj.jdbc.Driver
           url: jdbc:mysql://127.0.0.1:3306/zentao?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC&&zeroDateTimeBehavior=convertToNull
           username: root
-          password: ldf3291369
+          password: root
 
 mybatis-plus:
 #  configuration: