Merge branch 'Test' into 'master'

Test

See merge request crowd-2019/crowd-test-service-backend!16

core/pom.xml

@@ -3,7 +3,11 @@
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
-
+    <parent>
+        <groupId>com.mooctest.crowd</groupId>
+        <artifactId>crowd</artifactId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
     <groupId>com.mooctest.crowd</groupId>
     <artifactId>core</artifactId>
     <version>1.0-SNAPSHOT</version>
@@ -31,58 +35,107 @@
             <version>1.6.4</version>
         </dependency>
 
-        <!--dubbo-domainservice-api-->
-        <!--dubbo-dependency-->
-        <!-- https://mvnrepository.com/artifact/io.dubbo.springboot/spring-boot-starter-dubbo -->
-        <dependency>
-            <groupId>io.dubbo.springboot</groupId>
-            <artifactId>spring-boot-starter-dubbo</artifactId>
-            <version>1.0.0</version>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.javassist</groupId>
-                    <artifactId>javassist</artifactId>
-                </exclusion>
-                <exclusion>
-                    <groupId>org.slf4j</groupId>
-                    <artifactId>slf4j-log4j12</artifactId>
-                </exclusion>
-            </exclusions>
-        </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
             <version>1.18.6</version>
         </dependency>
+
+
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>18.0</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-jpa</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
-            <version>RELEASE</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter</artifactId>
-            <version>2.1.6.RELEASE</version>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.hibernate.javax.persistence</groupId>
+            <artifactId>hibernate-jpa-2.1-api</artifactId>
+            <version>1.0.0.Final</version>
         </dependency>
+
         <dependency>
-            <groupId>javax.persistence</groupId>
-            <artifactId>javax.persistence-api</artifactId>
-            <version>2.2</version>
-            <scope>compile</scope>
+            <groupId> org.springframework.boot </groupId>
+            <artifactId> spring-boot-configuration-processor</artifactId>
+            <optional> true </optional>
         </dependency>
+
         <dependency>
-            <groupId>javax.transaction</groupId>
-            <artifactId>javax.transaction-api</artifactId>
-            <version>1.3</version>
-            <scope>compile</scope>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.8.5</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>druid-spring-boot-starter</artifactId>
+            <version>1.1.10</version>
         </dependency>
         <dependency>
-            <groupId>org.springframework.data</groupId>
-            <artifactId>spring-data-commons</artifactId>
-            <version>2.1.9.RELEASE</version>
+            <groupId>org.jetbrains</groupId>
+            <artifactId>annotations</artifactId>
+            <version>RELEASE</version>
             <scope>compile</scope>
         </dependency>
 
+        <!-- https://mvnrepository.com/artifact/cn.afterturn/easypoi-spring-boot-starter -->
+        <dependency>
+            <groupId>cn.afterturn</groupId>
+            <artifactId>easypoi-base</artifactId>
+            <version>3.0.3</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.afterturn</groupId>
+            <artifactId>easypoi-web</artifactId>
+            <version>3.0.3</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.afterturn</groupId>
+            <artifactId>easypoi-annotation</artifactId>
+            <version>3.0.3</version>
+        </dependency>
+
+        <dependency>
+            <groupId>redis.clients</groupId>
+            <artifactId>jedis</artifactId>
+            <version>2.9.0</version>
+        </dependency>
+
+        <dependency>
+            <groupId>commons-fileupload</groupId>
+            <artifactId>commons-fileupload</artifactId>
+            <version>1.4</version>
+        </dependency>
     </dependencies>
     <build>
         <plugins>

core/src/main/java/com/mooctest/crowd/domain/Application.java

@@ -2,12 +2,22 @@ package com.mooctest.crowd.domain;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.boot.web.servlet.ServletComponentScan;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.scheduling.annotation.EnableScheduling;
 
 @SpringBootApplication
+@EnableConfigurationProperties
+@ServletComponentScan
+@EnableScheduling
+@EnableCaching
+@EnableAsync
 public class Application
 {
     public static void main( String[] args )
     {
         SpringApplication.run(Application.class,args);
     }
-}
+}

core/src/main/java/com/mooctest/crowd/domain/command/CrowdTestProjectCommand.java

@@ -18,8 +18,8 @@ public class CrowdTestProjectCommand {
     private String description;
     private String projectFile;
     private String requirementFile;
-    private double quotedPrice;
-    private double fixedPrice;
+    private Double quotedPrice;
+    private Double fixedPrice;
     private String status;
     private Timestamp creatTime;
 }

core/src/main/java/com/mooctest/crowd/domain/configuration/RoleConfiguration.java

@@ -0,0 +1,19 @@
+package com.mooctest.crowd.domain.configuration;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * Created by guochao on 2019/8/12.
+ */
+@Data
+@Component
+@ConfigurationProperties(prefix = "role-list")
+public class RoleConfiguration {
+    private Long generalUser;
+    private Long evaluationAgency;
+    private Long regionalManager;
+    private Long systemAdministrator;
+    private Long enterpriseUser;
+}

core/src/main/java/com/mooctest/crowd/domain/controller/CrowdTestProjectController.java

@@ -0,0 +1,589 @@
+package com.mooctest.crowd.domain.controller;
+
+import com.google.gson.Gson;
+import com.mooctest.crowd.domain.domainobject.CrowdTestProject;
+import com.mooctest.crowd.domain.domainobject.CrowdTestReport;
+import com.mooctest.crowd.domain.domainobject.CrowdTestTask;
+import com.mooctest.crowd.domain.domainobject.User;
+import com.mooctest.crowd.domain.repository.CrowdTestProjectRepo;
+import com.mooctest.crowd.domain.repository.UserRepo;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+
+/**
+ * @author guochao
+ * @date 2019-07-27 15:46
+ */
+
+@RestController
+@RequestMapping("/project/")
+public class CrowdTestProjectController {
+
+    @Autowired
+    private CrowdTestProjectRepo crowdTestProjectRepo;
+
+    @Autowired
+    private UserRepo userRepo;
+
+    @RequestMapping(value = "findById/{crowdTestProjectId}", method = RequestMethod.GET)
+    public String getCrowdTestProjectById(@PathVariable("crowdTestProjectId") Long crowdTestProjectId){
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(crowdTestProjectId);
+        return crowdTestProject.toString();
+    }
+
+    @RequestMapping(value = "findByProjectCode/{crowdTestProjectCode}", method = RequestMethod.GET)
+    public String getCrowdTestProjectByProjectCode(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode){
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        return crowdTestProject.toString();
+    }
+
+    @RequestMapping(value = "findByUserId/{userId}", method = RequestMethod.GET)
+    public String getAllCrowdTestProjectByUserId(@PathVariable("userId") Long userId){
+        List<CrowdTestProject> allCrowdTestProject = crowdTestProjectRepo.getCrowdListByUserId(userId);
+        return allCrowdTestProject.toString();
+    }
+
+    @RequestMapping(value = "findByRMId/{regionalManagerId}", method = RequestMethod.GET)
+    public String getAllCrowdTestProjectByRMId(@PathVariable("regionalManagerId") Long regionalManagerId){
+        List<CrowdTestProject> allCrowdTestProject = crowdTestProjectRepo.getCrowdListByRegionalManagerId(regionalManagerId);
+        return allCrowdTestProject.toString();
+    }
+
+    @RequestMapping(value = "findAll", method = RequestMethod.GET)
+    public String getAllCrowdTestProject(){
+        List<CrowdTestProject> allCrowdTestProject = crowdTestProjectRepo.getAllCrowdTestProject();
+        return allCrowdTestProject.toString();
+    }
+
+    /**
+     * 删除项目（普通用户）
+     * @param crowdTestProjectCode
+     * @return
+     */
+    @RequestMapping(value = "deleteProject/{userId}/{crowdTestProjectCode}", method = RequestMethod.GET)
+    public String deleteCrowdTestProjectByProjectCode(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode,@PathVariable("userId") Long userId) {
+
+        User user = userRepo.getByID(userId);
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.removeCrowdTestProject(user);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return "success";
+    }
+
+    /**
+     * 删除任务（区域管理员）
+     * @param crowdTestProjectCode
+     * @param crowdTestTaskCode
+     * @return
+     */
+    @RequestMapping(value = "deleteTask/{userId}/{crowdTestProjectCode}/{crowdTestTaskCode}", method = RequestMethod.GET)
+    public String deleteCrowdTestTask(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode,
+                                      @PathVariable("crowdTestTaskCode") String crowdTestTaskCode,
+                                      @PathVariable("userId") Long userId) {
+        User user = userRepo.getByID(userId);
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.removeCrowdTestTask(crowdTestTaskCode,user);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
+    }
+
+    /**
+     * 删除任务报告（测评机构）
+     * @param crowdTestProjectCode
+     * @param crowdTestTaskCode
+     * @param crowdTestReportCode
+     * @return
+     */
+    @RequestMapping(value = "deleteReport/{userId}/{crowdTestProjectCode}/{crowdTestTaskCode}/{crowdTestReportCode}", method = RequestMethod.GET)
+    public String deleteCrowdTestReport(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode,
+                                        @PathVariable("crowdTestTaskCode") String crowdTestTaskCode,
+                                        @PathVariable("crowdTestReportCode") String crowdTestReportCode,
+                                        @PathVariable("userId") Long userId) {
+        User user = userRepo.getByID(userId);
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.removeCrowdTestReport(crowdTestTaskCode,crowdTestReportCode,user);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
+    }
+
+    /**
+     * 删除项目报告（区域管理员）
+     * @param crowdTestProjectCode
+     * @return
+     */
+    @RequestMapping(value = "deleteProjectReport/{userId}/{crowdTestProjectCode}/{crowdTestProjectReportCode}", method = RequestMethod.GET)
+    public String deleteCrowdTestReport(@PathVariable("userId") Long userId,
+                                        @PathVariable("crowdTestProjectCode") String crowdTestProjectCode,
+                                        @PathVariable("crowdTestProjectReportCode") String crowdTestProjectReportCode) {
+        User user = userRepo.getByID(userId);
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.removeCrowdTestProjectReport(crowdTestProjectReportCode,user);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
+    }
+
+
+    @RequestMapping(value = "deleteListByProjectCode/{crowdTestProjectCode1}/{crowdTestProjectCode2}", method = RequestMethod.GET)
+    public void deleteCrowdTestProjectByProjectCode(@PathVariable("crowdTestProjectCode1") String crowdTestProjectCode1,
+                                                    @PathVariable("crowdTestProjectCode2") String crowdTestProjectCode2) {
+        CrowdTestProject crowdTestProject1 = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode1);
+        CrowdTestProject crowdTestProject2 = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode2);
+        List<CrowdTestProject> crowdTestProjectList = new ArrayList<>();
+        crowdTestProjectList.add(crowdTestProject1);
+        crowdTestProjectList.add(crowdTestProject2);
+        crowdTestProjectRepo.removeCrowdTestProjectList(crowdTestProjectList);
+    }
+
+
+    /**
+     * 对项目聚合根的操作
+     */
+
+    @RequestMapping(value = "modifyProject/{crowdTestProjectCode}/{linkMan}", method = RequestMethod.GET)
+    public void modifyCrowdTestProject(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode,@PathVariable("linkMan") String linkMan){
+        CrowdTestProject crowdTestProjectModify;
+
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        Gson gson = new Gson();
+        crowdTestProjectModify = gson.fromJson(gson.toJson(crowdTestProject), CrowdTestProject.class);
+        crowdTestProjectModify.setLinkMan(linkMan);
+        CrowdTestProject updateCrowdTestProject = crowdTestProject.updateCrowdTestProject(crowdTestProjectModify);
+        crowdTestProjectRepo.saveCrowdTestProject(updateCrowdTestProject);
+    }
+
+
+    @RequestMapping(value = "modifyTask/{crowdTestProjectCode}/{crowdTestTaskCode}/{taskName}", method = RequestMethod.GET)
+    public void modifyCrowdTestTask(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode, @PathVariable("crowdTestTaskCode") String crowdTestTaskCode,
+                                      @PathVariable("taskName") String taskName){
+        CrowdTestTask crowdTestTaskModify = new CrowdTestTask();
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
+        for(CrowdTestTask crowdTestTaskSelect : crowdTestTaskList){
+            if(crowdTestTaskCode.equals(crowdTestTaskSelect.getCode())){
+                // 使用Gson序列化进行深拷贝
+                Gson gson = new Gson();
+                crowdTestTaskModify = gson.fromJson(gson.toJson(crowdTestTaskSelect), CrowdTestTask.class);
+            }
+        }
+        crowdTestTaskModify.setName(taskName);
+        CrowdTestProject updateCrowdTestProject = crowdTestProject.updateCrowdTestTask(crowdTestTaskCode, crowdTestTaskModify);
+        crowdTestProjectRepo.saveCrowdTestProject(updateCrowdTestProject);
+    }
+
+    @RequestMapping(value = "modifyReport/{crowdTestProjectCode}/{crowdTestTaskCode}/{crowdTestReportCode}/{reportName}", method = RequestMethod.GET)
+    public void modifyCrowdTestReport(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode, @PathVariable("crowdTestTaskCode") String crowdTestTaskCode,
+                                      @PathVariable("crowdTestReportCode") String crowdTestReportCode, @PathVariable("reportName") String reportName){
+        CrowdTestReport crowdTestReportModify = new CrowdTestReport();
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        for(CrowdTestTask crowdTestTask : crowdTestProject.getCrowdTestTaskList()){
+            if(crowdTestTaskCode.equals(crowdTestTask.getCode())){
+                for(CrowdTestReport crowdTestReport : crowdTestTask.getCrowdTestReportList()){
+                    if(crowdTestReportCode.equals(crowdTestReport.getCode())){
+                        Gson gson = new Gson();
+                        crowdTestReportModify = gson.fromJson(gson.toJson(crowdTestReport), CrowdTestReport.class);
+                    }
+                }
+            }
+        }
+        crowdTestReportModify.setName(reportName);
+        CrowdTestProject updateCrowdTestProject = crowdTestProject.updateCrowdTestReport(crowdTestTaskCode, crowdTestReportCode, crowdTestReportModify);
+        crowdTestProjectRepo.saveCrowdTestProject(updateCrowdTestProject);
+    }
+
+    /*普通用户DO*/
+    /**
+     * 新建项目（普通用户）
+     * @param userId
+     * @param projectName
+     * @return
+     */
+    @RequestMapping(value = "createProject/{userId}/{projectName}", method = RequestMethod.GET)
+    public String createCrowdTestProject(@PathVariable("userId") Long userId,@PathVariable("projectName") String projectName){
+        //数据准备
+        CrowdTestProject crowdTestProject = new CrowdTestProject();
+        crowdTestProject.setCode("PRO"+System.currentTimeMillis());
+        crowdTestProject.setName(projectName);
+        crowdTestProject.setProjectDistributionTypeId(1L);
+        crowdTestProject.setLinkMan("郭超");
+        crowdTestProject.setPlatform("IOS");
+        crowdTestProject.setType("安卓测试");
+        crowdTestProject.setDescription("测试内容");
+        crowdTestProject.setLinkManMobile("13657094936");
+        crowdTestProject.setQuotedPrice(200.00);
+        crowdTestProject.setDeadTime(new Timestamp(getNextDay(new Date(System.currentTimeMillis()),1).getTime()));
+
+        User user = userRepo.getByID(userId);
+        crowdTestProject.setUserId(user.getId());
+        crowdTestProject.setDistributionProvince(user.getProvince());
+        crowdTestProject.setDistributionCity(user.getCity());
+
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.createCrowdTestProject(user);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
+    }
+
+    /**
+     * 发布项目（普通用户）
+     * @param userId
+     * @param crowdTestProjectCode
+     * @return
+     */
+    @RequestMapping(value = "releaseProject/{userId}/{crowdTestProjectCode}", method = RequestMethod.GET)
+    public String releaseCrowdTestProject(@PathVariable("userId") Long userId,@PathVariable("crowdTestProjectCode") String crowdTestProjectCode){
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        User user = userRepo.getByID(userId);
+        CrowdTestProject  crowdTestProjectResult = crowdTestProject.releaseCrowdTestProject(user);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
+    }
+
+
+    /**
+     * 对区域管理员的操作
+     */
+
+
+    /**
+     * 接收项目（区域管理员）
+     * @param userForRegionalManagerId
+     * @param crowdTestProjectCode
+     * @return
+     */
+    @RequestMapping(value = "receiveProject/{userForRegionalManagerId}/{crowdTestProjectCode}", method = RequestMethod.GET)
+    public String receiveTaskByProjectCode(@PathVariable("userForRegionalManagerId") Long userForRegionalManagerId, @PathVariable("crowdTestProjectCode") String crowdTestProjectCode) {
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+
+        User userForRegionalManager = userRepo.getByID(userForRegionalManagerId);
+//        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
+//        CrowdTestProject crowdTestProjectResult = regionalManager.receiveProject(crowdTestProject);
+
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.receiveProject(userForRegionalManager);
+        crowdTestProjectResult.setRegionalManagerId(userForRegionalManagerId);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProject);
+        return crowdTestProjectResult.toString();
+    }
+
+
+    /**
+     * 项目中新建任务（区域管理员拆分项目）
+     * @param crowdTestProjectCode
+     * @param taskName
+     * @return
+     */
+    @RequestMapping(value = "createTask/{regionalManagerId}/{crowdTestProjectCode}/{taskName}", method = RequestMethod.GET)
+    public String createCrowdTestTask(@PathVariable("regionalManagerId") Long regionalManagerId,@PathVariable("crowdTestProjectCode") String crowdTestProjectCode,@PathVariable("taskName") String taskName){
+        //数据准备
+        CrowdTestTask crowdTestTask = new CrowdTestTask();
+        crowdTestTask.setCode(crowdTestProjectCode+"_TASK"+System.currentTimeMillis());
+        crowdTestTask.setName(taskName);
+        crowdTestTask.setCrowdTestProjectCode(crowdTestProjectCode);
+        crowdTestTask.setType("接口测试");
+        crowdTestTask.setDescription("测试任务");
+        crowdTestTask.setDistributionType(0L);
+        crowdTestTask.setQuotedPrice(200.00);
+        crowdTestTask.setDeadTime(new Timestamp(getNextDay(new Date(System.currentTimeMillis()),1).getTime()));
+        crowdTestTask.setCreateTime(new Timestamp(System.currentTimeMillis()));
+
+        //具体操作
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+
+        User userForRegionalManager = userRepo.getByID(regionalManagerId);
+//        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
+//        CrowdTestProject crowdTestProjectResult = regionalManager.createCrowdTestTask(crowdTestProject, crowdTestTask);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.createCrowdTestTask(crowdTestTask, userForRegionalManager);
+        crowdTestTask.setDistributionProvince(crowdTestProject.getDistributionProvince());
+        crowdTestTask.setDistributionCity(crowdTestProject.getDistributionCity());
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
+    }
+
+    /**
+     * 发布任务（区域管理员）
+     * @param crowdTestProjectCode
+     * @return
+     */
+    @RequestMapping(value = "releaseTask/{regionalManagerId}/{crowdTestProjectCode}/{crowdTestTaskCode}", method = RequestMethod.GET)
+    public String releaseCrowdTestTask(@PathVariable("regionalManagerId") Long regionalManagerId,@PathVariable("crowdTestProjectCode") String crowdTestProjectCode,
+                                       @PathVariable("crowdTestTaskCode") String crowdTestTaskCode){
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        User user = userRepo.getByID(regionalManagerId);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.releaseCrowdTestTask(crowdTestTaskCode, user);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
+    }
+
+    /**
+     * 对测评机构的操作
+     */
+
+    /**
+     * 接收任务（测评机构）
+     * @param userForEvaluationAgencyId
+     * @param crowdTestProjectCode
+     * @param crowdTestTaskCode
+     * @return
+     */
+    @RequestMapping(value = "receiveTask/{userForEvaluationAgencyId}/{crowdTestProjectCode}/{crowdTestTaskCode}", method = RequestMethod.GET)
+    public String receiveTaskByProjectCode(@PathVariable("userForEvaluationAgencyId") Long userForEvaluationAgencyId, @PathVariable("crowdTestProjectCode") String crowdTestProjectCode,
+                                                    @PathVariable("crowdTestTaskCode") String crowdTestTaskCode) {
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+
+        User userForEvaluationAgency = userRepo.getByID(userForEvaluationAgencyId);
+//        CrowdTestProject crowdTestProjectResult = userForEvaluationAgency.receiveTask(crowdTestProject, crowdTestTaskCode);
+
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.receiveTask(crowdTestTaskCode, userForEvaluationAgency);
+
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
+    }
+
+    /**
+     * 项目的任务中新建报告（测评机构）
+     * @param crowdTestProjectCode
+     * @param reportName
+     * @return
+     */
+    @RequestMapping(value = "createReport/{userForEvaluationAgencyId}/{crowdTestProjectCode}/{crowdTestTaskCode}/{reportName}", method = RequestMethod.GET)
+    public String createCrowdTestReport(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode,@PathVariable("userForEvaluationAgencyId") Long userForEvaluationAgencyId,
+                                        @PathVariable("reportName") String reportName, @PathVariable("crowdTestTaskCode") String crowdTestTaskCode){
+
+
+        //report数据准备
+        CrowdTestReport crowdTestReport = new CrowdTestReport();
+        crowdTestReport.setCode(crowdTestTaskCode+"_REP"+System.currentTimeMillis());
+        crowdTestReport.setName(reportName);
+        crowdTestReport.setCreateTime(new Timestamp(System.currentTimeMillis()));
+
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        User userForEvaluationAgency = userRepo.getByID(userForEvaluationAgencyId);
+//        CrowdTestProject crowdTestProjectResult = userForEvaluationAgency.createCrowdTestReport(crowdTestProject, crowdTestTaskCode, crowdTestReport);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.createCrowdTestReport(crowdTestTaskCode, crowdTestReport, userForEvaluationAgency);
+
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
+    }
+
+    /**
+     * 提交任务（测评机构）
+     * @param crowdTestProjectCode
+     * @param userForEvaluationAgencyId
+     * @param crowdTestTaskCode
+     * @return
+     */
+    @RequestMapping(value = "commitTask/{userForEvaluationAgencyId}/{crowdTestProjectCode}/{crowdTestTaskCode}", method = RequestMethod.GET)
+    public String commitCrowdTestReport(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode,@PathVariable("userForEvaluationAgencyId") Long userForEvaluationAgencyId,
+                                        @PathVariable("crowdTestTaskCode") String crowdTestTaskCode){
+
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        User userForEvaluationAgency = userRepo.getByID(userForEvaluationAgencyId);
+//        CrowdTestProject crowdTestProjectResult = userForEvaluationAgency.commitCrowdTestTask(crowdTestProject, crowdTestTaskCode);
+
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.commitCrowdTestTask(crowdTestTaskCode, userForEvaluationAgency);
+
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
+    }
+
+    /**
+     * 区域管理员的操作
+     */
+
+
+    /**
+     * 确认结束任务（区域管理员）
+     * @param crowdTestProjectCode
+     * @return
+     */
+    @RequestMapping(value = "finishTask/{regionalManagerId}/{crowdTestProjectCode}/{crowdTestTaskCode}", method = RequestMethod.GET)
+    public String commitCrowdTestTask(@PathVariable("regionalManagerId") Long regionalManagerId,@PathVariable("crowdTestProjectCode") String crowdTestProjectCode,
+                                      @PathVariable("crowdTestTaskCode") String crowdTestTaskCode){
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        User user = userRepo.getByID(regionalManagerId);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.finishCrowdTestTask(crowdTestTaskCode,user);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
+    }
+
+    /**
+     * 创建项目报告（区域管理员）
+     * @param crowdTestProjectCode
+     * @return
+     */
+    @RequestMapping(value = "createProjectReport/{regionalManagerId}/{crowdTestProjectCode}/{projectReportName}", method = RequestMethod.GET)
+    public String createCrowdTestReport(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode,
+                                        @PathVariable("regionalManagerId") Long regionalManagerId,
+                                        @PathVariable("projectReportName") String projectReportName){
+
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+
+        //report数据准备
+        CrowdTestReport crowdTestReport = new CrowdTestReport();
+        crowdTestReport.setCode(crowdTestProjectCode+"_REP"+System.currentTimeMillis());
+        crowdTestReport.setName(projectReportName);
+        crowdTestReport.setDependencyCode(crowdTestProjectCode);
+        crowdTestReport.setCreateTime(new Timestamp(System.currentTimeMillis()));
+
+        User userForRegionalManager = userRepo.getByID(regionalManagerId);
+//        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
+//        CrowdTestProject crowdTestProjectResult = regionalManager.createCrowdTestProjectReport(crowdTestProject, crowdTestReport);
+
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.createCrowdTestProjectReport(crowdTestReport, userForRegionalManager);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
+    }
+
+    /**
+     * 提交项目（区域管理员）
+     * @param crowdTestProjectCode
+     * @return
+     */
+    @RequestMapping(value = "commitProject/{regionalManagerId}/{crowdTestProjectCode}", method = RequestMethod.GET)
+    public String commitProject(@PathVariable("regionalManagerId") Long regionalManagerId,@PathVariable("crowdTestProjectCode") String crowdTestProjectCode){
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        User userForRegionalManager = userRepo.getByID(regionalManagerId);
+//        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
+//        CrowdTestProject crowdTestProjectResult = regionalManager.commitCrowdTestProject(crowdTestProject);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.commitCrowdTestProject(userForRegionalManager);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
+    }
+
+    /**
+     * 对普通用户的操作
+     */
+
+    /**
+     * 结束项目（普通用户）
+     * @param crowdTestProjectCode
+     * @return
+     */
+    @RequestMapping(value = "finishProject/{userId}/{crowdTestProjectCode}", method = RequestMethod.GET)
+    public String finishProject(@PathVariable("userId") Long userId,@PathVariable("crowdTestProjectCode") String crowdTestProjectCode){
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        User user = userRepo.getByID(userId);
+//        CrowdTestProject crowdTestProjectResult = user.finishCrowdTestProject(crowdTestProject);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.finishCrowdTestProject(user);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
+    }
+
+
+    @RequestMapping(value = "getNum", method = RequestMethod.GET)
+    public String getNum(){
+        return "项目数：" + crowdTestProjectRepo.getAllProjectNum() + " 任务数：" + crowdTestProjectRepo.getAllTaskNum() + " 报告数：" + crowdTestProjectRepo.getAllReportNum() ;
+    }
+
+    /**
+     * 计算指定时间的后几天
+     */
+    private Date getNextDay(Date date, int day){
+        //计算相关的时间间隔
+        long addTime = 24*3600*1000;
+        addTime *= day;
+        //把时间间隔转换为毫秒数
+        Date nextDate=new Date(date.getTime() + addTime);
+        return nextDate;
+    }
+
+    /**
+     * 计算指定时间的前几天
+     */
+    private Date getBeforeDay(Date date, int day){
+        //计算相关的时间间隔
+        long subTime = 24*3600*1000;
+        subTime *= day;
+        //把时间间隔转换为毫秒数
+        Date beforeDate=new Date(date.getTime() - subTime);
+        return beforeDate;
+    }
+
+    /**
+     * 大陆手机号码11位数，匹配格式：前三位固定格式+后8位任意数
+     * 此方法中前三位格式有：
+     * 13+任意数
+     * 15+除4的任意数
+     * 18+除1和4的任意数
+     * 17+除9的任意数
+     * 147
+     */
+    private boolean isChinaPhoneLegal(String str) throws PatternSyntaxException {
+        String regExp = "^((13[0-9])|(15[^4])|(18[0,2,3,5-9])|(17[0-8])|(147))\\d{8}$";
+        Pattern p = Pattern.compile(regExp);
+        Matcher m = p.matcher(str);
+        return m.matches();
+    }
+
+    /**
+     * 香港手机号码8位数，5|6|8|9开头+7位任意数
+     */
+    private boolean isHKPhoneLegal(String str)throws PatternSyntaxException {
+        String regExp = "^(5|6|8|9)\\d{7}$";
+        Pattern p = Pattern.compile(regExp);
+        Matcher m = p.matcher(str);
+        return m.matches();
+    }
+
+    /**
+     * 座机号
+     */
+    private boolean isTel(String str)throws PatternSyntaxException {
+        String regExp = "^0[1-9](\\d{1,2}\\-?)\\d{7,8}";
+        Pattern p = Pattern.compile(regExp);
+        Matcher m = p.matcher(str);
+        return m.matches();
+    }
+
+    /**
+     * 判断手机号或者座机是正确
+     * @param phone
+     * @return
+     */
+    private boolean isRightPhone(String phone){
+        if(phone.startsWith("0")){
+            if(!isTel(phone)){
+                return false;
+            }
+        }else{
+            if(!(isChinaPhoneLegal(phone) || isHKPhoneLegal(phone))){
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * 匹配平台类型 0,1,2 任意  ^[0-2](([,][0-2])?([,][0-2])?)$
+     */
+    private boolean isPlatform(String str)throws PatternSyntaxException {
+        String regExp = "^[0-2](([,][0-2])?([,][0-2])?)$";
+        Pattern p = Pattern.compile(regExp);
+        Matcher m = p.matcher(str);
+        return m.matches();
+    }
+
+    /**
+     * 匹配项目类型 0,1,2,3,4,5,6 任意  ^[0-6](([,][0-6])?([,][0-6])?([,][0-6])?([,][0-6])?([,][0-6])?([,][0-6])?)$
+     */
+    private boolean isType(String str)throws PatternSyntaxException {
+        String regExp = "^[0-6](([,][0-6])?([,][0-6])?([,][0-6])?([,][0-6])?([,][0-6])?([,][0-6])?)$";
+        Pattern p = Pattern.compile(regExp);
+        Matcher m = p.matcher(str);
+        return m.matches();
+    }
+
+    @RequestMapping(value = "getAllNum", method = RequestMethod.GET)
+    public String getAllUserNum(){
+        return "用户数：" + userRepo.getAllUserNum() + " 测评机构数：" + userRepo.getAllAgencyNum() + " 测试资源数量：" + userRepo.getAllResourceNum() ;
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/dao/AgencyAbilityDao.java

@@ -0,0 +1,30 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.EvaluationAgencyAbilityPO;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface AgencyAbilityDao extends PagingAndSortingRepository<EvaluationAgencyAbilityPO, Long>, JpaSpecificationExecutor<EvaluationAgencyAbilityPO> {
+
+    Optional<EvaluationAgencyAbilityPO> findById(Long Id);
+
+    List<EvaluationAgencyAbilityPO> findByEvaluationAgencyIdAndIsDeleted(Long evaluationAgencyId, int isNotDeleted);
+
+    List<EvaluationAgencyAbilityPO> findAll();
+
+//    void deleteAll(List<EvaluationAgencyAbilityPO> evaluationAgencyAbilityPOList);
+
+    @Override
+    void deleteAll(Iterable<? extends EvaluationAgencyAbilityPO> iterable);
+
+    EvaluationAgencyAbilityPO save(EvaluationAgencyAbilityPO evaluationAgencyPO);
+
+//    List<EvaluationAgencyAbilityPO> saveAll(List<EvaluationAgencyAbilityPO> evaluationAgencyAbilityPOList);
+
+
+}

core/src/main/java/com/mooctest/crowd/domain/dao/AgencyResourceDao.java

@@ -0,0 +1,39 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.EvaluationAgencyResourcePO;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface AgencyResourceDao extends PagingAndSortingRepository<EvaluationAgencyResourcePO, Long>, JpaSpecificationExecutor<EvaluationAgencyResourcePO> {
+
+    Optional<EvaluationAgencyResourcePO> findById(Long Id);
+
+    List<EvaluationAgencyResourcePO> findByEvaluationAgencyIdAndIsDeleted(Long evaluationAgencyId, int isNotDeleted);
+
+//    List<EvaluationAgencyResourcePO> findByCountGreaterThanEqual(int professionalsFreeCount);
+
+    List<EvaluationAgencyResourcePO> findAll();
+
+    @Query(value = "SELECT SUM(p.totalNum) FROM EvaluationAgencyResourcePO p WHERE p.type = ?1")
+    Long getTotalResourceByType(String type);
+
+//    @Query(value = "SELECT SUM(p.totalNum) FROM EvaluationAgencyResourcePO p WHERE p.type = '服务器资源'")
+//    Long getTotalServerResource();
+//
+//    @Query(value = "SELECT SUM(p.totalNum) FROM EvaluationAgencyResourcePO p WHERE p.type = '服务器资源'")
+//    Long getTotalServerResource();
+
+    EvaluationAgencyResourcePO save(EvaluationAgencyResourcePO evaluationAgencyPO);
+
+//    List<EvaluationAgencyResourcePO> saveAll(List<EvaluationAgencyResourcePO> evaluationAgencyResourcePOList);
+
+    @Override
+    void deleteAll(Iterable<? extends EvaluationAgencyResourcePO> iterable);
+
+}

core/src/main/java/com/mooctest/crowd/domain/dao/CrowdTestProjectDao.java

@@ -0,0 +1,48 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.CrowdTestProjectPO;
+import com.mooctest.crowd.domain.model.RankInfo;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+
+/**
+ * @author guochao
+ * @date 2019-07-27 15:07
+ */
+
+@Transactional
+public interface CrowdTestProjectDao extends CrudRepository<CrowdTestProjectPO, Long> {
+
+//    @Override
+//    Optional<CrowdTestProjectPO> findById(Long id);
+
+    CrowdTestProjectPO findByIdAndIsDeleted(Long id, int isDeleted);
+
+    CrowdTestProjectPO findByCodeAndIsDeleted(String code, int isDeleted);
+
+    List<CrowdTestProjectPO> findByUserIdAndIsDeleted(Long userId, int isDeleted);
+
+    List<CrowdTestProjectPO> findAllByIsDeleted(int isDeleted);
+
+    List<CrowdTestProjectPO> findByRegionalManagerIdAndIsDeleted(Long regionalManagerId, int isDeleted);
+
+    List<CrowdTestProjectPO> findAllByStatusLessThanAndProjectDistributionTypeId(Integer status, Long distribution);
+
+    List<CrowdTestProjectPO> findByStatusLessThanAndProjectDistributionTypeId(Integer status, Long distributionType);
+
+    @Query(value = "SELECT new com.mooctest.crowd.domain.model.RankInfo(SUM(p.quotedPrice), p.userId) FROM CrowdTestProjectPO p where p.status>1 GROUP BY p.userId ORDER BY SUM(p.quotedPrice) DESC")
+    List<RankInfo> findTotalPriceOfUser(Pageable pageable);
+
+    @Override
+    void delete(CrowdTestProjectPO crowdTestProjectPO);
+
+    @Override
+    void deleteAll(Iterable<? extends CrowdTestProjectPO> iterable);
+
+    @Override
+    <S extends CrowdTestProjectPO> S save(S s);
+}

core/src/main/java/com/mooctest/crowd/domain/dao/CrowdTestReportDao.java

@@ -0,0 +1,33 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.CrowdTestReportPO;
+import org.springframework.data.repository.CrudRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+
+/**
+ * @author guochao
+ * @date 2019-07-27 15:07
+ */
+
+@Transactional
+public interface CrowdTestReportDao extends CrudRepository<CrowdTestReportPO, Long> {
+
+    CrowdTestReportPO findByIdAndIsDeleted(Long id, int isDeleted);
+
+    CrowdTestReportPO findByCodeAndIsDeleted(String code, int isDeleted);
+
+    List<CrowdTestReportPO> findByDependencyCodeAndIsDeleted(String dependencyCode, int isDeleted);
+
+    List<CrowdTestReportPO> findAllByIsDeleted(int isDeleted);
+
+    @Override
+    void delete(CrowdTestReportPO crowdTestProjectPO);
+
+    @Override
+    void deleteAll(Iterable<? extends CrowdTestReportPO> iterable);
+
+    @Override
+    <S extends CrowdTestReportPO> S save(S s);
+}

core/src/main/java/com/mooctest/crowd/domain/dao/CrowdTestTaskDao.java

@@ -0,0 +1,47 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.CrowdTestTaskPO;
+import com.mooctest.crowd.domain.model.RankInfo;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+
+/**
+ * @author guochao
+ * @date 2019-07-27 15:07
+ */
+
+@Transactional
+public interface CrowdTestTaskDao extends CrudRepository<CrowdTestTaskPO, Long> {
+
+    CrowdTestTaskPO findByIdAndIsDeleted(Long id, int isDeleted);
+
+    CrowdTestTaskPO findByCodeAndIsDeleted(String code, int isDeleted);
+
+    List<CrowdTestTaskPO> findByCrowdTestProjectCodeAndIsDeleted(String crowdTestProjectCode, int isDeleted);
+
+    List<CrowdTestTaskPO> findByEvaluationAgencyIdAndIsDeleted(Long evaluationAgencyId, int isDeleted);
+
+    List<CrowdTestTaskPO> findAllByIsDeleted(int isDeleted);
+
+    @Query(value = "SELECT new com.mooctest.crowd.domain.model.RankInfo(SUM(p.quotedPrice), p.evaluationAgencyId) FROM CrowdTestTaskPO p where p.evaluationAgencyId is not null and p.status>1 GROUP BY p.evaluationAgencyId ORDER BY SUM(p.quotedPrice) DESC")
+    List<RankInfo> findTotalPriceOfAgency(Pageable pageable);
+
+    @Query(nativeQuery = true, value = "select * from crowd_test_task where CTT_STATUS=1 and CTT_DISTRIBUTION_TYPE=2 order by CTT_QUOTED_PRICE DESC LIMIT 4")
+    List<CrowdTestTaskPO> findHotTask();
+
+    @Override
+    void delete(CrowdTestTaskPO crowdTestProjectPO);
+
+    @Override
+    void deleteAll(Iterable<? extends CrowdTestTaskPO> iterable);
+
+    @Override
+    <S extends CrowdTestTaskPO> S save(S s);
+
+    @Override
+    <S extends CrowdTestTaskPO> Iterable<S> saveAll(Iterable<S> iterable);
+}

core/src/main/java/com/mooctest/crowd/domain/dao/EnterpriseAuthenticationDao.java

@@ -0,0 +1,31 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.domainobject.EnterpriseAuthentication;
+import com.mooctest.crowd.domain.model.EnterpriseAuthenticationPO;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface EnterpriseAuthenticationDao extends PagingAndSortingRepository<EnterpriseAuthenticationPO, Long>, JpaSpecificationExecutor<EnterpriseAuthenticationPO> {
+
+    Optional<EnterpriseAuthenticationPO> findByIdAndIsDeleted(Long Id, int deletedStatus);
+
+    Optional<EnterpriseAuthenticationPO> findById(Long Id);
+
+    EnterpriseAuthenticationPO findByUserId(Long userId);
+
+    List<EnterpriseAuthenticationPO> findByIsAuthentication(Integer isAuthentication);
+
+    List<EnterpriseAuthenticationPO> findByIsAuthenticationIsNot(Integer isAuthentication);
+
+    EnterpriseAuthenticationPO findByUserIdAndIsDeleted(Long Id, int deletedStatus);
+
+    List<EnterpriseAuthenticationPO> findAll();
+
+    EnterpriseAuthenticationPO save(EnterpriseAuthenticationPO enterpriseAuthenticationPO);
+
+}

core/src/main/java/com/mooctest/crowd/domain/dao/EvaluationAgencyDao.java

@@ -0,0 +1,37 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.EvaluationAgencyPO;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface EvaluationAgencyDao extends PagingAndSortingRepository<EvaluationAgencyPO, Long>, JpaSpecificationExecutor<EvaluationAgencyPO> {
+
+    Optional<EvaluationAgencyPO> findById(Long Id);
+
+    EvaluationAgencyPO findByUserId(Long userId);
+
+    EvaluationAgencyPO findByUserIdAndIsDeleted(Long userId, int deletedStatus);
+
+    List<EvaluationAgencyPO> findByIsAuthentication(int isAuthentication);
+
+    List<EvaluationAgencyPO> findByIsAuthenticationIsNot(int isAuthentication);
+
+    @Override
+    Iterable<EvaluationAgencyPO> findAllById(Iterable<Long> iterable);
+
+    @Override
+    Iterable<EvaluationAgencyPO> findAll();
+
+    @Override
+    void delete(EvaluationAgencyPO evaluationAgencyPO);
+
+    void deleteAll(Iterable<? extends EvaluationAgencyPO> iterable);
+
+    EvaluationAgencyPO save(EvaluationAgencyPO evaluationAgencyPO);
+
+}

core/src/main/java/com/mooctest/crowd/domain/dao/PermissionDao.java

@@ -0,0 +1,18 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.PermissionPO;
+import org.springframework.data.repository.CrudRepository;
+
+import javax.transaction.Transactional;
+import java.util.Optional;
+
+@Transactional
+public interface PermissionDao extends CrudRepository<PermissionPO, Long>{
+
+    PermissionPO findByName(String name);
+
+    Optional<PermissionPO> findById(Long id);
+
+    @Override
+    <S extends PermissionPO> S save(S s);
+}

core/src/main/java/com/mooctest/crowd/domain/dao/PersonalAuthenticationDao.java

@@ -0,0 +1,31 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.domainobject.PersonalAuthentication;
+import com.mooctest.crowd.domain.model.PersonalAuthenticationPO;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface PersonalAuthenticationDao extends PagingAndSortingRepository<PersonalAuthenticationPO, Long>, JpaSpecificationExecutor<PersonalAuthenticationPO> {
+
+    Optional<PersonalAuthenticationPO> findById(Long Id);
+
+    Optional<PersonalAuthenticationPO> findByIdAndIsDeleted(Long Id, int deletedStatus);
+
+    PersonalAuthenticationPO findByUserId(Long userId);
+
+    PersonalAuthenticationPO findByUserIdAndIsDeleted(Long userId, int deletedStatus);
+
+    List<PersonalAuthenticationPO> findByIsAuthentication(Integer isAuthentication);
+
+    List<PersonalAuthenticationPO> findByIsAuthenticationIsNot(Integer isAuthentication);
+
+    List<PersonalAuthenticationPO> findAll();
+
+    PersonalAuthenticationPO save(PersonalAuthenticationPO personalAuthenticationPO);
+
+}

core/src/main/java/com/mooctest/crowd/domain/dao/RegionalDao.java

@@ -0,0 +1,30 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.RegionalPO;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import javax.transaction.Transactional;
+import java.util.Optional;
+
+@Transactional
+public interface RegionalDao extends PagingAndSortingRepository<RegionalPO, Long>, JpaSpecificationExecutor<RegionalPO> {
+
+    Optional<RegionalPO> findById(Long Id);
+
+//    RegionalPO findByProvince(String province);
+
+    @Override
+    Iterable<RegionalPO> findAllById(Iterable<Long> iterable);
+
+    @Override
+    Iterable<RegionalPO> findAll();
+
+    @Override
+    void delete(RegionalPO regionalPO);
+
+    void deleteAll(Iterable<? extends RegionalPO> iterable);
+
+    RegionalPO save(RegionalPO regionalPO);
+
+}

core/src/main/java/com/mooctest/crowd/domain/dao/RegionalManagerToRegionalDao.java

@@ -0,0 +1,33 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.RegionalManagerToRegionalPO;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface RegionalManagerToRegionalDao extends PagingAndSortingRepository<RegionalManagerToRegionalPO, Long>, JpaSpecificationExecutor<RegionalManagerToRegionalPO> {
+
+    Optional<RegionalManagerToRegionalPO> findById(Long Id);
+
+    List<RegionalManagerToRegionalPO> findByUserId(Long userId);
+
+    List<RegionalManagerToRegionalPO> findByUserIdAndIsDeleted(Long userId, int deletedStatus);
+
+    @Override
+    Iterable<RegionalManagerToRegionalPO> findAllById(Iterable<Long> iterable);
+
+    @Override
+    Iterable<RegionalManagerToRegionalPO> findAll();
+
+    @Override
+    void delete(RegionalManagerToRegionalPO regionalManagerToRegionalPO);
+
+    void deleteAll(Iterable<? extends RegionalManagerToRegionalPO> iterable);
+
+    RegionalManagerToRegionalPO save(RegionalManagerToRegionalPO regionalManagerToRegionalPO);
+
+}

core/src/main/java/com/mooctest/crowd/domain/dao/RoleDao.java

@@ -0,0 +1,16 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.RolePO;
+import org.springframework.data.repository.CrudRepository;
+
+import javax.transaction.Transactional;
+import java.util.Optional;
+
+@Transactional
+public interface RoleDao extends CrudRepository<RolePO, Long>{
+
+    RolePO findByName(String name);
+
+    Optional<RolePO> findById(Long id);
+
+}

core/src/main/java/com/mooctest/crowd/domain/dao/RoleToPermissionDao.java

@@ -0,0 +1,23 @@
+package com.mooctest.crowd.domain.dao;
+
+
+import com.mooctest.crowd.domain.model.RoleToPermissionPO;
+import org.springframework.data.repository.CrudRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface RoleToPermissionDao extends CrudRepository<RoleToPermissionPO,Long> {
+
+    @Override
+    Optional<RoleToPermissionPO> findById(Long id);
+
+    List<RoleToPermissionPO> findAllByRoleId(Long roleId);
+
+    List<RoleToPermissionPO> findAllByPermissionId(Long permissionId);
+
+    @Override
+    <S extends RoleToPermissionPO> S save(S s);
+}

core/src/main/java/com/mooctest/crowd/domain/dao/SystemAdministratorToUserDao.java

@@ -0,0 +1,18 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.SystemAdministratorToUserPO;
+import org.springframework.data.repository.CrudRepository;
+
+/**
+ * @author guochao
+ * @date 2019-08-24 09:42
+ */
+public interface SystemAdministratorToUserDao extends CrudRepository<SystemAdministratorToUserPO, Long> {
+
+    SystemAdministratorToUserPO findByIdAndIsDeleted(Long Long, int isNotDeleted);
+
+    SystemAdministratorToUserPO findByUserIdAndIsDeleted(Long id, int isNotDeleted);
+
+    @Override
+    <S extends SystemAdministratorToUserPO> S save(S s);
+}

core/src/main/java/com/mooctest/crowd/domain/dao/UserDao.java

@@ -1,21 +1,32 @@
 package com.mooctest.crowd.domain.dao;
 
-import com.mooctest.crowd.domain.model.User;
-import org.springframework.data.repository.CrudRepository;
+import com.mooctest.crowd.domain.model.UserPO;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.repository.PagingAndSortingRepository;
 
 import javax.transaction.Transactional;
+import java.util.Optional;
 
 @Transactional
-public interface UserDao extends CrudRepository<User,Long> {
+public interface UserDao extends PagingAndSortingRepository<UserPO, Long>, JpaSpecificationExecutor<UserPO> {
 
-//    @Query("SELECT u FROM User u WHERE u.U_MOBILE = :mobile")
-//    User findByMobile(@Param("mobile") String mobile);
+    UserPO findByMobile(String mobile);
 
-    User findByMobile(String mobile);
+    Optional<UserPO> findById(Long userId);
 
     @Override
-    long count();
+    Iterable<UserPO> findAllById(Iterable<Long> iterable);
+
+    @Override
+    Iterable<UserPO> findAll();
+
+    @Override
+    void delete(UserPO userPO);
+
+    void deleteAll(Iterable<? extends UserPO> iterable);
+
+    UserPO save(UserPO userPo);
 
     @Override
-    User save(User user);
+    long count();
 }

core/src/main/java/com/mooctest/crowd/domain/dao/UserToRoleDao.java

@@ -0,0 +1,21 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.UserToRolePO;
+import org.springframework.data.repository.CrudRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface UserToRoleDao extends CrudRepository<UserToRolePO,Long> {
+
+    @Override
+    Optional<UserToRolePO> findById(Long id);
+
+    List<UserToRolePO> findByUserId(Long userId);
+
+    List<UserToRolePO> findByRoleId(Long roleId);
+
+    UserToRolePO save(UserToRolePO userToRolePO);
+}

core/src/main/java/com/mooctest/crowd/domain/domainobject/AuthenticationStatus.java

@@ -0,0 +1,11 @@
+package com.mooctest.crowd.domain.domainobject;
+
+/**
+ * @author guochao
+ * @date 2019/7/9 14:21
+ */
+public class AuthenticationStatus {
+    public static final int isNotAuthenticated = -1; //未通过认证
+    public static final int isAuthenIng = 0;         //审核中
+    public static final int isAuthenticated = 1;     //已认证
+}

core/src/main/java/com/mooctest/crowd/domain/domainobject/CrowdTestProject.java

@@ -1,14 +1,13 @@
 package com.mooctest.crowd.domain.domainobject;
 
-import com.mooctest.crowd.domain.exception.CrowdTestProjectNotExistException;
-import com.mooctest.crowd.domain.exception.CrowdTestReportNotExistException;
-import com.mooctest.crowd.domain.exception.CrowdTestTaskNoPriceException;
-import com.mooctest.crowd.domain.exception.CrowdTestTaskNotExistException;
-import com.mooctest.crowd.domain.repository.CrowdTestProjectRepo;
+import com.google.gson.Gson;
+import com.mooctest.crowd.domain.exception.*;
 import lombok.Data;
 
 import java.sql.Timestamp;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 
 /**
  * @author guochao
@@ -19,143 +18,670 @@ public class CrowdTestProject {
 
     private Long id;
     private String name;
+    private String code;
     private Long userId;
     private Long regionalManagerId;
-    private ProjectDistributeType projectDistributeType;
+    private Long projectDistributionTypeId;
+    private String platform;
+    private String linkMan;
+    private String linkManMobile;
+    private String type;
     private String description;
     private String projectFile;
     private String requirementFile;
-    private double quotedPrice;
-    private double fixedPrice;
-    private String status;
-    private Timestamp creatTime;
+    private String distributionProvince;
+    private String distributionCity;
+    private Double quotedPrice;
+    private Double fixedPrice;
+    private int status;
+    private Timestamp deadTime;
+    private Timestamp endTime;
+    private int isDeleted;
+    private Timestamp createTime;
+
     private List<CrowdTestTask> crowdTestTaskList;
+    private CrowdTestReport crowdTestReportForProject;
 
     @Override
     public String toString() {
         return "CrowdTestProject{" +
                 "id=" + id +
                 ", name='" + name + '\'' +
+                ", code='" + code + '\'' +
                 ", userId=" + userId +
                 ", regionalManagerId=" + regionalManagerId +
-                ", projectDistributeType=" + projectDistributeType +
+                ", projectDistributionTypeId=" + projectDistributionTypeId +
+                ", platform='" + platform + '\'' +
+                ", linkMan='" + linkMan + '\'' +
+                ", linkManMobile='" + linkManMobile + '\'' +
+                ", type='" + type + '\'' +
                 ", description='" + description + '\'' +
-                ", projectFile=" + projectFile +
-                ", requirementFile=" + requirementFile +
+                ", projectFile='" + projectFile + '\'' +
+                ", requirementFile='" + requirementFile + '\'' +
+                ", distributionProvince='" + distributionProvince + '\'' +
+                ", distributionCity='" + distributionCity + '\'' +
                 ", quotedPrice=" + quotedPrice +
                 ", fixedPrice=" + fixedPrice +
-                ", status='" + status + '\'' +
-                ", creatTime=" + creatTime +
+                ", status=" + status +
+                ", deadTime=" + deadTime +
+                ", endTime=" + endTime +
+                ", isDeleted=" + isDeleted +
+                ", createTime=" + createTime +
                 ", crowdTestTaskList=" + crowdTestTaskList +
+                ", crowdTestReportForProject=" + crowdTestReportForProject +
                 '}';
     }
 
-    public CrowdTestTask getCrowdTestTaskByTaskId(CrowdTestProject crowdTestProject, Long taskId) throws CrowdTestTaskNotExistException {
-        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
-        for (CrowdTestTask crowdTestTask : crowdTestTaskList) {
-            if (crowdTestTask.getId().equals(taskId)) {
-                return crowdTestTask;
+    /**
+     * 更新项目信息
+     * @param crowdTestProjectModify
+     * @return
+     */
+    public CrowdTestProject updateCrowdTestProject( CrowdTestProject crowdTestProjectModify){
+        Gson gson = new Gson();
+        return gson.fromJson(gson.toJson(crowdTestProjectModify),CrowdTestProject.class);
+    }
+
+    /**
+     * 更新项目中的指定任务信息
+     * @param crowdTestTaskCode
+     * @param crowdTestTaskModify
+     * @return
+     */
+    public CrowdTestProject updateCrowdTestTask(String crowdTestTaskCode, CrowdTestTask crowdTestTaskModify){
+        List<CrowdTestTask> crowdTestTaskListNew = new ArrayList<>();
+        List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
+        for(CrowdTestTask crowdTestTaskSelect : crowdTestTaskList){
+            List<CrowdTestReport> crowdTestReportList = crowdTestTaskSelect.getCrowdTestReportList();
+            if(crowdTestTaskCode.equals(crowdTestTaskSelect.getCode())){
+                Gson gson = new Gson();
+                crowdTestTaskSelect = gson.fromJson(gson.toJson(crowdTestTaskModify), CrowdTestTask.class);
             }
+            crowdTestTaskSelect.setCrowdTestReportList(crowdTestReportList);
+            crowdTestTaskListNew.add(crowdTestTaskSelect);
         }
-        throw new CrowdTestTaskNotExistException();
+        this.setCrowdTestTaskList(crowdTestTaskListNew);
+        return this;
     }
 
-    public CrowdTestProject updateCrowdTestReportStatus(Long projectId, Long taskId, Long reportId, String status) throws CrowdTestTaskNoPriceException, CrowdTestTaskNotExistException, CrowdTestProjectNotExistException, CrowdTestReportNotExistException {
-        CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
-        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(projectId);
-        CrowdTestTask crowdTestTask = crowdTestProject.getCrowdTestTaskByTaskId(crowdTestProject, taskId);
-        CrowdTestReport crowdTestReport = crowdTestTask.getCrowdTestReportByReportId(crowdTestTask, reportId);
-        crowdTestReport.setStatus(status);
-        return crowdTestProject;
+    /**
+     * 更新项目中任务的指定报告信息
+     * @param crowdTestTaskCode
+     * @param crowdTestReportCode
+     * @param crowdTestReportModify
+     * @return
+     */
+    public CrowdTestProject updateCrowdTestReport( String crowdTestTaskCode, String crowdTestReportCode, CrowdTestReport crowdTestReportModify) {
+        List<CrowdTestTask> crowdTestTaskListNew = new ArrayList<>();
+        List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
+        for(CrowdTestTask crowdTestTaskSelect : crowdTestTaskList){
+            List<CrowdTestReport> crowdTestReportListNew = new ArrayList<>();
+            if(crowdTestTaskCode.equals(crowdTestTaskSelect.getCode())){
+                List<CrowdTestReport> crowdTestReportList = crowdTestTaskSelect.getCrowdTestReportList();
+                for(CrowdTestReport crowdTestReportSelect : crowdTestReportList){
+                    if(crowdTestReportCode.equals(crowdTestReportSelect.getCode())){
+                        Gson gson = new Gson();
+                        crowdTestReportSelect = gson.fromJson(gson.toJson(crowdTestReportModify), CrowdTestReport.class);
+                    }
+                    crowdTestReportListNew.add(crowdTestReportSelect);
+                }
+            }
+            crowdTestTaskSelect.setCrowdTestReportList(crowdTestReportListNew);
+            crowdTestTaskListNew.add(crowdTestTaskSelect);
+        }
+        this.setCrowdTestTaskList(crowdTestTaskListNew);
+        return this;
     }
 
-    /** Task */
+    /**
+     * 逻辑删除项目（项目发布者）
+     * @return
+     */
+    public CrowdTestProject removeCrowdTestProject(User user) {
+        //判断用户是否认证
+        if(user.getPersonalAuthentication() == null && user.getEnterpriseAuthentication() == null && user.getRegionalManager() == null && user.getEvaluationAgency() == null){
+            throw new CrowdTestProjectException("当前用户未进行认证，无权限对项目操作");
+        }
+        //判断用户是否为项目发起者
+        if(!this.getUserId().equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户无权限发布此项目");
+        }
+
+        this.getCrowdTestTaskList()
+                .stream().forEach(crowdTestTask -> crowdTestTask.removeCrowdTestTask());
+        this.getCrowdTestTaskList()
+                .stream().forEach(crowdTestTask -> crowdTestTask.getCrowdTestReportList().stream().forEach(crowdTestReport -> crowdTestReport.removeCrowdTestReport()));
 
-    public boolean updateCrowdTestTaskStatus(Long projectId, Long taskId, String status) throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException {
-        CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
-        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(projectId);
-        CrowdTestTask crowdTestTask = crowdTestProject.getCrowdTestTaskByTaskId(crowdTestProject, taskId);
-        boolean flag = true;
-        if (crowdTestTask.getPrice() > 0) {
-            crowdTestTask.setStatus(status);
-            return true;
-        } else {
-            throw new CrowdTestTaskNoPriceException();
+        CrowdTestReport crowdTestReportForProject = this.getCrowdTestReportForProject();
+        if(crowdTestReportForProject != null){
+            crowdTestReportForProject.removeCrowdTestReport();
         }
+        this.setIsDeleted(DeletedStatus.isDeleted);
+        return this;
     }
 
-    public boolean modifyCrowdTestTaskStatusToCommit(Long taskId, String status) throws CrowdTestTaskNotExistException {
-        CrowdTestTask crowdTestTask = this.getCrowdTestTaskByTaskId(this, taskId);
-        boolean flag = true;
-        List<CrowdTestReport> crowdTestReportList = crowdTestTask.getCrowdTestReportList();
-        for (CrowdTestReport crowdTestReport : crowdTestReportList) {
-            if (!crowdTestReport.getStatus().equals(CrowdTestReportStatus.COMMITED)) {
-                flag = false;
+    /**
+     * 逻辑删除任务（区域管理员）
+     * @param crowdTestTaskCode
+     * @return
+     */
+    public CrowdTestProject removeCrowdTestTask(String crowdTestTaskCode, User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限对任务进行操作");
+        }
+
+        //判断是否是当前项目的区域管理员
+        if(!this.getRegionalManagerId().equals(user.getId())){
+            throw new CrowdTestTaskException("当前用户没有权限删除此测试任务！");
+        }
+
+        Optional<CrowdTestTask> task = this.getCrowdTestTaskList()
+                .stream().filter(crowdTestTask -> crowdTestTask.getCode().equals(crowdTestTaskCode)).findFirst();
+        if(!task.isPresent()){
+            throw new CrowdTestTaskException("当前项目下没有此测试任务！");
+        }else{
+            task.get().removeCrowdTestTask();
+            task.get().getCrowdTestReportList().stream().forEach(crowdTestReport -> crowdTestReport.removeCrowdTestReport());
+        }
+        return this;
+    }
+
+    /**
+     * 逻辑删除报告（测评机构）
+     * @param crowdTestTaskCode
+     * @param crowdTestReportCode
+     * @return
+     */
+    public CrowdTestProject removeCrowdTestReport(String crowdTestTaskCode, String crowdTestReportCode, User user) {
+
+        //判断是否为测评机构
+        EvaluationAgency evaluationAgency = user.getEvaluationAgency();
+        if(evaluationAgency == null){
+            throw new UserNotExistException("当前用户不是测评机构，没有权限操作测试报告");
+        }
+
+        Optional<CrowdTestTask> task = this.getCrowdTestTaskList()
+                .stream().filter(crowdTestTask -> crowdTestTask.getCode().equals(crowdTestTaskCode)).findFirst();
+        if(!task.isPresent()){
+            throw new CrowdTestTaskException("当前项目下没有此测试任务！");
+        }else{
+            //判断是否是当前任务的测评机构
+            if(!task.get().getEvaluationAgencyId().equals(user.getId())){
+                throw new CrowdTestTaskException("当前用户没有权限删除此任务的测试报告！");
+            }else{
+                Optional<CrowdTestReport> report = task.get().getCrowdTestReportList()
+                        .stream().filter(crowdTestReport -> crowdTestReport.getCode().equals(crowdTestReportCode)).findFirst();
+                if(!report.isPresent()){
+                    throw new CrowdTestReportException("当前任务下没有此测试报告！");
+                }else{
+                    report.get().removeCrowdTestReport();
+                }
             }
         }
-        if (flag) {
-            crowdTestTask.setStatus(status);
-            return true;
-        } else {
-            return flag;
-        }
-    }
-
-    public boolean updateCrowdTestTaskStatusNoPrice(Long projectId, Long taskId, String status) throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException {
-        CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
-        if (crowdTestProjectRepo.getByID(projectId) != null) {
-            CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(projectId);
-            CrowdTestTask crowdTestTask = crowdTestProject.getCrowdTestTaskByTaskId(crowdTestProject, taskId);
-            crowdTestTask.setPrice(0.0);
-            if (crowdTestTask.getPrice() > 0) {
-                crowdTestTask.setStatus(status);
-                return true;
-            } else {
-                throw new CrowdTestTaskNoPriceException();
+        return this;
+    }
+
+
+    /**
+     * 删除项目报告（区域管理员）
+     * @return
+     */
+    public CrowdTestProject removeCrowdTestProjectReport(String crowdTestProjectReportCode,User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限对项目进行操作");
+        }
+
+        //判断是否是当前项目的区域管理员
+        if(!this.getRegionalManagerId().equals(user.getId())){
+            throw new CrowdTestTaskException("当前用户没有权限删除此测试任务！");
+        }
+
+        CrowdTestReport crowdTestReportForProject = this.getCrowdTestReportForProject();
+        if(crowdTestReportForProject == null){
+            throw new CrowdTestProjectException("当前项目下没有项目报告！");
+        }else if(!crowdTestProjectReportCode.equals(crowdTestReportForProject.getCode())){
+            throw new CrowdTestProjectException("当前项目下没有此项目报告！");
+        }else{
+            crowdTestReportForProject.setIsDeleted(DeletedStatus.isDeleted);
+        }
+        return this;
+    }
+
+    public void addTask(CrowdTestTask task){
+        if (!(this.getStatus() >= CrowdTestProjectStatus.HAS_RECEIVED || this.getStatus()<=CrowdTestTaskStatus.HAS_COMMITED))
+            throw new BaseException("当前阶段不允许创建新任务");
+        this.getCrowdTestTaskList().add(task);
+    }
+
+    public CrowdTestTask getTask(String taskCode){
+        Optional<CrowdTestTask> testTask = this.getCrowdTestTaskList().stream().filter(crowdTestTask -> crowdTestTask.getCode().equals(taskCode)).findFirst();
+        if (!testTask.isPresent())
+            throw new CrowdTestTaskNotExistException();
+        return testTask.get();
+    }
+
+    public CrowdTestReport getTaskReport(String taskCode, String reportCode){
+        Optional<CrowdTestReport> report = getTask(taskCode).getCrowdTestReportList().stream().filter(crowdTestReport -> crowdTestReport.getCode().equals(reportCode)).findFirst();
+        if (!report.isPresent())
+            throw new CrowdTestReportNotExistException();
+        return report.get();
+    }
+
+    /**
+     * 创建测试项目（普通用户）
+     * @return
+     */
+    public CrowdTestProject createCrowdTestProject(User user) {
+//        //判断用户是否认证
+//        if(user.getPersonalAuthentication() == null && user.getEnterpriseAuthentication() == null && user.getRegionalManager() == null && user.getEvaluationAgency() == null){
+//            throw new CrowdTestProjectException("当前用户未进行认证，无权限对项目操作");
+//        }
+        //增加设置项目code ---------需要补上
+//        String projectCode = GenerateFlowCodeUtil.generateFlowCode("PROJ");
+//        this.setCode(projectCode);
+
+        this.setStatus(CrowdTestProjectStatus.HAS_CREATED);
+        this.setCreateTime(new Timestamp(System.currentTimeMillis()));
+        return this;
+    }
+
+    /**
+     * 发布项目（普通用户）
+     * @return
+     */
+    public CrowdTestProject releaseCrowdTestProject(User user) {
+        //判断用户是否认证
+        if(user.getPersonalAuthentication() == null && user.getEnterpriseAuthentication() == null && user.getRegionalManager() == null && user.getEvaluationAgency() == null){
+            throw new CrowdTestProjectException("当前用户未进行认证，无权限对项目操作");
+        }
+        //判断用户是否为项目发起者
+        if(!this.getUserId().equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户无权限发布此项目");
+        }
+
+        //判断项目状态
+        if(this.status != (CrowdTestProjectStatus.HAS_RELEASED-1)){
+            throw new CrowdTestProjectException("当前项目状态不能被发布，当前状态为："+this.getStatus());
+        }else{
+            this.setStatus(CrowdTestProjectStatus.HAS_RELEASED);
+        }
+        return this;
+    }
+
+    /**
+     * 接收项目（区域管理员）
+     * @return
+     */
+    public CrowdTestProject receiveProject(User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限接收项目");
+        }
+
+        //判断项目状态
+        if(this.getStatus() != CrowdTestProjectStatus.HAS_RELEASED){
+            throw new CrowdTestProjectException("项目不能被接收，项目状态为: " + this.getStatus());
+        }else{
+            //项目是定向发布
+            if(this.getProjectDistributionTypeId() == 0){
+                if(!this.getRegionalManagerId().equals(user.getId())){
+                    throw new CrowdTestProjectException("当前用户没有权限接收此定向发布的项目！");
+                }else{
+                    this.setStatus(CrowdTestProjectStatus.HAS_RECEIVED);
+                }
+            }
+            //项目是区域发布
+            else if(this.getProjectDistributionTypeId() == 1){
+                List<RegionalManagerToRegional> regionalList = regionalManager.getRegionalList();
+                boolean isValidCity = false;
+                //判断管理员管辖的区域是否符合要求
+                for(RegionalManagerToRegional regional : regionalList){
+                    //判断市是否相同
+                    if(this.getDistributionCity().equals(regional.getCity())){
+                        isValidCity = true;
+                    }
+                    //如果市区是"*",则判断省份是否相同
+                    if(regional.getCity().equals("*")){
+                        if(this.getDistributionProvince().equals(regional.getProvince())){
+                            isValidCity = true;
+                        }
+                    }
+                }
+
+                if(!isValidCity){
+                    throw new CrowdTestProjectException("项目发布的区域不符合当前区域管理员所管辖的区域！");
+                }else{
+                    this.setRegionalManagerId(user.getId());
+                    this.setStatus(CrowdTestProjectStatus.HAS_RECEIVED);
+                }
+            }
+            //项目是广场发布
+            else{
+                this.setRegionalManagerId(user.getId());
+                this.setStatus(CrowdTestProjectStatus.HAS_RECEIVED);
             }
         }
-        throw new CrowdTestProjectNotExistException();
+        return this;
     }
 
-    public List<CrowdTestTask> updateCrowdTestTaskListStatus(Long projectId, String status) throws CrowdTestProjectNotExistException {
-        CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
-        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(projectId);
-        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
-        for (CrowdTestTask crowdTestTask : crowdTestTaskList) {
-            crowdTestTask.setStatus(status);
+    /**
+     * 创建测试任务（区域管理员）
+     * @param crowdTestTask
+     * @return
+     */
+    public CrowdTestProject createCrowdTestTask(CrowdTestTask crowdTestTask, User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限创建测试任务");
+        }
+
+        //判断是否是当前项目的区域管理员
+        if(!this.getRegionalManagerId().equals(user.getId())){
+            throw new CrowdTestTaskException("当前用户没有权限为此项目创建测试任务！");
+        }else{
+            //判断项目状态
+            if(this.getStatus() != (CrowdTestProjectStatus.HAS_COMMITED-1)){
+                throw new CrowdTestProjectException("当前项目状态不能创建任务，项目状态为: " + this.getStatus());
+            }else{
+                List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
+//            //增加设置任务code -------需要加上
+//            String taskCode = GenerateFlowCodeUtil.generateFlowCode("TASK-"+ command.getType());
+//            crowdTestTask.setCode(taskCode);
+
+                crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_CREATED);
+                //添加测试任务
+                crowdTestTaskList.add(crowdTestTask);
+                this.setCrowdTestTaskList(crowdTestTaskList);
+            }
         }
-        return crowdTestTaskList;
+        return this;
     }
 
+    /**
+     * 发布任务（区域管理员）
+     * @param crowdTestTaskCode
+     * @return
+     */
+    public CrowdTestProject releaseCrowdTestTask(String crowdTestTaskCode, User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限发布测试任务");
+        }
 
-    /** Project */
-    public CrowdTestReport getCrowdTestReportByProjectId(Long projectId, Long taskId, Long reportId) throws CrowdTestTaskNoPriceException, CrowdTestTaskNotExistException, CrowdTestProjectNotExistException, CrowdTestReportNotExistException {
-        CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
-        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(projectId);
-        CrowdTestTask crowdTestTask = crowdTestProject.getCrowdTestTaskByTaskId(crowdTestProject, taskId);
-        CrowdTestReport crowdTestReport = crowdTestTask.getCrowdTestReportByReportId(crowdTestTask, reportId);
-        return crowdTestReport;
+        //判断是否是当前项目的区域管理员
+        if(!this.regionalManagerId.equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户没有权限发布的当前项目下的任务！");
+        }else {
+            List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
+            List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
+            //发布任务时修改任务状态
+            for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+                if(crowdTestTaskCode.equals(crowdTestTask.getCode())){
+                    if(crowdTestTask.getStatus() != (CrowdTestTaskStatus.HAS_RELEASED-1)){
+                        throw new CrowdTestTaskException("当前任务不能被发布，当前任务状态为："+crowdTestTask.getStatus());
+                    }else{
+                        crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_RELEASED);
+                    }
+                }
+                crowdTestTaskListResult.add(crowdTestTask);
+            }
+            this.setCrowdTestTaskList(crowdTestTaskListResult);
+            return this;
+        }
     }
 
-    public List<CrowdTestReport> getCrowdTestReportListByProjectId(Long projectId, Long taskId) throws CrowdTestTaskNoPriceException, CrowdTestTaskNotExistException, CrowdTestProjectNotExistException, CrowdTestReportNotExistException {
-        CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
-        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(projectId);
-        CrowdTestTask crowdTestTask = crowdTestProject.getCrowdTestTaskByTaskId(crowdTestProject, taskId);
-        return crowdTestTask.getCrowdTestReportList();
+    /**
+     * 接收任务（测评机构）
+     * @return
+     */
+    public CrowdTestProject receiveTask(String crowdTestTaskCode, User user) {
+        //判断是否为测评机构
+        EvaluationAgency evaluationAgency = user.getEvaluationAgency();
+        if(evaluationAgency == null){
+            throw new UnauthorizedException("当前用户不是测评机构，没有权限接收任务");
+        }
+        Optional<CrowdTestTask> taskOp = this.getCrowdTestTaskList().stream().filter(task -> task.getCode().equals(crowdTestTaskCode)).findFirst();
+        //任务是否不存在
+        if (!taskOp.isPresent())
+            throw new CrowdTestTaskNotExistException();
+        CrowdTestTask task = taskOp.get();
+        //任务当前状态
+        if (task.getStatus()!=CrowdTestTaskStatus.HAS_RELEASED)
+            throw new CrowdTestTaskException("任务当前状态不能被接收，当前状态为："+task.getStatus());
+        //定向发布类型
+        if (task.getDistributionType() == 0) {
+            if (!task.getEvaluationAgencyId().equals(user.getId()))
+                throw new CrowdTestTaskException("当前用户没有权限接收此定向发布的任务！");
+        }
+        task.setEvaluationAgencyId(user.getId());
+        task.setStatus(CrowdTestTaskStatus.HAS_RECEIVED);
+        return this;
+    }
+
+
+
+    /**
+     * 创建测试报告（测评机构）
+     * @param crowdTestTaskCode
+     * @param crowdTestReport
+     * @return
+     */
+    public CrowdTestProject createCrowdTestReport(String crowdTestTaskCode, CrowdTestReport crowdTestReport, User user) {
+        //判断是否为测评机构
+        EvaluationAgency evaluationAgency = user.getEvaluationAgency();
+        if(evaluationAgency == null){
+            throw new UserNotExistException("当前用户不是测评机构，没有权限创建测试报告");
+        }
+        List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
+        List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
+        for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+            if(crowdTestTask.getCode().equals(crowdTestTaskCode)){
+                //判断是否是当前任务的测评机构
+                if(!crowdTestTask.getEvaluationAgencyId().equals(user.getId())){
+                    throw new CrowdTestTaskException("当前用户没有权限创建任务测试报告！");
+                }else{
+                    if(crowdTestTask.getStatus() != (CrowdTestTaskStatus.HAS_COMMITED-1)){
+                        throw new CrowdTestTaskException("当前任务无法创建测试报告，任务状态为："+crowdTestTask.getStatus());
+                    }else{
+                        //设置报告code ----------需要添加
+//                        String reportCode = GenerateFlowCodeUtil.generateFlowCode("REPORT");
+//                        crowdTestReport.setCode(reportCode);
+
+                        crowdTestReport.setScope(1);
+                        crowdTestReport.setDependencyCode(crowdTestTaskCode);
+                        List<CrowdTestReport> crowdTestReportList = crowdTestTask.getCrowdTestReportList();
+                        crowdTestReportList.add(crowdTestReport);
+                        crowdTestTask.setCrowdTestReportList(crowdTestReportList);
+                        crowdTestTaskListResult.add(crowdTestTask);
+                    }
+                }
+            }
+        }
+        this.setCrowdTestTaskList(crowdTestTaskListResult);
+        return this;
     }
 
-    public CrowdTestProject updateCrowdTestProjectStatusToFinish(Long projectId, String status) throws CrowdTestProjectNotExistException {
-        CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
-        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(projectId);
-        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
+    /**
+     * 提交测试任务（测评机构）
+     * @param crowdTestTaskCode
+     * @return
+     */
+    public CrowdTestProject commitCrowdTestTask(String crowdTestTaskCode, User user) {
+        //判断是否为测评机构
+        EvaluationAgency evaluationAgency = user.getEvaluationAgency();
+        if(evaluationAgency == null){
+            throw new UserNotExistException("当前用户不是测评机构，没有权限提交测试任务");
+        }
+
+        List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
+        List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
         for(CrowdTestTask crowdTestTask : crowdTestTaskList){
-            List<CrowdTestReport> crowdTestReportList = crowdTestTask.getCrowdTestReportList();
-            for(CrowdTestReport crowdTestReport : crowdTestReportList){
-                crowdTestReport.setStatus(status);
+            if(crowdTestTask.getCode().equals(crowdTestTaskCode)){
+                //判断是否是当前任务的测评机构
+                if(!crowdTestTask.getEvaluationAgencyId().equals(user.getId())){
+                    throw new CrowdTestTaskException("当前用户没有权限提交任务！");
+                }else{
+                    if(crowdTestTask.getCrowdTestReportList().size() == 0){
+                        throw new CrowdTestTaskException("当前任务中没有报告，不能提交此任务");
+                    }
+                    if(crowdTestTask.getStatus() != (CrowdTestTaskStatus.HAS_COMMITED-1)){
+                        throw new CrowdTestTaskException("当前任务无法提交，任务状态为："+crowdTestTask.getStatus());
+                    }else{
+                        crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_COMMITED);
+                    }
+                }
+            }
+            crowdTestTaskListResult.add(crowdTestTask);
+        }
+        this.setCrowdTestTaskList(crowdTestTaskListResult);
+        return this;
+    }
+
+    /**
+     * 结束任务（区域管理员）
+     * @return
+     */
+    public CrowdTestProject finishCrowdTestTask(String crowdTestTaskCode, User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限结束测试任务");
+        }
+
+        //判断是否是当前项目的区域管理员
+        if(!this.regionalManagerId.equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户没有权限结束当前项目下的任务！");
+        }
+
+        //项目状态判断
+        if(this.getStatus() != (CrowdTestProjectStatus.HAS_COMMITED-1)){
+            throw new CrowdTestProjectException("当前项目状态不可结束任务！");
+        }else {
+            List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
+            List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
+
+            for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+                if(crowdTestTaskCode.equals(crowdTestTask.getCode())){
+                    if(crowdTestTask.getStatus() != (CrowdTestTaskStatus.HAS_FINISHED-1)){
+                        throw new CrowdTestTaskException("当前任务不能被结束，任务状态为："+crowdTestTask.getStatus());
+                    }else{
+                        //结束任务时修改任务状态为"已结束"
+                        crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_FINISHED);
+                        crowdTestTask.setEndTime(new Timestamp(System.currentTimeMillis()));
+                    }
+                }
+                crowdTestTaskListResult.add(crowdTestTask);
+            }
+
+            this.setCrowdTestTaskList(crowdTestTaskListResult);
+        }
+
+
+        return this;
+    }
+
+    /**
+     * 创建项目报告（区域管理员）
+     * @param crowdTestReport
+     * @return
+     */
+    public CrowdTestProject createCrowdTestProjectReport(CrowdTestReport crowdTestReport, User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限创建项目报告");
+        }
+
+        //判断是否是当前项目的区域管理员
+        if(!this.regionalManagerId.equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户没有权限创建项目报告！");
+        }
+        //项目状态判断
+        if(this.getStatus() != (CrowdTestProjectStatus.HAS_COMMITED-1)){
+            throw new CrowdTestProjectException("当前项目状态不可创建项目报告！状态为："+this.getStatus());
+        }else{
+            crowdTestReport.setScope(0);
+            crowdTestReport.setDependencyCode(this.getCode());
+            this.setCrowdTestReportForProject(crowdTestReport);
+            return this;
+        }
+    }
+
+    /**
+     * 提交项目（区域管理员）
+     * @return
+     */
+    public CrowdTestProject commitCrowdTestProject(User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限提交项目");
+        }
+
+        //判断是否是当前项目的区域管理员
+        if(!this.regionalManagerId.equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户没有权限操作此项目！");
+        }
+
+        //项目状态判断
+        if(this.getStatus() != CrowdTestProjectStatus.HAS_RECEIVED){
+            throw new CrowdTestProjectException("当前项目状态不可提交项目！状态为："+this.getStatus());
+        }
+
+        //判断项目下是否有任务
+        if(this.getCrowdTestTaskList()==null || this.getCrowdTestTaskList().size() < 1){
+            throw new CrowdTestProjectException("还未创建任务，项目不能被提交");
+        }else{
+            //结束项目时查看是否已结束任务
+            if(this.getCrowdTestTaskList().stream().filter(task -> task.getStatus()!=CrowdTestTaskStatus.HAS_REJECTED)
+                    .anyMatch(task -> task.getStatus()!=CrowdTestTaskStatus.HAS_FINISHED)){
+                throw new CrowdTestTaskException("存在未结束的任务，项目不能被提交");
             }
-            crowdTestTask.setStatus(status);
         }
-        crowdTestProject.setStatus(status);
-        return crowdTestProject;
+        //判断项目下是否有项目报告
+        if(this.getCrowdTestReportForProject() == null){
+            throw new CrowdTestProjectException("还未创建项目报告，项目不能被提交");
+        }
+        this.setStatus(CrowdTestProjectStatus.HAS_COMMITED);
+        return this;
+    }
+
+    /**
+     * 结束项目（项目发起者）
+     * @return
+     */
+    public CrowdTestProject finishCrowdTestProject(User user) {
+        //判断用户是否认证
+//        if(user.getPersonalAuthentication() == null && user.getEnterpriseAuthentication() == null && user.getRegionalManager() == null && user.getEvaluationAgency() == null){
+//            throw new CrowdTestProjectException("当前用户未进行认证，无权限对项目操作");
+//        }
+        //判断是否为项目发起者
+        if(!this.getUserId().equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户没有权限结束项目!");
+        }
+
+        if(this.getStatus() != CrowdTestProjectStatus.HAS_COMMITED){
+            throw new CrowdTestProjectException("项目不能确认结束，当前状态为："+this.getStatus());
+        }else{
+            this.setStatus(CrowdTestProjectStatus.HAS_FINISHED);
+            this.setEndTime(new Timestamp(System.currentTimeMillis()));
+        }
+        return this;
+    }
+
+    public void reject(Long userId) {
+        if (this.getProjectDistributionTypeId()!=0
+                || this.getStatus() != CrowdTestProjectStatus.HAS_RELEASED
+                || !this.getRegionalManagerId().equals(userId)){
+            throw new CrowdTestProjectException("非法的操作");
+        }
+        this.setStatus(CrowdTestProjectStatus.HAS_REJECTED);
     }
 }

core/src/main/java/com/mooctest/crowd/domain/domainobject/CrowdTestProjectStatus.java

@@ -5,9 +5,12 @@ package com.mooctest.crowd.domain.domainobject;
  * @date 2019/7/9 14:21
  */
 public class CrowdTestProjectStatus {
-    public static final String CREATED = "HAS_CREATED";
-    public static final String RELEASED = "HAS_RELEASED";
-    public static final String RECEIVED = "HAS_RECEIVED";
-    public static final String splited = "HAS_SPLITED";
-    public static final String FINISHED = "HAS_FINISHED";
+    public static final int HAS_REJECTED = -1; //项目被拒
+    public static final int HAS_CREATED = 0;  //创建项目
+    public static final int HAS_RELEASED = 1; //发布项目
+    public static final int HAS_RECEIVED = 2; //接收项目
+//    public static final int HAS_SPLITED = 3;  //拆分项目
+//    public static final int HAS_REPORTED = 4; //生成项目报告
+    public static final int HAS_COMMITED = 3; //提交项目
+    public static final int HAS_FINISHED = 4; //结束项目
 }

core/src/main/java/com/mooctest/crowd/domain/domainobject/CrowdTestReport.java

@@ -12,25 +12,39 @@ import java.sql.Timestamp;
 public class CrowdTestReport {
 
     private Long id;
-    private Long crowdTestProjectId;
-    private Long crowdTestTaskId;
+    private String name;
+    private String code;
+    private String dependencyCode; //所依赖的项目或者任务
     private String type;
+    private int scope;
+    private String testObject;
     private String description;
     private String content;
-    private String status;
-    private Timestamp creatTime;
+    private String file;
+    private String conclusion;
+    private int isDeleted;
+    private Timestamp createTime;
 
     @Override
     public String toString() {
         return "CrowdTestReport{" +
                 "id=" + id +
-                ", crowdTestProjectId=" + crowdTestProjectId +
-                ", crowdTestTaskId=" + crowdTestTaskId +
-                ", type=" + type +
+                ", name='" + name + '\'' +
+                ", code='" + code + '\'' +
+                ", dependencyCode='" + dependencyCode + '\'' +
+                ", type='" + type + '\'' +
+                ", scope='" + scope + '\'' +
+                ", testObject='" + testObject + '\'' +
                 ", description='" + description + '\'' +
                 ", content='" + content + '\'' +
-                ", status='" + status + '\'' +
-                ", creatTime=" + creatTime +
+                ", file='" + file + '\'' +
+                ", conclusion='" + conclusion + '\'' +
+                ", isDeleted='" + isDeleted + '\'' +
+                ", createTime=" + createTime +
                 '}';
     }
+
+    public void removeCrowdTestReport() {
+        this.isDeleted = DeletedStatus.isDeleted;
+    }
 }

core/src/main/java/com/mooctest/crowd/domain/domainobject/CrowdTestReportStatus.java

@@ -1,11 +0,0 @@
-package com.mooctest.crowd.domain.domainobject;
-
-/**
- * @author guochao
- * @date 2019/7/9 14:21
- */
-public class CrowdTestReportStatus {
-    public static final String CREATED = "HAS_CREATED";
-    public static final String COMMITED = "HAS_COMMITED";
-    public static final String FINISHED = "HAS_FINISHED";
-}

core/src/main/java/com/mooctest/crowd/domain/domainobject/CrowdTestTask.java

@@ -1,11 +1,13 @@
 package com.mooctest.crowd.domain.domainobject;
 
-import com.mooctest.crowd.domain.exception.CrowdTestReportNotExistException;
+import com.mooctest.crowd.domain.exception.CrowdTestTaskException;
 import com.mooctest.crowd.domain.exception.CrowdTestTaskNotExistException;
+import com.mooctest.crowd.domain.exception.UnauthorizedException;
 import lombok.Data;
 
 import java.sql.Timestamp;
 import java.util.List;
+import java.util.Optional;
 
 /**
  * @author guochao
@@ -15,42 +17,107 @@ import java.util.List;
 public class CrowdTestTask {
     private Long id;
     private String name;
-    private Long crowdTestProjectId;
+    private String code;
+    private String crowdTestProjectCode;
     private Long evaluationAgencyId;
     private String type;
     private String description;
     private String requirementFile;
-    private Double price;
-    private String status;
-    private Timestamp creatTime;
+    private Long distributionType;
+    private String distributionProvince;
+    private String distributionCity;
+    private Double quotedPrice;
+    private Double fixedPrice;
+    private int status;
+    private Timestamp deadTime;
+    private Timestamp endTime;
+    private int isDeleted;
+    private Timestamp createTime;
     private List<CrowdTestReport> crowdTestReportList;
 
-
     @Override
     public String toString() {
         return "CrowdTestTask{" +
                 "id=" + id +
                 ", name='" + name + '\'' +
-                ", crowdTestProjectId=" + crowdTestProjectId +
+                ", code='" + code + '\'' +
+                ", crowdTestProjectCode='" + crowdTestProjectCode + '\'' +
                 ", evaluationAgencyId=" + evaluationAgencyId +
-                ", type=" + type +
+                ", type='" + type + '\'' +
                 ", description='" + description + '\'' +
-                ", requirementFile=" + requirementFile +
-                ", price=" + price +
+                ", requirementFile='" + requirementFile + '\'' +
+                ", distributionType='" + distributionType + '\'' +
+                ", distributionProvince='" + distributionProvince + '\'' +
+                ", distributionCity='" + distributionCity + '\'' +
+                ", quotedPrice=" + quotedPrice +
+                ", fixedPrice=" + fixedPrice +
                 ", status='" + status + '\'' +
-                ", creatTime=" + creatTime +
+                ", deadTime=" + deadTime +
+                ", endTime=" + endTime +
+                ", isDeleted='" + isDeleted + '\'' +
+                ", createTime=" + createTime +
                 ", crowdTestReportList=" + crowdTestReportList +
                 '}';
     }
 
-    public CrowdTestReport getCrowdTestReportByReportId(CrowdTestTask crowdTestTask, Long reportId) throws CrowdTestTaskNotExistException, CrowdTestReportNotExistException {
-        List<CrowdTestReport> crowdTestReportList = crowdTestTask.getCrowdTestReportList();
-        for (CrowdTestReport crowdTestReport : crowdTestReportList) {
-            if (crowdTestReport.getId().equals(reportId)) {
-                return crowdTestReport;
-            }
+//    public CrowdTestReport getCrowdTestReportByReportId(CrowdTestTask crowdTestTask, Long reportId) throws CrowdTestTaskNotExistException, CrowdTestReportNotExistException {
+//        List<CrowdTestReport> crowdTestReportList = crowdTestTask.getCrowdTestReportList();
+//        for (CrowdTestReport crowdTestReport : crowdTestReportList) {
+//            if (crowdTestReport.getId().equals(reportId)) {
+//                return crowdTestReport;
+//            }
+//        }
+//        throw new CrowdTestReportNotExistException();
+//    }
+
+    /**
+     * 接收任务（测评机构）
+     * @return
+     */
+    public void receive(User user) {
+        //判断是否为测评机构
+        EvaluationAgency evaluationAgency = user.getEvaluationAgency();
+        if(evaluationAgency == null){
+            throw new UnauthorizedException("当前用户不是测评机构，没有权限接收任务");
+        }
+        //任务当前状态
+        if (this.getStatus()!=CrowdTestTaskStatus.HAS_RELEASED)
+            throw new CrowdTestTaskException("任务当前状态不能被接收，当前状态为："+this.getStatus());
+        //定向发布类型
+        if (this.getDistributionType() == 0) {
+            if (!this.getEvaluationAgencyId().equals(user.getId()))
+                throw new CrowdTestTaskException("当前用户没有权限接收此定向发布的任务！");
+        }
+        this.setEvaluationAgencyId(user.getId());
+        this.setStatus(CrowdTestTaskStatus.HAS_RECEIVED);
+    }
+
+    public void reject(Long userId){
+        if (this.getDistributionType()!=0 || this.getStatus()!=CrowdTestTaskStatus.HAS_RELEASED || !this.getEvaluationAgencyId().equals(userId)){
+            throw new CrowdTestTaskException("非法操作！");
+        }
+        this.setStatus(CrowdTestTaskStatus.HAS_REJECTED);
+    }
+
+    public void removeCrowdTestTask() {
+        this.isDeleted = DeletedStatus.isDeleted;
+    }
+
+    public void commit(Long userId) {
+        if (this.getStatus()!=CrowdTestTaskStatus.HAS_RECEIVED || this.getCrowdTestReportList()==null || this.getCrowdTestReportList().size()<1){
+            throw new CrowdTestTaskException("当前状态不能提交任务");
         }
-        throw new CrowdTestReportNotExistException();
+        if (!this.getEvaluationAgencyId().equals(userId)){
+            throw new UnauthorizedException("无权对此任务进行操作");
+        }
+        this.setStatus(CrowdTestTaskStatus.HAS_COMMITED);
     }
 
+    public void confirmFinish(Long userId) {
+        if (this.getStatus()!=CrowdTestTaskStatus.HAS_COMMITED){
+            throw new CrowdTestTaskException("评测机构未提请结束任务，无法确认结束！");
+        }
+        this.setStatus(CrowdTestTaskStatus.HAS_FINISHED);
+        this.setEndTime(new Timestamp(System.currentTimeMillis()));
+    }
 }

core/src/main/java/com/mooctest/crowd/domain/domainobject/CrowdTestTaskStatus.java

@@ -5,9 +5,11 @@ package com.mooctest.crowd.domain.domainobject;
  * @date 2019/7/9 14:21
  */
 public class CrowdTestTaskStatus {
-    public static final String CREATED = "HAS_CREATED";
-    public static final String RELEASED = "HAS_RELEASED";
-    public static final String RECEIVED = "HAS_RECEIVED";
-    public static final String COMMITED = "HAS_COMMITED";
-    public static final String FINISHED = "HAS_FINISHED";
+    public static final int HAS_REJECTED = -1;  //定向发布被拒
+    public static final int HAS_CREATED = 0;    //创建任务
+    public static final int HAS_RELEASED = 1;   //发布任务
+    public static final int HAS_RECEIVED = 2;   //接受任务
+//    public static final int HAS_REPORTED = 3; //存在任务报告
+    public static final int HAS_COMMITED = 3;   //提交任务
+    public static final int HAS_FINISHED = 4;   //结束任务
 }

core/src/main/java/com/mooctest/crowd/domain/domainobject/DeletedStatus.java

@@ -0,0 +1,10 @@
+package com.mooctest.crowd.domain.domainobject;
+
+/**
+ * @author guochao
+ * @date 2019/7/9 14:21
+ */
+public class DeletedStatus {
+    public static final int isNotDeleted = 0; //未删除
+    public static final int isDeleted = 1;    //已删除
+}

core/src/main/java/com/mooctest/crowd/domain/domainobject/DistributeType.java

@@ -13,4 +13,13 @@ public class DistributeType {
     private Long id;
     private String name;
     private Date createTime;
+
+    @Override
+    public String toString() {
+        return "DistributeType{" +
+                "id=" + id +
+                ", name='" + name + '\'' +
+                ", createTime=" + createTime +
+                '}';
+    }
 }

core/src/main/java/com/mooctest/crowd/domain/domainobject/EnterpriseAuthentication.java

@@ -0,0 +1,106 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import com.mooctest.crowd.domain.exception.BaseException;
+import lombok.Data;
+import org.springframework.beans.BeanUtils;
+
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019-08-19 15:47
+ */
+@Data
+public class EnterpriseAuthentication {
+
+    private Long id;
+    private Long userId;
+    private String enterpriseName;
+    private String legalPersonName;
+    private String businessLicensePhoto;
+    private String unifiedSocialCreditCode;
+    private String bankAccount;
+    private String address;
+    private int isDeleted;
+    private int isAuthentication;
+    private String explain;
+    private Timestamp applyTime;
+    private Timestamp checkTime;
+
+    @Override
+    public String toString() {
+        return "CompanyAuth{" +
+                "id=" + id +
+                ", userId=" + userId +
+                ", enterpriseName='" + enterpriseName + '\'' +
+                ", legalPersonName='" + legalPersonName + '\'' +
+                ", businessLicensePhoto='" + businessLicensePhoto + '\'' +
+                ", unifiedSocialCreditCode='" + unifiedSocialCreditCode + '\'' +
+                ", bankAccount='" + bankAccount + '\'' +
+                ", address='" + address + '\'' +
+                ", isDeleted=" + isDeleted +
+                ", isAuthentication=" + isAuthentication +
+                ", explain=" + explain +
+                ", applyTime='" + applyTime + '\'' +
+                ", checkTime='" + checkTime + '\'' +
+                '}';
+    }
+
+    public EnterpriseAuthentication applyAuthentication(Long userId) {
+        this.setUserId(userId);
+        this.setIsAuthentication(AuthenticationStatus.isAuthenIng);
+        this.setIsDeleted(DeletedStatus.isNotDeleted);
+        this.setApplyTime(new Timestamp(System.currentTimeMillis()));
+        this.setCheckTime(null);
+        this.setExplain("");
+        return this;
+    }
+
+    public EnterpriseAuthentication passAuthentication() {
+        if(this.getIsAuthentication() == AuthenticationStatus.isNotAuthenticated){
+            throw new BaseException("当前是未通过认证状态，不可通过认证，需对认证信息进行修改后再提交认证申请");
+        }else if(this.getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+            throw new BaseException("当前已通过认证，不可再次进行认证");
+        }else{
+            this.setIsAuthentication(AuthenticationStatus.isAuthenticated);
+            this.setCheckTime(new Timestamp(System.currentTimeMillis()));
+            this.setExplain("");
+            return this;
+        }
+
+    }
+
+    public EnterpriseAuthentication rejectAuthentication(String explain) {
+        if(this.getIsDeleted() == DeletedStatus.isDeleted){
+            throw new BaseException("当前认证信息已被删除，不可做认证状态改变操作");
+        }else {
+            if(this.getIsAuthentication() == AuthenticationStatus.isNotAuthenticated){
+                throw new BaseException("当前已是未通过认证状态，不可再次拒绝认证");
+            }else if(this.getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+                throw new BaseException("当前已通过认证，不可拒绝认证");
+            }else {
+                this.setIsAuthentication(AuthenticationStatus.isNotAuthenticated);
+                this.setExplain(explain);
+                this.setCheckTime(new Timestamp(System.currentTimeMillis()));
+                return this;
+            }
+        }
+    }
+
+    public EnterpriseAuthentication updateAuthInfo(EnterpriseAuthentication modifyAuth) {
+        modifyAuth.userId = this.userId;
+        modifyAuth.id = this.id;
+        BeanUtils.copyProperties(modifyAuth,this);
+        this.setIsAuthentication(AuthenticationStatus.isAuthenIng);
+        this.setIsDeleted(DeletedStatus.isNotDeleted);
+        this.setApplyTime(new Timestamp(System.currentTimeMillis()));
+        this.setCheckTime(null);
+        this.setExplain("");
+        return this;
+    }
+
+    public EnterpriseAuthentication deleteAuth() {
+        this.isDeleted = DeletedStatus.isDeleted;
+        return this;
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/domainobject/EvaluationAgency.java

@@ -1,53 +1,114 @@
 package com.mooctest.crowd.domain.domainobject;
 
-import com.mooctest.crowd.domain.exception.CrowdTestProjectNotExistException;
-import com.mooctest.crowd.domain.exception.CrowdTestTaskNoPriceException;
-import com.mooctest.crowd.domain.exception.CrowdTestTaskNotExistException;
-import com.mooctest.crowd.domain.repository.CrowdTestProjectRepo;
+import com.mooctest.crowd.domain.exception.BaseException;
 import lombok.Data;
+import org.springframework.beans.BeanUtils;
 
 import java.sql.Timestamp;
+import java.util.List;
 
 /**
  * @author guochao
  * @date 2019/7/12 1:32
  */
 @Data
-public class EvaluationAgency extends User {
+public class EvaluationAgency {
     private Long id;
     private Long userId;
     private String evaluationAgencyName;
     private String bankAccount;
     private String address;
-    private String abilities;
-    private String resources;
+    private List<EvaluationAgencyAbility> evaluationAgencyAbilityList;
+    private List<EvaluationAgencyResource> evaluationAgencyResourceList;
     private String agencyPhoto;
+    private int isAuthentication;
+    private String explain;
+    private int isDeleted;
     private Timestamp updateTime;
     private Timestamp expireTime;
+    private Timestamp checkTime;
+    private Timestamp applyTime;
 
     @Override
-    public Long getId() {
-        return id;
+    public String toString() {
+        return "EvaluationAgency{" +
+                "id=" + id +
+                ", userId=" + userId +
+                ", evaluationAgencyName='" + evaluationAgencyName + '\'' +
+                ", bankAccount='" + bankAccount + '\'' +
+                ", address='" + address + '\'' +
+                ", evaluationAgencyAbilityList=" + evaluationAgencyAbilityList +
+                ", evaluationAgencyResourceList=" + evaluationAgencyResourceList +
+                ", agencyPhoto='" + agencyPhoto + '\'' +
+                ", isAuthentication=" + isAuthentication +
+                ", explain='" + explain + '\'' +
+                ", isDeleted=" + isDeleted +
+                ", updateTime=" + updateTime +
+                ", expireTime=" + expireTime +
+                ", applyTime=" + applyTime +
+                ", checkTime=" + checkTime +
+                '}';
     }
 
-    @Override
-    public void setId(Long id) {
-        this.id = id;
+    public EvaluationAgency applyAuthentication(Long userId) {
+        this.setUserId(userId);
+        this.setIsAuthentication(AuthenticationStatus.isAuthenIng);
+        this.setIsDeleted(DeletedStatus.isNotDeleted);
+        this.setApplyTime(new Timestamp(System.currentTimeMillis()));
+        this.setCheckTime(null);
+        this.setExplain("");
+        return this;
+    }
+
+    public EvaluationAgency passAuthentication() {
+        if(this.getIsAuthentication() == AuthenticationStatus.isNotAuthenticated){
+            throw new BaseException("当前是未通过认证状态，不可通过认证，需对认证信息进行修改后再提交认证申请");
+        }else if(this.getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+            throw new BaseException("当前已通过认证，不可再次进行认证");
+        }else{
+            this.setIsAuthentication(AuthenticationStatus.isAuthenticated);
+            this.setCheckTime(new Timestamp(System.currentTimeMillis()));
+            this.setExplain("");
+            return this;
+        }
+
     }
 
-    public boolean updateCrowdTestTaskStatusByEvaluationAgency(Long projectId, Long taskId, Long evaluationAgencyId, String status) throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException {
-        CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
-        if (crowdTestProjectRepo.getByID(projectId) != null) {
-            CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(projectId);
-            CrowdTestTask crowdTestTask = crowdTestProject.getCrowdTestTaskByTaskId(crowdTestProject, taskId);
-            if (crowdTestTask.getPrice() > 0) {
-                crowdTestTask.setEvaluationAgencyId(evaluationAgencyId);
-                crowdTestTask.setStatus(status);
-                return true;
-            } else {
-                throw new CrowdTestTaskNoPriceException();
+    public EvaluationAgency rejectAuthentication(String explain) {
+        if(this.getIsDeleted() == DeletedStatus.isDeleted){
+            throw new BaseException("当前认证信息已被删除，不可做认证状态改变操作");
+        }else {
+            if(this.getIsAuthentication() == AuthenticationStatus.isNotAuthenticated){
+                throw new BaseException("当前已是未通过认证状态，不可再次拒绝认证");
+            }else if(this.getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+                throw new BaseException("当前已通过认证，不可拒绝认证");
+            }else {
+                this.setIsAuthentication(AuthenticationStatus.isNotAuthenticated);
+                this.setExplain(explain);
+                this.setCheckTime(new Timestamp(System.currentTimeMillis()));
+                return this;
             }
         }
-        throw new CrowdTestProjectNotExistException();
+    }
+
+    public EvaluationAgency updateAuthInfo(EvaluationAgency modifyAuth) {
+        modifyAuth.userId = this.userId;
+        modifyAuth.id = this.id;
+        BeanUtils.copyProperties(modifyAuth,this);
+        this.setIsAuthentication(AuthenticationStatus.isAuthenIng);
+        this.setIsDeleted(DeletedStatus.isNotDeleted);
+        this.setIsAuthentication(AuthenticationStatus.isAuthenIng);
+        this.setApplyTime(new Timestamp(System.currentTimeMillis()));
+        this.setCheckTime(null);
+        this.setExplain("");
+        return this;
+    }
+
+    public EvaluationAgency deleteAuth() {
+        this.isDeleted = DeletedStatus.isDeleted;
+        //删除资源和能力
+        this.getEvaluationAgencyResourceList().stream().forEach(evaluationAgencyResource -> evaluationAgencyResource.deleteResource());
+        this.getEvaluationAgencyAbilityList().stream().forEach(evaluationAgencyAbility -> evaluationAgencyAbility.deleteAbility());
+        return this;
     }
 }

core/src/main/java/com/mooctest/crowd/domain/domainobject/EvaluationAgencyAbility.java

@@ -0,0 +1,41 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019/8/12 14:16
+ */
+@Data
+@NoArgsConstructor
+public class EvaluationAgencyAbility {
+
+    private Long id;
+    private Long evaluationAgencyId;
+    private String abilityName;
+    private int isDeleted;
+    private Timestamp createTime;
+
+    public EvaluationAgencyAbility(String abilityName){
+        this.abilityName = abilityName;
+    }
+
+    @Override
+    public String toString() {
+        return "EvaluationAgencyAbility{" +
+                "id=" + id +
+                ", evaluationAgencyId=" + evaluationAgencyId +
+                ", abilityName='" + abilityName + '\'' +
+                ", isDeleted=" + isDeleted +
+                ", createTime=" + createTime +
+                '}';
+    }
+
+    public EvaluationAgencyAbility deleteAbility(){
+        this.isDeleted = DeletedStatus.isDeleted;
+        return this;
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/domainobject/EvaluationAgencyResource.java

@@ -0,0 +1,49 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019/8/12 14:16
+ */
+@Data
+public class EvaluationAgencyResource {
+
+    private Long id;
+    private Long evaluationAgencyId;
+    private String type;
+    private String name;
+    private int totalNum;
+    private int availableNum;
+    private int isDeleted;
+    private Timestamp createTime;
+
+    @Override
+    public String toString() {
+        return "EvaluationAgencyResource{" +
+                "id=" + id +
+                ", evaluationAgencyId=" + evaluationAgencyId +
+                ", type='" + type + '\'' +
+                ", name='" + name + '\'' +
+                ", totalNum=" + totalNum +
+                ", availableNum=" + availableNum +
+                ", isDeleted=" + isDeleted +
+                ", createTime=" + createTime +
+                '}';
+    }
+
+    public EvaluationAgencyResource updateEvaluationAgencyResource(String[] resource){
+        this.type = resource[0];
+        this.name = resource[1];
+        this.totalNum = Integer.valueOf(resource[2]);
+        this.availableNum = Integer.valueOf(resource[3]);
+        return this;
+    }
+
+    public EvaluationAgencyResource deleteResource(){
+        this.isDeleted = DeletedStatus.isDeleted;
+        return this;
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/domainobject/Permission.java

@@ -10,7 +10,8 @@ import java.sql.Timestamp;
  */
 @Data
 public class Permission {
-    private Long id;
+
+    Long id;
     private String name;
     private String resource;
     private String operation;

core/src/main/java/com/mooctest/crowd/domain/domainobject/PersonalAuthentication.java

@@ -0,0 +1,103 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import com.mooctest.crowd.domain.exception.BaseException;
+import lombok.Data;
+import org.springframework.beans.BeanUtils;
+
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019-08-19 15:47
+ */
+@Data
+public class PersonalAuthentication {
+
+    private Long id;
+    private Long userId;
+    private String realName;
+    private String IDCard;
+    private String IDCardPhoto;
+    private String bankAccount;
+    private String address;
+    private int isDeleted;
+    private int isAuthentication;
+    private String explain;
+    private Timestamp applyTime;
+    private Timestamp checkTime;
+
+    @Override
+    public String toString() {
+        return "PersonalAuth{" +
+                "id=" + id +
+                ", userId=" + userId +
+                ", realName='" + realName + '\'' +
+                ", IDCard='" + IDCard + '\'' +
+                ", IDCardPhoto='" + IDCardPhoto + '\'' +
+                ", bankAccount='" + bankAccount + '\'' +
+                ", address='" + address + '\'' +
+                ", isAuthentication='" + isAuthentication + '\'' +
+                ", explain=" + explain +
+                ", applyTime='" + applyTime + '\'' +
+                ", checkTime='" + checkTime + '\'' +
+                '}';
+    }
+
+    public PersonalAuthentication applyAuthentication(Long userId) {
+        this.setUserId(userId);
+        this.setIsAuthentication(AuthenticationStatus.isAuthenIng);
+        this.setIsDeleted(DeletedStatus.isNotDeleted);
+        this.setApplyTime(new Timestamp(System.currentTimeMillis()));
+        this.setCheckTime(null);
+        this.setExplain("");
+        return this;
+    }
+
+    public PersonalAuthentication passAuthentication() {
+        if(this.getIsAuthentication() == AuthenticationStatus.isNotAuthenticated){
+            throw new BaseException("当前是未通过认证状态，不可通过认证，需对认证信息进行修改后再提交认证申请");
+        }else if(this.getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+            throw new BaseException("当前已通过认证，请勿重复操作");
+        }else{
+            this.setIsAuthentication(AuthenticationStatus.isAuthenticated);
+            this.setCheckTime(new Timestamp(System.currentTimeMillis()));
+            this.setExplain("");
+            return this;
+        }
+
+    }
+
+    public PersonalAuthentication rejectAuthentication(String explain) {
+        if(this.getIsDeleted() == DeletedStatus.isDeleted){
+            throw new BaseException("当前认证信息已被删除，不可做认证状态改变操作");
+        }else {
+            if(this.getIsAuthentication() == AuthenticationStatus.isNotAuthenticated){
+                throw new BaseException("当前已是未通过认证状态，不可再次拒绝认证");
+            }else if(this.getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+                throw new BaseException("当前已通过认证，不可拒绝认证");
+            }else {
+                this.setIsAuthentication(AuthenticationStatus.isNotAuthenticated);
+                this.setExplain(explain);
+                this.setCheckTime(new Timestamp(System.currentTimeMillis()));
+                return this;
+            }
+        }
+    }
+
+    public PersonalAuthentication updateAuthInfo(PersonalAuthentication modifyAuth) {
+        modifyAuth.userId = this.userId;
+        modifyAuth.id = this.id;
+        BeanUtils.copyProperties(modifyAuth,this);
+        this.setIsAuthentication(AuthenticationStatus.isAuthenIng);
+        this.setIsDeleted(DeletedStatus.isNotDeleted);
+        this.setApplyTime(new Timestamp(System.currentTimeMillis()));
+        this.setCheckTime(null);
+        this.setExplain("");
+        return this;
+    }
+
+    public PersonalAuthentication deleteAuth() {
+        this.isDeleted = DeletedStatus.isDeleted;
+        return this;
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/domainobject/Province.java

@@ -0,0 +1,21 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+
+/**
+ * @author guochao
+ * @date 2019-07-30 10:31
+ */
+@Data
+public class Province {
+    private Long code;
+    private String name;
+
+    @Override
+    public String toString() {
+        return "Province{" +
+                "code=" + code +
+                ", name='" + name + '\'' +
+                '}';
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/domainobject/Regional.java

@@ -0,0 +1,23 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+
+/**
+ * @author guochao
+ * @date 2019-07-30 10:31
+ */
+@Data
+public class Regional {
+    private Long id;
+    private Long provinceCode;
+    private String name;
+
+    @Override
+    public String toString() {
+        return "Regional{" +
+                "id=" + id +
+                ", provinceCode=" + provinceCode +
+                ", name='" + name + '\'' +
+                '}';
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/domainobject/RegionalManager.java

@@ -1,11 +1,7 @@
 package com.mooctest.crowd.domain.domainobject;
 
-import com.mooctest.crowd.domain.exception.CrowdTestProjectNotExistException;
-import com.mooctest.crowd.domain.exception.CrowdTestTaskNotExistException;
-import com.mooctest.crowd.domain.repository.CrowdTestProjectRepo;
 import lombok.Data;
 
-import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -13,39 +9,17 @@ import java.util.List;
  * @date 2019/7/9 14:16
  */
 @Data
-public class RegionalManager extends User {
+public class RegionalManager {
     private Long id;
     private Long userId;
-    private String regional;
+    private List<RegionalManagerToRegional> regionalList;
 
-    public List<CrowdTestTask> splitCrowdTestProjectToCrowdTestTaskList(Long projectId) throws CrowdTestProjectNotExistException {
-        CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
-        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(projectId);
-        crowdTestProject.setStatus(CrowdTestProjectStatus.splited);
-        List<CrowdTestTask> crowdTestTaskList = new ArrayList<CrowdTestTask>();
-        crowdTestProject.setCrowdTestTaskList(crowdTestTaskList);
-        return crowdTestTaskList;
+    @Override
+    public String toString() {
+        return "RegionalManager{" +
+                "id=" + id +
+                ", userId=" + userId +
+                ", regionalList=" + regionalList +
+                '}';
     }
-
-    public CrowdTestProject fixedPriceForCrowdTestTask(Long projectId, Long taskId, Double price) throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException {
-        CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
-        boolean flag = false;
-        if (crowdTestProjectRepo.getByID(projectId) != null) {
-            CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(projectId);
-            List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
-            for (CrowdTestTask crowdTestTask : crowdTestTaskList) {
-                if (crowdTestTask.getId().equals(taskId)) {
-                    crowdTestTask.setPrice(price);
-                    flag = true;
-                    return crowdTestProject;
-                }
-            }
-            if (!flag) {
-                throw new CrowdTestTaskNotExistException();
-            }
-        }
-        throw new CrowdTestProjectNotExistException();
-    }
-
-
 }

core/src/main/java/com/mooctest/crowd/domain/domainobject/RegionalManagerToRegional.java

@@ -0,0 +1,21 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+
+/**
+ * @author guochao
+ * @date 2019/7/9 14:16
+ */
+@Data
+public class RegionalManagerToRegional {
+    private String province;
+    private String city;
+
+    @Override
+    public String toString() {
+        return "Regional{" +
+                "province='" + province + '\'' +
+                ", city='" + city + '\'' +
+                '}';
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/domainobject/Role.java

@@ -3,6 +3,7 @@ package com.mooctest.crowd.domain.domainobject;
 import lombok.Data;
 
 import java.sql.Timestamp;
+import java.util.List;
 
 /**
  * @author guochao
@@ -13,4 +14,6 @@ public class Role {
     private Long id;
     private String name;
     private Timestamp createTime;
+    private List<Permission> permissionList;
+
 }

core/src/main/java/com/mooctest/crowd/domain/domainobject/SystemAdministrator.java → core/src/main/java/com/mooctest/crowd/domain/domainobject/SystemAdministratorToUser.java

@@ -2,12 +2,16 @@ package com.mooctest.crowd.domain.domainobject;
 
 import lombok.Data;
 
+import java.sql.Timestamp;
+
 /**
  * @author guochao
  * @date 2019/7/16 16:11
  */
 @Data
-public class SystemAdministrator extends User {
+    public class SystemAdministratorToUser {
     private Long id;
     private Long userId;
+    private int isDeleted;
+    private Timestamp createTime;
 }

core/src/main/java/com/mooctest/crowd/domain/domainobject/User.java

@@ -1,8 +1,11 @@
 package com.mooctest.crowd.domain.domainobject;
 
+import com.mooctest.crowd.domain.exception.BaseException;
+import com.mooctest.crowd.domain.exception.SystemAdministratorException;
 import lombok.Data;
 
 import java.sql.Timestamp;
+import java.util.List;
 
 /**
  * @author guochao
@@ -16,10 +19,263 @@ public class User {
     private String password;
     private String gender;
     private String mobile;
+    private String email;
     private String province;
     private String city;
     private String photoUrl;
-    private String isAvailable;
-    private String isDeleted;
+    private int isAvailable;
+    private int isDeleted;
     private Timestamp createTime;
+
+    private RegionalManager regionalManager;
+    private EvaluationAgency evaluationAgency;
+    private PersonalAuthentication personalAuthentication;
+    private EnterpriseAuthentication enterpriseAuthentication;
+    private SystemAdministratorToUser systemAdministratorToUser;
+    private List<Role> roleList;
+
+    @Override
+    public String toString() {
+        return "User{" +
+                "id=" + id +
+                ", name='" + name + '\'' +
+                ", userName='" + userName + '\'' +
+                ", password='" + password + '\'' +
+                ", gender='" + gender + '\'' +
+                ", mobile='" + mobile + '\'' +
+                ", email='" + email + '\'' +
+                ", province='" + province + '\'' +
+                ", city='" + city + '\'' +
+                ", photoUrl='" + photoUrl + '\'' +
+                ", isAvailable=" + isAvailable +
+                ", isDeleted=" + isDeleted +
+                ", createTime=" + createTime +
+                ", regionalManager=" + regionalManager +
+                ", evaluationAgency=" + evaluationAgency +
+                ", personalAuthentication=" + personalAuthentication +
+                ", enterpriseAuthentication=" + enterpriseAuthentication +
+                ", systemAdministratorToUser=" + systemAdministratorToUser +
+                ", roleList=" + roleList +
+                '}';
+    }
+
+    /**
+     * 机构认证——申请
+     * @param evaluationAgency
+     * @return
+     */
+    public User applyAgencyAuthentication(EvaluationAgency evaluationAgency) {
+        if (this.getPersonalAuthentication()!=null || this.getEnterpriseAuthentication()!=null || this.getPersonalAuthentication() != null)
+            throw new BaseException("已有认证信息，不可再次认证");
+        this.setEvaluationAgency(evaluationAgency.applyAuthentication(this.id));
+        return this;
+    }
+
+
+    /**
+     * 机构认证——通过
+     * @return
+     */
+    public User passAgencyAuthApplication(User agencyUser) {
+        //判断是否为系统管理员
+        judgeIsSystemAdministrator();
+
+        EvaluationAgency evaluationAgency = agencyUser.getEvaluationAgency();
+        evaluationAgency.passAuthentication();
+        List<Role> roleList = this.getRoleList();
+        Role role = new Role();
+        role.setId(2L);
+        roleList.add(role);
+        agencyUser.setRoleList(roleList);
+        return agencyUser;
+    }
+
+    /**
+     * 机构认证——驳回，并说明驳回原因
+     * @param explain
+     * @return
+     */
+    public User rejectAgencyAuth(User agencyUser, String explain) {
+        //判断是否为系统管理员
+        judgeIsSystemAdministrator();
+
+        EvaluationAgency evaluationAgency = agencyUser.getEvaluationAgency();
+        evaluationAgency.rejectAuthentication(explain);
+        return agencyUser;
+    }
+
+    /**
+     * 机构认证——信息修改
+     * @param modifyAuth
+     * @return
+     */
+    public User updateAgencyAuthInfo(EvaluationAgency modifyAuth){
+        if (this.getEnterpriseAuthentication()!=null || this.getPersonalAuthentication()!=null)
+            throw new BaseException("已有其他认证信息，不可对认证未企业用户");
+        if (this.getEvaluationAgency().getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+            throw new BaseException("已通过认证，不可修改认证信息");
+        }
+        this.getEvaluationAgency().updateAuthInfo(modifyAuth);
+        return this;
+    }
+
+    /**
+     * 机构认证——删除
+     * @return
+     */
+    public User deleteAgencyAuthInfo() {
+        EvaluationAgency evaluationAgency = this.getEvaluationAgency();
+//        RoleConfiguration roleConfiguration = new RoleConfiguration();
+//        final Long num = roleConfiguration.getGeneralUser();
+        evaluationAgency.deleteAuth();
+        return this;
+    }
+
+
+    /**
+     * 个人认证——申请
+     * @return
+     */
+    public User applyPersonalAuthentication(PersonalAuthentication personalAuth) {
+        if (this.getPersonalAuthentication()!=null || this.getEnterpriseAuthentication()!=null || this.getEvaluationAgency() != null)
+            throw new BaseException("已有认证信息，不可再次认证");
+        this.setPersonalAuthentication(personalAuth.applyAuthentication(this.id));
+        return this;
+    }
+
+    /**
+     * 个人认证——通过
+     * @return
+     */
+    public User passPersonalAuthApplication(User personalUser) {
+        //判断是否为系统管理员
+        judgeIsSystemAdministrator();
+
+        PersonalAuthentication personalAuth = personalUser.getPersonalAuthentication();
+        personalAuth.passAuthentication();
+        return personalUser;
+    }
+
+    /**
+     * 个人认证——驳回，并说明驳回原因
+     * @param explain
+     * @return
+     */
+    public User personalAuthReject(User personalUser, String explain) {
+        //判断是否为系统管理员
+        judgeIsSystemAdministrator();
+
+        PersonalAuthentication personalAuth = personalUser.getPersonalAuthentication();
+        personalAuth.rejectAuthentication(explain);
+        return personalUser;
+    }
+
+    /**
+     * 个人认证——信息修改
+     * @param modifyAuth
+     * @return
+     */
+    public User updatePersonalAuthInfo(PersonalAuthentication modifyAuth){
+        if (this.getPersonalAuthentication() == null)
+            throw new BaseException("当前用户未申请个人认证，无法修改");
+        if (this.getEvaluationAgency()!=null || this.getEnterpriseAuthentication()!=null)
+            throw new BaseException("已有其他认证信息，不可对个人认证进行操作");
+        if (this.getPersonalAuthentication().getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+            throw new BaseException("已通过认证，不可修改认证信息");
+        }
+        this.getPersonalAuthentication().updateAuthInfo(modifyAuth);
+        return this;
+    }
+
+    /**
+     * 个人认证——删除
+     * @return
+     */
+    public User deletePersonalAuthInfo() {
+        this.getPersonalAuthentication().deleteAuth();
+        return this;
+    }
+
+    /**
+     * 企业认证——申请
+     * @return
+     */
+    public User applyEnterpriseAuthentication(EnterpriseAuthentication enterpriseAuth) {
+        if (this.getEvaluationAgency()!=null || this.getPersonalAuthentication()!=null || this.getEnterpriseAuthentication()!=null)
+            throw new BaseException("已有认证信息，不可再次认证");
+        this.setEnterpriseAuthentication(enterpriseAuth.applyAuthentication(this.id));
+        return this;
+    }
+
+    /**
+     * 企业认证——通过
+     * @return
+     */
+    public User passEnterpriseAuthApplication(User enterpriseUser) {
+        //判断是否为系统管理员
+        judgeIsSystemAdministrator();
+
+        EnterpriseAuthentication enterpriseAuth = enterpriseUser.getEnterpriseAuthentication();
+        if(enterpriseAuth.getIsAuthentication() == AuthenticationStatus.isNotAuthenticated){
+            throw new BaseException("当前是未通过认证状态，不可通过认证，需对认证信息进行修改后再提交认证申请");
+        }else if(enterpriseAuth.getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+            throw new BaseException("当前已通过认证，不可再次进行认证");
+        }else{
+            enterpriseAuth.passAuthentication();
+            List<Role> roleList = this.getRoleList();
+            Role role = new Role();
+            role.setId(5L);
+            roleList.add(role);
+            enterpriseUser.setRoleList(roleList);
+            return enterpriseUser;
+        }
+    }
+
+    /**
+     * 企业认证——驳回，并说明驳回原因
+     * @param explain
+     * @return
+     */
+    public User enterpriseAuthReject(User enterpriseUser, String explain) {
+        //判断是否为系统管理员
+        judgeIsSystemAdministrator();
+
+        EnterpriseAuthentication enterpriseAuth = enterpriseUser.getEnterpriseAuthentication();
+        enterpriseAuth.rejectAuthentication(explain);
+        return enterpriseUser;
+    }
+
+    /**
+     * 企业认证——修改
+     * @param modifyAuth
+     * @return
+     */
+    public User updateEnterpriseAuthInfo(EnterpriseAuthentication modifyAuth){
+        if (this.getEnterpriseAuthentication() == null){
+            throw new BaseException("该用户未申请企业认证，无法修改");
+        }
+        if (this.getEvaluationAgency()!=null || this.getPersonalAuthentication()!=null)
+            throw new BaseException("已有其他认证信息，不可对认证未企业用户");
+        if (this.getEnterpriseAuthentication().getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+            throw new BaseException("已通过认证，不可修改认证信息");
+        }
+        this.getEnterpriseAuthentication().updateAuthInfo(modifyAuth);
+        return this;
+    }
+
+    /**
+     * 企业认证——删除
+     * @return
+     */
+    public User deleteEnterpriseAuthInfo() {
+        this.getEnterpriseAuthentication().deleteAuth();
+        return this;
+    }
+
+    //判断是否为系统管理员
+    private void judgeIsSystemAdministrator(){
+        if(this.getSystemAdministratorToUser() == null){
+            throw new SystemAdministratorException("当前用户不是系统管理员，没有权限进行认证审核操作");
+        }
+    }
 }

core/src/main/java/com/mooctest/crowd/domain/domainservice/RegisterDService.java

@@ -1,16 +1,14 @@
 package com.mooctest.crowd.domain.domainservice;
 
-import com.mooctest.crowd.domain.domainobject.Account;
-import com.mooctest.crowd.domain.exception.AccountNotExistException;
-import com.mooctest.crowd.domain.exception.HttpBadRequestException;
-import com.mooctest.crowd.domain.repository.AccountUTRepo;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
+import com.mooctest.crowd.domain.domainobject.Role;
+import com.mooctest.crowd.domain.domainobject.User;
+import com.mooctest.crowd.domain.factory.UserFactory;
+import com.mooctest.crowd.domain.util.EncryptionUtil;
 import org.springframework.stereotype.Service;
 
-import java.text.SimpleDateFormat;
-import java.util.Date;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * @Author: xuexb
@@ -19,42 +17,19 @@ import java.util.Date;
 @Service
 public class RegisterDService {
 
-    @Autowired
-    private AccountUTRepo accountUTRepo;
-
-    private Logger LOG = LoggerFactory.getLogger(getClass());
-
-    public Account register(String mobileNum, String password) throws AccountNotExistException {
-//        Account account = null;
-//        try {
-//            account = accountUTRepo.getByMobileNum(cmd.getMobileNum());
-//        } catch (AccountNotExistException e) {
-//            System.out.println("no user ");
-//            Account addAccount = AccountFactory.createAccount();
-//            addAccount.setMobileNum(cmd.getMobileNum());
-//            addAccount.setPassword(cmd.getPassword());
-//            account = accountUTRepo.addAccount(addAccount);
-//            e.printStackTrace();
-//        }
-        if(accountUTRepo.getByMobileNum(mobileNum) == null){
-            System.out.println("no user ");
-//            Account addAccount = AccountFactory.createAccount();
-//            addAccount.setMobileNum(cmd.getMobileNum());
-//            addAccount.setPassword(cmd.getPassword());
-//            return accountUTRepo.addAccount(addAccount);
-        }else{
-            String reason = "注册用户已存在";
-            createLogForRegister(mobileNum, reason);
-            System.out.println("注册用户已存在");
-            throw new HttpBadRequestException("user already exists");
-        }
-        return null;
-    }
-
-    private void createLogForRegister(String mobileNum, String reason) {
-        Date date = new Date();
-        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
-        LOG.error("用户{}注册失败,失败时间：{},失败原因：{}",new Object[]{mobileNum,df.format(date), reason});
+    public User register(String mobile, String password) {
+        User user = UserFactory.createUser();
+        user.setMobile(mobile);
+        user.setPassword(EncryptionUtil.encryptMD5(password));
+        user.setIsAvailable(1);
+        user.setIsDeleted(0);
+        user.setCreateTime(new Timestamp(System.currentTimeMillis()));
+        List<Role> roleList = new ArrayList<Role>();
+        Role role = new Role();
+        role.setName("generalUser");
+        roleList.add(role);
+        user.setRoleList(roleList);
+        return user;
     }
 
 }

core/src/main/java/com/mooctest/crowd/domain/exception/BaseException.java

@@ -8,7 +8,7 @@ import lombok.NoArgsConstructor;
  * @date 2019-07-25 00:15
  */
 @NoArgsConstructor
-public class BaseException extends Exception {
+public class BaseException extends RuntimeException {
     public BaseException(String msg){
         super(msg);
     }

core/src/main/java/com/mooctest/crowd/domain/exception/CrowdTestProjectCannotBeReceive.java

@@ -0,0 +1,11 @@
+package com.mooctest.crowd.domain.exception;
+
+/**
+ * @author guochao
+ * @date 2019-07-30 15:04
+ */
+public class CrowdTestProjectCannotBeReceive extends BaseException {
+    public CrowdTestProjectCannotBeReceive(String msg){
+        super(msg);
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/exception/CrowdTestProjectException.java

@@ -0,0 +1,12 @@
+package com.mooctest.crowd.domain.exception;
+
+/**
+ * @author guochao
+ * @date 2019-07-30 20:19
+ */
+public class CrowdTestProjectException extends BaseException {
+
+    public CrowdTestProjectException(String msg){
+        super(msg);
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/exception/CrowdTestReportException.java

@@ -0,0 +1,11 @@
+package com.mooctest.crowd.domain.exception;
+
+/**
+ * @author guochao
+ * @date 2019-07-30 17:24
+ */
+public class CrowdTestReportException extends BaseException {
+    public CrowdTestReportException(String msg) {
+        super(msg);
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/exception/CrowdTestTaskException.java

@@ -0,0 +1,11 @@
+package com.mooctest.crowd.domain.exception;
+
+/**
+ * @author guochao
+ * @date 2019-07-30 16:25
+ */
+public class CrowdTestTaskException extends BaseException {
+    public CrowdTestTaskException(String msg){
+        super(msg);
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/exception/EvaluationAgencyNotExistException.java

@@ -0,0 +1,14 @@
+package com.mooctest.crowd.domain.exception;
+
+import lombok.NoArgsConstructor;
+
+/**
+ * @author guochao
+ * @date 2019-07-30 09:15
+ */
+@NoArgsConstructor
+public class EvaluationAgencyNotExistException extends BaseException {
+    public EvaluationAgencyNotExistException(String msg){
+        super(msg);
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/exception/EvaluationAgencyResourceNotExist.java

@@ -0,0 +1,12 @@
+package com.mooctest.crowd.domain.exception;
+
+/**
+ * @author guochao
+ * @date 2019-08-14 20:54
+ */
+public class EvaluationAgencyResourceNotExist  extends BaseException {
+
+    public EvaluationAgencyResourceNotExist(String msg){
+        super(msg);
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/exception/Excel2ProjectException.java

@@ -0,0 +1,33 @@
+package com.mooctest.crowd.domain.exception;
+
+import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-11 22:46
+ */
+@NoArgsConstructor
+public class Excel2ProjectException extends BaseException {
+    private List<String> errorLog;
+
+    public Excel2ProjectException(List<String> errorLog){
+        this.errorLog = errorLog;
+    }
+
+    public Excel2ProjectException(List<String> errorLog, String msg){
+        super(msg);
+        this.errorLog = errorLog;
+    }
+
+    public String getErrorLogs() {
+        String logs = "";
+        for (String s : errorLog){
+            logs += (s+"\n");
+        }
+        return logs;
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/exception/PermissionNotFoundException.java

@@ -0,0 +1,4 @@
+package com.mooctest.crowd.domain.exception;
+
+public class PermissionNotFoundException extends BaseException {
+}

core/src/main/java/com/mooctest/crowd/domain/exception/RoleNotFoundException.java

@@ -0,0 +1,4 @@
+package com.mooctest.crowd.domain.exception;
+
+public class RoleNotFoundException extends BaseException {
+}

core/src/main/java/com/mooctest/crowd/domain/exception/SystemAdministratorException.java

@@ -0,0 +1,12 @@
+package com.mooctest.crowd.domain.exception;
+
+/**
+ * @author guochao
+ * @date 2019-08-24 09:56
+ */
+public class SystemAdministratorException extends BaseException {
+
+    public SystemAdministratorException(String msg){
+        super(msg);
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/exception/UnauthorizedException.java

@@ -0,0 +1,16 @@
+package com.mooctest.crowd.domain.exception;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-06 20:18
+ */
+public class UnauthorizedException extends BaseException {
+    public UnauthorizedException(){
+        super("请登录后访问");
+    }
+
+    public UnauthorizedException(String msg){
+        super(msg);
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/exception/UserNotExistException.java

@@ -0,0 +1,14 @@
+package com.mooctest.crowd.domain.exception;
+
+import lombok.NoArgsConstructor;
+
+/**
+ * @Author: xuexb
+ * @Date: 2019.7.5 14:36
+ */
+@NoArgsConstructor
+public class UserNotExistException extends BaseException {
+    public UserNotExistException(String msg){
+        super(msg);
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/factory/AccountFactory.java

@@ -1,7 +1,6 @@
 package com.mooctest.crowd.domain.factory;
 
 import com.mooctest.crowd.domain.domainobject.Account;
-import org.springframework.beans.factory.annotation.Autowired;
 
 /**
  * @Author: xuexb
@@ -9,9 +8,7 @@ import org.springframework.beans.factory.annotation.Autowired;
  */
 public class AccountFactory {
 
-    @Autowired
-    private static Account account;
     public static Account createAccount() {
-        return account;
+        return new Account();
     }
 }

core/src/main/java/com/mooctest/crowd/domain/factory/CrowdTestProjectFactory.java

@@ -1,8 +1,11 @@
 package com.mooctest.crowd.domain.factory;
 
-import com.mooctest.crowd.domain.domainobject.CrowdTestProject;
+import com.mooctest.crowd.domain.domainobject.*;
 import org.springframework.stereotype.Component;
 
+import java.sql.Date;
+import java.sql.Timestamp;
+
 /**
  * @author guochao
  * @date 2019/7/6 21:43
@@ -13,4 +16,42 @@ public class CrowdTestProjectFactory {
     public static CrowdTestProject createCrowdTestProject() {
         return new CrowdTestProject();
     }
+
+    public static CrowdTestProject defaulstCrowdTestProject() {
+        CrowdTestProject project = new CrowdTestProject();
+        project.setStatus(CrowdTestProjectStatus.HAS_FINISHED);
+        project.setIsDeleted(0);
+        project.setProjectDistributionTypeId(1L);
+        project.setDistributionProvince("江苏");
+        project.setDistributionCity("南京");
+        project.setRegionalManagerId(99222L);
+        project.setUserId(1L);
+        project.setProjectFile("");
+        project.setRequirementFile("");
+        project.setFixedPrice(30000.00);
+        project.setQuotedPrice(30000.00);
+        project.setDeadTime(new Timestamp(new Date(System.currentTimeMillis()).getTime()));
+        project.setEndTime(new Timestamp(new Date(System.currentTimeMillis()).getTime()));
+        return project;
+    }
+
+    public static CrowdTestTask defaultFinishedCrowdTask() {
+        CrowdTestTask task = new CrowdTestTask();
+        task.setStatus(CrowdTestTaskStatus.HAS_FINISHED);
+        task.setEvaluationAgencyId(1l);
+        task.setDistributionType(0l);
+        return task;
+    }
+
+    public static CrowdTestReport defaultProjectReport() {
+        CrowdTestReport report = new CrowdTestReport();
+        report.setScope(0);
+        report.setIsDeleted(0);
+        return report;
+    }
+
+    public static CrowdTestTask defaultTask() {
+        CrowdTestTask task = new CrowdTestTask();
+        return task;
+    }
 }

core/src/main/java/com/mooctest/crowd/domain/factory/UserFactory.java

@@ -0,0 +1,20 @@
+package com.mooctest.crowd.domain.factory;
+
+import com.mooctest.crowd.domain.domainobject.EvaluationAgency;
+import com.mooctest.crowd.domain.domainobject.Role;
+import com.mooctest.crowd.domain.domainobject.User;
+
+/**
+ * @Author: xuexb
+ * @Date: 2019.7.5 15:19
+ */
+public class UserFactory {
+
+    public static User createUser() {
+        return new User();
+    }
+
+    public static EvaluationAgency defaultAgency() {
+        return new EvaluationAgency();
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/model/CrowdTestProject.java

@@ -1,52 +0,0 @@
-package com.mooctest.crowd.domain.model;
-
-import lombok.Data;
-
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.Id;
-import javax.persistence.Table;
-import java.io.File;
-import java.sql.Timestamp;
-
-/**
- * @author guochao
- * @date 2019/7/6 18:27
- */
-@Data
-@Entity
-@Table(name = "crowd_test_project")
-public class CrowdTestProject {
-
-    @Id
-    @GeneratedValue
-    private Long id;
-    private String name;
-    private Long ownerId;
-    private Long managerId;
-    private Long distributionId;
-    private String description;
-    private File projectFile;
-    private File requirement;
-    private double quotedPrice;
-    private double fixedPrice;
-    private String status;
-    private Timestamp creatTime;
-    @Override
-    public String toString() {
-        return "CrowdTestProject{" +
-                "id=" + id +
-                ", name='" + name + '\'' +
-                ", ownerId=" + ownerId +
-                ", managerId=" + managerId +
-                ", distributionId=" + distributionId +
-                ", description='" + description + '\'' +
-                ", projectFile=" + projectFile +
-                ", requirement=" + requirement +
-                ", quotedPrice=" + quotedPrice +
-                ", fixedPrice=" + fixedPrice +
-                ", status='" + status + '\'' +
-                ", creatTime=" + creatTime +
-                '}';
-    }
-}

core/src/main/java/com/mooctest/crowd/domain/model/CrowdTestProjectPO.java

@@ -0,0 +1,114 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.io.Serializable;
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 18:27
+ */
+@Data
+@Entity
+@Table(name = "crowd_test_project")
+public class CrowdTestProjectPO implements Serializable {
+
+    @Id
+    @Column(name = "CTP_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "CTP_CODE")
+    private String code;
+
+    @Column(name = "CTP_NAME")
+    private String name;
+
+    @Column(name = "CTP_U_ID")
+    private Long userId;
+
+    @Column(name = "CTP_RM_ID")
+    private Long regionalManagerId;
+
+    @Column(name = "CTP_PDT_ID")
+    private Long projectDistributionTypeId;
+
+    @Column(name = "CTP_PLATFORM")
+    private String platform;
+
+    @Column(name = "CTP_LINK_MAN")
+    private String linkMan;
+
+    @Column(name = "CTP_Link_MAN_MOBILE")
+    private String linkManMobile;
+
+    @Column(name = "CTP_TYPE")
+    private String type;
+
+    @Column(name = "CTP_DESCRIPTION")
+    private String description;
+
+    @Column(name = "CTP_DISTRIBUTION_PROVINCE")
+    private String distributionProvince;
+
+    @Column(name = "CTP_DISTRIBUTION_CITY")
+    private String distributionCity;
+
+    @Column(name = "CTP_PROJECT_FILE")
+    private String projectFile;
+
+    @Column(name = "CTP_REQUIREMENT_FILE")
+    private String requirementFile;
+
+    @Column(name = "CTP_QUOTED_PRICE")
+    private Double quotedPrice;
+
+//    @Excel(name="项目定价")
+    @Column(name = "CTP_FIXED_PRICE")
+    private Double fixedPrice;
+
+    @Column(name = "CTP_STATUS")
+    private int status;
+
+    @Column(name = "CTP_DEAD_LINE")
+    private Timestamp deadTime;
+
+    @Column(name = "CTP_END_TIME")
+    private Timestamp endTime;
+
+    @Column(name = "CTP_IS_DELETED")
+    private int isDeleted;
+
+    @Column(name = "CTP_CREATE_TIME")
+    private Timestamp createTime;
+
+    @Override
+    public String toString() {
+        return "CrowdTestProjectPO{" +
+                "id=" + id +
+                ", code='" + code + '\'' +
+                ", name='" + name + '\'' +
+                ", userId=" + userId +
+                ", regionalManagerId=" + regionalManagerId +
+                ", projectDistributionTypeId=" + projectDistributionTypeId +
+                ", description='" + description + '\'' +
+                ", platform=" + platform +
+                ", linkMan='" + linkMan + '\'' +
+                ", linkManMobile='" + linkManMobile + '\'' +
+                ", type=" + type +
+                ", distributionProvince='" + distributionProvince + '\'' +
+                ", distributionCity='" + distributionCity + '\'' +
+                ", projectFile='" + projectFile + '\'' +
+                ", requirementFile='" + requirementFile + '\'' +
+                ", quotedPrice=" + quotedPrice +
+                ", fixedPrice=" + fixedPrice +
+                ", status=" + status +
+                ", deadTime=" + deadTime +
+                ", endTime=" + endTime +
+                ", isDeleted=" + isDeleted +
+                ", createTime=" + createTime +
+                '}';
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/model/CrowdTestReport.java

@@ -1,36 +0,0 @@
-package com.mooctest.crowd.domain.model;
-
-import lombok.Data;
-
-import java.sql.Timestamp;
-
-/**
- * @author guochao
- * @date 2019/7/11 14:16
- */
-@Data
-public class CrowdTestReport {
-
-    private Long id;
-    private Long projectId;
-    private Long taskId;
-    private int type;
-    private String description;
-    private String content;
-    private String status;
-    private Timestamp creatTime;
-
-    @Override
-    public String toString() {
-        return "CrowdTestReport{" +
-                "id=" + id +
-                ", projectId=" + projectId +
-                ", taskId=" + taskId +
-                ", type=" + type +
-                ", description='" + description + '\'' +
-                ", content='" + content + '\'' +
-                ", status='" + status + '\'' +
-                ", creatTime=" + creatTime +
-                '}';
-    }
-}

core/src/main/java/com/mooctest/crowd/domain/model/CrowdTestReportPO.java

@@ -0,0 +1,77 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019/7/11 14:16
+ */
+@Data
+@Entity(name = "crowd_test_report")
+public class CrowdTestReportPO {
+
+    @Id
+    @Column(name = "CTR_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "CTR_NAME")
+    private String name;
+
+    @Column(name = "CTR_CODE")
+    private String code;
+
+
+    @Column(name = "CTR_DEPENDENCY_CODE")
+    private String dependencyCode;
+
+    @Column(name = "CTR_TYPE")
+    private String type;
+
+    @Column(name = "CTR_CONTENT")
+    private String content;
+
+    @Column(name = "CTR_TEST_OBJECT")
+    private String testObject;
+
+    @Column(name = "CTR_DESCRIPTION")
+    private String description;
+
+    @Column(name = "CTR_SCOPE")
+    private int scope;
+
+    @Column(name = "CTR_CONCLUSION")
+    private String conclusion;
+
+    @Column(name = "CTR_FILE")
+    private String file;
+
+    @Column(name = "CTR_IS_DELETED")
+    private int isDeleted;
+
+    @Column(name = "CTR_CREATE_TIME")
+    private Timestamp createTime;
+
+
+    @Override
+    public String toString() {
+        return "CrowdTestReportPO{" +
+                "id=" + id +
+                ", name='" + name + '\'' +
+                ", code='" + code + '\'' +
+                ", dependencyCode='" + dependencyCode + '\'' +
+                ", type=" + type +
+                ", content='" + content + '\'' +
+                ", testObject='" + testObject + '\'' +
+                ", description='" + description + '\'' +
+                ", scope=" + scope +
+                ", conclusion='" + conclusion + '\'' +
+                ", file='" + file + '\'' +
+                ", isDeleted=" + isDeleted +
+                ", createTime=" + createTime +
+                '}';
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/model/CrowdTestTask.java

@@ -1,45 +0,0 @@
-package com.mooctest.crowd.domain.model;
-
-import lombok.Data;
-
-import java.io.File;
-import java.sql.Timestamp;
-import java.util.List;
-
-/**
- * @author guochao
- * @date 2019/7/11 14:14
- */
-@Data
-public class CrowdTestTask {
-    private Long id;
-    private String name;
-    private Long projectId;
-    private Long evaluationAgencyId;
-    private int type;
-    private String description;
-    private File requirementFile;
-    private Double price;
-    private String status;
-    private Timestamp creatTime;
-    private List<CrowdTestReport> crowdTestReportList;
-
-
-    @Override
-    public String toString() {
-        return "CrowdTestTask{" +
-                "id=" + id +
-                ", name='" + name + '\'' +
-                ", projectId=" + projectId +
-                ", evaluationAgencyId=" + evaluationAgencyId +
-                ", type=" + type +
-                ", description='" + description + '\'' +
-                ", requirementFile=" + requirementFile +
-                ", price=" + price +
-                ", status='" + status + '\'' +
-                ", creatTime=" + creatTime +
-                ", crowdTestReportList=" + crowdTestReportList +
-                '}';
-    }
-
-}

core/src/main/java/com/mooctest/crowd/domain/model/CrowdTestTaskPO.java

@@ -0,0 +1,96 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019/7/11 14:14
+ */
+@Data
+@Entity
+@Table(name = "crowd_test_task")
+public class
+CrowdTestTaskPO {
+    @Id
+    @Column(name = "CTT_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "CTT_CODE")
+    private String code;
+
+    @Column(name = "CTT_NAME")
+    private String name;
+
+    @Column(name = "CTT_CTP_CODE")
+    private String crowdTestProjectCode;
+
+    @Column(name = "CTT_EA_ID")
+    private Long evaluationAgencyId;
+
+    @Column(name = "CTT_TYPE")
+    private String type;
+
+    @Column(name = "CTT_DESCRIPTION")
+    private String description;
+
+    @Column(name = "CTT_REQUIREMENT_FILE")
+    private String requirementFile;
+
+    @Column(name = "CTT_DISTRIBUTION_TYPE")
+    private Long distributionType;
+
+    @Column(name = "CTT_DISTRIBUTION_PROVINCE")
+    private String distributionProvince;
+
+    @Column(name = "CTT_DISTRIBUTION_CITY")
+    private String distributionCity;
+
+    @Column(name = "CTT_QUOTED_PRICE")
+    private Double quotedPrice;
+
+    @Column(name = "CTT_FIXED_PRICE")
+    private Double fixedPrice;
+
+    @Column(name = "CTT_STATUS")
+    private int status;
+
+    @Column(name = "CTT_DEAD_LINE")
+    private Timestamp deadTime;
+
+    @Column(name = "CTT_END_TIME")
+    private Timestamp endTime;
+
+    @Column(name = "CTT_IS_DELETED")
+    private int isDeleted;
+
+    @Column(name = "CTT_CREATE_TIME")
+    private Timestamp createTime;
+
+    @Override
+    public String toString() {
+        return "CrowdTestTaskPO{" +
+                "id=" + id +
+                ", code='" + code + '\'' +
+                ", name='" + name + '\'' +
+                ", crowdTestProjectCode='" + crowdTestProjectCode + '\'' +
+                ", evaluationAgencyId=" + evaluationAgencyId +
+                ", type=" + type +
+                ", description='" + description + '\'' +
+                ", requirementFile='" + requirementFile + '\'' +
+                ", distributionType=" + distributionType +
+                ", distributionProvince='" + distributionProvince + '\'' +
+                ", distributionCity='" + distributionCity + '\'' +
+                ", quotedPrice=" + quotedPrice +
+                ", fixedPrice=" + fixedPrice +
+                ", status=" + status +
+                ", deadTime=" + deadTime +
+                ", endTime=" + endTime +
+                ", isDeleted='" + isDeleted + '\'' +
+                ", createTime=" + createTime +
+                '}';
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/model/DistributeType.java

@@ -1,16 +0,0 @@
-package com.mooctest.crowd.domain.model;
-
-import lombok.Data;
-
-import java.sql.Timestamp;
-
-/**
- * @author guochao
- * @date 2019/7/15 20:47
- */
-@Data
-public class DistributeType {
-    private Long id;
-    private String name;
-    private Timestamp createTime;
-}

core/src/main/java/com/mooctest/crowd/domain/model/DistributeTypePO.java

@@ -0,0 +1,36 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019/7/15 20:47
+ */
+@Data
+@Entity(name = "project_distribution_type")
+public class DistributeTypePO {
+
+    @Id
+    @Column(name = "PDT_ID")
+    private Long id;
+
+    @Column(name = "PDT_NAME")
+    private String name;
+
+    @Column(name = "PDT_CREATE_TIME")
+    private Timestamp createTime;
+
+    @Override
+    public String toString() {
+        return "DistributeTypePO{" +
+                "id=" + id +
+                ", name='" + name + '\'' +
+                ", createTime=" + createTime +
+                '}';
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/model/EnterpriseAuthenticationPO.java

@@ -0,0 +1,57 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019-08-19 15:47
+ */
+@Data
+@Entity
+@Table(name = "enterprise_authentication")
+public class EnterpriseAuthenticationPO {
+
+    @Id
+    @Column(name = "EA_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "EA_USER_ID")
+    private Long userId;
+
+    @Column(name = "EA_ENTERPRISE_NAME")
+    private String enterpriseName;
+
+    @Column(name = "EA_LEGAL_PERSON_NAME")
+    private String legalPersonName;
+
+    @Column(name = "EA_BUSINESS_LICENSE_PHOTO")
+    private String businessLicensePhoto;
+
+    @Column(name = "EA_UNIFIED_SOCIAL_CREDIT_CODE")
+    private String unifiedSocialCreditCode;
+
+    @Column(name = "EA_BANK_ACCOUNT")
+    private String bankAccount;
+
+    @Column(name = "EA_ADDRESS")
+    private String address;
+
+    @Column(name = "EA_IS_DELETED")
+    private int isDeleted;
+
+    @Column(name = "EA_IS_AUTHENTICATION")
+    private int isAuthentication;
+
+    @Column(name = "EA_NOT_PASS_EXPLAIN")
+    private String explain;
+
+    @Column(name = "EA_CHECK_TIME")
+    private Timestamp checkTime;
+
+    @Column(name = "EA_APPLY_TIME")
+    private Timestamp applyTime;
+}

core/src/main/java/com/mooctest/crowd/domain/model/EvaluationAgency.java

@@ -1,21 +0,0 @@
-package com.mooctest.crowd.domain.model;
-
-import lombok.Data;
-
-import java.sql.Timestamp;
-
-/**
- * @author guochao
- * @date 2019/7/12 1:32
- */
-@Data
-public class EvaluationAgency extends User {
-    private Long id;
-    private Long userId;
-    private String bankAccount;
-    private String address;
-    private String abilities;
-    private String resource;
-    private Timestamp updateTime;
-    private Timestamp expireTime;
-}

core/src/main/java/com/mooctest/crowd/domain/model/EvaluationAgencyAbilityPO.java

@@ -0,0 +1,32 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019/8/12 14:16
+ */
+@Data
+@Entity(name = "evaluation_agency_ability")
+public class EvaluationAgencyAbilityPO {
+
+    @Id
+    @Column(name = "EAA_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "EAA_EA_ID")
+    private Long evaluationAgencyId;
+
+    @Column(name = "EAA_ABILITY_NAME")
+    private String abilityName;
+
+    @Column(name = "EAA_IS_DELETED")
+    private int isDeleted;
+
+    @Column(name = "EAA_CREATE_TIME")
+    private Timestamp createTime;
+}

core/src/main/java/com/mooctest/crowd/domain/model/EvaluationAgencyPO.java

@@ -0,0 +1,56 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019/7/12 1:32
+ */
+@Data
+@Entity(name = "evaluation_agency")
+public class EvaluationAgencyPO{
+
+    @Id
+    @Column(name = "EA_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "EA_U_ID")
+    private Long userId;
+
+    @Column(name = "EA_NAME")
+    private String evaluationAgencyName;
+
+    @Column(name = "EA_BANK_ACCOUNT")
+    private String bankAccount;
+
+    @Column(name = "EA_ADDRESS")
+    private String address;
+
+    @Column(name = "EA_PHOTO")
+    private String agencyPhoto;
+
+    @Column(name = "EA_UPDATE_TIME")
+    private Timestamp updateTime;
+
+    @Column(name = "EA_EXPIRE_TIME")
+    private Timestamp expireTime;
+
+    @Column(name = "EA_IS_AUTHENTICATION")
+    private int isAuthentication;
+
+    @Column(name = "EA_NOT_PASS_EXPLAIN")
+    private String explain;
+
+    @Column(name = "EA_IS_DELETED")
+    private int isDeleted;
+
+    @Column(name = "EA_APPLY_TIME")
+    private Timestamp applyTime;
+
+    @Column(name = "EA_CHECK_TIME")
+    private Timestamp checkTime;
+}

core/src/main/java/com/mooctest/crowd/domain/model/EvaluationAgencyResourcePO.java

@@ -0,0 +1,42 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019/8/12 14:16
+ */
+@Data
+@Entity
+@Table(name = "evaluation_agency_resource")
+public class EvaluationAgencyResourcePO {
+
+    @Id
+    @Column(name = "EAR_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "EAR_EA_ID")
+    private Long evaluationAgencyId;
+
+    @Column(name = "EAR_TYPE")
+    private String type;
+
+    @Column(name = "EAR_NAME")
+    private String name;
+
+    @Column(name = "EAR_TOTAL_NUM")
+    private int totalNum;
+
+    @Column(name = "EAR_AVAILABLE_NUM")
+    private int availableNum;
+
+    @Column(name = "EAR_IS_DELETED")
+    private int isDeleted;
+
+    @Column(name = "EAR_CREATE_TIME")
+    private Timestamp createTime;
+}

core/src/main/java/com/mooctest/crowd/domain/model/GeneralUser.java → core/src/main/java/com/mooctest/crowd/domain/model/GeneralUserPO.java

@@ -7,7 +7,7 @@ import lombok.Data;
  * @date 2019/7/6 18:16
  */
 @Data
-public class GeneralUser extends User {
+public class GeneralUserPO extends UserPO {
     private Long id;
     private Long userId;
 }

core/src/main/java/com/mooctest/crowd/domain/model/Permission.java

@@ -1,16 +0,0 @@
-package com.mooctest.crowd.domain.model;
-
-import lombok.Data;
-
-/**
- * @author guochao
- * @date 2019/7/5 22:51
- */
-@Data
-public class Permission {
-
-    private Long id;
-    private String name;
-    private String resource;
-    private String operation;
-}

core/src/main/java/com/mooctest/crowd/domain/model/PermissionPO.java

@@ -0,0 +1,33 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019/7/5 22:51
+ */
+@Data
+@Entity
+@Table(name = "permission")
+public class PermissionPO {
+
+    @Id
+    @Column(name = "P_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    Long id;
+
+    @Column(name = "P_NAME")
+    private String name;
+
+    @Column(name = "P_RESOURCE")
+    private String resource;
+
+    @Column(name = "P_OPERATION")
+    private String operation;
+
+    @Column(name = "P_CREATE_TIME")
+    private Timestamp createTime;
+}

core/src/main/java/com/mooctest/crowd/domain/model/PersonalAuthenticationPO.java

@@ -0,0 +1,54 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019-08-19 15:47
+ */
+@Data
+@Entity
+@Table(name = "personal_authentication")
+public class PersonalAuthenticationPO {
+
+    @Id
+    @Column(name = "PA_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "PA_USER_ID")
+    private Long userId;
+
+    @Column(name = "PA_REAL_NAME")
+    private String realName;
+
+    @Column(name = "PA_ID_CARD")
+    private String IDCard;
+
+    @Column(name = "PA_ID_CARD_PHOTO")
+    private String IDCardPhoto;
+
+    @Column(name = "PA_BANK_ACCOUNT")
+    private String bankAccount;
+
+    @Column(name = "PA_ADDRESS")
+    private String address;
+
+    @Column(name = "PA_IS_DELETED")
+    private int isDeleted;
+
+    @Column(name = "PA_IS_AUTHENTICATION")
+    private int isAuthentication;
+
+    @Column(name = "PA_NOT_PASS_EXPLAIN")
+    private String explain;
+
+    @Column(name = "PA_APPLY_TIME")
+    private Timestamp applyTime;
+
+    @Column(name = "PA_CHECK_TIME")
+    private Timestamp checkTime;
+}

core/src/main/java/com/mooctest/crowd/domain/model/ProvincePO.java

@@ -0,0 +1,30 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+
+/**
+ * @author guochao
+ * @date 2019-07-30 10:31
+ */
+@Data
+@Entity
+@Table(name = "province")
+public class ProvincePO {
+    @Id
+    @Column(name = "P_CODE")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long code;
+
+    @Column(name = "P_NAME")
+    private String name;
+
+    @Override
+    public String toString() {
+        return "Province{" +
+                "code=" + code +
+                ", name='" + name + '\'' +
+                '}';
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/model/RankInfo.java

@@ -0,0 +1,18 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-20 01:19
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class RankInfo {
+    Double totalPrice;
+    Long entityId;
+}

core/src/main/java/com/mooctest/crowd/domain/model/RegionalManager.java

@@ -1,14 +0,0 @@
-package com.mooctest.crowd.domain.model;
-
-import lombok.Data;
-
-/**
- * @author guochao
- * @date 2019/7/9 14:16
- */
-@Data
-public class RegionalManager extends User {
-    private Long id;
-    private Long userId;
-    private String regional;
-}

core/src/main/java/com/mooctest/crowd/domain/model/RegionalManagerToRegionalPO.java

@@ -0,0 +1,40 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019/7/9 14:16
+ */
+@Data
+@Entity
+@Table(name = "regional_manager_to_regional")
+public class RegionalManagerToRegionalPO {
+
+    @Id
+    @Column(name = "RMTP_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "RMTP_U_ID")
+    private Long userId;
+
+    @Column(name = "RMTP_R_CODE")
+    private Long provinceCode;
+
+    @Column(name = "RMTP_PROVINCE")
+    private String province;
+
+    @Column(name = "RMTP_CITY")
+    private String city;
+
+    @Column(name = "RMTP_IS_DELETED")
+    private int isDeleted;
+
+    @Column(name = "RMTP_CREATED_TIME")
+    private Timestamp createTime;
+
+}

core/src/main/java/com/mooctest/crowd/domain/model/RegionalPO.java

@@ -0,0 +1,34 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+
+/**
+ * @author guochao
+ * @date 2019-07-30 10:31
+ */
+@Data
+@Entity
+@Table(name = "regional")
+public class RegionalPO {
+    @Id
+    @Column(name = "R_CODE")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "R_P_CODE")
+    private Long provinceCode;
+
+    @Column(name = "R_NAME")
+    private String name;
+
+    @Override
+    public String toString() {
+        return "RegionalPO{" +
+                "id=" + id +
+                ", provinceCode=" + provinceCode +
+                ", name='" + name + '\'' +
+                '}';
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/model/Role.java

@@ -1,13 +0,0 @@
-package com.mooctest.crowd.domain.model;
-
-import lombok.Data;
-
-/**
- * @author guochao
- * @date 2019/7/6 17:54
- */
-@Data
-public class Role {
-    private Long id;
-    private String name;
-}

core/src/main/java/com/mooctest/crowd/domain/model/RolePO.java

@@ -0,0 +1,25 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+@Entity(name = "role")
+public class RolePO {
+    @Id
+    @Column(name = "R_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "R_NAME")
+    private String name;
+
+    @Column(name = "R_CREATE_TIME")
+    private Timestamp createTime;
+}

core/src/main/java/com/mooctest/crowd/domain/model/RoleToPermissionPO.java

@@ -0,0 +1,29 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+@Entity
+@Table(name="role_to_permission")
+public class RoleToPermissionPO {
+    @Id
+    @Column(name = "RTP_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "RTP_R_ID")
+    private Long roleId;
+
+    @Column(name = "RTP_P_ID")
+    private Long permissionId;
+
+    @Column(name = "RTP_CREATE_TIME")
+    private Timestamp createTime;
+}

core/src/main/java/com/mooctest/crowd/domain/model/SystemAdministratorToUserPO.java

@@ -0,0 +1,29 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019-08-24 09:37
+ */
+@Data
+@Entity
+@Table(name="system_administrator_to_user")
+public class SystemAdministratorToUserPO {
+    @Id
+    @Column(name = "SATU_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "SATU_U_ID")
+    private Long userId;
+
+    @Column(name = "SATU_IS_DELETED")
+    private int isDeleted;
+
+    @Column(name = "SATU_CREATE_TIME")
+    private Timestamp createTime;
+}

core/src/main/java/com/mooctest/crowd/domain/model/User.java → core/src/main/java/com/mooctest/crowd/domain/model/UserPO.java

@@ -12,10 +12,11 @@ import java.sql.Timestamp;
 @Data
 @Table(name = "user")
 @Entity
-public class User {
+public class UserPO {
 
+//    @GeneratedValue(strategy = GenerationType.IDENTITY)
     @Id
-    @GeneratedValue
+    @Column(name = "U_ID")
     private Long id;
 
     @Column(name = "U_NAME")
@@ -45,12 +46,13 @@ public class User {
     @Column(name = "U_PHOTO_URL")
     private String photoUrl;
 
-    @Column(name = "U_IS_AVAILABILE")
-    private String isAvailable;
+    @Column(name = "U_IS_AVAILABLE")
+    private int isAvailable;
 
     @Column(name = "U_IS_DELETED")
-    private String isDeleted;
+    private int isDeleted;
 
     @Column(name = "U_CREATE_TIME")
     private Timestamp createTime;
+
 }

core/src/main/java/com/mooctest/crowd/domain/model/UserToRolePO.java

@@ -0,0 +1,31 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.*;
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+@Entity
+@Table(name="user_to_role")
+public class UserToRolePO {
+    @Id
+    @Column(name = "UTR_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "UTR_R_ID")
+    private Long roleId;
+
+    @Column(name = "UTR_U_ID")
+    private Long userId;
+
+    @Column(name = "UTR_CREATE_TIME")
+    private Timestamp createTime;
+}

core/src/main/java/com/mooctest/crowd/domain/repository/AccountUTRepo.java

@@ -2,9 +2,11 @@ package com.mooctest.crowd.domain.repository;
 
 import com.mooctest.crowd.domain.dao.UserDao;
 import com.mooctest.crowd.domain.domainobject.Account;
+import com.mooctest.crowd.domain.domainobject.User;
 import com.mooctest.crowd.domain.exception.AccountNotExistException;
 import com.mooctest.crowd.domain.factory.AccountFactory;
-import com.mooctest.crowd.domain.model.User;
+import com.mooctest.crowd.domain.model.UserPO;
+import com.mooctest.crowd.domain.util.Converter;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -22,20 +24,13 @@ public class AccountUTRepo implements IAccountRepo {
     @Autowired
     private UserDao userDao;
 
-    @Autowired
-    private User user;
-
     @Override
-    public Account getByMobileNum(String mobileNum) throws AccountNotExistException {
+    public User getByMobileNum(String mobileNum) throws AccountNotExistException {
 
-        System.out.println("mobileNum "  + mobileNum);
-        User user = userDao.findByMobile(mobileNum);
-        System.out.println("user "  + user);
-        if (user != null) {
-            Account account = AccountFactory.createAccount();
-            account.setMobileNum(user.getMobile());
-            account.setPassword(user.getPassword());
-            return account;
+        UserPO userPo = userDao.findByMobile(mobileNum);
+        System.out.println("user "  + userPo);
+        if (userPo != null) {
+            return Converter.convert(User.class,userPo);
         }
         throw new AccountNotExistException();
     }
@@ -65,18 +60,19 @@ public class AccountUTRepo implements IAccountRepo {
 
     @Override
     public Account addAccount(Account account){
-        user.setMobile(account.getMobileNum());
-        user.setPassword(account.getPassword());
-        User saveUser = userDao.save(user);
+        UserPO userPo = new UserPO();
+        userPo.setMobile(account.getMobileNum());
+        userPo.setPassword(account.getPassword());
+        UserPO saveUserPO = userDao.save(userPo);
         Account returnAccount = AccountFactory.createAccount();
-        returnAccount.setMobileNum(saveUser.getMobile());
-        returnAccount.setPassword(saveUser.getPassword());
+        returnAccount.setMobileNum(saveUserPO.getMobile());
+        returnAccount.setPassword(saveUserPO.getPassword());
         return returnAccount;
     }
 
     @Override
     public boolean removeAccount(Account account) throws AccountNotExistException {
-        Account byMobileNum = this.getByMobileNum(account.getMobileNum());
+        User byMobileNum = this.getByMobileNum(account.getMobileNum());
         if(byMobileNum != null){
             return true;
         }
@@ -85,11 +81,17 @@ public class AccountUTRepo implements IAccountRepo {
 
     @Override
     public Account updateAccount(Account account) throws AccountNotExistException {
-        Account byMobileNum = this.getByMobileNum(account.getMobileNum());
+        User byMobileNum = this.getByMobileNum(account.getMobileNum());
         if(byMobileNum != null){
-            byMobileNum = account;
-            return byMobileNum;
+//            byMobileNum = account;
+//            return byMobileNum;
+            return null;
         }
         throw new AccountNotExistException();
     }
+
+    public User save(User user) {
+        UserPO userPO = userDao.save(Converter.convert(UserPO.class, user));
+        return Converter.convert(User.class,userPO);
+    }
 }

core/src/main/java/com/mooctest/crowd/domain/repository/CrowdTestProjectRepo.java

@@ -1,15 +1,24 @@
 package com.mooctest.crowd.domain.repository;
 
-import com.mooctest.crowd.domain.domainobject.*;
+import com.mooctest.crowd.domain.dao.CrowdTestProjectDao;
+import com.mooctest.crowd.domain.dao.CrowdTestReportDao;
+import com.mooctest.crowd.domain.dao.CrowdTestTaskDao;
+import com.mooctest.crowd.domain.domainobject.CrowdTestProject;
+import com.mooctest.crowd.domain.domainobject.CrowdTestReport;
+import com.mooctest.crowd.domain.domainobject.CrowdTestTask;
+import com.mooctest.crowd.domain.domainobject.DeletedStatus;
 import com.mooctest.crowd.domain.exception.CrowdTestProjectNotExistException;
-import com.mooctest.crowd.domain.factory.CrowdTestProjectFactory;
+import com.mooctest.crowd.domain.model.CrowdTestProjectPO;
+import com.mooctest.crowd.domain.model.CrowdTestReportPO;
+import com.mooctest.crowd.domain.model.CrowdTestTaskPO;
+import com.mooctest.crowd.domain.util.Converter;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
-import java.text.SimpleDateFormat;
 import java.util.ArrayList;
-import java.util.Date;
 import java.util.List;
+import java.util.Optional;
 
 /**
  * @author guochao
@@ -19,121 +28,221 @@ import java.util.List;
 @Component
 public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
 
-    public CrowdTestProject getByName(String name) {
-        if("PROJECT_ONE".equals(name)){
-            CrowdTestProject crowdTestProject = CrowdTestProjectFactory.createCrowdTestProject();
-            crowdTestProject.setName("PROJECT_ONE");
-            crowdTestProject.setDescription("DESCRIPTION");
-            crowdTestProject.setProjectFile("PROJECTFILE.TXT");
-            crowdTestProject.setRequirementFile("REQUIREMENT.TXT");
-            crowdTestProject.setQuotedPrice(200.00);
-            return crowdTestProject;
-        }else {
-            return null;
+    @Autowired
+    private CrowdTestProjectDao crowdTestProjectDao;
+
+    @Autowired
+    private CrowdTestTaskDao crowdTestTaskDao;
+
+    @Autowired
+    private CrowdTestReportDao crowdTestReportDao;
+
+    @Override
+    public CrowdTestProject getByID(Long crowdTestProjectId) throws CrowdTestProjectNotExistException {
+
+        CrowdTestProjectPO crowdTestProjectPO = crowdTestProjectDao.findByIdAndIsDeleted(crowdTestProjectId, DeletedStatus.isNotDeleted);
+        if (crowdTestProjectPO == null) {
+            throw new CrowdTestProjectNotExistException();
+        }else{
+            CrowdTestProject crowdTestProjectResult = getCrowdTestProjectAndTaskAndReportByCrowdTestProjectPO(crowdTestProjectPO);
+            return crowdTestProjectResult;
         }
     }
 
     @Override
-    public CrowdTestProject getByID(Long id) throws CrowdTestProjectNotExistException {
-        if(id == 1L){
-            // project
-            CrowdTestProject crowdTestProject = CrowdTestProjectFactory.createCrowdTestProject();
-            crowdTestProject.setId(id);
-            crowdTestProject.setName("PROJECT_ONE");
-            ProjectDistributeType projectDistributeType = new ProjectDistributeType();
-            projectDistributeType.setId(123L);
-            crowdTestProject.setProjectDistributeType(projectDistributeType);
-            crowdTestProject.setDescription("DESCRIPTION");
-            crowdTestProject.setProjectFile("PROJECTFILE.TXT");
-            crowdTestProject.setRequirementFile("REQUIREMENT.TXT");
-            crowdTestProject.setQuotedPrice(200.00);
-
-            // report
-            List<CrowdTestReport> crowdTestReportList = new ArrayList<CrowdTestReport>();
-            CrowdTestReport crowdTestReport = new CrowdTestReport();
-            crowdTestReport.setId(1001L);
-            crowdTestReport.setCrowdTestTaskId(101L);
-            crowdTestReport.setStatus(CrowdTestReportStatus.CREATED);
-            crowdTestReportList.add(crowdTestReport);
-
-            // task
-            List<CrowdTestTask> crowdTestTaskList = new ArrayList<CrowdTestTask>();
-            CrowdTestTask crowdTestTask = new CrowdTestTask();
-            crowdTestTask.setId(101L);
-            crowdTestTask.setCrowdTestProjectId(1L);
-            crowdTestTask.setPrice(100.00);
-            crowdTestTask.setCrowdTestReportList(crowdTestReportList);
-            crowdTestTaskList.add(crowdTestTask);
-            crowdTestProject.setCrowdTestTaskList(crowdTestTaskList);
-
-            return crowdTestProject;
+    public CrowdTestProject getByProjectCode(String crowdTestProjectCode) throws CrowdTestProjectNotExistException {
+        CrowdTestProjectPO crowdTestProjectPO = crowdTestProjectDao.findByCodeAndIsDeleted(crowdTestProjectCode, DeletedStatus.isNotDeleted);
+        if (crowdTestProjectPO == null) {
+            throw new CrowdTestProjectNotExistException();
+        }else{
+            CrowdTestProject crowdTestProjectResult = getCrowdTestProjectAndTaskAndReportByCrowdTestProjectPO(crowdTestProjectPO);
+            return crowdTestProjectResult;
         }
-        throw new CrowdTestProjectNotExistException();
     }
 
     @Override
-    public List<CrowdTestProject> getByIDList(String[] ids) {
-        return null;
+    public List<CrowdTestProject> getCrowdListByUserId(Long userId) {
+        List<CrowdTestProjectPO> crowdTestProjectPOList = crowdTestProjectDao.findByUserIdAndIsDeleted(userId, DeletedStatus.isNotDeleted);
+        return getCrowdTestProjects(crowdTestProjectPOList);
+    }
+
+    @Override
+    public List<CrowdTestProject> getCrowdListByRegionalManagerId(Long regionalManagerId) {
+        List<CrowdTestProjectPO> crowdTestProjectPOList = crowdTestProjectDao.findByRegionalManagerIdAndIsDeleted(regionalManagerId,DeletedStatus.isNotDeleted);
+        return getCrowdTestProjects(crowdTestProjectPOList);
     }
 
 
     @Override
-    public CrowdTestProject addCrowdTestProject(CrowdTestProject crowdTestProject) throws CrowdTestProjectNotExistException {
-        if(this.getByName(crowdTestProject.getName()) != null){
-            String reason = "测试项目已存在";
-            createLogForCreateTestProject(crowdTestProject, reason);
-            return null;
-        }else {
-            return crowdTestProject;
+    public List<CrowdTestProject> getAllCrowdTestProject() {
+        List<CrowdTestProjectPO> crowdTestProjectPOList = crowdTestProjectDao.findAllByIsDeleted(DeletedStatus.isNotDeleted);
+        return getCrowdTestProjects(crowdTestProjectPOList);
+    }
+
+    @Override
+    public void saveCrowdTestProject(CrowdTestProject crowdTestProject) {
+        CrowdTestProjectPO crowdTestProjectPO = Converter.convert(CrowdTestProjectPO.class, crowdTestProject);
+        crowdTestProjectDao.save(crowdTestProjectPO);
+
+        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
+        if(crowdTestTaskList != null){
+            for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+                CrowdTestTaskPO crowdTestTaskPO = Converter.convert(CrowdTestTaskPO.class, crowdTestTask);
+                crowdTestTaskDao.save(crowdTestTaskPO);
+                List<CrowdTestReport> crowdTestReportList = crowdTestTask.getCrowdTestReportList();
+                if(crowdTestReportList != null){
+                    for(CrowdTestReport crowdTestReport : crowdTestReportList){
+                        CrowdTestReportPO crowdTestReportPO = Converter.convert(CrowdTestReportPO.class, crowdTestReport);
+                        crowdTestReportDao.save(crowdTestReportPO);
+                    }
+                }
+            }
         }
 
+        //保存项目报告
+        CrowdTestReport crowdTestReportForProject = crowdTestProject.getCrowdTestReportForProject();
+        if(crowdTestReportForProject != null){
+            CrowdTestReportPO crowdTestReportForProjectPO = Converter.convert(CrowdTestReportPO.class, crowdTestReportForProject);
+            crowdTestReportDao.save(crowdTestReportForProjectPO);
+        }
     }
 
-    private void createLogForCreateTestProject(CrowdTestProject crowdTestProject, String reason) {
-        Object testProjectName = crowdTestProject.getName();
-        Date date = new Date();
-        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
-        log.error("用户{}创建项目失败,失败时间：{},失败原因：{}",new Object[]{testProjectName,df.format(date), reason});
+//    @Override
+//    public void removeCrowdTestProject(String crowdTestProjectCode){
+//        CrowdTestProject crowdTestProject = getByProjectCode(crowdTestProjectCode);
+//        crowdTestProjectDao.delete(Converter.convert(CrowdTestProjectPO.class, crowdTestProject));
+//    }
+
+    public void removeCrowdTestProjectList(List<CrowdTestProject> crowdTestProjectList) {
+        List<CrowdTestProjectPO> crowdTestProjectPOList = new ArrayList<>();
+        for(CrowdTestProject crowdTestProject : crowdTestProjectList){
+            CrowdTestProjectPO crowdTestProjectPO = Converter.convert(CrowdTestProjectPO.class, crowdTestProject);
+            crowdTestProjectPOList.add(crowdTestProjectPO);
+        }
+        crowdTestProjectDao.deleteAll(crowdTestProjectPOList);
     }
 
-    @Override
-    public boolean removeCrowdTestProject(CrowdTestProject crowdTestProject) throws CrowdTestProjectNotExistException {
-        if(crowdTestProject.getId().equals(1L)){
-            return true;
-        }
-        throw new CrowdTestProjectNotExistException();
+
+//    /**
+//     * 新建项目
+//     * @param crowdTestProject
+//     * @return
+//     */
+//    @Override
+//    public CrowdTestProject saveCreateCrowdTestProject(CrowdTestProject crowdTestProject) {
+//        CrowdTestProjectPO crowdTestProjectPO = Converter.convert(CrowdTestProjectPO.class, crowdTestProject);
+//        CrowdTestProjectPO saveResult = crowdTestProjectDao.save(crowdTestProjectPO);
+//        return Converter.convert(CrowdTestProject.class, saveResult);
+//    }
+//
+//    /**
+//     * 在项目上新建一个任务进行保存
+//     * @param crowdTestProjectCode, crowdTestTask
+//     * @return
+//     */
+//    @Override
+//    public boolean saveCreateCrowdTestTask(String crowdTestProjectCode,CrowdTestTask crowdTestTask) {
+//        CrowdTestTaskPO crowdTestTaskPO = Converter.convert(CrowdTestTaskPO.class, crowdTestTask);
+//        crowdTestTaskDao.save(crowdTestTaskPO);
+//        return true;
+//    }
+//
+//
+//
+//    @Override
+//    public boolean saveCreateCrowdTestReport(String crowdTestProjectCode, String crowdTestTaskCode, CrowdTestReport crowdTestReport) {
+//        CrowdTestProject crowdTestProject = getByProjectCode(crowdTestProjectCode);
+//        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
+//        for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+//            if(crowdTestTaskCode.equals(crowdTestTask.getCode())){
+//                CrowdTestReportPO crowdTestReportPO = Converter.convert(CrowdTestReportPO.class, crowdTestReport);
+//                crowdTestReportDao.save(crowdTestReportPO);
+//            }
+//        }
+//
+//        return true;
+//    }
+
+
+    /**
+     * 根据projectId删除Project
+     * @param projectId
+     * @return boolean
+     */
+    public void deleteByProjectId(Long projectId){
+        Optional<CrowdTestProjectPO> project = crowdTestProjectDao.findById(projectId);
+        if (!project.isPresent())
+            throw new CrowdTestProjectNotExistException();
+        crowdTestProjectDao.delete(project.get());
     }
 
-    @Override
-    public CrowdTestProject updateCrowdTestProject(CrowdTestProject crowdTestProject) throws CrowdTestProjectNotExistException {
-        CrowdTestProject oldCrowdTestProject = getByID(crowdTestProject.getId());
-        if(oldCrowdTestProject.getId().equals(crowdTestProject.getId())){
-            oldCrowdTestProject = crowdTestProject;
-            return oldCrowdTestProject;
+    /**
+     * 通过项目信息获取项目-任务-报告信息
+     * @param crowdTestProjectPO
+     * @return
+     */
+    private CrowdTestProject getCrowdTestProjectAndTaskAndReportByCrowdTestProjectPO(CrowdTestProjectPO crowdTestProjectPO) {
+        CrowdTestProject crowdTestProjectResult = Converter.convert(CrowdTestProject.class, crowdTestProjectPO);
+        List<CrowdTestTaskPO> crowdTestTaskPOList = crowdTestTaskDao.findByCrowdTestProjectCodeAndIsDeleted(crowdTestProjectPO.getCode(), DeletedStatus.isNotDeleted);
+
+        List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
+        for(CrowdTestTaskPO crowdTestTaskPO : crowdTestTaskPOList){
+            CrowdTestTask crowdTestTaskResult = Converter.convert(CrowdTestTask.class, crowdTestTaskPO);
+            // 检索任务中的所有的报告
+            List<CrowdTestReport> crowdTestReportListResult = getCrowdTestReportByCrowdTestTask(crowdTestTaskPO.getCode());
+            crowdTestTaskResult.setCrowdTestReportList(crowdTestReportListResult);
+            crowdTestTaskListResult.add(crowdTestTaskResult);
+        }
+        crowdTestProjectResult.setCrowdTestTaskList(crowdTestTaskListResult);
+
+        //检索出项目报告
+        List<CrowdTestReportPO> crowdTestProjectReportPOList = crowdTestReportDao.findByDependencyCodeAndIsDeleted(crowdTestProjectResult.getCode(), DeletedStatus.isNotDeleted);
+        if(crowdTestProjectReportPOList.size() != 0){
+            CrowdTestReportPO crowdTestProjectReportPO = crowdTestProjectReportPOList.get(0);
+            CrowdTestReport crowdTestProjectReport = Converter.convert(CrowdTestReport.class, crowdTestProjectReportPO);
+            crowdTestProjectResult.setCrowdTestReportForProject(crowdTestProjectReport);
         }
-        throw new CrowdTestProjectNotExistException();
+        return crowdTestProjectResult;
     }
 
-    @Override
-    public CrowdTestProject updateCrowdTestProjectStatus(Long id, String status) throws CrowdTestProjectNotExistException {
-        if (this.getByID(id).getId().equals(id)){
-            CrowdTestProject crowdTestProject = this.getByID(id);
-            crowdTestProject.setStatus(status);
-            return crowdTestProject;
+    /**
+     * 通过任务信息获取报告信息
+     * @param crowdTestTaskCode
+     * @return
+     */
+    private List<CrowdTestReport> getCrowdTestReportByCrowdTestTask(String crowdTestTaskCode) {
+        List<CrowdTestReportPO> crowdTestReportPOList = crowdTestReportDao.findByDependencyCodeAndIsDeleted(crowdTestTaskCode, DeletedStatus.isNotDeleted);
+        List<CrowdTestReport> crowdTestReportListResult = new ArrayList<>();
+        for(CrowdTestReportPO crowdTestReportPO : crowdTestReportPOList){
+            CrowdTestReport crowdTestReportResult = Converter.convert(CrowdTestReport.class, crowdTestReportPO);
+            crowdTestReportListResult.add(crowdTestReportResult);
         }
-        throw new CrowdTestProjectNotExistException();
+        return crowdTestReportListResult;
     }
 
-    public boolean updateCrowdTestProjectList(List<CrowdTestProject> crowdTestProjects) throws CrowdTestProjectNotExistException {
-        List<CrowdTestProject> oldCrowdTestProjects = new ArrayList<CrowdTestProject>();
-        for (CrowdTestProject crowdTestProject : crowdTestProjects){
-            if (crowdTestProject.getId().equals(1L) || crowdTestProject.getId().equals(2L)){
-                oldCrowdTestProjects.add(crowdTestProject);
-            }else{
-                throw new CrowdTestProjectNotExistException();
-            }
+    /**
+     * 根据项目列表获取项目-任务-报告信息
+     * @param crowdTestProjectPOList
+     * @return
+     */
+    private List<CrowdTestProject> getCrowdTestProjects(List<CrowdTestProjectPO> crowdTestProjectPOList) {
+        List<CrowdTestProject> crowdTestProjectListResult = new ArrayList<>();
+        for (CrowdTestProjectPO crowdTestProjectPO : crowdTestProjectPOList) {
+            CrowdTestProject crowdTestProjectResult = getCrowdTestProjectAndTaskAndReportByCrowdTestProjectPO(crowdTestProjectPO);
+            crowdTestProjectListResult.add(crowdTestProjectResult);
         }
-        return true;
+        return crowdTestProjectListResult;
+    }
+
+    public long getAllProjectNum(){
+        return crowdTestProjectDao.count();
+    }
+
+    public long getAllTaskNum(){
+        return crowdTestTaskDao.count();
+    }
 
+    public long getAllReportNum(){
+        return crowdTestReportDao.count();
     }
 }

core/src/main/java/com/mooctest/crowd/domain/repository/EvaluationAgencyRepo.java

@@ -0,0 +1,88 @@
+package com.mooctest.crowd.domain.repository;
+
+import com.mooctest.crowd.domain.dao.AgencyAbilityDao;
+import com.mooctest.crowd.domain.dao.AgencyResourceDao;
+import com.mooctest.crowd.domain.domainobject.DeletedStatus;
+import com.mooctest.crowd.domain.domainobject.EvaluationAgencyAbility;
+import com.mooctest.crowd.domain.domainobject.EvaluationAgencyResource;
+import com.mooctest.crowd.domain.exception.EvaluationAgencyResourceNotExist;
+import com.mooctest.crowd.domain.model.EvaluationAgencyAbilityPO;
+import com.mooctest.crowd.domain.model.EvaluationAgencyResourcePO;
+import com.mooctest.crowd.domain.util.Converter;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * @author guochao
+ * @date 2019-08-14 09:51
+ */
+@Component
+public class EvaluationAgencyRepo implements IEvaluationAgencyRepo {
+    @Autowired
+    private AgencyResourceDao agencyResourceDao;
+
+    @Autowired
+    private AgencyAbilityDao agencyAbilityDao;
+
+    @Override
+    public EvaluationAgencyResource findById(Long id){
+        Optional<EvaluationAgencyResourcePO> evaluationAgencyResourcePOOptional = agencyResourceDao.findById(id);
+        if(!evaluationAgencyResourcePOOptional.isPresent()){
+            throw new EvaluationAgencyResourceNotExist("测评机构资源不存在");
+        }else{
+            return Converter.convert(EvaluationAgencyResource.class, evaluationAgencyResourcePOOptional.get());
+        }
+    }
+
+    @Override
+    public List<EvaluationAgencyResource> findByEvaluationAgencyId(Long evaluationAgencyId){
+        List<EvaluationAgencyResourcePO> evaluationAgencyResourcePOList = agencyResourceDao.findByEvaluationAgencyIdAndIsDeleted(evaluationAgencyId, DeletedStatus.isNotDeleted);
+        return evaluationAgencyResourcePOList.stream().map(evaluationAgencyResourcePO -> Converter.convert(EvaluationAgencyResource.class, evaluationAgencyResourcePO)).collect(Collectors.toList());
+
+    }
+
+
+    public void moveEvaluationAgencyResource(List<EvaluationAgencyResource> evaluationAgencyResourceList) {
+        List<EvaluationAgencyResourcePO> evaluationAgencyResourcePOList = evaluationAgencyResourceList.stream()
+                .map(evaluationAgencyResource -> Converter.convert(EvaluationAgencyResourcePO.class, evaluationAgencyResource))
+                .collect(Collectors.toList());
+        agencyResourceDao.deleteAll(evaluationAgencyResourcePOList);
+    }
+
+    @Override
+    public EvaluationAgencyResource saveEvaluationAgencyResource(EvaluationAgencyResource evaluationAgencyResource){
+        EvaluationAgencyResourcePO evaluationAgencyResourceResult = agencyResourceDao.save(Converter.convert(EvaluationAgencyResourcePO.class, evaluationAgencyResource));
+        return Converter.convert(EvaluationAgencyResource.class, evaluationAgencyResourceResult);
+    }
+
+//    public List<EvaluationAgencyResource> saveAllResource(List<EvaluationAgencyResource> sourceList){
+//        List<EvaluationAgencyResourcePO> evaluationAgencyResourcePOList = agencyResourceDao.saveAll(sourceList.stream().map(source -> Converter.convert(EvaluationAgencyResourcePO.class, source)).collect(Collectors.toList()));
+//        return evaluationAgencyResourcePOList.stream().map(sourcePO -> Converter.convert(EvaluationAgencyResource.class, sourcePO)).collect(Collectors.toList());
+//    }
+
+
+    //能力
+    @Override
+    public EvaluationAgencyAbility saveEvaluationAgencyAbility(EvaluationAgencyAbility EvaluationAgencyAbility){
+        EvaluationAgencyAbilityPO evaluationAgencyAbilityPO = agencyAbilityDao.save(Converter.convert(EvaluationAgencyAbilityPO.class, EvaluationAgencyAbility));
+        return Converter.convert(EvaluationAgencyAbility.class, evaluationAgencyAbilityPO);
+    }
+
+//    public List<EvaluationAgencyAbility> saveAllAbility(List<EvaluationAgencyAbility> abilityList){
+//        List<EvaluationAgencyAbilityPO> evaluationAgencyAbilityPOList = agencyAbilityDao.saveAll(abilityList.stream().map(source -> Converter.convert(EvaluationAgencyAbilityPO.class, source)).collect(Collectors.toList()));
+//        return evaluationAgencyAbilityPOList.stream().map(abilityPO -> Converter.convert(EvaluationAgencyAbility.class, abilityPO)).collect(Collectors.toList());
+//    }
+
+    @Override
+    public void moveEvaluationAgencyAbility(List<EvaluationAgencyAbility> evaluationAgencyAbilityList){
+        List<EvaluationAgencyAbilityPO> evaluationAgencyAbilityPOList = evaluationAgencyAbilityList.stream()
+                .map(evaluationAgencyAbility -> Converter.convert(EvaluationAgencyAbilityPO.class, evaluationAgencyAbility))
+                .collect(Collectors.toList());
+        agencyAbilityDao.deleteAll(evaluationAgencyAbilityPOList);
+    }
+
+}

core/src/main/java/com/mooctest/crowd/domain/repository/IAccountRepo.java

@@ -1,6 +1,7 @@
 package com.mooctest.crowd.domain.repository;
 
 import com.mooctest.crowd.domain.domainobject.Account;
+import com.mooctest.crowd.domain.domainobject.User;
 import com.mooctest.crowd.domain.exception.AccountNotExistException;
 
 import java.util.List;
@@ -11,7 +12,7 @@ import java.util.List;
  */
 public interface IAccountRepo{
 
-    Account getByMobileNum(String mobileNum) throws AccountNotExistException;
+    User getByMobileNum(String mobileNum) throws AccountNotExistException;
 
     Account getByID(Long id) throws AccountNotExistException;
 

core/src/main/java/com/mooctest/crowd/domain/repository/ICrowdTestProjectRepo.java

@@ -12,14 +12,33 @@ import java.util.List;
 public interface ICrowdTestProjectRepo {
     CrowdTestProject getByID(Long id) throws CrowdTestProjectNotExistException;
 
-    List<CrowdTestProject> getByIDList(String[] ids);
+    CrowdTestProject getByProjectCode(String crowdTestProjectCode);
 
-    CrowdTestProject addCrowdTestProject(CrowdTestProject testProject) throws CrowdTestProjectNotExistException;
+    List<CrowdTestProject> getAllCrowdTestProject();
 
-    boolean removeCrowdTestProject(CrowdTestProject crowdTestProject) throws CrowdTestProjectNotExistException;
+    List<CrowdTestProject> getCrowdListByUserId(Long userId);
 
-    CrowdTestProject updateCrowdTestProject(CrowdTestProject crowdTestProject) throws CrowdTestProjectNotExistException;
+    List<CrowdTestProject> getCrowdListByRegionalManagerId(Long regionalManagerId);
 
-    CrowdTestProject updateCrowdTestProjectStatus(Long id, String status) throws CrowdTestProjectNotExistException;
+    void saveCrowdTestProject(CrowdTestProject crowdTestProject);
+
+//    void removeCrowdTestProject(String crowdTestProjectCode) throws CrowdTestProjectNotExistException;
+
+//    CrowdTestProject saveCreateCrowdTestProject(CrowdTestProject crowdTestProject);
+//
+//    boolean saveCreateCrowdTestTask(String crowdTestProjectCode, CrowdTestTask crowdTestTask);
+//
+//    boolean saveCreateCrowdTestReport(String crowdTestProjectCode, String crowdTestTaskCode, CrowdTestReport crowdTestReport);
+
+
+//    void deleteByProjectId(Long projectId);
+
+//    List<CrowdTestProject> getByIDList(String[] ids);
+//
+//    boolean removeCrowdTestProject(CrowdTestProject crowdTestProject) throws CrowdTestProjectNotExistException;
+//
+//    CrowdTestProject updateCrowdTestProject(CrowdTestProject crowdTestProject) throws CrowdTestProjectNotExistException;
+//
+//    CrowdTestProject updateCrowdTestProjectStatus(Long id, String status) throws CrowdTestProjectNotExistException;
 
 }

core/src/main/java/com/mooctest/crowd/domain/repository/IEvaluationAgencyRepo.java

@@ -0,0 +1,25 @@
+package com.mooctest.crowd.domain.repository;
+
+import com.mooctest.crowd.domain.domainobject.EvaluationAgencyAbility;
+import com.mooctest.crowd.domain.domainobject.EvaluationAgencyResource;
+
+import java.util.List;
+
+/**
+ * @author guochao
+ * @date 2019-08-14 09:55
+ */
+public interface IEvaluationAgencyRepo {
+
+    EvaluationAgencyResource findById(Long id);
+
+    List<EvaluationAgencyResource> findByEvaluationAgencyId(Long evaluationAgencyId);
+
+    EvaluationAgencyResource saveEvaluationAgencyResource(EvaluationAgencyResource evaluationAgencyResource);
+
+//    List<EvaluationAgencyResource> saveAllResource(List<EvaluationAgencyResource> sourceList);
+
+    EvaluationAgencyAbility saveEvaluationAgencyAbility(EvaluationAgencyAbility EvaluationAgencyAbility);
+
+    void moveEvaluationAgencyAbility(List<EvaluationAgencyAbility> evaluationAgencyAbilityList);
+}

core/src/main/java/com/mooctest/crowd/domain/repository/IUserRepo.java

@@ -0,0 +1,34 @@
+package com.mooctest.crowd.domain.repository;
+
+import com.mooctest.crowd.domain.domainobject.User;
+import com.mooctest.crowd.domain.exception.UserNotExistException;
+
+import javax.management.relation.RoleNotFoundException;
+import java.util.List;
+
+/**
+ * @Author: xuexb
+ * @Date: 2019.7.5 14:58
+ */
+public interface IUserRepo {
+
+    User getByMobileNum(String mobileNum) throws UserNotExistException, RoleNotFoundException;
+
+    User getByID(Long id) throws UserNotExistException, RoleNotFoundException;
+
+    List<User> getByIdList(List<Long> ids) throws RoleNotFoundException;
+
+    List<User> getAllUser() throws RoleNotFoundException;
+
+//    User getByEvaluationAgencyByUserId(Long userId) throws UserNotExistException, com.mooctest.crowd.domain.exception.RoleNotFoundException;
+
+    void removeUser(User user);
+
+    void removeUserList(List<User> userList);
+
+    User saveUser(User user) throws RoleNotFoundException;
+
+    User saveUserAndRole(User user);
+
+    List<User> getApplyEvaluationAgencyByIsAuthenticated();
+}

core/src/main/java/com/mooctest/crowd/domain/repository/UserRepo.java

@@ -0,0 +1,415 @@
+package com.mooctest.crowd.domain.repository;
+
+import com.google.common.collect.Lists;
+import com.mooctest.crowd.domain.dao.*;
+import com.mooctest.crowd.domain.domainobject.*;
+import com.mooctest.crowd.domain.exception.PermissionNotFoundException;
+import com.mooctest.crowd.domain.exception.RoleNotFoundException;
+import com.mooctest.crowd.domain.exception.UserNotExistException;
+import com.mooctest.crowd.domain.model.*;
+import com.mooctest.crowd.domain.util.Converter;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @Author: xuexb
+ * @Date: 2019.7.5 14:28
+ */
+
+@Component
+public class UserRepo implements IUserRepo {
+
+    @Autowired
+    private UserDao userDao;
+
+    @Autowired
+    private RoleDao roleDao;
+
+    @Autowired
+    private PermissionDao permissionDao;
+
+    @Autowired
+    private UserToRoleDao userToRoleDao;
+
+    @Autowired
+    private RoleToPermissionDao roleToPermissionDao;
+
+    @Autowired
+    private EvaluationAgencyDao evaluationAgencyDao;
+
+    @Autowired
+    private RegionalManagerToRegionalDao regionalManagerToRegionalDao;
+
+    @Autowired
+    private AgencyResourceDao agencyResourceDao;
+
+    @Autowired
+    private AgencyAbilityDao agencyAbilityDao;
+
+    @Autowired
+    private EvaluationAgencyRepo resourceRepo;
+
+    @Autowired
+    private PersonalAuthenticationDao personalAuthenticationDao;
+
+    @Autowired
+    private EnterpriseAuthenticationDao enterpriseAuthenticationDao;
+
+    @Autowired
+    private SystemAdministratorToUserDao systemAdministratorToUserDao;
+
+    private Timestamp currentTime = new Timestamp(System.currentTimeMillis());
+
+    @Override
+    public User getByID(Long userId) throws UserNotExistException, RoleNotFoundException {
+        Optional<UserPO> userPOOptional = userDao.findById(userId);
+        if (!userPOOptional.isPresent()) {
+            throw new UserNotExistException("用户不存在");
+        }else{
+            User user = getUserAndRoleAndPermissionByUserPO(userPOOptional.get());
+            return user;
+        }
+    }
+
+    @Override
+    public User getByMobileNum(String mobileNum) throws UserNotExistException, RoleNotFoundException {
+        UserPO userPO = userDao.findByMobile(mobileNum);
+        if (userPO == null) {
+            throw new UserNotExistException("用户不存在");
+        }else {
+            User user = getUserAndRoleAndPermissionByUserPO(userPO);
+            return user;
+        }
+    }
+
+    @Override
+    public List<User> getByIdList(List<Long> ids) throws RoleNotFoundException {
+        Iterable<UserPO> allUserPOById = userDao.findAllById(ids);
+        ArrayList<UserPO> userPOArrayList = Lists.newArrayList(allUserPOById);
+        List<User> allUserResult = getUserAndRoleAndPermissionListByUserPOList(userPOArrayList);
+        return allUserResult;
+    }
+
+    /**
+     * 获取机构认证的申请
+     * @return
+     * @throws RoleNotFoundException
+     */
+    @Override
+    public List<User> getApplyEvaluationAgencyByIsAuthenticated(){
+        List<UserPO> userPOList = new ArrayList<>();
+        evaluationAgencyDao.findByIsAuthentication(AuthenticationStatus.isNotAuthenticated).forEach(evaluationAgencyPO -> {
+            userPOList.add(userDao.findById(evaluationAgencyPO.getUserId()).get());
+        });
+        List<User> allUserResult = getUserAndRoleAndPermissionListByUserPOList(userPOList);
+        return allUserResult;
+    }
+
+    @Override
+    public List<User> getAllUser() throws RoleNotFoundException {
+        Iterable<UserPO> allUserPO = userDao.findAll();
+        ArrayList<UserPO> userPOArrayList = Lists.newArrayList(allUserPO);
+        List<User> userListByIds = getUserAndRoleAndPermissionListByUserPOList(userPOArrayList);
+        return userListByIds;
+    }
+
+
+    //add
+//    @Override
+//    public User getByEvaluationAgencyByUserId(Long userId) throws UserNotExistException, RoleNotFoundException {
+//
+//        EvaluationAgencyPO evaluationAgencyPO = evaluationAgencyDao.findByUserId(userId);
+//        if(evaluationAgencyPO == null){
+//            throw new EvaluationAgencyNotExistException();
+//        }else{
+//            Optional<UserPO> userPOOptional = userDao.findById(userId);
+//            if (!userPOOptional.isPresent()) {
+//                throw new UserNotExistException();
+//            }else {
+//                UserPO userPO = userPOOptional.get();
+//                User user = getUserAndRoleAndPermissionByUserPO(userPO);
+//                user.setEvaluationAgency(evaluationAgencyResult);
+//                return user;
+//            }
+//        }
+//
+//    }
+
+    @Override
+    public void removeUser(User user) {
+        UserPO userPO = Converter.convert(UserPO.class, user);
+        userDao.delete(userPO);
+    }
+
+    @Override
+    public void removeUserList(List<User> userList) {
+        List<UserPO> userPOList = new ArrayList<>();
+        for (User user : userList) {
+            UserPO userPO = Converter.convert(UserPO.class, user);
+            userPOList.add(userPO);
+        }
+        userDao.deleteAll(userPOList);
+    }
+
+    /**
+     * 注册用户时默认为普通用户，分配角色后存入数据库
+     * @param user
+     * @return
+     */
+    @Override
+    public User saveUserAndRole(User user) {
+        UserPO userPO = userDao.save(Converter.convert(UserPO.class, user));
+        User saveResultUser = Converter.convert(User.class, userPO);
+        List<Role> roleList = user.getRoleList();
+
+        // 存储从数据库中取出的User的Role数据
+        List<Role> roleListResult = new ArrayList<>();
+
+        for(Role role : roleList){
+            RolePO rolePO = roleDao.findByName(role.getName());
+            Role roleConvert = Converter.convert(Role.class, rolePO);
+
+            UserToRolePO userToRolePO = new UserToRolePO();
+            userToRolePO.setRoleId(roleConvert.getId());
+            userToRolePO.setUserId(saveResultUser.getId());
+            userToRolePO.setCreateTime(currentTime);
+            userToRoleDao.save(userToRolePO);
+
+            Role roleResult = getPermissionByRole(roleConvert);
+            roleListResult.add(roleResult);
+        }
+        saveResultUser.setRoleList(roleListResult);
+        return saveResultUser;
+    }
+
+    /**
+     * 保存用户相关的所有信息（包括测评机构信息、角色信息、权限信息）
+     * @param user
+     * @return
+     * @throws RoleNotFoundException
+     */
+    @Override
+    public User saveUser(User user) throws RoleNotFoundException {
+        User userAndRoleByUser = saveRoleAndPermissionAndEvaluationAgencyByUser(user);
+        return userAndRoleByUser;
+    }
+
+
+    /**
+     *保存用户信息（包括测评机构信息、角色信息、权限信息）
+     * @param user
+     * @return
+     * @throws RoleNotFoundException
+     */
+    private User saveRoleAndPermissionAndEvaluationAgencyByUser(User user) throws RoleNotFoundException {
+        UserPO userPO = userDao.save(Converter.convert(UserPO.class, user));
+        List<Role> roleList = user.getRoleList();
+        if (roleList==null || roleList.size()==0){
+            UserToRolePO u2r = new UserToRolePO();
+            u2r.setUserId(userPO.getId());
+            u2r.setRoleId(1L);
+            userToRoleDao.save(u2r);
+        }
+        List<UserToRolePO> userToRolePOList = userToRoleDao.findByUserId(userPO.getId());
+        if(roleList != null){
+            for(Role role : roleList){
+                if (userToRolePOList.stream().noneMatch(userToRolePO -> userToRolePO.getRoleId().equals(role.getId()))) {
+                    UserToRolePO userToRolePO = new UserToRolePO();
+                    userToRolePO.setRoleId(role.getId());
+                    userToRolePO.setUserId(userPO.getId());
+                    userToRoleDao.save(userToRolePO);
+                }
+            }
+        }
+
+        /*机构认证保存机构信息*/
+        EvaluationAgency evaluationAgency = user.getEvaluationAgency();
+        if(evaluationAgency != null){
+            EvaluationAgencyPO evaluationAgencyPO = Converter.convert(EvaluationAgencyPO.class, evaluationAgency);
+            evaluationAgencyPO.setUserId(userPO.getId());
+            evaluationAgencyPO = evaluationAgencyDao.save(evaluationAgencyPO);
+            List<EvaluationAgencyResource> resources = evaluationAgency.getEvaluationAgencyResourceList();
+            List<EvaluationAgencyAbility> abilities = evaluationAgency.getEvaluationAgencyAbilityList();
+            for (EvaluationAgencyResource resource : resources) {
+                resource.setEvaluationAgencyId(evaluationAgencyPO.getId());
+                resourceRepo.saveEvaluationAgencyResource(resource);
+            }
+            for (EvaluationAgencyAbility ability : abilities) {
+                ability.setEvaluationAgencyId(evaluationAgencyPO.getId());
+                resourceRepo.saveEvaluationAgencyAbility(ability);
+            }
+//            // save测评机构资源
+//            EvaluationAgencyResource evaluationAgencyResource = evaluationAgency.getEvaluationAgencyResource();
+//            if(evaluationAgencyResource != null){
+//                EvaluationAgencyResourcePO evaluationAgencyResourcePO = Converter.convert(EvaluationAgencyResourcePO.class, evaluationAgencyResource);
+//                evaluationAgencyResourcePO.setEvaluationAgencyId(evaluationAgencyPO.getId());
+//                evaluationAgencyResourceDao.save(evaluationAgencyResourcePO);
+//            }
+        }
+
+        /*实名认证保存个人信息*/
+        if(user.getPersonalAuthentication() != null){
+            personalAuthenticationDao.save(Converter.convert(PersonalAuthenticationPO.class, user.getPersonalAuthentication()));
+        }
+
+        /*企业认证保存企业信息*/
+        if(user.getEnterpriseAuthentication() != null){
+            enterpriseAuthenticationDao.save(Converter.convert(EnterpriseAuthenticationPO.class, user.getEnterpriseAuthentication()));
+        }
+
+        return getByID(userPO.getId());
+    }
+
+    /**
+     * 通过角色获取角色和权限信息
+     * @param roleResult
+     * @return
+     */
+    private Role getPermissionByRole(Role roleResult) {
+        List<Permission> permissionResultList = new ArrayList<>();
+        List<RoleToPermissionPO> roleToPermissionPOList = roleToPermissionDao.findAllByRoleId(roleResult.getId());
+        for(RoleToPermissionPO roleToPermissionPO : roleToPermissionPOList){
+            Long permissionId = roleToPermissionPO.getPermissionId();
+            Optional<PermissionPO> permissionPOOptional = permissionDao.findById(permissionId);
+            if(!permissionPOOptional.isPresent()){
+                throw new PermissionNotFoundException();
+            }else{
+                PermissionPO permissionPO = permissionPOOptional.get();
+                permissionResultList.add(Converter.convert(Permission.class,permissionPO));
+            }
+        }
+        roleResult.setPermissionList(permissionResultList);
+        return roleResult;
+    }
+
+    /**
+     * 通过UsePOList获取用户-角色-权限信息
+     * @param userPOList
+     * @return
+     * @throws RoleNotFoundException
+     */
+    private List<User> getUserAndRoleAndPermissionListByUserPOList(List<UserPO> userPOList) throws RoleNotFoundException {
+        List<User> userList = new ArrayList<>();
+        for(UserPO userPO : userPOList){
+            User userAndRole = getUserAndRoleAndPermissionByUserPO(userPO);
+            userList.add(userAndRole);
+        }
+        return userList;
+    }
+
+    /**
+     * 通过用户信息获取用户-角色-权限信息
+     * @param userPO
+     * @return
+     * @throws RoleNotFoundException
+     */
+    private User getUserAndRoleAndPermissionByUserPO(UserPO userPO) throws RoleNotFoundException {
+        User userResult = Converter.convert(User.class, userPO);
+        List<UserToRolePO> userToRolePOList = userToRoleDao.findByUserId(userResult.getId());
+        List<Role> roleResultList = new ArrayList<>();
+        for (UserToRolePO userToRolePO : userToRolePOList) {
+            Optional<RolePO> rolePOOptional = roleDao.findById(userToRolePO.getRoleId());
+            if(rolePOOptional.isPresent()){
+                RolePO rolePO = rolePOOptional.get();
+                // 权限
+                Role roleResult = getPermissionByRole(Converter.convert(Role.class, rolePO));
+                roleResultList.add(roleResult);
+            }else{
+                throw new RoleNotFoundException();
+            }
+        }
+        userResult.setRoleList(roleResultList);
+
+        /*获取测评机构信息*/
+        EvaluationAgencyPO evaluationAgencyPO = evaluationAgencyDao.findByUserIdAndIsDeleted(userPO.getId(), DeletedStatus.isNotDeleted);
+        if(evaluationAgencyPO != null){
+            EvaluationAgency evaluationAgencyResult = Converter.convert(EvaluationAgency.class, evaluationAgencyPO);
+
+            /*获取测评机构能力*/
+            List<EvaluationAgencyAbilityPO> evaluationAgencyAbilityPOList = agencyAbilityDao.findByEvaluationAgencyIdAndIsDeleted(evaluationAgencyResult.getId(), DeletedStatus.isNotDeleted);
+            List<EvaluationAgencyAbility> evaluationAgencyAbilityList = new ArrayList<>();
+            if(evaluationAgencyAbilityPOList.size() != 0){
+                for(EvaluationAgencyAbilityPO evaluationAgencyAbilityPO : evaluationAgencyAbilityPOList){
+                    EvaluationAgencyAbility evaluationAgencyAbility = Converter.convert(EvaluationAgencyAbility.class, evaluationAgencyAbilityPO);
+                    evaluationAgencyAbilityList.add(evaluationAgencyAbility);
+                }
+            }
+            evaluationAgencyResult.setEvaluationAgencyAbilityList(evaluationAgencyAbilityList);
+
+            /*获取测评机构资源*/
+            List<EvaluationAgencyResourcePO> evaluationAgencyResourcePOList = agencyResourceDao.findByEvaluationAgencyIdAndIsDeleted(evaluationAgencyResult.getId(), DeletedStatus.isNotDeleted);
+            List<EvaluationAgencyResource> evaluationAgencyResourceList = new ArrayList<>();
+            if(evaluationAgencyResourcePOList.size() != 0){
+                for(EvaluationAgencyResourcePO evaluationAgencyResourcePO : evaluationAgencyResourcePOList){
+                    EvaluationAgencyResource evaluationAgencyResource = Converter.convert(EvaluationAgencyResource.class, evaluationAgencyResourcePO);
+                    evaluationAgencyResourceList.add(evaluationAgencyResource);
+                }
+            }
+            evaluationAgencyResult.setEvaluationAgencyResourceList(evaluationAgencyResourceList);
+            userResult.setEvaluationAgency(evaluationAgencyResult);
+        }
+
+        /*获取个人认证的信息*/
+        PersonalAuthenticationPO personalAuthenticationPO = personalAuthenticationDao.findByUserIdAndIsDeleted(userPO.getId(), DeletedStatus.isNotDeleted);
+        if(personalAuthenticationPO != null){
+            userResult.setPersonalAuthentication(Converter.convert(PersonalAuthentication.class, personalAuthenticationPO));
+        }
+
+        /*获取企业认证的信息*/
+        EnterpriseAuthenticationPO enterpriseAuthenticationPO = enterpriseAuthenticationDao.findByUserIdAndIsDeleted(userPO.getId(), DeletedStatus.isNotDeleted);
+        if(enterpriseAuthenticationPO != null){
+            userResult.setEnterpriseAuthentication(Converter.convert(EnterpriseAuthentication.class, enterpriseAuthenticationPO));
+        }
+
+        /*获取区域管理员信息*/
+        List<RegionalManagerToRegionalPO> regionalManagerToRegionalPOList = regionalManagerToRegionalDao.findByUserIdAndIsDeleted(userPO.getId(), DeletedStatus.isNotDeleted);
+        if(regionalManagerToRegionalPOList.size() > 0){
+            List<RegionalManagerToRegional> regionalList = new ArrayList<>();
+            RegionalManager regionalManager = new RegionalManager();
+            regionalManager.setUserId(userPO.getId());
+            for(RegionalManagerToRegionalPO regionalManagerToRegionalPO : regionalManagerToRegionalPOList){
+                if(regionalManagerToRegionalPO != null){
+                    regionalManager.setId(regionalManagerToRegionalPO.getId());
+                    /*获取区域管理员管理的区域信息*/
+                    RegionalManagerToRegional regionalResult = Converter.convert(RegionalManagerToRegional.class, regionalManagerToRegionalPO);
+                    regionalList.add(regionalResult);
+                }
+
+            }
+            regionalManager.setRegionalList(regionalList);
+            userResult.setRegionalManager(regionalManager);
+        }
+
+        //获取系统管理员信息
+        SystemAdministratorToUserPO systemAdministratorToUserPO = systemAdministratorToUserDao.findByUserIdAndIsDeleted(userPO.getId(), DeletedStatus.isNotDeleted);
+        if(systemAdministratorToUserPO != null){
+            userResult.setSystemAdministratorToUser(Converter.convert(SystemAdministratorToUser.class, systemAdministratorToUserPO));
+        }
+
+        return userResult;
+    }
+
+    public Role getRole(String roleName){
+        Role role = new Role();
+        BeanUtils.copyProperties(roleDao.findByName(roleName), role);
+        return role;
+    }
+
+    public long getAllUserNum(){
+        return userDao.count();
+    }
+
+    public long getAllAgencyNum(){
+        return evaluationAgencyDao.count();
+    }
+
+    public long getAllResourceNum(){
+        return agencyResourceDao.count();
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/util/Converter.java

@@ -0,0 +1,82 @@
+package com.mooctest.crowd.domain.util;
+
+import com.google.common.collect.Maps;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.springframework.cglib.beans.BeanCopier;
+
+import java.util.Map;
+
+public class Converter {
+
+    private static Map<CopierIdentity, BeanCopier> copierCache = Maps.newConcurrentMap();
+    private static PrimitiveConverter primitiveConverter = new PrimitiveConverter();
+
+    public static <T> T copy(T target, Object source) {
+        BeanCopier copier = getCopier(source.getClass(), target.getClass());
+        copier.copy(source, target, primitiveConverter);
+        return target;
+    }
+
+    public static <T> T convert(Class<T> targetClass, Object source) {
+        try {
+            T target = targetClass.newInstance();
+            BeanCopier copier = getCopier(source.getClass(), targetClass);
+            copier.copy(source, target, primitiveConverter);
+            return target;
+        } catch (InstantiationException | IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static BeanCopier getCopier(Class<?> source, Class<?> target) {
+        CopierIdentity identity = new CopierIdentity(source, target);
+        BeanCopier copier;
+        if (copierCache.containsKey(identity)) {
+            copier = copierCache.get(identity);
+        } else {
+            copier = BeanCopier.create(source, target, true);
+            copierCache.putIfAbsent(identity, copier);
+        }
+        return copier;
+    }
+
+    public static class PrimitiveConverter implements org.springframework.cglib.core.Converter {
+        @Override
+        @SuppressWarnings("unchecked")
+        public Object convert(Object value, Class target, Object context) {
+            if (value == null) return null;
+            if (target.equals(String.class)
+                    && !String.class.isAssignableFrom(value.getClass()))
+                return value.toString();
+            if (Number.class.isAssignableFrom(value.getClass())) {
+                Number num = (Number) value;
+                if (target.equals(int.class) || target.equals(Integer.class))
+                    return num.intValue();
+                else if (target.equals(long.class) || target.equals(Long.class))
+                    return num.longValue();
+                else if (target.equals(short.class) || target.equals(Short.class))
+                    return num.shortValue();
+                else if (target.equals(float.class) || target.equals(Float.class))
+                    return num.floatValue();
+                else if (target.equals(double.class) || target.equals(Double.class))
+                    return num.doubleValue();
+                else if (target.equals(byte.class) || target.equals(Byte.class))
+                    return num.byteValue();
+            } else if (target.isAssignableFrom(value.getClass()))
+                return value;
+            return null;
+        }
+    }
+
+    @AllArgsConstructor
+    @Data
+    @EqualsAndHashCode
+    private static class CopierIdentity {
+        private Class<?> source;
+        private Class<?> target;
+    }
+
+}
+

core/src/main/java/com/mooctest/crowd/domain/util/EncryptionUtil.java

@@ -0,0 +1,212 @@
+package com.mooctest.crowd.domain.util;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import sun.misc.BASE64Decoder;
+import sun.misc.BASE64Encoder;
+
+import javax.crypto.Cipher;
+import javax.crypto.SecretKey;
+import javax.crypto.SecretKeyFactory;
+import javax.crypto.spec.DESKeySpec;
+import java.io.IOException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+
+public class EncryptionUtil {
+
+    private static final Logger LOG = LoggerFactory.getLogger(EncryptionUtil.class);
+
+    // 定义 加密算法,可用 DES,DESede,Blowfish
+    private static String Algorithm = "DES";
+    private static String defaultKey = "witest.net";
+
+
+    public static String encryptMD5Hex(String str) {
+        String value = null;
+        // 用来将字节转换成 16 进制表示的字符
+        char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+
+        try {
+            MessageDigest md5 = MessageDigest.getInstance("MD5");
+            md5.update(str.getBytes());
+
+            // MD5 的计算结果是一个 128 位的长整数，用字节表示就是 16 个字节
+            byte temp[] = md5.digest();
+            // 每个字节用 16 进制表示的话，使用两个字符
+            char hex[] = new char[16 * 2];
+
+            // 表示转换结果中对应的字符位置
+            int k = 0;
+            // 从第一个字节开始，对 MD5 的每一个字节转换成 16 进制字符的转换
+            for (int i = 0; i < 16; i++) {
+                byte b = temp[i];
+                // 取字节中高 4 位的数字转换, >>> 为逻辑右移，将符号位一起右移
+                hex[k++] = hexDigits[b >>> 4 & 0xf];
+                // 取字节中低 4 位的数字转换
+                hex[k++] = hexDigits[b & 0xf];
+            }
+
+            // 转换后的结果转换为字符串
+            value = new String(hex);
+
+        } catch (Exception e) {
+            value = "";
+            LOG.error("", e);
+        }
+        return value;
+    }
+
+    public static String encryptMD5(String str) {
+        String s = str;
+        if (s == null) {
+            return "";
+        } else {
+            String value = null;
+            MessageDigest md5 = null;
+            try {
+                md5 = MessageDigest.getInstance("MD5");
+            } catch (NoSuchAlgorithmException ex) {
+                LOG.error("", ex);
+            }
+            sun.misc.BASE64Encoder baseEncoder = new sun.misc.BASE64Encoder();
+            try {
+                value = baseEncoder.encode(md5.digest(s.getBytes("utf-8")));
+            } catch (Exception ex) {
+            }
+            return value;
+        }
+    }
+
+    public static String transferMD5ToMD5Hex(String str) {
+
+        String value = null;
+        // 用来将字节转换成 16 进制表示的字符
+        char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+        BASE64Decoder base64Decoder = new BASE64Decoder();
+        try {
+            byte[] temp = base64Decoder.decodeBuffer(str);
+            // 每个字节用 16 进制表示的话，使用两个字符
+            char hex[] = new char[16 * 2];
+
+            // 表示转换结果中对应的字符位置
+            int k = 0;
+            // 从第一个字节开始，对 MD5 的每一个字节转换成 16 进制字符的转换
+            for (int i = 0; i < 16; i++) {
+                byte b = temp[i];
+                // 取字节中高 4 位的数字转换, >>> 为逻辑右移，将符号位一起右移
+                hex[k++] = hexDigits[b >>> 4 & 0xf];
+                // 取字节中低 4 位的数字转换
+                hex[k++] = hexDigits[b & 0xf];
+            }
+
+            // 转换后的结果转换为字符串
+            value = new String(hex);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return value;
+
+    }
+
+    public static String encryptDES(String content) throws Exception {
+        return encryptDES(content, defaultKey);
+    }
+
+    public static String decryptDES(String content) throws Exception {
+        return decryptDES(content, defaultKey);
+    }
+
+
+    /**
+     * Description 根据键值进行加密
+     *
+     * @param data
+     * @param key  加密键byte数组
+     * @return
+     * @throws Exception
+     */
+    public static String encryptDES(String data, String key) throws Exception {
+        byte[] bt = encryptDES(data.getBytes(), key.getBytes());
+        String strs = new BASE64Encoder().encode(bt);
+        return strs;
+    }
+
+    /**
+     * Description 根据键值进行解密
+     *
+     * @param data
+     * @param key  加密键byte数组
+     * @return
+     * @throws IOException
+     * @throws Exception
+     */
+    public static String decryptDES(String data, String key) throws IOException,
+            Exception {
+        if (data == null)
+            return null;
+        BASE64Decoder decoder = new BASE64Decoder();
+        byte[] buf = decoder.decodeBuffer(data);
+        byte[] bt = decryptDES(buf, key.getBytes());
+        return new String(bt);
+    }
+
+    /**
+     * Description 根据键值进行加密
+     *
+     * @param data
+     * @param key  加密键byte数组
+     * @return
+     * @throws Exception
+     */
+    private static byte[] encryptDES(byte[] data, byte[] key) throws Exception {
+        // 生成一个可信任的随机数源
+        SecureRandom sr = new SecureRandom();
+
+        // 从原始密钥数据创建DESKeySpec对象
+        DESKeySpec dks = new DESKeySpec(key);
+
+        // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
+        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(Algorithm);
+        SecretKey securekey = keyFactory.generateSecret(dks);
+
+        // Cipher对象实际完成加密操作
+        Cipher cipher = Cipher.getInstance(Algorithm);
+
+        // 用密钥初始化Cipher对象
+        cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);
+
+        return cipher.doFinal(data);
+    }
+
+
+    /**
+     * Description 根据键值进行解密
+     *
+     * @param data
+     * @param key  加密键byte数组
+     * @return
+     * @throws Exception
+     */
+    private static byte[] decryptDES(byte[] data, byte[] key) throws Exception {
+        // 生成一个可信任的随机数源
+        SecureRandom sr = new SecureRandom();
+
+        // 从原始密钥数据创建DESKeySpec对象
+        DESKeySpec dks = new DESKeySpec(key);
+
+        // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
+        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(Algorithm);
+        SecretKey securekey = keyFactory.generateSecret(dks);
+
+        // Cipher对象实际完成解密操作
+        Cipher cipher = Cipher.getInstance(Algorithm);
+
+        // 用密钥初始化Cipher对象
+        cipher.init(Cipher.DECRYPT_MODE, securekey, sr);
+
+        return cipher.doFinal(data);
+    }
+
+}

core/src/main/java/com/mooctest/crowd/domain/util/ExcelUtil.java

@@ -0,0 +1,249 @@
+//package com.mooctest.crowd.domain.util;
+//
+//import org.apache.poi.hssf.usermodel.HSSFCell;
+//import org.apache.poi.hssf.usermodel.HSSFRow;
+//import org.apache.poi.hssf.usermodel.HSSFSheet;
+//import org.apache.poi.hssf.usermodel.HSSFWorkbook;
+//
+//import java.io.File;
+//import java.io.FileInputStream;
+//import java.io.FileNotFoundException;
+//import java.io.IOException;
+//import java.text.NumberFormat;
+//import java.util.ArrayList;
+//import java.util.LinkedHashMap;
+//import java.util.List;
+//import java.util.Map;
+//
+///**
+// * @author guochao
+// * @date 2019-08-06 20:17
+// */
+//public class ExcelUtil {
+//    /*
+//     * 获取excel File
+//     * return java.io.file
+//     */
+//    public static File getExcelFile(String excel_file_dir){
+//
+//        String excel_file = PathTool.getTestDataPath()+excel_file_dir;
+//        File excelFile = new File(excel_file);
+//
+//        if(!excelFile.exists()){
+//            throw new RuntimeException(excel_file+" 文件不存在！");
+//        }
+//        if(!excelFile.getName().endsWith(".xls")){
+//            throw new RuntimeException(excel_file+" 文件类型不正确，只允许.xls结尾的文件！");
+//        }
+//        return excelFile;
+//    }
+//
+//    /*
+//     * 获取指定标签页名称的数据
+//     */
+//    public static List<Map<String,Object>> getExcelRecords(String excel_file_dir,String sheetName){
+//        if(sheetName==null){
+//            throw new RuntimeException("标签页名称不能为空！");
+//        }
+//        return getExcelRecords(excel_file_dir, sheetName, -1);
+//    }
+//    /*
+//     * 获取指定标签页索引的数据
+//     */
+//    public static List<Map<String,Object>> getExcelRecords(String excel_file_dir,int sheetIndex){
+//        if(sheetIndex<0){
+//            throw new RuntimeException("指定标签页索引不合法，请输入非负数！");
+//        }
+//        return getExcelRecords(excel_file_dir, null, sheetIndex);
+//    }
+//    /*
+//     * 获取指定excel文件、指定标签页（标签页名称、标签页索引）的内容，返回值格式：List<List<Object>>
+//     * 入参excel_file格式：bpm\\test1.xls,bsp\\test2.xls
+//     */
+//    private static List<Map<String,Object>> getExcelRecords(String excel_file_dir,String sheetName,int sheetIndex){
+//
+//        File excelFile = getExcelFile(excel_file_dir);
+//        List<Map<String,Object>> recordList = new ArrayList<Map<String,Object>>();
+//        HSSFWorkbook workbook=null;
+//
+//        try {
+//            workbook = new HSSFWorkbook(new FileInputStream(excelFile));
+//        } catch (FileNotFoundException e) {
+//            e.printStackTrace();
+//        } catch (IOException e) {
+//            e.printStackTrace();
+//        }
+//
+//
+//        //获取指定标签页
+//        HSSFSheet sheet = null;
+//        if(sheetName==null){
+//            sheet = workbook.getSheetAt(sheetIndex);
+//            if(sheet==null){
+//                throw new RuntimeException(sheetIndex+" 标签页不存在！");
+//            }
+//        }else{
+//            sheet = workbook.getSheet(sheetName);
+//            if(sheet==null){
+//                throw new RuntimeException(sheetName+" 标签页不存在！");
+//            }
+//        }
+//
+//
+//        //总行数
+//        int rows = sheet.getPhysicalNumberOfRows();
+//        if (rows < 2) {
+//            throw new RuntimeException(excelFile.getName()+" 内容为空，请重新编辑！");
+//        }
+//
+//        //不为空的单元格数  ，第一行是标题列
+//        HSSFRow keyRow = sheet.getRow(0);
+//        int cellNumber = keyRow.getPhysicalNumberOfCells();
+//
+//        //循环遍历，第一行是标题，所以从 1 开始遍历（0表示第一行，1表示第二行）
+//        for (int r = 1; r < rows; r++) {
+//            Map<String,Object> record = new LinkedHashMap<String,Object>();//使用HashMap的话，存进去的顺序与取出来的顺序是不一致的，此处需要使用LinkedHashMap
+//            HSSFRow row = sheet.getRow(r);
+//            Object value = null;
+//            for (int c = 0; c < cellNumber; c++) //共cellNumber列
+//            {
+//                HSSFCell cell = row.getCell(c);
+//
+//                //如果单元格不为空
+//                if (cell != null) {
+//                    switch (cell.getCellType()) {
+//                        case HSSFCell.CELL_TYPE_FORMULA:
+//                            break;
+//                        case HSSFCell.CELL_TYPE_NUMERIC:
+//                            //对数字进行格式化，使其不自动转化为科学计数法。
+//                            java.text.NumberFormat nf = java.text.NumberFormat.getInstance();
+//                            nf.setGroupingUsed(false);
+//                            value = nf.format( new Double(cell.getNumericCellValue()));
+//                            break;
+//                        case HSSFCell.CELL_TYPE_STRING:
+//                            value = cell.getStringCellValue();
+//                            break;
+//                        case HSSFCell.CELL_TYPE_BLANK:
+//                            value = null;
+//                            break;
+//                        default:
+//                            value = null;
+//                    }
+//                }else{
+//                    value=null;
+//                }
+//                record.put(keyRow.getCell(c).getStringCellValue(),value);
+//            }
+//            recordList.add(record);
+//        }
+//        return recordList;
+//    }
+//    /*
+//     * 获取excel的sheet个数
+//     */
+//    public static int getNumberOfSheets(String excel_file_dir){
+//        File excelFile = getExcelFile(excel_file_dir);
+//        HSSFWorkbook workbook=null;
+//        int numberOfSheets = 0;
+//        try {
+//            workbook = new HSSFWorkbook(new FileInputStream(excelFile));
+//            numberOfSheets = workbook.getNumberOfSheets();
+//        } catch (FileNotFoundException e) {
+//            e.printStackTrace();
+//        } catch (IOException e) {
+//            e.printStackTrace();
+//        }
+//        return numberOfSheets;
+//    }
+//
+//    /*
+//     * 根据sheetIndex获取sheetName
+//     */
+//    public static String getSheetNameBySheetIndex(String excel_file_dir,int sheetIndex){
+//        File excelFile = getExcelFile(excel_file_dir);
+//        HSSFWorkbook workbook=null;
+//        String sheetName = null;
+//        try {
+//            workbook = new HSSFWorkbook(new FileInputStream(excelFile));
+//            sheetName = workbook.getSheetName(sheetIndex);
+//        } catch (FileNotFoundException e) {
+//            e.printStackTrace();
+//        } catch (IOException e) {
+//            e.printStackTrace();
+//        }
+//        return sheetName;
+//    }
+//
+//    /*
+//     * 获取指定选项卡（索引）的行数
+//     */
+//    public static int getRowsOfSheet(String excel_file_dir,int sheetIndex){
+//        File excelFile = getExcelFile(excel_file_dir);
+//        HSSFWorkbook workbook=null;
+//        int rowsOfSheet = 0;
+//        try {
+//            workbook = new HSSFWorkbook(new FileInputStream(excelFile));
+//            rowsOfSheet = workbook.getSheetAt(sheetIndex).getPhysicalNumberOfRows();
+//        } catch (FileNotFoundException e) {
+//            e.printStackTrace();
+//        } catch (IOException e) {
+//            e.printStackTrace();
+//        }
+//        return rowsOfSheet;
+//    }
+//    /*
+//     * 获取指定选项卡（名称）的行数
+//     */
+//    public static int getRowsOfSheet(String excel_file_dir,String sheetName){
+//        File excelFile = getExcelFile(excel_file_dir);
+//        HSSFWorkbook workbook=null;
+//        int rowsOfSheet = 0;
+//        try {
+//            workbook = new HSSFWorkbook(new FileInputStream(excelFile));
+//            rowsOfSheet = workbook.getSheet(sheetName).getPhysicalNumberOfRows();
+//        } catch (FileNotFoundException e) {
+//            e.printStackTrace();
+//        } catch (IOException e) {
+//            e.printStackTrace();
+//        }
+//        return rowsOfSheet;
+//    }
+//    /*
+//     * 获取指定sheet、指定row、指定colum对应的cell的value
+//     * return:List[title,value],第一个元素是title，第二个元素是value
+//     * row/cell都是从0开始计算
+//     */
+//    public static List<String> getCell(String excel_file_dir,int sheetIndex,int rowIndex,int cellIndex){
+//
+//        File excelFile = getExcelFile(excel_file_dir);
+//        List<String> keyValueList = new ArrayList<String>();
+//        HSSFWorkbook workbook=null;
+//        String key = null;
+//        String value = null;
+//        try {
+//            workbook = new HSSFWorkbook(new FileInputStream(excelFile));
+//            key = workbook.getSheetAt(sheetIndex).getRow(0).getCell(cellIndex).getStringCellValue();//第一行（row 0）是标题列
+//            HSSFCell cell = workbook.getSheetAt(sheetIndex).getRow(rowIndex).getCell(cellIndex);
+//            if(cell==null){
+//                value = null;
+//            }else{
+//                if(cell.getCellType()==HSSFCell.CELL_TYPE_NUMERIC){//如果是数字类型
+//                    NumberFormat nf = NumberFormat.getInstance();
+//                    nf.setGroupingUsed(false);
+//                    value = nf.format( new Double(cell.getNumericCellValue()));
+//                }else if(cell.getCellType()==HSSFCell.CELL_TYPE_STRING){    //如果是文本类型
+//                    value = cell.getStringCellValue();
+//                }else{//否则全部视为null
+//                    value=null;
+//                }
+//            }
+//            keyValueList.add(key);
+//            keyValueList.add(value);
+//        } catch (FileNotFoundException e) {
+//            e.printStackTrace();
+//        } catch (IOException e) {
+//            e.printStackTrace();
+//        }
+//        return keyValueList;
+//    }
+//}