init repo

.gitignore

@@ -12,3 +12,5 @@
 # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
 hs_err_pid*
 
+/build/
+/gradle/

.idea/.gitignore

@@ -0,0 +1,10 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
+# Zeppelin ignored files
+/ZeppelinRemoteNotebooks/

build.gradle

@@ -0,0 +1,91 @@
+plugins {
+    id 'org.springframework.boot' version '2.3.7.RELEASE'
+    id 'io.spring.dependency-management' version '1.0.10.RELEASE'
+    id 'java'
+}
+
+group = 'com.rf'
+version = '0.0.1-SNAPSHOT'
+sourceCompatibility = '1.8'
+
+configurations {
+    compileOnly {
+        extendsFrom annotationProcessor
+    }
+}
+
+repositories {
+    maven {
+        url 'https://maven.aliyun.com/repository/public'
+    }
+    maven {
+        credentials {
+            username '0p07qf'
+            password 'z1XwdFEf4M'
+        }
+        url 'https://repo.rdc.aliyun.com/repository/107260-release-GqdtcU/'
+    }
+    maven {
+        credentials {
+            username '0p07qf'
+            password 'z1XwdFEf4M'
+        }
+        url 'https://repo.rdc.aliyun.com/repository/107260-snapshot-C6ziam/'
+    }
+    maven {
+        url "https://plugins.gradle.org/m2/"
+    }
+    mavenLocal()
+    mavenCentral()
+}
+
+dependencies {
+    implementation 'org.springframework.boot:spring-boot-starter-web'
+    // https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-jpa
+    implementation 'org.springframework.boot:spring-boot-starter-data-jpa:2.7.1'
+// https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-validation
+    implementation 'org.springframework.boot:spring-boot-starter-validation:2.7.0'
+
+    compileOnly 'org.projectlombok:lombok'
+    annotationProcessor 'org.projectlombok:lombok'
+    testImplementation('org.springframework.boot:spring-boot-starter-test') {
+        exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
+    }
+    // https://mvnrepository.com/artifact/com.alibaba/druid-spring-boot-starter
+    implementation group: 'com.alibaba', name: 'druid-spring-boot-starter', version: '1.2.9'
+    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
+    // https://mvnrepository.com/artifact/mysql/mysql-connector-java
+    implementation 'mysql:mysql-connector-java:8.0.29'
+    // https://mvnrepository.com/artifact/com.alibaba/fastjson
+    implementation 'com.alibaba:fastjson:1.2.83'
+    // https://mvnrepository.com/artifact/com.querydsl/querydsl-jpa
+    implementation 'com.querydsl:querydsl-jpa:5.0.0'
+    // https://mvnrepository.com/artifact/com.querydsl/querydsl-core
+    implementation 'com.querydsl:querydsl-core:5.0.0'
+    //关键地方(记得开启annotationProcessor)
+    annotationProcessor('com.querydsl:querydsl-apt:5.0.0:jpa',
+            "org.hibernate.javax.persistence:hibernate-jpa-2.1-api:1.0.2.Final",
+            "javax.annotation:javax.annotation-api:1.3.2",
+            "org.projectlombok:lombok")
+    // https://mvnrepository.com/artifact/com.auth0/java-jwt
+    implementation 'com.auth0:java-jwt:3.19.2'
+    // https://mvnrepository.com/artifact/org.apache.commons/commons-lang3
+    implementation 'org.apache.commons:commons-lang3:3.12.0'
+    // https://mvnrepository.com/artifact/com.github.ulisesbocchio/jasypt-spring-boot-starter
+    implementation 'com.github.ulisesbocchio:jasypt-spring-boot-starter:3.0.4'
+    // https://mvnrepository.com/artifact/org.apache.poi/poi-ooxml
+    implementation 'org.apache.poi:poi-ooxml:5.2.2'
+    // https://mvnrepository.com/artifact/com.github.xiaoymin/knife4j-spring-boot-starter
+    implementation 'com.github.xiaoymin:knife4j-spring-boot-starter:3.0.3'
+    // https://mvnrepository.com/artifact/io.springfox/springfox-boot-starter
+    implementation 'io.springfox:springfox-boot-starter:3.0.0'
+
+
+
+
+
+}
+
+test {
+    useJUnitPlatform()
+}

src/main/java/com/rf/kjb/ConfrontationTraining.java

@@ -0,0 +1,14 @@
+package com.rf.kjb;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+//@EnableSwagger2
+public class ConfrontationTraining {
+
+    public static void main(String[] args) {
+        SpringApplication.run(ConfrontationTraining.class, args);
+    }
+
+}

src/main/java/com/rf/kjb/area/dao/model/ProvinceEntity.java

@@ -0,0 +1,46 @@
+package com.rf.kjb.area.dao.model;
+
+import com.rf.kjb.base.model.BaseEntry;
+import lombok.*;
+import org.hibernate.Hibernate;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+import java.util.Objects;
+
+/**
+ * @Author:zzf
+ * @Date:2023/5/12:10:14
+ * @Description:
+ */
+@Getter
+@Setter
+@ToString
+@RequiredArgsConstructor
+@Entity
+@AllArgsConstructor
+//@NoArgsConstructor
+@Table(name = "t_province_info")
+@org.hibernate.annotations.Table(appliesTo = "t_province_info", comment = "地区信息表")
+@DynamicUpdate
+public class ProvinceEntity extends BaseEntry {
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || Hibernate.getClass(this) != Hibernate.getClass(o)) return false;
+        ProvinceEntity that = (ProvinceEntity) o;
+        return getId() != null && Objects.equals(getId(), that.getId());
+    }
+
+    @Override
+    public int hashCode() {
+        return getClass().hashCode();
+    }
+    @Column(name = "province_code",columnDefinition = "varchar(10) not null unique comment '编码'")
+    private String provinceCode;
+    @Column(name = "province_name",columnDefinition = "varchar(20) not null unique comment '名称'")
+    private String provinceName;
+
+}

src/main/java/com/rf/kjb/area/dao/repository/ProvinceRepository.java

@@ -0,0 +1,7 @@
+package com.rf.kjb.area.dao.repository;
+
+import com.rf.kjb.area.dao.model.ProvinceEntity;
+import com.rf.kjb.base.repository.BaseRepository;
+
+public interface ProvinceRepository extends BaseRepository<ProvinceEntity,String> {
+}

src/main/java/com/rf/kjb/area/rest/ProvinceController.java

@@ -0,0 +1,45 @@
+package com.rf.kjb.area.rest;
+
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.area.dao.model.ProvinceEntity;
+import com.rf.kjb.area.service.ProvinceService;
+import com.rf.kjb.base.rest.BaseController;
+import com.rf.kjb.utils.Result;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * @Author:zzf
+ * @Date:2023/5/12:10:30
+ * @Description:
+ */
+@RestController
+@RequestMapping("/v1/province")
+@Slf4j
+@Api(tags = "地区信息")
+public class ProvinceController extends BaseController {
+
+    @Autowired
+    private ProvinceService service;
+
+    @ApiOperation(value = "保存",notes = "provinceCode:编码；provinceName：名称")
+    @PostMapping("/save")
+    public Result save(@RequestBody String jsonObject){
+        ProvinceEntity provinceEntity = JSONObject.toJavaObject(JSONObject.parseObject(jsonObject),ProvinceEntity.class);
+        provinceEntity = this.service.save(provinceEntity);
+        return success(provinceEntity);
+    }
+
+
+    @ApiOperation("全量查询")
+    @GetMapping("/find")
+    public Result find(){
+        List<ProvinceEntity> provinceEntityList = this.service.findAll();
+        return success(provinceEntityList);
+    }
+}

src/main/java/com/rf/kjb/area/service/ProvinceService.java

@@ -0,0 +1,11 @@
+package com.rf.kjb.area.service;
+
+import com.rf.kjb.area.dao.model.ProvinceEntity;
+
+import java.util.List;
+
+public interface ProvinceService {
+    ProvinceEntity save(ProvinceEntity provinceEntity);
+
+    List<ProvinceEntity> findAll();
+}

src/main/java/com/rf/kjb/area/service/impl/ProvinceServiceImpl.java

@@ -0,0 +1,30 @@
+package com.rf.kjb.area.service.impl;
+
+import com.rf.kjb.area.dao.model.ProvinceEntity;
+import com.rf.kjb.area.dao.repository.ProvinceRepository;
+import com.rf.kjb.area.service.ProvinceService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * @Author:zzf
+ * @Date:2023/5/12:10:36
+ * @Description:
+ */
+@Service
+public class ProvinceServiceImpl implements ProvinceService {
+
+    @Autowired
+    private ProvinceRepository repository;
+    @Override
+    public ProvinceEntity save(ProvinceEntity provinceEntity) {
+        return this.repository.save(provinceEntity);
+    }
+
+    @Override
+    public List<ProvinceEntity> findAll() {
+        return this.repository.findAll();
+    }
+}

src/main/java/com/rf/kjb/base/model/BaseEntry.java

@@ -0,0 +1,42 @@
+package com.rf.kjb.base.model;
+
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.hibernate.annotations.GenericGenerator;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+import javax.persistence.*;
+import javax.validation.constraints.NotNull;
+import java.io.Serializable;
+import java.util.Date;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/1/18 19:13
+ */
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@EntityListeners({AuditingEntityListener.class})
+@MappedSuperclass
+public class BaseEntry implements Serializable {
+    @Getter
+    @Id
+    @GenericGenerator(name = "jpa-uuid", strategy = "uuid")
+    @GeneratedValue(generator = "jpa-uuid")
+    @Column(name = "id", columnDefinition = "varchar(36) COMMENT '数据ID'")
+    @NotNull(groups = Update.class)
+    private String id;
+
+    @Column(name = "create_time",columnDefinition = "timestamp default current_timestamp comment '创建时间'")
+    private Date createTime;
+
+    @Column(name = "update_time",columnDefinition = "timestamp comment '更新时间'")
+    private Date updateTime;
+    public @interface Update {
+    }
+}

src/main/java/com/rf/kjb/base/package-info.java

@@ -0,0 +1,4 @@
+package com.rf.kjb.base;
+/**
+ * 基础信息
+ */

src/main/java/com/rf/kjb/base/repository/BaseRepository.java

@@ -0,0 +1,18 @@
+package com.rf.kjb.base.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.querydsl.QuerydslPredicateExecutor;
+import org.springframework.data.repository.NoRepositoryBean;
+
+import java.io.Serializable;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/1/18 19:17
+ */
+@NoRepositoryBean
+public interface BaseRepository<T, PK extends Serializable> extends JpaRepository<T, PK>, JpaSpecificationExecutor, QuerydslPredicateExecutor<T> {
+
+}

src/main/java/com/rf/kjb/base/rest/BaseController.java

@@ -0,0 +1,37 @@
+package com.rf.kjb.base.rest;
+
+
+import com.rf.kjb.exception.ErrorCode;
+import com.rf.kjb.utils.Result;
+import org.springframework.util.StringUtils;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/1/18 19:20
+ */
+public class BaseController {
+
+    protected Result success() {
+        return success(null, "成功");
+    }
+
+    protected static <T> Result<T> success(T data) {
+        return success(data, "完成");
+    }
+
+    protected static <T> Result<T> success(T data, String message) {
+        if (null == data) {
+            return new Result<>(ErrorCode.SUCCESS.getErrorCode(), StringUtils.isEmpty(message)?ErrorCode.SUCCESS.getErrorMsg():message);
+        }
+        return new Result<>(ErrorCode.SUCCESS.getErrorCode(), StringUtils.isEmpty(message)?ErrorCode.SUCCESS.getErrorMsg():message, data);
+    }
+
+    protected static  Result fail(ErrorCode errorCode){
+        return new Result<>(errorCode.getErrorCode(),errorCode.getErrorMsg());
+    }
+
+
+
+
+}

src/main/java/com/rf/kjb/config/DruidConfig.java

@@ -0,0 +1,108 @@
+package com.rf.kjb.config;
+
+import com.alibaba.druid.filter.config.ConfigTools;
+import com.alibaba.druid.pool.DruidDataSource;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Primary;
+
+import javax.sql.DataSource;
+import java.sql.SQLException;
+import java.util.Properties;
+
+/**
+ * @Author:zzf
+ * @Date:2022/7/25:18:31
+ * @Description:
+ */
+@Slf4j
+public class DruidConfig {
+    @Value("${spring.datasource.url}")
+    private String url;
+    @Value("${spring.datasource.username}")
+    private String username;
+    @Value("${spring.datasource.password}")
+    private String password;
+    @Value("${spring.datasource.type}")
+    private String type;
+    @Value("${spring.datasource.publicKey}")
+    private String publicKey;
+
+    @Value("${spring.datasource.druid.initial-size}")
+    private Integer initialSize;
+
+    @Value("${spring.datasource.druid.min-idle}")
+    private Integer minIdle;
+
+    @Value("${spring.datasource.druid.max-active}")
+    private Integer maxActive;
+
+    @Value("${spring.datasource.druid.max-wait}")
+    private Integer maxWait;
+
+    @Value("${spring.datasource.druid.time-between-eviction-runs-millis}")
+    private Integer timeBetweenEvictionRunsMillis;
+
+    @Value("${spring.datasource.druid.min-evictable-idle-time-millis}")
+    private Integer minEvictableIdleTimeMillis;
+
+    @Value("${spring.datasource.druid.validation-query}")
+    private String validationQuery;
+
+    @Value("${spring.datasource.druid.test-while-idle}")
+    private Boolean testWhileIdle;
+
+    @Value("${spring.datasource.druid.test-on-borrow}")
+    private Boolean testOnBorrow;
+
+    @Value("${spring.datasource.druid.test-on-return}")
+    private Boolean testOnReturn;
+
+    @Value("${spring.datasource.druid.pool-prepared-statements}")
+    private Boolean poolPreparedStatements;
+
+    @Value("${spring.datasource.druid.max-pool-prepared-statement-per-connection-size}")
+    private Integer maxPoolPreparedStatementPerConnectionSize;
+
+    @Value("${spring.datasource.druid.filters}")
+    private String filters;
+
+    @Value("${spring.datasource.druid.use-global-data-source-stat}")
+    private Boolean useGlobalDataSourceStat;
+
+    @Value("${spring.datasource.druid.connect-properties}")
+    private Properties connectProperties;
+
+    @Bean
+    @Primary
+    public DataSource druidDataSource() throws Exception {
+        DruidDataSource datasource = new DruidDataSource();
+        datasource.setUrl(url);
+        datasource.setUsername(username);
+        // 解密后，再 set 进对象
+        datasource.setPassword(ConfigTools.decrypt(publicKey, password));
+        log.info("密码：" + ConfigTools.decrypt(publicKey, password));
+        datasource.setInitialSize(initialSize);
+        datasource.setMinIdle(minIdle);
+        datasource.setMaxActive(maxActive);
+        datasource.setMaxWait(maxWait);
+        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
+        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
+        datasource.setValidationQuery(validationQuery);
+        datasource.setTestWhileIdle(testWhileIdle);
+        datasource.setTestOnBorrow(testOnBorrow);
+        datasource.setTestOnReturn(testOnReturn);
+        datasource.setUseGlobalDataSourceStat(useGlobalDataSourceStat);
+        datasource.setConnectProperties(connectProperties);
+
+        try {
+            datasource.setFilters(filters);
+        } catch (SQLException e) {
+            log.error("========druid configuration initialization filter========", e);
+        }
+
+        return datasource;
+    }
+
+}

src/main/java/com/rf/kjb/config/Swagger3Config.java

@@ -0,0 +1,85 @@
+package com.rf.kjb.config;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import springfox.documentation.builders.RequestHandlerSelectors;
+import springfox.documentation.oas.annotations.EnableOpenApi;
+import springfox.documentation.service.*;
+import springfox.documentation.spi.DocumentationType;
+import springfox.documentation.spi.service.contexts.SecurityContext;
+import springfox.documentation.spring.web.plugins.Docket;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Description: Swagger3+knife4j Config
+ *
+ * @author: zzf
+ * @date: 2022-07-28
+ */
+@Configuration
+@EnableOpenApi
+public class Swagger3Config {
+
+    @Value("${swagger.enabled}")
+    Boolean swaggerEnabled;
+
+    @Bean
+    public Docket docket() {
+        return new Docket(DocumentationType.OAS_30)
+                .apiInfo(apiInfo())
+                // 是否开启swagger
+                .enable(swaggerEnabled)
+                .select()
+                // 过滤条件，扫描指定路径下的文件
+                .apis(RequestHandlerSelectors.basePackage("com.rf.kjb"))
+                // 指定路径处理，PathSelectors.any()代表不过滤任何路径
+                //.paths(PathSelectors.any())
+                .build()
+                .securitySchemes(securitySchemes())
+                .securityContexts(tokenContext());
+    }
+
+    private List<SecurityContext> tokenContext() {
+        List<SecurityContext> list = new ArrayList<>();
+        list.add(SecurityContext.builder()
+                .securityReferences(securityReferences())
+                .operationSelector(o -> o.requestMappingPattern().matches("/.*"))
+                .build());
+        return list;
+    }
+
+    public List<SecurityReference> securityReferences(){
+        List<SecurityReference> list = new ArrayList<>();
+        list.add( SecurityReference.builder()
+                .scopes(new AuthorizationScope[0])
+                .reference("Authorization")
+                .build());
+        return list;
+    }
+
+    private List<SecurityScheme> securitySchemes() {
+        List<SecurityScheme> list = new ArrayList<>();
+        list.add(HttpAuthenticationScheme.JWT_BEARER_BUILDER.name("Authorization").build());
+        return list;
+    }
+
+
+    private ApiInfo apiInfo() {
+        /*作者信息*/
+        Contact contact = new Contact("", "", "");
+        return new ApiInfo(
+                "KJB接口文档",
+                "KJB V1.0 测试接口文档",
+                "v1.0",
+                "",
+                contact,
+                "Apache 2.0",
+                "http://www.apache.org/licenses/LICENSE-2.0",
+                new ArrayList<>()
+        );
+    }
+}
+

src/main/java/com/rf/kjb/excel/ExcelBean.java

@@ -0,0 +1,72 @@
+package com.rf.kjb.excel;
+
+import org.apache.poi.xssf.usermodel.XSSFCellStyle;
+
+/**
+ * @author zzf
+ * @description:excel导出类
+ * @date 2021/1/27 9:23
+ */
+
+public class ExcelBean {
+    /**
+     * 列头（标题）名
+     */
+    public String headTextName;
+    /**
+     * 对应字段名
+     */
+    public String propertyName;
+    /**
+     * 合并单元格数
+     */
+    public Integer cols;
+    public XSSFCellStyle cellStyle;
+
+    public ExcelBean() {
+    }
+
+    public ExcelBean(String headTextName, String propertyName) {
+        this.headTextName = headTextName;
+        this.propertyName = propertyName;
+    }
+
+    public ExcelBean(String headTextName, String propertyName, Integer cols) {
+        super();
+        this.headTextName = headTextName;
+        this.propertyName = propertyName;
+        this.cols = cols;
+    }
+
+    public String getHeadTextName() {
+        return headTextName;
+    }
+
+    public void setHeadTextName(String headTextName) {
+        this.headTextName = headTextName;
+    }
+
+    public String getPropertyName() {
+        return propertyName;
+    }
+
+    public void setPropertyName(String propertyName) {
+        this.propertyName = propertyName;
+    }
+
+    public Integer getCols() {
+        return cols;
+    }
+
+    public void setCols(Integer cols) {
+        this.cols = cols;
+    }
+
+    public XSSFCellStyle getCellStyle() {
+        return cellStyle;
+    }
+
+    public void setCellStyle(XSSFCellStyle cellStyle) {
+        this.cellStyle = cellStyle;
+    }
+}

src/main/java/com/rf/kjb/excel/ExcelClass.java

@@ -0,0 +1,72 @@
+package com.rf.kjb.excel;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author zzf
+ * @description:Excel导出辅助类，自定义表头和字段英文值
+ * @date 2021/1/27 9:21
+ */
+public class ExcelClass {
+
+    /**
+     * 全量导出，自定义flag
+     *
+     * @param
+     * @return
+     */
+    public Map<Integer, List<ExcelBean>> contentExcel() {
+        List<ExcelBean> excel = new ArrayList<>();
+        Map<Integer, List<ExcelBean>> map = new LinkedHashMap<>();
+        //设置标题栏
+        excel.add(new ExcelBean("题号", "questionNo", 0));
+        excel.add(new ExcelBean("题目", "answer", 0));
+        excel.add(new ExcelBean("选择项", "checkItems", 0));
+        excel.add(new ExcelBean("类型", "questionType", 0));
+        excel.add(new ExcelBean("计分方向", "scoreDirection", 0));
+        map.put(0, excel);
+        return map;
+    }
+
+    public Map<Integer, List<ExcelBean>> userExportExcel() {
+        List<ExcelBean> excel = new ArrayList<>();
+        Map<Integer, List<ExcelBean>> map = new LinkedHashMap<>();
+        //设置标题栏
+        excel.add(new ExcelBean("机构名称", "institutionName", 0));
+        excel.add(new ExcelBean("机构编号", "institutionNo", 0));
+        excel.add(new ExcelBean("姓名", "petName", 0));
+        excel.add(new ExcelBean("性别", "gender", 0));
+        excel.add(new ExcelBean("出生年月", "birthday", 0));
+        excel.add(new ExcelBean("职业", "profession", 0));
+        excel.add(new ExcelBean("附加信息", "additionInfo", 0));
+        excel.add(new ExcelBean("账号", "phone", 0));
+        excel.add(new ExcelBean("密码", "password", 0));
+        map.put(0, excel);
+        return map;
+    }
+            /*excel.add(new ExcelBean("任务","backCount",0));
+            excel.add(new ExcelBean("组块","groupCount",0));
+            excel.add(new ExcelBean("字符次序","charShowCount",0));
+            excel.add(new ExcelBean("字符","charStr",0));
+            excel.add(new ExcelBean("响应时长(毫秒)","time",0));*/
+
+    /**
+     * 自定义导出
+     *
+     * @param entryMap key:中文表头  value 英文字段，与实体类一一对应
+     * @return
+     */
+    public Map<Integer, List<ExcelBean>> contentExcel(Map<String, String> entryMap) {
+        List<ExcelBean> excel = new ArrayList<>();
+        Map<Integer, List<ExcelBean>> map = new LinkedHashMap<>();
+        //设置标题栏
+        for (Map.Entry<String, String> entry : entryMap.entrySet()) {
+            excel.add(new ExcelBean(entry.getValue(), entry.getKey(), 0));
+            map.put(0, excel);
+        }
+        return map;
+    }
+}

src/main/java/com/rf/kjb/excel/ExcelUtil.java

@@ -0,0 +1,566 @@
+package com.rf.kjb.excel;
+
+
+import com.rf.kjb.utils.OSUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
+import org.apache.poi.ss.formula.functions.T;
+import org.apache.poi.ss.usermodel.*;
+import org.apache.poi.ss.util.CellRangeAddress;
+import org.apache.poi.util.StringUtil;
+import org.apache.poi.xssf.usermodel.*;
+import java.beans.PropertyDescriptor;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.lang.reflect.Method;
+import java.math.BigDecimal;
+import java.text.DecimalFormat;
+import java.text.NumberFormat;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author zzf
+ * @description:Excel 导出工具了哦
+ * @date 2021/1/27 9:18
+ */
+@Slf4j
+public class ExcelUtil {
+
+    /**
+     * excel 版本
+     **/
+    private final static String excel2003L = ".xls";
+    private final static String excel2007U = ".xlsx";
+
+    /**
+     * Excel导入
+     */
+    public static List<List<Object>> getBankListByExcel(InputStream in, String fileName) throws Exception {
+        List<List<Object>> list = null;
+        //创建Excel工作薄
+        Workbook work = getWorkbook(in, fileName);
+        if (null == work) {
+            throw new Exception("创建Excel工作薄为空！");
+        }
+        Sheet sheet = null;
+        Row row = null;
+        Cell cell = null;
+        list = new ArrayList<List<Object>>();
+        //遍历Excel中所有的sheet
+        System.out.println("work.getNumberOfSheets()：" + work.getNumberOfSheets());
+        for (int i = 0; i < work.getNumberOfSheets() - 1; i++) {
+            sheet = work.getSheetAt(i);
+            if (sheet == null) {
+                continue;
+            }
+            int sheetSize = 0;
+            //遍历当前sheet中的所有行
+            //包涵头部，所以要小于等于最后一列数,这里也可以在初始值加上头部行数，以便跳过头部
+            for (int j = sheet.getFirstRowNum(); j <= sheet.getLastRowNum(); j++) {
+                //读取一行
+                row = sheet.getRow(j);
+                //去掉空行和表头
+                if (row.getFirstCellNum() == j) {
+                    sheetSize = row.getLastCellNum();
+                }
+                if (row == null || row.getFirstCellNum() == j) {
+                    continue;
+                }
+                //遍历所有的列
+                List<Object> li = new ArrayList<Object>();
+                for (int y = row.getFirstCellNum(); y < sheetSize; y++) {
+                    cell = row.getCell(y);
+                    li.add(cell != null ? getCellValue(cell) : null);
+                }
+                list.add(li);
+            }
+        }
+        return list;
+    }
+
+    /**
+     * Excel分sheet导入
+     */
+    public static List<List<List<Object>>> getBankListByExcelSheet(InputStream in, String fileName) throws Exception {
+        List<List<List<Object>>> list = null;
+        //创建Excel工作薄
+        Workbook work = getWorkbook(in, fileName);
+        if (null == work) {
+            throw new Exception("创建Excel工作薄为空！");
+        }
+        Sheet sheet = null;
+        Row row = null;
+        Cell cell = null;
+        list = new ArrayList<List<List<Object>>>();
+        //遍历Excel中所有的sheet
+        for (int i = 0; i < work.getNumberOfSheets() - 1; i++) {
+            List<List<Object>> sheets = new ArrayList<List<Object>>();
+            sheet = work.getSheetAt(i);
+            if (sheet == null) {
+                continue;
+            }
+            int sheetSize = 0;
+            //遍历当前sheet中的所有行
+            //包涵头部，所以要小于等于最后一列数,这里也可以在初始值加上头部行数，以便跳过头部
+            for (int j = sheet.getFirstRowNum(); j <= sheet.getLastRowNum(); j++) {
+                //读取一行
+                row = sheet.getRow(j);
+                //去掉空行和表头
+                if (row == null || row.getFirstCellNum() == j) {
+                    continue;
+                }
+                if (isAllRowEmpty(row, sheet.getRow(0))) {
+                    continue;
+                }
+                sheetSize = row.getLastCellNum();
+                //遍历所有的列
+                List<Object> li = new ArrayList<Object>();
+                for (int y = row.getFirstCellNum(); y < sheetSize; y++) {
+                    cell = row.getCell(y);
+                    if (cell == null) {
+                        continue;
+                    }
+                    li.add(cell != null ? getCellValue(cell) : null);
+                }
+                sheets.add(li);
+            }
+            list.add(sheets);
+        }
+        return list;
+    }
+
+    /**
+     * 验证excel是否全部为空
+     *
+     * @param row      当前行
+     * @param firstRow 第一行标题行
+     * @return
+     */
+    public static boolean isAllRowEmpty(Row row, Row firstRow) {
+        int count = 0;
+        //单元格数量
+        int rowCount = firstRow.getLastCellNum() - firstRow.getFirstCellNum();
+        //判断多少个单元格为空
+        for (int c = 0; c < rowCount; c++) {
+            Cell cell = row.getCell(c);
+            if (cell == null || cell.getCellType() == CellType.BLANK || StringUtils.isEmpty((cell + "").trim())) {
+                count += 1;
+            }
+        }
+
+        if (count == rowCount) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * 描述：根据文件后缀，自适应上传文件的版本
+     */
+    private static Workbook getWorkbook(InputStream inStr, String fileName) throws Exception {
+        Workbook wb = null;
+        String fileType = fileName.substring(fileName.lastIndexOf("."));
+        if (excel2003L.equals(fileType)) {
+            //2003-
+            wb = new HSSFWorkbook(inStr);
+        } else if (excel2007U.equals(fileType)) {
+            //2007+
+            wb = new XSSFWorkbook(inStr);
+        } else {
+            throw new Exception("解析的文件格式有误！");
+        }
+        return wb;
+    }
+
+    /**
+     * 描述：对表格中数值进行格式化
+     */
+    private static Object getCellValue(Cell cell) {
+        Object value = null;
+        //格式化字符类型的数字
+        DecimalFormat df = new DecimalFormat("0");
+        //日期格式化
+        SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd");
+        //格式化数字
+        DecimalFormat df2 = new DecimalFormat("0.00");
+        switch (cell.getCellType()) {
+
+            case STRING:
+                value = cell.getRichStringCellValue().getString();
+                break;
+            case NUMERIC:
+                if ("General".equals(cell.getCellStyle().getDataFormatString())) {
+                    value = df.format(cell.getNumericCellValue());
+                } else if ("m/d/yy".equals(cell.getCellStyle().getDataFormatString())) {
+                    value = sdf.format(cell.getDateCellValue());
+                } else {
+                    value = df2.format(cell.getNumericCellValue());
+                }
+                break;
+            case BOOLEAN:
+                value = cell.getBooleanCellValue();
+                break;
+            case BLANK:
+                value = "";
+                break;
+            case FORMULA: //公式类型
+                try {
+                    if ("General".equals(cell.getCellStyle().getDataFormatString())) {
+                        value = df.format(cell.getNumericCellValue());
+                    } else if ("m/d/yy".equals(cell.getCellStyle().getDataFormatString())) {
+                        value = sdf.format(cell.getDateCellValue());
+                    } else {
+                        value = df2.format(cell.getNumericCellValue());
+                    }
+                } catch (IllegalStateException e) {
+                    value = String.valueOf(cell.getRichStringCellValue());
+                }
+                break;
+            default:
+                break;
+        }
+        return value;
+    }
+
+    /**
+     * @param clazz     数据类
+     * @param objs      导出数据列表
+     * @param resultMap 计算结果，各项得分
+     * @param map       表头
+     * @param fileName  文件名
+     * @param sheetName sheet页命
+     * @return
+     * @throws Exception
+     */
+    public static XSSFWorkbook createExcelFile(Class clazz, List objs, List<Map<String, String>> resultMap, Map<Integer, List<ExcelBean>> map, String fileName, String sheetName) throws Exception {
+        // 创建新的Excel工作簿
+        XSSFWorkbook workbook = new XSSFWorkbook();
+        // 在Excel工作簿中建一工作表，其名为缺省值, 也可以指定Sheet名称
+        XSSFSheet sheet = workbook.createSheet(sheetName);
+        // 以下为excel的字体样式以及excel的标题与内容的创建，下面会具体分析;
+        //字体样式
+        createFont(workbook);
+        //创建标题（头）
+        createTableHeader(sheet, map);
+        //创建内容
+        createTableRows(sheet, map, objs, resultMap, clazz);
+        FileOutputStream fileOutputStream;
+        File file = new File("./心理检测/检测结果/" + new SimpleDateFormat("yyyy-MM-dd").format(new Date()) + "/" + sheetName);
+        if (!file.exists()) {
+            if(!file.mkdirs()){
+                log.error("创建文件夹失败");
+                return null;
+            }
+        }
+        fileOutputStream = new FileOutputStream("./心理检测/检测结果/" + new SimpleDateFormat("yyyy-MM-dd").format(new Date()) + "/" + sheetName + "/" + fileName);
+        workbook.write(fileOutputStream);
+        fileOutputStream.close();
+        return workbook;
+    }
+
+
+    /**
+     * @param clazz
+     * @param objs
+     * @param resultMap
+     * @param map
+     * @param fileName
+     * @return
+     * @throws Exception
+     */
+    public static XSSFWorkbook createExcelFileForPublic(Class clazz, List objs, List<Map<String, String>> resultMap, Map<Integer, List<ExcelBean>> map, String fileName, String filePath) throws Exception {
+        // 创建新的Excel工作簿
+        XSSFWorkbook workbook = new XSSFWorkbook();
+        // 在Excel工作簿中建一工作表，其名为缺省值, 也可以指定Sheet名称
+        XSSFSheet sheet = workbook.createSheet("用户信息");
+        // 以下为excel的字体样式以及excel的标题与内容的创建，下面会具体分析;
+        //字体样式
+        createFont(workbook);
+        //创建标题（头）
+        createTableHeader(sheet, map);
+        //创建内容
+        createTableRows(sheet, map, objs, resultMap, clazz);
+        FileOutputStream fileOutputStream;
+        File file = new File(filePath);
+        if (!file.exists()) {
+            if(!file.mkdirs()){
+                log.error("创建文件夹失败");
+                return null;
+            }
+        }
+        fileOutputStream = new FileOutputStream(filePath + fileName);
+        workbook.write(fileOutputStream);
+        fileOutputStream.close();
+        return workbook;
+    }
+
+
+    private static XSSFCellStyle fontStyle;
+    private static XSSFCellStyle fontStyle2;
+
+    public static void createFont(XSSFWorkbook workbook) {
+        // 表头
+        fontStyle = workbook.createCellStyle();
+        XSSFFont font1 = workbook.createFont();
+        font1.setBold(true);
+        font1.setFontName("黑体");
+        // 设置字体大小
+        font1.setFontHeightInPoints((short) 14);
+        fontStyle.setFont(font1);
+        // 下边框
+        fontStyle.setBorderBottom(BorderStyle.THIN);
+        // 左边框
+        fontStyle.setBorderLeft(BorderStyle.THIN);
+        // 上边框
+        fontStyle.setBorderTop(BorderStyle.THIN);
+        // 右边框
+        fontStyle.setBorderRight(BorderStyle.THIN);
+        // 居中
+        fontStyle.setAlignment(HorizontalAlignment.CENTER);
+        // 内容
+        fontStyle2 = workbook.createCellStyle();
+        XSSFFont font2 = workbook.createFont();
+        font2.setFontName("宋体");
+        // 设置字体大小
+        font2.setFontHeightInPoints((short) 10);
+        fontStyle2.setFont(font2);
+        // 下边框
+        fontStyle2.setBorderBottom(BorderStyle.THIN);
+        // 左边框
+        fontStyle2.setBorderLeft(BorderStyle.THIN);
+        // 上边框
+        fontStyle2.setBorderTop(BorderStyle.THIN);
+        // 右边框
+        fontStyle2.setBorderRight(BorderStyle.THIN);
+        // 居中
+        fontStyle2.setAlignment(HorizontalAlignment.CENTER);
+    }
+
+    /**
+     * 根据ExcelMapping 生成列头（多行列头）
+     *
+     * @param sheet 工作簿
+     * @param map   每行每个单元格对应的列头信息
+     */
+    private static final void createTableHeader(XSSFSheet sheet, Map<Integer, List<ExcelBean>> map) {
+        //cell起始位置
+        int startIndex = 0;
+        //cell终止位置
+        int endIndex = 0;
+        for (Map.Entry<Integer, List<ExcelBean>> entry : map.entrySet()) {
+            XSSFRow row = sheet.createRow(entry.getKey());
+            List<ExcelBean> excels = entry.getValue();
+            for (int x = 0; x < excels.size(); x++) {
+                //合并单元格
+                if (excels.get(x).getCols() > 1) {
+                    if (x == 0) {
+                        endIndex += excels.get(x).getCols() - 1;
+                        CellRangeAddress range = new CellRangeAddress(0, 0, startIndex, endIndex);
+                        sheet.addMergedRegion(range);
+                    } else {
+                        endIndex += excels.get(x).getCols();
+                        CellRangeAddress range = new CellRangeAddress(0, 0, startIndex, endIndex);
+                        sheet.addMergedRegion(range);
+                    }
+                    startIndex += excels.get(x).getCols();
+                    XSSFCell cell = row.createCell(startIndex - excels.get(x).getCols());
+                    // 设置内容
+                    cell.setCellValue(excels.get(x).getHeadTextName());
+                    if (excels.get(x).getCellStyle() != null) {
+                        // 设置格式
+                        cell.setCellStyle(excels.get(x).getCellStyle());
+                    }
+                    cell.setCellStyle(fontStyle);
+                } else {
+                    XSSFCell cell = row.createCell(x);
+                    // 设置内容
+                    cell.setCellValue(excels.get(x).getHeadTextName());
+                    if (excels.get(x).getCellStyle() != null) {
+                        // 设置格式
+                        cell.setCellStyle(excels.get(x).getCellStyle());
+                    }
+                    cell.setCellStyle(fontStyle);
+                }
+            }
+        }
+    }
+
+    /**
+     * @param sheet     表格sheet页
+     * @param map       表头
+     * @param objs      答题列表
+     * @param clazz     量表实体类
+     * @param resultMap 测试结果得分
+     * @throws Exception
+     */
+    private static void createTableRows(XSSFSheet sheet, Map<Integer, List<ExcelBean>> map, List objs, List<Map<String, String>> resultMap, Class clazz) throws Exception {
+        int rowindex = map.size();
+        int maxKey = 0;
+        List<ExcelBean> ems;
+        for (Map.Entry<Integer, List<ExcelBean>> entry : map.entrySet()) {
+            if (entry.getKey() > maxKey) {
+                maxKey = entry.getKey();
+            }
+        }
+        ems = map.get(maxKey);
+        List<Integer> widths = new ArrayList<Integer>(ems.size());
+        //渲染答题记录
+        if (objs != null) {
+            for (Object obj : objs) {
+                XSSFRow row = sheet.createRow(rowindex);
+                for (int i = 0; i < ems.size(); i++) {
+                    ExcelBean em = (ExcelBean) ems.get(i);
+                    String propertyName = em.getPropertyName();
+                    PropertyDescriptor propertyDescriptor = new PropertyDescriptor(propertyName, clazz);
+                    Method method = propertyDescriptor.getReadMethod();
+                    Object rtn = method.invoke(obj);
+                    String value = "";
+                    // 如果是日期类型进行转换
+                    if (rtn != null) {
+
+                        if (rtn instanceof Date) {
+                            value = new SimpleDateFormat("yyyy-MM-dd").format(rtn);
+                        } else if (rtn instanceof BigDecimal) {
+                            NumberFormat nf = new DecimalFormat("#,##0.00");
+                            value = nf.format((BigDecimal) rtn).toString();
+                        } else if ((rtn instanceof Integer) && (Integer.valueOf(rtn.toString()) < 0)) {
+                            value = "--";
+                        } else {
+                            value = rtn.toString();
+                        }
+                    }
+                    XSSFCell cell = row.createCell(i);
+                    cell.setCellValue(value);
+                    cell.setCellType(CellType.STRING);
+                    cell.setCellStyle(fontStyle2);
+                    // 获得最大列宽
+                    int width = value.getBytes().length * 300;
+                    // 还未设置，设置当前
+                    if (widths.size() <= i) {
+                        widths.add(width);
+                        continue;
+                    }
+                    // 比原来大，更新数据
+                    if (width > widths.get(i)) {
+                        widths.set(i, width);
+                    }
+                }
+                rowindex++;
+            }
+        }
+        rowindex += 2;
+        if (resultMap != null && resultMap.size() > 0) {
+            for (int m = 0; m < resultMap.size(); m++) {
+                Map<String, String> hashMap = resultMap.get(m);
+                if (hashMap != null && hashMap.size() > 0) {
+                    //渲染最终各项得分
+                    XSSFRow titleRow = sheet.createRow(rowindex);
+                    rowindex += 1;
+                    XSSFRow scoreRow = sheet.createRow(rowindex);
+                    int i = 0;
+                    if (resultMap.size() > 0) {
+                        for (Map.Entry<String, String> entry : hashMap.entrySet()) {
+                            XSSFCell cellTitle = titleRow.createCell(i);
+                            cellTitle.setCellValue(entry.getKey());
+                            cellTitle.setCellType(CellType.STRING);
+                            cellTitle.setCellStyle(fontStyle2);
+                            XSSFCell cellScore = scoreRow.createCell(i);
+                            cellScore.setCellValue(entry.getValue());
+                            cellScore.setCellType(CellType.STRING);
+                            cellScore.setCellStyle(fontStyle2);
+                            i++;
+                        }
+                    }
+                }
+                rowindex += 2;
+            }
+        }
+
+        // 设置列宽
+        for (int index = 0; index < widths.size(); index++) {
+            Integer width = widths.get(index);
+            width = width < 2500 ? 2500 : width + 300;
+            width = width > 10000 ? 10000 + 300 : width + 300;
+            sheet.setColumnWidth(index, width);
+        }
+    }
+
+    /**
+     * 用户导入
+     *
+     * @param in
+     * @param fileName
+     * @return
+     * @throws Exception
+     */
+    public static List<List<Object>> getBankListByExcelForUserImport(InputStream in, String fileName) throws Exception {
+        List<List<Object>> list;
+        //创建Excel工作薄
+        Workbook work = getWorkbook(in, fileName);
+        if (null == work) {
+            throw new Exception("创建Excel工作薄为空！");
+        }
+        Sheet sheet;
+        Row row;
+        Cell cell;
+        list = new ArrayList<>();
+        //遍历Excel中所有的sheet
+        System.out.println("work.getNumberOfSheets()：" + work.getNumberOfSheets());
+        for (int i = 0; i < work.getNumberOfSheets(); i++) {
+            sheet = work.getSheetAt(i);
+            if (sheet == null) {
+                continue;
+            }
+            int sheetSize = 0;
+            //遍历当前sheet中的所有行
+            //包涵头部，所以要小于等于最后一列数,这里也可以在初始值加上头部行数，以便跳过头部
+            for (int j = sheet.getFirstRowNum(); j <= sheet.getLastRowNum(); j++) {
+                //读取一行
+                row = sheet.getRow(j);
+                //去掉空行和表头
+                if (row == null || row.getFirstCellNum() == j) {
+                    continue;
+                }
+                sheetSize = row.getLastCellNum();
+                //判断当前行是否为空
+                if (isRowEmpty(row)) {
+                    continue;
+                }
+                //遍历所有的列
+                List<Object> li = new ArrayList<Object>();
+                for (int y = row.getFirstCellNum(); y < sheetSize; y++) {
+                    cell = row.getCell(y);
+                    li.add(cell != null ? getCellValue(cell) : null);
+                }
+                list.add(li);
+            }
+        }
+        return list;
+    }
+
+    /**
+     * 判断行是否为空
+     *
+     * @param row 行
+     * @return true:空 ；false：非空
+     */
+    public static boolean isRowEmpty(Row row) {
+
+        for (int i = row.getFirstCellNum(); i < row.getLastCellNum(); i++) {
+            Cell cell = row.getCell(i);
+            if (cell != null && cell.getCellType() != CellType.STRING) {
+                return false;
+            } else {
+                break;
+            }
+        }
+        return true;
+    }
+}

src/main/java/com/rf/kjb/excel/package-info.java

@@ -0,0 +1,4 @@
+package com.rf.kjb.excel;
+/**
+ * excel 文件处理
+ */

src/main/java/com/rf/kjb/exception/ErrorCode.java

@@ -0,0 +1,36 @@
+package com.rf.kjb.exception;
+
+import lombok.Getter;
+
+@Getter
+public enum ErrorCode {
+    /** 系统 **/
+    SUCCESS(200,"处理完成"),
+
+    /** 用户模块错误码 **/
+    USER_EXISTS(1001,"用户已存在"),
+    USER_NOT_EXISTS(1002,"用户不存在"),
+    LOGIN_ERROR(1003, "账号或密码错误"),
+
+    IDENTIFIER_NULL(1004,"用户编号为空"),
+    PASSWORD_DIFF(1005, "两次输入的密码不一致"),
+    ROLE_ERROR(1006,"用户角色有误"),
+    OLD_PWD_ERROR(1007,"旧密码错误"),
+    /** 量表 **/
+    CATEGORY_EXIST(2001,"量表类别已存在"),
+    SCALE_UNUSEFUL(2002,"量表不可用"),
+
+
+
+    ;
+
+
+
+    ErrorCode(int errorCode, String errorMsg) {
+        this.errorCode = errorCode;
+        this.errorMsg = errorMsg;
+    }
+
+    int errorCode;
+    String errorMsg;
+}

src/main/java/com/rf/kjb/exception/KJBException.java

@@ -0,0 +1,16 @@
+package com.rf.kjb.exception;
+
+/**
+ * @Author:zzf
+ * @Date:2022/7/25:11:43
+ * @Description:
+ */
+public class KJBException extends RuntimeException{
+    private static final long serialVersionUID = 1L;
+
+    ErrorCode errorCode;
+
+    public KJBException(ErrorCode errorCode){
+        this.errorCode = errorCode;
+    }
+}

src/main/java/com/rf/kjb/exception/KJBExceptionHandler.java

@@ -0,0 +1,24 @@
+package com.rf.kjb.exception;
+
+import com.rf.kjb.base.rest.BaseController;
+import com.rf.kjb.utils.Result;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+
+import javax.servlet.http.HttpServletRequest;
+
+/**
+ * @Author:zzf
+ * @Date:2022/7/25:11:47
+ * @Description:
+ */
+@RestControllerAdvice
+@Slf4j
+public class KJBExceptionHandler extends BaseController {
+
+    public Result kjbExceptionHandler(HttpServletRequest req,KJBException e){
+        log.error("响应码{},响应消息{}",e.errorCode.errorCode,e.errorCode.errorMsg);
+        return fail(e.errorCode);
+    }
+
+}

src/main/java/com/rf/kjb/filter/DogFilter.java

@@ -0,0 +1,142 @@
+package com.rf.kjb.filter;
+
+
+import com.softkey.SoftKey;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import javax.servlet.*;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/10/29 16:56
+ */
+@Slf4j
+//@Component
+public class DogFilter implements Filter {
+
+    /**
+     * The <code>doFilter</code> method of the Filter is called by the container
+     * each time a request/response pair is passed through the chain due to a
+     * client request for a resource at the end of the chain. The FilterChain
+     * passed in to this method allows the Filter to pass on the request and
+     * response to the next entity in the chain.
+     * <p>
+     * A typical implementation of this method would follow the following
+     * pattern:- <br>
+     * 1. Examine the request<br>
+     * 2. Optionally wrap the request object with a custom implementation to
+     * filter content or headers for input filtering <br>
+     * 3. Optionally wrap the response object with a custom implementation to
+     * filter content or headers for output filtering <br>
+     * 4. a) <strong>Either</strong> invoke the next entity in the chain using
+     * the FilterChain object (<code>chain.doFilter()</code>), <br>
+     * 4. b) <strong>or</strong> not pass on the request/response pair to the
+     * next entity in the filter chain to block the request processing<br>
+     * 5. Directly set headers on the response after invocation of the next
+     * entity in the filter chain.
+     *
+     * @param request  The request to process
+     * @param response The response associated with the request
+     * @param chain    Provides access to the next filter in the chain for this
+     *                 filter to pass the request and response to for further
+     *                 processing
+     * @throws IOException      if an I/O error occurs during this filter's
+     *                          processing of the request
+     * @throws ServletException if the processing fails for any other reason
+     */
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
+
+        HttpServletResponse res = (HttpServletResponse) response;
+        int ret;
+        SoftKey ytsoftkey = new SoftKey();
+        String DevicePath;
+        DevicePath = ytsoftkey.FindPort(0);
+        boolean flag = false;
+        if(ytsoftkey.get_LastError()!=0)
+        {
+            System.out.println("未找到加密锁,请插入加密锁后，再进行操作。");
+            log.error("未找到加密锁,请插入加密锁后，再进行操作。");
+
+
+        }
+        if (ytsoftkey.CheckKeyByFindort_2() == 0)
+        {
+            System.out.println("使用普通算法一来检查:找到指定的加密锁");
+            log.info("使用普通算法一来检查:找到指定的加密锁");
+            flag = true;
+        }
+        else
+        {
+            log.error("使用普通算法一来检查:未能找到指定的加密锁");
+            System.out.println("使用普通算法一来检查:未能找到指定的加密锁");
+        }
+        ret = ytsoftkey.CheckKeyByEncstring();
+        if (ret == 1)
+        {
+            log.error("你生成加密代码时没有设置该函数");
+            System.out.println( "你生成加密代码时没有设置该函数");
+        }
+        if (ret == 0)
+        {
+            log.info("使用增强算法一来检查:找到指定的加密锁");
+            System.out.println("使用增强算法一来检查:找到指定的加密锁");
+            flag = true;
+        }
+        else
+        {
+            log.error("使用增强算法一来检查:未能找到指定的加密锁");
+            System.out.println("使用增强算法一来检查:未能找到指定的加密锁");
+        }
+        ret = ytsoftkey.CheckKeyByEncstring_New();
+        if (ret == 0)
+        {
+            log.info("使用增强算法二来检查:找到指定的加密锁");
+            System.out.println("使用增强算法二来检查:找到指定的加密锁");
+            flag = true;
+        }
+        else
+        {
+            if (ret < 0)
+            {
+                log.error("使用增强算法二来检查:未能找到指定的加密锁");
+                System.out.println("使用增强算法二来检查:未能找到指定的加密锁");
+            }
+            else
+            {
+                if (ret == 2)
+                {
+                    log.error("当前锁不支持这个功能。");
+                    System.out.println("当前锁不支持这个功能。");
+                }
+            }
+        }
+        ret = ytsoftkey.CheckKeyByReadEprom();
+        if (ret == 1)
+        {
+            log.error("加密代码时没有设置该函数");
+            System.out.println("加密代码时没有设置该函数");
+        }
+        if (ret == 0)
+        {
+            log.info("使用读写储存器来检查:找到指定的加密锁");
+            System.out.println("使用读写储存器来检查:找到指定的加密锁");
+            flag = true;
+        }
+        else
+        {
+            log.error("使用读写储存器来检查:未能找到指定的加密锁");
+            System.out.println("使用读写储存器来检查:未能找到指定的加密锁");
+
+        }
+        if(flag){
+            chain.doFilter(request, response);
+        }else {
+            res.sendError(403,"使用读写储存器来检查:未能找到指定的加密锁");
+        }
+    }
+}

src/main/java/com/rf/kjb/filter/JWTInterceptor.java

@@ -0,0 +1,50 @@
+package com.rf.kjb.filter;
+
+import com.alibaba.fastjson.JSON;
+import com.auth0.jwt.exceptions.SignatureVerificationException;
+import com.rf.kjb.user.dao.model.UserEntry;
+import com.rf.kjb.user.service.UserService;
+import com.rf.kjb.utils.JWTUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.web.servlet.HandlerInterceptor;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.util.HashMap;
+
+/**
+ * @author lpf
+ * @description:
+ * @date 2021/12/2821:48
+ */
+@Slf4j
+@Component
+public class JWTInterceptor implements HandlerInterceptor {
+
+    @Override
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
+        HashMap<String, Object> resultJson = new HashMap<>();
+        String uri = request.getRequestURI();
+        log.info("请求uri:" + uri);
+        //获取请求头token
+        try {
+            String token = request.getHeader("Authorization");
+            token = token.split(" ")[1];//以空格划分Bearer token，获取token
+            JWTUtil.verify(token);//验证令牌
+            return true; //放行
+        } catch (SignatureVerificationException e) {
+            e.printStackTrace();
+            resultJson.put("code", HttpServletResponse.SC_UNAUTHORIZED);
+            resultJson.put("msg", "无效签名信息");
+        } catch (Exception e) {
+            e.printStackTrace();
+            resultJson.put("code", HttpServletResponse.SC_UNAUTHORIZED);
+            resultJson.put("msg", "登录状态失效，请重新登录");
+        }
+        String s = JSON.toJSONString(resultJson);
+        response.setContentType("application/json;charset=UTF-8");
+        response.getWriter().println(s);
+        return false;
+    }
+}

src/main/java/com/rf/kjb/filter/JWTInterceptorConfig.java

@@ -0,0 +1,56 @@
+package com.rf.kjb.filter;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
+import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+/**
+ * @author lpf
+ * {@code @description:}
+ * {@code @date} 2021/12/2822:06
+ */
+@Configuration
+public class JWTInterceptorConfig implements WebMvcConfigurer {
+
+    @Autowired
+    private UserCheckInterceptor userCheckInterceptor;
+
+    @Autowired
+    private JWTInterceptor jwtInterceptor;
+
+
+    @Override
+    public void addInterceptors(InterceptorRegistry registry) {
+        //定义排除swagger访问的路径配置
+        String[] swaggerExcludes = new String[]{"/swagger*/**", "/v3/api-docs", "/webjars/**","/doc.html"};
+        String[] user = new String[]{"/v1/user/login", "/v1/user/register","/v1/user/**/checkUser","/v1/user/hello"};
+        String[] record = new String[]{"/v1/record/download/**","/v1/recordPhy/download","/v1/recordPhy/export/all/pulse/target"};
+        registry.addInterceptor(jwtInterceptor)
+                .addPathPatterns("/**")
+                .excludePathPatterns("/", "/index**", "/error")
+                .excludePathPatterns(user)
+                .excludePathPatterns(swaggerExcludes)
+                .excludePathPatterns(record)
+                .excludePathPatterns("/favicon.ico")
+                .excludePathPatterns("/druid/**")
+                .excludePathPatterns("/static/**");//排除静态资源
+        registry.addInterceptor(userCheckInterceptor)
+                .addPathPatterns("/**")
+                .excludePathPatterns("/", "/index.html", "/error")
+                .excludePathPatterns(user)
+                .excludePathPatterns(swaggerExcludes)
+                .excludePathPatterns(record)
+                .excludePathPatterns("/favicon.ico")
+                .excludePathPatterns("/druid/**")
+                .excludePathPatterns("/static/**");//排除静态资源
+
+    }
+
+    @Override
+    public void addResourceHandlers(ResourceHandlerRegistry registry) {
+        registry.addResourceHandler("/static/**")
+                .addResourceLocations("classpath:/static/");
+    }
+}

src/main/java/com/rf/kjb/filter/UserCheckInterceptor.java

@@ -0,0 +1,28 @@
+package com.rf.kjb.filter;
+
+import com.rf.kjb.utils.JWTUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import org.springframework.web.servlet.HandlerInterceptor;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * @author lpf
+ * @description:
+ * @date 2021/01/20 16:54
+ */
+@Slf4j
+@Component
+public class UserCheckInterceptor implements HandlerInterceptor {
+
+    @Override
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
+        //获取请求头token
+        String token = request.getHeader("Authorization");
+        token = token.split(" ")[1];//以空格划分Bearer token，获取token
+        JWTUtil.verify(token);//验证令牌
+
+        return true; //放行
+    }
+}

src/main/java/com/rf/kjb/hospital/dao/model/HospitalEntity.java

@@ -0,0 +1,57 @@
+package com.rf.kjb.hospital.dao.model;
+
+import com.rf.kjb.base.model.BaseEntry;
+import lombok.*;
+import org.hibernate.Hibernate;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+import java.util.Objects;
+
+/**
+ * @Author:zzf
+ * @Date:2023/5/12:10:56
+ * @Description:
+ */
+@Getter
+@Setter
+@ToString
+@RequiredArgsConstructor
+@Entity
+@AllArgsConstructor
+//@NoArgsConstructor
+@Table(name = "t_hospital_info")
+@org.hibernate.annotations.Table(appliesTo = "t_hospital_info", comment = "医院信息表")
+@DynamicUpdate
+public class HospitalEntity extends BaseEntry {
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || Hibernate.getClass(this) != Hibernate.getClass(o)) return false;
+        HospitalEntity that = (HospitalEntity) o;
+        return getId() != null && Objects.equals(getId(), that.getId());
+    }
+
+    @Override
+    public int hashCode() {
+        return getClass().hashCode();
+    }
+
+    @Column(name = "province_code",columnDefinition = "varchar(10) not null comment '地区编码'")
+    private String provinceCode;
+
+    @Column(name = "hospital_name",columnDefinition = "varchar(50) not null comment '医院名称'")
+    private String hospitalName;
+
+    @Column(name = "address",columnDefinition = "varchar(200) not null comment '地址'")
+    private String address;
+
+    @Column(name = "section",columnDefinition = "varchar(20) not null comment '科室'")
+    private String section;
+
+    @Column(name = "contact_number",columnDefinition = "varchar(255) not null comment '联系电话'")
+    private String contactNumber;
+
+}

src/main/java/com/rf/kjb/hospital/dao/repository/HospitalRepository.java

@@ -0,0 +1,7 @@
+package com.rf.kjb.hospital.dao.repository;
+
+import com.rf.kjb.base.repository.BaseRepository;
+import com.rf.kjb.hospital.dao.model.HospitalEntity;
+
+public interface HospitalRepository extends BaseRepository<HospitalEntity,String> {
+}

src/main/java/com/rf/kjb/hospital/rest/HospitalController.java

@@ -0,0 +1,48 @@
+package com.rf.kjb.hospital.rest;
+
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.area.dao.model.ProvinceEntity;
+import com.rf.kjb.area.service.ProvinceService;
+import com.rf.kjb.base.rest.BaseController;
+import com.rf.kjb.hospital.dao.model.HospitalEntity;
+import com.rf.kjb.hospital.service.HospitalService;
+import com.rf.kjb.utils.Result;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * @Author:zzf
+ * @Date:2023/5/12:11:27
+ * @Description:
+ */
+@RestController
+@RequestMapping("/v1/hospital")
+@Slf4j
+@Api(tags = "医院信息")
+public class HospitalController extends BaseController {
+    @Autowired
+    private HospitalService service;
+
+    @ApiOperation(value = "保存",notes = "provinceCode:地区编码；hospitalName：名称；address：地址；section：科室；contactNumber：联系电话")
+    @PostMapping("/save")
+    public Result save(@RequestBody String json){
+        HospitalEntity hospitalEntity = JSONObject.toJavaObject(JSONObject.parseObject(json),HospitalEntity.class);
+        hospitalEntity = this.service.save(hospitalEntity);
+        return success(hospitalEntity);
+    }
+
+
+    @ApiOperation(value = "全量查询",notes = "id:数据库主键；provinceCode：地区编码；hospitalName：名称；address:地址 pageNum：可为空，默认1 ；pageSize：可为空，默认10")
+    @PostMapping("/find")
+    public Result find(@RequestBody String json){
+        JSONObject jsonObject = JSONObject.parseObject(json);
+        Page<HospitalEntity> provinceEntityList = this.service.findAll(jsonObject);
+        return success(provinceEntityList);
+    }
+}

src/main/java/com/rf/kjb/hospital/service/HospitalService.java

@@ -0,0 +1,11 @@
+package com.rf.kjb.hospital.service;
+
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.hospital.dao.model.HospitalEntity;
+import org.springframework.data.domain.Page;
+
+public interface HospitalService {
+    HospitalEntity save(HospitalEntity hospitalEntity);
+
+    Page<HospitalEntity> findAll(JSONObject jsonObject);
+}

src/main/java/com/rf/kjb/hospital/service/impl/HospitalServiceImpl.java

@@ -0,0 +1,57 @@
+package com.rf.kjb.hospital.service.impl;
+
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.hospital.dao.model.HospitalEntity;
+import com.rf.kjb.hospital.dao.repository.HospitalRepository;
+import com.rf.kjb.hospital.service.HospitalService;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+
+import javax.persistence.criteria.Predicate;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @Author:zzf
+ * @Date:2023/5/12:11:28
+ * @Description:
+ */
+@Service
+public class HospitalServiceImpl implements HospitalService {
+
+    @Autowired
+    private HospitalRepository repository;
+    @Override
+    public HospitalEntity save(HospitalEntity hospitalEntity) {
+        return this.repository.save(hospitalEntity);
+    }
+
+    @Override
+    public Page<HospitalEntity> findAll(JSONObject jsonObject) {
+        Specification<HospitalEntity> specification = (root, query, criteriaBuilder) -> {
+            List<javax.persistence.criteria.Predicate> predicateList = new ArrayList<>();
+            if(jsonObject.containsKey("id") && StringUtils.isNotEmpty(jsonObject.getString("id"))){
+                predicateList.add(criteriaBuilder.equal(root.get("id"),jsonObject.getString("id")));
+            }
+            //id:数据库主键；provinceCode：地区编码；hospitalName：名称；address:地址；pageNum：可为空，默认1 ；pageSize：可为空，默认10
+            if(jsonObject.containsKey("provinceCode") && StringUtils.isNotEmpty(jsonObject.getString("provinceCode"))){
+                predicateList.add(criteriaBuilder.equal(root.get("provinceCode"),jsonObject.getString("provinceCode")));
+            }
+            if(jsonObject.containsKey("hospitalName") && StringUtils.isNotEmpty(jsonObject.getString("hospitalName"))){
+                predicateList.add(criteriaBuilder.like(root.get("hospitalName"),"%"+jsonObject.getString("hospitalName")+"%"));
+            }
+            if(jsonObject.containsKey("address") && StringUtils.isNotEmpty(jsonObject.getString("address"))){
+                predicateList.add(criteriaBuilder.like(root.get("address"),"%"+jsonObject.getString("address")+"%"));
+            }
+            query.where(criteriaBuilder.and(predicateList.toArray(new Predicate[0])));
+            return query.getRestriction();
+        };
+        int pageNum = (jsonObject.containsKey("pageNum") && jsonObject.getInteger("pageNum") >0)?jsonObject.getIntValue("pageNum"): 1;
+        int pageSize = (jsonObject.containsKey("pageSize") && jsonObject.getInteger("pageSize") >0)?jsonObject.getIntValue("pageSize"): 10;
+        return this.repository.findAll(specification, PageRequest.of(pageNum-1,pageSize));
+    }
+}

src/main/java/com/rf/kjb/scale/dao/dto/NewResultDto.java

@@ -0,0 +1,36 @@
+package com.rf.kjb.scale.dao.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * @author lpf
+ * @description:
+ * @date 2022/4/20 12:44
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class NewResultDto {
+
+    private String name;
+
+    private String score;
+
+    private String symptom;
+
+    private String improvementSuggestions;
+
+    private String flag;
+
+    private String reference;
+
+    private String nameExplain;
+
+    private String suggestion;
+
+    private String isTotalScoreExplain;
+
+
+}

src/main/java/com/rf/kjb/scale/dao/dto/RecordEntityDto.java

@@ -0,0 +1,30 @@
+package com.rf.kjb.scale.dao.dto;
+
+import com.rf.kjb.scale.dao.model.RecordEntity;
+import lombok.*;
+
+/**
+ * @author lpf
+ * @description: dto类，测试 记录
+ * @date 2022/5/12 15:39
+ */
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class RecordEntityDto extends RecordEntity{
+
+    //量表名称
+    private String name;
+
+    //用户名
+    private String userName;
+
+    //性别
+    private int gender;
+
+    //职业
+    private String profession;
+
+
+}

src/main/java/com/rf/kjb/scale/dao/dto/RecordPhyEntryDTO.java

@@ -0,0 +1,31 @@
+package com.rf.kjb.scale.dao.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+/**
+ * @Author:zzf
+ * @Date:2022/7/28:19:01
+ * @Description:生理测试结果
+ */
+
+@NoArgsConstructor
+@AllArgsConstructor
+@Getter
+@Setter
+public class RecordPhyEntryDTO  {
+
+    private String testDate;
+
+    private String testResult;
+
+    private String sourceData;
+
+    private String type;
+
+    private String filaName;
+
+    private String identifier;
+}

src/main/java/com/rf/kjb/scale/dao/model/AnswerEntity.java

@@ -0,0 +1,52 @@
+package com.rf.kjb.scale.dao.model;
+
+
+import com.rf.kjb.base.model.BaseEntry;
+import com.rf.kjb.scale.util.EncryptDecodeConverter;
+import lombok.*;
+import org.hibernate.annotations.DynamicUpdate;
+import javax.persistence.Column;
+import javax.persistence.Convert;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+/**
+ * @author zzf
+ * @description:答案选项实体类
+ * @date 2021/5/13 11:02
+ */
+@Entity
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "t_answer_info")
+@org.hibernate.annotations.Table(appliesTo = "t_answer_info", comment = "答案选项表")
+@DynamicUpdate
+public class AnswerEntity extends BaseEntry {
+
+    @Column(name = "question_no", columnDefinition = "varchar(10) comment '所属题号'")
+    private String questionNo;
+
+    @Convert(converter = EncryptDecodeConverter.class)
+    @Column(name = "name", columnDefinition = "varchar(500) comment '答案内容'")
+    private String name;
+
+    @Column(name = "options", columnDefinition = "varchar(10) comment '选项值'")
+    private String options;
+
+    @Column(name = "question_type", columnDefinition = "varchar(10) comment '类型：0-单选 1-多选 2-填空'")
+    private String questionType;
+
+    @Convert(converter = EncryptDecodeConverter.class)
+    @Column(name = "score", columnDefinition = "varchar(100) comment '分值'")
+    private String score;
+
+    @Column(name = "score_direction", columnDefinition = "varchar(10) comment '计分方向：1-正向；0-反向'")
+    private String scoreDirection;
+
+    @Column(name = "flag", columnDefinition = "varchar(50) comment '标识：所属量表'")
+    private String flag;
+
+}

src/main/java/com/rf/kjb/scale/dao/model/BaseScale.java

@@ -0,0 +1,19 @@
+package com.rf.kjb.scale.dao.model;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+
+/**
+ * @author zsy
+ * @description:
+ * @date 2021/7/20 15:55
+ */
+public class BaseScale {
+    public JSONArray jsonArray;
+    public JSONObject resultJson;
+
+    public BaseScale(JSONArray jsonArray, JSONObject resultJson){
+        this.jsonArray = jsonArray;
+        this.resultJson = resultJson;
+    }
+}

src/main/java/com/rf/kjb/scale/dao/model/CategoryEntry.java

@@ -0,0 +1,40 @@
+package com.rf.kjb.scale.dao.model;
+
+import com.rf.kjb.base.model.BaseEntry;
+import lombok.*;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Index;
+import javax.persistence.Table;
+
+/**
+ * @author zsy
+ * @description:量表类别信息表
+ * @date 2021/6/17 15:55
+ */
+@Entity
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "t_category_info",indexes = {
+        @Index(columnList = "ename"),
+        @Index(columnList = "type")
+})
+@org.hibernate.annotations.Table(appliesTo = "t_category_info", comment = "量表类别信息表")
+public class CategoryEntry extends BaseEntry {
+
+    @Column(name = "name", columnDefinition = "varchar(10) not null comment '类别名称(唯一)'")
+    private String name;
+
+    @Column(name = "ename", columnDefinition = "varchar(10) not null comment '英文名称(唯一)'")
+    private String ename;
+
+    @Column(name = "sequence", columnDefinition = "int(5) not null comment '排序(唯一)'")
+    private String sequence;
+
+    @Column(name = "type", columnDefinition = "varchar(10) not null comment '类型：0-量表；1-认知任务'")
+    private String type;
+
+}

src/main/java/com/rf/kjb/scale/dao/model/CategorySubjectEntity.java

@@ -0,0 +1,33 @@
+package com.rf.kjb.scale.dao.model;
+
+import com.rf.kjb.base.model.BaseEntry;
+import lombok.*;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Index;
+import javax.persistence.Table;
+
+/**
+ * @author zsy
+ * @description:量表-类别关联表
+ * @date 2021/6/17 15:55
+ */
+@Entity
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "t_category_subject" ,indexes ={
+        @Index(columnList = "flag"),
+        @Index(columnList = "ename")
+})
+@org.hibernate.annotations.Table(appliesTo = "t_category_subject", comment = "量表-类别关联表")
+public class CategorySubjectEntity extends BaseEntry {
+
+    @Column(name="flag" ,columnDefinition = "varchar(50) not null comment '量表查询标志'")
+    private String flag ;
+
+    @Column(name = "ename",columnDefinition = "varchar(10) not null comment '类别英文名称'")
+    private String ename;
+
+}

src/main/java/com/rf/kjb/scale/dao/model/DimensionEntity.java

@@ -0,0 +1,42 @@
+package com.rf.kjb.scale.dao.model;
+
+import com.rf.kjb.base.model.BaseEntry;
+import com.rf.kjb.scale.util.EncryptDecodeConverter;
+import lombok.*;
+import org.hibernate.annotations.DynamicUpdate;
+import javax.persistence.Column;
+import javax.persistence.Convert;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+/**
+ * @author zzf
+ * @description:量表维度实体类
+ * @date 2021/5/13 11:02
+ */
+@Entity
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "t_dimension_info")
+@org.hibernate.annotations.Table(appliesTo = "t_dimension_info", comment = "量表维度表")
+@DynamicUpdate
+public class DimensionEntity extends BaseEntry {
+
+    @Convert(converter = EncryptDecodeConverter.class)
+    @Column(name = "name", columnDefinition = "varchar(400) comment '维度名称'")
+    private String name;
+
+    @Convert(converter = EncryptDecodeConverter.class)
+    @Column(name = "question_no", columnDefinition = "varchar(600) comment '所含题号'")
+    private String questionNo;
+
+    @Column(name = "flag", columnDefinition = "varchar(50) comment '标识：所属量表'")
+    private String flag;
+
+    @Column(name = "is_icon_flag", columnDefinition = "varchar(2) default '0' comment '表示当前字段是否需要在图表展示：0---否，1---是'")
+    private String isIconFlag;
+
+}

src/main/java/com/rf/kjb/scale/dao/model/GameRecordEntity.java

@@ -0,0 +1,53 @@
+package com.rf.kjb.scale.dao.model;
+
+import com.rf.kjb.base.model.BaseEntry;
+import lombok.*;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+/**
+ * @Author:zzf
+ * @Date:2023/6/7:09:55
+ * @Description:
+ */
+@Entity
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "t_game_record_info")
+@org.hibernate.annotations.Table(appliesTo = "t_game_record_info", comment = "游戏记录")
+@DynamicUpdate
+public class GameRecordEntity extends BaseEntry {
+
+    @Column(name = "identifier" ,columnDefinition = "varchar(20) not null  comment '编号'")
+    private String identifier;
+
+    @Column(name = "game_scene",columnDefinition = "varchar(255) not null comment '游戏场景'")
+    private String gameScene;
+
+    @Column(name = "equipment_type",columnDefinition = "varchar(10) not null comment '设备类型'")
+    private String equipmentType;
+
+    @Column(name = "game_difficulty",columnDefinition = "varchar(20) not null comment '游戏难度'")
+    private String  gameDifficulty;
+
+    @Column(name = "game_time",columnDefinition = "varchar(20) not null comment '游戏时间'")
+    private String gameTime;
+
+    @Column(name = "animation_source_list",columnDefinition = "text not null comment '原始数据'")
+    private String animationSourceList;
+
+    @Column(name = "animation_target",columnDefinition = "text not null comment '指标数据'")
+    private String animationTarget;
+
+    @Column(name = "save_time",columnDefinition = "varchar(50) not null comment '保存指标时间'")
+    private String saveTime;
+
+    @Column(name = "file_name",columnDefinition = "varchar(100) not null comment '文件名'")
+    private String fileName;
+}

src/main/java/com/rf/kjb/scale/dao/model/RecordEntity.java

@@ -0,0 +1,51 @@
+package com.rf.kjb.scale.dao.model;
+
+import com.rf.kjb.base.model.BaseEntry;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+/**
+ * @author zsy
+ * @description:用户测试记录信息表
+ * @date 2021/6/17 15:55
+ */
+@Entity
+@Data
+@EqualsAndHashCode(callSuper = true)
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "t_user_record")
+@org.hibernate.annotations.Table(appliesTo = "t_user_record", comment = "用户测试记录信息表")
+public class RecordEntity extends BaseEntry {
+
+    @Column(name = "identifier", columnDefinition = "varchar(11) not null comment '用户手机号（登录账号）'")
+    private String identifier;
+
+    @Column(name = "flag", columnDefinition = "varchar(50) comment '量表/认知任务/生理标志'")
+    private String flag;
+
+    @Column(name = "test_date", columnDefinition = "varchar(50) not null comment '测试日期'")
+    private String testDate;
+
+    @Column(name = "test_result", columnDefinition = "text comment '测试结果'")
+    private String testResult;
+
+    @Column(name = "test_results", columnDefinition = "text comment '测试结果(String类型)'")
+    private String testResults;
+
+    @Column(name = "file_name", columnDefinition = "varchar(255) comment '测试结果文件名称'")
+    private String fileName;
+
+    @Column(name = "img", columnDefinition = "text comment 'b64格式图片'")
+    private String img;
+
+    @Column(name = "test_record", columnDefinition = "text comment '答题记录'")
+    private String testRecord;
+
+}

src/main/java/com/rf/kjb/scale/dao/model/RecordPhyEntry.java

@@ -0,0 +1,49 @@
+package com.rf.kjb.scale.dao.model;
+
+import com.rf.kjb.base.model.BaseEntry;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+/**
+ * @Author:zzf
+ * @Date:2022/7/28:19:01
+ * @Description:生理测试结果
+ */
+@Entity
+@Data
+@EqualsAndHashCode(callSuper=true)
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "t_user_record_phy")
+@org.hibernate.annotations.Table(appliesTo = "t_user_record_phy", comment = "生理测试记录")
+@DynamicUpdate
+public class RecordPhyEntry extends BaseEntry {
+
+    @Column(name = "test_date", columnDefinition = "varchar(50) not null comment '测试日期'")
+    private String testDate;
+
+    @Column(name = "test_result", columnDefinition = "mediumtext comment '测试结果'")
+    private String testResult;
+
+    @Column(name = "source_data",columnDefinition = "text comment '原始数据'")
+    private String sourceData;
+
+    @Column(name = "type", columnDefinition = "varchar(2) comment '类型：1为脉搏；2为心电；3为脑电'")
+    private String type;
+
+    @Column(name = "file_name",columnDefinition = "varchar(255) comment '文件名称'")
+    private String fileName;
+
+    @Column(name = "identifier",columnDefinition = "varchar(20) comment '用户编号'")
+    private String identifier;
+
+    @Column(name = "target",columnDefinition = "text comment '指标数据'")
+    private String target;
+}

src/main/java/com/rf/kjb/scale/dao/model/ScaleConfigEntry.java

@@ -0,0 +1,42 @@
+package com.rf.kjb.scale.dao.model;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.rf.kjb.base.model.BaseEntry;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.DynamicUpdate;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Index;
+import javax.persistence.Table;
+import java.time.LocalDateTime;
+
+/**
+ * @author lpf
+ * @description: 量表结果计算类注册实体类
+ * @date 2022/5/28 16:15
+ */
+@Entity
+@Data
+@EqualsAndHashCode(callSuper=true)
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "t_scale_config",indexes = {
+        @Index(columnList = "flag")
+})
+@org.hibernate.annotations.Table(appliesTo = "t_scale_config", comment = "量表注册信息量表")
+@DynamicUpdate
+public class ScaleConfigEntry extends BaseEntry {
+
+    @Column(name = "flag", columnDefinition = "varchar(50) comment '标识：所属量表'")
+    private String flag;
+
+    @Column(name = "type", columnDefinition = "varchar(2) comment '类型：0-量表；1-认知任务'")
+    private String type;
+
+    @Column(name = "result_config", columnDefinition = "text comment '量表或认知任务对应的配置java类'")
+    private String resultConfig;
+
+}

src/main/java/com/rf/kjb/scale/dao/model/ScaleEntry.java

@@ -0,0 +1,72 @@
+package com.rf.kjb.scale.dao.model;
+
+import com.rf.kjb.base.model.BaseEntry;
+import com.rf.kjb.scale.util.EncryptDecodeConverter;
+import lombok.*;
+import org.hibernate.annotations.DynamicUpdate;
+import javax.persistence.Column;
+import javax.persistence.Convert;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+/**
+ * @author zzf
+ * @description:量表通用实体类，表格导入的量表
+ * @date 2021/5/13 11:02
+ */
+@Entity
+@Data
+@EqualsAndHashCode(callSuper=true)
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "t_scale_info")
+@org.hibernate.annotations.Table(appliesTo = "t_scale_info", comment = "通用量表")
+@DynamicUpdate
+public class ScaleEntry extends BaseEntry {
+
+    @Column(name = "question_no", columnDefinition = "varchar(10) comment '题号'")
+    private String questionNo;
+
+    @Column(name = "serial_no", columnDefinition = "varchar(10) comment '序号，展示顺序'")
+    private String serialNo;
+
+    @Column(name = "content", columnDefinition = "varchar(3000) comment '题目内容'")
+    @Convert(converter = EncryptDecodeConverter.class)
+    private String answer;
+
+    @Column(name = "check_item", columnDefinition = "varchar(3000) comment '选项'")
+    @Convert(converter = EncryptDecodeConverter.class)
+    private String checkItems;
+
+    @Column(name = "question_type", columnDefinition = "varchar(10) comment '类型：0-单选 1-多选 2-填空'")
+    private String questionType;
+
+    @Column(name = "weight", columnDefinition = "varchar(10) comment '分量'")
+    private String weight;
+
+    @Column(name = "score", columnDefinition = "varchar(10) comment '分值'")
+    private String score;
+
+    @Column(name = "score_direction", columnDefinition = "varchar(10) comment '计分方向：1-正向；0-反向'")
+    private String scoreDirection;
+
+    @Column(name = "flag", columnDefinition = "varchar(50) comment '标识：所属量表'")
+    private String flag;
+
+    ///**
+    // * 加密
+    // */
+    //public void encrypt() {
+    //    this.answer = DESede.encryptString(this.answer);
+    //    this.checkItems = DESede.encryptString(this.checkItems);
+    //}
+    //
+    ///**
+    // * 解密代码
+    // */
+    //public void decrypt() {
+    //    this.answer = DESede.decryptString(this.answer);
+    //    this.checkItems = DESede.decryptString(this.checkItems);
+    //}
+
+}

src/main/java/com/rf/kjb/scale/dao/model/ScaleMarksEntity.java

@@ -0,0 +1,72 @@
+package com.rf.kjb.scale.dao.model;
+
+import com.rf.kjb.base.model.BaseEntry;
+import com.rf.kjb.scale.util.EncryptDecodeConverter;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.DynamicUpdate;
+
+import javax.persistence.Column;
+import javax.persistence.Convert;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+/**
+ * @author zzf
+ * @description:评分规则实体类
+ * @date 2021/5/13 11:02
+ */
+@Entity
+@Data
+@EqualsAndHashCode(callSuper=true)
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "t_scale_marks")
+@org.hibernate.annotations.Table(appliesTo = "t_scale_marks", comment = "评分规则表")
+@DynamicUpdate
+public class ScaleMarksEntity extends BaseEntry {
+
+    @Column(name = "name", columnDefinition = "varchar(400) comment '维度名称'")
+    @Convert(converter = EncryptDecodeConverter.class)
+    private String name;
+
+    @Column(name = "score_start", columnDefinition = "varchar(100) comment '起始分'")
+    @Convert(converter = EncryptDecodeConverter.class)
+    private String scoreStart;
+
+    @Column(name = "score_end", columnDefinition = "varchar(100) comment '结束分'")
+    @Convert(converter = EncryptDecodeConverter.class)
+    private String scoreEnd;
+
+    @Column(name = "symptom", columnDefinition = "text comment '该分段症状'")
+    @Convert(converter = EncryptDecodeConverter.class)
+    private String symptom;
+
+    @Column(name = "improvement_suggestions", columnDefinition = "text comment '该分段指导语'")
+    @Convert(converter = EncryptDecodeConverter.class)
+    private String improvementSuggestions;
+
+    @Column(name = "flag", columnDefinition = "varchar(50) comment '标识：所属量表'")
+    private String flag;
+
+    @Column(name = "reference", columnDefinition = "varchar(300) default '无' comment '常模参考值'")
+    @Convert(converter = EncryptDecodeConverter.class)
+    private String reference;
+
+    @Column(name = "standard_deviation", columnDefinition = "varchar(300) default '无' comment '标准差'")
+    @Convert(converter = EncryptDecodeConverter.class)
+    private String standardDeviation;
+
+    @Column(name = "name_explain", columnDefinition = "text comment '因子解释'")
+    @Convert(converter = EncryptDecodeConverter.class)
+    private String nameExplain;
+
+    @Column(name = "suggestion", columnDefinition = "text comment '建议'")
+    @Convert(converter = EncryptDecodeConverter.class)
+    private String suggestion;
+
+    @Column(name = "is_total_score_explain", columnDefinition = "varchar(50) default '否' comment '是否为总分解读'")
+    private String isTotalScoreExplain;
+}

src/main/java/com/rf/kjb/scale/dao/model/SubjectEntity.java

@@ -0,0 +1,81 @@
+package com.rf.kjb.scale.dao.model;
+
+import com.rf.kjb.base.model.BaseEntry;
+import com.rf.kjb.scale.util.EncryptDecodeConverter;
+import lombok.*;
+import javax.persistence.Column;
+import javax.persistence.Convert;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+/**
+ * @author zzf
+ * @description:量表和认知任务列表
+ * @date 2021/5/17 9:25
+ */
+@Entity
+@Data
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "t_subject_info")
+@org.hibernate.annotations.Table(appliesTo = "t_subject_info", comment = "量表和认知任务列表信息表")
+public class SubjectEntity extends BaseEntry {
+
+    @Column(name = "no", columnDefinition = "int(10) comment '编号，用于排序'")
+    private int no;
+
+    @Column(name = "flag", columnDefinition = "varchar(50) comment '查询标志'")
+    private String flag;
+
+    @Column(name = "name", columnDefinition = "varchar(255) comment '量表/认知任务名称'")
+    private String name;
+
+    @Column(name = "type", columnDefinition = "varchar(10) comment '类型：0-量表；1-认知任务'")
+    private String type;
+
+    @Convert(converter = EncryptDecodeConverter.class)
+    @Column(name = "description", columnDefinition = "text comment'描述文字信息'")
+    private String description;
+
+    @Column(name = "is_hot", columnDefinition = "varchar(1) comment '是否热门测试'")
+    private String isHot;
+
+    @Column(name = "test_num", columnDefinition = "int(10) comment '测试次数'")
+    private int testNum;
+
+    @Column(name = "is_new", columnDefinition = "varchar(1) comment '最新测试'")
+    private int isNew;
+
+    @Column(name = "image_url", columnDefinition = "varchar(200) comment '图片路径'")
+    private String imageUrl;
+
+    @Column(name = "uploader", columnDefinition = "varchar(50) comment '上传人'")
+    private String uploader;
+
+    @Column(name = "ename", columnDefinition = "varchar(255) comment '量表英文名称'")
+    private String eName;
+
+    @Column(name = "file_name", columnDefinition = "varchar(50) comment '量表文件名称'")
+    private String fileName;
+
+    @Column(name = "scoring_principle", columnDefinition = "text comment '计分原则'")
+    private String scoringPrinciple;
+
+    @Column(name = "status", columnDefinition = "varchar(1) comment '状态：0-可用(未检测)；1-不可用;2-通过；3-未通过'")
+    private int status;
+
+    @Column(name = "scale_limit", columnDefinition = "varchar(10) comment '量表权限:private 私密  public 公开'")
+    private String scaleLimit;
+
+    @Column(name = "men",columnDefinition = "varchar(20) comment '适用人群 ：0 全部  1 儿童 2 小学生 3中学及以上 4军警 5老年人'")
+    private String men;
+
+    @Column(name = "icon_info", columnDefinition = "varchar(10) default '无' comment '图表信息(若量表需要展示图表，不展示则显示无)'")
+    private String iconInfo;
+
+    @Column(name = "report_version", columnDefinition = "int default 1 comment '报告版本信息，默认为1---第一版本报告，详见SubjectConstant.class'")
+    private Integer reportVersion;
+
+}

src/main/java/com/rf/kjb/scale/dao/repository/AnswerRepository.java

@@ -0,0 +1,48 @@
+package com.rf.kjb.scale.dao.repository;
+;
+import com.rf.kjb.base.repository.BaseRepository;
+import com.rf.kjb.scale.dao.model.AnswerEntity;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:
+ * @date 2021/5/14 10:54
+ */
+public interface AnswerRepository extends BaseRepository<AnswerEntity, String> {
+
+
+    /**
+     * 根据flag获取全部答案
+     *
+     * @param flag
+     * @return
+     */
+    @Query(value = "select id,question_no,name,options,question_type,score,score,score_direction,flag,create_time,update_time from t_answer_info where flag = :flag", nativeQuery = true)
+    List<AnswerEntity> getAnswerByFlag(@Param("flag") String flag);
+
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "delete from t_answer_info", nativeQuery = true)
+    void deleteAll();
+
+    /**
+     * 根据id修改指定字段
+     *
+     * @return
+     */
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "UPDATE t_answer_info SET name = :name, score = :score WHERE id = :id ", nativeQuery = true)
+    void updateAnswer(@Param("name") String name, @Param("score") String score, @Param("id") String id);
+
+    @Transactional
+    @Modifying
+    @Query(value = "delete from t_answer_info where flag=:flag  ", nativeQuery = true)
+    void deleteAnswerByFlag(@Param("flag")String flag);
+}

src/main/java/com/rf/kjb/scale/dao/repository/CategoryRepository.java

@@ -0,0 +1,153 @@
+package com.rf.kjb.scale.dao.repository;
+
+import com.rf.kjb.base.repository.BaseRepository;
+import com.rf.kjb.scale.dao.model.CategoryEntry;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:Category
+ * @date 2021/6/17 15:55
+ */
+public interface CategoryRepository extends BaseRepository<CategoryEntry, String> {
+
+    /**
+     * 查询  分页
+     *
+     * @param pageNum
+     * @param pageSize
+     * @return
+     */
+    @Query(value = "select id,ename,name,sequence,type from t_category_info order by sequence limit :pageNum ,:pageSize ", nativeQuery = true)
+    List<CategoryEntry> findAll(@Param("pageNum") int pageNum, @Param("pageSize") int pageSize);
+
+    /**
+     * 总条数
+     *
+     * @return
+     */
+    @Query(value = "select count(1) from t_category_info   ", nativeQuery = true)
+    int allNum();
+
+    /**
+     * 根据名称模糊查询  分页
+     *
+     * @param pageNum
+     * @param pageSize
+     * @param searchStr
+     * @return
+     */
+    @Query(value = "select id,ename,name,sequence,type from t_category_info where name like %:searchStr% or ename like %:searchStr% order by sequence limit :pageNum ,:pageSize ", nativeQuery = true)
+    List<CategoryEntry> getSubjectListByName(@Param("pageNum") int pageNum, @Param("pageSize") int pageSize, @Param("searchStr") String searchStr);
+
+    /**
+     * 根据名称模糊查询总条数
+     *
+     * @param searchStr
+     * @return
+     */
+    @Query(value = "select count(1) from t_category_info where name like %:searchStr% or ename like %:searchStr%   ", nativeQuery = true)
+    int allNumByName(@Param("searchStr") String searchStr);
+
+    /**
+     * 效验是否存在
+     *
+     * @param name
+     * @param ename
+     * @param sequence
+     * @return
+     */
+    @Query(value = "select id,ename,name,sequence,type from t_category_info where name = :name or ename = :ename or sequence = :sequence", nativeQuery = true)
+    List<CategoryEntry> getCategoryByName(@Param("name") String name, @Param("ename") String ename, @Param("sequence") String sequence);
+
+    /**
+     * 查询所有类别信息
+     *
+     * @return
+     */
+    @Query(value = "select id,ename,name,sequence,type from t_category_info where type = :type and ename in (SELECT a.ename FROM t_category_subject a GROUP BY a.ename) order by sequence", nativeQuery = true)
+    List<CategoryEntry> findAllOrder(@Param("type") String type);
+
+
+    /**
+     * 查询机构的认知任务类别信息
+     *
+     * @return
+     */
+    @Query(value = "select id, ename, name, sequence, type\n" +
+            "from t_category_info\n" +
+            "where  ename in (select distinct(tcs.ename)\n" +
+            "                from   t_cognitive_task tct\n" +
+            "                         join\n" +
+            "                     t_institution_auth tia\n" +
+            "                         join\n" +
+            "                     t_category_subject tcs\n" +
+            "                     on tcs.flag = tct.task_code\n" +
+            "                         and b_id = tct.id\n" +
+            "                where tia.institution_no = ?1  and status='0'\n" +
+            "        ) or ename='CALL' order by sequence", nativeQuery = true)
+    List<CategoryEntry> findAllCTInstitution(String institutionNo);
+
+    /**
+     * 查询组的认知任务类别信息
+     *
+     * @return
+     */
+    @Query(value = "select id, ename, name, sequence, type\n" +
+            "from t_category_info\n" +
+            "where  ename in (select distinct(tcs.ename)\n" +
+            "                 from   t_cognitive_task tct\n" +
+            "                            join\n" +
+            "                        t_group_auth tga\n" +
+            "                            join\n" +
+            "                        t_category_subject tcs\n" +
+            "                        on tcs.flag = tct.task_code\n" +
+            "                            and b_id = tct.id\n" +
+            "                 where tga.group_id = ?1 and status='0'\n" +
+            ") or ename='CALL'\n" +
+            "order by sequence\n", nativeQuery = true)
+    List<CategoryEntry> findAllCTByGroup(String groupId);
+
+    /**
+     * 查询机构的量表类别信息
+     *
+     * @return
+     */
+    @Query(value = "select id, ename, name, sequence, type\n" +
+            "from t_category_info\n" +
+            "where ename in (select distinct(tcs.ename)\n" +
+            "                from t_subject_info tsi\n" +
+            "                         join\n" +
+            "                     t_institution_auth tia\n" +
+            "                         join\n" +
+            "                     t_category_subject tcs\n" +
+            "                     on tcs.flag = tsi.flag\n" +
+            "                         and b_id = tsi.id\n" +
+            "                where tia.institution_no = ?1 and status='0'\n" +
+            ")\n" +
+            "   or ename = 'ALL'  order by sequence ", nativeQuery = true)
+    List<CategoryEntry> findAllSubjectInstitution(String institutionNO);
+
+    /**
+     * 查询组的量表类别信息
+     *
+     * @return
+     */
+    @Query(value = "select id, ename, name, sequence, type\n" +
+            "from t_category_info\n" +
+            "where ename in (select distinct(tcs.ename)\n" +
+            "                from t_subject_info tsi\n" +
+            "                         join\n" +
+            "                     t_group_auth tga \n" +
+            "                         join\n" +
+            "                     t_category_subject tcs\n" +
+            "                     on tcs.flag = tsi.flag\n" +
+            "                         and b_id = tsi.id\n" +
+            "                where tga.group_id= ?1 and status='0'\n" +
+            ")\n" +
+            "   or ename = 'ALL' order by sequence ", nativeQuery = true)
+    List<CategoryEntry> findAllSubjectGroup(String groupId);
+}

src/main/java/com/rf/kjb/scale/dao/repository/CategorySubjectRepository.java

@@ -0,0 +1,27 @@
+package com.rf.kjb.scale.dao.repository;
+
+import com.rf.kjb.base.repository.BaseRepository;
+import com.rf.kjb.scale.dao.model.CategorySubjectEntity;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:Category
+ * @date 2021/6/17 15:55
+ */
+public interface CategorySubjectRepository extends BaseRepository<CategorySubjectEntity,String> {
+    @Query(value = "select id,ename,flag from t_category_subject where flag=:flag  ", nativeQuery = true)
+    List<CategorySubjectEntity> findByFlag(@Param("flag") String flag);
+
+    @Transactional
+    @Modifying
+    @Query(value = "delete from t_category_subject where flag=:flag  ", nativeQuery = true)
+    void deleteCategorySubjectByFlag(@Param("flag") String flag);
+
+    List<CategorySubjectEntity> findByEname(String typeName);
+}

src/main/java/com/rf/kjb/scale/dao/repository/DimensionRepository.java

@@ -0,0 +1,48 @@
+package com.rf.kjb.scale.dao.repository;
+
+import com.rf.kjb.base.repository.BaseRepository;
+import com.rf.kjb.scale.dao.model.DimensionEntity;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:
+ * @date 2021/5/14 10:54
+ */
+public interface DimensionRepository extends BaseRepository<DimensionEntity,String> {
+
+
+    /**
+     * 根据flag查询维度信息
+     * @param flag
+     * @return
+     */
+    @Query(value="select id,question_no,name,flag,is_icon_flag,create_time,update_time from t_dimension_info where flag = :flag",nativeQuery=true)
+    List<DimensionEntity> getDimensionByFlag(@Param("flag") String flag);
+
+
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "delete from t_dimension_info", nativeQuery = true)
+    void deleteAll();
+
+    /**
+     * 根据id修改指定字段
+     *
+     * @return
+     */
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "UPDATE t_dimension_info SET name = :name, question_no = :questionNo WHERE id = :id ", nativeQuery = true)
+    void updateDimension(@Param("name")String name, @Param("questionNo")String questionNo,@Param("id") String id);
+
+    @Transactional
+    @Modifying
+    @Query(value = "delete from t_dimension_info where flag=:flag  ", nativeQuery = true)
+    void deleteDimensionByFlag(@Param("flag")String flag);
+}

src/main/java/com/rf/kjb/scale/dao/repository/GameRecordRepository.java

@@ -0,0 +1,8 @@
+package com.rf.kjb.scale.dao.repository;
+
+import com.rf.kjb.base.repository.BaseRepository;
+import com.rf.kjb.scale.dao.model.GameRecordEntity;
+
+public interface GameRecordRepository extends BaseRepository<GameRecordEntity,String> {
+
+}

src/main/java/com/rf/kjb/scale/dao/repository/RecordPhyRepository.java

@@ -0,0 +1,43 @@
+package com.rf.kjb.scale.dao.repository;
+
+import com.rf.kjb.base.repository.BaseRepository;
+import com.rf.kjb.scale.dao.model.RecordPhyEntry;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import java.util.List;
+
+public interface RecordPhyRepository extends BaseRepository<RecordPhyEntry,String> {
+
+    /**
+     * 删选identifier
+     * @param identifiers
+     * @param type
+     * @param startDate
+     * @param endDate
+     * @param i
+     * @param pageSize
+     * @return
+     */
+
+    @Query(value = "select distinct identifier from t_user_record_phy t where 1 = 1" +
+            " and if ( :type is not null and :type != '',t.type = :type ,1=1) " +
+            " and if (:startDate is not null and :startDate != '',t.test_date >= :startDate,1=1)" +
+            " and if (:endDate is not null and :endDate != '',t.test_date <= :endDate,1=1)" +
+            " and if (:userName is not null and :userName != '',t.identifier in (select identifier from t_user_info where user_name like :userName),1=1)" +
+            " limit :pageNum,:pageSize",nativeQuery = true)
+    List<String> findIdentifiers(@Param("type") String type, @Param("startDate") String startDate,@Param("userName") String userName, @Param("endDate") String endDate,@Param("pageNum") int pageNum,@Param("pageSize") int pageSize);
+
+    @Query(value = "select count(distinct identifier) from t_user_record_phy t where 1 = 1" +
+            " and if ( :type is not null and :type != '',t.type = :type ,1=1) " +
+            " and if (:startDate is not null and :startDate != '',t.test_date >= :startDate,1=1)" +
+            " and if (:endDate is not null and :endDate != '',t.test_date <= :endDate,1=1)" +
+            " and if (:userName is not null and :userName != '',t.identifier in (select identifier from t_user_info where user_name like :userName),1=1)" +
+            "",nativeQuery = true)
+    int findIdentifiersCount(@Param("type") String type, @Param("startDate") String startDate,@Param("userName") String userName, @Param("endDate") String endDate);
+
+    List<RecordPhyEntry> findByType(String type);
+
+
+//    List<String> findIdentifiers(@Param("type") String type,@Param("userName") String userName,@Param("pageNum") int pageNum,@Param("pageSize") int pageSize);
+}

src/main/java/com/rf/kjb/scale/dao/repository/RecordRepository.java

@@ -0,0 +1,45 @@
+package com.rf.kjb.scale.dao.repository;
+
+import com.rf.kjb.base.repository.BaseRepository;
+import com.rf.kjb.scale.dao.model.RecordEntity;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:用户测试记录
+ * @date 2021/6/17 15:55
+ */
+public interface RecordRepository extends BaseRepository<RecordEntity, String> {
+
+
+    /**
+     * 根据id查询数据
+     *
+     * @return
+     */
+    @Query(value = "select * from t_user_record where id = :id ", nativeQuery = true)
+    RecordEntity getUserRecordById(@Param("id") String id);
+
+
+    @Query(value = "select distinct identifier from t_user_record t where 1 = 1" +
+            " and if (:startDate is not null and :startDate != '',t.test_date >= :startDate,1=1)" +
+            " and if (:endDate is not null and :endDate != '',t.test_date <= :endDate,1=1)" +
+            " and if (:flag is not null and :flag != '',t.flag = flag,1=1)" +
+            " and if (:userName is not null and :userName != '',t.identifier in (select identifier from t_user_info where user_name like :userName),1=1)" +
+            " limit :pageNum,:pageSize",nativeQuery = true)
+    List<String> findIdentifiers(@Param("flag") String flag ,@Param("startDate") String startDate, @Param("userName") String userName, @Param("endDate") String endDate, @Param("pageNum") int pageNum, @Param("pageSize") int pageSize);
+
+    @Query(value = "select count(distinct identifier) from t_user_record t where 1 = 1" +
+            " and if (:startDate is not null and :startDate != '',t.test_date >= :startDate,1=1)" +
+            " and if (:endDate is not null and :endDate != '',t.test_date <= :endDate,1=1)" +
+            " and if (:flag is not null and :flag != '',t.flag = flag,1=1)" +
+            " and if (:userName is not null and :userName != '',t.identifier in (select identifier from t_user_info where user_name like :userName),1=1)" +
+            "",nativeQuery = true)
+    int findIdentifiersCount(@Param("flag") String flag, @Param("startDate") String startDate,@Param("userName") String userName, @Param("endDate") String endDate);
+}

src/main/java/com/rf/kjb/scale/dao/repository/ScaleConfigRepository.java

@@ -0,0 +1,28 @@
+package com.rf.kjb.scale.dao.repository;
+
+import com.rf.kjb.base.repository.BaseRepository;
+import com.rf.kjb.scale.dao.model.ScaleConfigEntry;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * @author lpf
+ * @description:
+ * @date 2022/5/28 16:29
+ */
+public interface ScaleConfigRepository extends BaseRepository<ScaleConfigEntry, String> {
+
+    @Transactional
+    @Modifying
+    @Query(value = "delete from t_scale_config where flag= :flag  ", nativeQuery = true)
+    void deleteScaleConfigEntitiesByFlag(@Param("flag") String flag);
+
+    @Transactional
+    @Modifying
+    @Query(value = "update t_scale_config set result_config = ?2  where flag= ?1  ", nativeQuery = true)
+    void updateByFlag(String flag, String resultConfig);
+
+    ScaleConfigEntry findByFlag(String flag);
+}

src/main/java/com/rf/kjb/scale/dao/repository/ScaleMarksRepository.java

@@ -0,0 +1,60 @@
+package com.rf.kjb.scale.dao.repository;
+
+import com.rf.kjb.base.repository.BaseRepository;
+import com.rf.kjb.scale.dao.model.ScaleMarksEntity;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:
+ * @date 2021/5/14 10:54
+ */
+public interface ScaleMarksRepository extends BaseRepository<ScaleMarksEntity,String> {
+
+    /**
+     * 根据flag获取全部评分规则
+     *
+     * @param flag
+     * @return
+     */
+    @Query(value = "select id, flag, improvement_suggestions, score_end, score_start, symptom, name, name_explain, reference,standard_deviation,suggestion, is_total_score_explain,create_time,update_time from t_scale_marks where flag = :flag", nativeQuery = true)
+    List<ScaleMarksEntity> getScaleMarksByFlag(@Param("flag") String flag);
+
+    /**
+     * 根据id修改量表
+     *
+     * @return
+     */
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "UPDATE t_scale_marks SET symptom = :symptom, improvement_suggestions = :improvementSuggestions WHERE id = :id ", nativeQuery = true)
+    void updateById(@Param("id") String id, @Param("symptom") String symptom, @Param("improvementSuggestions") String improvementSuggestions);
+
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "delete from t_scale_marks", nativeQuery = true)
+    void deleteAll();
+
+    /**
+     * 根据id修改指定字段
+     *
+     * @return
+     */
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "UPDATE t_scale_marks SET improvement_suggestions = :improvementSuggestions" +
+            ", score_end = :scoreEnd" +
+            ", score_start = :scoreStart" +
+            ", name = :name" +
+            ", symptom = :symptom WHERE id = :id ", nativeQuery = true)
+    void updateMark(@Param("name") String name, @Param("scoreStart") String scoreStart,@Param("scoreEnd")  String scoreEnd,@Param("symptom")  String symptom, @Param("improvementSuggestions") String improvementSuggestions, @Param("id") String id);
+
+    @Transactional
+    @Modifying
+    @Query(value = "delete from t_scale_marks where flag=:flag  ", nativeQuery = true)
+    void deleteScaleMarkByFlag(@Param("flag")String flag);
+}

src/main/java/com/rf/kjb/scale/dao/repository/ScaleRepository.java

@@ -0,0 +1,42 @@
+package com.rf.kjb.scale.dao.repository;
+
+import com.rf.kjb.base.repository.BaseRepository;
+import com.rf.kjb.scale.dao.model.ScaleEntry;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/5/14 10:54
+ */
+public interface ScaleRepository extends BaseRepository<ScaleEntry,String> {
+
+    /**
+     * 根据flag查询检测列表
+     * @param flag
+     * @return
+     */
+    @Query(value="select id,check_item,content,flag,question_no,question_type,score,score_direction,serial_no,weight,create_time,update_time from t_scale_info where flag = :flag order by question_no+0,serial_no+0 ",nativeQuery=true)
+    List<ScaleEntry> getScaleByFlag(@Param("flag")String flag);
+
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "delete from t_scale_info", nativeQuery = true)
+    void deleteAll();
+
+    /**
+     * 根据id修改指定字段
+     *
+     * @return
+     */
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "UPDATE t_scale_info SET content = :answer, check_item = :checkItems WHERE id = :id ", nativeQuery = true)
+    void updateScale(@Param("answer")String answer, @Param("checkItems")String checkItems, @Param("id")String id);
+
+}

src/main/java/com/rf/kjb/scale/dao/repository/SubjectRepository.java

@@ -0,0 +1,93 @@
+package com.rf.kjb.scale.dao.repository;
+
+import com.rf.kjb.base.repository.BaseRepository;
+import com.rf.kjb.scale.dao.model.SubjectEntity;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
+import java.util.List;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/5/17 9:46
+ */
+public interface SubjectRepository extends BaseRepository<SubjectEntity, String> {
+    /**
+     * 查询
+     *
+     * @param type 0：量表   1：认知任务
+     * @return
+     */
+    @Query(value = "select * from t_subject_info where type = :type", nativeQuery = true)
+    List<SubjectEntity> findAll(@Param("type") String type);
+
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "delete from t_subject_info", nativeQuery = true)
+    void deleteAll();
+
+    /**
+     * 检索，根据中文名、英文名或录入人
+     *
+     * @param pageNum
+     * @param pageSize
+     * @param searchName
+     * @return
+     */
+    @Query(value = "select id,flag,name,no,type,is_hot,test_num,description,is_new,image_url,uploader,ename,file_name ,scoring_principle,status,scale_limit,men,icon_info from t_subject_info tsi where name like %:searchName% or ename like %:searchName%  order by flag desc  limit :pageNum ,:pageSize ", nativeQuery = true)
+    List<SubjectEntity> findByNameOrUploader(@Param("pageNum") int pageNum, @Param("pageSize") int pageSize, @Param("searchName") String searchName);
+
+    /**
+     * 查询  分页
+     *
+     * @param pageNum
+     * @param pageSize
+     * @return
+     */
+    @Query(value = "select id,flag,name,no,type,is_hot,test_num,description,is_new,image_url,uploader,ename,file_name,scoring_principle,status,scale_limit,men,icon_info from t_subject_info order by status,flag desc  limit :pageNum ,:pageSize ", nativeQuery = true)
+    List<SubjectEntity> findAll(@Param("pageNum") int pageNum, @Param("pageSize") int pageSize);
+
+    /**
+     * 根据flag查询
+     *
+     * @return
+     */
+    @Query(value = "select id,flag,name,no,type,is_hot,test_num,description,is_new,image_url,uploader,ename,file_name,scoring_principle,status,scale_limit,men,icon_info,create_time,update_time,report_version from t_subject_info where flag = :flag ", nativeQuery = true)
+    SubjectEntity getSubjectByFlag(@Param("flag") String flag);
+
+    /**
+     * 根据flag记录测试数
+     *
+     * @return
+     */
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "UPDATE t_subject_info SET test_num = test_num+1 WHERE flag = :flag ", nativeQuery = true)
+    void addTestNum(@Param("flag") String flag);
+
+    /**
+     * 修改量表测试结果效验状态
+     *
+     * @return
+     */
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "UPDATE t_subject_info SET status = :status WHERE flag = :flag ", nativeQuery = true)
+    void updateScaleStatus(@Param("flag") String flag, @Param("status") String status);
+
+    /**
+     * 根据id修改指定字段
+     *
+     * @return
+     */
+    @Transactional
+    @Modifying(clearAutomatically = true)
+    @Query(value = "UPDATE t_subject_info SET description = :description WHERE id = :id ", nativeQuery = true)
+    void updateSubject(@Param("description") String description, @Param("id") String id);
+
+
+    @Query(value = "select * from t_subject_info where name like :scaleName",nativeQuery = true)
+    List<SubjectEntity> findByName(@Param("scaleName") String scaleName);
+}

src/main/java/com/rf/kjb/scale/dao/repository/UserRecordPhyRepository.java

@@ -0,0 +1,20 @@
+package com.rf.kjb.scale.dao.repository;
+
+
+import com.rf.kjb.base.repository.BaseRepository;
+import com.rf.kjb.scale.dao.model.RecordPhyEntry;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import java.util.List;
+
+/**
+ * @author zsy
+ * @date 2021/6/17 15:55
+ */
+public interface UserRecordPhyRepository extends BaseRepository<RecordPhyEntry, String> {
+
+    @Query(value = "select id,test_date,test_result,type from t_user_record_phy where test_date = :testDate ", nativeQuery = true)
+    List<RecordPhyEntry> getuserRecordByTestDate(@Param("testDate") String testDate);
+
+}

src/main/java/com/rf/kjb/scale/package-info.java

@@ -0,0 +1,4 @@
+package com.rf.kjb.scale;
+/**
+ * 量表
+ */

src/main/java/com/rf/kjb/scale/rest/CategoryController.java

@@ -0,0 +1,73 @@
+package com.rf.kjb.scale.rest;
+
+import com.rf.kjb.base.rest.BaseController;
+import com.rf.kjb.exception.ErrorCode;
+import com.rf.kjb.scale.dao.model.CategoryEntry;
+import com.rf.kjb.scale.service.CategoryService;
+import com.rf.kjb.utils.Result;
+import com.rf.kjb.utils.Utils;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Date;
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:量表类别信息管理
+ * @date 2021/6/17 15:55
+ */
+
+@Slf4j
+@RestController
+@RequestMapping("/v1/category")
+@Api(tags = "量表类别信息管理")
+public class CategoryController extends BaseController {
+
+    @Autowired
+    private CategoryService categoryService;
+
+    /**
+     * 添加量表类别信息
+     *
+     * @param categoryEntity
+     * @return
+     */
+    @PostMapping("/save")
+    @ApiOperation("添加量表类别信息")
+    public Result saveCategoryInfo(@RequestBody CategoryEntry categoryEntity) {
+
+        assert StringUtils.isNotBlank(categoryEntity.getName()) : "类别名称为空";
+        assert StringUtils.isNotBlank(categoryEntity.getEname()) : "类别英文名为空";
+        assert StringUtils.isNotBlank(categoryEntity.getSequence()) : "序号为空";
+        List<CategoryEntry> categoryEntryList = this.categoryService.getCategoryByName(categoryEntity);
+        if(Utils.isNotBlank(categoryEntryList)){
+            return fail(ErrorCode.CATEGORY_EXIST);
+        }
+        if(categoryEntity.getCreateTime() == null){
+            categoryEntity.setCreateTime(new Date());
+        }else{
+            categoryEntity.setUpdateTime(new Date());
+        }
+
+        this.categoryService.save(categoryEntity);
+        return success();
+    }
+
+    /**
+     * 量表查询所有类别信息
+     *
+     * @return
+     */
+    @GetMapping("/getCategoryList")
+    @ApiOperation(value = "量表查询所有类别信息")
+    public Result getCategoryList() {
+        List<CategoryEntry> categoryEntryList = this.categoryService.findAll();
+        return success(categoryEntryList);
+    }
+
+}

src/main/java/com/rf/kjb/scale/rest/GameRecordController.java

@@ -0,0 +1,41 @@
+package com.rf.kjb.scale.rest;
+
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.base.rest.BaseController;
+import com.rf.kjb.scale.dao.model.GameRecordEntity;
+import com.rf.kjb.scale.service.GameRecordService;
+import com.rf.kjb.utils.Result;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.web.bind.annotation.*;
+
+/**
+ * @Author:zzf
+ * @Date:2023/6/7:09:55
+ * @Description:游戏记录
+ */
+@Slf4j
+@RestController
+@RequestMapping("/v1/game/record")
+@Api(tags = "游戏记录")
+public class GameRecordController extends BaseController {
+    @Autowired
+    private GameRecordService gameRecordService;
+    @ApiOperation(value = "保存记录")
+    @PostMapping("/save")
+    public Result save(@RequestBody String json){
+        GameRecordEntity gameRecordEntity = JSONObject.parseObject(json).toJavaObject(GameRecordEntity.class);
+        this.gameRecordService.save(gameRecordEntity);
+        return success();
+    }
+
+    @ApiOperation(value = "查询",notes = "id:游戏记录id；identifier：编号；gameScene：游戏场景；equipmentType：设备类型；gameDifficulty：游戏难度；gameTime：游戏时间；fileName：文件名;pageNum:页数，默认1；pageSize：每页记录数，默认10")
+    @GetMapping("/find")
+    public Result find(@RequestBody String json){
+        Page<GameRecordEntity> page = this.gameRecordService.find(json);
+        return success(page);
+    }
+}

src/main/java/com/rf/kjb/scale/rest/RecordController.java

@@ -0,0 +1,433 @@
+package com.rf.kjb.scale.rest;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.base.rest.BaseController;
+import com.rf.kjb.scale.dao.dto.RecordEntityDto;
+import com.rf.kjb.scale.dao.model.RecordEntity;
+import com.rf.kjb.scale.dao.model.SubjectEntity;
+import com.rf.kjb.scale.service.RecordService;
+import com.rf.kjb.scale.service.SubjectService;
+import com.rf.kjb.scale.util.DateUtil;
+import com.rf.kjb.user.dao.model.UserEntry;
+import com.rf.kjb.user.service.UserService;
+import com.rf.kjb.utils.Constant;
+import com.rf.kjb.utils.Result;
+import com.rf.kjb.utils.Utils;
+import com.rf.kjb.utils.ZipUtils;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.poi.ss.usermodel.*;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.web.bind.annotation.*;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.*;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.*;
+import java.util.stream.Stream;
+
+/**
+ * @Author:zzf
+ * {@code @Date:2022/8/3:15:29}
+ * {@code @Description:测试记录查询}
+ */
+@RestController
+@RequestMapping("/v1/record")
+@Slf4j
+@Api(tags = "量表测试记录")
+public class RecordController extends BaseController {
+
+    @Autowired
+    private RecordService recordService;
+
+    @Autowired
+    private UserService userService;
+
+    @Autowired
+    private SubjectService subjectService;
+
+    /**
+     * 查询做过量表的用户
+     * @return
+     */
+    @PostMapping("/users")
+    @ApiOperation(value = "量表维度查询用户",notes = "flag :量表flag  startTime ：开始时间 endTime：结束时间  userName：用户名 pageNum:页数  pageSize：每页记录数")
+    public Result<JSONObject> userList(@RequestBody String json){
+        List<String> identifiers;
+        List<UserEntry> userEntries = new ArrayList<>();
+        identifiers = this.recordService.findIdentifiers(json);
+        int count = this.recordService.findIdentifiersCount(json);
+        if(Utils.isNotBlank(identifiers)){
+            userEntries = this.userService.findByIdentifiers(identifiers);
+        }
+        JSONObject resultJson = new JSONObject();
+        resultJson.put("data",userEntries);
+        resultJson.put("allNum",count);
+        return  success(resultJson);
+    }
+
+    @PostMapping("/find")
+    @ApiOperation(value = "查询",notes = "pageNum:当前页数 默认1  pageSize：每页记录数，默认10 startDate：测试起始时间，可为空 endDate：测试结束时间 可为空；identifier：用户编号 可为空 scaleName:量表名称模糊查询")
+    public Result<JSONObject> find(@RequestBody String json){
+        List<RecordEntityDto> dtos = new ArrayList<>();
+        int allNum = 0;
+        Page<RecordEntity> page = this.recordService.find(json);
+        if(page.getTotalElements() >0){
+            allNum = (int) page.getTotalElements();
+            page.getContent().forEach(item ->{
+                RecordEntityDto dto = copyEntry(item);
+                dtos.add(dto);
+            });
+        }
+        JSONObject resultJson = new JSONObject();
+        resultJson.put("data",dtos);
+        resultJson.put("allNum",allNum);
+        return success(resultJson);
+    }
+
+    @PostMapping("/find/{id}")
+    @ApiOperation(value = "详情查询",notes = "id 主键 id")
+    public Result<JSONObject> findById(@PathVariable String id ){
+        RecordEntity entry  = this.recordService.findById(id);
+        assert entry != null : "测试记录不存在";
+        UserEntry userInfo = this.userService.findByIdentifier(entry.getIdentifier());
+        assert userInfo != null : "用户不存在";
+        SubjectEntity subjectEntity = this.subjectService.getSubjectByFlag(entry.getFlag());
+
+        JSONObject resultJson = new JSONObject();
+        resultJson.put("subject",subjectEntity);
+        resultJson.put("userInfo",userInfo);
+        resultJson.put("userRecordEntity",entry);
+
+        return success(resultJson);
+    }
+
+    @PostMapping("/download")
+    @ApiOperation(value = "用户测试结果批量下载",notes = "ids :数组，下载的结果id，为空时表示全部下载；flag :量表flag")
+    public String downloadResult(@RequestBody String json, HttpServletResponse response){
+        JSONObject condition = JSONObject.parseObject(json);
+        Workbook wb = new XSSFWorkbook();
+        //查询测试记录 不分页
+        List<RecordEntity> recordEntities = this.recordService.findNoPage(condition.toJSONString());
+        if(!Utils.isNotBlank(recordEntities)){
+            return  "无测试记录";
+        }
+        RecordEntity temp = recordEntities.get(0);
+        JSONArray dbJsonList = JSONArray.parseArray(temp.getTestResult());
+        JSONObject dbJson = dbJsonList.getJSONObject(0);
+        JSONArray tableContext = dbJson.getJSONArray("tableContext");
+        StringBuilder testResults = new StringBuilder();
+        for (int i = 0; i < tableContext.size(); i++) {
+            JSONObject jsonObject = tableContext.getJSONObject(i);
+            testResults.append(jsonObject.getString("name")).append(":").append(jsonObject.getJSONArray("value").getString(0)).append(";");
+        }
+        System.out.println("testresults==="+testResults);
+        String [] splits = testResults.substring(0,testResults.length()-1).split(";");
+        System.out.println("splits.length=="+splits.length);
+        for (int i = 0; i < splits.length; i++) {
+            System.out.println(splits[i]);
+        }
+        //标题行抽出字段
+        String [] title = new String[splits.length + 6];
+        title[0] = "姓名";
+        title[1] = "性别";
+        title[2] = "编号";
+        title[3] = "年龄";
+        title[4] = "测试时间";
+        title[5] = "测试名称";
+        for (int i = 0; i < splits.length; i++) {
+            title[i + 6] = splits[i].split(":")[0];
+        }
+        Sheet downSheet = wb.createSheet(Constant.BATCH_EXPORT_RESULT_SHEET_NAME);
+        //获取表头行
+        Row titleRow = downSheet.createRow(0);
+        //创建单元格，设置style居中，字体，单元格大小等
+        CellStyle style = wb.createCellStyle();
+        //设置水平对齐的样式为居中对齐;
+        style.setAlignment(HorizontalAlignment.CENTER);
+        //设置垂直对齐的样式为居中对齐;
+        style.setVerticalAlignment(VerticalAlignment.CENTER);
+        Cell cell;
+        //把已经写好的标题行写入excel文件中
+        for (int i = 0; i < title.length; i++) {
+            cell = titleRow.createCell(i);
+            cell.setCellValue(title[i]);
+            cell.setCellStyle(style);
+        }
+        Row row;
+        Map<String,String> subjectMap = loadAllSubject();
+        for (int i = recordEntities.size()-1; i >= 0; i--) {
+            RecordEntity recordEntity = recordEntities.get(i);
+
+            row = downSheet.createRow(i+1);
+            row.setRowStyle(style);
+            //用户信息
+            UserEntry userEntry = this.userService.findByIdentifier(recordEntity.getIdentifier());
+            //姓名
+            Cell cellUserName = row.createCell(0);
+            cellUserName.setCellValue(userEntry.getUserName());
+            //性别
+            Cell cellGender = row.createCell(1);
+            cellGender.setCellValue(userEntry.getGender() == 1?"男":"女");
+            //编号
+            Cell cellIdentifier = row.createCell(2);
+            cellIdentifier.setCellValue(userEntry.getIdentifier());
+            //年龄
+            Cell cellAge = row.createCell(3);
+            cellAge.setCellValue(userEntry.getAge());
+            //测试时间
+            Cell cellTestTime = row.createCell(4);
+            cellTestTime.setCellValue(recordEntity.getTestDate());
+            //测试名称
+            Cell cellScaleName = row.createCell(5);
+            cellScaleName.setCellValue(subjectMap.get(recordEntity.getFlag()));
+
+            tableContext = JSONArray.parseArray(recordEntity.getTestResult()).getJSONObject(0).getJSONArray("tableContext");
+            StringBuilder testResult = new StringBuilder();
+            for (int y = 0; y < tableContext.size(); y++) {
+                JSONObject jsonObject = tableContext.getJSONObject(y);
+                testResult.append(jsonObject.getString("name")).append(":").append(jsonObject.getJSONArray("value").getString(0)).append(";");
+            }
+
+            String[] splitl = testResult.substring(0,testResult.length()-1).split(";");
+            for (int z = 0; z < splitl.length; z++) {
+                String[] a = splitl[z].split(":");
+                Cell rowCell = row.createCell(z + 6);
+                rowCell.setCellValue(a[1]);
+                rowCell.setCellStyle(style);
+            }
+        }
+        //设置单元个宽度自适应，在此基础上把宽度调至1.5倍
+        for (int i = 0; i < title.length; i++) {
+            downSheet.autoSizeColumn(i, true);
+            int colWidth = downSheet.getColumnWidth(i) * 2;
+            if (colWidth < 255 * 256) {
+                downSheet.setColumnWidth(i, Math.max(colWidth, 3000));
+            } else {
+                downSheet.setColumnWidth(i, 6000);
+            }
+        }
+        //获取配置文件中保存对应excel文件的路径
+        String foldDir = "./心理检测/检测结果/" + DateUtil.getNowTime(DateUtil.DEFAULT_DATE_PATTERN) + "/" + Constant.BATCH_EXPORT_RESULT_SHEET_NAME;
+        //创建上传文件目录
+        File fileDir = new File(foldDir);
+        if(!fileDir.exists())  fileDir.mkdirs();
+
+        //设置文件名
+        String fileName = this.subjectService.getSubjectByFlag(temp.getFlag()).getName()+ Constant.SPLIT_CHAR + DateUtil.getNowTime(DateUtil.CN_DATE) +".xlsx";
+        OutputStream fileOut = null;
+        FileInputStream fis = null;
+        BufferedInputStream bis = null;
+        OutputStream os = null;
+        try{
+            fileOut = new FileOutputStream(foldDir+"/"+fileName);
+            wb.write(fileOut);
+            fileOut.close();
+            File file = new File(foldDir+"/"+fileName);
+            if(file.exists()){
+                /*response.reset();
+                response.setContentType("application/octet-stream");
+                response.setCharacterEncoding("utf-8");
+                response.setContentLength((int) file.length());
+                response.setHeader("Content-Disposition", "attachment;filename=" + java.net.URLEncoder.encode(file.getName(), "UTF-8"));
+
+                byte[] buffer = new byte[1024];
+                fis = new FileInputStream(file);
+                bis = new BufferedInputStream(fis);
+                os = response.getOutputStream();
+                int i = bis.read(buffer);
+                while (i != -1) {
+                    os.write(buffer, 0, i);
+                    i = bis.read(buffer);
+                }
+                return "下载成功";*/
+                return com.rf.kjb.utils.FileUtils.downloadFile(file,"",fileName,response);
+//                return downloadFile(file,"",fileName,response);
+            }
+        } catch (FileNotFoundException e) {
+            log.error("未找到文件：");
+            e.printStackTrace();
+            return "下载失败";
+        } catch (IOException e) {
+            log.error("文件写入失败");
+            e.printStackTrace();
+            return "下载失败";
+        }finally {
+            try{
+                if(fileOut != null) fileOut.close();
+
+            } catch (IOException e) {
+               log.error("关闭系统I/O资源失败");
+            }
+        }
+        return "下载失败";
+    }
+
+
+    @PostMapping("/findByFlag")
+    @ApiOperation(value = "根据flag查询量表测试记录，包含用户信息",notes = "flag:量表标志 pageNum：页数 pageSize：每页记录数 startDate:起始时间  endDate：结束时间")
+    public Result<JSONObject> testRecord(@RequestBody String json){
+        int allNum = 0;
+        List<RecordEntityDto> dtos = new ArrayList<>();
+        Page<RecordEntity> page = this.recordService.find(json);
+        if(page.getTotalElements() >0){
+            allNum = (int) page.getTotalElements();
+            page.getContent().forEach(item ->{
+                RecordEntityDto dto = copyEntry(item);
+
+                UserEntry userEntry = this.userService.findByIdentifier(item.getIdentifier());
+                dto.setUserName(userEntry.getUserName());
+                dto.setGender(userEntry.getGender());
+                dto.setProfession(userEntry.getProfession());
+                dtos.add(dto);
+            });
+        }
+        JSONObject resultJson = new JSONObject();
+        resultJson.put("data",dtos);
+        resultJson.put("allNum",allNum);
+        return success(resultJson);
+    }
+
+    @PostMapping("/download/source")
+    @ApiOperation(value = "原始数据批量下载",notes = "ids :数组，下载的结果id，为空时表示全部下载；flag：量表flag")
+    public String downSourceDate(@RequestBody String json, HttpServletResponse response) throws IOException {
+        //原始记录文件
+        File file;
+        //原始记录复制后文件
+        File destFile;
+        //查找原始记录路径文件夹名称
+        String testDate;
+        //查找原始记录路径文件夹名称
+        String folderName;
+        //所有记录汇总后文件夹，用来压缩
+        String filePath = null;
+        //原始记录文件名
+        String fileName;
+        //查询测试记录 不分页
+        JSONObject condition = JSONObject.parseObject(json);
+        List<RecordEntity> recordEntities = this.recordService.findNoPage(condition.toJSONString());
+        if(!Utils.isNotBlank(recordEntities)){
+            return  "无测试记录";
+        }
+        //加载所有的量表资源，减少数据库访问次数
+        Map<String,String> subjectMap = loadAllSubject();
+
+        for (RecordEntity recordEntity : recordEntities) {
+            fileName = recordEntity.getFileName().substring(recordEntity.getFileName().lastIndexOf("/")+1);
+            testDate = recordEntity.getTestDate();
+            folderName = subjectMap.get(recordEntity.getFlag());
+            //将日期格式 yyyy年MM月dd日HH时mm分ss秒转换成 yyyy-MM-dd
+            testDate = testDate.substring(0,10).replace("年","-").replace("月","-");
+            file = new File("./心理检测/检测结果/" + testDate + "/" + folderName + "/" + fileName);
+            destFile = new File("./心理检测/答题记录/" + folderName + "/" + recordEntity.getIdentifier() + "-" + folderName +"-"+recordEntity.getTestDate()+ ".xlsx");
+            filePath = "./心理检测/答题记录";
+            //将原始文件进行复制
+            FileUtils.copyFile(file, destFile);
+        }
+
+        //将复制后的整个文件夹打包
+        String zipPath = filePath+  DateUtil.getNowTime(DateUtil.DATE_PARSE_PATTERNS[3]);
+        ZipUtils.createZip(filePath, zipPath +".zip", false);
+
+        File zipFile = new File(zipPath + ".zip");
+        //下载压缩后文件
+        if (zipFile.exists()) {
+//            return downloadFile(zipFile,filePath,"答题记录-"+DateUtil.getNowTime(DateUtil.DATE_PARSE_PATTERNS[3])+".zip",response);
+            return com.rf.kjb.utils.FileUtils.downloadFile(zipFile,filePath,"答题记录-"+DateUtil.getNowTime(DateUtil.DATE_PARSE_PATTERNS[3])+".zip",response);
+        }
+        return "下载失败";
+    }
+
+    private String downloadFile(File file ,String filePath ,String fileName,HttpServletResponse response) throws IOException {
+        response.reset();
+        response.setContentType("application/octet-stream");
+        response.setCharacterEncoding("utf-8");
+        response.setContentLength((int) file.length());
+        response.setHeader("Content-Disposition", "attachment;filename=" + java.net.URLEncoder.encode(fileName, "UTF-8"));
+
+        byte[] buffer = new byte[1024];
+        FileInputStream fis = null;
+        BufferedInputStream bis = null;
+        try {
+            fis = new FileInputStream(file);
+            bis = new BufferedInputStream(fis);
+            OutputStream os = response.getOutputStream();
+            int i = bis.read(buffer);
+            while (i != -1) {
+                os.write(buffer, 0, i);
+                i = bis.read(buffer);
+            }
+
+            return "下载成功";
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (bis != null) {
+                try {
+                    bis.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            if (fis != null) {
+                try {
+                    fis.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            //将复制后的整个文件夹删除
+            if(StringUtils.isNotBlank(filePath)){
+                Path path = Paths.get(filePath);
+                try (Stream<Path> walk = Files.walk(path)) {
+                    walk.sorted(Comparator.reverseOrder())
+                            .forEach(com.rf.kjb.utils.FileUtils::deleteDirectoryStream);
+                }
+                //删除生成的压缩包
+                if(file.exists()) file.delete();
+            }
+
+        }
+        return "下载失败";
+    }
+
+    /**
+     * 加载所有的量表信息
+     * @return Map<flag,name>
+     */
+    private Map<String, String> loadAllSubject() {
+       List<SubjectEntity> subjectEntities =  this.subjectService.findAll("0");
+        Map<String,String> subjectMap = new HashMap<>();
+       if(Utils.isNotBlank(subjectEntities)){
+           subjectEntities.forEach(item -> subjectMap.put(item.getFlag(),item.getName()));
+       }
+       return subjectMap;
+    }
+
+    private RecordEntityDto copyEntry(RecordEntity item) {
+        RecordEntityDto dto = new RecordEntityDto();
+        dto.setId(item.getId());
+        dto.setCreateTime(item.getCreateTime());
+        dto.setTestRecord(item.getTestRecord());
+        dto.setFlag(item.getFlag());
+        dto.setIdentifier(item.getIdentifier());
+        dto.setFileName(item.getFileName());
+        dto.setTestDate(item.getTestDate());
+        dto.setImg(item.getImg());
+        dto.setTestResult(item.getTestResult());
+        dto.setTestResults(item.getTestResults());
+        dto.setUpdateTime(item.getUpdateTime());
+        dto.setName(this.subjectService.getSubjectByFlag(item.getFlag()).getName());
+        return dto;
+    }
+
+
+}

src/main/java/com/rf/kjb/scale/rest/RecordPhyController.java

@@ -0,0 +1,253 @@
+package com.rf.kjb.scale.rest;
+
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.base.rest.BaseController;
+import com.rf.kjb.scale.dao.model.RecordPhyEntry;
+import com.rf.kjb.scale.service.RecordPhyService;
+import com.rf.kjb.scale.util.DateUtil;
+import com.rf.kjb.user.dao.model.UserEntry;
+import com.rf.kjb.user.service.UserService;
+import com.rf.kjb.utils.FileUtils;
+import com.rf.kjb.utils.Result;
+import com.rf.kjb.utils.Utils;
+import com.rf.kjb.utils.ZipUtils;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.poi.ss.usermodel.*;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.web.bind.annotation.*;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.*;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Stream;
+
+/**
+ * @Author:zzf
+ * @Date:2022/7/28:19:20
+ * @Description:
+ */
+@RestController
+@RequestMapping("/v1/recordPhy")
+@Slf4j
+@Api(tags = "生理测试记录")
+public class RecordPhyController extends BaseController {
+
+    @Autowired
+    private RecordPhyService recordPhyService;
+
+    @Autowired
+    private UserService userService;
+
+    @PostMapping("/save")
+    @ApiOperation(value = "保存记录",notes = "testDate:测试时间戳；testResult：测试结果；sourceData：原始数据；type：类型 1 脉搏 2心电 3脑电；fileName：文件名；identifier：用户编号")
+    public Result save(@RequestBody String json){
+        RecordPhyEntry recordPhyEntry = JSONObject.parseObject(json).toJavaObject(RecordPhyEntry.class);
+        this.recordPhyService.save(recordPhyEntry);
+        return success();
+    }
+
+    @PostMapping("/find")
+    @ApiOperation(value = "查询",notes = "pageNum:当前页数 默认1  pageSize：每页记录数，默认10 startDate：测试起始时间，可为空 endDate：测试结束时间 type:类型：1为脉搏；2为心电；3为脑电，可为空 fileName:文件名称，可为空；identifier：用户编号 可为空")
+    public Result<Page<RecordPhyEntry>> find(@RequestBody String json){
+        JSONObject jsonObject = JSONObject.parseObject(json);
+        Page<RecordPhyEntry> page = this.recordPhyService.find(jsonObject);
+        return success(page);
+    }
+
+    @PostMapping("/find/{id}")
+    @ApiOperation(value = "详情查询",notes = "id 主键 id")
+    public Result<RecordPhyEntry> findById(@PathVariable String id ){
+        RecordPhyEntry entry  = this.recordPhyService.findById(id);
+        assert entry != null : "测试记录不存在";
+        return success(entry);
+    }
+
+    @PostMapping("/user")
+    @ApiOperation(value = "查询有生理测试记录的用户信息",notes = "pageNum:当前页数 默认1  pageSize：每页记录数，默认10 startDate：测试起始时间，可为空 endDate：测试结束时间 type:类型：1为脉搏；2为心电；3为脑电，可为空 filaName:文件名称，可为空；userName：用户名可为空")
+    public Result<JSONObject> findUser(@RequestBody String json){
+        List<String> identifiers;
+
+        List<UserEntry> userEntries = new ArrayList<>();
+        JSONObject jsonObject = JSONObject.parseObject(json);
+        identifiers = this.recordPhyService.findIdentifiers(jsonObject);
+        int count = this.recordPhyService.findIdentifiersCount(jsonObject);
+        if(Utils.isNotBlank(identifiers)){
+            userEntries = this.userService.findByIdentifiers(identifiers);
+        }
+        JSONObject resultJson = new JSONObject();
+        resultJson.put("data",userEntries);
+        resultJson.put("allNum",count);
+        return  success(resultJson);
+    }
+
+    @PostMapping("/download")
+    @ApiOperation(value = "原始数据批量下载",notes = "ids :数组，下载的结果id，为空时表示全部下载 ,flag :1为脉搏；2为心电；3为脑电")
+    public String download(@RequestBody String json, HttpServletResponse response) throws IOException {
+        JSONObject jsonObject = JSONObject.parseObject(json);
+        List<String> ids = jsonObject.getJSONArray("ids").toJavaList(String.class);
+        String  flag = jsonObject.getString("flag");
+        List<RecordPhyEntry> recordPhyEntryList = this.recordPhyService.find(ids,flag);
+        Set<String> fileNameSet = new HashSet<>();
+        if(Utils.isNotBlank(recordPhyEntryList)){
+//            HashMap<String,String> map = new HashMap<>();
+////            1为脉搏；2为心电；3为脑电
+//            recordPhyEntryList.forEach( item -> fileNameSet.add(item.getFileName()));
+//            if(Utils.isNotBlank(fileNameSet)){
+//                return downloadSourceFile(fileNameSet,flag,response);
+//            }
+            return downloadSourceFile(recordPhyEntryList,flag,response);
+        }
+        return "下载失败";
+    }
+
+    private String downloadSourceFile(List<RecordPhyEntry> recordPhyEntryList, String flag, HttpServletResponse response) throws IOException {
+        //copy   file
+        String path_prefix = System.getProperty("user.home");
+        //目标文件目录
+        String destFileParent = "./生理测试记录原始数据/";
+        recordPhyEntryList.forEach(item -> {
+            File file = new File(path_prefix + "/KJB/" + item.getFileName() + ".txt");
+            if(file.exists()){
+                //将txt文本内容转换成excel文件
+                try {
+                    FileUtils.txt2excel(file,destFileParent,flag,item);
+                } catch (IOException e) {
+                    log.error("文件下载失败：");
+                    e.printStackTrace();
+                    throw new RuntimeException(e);
+                }
+            }
+        });
+
+        //压缩文件
+        ZipUtils.createZip(destFileParent,"./生理测试记录原始数据.zip",true);
+        return FileUtils.downloadFile(new File("./生理测试记录原始数据.zip"),"","生理测试记录原始数据-"+ DateUtil.getCurrentDate(DateUtil.DATE_PARSE_PATTERNS[3]) +".zip",response);
+    }
+
+    private String downloadSourceFile(Set<String> fileNameSet, String flag,HttpServletResponse response) throws IOException {
+        //copy   file
+        String path_prefix = System.getProperty("user.home");
+        //目标文件目录
+        String destFileParent = "./生理测试记录原始数据/";
+        fileNameSet.forEach(fileName -> {
+            File file = new File(path_prefix + "/KJB/" + fileName + ".txt");
+            if(file.exists()){
+                //将txt文本内容转换成excel文件
+                try {
+                    FileUtils.txt2excel(file,destFileParent,flag);
+                } catch (IOException e) {
+                    log.error("文件下载失败：");
+                    e.printStackTrace();
+                    throw new RuntimeException(e);
+                }
+            }
+        });
+        //压缩文件
+        ZipUtils.createZip(destFileParent,"./生理测试记录原始数据.zip",true);
+        return FileUtils.downloadFile(new File("./生理测试记录原始数据.zip"),"","生理测试记录原始数据-"+ DateUtil.getCurrentDate(DateUtil.DATE_PARSE_PATTERNS[3]) +".zip",response);
+    }
+
+    @ApiOperation("全部导出脉搏测试指标")
+    @PostMapping("/export/all/pulse/target")
+    public String batchExportPulse(HttpServletResponse response) throws IOException {
+        List<RecordPhyEntry> recordPhyEntryList = this.recordPhyService.findByType("1");
+        if(recordPhyEntryList != null && recordPhyEntryList.size()>0){
+            String fileName = "./脉搏指标-"+new SimpleDateFormat("yyyyMMddHHmmss").format(new Date())+".xlsx";
+            File distFile = new File(fileName);
+            Workbook wb = new XSSFWorkbook();
+            //创建单元格，设置style居中，字体，单元格大小等
+            CellStyle style = wb.createCellStyle();
+            //设置水平对齐的样式为居中对齐;
+            style.setAlignment(HorizontalAlignment.CENTER);
+            //设置垂直对齐的样式为居中对齐;
+            style.setVerticalAlignment(VerticalAlignment.CENTER);
+            //创建表头
+            String [] titles = {"用户编号","测试时间","SD2","SD1","HF_norm","SDNN","LF_norm","RMSSD","VLF","LF/HF","PNN20","PNN50","SDSD","P_total","LF","HF","0.1Hz"};
+
+            Sheet sheet = wb.createSheet("时域指标和频域指标");
+            Row titleRow = sheet.createRow(0);
+            titleRow.setRowStyle(style);
+            for (int i = 0; i < titles.length; i++) {
+                titleRow.createCell(i).setCellValue(titles[i]);
+            }
+            AtomicInteger rowNum = new AtomicInteger();
+            recordPhyEntryList.forEach(item ->{
+                rowNum.addAndGet(1);
+                Row dataRow = sheet.createRow(rowNum.get());
+                JSONObject jsonObject = JSONObject.parseObject(item.getTestResult().replace("lf_nu","lf_norm").replace("hf_nu","hf_norm").toUpperCase());
+                for (int i = 0; i < titles.length; i++) {
+                    if(i == 0){
+                        Cell dataRowCell = dataRow.createCell(i);
+                        dataRowCell.setCellValue(item.getIdentifier());
+                    } else if (i == 1) {
+                        Cell dataRowCell = dataRow.createCell(i);
+                        dataRowCell.setCellValue(item.getTestDate());
+                    }else {
+                        Cell dataRowCell = dataRow.createCell(i);
+                        dataRowCell.setCellValue(jsonObject.getString(titles[i].toUpperCase()));
+                    }
+                }
+            });
+            OutputStream fileOut = Files.newOutputStream(distFile.toPath());
+            wb.write(fileOut);
+            fileOut.close();
+            response.reset();
+            response.setContentType("application/octet-stream");
+            response.setCharacterEncoding("utf-8");
+            response.setContentLength((int) distFile.length());
+            response.setHeader("Content-Disposition", "attachment;filename=" + java.net.URLEncoder.encode(distFile.getName(), "UTF-8"));
+            response.setHeader("filename",java.net.URLEncoder.encode(distFile.getName(), "UTF-8"));
+            byte[] buffer = new byte[1024];
+            FileInputStream fis = null;
+            BufferedInputStream bis = null;
+            try {
+                fis = new FileInputStream(distFile);
+                bis = new BufferedInputStream(fis);
+                OutputStream os = response.getOutputStream();
+                int i = bis.read(buffer);
+                while (i != -1) {
+                    os.write(buffer, 0, i);
+                    i = bis.read(buffer);
+                }
+
+                return "下载成功";
+            } catch (Exception e) {
+                e.printStackTrace();
+            } finally {
+                if (bis != null) {
+                    try {
+                        bis.close();
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+                if (fis != null) {
+                    try {
+                        fis.close();
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+                distFile.delete();
+            }
+            return "下载成功";
+        }
+        return "下载失败";
+    }
+
+
+
+
+
+}

src/main/java/com/rf/kjb/scale/rest/SubjectController.java

@@ -0,0 +1,52 @@
+package com.rf.kjb.scale.rest;
+
+import com.rf.kjb.base.rest.BaseController;
+import com.rf.kjb.scale.dao.model.ScaleEntry;
+import com.rf.kjb.scale.dao.model.SubjectEntity;
+import com.rf.kjb.scale.service.ScaleService;
+import com.rf.kjb.scale.service.SubjectService;
+import com.rf.kjb.utils.Result;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * @Author:zzf
+ * @Date:2022/7/28:17:03
+ * @Description:
+ */
+@RestController
+@RequestMapping("/v1/scale")
+@Api(tags = "量表")
+public class SubjectController extends BaseController {
+
+    @Autowired
+    private SubjectService subjectService;
+
+    @Autowired
+    private ScaleService scaleService;
+
+    @PostMapping("/find")
+    @ApiOperation(value = "查询量表",notes = "pageNum 页数，默认值1  pageSize 每页记录数，默认值10 name 量表名称(可为空)  flag 量表标志(可为空) typeName:分类英文名(可为空) role 用户角色")
+    public Result find(@RequestBody String json){
+        Page<SubjectEntity> list = this.subjectService.find(json);
+        return success(list);
+    }
+
+    /**
+     * 题目查询
+     * @param flag
+     * @return
+     */
+    @GetMapping("/{flag}")
+    @ApiOperation(value = "题目查询",notes = "flag 量表标志")
+    public Result findScale(@PathVariable String flag){
+        List<ScaleEntry> list = this.scaleService.getScaleByFlag(flag);
+        return success(list);
+    }
+
+}

src/main/java/com/rf/kjb/scale/rest/WebScaleResultController.java

@@ -0,0 +1,433 @@
+package com.rf.kjb.scale.rest;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson.serializer.SerializerFeature;
+import com.rf.kjb.base.rest.BaseController;
+import com.rf.kjb.excel.ExcelClass;
+import com.rf.kjb.excel.ExcelUtil;
+import com.rf.kjb.exception.ErrorCode;
+import com.rf.kjb.scale.dao.model.*;
+import com.rf.kjb.scale.service.*;
+import com.rf.kjb.scale.util.DateUtil;
+import com.rf.kjb.user.dao.model.UserEntry;
+import com.rf.kjb.user.service.UserService;
+import com.rf.kjb.utils.Constant;
+import com.rf.kjb.utils.Result;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.CellType;
+import org.apache.poi.ss.usermodel.Row;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.*;
+import javax.servlet.http.HttpServletResponse;
+import java.io.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.text.DecimalFormat;
+import java.text.SimpleDateFormat;
+import java.util.*;
+import java.util.stream.Stream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+/**
+ * @author zsf
+ * {@code @description:接收测试结果计算结果--量表测试}
+ * @date 2021/1/21 16:07
+ */
+@Slf4j
+@RestController
+@RequestMapping("/v1/result")
+@Api(tags = "web端量表测试结果计算")
+public class WebScaleResultController extends BaseController {
+
+    @Autowired
+    private SubjectService subjectService;
+
+    @Autowired
+    private RecordService userRecordService;
+
+    @Autowired
+    private UserService userService;
+
+    @Autowired
+    private ScaleService scaleService;
+
+    @Autowired
+    private AnswerService answerService;
+
+    @Autowired
+    private ScaleMarksService scaleMarksService;
+
+    @Autowired
+    private DimensionService dimensionService;
+
+    @Autowired
+    private ScaleConfigService scaleConfigService;
+
+    @Transactional(rollbackFor = Exception.class)
+    @PostMapping("/{flag}")
+    @ApiOperation(value = "flag:量表标志，jsonObject：测试结果")
+    public Result completeTest(@RequestBody String json, @PathVariable String flag) throws Exception {
+        JSONObject jsonObject = JSONObject.parseObject(json);
+        UserEntry userEntity = this.userService.findByIdentifier(jsonObject.getString("identifier"));
+        if(userEntity == null){
+            return fail(ErrorCode.USER_NOT_EXISTS);
+        }
+        String userName = userEntity.getUserName();
+        String userSex = userEntity.getGender() == 1 ?"男":"女";
+        String testTime = DateUtil.getNowTime_CN();
+        if (jsonObject.containsKey("startTime") && jsonObject.getDate("startTime") != null) {
+            testTime = DateUtil.getDateStr(jsonObject.getDate("startTime"), DateUtil.CN_DATE);
+        }
+        String fileName = userName + Constant.SPLIT_CHAR  + userSex + Constant.SPLIT_CHAR + testTime;
+        StringBuilder testResult = new StringBuilder();
+        JSONArray jsonArray = jsonObject.getJSONArray("scale_result");
+
+        // 创建返回的json对象
+        JSONObject resultJson = new JSONObject(true);
+        //根据flag获取全部选项
+        List<ScaleEntry> scaleEntities = this.scaleService.getScaleByFlag(flag);
+        //根据flag获取全部答案
+        List<AnswerEntity> answerEntities = this.answerService.getAnswerByFlag(flag);
+        //根据flag获取全部评分规则
+        List<ScaleMarksEntity> scaleMarksEntities = this.scaleMarksService.getScaleMarksByFlag(flag);
+        //根据flag获取全部维度信息
+        List<DimensionEntity> dimensionEntities = this.dimensionService.getDimensionByFlag(flag);
+        //根据flag获取量表名称
+        SubjectEntity subjectEntity = this.subjectService.getSubjectByFlag(flag);
+        resultJson.put("scaleEntities", scaleEntities);
+        resultJson.put("answerEntities", answerEntities);
+        resultJson.put("scaleMarksEntities", scaleMarksEntities);
+        resultJson.put("dimensionEntities", dimensionEntities);
+        //答题结果列表
+        List<ScaleEntry> dataList = jsonArray.toJavaList(ScaleEntry.class);
+        ScaleConfigEntry scaleConfigByFlag = scaleConfigService.findScaleConfigByFlag(flag);
+        String className = (scaleConfigByFlag== null ?"com.rf.kjb.scale.scaleResult.NEWCOMMONScaleNEW":scaleConfigByFlag.getResultConfig());
+        Class<?> cls;
+        try {
+            cls = Class.forName(className);
+            Constructor<?> cons = cls.getConstructor(JSONArray.class, JSONObject.class);
+            Object obj = cons.newInstance(jsonArray, resultJson);
+            Method method = cls.getDeclaredMethod("scaleCalculate");
+            resultJson = (JSONObject) method.invoke(obj);
+        } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InstantiationException |
+                 InvocationTargetException e) {
+            e.printStackTrace();
+        }
+        resultJson.getJSONObject("resultJson").remove("scaleEntities");
+        resultJson.getJSONObject("resultJson").remove("answerEntities");
+        resultJson.getJSONObject("resultJson").remove("scaleMarksEntities");
+        resultJson.getJSONObject("resultJson").remove("dimensionEntities");
+        if (resultJson.getJSONObject("resultJson").containsKey("resultJson") && resultJson.getJSONObject("resultJson").get("测试结果指导").equals("请认真按照实际情况如实回答")) {
+            resultJson = resultJson.getJSONObject("resultJson");
+            return success(resultJson, "完成");
+        }
+        fileName = fileName + "-" + subjectEntity.getName() + ".xlsx";
+        //导出文件
+        ExcelUtil.createExcelFile(ScaleEntry.class, dataList, (List<Map<String, String>>) resultJson.get("resultMapList"), new ExcelClass().contentExcel(), fileName, subjectEntity.getName());
+
+        //计算结果
+        JSONArray dbJsonList = new JSONArray();
+        JSONObject dbJson = new JSONObject(true);
+        Map<String, Object> newResultJson;
+        if (!resultJson.containsKey("newResultJson")) {
+            dbJson.put("version", 1.0);
+            dbJson.put("newTableContext", "");
+        } else {
+            newResultJson = (Map<String, Object>) resultJson.get("newResultJson");
+            dbJson.put("version", 2.0);
+            dbJson.put("newTableContext", newResultJson);
+        }
+        resultJson = resultJson.getJSONObject("resultJson");
+        // 获取JSON第一层所有的key
+        Set<String> keys = resultJson.keySet();
+
+        //列名
+        List colNames = new ArrayList();
+        colNames.add("项目");
+        colNames.add("内容");
+        dbJson.put("colNames", colNames);
+        JSONArray tableContext = new JSONArray();
+
+        // 获取第一层每个key对应的值 的类型
+        for (String key : keys) {
+            //列值
+            List colValue = new ArrayList();
+            colValue.add(resultJson.get(key));
+            JSONObject row = new JSONObject();
+            row.put("name", key);
+            row.put("value", colValue);
+            tableContext.add(row);
+        }
+        dbJson.put("tableContext", tableContext);
+        dbJsonList.add(dbJson);
+        //测试记录
+        int i = 1;
+        // 获取第一层每个key对应的值 的类型
+        for (String key : keys) {
+            if (i == keys.size()) {
+                testResult.append(key).append(":").append(resultJson.get(key));
+            } else {
+                testResult.append(key).append(":").append(resultJson.get(key)).append(";");
+            }
+            i++;
+        }
+        String filePath = "./心理检测/检测结果/" + new SimpleDateFormat("yyyy-MM-dd").format(new Date()) + "/" + subjectEntity.getName() + "/" + fileName;
+        RecordEntity userRecordEntity =  testRecord(flag, userEntity.getIdentifier(),testTime, filePath, JSON.toJSONString(dbJsonList, SerializerFeature.DisableCircularReferenceDetect),  JSON.toJSONString(dataList, SerializerFeature.DisableCircularReferenceDetect), testResult.toString());
+        return success(userRecordEntity.getId(),"完成");
+
+    }
+
+
+
+
+    private RecordEntity testRecord(String flag, String identifier,  String testTime, String fileName, String testResult,  String dataList, String testResults) {
+        //根据flag记录测试数
+        this.subjectService.addTestNum(flag);
+        //添加用户测试记录
+        RecordEntity userRecordEntity = new RecordEntity();
+        userRecordEntity.setFlag(flag);
+        userRecordEntity.setIdentifier(identifier);
+        userRecordEntity.setTestDate(testTime);
+        userRecordEntity.setTestResult(testResult);
+        userRecordEntity.setFileName(fileName);
+        userRecordEntity.setTestRecord(dataList);
+        userRecordEntity.setTestResults(testResults);
+        userRecordEntity.setCreateTime(new Date());
+        return this.userRecordService.save(userRecordEntity);
+    }
+
+    //@SafetyProcess
+//    @ApiOperation(value = "测试结果下载")
+//    @GetMapping("/download/testResult")
+    public String downloadTestResult(String id, HttpServletResponse response) throws Exception {
+        if (id != null) {
+            RecordEntity userRecordEntity = this.userRecordService.getUserRecordById(id);
+            if (userRecordEntity == null) {
+                return "该记录异常，下载失败";
+            }
+            assert StringUtils.isNotBlank(userRecordEntity.getFileName()) : "测试记录文件名为空";
+            File file = new File(userRecordEntity.getFileName());
+            if (file.exists()){
+                response.reset();
+                response.setContentType("application/octet-stream");
+                response.setCharacterEncoding("utf-8");
+                response.setContentLength((int) file.length());
+                response.setHeader("Content-Disposition", "attachment;filename=" + java.net.URLEncoder.encode(file.getName(), "UTF-8"));
+
+                if (downloadFile(response, file)) return "下载成功";
+            }else {
+                String fileName = userRecordEntity.getFileName();
+                String testDate = userRecordEntity.getTestDate();
+                assert StringUtils.isNotBlank(userRecordEntity.getFlag()):"测试记录标志为空";
+                String name = this.subjectService.getSubjectByFlag(userRecordEntity.getFlag()).getName();
+                //将日期格式 yyyy年MM月dd日HH时mm分ss秒转换成 yyyy-MM-dd
+                testDate = testDate.substring(0,10).replace("年","-").replace("月","-");
+                //设置文件路径
+                file = new File("./心理检测/检测结果/" + testDate + "/" + name + "/" + fileName);
+                if (file.exists()) {
+                    response.reset();
+                    response.setContentType("application/octet-stream");
+                    response.setCharacterEncoding("utf-8");
+                    response.setContentLength((int) file.length());
+                    response.setHeader("Content-Disposition", "attachment;filename=" + java.net.URLEncoder.encode(fileName, "UTF-8"));
+                    if (downloadFile(response, file)) return "下载成功";
+                }
+            }
+
+
+        }
+        return "下载失败";
+    }
+
+    /**
+     * 文件下载
+     * @param response
+     * @param file
+     * @return
+     */
+    private boolean downloadFile(HttpServletResponse response, File file) {
+        byte[] buffer = new byte[1024];
+        FileInputStream fis = null;
+        BufferedInputStream bis = null;
+        try {
+            fis = new FileInputStream(file);
+            bis = new BufferedInputStream(fis);
+            OutputStream os = response.getOutputStream();
+            int i = bis.read(buffer);
+            while (i != -1) {
+                os.write(buffer, 0, i);
+                i = bis.read(buffer);
+            }
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (bis != null) {
+                try {
+                    bis.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            if (fis != null) {
+                try {
+                    fis.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+        return false;
+    }
+
+
+    /**
+     * 验证excel是否全部为空
+     *
+     * @param row      当前行
+     * @param firstRow 第一行标题行
+     * @return
+     */
+    public static boolean isAllRowEmpty(Row row, Row firstRow) {
+        int count = 0;
+        //单元格数量
+        int rowCount = firstRow.getLastCellNum() - firstRow.getFirstCellNum();
+        //判断多少个单元格为空
+        for (int c = 0; c < rowCount; c++) {
+            Cell cell = row.getCell(c);
+            if (cell == null || cell.getCellType() == CellType.BLANK || StringUtils.isEmpty((cell + "").trim())) {
+                count += 1;
+            }
+        }
+
+        if (count == rowCount) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * 描述：对表格中数值进行格式化
+     */
+    private static Object getCellValue(Cell cell) {
+        Object value = null;
+        //格式化字符类型的数字
+        DecimalFormat df = new DecimalFormat("0");
+        //日期格式化
+        SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd");
+        //格式化数字
+        DecimalFormat df2 = new DecimalFormat("0.00");
+        switch (cell.getCellType()) {
+
+            case STRING:
+                value = cell.getRichStringCellValue().getString();
+                break;
+            case NUMERIC:
+                if ("General".equals(cell.getCellStyle().getDataFormatString())) {
+                    value = df.format(cell.getNumericCellValue());
+                } else if ("m/d/yy".equals(cell.getCellStyle().getDataFormatString())) {
+                    value = sdf.format(cell.getDateCellValue());
+                } else {
+                    value = df2.format(cell.getNumericCellValue());
+                }
+                break;
+            case BOOLEAN:
+                value = cell.getBooleanCellValue();
+                break;
+            case BLANK:
+                value = "";
+                break;
+            default:
+                break;
+        }
+        return value;
+    }
+
+
+
+
+    public static void zipFiles(File[] srcFiles, File zipFile) {
+        // 判断压缩后的文件存在不，不存在则创建
+        if (!zipFile.exists()) {
+            try {
+                zipFile.createNewFile();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        // 创建 FileOutputStream 对象
+        FileOutputStream fileOutputStream = null;
+        // 创建 ZipOutputStream
+        ZipOutputStream zipOutputStream = null;
+        // 创建 FileInputStream 对象
+        FileInputStream fileInputStream = null;
+
+        try {
+            // 实例化 FileOutputStream 对象
+            fileOutputStream = new FileOutputStream(zipFile);
+            // 实例化 ZipOutputStream 对象
+            zipOutputStream = new ZipOutputStream(fileOutputStream);
+            // 创建 ZipEntry 对象
+            ZipEntry zipEntry = null;
+            // 遍历源文件数组
+            for (int i = 0; i < srcFiles.length; i++) {
+                // 将源文件数组中的当前文件读入 FileInputStream 流中
+                fileInputStream = new FileInputStream(srcFiles[i]);
+                // 实例化 ZipEntry 对象，源文件数组中的当前文件
+                zipEntry = new ZipEntry(srcFiles[i].getName());
+                zipOutputStream.putNextEntry(zipEntry);
+                // 该变量记录每次真正读的字节个数
+                int len;
+                // 定义每次读取的字节数组
+                byte[] buffer = new byte[1024];
+                while ((len = fileInputStream.read(buffer)) > 0) {
+                    zipOutputStream.write(buffer, 0, len);
+                }
+            }
+            zipOutputStream.closeEntry();
+            zipOutputStream.close();
+            fileInputStream.close();
+            fileOutputStream.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+    }
+    /**
+     * 将Map字符串转换为Map
+     *
+     * @param str Map字符串
+     * @return Map
+     */
+    public static Map<String,String> mapStringToMap(String str){
+        str = str.substring(1, str.length()-1);
+        String[] strs = str.split(",");
+        Map<String,String> map = new HashMap<String, String>();
+        for (String string : strs) {
+            String key = string.split("=")[0];
+            String value = string.split("=")[1];
+            // 去掉头部空格
+            String key1 = key.trim();
+            String value1 = value.trim();
+            map.put(key1, value1);
+        }
+        return map;
+    }
+
+
+
+}

src/main/java/com/rf/kjb/scale/scaleResult/C16PFTScale.java

@@ -0,0 +1,226 @@
+package com.rf.kjb.scale.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.dto.NewResultDto;
+import com.rf.kjb.scale.dao.model.AnswerEntity;
+import com.rf.kjb.scale.dao.model.BaseScale;
+import com.rf.kjb.scale.dao.model.DimensionEntity;
+import com.rf.kjb.scale.dao.model.ScaleMarksEntity;
+import com.rf.kjb.scale.util.ScaleConstant;
+import org.springframework.beans.BeanUtils;
+import java.math.BigDecimal;
+import java.text.DecimalFormat;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @Author: GaoYiXuan
+ * @Description:
+ * @DateTime: 2022/7/18 23:01
+ * @Params:
+ * @Return
+ */
+
+public class C16PFTScale extends BaseScale {
+    public C16PFTScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+        //总分
+        double score = 0;
+        DecimalFormat df = new DecimalFormat("######0.00");
+        //结果列表
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+        //新版本数据格式
+        Map<String, Object> newResult = new LinkedHashMap<>();
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        //获取特殊维度信息：这些维度需要根据已有维度进行计算
+        dimensionEntities.add(new DimensionEntity("心理健康者的人格因素", "", "20211020112514", "1"));
+        dimensionEntities.add(new DimensionEntity("从事专业而有成就者的人格因素", "", "20211020112514", "1"));
+        dimensionEntities.add(new DimensionEntity("创造力强者的人格因素", "", "20211020112514", "1"));
+        dimensionEntities.add(new DimensionEntity("在新的环境中有成长能力的人格因素", "", "20211020112514", "1"));
+        dimensionEntities.add(new DimensionEntity("适应与焦虑性", "", "20211020112514", "1"));
+        dimensionEntities.add(new DimensionEntity("内向与外向性", "", "20211020112514", "1"));
+        dimensionEntities.add(new DimensionEntity("感情用事与安祥机警性", "", "20211020112514", "1"));
+        dimensionEntities.add(new DimensionEntity("怯懦与果断性", "", "20211020112514", "1"));
+        //计算每个维度得分dimensionEntities
+        double[] dimensionScore = new double[dimensionEntities.size()];
+        //jsonArray:用户自己选择的题目选项
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            //计算总分
+            for (AnswerEntity answerEntity : answerEntities) {
+                if (answerEntity.getQuestionNo().equals(jsonObject1.getString("questionNo"))) {
+                    if (answerEntity.getName().equals(jsonObject1.getString("checkItems"))) {
+                        score += Double.parseDouble(answerEntity.getScore());
+                        break;
+                    }
+                }
+            }
+
+            //计算维度分数
+            for (int y = 0; y < dimensionEntities.size(); y++) {
+                //获取维度信息
+                DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                //获取该维度下有哪些选项
+                String questionNos = dimensionEntity.getQuestionNo();
+                //得到选择题号
+                String[] questionNo = questionNos.split("；");
+                //处理特殊的维度分数
+                if ("心理健康者的人格因素".equals(dimensionEntity.getName())){
+                    dimensionScore[y] = dimensionScore[2] + dimensionScore[4] + (11 - dimensionScore[11]) + (11 - dimensionScore[15]);
+                } else if ("从事专业而有成就者的人格因素".equals(dimensionEntity.getName())){
+                    dimensionScore[y] = 2 * dimensionScore[14] + 2 * dimensionScore[5] + 2 * dimensionScore[2] + dimensionScore[3] + dimensionScore[10] + dimensionScore[13] + dimensionScore[12];
+                } else if ("创造力强者的人格因素".equals(dimensionEntity.getName())){
+                    dimensionScore[y] = 2 * (11 - dimensionScore[0]) + 2 * dimensionScore[1] + dimensionScore[3] + 2 * (11 - dimensionScore[4]) + dimensionScore[6] + 2 * dimensionScore[7] + dimensionScore[9] + (11 - dimensionScore[10]) + dimensionScore[12] + 2 * dimensionScore[13];
+                } else if ("在新的环境中有成长能力的人格因素".equals(dimensionEntity.getName())){
+                    dimensionScore[y] = dimensionScore[1] + dimensionScore[5] + dimensionScore[14] + (11 - dimensionScore[4]);
+                } else if ("适应与焦虑性".equals(dimensionEntity.getName())){
+                    dimensionScore[y] =((38 + 2 * dimensionScore[8] + 3 * dimensionScore[11] + 4 * dimensionScore[15]) - (2 * dimensionScore[2] + 2 * dimensionScore[6] + 2 * dimensionScore[14])) / 10;
+                } else if ("内向与外向性".equals(dimensionEntity.getName())){
+                    dimensionScore[y] =((2 * dimensionScore[0] + 3 * dimensionScore[3] + 4 * dimensionScore[4] + 5 * dimensionScore[6]) - (2 * dimensionScore[13] + 11)) / 10;
+                } else if ("感情用事与安祥机警性".equals(dimensionEntity.getName())){
+                    dimensionScore[y] =((77 + 2 * dimensionScore[2] + 2 * dimensionScore[3] + 2 * dimensionScore[4] + 2 * dimensionScore[10]) - (4 * dimensionScore[0] + 6*dimensionScore[7] + 2 * dimensionScore[9])) / 10;
+                } else if ("怯懦与果断性".equals(dimensionEntity.getName())){
+                    dimensionScore[y] = ((4 * dimensionScore[3] + 3 * dimensionScore[9] + 4 * dimensionScore[12] + 4 * dimensionScore[13]) - (3 * dimensionScore[0] + 2 * dimensionScore[5])) / 10;
+                }
+                //计算每道题的得分
+                for (String question : questionNo) {
+                    if (question.equals(jsonObject1.getString("questionNo"))) {
+                        //获取所有答案中本道题目的答案list数组
+                        List<AnswerEntity> nowQuestionAnswerList = answerEntities.stream().filter(answerEntity -> answerEntity.getQuestionNo().equals(question)).collect(Collectors.toList());
+                        //本题目的正确答案与自己的选项进行对比，正确的话相应分数进行相加
+                        for (AnswerEntity answerEntity : nowQuestionAnswerList) {
+                            if (answerEntity.getName().equals(jsonObject1.getString("checkItems"))) {
+                                dimensionScore[y] += Double.parseDouble(answerEntity.getScore());
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        //将量表总维度根据维度名称进行分组
+        Map<String, List<ScaleMarksEntity>> scaleMarksMap = scaleMarksEntities.stream().collect(Collectors.groupingBy(ScaleMarksEntity::getName));
+        //返回值以及存数据库格式
+        List<NewResultDto> newResultDtos = new ArrayList<>();
+        resultMap0.put("总分", df.format(score));
+        resultJson.put("总分", df.format(score));
+        BigDecimal scoreDecimal = new BigDecimal(df.format(score));
+        //如果没有总分这一栏，需要手动赋值返回
+        List<ScaleMarksEntity> totalScore = scaleMarksMap.get("总分");
+        if (totalScore == null) {
+            newResultDtos.add(new NewResultDto("总分", df.format(score), "无", "无",
+                    "无", "无", "无", "无", "是"));
+        } else {
+            for (ScaleMarksEntity tempTotalScore : totalScore) {
+                BigDecimal scoreStart = new BigDecimal(tempTotalScore.getScoreStart());
+                BigDecimal scoreEnd = new BigDecimal(tempTotalScore.getScoreEnd());
+                if (scoreDecimal.compareTo(scoreEnd) <= 0 && scoreDecimal.compareTo(scoreStart) >= 0) {
+                    newResultDtos.add(new NewResultDto("总分", df.format(score), tempTotalScore.getSymptom(), tempTotalScore.getImprovementSuggestions(),
+                            tempTotalScore.getFlag(), tempTotalScore.getReference(), tempTotalScore.getNameExplain(), tempTotalScore.getSuggestion(), tempTotalScore.getIsTotalScoreExplain()));
+                }
+            }
+        }
+
+
+        JSONObject iconInfo = new JSONObject();
+        //雷达图需要的维度以及最大值
+        List<Map<String, Object>> indicator = new LinkedList<>();
+        //雷达图所需要的常模参考值
+        LinkedList<String> reference = new LinkedList<>();
+        //雷达图需要的分数
+        LinkedList<String> scoreList = new LinkedList<>();
+        for (int y = 0; y < dimensionEntities.size(); y++) {
+            Map<String, Object> indicatorMap = new HashMap<>();
+            DimensionEntity dimensionEntity = dimensionEntities.get(y);
+            NewResultDto newResultDto1 = new NewResultDto();
+            //存放该维度总分
+            resultMap0.put(dimensionEntity.getName() + "得分", df.format(dimensionScore[y]));
+            resultJson.put(dimensionEntity.getName() + "得分", df.format(dimensionScore[y]));
+            newResultDto1.setScore(df.format(dimensionScore[y]));
+            newResultDtos.add(newResultDto1);
+            BigDecimal dimensionScoreDecimal = new BigDecimal(df.format(dimensionScore[y]));
+            //获取当前维度的评分规则
+            List<ScaleMarksEntity> scaleMarksEntities1 = scaleMarksMap.get(dimensionEntity.getName());
+            if (scaleMarksEntities1 != null) {
+                //循环遍历判断得分在哪个区间
+                for (ScaleMarksEntity scaleMarksEntity : scaleMarksEntities1) {
+                    BigDecimal decimalScoreEnd = new BigDecimal(scaleMarksEntity.getScoreEnd());
+                    BigDecimal decimalScoreStart = new BigDecimal(scaleMarksEntity.getScoreStart());
+                    if (dimensionScoreDecimal.compareTo(decimalScoreEnd) <= 0 && dimensionScoreDecimal.compareTo(decimalScoreStart) >= 0) {
+                        putDimResult(resultMap0, resultJson, dimensionEntity, newResultDto1, scaleMarksEntity);
+                        //需要进行图表展示的维度放入map
+                        if ("1".equals(dimensionEntity.getIsIconFlag())) {
+                            indicatorMap.put("text", dimensionEntity.getName());
+                            //将当前维度按照分数的结尾值来进行排序scaleMarksEntities1
+                            List<ScaleMarksEntity> collect = scaleMarksEntities1.stream().sorted(Comparator.comparing(ScaleMarksEntity::getScoreEnd, Comparator.comparingInt(Integer::parseInt))
+                                    .reversed()).collect(Collectors.toList());
+                            //排序完成后第一个的scoreEnd最大，也就是该维度最大的
+                            indicatorMap.put("max", collect.get(0).getScoreEnd());
+                            indicator.add(indicatorMap);
+                            if ("无".equals(scaleMarksEntity.getReference()) || "无".equals(scaleMarksEntity.getStandardDeviation())) {
+                                //常模参考值设为0
+                                reference.add("0");
+                            } else {
+                                reference.add(scaleMarksEntity.getReference());
+                            }
+                            scoreList.add(String.valueOf(dimensionScore[y]));
+                        }
+                    }
+                }
+            } else {
+                //如果分数规则表中无维度，而维度表中有相应维度，则只显示维度分数
+                newResultDto1.setFlag("无");
+                newResultDto1.setImprovementSuggestions("无");
+                newResultDto1.setName(dimensionEntity.getName());
+                newResultDto1.setReference("无");
+                newResultDto1.setNameExplain("无");
+                newResultDto1.setSuggestion("无");
+                newResultDto1.setIsTotalScoreExplain("否");
+                newResultDto1.setSymptom("无");
+            }
+        }
+        //需要图表展示的
+        iconInfo.put("indicator", indicator);
+        //判断是否有常模参考值，即reference的内容如果全为0，则不进行返回
+        if (!reference.stream().allMatch("0"::equals)) {
+            iconInfo.put("reference", reference);
+        }
+        iconInfo.put("scoreList", scoreList);
+        if (indicator.size() == 0 && reference.size() == 0) {
+            newResult.put("iconInfo", "");
+        } else {
+            newResult.put("iconInfo", iconInfo);
+        }
+        newResult.put("result", newResultDtos);
+        resultMapList.add(resultMap0);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+        returnJson.put("resultJson", resultJson);
+        returnJson.put(ScaleConstant.ResultEnum.RESULT_NEW_FIELD.getKeyword(), newResult);
+
+        return returnJson;
+    }
+
+    private static void putDimResult(Map<String, String> resultMap0, JSONObject resultJson, DimensionEntity dimensionEntity, NewResultDto newResultDto1, ScaleMarksEntity scaleMarksEntity) {
+        resultMap0.put(dimensionEntity.getName() + "常模参考值", scaleMarksEntity.getReference());
+        resultMap0.put(dimensionEntity.getName() + "症状", scaleMarksEntity.getSymptom());
+        resultJson.put(dimensionEntity.getName() + "解读", scaleMarksEntity.getSymptom());
+        resultMap0.put(dimensionEntity.getName() + "因子解释", scaleMarksEntity.getNameExplain());
+        resultMap0.put(dimensionEntity.getName() + "指导语", scaleMarksEntity.getImprovementSuggestions());
+        resultJson.put(dimensionEntity.getName() + "指导语", scaleMarksEntity.getImprovementSuggestions());
+        resultMap0.put(dimensionEntity.getName() + "建议", scaleMarksEntity.getSuggestion());
+        BeanUtils.copyProperties(scaleMarksEntity, newResultDto1);
+    }
+}

src/main/java/com/rf/kjb/scale/scaleResult/C16PFTScaleNEW.java

@@ -0,0 +1,226 @@
+package com.rf.kjb.scale.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.dto.NewResultDto;
+import com.rf.kjb.scale.dao.model.AnswerEntity;
+import com.rf.kjb.scale.dao.model.BaseScale;
+import com.rf.kjb.scale.dao.model.DimensionEntity;
+import com.rf.kjb.scale.dao.model.ScaleMarksEntity;
+import com.rf.kjb.scale.util.ScaleConstant;
+import org.springframework.beans.BeanUtils;
+import java.math.BigDecimal;
+import java.text.DecimalFormat;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @Author: GaoYiXuan
+ * @Description:
+ * @DateTime: 2022/7/18 23:01
+ * @Params:
+ * @Return
+ */
+
+public class C16PFTScaleNEW extends BaseScale {
+    public C16PFTScaleNEW(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+        //总分
+        double score = 0;
+        DecimalFormat df = new DecimalFormat("######0.00");
+        //结果列表
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+        //新版本数据格式
+        Map<String, Object> newResult = new LinkedHashMap<>();
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        //获取特殊维度信息：这些维度需要根据已有维度进行计算
+        dimensionEntities.add(new DimensionEntity("心理健康者的人格因素", "", "20211020112514", "1"));
+        dimensionEntities.add(new DimensionEntity("从事专业而有成就者的人格因素", "", "20211020112514", "1"));
+        dimensionEntities.add(new DimensionEntity("创造力强者的人格因素", "", "20211020112514", "1"));
+        dimensionEntities.add(new DimensionEntity("在新的环境中有成长能力的人格因素", "", "20211020112514", "1"));
+        dimensionEntities.add(new DimensionEntity("适应与焦虑性", "", "20211020112514", "1"));
+        dimensionEntities.add(new DimensionEntity("内向与外向性", "", "20211020112514", "1"));
+        dimensionEntities.add(new DimensionEntity("感情用事与安祥机警性", "", "20211020112514", "1"));
+        dimensionEntities.add(new DimensionEntity("怯懦与果断性", "", "20211020112514", "1"));
+        //计算每个维度得分dimensionEntities
+        double[] dimensionScore = new double[dimensionEntities.size()];
+        //jsonArray:用户自己选择的题目选项
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            //计算总分
+            for (AnswerEntity answerEntity : answerEntities) {
+                if (answerEntity.getQuestionNo().equals(jsonObject1.getString("questionNo"))) {
+                    if (answerEntity.getName().equals(jsonObject1.getString("checkItems"))) {
+                        score += Double.parseDouble(answerEntity.getScore());
+                        break;
+                    }
+                }
+            }
+
+            //计算维度分数
+            for (int y = 0; y < dimensionEntities.size(); y++) {
+                //获取维度信息
+                DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                //获取该维度下有哪些选项
+                String questionNos = dimensionEntity.getQuestionNo();
+                //得到选择题号
+                String[] questionNo = questionNos.split("；");
+                //处理特殊的维度分数
+                if ("心理健康者的人格因素".equals(dimensionEntity.getName())){
+                    dimensionScore[y] = dimensionScore[2] + dimensionScore[4] + (11 - dimensionScore[11]) + (11 - dimensionScore[15]);
+                } else if ("从事专业而有成就者的人格因素".equals(dimensionEntity.getName())){
+                    dimensionScore[y] = 2 * dimensionScore[14] + 2 * dimensionScore[5] + 2 * dimensionScore[2] + dimensionScore[3] + dimensionScore[10] + dimensionScore[13] + dimensionScore[12];
+                } else if ("创造力强者的人格因素".equals(dimensionEntity.getName())){
+                    dimensionScore[y] = 2 * (11 - dimensionScore[0]) + 2 * dimensionScore[1] + dimensionScore[3] + 2 * (11 - dimensionScore[4]) + dimensionScore[6] + 2 * dimensionScore[7] + dimensionScore[9] + (11 - dimensionScore[10]) + dimensionScore[12] + 2 * dimensionScore[13];
+                } else if ("在新的环境中有成长能力的人格因素".equals(dimensionEntity.getName())){
+                    dimensionScore[y] = dimensionScore[1] + dimensionScore[5] + dimensionScore[14] + (11 - dimensionScore[4]);
+                } else if ("适应与焦虑性".equals(dimensionEntity.getName())){
+                    dimensionScore[y] =((38 + 2 * dimensionScore[8] + 3 * dimensionScore[11] + 4 * dimensionScore[15]) - (2 * dimensionScore[2] + 2 * dimensionScore[6] + 2 * dimensionScore[14])) / 10;
+                } else if ("内向与外向性".equals(dimensionEntity.getName())){
+                    dimensionScore[y] =((2 * dimensionScore[0] + 3 * dimensionScore[3] + 4 * dimensionScore[4] + 5 * dimensionScore[6]) - (2 * dimensionScore[13] + 11)) / 10;
+                } else if ("感情用事与安祥机警性".equals(dimensionEntity.getName())){
+                    dimensionScore[y] =((77 + 2 * dimensionScore[2] + 2 * dimensionScore[3] + 2 * dimensionScore[4] + 2 * dimensionScore[10]) - (4 * dimensionScore[0] + 6*dimensionScore[7] + 2 * dimensionScore[9])) / 10;
+                } else if ("怯懦与果断性".equals(dimensionEntity.getName())){
+                    dimensionScore[y] = ((4 * dimensionScore[3] + 3 * dimensionScore[9] + 4 * dimensionScore[12] + 4 * dimensionScore[13]) - (3 * dimensionScore[0] + 2 * dimensionScore[5])) / 10;
+                }
+                //计算每道题的得分
+                for (String question : questionNo) {
+                    if (question.equals(jsonObject1.getString("questionNo"))) {
+                        //获取所有答案中本道题目的答案list数组
+                        List<AnswerEntity> nowQuestionAnswerList = answerEntities.stream().filter(answerEntity -> answerEntity.getQuestionNo().equals(question)).collect(Collectors.toList());
+                        //本题目的正确答案与自己的选项进行对比，正确的话相应分数进行相加
+                        for (AnswerEntity answerEntity : nowQuestionAnswerList) {
+                            if (answerEntity.getName().equals(jsonObject1.getString("checkItems"))) {
+                                dimensionScore[y] += Double.parseDouble(answerEntity.getScore());
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        //将量表总维度根据维度名称进行分组
+        Map<String, List<ScaleMarksEntity>> scaleMarksMap = scaleMarksEntities.stream().collect(Collectors.groupingBy(ScaleMarksEntity::getName));
+        //返回值以及存数据库格式
+        List<NewResultDto> newResultDtos = new ArrayList<>();
+        resultMap0.put("总分", df.format(score));
+        resultJson.put("总分", df.format(score));
+        BigDecimal scoreDecimal = new BigDecimal(df.format(score));
+        //如果没有总分这一栏，需要手动赋值返回
+        List<ScaleMarksEntity> totalScore = scaleMarksMap.get("总分");
+        if (totalScore == null) {
+            newResultDtos.add(new NewResultDto("总分", df.format(score), "无", "无",
+                    "无", "无", "无", "无", "是"));
+        } else {
+            for (ScaleMarksEntity tempTotalScore : totalScore) {
+                BigDecimal scoreStart = new BigDecimal(tempTotalScore.getScoreStart());
+                BigDecimal scoreEnd = new BigDecimal(tempTotalScore.getScoreEnd());
+                if (scoreDecimal.compareTo(scoreEnd) <= 0 && scoreDecimal.compareTo(scoreStart) >= 0) {
+                    newResultDtos.add(new NewResultDto("总分", df.format(score), tempTotalScore.getSymptom(), tempTotalScore.getImprovementSuggestions(),
+                            tempTotalScore.getFlag(), tempTotalScore.getReference(), tempTotalScore.getNameExplain(), tempTotalScore.getSuggestion(), tempTotalScore.getIsTotalScoreExplain()));
+                }
+            }
+        }
+
+
+        JSONObject iconInfo = new JSONObject();
+        //雷达图需要的维度以及最大值
+        List<Map<String, Object>> indicator = new LinkedList<>();
+        //雷达图所需要的常模参考值
+        LinkedList<String> reference = new LinkedList<>();
+        //雷达图需要的分数
+        LinkedList<String> scoreList = new LinkedList<>();
+        for (int y = 0; y < dimensionEntities.size(); y++) {
+            Map<String, Object> indicatorMap = new HashMap<>();
+            DimensionEntity dimensionEntity = dimensionEntities.get(y);
+            NewResultDto newResultDto1 = new NewResultDto();
+            //存放该维度总分
+            resultMap0.put(dimensionEntity.getName() + "得分", df.format(dimensionScore[y]));
+            resultJson.put(dimensionEntity.getName() + "得分", df.format(dimensionScore[y]));
+            newResultDto1.setScore(df.format(dimensionScore[y]));
+            newResultDtos.add(newResultDto1);
+            BigDecimal dimensionScoreDecimal = new BigDecimal(df.format(dimensionScore[y]));
+            //获取当前维度的评分规则
+            List<ScaleMarksEntity> scaleMarksEntities1 = scaleMarksMap.get(dimensionEntity.getName());
+            if (scaleMarksEntities1 != null) {
+                //循环遍历判断得分在哪个区间
+                for (ScaleMarksEntity scaleMarksEntity : scaleMarksEntities1) {
+                    BigDecimal decimalScoreEnd = new BigDecimal(scaleMarksEntity.getScoreEnd());
+                    BigDecimal decimalScoreStart = new BigDecimal(scaleMarksEntity.getScoreStart());
+                    if (dimensionScoreDecimal.compareTo(decimalScoreEnd) <= 0 && dimensionScoreDecimal.compareTo(decimalScoreStart) >= 0) {
+                        putDimResult(resultMap0, resultJson, dimensionEntity, newResultDto1, scaleMarksEntity);
+                        //需要进行图表展示的维度放入map
+                        if ("1".equals(dimensionEntity.getIsIconFlag())) {
+                            indicatorMap.put("text", dimensionEntity.getName());
+                            //将当前维度按照分数的结尾值来进行排序scaleMarksEntities1
+                            List<ScaleMarksEntity> collect = scaleMarksEntities1.stream().sorted(Comparator.comparing(ScaleMarksEntity::getScoreEnd, Comparator.comparingInt(Integer::parseInt))
+                                    .reversed()).collect(Collectors.toList());
+                            //排序完成后第一个的scoreEnd最大，也就是该维度最大的
+                            indicatorMap.put("max", collect.get(0).getScoreEnd());
+                            indicator.add(indicatorMap);
+                            if ("无".equals(scaleMarksEntity.getReference()) || "无".equals(scaleMarksEntity.getStandardDeviation())) {
+                                //常模参考值设为0
+                                reference.add("0");
+                            } else {
+                                reference.add(scaleMarksEntity.getReference());
+                            }
+                            scoreList.add(String.valueOf(dimensionScore[y]));
+                        }
+                    }
+                }
+            } else {
+                //如果分数规则表中无维度，而维度表中有相应维度，则只显示维度分数
+                newResultDto1.setFlag("无");
+                newResultDto1.setImprovementSuggestions("无");
+                newResultDto1.setName(dimensionEntity.getName());
+                newResultDto1.setReference("无");
+                newResultDto1.setNameExplain("无");
+                newResultDto1.setSuggestion("无");
+                newResultDto1.setIsTotalScoreExplain("否");
+                newResultDto1.setSymptom("无");
+            }
+        }
+        //需要图表展示的
+        iconInfo.put("indicator", indicator);
+        //判断是否有常模参考值，即reference的内容如果全为0，则不进行返回
+        if (!reference.stream().allMatch("0"::equals)) {
+            iconInfo.put("reference", reference);
+        }
+        iconInfo.put("scoreList", scoreList);
+        if (indicator.size() == 0 && reference.size() == 0) {
+            newResult.put("iconInfo", "");
+        } else {
+            newResult.put("iconInfo", iconInfo);
+        }
+        newResult.put("result", newResultDtos);
+        resultMapList.add(resultMap0);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+        returnJson.put("resultJson", resultJson);
+        returnJson.put(ScaleConstant.ResultEnum.RESULT_NEW_FIELD.getKeyword(), newResult);
+
+        return returnJson;
+    }
+
+    private static void putDimResult(Map<String, String> resultMap0, JSONObject resultJson, DimensionEntity dimensionEntity, NewResultDto newResultDto1, ScaleMarksEntity scaleMarksEntity) {
+        resultMap0.put(dimensionEntity.getName() + "常模参考值", scaleMarksEntity.getReference());
+        resultMap0.put(dimensionEntity.getName() + "症状", scaleMarksEntity.getSymptom());
+        resultJson.put(dimensionEntity.getName() + "结论", scaleMarksEntity.getSymptom());
+        resultMap0.put(dimensionEntity.getName() + "因子解释", scaleMarksEntity.getNameExplain());
+        resultMap0.put(dimensionEntity.getName() + "指导语", scaleMarksEntity.getImprovementSuggestions());
+        resultJson.put(dimensionEntity.getName() + "指导语", scaleMarksEntity.getImprovementSuggestions());
+        resultMap0.put(dimensionEntity.getName() + "建议", scaleMarksEntity.getSuggestion());
+        BeanUtils.copyProperties(scaleMarksEntity, newResultDto1);
+    }
+}

src/main/java/com/rf/kjb/scale/scaleResult/COMMONScale.java

@@ -0,0 +1,169 @@
+package com.rf.kjb.scale.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.model.AnswerEntity;
+import com.rf.kjb.scale.dao.model.BaseScale;
+import com.rf.kjb.scale.dao.model.DimensionEntity;
+import com.rf.kjb.scale.dao.model.ScaleMarksEntity;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author zsy
+ * @description:简单相加和分维度量表通用算法
+ * @date 2021/7/20 15:55
+ */
+public class COMMONScale extends BaseScale{
+
+    public COMMONScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+
+        // 自定义路径使用
+        /*ScaleUtil.getScaleDll("FESCVSCALE.dll");
+        System.out.println("JSONArray:"+jsonArray);
+        System.out.println("JSONObject:"+resultJson);
+        ScalesJNI scalesJNI = new ScalesJNI(jsonArray,resultJson);
+        String result = scalesJNI.commonScale(jsonArray.toString(), resultJson.toString());
+        JSONObject jsonObjectc =JSONObject.parseObject(result);
+        System.out.println("jsonObjectc:"+jsonObjectc);
+        return jsonObjectc;*/
+
+        //总分
+        double score = 0;
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        List<Map<String,String>> resultMapList = new ArrayList<>();
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        if (dimensionEntities.size() > 0){
+            //计算每个维度得分
+            double[] dimensionScore = new double[dimensionEntities.size()];
+            for (int i = 0; i < jsonArray.size(); i++) {
+                JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+                for (int y = 0; y < dimensionEntities.size(); y++) {
+                    //for (DimensionEntity dimensionEntity:dimensionEntities){
+                    DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                    String questionNos = dimensionEntity.getQuestionNo();
+                    String[] questionNo = questionNos.split("；");
+                    for (String question:questionNo){
+                        if (question.equals(jsonObject1.getString("questionNo"))){
+                            for (AnswerEntity answerEntity:answerEntities){
+                                if (answerEntity.getQuestionNo().equals(question) && answerEntity.getName().equals(jsonObject1.getString("checkItems"))){
+                                    dimensionScore[y] += Double.valueOf(answerEntity.getScore());
+                                }
+                            }
+                            break;
+                        }
+                    }
+                }
+                //计算总分
+                for (AnswerEntity answerEntity:answerEntities){
+                    if (answerEntity.getQuestionNo().equals(String.valueOf(i+1))){
+                        if (answerEntity.getName().equals(jsonObject1.getString("checkItems"))){
+                            score += Integer.valueOf(answerEntity.getScore());
+                        }
+                    }
+                }
+            }
+
+            resultMap0.put("总分", String.valueOf(score));
+            resultJson.put("总分", String.valueOf(score));
+            if (scaleMarksEntities.size() > 0){
+                for (ScaleMarksEntity scaleMarksEntity:scaleMarksEntities){
+                    if (scaleMarksEntity.getName() != null && scaleMarksEntity.getName().equals("无")){
+                        if (score <= Integer.valueOf(scaleMarksEntity.getScoreEnd()) && score >= Integer.valueOf(scaleMarksEntity.getScoreStart())){
+                            if (!scaleMarksEntity.getSymptom().equals("无")){
+                                resultMap0.put("解读", scaleMarksEntity.getSymptom());
+                                resultJson.put("解读", scaleMarksEntity.getSymptom());
+                            }
+                            if (scaleMarksEntity.getImprovementSuggestions() != null && !scaleMarksEntity.getImprovementSuggestions().equals("无")){
+                                resultMap0.put("建议", scaleMarksEntity.getImprovementSuggestions());
+                                resultJson.put("建议", scaleMarksEntity.getImprovementSuggestions());
+                            }
+                        }
+                    }
+                }
+            }
+            if (scaleMarksEntities.size() > 0){
+                for (int y = 0; y < dimensionEntities.size(); y++) {
+                    DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                    DecimalFormat df   = new DecimalFormat("######0.00");
+                    resultMap0.put(dimensionEntity.getName()+"得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y]))));
+                    resultJson.put(dimensionEntity.getName()+"得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y]))));
+                    for (ScaleMarksEntity scaleMarksEntity:scaleMarksEntities){
+                        if (scaleMarksEntity.getName() != null && scaleMarksEntity.getName().equals(dimensionEntity.getName())){
+                            if (dimensionScore[y] <= Integer.valueOf(scaleMarksEntity.getScoreEnd()) && dimensionScore[y] >= Integer.valueOf(scaleMarksEntity.getScoreStart())){
+                                if (!scaleMarksEntity.getSymptom().equals("无")){
+                                    resultMap0.put(dimensionEntity.getName()+"解读", scaleMarksEntity.getSymptom());
+                                    resultJson.put(dimensionEntity.getName()+"解读", scaleMarksEntity.getSymptom());
+                                }
+                                if (scaleMarksEntity.getImprovementSuggestions() != null && !scaleMarksEntity.getImprovementSuggestions().equals("无")){
+                                    resultMap0.put(dimensionEntity.getName()+"建议", scaleMarksEntity.getImprovementSuggestions());
+                                    resultJson.put(dimensionEntity.getName()+"建议", scaleMarksEntity.getImprovementSuggestions());
+                                }
+                            }
+                        }
+                    }
+                }
+                resultMapList.add(resultMap0);
+            }else {
+                for (int y = 0; y < dimensionEntities.size(); y++) {
+                    DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                    DecimalFormat df = new DecimalFormat("######0.00");
+                    resultMap0.put(dimensionEntity.getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y]))));
+                    resultJson.put(dimensionEntity.getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y]))));
+                }
+                resultMapList.add(resultMap0);
+            }
+
+        }else {
+            for (int i = 0; i < jsonArray.size(); i++) {
+                JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+                for (AnswerEntity answerEntity:answerEntities){
+                    if (answerEntity.getQuestionNo().equals(String.valueOf(i+1))){
+                        if (answerEntity.getName().equals(jsonObject1.getString("checkItems"))){
+                            score += Integer.valueOf(answerEntity.getScore());
+                        }
+                    }
+                }
+            }
+
+            resultMap0.put("总分", String.valueOf(score));
+            resultJson.put("总分", String.valueOf(score));
+            if (scaleMarksEntities.size() > 0){
+                for (ScaleMarksEntity scaleMarksEntity:scaleMarksEntities){
+                    if (score <= Integer.valueOf(scaleMarksEntity.getScoreEnd()) && score >= Integer.valueOf(scaleMarksEntity.getScoreStart())){
+                        if (!scaleMarksEntity.getSymptom().equals("无")){
+                            resultMap0.put("解读", scaleMarksEntity.getSymptom());
+                            resultJson.put("解读", scaleMarksEntity.getSymptom());
+                        }
+                        if (scaleMarksEntity.getImprovementSuggestions() != null && !scaleMarksEntity.getImprovementSuggestions().equals("无")){
+                            resultMap0.put("建议", scaleMarksEntity.getImprovementSuggestions());
+                            resultJson.put("建议", scaleMarksEntity.getImprovementSuggestions());
+                        }
+                    }
+                }
+            }
+            resultMapList.add(resultMap0);
+        }
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList",resultMapList);
+        //returnJson.put("scaleName",resultJson.getString("scaleName"));
+        returnJson.put("resultJson",resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/kjb/scale/scaleResult/GSDSScale.java

@@ -0,0 +1,63 @@
+package com.rf.kjb.scale.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.model.AnswerEntity;
+import com.rf.kjb.scale.dao.model.BaseScale;
+import com.rf.kjb.scale.dao.model.DimensionEntity;
+import com.rf.kjb.scale.dao.model.ScaleMarksEntity;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+/**
+ * @author xbw
+ * @description:总体睡眠障碍量表
+ * @date 2021/10/29 15:00
+ */
+public class GSDSScale extends BaseScale {
+    public GSDSScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+
+        //总分
+        double score = 0;
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        List<Map<String,String>> resultMapList = new ArrayList<>();
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        if (jsonArray.size() > 0){
+            //计算总分
+            for (int i = 0; i < jsonArray.size(); i++) {
+                JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+                for(AnswerEntity answerEntity:answerEntities){
+                    if (answerEntity.getQuestionNo().equals(String.valueOf(i+1)) && answerEntity.getName().equals(jsonObject1.getString("checkItems"))){
+                        score += Double.valueOf(answerEntity.getScore());
+                    }
+                }
+            }
+            DecimalFormat df = new DecimalFormat("######0.00");
+            score = Double.parseDouble(df.format(score / jsonArray.size()));
+            resultMap0.put("GSDS平均分", String.valueOf(score));
+            resultJson.put("GSDS平均分", String.valueOf(score));
+
+            resultMapList.add(resultMap0);
+        }
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList",resultMapList);
+        //returnJson.put("scaleName",resultJson.getString("scaleName"));
+        returnJson.put("resultJson",resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/kjb/scale/scaleResult/GSDSScaleNEW.java

@@ -0,0 +1,64 @@
+package com.rf.kjb.scale.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.model.AnswerEntity;
+import com.rf.kjb.scale.dao.model.BaseScale;
+import com.rf.kjb.scale.dao.model.DimensionEntity;
+import com.rf.kjb.scale.dao.model.ScaleMarksEntity;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author xbw
+ * @description:总体睡眠障碍量表
+ * @date 2021/10/29 15:00
+ */
+public class GSDSScaleNEW extends BaseScale {
+    public GSDSScaleNEW(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+
+        //总分
+        double score = 0;
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        List<Map<String,String>> resultMapList = new ArrayList<>();
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        if (jsonArray.size() > 0){
+            //计算总分
+            for (int i = 0; i < jsonArray.size(); i++) {
+                JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+                for(AnswerEntity answerEntity:answerEntities){
+                    if (answerEntity.getQuestionNo().equals(String.valueOf(i+1)) && answerEntity.getName().equals(jsonObject1.getString("checkItems"))){
+                        score += Double.valueOf(answerEntity.getScore());
+                    }
+                }
+            }
+            DecimalFormat df = new DecimalFormat("######0.00");
+            score = Double.parseDouble(df.format(score / jsonArray.size()));
+            resultMap0.put("GSDS平均分", String.valueOf(score));
+            resultJson.put("GSDS平均分", String.valueOf(score));
+
+            resultMapList.add(resultMap0);
+        }
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList",resultMapList);
+        //returnJson.put("scaleName",resultJson.getString("scaleName"));
+        returnJson.put("resultJson",resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/kjb/scale/scaleResult/MBTIScale.java

@@ -0,0 +1,314 @@
+package com.rf.kjb.scale.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.dto.NewResultDto;
+import com.rf.kjb.scale.dao.model.*;
+import com.rf.kjb.scale.util.ScaleConstant;
+
+import java.math.BigDecimal;
+import java.text.DecimalFormat;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @author zsy
+ * @description:职业性格测试
+ * @date 2021/7/20 15:55
+ */
+public class MBTIScale extends BaseScale {
+
+    public MBTIScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public JSONObject scaleCalculate() throws Exception {
+
+        //总分
+        double score = 0;
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取题目和答案列表
+        List<ScaleEntry> scaleEntities = (List<ScaleEntry>) resultJson.get("scaleEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        if (dimensionEntities.size() > 0) {
+            //计算每个维度得分
+            double[] dimensionScore = new double[dimensionEntities.size()];
+            for (int i = 0; i < jsonArray.size(); i++) {
+                JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+                for (int y = 0; y < dimensionEntities.size(); y++) {
+                    //for (DimensionEntity dimensionEntity:dimensionEntities){
+                    DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                    String questionNos = dimensionEntity.getQuestionNo();
+                    String[] questionNo = questionNos.split("；");
+                    for (String question : questionNo) {
+                        if (question.equals(jsonObject1.getString("questionNo"))) {
+                            for (AnswerEntity answerEntity : answerEntities) {
+                                if (answerEntity.getQuestionNo().equals(question) && answerEntity.getName().equals(jsonObject1.getString("checkItems"))) {
+                                    String checkItems = scaleEntities.get(Integer.valueOf(answerEntity.getQuestionNo()) - 1).getCheckItems();
+                                    String[] CheckIteml = checkItems.split("；");
+                                    if ((y & 1) == 1) {
+                                        if (CheckIteml[0].equals(jsonObject1.getString("checkItems"))) {
+                                            dimensionScore[y] += Double.valueOf(answerEntity.getScore());
+                                        } else {
+                                            dimensionScore[y - 1] += Double.valueOf(answerEntity.getScore());
+                                        }
+                                    } else {
+                                        if (CheckIteml[0].equals(jsonObject1.getString("checkItems"))) {
+                                            dimensionScore[y] += Double.valueOf(answerEntity.getScore());
+                                        } else {
+                                            dimensionScore[y + 1] += Double.valueOf(answerEntity.getScore());
+                                        }
+                                    }
+                                }
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+
+            /*score = dimensionScore[0]+dimensionScore[1]+dimensionScore[2]+dimensionScore[3]+dimensionScore[5]-dimensionScore[4]-dimensionScore[6]+100;
+            resultMap0.put("TMD(情绪纷乱的总分)", String.valueOf(score));
+            resultJson.put("TMD(情绪纷乱的总分)", String.valueOf(score));*/
+            for (int y = 0; y < dimensionEntities.size(); y += 2) {
+                DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                DecimalFormat df = new DecimalFormat("######0.00");
+                resultMap0.put(dimensionEntity.getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y]))));
+                resultJson.put(dimensionEntity.getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y]))));
+                resultMap0.put(dimensionEntities.get(y + 1).getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y + 1]))));
+                resultJson.put(dimensionEntities.get(y + 1).getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y + 1]))));
+            }
+            resultMapList.add(resultMap0);
+        }
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+        //returnJson.put("scaleName",resultJson.getString("scaleName"));
+        returnJson.put("resultJson", resultJson);
+
+        return returnJson;
+    }
+
+    public JSONObject scaleCalculateV2() throws Exception {
+
+        //总分
+        double score = 0;
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取题目和答案列表
+        List<ScaleEntry> scaleEntities = (List<ScaleEntry>) resultJson.get("scaleEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        //新版本数据格式
+        Map<String, Object> newResult = null;
+        if (dimensionEntities.size() > 0) {
+            //计算每个维度得分
+            double[] dimensionScore = new double[dimensionEntities.size()];
+            for (int i = 0; i < jsonArray.size(); i++) {
+                JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+                for (int y = 0; y < dimensionEntities.size(); y++) {
+                    //for (DimensionEntity dimensionEntity:dimensionEntities){
+                    DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                    String questionNos = dimensionEntity.getQuestionNo();
+                    String[] questionNo = questionNos.split("；");
+                    for (String question : questionNo) {
+                        if (question.equals(jsonObject1.getString("questionNo"))) {
+                            for (AnswerEntity answerEntity : answerEntities) {
+                                if (answerEntity.getQuestionNo().equals(question) && answerEntity.getName().equals(jsonObject1.getString("checkItems"))) {
+                                    String checkItems = scaleEntities.get(Integer.valueOf(answerEntity.getQuestionNo()) - 1).getCheckItems();
+                                    String[] CheckIteml = checkItems.split("；");
+                                    if ((y & 1) == 1) {
+                                        if (CheckIteml[0].equals(jsonObject1.getString("checkItems"))) {
+                                            dimensionScore[y] += Double.valueOf(answerEntity.getScore());
+                                        } else {
+                                            dimensionScore[y - 1] += Double.valueOf(answerEntity.getScore());
+                                        }
+                                    } else {
+                                        if (CheckIteml[0].equals(jsonObject1.getString("checkItems"))) {
+                                            dimensionScore[y] += Double.valueOf(answerEntity.getScore());
+                                        } else {
+                                            dimensionScore[y + 1] += Double.valueOf(answerEntity.getScore());
+                                        }
+                                    }
+                                }
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+
+            //将量表总维度根据维度名称进行分组
+            Map<String, List<ScaleMarksEntity>> scaleMarksMap = scaleMarksEntities.stream().collect(Collectors.groupingBy(ScaleMarksEntity::getName));
+            newResult = new LinkedHashMap<>();
+            //返回值以及存数据库格式
+            List<NewResultDto> newResultDtos = new ArrayList<>();
+            JSONObject iconInfo = new JSONObject();
+            //雷达图需要的维度以及最大值
+            List<Map<String, Object>> indicator = new LinkedList<>();
+            //雷达图所需要的常模参考值
+            LinkedList<String> reference = new LinkedList<>();
+            //雷达图需要的分数
+            LinkedList<String> scoreList = new LinkedList<>();
+
+            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "判断(J)", dimensionScore[0], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "知觉(P)", dimensionScore[1], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "思维(T)", dimensionScore[2], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "情感(F)", dimensionScore[3], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "感觉(S)", dimensionScore[4], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "直觉(N)", dimensionScore[5], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "外倾(E)", dimensionScore[6], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "内倾(I)", dimensionScore[7], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+            // “外倾/内倾”=(内倾-外倾)/21*10 (正分为内倾I， 负分为外倾E)
+            double score0 = ((dimensionScore[6] - dimensionScore[7]) / 21) * 10;
+            String score0FLag = null;
+            // “感觉/直觉”=(感觉-直觉)/26*10(正分为感觉S，负分为直觉N)
+            double score1 = ((dimensionScore[4] - dimensionScore[5]) / 26) * 10;
+            String score1FLag = null;
+            //“思考/情感”=(思考-情感)/24*10(正分为思考T，负分为情感F)
+            double score2 = ((dimensionScore[2] - dimensionScore[3]) / 24) * 10;
+            String score2FLag = null;
+            //“知觉/判断”=(知觉-判断)/22*10(正分为感性P，负分为判断J)
+            double score3 = ((dimensionScore[1] - dimensionScore[0]) / 22) * 10;
+            String score3FLag = null;
+            DecimalFormat df = new DecimalFormat("######0.00");
+            if (new BigDecimal(df.format(score0)).compareTo(new BigDecimal("-20")) >= 0 && new BigDecimal(df.format(score0)).compareTo(new BigDecimal("0")) < 0) {
+                newResultDtos.add(new NewResultDto("外倾—内倾", df.format(score0), "外倾型", "外倾态度（E）：在外倾的态度中，心理能量和注意是向外流动的，是指向外在环境中的客体的。个体着重外在世界，因注意外在事情而获得动力。",
+                        "无", "无", "(内倾-外倾)/21*10", "无", "否"));
+                score0FLag = "E";
+            } else if (new BigDecimal(df.format(score0)).compareTo(new BigDecimal("0")) >= 0 && new BigDecimal(df.format(score0)).compareTo(new BigDecimal("20")) <= 0) {
+                newResultDtos.add(new NewResultDto("外倾—内倾", df.format(score0), "内倾型", "内倾态度（I）：在内倾的态度中，心理能量是从外部环境向内流动的，指向个体的内在经验与反应。个体着重内在世界，因内省、感觉而获得动力。",
+                        "无", "无", "(内倾-外倾)/21*10", "无", "否"));
+                score0FLag = "I";
+            }
+            if (new BigDecimal(df.format(score1)).compareTo(new BigDecimal("-25")) >= 0 && new BigDecimal(df.format(score1)).compareTo(new BigDecimal("0")) < 0) {
+                newResultDtos.add(new NewResultDto("感觉—直觉", df.format(score1), "直觉型", "直觉功能（N）：偏好直觉的个体倾向于感知的可能性、事物之间的关系，注重事物的未来发展。",
+                        "无", "无", "(感觉-直觉)/26*10", "无", "否"));
+                score1FLag = "N";
+            } else if (new BigDecimal(df.format(score1)).compareTo(new BigDecimal("0")) >= 0 && new BigDecimal(df.format(score1)).compareTo(new BigDecimal("25")) <= 0) {
+                newResultDtos.add(new NewResultDto("感觉—直觉", df.format(score1), "感觉型", "感觉功能（S）：偏好感觉的个体倾向于通过视觉、听觉、触觉、味觉和嗅觉这5种方式来获得信息，个体表现为注重现在的事实与具体观点。",
+                        "无", "无", "(感觉-直觉)/26*10", "无", "否"));
+                score1FLag = "S";
+            }
+            if (new BigDecimal(df.format(score2)).compareTo(new BigDecimal("-23")) >= 0 && new BigDecimal(df.format(score2)).compareTo(new BigDecimal("0")) < 0) {
+                newResultDtos.add(new NewResultDto("感觉—直觉", df.format(score2), "情感型", "情感功能（F）：在作出判断时，倾向于从个人感觉出发，注重事物对自身的价值与喜好。",
+                        "无", "无", "(思考-情感)/24*10", "无", "否"));
+                score2FLag = "F";
+            } else if (new BigDecimal(df.format(score2)).compareTo(new BigDecimal("0")) >= 0 && new BigDecimal(df.format(score2)).compareTo(new BigDecimal("23")) <= 0) {
+                newResultDtos.add(new NewResultDto("感觉—直觉", df.format(score2), "思考型", "思维功能（T）：根据对客观事实的分析，来作出决定，注重公平原则。",
+                        "无", "无", "(思考-情感)/24*10", "无", "否"));
+                score2FLag = "T";
+            }
+            if (new BigDecimal(df.format(score3)).compareTo(new BigDecimal("-21")) >= 0 && new BigDecimal(df.format(score3)).compareTo(new BigDecimal("0")) < 0) {
+                newResultDtos.add(new NewResultDto("判断—知觉", df.format(score3), "判断型", "判断态度(J)：喜欢有条理的生活，实践计划时，以目标为本。通过思考或情感(T或F)来对外界作出反应。",
+                        "无", "无", "(知觉-判断)/22*10", "无", "否"));
+                score3FLag = "J";
+            } else if (new BigDecimal(df.format(score3)).compareTo(new BigDecimal("0")) >= 0 && new BigDecimal(df.format(score3)).compareTo(new BigDecimal("21")) <= 0) {
+                newResultDtos.add(new NewResultDto("判断—知觉", df.format(score3), "感性型", "感知态度（P）：不介意突发事情，喜欢弹性生活，注重过程而非目标。通过感觉或直觉（N或S）来对外界作出反应。",
+                        "无", "无", "(知觉-判断)/22*10", "无", "否"));
+                score3FLag = "P";
+            }
+            String totalFlag = score0FLag + score1FLag + score2FLag + score3FLag;
+            if ("ISTJ".equals(totalFlag)) {
+                resultMap0.put("解读", "沉静，认真，有责任感，讲求实际，注重事实，目标清晰且不易动摇，工作生活都打理得井井有条，心思缜密，重视传统和忠诚。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ISTJ组合型", "沉静，认真，有责任感，讲求实际，注重事实，目标清晰且不易动摇，工作生活都打理得井井有条，心思缜密，重视传统和忠诚。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ISFJ".equals(totalFlag)) {
+                resultMap0.put("解读", "沉静，友善，谨慎，有责任感，重视细节，勤奋，做事有始有终，忠诚，细心，关心他人感受、尊重他人、替他人着想，努力创造一个有秩序、和谐的工作和家居环境。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ISFJ组合型", "沉静，友善，谨慎，有责任感，重视细节，勤奋，做事有始有终，忠诚，细心，关心他人感受、尊重他人、替他人着想，努力创造一个有秩序、和谐的工作和家居环境。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("INFJ".equals(totalFlag)) {
+                resultMap0.put("解读", "喜欢探索世界意义、体察万物关系，对人有很强的洞察力，坚持并践履自己的价值观念，懂得关心他人，友好而和善，有一个清晰的理念以谋取大众的最佳利益，能够有计划地、果断地去实践自己的理念。");
+                newResultDtos.add(new NewResultDto("总分", "无", "INFJ组合型", "喜欢探索世界意义、体察万物关系，对人有很强的洞察力，坚持并践履自己的价值观念，懂得关心他人，友好而和善，有一个清晰的理念以谋取大众的最佳利益，能够有计划地、果断地去实践自己的理念。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("INTJ".equals(totalFlag)) {
+                resultMap0.put("解读", "具有创意头脑、有很大的冲劲去实践自己的理念，较为聪慧，能够很快地掌握事情发展的规律，想出长远的发展方向。对复杂的理论充满激情，会有条理地开展工作，并致力于目标的达成，是天生的组织者，有怀疑精神，能看到更多的机会，独立自主，有高水准的工作表现。");
+                newResultDtos.add(new NewResultDto("总分", "无", "INTJ组合型", "具有创意头脑、有很大的冲劲去实践自己的理念，较为聪慧，能够很快地掌握事情发展的规律，想出长远的发展方向。对复杂的理论充满激情，会有条理地开展工作，并致力于目标的达成，是天生的组织者，有怀疑精神，能看到更多的机会，独立自主，有高水准的工作表现。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ISTP".equals(totalFlag)) {
+                resultMap0.put("解读", "是冷静的观察者，具有超强的忍耐力和弹性，很重视事件的前因后果，遇到问题会马上行动并找到应对措施，可以从大量信息中找到症结，能够以理性的原则把事实组织起来，重视效率，善于实践，动手能力强。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ISTP组合型", "是冷静的观察者，具有超强的忍耐力和弹性，很重视事件的前因后果，遇到问题会马上行动并找到应对措施，可以从大量信息中找到症结，能够以理性的原则把事实组织起来，重视效率，善于实践，动手能力强。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ISFP".equals(totalFlag)) {
+                resultMap0.put("解读", "沉静、友善、敏感和仁慈，心思细腻，不喜欢与人产生冲突，不会强迫别人接受自己的意见或价值观，喜欢有独自的空间，可以按照自己的时间规划进行工作安排，渴望沟通分享，热爱大自然，喜欢探索未知的事物。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ISFP组合型", "沉静、友善、敏感和仁慈，心思细腻，不喜欢与人产生冲突，不会强迫别人接受自己的意见或价值观，喜欢有独自的空间，可以按照自己的时间规划进行工作安排，渴望沟通分享，热爱大自然，喜欢探索未知的事物。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("INFP".equals(totalFlag)) {
+                resultMap0.put("解读", "理想主义者，忠于自己的价值观及自己所重视的人，只要双方的价值观没有抵触，往往能包容他人，有弹性，善于接受新事物，有好奇心，能快速预判事情的发展趋向，适应力强，能快速发现他人的优势，并助其发挥潜能。");
+                newResultDtos.add(new NewResultDto("总分", "无", "INFP组合型", "理想主义者，忠于自己的价值观及自己所重视的人，只要双方的价值观没有抵触，往往能包容他人，有弹性，善于接受新事物，有好奇心，能快速预判事情的发展趋向，适应力强，能快速发现他人的优势，并助其发挥潜能。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("INTP".equals(totalFlag)) {
+                resultMap0.put("解读", "沉静、满足、有弹性、适应力强，有怀疑精神，有时喜欢批评，擅于分析，对任何感兴趣的事物，都要探索一个合理的解释，喜欢理论性和抽象性的概念，热衷于思考，有深度的钻研精神，思维严谨有条理。");
+                newResultDtos.add(new NewResultDto("总分", "无", "INTP组合型", "沉静、满足、有弹性、适应力强，有怀疑精神，有时喜欢批评，擅于分析，对任何感兴趣的事物，都要探索一个合理的解释，喜欢理论性和抽象性的概念，热衷于思考，有深度的钻研精神，思维严谨有条理。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ESTP".equals(totalFlag)) {
+                resultMap0.put("解读", "自然不做作，喜欢主动与别人交往，专注于“此时此地”，讲求实际，注重结果，希望以积极的行动去解决问题，喜欢学习新的事物，较为理性，擅长数学及专业理论，追求利益最大化，但过度严谨。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ESTP组合型", "自然不做作，喜欢主动与别人交往，专注于“此时此地”，讲求实际，注重结果，希望以积极的行动去解决问题，喜欢学习新的事物，较为理性，擅长数学及专业理论，追求利益最大化，但过度严谨。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ESFP".equals(totalFlag)) {
+                resultMap0.put("解读", "外向、友善、包容，热爱生命，喜欢物质享受，接受力强，讲究实用性，易接受新朋友和适应新环境，富有灵活性，善于识人，喜欢和他人一起工作，周到得体，但处理原则问题时会摇摆不定。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ESFP组合型", "外向、友善、包容，热爱生命，喜欢物质享受，接受力强，讲究实用性，易接受新朋友和适应新环境，富有灵活性，善于识人，喜欢和他人一起工作，周到得体，但处理原则问题时会摇摆不定。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ENFP".equals(totalFlag)) {
+                resultMap0.put("解读", "热情且富有想象力，认为生活充满很多可能性，有灵性，可以快速将事物的有关信息联系起来，有信心按照自己的判断去解决问题，有很强的即兴发挥能力，容易冲动，很需要别人的肯定，也乐于欣赏和支持别人。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ENFP组合型", "热情且富有想象力，认为生活充满很多可能性，有灵性，可以快速将事物的有关信息联系起来，有信心按照自己的判断去解决问题，有很强的即兴发挥能力，容易冲动，很需要别人的肯定，也乐于欣赏和支持别人。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ENTP".equals(totalFlag)) {
+                resultMap0.put("解读", "思维敏捷，反应快，勇于发言，善于洞察别人，能激励他人，警觉性强，喜欢用战略的眼光分析问题，不喜欢例行公事，能随机应变地去应付新的和富于挑战性的问题。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ENTP组合型", "思维敏捷，反应快，勇于发言，善于洞察别人，能激励他人，警觉性强，喜欢用战略的眼光分析问题，不喜欢例行公事，能随机应变地去应付新的和富于挑战性的问题。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ESTJ".equals(totalFlag)) {
+                resultMap0.put("解读", "讲求实际，注重现实，能果断而快速地作出实际可行的决定，并安排计划和组织人员去完成工作，注重细节，有一套清晰的逻辑标准，能遵从规章制度并坚决执行，善于处理程式化事物，一丝不苟，习惯以经验解决问题。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ESTJ组合型", "讲求实际，注重现实，能果断而快速地作出实际可行的决定，并安排计划和组织人员去完成工作，注重细节，有一套清晰的逻辑标准，能遵从规章制度并坚决执行，善于处理程式化事物，一丝不苟，习惯以经验解决问题。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ESFJ".equals(totalFlag)) {
+                resultMap0.put("解读", "能言善辩，有爱心、尽责，善于合作，喜欢与别人共事，能够注意到别人生活中的需要，渴望和谐的环境并致力于营造这样的环境，希望自己的努力可以得到认可，有极强的同理心，希望通过自己的力量帮助他人。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ESFJ组合型", "能言善辩，有爱心、尽责，善于合作，喜欢与别人共事，能够注意到别人生活中的需要，渴望和谐的环境并致力于营造这样的环境，希望自己的努力可以得到认可，有极强的同理心，希望通过自己的力量帮助他人。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ENFJ".equals(totalFlag)) {
+                resultMap0.put("解读", "温情，有同情心，反应敏捷，有责任感，能为他人着想，善于发现他人的潜能，表达能力强，社交活跃，能积极地协助他人和组织的成长，有启发人的领导才能，忠诚，对赞美和批评都能作出快速回应，喜欢直接表明自己的观点。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ENFJ组合型", "温情，有同情心，反应敏捷，有责任感，能为他人着想，善于发现他人的潜能，表达能力强，社交活跃，能积极地协助他人和组织的成长，有启发人的领导才能，忠诚，对赞美和批评都能作出快速回应，喜欢直接表明自己的观点。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ENTJ".equals(totalFlag)) {
+                resultMap0.put("解读", "坦率、果断、乐于作为领导者，能够发现组织规章制度的不合理性并着力加以改善，喜欢制定长远计划，善于设定目标，努力求知，又能把知识传给别人，富有远见，见解深刻。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ENTJ组合型", "坦率、果断、乐于作为领导者，能够发现组织规章制度的不合理性并着力加以改善，喜欢制定长远计划，善于设定目标，努力求知，又能把知识传给别人，富有远见，见解深刻。",
+                        "无", "无", "无", "无", "是"));
+            }
+            //需要图表展示的
+            iconInfo.put("indicator", indicator);
+            //判断是否有常模参考值，即reference的内容如果全为0，则不进行返回
+            if (!reference.stream().allMatch("0"::equals)) {
+                iconInfo.put("reference", reference);
+            }
+            iconInfo.put("scoreList", scoreList);
+            if (indicator.size() == 0 && reference.size() == 0) {
+                newResult.put("iconInfo", "");
+            } else {
+                newResult.put("iconInfo", iconInfo);
+            }
+            newResult.put("result", newResultDtos);
+            resultMapList.add(resultMap0);
+        }
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+
+        returnJson.put("resultJson", resultJson);
+        returnJson.put(ScaleConstant.ResultEnum.RESULT_NEW_FIELD.getKeyword(), newResult);
+
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/kjb/scale/scaleResult/MBTIScaleNEW.java

@@ -0,0 +1,314 @@
+package com.rf.kjb.scale.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.dto.NewResultDto;
+import com.rf.kjb.scale.dao.model.*;
+import com.rf.kjb.scale.util.ScaleConstant;
+
+import java.math.BigDecimal;
+import java.text.DecimalFormat;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @author zsy
+ * @description:职业性格测试
+ * @date 2021/7/20 15:55
+ */
+public class MBTIScaleNEW extends BaseScale {
+
+    public MBTIScaleNEW(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public JSONObject scaleCalculate() throws Exception {
+
+        //总分
+        double score = 0;
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取题目和答案列表
+        List<ScaleEntry> scaleEntities = (List<ScaleEntry>) resultJson.get("scaleEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        if (dimensionEntities.size() > 0) {
+            //计算每个维度得分
+            double[] dimensionScore = new double[dimensionEntities.size()];
+            for (int i = 0; i < jsonArray.size(); i++) {
+                JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+                for (int y = 0; y < dimensionEntities.size(); y++) {
+                    //for (DimensionEntity dimensionEntity:dimensionEntities){
+                    DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                    String questionNos = dimensionEntity.getQuestionNo();
+                    String[] questionNo = questionNos.split("；");
+                    for (String question : questionNo) {
+                        if (question.equals(jsonObject1.getString("questionNo"))) {
+                            for (AnswerEntity answerEntity : answerEntities) {
+                                if (answerEntity.getQuestionNo().equals(question) && answerEntity.getName().equals(jsonObject1.getString("checkItems"))) {
+                                    String checkItems = scaleEntities.get(Integer.valueOf(answerEntity.getQuestionNo()) - 1).getCheckItems();
+                                    String[] CheckIteml = checkItems.split("；");
+                                    if ((y & 1) == 1) {
+                                        if (CheckIteml[0].equals(jsonObject1.getString("checkItems"))) {
+                                            dimensionScore[y] += Double.valueOf(answerEntity.getScore());
+                                        } else {
+                                            dimensionScore[y - 1] += Double.valueOf(answerEntity.getScore());
+                                        }
+                                    } else {
+                                        if (CheckIteml[0].equals(jsonObject1.getString("checkItems"))) {
+                                            dimensionScore[y] += Double.valueOf(answerEntity.getScore());
+                                        } else {
+                                            dimensionScore[y + 1] += Double.valueOf(answerEntity.getScore());
+                                        }
+                                    }
+                                }
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+
+            /*score = dimensionScore[0]+dimensionScore[1]+dimensionScore[2]+dimensionScore[3]+dimensionScore[5]-dimensionScore[4]-dimensionScore[6]+100;
+            resultMap0.put("TMD(情绪纷乱的总分)", String.valueOf(score));
+            resultJson.put("TMD(情绪纷乱的总分)", String.valueOf(score));*/
+            for (int y = 0; y < dimensionEntities.size(); y += 2) {
+                DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                DecimalFormat df = new DecimalFormat("######0.00");
+                resultMap0.put(dimensionEntity.getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y]))));
+                resultJson.put(dimensionEntity.getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y]))));
+                resultMap0.put(dimensionEntities.get(y + 1).getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y + 1]))));
+                resultJson.put(dimensionEntities.get(y + 1).getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y + 1]))));
+            }
+            resultMapList.add(resultMap0);
+        }
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+        //returnJson.put("scaleName",resultJson.getString("scaleName"));
+        returnJson.put("resultJson", resultJson);
+
+        return returnJson;
+    }
+
+    public JSONObject scaleCalculateV2() throws Exception {
+
+        //总分
+        double score = 0;
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取题目和答案列表
+        List<ScaleEntry> scaleEntities = (List<ScaleEntry>) resultJson.get("scaleEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        //新版本数据格式
+        Map<String, Object> newResult = null;
+        if (dimensionEntities.size() > 0) {
+            //计算每个维度得分
+            double[] dimensionScore = new double[dimensionEntities.size()];
+            for (int i = 0; i < jsonArray.size(); i++) {
+                JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+                for (int y = 0; y < dimensionEntities.size(); y++) {
+                    //for (DimensionEntity dimensionEntity:dimensionEntities){
+                    DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                    String questionNos = dimensionEntity.getQuestionNo();
+                    String[] questionNo = questionNos.split("；");
+                    for (String question : questionNo) {
+                        if (question.equals(jsonObject1.getString("questionNo"))) {
+                            for (AnswerEntity answerEntity : answerEntities) {
+                                if (answerEntity.getQuestionNo().equals(question) && answerEntity.getName().equals(jsonObject1.getString("checkItems"))) {
+                                    String checkItems = scaleEntities.get(Integer.parseInt(answerEntity.getQuestionNo()) - 1).getCheckItems();
+                                    String[] CheckIteml = checkItems.split("；");
+                                    if ((y & 1) == 1) {
+                                        if (CheckIteml[0].equals(jsonObject1.getString("checkItems"))) {
+                                            dimensionScore[y] += Double.valueOf(answerEntity.getScore());
+                                        } else {
+                                            dimensionScore[y - 1] += Double.valueOf(answerEntity.getScore());
+                                        }
+                                    } else {
+                                        if (CheckIteml[0].equals(jsonObject1.getString("checkItems"))) {
+                                            dimensionScore[y] += Double.valueOf(answerEntity.getScore());
+                                        } else {
+                                            dimensionScore[y + 1] += Double.valueOf(answerEntity.getScore());
+                                        }
+                                    }
+                                }
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+
+            //将量表总维度根据维度名称进行分组
+            Map<String, List<ScaleMarksEntity>> scaleMarksMap = scaleMarksEntities.stream().collect(Collectors.groupingBy(ScaleMarksEntity::getName));
+            newResult = new LinkedHashMap<>();
+            //返回值以及存数据库格式
+            List<NewResultDto> newResultDtos = new ArrayList<>();
+            JSONObject iconInfo = new JSONObject();
+            //雷达图需要的维度以及最大值
+            List<Map<String, Object>> indicator = new LinkedList<>();
+            //雷达图所需要的常模参考值
+            LinkedList<String> reference = new LinkedList<>();
+            //雷达图需要的分数
+            LinkedList<String> scoreList = new LinkedList<>();
+
+            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "判断(J)", dimensionScore[0], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "知觉(P)", dimensionScore[1], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "思维(T)", dimensionScore[2], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "情感(F)", dimensionScore[3], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "感觉(S)", dimensionScore[4], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "直觉(N)", dimensionScore[5], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "外倾(E)", dimensionScore[6], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+            NEWCOMMONScale.commonComputeDimensionScore(null, resultMap0, resultJson, "内倾(I)", dimensionScore[7], true, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+            // “外倾/内倾”=(内倾-外倾)/21*10 (正分为内倾I， 负分为外倾E)
+            double score0 = ((dimensionScore[6] - dimensionScore[7]) / 21) * 10;
+            String score0FLag = null;
+            // “感觉/直觉”=(感觉-直觉)/26*10(正分为感觉S，负分为直觉N)
+            double score1 = ((dimensionScore[4] - dimensionScore[5]) / 26) * 10;
+            String score1FLag = null;
+            //“思考/情感”=(思考-情感)/24*10(正分为思考T，负分为情感F)
+            double score2 = ((dimensionScore[2] - dimensionScore[3]) / 24) * 10;
+            String score2FLag = null;
+            //“知觉/判断”=(知觉-判断)/22*10(正分为感性P，负分为判断J)
+            double score3 = ((dimensionScore[1] - dimensionScore[0]) / 22) * 10;
+            String score3FLag = null;
+            DecimalFormat df = new DecimalFormat("######0.00");
+            if (new BigDecimal(df.format(score0)).compareTo(new BigDecimal("-20")) >= 0 && new BigDecimal(df.format(score0)).compareTo(new BigDecimal("0")) < 0) {
+                newResultDtos.add(new NewResultDto("外倾—内倾", df.format(score0), "外倾型", "外倾态度（E）：在外倾的态度中，心理能量和注意是向外流动的，是指向外在环境中的客体的。个体着重外在世界，因注意外在事情而获得动力。",
+                        "无", "无", "(内倾-外倾)/21*10", "无", "否"));
+                score0FLag = "E";
+            } else if (new BigDecimal(df.format(score0)).compareTo(new BigDecimal("0")) >= 0 && new BigDecimal(df.format(score0)).compareTo(new BigDecimal("20")) <= 0) {
+                newResultDtos.add(new NewResultDto("外倾—内倾", df.format(score0), "内倾型", "内倾态度（I）：在内倾的态度中，心理能量是从外部环境向内流动的，指向个体的内在经验与反应。个体着重内在世界，因内省、感觉而获得动力。",
+                        "无", "无", "(内倾-外倾)/21*10", "无", "否"));
+                score0FLag = "I";
+            }
+            if (new BigDecimal(df.format(score1)).compareTo(new BigDecimal("-25")) >= 0 && new BigDecimal(df.format(score1)).compareTo(new BigDecimal("0")) < 0) {
+                newResultDtos.add(new NewResultDto("感觉—直觉", df.format(score1), "直觉型", "直觉功能（N）：偏好直觉的个体倾向于感知的可能性、事物之间的关系，注重事物的未来发展。",
+                        "无", "无", "(感觉-直觉)/26*10", "无", "否"));
+                score1FLag = "N";
+            } else if (new BigDecimal(df.format(score1)).compareTo(new BigDecimal("0")) >= 0 && new BigDecimal(df.format(score1)).compareTo(new BigDecimal("25")) <= 0) {
+                newResultDtos.add(new NewResultDto("感觉—直觉", df.format(score1), "感觉型", "感觉功能（S）：偏好感觉的个体倾向于通过视觉、听觉、触觉、味觉和嗅觉这5种方式来获得信息，个体表现为注重现在的事实与具体观点。",
+                        "无", "无", "(感觉-直觉)/26*10", "无", "否"));
+                score1FLag = "S";
+            }
+            if (new BigDecimal(df.format(score2)).compareTo(new BigDecimal("-23")) >= 0 && new BigDecimal(df.format(score2)).compareTo(new BigDecimal("0")) < 0) {
+                newResultDtos.add(new NewResultDto("感觉—直觉", df.format(score2), "情感型", "情感功能（F）：在作出判断时，倾向于从个人感觉出发，注重事物对自身的价值与喜好。",
+                        "无", "无", "(思考-情感)/24*10", "无", "否"));
+                score2FLag = "F";
+            } else if (new BigDecimal(df.format(score2)).compareTo(new BigDecimal("0")) >= 0 && new BigDecimal(df.format(score2)).compareTo(new BigDecimal("23")) <= 0) {
+                newResultDtos.add(new NewResultDto("感觉—直觉", df.format(score2), "思考型", "思维功能（T）：根据对客观事实的分析，来作出决定，注重公平原则。",
+                        "无", "无", "(思考-情感)/24*10", "无", "否"));
+                score2FLag = "T";
+            }
+            if (new BigDecimal(df.format(score3)).compareTo(new BigDecimal("-21")) >= 0 && new BigDecimal(df.format(score3)).compareTo(new BigDecimal("0")) < 0) {
+                newResultDtos.add(new NewResultDto("判断—知觉", df.format(score3), "判断型", "判断态度(J)：喜欢有条理的生活，实践计划时，以目标为本。通过思考或情感(T或F)来对外界作出反应。",
+                        "无", "无", "(知觉-判断)/22*10", "无", "否"));
+                score3FLag = "J";
+            } else if (new BigDecimal(df.format(score3)).compareTo(new BigDecimal("0")) >= 0 && new BigDecimal(df.format(score3)).compareTo(new BigDecimal("21")) <= 0) {
+                newResultDtos.add(new NewResultDto("判断—知觉", df.format(score3), "感性型", "感知态度（P）：不介意突发事情，喜欢弹性生活，注重过程而非目标。通过感觉或直觉（N或S）来对外界作出反应。",
+                        "无", "无", "(知觉-判断)/22*10", "无", "否"));
+                score3FLag = "P";
+            }
+            String totalFlag = score0FLag + score1FLag + score2FLag + score3FLag;
+            if ("ISTJ".equals(totalFlag)) {
+                resultMap0.put("结论", "沉静，认真，有责任感，讲求实际，注重事实，目标清晰且不易动摇，工作生活都打理得井井有条，心思缜密，重视传统和忠诚。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ISTJ组合型", "沉静，认真，有责任感，讲求实际，注重事实，目标清晰且不易动摇，工作生活都打理得井井有条，心思缜密，重视传统和忠诚。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ISFJ".equals(totalFlag)) {
+                resultMap0.put("结论", "沉静，友善，谨慎，有责任感，重视细节，勤奋，做事有始有终，忠诚，细心，关心他人感受、尊重他人、替他人着想，努力创造一个有秩序、和谐的工作和家居环境。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ISFJ组合型", "沉静，友善，谨慎，有责任感，重视细节，勤奋，做事有始有终，忠诚，细心，关心他人感受、尊重他人、替他人着想，努力创造一个有秩序、和谐的工作和家居环境。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("INFJ".equals(totalFlag)) {
+                resultMap0.put("结论", "喜欢探索世界意义、体察万物关系，对人有很强的洞察力，坚持并践履自己的价值观念，懂得关心他人，友好而和善，有一个清晰的理念以谋取大众的最佳利益，能够有计划地、果断地去实践自己的理念。");
+                newResultDtos.add(new NewResultDto("总分", "无", "INFJ组合型", "喜欢探索世界意义、体察万物关系，对人有很强的洞察力，坚持并践履自己的价值观念，懂得关心他人，友好而和善，有一个清晰的理念以谋取大众的最佳利益，能够有计划地、果断地去实践自己的理念。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("INTJ".equals(totalFlag)) {
+                resultMap0.put("结论", "具有创意头脑、有很大的冲劲去实践自己的理念，较为聪慧，能够很快地掌握事情发展的规律，想出长远的发展方向。对复杂的理论充满激情，会有条理地开展工作，并致力于目标的达成，是天生的组织者，有怀疑精神，能看到更多的机会，独立自主，有高水准的工作表现。");
+                newResultDtos.add(new NewResultDto("总分", "无", "INTJ组合型", "具有创意头脑、有很大的冲劲去实践自己的理念，较为聪慧，能够很快地掌握事情发展的规律，想出长远的发展方向。对复杂的理论充满激情，会有条理地开展工作，并致力于目标的达成，是天生的组织者，有怀疑精神，能看到更多的机会，独立自主，有高水准的工作表现。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ISTP".equals(totalFlag)) {
+                resultMap0.put("结论", "是冷静的观察者，具有超强的忍耐力和弹性，很重视事件的前因后果，遇到问题会马上行动并找到应对措施，可以从大量信息中找到症结，能够以理性的原则把事实组织起来，重视效率，善于实践，动手能力强。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ISTP组合型", "是冷静的观察者，具有超强的忍耐力和弹性，很重视事件的前因后果，遇到问题会马上行动并找到应对措施，可以从大量信息中找到症结，能够以理性的原则把事实组织起来，重视效率，善于实践，动手能力强。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ISFP".equals(totalFlag)) {
+                resultMap0.put("结论", "沉静、友善、敏感和仁慈，心思细腻，不喜欢与人产生冲突，不会强迫别人接受自己的意见或价值观，喜欢有独自的空间，可以按照自己的时间规划进行工作安排，渴望沟通分享，热爱大自然，喜欢探索未知的事物。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ISFP组合型", "沉静、友善、敏感和仁慈，心思细腻，不喜欢与人产生冲突，不会强迫别人接受自己的意见或价值观，喜欢有独自的空间，可以按照自己的时间规划进行工作安排，渴望沟通分享，热爱大自然，喜欢探索未知的事物。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("INFP".equals(totalFlag)) {
+                resultMap0.put("结论", "理想主义者，忠于自己的价值观及自己所重视的人，只要双方的价值观没有抵触，往往能包容他人，有弹性，善于接受新事物，有好奇心，能快速预判事情的发展趋向，适应力强，能快速发现他人的优势，并助其发挥潜能。");
+                newResultDtos.add(new NewResultDto("总分", "无", "INFP组合型", "理想主义者，忠于自己的价值观及自己所重视的人，只要双方的价值观没有抵触，往往能包容他人，有弹性，善于接受新事物，有好奇心，能快速预判事情的发展趋向，适应力强，能快速发现他人的优势，并助其发挥潜能。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("INTP".equals(totalFlag)) {
+                resultMap0.put("结论", "沉静、满足、有弹性、适应力强，有怀疑精神，有时喜欢批评，擅于分析，对任何感兴趣的事物，都要探索一个合理的解释，喜欢理论性和抽象性的概念，热衷于思考，有深度的钻研精神，思维严谨有条理。");
+                newResultDtos.add(new NewResultDto("总分", "无", "INTP组合型", "沉静、满足、有弹性、适应力强，有怀疑精神，有时喜欢批评，擅于分析，对任何感兴趣的事物，都要探索一个合理的解释，喜欢理论性和抽象性的概念，热衷于思考，有深度的钻研精神，思维严谨有条理。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ESTP".equals(totalFlag)) {
+                resultMap0.put("结论", "自然不做作，喜欢主动与别人交往，专注于“此时此地”，讲求实际，注重结果，希望以积极的行动去解决问题，喜欢学习新的事物，较为理性，擅长数学及专业理论，追求利益最大化，但过度严谨。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ESTP组合型", "自然不做作，喜欢主动与别人交往，专注于“此时此地”，讲求实际，注重结果，希望以积极的行动去解决问题，喜欢学习新的事物，较为理性，擅长数学及专业理论，追求利益最大化，但过度严谨。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ESFP".equals(totalFlag)) {
+                resultMap0.put("结论", "外向、友善、包容，热爱生命，喜欢物质享受，接受力强，讲究实用性，易接受新朋友和适应新环境，富有灵活性，善于识人，喜欢和他人一起工作，周到得体，但处理原则问题时会摇摆不定。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ESFP组合型", "外向、友善、包容，热爱生命，喜欢物质享受，接受力强，讲究实用性，易接受新朋友和适应新环境，富有灵活性，善于识人，喜欢和他人一起工作，周到得体，但处理原则问题时会摇摆不定。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ENFP".equals(totalFlag)) {
+                resultMap0.put("结论", "热情且富有想象力，认为生活充满很多可能性，有灵性，可以快速将事物的有关信息联系起来，有信心按照自己的判断去解决问题，有很强的即兴发挥能力，容易冲动，很需要别人的肯定，也乐于欣赏和支持别人。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ENFP组合型", "热情且富有想象力，认为生活充满很多可能性，有灵性，可以快速将事物的有关信息联系起来，有信心按照自己的判断去解决问题，有很强的即兴发挥能力，容易冲动，很需要别人的肯定，也乐于欣赏和支持别人。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ENTP".equals(totalFlag)) {
+                resultMap0.put("结论", "思维敏捷，反应快，勇于发言，善于洞察别人，能激励他人，警觉性强，喜欢用战略的眼光分析问题，不喜欢例行公事，能随机应变地去应付新的和富于挑战性的问题。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ENTP组合型", "思维敏捷，反应快，勇于发言，善于洞察别人，能激励他人，警觉性强，喜欢用战略的眼光分析问题，不喜欢例行公事，能随机应变地去应付新的和富于挑战性的问题。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ESTJ".equals(totalFlag)) {
+                resultMap0.put("结论", "讲求实际，注重现实，能果断而快速地作出实际可行的决定，并安排计划和组织人员去完成工作，注重细节，有一套清晰的逻辑标准，能遵从规章制度并坚决执行，善于处理程式化事物，一丝不苟，习惯以经验解决问题。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ESTJ组合型", "讲求实际，注重现实，能果断而快速地作出实际可行的决定，并安排计划和组织人员去完成工作，注重细节，有一套清晰的逻辑标准，能遵从规章制度并坚决执行，善于处理程式化事物，一丝不苟，习惯以经验解决问题。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ESFJ".equals(totalFlag)) {
+                resultMap0.put("结论", "能言善辩，有爱心、尽责，善于合作，喜欢与别人共事，能够注意到别人生活中的需要，渴望和谐的环境并致力于营造这样的环境，希望自己的努力可以得到认可，有极强的同理心，希望通过自己的力量帮助他人。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ESFJ组合型", "能言善辩，有爱心、尽责，善于合作，喜欢与别人共事，能够注意到别人生活中的需要，渴望和谐的环境并致力于营造这样的环境，希望自己的努力可以得到认可，有极强的同理心，希望通过自己的力量帮助他人。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ENFJ".equals(totalFlag)) {
+                resultMap0.put("结论", "温情，有同情心，反应敏捷，有责任感，能为他人着想，善于发现他人的潜能，表达能力强，社交活跃，能积极地协助他人和组织的成长，有启发人的领导才能，忠诚，对赞美和批评都能作出快速回应，喜欢直接表明自己的观点。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ENFJ组合型", "温情，有同情心，反应敏捷，有责任感，能为他人着想，善于发现他人的潜能，表达能力强，社交活跃，能积极地协助他人和组织的成长，有启发人的领导才能，忠诚，对赞美和批评都能作出快速回应，喜欢直接表明自己的观点。",
+                        "无", "无", "无", "无", "是"));
+            } else if ("ENTJ".equals(totalFlag)) {
+                resultMap0.put("结论", "坦率、果断、乐于作为领导者，能够发现组织规章制度的不合理性并着力加以改善，喜欢制定长远计划，善于设定目标，努力求知，又能把知识传给别人，富有远见，见解深刻。");
+                newResultDtos.add(new NewResultDto("总分", "无", "ENTJ组合型", "坦率、果断、乐于作为领导者，能够发现组织规章制度的不合理性并着力加以改善，喜欢制定长远计划，善于设定目标，努力求知，又能把知识传给别人，富有远见，见解深刻。",
+                        "无", "无", "无", "无", "是"));
+            }
+            //需要图表展示的
+            iconInfo.put("indicator", indicator);
+            //判断是否有常模参考值，即reference的内容如果全为0，则不进行返回
+            if (!reference.stream().allMatch("0"::equals)) {
+                iconInfo.put("reference", reference);
+            }
+            iconInfo.put("scoreList", scoreList);
+            if (indicator.size() == 0 && reference.size() == 0) {
+                newResult.put("iconInfo", "");
+            } else {
+                newResult.put("iconInfo", iconInfo);
+            }
+            newResult.put("result", newResultDtos);
+            resultMapList.add(resultMap0);
+        }
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+
+        returnJson.put("resultJson", resultJson);
+        returnJson.put(ScaleConstant.ResultEnum.RESULT_NEW_FIELD.getKeyword(), newResult);
+
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/kjb/scale/scaleResult/NEWCOMMONScale.java

@@ -0,0 +1,293 @@
+package com.rf.kjb.scale.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.dto.NewResultDto;
+import com.rf.kjb.scale.dao.model.AnswerEntity;
+import com.rf.kjb.scale.dao.model.BaseScale;
+import com.rf.kjb.scale.dao.model.DimensionEntity;
+import com.rf.kjb.scale.dao.model.ScaleMarksEntity;
+import com.rf.kjb.scale.util.ScaleConstant;
+import org.springframework.beans.BeanUtils;
+import org.springframework.lang.Nullable;
+
+import java.math.BigDecimal;
+import java.text.DecimalFormat;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @author lpf
+ * @description:新量表（需要图表信息之类的）保存处理接口
+ * @date 2022/4/22 15:55
+ */
+public class NEWCOMMONScale extends BaseScale {
+
+    public NEWCOMMONScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public JSONObject scaleCalculate() throws Exception {
+
+        //总分
+        double score = 0;
+        DecimalFormat df = new DecimalFormat("######0.00");
+
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+        //新版本数据格式
+        Map<String, Object> newResult = new LinkedHashMap<>();
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        //计算每个维度得分dimensionEntities
+        double[] dimensionScore = new double[dimensionEntities.size()];
+        //jsonArray:用户自己选择的题目选项
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            //计算总分
+            for (AnswerEntity answerEntity : answerEntities) {
+                if (answerEntity.getQuestionNo().equals(jsonObject1.getString("questionNo"))) {
+                    if (answerEntity.getName().equals(jsonObject1.getString("checkItems"))) {
+                        score += Double.parseDouble(answerEntity.getScore());
+                        break;
+                    }
+                }
+            }
+
+            //计算维度分数
+            for (int y = 0; y < dimensionEntities.size(); y++) {
+                //获取维度信息
+                DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                //获取该维度下有哪些选项
+                String questionNos = dimensionEntity.getQuestionNo();
+                //删除空白字符后得到进行划分得到选择题号
+                String[] questionNo = questionNos.replaceAll("\\s","").split("；");
+                //计算每道题的得分
+                for (String question : questionNo) {
+                    if (question.equals(jsonObject1.getString("questionNo"))) {
+                        //获取所有答案中本道题目的答案list数组
+                        List<AnswerEntity> nowQuestionAnswerList = answerEntities.stream().filter(answerEntity -> answerEntity.getQuestionNo().equals(question)).collect(Collectors.toList());
+                        //本题目的正确答案与自己的选项进行对比，正确的话相应分数进行相加
+                        for (AnswerEntity answerEntity : nowQuestionAnswerList) {
+                            if (answerEntity.getName().equals(jsonObject1.getString("checkItems"))) {
+                                dimensionScore[y] += Double.parseDouble(answerEntity.getScore());
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        //将量表总维度根据维度名称进行分组
+        Map<String, List<ScaleMarksEntity>> scaleMarksMap = scaleMarksEntities.stream().collect(Collectors.groupingBy(ScaleMarksEntity::getName));
+        //返回值以及存数据库格式
+        List<NewResultDto> newResultDtos = new ArrayList<>();
+        resultMap0.put("总分", df.format(score));
+        resultJson.put("总分", df.format(score));
+        BigDecimal scoreDecimal = new BigDecimal(df.format(score));
+        //如果没有总分这一栏，需要手动赋值返回
+        List<ScaleMarksEntity> totalScore = scaleMarksMap.get("总分");
+        if (totalScore == null) {
+            newResultDtos.add(new NewResultDto("总分", df.format(score), "无", "无",
+                    "无", "无", "无", "无", "是"));
+        } else {
+            for (ScaleMarksEntity tempTotalScore : totalScore) {
+                BigDecimal scoreStart = new BigDecimal(tempTotalScore.getScoreStart());
+                BigDecimal scoreEnd = new BigDecimal(tempTotalScore.getScoreEnd());
+                if (scoreDecimal.compareTo(scoreEnd) <= 0 && scoreDecimal.compareTo(scoreStart) >= 0) {
+                    newResultDtos.add(new NewResultDto("总分", df.format(score), tempTotalScore.getSymptom(), tempTotalScore.getImprovementSuggestions(),
+                            tempTotalScore.getFlag(), tempTotalScore.getReference(), tempTotalScore.getNameExplain(), tempTotalScore.getSuggestion(), tempTotalScore.getIsTotalScoreExplain()));
+                }
+            }
+        }
+
+
+        JSONObject iconInfo = new JSONObject();
+        //雷达图需要的维度以及最大值
+        List<Map<String, Object>> indicator = new LinkedList<>();
+        //雷达图所需要的常模参考值
+        LinkedList<String> reference = new LinkedList<>();
+        //雷达图需要的分数
+        LinkedList<String> scoreList = new LinkedList<>();
+        //计算维度所在评分区间
+        commonComputeDimensionScore(df, resultMap0, resultJson, dimensionEntities, dimensionScore, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+        //需要图表展示的
+        iconInfo.put("indicator", indicator);
+        //判断是否有常模参考值，即reference的内容如果全为0，则不进行返回
+        if (!reference.stream().allMatch("0"::equals)) {
+            iconInfo.put("reference", reference);
+        }
+        iconInfo.put("scoreList", scoreList);
+        if (indicator.size() == 0 && reference.size() == 0) {
+            newResult.put("iconInfo", "");
+        } else {
+            newResult.put("iconInfo", iconInfo);
+        }
+        newResult.put("result", newResultDtos);
+        resultMapList.add(resultMap0);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+        returnJson.put("resultJson", resultJson);
+        returnJson.put(ScaleConstant.ResultEnum.RESULT_NEW_FIELD.getKeyword(), newResult);
+
+        return returnJson;
+    }
+
+    /**
+     * 通用计算量表所有维度分数，以及其维度所在分数段症状等
+     *
+     * @param df                用来设置小数位数，例如保留两位小数DecimalFormat df = new DecimalFormat("######0.00");
+     * @param resultMap         用来向数据库存
+     * @param resultJson        WebScaleResultController传递过来的评分规则等相关参数
+     * @param dimensionEntities 量表维度list信息
+     * @param dimensionScore    量表维度分数，需要和量表维度list对应
+     * @param scaleMarksMap     评分规则的map
+     * @param newResultDtos     各个维度的结论，等级解释等list
+     * @param indicator         雷达图需要的维度以及最大值
+     * @param reference         雷达图所需要的常模参考值
+     * @param scoreList         雷达图需要的分数
+     */
+    public static void commonComputeDimensionScore(@Nullable DecimalFormat df, Map<String, String> resultMap, JSONObject resultJson, List<DimensionEntity> dimensionEntities, double[] dimensionScore, Map<String, List<ScaleMarksEntity>> scaleMarksMap, List<NewResultDto> newResultDtos, List<Map<String, Object>> indicator, List<String> reference, List<String> scoreList) {
+        if (df == null) {
+            df = new DecimalFormat("######0.00");
+        }
+        for (int y = 0; y < dimensionEntities.size(); y++) {
+            Map<String, Object> indicatorMap = new HashMap<>();
+            DimensionEntity dimensionEntity = dimensionEntities.get(y);
+            NewResultDto newResultDto1 = new NewResultDto();
+            //存放该维度总分
+            resultMap.put(dimensionEntity.getName() + "得分", df.format(dimensionScore[y]));
+            resultJson.put(dimensionEntity.getName() + "得分", df.format(dimensionScore[y]));
+            newResultDto1.setScore(df.format(dimensionScore[y]));
+            newResultDtos.add(newResultDto1);
+            BigDecimal dimensionScoreDecimal = new BigDecimal(df.format(dimensionScore[y]));
+            //获取当前维度的评分规则
+            List<ScaleMarksEntity> scaleMarksEntities1 = scaleMarksMap.get(dimensionEntity.getName());
+            if (scaleMarksEntities1 != null) {
+                //循环遍历判断得分在哪个区间
+                for (ScaleMarksEntity scaleMarksEntity : scaleMarksEntities1) {
+                    BigDecimal decimalScoreEnd = new BigDecimal(scaleMarksEntity.getScoreEnd());
+                    BigDecimal decimalScoreStart = new BigDecimal(scaleMarksEntity.getScoreStart());
+                    if (dimensionScoreDecimal.compareTo(decimalScoreEnd) <= 0 && dimensionScoreDecimal.compareTo(decimalScoreStart) >= 0) {
+                        putDimResult(resultMap, resultJson, dimensionEntity.getName(), newResultDto1, scaleMarksEntity);
+                        //需要进行图表展示的维度放入map
+                        if ("1".equals(dimensionEntity.getIsIconFlag())) {
+                            indicatorMap.put("text", dimensionEntity.getName());
+                            //将当前维度按照分数的结尾值来进行排序scaleMarksEntities1
+                            List<ScaleMarksEntity> collect = scaleMarksEntities1.stream().sorted(Comparator.comparing(ScaleMarksEntity::getScoreEnd, Comparator.comparingInt(Integer::parseInt))
+                                    .reversed()).collect(Collectors.toList());
+                            //排序完成后第一个的scoreEnd最大，也就是该维度最大的
+                            indicatorMap.put("max", collect.get(0).getScoreEnd());
+                            indicator.add(indicatorMap);
+                            if ("无".equals(scaleMarksEntity.getReference()) || "无".equals(scaleMarksEntity.getStandardDeviation())) {
+                                //常模参考值设为0
+                                reference.add("0");
+                            } else {
+                                reference.add(scaleMarksEntity.getReference());
+                            }
+                            scoreList.add(String.valueOf(dimensionScore[y]));
+                        }
+                    }
+                }
+            } else {
+                //如果分数规则表中无维度，而维度表中有相应维度，则只显示维度分数
+                newResultDto1.setFlag("无");
+                newResultDto1.setImprovementSuggestions("无");
+                newResultDto1.setName(dimensionEntity.getName());
+                newResultDto1.setReference("无");
+                newResultDto1.setNameExplain("无");
+                newResultDto1.setSuggestion("无");
+                newResultDto1.setIsTotalScoreExplain("否");
+                newResultDto1.setSymptom("无");
+            }
+        }
+    }
+
+    /**
+     * 通用计算单个维度分数，以及其维度所在分数段症状等
+     *
+     * @param df              默认为两位小数，可以为null，用来设置小数位数，例如保留两位小数DecimalFormat df = new DecimalFormat("######0.00");
+     * @param resultMap       用来向数据库存
+     * @param resultJson      WebScaleResultController传递过来的评分规则等相关参数
+     * @param dimensionName   维度名称
+     * @param dimensionScore  维度分数
+     * @param isDimensionShow 是否在雷达图中展示
+     * @param scaleMarksMap   评分规则的map
+     * @param newResultDtos   各个维度的结论，等级解释等list
+     * @param indicator       雷达图需要的维度以及最大值
+     * @param reference       雷达图所需要的常模参考值
+     * @param scoreList       雷达图需要的分数
+     */
+    public static void commonComputeDimensionScore(@Nullable DecimalFormat df, Map<String, String> resultMap, JSONObject resultJson, String dimensionName, double dimensionScore, Boolean isDimensionShow, Map<String, List<ScaleMarksEntity>> scaleMarksMap, List<NewResultDto> newResultDtos, List<Map<String, Object>> indicator, List<String> reference, List<String> scoreList) {
+        if (df == null) {
+            df = new DecimalFormat("######0.00");
+        }
+        Map<String, Object> indicatorMap = new HashMap<>();
+        NewResultDto newResultDto = new NewResultDto();
+        //存放该维度总分
+        resultMap.put(dimensionName + "得分", df.format(dimensionScore));
+        resultJson.put(dimensionName + "得分", df.format(dimensionScore));
+        newResultDto.setScore(df.format(dimensionScore));
+        newResultDtos.add(newResultDto);
+        BigDecimal dimensionScoreDecimal = new BigDecimal(df.format(dimensionScore));
+        //获取当前维度的评分规则
+        List<ScaleMarksEntity> scaleMarksEntities1 = scaleMarksMap.get(dimensionName);
+        if (scaleMarksEntities1 != null) {
+            //循环遍历判断得分在哪个区间
+            for (ScaleMarksEntity scaleMarksEntity : scaleMarksEntities1) {
+                BigDecimal decimalScoreEnd = new BigDecimal(scaleMarksEntity.getScoreEnd());
+                BigDecimal decimalScoreStart = new BigDecimal(scaleMarksEntity.getScoreStart());
+                if (dimensionScoreDecimal.compareTo(decimalScoreEnd) <= 0 && dimensionScoreDecimal.compareTo(decimalScoreStart) >= 0) {
+                    putDimResult(resultMap, resultJson, dimensionName, newResultDto, scaleMarksEntity);
+                    //需要进行图表展示的维度放入map
+                    if (isDimensionShow) {
+                        indicatorMap.put("text", dimensionName);
+                        //将当前维度按照分数的结尾值来进行排序scaleMarksEntities1
+                        List<ScaleMarksEntity> collect = scaleMarksEntities1.stream().sorted(Comparator.comparing(ScaleMarksEntity::getScoreEnd, Comparator.comparingInt(Integer::parseInt))
+                                .reversed()).collect(Collectors.toList());
+                        //排序完成后第一个的scoreEnd最大，也就是该维度最大的
+                        indicatorMap.put("max", collect.get(0).getScoreEnd());
+                        indicator.add(indicatorMap);
+                        if ("无".equals(scaleMarksEntity.getReference()) || "无".equals(scaleMarksEntity.getStandardDeviation())) {
+                            //常模参考值设为0
+                            reference.add("0");
+                        } else {
+                            reference.add(scaleMarksEntity.getReference());
+                        }
+                        scoreList.add(String.valueOf(dimensionScore));
+                    }
+                }
+            }
+        } else {
+            //如果分数规则表中无维度，而维度表中有相应维度，则只显示维度分数
+            newResultDto.setFlag("无");
+            newResultDto.setImprovementSuggestions("无");
+            newResultDto.setName(dimensionName);
+            newResultDto.setReference("无");
+            newResultDto.setNameExplain("无");
+            newResultDto.setSuggestion("无");
+            newResultDto.setIsTotalScoreExplain("否");
+            newResultDto.setSymptom("无");
+        }
+    }
+
+
+    private static void putDimResult(Map<String, String> resultMap0, JSONObject resultJson, String dimensionName, NewResultDto newResultDto1, ScaleMarksEntity scaleMarksEntity) {
+        resultMap0.put(dimensionName + "常模参考值", scaleMarksEntity.getReference());
+        resultMap0.put(dimensionName + "症状", scaleMarksEntity.getSymptom());
+        resultJson.put(dimensionName + "解读", scaleMarksEntity.getSymptom());
+        resultMap0.put(dimensionName + "因子解释", scaleMarksEntity.getNameExplain());
+        resultMap0.put(dimensionName + "指导语", scaleMarksEntity.getImprovementSuggestions());
+        resultJson.put(dimensionName + "指导语", scaleMarksEntity.getImprovementSuggestions());
+        resultMap0.put(dimensionName + "建议", scaleMarksEntity.getSuggestion());
+        BeanUtils.copyProperties(scaleMarksEntity, newResultDto1);
+    }
+
+
+}

src/main/java/com/rf/kjb/scale/scaleResult/NEWCOMMONScaleNEW.java

@@ -0,0 +1,306 @@
+package com.rf.kjb.scale.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.dto.NewResultDto;
+import com.rf.kjb.scale.dao.model.*;
+import com.rf.kjb.scale.util.ScaleConstant;
+import org.springframework.beans.BeanUtils;
+import org.springframework.lang.Nullable;
+
+import java.math.BigDecimal;
+import java.text.DecimalFormat;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @author lpf
+ * @description:新量表（需要图表信息之类的）保存处理接口
+ * @date 2022/4/22 15:55
+ */
+public class NEWCOMMONScaleNEW extends BaseScale {
+
+    public NEWCOMMONScaleNEW(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public JSONObject scaleCalculate() throws Exception {
+
+        //总分
+        double score = 0;
+        DecimalFormat df = new DecimalFormat("######0.00");
+
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+        //新版本数据格式
+        Map<String, Object> newResult = new LinkedHashMap<>();
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        //计算每个维度得分dimensionEntities
+        double[] dimensionScore = new double[dimensionEntities.size()];
+        //jsonArray:用户自己选择的题目选项
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            //计算总分
+            for (AnswerEntity answerEntity : answerEntities) {
+                if (answerEntity.getQuestionNo().equals(jsonObject1.getString("questionNo"))) {
+                    if (answerEntity.getName().replaceAll("\\s", "").equals(jsonObject1.getString("checkItems").replaceAll("\\s", ""))) {
+                        score += Double.parseDouble(answerEntity.getScore());
+                        break;
+                    }
+                }
+            }
+
+            //计算维度分数
+            for (int y = 0; y < dimensionEntities.size(); y++) {
+                //获取维度信息
+                DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                //获取该维度下有哪些选项
+                String questionNos = dimensionEntity.getQuestionNo();
+                //删除空白字符后得到进行划分得到选择题号
+                String[] questionNo = questionNos.replaceAll("\\s", "").split("；");
+                //计算每道题的得分
+                for (String question : questionNo) {
+                    if (question.equals(jsonObject1.getString("questionNo"))) {
+                        //获取所有答案中本道题目的答案list数组
+                        List<AnswerEntity> nowQuestionAnswerList = answerEntities.stream().filter(answerEntity -> answerEntity.getQuestionNo().equals(question)).collect(Collectors.toList());
+                        //本题目的正确答案与自己的选项进行对比，正确的话相应分数进行相加
+                        for (AnswerEntity answerEntity : nowQuestionAnswerList) {
+                            if (answerEntity.getName().replaceAll("\\s", "").equals(jsonObject1.getString("checkItems").replaceAll("\\s", ""))) {
+                                dimensionScore[y] += Double.parseDouble(answerEntity.getScore());
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        //将量表总维度根据维度名称进行分组
+        Map<String, List<ScaleMarksEntity>> scaleMarksMap = scaleMarksEntities.stream().collect(Collectors.groupingBy(ScaleMarksEntity::getName));
+        //返回值以及存数据库格式
+        List<NewResultDto> newResultDtos = new ArrayList<>();
+        resultMap0.put("总分", df.format(score));
+        resultJson.put("总分", df.format(score));
+        BigDecimal scoreDecimal = new BigDecimal(df.format(score));
+        //如果没有总分这一栏，需要手动赋值返回
+        List<ScaleMarksEntity> totalScore = scaleMarksMap.get("总分");
+        List<ScaleMarksEntity> totalScores = scaleMarksMap.get("无");
+        if (totalScore == null) {
+            if (totalScores == null){
+                newResultDtos.add(new NewResultDto("总分", df.format(score), "无", "无",
+                        "无", "无", "无", "无", "是"));
+            }else {
+                for (ScaleMarksEntity tempTotalScore : totalScores) {
+                    BigDecimal scoreStart = new BigDecimal(tempTotalScore.getScoreStart());
+                    BigDecimal scoreEnd = new BigDecimal(tempTotalScore.getScoreEnd());
+                    if (scoreDecimal.compareTo(scoreEnd) <= 0 && scoreDecimal.compareTo(scoreStart) >= 0) {
+                        newResultDtos.add(new NewResultDto("总分", df.format(score), tempTotalScore.getSymptom(), tempTotalScore.getImprovementSuggestions(),
+                                tempTotalScore.getFlag(), tempTotalScore.getReference(), tempTotalScore.getNameExplain(), tempTotalScore.getSuggestion(), tempTotalScore.getIsTotalScoreExplain()));
+                        resultMap0.put("总分症状", tempTotalScore.getSymptom());
+                        resultMap0.put("总分指导语", tempTotalScore.getImprovementSuggestions());
+                    }
+                }
+            }
+        } else {
+            for (ScaleMarksEntity tempTotalScore : totalScore) {
+                BigDecimal scoreStart = new BigDecimal(tempTotalScore.getScoreStart());
+                BigDecimal scoreEnd = new BigDecimal(tempTotalScore.getScoreEnd());
+                if (scoreDecimal.compareTo(scoreEnd) <= 0 && scoreDecimal.compareTo(scoreStart) >= 0) {
+                    newResultDtos.add(new NewResultDto("总分", df.format(score), tempTotalScore.getSymptom(), tempTotalScore.getImprovementSuggestions(),
+                            tempTotalScore.getFlag(), tempTotalScore.getReference(), tempTotalScore.getNameExplain(), tempTotalScore.getSuggestion(), tempTotalScore.getIsTotalScoreExplain()));
+                    resultMap0.put("总分症状", tempTotalScore.getSymptom());
+                    resultMap0.put("总分指导语", tempTotalScore.getImprovementSuggestions());
+                }
+            }
+        }
+
+
+        JSONObject iconInfo = new JSONObject();
+        //雷达图需要的维度以及最大值
+        List<Map<String, Object>> indicator = new LinkedList<>();
+        //雷达图所需要的常模参考值
+        LinkedList<String> reference = new LinkedList<>();
+        //雷达图需要的分数
+        LinkedList<String> scoreList = new LinkedList<>();
+        //计算维度所在评分区间
+        commonComputeDimensionScore(df, resultMap0, resultJson, dimensionEntities, dimensionScore, scaleMarksMap, newResultDtos, indicator, reference, scoreList);
+        //需要图表展示的
+        iconInfo.put("indicator", indicator);
+        //判断是否有常模参考值，即reference的内容如果全为0，则不进行返回
+        if (!reference.stream().allMatch("0"::equals)) {
+            iconInfo.put("reference", reference);
+        }
+        iconInfo.put("scoreList", scoreList);
+        if (indicator.size() == 0 && reference.size() == 0) {
+            newResult.put("iconInfo", "");
+        } else {
+            newResult.put("iconInfo", iconInfo);
+        }
+        newResult.put("result", newResultDtos);
+        resultMapList.add(resultMap0);
+
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+        returnJson.put("resultJson", resultJson);
+        returnJson.put(ScaleConstant.ResultEnum.RESULT_NEW_FIELD.getKeyword(), newResult);
+
+        return returnJson;
+    }
+
+    /**
+     * 通用计算量表所有维度分数，以及其维度所在分数段症状等
+     *
+     * @param df                用来设置小数位数，例如保留两位小数DecimalFormat df = new DecimalFormat("######0.00");
+     * @param resultMap         用来向数据库存
+     * @param resultJson        WebScaleResultController传递过来的评分规则等相关参数
+     * @param dimensionEntities 量表维度list信息
+     * @param dimensionScore    量表维度分数，需要和量表维度list对应
+     * @param scaleMarksMap     评分规则的map
+     * @param newResultDtos     各个维度的结论，等级解释等list
+     * @param indicator         雷达图需要的维度以及最大值
+     * @param reference         雷达图所需要的常模参考值
+     * @param scoreList         雷达图需要的分数
+     */
+    public static void commonComputeDimensionScore(@Nullable DecimalFormat df, Map<String, String> resultMap, JSONObject resultJson, List<DimensionEntity> dimensionEntities, double[] dimensionScore, Map<String, List<ScaleMarksEntity>> scaleMarksMap, List<NewResultDto> newResultDtos, List<Map<String, Object>> indicator, List<String> reference, List<String> scoreList) {
+        if (df == null) {
+            df = new DecimalFormat("######0.00");
+        }
+        for (int y = 0; y < dimensionEntities.size(); y++) {
+            Map<String, Object> indicatorMap = new HashMap<>();
+            DimensionEntity dimensionEntity = dimensionEntities.get(y);
+            NewResultDto newResultDto1 = new NewResultDto();
+            //存放该维度总分
+            resultMap.put(dimensionEntity.getName() + "得分", df.format(dimensionScore[y]));
+            resultJson.put(dimensionEntity.getName() + "得分", df.format(dimensionScore[y]));
+            newResultDto1.setScore(df.format(dimensionScore[y]));
+            newResultDtos.add(newResultDto1);
+            BigDecimal dimensionScoreDecimal = new BigDecimal(df.format(dimensionScore[y]));
+            //获取当前维度的评分规则
+            List<ScaleMarksEntity> scaleMarksEntities1 = scaleMarksMap.get(dimensionEntity.getName());
+            if (scaleMarksEntities1 != null) {
+                //循环遍历判断得分在哪个区间
+                for (ScaleMarksEntity scaleMarksEntity : scaleMarksEntities1) {
+                    BigDecimal decimalScoreEnd = new BigDecimal(scaleMarksEntity.getScoreEnd());
+                    BigDecimal decimalScoreStart = new BigDecimal(scaleMarksEntity.getScoreStart());
+                    if (dimensionScoreDecimal.compareTo(decimalScoreEnd) <= 0 && dimensionScoreDecimal.compareTo(decimalScoreStart) >= 0) {
+                        putDimResult(resultMap, resultJson, dimensionEntity.getName(), newResultDto1, scaleMarksEntity);
+                        //需要进行图表展示的维度放入map
+                        if ("1".equals(dimensionEntity.getIsIconFlag())) {
+                            indicatorMap.put("text", dimensionEntity.getName());
+                            //将当前维度按照分数的结尾值来进行排序scaleMarksEntities1
+                            List<ScaleMarksEntity> collect = scaleMarksEntities1.stream().sorted(Comparator.comparing(ScaleMarksEntity::getScoreEnd, Comparator.comparingInt(Integer::parseInt))
+                                    .reversed()).collect(Collectors.toList());
+                            //排序完成后第一个的scoreEnd最大，也就是该维度最大的
+                            indicatorMap.put("max", collect.get(0).getScoreEnd());
+                            indicator.add(indicatorMap);
+                            if ("无".equals(scaleMarksEntity.getReference()) || "无".equals(scaleMarksEntity.getStandardDeviation())) {
+                                //常模参考值设为0
+                                reference.add("0");
+                            } else {
+                                reference.add(scaleMarksEntity.getReference());
+                            }
+                            scoreList.add(String.valueOf(dimensionScore[y]));
+                        }
+                    }
+                }
+            } else {
+                //如果分数规则表中无维度，而维度表中有相应维度，则只显示维度分数
+                newResultDto1.setFlag("无");
+                newResultDto1.setImprovementSuggestions("无");
+                newResultDto1.setName(dimensionEntity.getName());
+                newResultDto1.setReference("无");
+                newResultDto1.setNameExplain("无");
+                newResultDto1.setSuggestion("无");
+                newResultDto1.setIsTotalScoreExplain("否");
+                newResultDto1.setSymptom("无");
+            }
+        }
+    }
+
+    /**
+     * 通用计算单个维度分数，以及其维度所在分数段症状等
+     *
+     * @param df              默认为两位小数，可以为null，用来设置小数位数，例如保留两位小数DecimalFormat df = new DecimalFormat("######0.00");
+     * @param resultMap       用来向数据库存
+     * @param resultJson      WebScaleResultController传递过来的评分规则等相关参数
+     * @param dimensionName   维度名称
+     * @param dimensionScore  维度分数
+     * @param isDimensionShow 是否在雷达图中展示
+     * @param scaleMarksMap   评分规则的map
+     * @param newResultDtos   各个维度的结论，等级解释等list
+     * @param indicator       雷达图需要的维度以及最大值
+     * @param reference       雷达图所需要的常模参考值
+     * @param scoreList       雷达图需要的分数
+     */
+    public static void commonComputeDimensionScore(@Nullable DecimalFormat df, Map<String, String> resultMap, JSONObject resultJson, String dimensionName, double dimensionScore, Boolean isDimensionShow, Map<String, List<ScaleMarksEntity>> scaleMarksMap, List<NewResultDto> newResultDtos, List<Map<String, Object>> indicator, List<String> reference, List<String> scoreList) {
+        if (df == null) {
+            df = new DecimalFormat("######0.00");
+        }
+        Map<String, Object> indicatorMap = new HashMap<>();
+        NewResultDto newResultDto = new NewResultDto();
+        //存放该维度总分
+        resultMap.put(dimensionName + "得分", df.format(dimensionScore));
+        resultJson.put(dimensionName + "得分", df.format(dimensionScore));
+        newResultDto.setScore(df.format(dimensionScore));
+        newResultDtos.add(newResultDto);
+        BigDecimal dimensionScoreDecimal = new BigDecimal(df.format(dimensionScore));
+        //获取当前维度的评分规则
+        List<ScaleMarksEntity> scaleMarksEntities1 = scaleMarksMap.get(dimensionName);
+        if (scaleMarksEntities1 != null) {
+            //循环遍历判断得分在哪个区间
+            for (ScaleMarksEntity scaleMarksEntity : scaleMarksEntities1) {
+                BigDecimal decimalScoreEnd = new BigDecimal(scaleMarksEntity.getScoreEnd());
+                BigDecimal decimalScoreStart = new BigDecimal(scaleMarksEntity.getScoreStart());
+                if (dimensionScoreDecimal.compareTo(decimalScoreEnd) <= 0 && dimensionScoreDecimal.compareTo(decimalScoreStart) >= 0) {
+                    putDimResult(resultMap, resultJson, dimensionName, newResultDto, scaleMarksEntity);
+                    //需要进行图表展示的维度放入map
+                    if (isDimensionShow) {
+                        indicatorMap.put("text", dimensionName);
+                        //将当前维度按照分数的结尾值来进行排序scaleMarksEntities1
+                        List<ScaleMarksEntity> collect = scaleMarksEntities1.stream().sorted(Comparator.comparing(ScaleMarksEntity::getScoreEnd, Comparator.comparingInt(Integer::parseInt))
+                                .reversed()).collect(Collectors.toList());
+                        //排序完成后第一个的scoreEnd最大，也就是该维度最大的
+                        indicatorMap.put("max", collect.get(0).getScoreEnd());
+                        indicator.add(indicatorMap);
+                        if ("无".equals(scaleMarksEntity.getReference()) || "无".equals(scaleMarksEntity.getStandardDeviation())) {
+                            //常模参考值设为0
+                            reference.add("0");
+                        } else {
+                            reference.add(scaleMarksEntity.getReference());
+                        }
+                        scoreList.add(String.valueOf(dimensionScore));
+                    }
+                }
+            }
+        } else {
+            //如果分数规则表中无维度，而维度表中有相应维度，则只显示维度分数
+            newResultDto.setFlag("无");
+            newResultDto.setImprovementSuggestions("无");
+            newResultDto.setName(dimensionName);
+            newResultDto.setReference("无");
+            newResultDto.setNameExplain("无");
+            newResultDto.setSuggestion("无");
+            newResultDto.setIsTotalScoreExplain("否");
+            newResultDto.setSymptom("无");
+        }
+    }
+
+
+    private static void putDimResult(Map<String, String> resultMap0, JSONObject resultJson, String dimensionName, NewResultDto newResultDto1, ScaleMarksEntity scaleMarksEntity) {
+        resultMap0.put(dimensionName + "常模参考值", scaleMarksEntity.getReference());
+        resultMap0.put(dimensionName + "症状", scaleMarksEntity.getSymptom());
+        resultJson.put(dimensionName + "结论", scaleMarksEntity.getSymptom());
+        resultMap0.put(dimensionName + "因子解释", scaleMarksEntity.getNameExplain());
+        resultMap0.put(dimensionName + "指导语", scaleMarksEntity.getImprovementSuggestions());
+        resultJson.put(dimensionName + "指导语", scaleMarksEntity.getImprovementSuggestions());
+        resultMap0.put(dimensionName + "建议", scaleMarksEntity.getSuggestion());
+        BeanUtils.copyProperties(scaleMarksEntity, newResultDto1);
+    }
+
+}

src/main/java/com/rf/kjb/scale/scaleResult/POMSScale.java

@@ -0,0 +1,81 @@
+package com.rf.kjb.scale.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.model.*;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author zsy
+ * @description:心境状态量表
+ * @date 2021/7/20 15:55
+ */
+public class POMSScale extends BaseScale{
+
+    public POMSScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+
+        //总分
+        double score = 0;
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        List<Map<String,String>> resultMapList = new ArrayList<>();
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取题目和答案列表
+        List<ScaleEntry> scaleEntities = (List<ScaleEntry>) resultJson.get("scaleEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        if (dimensionEntities.size() > 0){
+            //计算每个维度得分
+            double[] dimensionScore = new double[dimensionEntities.size()];
+            for (int i = 0; i < jsonArray.size(); i++) {
+                JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+                for (int y = 0; y < dimensionEntities.size(); y++) {
+                    //for (DimensionEntity dimensionEntity:dimensionEntities){
+                    DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                    String questionNos = dimensionEntity.getQuestionNo();
+                    String[] questionNo = questionNos.split("；");
+                    for (String question:questionNo){
+                        if (question.equals(jsonObject1.getString("questionNo"))){
+                            for (AnswerEntity answerEntity:answerEntities){
+                                if (answerEntity.getQuestionNo().equals(question) && answerEntity.getName().equals(jsonObject1.getString("checkItems"))){
+                                    dimensionScore[y] += Double.valueOf(answerEntity.getScore());
+                                }
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+
+            score = dimensionScore[0]+dimensionScore[1]+dimensionScore[2]+dimensionScore[3]+dimensionScore[5]-dimensionScore[4]-dimensionScore[6]+100;
+            resultMap0.put("TMD(情绪纷乱的总分)", String.valueOf(score));
+            resultJson.put("TMD(情绪纷乱的总分)", String.valueOf(score));
+            for (int y = 0; y < dimensionEntities.size(); y++) {
+                DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                DecimalFormat df = new DecimalFormat("######0.00");
+                resultMap0.put(dimensionEntity.getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y]))));
+                resultJson.put(dimensionEntity.getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y]))));
+            }
+            resultMapList.add(resultMap0);
+        }
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList",resultMapList);
+        //returnJson.put("scaleName",resultJson.getString("scaleName"));
+        returnJson.put("resultJson",resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/kjb/scale/scaleResult/POMSScaleNEW.java

@@ -0,0 +1,81 @@
+package com.rf.kjb.scale.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.model.*;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author zsy
+ * @description:心境状态量表
+ * @date 2021/7/20 15:55
+ */
+public class POMSScaleNEW extends BaseScale {
+
+    public POMSScaleNEW(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+
+        //总分
+        double score = 0;
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        List<Map<String,String>> resultMapList = new ArrayList<>();
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取题目和答案列表
+        List<ScaleEntry> scaleEntities = (List<ScaleEntry>) resultJson.get("scaleEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        if (dimensionEntities.size() > 0){
+            //计算每个维度得分
+            double[] dimensionScore = new double[dimensionEntities.size()];
+            for (int i = 0; i < jsonArray.size(); i++) {
+                JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+                for (int y = 0; y < dimensionEntities.size(); y++) {
+                    //for (DimensionEntity dimensionEntity:dimensionEntities){
+                    DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                    String questionNos = dimensionEntity.getQuestionNo();
+                    String[] questionNo = questionNos.split("；");
+                    for (String question:questionNo){
+                        if (question.equals(jsonObject1.getString("questionNo"))){
+                            for (AnswerEntity answerEntity:answerEntities){
+                                if (answerEntity.getQuestionNo().equals(question) && answerEntity.getName().equals(jsonObject1.getString("checkItems"))){
+                                    dimensionScore[y] += Double.valueOf(answerEntity.getScore());
+                                }
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+
+            score = dimensionScore[0]+dimensionScore[1]+dimensionScore[2]+dimensionScore[3]+dimensionScore[5]-dimensionScore[4]-dimensionScore[6]+100;
+            resultMap0.put("TMD(情绪纷乱的总分)", String.valueOf(score));
+            resultJson.put("TMD(情绪纷乱的总分)", String.valueOf(score));
+            for (int y = 0; y < dimensionEntities.size(); y++) {
+                DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                DecimalFormat df = new DecimalFormat("######0.00");
+                resultMap0.put(dimensionEntity.getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y]))));
+                resultJson.put(dimensionEntity.getName() + "得分", String.valueOf(Double.parseDouble(df.format(dimensionScore[y]))));
+            }
+            resultMapList.add(resultMap0);
+        }
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList",resultMapList);
+        //returnJson.put("scaleName",resultJson.getString("scaleName"));
+        returnJson.put("resultJson",resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/kjb/scale/scaleResult/PSSSScaleNEW.java

@@ -0,0 +1,70 @@
+package com.rf.kjb.scale.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.model.BaseScale;
+import com.rf.kjb.utils.Constant;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author zsy
+ * @description:领悟社会支持量表
+ * @date 2021/7/20 15:55
+ */
+public class PSSSScaleNEW extends BaseScale {
+
+    public PSSSScaleNEW(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+        //得分
+        int score = 0;
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            if (jsonObject1.getString("checkItems").equals("极不同意")) {
+                score += 1;
+            } else if (jsonObject1.getString("checkItems").equals("很不同意")) {
+                score += 2;
+            } else if (jsonObject1.getString("checkItems").equals("稍不同意")) {
+                score += 3;
+            } else if (jsonObject1.getString("checkItems").equals("中立")) {
+                score += 4;
+            } else if (jsonObject1.getString("checkItems").equals("稍同意")) {
+                score += 5;
+            } else if (jsonObject1.getString("checkItems").equals("很同意")) {
+                score += 6;
+            } else if (jsonObject1.getString("checkItems").equals("极同意")) {
+                score += 7;
+            }
+        }
+        //得分列表
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        resultMap.put("总分", String.valueOf(score));
+        resultJson.put("总分", String.valueOf(score));
+        if (score <= 36){
+            resultMap.put("结论", "低支持状态");
+            resultJson.put("结论", "低支持状态");
+        }else if (score > 36 && score <= 60){
+            resultMap.put("结论", "中支持状态");
+            resultJson.put("结论", "中支持状态");
+        }else {
+            resultMap.put("结论", "高支持状态");
+            resultJson.put("结论", "高支持状态");
+        }
+
+        List<Map<String,String>> resultMapList = new ArrayList<>();
+        resultMapList.add(resultMap);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList",resultMapList);
+        returnJson.put("scaleName", Constant.SHEET_NAME_PSSS);
+        returnJson.put("resultJson",resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/kjb/scale/scaleResult/PSSScale.java

@@ -0,0 +1,158 @@
+package com.rf.kjb.scale.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.model.BaseScale;
+import com.rf.kjb.utils.Constant;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author zsy
+ * @description:压力知觉量表 （新版本已使用新模板通用处理方式处理）
+ * @date 2021/7/20 15:55
+ */
+public class PSSScale extends BaseScale{
+
+    public PSSScale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public  JSONObject scaleCalculate() throws Exception {
+
+        // 自定义路径使用
+        /*ScaleUtil.getScaleDll("PSSScale");
+        //ScaleUtil.loadLib("PSSScale");
+        //System.out.println("JSONArray:"+jsonArray);
+        //System.out.println("resultJson:"+resultJson);
+        XScale xScale = new XScale(jsonArray,resultJson);
+        String result = xScale.PSSScale(jsonArray.toString(), resultJson.toString());
+        System.out.println("dllresult:"+result);
+        //解决排序问题
+        LinkedHashMap<String, Object> jsonMap = JSON.parseObject(result,LinkedHashMap.class, Feature.OrderedField);
+        JSONObject jsonObject = new JSONObject(true);
+        jsonObject.putAll(jsonMap);
+        System.out.println("jsonObject:"+jsonObject);
+        return jsonObject;*/
+
+        //压力知觉均分
+        double score = 0;
+        //危机知觉均分
+        double score1 = 0;
+        //应对能力知觉均分
+        double score2 = 0;
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            if (jsonObject1.getString("scoreDirection").equals("1")) {
+                if (i == 3 || i == 4 || i == 6 || i == 7){
+                    if (jsonObject1.getString("checkItems").equals("偶尔")) {
+                        score2 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("有时")) {
+                        score2 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("常常")) {
+                        score2 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("总是")) {
+                        score2 += 4;
+                    }
+                }else {
+                    if (jsonObject1.getString("checkItems").equals("偶尔")) {
+                        score1 += 1;
+                    } else if (jsonObject1.getString("checkItems").equals("有时")) {
+                        score1 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("常常")) {
+                        score1 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("总是")) {
+                        score1 += 4;
+                    }
+                }
+            } else if (jsonObject1.getString("scoreDirection").equals("0")) {
+                if (i == 3 || i == 4 || i == 6 || i == 7){
+                    if (jsonObject1.getString("checkItems").equals("偶尔")) {
+                        score2 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有时")) {
+                        score2 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("常常")) {
+                        score2 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("总是")) {
+                        score2 += 1;
+                    }
+                }else {
+                    if (jsonObject1.getString("checkItems").equals("偶尔")) {
+                        score1 += 4;
+                    } else if (jsonObject1.getString("checkItems").equals("有时")) {
+                        score1 += 3;
+                    } else if (jsonObject1.getString("checkItems").equals("常常")) {
+                        score1 += 2;
+                    } else if (jsonObject1.getString("checkItems").equals("总是")) {
+                        score1 += 1;
+                    }
+                }
+            }
+        }
+        DecimalFormat df   = new DecimalFormat("######0.00");
+        score = (score1 + score2)/10;
+        score1 = score1/6;
+        score2 = score2/4;
+        //得分列表
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        resultMap.put("压力知觉均分", String.valueOf(Double.parseDouble(df.format(score))));
+        resultJson.put("压力知觉均分", String.valueOf(Double.parseDouble(df.format(score))));
+        if (score < 1){
+            resultMap.put("压力知觉解读", "您的压力水平较低，请继续保持");
+            resultJson.put("压力知觉解读", "您的压力水平较低，请继续保持");
+        }else if (score >= 1 && score <2 ){
+            resultMap.put("压力知觉解读", "您的压力水平较低，如有必要，建议寻找合适的方法减压");
+            resultJson.put("压力知觉解读", "您的压力水平较低，如有必要，建议寻找合适的方法减压");
+        }else if (score >= 2 && score <3){
+            resultMap.put("压力知觉解读", "您目前存在着一定的心理压力，建议寻找合适的方法进行减压，如有必要，请寻求心理咨询");
+            resultJson.put("压力知觉解读", "您目前存在着一定的心理压力，建议寻找合适的方法进行减压，如有必要，请寻求心理咨询");
+        }else if (score >= 3){
+            resultMap.put("压力知觉解读", "您目前的心理压力较大，一定要寻找合适的方法进行减压，推荐进行专业的心理咨询");
+            resultJson.put("压力知觉解读", "您目前的心理压力较大，一定要寻找合适的方法进行减压，推荐进行专业的心理咨询");
+        }
+        resultMap.put("应对能力知觉均分", String.valueOf(Double.parseDouble(df.format(score1))));
+        resultJson.put("应对能力知觉均分", String.valueOf(Double.parseDouble(df.format(score1))));
+        if (score1 < 1){
+            resultMap.put("应对能力知觉解读", "您的压力水平较低，请继续保持");
+            resultJson.put("应对能力知觉解读", "您的压力水平较低，请继续保持");
+        }else if (score1 >= 1 && score1 <2 ){
+            resultMap.put("应对能力知觉解读", "您的压力水平较低，如有必要，建议寻找合适的方法减压");
+            resultJson.put("应对能力知觉解读", "您的压力水平较低，如有必要，建议寻找合适的方法减压");
+        }else if (score1 >= 2 && score1 <3){
+            resultMap.put("应对能力知觉解读", "您目前存在着一定的心理压力，建议寻找合适的方法进行减压，如有必要，请寻求心理咨询");
+            resultJson.put("应对能力知觉解读", "您目前存在着一定的心理压力，建议寻找合适的方法进行减压，如有必要，请寻求心理咨询");
+        }else if (score1 >= 3){
+            resultMap.put("应对能力知觉解读", "您目前的心理压力较大，一定要寻找合适的方法进行减压，推荐进行专业的心理咨询");
+            resultJson.put("应对能力知觉解读", "您目前的心理压力较大，一定要寻找合适的方法进行减压，推荐进行专业的心理咨询");
+        }
+        resultMap.put("危机知觉均分", String.valueOf(Double.parseDouble(df.format(score2))));
+        resultJson.put("危机知觉均分", String.valueOf(Double.parseDouble(df.format(score2))));
+        if (score2 < 1){
+            resultMap.put("危机知觉解读", "您的压力水平较低，请继续保持");
+            resultJson.put("危机知觉解读", "您的压力水平较低，请继续保持");
+        }else if (score2 >= 1 && score2 <2 ){
+            resultMap.put("危机知觉解读", "您的压力水平较低，如有必要，建议寻找合适的方法减压");
+            resultJson.put("危机知觉解读", "您的压力水平较低，如有必要，建议寻找合适的方法减压");
+        }else if (score2 >= 2 && score2 <3){
+            resultMap.put("危机知觉解读", "您目前存在着一定的心理压力，建议寻找合适的方法进行减压，如有必要，请寻求心理咨询");
+            resultJson.put("危机知觉解读", "您目前存在着一定的心理压力，建议寻找合适的方法进行减压，如有必要，请寻求心理咨询");
+        }else if (score2 >= 3){
+            resultMap.put("危机知觉解读", "您目前的心理压力较大，一定要寻找合适的方法进行减压，推荐进行专业的心理咨询");
+            resultJson.put("危机知觉解读", "您目前的心理压力较大，一定要寻找合适的方法进行减压，推荐进行专业的心理咨询");
+        }
+
+        List<Map<String,String>> resultMapList = new ArrayList<>();
+        resultMapList.add(resultMap);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList",resultMapList);
+        returnJson.put("scaleName", Constant.SHEET_NAME_PSS);
+        returnJson.put("resultJson",resultJson);
+
+        return returnJson;
+    }
+}

src/main/java/com/rf/kjb/scale/scaleResult/SCL90Scale.java

@@ -0,0 +1,218 @@
+package com.rf.kjb.scale.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.dto.NewResultDto;
+import com.rf.kjb.scale.dao.model.AnswerEntity;
+import com.rf.kjb.scale.dao.model.BaseScale;
+import com.rf.kjb.scale.dao.model.DimensionEntity;
+import com.rf.kjb.scale.dao.model.ScaleMarksEntity;
+import com.rf.kjb.utils.Constant;
+import org.springframework.beans.BeanUtils;
+
+import java.text.DecimalFormat;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @author zsy
+ * @description:症状自评量表 flag=20210617140713
+ * @date 2021/7/20 15:55
+ */
+public class SCL90Scale extends BaseScale {
+
+    public SCL90Scale(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public JSONObject scaleCalculate() throws Exception {
+
+        //总分
+        double score = 0;
+        //总均分
+        double GPA = 0;
+        //阳性项目数
+        int positive = 0;
+        //阳性项目总分
+        int positiveScore = 0;
+
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        //老版本数据格式
+        Map<String, Object> newResult = new LinkedHashMap<>();
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        //计算每个维度得分dimensionEntities
+        double[] dimensionScore = new double[dimensionEntities.size()];
+        //jsonArray:用户自己选择的题目选项
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            for (int y = 0; y < dimensionEntities.size(); y++) {
+                //获取维度信息
+                DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                //获取该维度下有哪些选项
+                String questionNos = dimensionEntity.getQuestionNo();
+                //得到选择题号
+                String[] questionNo = questionNos.split("；");
+                //计算每道题的得分
+                for (String question : questionNo) {
+                    if (question.equals(jsonObject1.getString("questionNo"))) {
+                        //获取所有答案中本道题目的答案list数组
+                        List<AnswerEntity> nowQuestionAnswerList = answerEntities.stream().filter(answerEntity -> answerEntity.getQuestionNo().equals(question)).collect(Collectors.toList());
+                        //本题目的正确答案与自己的选项进行对比，正确的话相应分数进行相加
+                        for (AnswerEntity answerEntity : nowQuestionAnswerList) {
+                            if (answerEntity.getName().equals(jsonObject1.getString("checkItems"))) {
+                                dimensionScore[y] += Double.parseDouble(answerEntity.getScore());
+                                //如果用户选择的当前题目的的分数大于2分，即为阳性项目分，并进行处理
+                                if (Integer.parseInt(answerEntity.getScore()) >= 2) {
+                                    positive += 1;
+                                    positiveScore += Integer.parseInt(answerEntity.getScore());
+                                }
+                                //计算总分
+                                score += Integer.parseInt(answerEntity.getScore());
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        //将量表总维度根据维度名称进行分组
+        Map<String, List<ScaleMarksEntity>> scaleMarksMap = scaleMarksEntities.stream().collect(Collectors.groupingBy(ScaleMarksEntity::getName));
+        //返回值以及存数据库格式
+        List<NewResultDto> newResultDtos = new ArrayList<>();
+
+        resultMap0.put("总分", String.valueOf(score));
+        resultJson.put("总分", String.valueOf(score));
+        DecimalFormat df = new DecimalFormat("######0.00");
+        GPA = Double.parseDouble(df.format(score / 90));
+        resultMap0.put("总均分", String.valueOf(GPA));
+        resultJson.put("总均分", String.valueOf(GPA));
+
+        List<ScaleMarksEntity> totalScore = scaleMarksMap.get("总分");
+        ScaleMarksEntity tempTotalScore = totalScore.get(0);
+        newResultDtos.add(new NewResultDto("总分", String.valueOf(score), tempTotalScore.getSymptom(), tempTotalScore.getImprovementSuggestions(),
+                tempTotalScore.getFlag(), tempTotalScore.getReference(), tempTotalScore.getNameExplain(), tempTotalScore.getSuggestion(), tempTotalScore.getIsTotalScoreExplain()));
+
+        List<ScaleMarksEntity> gpaScale = scaleMarksMap.get("总均分");
+        for (ScaleMarksEntity scaleMarksEntity : gpaScale) {
+            if (GPA <= Double.parseDouble(df.format(Double.parseDouble(scaleMarksEntity.getScoreEnd()))) && GPA >= Double.parseDouble(df.format(Double.parseDouble(scaleMarksEntity.getScoreStart())))) {
+                resultMap0.put("总均分常模参考值", scaleMarksEntity.getReference());
+                resultMap0.put("总均分症状", scaleMarksEntity.getSymptom());
+                resultJson.put("总均分症状", scaleMarksEntity.getSymptom());
+                resultMap0.put("总均分因子解释", scaleMarksEntity.getNameExplain());
+                resultMap0.put("总均分指导语", scaleMarksEntity.getImprovementSuggestions());
+                resultMap0.put("总均分建议", scaleMarksEntity.getSuggestion());
+
+                NewResultDto newResultDto = new NewResultDto();
+                BeanUtils.copyProperties(scaleMarksEntity, newResultDto);
+                newResultDto.setScore(String.valueOf(GPA));
+                newResultDtos.add(newResultDto);
+            }
+        }
+
+        resultMap0.put("阳性项目数", String.valueOf(positive));
+        resultJson.put("阳性项目数", String.valueOf(positive));
+        List<ScaleMarksEntity> tempPositive = scaleMarksMap.get("阳性项目数");
+        ScaleMarksEntity scaleMarksEntity1 = tempPositive.get(0);
+        NewResultDto newResultDto = new NewResultDto();
+        BeanUtils.copyProperties(scaleMarksEntity1, newResultDto);
+        newResultDto.setScore(String.valueOf(positive));
+        newResultDtos.add(newResultDto);
+
+        resultMap0.put("阴性项目数", String.valueOf(90 - positive));
+        resultJson.put("阴性项目数", String.valueOf(90 - positive));
+        List<ScaleMarksEntity> tempPositive1 = scaleMarksMap.get("阴性项目数");
+        NewResultDto newResultDto2 = new NewResultDto();
+        BeanUtils.copyProperties(tempPositive1.get(0), newResultDto2);
+        newResultDto2.setScore(String.valueOf(90 - positive));
+        newResultDtos.add(newResultDto2);
+
+        NewResultDto newResultDto3 = new NewResultDto();
+        if (positive == 0) {
+            resultMap0.put("阳性症状均分", "0");
+            resultJson.put("阳性症状均分", "0");
+            newResultDto3.setScore(String.valueOf(90 - positive));
+        } else {
+            resultMap0.put("阳性症状均分", String.valueOf(Double.parseDouble(df.format(positiveScore / positive))));
+            resultJson.put("阳性症状均分", String.valueOf(Double.parseDouble(df.format(positiveScore / positive))));
+            newResultDto3.setScore(String.valueOf(Double.parseDouble(df.format(positiveScore / positive))));
+        }
+        List<ScaleMarksEntity> tempPositive2 = scaleMarksMap.get("阳性项目均分");
+        BeanUtils.copyProperties(tempPositive2.get(0), newResultDto3);
+        newResultDtos.add(newResultDto3);
+
+        JSONObject iconInfo = new JSONObject();
+        //雷达图需要的维度以及最大值
+        List<Map<String, Object>> indicator = new LinkedList<>();
+        //雷达图所需要的常模参考值
+        LinkedList<String> reference = new LinkedList<>();
+        //雷达图需要的分数
+        LinkedList<String> scoreList = new LinkedList<>();
+        for (int y = 0; y < dimensionEntities.size(); y++) {
+            Map<String, Object> indicatorMap = new HashMap<>();
+            DimensionEntity dimensionEntity = dimensionEntities.get(y);
+            NewResultDto newResultDto1 = new NewResultDto();
+            String questionNos = dimensionEntity.getQuestionNo();
+            String[] questionNo = questionNos.split("；");
+            double resultScore = Double.parseDouble(df.format(dimensionScore[y] / questionNo.length));
+            //存放该维度总分
+            resultMap0.put(dimensionEntity.getName()+"得分", String.valueOf(resultScore));
+            resultJson.put(dimensionEntity.getName()+"得分", String.valueOf(resultScore));
+            newResultDto1.setScore(String.valueOf(resultScore));
+            newResultDtos.add(newResultDto1);
+            //获取当前维度的评分规则
+            List<ScaleMarksEntity> scaleMarksEntities1 = scaleMarksMap.get(dimensionEntity.getName());
+            //循环遍历判断得分在哪个区间
+            for (ScaleMarksEntity scaleMarksEntity : scaleMarksEntities1) {
+                if (resultScore <= Double.parseDouble(df.format(Double.parseDouble(scaleMarksEntity.getScoreEnd()))) && resultScore >= Double.parseDouble(df.format(Double.parseDouble(scaleMarksEntity.getScoreStart())))) {
+                    putDimResult(resultMap0, resultJson, dimensionEntity, newResultDto1, scaleMarksEntity);
+                    //需要进行图表展示的维度放入map
+                    if ("1".equals(dimensionEntity.getIsIconFlag())) {
+                        indicatorMap.put("text", dimensionEntity.getName());
+                        indicatorMap.put("max", scaleMarksEntity.getScoreEnd());
+                        indicator.add(indicatorMap);
+                        if ("无".equals(scaleMarksEntity.getReference()) || "无".equals(scaleMarksEntity.getStandardDeviation())) {
+                            //常模参考值设为0
+                            reference.add("0");
+                        } else {
+                            reference.add(scaleMarksEntity.getReference());
+                        }
+                        scoreList.add(String.valueOf(resultScore));
+                    }
+                }
+            }
+        }
+        //需要图表展示的
+        iconInfo.put("indicator", indicator);
+        iconInfo.put("reference", reference);
+        iconInfo.put("scoreList", scoreList);
+        newResult.put("iconInfo", iconInfo);
+        newResult.put("result", newResultDtos);
+        resultMapList.add(resultMap0);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+        returnJson.put("scaleName", Constant.SHEET_NAME_SCL_90);
+        returnJson.put("resultJson", resultJson);
+        returnJson.put("newResultJson", newResult);
+
+        return returnJson;
+    }
+
+    private static void putDimResult(Map<String, String> resultMap0, JSONObject oldResult, DimensionEntity dimensionEntity, NewResultDto newResultDto1, ScaleMarksEntity scaleMarksEntity) {
+        resultMap0.put(dimensionEntity.getName() + "常模参考值", scaleMarksEntity.getReference());
+        resultMap0.put(dimensionEntity.getName() + "症状", scaleMarksEntity.getSymptom());
+        oldResult.put(dimensionEntity.getName() + "症状", scaleMarksEntity.getSymptom());
+        resultMap0.put(dimensionEntity.getName() + "因子解释", scaleMarksEntity.getNameExplain());
+        resultMap0.put(dimensionEntity.getName() + "指导语", scaleMarksEntity.getImprovementSuggestions());
+        resultMap0.put(dimensionEntity.getName() + "建议", scaleMarksEntity.getSuggestion());
+        BeanUtils.copyProperties(scaleMarksEntity, newResultDto1);
+    }
+}

src/main/java/com/rf/kjb/scale/scaleResult/SCL90ScaleNEW.java

@@ -0,0 +1,218 @@
+package com.rf.kjb.scale.scaleResult;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.dto.NewResultDto;
+import com.rf.kjb.scale.dao.model.AnswerEntity;
+import com.rf.kjb.scale.dao.model.BaseScale;
+import com.rf.kjb.scale.dao.model.DimensionEntity;
+import com.rf.kjb.scale.dao.model.ScaleMarksEntity;
+import com.rf.kjb.utils.Constant;
+import org.springframework.beans.BeanUtils;
+
+import java.text.DecimalFormat;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @author zsy
+ * @description:症状自评量表 flag=20210617140713
+ * @date 2021/7/20 15:55
+ */
+public class SCL90ScaleNEW extends BaseScale {
+
+    public SCL90ScaleNEW(JSONArray jsonArray, JSONObject resultJson) {
+        super(jsonArray, resultJson);
+    }
+
+    public JSONObject scaleCalculate() throws Exception {
+
+        //总分
+        double score = 0;
+        //总均分
+        double GPA = 0;
+        //阳性项目数
+        int positive = 0;
+        //阳性项目总分
+        int positiveScore = 0;
+
+        Map<String, String> resultMap0 = new LinkedHashMap<>();
+        //老版本数据格式
+        Map<String, Object> newResult = new LinkedHashMap<>();
+        List<Map<String, String>> resultMapList = new ArrayList<>();
+
+
+        //获取答案列表
+        List<AnswerEntity> answerEntities = (List<AnswerEntity>) resultJson.get("answerEntities");
+        //获取评分规则列表
+        List<ScaleMarksEntity> scaleMarksEntities = (List<ScaleMarksEntity>) resultJson.get("scaleMarksEntities");
+        //获取维度信息列表
+        List<DimensionEntity> dimensionEntities = (List<DimensionEntity>) resultJson.get("dimensionEntities");
+        //计算每个维度得分dimensionEntities
+        double[] dimensionScore = new double[dimensionEntities.size()];
+        //jsonArray:用户自己选择的题目选项
+        for (int i = 0; i < jsonArray.size(); i++) {
+            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
+            for (int y = 0; y < dimensionEntities.size(); y++) {
+                //获取维度信息
+                DimensionEntity dimensionEntity = dimensionEntities.get(y);
+                //获取该维度下有哪些选项
+                String questionNos = dimensionEntity.getQuestionNo();
+                //得到选择题号
+                String[] questionNo = questionNos.split("；");
+                //计算每道题的得分
+                for (String question : questionNo) {
+                    if (question.equals(jsonObject1.getString("questionNo"))) {
+                        //获取所有答案中本道题目的答案list数组
+                        List<AnswerEntity> nowQuestionAnswerList = answerEntities.stream().filter(answerEntity -> answerEntity.getQuestionNo().equals(question)).collect(Collectors.toList());
+                        //本题目的正确答案与自己的选项进行对比，正确的话相应分数进行相加
+                        for (AnswerEntity answerEntity : nowQuestionAnswerList) {
+                            if (answerEntity.getName().equals(jsonObject1.getString("checkItems"))) {
+                                dimensionScore[y] += Double.parseDouble(answerEntity.getScore());
+                                //如果用户选择的当前题目的的分数大于2分，即为阳性项目分，并进行处理
+                                if (Integer.parseInt(answerEntity.getScore()) >= 2) {
+                                    positive += 1;
+                                    positiveScore += Integer.parseInt(answerEntity.getScore());
+                                }
+                                //计算总分
+                                score += Integer.parseInt(answerEntity.getScore());
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        //将量表总维度根据维度名称进行分组
+        Map<String, List<ScaleMarksEntity>> scaleMarksMap = scaleMarksEntities.stream().collect(Collectors.groupingBy(ScaleMarksEntity::getName));
+        //返回值以及存数据库格式
+        List<NewResultDto> newResultDtos = new ArrayList<>();
+
+        resultMap0.put("总分", String.valueOf(score));
+        resultJson.put("总分", String.valueOf(score));
+        DecimalFormat df = new DecimalFormat("######0.00");
+        GPA = Double.parseDouble(df.format(score / 90));
+        resultMap0.put("总均分", String.valueOf(GPA));
+        resultJson.put("总均分", String.valueOf(GPA));
+
+        List<ScaleMarksEntity> totalScore = scaleMarksMap.get("总分");
+        ScaleMarksEntity tempTotalScore = totalScore.get(0);
+        newResultDtos.add(new NewResultDto("总分", String.valueOf(score), tempTotalScore.getSymptom(), tempTotalScore.getImprovementSuggestions(),
+                tempTotalScore.getFlag(), tempTotalScore.getReference(), tempTotalScore.getNameExplain(), tempTotalScore.getSuggestion(), tempTotalScore.getIsTotalScoreExplain()));
+
+        List<ScaleMarksEntity> gpaScale = scaleMarksMap.get("总均分");
+        for (ScaleMarksEntity scaleMarksEntity : gpaScale) {
+            if (GPA <= Double.parseDouble(df.format(Double.parseDouble(scaleMarksEntity.getScoreEnd()))) && GPA >= Double.parseDouble(df.format(Double.parseDouble(scaleMarksEntity.getScoreStart())))) {
+                resultMap0.put("总均分常模参考值", scaleMarksEntity.getReference());
+                resultMap0.put("总均分症状", scaleMarksEntity.getSymptom());
+                resultJson.put("总均分症状", scaleMarksEntity.getSymptom());
+                resultMap0.put("总均分因子解释", scaleMarksEntity.getNameExplain());
+                resultMap0.put("总均分指导语", scaleMarksEntity.getImprovementSuggestions());
+                resultMap0.put("总均分建议", scaleMarksEntity.getSuggestion());
+
+                NewResultDto newResultDto = new NewResultDto();
+                BeanUtils.copyProperties(scaleMarksEntity, newResultDto);
+                newResultDto.setScore(String.valueOf(GPA));
+                newResultDtos.add(newResultDto);
+            }
+        }
+
+        resultMap0.put("阳性项目数", String.valueOf(positive));
+        resultJson.put("阳性项目数", String.valueOf(positive));
+        List<ScaleMarksEntity> tempPositive = scaleMarksMap.get("阳性项目数");
+        ScaleMarksEntity scaleMarksEntity1 = tempPositive.get(0);
+        NewResultDto newResultDto = new NewResultDto();
+        BeanUtils.copyProperties(scaleMarksEntity1, newResultDto);
+        newResultDto.setScore(String.valueOf(positive));
+        newResultDtos.add(newResultDto);
+
+        resultMap0.put("阴性项目数", String.valueOf(90 - positive));
+        resultJson.put("阴性项目数", String.valueOf(90 - positive));
+        List<ScaleMarksEntity> tempPositive1 = scaleMarksMap.get("阴性项目数");
+        NewResultDto newResultDto2 = new NewResultDto();
+        BeanUtils.copyProperties(tempPositive1.get(0), newResultDto2);
+        newResultDto2.setScore(String.valueOf(90 - positive));
+        newResultDtos.add(newResultDto2);
+
+        NewResultDto newResultDto3 = new NewResultDto();
+        if (positive == 0) {
+            resultMap0.put("阳性症状均分", "0");
+            resultJson.put("阳性症状均分", "0");
+            newResultDto3.setScore("0");
+        } else {
+            resultMap0.put("阳性症状均分", String.valueOf(Double.parseDouble(df.format(positiveScore / positive))));
+            resultJson.put("阳性症状均分", String.valueOf(Double.parseDouble(df.format(positiveScore / positive))));
+            newResultDto3.setScore(String.valueOf(Double.parseDouble(df.format(positiveScore / positive))));
+        }
+        List<ScaleMarksEntity> tempPositive2 = scaleMarksMap.get("阳性项目均分");
+        BeanUtils.copyProperties(tempPositive2.get(0), newResultDto3);
+        newResultDtos.add(newResultDto3);
+
+        JSONObject iconInfo = new JSONObject();
+        //雷达图需要的维度以及最大值
+        List<Map<String, Object>> indicator = new LinkedList<>();
+        //雷达图所需要的常模参考值
+        LinkedList<String> reference = new LinkedList<>();
+        //雷达图需要的分数
+        LinkedList<String> scoreList = new LinkedList<>();
+        for (int y = 0; y < dimensionEntities.size(); y++) {
+            Map<String, Object> indicatorMap = new HashMap<>();
+            DimensionEntity dimensionEntity = dimensionEntities.get(y);
+            NewResultDto newResultDto1 = new NewResultDto();
+            String questionNos = dimensionEntity.getQuestionNo();
+            String[] questionNo = questionNos.split("；");
+            double resultScore = Double.parseDouble(df.format(dimensionScore[y] / questionNo.length));
+            //存放该维度总分
+            resultMap0.put(dimensionEntity.getName()+"得分", String.valueOf(resultScore));
+            resultJson.put(dimensionEntity.getName()+"得分", String.valueOf(resultScore));
+            newResultDto1.setScore(String.valueOf(resultScore));
+            newResultDtos.add(newResultDto1);
+            //获取当前维度的评分规则
+            List<ScaleMarksEntity> scaleMarksEntities1 = scaleMarksMap.get(dimensionEntity.getName());
+            //循环遍历判断得分在哪个区间
+            for (ScaleMarksEntity scaleMarksEntity : scaleMarksEntities1) {
+                if (resultScore <= Double.parseDouble(df.format(Double.parseDouble(scaleMarksEntity.getScoreEnd()))) && resultScore >= Double.parseDouble(df.format(Double.parseDouble(scaleMarksEntity.getScoreStart())))) {
+                    putDimResult(resultMap0, resultJson, dimensionEntity, newResultDto1, scaleMarksEntity);
+                    //需要进行图表展示的维度放入map
+                    if ("1".equals(dimensionEntity.getIsIconFlag())) {
+                        indicatorMap.put("text", dimensionEntity.getName());
+                        indicatorMap.put("max", scaleMarksEntity.getScoreEnd());
+                        indicator.add(indicatorMap);
+                        if ("无".equals(scaleMarksEntity.getReference()) || "无".equals(scaleMarksEntity.getStandardDeviation())) {
+                            //常模参考值设为0
+                            reference.add("0");
+                        } else {
+                            reference.add(scaleMarksEntity.getReference());
+                        }
+                        scoreList.add(String.valueOf(resultScore));
+                    }
+                }
+            }
+        }
+        //需要图表展示的
+        iconInfo.put("indicator", indicator);
+        iconInfo.put("reference", reference);
+        iconInfo.put("scoreList", scoreList);
+        newResult.put("iconInfo", iconInfo);
+        newResult.put("result", newResultDtos);
+        resultMapList.add(resultMap0);
+
+        JSONObject returnJson = new JSONObject(true);
+        returnJson.put("resultMapList", resultMapList);
+        returnJson.put("scaleName", Constant.SHEET_NAME_SCL_90);
+        returnJson.put("resultJson", resultJson);
+        returnJson.put("newResultJson", newResult);
+
+        return returnJson;
+    }
+
+    private static void putDimResult(Map<String, String> resultMap0, JSONObject oldResult, DimensionEntity dimensionEntity, NewResultDto newResultDto1, ScaleMarksEntity scaleMarksEntity) {
+        resultMap0.put(dimensionEntity.getName() + "常模参考值", scaleMarksEntity.getReference());
+        resultMap0.put(dimensionEntity.getName() + "症状", scaleMarksEntity.getSymptom());
+        oldResult.put(dimensionEntity.getName() + "症状", scaleMarksEntity.getSymptom());
+        resultMap0.put(dimensionEntity.getName() + "因子解释", scaleMarksEntity.getNameExplain());
+        resultMap0.put(dimensionEntity.getName() + "指导语", scaleMarksEntity.getImprovementSuggestions());
+        resultMap0.put(dimensionEntity.getName() + "建议", scaleMarksEntity.getSuggestion());
+        BeanUtils.copyProperties(scaleMarksEntity, newResultDto1);
+    }
+}

src/main/java/com/rf/kjb/scale/scaleResult/package-info.java

@@ -0,0 +1,2 @@
+package com.rf.kjb.scale.scaleResult;
+/** 计算规则映射 **/

src/main/java/com/rf/kjb/scale/service/AnswerService.java

@@ -0,0 +1,34 @@
+package com.rf.kjb.scale.service;
+
+
+
+import com.rf.kjb.scale.dao.model.AnswerEntity;
+
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:
+ * @date 2021/5/14 10:49
+ */
+public interface AnswerService {
+    /**
+     * 根据flag获取全部答案
+     * @param flag
+     */
+    List<AnswerEntity> getAnswerByFlag(String flag);
+
+    /**
+     * 保存
+     * @param answerEntity
+     */
+    void saveAnswer(AnswerEntity answerEntity);
+
+    void saveBatchAnswer(List<AnswerEntity> answerEntity);
+
+    List<AnswerEntity> findAll();
+
+    void updateAnswer(AnswerEntity answerEntity);
+
+    void deleteAnswerByFlag(String flag);
+}

src/main/java/com/rf/kjb/scale/service/CategoryService.java

@@ -0,0 +1,34 @@
+package com.rf.kjb.scale.service;
+
+
+import com.rf.kjb.scale.dao.model.CategoryEntry;
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:量表类别信息管理
+ * @date 2021/6/17 15:55
+ */
+public interface CategoryService {
+
+    /**
+     * 保存
+     *
+     * @param categoryEntity
+     */
+    void save(CategoryEntry categoryEntity);
+
+    /**
+     * 名称查询
+     * @param name
+     * @return
+     */
+    List<CategoryEntry> getCategoryByName(CategoryEntry categoryEntry);
+
+    /**
+     * 查询所有类别
+     * @return
+     */
+    List<CategoryEntry> findAll();
+
+}

src/main/java/com/rf/kjb/scale/service/CategorySubjectService.java

@@ -0,0 +1,34 @@
+package com.rf.kjb.scale.service;
+
+
+
+
+import com.rf.kjb.scale.dao.model.CategorySubjectEntity;
+
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:量表-类别关联信息管理
+ * @date 2021/6/17 15:55
+ */
+public interface CategorySubjectService {
+
+    /**
+     * 保存
+     * @param categorySubjectEntity
+     */
+    void save(CategorySubjectEntity categorySubjectEntity);
+
+    List<CategorySubjectEntity> findByFlag(String flag);
+
+    void deleteCategorySubjectByFlag(String flag);
+
+
+    /**
+     * 分类英文名查询分类下的所有flag
+     * @param typeName
+     * @return
+     */
+    List<CategorySubjectEntity> findByEname(String typeName);
+}

src/main/java/com/rf/kjb/scale/service/DimensionService.java

@@ -0,0 +1,36 @@
+package com.rf.kjb.scale.service;
+
+
+import com.rf.kjb.scale.dao.model.DimensionEntity;
+
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:
+ * @date 2021/5/14 10:49
+ */
+public interface DimensionService {
+
+    /**
+     * 保存
+     *
+     * @param dimensionEntity
+     */
+    void saveDimension(DimensionEntity dimensionEntity);
+
+    void saveBatch(List<DimensionEntity> dimensionEntity);
+
+    /**
+     * 根据flag查询维度信息
+     *
+     * @param flag
+     */
+    List<DimensionEntity> getDimensionByFlag(String flag);
+
+    List<DimensionEntity> findAll();
+
+    void updateDimension(DimensionEntity dimensionEntity);
+
+    void deleteDimensionByFlag(String flag);
+}

src/main/java/com/rf/kjb/scale/service/GameRecordService.java

@@ -0,0 +1,10 @@
+package com.rf.kjb.scale.service;
+
+import com.rf.kjb.scale.dao.model.GameRecordEntity;
+import org.springframework.data.domain.Page;
+
+public interface GameRecordService {
+    void save(GameRecordEntity gameRecordEntity);
+
+    Page<GameRecordEntity> find(String json);
+}

src/main/java/com/rf/kjb/scale/service/RecordPhyService.java

@@ -0,0 +1,25 @@
+package com.rf.kjb.scale.service;
+
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.model.RecordPhyEntry;
+import org.springframework.data.domain.Page;
+
+import java.util.List;
+
+public interface RecordPhyService {
+    void save(RecordPhyEntry recordPhyEntry);
+
+    Page<RecordPhyEntry> find(JSONObject jsonObject);
+
+    List<String> findIdentifiers(JSONObject jsonObject);
+
+    int findIdentifiersCount(JSONObject jsonObject);
+
+    RecordPhyEntry findById(String id);
+
+    List<RecordPhyEntry> find(List<String> recordingIds, String flag);
+
+    List<RecordPhyEntry> findAll(JSONObject jsonObject);
+
+    List<RecordPhyEntry> findByType(String type);
+}

src/main/java/com/rf/kjb/scale/service/RecordService.java

@@ -0,0 +1,60 @@
+package com.rf.kjb.scale.service;
+
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.model.RecordEntity;
+import org.springframework.data.domain.Page;
+
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:用户测试记录
+ * @date 2021/6/17 15:55
+ */
+public interface RecordService {
+
+    /**
+     * 保存
+     *
+     * @param userRecordEntity
+     */
+    RecordEntity save(RecordEntity userRecordEntity);
+
+    /**
+     * 根据id查询数据
+     *
+     * @return
+     */
+    RecordEntity getUserRecordById(String id);
+
+
+
+
+    /**
+     * 查询全量数据
+     *
+     * @return
+     */
+    List<RecordEntity> findAll();
+
+
+    /**
+     *
+     * @param json
+     * @return
+     */
+    List<String> findIdentifiers(String json);
+
+    int findIdentifiersCount(String json);
+
+    Page<RecordEntity> find(String json);
+
+    RecordEntity findById(String id);
+
+    /**
+     * 不分页查询
+     * @param json
+     * @return
+     */
+    List<RecordEntity> findNoPage(String json);
+}

src/main/java/com/rf/kjb/scale/service/ScaleConfigService.java

@@ -0,0 +1,14 @@
+package com.rf.kjb.scale.service;
+
+import com.rf.kjb.scale.dao.model.ScaleConfigEntry;
+
+/**
+ * @author lpf
+ * @description:
+ * @date 2022/5/28 16:29
+ */
+public interface ScaleConfigService {
+
+    ScaleConfigEntry findScaleConfigByFlag(String flag);
+
+}

src/main/java/com/rf/kjb/scale/service/ScaleMarksService.java

@@ -0,0 +1,22 @@
+package com.rf.kjb.scale.service;
+
+import com.rf.kjb.scale.dao.model.ScaleMarksEntity;
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:
+ * @date 2021/5/14 10:49
+ */
+public interface ScaleMarksService {
+    /**
+     * 根据flag获取全部评分规则
+     *
+     * @param flag
+     */
+    List<ScaleMarksEntity> getScaleMarksByFlag(String flag);
+
+    List<ScaleMarksEntity> findAll();
+
+
+}

src/main/java/com/rf/kjb/scale/service/ScaleService.java

@@ -0,0 +1,29 @@
+package com.rf.kjb.scale.service;
+
+import com.rf.kjb.scale.dao.model.ScaleEntry;
+import java.util.List;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/5/14 10:49
+ */
+public interface ScaleService {
+
+    /**
+     * 全量查询
+     *
+     * @return
+     */
+    List<ScaleEntry> findAll();
+
+
+    /**
+     * 根据flag查询检测列表
+     *
+     * @param flag
+     * @return
+     */
+    List<ScaleEntry> getScaleByFlag(String flag);
+
+}

src/main/java/com/rf/kjb/scale/service/SubjectService.java

@@ -0,0 +1,83 @@
+package com.rf.kjb.scale.service;
+
+import com.rf.kjb.scale.dao.model.SubjectEntity;
+import org.springframework.data.domain.Page;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author zzf
+ * @description:
+ * @date 2021/5/17 9:44
+ */
+public interface SubjectService {
+    /**
+     * 获取量表和认知任务列表
+     *
+     * @return
+     */
+    List<SubjectEntity> findAll(int pageNum, int pageSize);
+
+    /**
+     * 检索，根据中文名或录入人
+     *
+     * @param pageNum
+     * @param pageSize
+     * @param searchName
+     * @return
+     */
+    List<SubjectEntity> findByNameOrUploader(int pageNum, int pageSize, String searchName);
+
+
+
+
+    /**
+     * 保存
+     *
+     * @param subjectEntity
+     */
+    void save(SubjectEntity subjectEntity);
+
+
+
+
+    /**
+     * 查询
+     *
+     * @param type 0：量表  1：认知任务
+     * @return
+     */
+    List<SubjectEntity> findAll(String type);
+
+    /**
+     * 根据flag查询
+     *
+     * @return
+     */
+    SubjectEntity getSubjectByFlag(String flag);
+
+    /**
+     * 根据flag记录测试数
+     *
+     * @return
+     */
+    void addTestNum(String flag);
+
+
+
+
+
+
+    /**
+     * 修改量表测试结果效验状态
+     *
+     * @param flag
+     * @return
+     */
+    void updateScaleStatus(String flag, String status);
+
+
+    void update(SubjectEntity subjectEntity);
+
+    Page<SubjectEntity> find(String json);
+}

src/main/java/com/rf/kjb/scale/service/UserRecordPhyService.java

@@ -0,0 +1,13 @@
+package com.rf.kjb.scale.service;
+
+import com.rf.kjb.scale.dao.model.RecordPhyEntry;
+import java.util.List;
+
+/**
+ * @author zsy
+ * @date 2021/6/17 15:55
+ */
+public interface UserRecordPhyService {
+
+    List<RecordPhyEntry> getuserRecordByTestDate(String testDate);
+}

src/main/java/com/rf/kjb/scale/service/impl/AnswerServiceImpl.java

@@ -0,0 +1,67 @@
+package com.rf.kjb.scale.service.impl;
+
+import com.rf.kjb.scale.dao.model.AnswerEntity;
+import com.rf.kjb.scale.dao.repository.AnswerRepository;
+import com.rf.kjb.scale.service.AnswerService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:
+ * @date 2021/5/14 10:51
+ */
+@Service
+@Slf4j
+public class AnswerServiceImpl implements AnswerService {
+    @Autowired
+    private AnswerRepository answerRepository;
+
+
+    /**
+     * 根据flag获取全部答案
+     *
+     * @param flag
+     */
+    @Override
+    public List<AnswerEntity> getAnswerByFlag(String flag) {
+        return this.answerRepository.getAnswerByFlag(flag);
+    }
+
+
+    /**
+     * 保存
+     *
+     * @param answerEntity
+     */
+    @Override
+    public void saveAnswer(AnswerEntity answerEntity) {
+        //数据加密
+        //answerEntity.encrypt();
+        this.answerRepository.save(answerEntity);
+    }
+
+    @Override
+    public void saveBatchAnswer(List<AnswerEntity> answerEntity) {
+
+        this.answerRepository.saveAll(answerEntity);
+    }
+
+    @Override
+    public List<AnswerEntity> findAll() {
+        return answerRepository.findAll();
+    }
+
+    @Override
+    public void updateAnswer(AnswerEntity answerEntity) {
+        answerRepository.updateAnswer(answerEntity.getName(),answerEntity.getScore(),answerEntity.getId());
+    }
+
+    @Override
+    public void deleteAnswerByFlag(String flag) {
+        this.answerRepository.deleteAnswerByFlag(flag);
+    }
+
+}

src/main/java/com/rf/kjb/scale/service/impl/CategoryServiceImpl.java

@@ -0,0 +1,81 @@
+package com.rf.kjb.scale.service.impl;
+
+
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.model.CategoryEntry;
+import com.rf.kjb.scale.dao.model.CategorySubjectEntity;
+import com.rf.kjb.scale.dao.model.SubjectEntity;
+import com.rf.kjb.scale.dao.repository.CategoryRepository;
+import com.rf.kjb.scale.service.CategoryService;
+import com.rf.kjb.utils.Utils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+
+import javax.persistence.criteria.Predicate;
+import java.util.ArrayList;
+import java.util.List;
+
+
+/**
+ * @author zsy
+ * @description:量表类别信息管理
+ * @date 2021/6/17 15:55
+ */
+@Service
+public class CategoryServiceImpl implements CategoryService {
+
+    @Autowired
+    private CategoryRepository categoryRepository;
+
+
+    /**
+     * 保存
+     *
+     * @param CategoryEntry
+     */
+    @Override
+    public void save(CategoryEntry CategoryEntry) {
+        this.categoryRepository.save(CategoryEntry);
+    }
+
+
+
+    /**
+     * 名称查询
+     *
+     * @param categoryEntry
+     * @return
+     */
+    @Override
+    public List<CategoryEntry> getCategoryByName(CategoryEntry categoryEntry) {
+
+        Specification<CategoryEntry> specification = (root, query, cb) -> {
+            List<Predicate> predicateList = new ArrayList<>();
+            if(StringUtils.isNotBlank(categoryEntry.getEname())){
+                predicateList.add(cb.equal(root.get("ename"),categoryEntry.getEname()));
+            }
+            if(StringUtils.isNotBlank(categoryEntry.getName())){
+                predicateList.add(cb.equal(root.get("name"),categoryEntry.getName()));
+            }
+            query.where(cb.and(predicateList.toArray(new Predicate[0])));
+            query.orderBy(cb.asc(root.get("sequence")));
+            return query.getRestriction();
+        };
+        return this.categoryRepository.findAll(specification);
+    }
+
+    /**
+     * 查询所有类别
+     *
+     * @return
+     */
+    @Override
+    public List<CategoryEntry> findAll() {
+        return this.categoryRepository.findAll(Sort.by(Sort.Order.asc("sequence")));
+    }
+
+}

src/main/java/com/rf/kjb/scale/service/impl/CategorySubjectServiceImpl.java

@@ -0,0 +1,53 @@
+package com.rf.kjb.scale.service.impl;
+
+import com.rf.kjb.scale.dao.model.CategorySubjectEntity;
+import com.rf.kjb.scale.dao.repository.CategorySubjectRepository;
+import com.rf.kjb.scale.service.CategorySubjectService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:量表类别关联信息管理
+ * @date 2021/6/17 15:55
+ */
+@Service
+public class CategorySubjectServiceImpl implements CategorySubjectService {
+
+    @Autowired
+    private CategorySubjectRepository categorySubjectRepository;
+
+
+    /**
+     * 保存
+     * @param categorySubjectEntity
+     */
+    @Override
+    public void save(CategorySubjectEntity categorySubjectEntity) {
+        this.categorySubjectRepository.save(categorySubjectEntity);
+    }
+
+    @Override
+    public List<CategorySubjectEntity> findByFlag(String flag) {
+        return this.categorySubjectRepository.findByFlag(flag);
+    }
+
+    @Override
+    public void deleteCategorySubjectByFlag(String flag) {
+        this.categorySubjectRepository.deleteCategorySubjectByFlag(flag);
+    }
+
+    /**
+     * 分类英文名查询分类下的所有flag
+     *
+     * @param typeName
+     * @return
+     */
+    @Override
+    public List<CategorySubjectEntity> findByEname(String typeName) {
+        return this.categorySubjectRepository.findByEname(typeName);
+    }
+
+}

src/main/java/com/rf/kjb/scale/service/impl/DimensionServiceImpl.java

@@ -0,0 +1,62 @@
+package com.rf.kjb.scale.service.impl;
+
+import com.rf.kjb.scale.dao.model.DimensionEntity;
+import com.rf.kjb.scale.dao.repository.DimensionRepository;
+import com.rf.kjb.scale.service.DimensionService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:
+ * @date 2021/5/14 10:51
+ */
+@Service
+@Slf4j
+public class DimensionServiceImpl implements DimensionService {
+    @Autowired
+    private DimensionRepository dimensionRepository;
+
+    /**
+     * 保存
+     *
+     * @param dimensionEntity
+     */
+    @Override
+    public void saveDimension(DimensionEntity dimensionEntity) {
+        //dimensionEntity.encrypt();
+        this.dimensionRepository.save(dimensionEntity);
+    }
+
+    @Override
+    public void saveBatch(List<DimensionEntity> dimensionEntitys) {
+        this.dimensionRepository.saveAll(dimensionEntitys);
+    }
+
+    /**
+     * 根据flag查询维度信息
+     *
+     * @param flag
+     */
+    @Override
+    public List<DimensionEntity> getDimensionByFlag(String flag) {
+        return this.dimensionRepository.getDimensionByFlag(flag);
+    }
+
+    @Override
+    public List<DimensionEntity> findAll() {
+        return dimensionRepository.findAll();
+    }
+
+    @Override
+    public void updateDimension(DimensionEntity dimensionEntity) {
+        this.dimensionRepository.updateDimension(dimensionEntity.getName(),dimensionEntity.getQuestionNo(),dimensionEntity.getId());
+    }
+
+    @Override
+    public void deleteDimensionByFlag(String flag) {
+        this.dimensionRepository.deleteDimensionByFlag(flag);
+    }
+}

src/main/java/com/rf/kjb/scale/service/impl/GameRecordServiceImpl.java

@@ -0,0 +1,74 @@
+package com.rf.kjb.scale.service.impl;
+
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.model.GameRecordEntity;
+import com.rf.kjb.scale.dao.model.RecordPhyEntry;
+import com.rf.kjb.scale.dao.repository.GameRecordRepository;
+import com.rf.kjb.scale.service.GameRecordService;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+
+import javax.persistence.criteria.Predicate;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @Author:zzf
+ * @Date:2023/6/7:10:26
+ * @Description:
+ */
+@Service
+public class GameRecordServiceImpl implements GameRecordService {
+    @Autowired
+    private GameRecordRepository gameRecordRepository;
+    @Override
+    public void save(GameRecordEntity gameRecordEntity) {
+        this.gameRecordRepository.save(gameRecordEntity);
+    }
+
+    @Override
+    public Page<GameRecordEntity> find(String json) {
+        JSONObject jsonObject = JSONObject.parseObject(json);
+        int pageNum = 1;
+        int pageSize = 10 ;
+
+        if(jsonObject.containsKey("pageNum")&&jsonObject.getIntValue("pageNum")>0){
+            pageNum = jsonObject.getIntValue("pageNum");
+        }
+        if(jsonObject.containsKey("pageSize")&&jsonObject.getIntValue("pageSize")>0){
+            pageSize = jsonObject.getIntValue("pageSize");
+        }
+        Specification<RecordPhyEntry> specification = (root, query, cb) -> {
+            List<Predicate> predicateList = new ArrayList<>();
+            if(jsonObject.containsKey("id")&& StringUtils.isNotBlank(jsonObject.getString("id"))){
+                predicateList.add(cb.equal(root.get("id"),jsonObject.getString("id")));
+            }
+            if(jsonObject.containsKey("identifier") && StringUtils.isNotBlank(jsonObject.getString("identifier"))){
+                predicateList.add(cb.equal(root.get("identifier"),jsonObject.getString("identifier")));
+            }
+            if(jsonObject.containsKey("gameScene") && StringUtils.isNotBlank(jsonObject.getString("gameScene"))){
+                predicateList.add(cb.equal(root.get("gameScene"),jsonObject.getString("gameScene")));
+            }
+            if(jsonObject.containsKey("equipmentType") && StringUtils.isNotBlank(jsonObject.getString("equipmentType"))){
+                predicateList.add(cb.equal(root.get("equipmentType"),jsonObject.getString("equipmentType")));
+            }
+            if(jsonObject.containsKey("fileName") && StringUtils.isNotBlank(jsonObject.getString("fileName"))){
+                predicateList.add(cb.like(root.get("fileName"),"%"+jsonObject.getString("fileName")+"%"));
+            }
+            if(jsonObject.containsKey("gameDifficulty")){
+                predicateList.add(cb.equal(root.get("gameDifficulty"),jsonObject.getString("gameDifficulty")));
+            }
+            if(jsonObject.containsKey("gameTime")){
+                predicateList.add(cb.equal(root.get("gameTime"),jsonObject.getString("gameTime")));
+            }
+            query.where(cb.and(predicateList.toArray(new Predicate[0])));
+            query.orderBy(cb.asc(root.get("saveTime")));
+            return query.getRestriction();
+        };
+        return this.gameRecordRepository.findAll(specification, PageRequest.of(pageNum-1,pageSize));
+    }
+}

src/main/java/com/rf/kjb/scale/service/impl/RecordPhyServiceImpl.java

@@ -0,0 +1,139 @@
+package com.rf.kjb.scale.service.impl;
+
+import com.alibaba.fastjson.JSONObject;
+import com.rf.kjb.scale.dao.model.RecordPhyEntry;
+import com.rf.kjb.scale.dao.repository.RecordPhyRepository;
+import com.rf.kjb.scale.service.RecordPhyService;
+import com.rf.kjb.utils.Utils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+
+import javax.persistence.criteria.Predicate;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @Author:zzf
+ * @Date:2022/7/28:19:25
+ * @Description:
+ */
+@Service
+public class RecordPhyServiceImpl implements RecordPhyService {
+
+    @Autowired
+    private RecordPhyRepository repository;
+
+    @Override
+    public void save(RecordPhyEntry recordPhyEntry) {
+        this.repository.save(recordPhyEntry);
+    }
+
+    @Override
+    public Page<RecordPhyEntry> find(JSONObject jsonObject) {
+        int pageNum = 1;
+        int pageSize = 10 ;
+
+        if(jsonObject.containsKey("pageNum")&&jsonObject.getIntValue("pageNum")>0){
+            pageNum = jsonObject.getIntValue("pageNum");
+        }
+        if(jsonObject.containsKey("pageSize")&&jsonObject.getIntValue("pageSize")>0){
+            pageSize = jsonObject.getIntValue("pageSize");
+        }
+        Specification<RecordPhyEntry> specification = (root, query, cb) -> {
+
+            List<Predicate> predicateList = new ArrayList<>();
+            if(jsonObject.containsKey("startDate")&& StringUtils.isNotBlank(jsonObject.getString("startDate"))){
+                predicateList.add(cb.greaterThanOrEqualTo(root.get("testDate"),jsonObject.getString("startDate")));
+            }
+            if(jsonObject.containsKey("endDate") && StringUtils.isNotBlank(jsonObject.getString("endDate"))){
+                predicateList.add(cb.lessThanOrEqualTo(root.get("testDate"),jsonObject.getString("endDate")+"23时59分59秒999"));
+            }
+            if(jsonObject.containsKey("type") && StringUtils.isNotBlank(jsonObject.getString("type"))){
+                predicateList.add(cb.equal(root.get("type"),jsonObject.getString("type")));
+            }
+            if(jsonObject.containsKey("fileName") && StringUtils.isNotBlank(jsonObject.getString("fileName"))){
+                predicateList.add(cb.like(root.get("fileName"),"%"+jsonObject.getString("fileName")+"%"));
+            }
+            if(jsonObject.containsKey("identifier")){
+               predicateList.add(cb.equal(root.get("identifier"),jsonObject.getString("identifier")));
+            }
+            query.where(cb.and(predicateList.toArray(new Predicate[0])));
+            query.orderBy(cb.asc(root.get("testDate")));
+            return query.getRestriction();
+        };
+        return this.repository.findAll(specification, PageRequest.of(pageNum-1,pageSize));
+    }
+
+    @Override
+    public List<String> findIdentifiers(JSONObject jsonObject) {
+        int pageNum = 1;
+        int pageSize = 10;
+        if(jsonObject.containsKey("pageNum")){
+            pageNum = jsonObject.getIntValue("pageNum") -1;
+        }
+        if(jsonObject.containsKey("pageSize")){
+            pageSize = jsonObject.getIntValue("pageSize");
+        }
+
+        String startDate = jsonObject.containsKey("startDate")?jsonObject.getString("startDate"):"";
+        String endDate = jsonObject.containsKey("endDate")?jsonObject.getString("endDate"):"";
+        String type = jsonObject.containsKey("type")?jsonObject.getString("type"):"";
+//        String userName = jsonObject.containsKey("userName")?"%"+jsonObject.getString("userName")+"%":"";
+        String userName ="";
+        if(jsonObject.containsKey("userName") && StringUtils.isNotBlank(jsonObject.getString("userName"))){
+            userName = "%"+jsonObject.getString("userName")+"%";
+        }
+//        return this.repository.findIdentifiers(type,startDate,endDate,userName,pageNum-1,pageSize);
+        return this.repository.findIdentifiers(type,startDate,userName,endDate,pageNum*pageSize,pageSize);
+    }
+
+    @Override
+    public int findIdentifiersCount(JSONObject jsonObject) {
+        String startDate = jsonObject.containsKey("startDate")?jsonObject.getString("startDate"):"";
+        String endDate = jsonObject.containsKey("endDate")?jsonObject.getString("endDate"):"";
+        String type = jsonObject.containsKey("type")?jsonObject.getString("type"):"";
+//        String userName = jsonObject.containsKey("userName")?"%"+jsonObject.getString("userName")+"%":"";
+        String userName ="";
+        if(jsonObject.containsKey("userName") && StringUtils.isNotBlank(jsonObject.getString("userName"))){
+            userName = "%"+jsonObject.getString("userName")+"%";
+        }
+        return this.repository.findIdentifiersCount(type,startDate,userName,endDate);
+    }
+
+    @Override
+    public RecordPhyEntry findById(String id) {
+        return this.repository.findById(id).orElse(null);
+    }
+
+    @Override
+    public List<RecordPhyEntry> find(List<String> recordingIds, String flag) {
+        Specification<RecordPhyEntry> specification = (root, query, cb) -> {
+
+            List<Predicate> predicateList = new ArrayList<>();
+           if(Utils.isNotBlank(recordingIds)){
+               predicateList.add(root.get("id").in(recordingIds));
+           }
+           if(StringUtils.isNotBlank(flag)){
+                predicateList.add(cb.equal(root.get("type"),flag));
+           }
+            query.where(cb.and(predicateList.toArray(new Predicate[0])));
+            query.orderBy(cb.desc(root.get("testDate")));
+            return query.getRestriction();
+        };
+        return this.repository.findAll(specification);
+    }
+
+    @Override
+    public List<RecordPhyEntry> findAll(JSONObject jsonObject) {
+        return null;
+    }
+
+    @Override
+    public List<RecordPhyEntry> findByType(String type) {
+        return this.repository.findByType(type);
+    }
+}

src/main/java/com/rf/kjb/scale/service/impl/RecordServiceImpl.java

@@ -0,0 +1,196 @@
+package com.rf.kjb.scale.service.impl;
+
+
+import com.alibaba.fastjson.JSONObject;
+import com.mysql.cj.util.Util;
+import com.rf.kjb.scale.dao.model.RecordEntity;
+
+import com.rf.kjb.scale.dao.model.SubjectEntity;
+import com.rf.kjb.scale.dao.repository.RecordRepository;
+import com.rf.kjb.scale.dao.repository.SubjectRepository;
+import com.rf.kjb.scale.service.RecordService;
+import com.rf.kjb.user.dao.model.UserEntry;
+import com.rf.kjb.user.dao.repository.UserRepository;
+import com.rf.kjb.utils.Utils;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import javax.persistence.criteria.Predicate;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author zsy
+ * @description:用户测试记录
+ * @date 2021/6/17 15:55
+ */
+@Slf4j
+@Service
+public class RecordServiceImpl implements RecordService {
+
+    @Autowired
+    private RecordRepository userRecordRepository;
+
+    @Autowired
+    private SubjectRepository subjectRepository;
+
+    @Autowired
+    private UserRepository userRepository;
+
+    /**
+     * 保存
+     *
+     * @param userRecordEntity
+     */
+    @Override
+    public RecordEntity save(RecordEntity userRecordEntity) {
+        return this.userRecordRepository.save(userRecordEntity);
+    }
+
+    /**
+     * 根据id查询数据
+     *
+     * @return
+     */
+    @Override
+    public RecordEntity getUserRecordById(String id) {
+        return this.userRecordRepository.getUserRecordById(id);
+    }
+
+
+    /**
+     * 查询全量数据
+     *
+     * @return
+     */
+    @Override
+    public List<RecordEntity> findAll() {
+        return this.userRecordRepository.findAll();
+    }
+
+
+    /**
+     * @param json
+     * @return
+     */
+    @Override
+    public List<String> findIdentifiers(String json) {
+        JSONObject jsonObject = JSONObject.parseObject(json);
+        int pageNum = 1;
+        int pageSize = 10;
+        if(jsonObject.containsKey("pageNum")){
+            pageNum = jsonObject.getIntValue("pageNum") -1;
+        }
+        if(jsonObject.containsKey("pageSize")){
+            pageSize = jsonObject.getIntValue("pageSize");
+        }
+
+        String startDate = jsonObject.containsKey("startDate")?jsonObject.getString("startDate"):"";
+        String endDate = jsonObject.containsKey("endDate")?jsonObject.getString("endDate"):"";
+        String userName ="";
+        String flag = "";
+        if(jsonObject.containsKey("flag") && StringUtils.isNotBlank(jsonObject.getString("flag"))){
+            flag = jsonObject.getString("flag");
+        }
+        if(jsonObject.containsKey("userName") && StringUtils.isNotBlank(jsonObject.getString("userName"))){
+            userName = "%"+jsonObject.getString("userName")+"%";
+        }
+        return this.userRecordRepository.findIdentifiers(flag,startDate,userName,endDate,pageNum,pageSize);
+
+
+    }
+
+    @Override
+    public int findIdentifiersCount(String json) {
+        JSONObject jsonObject = JSONObject.parseObject(json);
+        String startDate = jsonObject.containsKey("startDate")?jsonObject.getString("startDate"):"";
+        String endDate = jsonObject.containsKey("endDate")?jsonObject.getString("endDate"):"";
+        String userName ="";
+        String flag = "";
+        if(jsonObject.containsKey("flag") && StringUtils.isNotBlank(jsonObject.getString("flag"))){
+            flag = jsonObject.getString("flag");
+        }
+        if(jsonObject.containsKey("userName") && StringUtils.isNotBlank(jsonObject.getString("userName"))){
+            userName = "%"+jsonObject.getString("userName")+"%";
+        }
+        return this.userRecordRepository.findIdentifiersCount(flag,startDate,userName,endDate);
+    }
+
+    @Override
+    public Page<RecordEntity> find(String json) {
+        int pageNum = 1;
+        int pageSize = 10 ;
+        JSONObject jsonObject = JSONObject.parseObject(json);
+        if(jsonObject.containsKey("pageNum")&&jsonObject.getIntValue("pageNum")>0){
+            pageNum = jsonObject.getIntValue("pageNum");
+        }
+        if(jsonObject.containsKey("pageSize")&&jsonObject.getIntValue("pageSize")>0){
+            pageSize = jsonObject.getIntValue("pageSize");
+        }
+
+        Specification<RecordEntity> specification = createSpecification(jsonObject);
+        return this.userRecordRepository.findAll(specification, PageRequest.of(pageNum-1,pageSize));
+    }
+
+    @Override
+    public RecordEntity findById(String id) {
+        return this.userRecordRepository.findById(id).orElse(null);
+    }
+
+    @Override
+    public List<RecordEntity> findNoPage(String json) {
+        JSONObject jsonObject = JSONObject.parseObject(json);
+        Specification<RecordEntity> specification = createSpecification(jsonObject);
+
+        return this.userRecordRepository.findAll(specification);
+    }
+
+    private Specification<RecordEntity> createSpecification(JSONObject jsonObject) {
+        return (root, query, cb) -> {
+
+            List<Predicate> predicateList = new ArrayList<>();
+            if(jsonObject.containsKey("startDate")&& StringUtils.isNotBlank(jsonObject.getString("startDate"))){
+                predicateList.add(cb.greaterThanOrEqualTo(root.get("testDate"),jsonObject.getString("startDate")));
+            }
+            if(jsonObject.containsKey("endDate") && StringUtils.isNotBlank(jsonObject.getString("endDate"))){
+                predicateList.add(cb.lessThanOrEqualTo(root.get("testDate"),jsonObject.getString("endDate")+"23时59分59秒"));
+            }
+            if(jsonObject.containsKey("identifier")){
+                predicateList.add(cb.equal(root.get("identifier"),jsonObject.getString("identifier")));
+            }
+            if(jsonObject.containsKey("id") && StringUtils.isNotBlank(jsonObject.getString("id"))){
+                predicateList.add(cb.equal(root.get("id"),jsonObject.getString("id")));
+            }
+            if(jsonObject.containsKey("ids") && jsonObject.getJSONArray("ids") != null && jsonObject.getJSONArray("ids").size()>0){
+                List<String> ids = jsonObject.getJSONArray("ids").toJavaList(String.class);
+                predicateList.add(root.<String>get("id").in(ids));
+            }
+            if(jsonObject.containsKey("scaleName") && StringUtils.isNotBlank(jsonObject.getString("scaleName"))){
+                List<SubjectEntity> list = this.subjectRepository.findByName("%"+jsonObject.getString("scaleName")+"%");
+                if(Utils.isNotBlank(list)){
+                    List<String> flags = new ArrayList<>();
+                    list.forEach(item -> flags.add(item.getFlag()));
+                    predicateList.add(root.get("flag").in(flags));
+                }else{
+                    //以量表名称为筛选条件但未找到时，将查询条件修改为flag = ""返回 空数据
+                    predicateList.add(cb.equal(root.get("flag"),""));
+                }
+            }
+            if(jsonObject.containsKey("flag") && StringUtils.isNotBlank(jsonObject.getString("flag"))){
+                predicateList.add(cb.equal(root.get("flag"),jsonObject.getString("flag")));
+            }
+            if(jsonObject.containsKey("userName") && StringUtils.isNotBlank(jsonObject.getString("userName"))){
+
+                List<String> identifiers = this.userRepository.findIdentifierByName("%"+jsonObject.getString("userName")+"%");
+                predicateList.add(root.get("identifier").in(identifiers));
+            }
+            query.where(cb.and(predicateList.toArray(new Predicate[0])));
+            query.orderBy(cb.desc(root.get("testDate")));
+            return query.getRestriction();
+        };
+    }
+}