feat: ASW-109 pcap页面增加跳转到opensearch dashboard按钮

1.修复 session已关闭的 vnc连接未断开
2.创建 session 时，检查 env 状态

.gitlab-ci.yml

@@ -0,0 +1,82 @@
+# 定义全局docker镜像
+image: git.mesalab.cn:7443/nezha/nz-build-env:1.6
+# 定义全局变量
+variables:
+  MINIO_HOST: 'http://192.168.40.48:2020/'
+  MINIO_USER: 'admin'
+  MINIO_PWD: "Nezha@02!"
+  MAVEN_REPO: "/etc/maven/repository/"
+  # mariadb 数据库定义（非必须）
+  MYSQL_DATABASE: "test"
+  # mariadb 密码配置（必须），注意变量名是 MYSQL_ROOT_PASSWORD
+  MYSQL_ROOT_PASSWORD: '111111'
+# 定义全局依赖的docker服务，即 这条流水线 pipeline 中的任务都用这里的服务
+services:
+  - mariadb:10.2.14
+# 开始执行脚本前所需执行脚本
+before_script:
+  - echo "begin ci"
+# 脚本执行完后的钩子，执行所需脚本
+after_script:
+  - echo "end ci"
+# 该ci pipeline适合的场景，按照定义的顺序执行任务
+stages:
+  - build
+  - test
+# paths主要是来指定需要被缓存的文件路径，需要特别指出的是这里的 paths 是相对路径，是相对于gitlab中项目目录的路径，也就是说被缓存的文件都是在项目目录之内的
+# maven setting /usr/share/maven/conf/settings.xml
+cache:
+  paths:
+    - $MAVEN_REPO
+
+# 定义的任务
+build_rpm:
+  stage: build
+  # 所需执行的脚本
+  script:
+    - env | sort
+    - pwd
+    - export FILE_NAME=$CI_PROJECT_NAME-$CI_COMMIT_REF_NAME-$CI_COMMIT_SHORT_SHA.tar.gz
+    - mvn clean install -Dmaven.test.skip=true
+    - cd ./target
+    - tar -zcvf $FILE_NAME asw-controller.jar
+    # 将 文件 上传到 minio
+    - mc alias set asw $MINIO_HOST $MINIO_USER $MINIO_PWD
+    - mc cp $FILE_NAME asw/release/asw-controller/$FILE_NAME
+    - cd ../
+  # 在哪个分支上可用
+  only:
+    - /^rel-.*$/i
+  # 指定哪个ci runner跑该工作
+  tags:
+    - asw
+
+# 定义的任务
+dev_build:
+  stage: test
+  # 所需执行的脚本
+  script:
+    - env | sort
+    - pwd
+    - export FILE_NAME=$CI_PROJECT_NAME-$CI_COMMIT_REF_NAME-$CI_COMMIT_SHORT_SHA.tar.gz
+    - mvn clean install -Dmaven.test.skip=true
+    - cd ./target
+    # - "git log -100 --pretty=format:'%ad : %s' > git-log.html"
+    # - tar -zcvf $FILE_NAME asw-controller.jar git-log.html
+    - tar -zcvf $FILE_NAME asw-controller.jar
+    - md5sum $FILE_NAME > $CI_PROJECT_NAME-$CI_COMMIT_REF_NAME-latest.tar.gz.md5sum.txt
+    # 将 文件 上传到 minio
+    - mc alias set asw $MINIO_HOST $MINIO_USER $MINIO_PWD
+    - mc cp $FILE_NAME asw/ci-cd/asw-controller/$FILE_NAME
+    - mc cp $FILE_NAME asw/ci-cd/asw-controller/$CI_PROJECT_NAME-$CI_COMMIT_REF_NAME-latest.tar.gz
+    - mc cp $CI_PROJECT_NAME-$CI_COMMIT_REF_NAME-latest.tar.gz.md5sum.txt asw/ci-cd/asw-controller/$CI_PROJECT_NAME-$CI_COMMIT_REF_NAME-latest.tar.gz.md5sum.txt
+    - cd ../
+  # 在哪个分支上可用
+  only:
+    - /^dev-.*$/i
+  # 指定不执行的标签
+  except:
+    - schedules
+  # 指定哪个ci runner跑该工作
+  tags:
+    - asw

pom.xml

@@ -79,6 +79,14 @@
 			<artifactId>sa-token-spring-boot3-starter</artifactId>
 			<version>1.37.0</version>
 		</dependency>
+
+		<!-- Sa-Token 整合 jwt -->
+		<dependency>
+			<groupId>cn.dev33</groupId>
+			<artifactId>sa-token-jwt</artifactId>
+			<version>1.37.0</version>
+		</dependency>
+
 		<dependency>
 			<groupId>cn.hutool</groupId>
 			<artifactId>hutool-all</artifactId>
@@ -143,6 +151,46 @@
 			<artifactId>simplemagic</artifactId>
 			<version>1.16</version>
 		</dependency>
+
+		<!--Feign client支持-->
+		<dependency>
+			<groupId>org.springframework.cloud</groupId>
+			<artifactId>spring-cloud-starter-openfeign</artifactId>
+			<version>3.1.5</version>
+		</dependency>
+
+		<dependency>
+			<groupId>com.alibaba.fastjson2</groupId>
+			<artifactId>fastjson2</artifactId>
+			<version>2.0.51</version>
+		</dependency>
+
+
+		<!--opensearch-->
+		<dependency>
+			<groupId>org.opensearch.client</groupId>
+			<artifactId>opensearch-java</artifactId>
+			<version>2.12.0</version>
+		</dependency>
+
+		<dependency>
+			<groupId>org.opensearch.client</groupId>
+			<artifactId>opensearch-rest-client</artifactId>
+			<version>2.12.0</version>
+		</dependency>
+
+		<!-- https://mvnrepository.com/artifact/org.eclipse.jgit/org.eclipse.jgit -->
+		<dependency>
+			<groupId>org.eclipse.jgit</groupId>
+			<artifactId>org.eclipse.jgit</artifactId>
+			<version>7.0.0.202409031743-r</version>
+		</dependency>
+
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-freemarker</artifactId>
+		</dependency>
+
 	</dependencies>
 
 	<build>

src/main/java/net/geedge/asw/common/config/FreeMarkerConfig.java

@@ -0,0 +1,33 @@
+package net.geedge.asw.common.config;
+
+import net.geedge.asw.common.util.T;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.ui.freemarker.FreeMarkerConfigurationFactoryBean;
+
+import java.util.Properties;
+
+@Configuration
+public class FreeMarkerConfig {
+
+    @Value("${asw.template.path:static}")
+    private String templatePath;
+
+    @Bean
+    public FreeMarkerConfigurationFactoryBean factoryBean() {
+        FreeMarkerConfigurationFactoryBean freeMarkerConfigurationFactoryBean = new FreeMarkerConfigurationFactoryBean();
+        // 设置 FreeMarker 模板位置
+        boolean exist = T.FileUtil.exist(templatePath);
+        templatePath = exist ? templatePath : "classpath:" + templatePath;
+        freeMarkerConfigurationFactoryBean.setTemplateLoaderPath(templatePath);
+
+        // 其他配置
+        Properties settings = new Properties();
+        settings.setProperty("default_encoding", "utf-8");
+        settings.setProperty("number_format", "0.##");
+
+        freeMarkerConfigurationFactoryBean.setFreemarkerSettings(settings);
+        return freeMarkerConfigurationFactoryBean;
+    }
+}

src/main/java/net/geedge/asw/common/config/GUIHistoryRouterFilter.java

@@ -0,0 +1,51 @@
+package net.geedge.asw.common.config;
+
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.core.io.Resource;
+import org.springframework.core.io.ResourceLoader;
+import org.springframework.stereotype.Component;
+import org.springframework.web.filter.OncePerRequestFilter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+
+@Component
+public class GUIHistoryRouterFilter extends OncePerRequestFilter {
+
+    @Value("${router.prefixes:/static/,/api/}")
+    private String pathPrefixes;
+
+    private final ResourceLoader resourceLoader;
+
+    public GUIHistoryRouterFilter(ResourceLoader resourceLoader) {
+        this.resourceLoader = resourceLoader;
+    }
+
+    @Override
+    protected void doFilterInternal(HttpServletRequest request,
+                                    HttpServletResponse response,
+                                    FilterChain filterChain) throws ServletException, IOException {
+
+        List<String> prefixes = Arrays.asList(pathPrefixes.split(","));
+        String path = request.getRequestURI();
+        boolean matches = prefixes.stream().anyMatch(path::startsWith);
+
+        if (!matches) {
+            // If the path does not start with any of the specified prefixes, return index.html
+            Resource resource = resourceLoader.getResource("file:./public/index.html");
+            response.setContentType("text/html");
+            response.setCharacterEncoding("UTF-8");
+            Files.copy(resource.getFile().toPath(), response.getOutputStream());
+            return;
+        }
+        // If the path matches any of the prefixes, continue the filter chain
+        filterChain.doFilter(request, response);
+    }
+}

src/main/java/net/geedge/asw/common/config/I18nConfig.java

@@ -0,0 +1,122 @@
+package net.geedge.asw.common.config;
+
+import cn.hutool.log.Log;
+import jakarta.annotation.PostConstruct;
+import net.geedge.asw.common.util.Constants;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.sys.entity.SysI18nEntity;
+import net.geedge.asw.module.sys.service.ISysI18nService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ResourceLoaderAware;
+import org.springframework.context.support.AbstractMessageSource;
+import org.springframework.core.io.DefaultResourceLoader;
+import org.springframework.core.io.ResourceLoader;
+import org.springframework.stereotype.Component;
+
+import java.text.MessageFormat;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Component
+public class I18nConfig extends AbstractMessageSource implements ResourceLoaderAware {
+
+    private static final Log log = Log.get();
+
+    @Autowired
+    private ISysI18nService sysI18nService;
+
+    /**
+     * 国际化缓存
+     */
+    public static final Map<String, Map<String, String>> I18N_CACHE = new HashMap<>();
+
+    @PostConstruct
+    public void init() {
+        this.reload();
+    }
+
+    /**
+     * 重新将数据库中的国际化配置加载
+     */
+    public void reload() {
+        I18N_CACHE.clear();
+    }
+
+
+    protected ResourceLoader resourceLoader;
+
+    @Override
+    public void setResourceLoader(ResourceLoader resourceLoader) {
+        this.resourceLoader = (resourceLoader == null ? new DefaultResourceLoader() : resourceLoader);
+    }
+
+    @Override
+    protected MessageFormat resolveCode(String code, Locale locale) {
+        String msg = this.getSourceFromCache(code, locale);
+        MessageFormat messageFormat = new MessageFormat(msg, locale);
+        return messageFormat;
+    }
+
+    @Override
+    protected String resolveCodeWithoutArguments(String code, Locale locale) {
+        return this.getSourceFromCache(code, locale);
+    }
+
+    /**
+     * 从缓存中取出国际化配置对应的数据 或者从父级获取
+     *
+     * @param code
+     * @param locale
+     * @param param
+     * @return
+     */
+    public String getSourceFromCache(String code, Locale locale, Object... param) {
+        String language = locale.getLanguage();
+        if (T.ObjectUtil.isEmpty(I18N_CACHE)) {
+            this.loadAllMessageResourcesFromDB();
+        }
+        Map<String, String> props = I18N_CACHE.get(language);
+        if (null != props && props.containsKey(code)) {
+            String msg = props.get(code);
+            if (T.ObjectUtil.isEmpty(param)) {
+                return msg;
+            }
+            return MessageFormat.format(msg, param);
+        } else {
+            try {
+                if (null != this.getParentMessageSource()) {
+                    return this.getParentMessageSource().getMessage(code, param, locale);
+                }
+            } catch (Exception e) {
+                log.error(e);
+            }
+            return code;
+        }
+    }
+
+    /**
+     * 从数据库中获取所有国际化配置
+     */
+    public void loadAllMessageResourcesFromDB() {
+        List<SysI18nEntity> list = sysI18nService.list();
+        if (T.CollUtil.isNotEmpty(list)) {
+            try {
+                for (String lang : Constants.LANG_LIST) {
+                    Map<String, String> langMap = I18N_CACHE.get(lang);
+                    langMap = T.ObjectUtil.defaultIfNull(langMap, new HashMap<>());
+                    I18N_CACHE.put(lang, langMap);
+
+                    List<SysI18nEntity> dataList = list.stream().filter(pojo -> T.StrUtil.equals(lang, pojo.getLang())).collect(Collectors.toList());
+                    for (SysI18nEntity entity : dataList) {
+                        langMap.put(entity.getCode(), entity.getValue());
+                    }
+                }
+            } catch (Exception e) {
+                log.error(e);
+            }
+        }
+    }
+}

src/main/java/net/geedge/asw/common/config/LocaleConfig.java

@@ -0,0 +1,66 @@
+package net.geedge.asw.common.config;
+
+import cn.hutool.log.Log;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import net.geedge.asw.common.util.T;
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.i18n.LocaleContextHolder;
+import org.springframework.web.servlet.LocaleResolver;
+import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
+import org.springframework.web.servlet.i18n.SessionLocaleResolver;
+
+import java.util.Locale;
+
+@Configuration
+@EnableAutoConfiguration
+@ComponentScan
+public class LocaleConfig implements WebMvcConfigurer {
+
+    @Bean
+    public LocaleResolver localeResolver() {
+        SessionLocaleResolver slr = new SessionLocaleResolver();
+        // 默认语言
+        slr.setDefaultLocale(Locale.of("en"));
+        return slr;
+    }
+
+    @Bean
+    public LocaleChangeInterceptor localeChangeInterceptor() {
+        MyI18nInterceptor lci = new MyI18nInterceptor();
+        // 参数名
+        lci.setParamName("Language");
+        return lci;
+    }
+
+    @Override
+    public void addInterceptors(InterceptorRegistry registry) {
+        registry.addInterceptor(localeChangeInterceptor());
+    }
+
+}
+
+class MyI18nInterceptor extends LocaleChangeInterceptor {
+
+    private static final Log log = Log.get();
+
+    @Override
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
+        try {
+            String language = request.getHeader(getParamName());
+            if (T.ObjectUtil.isNotEmpty(language)) {
+                Locale locale = parseLocaleValue(language);
+                LocaleContextHolder.setLocale(locale);
+            }
+        } catch (Exception e) {
+            log.error(e, "[preHandle] [error]");
+        }
+        return true;
+    }
+
+}

src/main/java/net/geedge/asw/common/config/MybatisPlusConfig.java

@@ -1,11 +1,15 @@
 package net.geedge.asw.common.config;
 
+import com.baomidou.mybatisplus.annotation.DbType;
+import com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator;
+import com.baomidou.mybatisplus.core.incrementer.IdentifierGenerator;
+import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
+import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
-import com.baomidou.mybatisplus.annotation.DbType;
-import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
-import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
+import java.util.UUID;
+import java.util.concurrent.ThreadLocalRandom;
 
 @Configuration(proxyBeanMethods = false)
 public class MybatisPlusConfig {
@@ -19,4 +23,29 @@ public class MybatisPlusConfig {
         interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MARIADB));//如果配置多个插件,切记分页最后添加
         return interceptor;
     }
+
+    @Bean
+    public IdentifierGenerator identifierGenerator() {
+        return new IdentifierGenerator() {
+
+            @Override
+            public Number nextId(Object entity) {
+                return DefaultIdentifierGenerator.getInstance().nextId(entity);
+            }
+
+            /**
+             * 自定义 UUID 生成格式，带有中划线，示例格式：c2ce91d1-d1f4-4629-aae4-414df36d87ca
+             *
+             * @param entity
+             * @return
+             */
+            @Override
+            public String nextUUID(Object entity) {
+                ThreadLocalRandom random = ThreadLocalRandom.current();
+                return (new UUID(random.nextLong(), random.nextLong())).toString();
+            }
+
+        };
+    }
+
 }

src/main/java/net/geedge/asw/common/config/Query.java

@@ -0,0 +1,101 @@
+package net.geedge.asw.common.config;
+
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.core.metadata.OrderItem;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import net.geedge.asw.common.util.ASWException;
+import net.geedge.asw.common.util.Constants;
+import net.geedge.asw.common.util.RCode;
+import net.geedge.asw.common.util.T;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 查询参数
+ */
+public class Query {
+
+    private Class clz;
+
+    public Class<? extends Object> getClz() {
+        return clz;
+    }
+
+    public void setClz(Class clz) {
+        this.clz = clz;
+    }
+
+    public Query(Class clz) {
+        this.clz = clz;
+    }
+
+    public Page getPage(Map<String, Object> params) {
+        return this.getPage(params, null, false);
+    }
+
+    public Page getPage(Map<String, Object> params, String defaultOrderField, boolean isAsc) {
+        //分页参数
+        long curPage = 1;
+        long limit = Constants.PAGESIZE;
+
+        if(params.get(Constants.PAGE) != null){
+            curPage = Long.parseLong((String)params.get(Constants.PAGE));
+        }
+        if(params.get(Constants.LIMIT) != null){
+            limit = Long.parseLong((String)params.get(Constants.LIMIT));
+            if(limit == -1){
+                limit = Long.MAX_VALUE;
+                curPage = 0;
+            }
+        }
+
+        //分页对象
+        Page page = new Page(curPage, limit);
+
+        //分页参数
+        params.put(Constants.PAGE, page);
+
+        //排序字段  orderBy=id
+        //防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险）
+        String orderField = SQLFilter.sqlInject((String)params.get(Constants.ORDER));
+
+        if (StrUtil.isNotEmpty(orderField)) {
+            boolean matcheFlag = orderField.trim().matches("-?[a-zA-Z_.-]+");
+            if (!matcheFlag) {
+                throw new ASWException(RCode.ERROR);
+            }
+
+            // 获取表名
+            Class<?> clz = this.getClz();
+            String tableName = "";
+            if (clz != null) {
+                TableName table = this.getClz().getAnnotation(TableName.class);
+                tableName = table.value();
+            }
+            // 通过表名获取排序字段映射
+            Map<String, String> columnAliasMap = Constants.TABLE_NAME_ORDER_FIELD_MAPPING.get(tableName);
+            columnAliasMap = T.MapUtil.isEmpty(columnAliasMap) ? new HashMap<>():columnAliasMap;
+            if (orderField.startsWith("-")) {
+                orderField = orderField.substring(1, orderField.length());
+                orderField = columnAliasMap.get(orderField) != null ? columnAliasMap.get(orderField) : orderField;
+                return page.addOrder(OrderItem.desc(orderField));
+            } else {
+                orderField = columnAliasMap.get(orderField) != null ? columnAliasMap.get(orderField) : orderField;
+                return page.addOrder(OrderItem.asc(orderField));
+            }
+        }
+
+        // 默认排序
+        if (StrUtil.isNotEmpty(defaultOrderField)) {
+            if (isAsc) {
+                return page.addOrder(OrderItem.asc(defaultOrderField));
+            } else {
+                return page.addOrder(OrderItem.desc(defaultOrderField));
+            }
+        }
+
+        return page;
+    }
+}

src/main/java/net/geedge/asw/common/config/SQLFilter.java

@@ -0,0 +1,49 @@
+/**
+ *
+ */
+
+package net.geedge.asw.common.config;
+
+import net.geedge.asw.common.util.ASWException;
+import net.geedge.asw.common.util.RCode;
+import net.geedge.asw.common.util.T;
+
+import java.util.regex.Pattern;
+
+/**
+ * SQL过滤
+ *
+ * @author Mark sunlightcs@gmail.com
+ */
+public class SQLFilter {
+
+    private static String reg = "(?:')|(?:--)|(/\\*(?:.|[\\n\\r])*?\\*/)|(\\b(select|update|union|and|or|delete|insert|trancate|char|into|substr|ascii|declare|exec|count|master|into|drop|execute)\\b)";
+
+    private static Pattern sqlPattern = Pattern.compile(reg, Pattern.CASE_INSENSITIVE);
+
+    /**
+     * SQL注入过滤
+     * @param str  待验证的字符串
+     */
+    public static String sqlInject(String str) {
+        if (T.StrUtil.isBlank(str)) {
+            return null;
+        }
+
+        //转换成小写
+        String str1 = str.toLowerCase();
+
+        String s = "";
+        if (str1.startsWith("-")) {
+            s = str1.substring(1);
+        } else {
+            s = str1;
+        }
+
+        if (sqlPattern.matcher(s).matches()) {
+            throw new ASWException(RCode.ERROR);
+        }
+
+        return str;
+    }
+}

src/main/java/net/geedge/asw/common/config/SaTokenConfigure.java

@@ -1,17 +1,23 @@
 package net.geedge.asw.common.config;
 
-import java.util.concurrent.TimeUnit;
-
+import cn.dev33.satoken.config.SaTokenConfig;
+import cn.dev33.satoken.interceptor.SaInterceptor;
+import cn.dev33.satoken.jwt.SaJwtTemplate;
+import cn.dev33.satoken.jwt.SaJwtUtil;
+import cn.dev33.satoken.jwt.StpLogicJwtForStateless;
+import cn.dev33.satoken.router.SaRouter;
+import cn.dev33.satoken.stp.StpLogic;
+import cn.dev33.satoken.stp.StpUtil;
+import cn.hutool.jwt.JWT;
+import jakarta.annotation.PostConstruct;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
-import cn.dev33.satoken.config.SaTokenConfig;
-import cn.dev33.satoken.interceptor.SaInterceptor;
-import cn.dev33.satoken.router.SaRouter;
-import cn.dev33.satoken.stp.StpUtil;
+import java.util.concurrent.TimeUnit;
 
 @Configuration(proxyBeanMethods = false)
 public class SaTokenConfigure implements WebMvcConfigurer {
@@ -38,6 +44,8 @@ public class SaTokenConfigure implements WebMvcConfigurer {
 		config.setTokenStyle("simple-uuid"); // token 风格
 		config.setIsLog(false); // 是否输出操作日志
 		config.setIsPrint(false);
+		// jwt秘钥
+		config.setJwtSecretKey("ypCLARItfzxvdVqRwPcwIasdgAkhoubj");
 //		config.setIsReadCookie(false);
 	}
 
@@ -47,7 +55,32 @@ public class SaTokenConfigure implements WebMvcConfigurer {
 		// 注册 Sa-Token 拦截器，打开注解式鉴权功能
 		registry.addInterceptor(new SaInterceptor(handler -> {
 			SaRouter.match("/file/**").notMatch("/file/content/*").check(r -> StpUtil.checkLogin());
-			SaRouter.match("/sys/**").notMatch("/sys/login").check(r -> StpUtil.checkLogin());
+			SaRouter.match("/api/v1/**").notMatch("/api/v1/login").check(r -> StpUtil.checkLogin());
 		})).addPathPatterns("/**");
 	}
+
+	@Bean
+	public StpLogic getStpLogicJwt() {
+		// Sa-Token 整合 jwt (Stateless 无状态模式)
+		return new StpLogicJwtForStateless();
+	}
+
+	/**
+	 * 自定义 SaJwtUtil 生成 token 的算法
+	 */
+	@PostConstruct
+	public void setSaJwtTemplate() {
+		SaJwtUtil.setSaJwtTemplate(new SaJwtTemplate() {
+			@Override
+			public String generateToken(JWT jwt, String keyt) {
+				// header
+				jwt.setHeader("alg", "HS256");
+				jwt.setHeader("typ", "JWT");
+
+				// payload
+				jwt.setPayload("iss", "net.geedge.asw");
+				return super.generateToken(jwt, keyt);
+			}
+		});
+	}
 }

src/main/java/net/geedge/asw/common/config/SpringContextUtils.java

@@ -0,0 +1,41 @@
+package net.geedge.asw.common.config;
+
+import org.springframework.beans.BeansException;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.stereotype.Component;
+
+/**
+ * Spring Context 工具类
+ */
+@Component
+public class SpringContextUtils implements ApplicationContextAware {
+
+    private static ApplicationContext applicationContext;
+
+    @Override
+    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+        SpringContextUtils.applicationContext = applicationContext;
+    }
+
+    public static Object getBean(String name) {
+        return applicationContext.getBean(name);
+    }
+
+    public static <T> T getBean(Class<T> requiredType) {
+        return applicationContext.getBean(requiredType);
+    }
+
+    public static String getProperty(String key, String defaultValue) {
+        return applicationContext.getEnvironment().getProperty(key, defaultValue);
+    }
+
+    public static <T> T getBean(String name, Class<T> requiredType) {
+        return applicationContext.getBean(name, requiredType);
+    }
+
+    public static Class<? extends Object> getType(String name) {
+        return applicationContext.getType(name);
+    }
+
+}

src/main/java/net/geedge/asw/common/config/exception/ASWExceptionHandler.java

@@ -1,18 +1,20 @@
 package net.geedge.asw.common.config.exception;
 
-import org.apache.catalina.connector.ClientAbortException;
-import org.springframework.dao.DuplicateKeyException;
-import org.springframework.http.HttpStatus;
-import org.springframework.web.bind.annotation.ExceptionHandler;
-import org.springframework.web.bind.annotation.ResponseStatus;
-import org.springframework.web.bind.annotation.RestControllerAdvice;
-
 import cn.dev33.satoken.exception.NotLoginException;
 import cn.hutool.log.Log;
 import jakarta.servlet.http.HttpServletRequest;
 import net.geedge.asw.common.util.ASWException;
 import net.geedge.asw.common.util.R;
 import net.geedge.asw.common.util.RCode;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.sys.service.ISysI18nService;
+import org.apache.catalina.connector.ClientAbortException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
 
 /**
  * 异常处理器
@@ -22,6 +24,9 @@ public class ASWExceptionHandler {
 
 	private static final Log log = Log.get();
 
+	@Autowired
+	private ISysI18nService sysI18nService;
+
 	/**
 	 * 处理自定义异常
 	 */
@@ -29,7 +34,19 @@ public class ASWExceptionHandler {
 	@ResponseStatus(value = HttpStatus.BAD_REQUEST)
 	public R handleDHException(ASWException e, HttpServletRequest request) {
 		log.warn(e, "Request uri: {}", request.getRequestURI());
-		return R.error(e.getCode(), e.getMsg());
+		R r = new R();
+		r.put("code", e.getCode());
+		String msg = "";
+		// by code
+		if (T.ObjectUtil.isNotEmpty(e.getCode())) {
+			msg = sysI18nService.queryValueByName(T.StrUtil.toString(e.getCode()), e.getParam());
+		}
+		if (T.StrUtil.isEmpty(msg) && (T.ObjectUtil.isEmpty(e.getRCode()) || T.ObjectUtil.equals(msg, e.getRCode().toString()))) {
+			r.put("msg", e.getMsg());
+		} else {
+			r.put("msg", msg);
+		}
+		return r;
 	}
 
 	/**
@@ -49,7 +66,8 @@ public class ASWExceptionHandler {
 	@ResponseStatus(value = HttpStatus.BAD_REQUEST)
 	public R handleDuplicateKeyException(DuplicateKeyException e, HttpServletRequest request) {
 		log.error(e, "Request uri: {}", request.getRequestURI());
-		return R.error(RCode.SYS_DUPLICATE_RECORD);
+		String msg = sysI18nService.queryValueByName(RCode.SYS_DUPLICATE_RECORD.getCode().toString());
+		return R.error(RCode.SYS_DUPLICATE_RECORD.getCode(), msg);
 	}
 
 	@ExceptionHandler(Exception.class)

src/main/java/net/geedge/asw/common/config/job/JobConfig.java

@@ -0,0 +1,103 @@
+package net.geedge.asw.common.config.job;
+
+import cn.hutool.log.Log;
+import jakarta.annotation.PostConstruct;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.environment.job.JobEnvironmentStatusChecker;
+import net.geedge.asw.module.runner.job.JobPlaybookExecResultChecker;
+import net.geedge.asw.module.runner.job.JobPlaybookExecutor;
+import net.geedge.asw.module.sys.service.ISysConfigService;
+import org.quartz.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.env.Environment;
+
+import java.util.TimeZone;
+
+@Configuration
+public class JobConfig {
+
+    private static final Log log = Log.get();
+
+    private static final String JOB_NAME_PREFIX = "ASW_JOB";
+    private static final String JOB_DEFAULT_GROUP = "SYSTEM";
+
+    /**
+     * get job key
+     * job_name=ASW_JOB_{name}
+     * group_name=SYSTEM
+     */
+    private static JobKey getJobKey(String name) {
+        String jobName = T.StrUtil.concat(true, JOB_NAME_PREFIX, "_", name);
+        return new JobKey(jobName, JOB_DEFAULT_GROUP);
+    }
+
+    @Autowired
+    private Scheduler scheduler;
+
+    @Autowired
+    private Environment environment;
+
+    @Autowired
+    private ISysConfigService sysConfigService;
+
+    @Bean
+    public JobDetail JobEnvironmentStatusChecker() {
+        return JobBuilder.newJob(JobEnvironmentStatusChecker.class)
+                .withIdentity(getJobKey(JobEnvironmentStatusChecker.class.getSimpleName()))
+                .storeDurably()
+                .build();
+    }
+
+    @Bean
+    public JobDetail JobPlaybookExecutor() {
+        return JobBuilder.newJob(JobPlaybookExecutor.class)
+                .withIdentity(getJobKey(JobPlaybookExecutor.class.getSimpleName()))
+                .storeDurably()
+                .build();
+    }
+
+    @Bean
+    public JobDetail JobPlaybookExecResultChecker() {
+        return JobBuilder.newJob(JobPlaybookExecResultChecker.class)
+                .withIdentity(getJobKey(JobPlaybookExecResultChecker.class.getSimpleName()))
+                .storeDurably()
+                .build();
+    }
+
+    @PostConstruct
+    public void init() throws SchedulerException {
+        // JobEnvironmentStatusChecker
+        createCronScheduleJob(JobEnvironmentStatusChecker(), environment.getProperty("asw.cron.JobEnvironmentStatusChecker", "0 0/1 * * * ? *"));
+        createCronScheduleJob(JobPlaybookExecutor(), environment.getProperty("asw.cron.JobPlaybookExecutor", "0 0/1 * * * ? *"));
+        createCronScheduleJob(JobPlaybookExecResultChecker(), environment.getProperty("asw.cron.JobPlaybookExecResultChecker", "0/30 * * * * ?"));
+    }
+
+    /**
+     * create cron schedule job
+     * 先删后增
+     */
+    private void createCronScheduleJob(JobDetail jobDetail, String cronExpression) throws SchedulerException {
+        JobKey key = jobDetail.getKey();
+
+        boolean jobExists = scheduler.checkExists(key);
+        if (log.isDebugEnabled()) {
+            log.debug("[createCronScheduleJob] [key: {}] [exists: {}]", key.toString(), jobExists);
+        }
+        if (jobExists) {
+            scheduler.deleteJob(key);
+            log.debug("[createCronScheduleJob] [key: {}] [deleted]", key.toString());
+        }
+
+        String timezone = sysConfigService.getValue("timezone");
+        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression).inTimeZone(TimeZone.getTimeZone(timezone));
+
+        CronTrigger cronTrigger = TriggerBuilder.newTrigger()
+                .forJob(jobDetail)
+                .withSchedule(cronScheduleBuilder)
+                .build();
+        scheduler.scheduleJob(jobDetail, cronTrigger);
+    }
+
+}

src/main/java/net/geedge/asw/common/config/websocket/EnvironmentNovncWebSocketHandler.java

@@ -0,0 +1,159 @@
+package net.geedge.asw.common.config.websocket;
+
+
+import cn.hutool.core.io.IoUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.json.JSONObject;
+import cn.hutool.log.Log;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import net.geedge.asw.common.util.Constants;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.environment.entity.EnvironmentEntity;
+import net.geedge.asw.module.environment.entity.EnvironmentSessionEntity;
+import net.geedge.asw.module.environment.service.IEnvironmentService;
+import net.geedge.asw.module.environment.service.IEnvironmentSessionService;
+import org.springframework.stereotype.Component;
+import org.springframework.web.socket.*;
+import org.springframework.web.socket.handler.TextWebSocketHandler;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.WebSocket;
+import java.nio.ByteBuffer;
+import java.util.concurrent.CompletionStage;
+
+@Component
+public class EnvironmentNovncWebSocketHandler extends TextWebSocketHandler {
+    private static final Log log = Log.get();
+
+    /**
+     * env id
+     */
+    private String envId;
+
+    /**
+     * session
+     */
+    private String sessionId;
+
+    /**
+     * user id
+     */
+    private String userId;
+
+
+    private IEnvironmentService environmentService;
+
+    private IEnvironmentSessionService environmentSessionService;
+
+    public EnvironmentNovncWebSocketHandler(IEnvironmentService environmentService, IEnvironmentSessionService environmentSessionService) {
+        this.environmentService = environmentService;
+        this.environmentSessionService = environmentSessionService;
+    }
+
+    private void initFieldVal(WebSocketSession session) {
+        this.envId = (String) session.getAttributes().get("envId");
+        this.sessionId = (String) session.getAttributes().get("sessionId");
+        this.userId = (String) session.getAttributes().get("userId");
+        Constants.ENV_NOVNC_WEBSOCKET_SESSION.put(sessionId, session);
+    }
+
+    @Override
+    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
+        super.afterConnectionEstablished(session);
+        this.initFieldVal(session);
+        // token
+        if (T.StrUtil.isEmpty(userId)) {
+            log.warn("Websocket token authentication failed");
+            session.close(CloseStatus.NORMAL.withReason("Websocket token authentication failed"));
+            return;
+        }
+
+        // env session
+        EnvironmentSessionEntity environmentSession = environmentSessionService.getOne(new LambdaQueryWrapper<EnvironmentSessionEntity>().eq(EnvironmentSessionEntity::getId, sessionId).eq(EnvironmentSessionEntity::getStatus, 1));
+        if (environmentSession == null) {
+            log.warn("environment session does not exist. session id: {}", sessionId);
+            session.close(CloseStatus.NORMAL.withReason("Environment session does not exist"));
+            return;
+        }
+        log.info("WebSocket connectioned. after connection established open environment begin...  environment id: {}", envId);
+        EnvironmentEntity deviceEntity = environmentService.queryInfo(envId);
+        JSONObject paramJSONObject = deviceEntity.getParamJSONObject();
+
+        String urlStr = String.format("%s%s", paramJSONObject.getStr("url"), Constants.ENV_NOVNC_WEBSOCKET_PATH);
+        urlStr = urlStr.replace("http", "ws");
+        WebSocket webSocket = null;
+        try {
+            HttpClient client = HttpClient.newHttpClient();
+            webSocket = client.newWebSocketBuilder()
+                    .buildAsync(URI.create(urlStr), new WebSocketListener(session))
+                    .get();
+        } catch (Exception e) {
+            log.error(e, "Environment WebSocket connectioned. after connection established open environment error. session id: {}", sessionId);
+            if (ObjectUtil.isNotNull(webSocket)) {
+                webSocket.sendClose(WebSocket.NORMAL_CLOSURE, "Normal closure");
+            }
+            if (session != null) {
+                session.close(CloseStatus.NORMAL.withReason("Environment WebSocket connectioned. after connection established open environment error!"));
+                IoUtil.close(session);
+                Constants.ENV_NOVNC_WEBSOCKET_SESSION.remove(sessionId);
+            }
+        }
+        log.info("[afterConnectionEstablished] [environment server: {}]", T.JSONUtil.toJsonStr(paramJSONObject));
+        session.getAttributes().put("envWebsocket", webSocket);
+    }
+
+    // WebSocket 监听器实现
+    private static class WebSocketListener implements WebSocket.Listener {
+        private WebSocketSession session;
+
+        public WebSocketListener(WebSocketSession session) {
+            this.session = session;
+        }
+
+
+        @Override
+        public CompletionStage<?> onBinary(WebSocket webSocket, ByteBuffer data, boolean last) {
+
+            try {
+                // env -> asw
+                session.sendMessage(new BinaryMessage(data, true));
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+            return WebSocket.Listener.super.onBinary(webSocket, data, last);
+        }
+
+        @Override
+        public CompletionStage<?> onClose(WebSocket webSocket, int statusCode, String reason) {
+            log.info("Environment webSocket connection closed, Status: " + statusCode + ", Reason: " + reason);
+            return WebSocket.Listener.super.onClose(webSocket, statusCode, reason);
+        }
+    }
+
+    @Override
+    protected void handleBinaryMessage(WebSocketSession session, BinaryMessage message) {
+        try {
+            // asw -> env
+            WebSocket envSocket = (WebSocket) session.getAttributes().get("envWebsocket");
+            if (envSocket != null) {
+                envSocket.sendBinary(message.getPayload(), true);
+            }
+        } catch (Exception e) {
+            log.error(e, "[handleBinaryMessage] [error]");
+        }
+    }
+
+    @Override
+    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
+        log.info("[afterConnectionClosed] [WebSocket connection closed] [websocket uri: {}]", session.getUri());
+        WebSocket envWebsocket = (WebSocket) session.getAttributes().get("envWebsocket");
+        if (envWebsocket != null) {
+            envWebsocket.sendClose(WebSocket.NORMAL_CLOSURE, "Normal closure");
+        }
+        Constants.ENV_NOVNC_WEBSOCKET_SESSION.remove(sessionId);
+        super.afterConnectionClosed(session, status);
+    }
+
+}

src/main/java/net/geedge/asw/common/config/websocket/EnvironmentTerminalWebSocketHandler.java

@@ -0,0 +1,160 @@
+package net.geedge.asw.common.config.websocket;
+
+import cn.hutool.core.io.IoUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.json.JSONObject;
+import cn.hutool.log.Log;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import net.geedge.asw.common.util.Constants;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.environment.entity.EnvironmentEntity;
+import net.geedge.asw.module.environment.entity.EnvironmentSessionEntity;
+import net.geedge.asw.module.environment.service.IEnvironmentService;
+import net.geedge.asw.module.environment.service.IEnvironmentSessionService;
+import org.springframework.stereotype.Component;
+import org.springframework.web.socket.CloseStatus;
+import org.springframework.web.socket.TextMessage;
+import org.springframework.web.socket.WebSocketSession;
+import org.springframework.web.socket.handler.TextWebSocketHandler;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.WebSocket;
+import java.util.concurrent.CompletionStage;
+
+@Component
+public class EnvironmentTerminalWebSocketHandler extends TextWebSocketHandler {
+
+    private static final Log log = Log.get();
+
+    /**
+     * env id
+     */
+    private String envId;
+
+    /**
+     * session
+     */
+    private String sessionId;
+
+    /**
+     * user id
+     */
+    private String userId;
+
+
+    private IEnvironmentService environmentService;
+
+    private IEnvironmentSessionService environmentSessionService;
+
+    public EnvironmentTerminalWebSocketHandler(IEnvironmentService environmentService, IEnvironmentSessionService environmentSessionService) {
+        this.environmentService = environmentService;
+        this.environmentSessionService = environmentSessionService;
+    }
+
+    private void initFieldVal(WebSocketSession session) {
+        this.envId = (String) session.getAttributes().get("envId");
+        this.sessionId = (String) session.getAttributes().get("sessionId");
+        this.userId = (String) session.getAttributes().get("userId");
+        Constants.ENV_TERMINAL_WEBSOCKET_SESSION.put(sessionId, session);
+    }
+
+    @Override
+    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
+        super.afterConnectionEstablished(session);
+
+        this.initFieldVal(session);
+        // token
+        if (T.StrUtil.isEmpty(userId)) {
+            log.warn("Websocket token authentication failed");
+            session.close(CloseStatus.NORMAL.withReason("Websocket token authentication failed"));
+            return;
+        }
+
+        // env session
+        EnvironmentSessionEntity environmentSession = environmentSessionService.getOne(new LambdaQueryWrapper<EnvironmentSessionEntity>().eq(EnvironmentSessionEntity::getId, sessionId).eq(EnvironmentSessionEntity::getStatus, 1));
+        if (environmentSession == null) {
+            log.warn("environment session does not exist. session id: {}", sessionId);
+            session.close(CloseStatus.NORMAL.withReason("Environment session does not exist"));
+            return;
+        }
+        log.info("WebSocket connectioned. after connection established open environment terminal begin...  environment id: {}", envId);
+        EnvironmentEntity deviceEntity = environmentService.queryInfo(envId);
+        JSONObject paramJSONObject = deviceEntity.getParamJSONObject();
+
+        String urlStr = String.format("%s%s", paramJSONObject.getStr("url"), Constants.ENV_TERMINAL_WEBSOCKET_PATH);
+        urlStr = urlStr.replace("http", "ws");
+        WebSocket webSocket = null;
+        try {
+            HttpClient client = HttpClient.newHttpClient();
+            webSocket = client.newWebSocketBuilder()
+                    .buildAsync(URI.create(urlStr), new WebSocketListener(session))
+                    .get();
+        } catch (Exception e) {
+            log.error(e, "Environment terminal webSocket connectioned. after connection established open environment terminal error. session id: {}", sessionId);
+            if (ObjectUtil.isNotNull(webSocket)) {
+                webSocket.sendClose(WebSocket.NORMAL_CLOSURE, "Normal closure");
+            }
+            if (ObjectUtil.isNotNull(session)) {
+                session.close(CloseStatus.NORMAL.withReason("Environment terminal webSocket connectioned. after connection established open environment terminal error!"));
+                IoUtil.close(session);
+                Constants.ENV_TERMINAL_WEBSOCKET_SESSION.remove(sessionId);
+            }
+        }
+        log.info("[afterConnectionEstablished] [environment terminal url: {}]", urlStr);
+        session.getAttributes().put("terminalWebsocket", webSocket);
+    }
+
+
+    // WebSocket 监听器实现
+    private static class WebSocketListener implements WebSocket.Listener {
+        private WebSocketSession session;
+
+        public WebSocketListener(WebSocketSession session) {
+            this.session = session;
+        }
+
+
+        @Override
+        public CompletionStage<?> onText(WebSocket webSocket, CharSequence message, boolean last) {
+            try {
+                // env -> asw
+                session.sendMessage(new TextMessage(message));
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+            return WebSocket.Listener.super.onText(webSocket, message, last);
+        }
+
+        @Override
+        public CompletionStage<?> onClose(WebSocket webSocket, int statusCode, String reason) {
+            log.info("Environment terminal webSocket connection closed, Status: " + statusCode + ", Reason: " + reason);
+            return WebSocket.Listener.super.onClose(webSocket, statusCode, reason);
+        }
+    }
+
+
+    @Override
+    protected void handleTextMessage(WebSocketSession session, TextMessage message) {
+        WebSocket terminalWebsocket = (WebSocket) session.getAttributes().get("terminalWebsocket");
+        try {
+            if (terminalWebsocket != null) {
+                terminalWebsocket.sendText(message.getPayload(), true);
+            }
+        } catch (Exception e) {
+        }
+    }
+
+    @Override
+    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
+        log.info("[afterConnectionClosed] [Terminal webSocket connection closed] [uri: {}]", session.getUri());
+        WebSocket envWebsocket = (WebSocket) session.getAttributes().get("terminalWebsocket");
+        if (envWebsocket != null) {
+            envWebsocket.sendClose(WebSocket.NORMAL_CLOSURE, "Normal closure");
+        }
+
+        Constants.ENV_TERMINAL_WEBSOCKET_SESSION.remove(sessionId);
+        super.afterConnectionClosed(session, status);
+    }
+}

src/main/java/net/geedge/asw/common/config/websocket/EnvironmentWebSocketInterceptor.java

@@ -0,0 +1,53 @@
+package net.geedge.asw.common.config.websocket;
+
+import cn.dev33.satoken.stp.StpUtil;
+import cn.hutool.log.Log;
+import net.geedge.asw.common.util.T;
+import org.springframework.http.server.ServerHttpRequest;
+import org.springframework.http.server.ServerHttpResponse;
+import org.springframework.http.server.ServletServerHttpRequest;
+import org.springframework.stereotype.Component;
+import org.springframework.web.socket.WebSocketHandler;
+import org.springframework.web.socket.server.support.HttpSessionHandshakeInterceptor;
+
+
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+@Component
+public class EnvironmentWebSocketInterceptor extends HttpSessionHandshakeInterceptor {
+    private static final Log log = Log.get();
+
+    private String regex = "^/api/v1/env/([^/]+)/session/([^/]+)/(novnc|terminal)$";
+
+    @Override
+    public synchronized boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception {
+        if (request instanceof ServletServerHttpRequest) {
+            ServletServerHttpRequest servletRequest = (ServletServerHttpRequest) request;
+            String servletPath = servletRequest.getServletRequest().getServletPath();
+            Pattern pattern = Pattern.compile(regex);
+            Matcher matcher = pattern.matcher(servletPath);
+            if (matcher.find()) {
+                attributes.put("envId", matcher.group(1));
+                attributes.put("sessionId", matcher.group(2));
+            }
+            try {
+                String token = servletRequest.getServletRequest().getParameter("token");
+                StpUtil.setTokenValue(token);
+                String userId = StpUtil.getLoginIdAsString();
+                attributes.put("userId", userId);
+            }catch (Exception e){
+                log.error("Websocket token authentication failed");
+                attributes.put("userId", T.StrUtil.EMPTY);
+            }
+        }
+        return super.beforeHandshake(request, response, wsHandler, attributes);
+    }
+
+    @Override
+    public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception exception) {
+        super.afterHandshake(request, response, wsHandler, exception);
+    }
+
+}

src/main/java/net/geedge/asw/common/config/websocket/WebSocketConfig.java

@@ -0,0 +1,31 @@
+package net.geedge.asw.common.config.websocket;
+
+import net.geedge.asw.module.environment.service.IEnvironmentService;
+import net.geedge.asw.module.environment.service.IEnvironmentSessionService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.socket.config.annotation.EnableWebSocket;
+import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
+import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
+
+@Configuration
+@EnableWebSocket
+public class WebSocketConfig implements WebSocketConfigurer {
+
+    @Autowired
+    private IEnvironmentService deviceService;
+
+    @Autowired
+    private IEnvironmentSessionService environmentSessionService;
+
+    @Override
+    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
+        registry.addHandler(new EnvironmentNovncWebSocketHandler(deviceService, environmentSessionService), "/api/v1/env/{envId}/session/{sessionId}/novnc")
+                .addInterceptors(new EnvironmentWebSocketInterceptor())
+                .setAllowedOrigins("*");
+
+        registry.addHandler(new EnvironmentTerminalWebSocketHandler(deviceService, environmentSessionService), "/api/v1/env/{envId}/session/{sessionId}/terminal")
+                .addInterceptors(new EnvironmentWebSocketInterceptor())
+                .setAllowedOrigins("*");
+    }
+}

src/main/java/net/geedge/asw/common/util/ASWException.java

@@ -12,12 +12,14 @@ public class ASWException extends RuntimeException {
 	private String msg = RCode.ERROR.getMsg();
 	private int code = RCode.ERROR.getCode();
 	private Object[] param = new Object[] {};
+	private RCode rCode;
 
 	public ASWException(RCode rCode) {
 		super(rCode.getMsg());
 		this.code = rCode.getCode();
 		this.msg = rCode.getMsg();
 		this.param = rCode.getParam();
+		this.rCode = rCode;
 	}
 
 	public ASWException(String msg) {

src/main/java/net/geedge/asw/common/util/Constants.java

@@ -1,6 +1,11 @@
 package net.geedge.asw.common.util;
 
+import org.springframework.web.socket.WebSocketSession;
+
 import java.io.File;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 public class Constants {
 
@@ -14,6 +19,100 @@ public class Constants {
 	 */
 	public static final String TEMP_PATH = System.getProperty("user.dir") + File.separator + "tmp";
 
+	/**
+	 * playbook dir
+	 */
+	public static File PLAYBOOK_FILES_DIR = T.FileUtil.file(T.WebPathUtil.getRootPath(), "playbook_files");
+
+	/**
+	 * 国际化语言列表
+	 */
+	public static final List<String> LANG_LIST = T.ListUtil.of("en", "zh");
 
 
+	/**
+	 * 工作空间可见性列表
+	 */
+	public static final List<String> VISIBILITY_LIST = T.ListUtil.of("public", "private");
+
+	/**
+	 * 当前页码
+	 */
+	public static final String PAGE = "current";
+	/**
+	 * 每页显示记录数
+	 */
+	public static final String LIMIT = "size";
+	/**
+	 * 每页显示条数
+	 */
+	public static final long PAGESIZE = 20;
+	/**
+	 * 排序方式
+	 */
+	public static final String ORDER = "orderBy";
+	/**
+	 * 表名 和 排序字段对应关系 KEY: tablename
+	 */
+	public static final Map<String, Map<String, String>> TABLE_NAME_ORDER_FIELD_MAPPING = T.MapUtil.newHashMap();
+
+	static {
+		Map<String, String> applicationOrderFieldMap = new HashMap<>();
+		TABLE_NAME_ORDER_FIELD_MAPPING.put("application", applicationOrderFieldMap);
+	}
+
+
+	/**
+	 * env api path prefix
+	 */
+	public static final String ENV_API_PREFIX = "/api/v1/env";
+
+	public static final String AUTH_TOKEN_CODE = "Authorization";
+
+
+	public static final Map<String, String> CORS_HEADER = T.MapUtil
+			.builder("Access-Control-Allow-Credentials", "true")
+			.put("Access-Control-Allow-Methods", "GET,PUT,POST,PATCH,DELETE,HEAD,OPTIONS")
+			.put("Access-Control-Max-Age", "18000").put("Access-Control-Allow-Origin", "*").build();
+
+
+	/**
+	 * env api novnc websocket path
+	 */
+	public static final String ENV_NOVNC_WEBSOCKET_PATH = "/api/v1/env/novnc";
+
+	public static final String ENV_TERMINAL_WEBSOCKET_PATH = "/api/v1/env/terminal";
+
+	/**
+	 * env api stop tcpdump path
+	 */
+	public static final String ENV_API_TCPDUMP_PATH = "/api/v1/env/pcap";
+
+	/**
+	 * env api status path
+	 */
+	public static final String ENV_API_STATUS_PATH = "/api/v1/env/status";
+
+	/**
+	 * novnc websocket 连接信息对应的 env session id  用以进行主动断开服务器连接功能
+	 */
+	public static final Map<String, WebSocketSession> ENV_NOVNC_WEBSOCKET_SESSION = T.MapUtil.newHashMap();
+
+	/**
+	 * terminal websocket 连接信息对应的 env session id  用以进行主动断开服务器连接功能
+	 */
+	public static final Map<String, WebSocketSession> ENV_TERMINAL_WEBSOCKET_SESSION = T.MapUtil.newHashMap();
+
+
+	/**
+	 * Android package type
+	 */
+	public static final List<String> ANDROID_PACKAGE_TYPE_LIST = T.ListUtil.of("xapk", "apk");
+
+	public static final String EMPTY_FILE_MD5 = "d41d8cd98f00b204e9800998ecf8427e";
+
+	/**
+	 * tid -> jobId 用于获取 job 运行结果
+	 */
+	public static final Map<String, String> PLAYBOOK_EXECUTOR_RESULT = T.MapUtil.newHashMap();
 }

src/main/java/net/geedge/asw/common/util/HttpContextUtils.java

@@ -0,0 +1,21 @@
+/**
+
+ *
+
+ *
+ * 
+ */
+
+package net.geedge.asw.common.util;
+
+import jakarta.servlet.http.HttpServletRequest;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+
+public class HttpContextUtils {
+
+	public static HttpServletRequest getHttpServletRequest() {
+		return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
+	}
+}

src/main/java/net/geedge/asw/common/util/IPUtils.java

@@ -0,0 +1,82 @@
+/**
+
+ *
+
+ *
+ * 
+ */
+
+package net.geedge.asw.common.util;
+
+import cn.hutool.log.Log;
+import jakarta.servlet.http.HttpServletRequest;
+import org.apache.commons.lang3.StringUtils;
+
+
+/**
+ * IP地址
+ *
+ * @author Mark sunlightcs@gmail.com
+ */
+public class IPUtils {
+	private static Log logger = Log.get();
+
+	/**
+	 * 获取IP地址
+	 * 
+	 * 使用Nginx等反向代理软件， 则不能通过request.getRemoteAddr()获取IP地址
+	 * 如果使用了多级反向代理的话，X-Forwarded-For的值并不止一个，而是一串IP地址，X-Forwarded-For中第一个非unknown的有效IP字符串，则为真实IP地址
+	 */
+	public static String getIpAddr(HttpServletRequest request) {
+    	String ip = null;
+        try {
+            ip = request.getHeader("x-forwarded-for");
+            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
+                ip = request.getHeader("Proxy-Client-IP");
+            }
+            if (StringUtils.isEmpty(ip) || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
+                ip = request.getHeader("WL-Proxy-Client-IP");
+            }
+            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
+                ip = request.getHeader("HTTP_CLIENT_IP");
+            }
+            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
+                ip = request.getHeader("HTTP_X_FORWARDED_FOR");
+            }
+            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
+                ip = request.getRemoteAddr();
+            }
+        } catch (Exception e) {
+        	logger.error("IPUtils ERROR ",e);
+        }
+        
+//        //使用代理，则获取第一个IP地址
+//        if(StringUtils.isEmpty(ip) && ip.length() > 15) {
+//			if(ip.indexOf(",") > 0) {
+//				ip = ip.substring(0, ip.indexOf(","));
+//			}
+//		}
+        
+        return ip;
+    }
+    /**
+     * 功能：判断一个IP是不是在一个网段下的
+     * 格式：isInRange("192.168.8.3", "192.168.9.10/22");
+     */
+    public static boolean isInRange(String ip, String cidr) {
+        String[] ips = ip.split("\\.");
+        int ipAddr = (Integer.parseInt(ips[0]) << 24)
+                | (Integer.parseInt(ips[1]) << 16)
+                | (Integer.parseInt(ips[2]) << 8) | Integer.parseInt(ips[3]);
+        int type = Integer.parseInt(cidr.replaceAll(".*/", ""));
+        int mask = 0xFFFFFFFF << (32 - type);
+        String cidrIp = cidr.replaceAll("/.*", "");
+        String[] cidrIps = cidrIp.split("\\.");
+        int cidrIpAddr = (Integer.parseInt(cidrIps[0]) << 24)
+                | (Integer.parseInt(cidrIps[1]) << 16)
+                | (Integer.parseInt(cidrIps[2]) << 8)
+                | Integer.parseInt(cidrIps[3]);
+
+        return (ipAddr & mask) == (cidrIpAddr & mask);
+    }
+}

src/main/java/net/geedge/asw/common/util/RCode.java

@@ -5,7 +5,7 @@ import java.text.MessageFormat;
 public enum RCode {
 
 	/**
-	 * 10**** : 系统认证 或 通用错误提示 20**** : screen module
+	 * 10**** : 系统认证 或 通用错误提示 20**** : sys module
 	 */
 
 	ERROR(999, "error"), // 通用错误/未知错误
@@ -18,27 +18,79 @@ public enum RCode {
 	PARAM_CANNOT_EMPTY(100006, "parameter cannot be empty"), // parameter 不能为空
 	USER_NO_LOGIN(100007, "user not login"), // 用户未登录
 	SYS_RECORD_NOT_FOUND(100008, "record not found"),// 未找到记录
+	USER_ID_CANNOT_EMPTY(100009, "user id cannot be empty"),// 用户 ID 不能为空
+	ROLE_ID_CANNOT_EMPTY(100010, "role id cannot be empty"),// 权限 ID 不能为空
+	USER_NOT_EXIST(100011, "user does not exist"),
+	ROLE_NOT_EXIST(100012, "role does not exist"),
+	SYS_USER_NAME_CANNOT_EMPTY(100013, "username cannot be empty"),
+	SYS_ACCESS_LEVEL_CANNOT_EMPTY(100014, "accessLevel cannot be empty"),
+	SYS_WORKSPACE_ROLES_CANNOT_EMPTY(100015, "workspaceRoles cannot be empty"),
+	SYS_USER_BUILT_IN(100016, "Built-in user are not allowed to delete or update"),
+	SYS_ROLE_BUILT_IN(100017, "Built-in role are not allowed to delete or update"),
+	SYS_ROLE_NOT_DELETE(100018, "Used role cannot be deleted"),
+	SYS_USER_OLDPWD_INCORRECT(100019, "Incorrect old password. Please try again."),
 
 
-	SCREEN_ID_CANNOT_EMPTY(200001, "id cannot be empty"),
+	// Application
+	APP_ID_CANNOT_EMPTY(201001, "application id cannot be empty"),
+	APP_NAME_CANNOT_EMPTY(201002, "application name cannot be empty"),
+	APP_LONGNAME_CANNOT_EMPTY(201003, "application longName cannot be empty"),
+	APP_PROPERTIES_CANNOT_EMPTY(201004, "application properties cannot be empty"),
+	APP_SURROGATES_CANNOT_EMPTY(201005, "application surrogates cannot be empty"),
+	APP_DESCRIPTION_CANNOT_EMPTY(201006, "application description cannot be empty"),
+	APP_DUPLICATE_RECORD(201007, "application duplicate record"),
+	APP_NOT_EXIST(201008, "application does not exist"),
+	APP_PACKAGE_NAME_FORMAT_ERROR(201009, "application package name format error"),
+	APP_TAGS_FORMAT_ERROR(201010, "application tags format error"),
+	APP_SIGNATURE_FORMAT_ERROR(201011, "application signature format error"),
+	APP_SIGNATURE_CONTENT_CANNOT_EMPTY(201012, "application signature content cannot be empty"),
+	APP_SIGNATURE_NOT_EXIST(201013, "application signature does not exist"),
+	APP_NOTE_CONTENT_CANNOT_EMPTY(201014, "application note content cannot be empty"),
+	APP_ATTACHMENT_NOT_EXIST(201015, "application attachment does not exist"),
+	APP_PROPERTIES_FORMAT_ERROR(201016, "application properties format error"),
+	APP_IMPORT_FILE_FORMAT_ERROR(201017, "application import file format error"),
+
+
+
+	// Package
+	PACKAGE_ID_CANNOT_EMPTY(202001, "package id cannot be empty"),
+	PACKAGE_DESCRIPTION_CANNOT_EMPTY(202002, "package description cannot be empty"),
+	PACKAGE_FILE_TYPE_ERROR(202003, "package invalid file"),
+
+
+	// Runner
+	RUNNER_ID_CANNOT_EMPTY(301001, "runner id cannot be empty"),
+
+
+	// Playbook
+	PLAYBOOK_ID_CANNOT_EMPTY(302001, "playbook id cannot be empty"),
+	PLAYBOOK_NAME_DUPLICATE(302002, "playbook name duplicate "),
+
+	// Workspace
+	WORKSPACE_ID_CANNOT_EMPTY(401001, "workspace id cannot be empty"),
+	WORKSPACE_NAME_CANNOT_EMPTY(401002, "workspace name cannot be empty"),
+	WORKSPACE_VISIBILITY_CANNOT_EMPTY(401003, "workspace visibility cannot be empty"),
+	WORKSPACE_USER_CANNOT_EMPTY(401004, "workspace user cannot be empty"),
+	WORKSPACE_ALREADY_EXISTS(401005, "workspace already exists"),
+	WORKSPACE_MEMBER_CANNOT_EMPTY(401006, "workspace member cannot be empty"),
+	WORKSPACE_CANNOT_DELETE(401007, "Built-in workspace cannot be deleted"),
+	WORKSPACE_VISIBILITY_ERROR(401008, "workspace visibility error"),
+	WORKSPACE_BUILT_IN(401009, "Built-in workspace cannot be update"),
+	WORKSPACE_NOT_EXIST(401010, "Workspace does not exist"),
+	WORKSPACE_MEMBER_USER_ID_REPEAT(401011, "Workspace member user repeat"),
+
+	//PCAP
+	PCAP_UPLOAD_WEB_SHARK_ERROR(501001, "web shark upload pcap error"),
+
+
+	//environment
+	ENVIRONMENT_SESSION_NOT_EXIST(601001, "environment session does not exist"),
+	ENVIRONMENT_NOT_EXIST(601002, "environment does not exist"),
+	ENVIRONMENT_USED(601003, "The environment is already in use"),
+	ENVIRONMENT_STATUS_ERROR(601004, "The environment status is unavailable"),
+	ENVIRONMENT_ID_CANNOT_EMPTY(601005, "environment id cannot be empty"),
 
-	SCREE_DATASOURCE_DEFAULT_CANNOT_BE_DELETE(300001,"The default data source cannot be deleted."),
-	SCREE_DATASOURCE_REPEAT(300002,"Screen datasource name duplicate"),
 
-	/**
-	 * import
-	 */
-	EXCELFILE_TYPE_ERROR(400001, "The type can only be xlsx, json, csv"),
-	EXCELFILE_PARSE_ERROR(400002, "Import file resolution failed"),
-	EXCELFILE_HEADER_TEMPLATE_ERROR(400003,"The header row of the import template is inconsistent with the system template"),
-	EXCELFILE_HEADER_LANGUAGE_ERROR(400004, "Language must be en, zh or ru"),
-	EXCELFILE_IMPORT_FILE_ISNULL(400005, "Import file is null"),
-	EXCELFILE_HEADER_LANGUAGE_ISNULL(400006, "Language can not be empty"),
-	EXCELFILE_IMPORT_ERROR(400007, "File import error"),
-	EXCELFILE_SCHEDULE_TASK_IS_NULL(400008, "Schedule task can not be empty"),
-	EXCELFILE_SCHEDULE_CRON_IS_NULL(400009, "Schedule cron can not be empty"),
-	EXCELFILE_SCHEDULE_ENABLE_IS_NULL(400010, "Schedule enable can not be empty"),
-	EXCELFILE_SCHEDULE_SCRIPT_IS_NULL(400011, "Schedule script can not be empty"),
 
 
 	SUCCESS(200, "success"); // 成功

src/main/java/net/geedge/asw/common/util/ResponseUtil.java

@@ -1,16 +1,15 @@
 package net.geedge.asw.common.util;
 
-import java.io.IOException;
-
-import org.springframework.http.MediaType;
-
-import com.j256.simplemagic.ContentInfo;
-import com.j256.simplemagic.ContentInfoUtil;
-
 import cn.hutool.core.io.IORuntimeException;
 import cn.hutool.core.util.ReflectUtil;
 import cn.hutool.core.util.StrUtil;
+import com.j256.simplemagic.ContentInfo;
+import com.j256.simplemagic.ContentInfoUtil;
 import jakarta.servlet.http.HttpServletResponse;
+import org.springframework.http.MediaType;
+
+import java.io.IOException;
+import java.net.URLEncoder;
 
 public class ResponseUtil {
 
@@ -25,7 +24,7 @@ public class ResponseUtil {
      * @throws IOException
      */
     public static void downloadFile(HttpServletResponse response, String contentType, String filename, byte[] data) throws IORuntimeException, IOException {
-        String fileName = T.URLUtil.encode(filename, T.CharsetUtil.CHARSET_UTF_8);
+        String fileName = URLEncoder.encode(filename, "UTF-8");
         ReflectUtil.invoke(response, "addHeader", "Content-Disposition", "attachment; filename=" + fileName);
         ReflectUtil.invoke(response, "addHeader", "Content-Length", "" + data.length);
         ReflectUtil.invoke(response, "setHeader", "Access-Control-Expose-Headers", "Content-Disposition");
@@ -46,7 +45,7 @@ public class ResponseUtil {
     public static void downloadFile(HttpServletResponse response, String filename, byte[] data)
             throws IORuntimeException, IOException {
         response.setContentType(ResponseUtil.getDownloadContentType(filename));
-        String fileName = T.URLUtil.encode(filename, T.CharsetUtil.CHARSET_UTF_8);
+        String fileName = URLEncoder.encode(filename, "UTF-8");
 //		response.addHeader("Content-Disposition", "attachment; filename=" + fileName);
 //		response.addHeader("Content-Length", "" + data.length);
 //		response.setHeader("Access-Control-Expose-Headers", "Content-Disposition");

src/main/java/net/geedge/asw/common/util/T.java

@@ -1,27 +1,9 @@
 package net.geedge.asw.common.util;
 
-import java.awt.Graphics;
-import java.awt.Robot;
-import java.lang.ref.PhantomReference;
-import java.lang.ref.Reference;
-import java.lang.ref.ReferenceQueue;
-import java.lang.ref.SoftReference;
-import java.lang.ref.WeakReference;
-import java.lang.reflect.Type;
-import java.math.BigDecimal;
-import java.net.Socket;
-import java.nio.ByteBuffer;
-import java.security.NoSuchAlgorithmException;
-import java.security.SecureRandom;
-import java.time.LocalDateTime;
-import java.time.temporal.Temporal;
-import java.time.temporal.TemporalAccessor;
-import java.util.Calendar;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.Spliterator;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
+import cn.hutool.core.date.DateTime;
+import cn.hutool.log.Log;
+import com.baomidou.mybatisplus.core.metadata.OrderItem;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 
 import javax.crypto.Cipher;
 import javax.crypto.KeyGenerator;
@@ -29,10 +11,23 @@ import javax.crypto.SecretKey;
 import javax.crypto.spec.SecretKeySpec;
 import javax.tools.JavaCompiler;
 import javax.tools.JavaFileObject;
-
-import com.baomidou.mybatisplus.core.metadata.OrderItem;
-
-import cn.hutool.core.date.DateTime;
+import java.awt.*;
+import java.io.File;
+import java.io.UnsupportedEncodingException;
+import java.lang.ref.*;
+import java.lang.reflect.Type;
+import java.math.BigDecimal;
+import java.net.Socket;
+import java.net.URLDecoder;
+import java.nio.ByteBuffer;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.time.LocalDateTime;
+import java.time.temporal.Temporal;
+import java.time.temporal.TemporalAccessor;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 public class T {
 
@@ -315,6 +310,27 @@ public class T {
 	 * @author xiaoleilu
 	 */
 	public static class PageUtil extends cn.hutool.core.util.PageUtil {
+		public static final Integer DEFAULT_PAGENO = 1;
+		public static final Integer DEFAULT_PAGESIZE = 20;
+
+		public static Page getPage(Map<String, Object> params) {
+			// 分页参数
+			Integer pageNo = T.MapUtil.getInt(params, "current", DEFAULT_PAGENO);
+			Integer pageSize = T.MapUtil.getInt(params, "size", DEFAULT_PAGESIZE);
+			if (pageSize == -1) {
+				pageNo = 0;
+				pageSize = Integer.MAX_VALUE;
+			}
+
+			Page page = Page.of(pageNo, pageSize);
+
+			String orderBy = T.MapUtil.getStr(params, "orderBy");
+			if (T.StrUtil.isNotEmpty(orderBy)) {
+				page.addOrder(T.PageUtil.decodeOrderByStr(orderBy));
+			}
+			return page;
+		}
+
 		public static OrderItem decodeOrderByStr(String orderBy) {
 			if (cn.hutool.core.util.StrUtil.isBlank(orderBy)) {
 				return null;
@@ -1526,4 +1542,37 @@ public class T {
 			super(value);
 		}
 	}
+
+
+	/**
+	 * 获取项目中各种路径
+	 *
+	 * @author ThinkPad
+	 */
+	public static class WebPathUtil {
+		private static final Log log = Log.get();
+
+		/**
+		 * 如果已打成jar包，则返回jar包所在目录
+		 * 如果未打成jar，则返回target所在目录
+		 *
+		 * @return
+		 */
+		public static String getClassPath() {
+			try {
+				// 项目的编译文件的根目录
+				String path = URLDecoder.decode(System.getProperty("user.dir"), "utf-8");
+				log.debug("root path:{}", path);
+				return path;
+			} catch (UnsupportedEncodingException e) {
+				return null;
+			}
+		}
+
+		public static String getRootPath() {
+			File file = T.FileUtil.file(WebPathUtil.getClassPath());
+			return file.getAbsolutePath();
+		}
+	}
+
 }

src/main/java/net/geedge/asw/common/util/TemplateUtil.java

@@ -0,0 +1,28 @@
+package net.geedge.asw.common.util;
+
+import freemarker.cache.StringTemplateLoader;
+import freemarker.template.Configuration;
+import freemarker.template.Template;
+
+import java.io.IOException;
+
+public class TemplateUtil {
+
+    public static Template stringToTemplate(String templateStr,String templateKey) throws IOException {
+
+        // 创建配置类
+        Configuration configuration = new Configuration(Configuration.DEFAULT_INCOMPATIBLE_IMPROVEMENTS);
+        //创建模板加载器
+        StringTemplateLoader templateLoader = new StringTemplateLoader();
+        // 存入模板
+        templateLoader.putTemplate(templateKey, templateStr);  //template  = 虚拟名称, 用来当作获取静态文件的key
+        //加载模板加载器
+        configuration.setTemplateLoader(templateLoader);
+        //得到模板
+        Template template = configuration.getTemplate(templateKey, "utf-8");
+
+        return  template;
+
+    }
+
+}

src/main/java/net/geedge/asw/common/util/VerifyUtil.java

@@ -387,6 +387,13 @@ public class VerifyUtil {
 		return this;
 	}
 
+	public VerifyUtil json(RCode code) {
+		if (!T.JSONUtil.isTypeJSON(T.StrUtil.toStringOrNull(value))) {
+			throw ASWException.builder().rcode(code).build();
+		}
+		return this;
+	}
+
 	/**
 	 * 多参数校验，不能同时为空
 	 * 

src/main/java/net/geedge/asw/module/app/controller/ApplicationController.java

@@ -0,0 +1,323 @@
+package net.geedge.asw.module.app.controller;
+
+import cn.hutool.json.JSONObject;
+import cn.hutool.log.Log;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import jakarta.servlet.http.HttpServletResponse;
+import net.geedge.asw.common.util.ASWException;
+import net.geedge.asw.common.util.R;
+import net.geedge.asw.common.util.RCode;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.app.entity.*;
+import net.geedge.asw.module.app.service.*;
+import net.geedge.asw.module.workspace.entity.WorkspaceEntity;
+import net.geedge.asw.module.workspace.service.IWorkspaceService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/api/v1/application")
+public class ApplicationController {
+
+    private static final Log log = Log.get();
+
+    @Autowired
+    private IWorkspaceService workspaceService;
+
+    @Autowired
+    private IApplicationService applicationService;
+
+    @Autowired
+    private IApplicationSignatureService signatureService;
+
+    @Autowired
+    private IApplicationNoteService noteService;
+
+    @Autowired
+    private IApplicationHrefService hrefService;
+
+    @Autowired
+    private IApplicationAttachmentService attachmentService;
+
+    @GetMapping("/{id}")
+    public R detail(@PathVariable("id") String id, String workspaceId) {
+        T.VerifyUtil.is(workspaceId).notNull();
+        ApplicationEntity entity = applicationService.detail(id, workspaceId);
+        if (T.ObjectUtil.isNull(entity)) {
+            throw new ASWException(RCode.APP_NOT_EXIST);
+        }
+        return R.ok().putData("record", entity);
+    }
+
+
+    @GetMapping
+    public R list(@RequestParam Map<String, Object> params) {
+        T.VerifyUtil.is(params).notNull()
+                .and(T.MapUtil.getStr(params, "workspaceId")).notEmpty(RCode.WORKSPACE_ID_CANNOT_EMPTY);
+        Page page = applicationService.queryList(params);
+        return R.ok(page);
+    }
+
+    @PostMapping
+    @Transactional(rollbackFor = Exception.class)
+    public R add(@RequestParam(required = true) String basic,
+                 @RequestParam(required = false) String signature,
+                 @RequestParam(required = false) String note,
+                 @RequestParam(required = false) String hrefs,
+                 @RequestParam(required = false, value = "files") List<MultipartFile> fileList) {
+        // validate
+        ApplicationEntity entity;
+        try {
+            entity = T.JSONUtil.toBean(basic, ApplicationEntity.class);
+
+            if (T.StrUtil.isNotEmpty(signature)) {
+                ApplicationSignatureEntity signatureEntity = T.JSONUtil.toBean(signature, ApplicationSignatureEntity.class);
+                entity.setSignature(signatureEntity);
+            }
+
+            if (T.StrUtil.isNotEmpty(note)) {
+                ApplicationNoteEntity noteEntity = T.JSONUtil.toBean(note, ApplicationNoteEntity.class);
+                entity.setNote(noteEntity);
+            }
+
+            if (T.StrUtil.isNotEmpty(hrefs)) {
+                T.JSONUtil.toList(hrefs, ApplicationHrefEntity.class);
+            }
+        } catch (Exception e) {
+            log.error(e, "[add] [param format error]");
+            throw new ASWException(RCode.ERROR);
+        }
+
+        T.VerifyUtil.is(entity).notNull()
+                .and(entity.getName()).notEmpty(RCode.APP_NAME_CANNOT_EMPTY)
+                .and(entity.getWorkspaceId()).notEmpty(RCode.WORKSPACE_ID_CANNOT_EMPTY);
+
+        // save application
+        ApplicationEntity applicationEntity = applicationService.saveApplication(entity);
+
+        // save attachment
+        fileList = T.CollUtil.defaultIfEmpty(fileList, new ArrayList<>());
+        for (MultipartFile file : fileList) {
+            attachmentService.saveAttachment(file.getResource(), applicationEntity.getId());
+        }
+
+        // save href
+        if (T.StrUtil.isNotEmpty(hrefs)) {
+            List<ApplicationHrefEntity> hrefList = T.JSONUtil.toList(hrefs, ApplicationHrefEntity.class);
+            hrefService.updateBatchHref(applicationEntity.getId(), hrefList);
+        }
+        return R.ok().putData("id", applicationEntity.getId());
+    }
+
+    @PutMapping
+    public R update(@RequestBody ApplicationEntity entity) {
+        T.VerifyUtil.is(entity).notNull()
+                .and(entity.getId()).notEmpty(RCode.ID_CANNOT_EMPTY)
+                .and(entity.getName()).notEmpty(RCode.NAME_CANNOT_EMPTY)
+                //.and(entity.getSignature()).notEmpty(RCode.APP_SURROGATES_CANNOT_EMPTY)
+                //.and(entity.getNote()).notEmpty(RCode.APP_PROPERTIES_CANNOT_EMPTY)
+                .and(entity.getWorkspaceId()).notEmpty(RCode.WORKSPACE_ID_CANNOT_EMPTY);
+
+        ApplicationEntity applicationEntity = applicationService.updateApplication(entity);
+        return R.ok().putData("id", applicationEntity.getId());
+    }
+
+
+    @PutMapping("/{id}/basic")
+    public R basic(@PathVariable String id, @RequestBody ApplicationEntity entity) {
+        T.VerifyUtil.is(entity).notNull()
+                .and(entity.getName()).notEmpty(RCode.NAME_CANNOT_EMPTY)
+                .and(entity.getWorkspaceId()).notEmpty(RCode.WORKSPACE_ID_CANNOT_EMPTY);
+        entity.setId(id);
+        ApplicationEntity app = applicationService.updateBasic(entity);
+        return R.ok().putData("id", app.getId());
+    }
+
+    @PutMapping("/{applicationId}/signature")
+    public R updateSignature(@PathVariable("applicationId") String applicationId, @RequestBody ApplicationSignatureEntity signature) {
+        T.VerifyUtil.is(signature).notNull()
+                .and(signature.getContent()).notEmpty(RCode.APP_SURROGATES_CANNOT_EMPTY)
+                .and(signature.getContent()).json(RCode.APP_SURROGATES_CANNOT_EMPTY);
+
+        signatureService.saveSignature(signature, applicationId);
+        return R.ok().putData("id", signature.getId());
+    }
+
+    @PutMapping("/{applicationId}/note")
+    public R updateNote(@PathVariable("applicationId") String applicationId, @RequestBody ApplicationNoteEntity note) {
+        T.VerifyUtil.is(note).notNull();
+                //.and(note.getContent()).notEmpty(RCode.APP_NOTE_CONTENT_CANNOT_EMPTY);
+
+        noteService.saveNote(note, applicationId);
+        return R.ok().putData("id", note.getId());
+    }
+
+    @DeleteMapping
+    public R delete(String[] ids) {
+        T.VerifyUtil.is(ids).notEmpty();
+        applicationService.removeApplication(T.ListUtil.of(ids));
+        return R.ok();
+    }
+
+
+    @GetMapping("/{applicationId}/attachment")
+    public R queryAttachment(@PathVariable String applicationId) {
+        T.VerifyUtil.is(applicationId).notNull();
+
+        List<ApplicationAttachmentEntity> list = attachmentService.list(new LambdaQueryWrapper<ApplicationAttachmentEntity>().eq(ApplicationAttachmentEntity::getApplicationId, applicationId));
+        return R.ok().putData("records", list);
+    }
+
+
+    @GetMapping("/{applicationId}/attachment/{attachmentId}")
+    public void downloadAttachment(HttpServletResponse response, @PathVariable String applicationId, @PathVariable String attachmentId) throws IOException {
+        T.VerifyUtil.is(applicationId).notNull()
+                .and(attachmentId).notNull();
+
+        attachmentService.download(response, applicationId, attachmentId);
+    }
+
+    @PostMapping("/{applicationId}/attachment")
+    public R uploadAttachment(@PathVariable String applicationId, @RequestParam("files") List<MultipartFile> fileList) {
+
+        List<ApplicationAttachmentEntity> recordList = T.ListUtil.list(true);
+        for (int i = 0; i < fileList.size(); i++) {
+            MultipartFile file = fileList.get(i);
+            ApplicationAttachmentEntity attachmentEntity = attachmentService.saveAttachment(file.getResource(), applicationId);
+            recordList.add(attachmentEntity);
+        }
+        return R.ok().putData("records", recordList);
+    }
+
+    @DeleteMapping("/{applicationId}/attachment")
+    public R removedAttachment(@PathVariable String applicationId, @RequestParam String ids) {
+
+        attachmentService.removedAttachment(applicationId, ids);
+        return R.ok();
+    }
+
+
+    @GetMapping("/{applicationId}/signature")
+    public R querySignature(@PathVariable String applicationId) {
+        T.VerifyUtil.is(applicationId).notNull();
+        List<ApplicationSignatureEntity> signatureList = signatureService.queryList(applicationId);
+        return R.ok().putData("records", signatureList);
+    }
+
+
+    @GetMapping("/{applicationId}/signature/{oldVersion}/{newVersion}")
+    public R signatureCompare(@PathVariable("applicationId") String applicationId,
+                              @PathVariable("oldVersion") String oldVersion,
+                              @PathVariable("newVersion") String newVersion) {
+        List<ApplicationSignatureEntity> list = signatureService.compare(applicationId, oldVersion, newVersion);
+        return R.ok().putData("records", list);
+    }
+
+
+    @PutMapping("/{applicationId}/signature/{version}/restore")
+    public R restore(@PathVariable("applicationId") String applicationId,
+                     @PathVariable("version") String version) {
+        signatureService.restore(applicationId, version);
+        return R.ok();
+    }
+
+
+    // application href
+    @GetMapping("/{applicationId}/href")
+    public R queryHref(@PathVariable String applicationId) {
+        List<ApplicationHrefEntity> entityList = hrefService.queryList(applicationId);
+        return R.ok().putData("records", entityList);
+    }
+
+    @RequestMapping(value = "/{applicationId}/href", method = {RequestMethod.POST, RequestMethod.PUT})
+    public R updateBatchHref(@PathVariable String applicationId, @RequestBody List<ApplicationHrefEntity> hrefList) {
+        // validate
+        ApplicationEntity application = applicationService.getById(applicationId);
+        T.VerifyUtil.is(application).notNull(RCode.APP_NOT_EXIST);
+
+        for (ApplicationHrefEntity href : hrefList) {
+            T.VerifyUtil.is(href).notNull()
+                    .and(href.getName()).notEmpty(RCode.NAME_CANNOT_EMPTY)
+                    .and(href.getUrl()).notEmpty(RCode.PARAM_CANNOT_EMPTY);
+
+            href.setApplicationId(applicationId);
+        }
+
+        // save or update batch
+        List<ApplicationHrefEntity> entityList = hrefService.updateBatchHref(hrefList);
+        List<Map<String, String>> records = entityList.stream()
+                .map(entity -> Map.of("id", entity.getId()))
+                .collect(Collectors.toList());
+        return R.ok().putData("records", records);
+    }
+
+    @DeleteMapping("/{applicationId}/href")
+    public R deleteHref(@PathVariable String applicationId, @RequestParam String[] ids) {
+        // remove
+        hrefService.remove(new LambdaQueryWrapper<ApplicationHrefEntity>()
+                .eq(ApplicationHrefEntity::getApplicationId, applicationId)
+                .in(ApplicationHrefEntity::getId, T.ListUtil.of(ids)));
+        return R.ok();
+    }
+
+
+    @PostMapping("/import")
+    public R importApplication(@RequestParam String workspaceId,
+                               @RequestParam(defaultValue = "tsg2402") String format,
+                               @RequestParam(value = "files") List<MultipartFile> fileList) {
+        // validate
+        WorkspaceEntity workspace = workspaceService.getById(workspaceId);
+        T.VerifyUtil.is(workspace).notNull(RCode.WORKSPACE_NOT_EXIST);
+
+        List<JSONObject> dataList = T.ListUtil.list(true);
+        try {
+            for (MultipartFile multipartFile : fileList) {
+                String str = T.IoUtil.readUtf8(multipartFile.getInputStream());
+                JSONObject jsonObject = T.JSONUtil.parseObj(str);
+                if (null == jsonObject.getJSONArray("applications")) {
+                    continue;
+                }
+                dataList.add(jsonObject);
+            }
+        } catch (Exception e) {
+            throw new ASWException(RCode.APP_IMPORT_FILE_FORMAT_ERROR);
+        }
+
+        // import
+        List<ApplicationEntity> entityList = applicationService.importAppByFormat(workspaceId, format, dataList);
+        List<Map<String, String>> records = entityList.stream()
+                .map(entity -> Map.of("id", entity.getId()))
+                .collect(Collectors.toList());
+        return R.ok().putData("records", records);
+    }
+
+    @GetMapping("/export")
+    public void exportApplication(@RequestParam String workspaceId,
+                                  @RequestParam String ids,
+                                  @RequestParam(defaultValue = "tsg2402") String format,
+                                  HttpServletResponse response) throws IOException {
+        // validate
+        List<ApplicationEntity> appList = applicationService.list(
+                new LambdaQueryWrapper<ApplicationEntity>()
+                        .eq(ApplicationEntity::getWorkspaceId, workspaceId)
+                        .in(ApplicationEntity::getId, T.ListUtil.of(ids.split(",")))
+        );
+        T.VerifyUtil.is(appList).notEmpty(RCode.APP_NOT_EXIST);
+
+        // format
+        byte[] bytes = applicationService.exportAppByFormat(appList, format);
+
+        // response
+        T.ResponseUtil.downloadFile(response, T.StrUtil.concat(true, "application_", System.currentTimeMillis() + ".json"), bytes);
+    }
+
+}

src/main/java/net/geedge/asw/module/app/controller/GitController.java

@@ -0,0 +1,52 @@
+package net.geedge.asw.module.app.controller;
+
+import net.geedge.asw.common.util.ASWException;
+import net.geedge.asw.common.util.R;
+import net.geedge.asw.common.util.RCode;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.app.service.IGitService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/v1/workspace")
+public class GitController {
+
+    @Autowired
+    private IGitService gitService;
+
+    @GetMapping("/{workspaceId}/branch")
+    public R listBranch(@PathVariable("workspaceId") String workspaceId,
+                        @RequestParam(value = "search", required = false) String search) {
+        List<Map<Object, Object>> list = gitService.listBranch(workspaceId, search);
+        return R.ok().putData("records", list);
+    }
+
+    @GetMapping("/{workspaceId}/branch/{branchName}")
+    public R infoBranch(@PathVariable("workspaceId") String workspaceId, @PathVariable("branchName") String branchName) {
+        Map<Object, Object> record = gitService.infoBranch(workspaceId, branchName);
+        return R.ok().putData("record", record);
+    }
+
+    @PostMapping("/{workspaceId}/branch")
+    public R newBranch(@PathVariable("workspaceId") String workspaceId, @RequestBody Map<String, String> requestBody) {
+        String branch = T.MapUtil.getStr(requestBody, "branch", "");
+        String ref = T.MapUtil.getStr(requestBody, "ref", "");
+        if (T.StrUtil.hasEmpty(branch, ref)) {
+            throw new ASWException(RCode.PARAM_CANNOT_EMPTY);
+        }
+
+        Map<Object, Object> record = gitService.newBranch(workspaceId, branch, ref);
+        return R.ok().putData("record", record);
+    }
+
+    @DeleteMapping("/{workspaceId}/branch/{branchName}")
+    public R deleteBranch(@PathVariable("workspaceId") String workspaceId, @PathVariable("branchName") String branchName) {
+        gitService.deleteBranch(workspaceId, branchName);
+        return R.ok();
+    }
+
+}

src/main/java/net/geedge/asw/module/app/controller/PackageController.java

@@ -0,0 +1,71 @@
+package net.geedge.asw.module.app.controller;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import jakarta.servlet.http.HttpServletResponse;
+import net.geedge.asw.common.util.R;
+import net.geedge.asw.common.util.RCode;
+import net.geedge.asw.common.util.ResponseUtil;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.app.entity.PackageEntity;
+import net.geedge.asw.module.app.service.IPackageService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/v1/workspace")
+public class PackageController {
+
+    @Autowired
+    private IPackageService packageService;
+
+    @GetMapping("/{workspaceId}/package/{id}")
+    public R detail(@PathVariable("workspaceId") String workspaceId, @PathVariable("id") String id) {
+        PackageEntity entity = packageService.queryInfo(id);
+        return R.ok().putData("record", entity);
+    }
+
+    @GetMapping("/{workspaceId}/package")
+    public R list(@PathVariable("workspaceId") String workspaceId, @RequestParam Map<String, Object> params) {
+        // workspaceId
+        params = T.MapUtil.defaultIfEmpty(params, new HashMap<>());
+        params.put("workspaceId", workspaceId);
+
+        Page page = packageService.queryList(params);
+        return R.ok(page);
+    }
+
+    @PostMapping("/{workspaceId}/package")
+    public R add(@PathVariable(value = "workspaceId", required = true) String workspaceId,
+                 @RequestParam(value = "description", required = false) String description,
+                 @RequestParam(value = "file") MultipartFile file) {
+
+        PackageEntity entity = packageService.savePackage(workspaceId, description, file.getResource());
+        return R.ok().putData("record", entity);
+    }
+
+    @DeleteMapping("/{workspaceId}/package")
+    public R delete(String[] ids) {
+        T.VerifyUtil.is(ids).notEmpty();
+        packageService.removePackage(T.ListUtil.of(ids));
+        return R.ok();
+    }
+
+    @GetMapping("/{workspaceId}/package/{id}/download")
+    public void download(@PathVariable("workspaceId") String workspaceId,
+                         @PathVariable("id") String id,
+                         HttpServletResponse response) throws IOException {
+        PackageEntity entity = packageService.getById(id);
+        T.VerifyUtil.is(entity).notNull(RCode.SYS_RECORD_NOT_FOUND);
+
+        File pkgFile = T.FileUtil.file(entity.getPath());
+        ResponseUtil.downloadFile(response, MediaType.APPLICATION_OCTET_STREAM_VALUE, entity.getName(), T.FileUtil.readBytes(pkgFile));
+    }
+
+}

src/main/java/net/geedge/asw/module/app/dao/ApplicationAttachmentDao.java

@@ -0,0 +1,10 @@
+package net.geedge.asw.module.app.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import net.geedge.asw.module.app.entity.ApplicationAttachmentEntity;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface ApplicationAttachmentDao extends BaseMapper<ApplicationAttachmentEntity>{
+
+}

src/main/java/net/geedge/asw/module/app/dao/ApplicationDao.java

@@ -0,0 +1,15 @@
+package net.geedge.asw.module.app.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import net.geedge.asw.module.app.entity.ApplicationEntity;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.List;
+import java.util.Map;
+
+@Mapper
+public interface ApplicationDao extends BaseMapper<ApplicationEntity>{
+
+    List<ApplicationEntity> queryList(Page page, Map<String, Object> params);
+}

src/main/java/net/geedge/asw/module/app/dao/ApplicationHrefDao.java

@@ -0,0 +1,15 @@
+package net.geedge.asw.module.app.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import net.geedge.asw.module.app.entity.ApplicationHrefEntity;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+@Mapper
+public interface ApplicationHrefDao extends BaseMapper<ApplicationHrefEntity> {
+
+    List<ApplicationHrefEntity> queryList(@Param("applicationId") String applicationId);
+
+}

src/main/java/net/geedge/asw/module/app/dao/ApplicationLogDao.java

@@ -0,0 +1,10 @@
+package net.geedge.asw.module.app.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import net.geedge.asw.module.app.entity.ApplicationLogEntity;
+import org.apache.ibatis.annotations.Mapper;
+
+
+@Mapper
+public interface ApplicationLogDao extends BaseMapper<ApplicationLogEntity> {
+}

src/main/java/net/geedge/asw/module/app/dao/ApplicationNoteDao.java

@@ -0,0 +1,10 @@
+package net.geedge.asw.module.app.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import net.geedge.asw.module.app.entity.ApplicationNoteEntity;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface ApplicationNoteDao extends BaseMapper<ApplicationNoteEntity>{
+
+}

src/main/java/net/geedge/asw/module/app/dao/ApplicationSignatureDao.java

@@ -0,0 +1,15 @@
+package net.geedge.asw.module.app.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import net.geedge.asw.module.app.entity.ApplicationSignatureEntity;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+import java.util.Map;
+
+@Mapper
+public interface ApplicationSignatureDao extends BaseMapper<ApplicationSignatureEntity>{
+
+    List<ApplicationSignatureEntity> queryList(@Param("params") Map<Object, Object> params);
+}

src/main/java/net/geedge/asw/module/app/dao/PackageDao.java

@@ -0,0 +1,16 @@
+package net.geedge.asw.module.app.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import net.geedge.asw.module.app.entity.PackageEntity;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.List;
+import java.util.Map;
+
+@Mapper
+public interface PackageDao extends BaseMapper<PackageEntity>{
+
+    List<PackageEntity> queryList(Page page, Map<String, Object> params);
+
+}

src/main/java/net/geedge/asw/module/app/entity/ApplicationAttachmentEntity.java

@@ -0,0 +1,25 @@
+package net.geedge.asw.module.app.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+@Data
+@TableName("application_attachment")
+public class ApplicationAttachmentEntity {
+
+	@TableId(type = IdType.ASSIGN_UUID)
+	private String id;
+
+	private String applicationId;
+
+	private String name;
+
+	private String path;
+
+	private Long createTimestamp;
+
+	private String createUserId;
+
+}

src/main/java/net/geedge/asw/module/app/entity/ApplicationEntity.java

@@ -0,0 +1,67 @@
+package net.geedge.asw.module.app.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
+import lombok.Data;
+import net.geedge.asw.module.sys.entity.SysUserEntity;
+
+import java.util.List;
+
+@Data
+@TableName(value = "application", autoResultMap = true)
+public class ApplicationEntity {
+
+	@TableId(type = IdType.ASSIGN_UUID)
+	private String id;
+
+	private String name;
+
+	private String tags;
+
+	private String packageName;
+
+	private String website;
+
+	private String provider;
+
+	@TableField(typeHandler = JacksonTypeHandler.class)
+	private Object properties;
+
+	private String status;
+
+	private String description;
+
+	private Long createTimestamp;
+
+	private Long updateTimestamp;
+
+	private String createUserId;
+
+	private String updateUserId;
+
+	private String workspaceId;
+
+	private Integer opVersion;
+
+	@TableField(exist = false)
+	private SysUserEntity createUser;
+
+	@TableField(exist = false)
+	private SysUserEntity updateUser;
+
+	@TableField(exist = false)
+	private ApplicationSignatureEntity signature;
+
+	@TableField(exist = false)
+	private ApplicationNoteEntity note;
+
+	@TableField(exist = false)
+	private List<ApplicationAttachmentEntity> attatchments;
+
+	@TableField(exist = false)
+	private List<ApplicationHrefEntity> hrefs;
+
+}

src/main/java/net/geedge/asw/module/app/entity/ApplicationHrefEntity.java

@@ -0,0 +1,30 @@
+package net.geedge.asw.module.app.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+import net.geedge.asw.module.sys.entity.SysUserEntity;
+
+import java.io.Serializable;
+
+@Data
+@TableName(value = "application_href", autoResultMap = true)
+public class ApplicationHrefEntity implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @TableId(type = IdType.ASSIGN_UUID)
+    private String id;
+    private String applicationId;
+    private String name;
+    private String url;
+
+    @TableField(updateStrategy = FieldStrategy.NEVER)
+    private Long createTimestamp;
+
+    @TableField(updateStrategy = FieldStrategy.NEVER)
+    private String createUserId;
+
+    @TableField(exist = false)
+    private SysUserEntity createUser;
+
+}

src/main/java/net/geedge/asw/module/app/entity/ApplicationLogEntity.java

@@ -0,0 +1,61 @@
+package net.geedge.asw.module.app.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
+import lombok.Data;
+import net.geedge.asw.module.sys.entity.SysUserEntity;
+import java.util.List;
+
+@Data
+@TableName(value = "application_log", autoResultMap = true)
+public class ApplicationLogEntity {
+
+    @TableId(type = IdType.ASSIGN_UUID)
+    private String id;
+
+    private String name;
+
+    private String tags;
+
+    private String packageName;
+
+    private String website;
+
+    private String provider;
+
+    @TableField(typeHandler = JacksonTypeHandler.class)
+    private String properties;
+
+    private String description;
+
+    private Long createTimestamp;
+
+    private Long updateTimestamp;
+
+    private String createUserId;
+
+    private String updateUserId;
+
+    private String workspaceId;
+
+    private Integer opVersion;
+
+    @TableField(exist = false)
+    private SysUserEntity createUser;
+
+    @TableField(exist = false)
+    private SysUserEntity updateUser;
+
+    @TableField(exist = false)
+    private ApplicationSignatureEntity signature;
+
+    @TableField(exist = false)
+    private ApplicationNoteEntity note;
+
+    @TableField(exist = false)
+    private List<ApplicationAttachmentEntity> attatchments;
+
+}

src/main/java/net/geedge/asw/module/app/entity/ApplicationNoteEntity.java

@@ -0,0 +1,25 @@
+package net.geedge.asw.module.app.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+@Data
+@TableName("application_note")
+public class ApplicationNoteEntity {
+
+	@TableId(type = IdType.ASSIGN_UUID)
+	private String id;
+
+	private String applicationId;
+
+	private String content;
+
+	private Long createTimestamp;
+
+	private String createUserId;
+
+	private Long opVersion;
+
+}

src/main/java/net/geedge/asw/module/app/entity/ApplicationSignatureEntity.java

@@ -0,0 +1,30 @@
+package net.geedge.asw.module.app.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import net.geedge.asw.module.sys.entity.SysUserEntity;
+
+@Data
+@TableName("application_signature")
+public class ApplicationSignatureEntity {
+
+	@TableId(type = IdType.ASSIGN_UUID)
+	private String id;
+
+	private String applicationId;
+
+	private String content;
+
+	private Long createTimestamp;
+
+	private String createUserId;
+
+	private Long opVersion;
+
+	@TableField(exist = false)
+	private SysUserEntity createUser;
+
+}

src/main/java/net/geedge/asw/module/app/entity/PackageEntity.java

@@ -0,0 +1,38 @@
+package net.geedge.asw.module.app.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import net.geedge.asw.module.sys.entity.SysUserEntity;
+
+@Data
+@TableName("package")
+public class PackageEntity {
+
+	@TableId(type = IdType.ASSIGN_UUID)
+	private String id;
+	private String name;
+	private String icon;
+	private String description;
+	private String platform;
+	private String version;
+	private String identifier;
+	private String path;
+	private Long size;
+
+	private Long createTimestamp;
+	private Long updateTimestamp;
+	private String createUserId;
+	private String updateUserId;
+
+	private String workspaceId;
+
+	@TableField(exist = false)
+	private SysUserEntity createUser;
+
+	@TableField(exist = false)
+	private SysUserEntity updateUser;
+
+}

src/main/java/net/geedge/asw/module/app/service/IApplicationAttachmentService.java

@@ -0,0 +1,17 @@
+package net.geedge.asw.module.app.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import jakarta.servlet.http.HttpServletResponse;
+import net.geedge.asw.module.app.entity.ApplicationAttachmentEntity;
+import org.springframework.core.io.Resource;
+
+import java.io.IOException;
+
+public interface IApplicationAttachmentService extends IService<ApplicationAttachmentEntity>{
+
+    ApplicationAttachmentEntity saveAttachment(Resource fileResource, String applicationId);
+
+    void removedAttachment(String applicationId, String ids);
+
+    void download(HttpServletResponse response, String applicationId, String attachmentId) throws IOException;
+}

src/main/java/net/geedge/asw/module/app/service/IApplicationHrefService.java

@@ -0,0 +1,17 @@
+package net.geedge.asw.module.app.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import net.geedge.asw.module.app.entity.ApplicationHrefEntity;
+
+import java.util.List;
+
+public interface IApplicationHrefService extends IService<ApplicationHrefEntity> {
+
+    List<ApplicationHrefEntity> queryList(String applicationId);
+
+    List<ApplicationHrefEntity> updateBatchHref(List<ApplicationHrefEntity> hrefList);
+
+    List<ApplicationHrefEntity> updateBatchHref(String applicationId, List<ApplicationHrefEntity> hrefList);
+
+
+}

src/main/java/net/geedge/asw/module/app/service/IApplicationLogService.java

@@ -0,0 +1,7 @@
+package net.geedge.asw.module.app.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import net.geedge.asw.module.app.entity.ApplicationLogEntity;
+
+public interface IApplicationLogService extends IService<ApplicationLogEntity> {
+}

src/main/java/net/geedge/asw/module/app/service/IApplicationNoteService.java

@@ -0,0 +1,9 @@
+package net.geedge.asw.module.app.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import net.geedge.asw.module.app.entity.ApplicationNoteEntity;
+
+public interface IApplicationNoteService extends IService<ApplicationNoteEntity>{
+
+    void saveNote(ApplicationNoteEntity note, String applicationId);
+}

src/main/java/net/geedge/asw/module/app/service/IApplicationService.java

@@ -0,0 +1,29 @@
+package net.geedge.asw.module.app.service;
+
+import cn.hutool.json.JSONObject;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.IService;
+import net.geedge.asw.module.app.entity.ApplicationEntity;
+
+import java.util.List;
+import java.util.Map;
+
+public interface IApplicationService extends IService<ApplicationEntity>{
+
+    ApplicationEntity detail(String id, String workspaceId);
+
+    Page queryList(Map<String, Object> params);
+
+    ApplicationEntity saveApplication(ApplicationEntity entity);
+
+    ApplicationEntity updateApplication(ApplicationEntity entity);
+
+    ApplicationEntity updateBasic(ApplicationEntity entity);
+
+    void removeApplication(List<String> ids);
+
+    byte[] exportAppByFormat(List<ApplicationEntity> appList, String format);
+
+    List<ApplicationEntity> importAppByFormat(String workspaceId, String format, List<JSONObject> dataList);
+
+}

src/main/java/net/geedge/asw/module/app/service/IApplicationSignatureService.java

@@ -0,0 +1,20 @@
+package net.geedge.asw.module.app.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import net.geedge.asw.module.app.entity.ApplicationSignatureEntity;
+
+import java.util.List;
+
+public interface IApplicationSignatureService extends IService<ApplicationSignatureEntity>{
+
+    void saveSignature(ApplicationSignatureEntity signature, String applicationId);
+
+    List<ApplicationSignatureEntity> queryList(String applicationId);
+
+    List<ApplicationSignatureEntity> compare(String applicationId, String oldVersion, String newVersion);
+
+    void restore(String id, String version);
+
+    ApplicationSignatureEntity queryLastVersionSignatureByAppId(String applicationId);
+
+}

src/main/java/net/geedge/asw/module/app/service/IGitService.java

@@ -0,0 +1,16 @@
+package net.geedge.asw.module.app.service;
+
+import java.util.List;
+import java.util.Map;
+
+public interface IGitService {
+
+    List<Map<Object, Object>> listBranch(String workspaceId, String search);
+
+    Map<Object, Object> infoBranch(String workspaceId, String branchName);
+
+    Map<Object, Object> newBranch(String workspaceId, String branchName, String ref);
+
+    void deleteBranch(String workspaceId, String branchName);
+
+}

src/main/java/net/geedge/asw/module/app/service/IPackageService.java

@@ -0,0 +1,20 @@
+package net.geedge.asw.module.app.service;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.IService;
+import net.geedge.asw.module.app.entity.PackageEntity;
+import org.springframework.core.io.Resource;
+
+import java.util.List;
+import java.util.Map;
+
+public interface IPackageService extends IService<PackageEntity>{
+
+    PackageEntity queryInfo(String id);
+
+    Page queryList(Map<String, Object> params);
+
+    PackageEntity savePackage(String workspaceId, String description, Resource fileResource);
+
+    void removePackage(List<String> ids);
+}

src/main/java/net/geedge/asw/module/app/service/ITSGApplicationService.java

@@ -0,0 +1,15 @@
+package net.geedge.asw.module.app.service;
+
+import cn.hutool.json.JSONObject;
+import net.geedge.asw.module.app.entity.ApplicationEntity;
+
+import java.util.List;
+import java.util.Map;
+
+public interface ITSGApplicationService {
+
+    Map<Object, Object> aswToTsg2402(List<ApplicationEntity> appList);
+
+    List<ApplicationEntity> tsg2402ToAsw(String workspaceId, List<JSONObject> dataList);
+
+}

src/main/java/net/geedge/asw/module/app/service/impl/ApplicationAttachmentServiceImpl.java

@@ -0,0 +1,101 @@
+package net.geedge.asw.module.app.service.impl;
+
+import cn.dev33.satoken.stp.StpUtil;
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.log.Log;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import jakarta.servlet.http.HttpServletResponse;
+import net.geedge.asw.common.util.ASWException;
+import net.geedge.asw.common.util.RCode;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.app.dao.ApplicationAttachmentDao;
+import net.geedge.asw.module.app.entity.ApplicationAttachmentEntity;
+import net.geedge.asw.module.app.entity.ApplicationEntity;
+import net.geedge.asw.module.app.service.IApplicationAttachmentService;
+import net.geedge.asw.module.app.service.IApplicationService;
+import org.apache.commons.io.FileUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.io.Resource;
+import org.springframework.http.MediaTypeFactory;
+import org.springframework.stereotype.Service;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+
+@Service
+public class ApplicationAttachmentServiceImpl extends ServiceImpl<ApplicationAttachmentDao, ApplicationAttachmentEntity> implements IApplicationAttachmentService {
+
+    private static final Log log = Log.get();
+
+    @Autowired
+    private IApplicationService applicationService;
+
+    @Override
+    public ApplicationAttachmentEntity saveAttachment(Resource fileResource, String applicationId) {
+
+        ApplicationEntity app = applicationService.getById(applicationId);
+        ApplicationAttachmentEntity entity = new ApplicationAttachmentEntity();
+        try {
+            entity.setName(fileResource.getFilename());
+            entity.setCreateTimestamp(System.currentTimeMillis());
+            entity.setCreateUserId(StpUtil.getLoginIdAsString());
+            entity.setApplicationId(applicationId);
+
+            // path
+            File destination = T.FileUtil.file(T.WebPathUtil.getRootPath(), app.getId(), fileResource.getFilename());
+            FileUtils.copyInputStreamToFile(fileResource.getInputStream(), destination);
+            entity.setPath(destination.getPath());
+
+            // 根据文件 applicationId path 判断是否已上存在，存在则响应当前实体
+            ApplicationAttachmentEntity attachment = this.getOne(new LambdaQueryWrapper<ApplicationAttachmentEntity>()
+                    .eq(ApplicationAttachmentEntity::getApplicationId, applicationId)
+                    .eq(ApplicationAttachmentEntity::getPath, destination.getPath()));
+            if (T.ObjectUtil.isNotNull(attachment)) {
+                return attachment;
+            }
+
+            // save
+            this.save(entity);
+
+        } catch (IOException e) {
+            log.error(e, "[saveAttachment] [error] [applicationId: {}]", applicationId);
+            throw new ASWException(RCode.ERROR);
+        }
+        return entity;
+    }
+
+    @Override
+    public void removedAttachment(String applicationId, String ids) {
+
+        List<String> idList = Arrays.asList(ids.split(","));
+
+        for (String id : idList) {
+            ApplicationAttachmentEntity attachment = this.getOne(new LambdaQueryWrapper<ApplicationAttachmentEntity>()
+                    .eq(ApplicationAttachmentEntity::getApplicationId, applicationId)
+                    .eq(ApplicationAttachmentEntity::getId, id));
+
+            T.FileUtil.del(FileUtil.file(attachment.getPath()));
+            this.removeById(id);
+        }
+    }
+
+    @Override
+    public void download(HttpServletResponse response, String applicationId, String attachmentId) throws IOException {
+        ApplicationAttachmentEntity attachment = this.getOne(new LambdaQueryWrapper<ApplicationAttachmentEntity>()
+                .eq(ApplicationAttachmentEntity::getApplicationId, applicationId)
+                .eq(ApplicationAttachmentEntity::getId, attachmentId));
+        if (T.ObjectUtil.isNull(attachment)) {
+            throw new ASWException(RCode.APP_ATTACHMENT_NOT_EXIST);
+        }
+        File file = FileUtil.file(attachment.getPath());
+        response.setStatus(200);
+        response.setContentType( MediaTypeFactory.getMediaType(file.getName()).toString());
+        response.setContentLength(Integer.parseInt(String.valueOf(file.length())));
+        response.setHeader("Content-disposition", "attachment; filename=" + file.getName());
+        response.getOutputStream().write(T.FileUtil.readBytes(file));
+        response.flushBuffer();
+    }
+}

src/main/java/net/geedge/asw/module/app/service/impl/ApplicationHrefServiceImpl.java

@@ -0,0 +1,59 @@
+package net.geedge.asw.module.app.service.impl;
+
+import cn.dev33.satoken.stp.StpUtil;
+import cn.hutool.log.Log;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import net.geedge.asw.common.util.ASWException;
+import net.geedge.asw.common.util.RCode;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.app.dao.ApplicationHrefDao;
+import net.geedge.asw.module.app.entity.ApplicationHrefEntity;
+import net.geedge.asw.module.app.service.IApplicationHrefService;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+@Service
+public class ApplicationHrefServiceImpl extends ServiceImpl<ApplicationHrefDao, ApplicationHrefEntity> implements IApplicationHrefService {
+
+    private static final Log log = Log.get();
+
+    @Override
+    public List<ApplicationHrefEntity> queryList(String applicationId) {
+        return this.getBaseMapper().queryList(applicationId);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public List<ApplicationHrefEntity> updateBatchHref(List<ApplicationHrefEntity> hrefList) {
+        for (ApplicationHrefEntity entity : hrefList) {
+
+            // validate
+            ApplicationHrefEntity one = this.getOne(new LambdaQueryWrapper<ApplicationHrefEntity>()
+                    .eq(ApplicationHrefEntity::getApplicationId, entity.getApplicationId())
+                    .eq(ApplicationHrefEntity::getName, entity.getName())
+                    .ne(T.ObjectUtil.isNotEmpty(entity.getId()), ApplicationHrefEntity::getId, entity.getId()));
+            if (T.ObjectUtil.isNotNull(one)) {
+                throw ASWException.builder().rcode(RCode.SYS_DUPLICATE_RECORD).build();
+            }
+
+            entity.setCreateTimestamp(System.currentTimeMillis());
+            entity.setCreateUserId(StpUtil.getLoginIdAsString());
+
+            // save or update
+            this.saveOrUpdate(entity);
+        }
+        return hrefList;
+    }
+
+    @Override
+    public List<ApplicationHrefEntity> updateBatchHref(String applicationId, List<ApplicationHrefEntity> hrefList) {
+        for (ApplicationHrefEntity entity : hrefList) {
+            entity.setApplicationId(applicationId);
+        }
+        return this.updateBatchHref(hrefList);
+    }
+
+}

src/main/java/net/geedge/asw/module/app/service/impl/ApplicationLogServiceImpl.java

@@ -0,0 +1,13 @@
+package net.geedge.asw.module.app.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import net.geedge.asw.module.app.dao.ApplicationLogDao;
+import net.geedge.asw.module.app.entity.ApplicationLogEntity;
+import net.geedge.asw.module.app.service.IApplicationLogService;
+import org.springframework.stereotype.Service;
+
+
+@Service
+public class ApplicationLogServiceImpl extends ServiceImpl<ApplicationLogDao, ApplicationLogEntity>  implements IApplicationLogService {
+
+}

src/main/java/net/geedge/asw/module/app/service/impl/ApplicationNoteServiceImpl.java

@@ -0,0 +1,36 @@
+package net.geedge.asw.module.app.service.impl;
+
+import cn.dev33.satoken.stp.StpUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.app.dao.ApplicationNoteDao;
+import net.geedge.asw.module.app.entity.ApplicationNoteEntity;
+import net.geedge.asw.module.app.service.IApplicationNoteService;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class ApplicationNoteServiceImpl extends ServiceImpl<ApplicationNoteDao, ApplicationNoteEntity> implements IApplicationNoteService {
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void saveNote(ApplicationNoteEntity note, String applicationId) {
+        // query last note
+        ApplicationNoteEntity noteLast = this.getOne(new LambdaQueryWrapper<ApplicationNoteEntity>()
+                .eq(ApplicationNoteEntity::getApplicationId, applicationId)
+                .orderByDesc(ApplicationNoteEntity::getOpVersion)
+                .last("limit 1"));
+
+        if (T.ObjectUtil.isNotEmpty(noteLast)){
+            note.setOpVersion(noteLast.getOpVersion() + 1);
+        }
+
+        //save note
+        note.setApplicationId(applicationId);
+        note.setCreateTimestamp(System.currentTimeMillis());
+        note.setCreateUserId(StpUtil.getLoginIdAsString());
+
+       this.save(note);
+    }
+}

src/main/java/net/geedge/asw/module/app/service/impl/ApplicationServiceImpl.java

@@ -0,0 +1,286 @@
+package net.geedge.asw.module.app.service.impl;
+
+import cn.dev33.satoken.stp.StpUtil;
+import cn.hutool.json.JSON;
+import cn.hutool.json.JSONConfig;
+import cn.hutool.json.JSONObject;
+import cn.hutool.log.Log;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import net.geedge.asw.common.util.ASWException;
+import net.geedge.asw.common.util.RCode;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.app.dao.ApplicationDao;
+import net.geedge.asw.module.app.entity.*;
+import net.geedge.asw.module.app.service.*;
+import net.geedge.asw.module.sys.entity.SysUserEntity;
+import net.geedge.asw.module.sys.service.ISysUserService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+@Service
+public class ApplicationServiceImpl extends ServiceImpl<ApplicationDao, ApplicationEntity> implements IApplicationService {
+
+    private static final Log log = Log.get();
+
+    @Autowired
+    private IApplicationLogService applicationLogService;
+
+
+    @Autowired
+    private ISysUserService userService;
+
+    @Autowired
+    private IApplicationSignatureService signatureService;
+
+    @Autowired
+    private IApplicationNoteService noteService;
+
+    @Autowired
+    private IApplicationHrefService hrefService;
+
+    @Autowired
+    private IApplicationAttachmentService attachmentService;
+
+    @Autowired
+    private ITSGApplicationService tsgApplicationService;
+
+    @Override
+    public ApplicationEntity detail(String id, String workspaceId) {
+        ApplicationEntity app = this.getOne(new LambdaQueryWrapper<ApplicationEntity>()
+                .eq(ApplicationEntity::getId, id)
+                .eq(ApplicationEntity::getWorkspaceId, workspaceId));
+
+        ApplicationSignatureEntity signature = signatureService.getOne(new LambdaQueryWrapper<ApplicationSignatureEntity>()
+                .eq(ApplicationSignatureEntity::getApplicationId, app.getId())
+                .orderByDesc(ApplicationSignatureEntity::getOpVersion)
+                .last("limit 1"));
+        app.setSignature(signature);
+
+        ApplicationNoteEntity note = noteService.getOne(new LambdaQueryWrapper<ApplicationNoteEntity>()
+                .eq(ApplicationNoteEntity::getApplicationId, app.getId())
+                .orderByDesc(ApplicationNoteEntity::getOpVersion)
+                .last("limit 1"));
+        app.setNote(note);
+
+        List<ApplicationAttachmentEntity> attachmentEntityList = attachmentService.list(new LambdaQueryWrapper<ApplicationAttachmentEntity>()
+                .eq(ApplicationAttachmentEntity::getApplicationId, app.getId()));
+        attachmentEntityList.stream().forEach(x -> x.setPath(null));
+        app.setAttatchments(attachmentEntityList);
+
+        List<ApplicationHrefEntity> hrefEntityList = hrefService.list(new LambdaQueryWrapper<ApplicationHrefEntity>()
+                .eq(ApplicationHrefEntity::getApplicationId, app.getId()));
+        app.setHrefs(hrefEntityList);
+
+        SysUserEntity createUser = userService.getById(app.getCreateUserId());
+        SysUserEntity updateUser = userService.getById(app.getUpdateUserId());
+        app.setCreateUser(createUser);
+        app.setUpdateUser(updateUser);
+
+        return app;
+    }
+
+    @Override
+    public Page queryList(Map<String, Object> params) {
+        Page page = T.PageUtil.getPage(params);
+        List<ApplicationEntity> packageList = this.getBaseMapper().queryList(page, params);
+        page.setRecords(packageList);
+        return page;
+    }
+
+    private void validateParam(ApplicationEntity entity, boolean isUpdate) {
+        ApplicationEntity one = this.getOne(new LambdaQueryWrapper<ApplicationEntity>()
+                .eq(ApplicationEntity::getWorkspaceId, entity.getWorkspaceId())
+                .eq(ApplicationEntity::getName, entity.getName()));
+
+        if (T.ObjectUtil.isNotNull(one) && !isUpdate || T.ObjectUtil.isNotNull(one) && isUpdate && !T.StrUtil.equals(entity.getId(), one.getId())) {
+            throw ASWException.builder().rcode(RCode.APP_DUPLICATE_RECORD).build();
+        }
+
+        // package name format
+        if (T.ObjectUtil.isNotEmpty(entity.getPackageName()) && !T.JSONUtil.isTypeJSON(entity.getPackageName())) {
+            throw ASWException.builder().rcode(RCode.APP_PACKAGE_NAME_FORMAT_ERROR).build();
+        } else if (T.ObjectUtil.isEmpty(entity.getPackageName())) {
+            entity.setPackageName("{}");
+        }
+
+        // tags name format
+        if (T.StrUtil.isNotEmpty(entity.getTags()) && !T.JSONUtil.isTypeJSON(entity.getTags())) {
+            throw ASWException.builder().rcode(RCode.APP_TAGS_FORMAT_ERROR).build();
+        }
+
+        // signature
+        if (T.ObjectUtil.isNotEmpty(entity.getSignature())) {
+            if (!T.StrUtil.isNotEmpty(entity.getSignature().getContent())){
+                throw ASWException.builder().rcode(RCode.APP_SIGNATURE_CONTENT_CANNOT_EMPTY).build();
+            }
+
+            if (!T.JSONUtil.isTypeJSON(entity.getSignature().getContent())){
+                throw ASWException.builder().rcode(RCode.APP_SIGNATURE_CONTENT_CANNOT_EMPTY).build();
+            }
+        }
+
+        // note
+       /* if (T.ObjectUtil.isNotEmpty(entity.getNote()) && !T.StrUtil.isNotEmpty(entity.getNote().getContent())) {
+            throw ASWException.builder().rcode(RCode.APP_NOTE_CONTENT_CANNOT_EMPTY).build();
+        }*/
+
+        // properties
+       if (T.ObjectUtil.isNotEmpty(entity.getProperties()) && !T.JSONUtil.isTypeJSON(entity.getProperties().toString())) {
+            throw ASWException.builder().rcode(RCode.APP_PROPERTIES_FORMAT_ERROR).build();
+        }
+
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public ApplicationEntity saveApplication(ApplicationEntity entity) {
+
+        this.validateParam(entity, false);
+
+        // save
+        entity.setCreateTimestamp(System.currentTimeMillis());
+        entity.setUpdateTimestamp(System.currentTimeMillis());
+        entity.setCreateUserId(StpUtil.getLoginIdAsString());
+        entity.setUpdateUserId(StpUtil.getLoginIdAsString());
+        this.save(entity);
+
+        if (T.ObjectUtil.isNotEmpty(entity.getSignature())){
+            // save signature
+            signatureService.saveSignature(entity.getSignature(), entity.getId());
+        }
+
+        if (T.ObjectUtil.isNotEmpty(entity.getNote())){
+            //save note
+            noteService.saveNote(entity.getNote(), entity.getId());
+        }
+
+
+        return entity;
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public ApplicationEntity updateApplication(ApplicationEntity entity) {
+
+        this.validateParam(entity, true);
+
+        ApplicationEntity one = this.getById(entity.getId());
+        entity.setUpdateTimestamp(System.currentTimeMillis());
+        entity.setUpdateUserId(StpUtil.getLoginIdAsString());
+        entity.setOpVersion(one.getOpVersion() + 1);
+
+        // update
+        this.updateById(entity);
+
+        // save log
+        this.saveApplicationToLog(one);
+
+        if (T.ObjectUtil.isNotEmpty(entity.getSignature())){
+            // save signature
+            signatureService.saveSignature(entity.getSignature(), entity.getId());
+        }
+
+        if (T.ObjectUtil.isNotEmpty(entity.getNote())){
+            //save note
+            noteService.saveNote(entity.getNote(), entity.getId());
+        }
+
+        return entity;
+    }
+
+    private void saveApplicationToLog(ApplicationEntity one) {
+        ApplicationLogEntity applicationLogEntity = T.BeanUtil.toBean(one, ApplicationLogEntity.class);
+        applicationLogEntity.setUpdateTimestamp(System.currentTimeMillis());
+        applicationLogEntity.setUpdateUserId(StpUtil.getLoginIdAsString());
+        applicationLogEntity.setCreateTimestamp(System.currentTimeMillis());
+        applicationLogEntity.setCreateUserId(StpUtil.getLoginIdAsString());
+        applicationLogService.save(applicationLogEntity);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void removeApplication(List<String> ids) {
+        // remove
+        this.removeBatchByIds(ids);
+        applicationLogService.removeBatchByIds(ids);
+        signatureService.remove(new LambdaQueryWrapper<ApplicationSignatureEntity>().in(ApplicationSignatureEntity::getApplicationId, ids));
+        noteService.remove(new LambdaQueryWrapper<ApplicationNoteEntity>().in(ApplicationNoteEntity::getApplicationId, ids));
+        attachmentService.remove(new LambdaQueryWrapper<ApplicationAttachmentEntity>().in(ApplicationAttachmentEntity::getApplicationId, ids));
+        hrefService.remove(new LambdaQueryWrapper<ApplicationHrefEntity>().in(ApplicationHrefEntity::getApplicationId, ids));
+    }
+
+    @Override
+    public ApplicationEntity updateBasic(ApplicationEntity entity) {
+
+        ApplicationEntity one = this.getById(entity.getId());
+        if (T.ObjectUtil.isNotNull(one) && !T.StrUtil.equals(entity.getId(), one.getId())) {
+            throw ASWException.builder().rcode(RCode.APP_DUPLICATE_RECORD).build();
+        }
+
+        // package name format
+        if (T.ObjectUtil.isNotEmpty(entity.getPackageName()) && !T.JSONUtil.isTypeJSON(entity.getPackageName())) {
+            throw ASWException.builder().rcode(RCode.APP_PACKAGE_NAME_FORMAT_ERROR).build();
+        } else if (T.ObjectUtil.isEmpty(entity.getPackageName())) {
+            entity.setPackageName("{}");
+        }
+
+        // properties
+        if (T.ObjectUtil.isNotEmpty(entity.getProperties()) && !T.JSONUtil.isTypeJSON(entity.getProperties().toString())) {
+            throw ASWException.builder().rcode(RCode.APP_PROPERTIES_FORMAT_ERROR).build();
+        }
+
+        entity.setUpdateTimestamp(System.currentTimeMillis());
+        entity.setUpdateUserId(StpUtil.getLoginIdAsString());
+        entity.setOpVersion(one.getOpVersion() + 1);
+
+        this.saveApplicationToLog(one);
+        this.updateById(entity);
+        return entity;
+    }
+
+    @Override
+    public byte[] exportAppByFormat(List<ApplicationEntity> appList, String format) {
+        try {
+            switch (format) {
+                case "tsg2402": {
+                    Map<Object, Object> m = tsgApplicationService.aswToTsg2402(appList);
+                    JSON json = new JSONObject(m, JSONConfig.create().setIgnoreNullValue(false).setKeyComparator(String::compareToIgnoreCase));
+                    return T.StrUtil.bytes(json.toJSONString(0));
+                }
+                default:
+                    break;
+            }
+            return new byte[]{};
+        } catch (Exception e) {
+            log.error(e, "[exportAppByFormat] [error] [format: {}] [application: {}]", format, T.JSONUtil.toJsonStr(appList));
+            throw new ASWException(RCode.ERROR);
+        }
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public List<ApplicationEntity> importAppByFormat(String workspaceId, String format, List<JSONObject> dataList) {
+        try {
+            switch (format) {
+                case "tsg2402": {
+                    List<ApplicationEntity> records = tsgApplicationService.tsg2402ToAsw(workspaceId, dataList);
+                    return records;
+                }
+                default:
+                    break;
+            }
+            return new ArrayList<>();
+        } catch (Exception e) {
+            log.error(e, "[importAppByFormat] [error] [workspaceId: {}] [format: {}]", workspaceId, format);
+            throw new ASWException(RCode.ERROR);
+        }
+    }
+
+}

src/main/java/net/geedge/asw/module/app/service/impl/ApplicationSignatureServiceImpl.java

@@ -0,0 +1,85 @@
+package net.geedge.asw.module.app.service.impl;
+
+import cn.dev33.satoken.stp.StpUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import net.geedge.asw.common.util.ASWException;
+import net.geedge.asw.common.util.RCode;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.app.dao.ApplicationSignatureDao;
+import net.geedge.asw.module.app.entity.ApplicationSignatureEntity;
+import net.geedge.asw.module.app.service.IApplicationSignatureService;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+@Service
+public class ApplicationSignatureServiceImpl extends ServiceImpl<ApplicationSignatureDao, ApplicationSignatureEntity> implements IApplicationSignatureService {
+
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void saveSignature(ApplicationSignatureEntity signature, String applicationId) {
+        // query last note
+        ApplicationSignatureEntity signatureLast = this.queryLastVersionSignatureByAppId(applicationId);
+
+        if (T.ObjectUtil.isNotEmpty(signatureLast)){
+            signature.setOpVersion(signatureLast.getOpVersion() + 1);
+        }
+
+        // save signature
+        signature.setApplicationId(applicationId);
+        signature.setCreateTimestamp(System.currentTimeMillis());
+        signature.setCreateUserId(StpUtil.getLoginIdAsString());
+
+        this.save(signature);
+    }
+
+    @Override
+    public List<ApplicationSignatureEntity> queryList(String applicationId) {
+        Map<Object, Object> params = T.MapUtil.builder().put("applicationId", applicationId).build();
+        List<ApplicationSignatureEntity> list = this.getBaseMapper().queryList(params);
+        return list;
+    }
+
+    @Override
+    public List<ApplicationSignatureEntity> compare(String applicationId, String oldVersion, String newVersion) {
+
+        List<String> versionList = Arrays.asList(oldVersion, newVersion);
+        Map<Object, Object> params = T.MapUtil.builder()
+                .put("applicationId", applicationId)
+                .put("versions", versionList)
+                .build();
+        List<ApplicationSignatureEntity> list = this.getBaseMapper().queryList(params);
+        return list;
+    }
+
+    @Override
+    public void restore(String applicationId, String version) {
+        ApplicationSignatureEntity signature = this.getOne(new LambdaQueryWrapper<ApplicationSignatureEntity>()
+                .eq(ApplicationSignatureEntity::getApplicationId, applicationId)
+                .eq(ApplicationSignatureEntity::getOpVersion, version));
+        ApplicationSignatureEntity lastSignature = this.queryLastVersionSignatureByAppId(applicationId);
+        if (T.ObjectUtil.isEmpty(signature)) {
+            throw ASWException.builder().rcode(RCode.APP_SIGNATURE_NOT_EXIST).build();
+        }
+
+        // restore
+        signature.setId(null);
+        signature.setOpVersion(lastSignature.getOpVersion() + 1);
+        this.save(signature);
+    }
+
+    @Override
+    public ApplicationSignatureEntity queryLastVersionSignatureByAppId(String applicationId) {
+        ApplicationSignatureEntity entity = this.getOne(new LambdaQueryWrapper<ApplicationSignatureEntity>()
+                .eq(ApplicationSignatureEntity::getApplicationId, applicationId)
+                .orderByDesc(ApplicationSignatureEntity::getOpVersion)
+                .last("limit 1"));
+        return entity;
+    }
+
+}

src/main/java/net/geedge/asw/module/app/service/impl/GitServiceImpl.java

@@ -0,0 +1,182 @@
+package net.geedge.asw.module.app.service.impl;
+
+import cn.hutool.log.Log;
+import net.geedge.asw.common.util.ASWException;
+import net.geedge.asw.common.util.RCode;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.app.service.IGitService;
+import net.geedge.asw.module.workspace.entity.WorkspaceEntity;
+import net.geedge.asw.module.workspace.service.IWorkspaceService;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.lib.Config;
+import org.eclipse.jgit.lib.PersonIdent;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.StoredConfig;
+import org.eclipse.jgit.revwalk.RevCommit;
+import org.eclipse.jgit.revwalk.RevWalk;
+import org.eclipse.jgit.storage.file.FileRepositoryBuilder;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Service
+public class GitServiceImpl implements IGitService {
+
+    private final static Log log = Log.get();
+
+    /**
+     * 本地分支引用前缀
+     */
+    public static final String LOCAL_BRANCH_PREFIX = "refs/heads/";
+
+    @Autowired
+    private IWorkspaceService workspaceService;
+
+    /**
+     * get repository path
+     * path= {webRootPath}/workspeace/{workspace.name}
+     */
+    private File getRepoDirPath(String workspaceId) {
+        WorkspaceEntity workspace = workspaceService.getById(workspaceId);
+        File repoDir = T.FileUtil.file(T.WebPathUtil.getRootPath(), "workspeace", workspace.getName());
+        return repoDir;
+    }
+
+    /**
+     * get git instance
+     */
+    private Git getGitInstance(File repoDir) {
+        try {
+            if (T.FileUtil.exist(repoDir) && T.FileUtil.file(repoDir, ".git").exists()) {
+                log.info("[getGitInstance] [open exist repository] [path: {}]", repoDir);
+
+                FileRepositoryBuilder builder = new FileRepositoryBuilder();
+                builder.setGitDir(T.FileUtil.file(repoDir, ".git"));
+                builder.readEnvironment();
+                builder.findGitDir();
+
+                return new Git(builder.build());
+            } else {
+                log.info("[getGitInstance] [init new repository] [path: {}]", repoDir);
+                // init
+                Git git = Git.init().setDirectory(repoDir).call();
+                // config
+                StoredConfig config = git.getRepository().getConfig();
+                config.setString("user", null, "name", "asw");
+                config.setString("user", null, "email", "asw@geedgenetworks.com");
+                config.save();
+                return git;
+            }
+        } catch (IOException | GitAPIException | IllegalStateException e) {
+            log.error(e, "[getGitInstance] [error] [path: {}]", repoDir);
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public List<Map<Object, Object>> listBranch(String workspaceId, String search) {
+        List<Map<Object, Object>> resultList = T.ListUtil.list(true);
+
+        File repoDir = this.getRepoDirPath(workspaceId);
+        try (Git git = this.getGitInstance(repoDir)) {
+//            List<Ref> call = git.branchList().setListMode(ListBranchCommand.ListMode.ALL).call();
+
+            // 默认行为，进查询本地分支
+            List<Ref> call = git.branchList().call();
+            RevWalk revCommits = new RevWalk(git.getRepository());
+
+            for (Ref ref : call) {
+                String branchName = ref.getName();
+                // 返回时去掉前缀
+                branchName = branchName.replaceAll(LOCAL_BRANCH_PREFIX, "");
+                if (T.StrUtil.isNotEmpty(search)) {
+                    if (!T.StrUtil.contains(branchName, search)) {
+                        continue;
+                    }
+                }
+
+                Map<Object, Object> m = T.MapUtil.builder()
+                        .put("name", branchName)
+                        .build();
+
+                RevCommit commit = revCommits.parseCommit(ref.getObjectId());
+                List<String> parentIds = Arrays.stream(commit.getParents()).map(RevCommit::getName).collect(Collectors.toList());
+
+                Map<Object, Object> m1 = new LinkedHashMap<>();
+                m1.put("id", commit.getName());
+                m1.put("shortId", T.StrUtil.subPre(commit.getName(), 8));
+                m1.put("createdAt", commit.getCommitTime());
+
+                m1.put("title", commit.getShortMessage());
+                m1.put("message", commit.getFullMessage());
+                m1.put("parentIds", parentIds);
+
+                PersonIdent authorIdent = commit.getAuthorIdent();
+                m1.put("authorName", authorIdent.getName());
+                m1.put("authorEmail", authorIdent.getEmailAddress());
+                m1.put("authoredDate", authorIdent.getWhen().getTime());
+
+                PersonIdent committerIdent = commit.getCommitterIdent();
+                m1.put("committerName", committerIdent.getName());
+                m1.put("committerEmail", committerIdent.getEmailAddress());
+                m1.put("committedDate", committerIdent.getWhen().getTime());
+
+                m.put("commit", m1);
+                resultList.add(m);
+            }
+        } catch (GitAPIException | IOException e) {
+            log.error(e, "[listBranch] [error] [workspaceId: {}]", workspaceId);
+            throw new ASWException(RCode.ERROR);
+        }
+        return resultList;
+    }
+
+    @Override
+    public Map<Object, Object> infoBranch(String workspaceId, String branchName) {
+        List<Map<Object, Object>> listBranch = this.listBranch(workspaceId, branchName);
+
+        // 分支不存在
+        if (T.CollUtil.isEmpty(listBranch)) {
+            throw new ASWException(RCode.SYS_RECORD_NOT_FOUND);
+        }
+        return T.CollUtil.getFirst(listBranch);
+    }
+
+    @Override
+    public Map<Object, Object> newBranch(String workspaceId, String branchName, String ref) {
+        File repoDir = this.getRepoDirPath(workspaceId);
+        try (Git git = this.getGitInstance(repoDir)) {
+            git.branchCreate()
+                    .setName(branchName)
+                    .setStartPoint(ref)
+                    .call();
+
+            return this.infoBranch(workspaceId, branchName);
+        } catch (GitAPIException e) {
+            log.error(e, "[newBranch] [error] [workspaceId: {}] [branchName: {}] [ref: {}]", workspaceId, branchName, ref);
+            throw new ASWException(RCode.ERROR);
+        }
+    }
+
+    @Override
+    public void deleteBranch(String workspaceId, String branchName) {
+        File repoDir = this.getRepoDirPath(workspaceId);
+        try (Git git = this.getGitInstance(repoDir)) {
+            git.branchDelete()
+                    .setBranchNames(branchName)
+                    .call();
+        } catch (GitAPIException e) {
+            log.error(e, "[deleteBranch] [error] [workspaceId: {}] [branchName: {}]", workspaceId, branchName);
+            throw new ASWException(RCode.ERROR);
+        }
+    }
+
+}

src/main/java/net/geedge/asw/module/app/service/impl/PackageServiceImpl.java

@@ -0,0 +1,139 @@
+package net.geedge.asw.module.app.service.impl;
+
+import cn.dev33.satoken.stp.StpUtil;
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.log.Log;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import net.geedge.asw.common.util.ASWException;
+import net.geedge.asw.common.util.Constants;
+import net.geedge.asw.common.util.RCode;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.app.dao.PackageDao;
+import net.geedge.asw.module.app.entity.PackageEntity;
+import net.geedge.asw.module.app.service.IPackageService;
+import net.geedge.asw.module.app.util.ApkInfo;
+import net.geedge.asw.module.app.util.ApkUtil;
+import net.geedge.asw.module.app.util.PkgConstant;
+import net.geedge.asw.module.sys.entity.SysUserEntity;
+import net.geedge.asw.module.sys.service.ISysUserService;
+import net.geedge.asw.module.workbook.service.IWorkbookResourceService;
+import net.geedge.asw.module.workbook.util.WorkbookConstant;
+import org.apache.commons.io.FileUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.io.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Map;
+
+@Service
+public class PackageServiceImpl extends ServiceImpl<PackageDao, PackageEntity> implements IPackageService {
+
+    private final static Log log = Log.get();
+
+    @Autowired
+    private ISysUserService sysUserService;
+
+    @Autowired
+    private IWorkbookResourceService workbookResourceService;
+
+    @Override
+    public PackageEntity queryInfo(String id) {
+        PackageEntity entity = this.getById(id);
+        T.VerifyUtil.is(entity).notNull(RCode.SYS_RECORD_NOT_FOUND);
+
+        // user
+        SysUserEntity createUser = sysUserService.getById(entity.getCreateUserId());
+        SysUserEntity updateUser = sysUserService.getById(entity.getUpdateUserId());
+
+        createUser.setPwd(null);
+        updateUser.setPwd(null);
+
+        entity.setCreateUser(createUser);
+        entity.setUpdateUser(updateUser);
+        return entity;
+    }
+
+    @Override
+    public Page queryList(Map<String, Object> params) {
+        Page page = T.PageUtil.getPage(params);
+        List<PackageEntity> packageList = this.getBaseMapper().queryList(page, params);
+        page.setRecords(packageList);
+        return page;
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public PackageEntity savePackage(String workspaceId, String description, Resource fileResource) {
+
+        String pkgId = T.StrUtil.uuid();
+        String filename = fileResource.getFilename();
+        String suffix = T.FileUtil.extName(filename);
+        suffix = T.StrUtil.emptyToDefault(suffix, "apk");
+        if (!Constants.ANDROID_PACKAGE_TYPE_LIST.contains(suffix)) {
+            throw new ASWException(RCode.PACKAGE_FILE_TYPE_ERROR);
+        }
+        String saveFileName = pkgId + "." + suffix;
+        File destination = T.FileUtil.file(PkgConstant.APK_FILES_DIR, saveFileName);
+        PackageEntity entity = new PackageEntity();
+        ApkUtil apkUtil = new ApkUtil();
+        apkUtil.setAaptToolPath(Path.of(T.WebPathUtil.getRootPath(), "lib", "aapt").toString());
+        try {
+            FileUtils.copyInputStreamToFile(fileResource.getInputStream(), destination);
+            if (suffix.equals("apk")) {
+                // parse
+                ApkInfo apkInfo = apkUtil.parseApk(destination.getPath());
+                if (T.ObjectUtil.isNull(apkInfo)) {
+                    throw new ASWException(RCode.PACKAGE_FILE_TYPE_ERROR);
+                }
+                entity.setVersion(apkInfo.getVersionName());
+                entity.setIdentifier(apkInfo.getPackageName());
+            } else {
+                ApkInfo apkInfo = apkUtil.parseXapk(destination.getPath());
+                if (T.ObjectUtil.isNull(apkInfo)) {
+                    throw new ASWException(RCode.PACKAGE_FILE_TYPE_ERROR);
+                }
+                entity.setVersion(apkInfo.getSdkVersion());
+                entity.setIdentifier(apkInfo.getPackageName());
+            }
+        } catch (Exception e) {
+            log.error(e, "[savePackage] [save package error] [file: {}]", fileResource.getFilename());
+            FileUtil.del(destination);
+            throw new ASWException(RCode.PACKAGE_FILE_TYPE_ERROR);
+        }
+        entity.setId(pkgId);
+        entity.setName(fileResource.getFilename());
+        entity.setDescription(T.StrUtil.emptyToDefault(description, ""));
+        entity.setPlatform(PkgConstant.Platform.ANDROID.getValue());
+        entity.setWorkspaceId(workspaceId);
+        entity.setCreateUserId(StpUtil.getLoginIdAsString());
+        entity.setUpdateUserId(StpUtil.getLoginIdAsString());
+        entity.setCreateTimestamp(System.currentTimeMillis());
+        entity.setUpdateTimestamp(System.currentTimeMillis());
+        entity.setSize(destination.length());
+        entity.setPath(destination.getPath());
+        this.save(entity);
+        return entity;
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void removePackage(List<String> ids) {
+        for (String id : ids) {
+            PackageEntity entity = this.getById(id);
+            // remove file
+            T.FileUtil.del(entity.getPath());
+
+            // remove
+            this.removeById(id);
+        }
+
+        // workbook resource
+        workbookResourceService.removeResource(ids, WorkbookConstant.ResourceType.PACKAGE.getValue());
+    }
+
+}

src/main/java/net/geedge/asw/module/app/service/impl/TSGApplicationServiceImpl.java

@@ -0,0 +1,823 @@
+package net.geedge.asw.module.app.service.impl;
+
+import cn.dev33.satoken.stp.StpUtil;
+import cn.hutool.core.lang.Validator;
+import cn.hutool.json.JSONArray;
+import cn.hutool.json.JSONObject;
+import cn.hutool.log.Log;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.app.entity.ApplicationEntity;
+import net.geedge.asw.module.app.entity.ApplicationSignatureEntity;
+import net.geedge.asw.module.app.service.IApplicationService;
+import net.geedge.asw.module.app.service.IApplicationSignatureService;
+import net.geedge.asw.module.app.service.ITSGApplicationService;
+import net.geedge.asw.module.attribute.entity.AttributeEntity;
+import net.geedge.asw.module.attribute.service.IAttributeService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Service
+public class TSGApplicationServiceImpl implements ITSGApplicationService {
+
+    private static final Log log = Log.get();
+
+    @Autowired
+    private IAttributeService attributeService;
+
+    @Autowired
+    private IApplicationService applicationService;
+
+    @Autowired
+    private IApplicationSignatureService applicationSignatureService;
+
+    @Override
+    public Map<Object, Object> aswToTsg2402(List<ApplicationEntity> appList) {
+
+        List<Object> applications = this.buildTSG2402Applications(appList);
+
+        Map<Object, Object> signatures = this.buildTSG2402Signatures(appList);
+
+        Map<Object, Object> m = T.MapUtil.builder()
+                .put("applications", applications)
+                .putAll(signatures)
+                .build();
+        return m;
+    }
+
+    private List<Object> buildTSG2402Applications(List<ApplicationEntity> appList) {
+        List<Object> applications = T.ListUtil.list(true);
+        for (ApplicationEntity app : appList) {
+            // application
+            Map<Object, Object> application = T.MapUtil.builder()
+                    .put("app_name", app.getName())
+                    .put("app_longname", app.getName())
+                    .put("description", app.getDescription())
+                    .build();
+
+            // app_properties
+            Map properties = (Map) app.getProperties();
+            Map<Object, Object> app_properties = T.MapUtil.builder()
+                    .put("parent_app_id", 0)
+                    .put("parent_app_name", "null")
+                    .put("category", T.MapUtil.getStr(properties, "category", ""))
+                    .put("subcategory", T.MapUtil.getStr(properties, "subcategory", ""))
+                    .put("content", T.MapUtil.getStr(properties, "content", ""))
+                    .put("risk", T.MapUtil.getStr(properties, "risk", "1"))
+                    .put("characteristics", T.MapUtil.getStr(properties, "characteristics", ""))
+                    .put("deny_action", T.MapUtil.builder()
+                            .put("method", "drop")
+                            .put("after_n_packets", 0)
+                            .put("send_icmp_unreachable", 0)
+                            .put("send_tcp_reset", 0)
+                            .build()
+                    )
+                    .put("continue_scanning", 0)
+                    .put("tcp_timeout", 0)
+                    .put("udp_timeout", 0)
+                    .put("tcp_half_close", 0)
+                    .put("tcp_time_wait", 0)
+                    .build();
+            application.put("app_properties", app_properties);
+
+            // app_surrogates
+            ApplicationSignatureEntity signature = applicationSignatureService.queryLastVersionSignatureByAppId(app.getId());
+            JSONObject jsonObject = T.JSONUtil.parseObj(signature.getContent());
+            JSONArray surrogates = jsonObject.getJSONArray("surrogates");
+            if (!surrogates.isEmpty()) {
+                List<Map> app_surrogates = T.ListUtil.list(true);
+                surrogates.forEach(obj -> {
+                    List<Object> signature_sequence = T.ListUtil.list(true);
+
+                    JSONArray signatureArr = ((JSONObject) obj).getJSONArray("signatures");
+                    signatureArr.stream().map(o -> ((JSONObject) o).getStr("name")).forEach(tname -> {
+                        signature_sequence.add(T.MapUtil.builder()
+                                .put("signature", tname)
+                                .put("exclude", 0)
+                                .build()
+                        );
+                    });
+
+                    app_surrogates.add(
+                            T.MapUtil.builder()
+                                    .put("group_by", "session")
+                                    .put("time_window", 0)
+                                    .put("ordered_match", "no")
+                                    .put("signature_sequence", signature_sequence)
+                                    .build()
+                    );
+                });
+                application.put("app_surrogates", app_surrogates);
+            }
+            applications.add(application);
+        }
+        return applications;
+    }
+
+    private Map<Object, Object> buildTSG2402Signatures(List<ApplicationEntity> appList) {
+        List<Object> signatures = T.ListUtil.list(true);
+        List<Object> sig_objects = T.ListUtil.list(true);
+
+        int sig_object_id = 10, signature_id = 0;
+        for (ApplicationEntity app : appList) {
+            ApplicationSignatureEntity signature = applicationSignatureService.queryLastVersionSignatureByAppId(app.getId());
+            JSONObject jsonObject = T.JSONUtil.parseObj(signature.getContent());
+            JSONArray surrogates = jsonObject.getJSONArray("surrogates");
+            List<Object> signaturesForApp = surrogates.stream()
+                    .map(obj -> ((JSONObject) obj).getJSONArray("signatures"))
+                    .flatMap(Collection::stream)
+                    .collect(Collectors.toList());
+            for (Object object : signaturesForApp) {
+                JSONObject surrogate = (JSONObject) object;
+
+                Map<Object, Object> m = T.MapUtil.builder()
+                        .put("signature_id", signature_id++)
+                        .put("signature_name", T.MapUtil.getStr(surrogate, "name"))
+                        .put("signature_desc", T.MapUtil.getStr(surrogate, "description", ""))
+                        .put("icon_color", "")
+                        .build();
+
+                List<Object> and_conditions = T.ListUtil.list(true);
+                JSONArray conditions = surrogate.getJSONArray("conditions");
+                for (Object condition : conditions) {
+                    JSONObject conditionJSONObj = (JSONObject) condition;
+
+                    String attributeType = T.MapUtil.getStr(conditionJSONObj, "attributeType");
+                    String attributeName = T.MapUtil.getStr(conditionJSONObj, "attributeName");
+                    AttributeEntity attributeEntity = attributeService.queryAttribute(attributeType, attributeName);
+                    if (null == attributeEntity || T.StrUtil.isEmpty(attributeEntity.getObjectType())) continue;
+
+                    Map<Object, Object> or_condition_obj = T.MapUtil.builder()
+                            .put("lua_profile_id", 0)
+                            .put("attribute_type", attributeType)
+                            .put("attribute_name", attributeName)
+                            .put("protocol", attributeEntity.getProtocol())
+                            .build();
+
+                    List<Integer> source_object_ids = T.ListUtil.list(true);
+
+                    // sig_objects
+                    JSONArray items = conditionJSONObj.getJSONArray("items");
+
+                    String conditionType = attributeEntity.getObjectType();
+                    if ("application".equalsIgnoreCase(conditionType)) {
+                        continue;
+                    } else if ("boolean".equals(conditionType)) {
+                        items.stream()
+                                .map(obj -> (JSONObject) obj)
+                                .forEach(item -> {
+                                    String itemValue = T.MapUtil.getStr((JSONObject) item, "item");
+                                    if ("True".equalsIgnoreCase(itemValue)) {
+                                        source_object_ids.add(2);
+                                    } else if ("False".equalsIgnoreCase(itemValue)) {
+                                        source_object_ids.add(3);
+                                    }
+                                });
+                    } else if ("ip_protocol".equals(conditionType)) {
+                        items.stream()
+                                .map(obj -> (JSONObject) obj)
+                                .forEach(item -> {
+                                    String itemValue = T.MapUtil.getStr((JSONObject) item, "item");
+                                    if ("ICMP".equalsIgnoreCase(itemValue)) {
+                                        source_object_ids.add(5);
+                                    } else if ("TCP".equalsIgnoreCase(itemValue)) {
+                                        source_object_ids.add(6);
+                                    } else if ("UDP".equalsIgnoreCase(itemValue)) {
+                                        source_object_ids.add(7);
+                                    }
+                                });
+                    } else {
+                        String name = T.MapUtil.getStr((JSONObject) items.getFirst(), "item");
+                        Map<Object, Object> sig_object = T.MapUtil.builder()
+                                .put("id", sig_object_id)
+                                .put("source_id", sig_object_id)
+                                .put("name", name)
+                                .put("source_name", name)
+                                .put("type", conditionType)
+                                .put("sub_type", attributeEntity.getType())
+                                .put("member_type", "item")
+                                .put("uuid", T.IdUtil.fastSimpleUUID())
+                                .put("statistics_option", "none")
+                                .build();
+
+                        Map<Object, Object> member = this.buildTSG2402SignaturesMember(attributeEntity, items);
+                        sig_object.put("member", member);
+
+                        sig_objects.add(sig_object);
+                        source_object_ids.add(sig_object_id);
+                        sig_object_id++;
+                    }
+
+                    or_condition_obj.put("source_object_ids", source_object_ids);
+                    Map<Object, Object> and_condition_item = T.MapUtil.builder()
+                            .put("not_flag", T.MapUtil.getBool(conditionJSONObj, "negate_option", false) ? 1 : 0)
+                            .put("or_conditions", T.ListUtil.of(or_condition_obj))
+                            .build();
+                    and_conditions.add(and_condition_item);
+                }
+
+                if (T.CollUtil.isNotEmpty(and_conditions)) {
+                    m.put("and_conditions", and_conditions);
+                    signatures.add(m);
+                }
+            }
+        }
+        sig_objects.add(T.JSONUtil.parseObj("""
+                 {
+                    "id": 2,
+                    "type": "boolean",
+                    "name": "True",
+                    "vsys_id": 0,
+                    "description": "True",
+                    "source_id": 2,
+                    "source_name": "True",
+                    "member_type": "item",
+                    "uuid": "c4ca4238a0b923820dcc509a6f75849b",
+                    "statistics_option": "elaborate"
+                }
+                 """));
+        sig_objects.add(T.JSONUtil.parseObj("""
+                 {
+                    "id": 3,
+                    "type": "boolean",
+                    "name": "False",
+                    "vsys_id": 0,
+                    "description": "False",
+                    "source_id": 3,
+                    "source_name": "False",
+                    "member_type": "item",
+                    "uuid": "cfcd208495d565ef66e7dff9f98764da",
+                    "statistics_option": "elaborate"
+                }
+                 """));
+        sig_objects.add(T.JSONUtil.parseObj("""
+                 {
+                    "id": 5,
+                    "type": "ip_protocol",
+                    "name": "ICMP",
+                    "vsys_id": 0,
+                    "description": "ICMP",
+                    "source_id": 5,
+                    "source_name": "ICMP",
+                    "member_type": "item",
+                    "uuid": "c4ca4238a0b923820dcc509a6f75849b",
+                    "statistics_option": "elaborate"
+                }
+                 """));
+        sig_objects.add(T.JSONUtil.parseObj("""
+                {
+                     "id": 6,
+                     "type": "ip_protocol",
+                     "name": "TCP",
+                     "vsys_id": 0,
+                     "description": "TCP",
+                     "source_id": 6,
+                     "source_name": "TCP",
+                     "member_type": "item",
+                     "uuid": "1679091c5a880faf6fb5e6087eb1b2dc",
+                     "statistics_option": "elaborate"
+                 }
+                 """));
+        sig_objects.add(T.JSONUtil.parseObj("""
+                {
+                    "id": 7,
+                    "type": "ip_protocol",
+                    "name": "UDP",
+                    "vsys_id": 0,
+                    "description": "UDP",
+                    "source_id": 7,
+                    "source_name": "UDP",
+                    "member_type": "item",
+                    "uuid": "70efdf2ec9b086079795c442636b55fb",
+                    "statistics_option": "elaborate"
+                }
+                 """));
+        Map<Object, Object> m = T.MapUtil.builder()
+                .put("signatures", signatures)
+                .put("sig_objects", sig_objects)
+                .build();
+        return m;
+    }
+
+    private Map<Object, Object> buildTSG2402SignaturesMember(AttributeEntity attributeEntity, JSONArray itemArr) {
+        List<Object> list = T.ListUtil.list(true);
+        itemArr.stream()
+                .map(obj -> (JSONObject) obj)
+                .forEach(item -> {
+                    String objectType = attributeEntity.getObjectType().toLowerCase();
+                    switch (objectType) {
+                        case "keywords":
+                        case "http_signature": {
+                            String str = item.getStr("item");
+                            List<String> patternExprList = T.ListUtil.list(true);
+                            patternExprList.add(str);
+
+                            // 0 -> 无表达式，1 -> 与表达式，2 -> 正则表达式，3、带偏移量的子串匹配
+                            int expr_type = 0;
+                            String exprType = item.getStr("exprType", "and");
+                            if ("and".equalsIgnoreCase(exprType)) {
+                                patternExprList = T.StrUtil.split(str, "&");
+                                if (patternExprList.size() > 1) {
+                                    expr_type = 1;
+                                }
+                            } else if ("regex".equalsIgnoreCase(exprType)) {
+                                expr_type = 2;
+                            }
+
+                            JSONArray patternArr = new JSONArray();
+                            for (String expr : patternExprList) {
+                                JSONObject pattern = new JSONObject();
+                                pattern.put("keywords", expr);
+
+                                Map<String, String> rangeVarMap = this.getRangeVarFromExpr(expr);
+                                if (T.MapUtil.isNotEmpty(rangeVarMap)) {
+                                    expr_type = 3;
+                                    pattern.put("keywords", expr.replaceAll("^\\(.*?\\)", ""));
+                                    pattern.put("offset", T.MapUtil.getInt(rangeVarMap, "offset"));
+                                    pattern.put("depth", T.MapUtil.getInt(rangeVarMap, "depth"));
+                                }
+                                patternArr.add(pattern);
+                            }
+
+                            if ("keywords".equals(objectType)) {
+                                Map<Object, Object> m = T.MapUtil.builder()
+                                        .put("string", T.MapUtil.builder()
+                                                .put("item_type", "keywords")
+                                                .put("expr_type", expr_type)
+                                                .put("is_hexbin", 0)
+                                                .put("patterns", patternArr)
+                                                .build()
+                                        ).build();
+                                list.add(m);
+                            }
+                            if ("http_signature".equals(objectType)) {
+                                Map<Object, Object> m = T.MapUtil.builder()
+                                        .put("contextual_string", T.MapUtil.builder()
+                                                .put("expr_type", expr_type)
+                                                .put("is_hexbin", 0)
+                                                .put("context_name", item.getStr("district", "Set-Cookie"))
+                                                .put("patterns", patternArr)
+                                                .build()
+                                        )
+                                        .build();
+                                list.add(m);
+                            }
+                            break;
+                        }
+                        case "url":
+                        case "fqdn": {
+                            Map<Object, Object> m = T.MapUtil.builder()
+                                    .put("string", T.MapUtil.builder()
+                                            .put("item_type", objectType)
+                                            .put("expr_type", 0)
+                                            .put("is_hexbin", 0)
+                                            .put("patterns", T.ListUtil.of(
+                                                    new JSONObject().put("keywords", item.getStr("item"))
+                                            ))
+                                            .build()
+                                    )
+                                    .build();
+                            list.add(m);
+                            break;
+                        }
+                        case "ip": {
+                            String str = item.getStr("item");
+                            String ip = str;
+                            String port = "0-65535";
+                            if (str.contains("#")) {
+                                ip = str.split("#")[0];
+                                port = str.split("#")[1];
+                            }
+                            Map<Object, Object> m = T.MapUtil.builder()
+                                    .put("ip", T.MapUtil.builder()
+                                            .put("addr_type", Validator.isIpv4(str) ? 4 : 6)
+                                            .put("port", port)
+                                            .put("ip_address", ip)
+                                            .build()
+                                    )
+                                    .build();
+                            list.add(m);
+                            break;
+                        }
+                        case "port": {
+                            String port = item.getStr("item");
+                            Map<Object, Object> m = T.MapUtil.builder()
+                                    .put("port", new JSONObject().put("port", port))
+                                    .build();
+                            if (port.contains("-")) {
+                                m.put("port", new JSONObject().put("port_range", port));
+                            }
+                            list.add(m);
+                            break;
+                        }
+                        case "interval": {
+                            String str = item.getStr("item");
+                            String low_boundary = str, up_boundary = str;
+                            if (str.contains("-")) {
+                                low_boundary = item.getStr("item").split("-")[0];
+                                up_boundary = item.getStr("item").split("-")[1];
+                            }
+                            Map<Object, Object> m = T.MapUtil.builder()
+                                    .put("interval", T.MapUtil.builder()
+                                            .put("low_boundary", low_boundary)
+                                            .put("up_boundary", up_boundary)
+                                            .build()
+                                    )
+                                    .build();
+                            list.add(m);
+                            break;
+                        }
+                        case "boolean":
+                        case "ip_protocol":
+                        case "application": {
+                            break;
+                        }
+                        default:
+                            break;
+                    }
+                });
+
+        Map<Object, Object> member = T.MapUtil.builder()
+                .put("items", list)
+                .build();
+        return member;
+    }
+
+    /**
+     * 获取表达式中的 range 变量，示例 (nocase=off,offset=6,depth=13)expr_xxxxxxxxx
+     */
+    private Map<String, String> getRangeVarFromExpr(String expr) {
+        try {
+            String regex = "^\\(([^)]+)\\)";
+            String str = T.ReUtil.get(regex, expr, 1);
+            if (T.StrUtil.isNotEmpty(str)) {
+                String[] pairs = str.split(",");
+
+                Map<String, String> map = new HashMap<>();
+                for (String pair : pairs) {
+                    String[] keyValue = pair.split("=");
+                    if (keyValue.length == 2) {
+                        map.put(keyValue[0].trim(), keyValue[1].trim());
+                    }
+                }
+                // 不包含 offset，depth 算没有配置
+                if (!map.containsKey("offset") || !map.containsKey("depth")) {
+                    return new HashMap<>();
+                }
+                return map;
+            }
+        } catch (Exception e) {
+            log.error(e, "[getRangeVarFromExpr] [expr: {}]", expr);
+        }
+        return new HashMap<>();
+    }
+
+// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public List<ApplicationEntity> tsg2402ToAsw(String workspaceId, List<JSONObject> dataList) {
+        List<ApplicationEntity> records = T.ListUtil.list(true);
+        for (JSONObject tsgAppSourceData : dataList) {
+
+            JSONArray all_application = tsgAppSourceData.getJSONArray("applications");
+            JSONArray all_signature = tsgAppSourceData.getJSONArray("signatures");
+            JSONArray all_sig_object = tsgAppSourceData.getJSONArray("sig_objects");
+
+            all_application.stream()
+                    .map(obj -> (JSONObject) obj)
+                    .forEach(application -> {
+                        // application
+                        String app_name = application.getStr("app_name");
+                        String description = application.getStr("description");
+
+                        JSONObject appProperties = application.getJSONObject("app_properties");
+                        String category = T.MapUtil.getStr(appProperties, "category", "");
+                        String subcategory = T.MapUtil.getStr(appProperties, "subcategory", "");
+                        String content = T.MapUtil.getStr(appProperties, "content", "");
+                        int risk = T.MapUtil.getInt(appProperties, "risk", 1);
+                        String characteristics = T.MapUtil.getStr(appProperties, "characteristics", "");
+
+                        Map<Object, Object> properties = T.MapUtil.builder()
+                                .put("category", category)
+                                .put("subcategory", subcategory)
+                                .put("content", content)
+                                .put("risk", risk)
+                                .put("characteristics", characteristics)
+                                .build();
+
+                        // save or update application
+                        ApplicationEntity entity = new ApplicationEntity();
+                        entity.setName(app_name);
+                        entity.setDescription(description);
+                        entity.setProperties(properties);
+                        entity.setPackageName("{}");
+                        entity.setWorkspaceId(workspaceId);
+                        entity.setCreateTimestamp(System.currentTimeMillis());
+                        entity.setUpdateTimestamp(System.currentTimeMillis());
+                        entity.setCreateUserId(StpUtil.getLoginIdAsString());
+                        entity.setUpdateUserId(StpUtil.getLoginIdAsString());
+
+                        ApplicationEntity one = applicationService.getOne(new LambdaQueryWrapper<ApplicationEntity>()
+                                .eq(ApplicationEntity::getWorkspaceId, workspaceId)
+                                .eq(ApplicationEntity::getName, app_name));
+                        if (null != one) {
+                            entity.setId(one.getId());
+                        }
+                        applicationService.saveOrUpdate(entity);
+
+                        records.add(entity);
+                        String applicationId = entity.getId();
+
+                        // surrogate - signature
+                        Map<String, List<String>> surrAndSignListMap = T.MapUtil.newHashMap();
+                        JSONArray app_surrogates = application.getJSONArray("app_surrogates");
+                        if (T.ObjectUtil.isNotEmpty(app_surrogates)) {
+                            for (int i = 0; i < app_surrogates.size(); i++) {
+                                JSONObject surrogate = (JSONObject) app_surrogates.get(i);
+                                List<String> signatureNameList = (List<String>) T.JSONUtil.getByPath(surrogate, "signature_sequence.signature");
+                                surrAndSignListMap.put("surrogate_" + (i + 1), signatureNameList);
+                            }
+                        }
+
+
+                        List<Object> insertSurrogateList = T.ListUtil.list(true);
+                        for (Map.Entry<String, List<String>> entry : surrAndSignListMap.entrySet()) {
+                            String surrogateName = entry.getKey();
+
+                            List<String> signatureNameList = entry.getValue();
+                            List<JSONObject> signatureListInApp = all_signature.stream()
+                                    .filter(obj -> {
+                                        String str = T.MapUtil.getStr((JSONObject) obj, "signature_name", "");
+                                        return signatureNameList.contains(str);
+                                    })
+                                    .map(obj -> (JSONObject) obj)
+                                    .collect(Collectors.toList());
+                            if (T.CollUtil.isEmpty(signatureListInApp)) continue;
+
+                            List<JSONObject> sigObjectList = all_sig_object.stream()
+                                    .map(obj -> (JSONObject) obj)
+                                    .collect(Collectors.toList());
+                            Map<Object, Object> aswSrrogate = this.buildAswSurrogateFromTSG2402(surrogateName, signatureListInApp, sigObjectList);
+                            insertSurrogateList.add(aswSrrogate);
+                        }
+
+                        Map<Object, Object> sm = T.MapUtil.builder()
+                                .put("surrogates", insertSurrogateList)
+                                .build();
+
+                        // save application signatrue
+                        ApplicationSignatureEntity signatureEntity = new ApplicationSignatureEntity();
+                        signatureEntity.setApplicationId(applicationId);
+                        signatureEntity.setContent(T.JSONUtil.toJsonStr(sm));
+                        signatureEntity.setCreateTimestamp(System.currentTimeMillis());
+                        signatureEntity.setCreateUserId(StpUtil.getLoginIdAsString());
+                        signatureEntity.setOpVersion(0L);
+
+                        ApplicationSignatureEntity signatureLast = applicationSignatureService.queryLastVersionSignatureByAppId(applicationId);
+                        if (T.ObjectUtil.isNotEmpty(signatureLast)) {
+                            signatureEntity.setOpVersion(signatureLast.getOpVersion() + 1);
+                        }
+                        applicationSignatureService.save(signatureEntity);
+                    });
+        }
+        return records;
+    }
+
+    private Map<Object, Object> buildAswSurrogateFromTSG2402(String surrogateName, List<JSONObject> signatureList, List<JSONObject> sigObjectList) {
+        // surrogate
+        Map<Object, Object> surrogate = T.MapUtil.builder()
+                .put("name", surrogateName)
+                .put("description", "")
+                .build();
+
+        // signatures
+        List<Object> signatures = T.ListUtil.list(true);
+        for (JSONObject jsonObject : signatureList) {
+            String signature_name = jsonObject.getStr("signature_name");
+            String signature_description = jsonObject.getStr("signature_desc");
+
+            Map<Object, Object> signMap = T.MapUtil.builder()
+                    .put("name", signature_name)
+                    .put("description", signature_description)
+                    .build();
+
+            // conditions
+            List<Map<Object, Object>> conditionMapList = T.ListUtil.list(true);
+
+            JSONArray and_conditions = jsonObject.getJSONArray("and_conditions");
+            for (Object obj : and_conditions) {
+                JSONObject conditions = (JSONObject) obj;
+                // base field
+                Integer not_flag = conditions.getInt("not_flag", 0);
+
+                JSONObject or_condition = (JSONObject) T.JSONUtil.getByPath(conditions, "or_conditions[0]");
+                String attribute_name = or_condition.getStr("attribute_name", "");
+                String attribute_type = or_condition.getStr("attribute_type", "");
+
+                Map<Object, Object> m = T.MapUtil.builder()
+                        .put("attributeName", attribute_name)
+                        .put("attributeType", attribute_type)
+                        .put("negate_option", not_flag == 1 ? true : false)
+                        .put("description", "")
+                        .build();
+
+                // items
+                List<Integer> source_object_ids = (List<Integer>) T.JSONUtil.getByPath(or_condition, "source_object_ids");
+                if (T.CollUtil.isEmpty(source_object_ids)) continue;
+
+                List<JSONObject> sourceObjectList = sigObjectList.stream()
+                        .filter(entries -> {
+                            Integer anInt = entries.getInt("id");
+                            return source_object_ids.contains(anInt);
+                        })
+                        .collect(Collectors.toList());
+
+                List<Map<Object, Object>> itemList = this.buildAswConditionItemsFromTSG2402(sourceObjectList);
+                if (T.CollUtil.isEmpty(itemList)) continue;
+
+                // 按 item value 去重
+                List<Map<String, String>> distinctItemList = itemList.stream()
+                        .collect(Collectors.collectingAndThen(
+                                Collectors.toMap(
+                                        map -> map.get("item"),
+                                        map -> map,
+                                        (existing, replacement) -> existing // 保留第一个出现的元素
+                                ),
+                                map -> new ArrayList(map.values())
+                        ));
+                m.put("items", distinctItemList);
+                conditionMapList.add(m);
+            }
+
+            signMap.put("conditions", conditionMapList);
+            signatures.add(signMap);
+        }
+
+        surrogate.put("signatures", signatures);
+        return surrogate;
+    }
+
+    private List<Map<Object, Object>> buildAswConditionItemsFromTSG2402(List<JSONObject> sourceObjectList) {
+        List<Map<Object, Object>> iiemList = T.ListUtil.list(true);
+        for (JSONObject jsonObject : sourceObjectList) {
+
+            String type = jsonObject.getStr("type");
+            JSONArray itemArr = (JSONArray) T.JSONUtil.getByPath(jsonObject, "member.items");
+            itemArr = T.CollUtil.defaultIfEmpty(itemArr, new JSONArray());
+
+            switch (type) {
+                case "http_signature":
+                case "keywords": {
+                    String exprTypeJsonPath = "keywords" .equals(type) ? "string.expr_type" : "contextual_string.expr_type";
+                    String firstExprJsonPath = "keywords" .equals(type) ? "string.patterns[0].keywords" : "contextual_string.patterns[0].keywords";
+                    String patternsJsonPath = "keywords" .equals(type) ? "string.patterns" : "contextual_string.patterns";
+
+                    itemArr.stream()
+                            .map(obj -> (JSONObject) obj)
+                            .forEach(item -> {
+                                // 0 -> 无表达式，1 -> 与表达式，2 -> 正则表达式，3、带偏移量的子串匹配
+                                Integer expr_type = (Integer) T.JSONUtil.getByPath(item, exprTypeJsonPath);
+
+                                String tempType = "and";
+                                String expr = (String) T.JSONUtil.getByPath(item, firstExprJsonPath);
+                                switch (expr_type) {
+                                    case 0:
+                                        break;
+                                    case 1: {
+                                        JSONArray patterns = (JSONArray) T.JSONUtil.getByPath(item, patternsJsonPath);
+                                        expr = patterns.stream()
+                                                .map(obj -> ((JSONObject) obj).getStr("keywords"))
+                                                .collect(Collectors.joining("&"));
+                                        break;
+                                    }
+                                    case 2:
+                                        tempType = "regex";
+                                        break;
+                                    case 3: {
+                                        JSONArray patterns = (JSONArray) T.JSONUtil.getByPath(item, patternsJsonPath);
+                                        expr = patterns.stream()
+                                                .map(obj -> {
+                                                    String keywords = ((JSONObject) obj).getStr("keywords");
+                                                    String offset = ((JSONObject) obj).getStr("offset");
+                                                    String depth = ((JSONObject) obj).getStr("depth");
+                                                    return T.StrUtil.concat(true, "(offset=", offset, ",depth=", depth, ")", keywords);
+                                                })
+                                                .collect(Collectors.joining("&"));
+                                        break;
+                                    }
+                                    default:
+                                        break;
+                                }
+                                Map<Object, Object> m = T.MapUtil.builder()
+                                        .put("item", expr)
+                                        .put("exprType", tempType)
+                                        .put("description", "")
+                                        .build();
+                                String context_name = (String) T.JSONUtil.getByPath(item, "contextual_string.context_name");
+                                if (T.StrUtil.isNotEmpty(context_name)) {
+                                    m.put("district", context_name);
+                                }
+                                iiemList.add(m);
+                            });
+                    break;
+                }
+                case "url":
+                case "fqdn": {
+                    itemArr.stream()
+                            .map(obj -> (JSONObject) obj)
+                            .forEach(item -> {
+                                String str = (String) T.JSONUtil.getByPath(item, "string.patterns[0].keywords");
+                                iiemList.add(
+                                        T.MapUtil.builder()
+                                                .put("item", str)
+                                                .put("description", "")
+                                                .build()
+                                );
+                            });
+                    break;
+                }
+                case "ip": {
+                    itemArr.stream()
+                            .map(obj -> (JSONObject) obj)
+                            .forEach(item -> {
+                                String port = (String) T.JSONUtil.getByPath(item, "ip.port");
+                                String ipAddress = (String) T.JSONUtil.getByPath(item, "ip.ip_address");
+                                if (T.StrUtil.isEmpty(ipAddress)) {
+                                    ipAddress = (String) T.JSONUtil.getByPath(item, "ip.ip_cidr");
+                                }
+                                if (T.StrUtil.isEmpty(ipAddress)) {
+                                    ipAddress = (String) T.JSONUtil.getByPath(item, "ip.ip_range");
+                                }
+                                if (!"0-65535" .equalsIgnoreCase(port)) {
+                                    ipAddress = T.StrUtil.concat(true, ipAddress, "#", port);
+                                }
+                                iiemList.add(
+                                        T.MapUtil.builder()
+                                                .put("item", ipAddress)
+                                                .put("description", "")
+                                                .build()
+                                );
+                            });
+                    break;
+                }
+                case "port": {
+                    itemArr.stream()
+                            .map(obj -> (JSONObject) obj)
+                            .forEach(item -> {
+                                String port = (String) T.JSONUtil.getByPath(item, "port.port");
+                                if (T.StrUtil.isEmpty(port)) {
+                                    port = (String) T.JSONUtil.getByPath(item, "port.port_range");
+                                }
+                                iiemList.add(
+                                        T.MapUtil.builder()
+                                                .put("item", port)
+                                                .put("description", "")
+                                                .build()
+                                );
+                            });
+                    break;
+                }
+                case "interval": {
+                    itemArr.stream()
+                            .map(obj -> (JSONObject) obj)
+                            .forEach(item -> {
+                                Object low_boundary = T.JSONUtil.getByPath(item, "interval.low_boundary");
+                                Object up_boundary = T.JSONUtil.getByPath(item, "interval.up_boundary");
+                                Map<Object, Object> m = T.MapUtil.builder()
+                                        .put("item", low_boundary + "-" + up_boundary)
+                                        .put("description", "")
+                                        .build();
+                                iiemList.add(m);
+                            });
+                    break;
+                }
+                case "boolean":
+                case "ip_protocol": {
+                    Map<Object, Object> m = T.MapUtil.builder()
+                            .put("item", jsonObject.getStr("name"))
+                            .put("description", "")
+                            .build();
+                    iiemList.add(m);
+                    break;
+                }
+                case "application": {
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        return iiemList;
+    }
+
+}

src/main/java/net/geedge/asw/module/app/util/ApkInfo.java

@@ -0,0 +1,169 @@
+package net.geedge.asw.module.app.util;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ApkInfo {
+
+    public static final String APPLICATION_ICON_120 = "application-icon-120";
+    public static final String APPLICATION_ICON_160 = "application-icon-160";
+    public static final String APPLICATION_ICON_240 = "application-icon-240";
+    public static final String APPLICATION_ICON_320 = "application-icon-320";
+
+    // 所需设备属性
+    private List<String> features;
+    // 图标
+    private String icon;
+    // 各分辨率下图标路径
+    private Map<String, String> icons;
+    // 应用程序名
+    private String label;
+    // 入口Activity
+    private String launchableActivity;
+    // 支持的Android平台最低版本号
+    private String minSdkVersion;
+    // 主包名
+    private String packageName;
+    // 支持的SDK版本
+    private String sdkVersion;
+    // Apk文件大小（字节）
+    private long size;
+    // 目标SDK版本
+    private String targetSdkVersion;
+    // 所需权限
+    private List<String> usesPermissions;
+    // 内部版本号
+    private String versionCode;
+    // 外部版本号
+    private String versionName;
+
+    public ApkInfo() {
+        this.features = new ArrayList<>();
+        this.icons = new HashMap<>();
+        this.usesPermissions = new ArrayList<>();
+    }
+
+    public List<String> getFeatures() {
+        return features;
+    }
+
+    public void setFeatures(List<String> features) {
+        this.features = features;
+    }
+
+    public void addToFeatures(String feature) {
+        this.features.add(feature);
+    }
+
+    public String getIcon() {
+        return icon;
+    }
+
+    public void setIcon(String icon) {
+        this.icon = icon;
+    }
+
+    public Map<String, String> getIcons() {
+        return icons;
+    }
+
+    public void setIcons(Map<String, String> icons) {
+        this.icons = icons;
+    }
+
+    public void addToIcons(String key, String value) {
+        this.icons.put(key, value);
+    }
+
+    public String getLabel() {
+        return label;
+    }
+
+    public void setLabel(String label) {
+        this.label = label;
+    }
+
+    public String getLaunchableActivity() {
+        return launchableActivity;
+    }
+
+    public void setLaunchableActivity(String launchableActivity) {
+        this.launchableActivity = launchableActivity;
+    }
+
+    public String getMinSdkVersion() {
+        return minSdkVersion;
+    }
+
+    public void setMinSdkVersion(String minSdkVersion) {
+        this.minSdkVersion = minSdkVersion;
+    }
+
+    public String getPackageName() {
+        return packageName;
+    }
+
+    public void setPackageName(String packageName) {
+        this.packageName = packageName;
+    }
+
+    public String getSdkVersion() {
+        return sdkVersion;
+    }
+
+    public void setSdkVersion(String sdkVersion) {
+        this.sdkVersion = sdkVersion;
+    }
+
+    public long getSize() {
+        return size;
+    }
+
+    public void setSize(long size) {
+        this.size = size;
+    }
+
+    public String getTargetSdkVersion() {
+        return targetSdkVersion;
+    }
+
+    public void setTargetSdkVersion(String targetSdkVersion) {
+        this.targetSdkVersion = targetSdkVersion;
+    }
+
+    public List<String> getUsesPermissions() {
+        return usesPermissions;
+    }
+
+    public void setUsesPermissions(List<String> usesPermissions) {
+        this.usesPermissions = usesPermissions;
+    }
+
+    public void addToUsesPermissions(String usesPermission) {
+        this.usesPermissions.add(usesPermission);
+    }
+
+    public String getVersionCode() {
+        return versionCode;
+    }
+
+    public void setVersionCode(String versionCode) {
+        this.versionCode = versionCode;
+    }
+
+    public String getVersionName() {
+        return versionName;
+    }
+
+    public void setVersionName(String versionName) {
+        this.versionName = versionName;
+    }
+
+    @Override
+    public String toString() {
+        return "ApkInfo [features=" + features + ", icon=" + icon + ", icons=" + icons + ", label=" + label + ", launchableActivity=" + launchableActivity + ", minSdkVersion=" + minSdkVersion + ", packageName=" + packageName + ", sdkVersion=" + sdkVersion + ", size=" + size + ", targetSdkVersion=" + targetSdkVersion + ", usesPermissions=" + usesPermissions + ", versionCode=" + versionCode + ", versionName=" + versionName + "]";
+    }
+
+}

src/main/java/net/geedge/asw/module/app/util/ApkUtil.java

@@ -0,0 +1,155 @@
+package net.geedge.asw.module.app.util;
+
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.log.Log;
+import net.geedge.asw.common.util.Constants;
+import net.geedge.asw.common.util.T;
+
+import java.io.*;
+import java.util.Map;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+public class ApkUtil {
+
+    private static final Log log = Log.get();
+
+    public static final String APPLICATION = "application:";
+    public static final String APPLICATION_ICON = "application-icon";
+    public static final String APPLICATION_LABEL = "application-label";
+    public static final String APPLICATION_LABEL_N = "application: label";
+    public static final String DENSITIES = "densities";
+    public static final String LAUNCHABLE_ACTIVITY = "launchable";
+    public static final String PACKAGE = "package";
+    public static final String SDK_VERSION = "sdkVersion";
+    public static final String SUPPORTS_ANY_DENSITY = "support-any-density";
+    public static final String SUPPORTS_SCREENS = "support-screens";
+    public static final String TARGET_SDK_VERSION = "targetSdkVersion";
+    public static final String VERSION_CODE = "versionCode";
+    public static final String VERSION_NAME = "versionName";
+    public static final String USES_FEATURE = "uses-feature";
+    public static final String USES_IMPLIED_FEATURE = "uses-implied-feature";
+    public static final String USES_PERMISSION = "uses-permission";
+
+    private static final String SPLIT_REGEX = "(: )|(=')|(' )|'";
+
+    private ProcessBuilder builder;
+    // aapt 所在目录
+    private String aaptToolPath = "aapt";
+
+    public ApkUtil() {
+        builder = new ProcessBuilder();
+        builder.redirectErrorStream(true);
+    }
+
+    public String getAaptToolPath() {
+        return aaptToolPath;
+    }
+
+    public void setAaptToolPath(String aaptToolPath) {
+        this.aaptToolPath = aaptToolPath;
+    }
+
+    public ApkInfo parseApk(String apkPath) {
+        String aaptTool = aaptToolPath;
+        Process process = null;
+        InputStream inputStream = null;
+        BufferedReader bufferedReader = null;
+        try {
+            process = builder.command(aaptTool, "d", "badging", apkPath).start();
+            inputStream = process.getInputStream();
+            bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
+            ApkInfo apkInfo = new ApkInfo();
+            apkInfo.setSize(new File(apkPath).length());
+            String temp = null;
+            while ((temp = bufferedReader.readLine()) != null) {
+                setApkInfoProperty(apkInfo, temp);
+            }
+            if (T.StrUtil.isBlank(apkInfo.getPackageName()) || T.StrUtil.isBlank(apkInfo.getVersionName())) {
+                return null;
+            }
+            return apkInfo;
+        } catch (IOException e) {
+            log.error(e, "[parseApk] [error] [path: {}]", apkPath);
+            return null;
+        } finally {
+            if (process != null) {
+                process.destroy();
+            }
+            T.IoUtil.close(inputStream);
+            T.IoUtil.close(bufferedReader);
+        }
+    }
+
+    public ApkInfo parseXapk(String xapkPath) {
+        InputStream inputStream = null;
+        BufferedReader reader = null;
+        File tempFile = null;
+        try {
+            ZipFile zipFile = new ZipFile(T.FileUtil.file(xapkPath));
+            ZipEntry entry = zipFile.getEntry("manifest.json");
+            inputStream = zipFile.getInputStream(entry);
+            StringBuilder manifestJson = new StringBuilder();
+            reader = new BufferedReader(new InputStreamReader(inputStream));
+            String line;
+            while ((line = reader.readLine()) != null) {
+                manifestJson.append(line).append("\n");
+            }
+            Map manifest = T.JSONUtil.toBean(manifestJson.toString(), Map.class);
+            ZipEntry packageFile = zipFile.getEntry(T.StrUtil.concat(true, T.MapUtil.getStr(manifest, "package_name"), ".apk"));
+            tempFile = T.FileUtil.file(Constants.TEMP_PATH, packageFile.getName());
+            FileUtil.writeBytes(zipFile.getInputStream(packageFile).readAllBytes(), tempFile);
+            ApkInfo apkInfo = this.parseApk(tempFile.getPath());
+            if (apkInfo == null) {
+                return null;
+            }
+            if (!T.BooleanUtil.and(apkInfo.getVersionName().equals(T.MapUtil.getStr(manifest, "version_name")),
+                    apkInfo.getPackageName().equals(T.MapUtil.getStr(manifest, "package_name")))) {
+                return null;
+            }
+            return apkInfo;
+        } catch (Exception e) {
+            log.error(e, "[parseXapk] [error] [path: {}]", xapkPath);
+            return null;
+        } finally {
+            T.FileUtil.del(tempFile);
+            T.IoUtil.close(inputStream);
+            T.IoUtil.close(reader);
+        }
+    }
+
+    private void setApkInfoProperty(ApkInfo apkInfo, String source) {
+        if (source.startsWith(APPLICATION)) {
+            String[] rs = source.split("( icon=')|'");
+            apkInfo.setIcon(rs[rs.length - 1]);
+        } else if (source.startsWith(APPLICATION_ICON)) {
+            apkInfo.addToIcons(getKeyBeforeColon(source), getPropertyInQuote(source));
+        } else if (source.startsWith(APPLICATION_LABEL)) {
+            apkInfo.setLabel(getPropertyInQuote(source));
+        } else if (source.startsWith(LAUNCHABLE_ACTIVITY)) {
+            apkInfo.setLaunchableActivity(getPropertyInQuote(source));
+        } else if (source.startsWith(PACKAGE)) {
+            String[] packageInfo = source.split(SPLIT_REGEX);
+            apkInfo.setPackageName(packageInfo[2]);
+            apkInfo.setVersionCode(packageInfo[4]);
+            apkInfo.setVersionName(packageInfo[6]);
+        } else if (source.startsWith(SDK_VERSION)) {
+            apkInfo.setSdkVersion(getPropertyInQuote(source));
+        } else if (source.startsWith(TARGET_SDK_VERSION)) {
+            apkInfo.setTargetSdkVersion(getPropertyInQuote(source));
+        } else if (source.startsWith(USES_PERMISSION)) {
+            apkInfo.addToUsesPermissions(getPropertyInQuote(source));
+        } else if (source.startsWith(USES_FEATURE)) {
+            apkInfo.addToFeatures(getPropertyInQuote(source));
+        }
+    }
+
+    private String getKeyBeforeColon(String source) {
+        return source.substring(0, source.indexOf(':'));
+    }
+
+    private String getPropertyInQuote(String source) {
+        int index = source.indexOf("'") + 1;
+        return source.substring(index, source.indexOf('\'', index));
+    }
+}

src/main/java/net/geedge/asw/module/app/util/PkgConstant.java

@@ -0,0 +1,37 @@
+package net.geedge.asw.module.app.util;
+
+import net.geedge.asw.common.util.T;
+
+import java.io.File;
+
+public class PkgConstant {
+
+    /**
+     * android packages file dir
+     */
+    public static File APK_FILES_DIR = T.FileUtil.file(T.WebPathUtil.getRootPath(), "apk_files");
+
+    /**
+     * support platform
+     */
+    public enum Platform {
+        ANDROID("android"),
+
+        IOS("ios"),
+
+        WINDOWS("windows"),
+
+        LINUX("linux");
+
+        private String value;
+
+        Platform(String value) {
+            this.value = value;
+        }
+
+        public String getValue() {
+            return value;
+        }
+    }
+
+}

src/main/java/net/geedge/asw/module/attribute/controller/AttributeController.java

@@ -0,0 +1,26 @@
+package net.geedge.asw.module.attribute.controller;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import net.geedge.asw.common.util.R;
+import net.geedge.asw.module.attribute.service.IAttributeService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/v1/attribute")
+public class AttributeController {
+
+    @Autowired
+    private IAttributeService attributeService;
+
+    @GetMapping
+    public R list(@RequestParam Map<String, Object> params) {
+        Page page = attributeService.queryList(params);
+        return R.ok(page);
+    }
+}

src/main/java/net/geedge/asw/module/attribute/dao/AttributeDao.java

@@ -0,0 +1,15 @@
+package net.geedge.asw.module.attribute.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import net.geedge.asw.module.attribute.entity.AttributeEntity;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+import java.util.Map;
+
+@Mapper
+public interface AttributeDao extends BaseMapper<AttributeEntity> {
+
+    List<AttributeEntity> queryList(@Param("params") Map<String, Object> params);
+}

src/main/java/net/geedge/asw/module/attribute/entity/AttributeEntity.java

@@ -0,0 +1,43 @@
+package net.geedge.asw.module.attribute.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import net.geedge.asw.module.sys.entity.SysUserEntity;
+
+@Data
+@TableName("attribute_dict")
+public class AttributeEntity {
+
+    @TableId(type = IdType.ASSIGN_UUID)
+    private String id;
+
+    private String name;
+
+    private String type;
+
+    private String protocol;
+
+    private String layer;
+
+    private String stage;
+
+    private String objectType;
+
+    private Long createTimestamp;
+
+    private Long updateTimestamp;
+
+    private String createUserId;
+
+    private String updateUserId;
+
+    @TableField(exist = false)
+    private SysUserEntity createUser;
+
+    @TableField(exist = false)
+    private SysUserEntity updateUser;
+
+}

src/main/java/net/geedge/asw/module/attribute/service/IAttributeService.java

@@ -0,0 +1,13 @@
+package net.geedge.asw.module.attribute.service;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.IService;
+import net.geedge.asw.module.attribute.entity.AttributeEntity;
+
+import java.util.Map;
+
+public interface IAttributeService extends IService<AttributeEntity> {
+    Page queryList(Map<String, Object> params);
+
+    AttributeEntity queryAttribute(String type, String name);
+}

src/main/java/net/geedge/asw/module/attribute/service/impl/AttributeServiceImpl.java

@@ -0,0 +1,39 @@
+package net.geedge.asw.module.attribute.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.attribute.dao.AttributeDao;
+import net.geedge.asw.module.attribute.entity.AttributeEntity;
+import net.geedge.asw.module.attribute.service.IAttributeService;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Map;
+
+@Service
+public class AttributeServiceImpl extends ServiceImpl<AttributeDao, AttributeEntity> implements IAttributeService {
+
+
+    @Override
+    public Page queryList(Map<String, Object> params) {
+
+        Page page = T.PageUtil.getPage(params);
+        List<AttributeEntity> attributeList = this.getBaseMapper().queryList(params);
+        page.setRecords(attributeList);
+        return page;
+    }
+
+    @Override
+    public AttributeEntity queryAttribute(String type, String name) {
+        AttributeEntity one = this.getOne(new LambdaQueryWrapper<AttributeEntity>()
+                .eq(AttributeEntity::getType, type)
+                .eq(AttributeEntity::getName, name)
+                .last("limit 1")
+        );
+        return one;
+    }
+
+}

src/main/java/net/geedge/asw/module/environment/controller/EnvironmentController.java

@@ -0,0 +1,242 @@
+package net.geedge.asw.module.environment.controller;
+
+import cn.dev33.satoken.stp.StpUtil;
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.core.util.ArrayUtil;
+import cn.hutool.http.HttpRequest;
+import cn.hutool.http.HttpResponse;
+import cn.hutool.json.JSONObject;
+import cn.hutool.log.Log;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import net.geedge.asw.common.util.*;
+import net.geedge.asw.module.environment.entity.EnvironmentEntity;
+import net.geedge.asw.module.environment.entity.EnvironmentSessionEntity;
+import net.geedge.asw.module.environment.service.IEnvironmentService;
+import net.geedge.asw.module.environment.service.IEnvironmentSessionService;
+import net.geedge.asw.module.environment.util.EnvironmentUtil;
+import net.geedge.asw.module.runner.entity.PcapEntity;
+import net.geedge.asw.module.runner.service.IPcapService;
+import net.geedge.asw.module.runner.util.RunnerConstant;
+import net.geedge.asw.module.sys.service.ISysUserService;
+import net.geedge.asw.module.workspace.entity.WorkspaceEntity;
+import net.geedge.asw.module.workspace.service.IWorkspaceService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.*;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.socket.CloseStatus;
+import org.springframework.web.socket.WebSocketSession;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.*;
+
+@RestController
+@RequestMapping("/api/v1/env")
+public class EnvironmentController {
+
+    private static final Log log = Log.get();
+
+
+    @Autowired
+    private IEnvironmentService environmentService;
+
+    @Autowired
+    private IEnvironmentSessionService environmentSessionService;
+
+    @Autowired
+    private ISysUserService userService;
+
+    @Autowired
+    private IWorkspaceService workspaceService;
+
+    @Autowired
+    private IPcapService pcapService;
+
+    @GetMapping("/{id}")
+    public R detail(@PathVariable("id") String id) {
+        EnvironmentEntity entity = environmentService.queryInfo(id);
+        return R.ok().putData("record", entity);
+    }
+
+    @GetMapping
+    public R list(@RequestParam Map<String, Object> params) {
+        T.VerifyUtil.is(params).notNull()
+                .and(T.MapUtil.getStr(params, "workspaceId")).notEmpty(RCode.WORKSPACE_ID_CANNOT_EMPTY);
+        Page page = environmentService.queryList(params);
+        return R.ok(page);
+    }
+
+    @GetMapping("/mgt")
+    public R queryList(@RequestParam Map<String, Object> params) {
+        Page page = environmentService.findEnvironmentByCurrentUserId(params);
+        return R.ok().putData(page);
+    }
+
+
+    @PostMapping("/mgt")
+    public R save(@RequestBody EnvironmentEntity entity) {
+        EnvironmentEntity env = environmentService.saveEnv(entity);
+        return R.ok().putData("record", env.getId());
+    }
+
+    @PutMapping("/mgt")
+    public R update(@RequestBody EnvironmentEntity entity) {
+        EnvironmentEntity env = environmentService.updateEnv(entity);
+        return R.ok().putData("record", env.getId());
+    }
+
+    @DeleteMapping("/mgt")
+    public R delete(String ids) {
+        T.VerifyUtil.is(ids).notEmpty();
+        environmentService.removeEnv(T.ListUtil.of(ids.split(",")));
+        return R.ok();
+    }
+
+    @PostMapping("/test")
+    public R testConnect(@RequestBody EnvironmentEntity entity) {
+        T.VerifyUtil.is(entity).notNull()
+                .and(entity.getParam()).notEmpty(RCode.PARAM_CANNOT_EMPTY);
+
+        JSONObject jsonObject = entity.getParamJSONObject();
+        String url = jsonObject.getStr("url");
+        String token = jsonObject.getStr("token");
+        if (T.StrUtil.hasEmpty(url, token)) {
+            return R.error(RCode.PARAM_CANNOT_EMPTY);
+        }
+
+        try {
+            HttpRequest request = T.HttpUtil.createGet(String.format("%s/api/v1/env/status", url));
+            request.header("Authorization", token);
+            HttpResponse response = request.execute();
+            log.info("[testConnect] [status: {}]", response.getStatus());
+            if (response.getStatus() == 401) {
+                return R.error(401, "Unauthorized");
+            }
+            if (response.isOk()) {
+                return R.ok();
+            }
+        } catch (Exception e) {
+            log.error(e);
+            return R.error(RCode.ERROR);
+        }
+        return R.error(RCode.ERROR);
+    }
+
+    @RequestMapping(value = "/{envId}/session/{sessionId}/**", method ={ RequestMethod.GET, RequestMethod.POST, RequestMethod.DELETE}, headers = "Upgrade!=websocket")
+    public void agentEvn(@PathVariable("envId") String envId, @PathVariable("sessionId") String sessionId, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
+        EnvironmentSessionEntity session = environmentSessionService.getOne(new LambdaQueryWrapper<EnvironmentSessionEntity>().eq(EnvironmentSessionEntity::getId, sessionId).eq(EnvironmentSessionEntity::getStatus, 1));
+        if (T.ObjectUtil.isNull(session)){
+            throw new ASWException(RCode.ENVIRONMENT_SESSION_NOT_EXIST);
+        }
+
+        EnvironmentEntity environment = environmentService.getById(session.getEnvId());
+        if (T.ObjectUtil.isNull(environment)) {
+            throw new ASWException(RCode.ENVIRONMENT_NOT_EXIST);
+        }
+
+        EnvironmentUtil.getForObject(environment, request, response, sessionId);
+    }
+
+    @GetMapping("/mySession")
+    public R mySession(@RequestParam Map params){
+       Page page = environmentService.mySession(params);
+        return R.ok(page);
+    }
+
+    @PostMapping("/{envId}/session")
+    public R saveSession(@PathVariable("envId") String envId, @RequestParam String workspaceId){
+        EnvironmentSessionEntity session = environmentSessionService.saveSession(envId, workspaceId);
+        return R.ok().putData("record", session.getId());
+    }
+
+    @GetMapping("/{envId}/session/{sessionId}")
+    public R querySession(@PathVariable("envId") String envId, @PathVariable("sessionId") String sessionId, @RequestParam String workspaceId){
+        EnvironmentSessionEntity session = environmentSessionService.getOne(new LambdaQueryWrapper<EnvironmentSessionEntity>().eq(EnvironmentSessionEntity::getId, sessionId).eq(EnvironmentSessionEntity::getWorkspaceId, workspaceId));
+        session.setEnv(environmentService.getById(envId));
+        session.setWorkspace(workspaceService.getById(workspaceId));
+        session.setUser(userService.getById(session.getUserId()));
+        return R.ok().putData("record", session);
+    }
+
+
+    @DeleteMapping("/{envId}/session/{sessionId}")
+    @Transactional
+    public R removeSession(@PathVariable("envId") String envId, @PathVariable("sessionId") String sessionId, @RequestParam String workspaceId) {
+        EnvironmentSessionEntity session = environmentSessionService.getById(sessionId);
+        WebSocketSession novncSession = Constants.ENV_NOVNC_WEBSOCKET_SESSION.get(sessionId);
+        WebSocketSession terminalSession = Constants.ENV_TERMINAL_WEBSOCKET_SESSION.get(sessionId);
+        // 根据 session 找到 novncSession&terminalSession ，更新状态，设置结束时间
+        session.setEndTimestamp(System.currentTimeMillis());
+        session.setStatus(2);
+        environmentSessionService.updateById(session);
+        try {
+            if (T.ObjectUtil.isNotEmpty(novncSession)) {
+                Constants.ENV_NOVNC_WEBSOCKET_SESSION.remove(sessionId);
+                novncSession.close(CloseStatus.NORMAL.withReason("Administrator disconnected."));
+            }
+            if (T.ObjectUtil.isNotEmpty(terminalSession)) {
+                Constants.ENV_TERMINAL_WEBSOCKET_SESSION.remove(sessionId);
+                terminalSession.close(CloseStatus.NORMAL.withReason("Administrator disconnected."));
+            }
+        } catch (IOException e) {
+            log.error(e, "RemoveSession send exit prompt error sessionId: {}", sessionId);
+        }
+        return R.ok();
+    }
+
+
+    @DeleteMapping("/{envId}/session/{sessionId}/pcap/{pcapId}")
+    public R stopTcpdump(@PathVariable("envId") String envId,
+                         @PathVariable("sessionId") String sessionId,
+                         @PathVariable("pcapId") String pcapId,
+                         @RequestParam Map param) throws IOException, ServletException {
+        EnvironmentSessionEntity session = environmentSessionService.getOne(new LambdaQueryWrapper<EnvironmentSessionEntity>().eq(EnvironmentSessionEntity::getId, sessionId).eq(EnvironmentSessionEntity::getStatus, 1));
+        if (T.ObjectUtil.isNull(session)){
+            throw new ASWException(RCode.ENVIRONMENT_SESSION_NOT_EXIST);
+        }
+        EnvironmentEntity environment = environmentService.getById(envId);
+        if (T.ObjectUtil.isNull(environment)) {
+            throw new ASWException(RCode.ENVIRONMENT_NOT_EXIST);
+        }
+        // build query param
+        Map params = T.MapUtil.builder().put("id", pcapId).put("returnFile", T.MapUtil.getBool(param, "savePcap")).build();
+        ResponseEntity<byte[]> responseEntity = EnvironmentUtil.stopTcpdump(environment, params);
+        if (T.MapUtil.getBool(param, "savePcap")){
+            // save pcap to workspace
+            WorkspaceEntity workspace = workspaceService.getById(session.getWorkspaceId());
+            String pcapName = T.StrUtil.emptyToDefault(T.MapUtil.getStr(param,"pcapName"), pcapId);
+            File destination = T.FileUtil.file(T.WebPathUtil.getRootPath(), workspace.getId(), T.StrUtil.concat(true,pcapName, ".pcap"));
+            if (destination.exists()){
+                String formatTime = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
+                destination = T.FileUtil.file(T.WebPathUtil.getRootPath(), workspace.getId(), T.StrUtil.concat(true, pcapName, "-", formatTime, ".pcap"));
+            }
+            // create empty file
+            destination = FileUtil.touch(destination);
+           if (ArrayUtil.isNotEmpty(responseEntity.getBody())){
+               FileOutputStream fos = new FileOutputStream(destination);
+               T.IoUtil.write(fos,true, responseEntity.getBody());
+           }
+            log.info("save pcap to path:{}", destination.getAbsolutePath());
+            // save entity
+            PcapEntity entity = new PcapEntity();
+            entity.setId(pcapId);
+            entity.setName(destination.getName());
+            entity.setSize(destination.length());
+            entity.setStatus(RunnerConstant.PcapStatus.UPLOADED.getValue());
+            entity.setCreateTimestamp(System.currentTimeMillis());
+            entity.setCreateUserId(StpUtil.getLoginIdAsString());
+            entity.setWorkspaceId(workspace.getId());
+            entity.setPath(destination.getPath());
+            entity.setMd5(destination.length() == 0 ? Constants.EMPTY_FILE_MD5 : T.DigestUtil.md5Hex(destination));
+            pcapService.save(entity);
+        }
+        return R.ok();
+    }
+}

src/main/java/net/geedge/asw/module/environment/dao/EnvironmentDao.java

@@ -0,0 +1,17 @@
+package net.geedge.asw.module.environment.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import net.geedge.asw.module.environment.entity.EnvironmentEntity;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.List;
+import java.util.Map;
+
+@Mapper
+public interface EnvironmentDao extends BaseMapper<EnvironmentEntity> {
+
+    List<EnvironmentEntity> queryList(Page page, Map<String, Object> params);
+
+    List<EnvironmentEntity> mySession(Page page, Map params);
+}

src/main/java/net/geedge/asw/module/environment/dao/EnvironmentSessionDao.java

@@ -0,0 +1,14 @@
+package net.geedge.asw.module.environment.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import net.geedge.asw.module.environment.entity.EnvironmentSessionEntity;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.List;
+
+@Mapper
+public interface EnvironmentSessionDao extends BaseMapper<EnvironmentSessionEntity> {
+
+    List<EnvironmentSessionEntity> queryListByUsed();
+
+}

src/main/java/net/geedge/asw/module/environment/dao/EnvironmentWorkspaceDao.java

@@ -0,0 +1,9 @@
+package net.geedge.asw.module.environment.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import net.geedge.asw.module.environment.entity.EnvironmentWorkspaceEntity;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface EnvironmentWorkspaceDao extends BaseMapper<EnvironmentWorkspaceEntity> {
+}

src/main/java/net/geedge/asw/module/environment/entity/EnvironmentEntity.java

@@ -0,0 +1,66 @@
+package net.geedge.asw.module.environment.entity;
+
+import cn.hutool.json.JSONObject;
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.Data;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.sys.entity.SysUserEntity;
+import net.geedge.asw.module.workspace.entity.WorkspaceEntity;
+
+import java.util.List;
+
+@Data
+@TableName("environment")
+public class EnvironmentEntity {
+
+    @TableId(type = IdType.ASSIGN_UUID)
+    private String id;
+    private String name;
+    private String location;
+    private String platform;
+    private Object param;
+    private String description;
+    private Integer status;
+
+    private Long lastHealthCheck;
+    private Long createTimestamp;
+    private Long updateTimestamp;
+    private String createUserId;
+    private String updateUserId;
+
+    @TableField(exist = false)
+    private String workspaceId;
+
+    @TableField(exist = false)
+    private SysUserEntity createUser;
+
+    @TableField(exist = false)
+    private SysUserEntity updateUser;
+
+    @TableField(exist = false)
+    private JSONObject useUser;
+
+    @TableField(exist = false)
+    private List<WorkspaceEntity> workspaces;
+
+    @TableField(exist = false)
+    private EnvironmentSessionEntity session;
+
+    @TableField(exist = false)
+    private List<String> workspaceIds;
+
+    @JsonIgnore
+    public String getParamStr() {
+        return null == this.param ? "{}" : T.JSONUtil.toJsonStr(this.param);
+    }
+
+    @JsonIgnore
+    public JSONObject getParamJSONObject() {
+        return null == this.param ? new JSONObject() : T.JSONUtil.parseObj(this.getParamStr());
+    }
+
+}

src/main/java/net/geedge/asw/module/environment/entity/EnvironmentSessionEntity.java

@@ -0,0 +1,36 @@
+package net.geedge.asw.module.environment.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import net.geedge.asw.module.sys.entity.SysUserEntity;
+import net.geedge.asw.module.workspace.entity.WorkspaceEntity;
+
+@Data
+@TableName("environment_session")
+public class EnvironmentSessionEntity {
+
+    @TableId(type = IdType.ASSIGN_UUID)
+    private String id;
+    private String envId;
+    private String userId;
+    private Integer status;
+    private String jobId;
+
+    private Long startTimestamp;
+    private Long endTimestamp;
+
+    private String workspaceId;
+
+    @TableField(exist = false)
+    private EnvironmentEntity env;
+
+    @TableField(exist = false)
+    private WorkspaceEntity workspace;
+
+    @TableField(exist = false)
+    private SysUserEntity user;
+
+}

src/main/java/net/geedge/asw/module/environment/entity/EnvironmentWorkspaceEntity.java

@@ -0,0 +1,19 @@
+package net.geedge.asw.module.environment.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+
+@Data
+@TableName("environment_workspace")
+public class EnvironmentWorkspaceEntity {
+    @TableId(type = IdType.ASSIGN_UUID)
+    private String id;
+
+    private String envId;
+    private String workspaceId;
+    private Long createTimestamp;
+    private String createUserId;
+}

src/main/java/net/geedge/asw/module/environment/job/JobEnvironmentStatusChecker.java

@@ -0,0 +1,124 @@
+package net.geedge.asw.module.environment.job;
+
+import cn.hutool.http.HttpRequest;
+import cn.hutool.http.HttpResponse;
+import cn.hutool.json.JSONObject;
+import cn.hutool.log.Log;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import net.geedge.asw.common.util.RCode;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.environment.entity.EnvironmentEntity;
+import net.geedge.asw.module.environment.entity.EnvironmentSessionEntity;
+import net.geedge.asw.module.environment.service.IEnvironmentService;
+import net.geedge.asw.module.environment.service.IEnvironmentSessionService;
+import org.apache.commons.lang3.time.StopWatch;
+import org.quartz.DisallowConcurrentExecution;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.quartz.QuartzJobBean;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+@DisallowConcurrentExecution
+public class JobEnvironmentStatusChecker extends QuartzJobBean {
+
+    private static final Log log = Log.get();
+
+    @Autowired
+    private IEnvironmentService envService;
+
+    @Autowired
+    private IEnvironmentSessionService envSessionService;
+
+    @Override
+    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
+        Thread.currentThread().setName("JobEnvironmentStatusChecker");
+
+        log.info("[JobEnvironmentStatusChecker] [begin]");
+        StopWatch sw = new StopWatch();
+        sw.start();
+        try {
+            this.environmentStatusChecker();
+        } catch (Exception e) {
+            log.error(e, "[JobEnvironmentStatusChecker] [error]");
+        } finally {
+            sw.stop();
+        }
+        log.info("[JobEnvironmentStatusChecker] [finshed] [Run Time: {}]", sw.toString());
+    }
+
+    /**
+     * environment status checker
+     * <p>
+     * 1. update entity status、lastHealthCheck
+     * 2. close the offline env session
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public void environmentStatusChecker() {
+        List<EnvironmentEntity> list = envService.list();
+        for (EnvironmentEntity entity : list) {
+            Thread.ofVirtual().start(() -> {
+                String result = null;
+                try {
+                    JSONObject paramJSONObject = entity.getParamJSONObject();
+                    String url = paramJSONObject.getStr("url");
+                    String token = paramJSONObject.getStr("token");
+
+                    HttpRequest request = T.HttpUtil.createGet(String.format("%s/api/v1/env/status", url));
+                    request.header("Authorization", token);
+
+                    HttpResponse response = request.execute();
+                    log.info("[environmentStatusChecker] [env: {}] [status: {}]", entity.getId(), response.getStatus());
+
+                    if (response.isOk()) {
+                        result = response.body();
+                    }
+                } catch (RuntimeException e) {
+                    log.error(e, "[environmentStatusChecker] [request api error] [env: {}]", entity.getId());
+                }
+
+                if (log.isDebugEnabled()) {
+                    log.debug("[environmentStatusChecker] [env: {}] [result: {}]", entity.getId(), result);
+                }
+
+                entity.setStatus(0);
+                entity.setLastHealthCheck(System.currentTimeMillis());
+
+                if (T.StrUtil.isNotEmpty(result)) {
+                    try {
+                        JSONObject jsonObject = T.JSONUtil.parseObj(result);
+                        if (T.ObjectUtil.equal(RCode.SUCCESS.getCode(), jsonObject.getInt("code"))) {
+                            JSONObject data = jsonObject.getJSONObject("data");
+                            String status = data.getStr("status");
+                            if (T.StrUtil.equals("online", status)) {
+                                entity.setStatus(1);
+                            }
+                        }
+                    } catch (Exception e) {
+                        log.error(e, "[environmentStatusChecker] [parse result error] [env: {}]", entity.getId());
+                    }
+                }
+
+                // update entity status、lastHealthCheck
+                envService.update(new LambdaUpdateWrapper<EnvironmentEntity>()
+                        .set(EnvironmentEntity::getStatus, entity.getStatus())
+                        .set(EnvironmentEntity::getLastHealthCheck, entity.getLastHealthCheck())
+                        .eq(EnvironmentEntity::getId, entity.getId())
+                );
+
+                // close the offline env session
+                if (0 == entity.getStatus()) {
+                    envSessionService.update(new LambdaUpdateWrapper<EnvironmentSessionEntity>()
+                            .set(EnvironmentSessionEntity::getStatus, 2)
+                            .set(EnvironmentSessionEntity::getEndTimestamp, System.currentTimeMillis())
+                            .eq(EnvironmentSessionEntity::getStatus, 1)
+                            .eq(EnvironmentSessionEntity::getEnvId, entity.getId())
+                    );
+                }
+            });
+        }
+    }
+
+}

src/main/java/net/geedge/asw/module/environment/service/IEnvironmentService.java

@@ -0,0 +1,25 @@
+package net.geedge.asw.module.environment.service;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.IService;
+import net.geedge.asw.module.environment.entity.EnvironmentEntity;
+
+import java.util.List;
+import java.util.Map;
+
+public interface IEnvironmentService extends IService<EnvironmentEntity>{
+
+    EnvironmentEntity queryInfo(String id);
+
+    Page queryList(Map<String, Object> params);
+
+    Page findEnvironmentByCurrentUserId(Map<String, Object> params);
+
+    void removeEnv(List<String> ids);
+
+    Page mySession(Map params);
+
+    EnvironmentEntity saveEnv(EnvironmentEntity entity);
+
+    EnvironmentEntity updateEnv(EnvironmentEntity entity);
+}

src/main/java/net/geedge/asw/module/environment/service/IEnvironmentSessionService.java

@@ -0,0 +1,13 @@
+package net.geedge.asw.module.environment.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import net.geedge.asw.module.environment.entity.EnvironmentSessionEntity;
+
+import java.util.List;
+
+public interface IEnvironmentSessionService extends IService<EnvironmentSessionEntity>{
+
+    EnvironmentSessionEntity saveSession(String envId, String workspaceId);
+
+    List<EnvironmentSessionEntity> queryListByUsed();
+}

src/main/java/net/geedge/asw/module/environment/service/IEnvironmentWorkspaceService.java

@@ -0,0 +1,7 @@
+package net.geedge.asw.module.environment.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import net.geedge.asw.module.environment.entity.EnvironmentWorkspaceEntity;
+
+public interface IEnvironmentWorkspaceService extends IService<EnvironmentWorkspaceEntity> {
+}

src/main/java/net/geedge/asw/module/environment/service/impl/EnvironmentServiceImpl.java

@@ -0,0 +1,204 @@
+package net.geedge.asw.module.environment.service.impl;
+
+import cn.dev33.satoken.stp.StpUtil;
+import cn.hutool.log.Log;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import net.geedge.asw.common.config.Query;
+import net.geedge.asw.common.util.ASWException;
+import net.geedge.asw.common.util.RCode;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.environment.dao.EnvironmentDao;
+import net.geedge.asw.module.environment.entity.EnvironmentEntity;
+import net.geedge.asw.module.environment.entity.EnvironmentSessionEntity;
+import net.geedge.asw.module.environment.entity.EnvironmentWorkspaceEntity;
+import net.geedge.asw.module.environment.service.IEnvironmentService;
+import net.geedge.asw.module.environment.service.IEnvironmentSessionService;
+import net.geedge.asw.module.environment.service.IEnvironmentWorkspaceService;
+import net.geedge.asw.module.sys.entity.SysUserEntity;
+import net.geedge.asw.module.sys.service.ISysUserService;
+import net.geedge.asw.module.workspace.entity.WorkspaceEntity;
+import net.geedge.asw.module.workspace.service.IWorkspaceService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+@Service
+public class EnvironmentServiceImpl extends ServiceImpl<EnvironmentDao, EnvironmentEntity> implements IEnvironmentService {
+
+    private static final Log log = Log.get();
+
+    @Autowired
+    private ISysUserService sysUserService;
+
+    @Autowired
+    private IEnvironmentSessionService environmentSessionService;
+
+    @Autowired
+    private IEnvironmentWorkspaceService environmentWorkspaceService;
+
+    @Autowired
+    private IWorkspaceService workspaceService;
+
+    @Override
+    public EnvironmentEntity queryInfo(String id) {
+        EnvironmentEntity environment = this.getById(id);
+        T.VerifyUtil.is(environment).notNull(RCode.SYS_RECORD_NOT_FOUND);
+
+        // param
+        environment.setParam(environment.getParamJSONObject());
+
+        // user
+        SysUserEntity createUser = sysUserService.getById(environment.getCreateUserId());
+        SysUserEntity updateUser = sysUserService.getById(environment.getUpdateUserId());
+        createUser.setPwd(null);
+        updateUser.setPwd(null);
+        environment.setCreateUser(createUser);
+        environment.setUpdateUser(updateUser);
+
+        // workspaces
+        List<EnvironmentWorkspaceEntity> environmentWorkspaceList = environmentWorkspaceService.list(new LambdaQueryWrapper<EnvironmentWorkspaceEntity>().eq(EnvironmentWorkspaceEntity::getEnvId, id));
+        if (T.CollUtil.isNotEmpty(environmentWorkspaceList)) {
+            List<String> workspaceIds = environmentWorkspaceList.stream().map(x -> x.getWorkspaceId()).toList();
+            List<WorkspaceEntity> workspaceList = workspaceService.list(new LambdaQueryWrapper<WorkspaceEntity>().in(WorkspaceEntity::getId, workspaceIds));
+            environment.setWorkspaces(workspaceList);
+        }
+
+        // session
+        EnvironmentSessionEntity deviceSession = environmentSessionService.getOne(new LambdaQueryWrapper<EnvironmentSessionEntity>()
+                .eq(EnvironmentSessionEntity::getEnvId, environment.getId())
+                .eq(EnvironmentSessionEntity::getStatus, 1));
+        if (null != deviceSession) {
+            SysUserEntity useUser = sysUserService.getById(deviceSession.getUserId());
+            useUser.setPwd(null);
+            WorkspaceEntity workspace = workspaceService.getById(deviceSession.getWorkspaceId());
+            deviceSession.setUser(useUser);
+            deviceSession.setWorkspace(workspace);
+            environment.setSession(deviceSession);
+            environment.setStatus(environment.getStatus() == 1 ? 2 : environment.getStatus());
+        }
+        return environment;
+    }
+
+    @Override
+    public Page queryList(Map<String, Object> params) {
+        Page page = T.PageUtil.getPage(params);
+        List<EnvironmentEntity> packageList = this.getBaseMapper().queryList(page, params);
+
+        List<EnvironmentSessionEntity> sessionEntityList = environmentSessionService.queryListByUsed();
+        List<String> envIdList = sessionEntityList.stream().map(x -> x.getEnvId()).toList();
+
+        Map<String, EnvironmentSessionEntity> sessionByEnvId = sessionEntityList.stream().collect(Collectors.toMap(EnvironmentSessionEntity::getEnvId, Function.identity()));
+
+        for (EnvironmentEntity entity : packageList) {
+            entity.setParam(entity.getParamJSONObject());
+            entity.setStatus(envIdList.contains(entity.getId()) ? 2 : entity.getStatus());
+            entity.setSession(sessionByEnvId.get(entity.getId()));
+        }
+        page.setRecords(packageList);
+        return page;
+    }
+
+    @Override
+    public Page findEnvironmentByCurrentUserId(Map<String, Object> params) {
+        params.put("currentUserId", StpUtil.getLoginIdAsString());
+        Page page = this.queryList(params);
+        return page;
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void removeEnv(List<String> ids) {
+        // remove
+        this.remove(new LambdaQueryWrapper<EnvironmentEntity>().in(EnvironmentEntity::getId, ids).eq(EnvironmentEntity::getCreateUserId, StpUtil.getLoginIdAsString()));
+
+        // session
+        environmentSessionService.remove(new LambdaQueryWrapper<EnvironmentSessionEntity>().in(EnvironmentSessionEntity::getEnvId, ids));
+
+        //device workspace
+        environmentWorkspaceService.remove(new LambdaQueryWrapper<EnvironmentWorkspaceEntity>().in(EnvironmentWorkspaceEntity::getEnvId, ids));
+    }
+
+    @Override
+    public Page mySession(Map params) {
+        String currentUserId = StpUtil.getLoginIdAsString();
+        params.put("currentUserId", currentUserId);
+        Page page = new Query(EnvironmentEntity.class).getPage(params);
+
+        List<EnvironmentSessionEntity> sessionEntityList = environmentSessionService.queryListByUsed();
+        List<EnvironmentEntity> packageList = this.getBaseMapper().mySession(page, params);
+        List<String> envIdList = sessionEntityList.stream().map(x -> x.getEnvId()).toList();
+        Map<String, EnvironmentSessionEntity> sessionByEnvId = sessionEntityList.stream().collect(Collectors.toMap(EnvironmentSessionEntity::getEnvId, Function.identity()));
+        for (EnvironmentEntity entity : packageList) {
+            entity.setParam(entity.getParamJSONObject());
+            entity.setStatus(envIdList.contains(entity.getId()) ? 2 : entity.getStatus());
+            entity.setSession(sessionByEnvId.get(entity.getId()));
+        }
+        page.setRecords(packageList);
+        return page;
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public EnvironmentEntity saveEnv(EnvironmentEntity entity) {
+        entity.setCreateUserId(StpUtil.getLoginIdAsString());
+        entity.setUpdateUserId(StpUtil.getLoginIdAsString());
+        entity.setCreateTimestamp(System.currentTimeMillis());
+        entity.setUpdateTimestamp(System.currentTimeMillis());
+        entity.setParam(entity.getParamStr());
+        this.save(entity);
+
+        // save env workspace
+        if (T.CollUtil.isNotEmpty(entity.getWorkspaceIds())){
+            List<EnvironmentWorkspaceEntity> list = T.ListUtil.list(false);
+            for (String workspaceId : entity.getWorkspaceIds()) {
+                EnvironmentWorkspaceEntity environmentWorkspace = new EnvironmentWorkspaceEntity();
+                environmentWorkspace.setEnvId(entity.getId());
+                environmentWorkspace.setWorkspaceId(workspaceId);
+                environmentWorkspace.setCreateTimestamp(System.currentTimeMillis());
+                environmentWorkspace.setCreateUserId(StpUtil.getLoginIdAsString());
+                list.add(environmentWorkspace);
+            }
+            environmentWorkspaceService.saveBatch(list);
+        }
+        return entity;
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public EnvironmentEntity updateEnv(EnvironmentEntity entity) {
+
+        EnvironmentEntity environment = this.getOne(new LambdaQueryWrapper<EnvironmentEntity>().eq(EnvironmentEntity::getId, entity.getId()).eq(EnvironmentEntity::getCreateUserId, StpUtil.getLoginIdAsString()));
+        if (T.ObjectUtil.isNull(environment)) {
+            throw new ASWException(RCode.ENVIRONMENT_NOT_EXIST);
+        }
+        entity.setUpdateUserId(StpUtil.getLoginIdAsString());
+        entity.setUpdateTimestamp(System.currentTimeMillis());
+        entity.setParam(entity.getParamStr());
+
+        this.updateById(entity);
+
+        environmentWorkspaceService.remove(new LambdaQueryWrapper<EnvironmentWorkspaceEntity>().eq(EnvironmentWorkspaceEntity::getEnvId, entity.getId()));
+        // save env workspace
+        if (T.CollUtil.isNotEmpty(entity.getWorkspaceIds())){
+            List<EnvironmentWorkspaceEntity> list = T.ListUtil.list(false);
+            for (String workspaceId : entity.getWorkspaceIds()) {
+                EnvironmentWorkspaceEntity environmentWorkspace = new EnvironmentWorkspaceEntity();
+                environmentWorkspace.setEnvId(entity.getId());
+                environmentWorkspace.setWorkspaceId(workspaceId);
+                environmentWorkspace.setCreateTimestamp(System.currentTimeMillis());
+                environmentWorkspace.setCreateUserId(StpUtil.getLoginIdAsString());
+                list.add(environmentWorkspace);
+            }
+            environmentWorkspaceService.saveBatch(list);
+        }
+        return entity;
+    }
+
+}

src/main/java/net/geedge/asw/module/environment/service/impl/EnvironmentSessionServiceImpl.java

@@ -0,0 +1,95 @@
+package net.geedge.asw.module.environment.service.impl;
+
+import cn.dev33.satoken.stp.StpUtil;
+import cn.hutool.log.Log;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import net.geedge.asw.common.util.ASWException;
+import net.geedge.asw.common.util.Constants;
+import net.geedge.asw.common.util.RCode;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.environment.dao.EnvironmentSessionDao;
+import net.geedge.asw.module.environment.entity.EnvironmentEntity;
+import net.geedge.asw.module.environment.entity.EnvironmentSessionEntity;
+import net.geedge.asw.module.environment.service.IEnvironmentService;
+import net.geedge.asw.module.environment.service.IEnvironmentSessionService;
+import net.geedge.asw.module.environment.util.EnvironmentUtil;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Map;
+
+@Service
+public class EnvironmentSessionServiceImpl extends ServiceImpl<EnvironmentSessionDao, EnvironmentSessionEntity> implements IEnvironmentSessionService {
+
+    private static final Log log = Log.get();
+
+    @Autowired
+    private IEnvironmentService environmentService;
+
+    @Override
+    public EnvironmentSessionEntity saveSession(String envId, String workspaceId) {
+
+        List<EnvironmentSessionEntity> sessionEntityList = this.list(new LambdaQueryWrapper<EnvironmentSessionEntity>()
+                .eq(EnvironmentSessionEntity::getEnvId, envId)
+                .eq(EnvironmentSessionEntity::getWorkspaceId, workspaceId)
+                .eq(EnvironmentSessionEntity::getStatus, 1));
+
+        if (T.CollectionUtil.isNotEmpty(sessionEntityList)) {
+            throw new ASWException(RCode.ENVIRONMENT_USED);
+        }
+        boolean isFree = this.checkEnvironmentStatus(envId);
+        if (!isFree) {
+            throw new ASWException(RCode.ENVIRONMENT_STATUS_ERROR);
+        }
+        EnvironmentSessionEntity session = new EnvironmentSessionEntity();
+        session.setEnvId(envId);
+        session.setWorkspaceId(workspaceId);
+        session.setStatus(1);
+        session.setStartTimestamp(System.currentTimeMillis());
+        session.setUserId(StpUtil.getLoginIdAsString());
+
+        this.save(session);
+        return session;
+    }
+
+    private boolean checkEnvironmentStatus(String envId) {
+        boolean isFree = true;
+        EnvironmentEntity environment = environmentService.getById(envId);
+        if (T.ObjectUtil.isNull(environment)) {
+            throw new ASWException(RCode.ENVIRONMENT_NOT_EXIST);
+        }
+        if (environment.getStatus() != 1){
+            isFree = false;
+        }
+        String resultJsonStr = T.StrUtil.EMPTY_JSON;
+        try {
+            resultJsonStr = EnvironmentUtil.requestGet(environment, Constants.ENV_API_STATUS_PATH, null, String.class);
+        }catch (Exception e){
+            log.error(e, "CheckEnvironmentStatus. request environment status api error environment: {}]", T.JSONUtil.toJsonStr(environment));
+            isFree = false;
+        }
+        log.info("CheckEnvironmentStatus. environment status api result: {}", resultJsonStr);
+
+        Map resultObj = T.JSONUtil.toBean(resultJsonStr, Map.class);
+        if (T.BooleanUtil.or(
+                T.MapUtil.isEmpty(resultObj),
+                T.ObjectUtil.notEqual(RCode.SUCCESS.getCode(), resultObj.get("code")))) {
+            isFree = false;
+        } else {
+            Map data = T.MapUtil.get(resultObj, "data", Map.class);
+            String status = T.MapUtil.getStr(data, "status");
+            if (!T.StrUtil.equalsIgnoreCase(status, "online")){
+                isFree = false;
+            }
+        }
+        return isFree;
+    }
+
+    @Override
+    public List<EnvironmentSessionEntity> queryListByUsed() {
+        List<EnvironmentSessionEntity> sessionEntityList = this.getBaseMapper().queryListByUsed();
+        return sessionEntityList;
+    }
+}

src/main/java/net/geedge/asw/module/environment/service/impl/EnvironmentWorkspaceServiceImpl.java

@@ -0,0 +1,11 @@
+package net.geedge.asw.module.environment.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import net.geedge.asw.module.environment.dao.EnvironmentWorkspaceDao;
+import net.geedge.asw.module.environment.entity.EnvironmentWorkspaceEntity;
+import net.geedge.asw.module.environment.service.IEnvironmentWorkspaceService;
+import org.springframework.stereotype.Service;
+
+@Service
+public class EnvironmentWorkspaceServiceImpl extends ServiceImpl<EnvironmentWorkspaceDao, EnvironmentWorkspaceEntity>  implements IEnvironmentWorkspaceService {
+}

src/main/java/net/geedge/asw/module/environment/util/EnvironmentUtil.java

@@ -0,0 +1,243 @@
+package net.geedge.asw.module.environment.util;
+
+import cn.hutool.core.net.url.UrlBuilder;
+import cn.hutool.core.net.url.UrlPath;
+import cn.hutool.core.net.url.UrlQuery;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.core.util.URLUtil;
+import cn.hutool.http.Header;
+import cn.hutool.json.JSONObject;
+import cn.hutool.log.Log;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.servlet.http.Part;
+import net.geedge.asw.common.util.ASWException;
+import net.geedge.asw.common.util.Constants;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.environment.entity.EnvironmentEntity;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.io.ByteArrayResource;
+import org.springframework.http.*;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+import org.springframework.web.client.RestTemplate;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+
+@Configuration
+@SuppressWarnings("all")
+public class EnvironmentUtil {
+
+	private static Log log = Log.get();
+	private static RestTemplate restTemplate;
+
+	public static <T> T requestGet(EnvironmentEntity environment, String path, String queryString, Class<T> responseType) {
+		return request(environment, HttpMethod.GET, path, queryString, null, responseType);
+	}
+
+	public static <T> T request(EnvironmentEntity environment, HttpMethod method, String path, String queryString, Object body,
+								Class<T> responseType) {
+		JSONObject jsonObject = environment.getParamJSONObject();
+		String url = jsonObject.getStr("url");
+		String token = jsonObject.getStr("token");
+
+		String urlString = UrlBuilder.of(url)
+				.setPath(UrlPath.of(path, Charset.forName("UTF-8")))
+				.setQuery(UrlQuery.of(queryString, Charset.forName("UTF-8"), false, true))
+				.setCharset(StandardCharsets.UTF_8).toString();
+
+		HttpHeaders headers = new HttpHeaders();
+		headers.add(HttpHeaders.AUTHORIZATION,token);
+		HttpEntity httpEntity = body == null ? new HttpEntity(headers) : new HttpEntity(body, headers);
+		// 发送 请求
+		return request(urlString, method, token, body, responseType);
+	}
+
+	public static <T> T request(String url, HttpMethod method, String token, Object body, Class<T> responseType) {
+		HttpHeaders headers = new HttpHeaders();
+		headers.add(HttpHeaders.AUTHORIZATION, token);
+		HttpEntity httpEntity = body == null ? new HttpEntity(headers) : new HttpEntity(body, headers);
+		// 发送 请求
+		ResponseEntity<T> exchange = null;
+		try {
+			exchange = restTemplate.exchange(new URI(url), method, httpEntity, responseType);
+		} catch (URISyntaxException e) {
+			log.error(e);
+		}
+		return exchange.getBody();
+	}
+
+	public static <T> T requestGet(String url, String token, Class<T> responseType) {
+		HttpHeaders headers = new HttpHeaders();
+		headers.add(HttpHeaders.AUTHORIZATION, token);
+		HttpEntity httpEntity = new HttpEntity(headers);
+		// 发送 请求
+		ResponseEntity<T> exchange = restTemplate.exchange(url, HttpMethod.GET, httpEntity, responseType);
+		return exchange.getBody();
+	}
+
+	/**
+	 * agent stop tcpdump
+	 * @param environment
+	 * @param params
+	 * @return
+	 * @throws IOException
+	 * @throws ServletException
+	 */
+	public static ResponseEntity<byte[]> stopTcpdump(EnvironmentEntity environment, Map params) throws IOException, ServletException {
+		JSONObject jsonObject = environment.getParamJSONObject();
+		String url = jsonObject.getStr("url");
+		String token = jsonObject.getStr("token");
+
+		String urlStr = UrlBuilder.of(url)
+				.setPath(UrlPath.of(Constants.ENV_API_TCPDUMP_PATH, Charset.forName("UTF-8")))
+				.setQuery(UrlQuery.of(params))
+				.setCharset(StandardCharsets.UTF_8).toString();
+		// token
+		HttpHeaders headers = new HttpHeaders();
+		headers.add(HttpHeaders.AUTHORIZATION, token);
+		HttpEntity httpEntity = new HttpEntity(headers);
+		ResponseEntity<byte[]> responseEntity = null;
+		try {
+			responseEntity = restTemplate.exchange(new URI(urlStr), HttpMethod.DELETE, httpEntity, byte[].class);
+		} catch (Exception e) {
+			log.error(e, "stop tcpdump request error. url:{}", urlStr);
+			String message = e.getMessage();
+			if (ObjectUtil.isNotNull(e.getCause())) {
+				message = e.getCause().getMessage();
+			}
+			throw new ASWException(message, HttpStatus.INTERNAL_SERVER_ERROR.value());
+		}
+		int statusCode = responseEntity.getStatusCodeValue();
+		log.info("stop tcpdump request url:{}, responseStatus:{}", urlStr, statusCode);
+		return responseEntity;
+	}
+
+	/**
+	 * env api agent
+	 * @param device
+	 * @param request
+	 * @param response
+	 * @param sessionId
+	 * @throws IOException
+	 * @throws ServletException
+	 */
+	public static void getForObject(EnvironmentEntity device, HttpServletRequest request, HttpServletResponse response, String sessionId) throws IOException, ServletException {
+		// path
+		String[] paths = request.getServletPath().split(sessionId);
+		String path = Arrays.asList(paths).getLast();
+		path = path.startsWith("/") ? (String.format("%s%s", Constants.ENV_API_PREFIX, path))
+				: (String.format("%s/%s", Constants.ENV_API_PREFIX, path));
+
+		// host port token
+		JSONObject jsonObject = device.getParamJSONObject();
+		String url = jsonObject.getStr("url");
+		String token = jsonObject.getStr("token");
+
+		// query param
+		String queryString = request.getQueryString();
+		queryString = StrUtil.isNotBlank(queryString) ? queryString : "";
+		queryString = URLUtil.decode(queryString);
+
+
+		String urlStr = UrlBuilder.of(url)
+				.setPath(UrlPath.of(path, Charset.forName("UTF-8")))
+				.setQuery(UrlQuery.of(queryString, Charset.forName("UTF-8"), false, true))
+				.setCharset(StandardCharsets.UTF_8).toString();
+
+		// token
+		HttpHeaders headers = new HttpHeaders();
+		Enumeration<String> headerNames = request.getHeaderNames();
+		while (headerNames.hasMoreElements()) {
+			String hn = headerNames.nextElement();
+			if (Constants.AUTH_TOKEN_CODE.equalsIgnoreCase(hn)) {
+				continue;
+			}
+			headers.add(hn, request.getHeader(hn));
+		}
+		headers.add(HttpHeaders.AUTHORIZATION, token);
+
+		// body
+		byte[] body = T.IoUtil.readBytes(request.getInputStream());
+		HttpEntity httpEntity = new HttpEntity(body, headers);
+
+		// from-data
+		if (request.getContentType() != null &&
+				request.getContentType().startsWith("multipart")) {
+			// 获取表单中的文件和参数
+			Collection<Part> parts = request.getParts();
+			// from 表单文件
+			MultiValueMap<String, Object> form = new LinkedMultiValueMap<>();
+			for (Part part : parts) {
+				String partName = part.getName();
+				if (part.getSubmittedFileName() != null) {
+					ByteArrayResource resource = new ByteArrayResource(part.getInputStream().readAllBytes()) {
+						@Override
+						public String getFilename() {
+							return part.getSubmittedFileName();
+						}
+					};
+					form.add(partName, resource);
+				} else {
+					form.add(partName, part.getInputStream().readAllBytes());
+				}
+				httpEntity = new HttpEntity(form, headers);
+			}
+		}
+
+		ResponseEntity<byte[]> responseEntity = null;
+		try {
+			responseEntity = restTemplate.exchange(new URI(urlStr), HttpMethod.valueOf(request.getMethod()), httpEntity, byte[].class);
+		} catch (Exception e) {
+			log.error(e, "env request error. url:{}", urlStr);
+			String message = e.getMessage();
+			if (ObjectUtil.isNotNull(e.getCause())) {
+				message = e.getCause().getMessage();
+			}
+			throw new ASWException(message, HttpStatus.INTERNAL_SERVER_ERROR.value());
+		}
+		log.info("env request url:{}, responseStatus:{}", urlStr, responseEntity.getStatusCode());
+		writeResponseWithHeaders(response, responseEntity);
+	}
+
+	public static void writeResponseWithHeaders(HttpServletResponse response, ResponseEntity<byte[]> responseEntity) throws IOException {
+		HttpHeaders httpHeaders = responseEntity.getHeaders();
+		int statusCode = responseEntity.getStatusCodeValue();
+		byte[] responseBody = responseEntity.getBody();
+		response.reset();
+		response.setStatus(statusCode);
+		Set<Map.Entry<String, List<String>>> entrySet = httpHeaders.entrySet();
+		// 设置 cors 响应头
+		Constants.CORS_HEADER.forEach((k, v) -> {
+			response.setHeader(k, v);
+		});
+		for (Map.Entry<String, List<String>> en : entrySet) {
+			String name = en.getKey();
+			List<String> value = en.getValue();
+			if (en.getKey().equalsIgnoreCase(Header.CONTENT_LENGTH.getValue())) {
+				continue;
+			}
+			if (en.getKey().equalsIgnoreCase(Header.TRANSFER_ENCODING.getValue())) {
+				continue;
+			}
+			response.setHeader(name, T.StrUtil.join(",", value.toArray()));
+		}
+		response.setContentLength(T.ArrayUtil.length(responseBody));
+		response.getOutputStream().write(responseBody);
+		response.flushBuffer();
+	}
+
+	@Autowired
+	public void setRestTemplate(RestTemplate restTemplate) {
+		EnvironmentUtil.restTemplate = restTemplate;
+	}
+
+}

src/main/java/net/geedge/asw/module/feign/FeignClientConfiguration.java

@@ -0,0 +1,99 @@
+package net.geedge.asw.module.feign;
+
+import cn.hutool.core.net.url.UrlBuilder;
+import cn.hutool.log.Log;
+import feign.Feign;
+import feign.form.FormEncoder;
+import net.geedge.asw.module.feign.client.*;
+import net.geedge.asw.module.feign.support.Fastjson2Decoder;
+import net.geedge.asw.module.feign.support.Fastjson2Encoder;
+import net.geedge.asw.module.feign.support.Http2Client;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class FeignClientConfiguration {
+
+    private static final Log log = Log.get();
+
+    @Value("${zeek.url:127.0.0.1:8086}")
+    private String zeekUrl;
+
+    @Value("${geoip.url:127.0.0.1:8087}")
+    private String geoipUrl;
+
+    @Value("${kibana.url:127.0.0.1:5601}")
+    private String kibanaUrl;
+
+    @Value("${webShark.url:127.0.0.1:8085}")
+    private String websharkurl;
+
+    @Value("${pcapComment.url:127.0.0.1:5000}")
+    private String pcapCommentUrl;
+
+    @Bean("zeekClient")
+    public ZeekClient zeekClient() {
+        String url = UrlBuilder.ofHttp(zeekUrl).toString();
+        log.info("[zeekClient] [url: {}]", url);
+        return Feign.builder()
+                .encoder(new FormEncoder())
+                .decoder(new Fastjson2Decoder())
+                .client(new Http2Client())
+                .target(ZeekClient.class, url);
+    }
+
+    @Bean("geoipClient")
+    public GeoipClient geoipClient() {
+        String url = UrlBuilder.ofHttp(geoipUrl).toString();
+        log.info("[geoipClient] [url: {}]", url);
+        return Feign.builder()
+                .encoder(new Fastjson2Encoder())
+                .decoder(new Fastjson2Decoder())
+                .client(new Http2Client())
+                .target(GeoipClient.class, url);
+    }
+
+    @Bean("kibanaClient")
+    public KibanaClient kibanaClient() {
+        String url = UrlBuilder.ofHttp(kibanaUrl).toString();
+        log.info("[kibanaClient] [url: {}]", url);
+        return Feign.builder()
+                .encoder(new Fastjson2Encoder())
+                .decoder(new Fastjson2Decoder())
+                .client(new Http2Client())
+                .target(KibanaClient.class, url);
+    }
+
+    @Bean("webSharkClient")
+    public WebSharkClient webSharkClient() {
+        String url = UrlBuilder.ofHttp(websharkurl).toString();
+        log.info("[webSharkClient] [url: {}]", url);
+        return Feign.builder()
+                .encoder(new FormEncoder())
+                .client(new Http2Client())
+                .target(WebSharkClient.class, url);
+    }
+
+    @Bean("pcapCommentClient")
+    public PcapCommentClient pcapCommentClient() {
+        String url = UrlBuilder.ofHttp(pcapCommentUrl).toString();
+        log.info("[pcapCommentClient] [url: {}]", url);
+        return Feign.builder()
+                .encoder(new FormEncoder())
+                .client(new Http2Client())
+                .target(PcapCommentClient.class, url);
+    }
+
+    @Bean("dashboardClient")
+    public DashboardClient dashboardClient() {
+        String url = UrlBuilder.ofHttp(kibanaUrl).toString();
+        log.info("[kibanaClient] [url: {}]", url);
+        return Feign.builder()
+                .encoder(new FormEncoder())
+                .decoder(new Fastjson2Decoder())
+                .client(new Http2Client())
+                .target(DashboardClient.class, url);
+    }
+
+}

src/main/java/net/geedge/asw/module/feign/OpenSearchClientConfiguration.java

@@ -0,0 +1,88 @@
+package net.geedge.asw.module.feign;
+
+import cn.hutool.log.Log;
+import net.geedge.asw.common.util.T;
+import org.apache.http.HttpHost;
+import org.apache.http.auth.AuthScope;
+import org.apache.http.auth.UsernamePasswordCredentials;
+import org.apache.http.conn.ssl.NoopHostnameVerifier;
+import org.apache.http.impl.client.BasicCredentialsProvider;
+import org.apache.http.impl.nio.reactor.IOReactorConfig;
+import org.apache.http.ssl.SSLContextBuilder;
+import org.opensearch.client.RestClient;
+import org.opensearch.client.RestClientBuilder;
+import org.opensearch.client.json.jackson.JacksonJsonpMapper;
+import org.opensearch.client.opensearch.OpenSearchClient;
+import org.opensearch.client.opensearch.core.InfoResponse;
+import org.opensearch.client.transport.OpenSearchTransport;
+import org.opensearch.client.transport.rest_client.RestClientTransport;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.stereotype.Component;
+
+import javax.net.ssl.SSLContext;
+import java.io.IOException;
+import java.security.KeyManagementException;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+
+@Component
+public class OpenSearchClientConfiguration {
+
+    private static final Log log = Log.get();
+
+    @Value("${opensearch.url:127.0.0.1:7200}")
+    private String hostAndPort;
+
+    @Value("${opensearch.username:admin}")
+    private String username;
+
+    @Value("${opensearch.password:G1egG2U4NrjHRzV}")
+    private String password;
+
+    @Bean("openSearchClient")
+    public OpenSearchClient openSearchClient() {
+        try {
+            if (T.StrUtil.hasEmpty(this.hostAndPort, this.username, this.password)) {
+                throw new IllegalArgumentException("OpenSearchClient init info cannot be empty.");
+            }
+
+            BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
+            credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(username, password));
+
+            // Setup SSL context to trust all certificates
+            SSLContext sslContext = SSLContextBuilder.create()
+                    .loadTrustMaterial((chain, authType) -> true)
+                    .build();
+
+            String[] split = this.hostAndPort.split(":");
+            String host = split[0];
+            Integer port = Integer.valueOf(split[1]);
+            SSLContext finalSslContext = sslContext;
+            RestClientBuilder builder = RestClient.builder(
+                            new HttpHost(host, port, "https"))
+                    .setHttpClientConfigCallback(httpAsyncClientBuilder -> {
+                        httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider)
+                                .setSSLContext(finalSslContext)
+                                .setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
+                                .setDefaultIOReactorConfig(
+                                        IOReactorConfig.custom()
+                                                .setIoThreadCount(1)
+                                                .build()
+                                );
+                        return httpAsyncClientBuilder;
+                    });
+
+            RestClient restClient = builder.build();
+            OpenSearchTransport transport = new RestClientTransport(restClient, new JacksonJsonpMapper());
+            OpenSearchClient client = new OpenSearchClient(transport);
+
+            InfoResponse info = client.info();
+            log.info("[openSearchClient] [url: {}] [{}]", this.hostAndPort, info.version().distribution() + ": " + info.version().number());
+            return client;
+        } catch (NoSuchAlgorithmException | KeyManagementException | KeyStoreException | IOException e) {
+            log.error("[openSearchClient] [error] [url: {}]", this.hostAndPort);
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/net/geedge/asw/module/feign/client/DashboardClient.java

@@ -0,0 +1,22 @@
+package net.geedge.asw.module.feign.client;
+
+import com.alibaba.fastjson2.JSONObject;
+import feign.Headers;
+import feign.Param;
+import feign.RequestLine;
+import org.springframework.cloud.openfeign.FeignClient;
+
+import java.io.File;
+
+@FeignClient(name = "dashboardClient")
+@Headers("Authorization: Bearer {token}")
+public interface DashboardClient {
+
+    @Headers({
+            "Content-Type: multipart/form-data",
+            "osd-xsrf: true",
+            "kbn-xsrf: true"
+    })
+    @RequestLine("POST /api/saved_objects/_import?createNewCopies={createNewCopies}")
+    JSONObject importDashboard(@Param("token") String token, @Param("file") File file, @Param("createNewCopies") boolean createNewCopies);
+}

src/main/java/net/geedge/asw/module/feign/client/GeoipClient.java

@@ -0,0 +1,14 @@
+package net.geedge.asw.module.feign.client;
+
+import com.alibaba.fastjson2.JSONArray;
+import feign.Param;
+import feign.RequestLine;
+import org.springframework.cloud.openfeign.FeignClient;
+
+@FeignClient(name = "geoipClient")
+public interface GeoipClient {
+
+    @RequestLine("GET /geoip?ips={ip}")
+    JSONArray geoip(@Param("ip") String ipAddress);
+
+}

src/main/java/net/geedge/asw/module/feign/client/KibanaClient.java

@@ -0,0 +1,30 @@
+package net.geedge.asw.module.feign.client;
+
+import com.alibaba.fastjson2.JSONObject;
+import feign.Headers;
+import feign.Param;
+import feign.RequestLine;
+import org.springframework.cloud.openfeign.FeignClient;
+
+@FeignClient(name = "kibanaClient")
+@Headers("Authorization: Bearer {token}")
+public interface KibanaClient {
+
+    @RequestLine("GET /api/saved_objects/_find?fields=title&per_page=10000&type={type}&search_fields=title&search={name}")
+    JSONObject findIndexPattern(@Param("token") String token, @Param("type") String type , @Param("name") String name);
+
+    @Headers({
+            "Content-Type: application/json",
+            "osd-xsrf: true"
+    })
+    @RequestLine("POST /api/saved_objects/index-pattern/{id}")
+    JSONObject saveIndexPattern(@Param("token") String token, @Param("id") String id, JSONObject body);
+
+    @Headers({
+            "Content-Type: application/json",
+            "osd-xsrf: true"
+    })
+    @RequestLine("DELETE /api/saved_objects/index-pattern/{id}?force={force}")
+    JSONObject deleteIndexPattern(@Param("token") String token,  @Param("id") String id , @Param("force") boolean force);
+
+}

src/main/java/net/geedge/asw/module/feign/client/PcapCommentClient.java

@@ -0,0 +1,18 @@
+package net.geedge.asw.module.feign.client;
+
+import feign.Headers;
+import feign.Param;
+import feign.RequestLine;
+import feign.Response;
+import org.springframework.cloud.openfeign.FeignClient;
+
+import java.io.File;
+
+@FeignClient(name = "pcapCommentClient")
+public interface PcapCommentClient {
+
+    @RequestLine("POST /api/v1/pcap/comment")
+    @Headers("Content-Type: multipart/form-data")
+    Response addCommon(@Param("file") File file, @Param("url") String url, @Param("id") String pcapId);
+
+}

src/main/java/net/geedge/asw/module/feign/client/WebSharkClient.java

@@ -0,0 +1,18 @@
+package net.geedge.asw.module.feign.client;
+
+import feign.Headers;
+import feign.Param;
+import feign.RequestLine;
+import feign.Response;
+import org.springframework.cloud.openfeign.FeignClient;
+
+import java.io.File;
+import java.util.Map;
+
+@FeignClient(name = "webSharkClient")
+public interface WebSharkClient {
+
+    @RequestLine("POST /webshark/upload")
+    @Headers("Content-Type: multipart/form-data")
+    Response upload(@Param("fileKey") File file);
+}

src/main/java/net/geedge/asw/module/feign/client/ZeekClient.java

@@ -0,0 +1,18 @@
+package net.geedge.asw.module.feign.client;
+
+import com.alibaba.fastjson2.JSONArray;
+import feign.Headers;
+import feign.Param;
+import feign.RequestLine;
+import org.springframework.cloud.openfeign.FeignClient;
+
+import java.io.File;
+
+@FeignClient(name = "zeekClient")
+public interface ZeekClient {
+
+    @RequestLine("POST /upload")
+    @Headers("Content-Type: multipart/form-data")
+    JSONArray parser(@Param("pcap") File file);
+
+}

src/main/java/net/geedge/asw/module/feign/support/Fastjson2Decoder.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2012-2024 The Feign Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.geedge.asw.module.feign.support;
+
+import com.alibaba.fastjson2.JSON;
+import com.alibaba.fastjson2.JSONException;
+import com.alibaba.fastjson2.JSONReader;
+import feign.FeignException;
+import feign.Response;
+import feign.Util;
+import feign.codec.Decoder;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.lang.reflect.Type;
+
+import static feign.Util.ensureClosed;
+
+/**
+ * @author changjin wei(魏昌进)
+ */
+public class Fastjson2Decoder implements Decoder {
+
+    private final JSONReader.Feature[] features;
+
+    public Fastjson2Decoder() {
+        this(new JSONReader.Feature[0]);
+    }
+
+    public Fastjson2Decoder(JSONReader.Feature[] features) {
+        this.features = features;
+    }
+
+    @Override
+    public Object decode(Response response, Type type) throws IOException, FeignException {
+        if (response.status() == 404 || response.status() == 204) return Util.emptyValueOf(type);
+        if (response.body() == null) return null;
+        Reader reader = response.body().asReader(response.charset());
+        try {
+            return JSON.parseObject(reader, type, features);
+        } catch (JSONException e) {
+            if (e.getCause() != null && e.getCause() instanceof IOException) {
+                throw IOException.class.cast(e.getCause());
+            }
+            throw e;
+        } finally {
+            ensureClosed(reader);
+        }
+    }
+}

src/main/java/net/geedge/asw/module/feign/support/Fastjson2Encoder.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2012-2024 The Feign Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.geedge.asw.module.feign.support;
+
+import com.alibaba.fastjson2.JSON;
+import com.alibaba.fastjson2.JSONWriter;
+import feign.RequestTemplate;
+import feign.Util;
+import feign.codec.EncodeException;
+import feign.codec.Encoder;
+
+import java.lang.reflect.Type;
+
+/**
+ * @author changjin wei(魏昌进)
+ */
+public class Fastjson2Encoder implements Encoder {
+
+    private final JSONWriter.Feature[] features;
+
+    public Fastjson2Encoder() {
+        this(new JSONWriter.Feature[0]);
+    }
+
+    public Fastjson2Encoder(JSONWriter.Feature[] features) {
+        this.features = features;
+    }
+
+    @Override
+    public void encode(Object object, Type bodyType, RequestTemplate template) throws EncodeException {
+        template.body(JSON.toJSONBytes(object, features), Util.UTF_8);
+    }
+}

src/main/java/net/geedge/asw/module/feign/support/Http2Client.java

@@ -0,0 +1,254 @@
+/*
+ * Copyright 2012-2024 The Feign Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.geedge.asw.module.feign.support;
+
+import feign.*;
+import feign.Request.Options;
+import feign.Request.ProtocolVersion;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.ref.SoftReference;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpClient.Redirect;
+import java.net.http.HttpClient.Version;
+import java.net.http.HttpRequest;
+import java.net.http.HttpRequest.BodyPublisher;
+import java.net.http.HttpRequest.BodyPublishers;
+import java.net.http.HttpRequest.Builder;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+import java.time.Duration;
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static feign.Util.enumForName;
+
+public class Http2Client implements Client, AsyncClient<Object> {
+
+    private final HttpClient client;
+
+    private final Map<Integer, SoftReference<HttpClient>> clients = new ConcurrentHashMap<>();
+
+    /**
+     * Creates the new Http2Client using following defaults:
+     * <ul>
+     * <li>Connect Timeout: 10 seconds, as {@link Request.Options#Options()} uses</li>
+     * <li>Follow all 3xx redirects</li>
+     * <li>HTTP 2</li>
+     * </ul>
+     *
+     * @see Request.Options#Options()
+     */
+    public Http2Client() {
+        this(HttpClient.newBuilder()
+                .followRedirects(Redirect.ALWAYS)
+                .version(Version.HTTP_2)
+                .connectTimeout(Duration.ofMillis(10000))
+                .build());
+    }
+
+    public Http2Client(Options options) {
+        this(newClientBuilder(options)
+                .version(Version.HTTP_2)
+                .build());
+    }
+
+    public Http2Client(HttpClient client) {
+        this.client = Util.checkNotNull(client, "HttpClient must not be null");
+    }
+
+    @Override
+    public Response execute(Request request, Options options) throws IOException {
+        final HttpRequest httpRequest;
+        try {
+            httpRequest = newRequestBuilder(request, options)
+                    .version(client.version())
+                    .build();
+        } catch (URISyntaxException e) {
+            throw new IOException("Invalid uri " + request.url(), e);
+        }
+
+        HttpClient clientForRequest = getOrCreateClient(options);
+        HttpResponse<InputStream> httpResponse;
+        try {
+            httpResponse = clientForRequest.send(httpRequest, BodyHandlers.ofInputStream());
+        } catch (final InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new IOException(e);
+        }
+
+        return toFeignResponse(request, httpResponse);
+    }
+
+    @Override
+    public CompletableFuture<Response> execute(Request request,
+                                               Options options,
+                                               Optional<Object> requestContext) {
+        HttpRequest httpRequest;
+        try {
+            httpRequest = newRequestBuilder(request, options).build();
+        } catch (URISyntaxException e) {
+            throw new IllegalArgumentException("Invalid uri " + request.url(), e);
+        }
+
+        HttpClient clientForRequest = getOrCreateClient(options);
+        CompletableFuture<HttpResponse<InputStream>> future =
+                clientForRequest.sendAsync(httpRequest, HttpResponse.BodyHandlers.ofInputStream());
+        return future.thenApply(httpResponse -> toFeignResponse(request, httpResponse));
+    }
+
+    protected Response toFeignResponse(Request request, HttpResponse<InputStream> httpResponse) {
+        final OptionalLong length = httpResponse.headers().firstValueAsLong("Content-Length");
+
+        return Response.builder()
+                .protocolVersion(enumForName(ProtocolVersion.class, httpResponse.version()))
+                .body(httpResponse.body(), length.isPresent() ? (int) length.getAsLong() : null)
+                .reason(httpResponse.headers().firstValue("Reason-Phrase").orElse(null))
+                .request(request)
+                .status(httpResponse.statusCode())
+                .headers(castMapCollectType(httpResponse.headers().map()))
+                .build();
+    }
+
+    private HttpClient getOrCreateClient(Options options) {
+        if (doesClientConfigurationDiffer(options)) {
+            // create a new client from the existing one - but with connectTimeout and followRedirect
+            // settings from options
+            final int clientKey = createClientKey(options);
+
+            SoftReference<HttpClient> requestScopedSoftReference = clients.get(clientKey);
+            HttpClient requestScoped =
+                    requestScopedSoftReference == null ? null : requestScopedSoftReference.get();
+
+            if (requestScoped == null) {
+                java.net.http.HttpClient.Builder builder = newClientBuilder(options)
+                        .sslContext(client.sslContext())
+                        .sslParameters(client.sslParameters())
+                        .version(client.version());
+                client.authenticator().ifPresent(builder::authenticator);
+                client.cookieHandler().ifPresent(builder::cookieHandler);
+                client.executor().ifPresent(builder::executor);
+                client.proxy().ifPresent(builder::proxy);
+                requestScoped = builder.build();
+                clients.put(clientKey, new SoftReference<>(requestScoped));
+            }
+            return requestScoped;
+        }
+        return client;
+    }
+
+    private boolean doesClientConfigurationDiffer(Options options) {
+        if ((client.followRedirects() == Redirect.ALWAYS) != options.isFollowRedirects()) {
+            return true;
+        }
+        return client.connectTimeout()
+                .map(timeout -> timeout.toMillis() != options.connectTimeoutMillis())
+                .orElse(true);
+    }
+
+    /**
+     * Creates integer key that represents {@link Options} settings based on
+     * {@link Http2Client#doesClientConfigurationDiffer(Options)} method
+     *
+     * @param options value
+     * @return integer key
+     */
+    public int createClientKey(feign.Request.Options options) {
+        int key = options.connectTimeoutMillis();
+        if (options.isFollowRedirects()) {
+            key |= 1 << 31; // connectTimeoutMillis always positive, so we can use first sign bit for
+            // isFollowRedirects flag
+        }
+        return key;
+    }
+
+    private static java.net.http.HttpClient.Builder newClientBuilder(Options options) {
+        return HttpClient
+                .newBuilder()
+                .followRedirects(options.isFollowRedirects() ? Redirect.ALWAYS : Redirect.NEVER)
+                .connectTimeout(Duration.ofMillis(options.connectTimeoutMillis()));
+    }
+
+    private Builder newRequestBuilder(Request request, Options options) throws URISyntaxException {
+        URI uri = new URI(request.url());
+
+        final BodyPublisher body;
+        final byte[] data = request.body();
+        if (data == null) {
+            body = BodyPublishers.noBody();
+        } else {
+            body = BodyPublishers.ofByteArray(data);
+        }
+
+        final Builder requestBuilder = HttpRequest.newBuilder()
+                .uri(uri)
+                .timeout(Duration.ofMillis(options.readTimeoutMillis()))
+                .version(client.version());
+
+        final Map<String, Collection<String>> headers = filterRestrictedHeaders(request.headers());
+        if (!headers.isEmpty()) {
+            requestBuilder.headers(asString(headers));
+        }
+
+        return requestBuilder.method(request.httpMethod().toString(), body);
+    }
+
+    /**
+     * There is a bunch o headers that the http2 client do not allow to be set.
+     *
+     * @see jdk.internal.net.http.common.Utils.DISALLOWED_HEADERS_SET
+     */
+    private static final Set<String> DISALLOWED_HEADERS_SET;
+
+    static {
+        // A case insensitive TreeSet of strings.
+        final TreeSet<String> treeSet = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
+        treeSet.addAll(Set.of("connection", "content-length", "expect", "host", "upgrade"));
+        DISALLOWED_HEADERS_SET = Collections.unmodifiableSet(treeSet);
+    }
+
+    private Map<String, Collection<String>> filterRestrictedHeaders(Map<String, Collection<String>> headers) {
+        final Map<String, Collection<String>> filteredHeaders = headers.keySet()
+                .stream()
+                .filter(headerName -> !DISALLOWED_HEADERS_SET.contains(headerName))
+                .collect(Collectors.toMap(
+                        Function.identity(),
+                        headers::get));
+
+        filteredHeaders.computeIfAbsent("Accept", key -> List.of("*/*"));
+
+        return filteredHeaders;
+    }
+
+    private Map<String, Collection<String>> castMapCollectType(Map<String, List<String>> map) {
+        final Map<String, Collection<String>> result = new HashMap<>();
+        map.forEach((key, value) -> result.put(key, new HashSet<>(value)));
+        return result;
+    }
+
+    private String[] asString(Map<String, Collection<String>> headers) {
+        return headers.entrySet().stream()
+                .flatMap(entry -> entry.getValue()
+                        .stream()
+                        .map(value -> Arrays.asList(entry.getKey(), value))
+                        .flatMap(List::stream))
+                .toArray(String[]::new);
+    }
+}

src/main/java/net/geedge/asw/module/runner/controller/JobController.java

@@ -0,0 +1,80 @@
+package net.geedge.asw.module.runner.controller;
+
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import net.geedge.asw.common.util.R;
+import net.geedge.asw.common.util.RCode;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.runner.entity.JobEntity;
+import net.geedge.asw.module.runner.service.IJobService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/v1/workspace")
+public class JobController {
+
+    @Autowired
+    private IJobService jobService;
+
+    @GetMapping("/{workspaceId}/job/{id}")
+    public R detail(@PathVariable("workspaceId") String workspaceId,
+                    @PathVariable("id") String id) {
+        JobEntity jobEntity = jobService.queryInfo(id);
+        return R.ok().putData("record", jobEntity);
+    }
+
+    @GetMapping("/{workspaceId}/job")
+    public R list(@PathVariable("workspaceId") String workspaceId,
+                  @RequestParam Map<String, Object> params) {
+        T.VerifyUtil.is(params).notNull()
+                .and(workspaceId).notEmpty(RCode.WORKSPACE_ID_CANNOT_EMPTY);
+        params.put("workspaceId", workspaceId);
+        Page page = jobService.queryList(params);
+        return R.ok(page);
+    }
+
+    @PostMapping("/{workspaceId}/job")
+    public R add(@PathVariable("workspaceId") String workspaceId,
+                 @RequestBody JobEntity entity) {
+        T.VerifyUtil.is(entity).notNull()
+                .and(entity.getEnvironmentId()).notEmpty(RCode.ENVIRONMENT_ID_CANNOT_EMPTY)
+                .and(entity.getPackageId()).notEmpty(RCode.PACKAGE_ID_CANNOT_EMPTY)
+                .and(entity.getPlaybookId()).notEmpty(RCode.PLAYBOOK_ID_CANNOT_EMPTY)
+                .and(entity.getWorkspaceId()).notEmpty(RCode.WORKSPACE_ID_CANNOT_EMPTY);
+
+        entity.setEnvId(entity.getEnvironmentId());
+
+        JobEntity jobEntity = jobService.saveJob(entity);
+        return R.ok().putData("id", jobEntity.getId());
+    }
+
+    @DeleteMapping("/{workspaceId}/job")
+    public R delete(@PathVariable("workspaceId") String workspaceId,
+                    @RequestParam String ids) {
+        T.VerifyUtil.is(ids).notEmpty();
+        List<String> idList = Arrays.asList(ids.split(","));
+        jobService.removeJob(idList);
+        return R.ok();
+    }
+
+    @PutMapping("/{workspaceId}/job/cancel")
+    public R cancel(@PathVariable("workspaceId") String workspaceId,
+                    @RequestParam String ids) {
+        T.VerifyUtil.is(ids).notEmpty();
+        List<String> idList = Arrays.asList(ids.split(","));
+        // TODO 其他处理
+
+        // update state
+        jobService.update(new LambdaUpdateWrapper<JobEntity>()
+                .in(JobEntity::getId, idList)
+                .set(JobEntity::getStatus, "cancel")
+        );
+        return R.ok();
+    }
+
+}

src/main/java/net/geedge/asw/module/runner/controller/PcapController.java

@@ -0,0 +1,202 @@
+package net.geedge.asw.module.runner.controller;
+
+import cn.hutool.core.date.DatePattern;
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.core.net.url.UrlBuilder;
+import cn.hutool.log.Log;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import feign.Response;
+import jakarta.servlet.http.HttpServletResponse;
+import net.geedge.asw.common.config.SpringContextUtils;
+import net.geedge.asw.common.util.*;
+import net.geedge.asw.module.feign.client.WebSharkClient;
+import net.geedge.asw.module.runner.entity.PcapEntity;
+import net.geedge.asw.module.runner.service.IPcapService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/api/v1/pcap")
+public class PcapController {
+
+    private static final Log log = Log.get();
+
+    @Autowired
+    private IPcapService pcapService;
+
+    @Value("${webShark.url:127.0.0.1:8085}")
+    private String websharkurl;
+
+    @GetMapping("/{id}")
+    public R detail(@PathVariable("id") String id) {
+        PcapEntity pcapEntity = pcapService.queryInfo(id);
+        return R.ok().putData("record", pcapEntity);
+    }
+
+    @GetMapping
+    public R list(@RequestParam Map<String, Object> params) {
+        T.VerifyUtil.is(params).notNull()
+                .and(T.MapUtil.getStr(params, "workspaceId")).notEmpty(RCode.WORKSPACE_ID_CANNOT_EMPTY);
+
+        Page page = pcapService.queryList(params);
+        return R.ok(page);
+    }
+
+    @PostMapping
+    @Transactional(rollbackFor = Exception.class)
+    public R add(@RequestParam(value = "files", required = true) List<MultipartFile> fileList,
+                 @RequestParam(value = "descriptions", required = false) List<String> descriptionList,
+                 @RequestParam(required = false) String workspaceId) throws IOException {
+        T.VerifyUtil.is(workspaceId).notEmpty(RCode.WORKSPACE_ID_CANNOT_EMPTY);
+
+        List<Object> recordList = T.ListUtil.list(true);
+        for (int i = 0; i < fileList.size(); i++) {
+            MultipartFile file = fileList.get(i);
+            String description = T.StrUtil.emptyToDefault(T.CollUtil.get(descriptionList, i), "");
+            PcapEntity pcapEntity = pcapService.savePcap(file.getResource(), description, workspaceId);
+            recordList.add(
+                    T.MapUtil.builder()
+                            .put("id", pcapEntity.getId())
+                            .build()
+            );
+        }
+        return R.ok().putData("records", recordList);
+    }
+
+    @PutMapping
+    @Transactional(rollbackFor = Exception.class)
+    public R update(@RequestBody List<Map<String, String>> body) {
+        List<Object> recordList = T.ListUtil.list(true);
+        for (Map<String, String> map : body) {
+            String id = T.MapUtil.getStr(map, "id", "");
+            if (T.StrUtil.isEmpty(id)) {
+                continue;
+            }
+            String description = T.MapUtil.getStr(map, "description", "");
+            pcapService.update(new LambdaUpdateWrapper<PcapEntity>()
+                    .eq(PcapEntity::getId, id)
+                    .set(PcapEntity::getDescription, description)
+            );
+            recordList.add(
+                    T.MapUtil.builder()
+                            .put("id", id)
+                            .build()
+            );
+        }
+        return R.ok().putData("records", recordList);
+    }
+
+    @DeleteMapping
+    public R delete(String[] ids) {
+        T.VerifyUtil.is(ids).notEmpty();
+
+        pcapService.deletePcap(ids);
+        return R.ok();
+    }
+
+    @PutMapping("/parse2session")
+    public R parse2session(String[] ids) {
+        T.VerifyUtil.is(ids).notEmpty();
+
+        pcapService.parse2session(ids);
+
+        // records
+        List<PcapEntity> entityList = pcapService.list(new LambdaQueryWrapper<PcapEntity>().in(PcapEntity::getId, ids));
+        List<Map<String, String>> records = entityList.stream()
+                .map(entity ->
+                        Map.of(
+                                "id", entity.getId(),
+                                "name", entity.getName(),
+                                "status", entity.getStatus()
+                        )
+                )
+                .collect(Collectors.toList());
+        return R.ok().putData("records", records);
+    }
+
+
+    @GetMapping("/download")
+    public void download(HttpServletResponse response, String ids) throws IOException {
+        T.VerifyUtil.is(ids).notEmpty();
+        List<String> pcapIdList = Arrays.asList(ids.split(","));
+        List<PcapEntity> pcapList = pcapService.listByIds(pcapIdList);
+        if (T.CollectionUtil.isNotEmpty(pcapList) && pcapList.size() == 1) {
+            PcapEntity first = pcapList.getFirst();
+            File pcapFile = T.FileUtil.file(first.getPath());
+            ResponseUtil.downloadFile(response, MediaType.APPLICATION_OCTET_STREAM_VALUE, first.getName(), T.FileUtil.readBytes(pcapFile));
+        }
+        if (pcapList.size() > 1) {
+            File zipFile = T.FileUtil.file(T.StrUtil.concat(true, Constants.TEMP_PATH, "/", "pcap-", DateUtil.format(DateUtil.date(), DatePattern.PURE_DATETIME_PATTERN) + ".zip"));
+            List<File> fileList = pcapList.stream().map(x -> T.FileUtil.file(x.getPath())).toList();
+            T.ZipUtil.zip(zipFile, false, fileList.toArray(new File[0]));
+            ResponseUtil.downloadFile(response, zipFile.getName(), T.FileUtil.readBytes(zipFile));
+            T.FileUtil.del(zipFile);
+        }
+    }
+
+    @GetMapping("/{id}/webshark")
+    public R webshark(@PathVariable String id) {
+        T.VerifyUtil.is(id).notEmpty();
+
+        HashMap<Object, Object> result = T.MapUtil.newHashMap();
+        PcapEntity pcap = pcapService.getById(id);
+        File pcapFile = pcap.getCommonPcapFilePath().toFile();
+        pcapFile = FileUtil.exist(pcapFile) ? pcapFile : T.FileUtil.file(pcap.getPath());
+        String uploadFileName = T.StrUtil.concat(true, id, ".", T.FileUtil.getSuffix(pcapFile));
+        File newFile = FileUtil.copy(pcapFile, FileUtil.file(Constants.TEMP_PATH, uploadFileName), false);
+        try {
+            WebSharkClient webSharkClient = (WebSharkClient) SpringContextUtils.getBean("webSharkClient");
+            Response obj = webSharkClient.upload(newFile);
+            if (T.ObjectUtil.isNotEmpty(obj) && HttpStatus.resolve(obj.status()).is2xxSuccessful()){
+                String baseUrl = UrlBuilder.ofHttp(websharkurl)
+                        .addPath("/webshark")
+                        .toString();
+                result.put("fileName", uploadFileName);
+                result.put("url", baseUrl);
+            }
+        }catch (Exception e){
+            log.error(e, "webshark upload pcap error, id: {}", pcap.getId());
+            throw new ASWException(RCode.PCAP_UPLOAD_WEB_SHARK_ERROR);
+        }finally {
+            FileUtil.del(newFile);
+        }
+        return R.ok(result);
+    }
+
+
+    @PutMapping("/unparse2session")
+    public R unparse2session(String[] ids) {
+        T.VerifyUtil.is(ids).notEmpty();
+
+        pcapService.unparse2session(ids);
+        return R.ok();
+    }
+
+    @GetMapping("/explore")
+    public R explore(@RequestParam String workspaceId, @RequestParam String pcapIds,  @RequestParam(required = false) String protocol,  @RequestParam(required = false) String streamId) {
+        String discoverUrl = pcapService.generateKibanaDiscoverUrl(workspaceId, pcapIds, protocol, streamId);
+        return R.ok().putData("url", discoverUrl);
+    }
+
+    @GetMapping("/dashboard")
+    public R dashboard(@RequestParam String workspaceId, @RequestParam String pcapIds) {
+        String dashboardUrl = pcapService.generateKibanaDashboardUrl(workspaceId, pcapIds);
+        return R.ok().putData("url", dashboardUrl);
+    }
+}

src/main/java/net/geedge/asw/module/runner/controller/PlaybookController.java

@@ -0,0 +1,65 @@
+package net.geedge.asw.module.runner.controller;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import jakarta.servlet.http.HttpServletResponse;
+import net.geedge.asw.common.util.R;
+import net.geedge.asw.common.util.RCode;
+import net.geedge.asw.common.util.ResponseUtil;
+import net.geedge.asw.common.util.T;
+import net.geedge.asw.module.runner.entity.PlaybookEntity;
+import net.geedge.asw.module.runner.service.IPlaybookService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/v1/workspace")
+public class PlaybookController {
+
+    @Autowired
+    private IPlaybookService playbookService;
+
+    @GetMapping("/{workspaceId}/playbook/{id}")
+    public R detail(@PathVariable("workspaceId") String workspaceId, @PathVariable("id") String id) {
+        PlaybookEntity playbook = playbookService.detail(workspaceId, id);
+        return R.ok().put("record", playbook);
+    }
+
+    @GetMapping("/{workspaceId}/playbook")
+    public R list(@PathVariable("workspaceId") String workspaceId, @RequestParam Map params) {
+        Page page = playbookService.queryList(workspaceId, params);
+        return R.ok(page);
+    }
+
+    @PostMapping("/{workspaceId}/playbook")
+    public R save(@PathVariable("workspaceId") String workspaceId,
+                  @RequestParam("file") MultipartFile file,
+                  @RequestParam("name") String name,
+                  @RequestParam(value = "description", required = false) String description) {
+        PlaybookEntity playbook = playbookService.savePlaybook(workspaceId, file, name, description);
+        return R.ok().put("record", playbook);
+    }
+
+    @DeleteMapping("/{workspaceId}/playbook")
+    public R delete(@PathVariable("workspaceId") String workspaceId,
+                    @RequestParam("ids") String ids) {
+        playbookService.delete(workspaceId, ids);
+        return R.ok();
+    }
+
+    @GetMapping("/{workspaceId}/playbook/{id}/download")
+    public void download(@PathVariable("workspaceId") String workspaceId,
+                         @PathVariable("id") String id, HttpServletResponse response) throws IOException {
+
+        PlaybookEntity entity = playbookService.getById(id);
+        T.VerifyUtil.is(entity).notNull(RCode.SYS_RECORD_NOT_FOUND);
+
+        File playbookFile = T.FileUtil.file(entity.getPath());
+        ResponseUtil.downloadFile(response, MediaType.APPLICATION_OCTET_STREAM_VALUE, entity.getName(), T.FileUtil.readBytes(playbookFile));
+    }
+}

src/main/java/net/geedge/asw/module/runner/controller/RunnerController.java

@@ -0,0 +1,174 @@
+//package net.geedge.asw.module.runner.controller;
+//
+//import cn.dev33.satoken.annotation.SaIgnore;
+//import cn.hutool.core.lang.Opt;
+//import cn.hutool.log.Log;
+//import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+//import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+//import jakarta.servlet.http.HttpServletResponse;
+//import net.geedge.asw.common.util.R;
+//import net.geedge.asw.common.util.RCode;
+//import net.geedge.asw.common.util.T;
+//import net.geedge.asw.module.app.entity.PackageEntity;
+//import net.geedge.asw.module.runner.entity.JobEntity;
+//import net.geedge.asw.module.runner.entity.PlaybookEntity;
+//import net.geedge.asw.module.runner.entity.RunnerEntity;
+//import net.geedge.asw.module.runner.service.IJobService;
+//import net.geedge.asw.module.runner.service.IRunnerService;
+//import org.springframework.beans.factory.annotation.Autowired;
+//import org.springframework.web.bind.annotation.*;
+//import org.springframework.web.multipart.MultipartFile;
+//
+//import java.io.IOException;
+//import java.util.Map;
+//
+//@RestController
+//@RequestMapping("/api/v1/runner")
+//public class RunnerController {
+//
+//    private static final Log log = Log.get();
+//
+//    @Autowired
+//    private IJobService jobService;
+//
+//    @Autowired
+//    private IRunnerService runnerService;
+//
+//    @GetMapping("/{id}")
+//    public R detail(@PathVariable("id") String id) {
+//        RunnerEntity runnerEntity = runnerService.getById(id);
+//        return R.ok().putData("record", runnerEntity);
+//    }
+//
+//    @GetMapping
+//    public R list(@RequestParam Map<String, Object> params) {
+//        T.VerifyUtil.is(params).notNull()
+//                .and(T.MapUtil.getStr(params, "workspaceId")).notEmpty(RCode.WORKSPACE_ID_CANNOT_EMPTY);
+//
+//        Page page = runnerService.queryList(params);
+//        return R.ok(page);
+//    }
+//
+//    @PostMapping
+//    public R add(@RequestBody RunnerEntity entity) {
+//        T.VerifyUtil.is(entity).notNull()
+//                .and(entity.getWorkspaceId()).notEmpty(RCode.WORKSPACE_ID_CANNOT_EMPTY);
+//
+//        RunnerEntity runner = runnerService.saveRunner(entity);
+//        return R.ok().putData("record", runner);
+//    }
+//
+//    @PutMapping
+//    public R update(@RequestBody RunnerEntity entity) {
+//        T.VerifyUtil.is(entity).notNull()
+//                .and(entity.getId()).notEmpty(RCode.ID_CANNOT_EMPTY)
+//                .and(entity.getWorkspaceId()).notEmpty(RCode.WORKSPACE_ID_CANNOT_EMPTY);
+//
+//        RunnerEntity runner = runnerService.updateRunner(entity);
+//        return R.ok().putData("record", runner);
+//    }
+//
+//    @DeleteMapping("/{id}")
+//    public R delete(@PathVariable("id") String id) {
+//        runnerService.removeById(id);
+//        return R.ok();
+//    }
+//
+//    @SaIgnore
+//    @PostMapping("/register")
+//    public void register(@RequestHeader("Authorization") String token, HttpServletResponse response) throws IOException {
+//        RunnerEntity runner = runnerService.getOne(new LambdaUpdateWrapper<RunnerEntity>().eq(RunnerEntity::getToken, token));
+//        String status = Opt.ofNullable(runner).map(RunnerEntity::getStatus).orElseGet(() -> null);
+//        if (!T.StrUtil.equals("online", status)) {
+//            log.warn("[register] [runner is offline] [token: {}]", token);
+//            response.sendError(HttpServletResponse.SC_FORBIDDEN, "Runner is offline");
+//        }
+//    }
+//
+//    @SaIgnore
+//    @PostMapping("/heartbeat")
+//    public void heartbeat(@RequestHeader("Authorization") String token, @RequestBody Map<String, Integer> platformMap,
+//                          HttpServletResponse response) throws IOException {
+//        RunnerEntity runner = runnerService.getOne(new LambdaUpdateWrapper<RunnerEntity>().eq(RunnerEntity::getToken, token));
+//        String status = Opt.ofNullable(runner).map(RunnerEntity::getStatus).orElseGet(() -> null);
+//        if (!T.StrUtil.equals("online", status)) {
+//            log.warn("[heartbeat] [runner is offline] [token: {}]", token);
+//            response.sendError(HttpServletResponse.SC_FORBIDDEN, "Runner is offline");
+//            return;
+//        }
+//
+//        // update last_heartbeat_timestamp
+//        runnerService.update(new LambdaUpdateWrapper<RunnerEntity>()
+//                .set(RunnerEntity::getLastHeartbeatTimestamp, System.currentTimeMillis())
+//                .eq(RunnerEntity::getId, runner.getId()));
+//
+//        // findjob by platform
+//        String platform = platformMap.entrySet().stream().filter(entry -> entry.getValue() > 0).findFirst().map(entry -> entry.getKey()).orElseGet(null);
+//        JobEntity job = jobService.assignPendingJob(runner.getId(), platform);
+//        if (T.ObjectUtil.isNotNull(job)) {
+//            // package
+//            PackageEntity pkg = job.getPkg();
+//            Map<String, String> pkgInfo = T.MapUtil.builder("id", pkg.getId())
+//                    .put("platform", pkg.getPlatform())
+//                    .put("identifier", pkg.getIdentifier())
+//                    .put("version", pkg.getVersion())
+//                    .build();
+//
+//            // playbook
+//            PlaybookEntity playbook = job.getPlaybook();
+//            Map<String, String> pbInfo = T.MapUtil.builder("id", playbook.getId())
+//                    .put("name", playbook.getName())
+//                    .build();
+//
+//            // response job info
+//            Map<Object, Object> responseData = T.MapUtil.builder()
+//                    .put("id", job.getId())
+//                    .put("pkg", pkgInfo)
+//                    .put("playbook", pbInfo)
+//                    .build();
+//            response.setCharacterEncoding("UTF-8");
+//            response.setContentType("text/html; charset=UTF-8");
+//            response.getWriter().write(T.JSONUtil.toJsonStr(responseData));
+//        }
+//    }
+//
+//    @SaIgnore
+//    @PutMapping("/trace/{jobId}")
+//    public void trace(@RequestHeader("Authorization") String token, @PathVariable String jobId, @RequestBody byte[] bytes,
+//                      HttpServletResponse response) throws IOException {
+//        RunnerEntity runner = runnerService.getOne(new LambdaUpdateWrapper<RunnerEntity>().eq(RunnerEntity::getToken, token));
+//        String status = Opt.ofNullable(runner).map(RunnerEntity::getStatus).orElseGet(() -> null);
+//        if (!T.StrUtil.equals("online", status)) {
+//            log.warn("[trace] [runner is offline] [token: {}]", token);
+//            response.sendError(HttpServletResponse.SC_FORBIDDEN, "Runner is offline");
+//            return;
+//        }
+//
+//        try {
+//            // 追加到文件中
+//            String content = T.StrUtil.str(bytes, T.CharsetUtil.CHARSET_UTF_8);
+//            jobService.appendTraceLogStrToFile(jobId, content);
+//        } catch (Exception e) {
+//            log.error("[trace] [error] [job: {}]", jobId);
+//            response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+//        }
+//    }
+//
+//    @SaIgnore
+//    @PutMapping("/jobResult/{jobId}")
+//    public void jobResult(@RequestHeader("Authorization") String token, @PathVariable String jobId, @RequestParam String state,
+//                          @RequestParam(value = "file", required = false) MultipartFile pcapFile,
+//                          HttpServletResponse response) throws IOException {
+//        RunnerEntity runner = runnerService.getOne(new LambdaUpdateWrapper<RunnerEntity>().eq(RunnerEntity::getToken, token));
+//        String status = Opt.ofNullable(runner).map(RunnerEntity::getStatus).orElseGet(() -> null);
+//        if (!T.StrUtil.equals("online", status)) {
+//            log.warn("[trace] [runner is offline] [token: {}]", token);
+//            response.sendError(HttpServletResponse.SC_FORBIDDEN, "Runner is offline");
+//            return;
+//        }
+//
+//        // 更新任务状态
+//        jobService.updateJobResult(jobId, state, pcapFile);
+//    }
+//
+//}

src/main/java/net/geedge/asw/module/runner/dao/JobDao.java

@@ -0,0 +1,17 @@
+package net.geedge.asw.module.runner.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import net.geedge.asw.module.runner.entity.JobEntity;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+import java.util.Map;
+
+@Mapper
+public interface JobDao extends BaseMapper<JobEntity>{
+
+    List<JobEntity> queryList(IPage page, Map<String, Object> params);
+
+}