Merge branch 'feature-domain-implement' into 'Test'

Feature domain implement

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

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/DefaultFeatureConfiguration.java

@@ -0,0 +1,16 @@
+package com.mooctest.crowd.domain.configuration;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * Created by lipeiyuan on 2018/3/12.
+ */
+@Data
+@Component
+@ConfigurationProperties(prefix = "feature-switch.default")
+public class DefaultFeatureConfiguration {
+
+    private String role;
+}

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

@@ -0,0 +1,754 @@
+package com.mooctest.crowd.domain.controller;
+
+import com.google.gson.Gson;
+import com.mooctest.crowd.domain.domainobject.*;
+import com.mooctest.crowd.domain.model.CrowdTestProjectPO;
+import com.mooctest.crowd.domain.repository.CrowdTestProjectRepo;
+import com.mooctest.crowd.domain.repository.UserRepo;
+import com.mooctest.crowd.domain.util.Converter;
+import com.mooctest.crowd.domain.util.FileUtil;
+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 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 org.springframework.web.multipart.MultipartFile;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.sql.Timestamp;
+import java.text.DecimalFormat;
+import java.util.*;
+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("/api/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/{crowdTestProjectCode}", method = RequestMethod.GET)
+    public String deleteCrowdTestProjectByProjectCode(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode) {
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.removeCrowdTestProject();
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getAllCrowdTestProject().toString();
+    }
+
+    /**
+     * 删除任务（区域管理员）
+     * @param crowdTestProjectCode
+     * @param crowdTestTaskCode
+     * @return
+     */
+    @RequestMapping(value = "deleteTask/{crowdTestProjectCode}/{crowdTestTaskCode}", method = RequestMethod.GET)
+    public String deleteCrowdTestTask(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode,
+                                      @PathVariable("crowdTestTaskCode") String crowdTestTaskCode) {
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.removeCrowdTestTask(crowdTestTaskCode);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getAllCrowdTestProject().toString();
+    }
+
+    /**
+     * 删除任务报告（测评机构）
+     * @param crowdTestProjectCode
+     * @param crowdTestTaskCode
+     * @param crowdTestReportCode
+     * @return
+     */
+    @RequestMapping(value = "deleteReport/{crowdTestProjectCode}/{crowdTestTaskCode}/{crowdTestReportCode}", method = RequestMethod.GET)
+    public String deleteCrowdTestReport(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode,
+                                        @PathVariable("crowdTestTaskCode") String crowdTestTaskCode,
+                                        @PathVariable("crowdTestReportCode") String crowdTestReportCode) {
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.removeCrowdTestReport(crowdTestTaskCode,crowdTestReportCode);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getAllCrowdTestProject().toString();
+    }
+
+    /**
+     * 删除项目报告（区域管理员）
+     * @param crowdTestProjectCode
+     * @return
+     */
+    @RequestMapping(value = "deleteProjectReport/{crowdTestProjectCode}", method = RequestMethod.GET)
+    public String deleteCrowdTestReport(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode) {
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.removeCrowdTestProjectReport();
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getAllCrowdTestProject().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(crowdTestProject, 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(crowdTestProject, 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(crowdTestProject, 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.setLinkManMobile("13657094936");
+        crowdTestProject.setQuotedPrice(200.00);
+        crowdTestProject.setDeadTime(new Timestamp(getNextDay(new Date(System.currentTimeMillis()),1).getTime()));
+        crowdTestProject.setCreateTime(new Timestamp(System.currentTimeMillis()));
+
+        User user = userRepo.getByID(userId);
+        CrowdTestProject crowdTestProjectResult = user.createCrowdTestProject(crowdTestProject);
+        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 = user.releaseCrowdTestProject(crowdTestProject);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
+    }
+
+
+    /**
+     * 对区域管理员的操作
+     */
+
+    /**
+     * 接收项目（区域管理员）
+     * @param regionalManagerId
+     * @param crowdTestProjectCode
+     * @return
+     */
+    @RequestMapping(value = "receiveProject/{regionalManagerId}/{crowdTestProjectCode}", method = RequestMethod.GET)
+    public String receiveTaskByProjectCode(@PathVariable("regionalManagerId") Long regionalManagerId, @PathVariable("crowdTestProjectCode") String crowdTestProjectCode) {
+        User userForRegionalManager = userRepo.getByID(regionalManagerId);
+        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
+
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+
+        CrowdTestProject crowdTestProjectResult = regionalManager.receiveProject(crowdTestProject);
+        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){
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+
+        //数据准备
+        CrowdTestTask crowdTestTask = new CrowdTestTask();
+        crowdTestTask.setCode(crowdTestProjectCode+"_TASK"+System.currentTimeMillis());
+        crowdTestTask.setName(taskName);
+        crowdTestTask.setCrowdTestProjectCode(crowdTestProjectCode);
+        crowdTestTask.setQuotedPrice(200.00);
+        crowdTestTask.setDeadTime(new Timestamp(getNextDay(new Date(System.currentTimeMillis()),1).getTime()));
+        crowdTestTask.setCreateTime(new Timestamp(System.currentTimeMillis()));
+
+        //具体操作
+        User userForRegionalManager = userRepo.getByID(regionalManagerId);
+        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
+
+        CrowdTestProject crowdTestProjectResult = regionalManager.createCrowdTestTask(crowdTestProject, crowdTestTask);
+        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 userForRegionalManager = userRepo.getByID(regionalManagerId);
+        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
+
+        CrowdTestProject crowdTestProjectResult = regionalManager.releaseCrowdTestTask(crowdTestProject, crowdTestTaskCode);
+        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);
+        System.out.println(crowdTestProjectResult);
+        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){
+
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
+
+        //report数据准备
+        CrowdTestReport crowdTestReport = new CrowdTestReport();
+        crowdTestReport.setCode(crowdTestTaskCode+"_REP"+System.currentTimeMillis());
+        crowdTestReport.setName(reportName);
+        crowdTestReport.setDependencyCode(crowdTestTaskCode);
+        crowdTestReport.setCreateTime(new Timestamp(System.currentTimeMillis()));
+
+        User userForEvaluationAgency = userRepo.getByID(userForEvaluationAgencyId);
+        CrowdTestProject crowdTestProjectResult = userForEvaluationAgency.createCrowdTestReport(crowdTestProject, crowdTestTaskCode, crowdTestReport);
+        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);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
+    }
+
+    /**
+     * 区域管理员的操作
+     */
+
+
+    /**
+     * 确认结束任务（区域管理员）
+     * @param crowdTestProjectCode
+     * @return
+     */
+    @RequestMapping(value = "finishTask/{regionalManagerId}/{crowdTestProjectCode}", method = RequestMethod.GET)
+    public String commitCrowdTestTask(@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.finishCrowdTestTask(crowdTestProject);
+        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);
+
+        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);
+        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.finishCrowdTestProjet(crowdTestProject);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
+    }
+
+
+    /**
+     * 通过EXCEL向数据库中导入众包项目文件，并补全项目中任务和报告的数据
+     * @param file
+     * @return
+     */
+    @RequestMapping(value = "projectListImportByExcel", method = RequestMethod.POST)
+    public String projectListImportByExcel(MultipartFile file){
+        //解析excel
+        List<CrowdTestProjectPO> crowdTestProjectPOList = FileUtil.importExcel(file,0,1,CrowdTestProjectPO.class);
+
+        for(int i = 0; i < crowdTestProjectPOList.size(); i++){
+            CrowdTestProject crowdTestProject = Converter.convert(CrowdTestProject.class, crowdTestProjectPOList.get(i));
+            CrowdTestProject crowdTestProjectResult = crowdTestProject.generateDefaultTaskAndReportData();
+            //TODO 保存数据库
+            crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+
+        }
+        System.out.println("共导入数据【"+crowdTestProjectPOList.size()+"】行");
+
+        return "success";
+    }
+
+
+    /**
+     * 通过EXCEL向数据库中导入众包项目文件，并补全项目中任务和报告的数据
+     * @param file
+     * @return
+     */
+    @RequestMapping(value = "projectImportByExcel", method = RequestMethod.POST)
+    public String projectImportByExcel(MultipartFile file) {
+        List<String> logList = new ArrayList<>();
+        List<Map<Integer,Object>> recordList = new ArrayList<>();
+        HSSFWorkbook workbook=null;
+        try {
+            workbook = new HSSFWorkbook(file.getInputStream());
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        //获取指定标签页
+        HSSFSheet sheet = workbook.getSheetAt(0);
+        if(sheet==null){
+            throw new RuntimeException("标签页不存在！");
+        }
+
+        //总行数
+        int rows = sheet.getPhysicalNumberOfRows();
+        if (rows < 2) {
+            throw new RuntimeException(file.getName()+" 内容为空，请重新编辑！");
+        }
+
+        //不为空的单元格数  ，第一行是标题列
+        HSSFRow keyRow = sheet.getRow(0);
+        int cellNumber = keyRow.getPhysicalNumberOfCells();
+
+        //循环遍历，第一行是标题，所以从 1 开始遍历（0表示第一行，1表示第二行）
+        for (int r = 1; r < rows; r++) {
+            Map<Integer,Object> record = new LinkedHashMap<Integer,Object>();//使用HashMap的话，存进去的顺序与取出来的顺序是不一致的，此处需要使用LinkedHashMap
+            HSSFRow row = sheet.getRow(r);
+            if(row == null){
+                logList.add("表中存在错误的单元格，请把与内容无关的单元格置空");
+                break;
+            }
+
+            for (int c = 0; c < cellNumber; c++){ //共cellNumber列
+                HSSFCell cell = row.getCell(c);
+                String cellValue = "";
+                DecimalFormat df = new DecimalFormat("#");
+                //如果单元格不为空
+                if (cell != null) {
+                    if(c == 1){
+                        String platform =cell.getRichStringCellValue().getString().trim();
+                        if(platform.length() == 0){
+                            logList.add("第"+(r+1)+"行第"+(c+1)+"列数据为空");
+                        }else{
+                            if(!isPlatform(platform)){
+                                logList.add("第"+(r+1)+"行第"+(c+1)+"列数据不符合要求");
+                            }else{
+                                String platformSave = "[" + platform + "]";
+                                record.put(c,platformSave);
+                                continue;
+                            }
+
+                        }
+                    }
+
+                    if(c == 4){
+                        String type =cell.getRichStringCellValue().getString().trim();
+                        if(type.length() == 0){
+                            logList.add("第"+(r+1)+"行第"+(c+1)+"列数据为空");
+                        }else{
+                            if(!isType(type)){
+                                logList.add("第"+(r+1)+"行第"+(c+1)+"列数据不符合要求");
+                            }else{
+                                String typeSave = "[" + type + "]";
+                                record.put(c,typeSave);
+                                continue;
+                            }
+
+                        }
+                    }
+
+                    if(c == 3){
+                        String phone = cell.getRichStringCellValue().getString().trim();
+                        if(!isRightPhone(phone)){
+                            logList.add("第"+(r+1)+"行第"+(c+1)+"列手机号格式不正确");
+                        }
+                    }
+
+                    switch (cell.getCellType()) {
+                        case HSSFCell.CELL_TYPE_STRING:
+                            cellValue =cell.getRichStringCellValue().getString().trim();
+                            if(cellValue.indexOf(" ") != -1){
+                                logList.add("第"+(r+1)+"行第"+(c+1)+"列数据中存在空格");
+                            }
+                            break;
+                        case HSSFCell.CELL_TYPE_NUMERIC:
+                            cellValue =df.format(cell.getNumericCellValue());
+                            break;
+                        case HSSFCell.CELL_TYPE_BOOLEAN:
+                            cellValue =String.valueOf(cell.getBooleanCellValue()).trim();
+                            break;
+                        case HSSFCell.CELL_TYPE_FORMULA:
+                            cellValue =cell.getCellFormula();
+                            break;
+                        case HSSFCell.CELL_TYPE_BLANK:
+                            logList.add("第"+(r+1)+"行第"+(c+1)+"列数据为空");
+                            break;
+                        default:
+                            cellValue = "";
+                    }
+                }else{
+                    logList.add("第"+(r+1)+"行第"+(c+1)+"列为空");
+                }
+                record.put(c,cellValue);
+            }
+            recordList.add(record);
+        }
+
+//        System.out.println("logList.toString() " + logList.toString());
+//        System.out.println("recordList.toString()  " + recordList.toString());
+
+        if(logList.size() != 0){
+            String mes = "表格中存在问题，导入失败！";
+            return mes + logList.toString();
+        }else{
+            List<CrowdTestProjectPO> crowdTestProjectPOList = new ArrayList<>();
+            CrowdTestProjectPO crowdTestProjectPO = new CrowdTestProjectPO();
+            for(Map<Integer,Object> map : recordList){
+                crowdTestProjectPO.setName(map.get(0).toString());
+                crowdTestProjectPO.setPlatform(map.get(1).toString());
+                crowdTestProjectPO.setLinkMan(map.get(2).toString());
+                crowdTestProjectPO.setLinkManMobile(map.get(3).toString());
+                crowdTestProjectPO.setType(map.get(4).toString());
+                crowdTestProjectPO.setDescription(map.get(5).toString());
+                crowdTestProjectPOList.add(crowdTestProjectPO);
+            }
+            for(int i = 0; i < crowdTestProjectPOList.size(); i++){
+                CrowdTestProject crowdTestProject = Converter.convert(CrowdTestProject.class, crowdTestProjectPOList.get(i));
+                CrowdTestProject crowdTestProjectResult = crowdTestProject.generateDefaultTaskAndReportData();
+                //TODO 保存数据库
+                crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+            }
+            return "SUCCESS";
+        }
+    }
+
+
+    /**
+     * 通过表单向数据库中导入众包项目文件，并补全项目中任务和报告的数据
+     * @return
+     */
+    @RequestMapping(value = "projectListImportByForm", method = RequestMethod.GET)
+    public String projectListImportByForm(){
+
+        //数据准备
+        CrowdTestProject crowdTestProject = new CrowdTestProject();
+        crowdTestProject.setName("百度APP");
+        crowdTestProject.setPlatform("[1,2]");
+        crowdTestProject.setLinkMan("薛晓波");
+        crowdTestProject.setLinkManMobile("13567908766");
+        crowdTestProject.setType("[1]");
+        crowdTestProject.setDescription("测试项目中存在的bug");
+
+        //具体操作
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.generateDefaultTaskAndReportData();
+        //TODO 保存数据库
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return "success";
+    }
+
+
+
+    /**
+     * 计算指定时间的后几天
+     */
+    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();
+    }
+}

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

@@ -0,0 +1,38 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.CrowdTestProjectPO;
+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);
+
+    @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,38 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.CrowdTestTaskPO;
+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);
+
+    @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/EvaluationAgencyDao.java

@@ -0,0 +1,33 @@
+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);
+
+    List<EvaluationAgencyPO> findByIsAuthentication(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/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/RegionalManagerDao.java

@@ -0,0 +1,33 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.RegionalManagerPO;
+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 RegionalManagerDao extends PagingAndSortingRepository<RegionalManagerPO, Long>, JpaSpecificationExecutor<RegionalManagerPO> {
+
+    Optional<RegionalManagerPO> findById(Long Id);
+
+    List<RegionalManagerPO> findByUserId(Long userId);
+
+    RegionalManagerPO findByRegionalId(Long regionalId);
+
+    @Override
+    Iterable<RegionalManagerPO> findAllById(Iterable<Long> iterable);
+
+    @Override
+    Iterable<RegionalManagerPO> findAll();
+
+    @Override
+    void delete(RegionalManagerPO regionalManagerPO);
+
+    void deleteAll(Iterable<? extends RegionalManagerPO> iterable);
+
+    RegionalManagerPO save(RegionalManagerPO regionalManagerPO);
+
+}

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/UserDao.java

@@ -1,21 +1,30 @@
 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
-    User save(User user);
+    Iterable<UserPO> findAll();
+
+    @Override
+    void delete(UserPO userPO);
+
+    void deleteAll(Iterable<? extends UserPO> iterable);
+
+    UserPO save(UserPO userPo);
+
 }

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,13 +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.BaseException;
+import com.mooctest.crowd.domain.exception.CrowdTestProjectException;
 import lombok.Data;
 
 import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.Date;
 import java.util.List;
 
 /**
@@ -19,143 +19,341 @@ 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 +
+                ", deadTime=" + deadTime +
+                ", endTime=" + endTime +
+                ", createTime=" + createTime +
+                ", isDeleted=" + isDeleted +
                 ", crowdTestTaskList=" + crowdTestTaskList +
+                ", crowdTestReportForProject=" + crowdTestReportForProject +
                 '}';
     }
 
-    public CrowdTestTask getCrowdTestTaskByTaskId(CrowdTestProject crowdTestProject, Long taskId) throws CrowdTestTaskNotExistException {
+
+    /**
+     * 更新项目信息
+     * @param crowdTestProject
+     * @param crowdTestProjectModify
+     * @return
+     */
+    public CrowdTestProject updateCrowdTestProject(CrowdTestProject crowdTestProject, CrowdTestProject crowdTestProjectModify){
+        Gson gson = new Gson();
+        crowdTestProject = gson.fromJson(gson.toJson(crowdTestProjectModify),CrowdTestProject.class);
+        return crowdTestProject;
+    }
+
+    /**
+     * 更新项目中的指定任务信息
+     * @param crowdTestProject
+     * @param crowdTestTaskCode
+     * @param crowdTestTaskModify
+     * @return
+     */
+    public CrowdTestProject updateCrowdTestTask(CrowdTestProject crowdTestProject, String crowdTestTaskCode, CrowdTestTask crowdTestTaskModify){
+        List<CrowdTestTask> crowdTestTaskListNew = new ArrayList<>();
         List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
-        for (CrowdTestTask crowdTestTask : crowdTestTaskList) {
-            if (crowdTestTask.getId().equals(taskId)) {
-                return crowdTestTask;
+        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();
+        crowdTestProject.setCrowdTestTaskList(crowdTestTaskListNew);
+        return crowdTestProject;
     }
 
-    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);
+    /**
+     * 更新项目中任务的指定报告信息
+     * @param crowdTestProject
+     * @param crowdTestTaskCode
+     * @param crowdTestReportCode
+     * @param crowdTestReportModify
+     * @return
+     */
+    public CrowdTestProject updateCrowdTestReport(CrowdTestProject crowdTestProject, String crowdTestTaskCode, String crowdTestReportCode, CrowdTestReport crowdTestReportModify) {
+        List<CrowdTestTask> crowdTestTaskListNew = new ArrayList<>();
+        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.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);
+        }
+        crowdTestProject.setCrowdTestTaskList(crowdTestTaskListNew);
         return crowdTestProject;
     }
 
-    /** Task */
-
-    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();
+    /**
+     * 逻辑删除项目
+     * @return
+     */
+    public CrowdTestProject removeCrowdTestProject() {
+        if(this.getIsDeleted() == DeletedStatus.isDeleted){
+            throw new CrowdTestProjectException("项目已被删除，不能再次删除");
+        }else{
+            List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
+            for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+                crowdTestTask.removeCrowdTestTask();
+                List<CrowdTestReport> crowdTestReportList = crowdTestTask.getCrowdTestReportList();
+                for(CrowdTestReport crowdTestReport : crowdTestReportList){
+                    crowdTestReport.removeCrowdTestReport();
+                }
+            }
+            this.setStatus(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) {
+        List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
+        for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+            if(crowdTestTaskCode.equals(crowdTestTask.getCode())){
+                crowdTestTask.removeCrowdTestTask();
+                List<CrowdTestReport> crowdTestReportList = crowdTestTask.getCrowdTestReportList();
+                for(CrowdTestReport crowdTestReport : crowdTestReportList){
+                    crowdTestReport.removeCrowdTestReport();
+                }
+            }
+        }
+
+        boolean judgeHasCrowdTestTask = false;
+        for(CrowdTestTask crowdTestTask : this.getCrowdTestTaskList()){
+            if(crowdTestTask.getIsDeleted() == DeletedStatus.isNotDeleted){
+                judgeHasCrowdTestTask = true;
             }
         }
-        if (flag) {
-            crowdTestTask.setStatus(status);
-            return true;
-        } else {
-            return flag;
+
+        // 如果删除任务后，项目中不存在任务，把项目状态从HAS_SPLITED改为HAS_RECEIVED
+        if(!judgeHasCrowdTestTask){
+            this.setStatus(CrowdTestProjectStatus.HAS_RECEIVED);
         }
+        return this;
     }
 
-    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();
+    /**
+     * 逻辑删除报告
+     * @param crowdTestTaskCode
+     * @param crowdTestReportCode
+     * @return
+     */
+    public CrowdTestProject removeCrowdTestReport(String crowdTestTaskCode, String crowdTestReportCode) {
+        List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
+        for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+            if(crowdTestTaskCode.equals(crowdTestTask.getCode())){
+                List<CrowdTestReport> crowdTestReportList = crowdTestTask.getCrowdTestReportList();
+                for(CrowdTestReport crowdTestReport : crowdTestReportList){
+                    if(crowdTestReportCode.equals(crowdTestReport.getCode())){
+                        crowdTestReport.removeCrowdTestReport();
+                    }
+                }
             }
         }
-        throw new CrowdTestProjectNotExistException();
-    }
 
-    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);
+        boolean judgeHasCrowdTestReport = false;
+        for(CrowdTestTask crowdTestTask : this.getCrowdTestTaskList()){
+            if(crowdTestTaskCode.equals(crowdTestTask.getCode())){
+                List<CrowdTestReport> crowdTestReportList = crowdTestTask.getCrowdTestReportList();
+                for(CrowdTestReport crowdTestReport : crowdTestReportList){
+                    if(crowdTestReport.getIsDeleted() == DeletedStatus.isNotDeleted){
+                        judgeHasCrowdTestReport = true;
+                    }
+                }
+                // 删除报告后，如果任务中不存在报告，把任务状态从HAS_REPORTED改为HAS_RECEIVED
+                if(!judgeHasCrowdTestReport){
+                    crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_RECEIVED);
+                }
+            }
         }
-        return crowdTestTaskList;
+        return this;
     }
 
 
-    /** 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;
+    /**
+     * 删除项目报告，并修改项目转态
+     * @return
+     */
+    public CrowdTestProject removeCrowdTestProjectReport() {
+        CrowdTestReport crowdTestReportForProject = this.getCrowdTestReportForProject();
+        if(crowdTestReportForProject.getIsDeleted() != DeletedStatus.isNotDeleted){
+            throw new CrowdTestProjectException("项目报告已经被删除，不可重复删除");
+        }else{
+            crowdTestReportForProject.setIsDeleted(DeletedStatus.isDeleted);
+        }
+
+        if(CrowdTestProjectStatus.HAS_REPORTED == this.getStatus()){
+            this.setStatus(CrowdTestProjectStatus.HAS_SPLITED);
+        }else{
+            throw new CrowdTestProjectException("项目当前状态不可进行报告删除，当前状态为："+this.getStatus());
+        }
+        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();
+    public void addTask(CrowdTestTask task){
+        if (this.getStatus() != CrowdTestProjectStatus.HAS_RECEIVED && this.getStatus() != CrowdTestProjectStatus.HAS_SPLITED)
+            throw new BaseException("当前阶段不允许创建新任务");
+        this.getCrowdTestTaskList().add(task);
+        this.setStatus(CrowdTestProjectStatus.HAS_SPLITED);
     }
 
-    public CrowdTestProject updateCrowdTestProjectStatusToFinish(Long projectId, String status) throws CrowdTestProjectNotExistException {
-        CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
-        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(projectId);
-        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
-        for(CrowdTestTask crowdTestTask : crowdTestTaskList){
-            List<CrowdTestReport> crowdTestReportList = crowdTestTask.getCrowdTestReportList();
-            for(CrowdTestReport crowdTestReport : crowdTestReportList){
-                crowdTestReport.setStatus(status);
+    /**
+     * 设置任务和报告的数据
+     * @return
+     */
+    public CrowdTestProject generateDefaultTaskAndReportData() {
+        this.setCode("PROJ-"+ this.getName()); //换成名称
+        this.setUserId(11L);
+        this.setRegionalManagerId(13L);
+        this.setProjectDistributionTypeId(1L);
+        this.setDistributionProvince("江苏");
+        this.setDistributionCity("南京");
+        this.setFixedPrice(100000.00);
+        this.setQuotedPrice(100000.00);
+        this.setStatus(CrowdTestProjectStatus.HAS_FINISHED);
+        this.setIsDeleted(DeletedStatus.isNotDeleted);
+        this.setCreateTime(new Timestamp(getBeforeDay(new Date(System.currentTimeMillis()),5).getTime()));
+        this.setDeadTime(new Timestamp(getBeforeDay(new Date(System.currentTimeMillis()),1).getTime()));
+        
+        //初始化任务
+        int taskCount = 1;
+        List<CrowdTestTask> crowdTestTaskList = new ArrayList<>();
+        for(int j = 0; j < taskCount; j++){
+            CrowdTestTask crowdTestTask = new CrowdTestTask();
+            crowdTestTask.setCode(this.getCode()+"-TASK-任务"+(j+1));
+            crowdTestTask.setName(this.getName() + "-任务" + (j+1));
+            crowdTestTask.setCrowdTestProjectCode(this.getCode());
+            crowdTestTask.setEvaluationAgencyId(12L);
+            crowdTestTask.setType(0);
+            crowdTestTask.setDistributionType(this.getProjectDistributionTypeId());
+            crowdTestTask.setDistributionProvince(this.getDistributionProvince());
+            crowdTestTask.setDistributionCity(this.getDistributionCity());
+            crowdTestTask.setDescription("这是"+this.getName()+"测试项目的第"+(j+1)+"个测试任务");
+            crowdTestTask.setQuotedPrice(this.getQuotedPrice() / taskCount);
+            crowdTestTask.setFixedPrice(this.getFixedPrice() / taskCount);
+            crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_FINISHED);
+            crowdTestTask.setIsDeleted(DeletedStatus.isNotDeleted);
+            crowdTestTask.setCreateTime(new Timestamp(getBeforeDay(new Date(System.currentTimeMillis()),4).getTime()));
+            crowdTestTask.setDeadTime(new Timestamp(getBeforeDay(new Date(System.currentTimeMillis()),2).getTime()));
+
+            //初始化任务报告
+            int reportCount = 1;
+            List<CrowdTestReport> crowdTestReportList = new ArrayList<>();
+
+            for(int k = 0; k < reportCount; k++){
+                CrowdTestReport crowdTestReport = new CrowdTestReport();
+                crowdTestReport.setCode(crowdTestTask.getCode()+"REPO-报告"+(k+1));
+                crowdTestReport.setName(crowdTestTask.getName()+"-报告"+(k+1));
+                crowdTestReport.setDependencyCode(crowdTestTask.getCode());
+                crowdTestReport.setType(0);
+                crowdTestReport.setScope(0);
+                crowdTestReport.setContent(crowdTestTask.getDescription()+"的第"+(k+1)+"的测试报告");
+                crowdTestReport.setConclusion("TEST SUCCESS");
+                crowdTestReport.setIsDeleted(DeletedStatus.isNotDeleted);
+                crowdTestReport.setCreateTime(new Timestamp(getBeforeDay(new Date(System.currentTimeMillis()),3).getTime()));
+                crowdTestReportList.add(crowdTestReport);
             }
-            crowdTestTask.setStatus(status);
+            crowdTestTask.setCrowdTestReportList(crowdTestReportList);
+            crowdTestTaskList.add(crowdTestTask);
         }
-        crowdTestProject.setStatus(status);
-        return crowdTestProject;
+        //初始化项目报告
+        CrowdTestReport crowdTestReportForProject = new CrowdTestReport();
+        crowdTestReportForProject.setCode(this.getCode()+"-项目报告");
+        crowdTestReportForProject.setName(this.getName()+"-项目报告");
+        crowdTestReportForProject.setDependencyCode(this.getCode());
+        crowdTestReportForProject.setType(0);
+        crowdTestReportForProject.setScope(0);
+        crowdTestReportForProject.setContent(this.getName()+"的项目报告");
+        crowdTestReportForProject.setConclusion("PROJECT TEST SUCCESS");
+        crowdTestReportForProject.setIsDeleted(DeletedStatus.isNotDeleted);
+        crowdTestReportForProject.setCreateTime(new Timestamp(getBeforeDay(new Date(System.currentTimeMillis()),2).getTime()));
+
+        this.setCrowdTestReportForProject(crowdTestReportForProject);
+        this.setCrowdTestTaskList(crowdTestTaskList);
+
+        return this;
+    }
+
+    /**
+     * 计算指定时间的后几天
+     */
+    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;
     }
 }

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

@@ -5,9 +5,11 @@ 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_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 = 5; //提交项目
+    public static final int HAS_FINISHED = 6; //结束项目
 }

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 type;
+    private String name;
+    private String code;
+    private String dependencyCode; //所依赖的项目或者任务
+    private int 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

@@ -15,30 +15,45 @@ 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 int 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 +
                 '}';
     }
@@ -53,4 +68,7 @@ public class CrowdTestTask {
         throw new CrowdTestReportNotExistException();
     }
 
+    public void removeCrowdTestTask() {
+        this.isDeleted = DeletedStatus.isDeleted;
+    }
 }

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

@@ -5,9 +5,10 @@ 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_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 = 4; //提交任务
+    public static final int HAS_FINISHED = 5; //结束任务
 }

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/EvaluationAgency.java

@@ -1,9 +1,5 @@
 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 lombok.Data;
 
 import java.sql.Timestamp;
@@ -13,7 +9,7 @@ import java.sql.Timestamp;
  * @date 2019/7/12 1:32
  */
 @Data
-public class EvaluationAgency extends User {
+public class EvaluationAgency {
     private Long id;
     private Long userId;
     private String evaluationAgencyName;
@@ -22,32 +18,28 @@ public class EvaluationAgency extends User {
     private String abilities;
     private String resources;
     private String agencyPhoto;
+    private int isAuthentication;
+    private int isDeleted;
     private Timestamp updateTime;
     private Timestamp expireTime;
+    private Timestamp createTime;
 
     @Override
-    public Long getId() {
-        return id;
-    }
-
-    @Override
-    public void setId(Long id) {
-        this.id = id;
-    }
-
-    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();
-            }
-        }
-        throw new CrowdTestProjectNotExistException();
+    public String toString() {
+        return "EvaluationAgency{" +
+                "id=" + id +
+                ", userId=" + userId +
+                ", evaluationAgencyName='" + evaluationAgencyName + '\'' +
+                ", bankAccount='" + bankAccount + '\'' +
+                ", address='" + address + '\'' +
+                ", abilities='" + abilities + '\'' +
+                ", resources='" + resources + '\'' +
+                ", agencyPhoto='" + agencyPhoto + '\'' +
+                ", isAuthentication=" + isAuthentication +
+                ", isDeleted=" + isDeleted +
+                ", updateTime=" + updateTime +
+                ", expireTime=" + expireTime +
+                ", createTime=" + createTime +
+                '}';
     }
 }

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/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 String province;
+    private String city;
+
+    @Override
+    public String toString() {
+        return "Regional{" +
+                "id=" + id +
+                ", province='" + province + '\'' +
+                ", city='" + city + '\'' +
+                '}';
+    }
+}

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

@@ -1,8 +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 com.mooctest.crowd.domain.exception.CrowdTestProjectException;
+import com.mooctest.crowd.domain.exception.CrowdTestTaskException;
 import lombok.Data;
 
 import java.util.ArrayList;
@@ -13,39 +12,163 @@ 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 Long regionalId;
 
-    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>();
+//    private Regional regional;
+    private List<Regional> regionalList;
+
+    @Override
+    public String toString() {
+        return "RegionalManager{" +
+                "id=" + id +
+                ", userId=" + userId +
+                ", regionalList=" + regionalList +
+                '}';
+    }
+
+
+    /**
+     * 区域管理员接收项目
+     * @param crowdTestProject
+     * @return
+     */
+    public CrowdTestProject receiveProject(CrowdTestProject crowdTestProject) {
+        List<Regional> regionalList = this.getRegionalList();
+        if(crowdTestProject.getRegionalManagerId() != null){
+            throw new CrowdTestProjectException("项目已被接收");
+        }else if(crowdTestProject.getStatus() != (CrowdTestProjectStatus.HAS_RECEIVED-1)){
+            throw new CrowdTestProjectException("项目不能被接收，项目状态为: " + crowdTestProject.getStatus());
+        }else{
+            boolean couldReceive = false;
+            for(Regional regional : regionalList){
+                if(crowdTestProject.getDistributionProvince().equals(regional.getProvince())&&crowdTestProject.getDistributionCity().equals(regional.getCity())){
+                    couldReceive = true;
+                }
+            }
+            if(!couldReceive){
+                throw new CrowdTestProjectException("项目区域不符合区域管理员的要求");
+            }else{
+                crowdTestProject.setRegionalManagerId(this.getUserId());
+                crowdTestProject.setStatus(CrowdTestProjectStatus.HAS_RECEIVED);
+            }
+        }
+        return crowdTestProject;
+    }
+
+    /**
+     * 创建测试任务
+     * @param crowdTestTask
+     * @return
+     */
+    public CrowdTestProject createCrowdTestTask(CrowdTestProject crowdTestProject, CrowdTestTask crowdTestTask) {
+        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
+
+        crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_CREATED);
+        crowdTestTask.setDistributionProvince(crowdTestProject.getDistributionProvince());
+        crowdTestTask.setDistributionCity(crowdTestProject.getDistributionCity());
+
+        //添加测试任务
+        crowdTestTaskList.add(crowdTestTask);
+
+        //修改项目状态
+        if(CrowdTestProjectStatus.HAS_SPLITED != crowdTestProject.getStatus()){
+            crowdTestProject.setStatus(CrowdTestProjectStatus.HAS_SPLITED);
+        }
         crowdTestProject.setCrowdTestTaskList(crowdTestTaskList);
-        return crowdTestTaskList;
+        return crowdTestProject;
     }
 
-    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;
+
+    /**
+     * 发布任务
+     * @param crowdTestProject
+     * @param crowdTestTaskCode
+     * @return
+     */
+    public CrowdTestProject releaseCrowdTestTask(CrowdTestProject crowdTestProject, String crowdTestTaskCode) {
+        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.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);
                 }
             }
-            if (!flag) {
-                throw new CrowdTestTaskNotExistException();
+            crowdTestTaskListResult.add(crowdTestTask);
+        }
+
+        crowdTestProject.setCrowdTestTaskList(crowdTestTaskListResult);
+        return crowdTestProject;
+    }
+
+    /**
+     * 结束任务
+     * @param crowdTestProject
+     * @return
+     */
+    public CrowdTestProject finishCrowdTestTask(CrowdTestProject crowdTestProject) {
+        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
+        List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
+        //结束任务时修改任务状态为"已结束"
+        for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+            if(crowdTestTask.getStatus() != (CrowdTestTaskStatus.HAS_FINISHED-1)){
+                throw new CrowdTestTaskException("存在任务不能被结束，状态为："+crowdTestTask.getStatus());
+            }else{
+                crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_FINISHED);
             }
+            crowdTestTaskListResult.add(crowdTestTask);
         }
-        throw new CrowdTestProjectNotExistException();
+
+        crowdTestProject.setCrowdTestTaskList(crowdTestTaskListResult);
+        return crowdTestProject;
     }
 
 
+    /**
+     * 创建项目报告
+     * @param crowdTestProject
+     * @param crowdTestReport
+     * @return
+     */
+    public CrowdTestProject createCrowdTestProjectReport(CrowdTestProject crowdTestProject, CrowdTestReport crowdTestReport) {
+        crowdTestProject.setCrowdTestReportForProject(crowdTestReport);
+        if(crowdTestProject.getStatus() != (CrowdTestProjectStatus.HAS_REPORTED - 1)){
+            throw new CrowdTestProjectException("项目报告不能被提交，当前状态为："+crowdTestProject.getStatus());
+        }else {
+            crowdTestProject.setStatus(CrowdTestProjectStatus.HAS_REPORTED);
+        }
+        return crowdTestProject;
+    }
+
+
+    /**
+     * 提交项目
+     * @param crowdTestProject
+     * @return
+     */
+    public CrowdTestProject commitCrowdTestProject(CrowdTestProject crowdTestProject) {
+        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
+        if(crowdTestProject.getCrowdTestReportForProject() == null){
+            throw new CrowdTestProjectException("还未创建项目报告，项目不能被提交");
+        }
+
+        //结束项目时查看是否已结束任务
+        if(crowdTestProject.getStatus() != (CrowdTestProjectStatus.HAS_COMMITED - 1)){
+            throw new CrowdTestProjectException("项目不能被结束，状态为："+crowdTestProject.getStatus());
+        }else{
+            for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+                if(crowdTestTask.getStatus() != CrowdTestTaskStatus.HAS_FINISHED){
+                    throw new CrowdTestTaskException("存在未结束的任务，项目不能被提交");
+                }
+            }
+        }
+        crowdTestProject.setStatus(CrowdTestProjectStatus.HAS_COMMITED);
+        return crowdTestProject;
+    }
 }

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/User.java

@@ -1,8 +1,12 @@
 package com.mooctest.crowd.domain.domainobject;
 
+import com.mooctest.crowd.domain.exception.CrowdTestProjectException;
+import com.mooctest.crowd.domain.exception.CrowdTestTaskException;
 import lombok.Data;
 
 import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * @author guochao
@@ -19,7 +23,232 @@ public class User {
     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 List<Role> roleList;
+    private EvaluationAgency evaluationAgency;
+
+    @Override
+    public String toString() {
+        return "User{" +
+                "id=" + id +
+                ", name='" + name + '\'' +
+                ", userName='" + userName + '\'' +
+                ", password='" + password + '\'' +
+                ", gender='" + gender + '\'' +
+                ", mobile='" + mobile + '\'' +
+                ", province='" + province + '\'' +
+                ", city='" + city + '\'' +
+                ", photoUrl='" + photoUrl + '\'' +
+                ", isAvailable=" + isAvailable +
+                ", isDeleted=" + isDeleted +
+                ", createTime=" + createTime +
+                ", regionalManager=" + regionalManager +
+                ", roleList=" + roleList +
+                ", evaluationAgency=" + evaluationAgency +
+                '}';
+    }
+
+    /**
+     * 创建测试项目（普通用户）
+     * @param crowdTestProject
+     * @return
+     */
+    public CrowdTestProject createCrowdTestProject(CrowdTestProject crowdTestProject) {
+        crowdTestProject.setUserId(this.getId());
+        crowdTestProject.setDistributionProvince(this.getProvince());
+        crowdTestProject.setDistributionCity(this.getCity());
+        crowdTestProject.setStatus(CrowdTestProjectStatus.HAS_CREATED);
+        return crowdTestProject;
+    }
+
+
+    /**
+     * 发布项目（普通用户）
+     * @param crowdTestProject
+     * @return
+     */
+    public CrowdTestProject releaseCrowdTestProject(CrowdTestProject crowdTestProject) {
+        if(crowdTestProject.getStatus() != (CrowdTestProjectStatus.HAS_RELEASED-1)){
+            throw new CrowdTestProjectException("当前项目状态不能被发布");
+        }else{
+            crowdTestProject.setStatus(CrowdTestProjectStatus.HAS_RELEASED);
+        }
+        return crowdTestProject;
+    }
+
+    /**
+     * 接收任务（测评机构）
+     * @param crowdTestProject
+     * @param crowdTestTaskCode
+     * @return
+     */
+    public CrowdTestProject receiveTask(CrowdTestProject crowdTestProject, String crowdTestTaskCode) {
+
+        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
+        List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
+        for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+            if(crowdTestTaskCode.equals(crowdTestTask.getCode())){
+                if(crowdTestTask.getStatus() != (CrowdTestTaskStatus.HAS_RECEIVED - 1)){
+                    throw new CrowdTestTaskException("任务当前状态不能被接收，当前状态为："+crowdTestTask.getStatus());
+                }else if(!(this.getProvince().equals(crowdTestTask.getDistributionProvince())&&this.getCity().equals(crowdTestTask.getDistributionCity()))){
+                    throw new CrowdTestTaskException("测评机构区域不符合任务区域的要求");
+                }else{
+                    crowdTestTask.setEvaluationAgencyId(this.getId());
+                    crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_RECEIVED);
+                }
+            }
+            crowdTestTaskListResult.add(crowdTestTask);
+        }
+        crowdTestProject.setCrowdTestTaskList(crowdTestTaskList);
+        return crowdTestProject;
+
+    }
+
+    /**
+     * 创建测试报告（测评机构）
+     * @param crowdTestTaskCode
+     * @param crowdTestReport
+     * @return
+     */
+    public CrowdTestProject createCrowdTestReport(CrowdTestProject crowdTestProject,String crowdTestTaskCode, CrowdTestReport crowdTestReport) {
+        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
+        List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
+        for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+            if(crowdTestTask.getCode().equals(crowdTestTaskCode)){
+                List<CrowdTestReport> crowdTestReportList = crowdTestTask.getCrowdTestReportList();
+                crowdTestReportList.add(crowdTestReport);
+                crowdTestTask.setCrowdTestReportList(crowdTestReportList);
+            }
+            crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_REPORTED);
+            crowdTestTaskListResult.add(crowdTestTask);
+        }
+        crowdTestProject.setCrowdTestTaskList(crowdTestTaskListResult);
+        return crowdTestProject;
+    }
+
+//    /**
+//     * 提交测试报告（测评机构）
+//     * @param crowdTestProject
+//     * @param crowdTestTaskCode
+//     * @param crowdTestReportCode
+//     * @return
+//     */
+//    public CrowdTestProject commitCrowdTestReport(CrowdTestProject crowdTestProject, String crowdTestTaskCode, String crowdTestReportCode) {
+//        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
+//        List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
+//        for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+//            if(crowdTestTask.getCode().equals(crowdTestTaskCode)){
+//                List<CrowdTestReport> crowdTestReportList = crowdTestTask.getCrowdTestReportList();
+//                List<CrowdTestReport> crowdTestReportListResult = new ArrayList<>();
+//                for(CrowdTestReport crowdTestReport : crowdTestReportList){
+//                    if(crowdTestReportCode.equals(crowdTestReport.getCode())){
+//                        if(CrowdTestReportStatus.COMMITED.equals(crowdTestReport.getStatus())){
+//                            throw new CrowdTestReportException("报告已被提交，不能再次提交");
+//                        }else if(CrowdTestReportStatus.CREATED.equals(crowdTestReport.getStatus())){
+//                            crowdTestReport.setStatus(CrowdTestReportStatus.COMMITED);
+//                            crowdTestReportListResult.add(crowdTestReport);
+//                        }else{
+//                            throw new CrowdTestReportException("报告状态有误");
+//                        }
+//                    }
+//                }
+//
+//                crowdTestTask.setCrowdTestReportList(crowdTestReportListResult);
+//            }
+//            crowdTestTaskListResult.add(crowdTestTask);
+//        }
+//        crowdTestProject.setCrowdTestTaskList(crowdTestTaskListResult);
+//        return crowdTestProject;
+//    }
+//
+//    /**
+//     * 提交所有测试报告（测评机构）
+//     * @param crowdTestProject
+//     * @param crowdTestTaskCode
+//     * @return
+//     */
+//    public CrowdTestProject commitAllCrowdTestReport(CrowdTestProject crowdTestProject, String crowdTestTaskCode) {
+//        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
+//        List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
+//        for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+//            if(crowdTestTask.getCode().equals(crowdTestTaskCode)){
+//                List<CrowdTestReport> crowdTestReportList = crowdTestTask.getCrowdTestReportList();
+//                List<CrowdTestReport> crowdTestReportListResult = new ArrayList<>();
+//                for(CrowdTestReport crowdTestReport : crowdTestReportList){
+//                    if(CrowdTestReportStatus.COMMITED.equals(crowdTestReport.getStatus())){
+//                        throw new CrowdTestReportException("报告已被提交，不能再次提交");
+//                    }else if(CrowdTestReportStatus.CREATED.equals(crowdTestReport.getStatus())){
+//                        crowdTestReport.setStatus(CrowdTestReportStatus.COMMITED);
+//                        crowdTestReportListResult.add(crowdTestReport);
+//                    }else{
+//                        throw new CrowdTestReportException("报告状态有误");
+//                    }
+//                }
+//
+//                crowdTestTask.setCrowdTestReportList(crowdTestReportListResult);
+//            }
+//            crowdTestTaskListResult.add(crowdTestTask);
+//        }
+//        crowdTestProject.setCrowdTestTaskList(crowdTestTaskListResult);
+//        return crowdTestProject;
+//    }
+
+    /**
+     * 提交测试任务
+     * @param crowdTestProject
+     * @param crowdTestTaskCode
+     * @return
+     */
+    public CrowdTestProject commitCrowdTestTask(CrowdTestProject crowdTestProject, String crowdTestTaskCode) {
+        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
+        List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
+        for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+            if(crowdTestTask.getCode().equals(crowdTestTaskCode)){
+                System.out.println("list:"+crowdTestTask.getCrowdTestReportList());
+                if(crowdTestTask.getCrowdTestReportList().size() == 0){
+                    throw new CrowdTestTaskException("当前任务中没有报告，不能提交此任务");
+                }else if(crowdTestTask.getStatus() != (CrowdTestTaskStatus.HAS_COMMITED-1)){
+                    throw new CrowdTestTaskException("任务状态有误，无法提交，任务状态为："+crowdTestTask.getStatus());
+                }else if((CrowdTestTaskStatus.HAS_COMMITED - 1) == crowdTestTask.getStatus()){
+                    crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_COMMITED);
+                }
+            }
+            crowdTestTaskListResult.add(crowdTestTask);
+
+        }
+        crowdTestProject.setCrowdTestTaskList(crowdTestTaskListResult);
+        return crowdTestProject;
+    }
+
+    /**
+     * 结束项目
+     * @param crowdTestProject
+     * @return
+     */
+    public CrowdTestProject finishCrowdTestProjet(CrowdTestProject crowdTestProject) {
+        if(crowdTestProject.getStatus() != (CrowdTestProjectStatus.HAS_FINISHED - 1)){
+            throw new CrowdTestProjectException("项目不能被提交，当前状态为："+crowdTestProject.getStatus());
+        }else{
+            crowdTestProject.setStatus(CrowdTestProjectStatus.HAS_FINISHED);
+        }
+        return crowdTestProject;
+    }
+
+
+    public User applyAgencyAuthentication(EvaluationAgency evaluationAgency) {
+        evaluationAgency.setUserId(this.id);
+        evaluationAgency.setIsAuthentication(AuthenticationStatus.isAuthenIng);
+        evaluationAgency.setIsDeleted(DeletedStatus.isNotDeleted);
+        this.setEvaluationAgency(evaluationAgency);
+        return this;
+    }
+
+    public User passApplication() {
+        this.getEvaluationAgency().setIsAuthentication(AuthenticationStatus.isAuthenticated);
+        return this;
+    }
 }

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,29 @@ 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 DefaultFeatureConfiguration defaultFeatureConfiguration = new DefaultFeatureConfiguration();
+//
+//    private Logger LOG = LoggerFactory.getLogger(getClass());
+
+    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;
     }
 
-    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});
-    }
+//    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});
+//    }
 
 }

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,8 @@
+package com.mooctest.crowd.domain.exception;
+
+/**
+ * @author guochao
+ * @date 2019-07-30 09:15
+ */
+public class EvaluationAgencyNotExistException extends BaseException {
+}

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/UnauthorizedException.java

@@ -0,0 +1,12 @@
+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("请登录后访问");
+    }
+}

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

@@ -0,0 +1,8 @@
+package com.mooctest.crowd.domain.exception;
+
+/**
+ * @Author: xuexb
+ * @Date: 2019.7.5 14:36
+ */
+public class UserNotExistException extends BaseException {
+}

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,39 @@ 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(1L);
+        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);
+        task.setDistributionProvince("江苏");
+        task.setDistributionCity("南京");
+        return task;
+    }
+
+    public static CrowdTestReport defaultProjectReport() {
+        CrowdTestReport report = new CrowdTestReport();
+        report.setScope(0);
+        report.setIsDeleted(0);
+        return report;
+    }
 }

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

@@ -0,0 +1,19 @@
+package com.mooctest.crowd.domain.factory;
+
+import com.mooctest.crowd.domain.domainobject.EvaluationAgency;
+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,121 @@
+package com.mooctest.crowd.domain.model;
+
+import cn.afterturn.easypoi.excel.annotation.Excel;
+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;
+
+    @Excel(name="项目名称")
+    @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;
+
+    @Excel(name="测试平台",replace = { "导师_1", "博士后_2","博士_3", "硕士_4","无_5"},orderNum = "0")
+    @Column(name = "CTP_PLATFORM")
+    private String platform;
+
+    @Excel(name="项目联系人")
+    @Column(name = "CTP_LINK_MAN")
+    private String linkMan;
+
+    @Excel(name="联系手机号")
+    @Column(name = "CTP_Link_MAN_MOBILE")
+    private String linkManMobile;
+
+    @Excel(name="项目类型")
+    @Column(name = "CTP_TYPE")
+    private String type;
+
+    @Excel(name="需求描述")
+    @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 int 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,95 @@
+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(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 int 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/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/EvaluationAgencyPO.java

@@ -0,0 +1,75 @@
+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_ABILITIES")
+    private String abilities;
+
+    @Column(name = "EA_RESOURCES")
+    private String resources;
+
+    @Column(name = "EA_PHOTO")
+    private String agencyPhoto;
+
+    @Column(name = "EA_IS_AUTHENTICATION")
+    private int isAuthentication;
+
+    @Column(name = "EA_IS_DELETED")
+    private int isDeleted;
+
+    @Column(name = "EA_UPDATE_TIME")
+    private Timestamp updateTime;
+
+    @Column(name = "EA_EXPIRE_TIME")
+    private Timestamp expireTime;
+
+    @Column(name = "EA_CREATE_TIME")
+    private Timestamp createTime;
+
+    @Override
+    public String toString() {
+        return "EvaluationAgencyPO{" +
+                "id=" + id +
+                ", userId=" + userId +
+                ", evaluationAgencyName='" + evaluationAgencyName + '\'' +
+                ", bankAccount='" + bankAccount + '\'' +
+                ", address='" + address + '\'' +
+                ", abilities='" + abilities + '\'' +
+                ", resources='" + resources + '\'' +
+                ", agencyPhoto='" + agencyPhoto + '\'' +
+                ", isAuthentication=" + isAuthentication +
+                ", isDeleted=" + isDeleted +
+                ", updateTime=" + updateTime +
+                ", expireTime=" + expireTime +
+                ", createTime=" + 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/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/RegionalManagerPO.java

@@ -0,0 +1,35 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+
+/**
+ * @author guochao
+ * @date 2019/7/9 14:16
+ */
+@Data
+@Entity
+@Table(name = "regional_manager_to_regional")
+public class RegionalManagerPO {
+
+    @Id
+    @Column(name = "RM_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "RM_U_ID")
+    private Long userId;
+
+    @Column(name = "RM_RL_ID")
+    private Long regionalId;
+
+    @Override
+    public String toString() {
+        return "RegionalManagerPO{" +
+                "id=" + id +
+                ", userId=" + userId +
+                ", regionalId='" + regionalId + '\'' +
+                '}';
+    }
+}

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 = "RL_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "RL_PROVINCE")
+    private String province;
+
+    @Column(name = "RL_CITY")
+    private String city;
+
+    @Override
+    public String toString() {
+        return "Regional{" +
+                "id=" + id +
+                ", province='" + province + '\'' +
+                ", city='" + city + '\'' +
+                '}';
+    }
+}

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/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,209 @@ 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 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> getCrowdListByRegionalManagerId(Long regionalManagerId) {
+        List<CrowdTestProjectPO> crowdTestProjectPOList = crowdTestProjectDao.findByRegionalManagerIdAndIsDeleted(regionalManagerId,DeletedStatus.isNotDeleted);
+        return getCrowdTestProjects(crowdTestProjectPOList);
     }
 
-    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 List<CrowdTestProject> getAllCrowdTestProject() {
+        List<CrowdTestProjectPO> crowdTestProjectPOList = crowdTestProjectDao.findAllByIsDeleted(DeletedStatus.isNotDeleted);
+        return getCrowdTestProjects(crowdTestProjectPOList);
     }
 
     @Override
-    public boolean removeCrowdTestProject(CrowdTestProject crowdTestProject) throws CrowdTestProjectNotExistException {
-        if(crowdTestProject.getId().equals(1L)){
-            return true;
+    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);
         }
-        throw new CrowdTestProjectNotExistException();
     }
 
-    @Override
-    public CrowdTestProject updateCrowdTestProject(CrowdTestProject crowdTestProject) throws CrowdTestProjectNotExistException {
-        CrowdTestProject oldCrowdTestProject = getByID(crowdTestProject.getId());
-        if(oldCrowdTestProject.getId().equals(crowdTestProject.getId())){
-            oldCrowdTestProject = crowdTestProject;
-            return oldCrowdTestProject;
+//    @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);
         }
-        throw new CrowdTestProjectNotExistException();
+        crowdTestProjectDao.deleteAll(crowdTestProjectPOList);
     }
 
-    @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 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());
+    }
+
+    /**
+     * 通过项目信息获取项目-任务-报告信息
+     * @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;
     }
 
-    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 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);
         }
-        return true;
+        return crowdTestReportListResult;
+    }
 
+    /**
+     * 根据项目列表获取项目-任务-报告信息
+     * @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 crowdTestProjectListResult;
     }
 }

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/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,323 @@
+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 RegionalManagerDao regionalManagerDao;
+
+    @Autowired
+    private RegionalDao regionalDao;
+
+    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());
+        for(Role role : roleList){
+            if (!userToRolePOList.stream().filter(userToRolePO -> userToRolePO.getRoleId() == role.getId()).findFirst().isPresent()) {
+                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());
+            evaluationAgencyDao.save(evaluationAgencyPO);
+        }
+        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.findByUserId(userPO.getId());
+        if(evaluationAgencyPO != null){
+            EvaluationAgency evaluationAgencyResult = Converter.convert(EvaluationAgency.class, evaluationAgencyPO);
+            userResult.setEvaluationAgency(evaluationAgencyResult);
+        }
+
+        /*获取区域管理员信息*/
+        List<RegionalManagerPO> regionalManagerPOList = regionalManagerDao.findByUserId(userPO.getId());
+//        List<RegionalManager> regionalManagerListResult = new ArrayList<>();
+        List<Regional> regionalList = new ArrayList<>();
+        RegionalManager regionalManager = new RegionalManager();
+        regionalManager.setUserId(userPO.getId());
+        for(RegionalManagerPO regionalManagerPO : regionalManagerPOList){
+
+            if(regionalManagerPO != null){
+                /*获取区域管理员管理的区域信息*/
+                RegionalManager regionalManagerResult = Converter.convert(RegionalManager.class, regionalManagerPO);
+                Optional<RegionalPO> regionalPOOptional = regionalDao.findById(regionalManagerPO.getRegionalId());
+                if(regionalPOOptional.isPresent()){
+                    RegionalPO regionalPO = regionalPOOptional.get();
+                    Regional regionalResult = Converter.convert(Regional.class, regionalPO);
+                    regionalList.add(regionalResult);
+//                    regionalManagerResult.setRegional(regionalResult);
+                }
+//                regionalManagerListResult.add(regionalManagerResult);
+            }
+
+        }
+
+        regionalManager.setRegionalList(regionalList);
+//        userResult.setRegionalManagerInfo(regionalManagerListResult);
+        userResult.setRegionalManager(regionalManager);
+        return userResult;
+    }
+
+    public Role getRole(String roleName){
+        Role role = new Role();
+        BeanUtils.copyProperties(roleDao.findByName(roleName), role);
+        return role;
+    }
+}

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;
+//    }
+//}

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

@@ -0,0 +1,100 @@
+package com.mooctest.crowd.domain.util;
+
+import cn.afterturn.easypoi.excel.ExcelExportUtil;
+import cn.afterturn.easypoi.excel.ExcelImportUtil;
+import cn.afterturn.easypoi.excel.entity.ExportParams;
+import cn.afterturn.easypoi.excel.entity.ImportParams;
+import cn.afterturn.easypoi.excel.entity.enmus.ExcelType;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.File;
+import java.io.IOException;
+import java.net.URLEncoder;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+
+/**
+ * Created by 郭超 on 2019/8/3.
+ */
+public class FileUtil {
+    public static void exportExcel(List<?> list, String title, String sheetName, Class<?> pojoClass, String fileName, boolean isCreateHeader, HttpServletResponse response){
+        ExportParams exportParams = new ExportParams(title, sheetName);
+        exportParams.setCreateHeadRows(isCreateHeader);
+        defaultExport(list, pojoClass, fileName, response, exportParams);
+
+    }
+    public static void exportExcel(List<?> list, String title, String sheetName, Class<?> pojoClass,String fileName, HttpServletResponse response){
+        defaultExport(list, pojoClass, fileName, response, new ExportParams(title, sheetName));
+    }
+    public static void exportExcel(List<Map<String, Object>> list, String fileName, HttpServletResponse response){
+        defaultExport(list, fileName, response);
+    }
+
+    private static void defaultExport(List<?> list, Class<?> pojoClass, String fileName, HttpServletResponse response, ExportParams exportParams) {
+        Workbook workbook = ExcelExportUtil.exportExcel(exportParams,pojoClass,list);
+        if (workbook != null);
+        downLoadExcel(fileName, response, workbook);
+    }
+
+    private static void downLoadExcel(String fileName, HttpServletResponse response, Workbook workbook) {
+        try {
+            response.setCharacterEncoding("UTF-8");
+            response.setHeader("content-Type", "application/vnd.ms-excel");
+            response.setHeader("Content-Disposition",
+                    "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
+            workbook.write(response.getOutputStream());
+        } catch (IOException e) {
+//            throw new NormalException(e.getMessage());
+            System.out.println("52....");
+        }
+    }
+    private static void defaultExport(List<Map<String, Object>> list, String fileName, HttpServletResponse response) {
+        Workbook workbook = ExcelExportUtil.exportExcel(list, ExcelType.HSSF);
+        if (workbook != null);
+        downLoadExcel(fileName, response, workbook);
+    }
+
+    public static <T> List<T> importExcel(String filePath,Integer titleRows,Integer headerRows, Class<T> pojoClass){
+        if (StringUtils.isBlank(filePath)){
+            return null;
+        }
+        ImportParams params = new ImportParams();
+        params.setTitleRows(titleRows);
+        params.setHeadRows(headerRows);
+        List<T> list = null;
+        try {
+            list = ExcelImportUtil.importExcel(new File(filePath), pojoClass, params);
+        }catch (NoSuchElementException e){
+//            throw new NormalException("模板不能为空");
+            System.out.println("模板不能为空");
+        } catch (Exception e) {
+            e.printStackTrace();
+//            throw new NormalException(e.getMessage());
+            System.out.println("76...");
+        }
+        return list;
+    }
+    public static <T> List<T> importExcel(MultipartFile file, Integer titleRows, Integer headerRows, Class<T> pojoClass){
+        if (file == null){
+            return null;
+        }
+        ImportParams params = new ImportParams();
+        params.setTitleRows(titleRows);
+        params.setHeadRows(headerRows);
+        List<T> list = null;
+        try {
+            list = ExcelImportUtil.importExcel(file.getInputStream(), pojoClass, params);
+        }catch (NoSuchElementException e){
+//            throw new NormalException("excel文件不能为空");
+            System.out.println("excel文件不能为空");
+        } catch (Exception e) {
+//            throw new NormalException(e.getMessage());
+            System.out.println("94...");
+        }
+        return list;
+    }
+}

core/src/resources/application.yaml → core/src/main/resources/application.yml

@@ -3,13 +3,21 @@ spring:
     guava:
       spec: expireAfterWrite=30s
   datasource:
+#    type: com.alibaba.druid.pool.DruidDataSource
+#    druid:
+#      initial-size: 5
+#      max-active: 20
     driver-class-name: com.mysql.jdbc.Driver
     url: jdbc:mysql://101.37.175.111:3306/crowd-test-service?useSSL=false&useUnicode=yes&characterEncoding=UTF-8
     username: mooctest
     password: secr3t!
-    # Keep the connection alive if idle for a long time (needed in production)
+    initialPoolSize: 5
+      # Keep the connection alive if idle for a long time (needed in production)
     testWhileIdle: true
     validationQuery: SELECT 1
+
+    minPoolSize: 5
+    maxPoolSize: 1000
   # Show or not log for each sql query
   jpa:
     show-sql: true
@@ -22,5 +30,9 @@ spring:
   # The SQL dialect makes Hibernate generate better SQL for the chosen database
   properties.hibernate.dialect: org.hibernate.dialect.MySQL5Dialect
 
+feature-switch:
+  default:
+    role: generalUser
+
 #swagger:
 #  enable: true

core/src/test/java/com/mooctest/crowd/domain/domainobject/EvaluationAgencyTest.java

@@ -1,154 +1,154 @@
-package com.mooctest.crowd.domain.domainobject;
-
-import com.mooctest.crowd.domain.command.CrowdTestReportCommand;
-import com.mooctest.crowd.domain.command.CrowdTestTaskCommand;
-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 org.junit.Test;
-
-import java.util.List;
-
-import static org.junit.Assert.*;
-
-/**
- * @author guochao
- * @date 2019/7/16 10:18
- */
-public class EvaluationAgencyTest {
-    private CrowdTestProject crowdTestProject = new CrowdTestProject();
-    private CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
-    private CrowdTestTaskCommand crowdTestTaskCommand = new CrowdTestTaskCommand();
-    private CrowdTestReportCommand crowdTestReportCommand = new CrowdTestReportCommand();
-    private EvaluationAgency evaluationAgency = new EvaluationAgency();
-    @Test
-    public void should_modify_crowd_test_task_status_when_evaluation_agency_receive_task() throws CrowdTestTaskNotExistException, CrowdTestProjectNotExistException, CrowdTestTaskNoPriceException {
-        // arrange
-        evaluationAgency.setId(4444L);
-        crowdTestTaskCommand.setId(101L);
-        crowdTestTaskCommand.setCrowdTestProjectId(1L);
-        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
-        Long taskId = crowdTestTaskCommand.getId();
-        Long evaluationAgencyId = evaluationAgency.getId();
-        // action
-        boolean result = evaluationAgency.updateCrowdTestTaskStatusByEvaluationAgency(projectId, taskId, evaluationAgencyId, CrowdTestTaskStatus.RELEASED);
-        // assert
-        assertTrue(result);
-    }
-
-    @Test
-    public void should_return_true_when_view_crowd_test_task_success() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException {
-        // arrange
-        crowdTestTaskCommand.setId(101L);
-        crowdTestTaskCommand.setCrowdTestProjectId(1L);
-        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
-        Long taskId = crowdTestTaskCommand.getId();
-        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(projectId);
-        // action
-        CrowdTestTask crowdTestTask = crowdTestProject.getCrowdTestTaskByTaskId(crowdTestProject, taskId);
-        // assert
-        assertEquals(crowdTestTask.getId(), taskId);
-    }
-
-    @Test(expected = CrowdTestTaskNotExistException.class)
-    public void should_throw_when_view_crowd_test_task_not_exist() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException {
-        // arrange
-        crowdTestTaskCommand.setId(102L);
-        crowdTestTaskCommand.setCrowdTestProjectId(1L);
-        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
-        Long taskId = crowdTestTaskCommand.getId();
-        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(projectId);
-        // action
-        crowdTestProject.getCrowdTestTaskByTaskId(crowdTestProject, taskId);
-    }
-
-    @Test
-    public void should_modify_status_when_commit_crowd_test_report_success() throws CrowdTestTaskNoPriceException, CrowdTestReportNotExistException, CrowdTestProjectNotExistException, CrowdTestTaskNotExistException {
-        // arrange
-        crowdTestReportCommand.setId(1001L);
-        crowdTestReportCommand.setCrowdTestTaskId(101L);
-        crowdTestTaskCommand.setCrowdTestProjectId(1L);
-        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
-        Long taskId = crowdTestReportCommand.getCrowdTestTaskId();
-        Long reportId = crowdTestReportCommand.getId();
-        // action
-        CrowdTestProject newCrowdTestProject = crowdTestProject.updateCrowdTestReportStatus(projectId, taskId, reportId, CrowdTestReportStatus.COMMITED);
-        // assert
-        CrowdTestTask crowdTestTask = newCrowdTestProject.getCrowdTestTaskByTaskId(newCrowdTestProject, taskId);
-        CrowdTestReport crowdTestReport = crowdTestTask.getCrowdTestReportByReportId(crowdTestTask, reportId);
-        assertEquals(crowdTestReport.getStatus(), CrowdTestReportStatus.COMMITED);
-    }
-
-    @Test(expected = CrowdTestReportNotExistException.class)
-    public void should_throw_when_commit_crowd_test_report_not_exist() throws CrowdTestTaskNoPriceException, CrowdTestReportNotExistException, CrowdTestProjectNotExistException, CrowdTestTaskNotExistException {
-        // arrange
-        crowdTestReportCommand.setId(1002L);
-        crowdTestReportCommand.setCrowdTestTaskId(101L);
-        crowdTestTaskCommand.setCrowdTestProjectId(1L);
-        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
-        Long taskId = crowdTestReportCommand.getCrowdTestTaskId();
-        Long reportId = crowdTestReportCommand.getId();
-        // action
-        crowdTestProject.updateCrowdTestReportStatus(projectId, taskId, reportId, CrowdTestReportStatus.COMMITED);
-    }
-
-    @Test
-    public void should_modify_crowd_test_task_status_commited_when_commit_crowd_test_task() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException, CrowdTestReportNotExistException {
-        // arrange
-        crowdTestTaskCommand.setCrowdTestProjectId(1L);
-        crowdTestTaskCommand.setId(101L);
-        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
-        Long taskId = crowdTestTaskCommand.getId();
-        CrowdTestProject newCrowdTestProject = crowdTestProject.updateCrowdTestReportStatus(projectId, taskId, 1001L, CrowdTestReportStatus.COMMITED);
-        // action
-        boolean result = newCrowdTestProject.modifyCrowdTestTaskStatusToCommit(taskId, CrowdTestTaskStatus.COMMITED);
-        // assert
-        assertTrue(result);
-    }
-
-    @Test
-    public void should_throw_when_commit_crowd_test_task_has_no_commit_crowd_test_report() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException, CrowdTestReportNotExistException {
-        // arrange
-        crowdTestTaskCommand.setCrowdTestProjectId(1L);
-        crowdTestTaskCommand.setId(101L);
-        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
-        Long taskId = crowdTestTaskCommand.getId();
-        CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
-        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(projectId);
-        // action
-        boolean result = crowdTestProject.modifyCrowdTestTaskStatusToCommit(taskId, CrowdTestTaskStatus.COMMITED);
-        // assert
-        assertFalse(result);
-    }
-
-    @Test
-    public void should_return_true_when_view_crowd_test_project_success() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException, CrowdTestReportNotExistException {
-        // arrange
-        crowdTestReportCommand.setId(1001L);
-        crowdTestReportCommand.setCrowdTestTaskId(101L);
-        crowdTestReportCommand.setCrowdTestProjectId(1L);
-        Long projectId = crowdTestReportCommand.getCrowdTestProjectId();
-        Long taskId = crowdTestReportCommand.getCrowdTestTaskId();
-        Long reportId = crowdTestReportCommand.getId();
-        // action
-        CrowdTestReport crowdTestReport = crowdTestProject.getCrowdTestReportByProjectId(projectId, taskId, reportId);
-        // assert
-        assertEquals(crowdTestReport.getId(), reportId);
-    }
-
-    @Test
-    public void should_return_true_when_view_crowd_test_project_list_success() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException, CrowdTestReportNotExistException {
-        // arrange
-        crowdTestReportCommand.setCrowdTestProjectId(1L);
-        crowdTestReportCommand.setCrowdTestTaskId(101L);
-        Long projectId = crowdTestReportCommand.getCrowdTestProjectId();
-        Long taskId = crowdTestReportCommand.getCrowdTestTaskId();
-        // action
-        List<CrowdTestReport> crowdTestReportList = crowdTestProject.getCrowdTestReportListByProjectId(projectId, taskId);
-        // assert
-
-        assertEquals(crowdTestReportList.get(0).getCrowdTestTaskId(), taskId);
-    }
-}
+//package com.mooctest.crowd.domain.domainobject;
+//
+//import com.mooctest.crowd.domain.command.CrowdTestReportCommand;
+//import com.mooctest.crowd.domain.command.CrowdTestTaskCommand;
+//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 org.junit.Test;
+//
+//import java.util.List;
+//
+//import static org.junit.Assert.*;
+//
+///**
+// * @author guochao
+// * @date 2019/7/16 10:18
+// */
+//public class EvaluationAgencyTest {
+//    private CrowdTestProject crowdTestProject = new CrowdTestProject();
+//    private CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
+//    private CrowdTestTaskCommand crowdTestTaskCommand = new CrowdTestTaskCommand();
+//    private CrowdTestReportCommand crowdTestReportCommand = new CrowdTestReportCommand();
+//    private EvaluationAgency evaluationAgency = new EvaluationAgency();
+//    @Test
+//    public void should_modify_crowd_test_task_status_when_evaluation_agency_receive_task() throws CrowdTestTaskNotExistException, CrowdTestProjectNotExistException, CrowdTestTaskNoPriceException {
+//        // arrange
+//        evaluationAgency.setId(4444L);
+//        crowdTestTaskCommand.setId(101L);
+//        crowdTestTaskCommand.setCrowdTestProjectId(1L);
+//        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
+//        Long taskId = crowdTestTaskCommand.getId();
+//        Long evaluationAgencyId = evaluationAgency.getId();
+//        // action
+//        boolean result = evaluationAgency.updateCrowdTestTaskStatusByEvaluationAgency(projectId, taskId, evaluationAgencyId, CrowdTestTaskStatus.RELEASED);
+//        // assert
+//        assertTrue(result);
+//    }
+//
+//    @Test
+//    public void should_return_true_when_view_crowd_test_task_success() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException {
+//        // arrange
+//        crowdTestTaskCommand.setId(101L);
+//        crowdTestTaskCommand.setCrowdTestProjectId(1L);
+//        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
+//        Long taskId = crowdTestTaskCommand.getId();
+//        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(projectId);
+//        // action
+//        CrowdTestTask crowdTestTask = crowdTestProject.getCrowdTestTaskByTaskId(crowdTestProject, taskId);
+//        // assert
+//        assertEquals(crowdTestTask.getId(), taskId);
+//    }
+//
+//    @Test(expected = CrowdTestTaskNotExistException.class)
+//    public void should_throw_when_view_crowd_test_task_not_exist() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException {
+//        // arrange
+//        crowdTestTaskCommand.setId(102L);
+//        crowdTestTaskCommand.setCrowdTestProjectId(1L);
+//        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
+//        Long taskId = crowdTestTaskCommand.getId();
+//        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(projectId);
+//        // action
+//        crowdTestProject.getCrowdTestTaskByTaskId(crowdTestProject, taskId);
+//    }
+//
+//    @Test
+//    public void should_modify_status_when_commit_crowd_test_report_success() throws CrowdTestTaskNoPriceException, CrowdTestReportNotExistException, CrowdTestProjectNotExistException, CrowdTestTaskNotExistException {
+//        // arrange
+//        crowdTestReportCommand.setId(1001L);
+//        crowdTestReportCommand.setCrowdTestTaskId(101L);
+//        crowdTestTaskCommand.setCrowdTestProjectId(1L);
+//        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
+//        Long taskId = crowdTestReportCommand.getCrowdTestTaskId();
+//        Long reportId = crowdTestReportCommand.getId();
+//        // action
+//        CrowdTestProject newCrowdTestProject = crowdTestProject.updateCrowdTestReportStatus(projectId, taskId, reportId, CrowdTestReportStatus.COMMITED);
+//        // assert
+//        CrowdTestTask crowdTestTask = newCrowdTestProject.getCrowdTestTaskByTaskId(newCrowdTestProject, taskId);
+//        CrowdTestReport crowdTestReport = crowdTestTask.getCrowdTestReportByReportId(crowdTestTask, reportId);
+//        assertEquals(crowdTestReport.getStatus(), CrowdTestReportStatus.COMMITED);
+//    }
+//
+//    @Test(expected = CrowdTestReportNotExistException.class)
+//    public void should_throw_when_commit_crowd_test_report_not_exist() throws CrowdTestTaskNoPriceException, CrowdTestReportNotExistException, CrowdTestProjectNotExistException, CrowdTestTaskNotExistException {
+//        // arrange
+//        crowdTestReportCommand.setId(1002L);
+//        crowdTestReportCommand.setCrowdTestTaskId(101L);
+//        crowdTestTaskCommand.setCrowdTestProjectId(1L);
+//        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
+//        Long taskId = crowdTestReportCommand.getCrowdTestTaskId();
+//        Long reportId = crowdTestReportCommand.getId();
+//        // action
+//        crowdTestProject.updateCrowdTestReportStatus(projectId, taskId, reportId, CrowdTestReportStatus.COMMITED);
+//    }
+//
+//    @Test
+//    public void should_modify_crowd_test_task_status_commited_when_commit_crowd_test_task() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException, CrowdTestReportNotExistException {
+//        // arrange
+//        crowdTestTaskCommand.setCrowdTestProjectId(1L);
+//        crowdTestTaskCommand.setId(101L);
+//        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
+//        Long taskId = crowdTestTaskCommand.getId();
+//        CrowdTestProject newCrowdTestProject = crowdTestProject.updateCrowdTestReportStatus(projectId, taskId, 1001L, CrowdTestReportStatus.COMMITED);
+//        // action
+//        boolean result = newCrowdTestProject.modifyCrowdTestTaskStatusToCommit(taskId, CrowdTestTaskStatus.COMMITED);
+//        // assert
+//        assertTrue(result);
+//    }
+//
+//    @Test
+//    public void should_throw_when_commit_crowd_test_task_has_no_commit_crowd_test_report() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException, CrowdTestReportNotExistException {
+//        // arrange
+//        crowdTestTaskCommand.setCrowdTestProjectId(1L);
+//        crowdTestTaskCommand.setId(101L);
+//        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
+//        Long taskId = crowdTestTaskCommand.getId();
+//        CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
+//        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(projectId);
+//        // action
+//        boolean result = crowdTestProject.modifyCrowdTestTaskStatusToCommit(taskId, CrowdTestTaskStatus.COMMITED);
+//        // assert
+//        assertFalse(result);
+//    }
+//
+//    @Test
+//    public void should_return_true_when_view_crowd_test_project_success() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException, CrowdTestReportNotExistException {
+//        // arrange
+//        crowdTestReportCommand.setId(1001L);
+//        crowdTestReportCommand.setCrowdTestTaskId(101L);
+//        crowdTestReportCommand.setCrowdTestProjectId(1L);
+//        Long projectId = crowdTestReportCommand.getCrowdTestProjectId();
+//        Long taskId = crowdTestReportCommand.getCrowdTestTaskId();
+//        Long reportId = crowdTestReportCommand.getId();
+//        // action
+//        CrowdTestReport crowdTestReport = crowdTestProject.getCrowdTestReportByProjectId(projectId, taskId, reportId);
+//        // assert
+//        assertEquals(crowdTestReport.getId(), reportId);
+//    }
+//
+//    @Test
+//    public void should_return_true_when_view_crowd_test_project_list_success() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException, CrowdTestReportNotExistException {
+//        // arrange
+//        crowdTestReportCommand.setCrowdTestProjectId(1L);
+//        crowdTestReportCommand.setCrowdTestTaskId(101L);
+//        Long projectId = crowdTestReportCommand.getCrowdTestProjectId();
+//        Long taskId = crowdTestReportCommand.getCrowdTestTaskId();
+//        // action
+//        List<CrowdTestReport> crowdTestReportList = crowdTestProject.getCrowdTestReportListByProjectId(projectId, taskId);
+//        // assert
+//
+//        assertEquals(crowdTestReportList.get(0).getCrowdTestTaskId(), taskId);
+//    }
+//}

core/src/test/java/com/mooctest/crowd/domain/domainobject/GeneralUserTest.java

@@ -1,18 +1,8 @@
 package com.mooctest.crowd.domain.domainobject;
 
-import com.mooctest.crowd.domain.command.CrowdTestProjectCommand;
-import com.mooctest.crowd.domain.exception.CrowdTestProjectNotExistException;
-import com.mooctest.crowd.domain.repository.CrowdTestProjectRepo;
-import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.runners.MockitoJUnitRunner;
 
-import java.util.ArrayList;
-import java.util.List;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
 /**
  * @author guochao
  * @date 2019/7/6 18:17
@@ -43,186 +33,186 @@ public class GeneralUserTest {
 //        when(testProjectRepo.getByID(1L)).thenReturn(testProject);
 //    }
 
-
-    @Test
-    public void should_return_true_when_create_crowd_test_project_success() throws CrowdTestProjectNotExistException {
-        // arrange
-        CrowdTestProjectCommand crowdTestProjectCommand = new CrowdTestProjectCommand();
-        crowdTestProjectCommand.setName("PROJECT_TWO");
-        crowdTestProjectCommand.setDescription("DESCRIPTION");
-        crowdTestProjectCommand.setDistributeId(123L);
-        crowdTestProjectCommand.setStatus(CrowdTestProjectStatus.CREATED);
-        crowdTestProjectCommand.setProjectFile("PROJECTFILE.TXT");
-        crowdTestProjectCommand.setRequirementFile("REQUIREMENT.TXT");
-        crowdTestProjectCommand.setQuotedPrice(200.00);
-
-        CrowdTestProject crowdTestProject2 = new CrowdTestProject();
-        crowdTestProject2.setName(crowdTestProjectCommand.getName());
-        ProjectDistributeType projectDistributeType = new ProjectDistributeType();
-        projectDistributeType.setId(crowdTestProjectCommand.getDistributeId());
-        crowdTestProject2.setProjectDistributeType(projectDistributeType);
-        crowdTestProject2.setDescription(crowdTestProjectCommand.getDescription());
-        crowdTestProject2.setProjectFile(crowdTestProjectCommand.getProjectFile());
-        crowdTestProject2.setRequirementFile(crowdTestProjectCommand.getRequirementFile());
-        crowdTestProject2.setQuotedPrice(crowdTestProjectCommand.getQuotedPrice());
-        crowdTestProject2.setStatus(crowdTestProjectCommand.getStatus());
-        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
-
-        // action
-        CrowdTestProject crowdTestProject = testProjectRepo.addCrowdTestProject(crowdTestProject2);
-
-        // assert
-        assertEquals(crowdTestProject, crowdTestProject2);
-    }
-
-    @Test
-    public void should_return_crowd_test_project_when_view_exist_crowd_test_project() throws CrowdTestProjectNotExistException {
-        // arrange
-        CrowdTestProjectCommand crowdTestProjectCommand = new CrowdTestProjectCommand();
-        crowdTestProjectCommand.setId(1L);
-        crowdTestProjectCommand.setName("PROJECT_ONE");
-//        CrowdTestProject testProject = this.createCrowdTestProject();
-        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
-        // action
-        CrowdTestProject crowdTestProject = testProjectRepo.getByID(crowdTestProjectCommand.getId());
-
-        // assert
-        assertEquals(crowdTestProject.getName(), crowdTestProjectCommand.getName());
-    }
-
-    @Test(expected = CrowdTestProjectNotExistException.class)
-    public void should_throw_when_view__not_exist_crowd_test_project() throws CrowdTestProjectNotExistException {
-        // arrange
-        CrowdTestProjectCommand crowdTestProjectCommand = new CrowdTestProjectCommand();
-        crowdTestProjectCommand.setId(2L);
-        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
-        // action
-        CrowdTestProject crowdTestProject = testProjectRepo.getByID(crowdTestProjectCommand.getId());
-    }
-
-    @Test
-    public void should_return_true_when_remove_crowd_test_project_success() throws CrowdTestProjectNotExistException {
-        // arrange
-        CrowdTestProject crowdTestProject = createCrowdTestProject();
-        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
-
-        // action
-        boolean result = testProjectRepo.removeCrowdTestProject(crowdTestProject);
-
-        // assert
-        assertTrue(result);
-    }
-
-    @Test(expected = CrowdTestProjectNotExistException.class)
-    public void should_throw_when_remove_not_exist_crowd_test_project() throws CrowdTestProjectNotExistException {
-        // arrange
+//
+//    @Test
+//    public void should_return_true_when_create_crowd_test_project_success() throws CrowdTestProjectNotExistException {
+//        // arrange
+//        CrowdTestProjectCommand crowdTestProjectCommand = new CrowdTestProjectCommand();
+//        crowdTestProjectCommand.setName("PROJECT_TWO");
+//        crowdTestProjectCommand.setDescription("DESCRIPTION");
+//        crowdTestProjectCommand.setDistributeId(123L);
+//        crowdTestProjectCommand.setStatus(CrowdTestProjectStatus.CREATED);
+//        crowdTestProjectCommand.setProjectFile("PROJECTFILE.TXT");
+//        crowdTestProjectCommand.setRequirementFile("REQUIREMENT.TXT");
+//        crowdTestProjectCommand.setQuotedPrice(200.00);
+//
+//        CrowdTestProject crowdTestProject2 = new CrowdTestProject();
+//        crowdTestProject2.setName(crowdTestProjectCommand.getName());
+//        ProjectDistributeType projectDistributeType = new ProjectDistributeType();
+//        projectDistributeType.setId(crowdTestProjectCommand.getDistributeId());
+//        crowdTestProject2.setProjectDistributeType(projectDistributeType);
+//        crowdTestProject2.setDescription(crowdTestProjectCommand.getDescription());
+//        crowdTestProject2.setProjectFile(crowdTestProjectCommand.getProjectFile());
+//        crowdTestProject2.setRequirementFile(crowdTestProjectCommand.getRequirementFile());
+//        crowdTestProject2.setQuotedPrice(crowdTestProjectCommand.getQuotedPrice());
+//        crowdTestProject2.setStatus(crowdTestProjectCommand.getStatus());
+//        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
+//
+//        // action
+//        CrowdTestProject crowdTestProject = testProjectRepo.addCrowdTestProject(crowdTestProject2);
+//
+//        // assert
+//        assertEquals(crowdTestProject, crowdTestProject2);
+//    }
+//
+//    @Test
+//    public void should_return_crowd_test_project_when_view_exist_crowd_test_project() throws CrowdTestProjectNotExistException {
+//        // arrange
+//        CrowdTestProjectCommand crowdTestProjectCommand = new CrowdTestProjectCommand();
+//        crowdTestProjectCommand.setId(1L);
+//        crowdTestProjectCommand.setName("PROJECT_ONE");
+////        CrowdTestProject testProject = this.createCrowdTestProject();
+//        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
+//        // action
+//        CrowdTestProject crowdTestProject = testProjectRepo.getByID(crowdTestProjectCommand.getId());
+//
+//        // assert
+//        assertEquals(crowdTestProject.getName(), crowdTestProjectCommand.getName());
+//    }
+//
+//    @Test(expected = CrowdTestProjectNotExistException.class)
+//    public void should_throw_when_view__not_exist_crowd_test_project() throws CrowdTestProjectNotExistException {
+//        // arrange
+//        CrowdTestProjectCommand crowdTestProjectCommand = new CrowdTestProjectCommand();
+//        crowdTestProjectCommand.setId(2L);
+//        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
+//        // action
+//        CrowdTestProject crowdTestProject = testProjectRepo.getByID(crowdTestProjectCommand.getId());
+//    }
+//
+//    @Test
+//    public void should_return_true_when_remove_crowd_test_project_success() throws CrowdTestProjectNotExistException {
+//        // arrange
+//        CrowdTestProject crowdTestProject = createCrowdTestProject();
+//        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
+//
+//        // action
+//        boolean result = testProjectRepo.removeCrowdTestProject(crowdTestProject);
+//
+//        // assert
+//        assertTrue(result);
+//    }
+//
+//    @Test(expected = CrowdTestProjectNotExistException.class)
+//    public void should_throw_when_remove_not_exist_crowd_test_project() throws CrowdTestProjectNotExistException {
+//        // arrange
+////        CrowdTestProject crowdTestProject = new CrowdTestProject();
 //        CrowdTestProject crowdTestProject = new CrowdTestProject();
-        CrowdTestProject crowdTestProject = new CrowdTestProject();
-        crowdTestProject.setId(2L);
-
-        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
-
-        // action
-        boolean result = testProjectRepo.removeCrowdTestProject(crowdTestProject);
-    }
-
-    @Test
-    public void should_return_true_when_update_crowd_test_project_success() throws CrowdTestProjectNotExistException {
-        // arrange
-        CrowdTestProject crowdTestProject = createCrowdTestProject();
-        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
-
-        // action
-        CrowdTestProject updateCrowdTestProject = testProjectRepo.updateCrowdTestProject(crowdTestProject);
-
-        // assert
-        assertEquals(updateCrowdTestProject.getName(), crowdTestProject.getName());
-    }
-
-    @Test(expected = CrowdTestProjectNotExistException.class)
-    public void should_throw_when_update_crowd_test_project_not_exist() throws CrowdTestProjectNotExistException {
-        // arrange
+//        crowdTestProject.setId(2L);
+//
+//        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
+//
+//        // action
+//        boolean result = testProjectRepo.removeCrowdTestProject(crowdTestProject);
+//    }
+//
+//    @Test
+//    public void should_return_true_when_update_crowd_test_project_success() throws CrowdTestProjectNotExistException {
+//        // arrange
+//        CrowdTestProject crowdTestProject = createCrowdTestProject();
+//        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
+//
+//        // action
+//        CrowdTestProject updateCrowdTestProject = testProjectRepo.updateCrowdTestProject(crowdTestProject);
+//
+//        // assert
+//        assertEquals(updateCrowdTestProject.getName(), crowdTestProject.getName());
+//    }
+//
+//    @Test(expected = CrowdTestProjectNotExistException.class)
+//    public void should_throw_when_update_crowd_test_project_not_exist() throws CrowdTestProjectNotExistException {
+//        // arrange
+////        CrowdTestProject crowdTestProject = new CrowdTestProject();
 //        CrowdTestProject crowdTestProject = new CrowdTestProject();
-        CrowdTestProject crowdTestProject = new CrowdTestProject();
-
-        crowdTestProject.setId(2L);
-        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
-
-        // action
-        testProjectRepo.updateCrowdTestProject(crowdTestProject);
-    }
-
-    @Test
-    public void should_return_ture_when_update_crowd_test_project_list_success() throws CrowdTestProjectNotExistException {
-        // arrange
-        List<CrowdTestProject> crowdTestProjects = new ArrayList<CrowdTestProject>();
-        CrowdTestProject crowdTestProject1 = createCrowdTestProject();
-        crowdTestProjects.add(crowdTestProject1);
+//
+//        crowdTestProject.setId(2L);
+//        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
+//
+//        // action
+//        testProjectRepo.updateCrowdTestProject(crowdTestProject);
+//    }
+//
+//    @Test
+//    public void should_return_ture_when_update_crowd_test_project_list_success() throws CrowdTestProjectNotExistException {
+//        // arrange
+//        List<CrowdTestProject> crowdTestProjects = new ArrayList<CrowdTestProject>();
+//        CrowdTestProject crowdTestProject1 = createCrowdTestProject();
+//        crowdTestProjects.add(crowdTestProject1);
+////        CrowdTestProject crowdTestProject = new CrowdTestProject();
 //        CrowdTestProject crowdTestProject = new CrowdTestProject();
-        CrowdTestProject crowdTestProject = new CrowdTestProject();
-        crowdTestProject.setId(2L);
-        crowdTestProject.setName("PROJECT_TWO");
-        crowdTestProject.setDescription("DESCRIPTION");
-        ProjectDistributeType projectDistributeType = new ProjectDistributeType();
-        projectDistributeType.setId(123L);
-        crowdTestProject.setProjectDistributeType(projectDistributeType);
-        crowdTestProject.setProjectFile("PROJECTFILE.TXT");
-        crowdTestProject.setRequirementFile("REQUIREMENT.TXT");
-        crowdTestProject.setQuotedPrice(200.00);
-        crowdTestProject.setStatus(CrowdTestProjectStatus.CREATED);
-        crowdTestProjects.add(crowdTestProject);
-        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
-
-        // action
-        boolean result = testProjectRepo.updateCrowdTestProjectList(crowdTestProjects);
-
-        // assert
-        assertTrue(result);
-    }
-
-    @Test(expected = CrowdTestProjectNotExistException.class)
-    public void should_throw_when_update_crowd_test_project_list_not_exist() throws CrowdTestProjectNotExistException {
-        // arrange
-        List<CrowdTestProject> crowdTestProjects = new ArrayList<CrowdTestProject>();
-        CrowdTestProject crowdTestProject1 = createCrowdTestProject();
-        crowdTestProjects.add(crowdTestProject1);
-        CrowdTestProject crowdTestProject = new CrowdTestProject();
-        crowdTestProject.setId(3L);
-        crowdTestProject.setName("PROJECT_TWO");
-        crowdTestProject.setDescription("DESCRIPTION");
-        crowdTestProject.setProjectFile("PROJECTFILE.TXT");
-        crowdTestProject.setRequirementFile("REQUIREMENT.TXT");
-        crowdTestProject.setQuotedPrice(200.00);
-        crowdTestProjects.add(crowdTestProject);
-        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
-
-        // action
-        boolean result = testProjectRepo.updateCrowdTestProjectList(crowdTestProjects);
-    }
-
-    // 2.4
-    @Test
-    public void should_modify_status_released_when_release_crowd_test_project() {
-        // arrange
-        CrowdTestProject crowdTestProject = this.createCrowdTestProject();
-        // action
-        crowdTestProject.setStatus(CrowdTestProjectStatus.RELEASED);
-        // assert
-        assertEquals(crowdTestProject.getStatus(),"HAS_RELEASED");
-    }
-
-    private CrowdTestProject createCrowdTestProject() {
-        CrowdTestProject crowdTestProject = new CrowdTestProject();
-        crowdTestProject.setId(1L);
-        crowdTestProject.setName("PROJECT_ONE");
-        crowdTestProject.setDescription("DESCRIPTION");
-        ProjectDistributeType projectDistributeType = new ProjectDistributeType();
-        projectDistributeType.setId(123L);
-        crowdTestProject.setProjectDistributeType(projectDistributeType);
-        crowdTestProject.setProjectFile("PROJECTFILE.TXT");
-        crowdTestProject.setRequirementFile("REQUIREMENT.TXT");
-        crowdTestProject.setQuotedPrice(200.00);
-        crowdTestProject.setStatus(CrowdTestProjectStatus.CREATED);
-        return crowdTestProject;
-    }
+//        crowdTestProject.setId(2L);
+//        crowdTestProject.setName("PROJECT_TWO");
+//        crowdTestProject.setDescription("DESCRIPTION");
+//        ProjectDistributeType projectDistributeType = new ProjectDistributeType();
+//        projectDistributeType.setId(123L);
+//        crowdTestProject.setProjectDistributeType(projectDistributeType);
+//        crowdTestProject.setProjectFile("PROJECTFILE.TXT");
+//        crowdTestProject.setRequirementFile("REQUIREMENT.TXT");
+//        crowdTestProject.setQuotedPrice(200.00);
+//        crowdTestProject.setStatus(CrowdTestProjectStatus.CREATED);
+//        crowdTestProjects.add(crowdTestProject);
+//        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
+//
+//        // action
+//        boolean result = testProjectRepo.updateCrowdTestProjectList(crowdTestProjects);
+//
+//        // assert
+//        assertTrue(result);
+//    }
+//
+//    @Test(expected = CrowdTestProjectNotExistException.class)
+//    public void should_throw_when_update_crowd_test_project_list_not_exist() throws CrowdTestProjectNotExistException {
+//        // arrange
+//        List<CrowdTestProject> crowdTestProjects = new ArrayList<CrowdTestProject>();
+//        CrowdTestProject crowdTestProject1 = createCrowdTestProject();
+//        crowdTestProjects.add(crowdTestProject1);
+//        CrowdTestProject crowdTestProject = new CrowdTestProject();
+//        crowdTestProject.setId(3L);
+//        crowdTestProject.setName("PROJECT_TWO");
+//        crowdTestProject.setDescription("DESCRIPTION");
+//        crowdTestProject.setProjectFile("PROJECTFILE.TXT");
+//        crowdTestProject.setRequirementFile("REQUIREMENT.TXT");
+//        crowdTestProject.setQuotedPrice(200.00);
+//        crowdTestProjects.add(crowdTestProject);
+//        CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
+//
+//        // action
+//        boolean result = testProjectRepo.updateCrowdTestProjectList(crowdTestProjects);
+//    }
+//
+//    // 2.4
+//    @Test
+//    public void should_modify_status_released_when_release_crowd_test_project() {
+//        // arrange
+//        CrowdTestProject crowdTestProject = this.createCrowdTestProject();
+//        // action
+//        crowdTestProject.setStatus(CrowdTestProjectStatus.RELEASED);
+//        // assert
+//        assertEquals(crowdTestProject.getStatus(),"HAS_RELEASED");
+//    }
+//
+//    private CrowdTestProject createCrowdTestProject() {
+//        CrowdTestProject crowdTestProject = new CrowdTestProject();
+//        crowdTestProject.setId(1L);
+//        crowdTestProject.setName("PROJECT_ONE");
+//        crowdTestProject.setDescription("DESCRIPTION");
+//        ProjectDistributeType projectDistributeType = new ProjectDistributeType();
+//        projectDistributeType.setId(123L);
+//        crowdTestProject.setProjectDistributeType(projectDistributeType);
+//        crowdTestProject.setProjectFile("PROJECTFILE.TXT");
+//        crowdTestProject.setRequirementFile("REQUIREMENT.TXT");
+//        crowdTestProject.setQuotedPrice(200.00);
+//        crowdTestProject.setStatus(CrowdTestProjectStatus.CREATED);
+//        return crowdTestProject;
+//    }
 }

core/src/test/java/com/mooctest/crowd/domain/domainobject/RegionalManagerTest.java

@@ -1,217 +1,217 @@
-package com.mooctest.crowd.domain.domainobject;
-
-import com.mooctest.crowd.domain.command.CrowdTestProjectCommand;
-import com.mooctest.crowd.domain.command.CrowdTestTaskCommand;
-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 org.junit.Test;
-
-import java.util.List;
-
-import static org.junit.Assert.*;
-
-/**
- * @author guochao
- * @date 2019/7/9 14:20
- */
-public class RegionalManagerTest {
-
-    private CrowdTestProject crowdTestProject = new CrowdTestProject();
-    private CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
-    private CrowdTestProjectCommand crowdTestProjectCommand = new CrowdTestProjectCommand();
-    private CrowdTestTaskCommand crowdTestTaskCommand = new CrowdTestTaskCommand();
-    private GeneralUserTest generalUserTest = new GeneralUserTest();
-    private RegionalManager regionalManager = new RegionalManager();
-
-    @Test
-    public void should_modify_status_received_when_receive_crowd_test_project() throws CrowdTestProjectNotExistException {
-        // arrange
-        crowdTestProjectCommand.setId(1L);
-        crowdTestProjectCommand.setStatus(CrowdTestProjectStatus.RECEIVED);
-        // action
-        CrowdTestProject crowdTestProject = crowdTestProjectRepo.updateCrowdTestProjectStatus(crowdTestProjectCommand.getId(), crowdTestProjectCommand.getStatus());
-        // assert
-        assertEquals(crowdTestProject.getStatus(), crowdTestProjectCommand.getStatus());
-    }
-
-    @Test(expected = CrowdTestProjectNotExistException.class)
-    public void should_throw_when_receive_crowd_test_project_not_exist() throws CrowdTestProjectNotExistException {
-        // arrange
-        crowdTestProjectCommand.setId(2L);
-        crowdTestProjectCommand.setStatus(CrowdTestProjectStatus.RECEIVED);
-        // action
-        crowdTestProjectRepo.updateCrowdTestProjectStatus(crowdTestProjectCommand.getId(), crowdTestProjectCommand.getStatus());
-    }
-
-    @Test
-    public void should_return_crowd_test_project_when_general_user_view_exist_crowd_test_project() throws CrowdTestProjectNotExistException {
-        generalUserTest.should_return_crowd_test_project_when_view_exist_crowd_test_project();
-    }
-
-    @Test(expected = CrowdTestProjectNotExistException.class)
-    public void should_throw_when_general_user_view__not_exist_crowd_test_project() throws CrowdTestProjectNotExistException {
-        generalUserTest.should_throw_when_view__not_exist_crowd_test_project();
-    }
-
-    @Test
-    public void should_return_crowd_test_task_list_when_split_crowd_test_project_success() throws CrowdTestProjectNotExistException {
-        // arrange
-        crowdTestProjectCommand.setId(1L);
-        // action
-        List<CrowdTestTask> crowdTestTasks = regionalManager.splitCrowdTestProjectToCrowdTestTaskList(crowdTestProjectCommand.getId());
-        // assert
-        assertNotNull(crowdTestTasks);
-    }
-
-    @Test(expected = CrowdTestProjectNotExistException.class)
-    public void should_throw_when_split_crowd_test_project_not_exist() throws CrowdTestProjectNotExistException {
-        // arrange
-        crowdTestProjectCommand.setId(2L);
-
-        // action
-        regionalManager.splitCrowdTestProjectToCrowdTestTaskList(crowdTestProjectCommand.getId());
-    }
-
-    @Test
-    public void should_return_true_when_make_a_price_for_crowd_test_project_success() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException {
-        // arrange
-        crowdTestTaskCommand.setId(101L);
-        crowdTestTaskCommand.setCrowdTestProjectId(1L);
-        crowdTestTaskCommand.setPrice(100.00);
-        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
-        Long id = crowdTestTaskCommand.getId();
-        Double price = crowdTestTaskCommand.getPrice();
-        // action
-        CrowdTestProject crowdTestProject = regionalManager.fixedPriceForCrowdTestTask(projectId, id, price);
-        List<CrowdTestTask> crowdTestTaskList = crowdTestProjectRepo.getByID(crowdTestProject.getId()).getCrowdTestTaskList();
-        for (CrowdTestTask crowdTestTask : crowdTestTaskList
-        ) {
-            if (crowdTestTask.getId().equals(id)) {
-                // assert
-                assertEquals(price, crowdTestTask.getPrice());
-            }
-        }
-    }
-
-    @Test(expected = CrowdTestProjectNotExistException.class)
-    public void should_throw_when_make_a_price_for_crowd_test_project_not_exist() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException {
-        // arrange
-        crowdTestTaskCommand.setId(101L);
-        crowdTestTaskCommand.setCrowdTestProjectId(2L);
-        crowdTestTaskCommand.setPrice(100.00);
-        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
-        Long id = crowdTestTaskCommand.getId();
-        Double price = crowdTestTaskCommand.getPrice();
-        // action
-        regionalManager.fixedPriceForCrowdTestTask(projectId, id, price);
-    }
-
-    @Test(expected = CrowdTestTaskNotExistException.class)
-    public void should_throw_when_make_a_price_for_crowd_test_task_not_exist() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException {
-        // arrange
-        crowdTestTaskCommand.setId(103L);
-        crowdTestTaskCommand.setCrowdTestProjectId(1L);
-        crowdTestTaskCommand.setPrice(100.00);
-        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
-        Long id = crowdTestTaskCommand.getId();
-        Double price = crowdTestTaskCommand.getPrice();
-        // action
-        regionalManager.fixedPriceForCrowdTestTask(projectId, id, price);
-    }
-
-    @Test
-    public void should_return_true_when_distribute_crowd_test_task_to_evaluation_agency_success() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException {
-        // arrange
-        crowdTestTaskCommand.setId(101L);
-        crowdTestTaskCommand.setCrowdTestProjectId(1L);
-        crowdTestTaskCommand.setStatus(CrowdTestTaskStatus.RELEASED);
-        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
-        Long taskId = crowdTestTaskCommand.getId();
-        String status = crowdTestProjectCommand.getStatus();
-        // action
-        boolean result = crowdTestProject.updateCrowdTestTaskStatus(projectId, taskId, status);
-
-        // assert
-        assertTrue(result);
-    }
-
-    @Test(expected = CrowdTestProjectNotExistException.class)
-    public void should_throw_when_distribute_crowd_test_task_crowd_test_project_not_exist() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException {
-        // arrange
-        crowdTestTaskCommand.setId(101L);
-        crowdTestTaskCommand.setCrowdTestProjectId(2L);
-        crowdTestTaskCommand.setStatus(CrowdTestTaskStatus.RELEASED);
-        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
-        Long taskId = crowdTestTaskCommand.getId();
-        String status = crowdTestProjectCommand.getStatus();
-        // action
-        crowdTestProject.updateCrowdTestTaskStatus(projectId, taskId, status);
-    }
-
-    @Test(expected = CrowdTestTaskNotExistException.class)
-    public void should_throw_when_distribute_crowd_test_task_crowd_test_task_not_exist() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException {
-        // arrange
-        crowdTestTaskCommand.setId(103L);
-        crowdTestTaskCommand.setCrowdTestProjectId(1L);
-        crowdTestTaskCommand.setStatus(CrowdTestTaskStatus.RELEASED);
-        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
-        Long taskId = crowdTestTaskCommand.getId();
-        String status = crowdTestProjectCommand.getStatus();
-        // action
-        crowdTestProject.updateCrowdTestTaskStatus(projectId, taskId, status);
-    }
-
-    @Test(expected = CrowdTestTaskNoPriceException.class)
-    public void should_throw_when_distribute_crowd_test_task_price_not_exist() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException {
-        // arrange
-        crowdTestTaskCommand.setId(101L);
-        crowdTestTaskCommand.setCrowdTestProjectId(1L);
-        crowdTestTaskCommand.setStatus(CrowdTestTaskStatus.RELEASED);
-        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
-        Long taskId = crowdTestTaskCommand.getId();
-        String status = crowdTestProjectCommand.getStatus();
-        // action
-        crowdTestProject.updateCrowdTestTaskStatusNoPrice(projectId, taskId, status);
-    }
-
-    @Test
-    public void should_modify_all_task_status_finished_when_aggregation_task() throws CrowdTestProjectNotExistException {
-        // arrange
-        crowdTestProjectCommand.setId(1L);
-        Long projectId = crowdTestProjectCommand.getId();
-        // action
-        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.updateCrowdTestTaskListStatus(projectId, CrowdTestTaskStatus.FINISHED);
-        // assert
-        boolean result = true;
-        for (CrowdTestTask crowdTestTask : crowdTestTaskList) {
-            if (crowdTestTask.getStatus().equals("HAS_FINISHED")){
-                continue;
-            }else{
-                result = false;
-            }
-        }
-        assertTrue(result);
-    }
-
-    @Test
-    public void should_modify_project_status_finished_when_submit_crowd_test_project_success() throws CrowdTestProjectNotExistException {
-        // arrange
-        crowdTestProjectCommand.setId(1L);
-        crowdTestProjectCommand.setStatus(CrowdTestProjectStatus.FINISHED);
-        // action
-        CrowdTestProject crowdTestProject = crowdTestProjectRepo.updateCrowdTestProjectStatus(crowdTestProjectCommand.getId(), crowdTestProjectCommand.getStatus());
-        // assert
-        assertEquals(crowdTestProject.getStatus(), crowdTestProjectCommand.getStatus());
-    }
-
-    @Test(expected = CrowdTestProjectNotExistException.class)
-    public void should_throw_when_submit_crowd_test_project_not_exist() throws CrowdTestProjectNotExistException {
-        // arrange
-        crowdTestProjectCommand.setId(2L);
-        crowdTestProjectCommand.setStatus(CrowdTestProjectStatus.FINISHED);
-        // action
-        crowdTestProjectRepo.updateCrowdTestProjectStatus(crowdTestProjectCommand.getId(), crowdTestProjectCommand.getStatus());
-    }
-}
+//package com.mooctest.crowd.domain.domainobject;
+//
+//import com.mooctest.crowd.domain.command.CrowdTestProjectCommand;
+//import com.mooctest.crowd.domain.command.CrowdTestTaskCommand;
+//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 org.junit.Test;
+//
+//import java.util.List;
+//
+//import static org.junit.Assert.*;
+//
+///**
+// * @author guochao
+// * @date 2019/7/9 14:20
+// */
+//public class RegionalManagerTest {
+//
+//    private CrowdTestProject crowdTestProject = new CrowdTestProject();
+//    private CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
+//    private CrowdTestProjectCommand crowdTestProjectCommand = new CrowdTestProjectCommand();
+//    private CrowdTestTaskCommand crowdTestTaskCommand = new CrowdTestTaskCommand();
+//    private GeneralUserTest generalUserTest = new GeneralUserTest();
+//    private RegionalManager regionalManager = new RegionalManager();
+//
+//    @Test
+//    public void should_modify_status_received_when_receive_crowd_test_project() throws CrowdTestProjectNotExistException {
+//        // arrange
+//        crowdTestProjectCommand.setId(1L);
+//        crowdTestProjectCommand.setStatus(CrowdTestProjectStatus.RECEIVED);
+//        // action
+//        CrowdTestProject crowdTestProject = crowdTestProjectRepo.updateCrowdTestProjectStatus(crowdTestProjectCommand.getId(), crowdTestProjectCommand.getStatus());
+//        // assert
+//        assertEquals(crowdTestProject.getStatus(), crowdTestProjectCommand.getStatus());
+//    }
+//
+//    @Test(expected = CrowdTestProjectNotExistException.class)
+//    public void should_throw_when_receive_crowd_test_project_not_exist() throws CrowdTestProjectNotExistException {
+//        // arrange
+//        crowdTestProjectCommand.setId(2L);
+//        crowdTestProjectCommand.setStatus(CrowdTestProjectStatus.RECEIVED);
+//        // action
+//        crowdTestProjectRepo.updateCrowdTestProjectStatus(crowdTestProjectCommand.getId(), crowdTestProjectCommand.getStatus());
+//    }
+//
+//    @Test
+//    public void should_return_crowd_test_project_when_general_user_view_exist_crowd_test_project() throws CrowdTestProjectNotExistException {
+//        generalUserTest.should_return_crowd_test_project_when_view_exist_crowd_test_project();
+//    }
+//
+//    @Test(expected = CrowdTestProjectNotExistException.class)
+//    public void should_throw_when_general_user_view__not_exist_crowd_test_project() throws CrowdTestProjectNotExistException {
+//        generalUserTest.should_throw_when_view__not_exist_crowd_test_project();
+//    }
+//
+//    @Test
+//    public void should_return_crowd_test_task_list_when_split_crowd_test_project_success() throws CrowdTestProjectNotExistException {
+//        // arrange
+//        crowdTestProjectCommand.setId(1L);
+//        // action
+//        List<CrowdTestTask> crowdTestTasks = regionalManager.splitCrowdTestProjectToCrowdTestTaskList(crowdTestProjectCommand.getId());
+//        // assert
+//        assertNotNull(crowdTestTasks);
+//    }
+//
+//    @Test(expected = CrowdTestProjectNotExistException.class)
+//    public void should_throw_when_split_crowd_test_project_not_exist() throws CrowdTestProjectNotExistException {
+//        // arrange
+//        crowdTestProjectCommand.setId(2L);
+//
+//        // action
+//        regionalManager.splitCrowdTestProjectToCrowdTestTaskList(crowdTestProjectCommand.getId());
+//    }
+//
+//    @Test
+//    public void should_return_true_when_make_a_price_for_crowd_test_project_success() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException {
+//        // arrange
+//        crowdTestTaskCommand.setId(101L);
+//        crowdTestTaskCommand.setCrowdTestProjectId(1L);
+//        crowdTestTaskCommand.setPrice(100.00);
+//        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
+//        Long id = crowdTestTaskCommand.getId();
+//        Double price = crowdTestTaskCommand.getPrice();
+//        // action
+//        CrowdTestProject crowdTestProject = regionalManager.fixedPriceForCrowdTestTask(projectId, id, price);
+//        List<CrowdTestTask> crowdTestTaskList = crowdTestProjectRepo.getByID(crowdTestProject.getId()).getCrowdTestTaskList();
+//        for (CrowdTestTask crowdTestTask : crowdTestTaskList
+//        ) {
+//            if (crowdTestTask.getId().equals(id)) {
+//                // assert
+//                assertEquals(price, crowdTestTask.getPrice());
+//            }
+//        }
+//    }
+//
+//    @Test(expected = CrowdTestProjectNotExistException.class)
+//    public void should_throw_when_make_a_price_for_crowd_test_project_not_exist() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException {
+//        // arrange
+//        crowdTestTaskCommand.setId(101L);
+//        crowdTestTaskCommand.setCrowdTestProjectId(2L);
+//        crowdTestTaskCommand.setPrice(100.00);
+//        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
+//        Long id = crowdTestTaskCommand.getId();
+//        Double price = crowdTestTaskCommand.getPrice();
+//        // action
+//        regionalManager.fixedPriceForCrowdTestTask(projectId, id, price);
+//    }
+//
+//    @Test(expected = CrowdTestTaskNotExistException.class)
+//    public void should_throw_when_make_a_price_for_crowd_test_task_not_exist() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException {
+//        // arrange
+//        crowdTestTaskCommand.setId(103L);
+//        crowdTestTaskCommand.setCrowdTestProjectId(1L);
+//        crowdTestTaskCommand.setPrice(100.00);
+//        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
+//        Long id = crowdTestTaskCommand.getId();
+//        Double price = crowdTestTaskCommand.getPrice();
+//        // action
+//        regionalManager.fixedPriceForCrowdTestTask(projectId, id, price);
+//    }
+//
+//    @Test
+//    public void should_return_true_when_distribute_crowd_test_task_to_evaluation_agency_success() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException {
+//        // arrange
+//        crowdTestTaskCommand.setId(101L);
+//        crowdTestTaskCommand.setCrowdTestProjectId(1L);
+//        crowdTestTaskCommand.setStatus(CrowdTestTaskStatus.RELEASED);
+//        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
+//        Long taskId = crowdTestTaskCommand.getId();
+//        String status = crowdTestProjectCommand.getStatus();
+//        // action
+//        boolean result = crowdTestProject.updateCrowdTestTaskStatus(projectId, taskId, status);
+//
+//        // assert
+//        assertTrue(result);
+//    }
+//
+//    @Test(expected = CrowdTestProjectNotExistException.class)
+//    public void should_throw_when_distribute_crowd_test_task_crowd_test_project_not_exist() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException {
+//        // arrange
+//        crowdTestTaskCommand.setId(101L);
+//        crowdTestTaskCommand.setCrowdTestProjectId(2L);
+//        crowdTestTaskCommand.setStatus(CrowdTestTaskStatus.RELEASED);
+//        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
+//        Long taskId = crowdTestTaskCommand.getId();
+//        String status = crowdTestProjectCommand.getStatus();
+//        // action
+//        crowdTestProject.updateCrowdTestTaskStatus(projectId, taskId, status);
+//    }
+//
+//    @Test(expected = CrowdTestTaskNotExistException.class)
+//    public void should_throw_when_distribute_crowd_test_task_crowd_test_task_not_exist() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException {
+//        // arrange
+//        crowdTestTaskCommand.setId(103L);
+//        crowdTestTaskCommand.setCrowdTestProjectId(1L);
+//        crowdTestTaskCommand.setStatus(CrowdTestTaskStatus.RELEASED);
+//        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
+//        Long taskId = crowdTestTaskCommand.getId();
+//        String status = crowdTestProjectCommand.getStatus();
+//        // action
+//        crowdTestProject.updateCrowdTestTaskStatus(projectId, taskId, status);
+//    }
+//
+//    @Test(expected = CrowdTestTaskNoPriceException.class)
+//    public void should_throw_when_distribute_crowd_test_task_price_not_exist() throws CrowdTestProjectNotExistException, CrowdTestTaskNotExistException, CrowdTestTaskNoPriceException {
+//        // arrange
+//        crowdTestTaskCommand.setId(101L);
+//        crowdTestTaskCommand.setCrowdTestProjectId(1L);
+//        crowdTestTaskCommand.setStatus(CrowdTestTaskStatus.RELEASED);
+//        Long projectId = crowdTestTaskCommand.getCrowdTestProjectId();
+//        Long taskId = crowdTestTaskCommand.getId();
+//        String status = crowdTestProjectCommand.getStatus();
+//        // action
+//        crowdTestProject.updateCrowdTestTaskStatusNoPrice(projectId, taskId, status);
+//    }
+//
+//    @Test
+//    public void should_modify_all_task_status_finished_when_aggregation_task() throws CrowdTestProjectNotExistException {
+//        // arrange
+//        crowdTestProjectCommand.setId(1L);
+//        Long projectId = crowdTestProjectCommand.getId();
+//        // action
+//        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.updateCrowdTestTaskListStatus(projectId, CrowdTestTaskStatus.FINISHED);
+//        // assert
+//        boolean result = true;
+//        for (CrowdTestTask crowdTestTask : crowdTestTaskList) {
+//            if (crowdTestTask.getStatus().equals("HAS_FINISHED")){
+//                continue;
+//            }else{
+//                result = false;
+//            }
+//        }
+//        assertTrue(result);
+//    }
+//
+//    @Test
+//    public void should_modify_project_status_finished_when_submit_crowd_test_project_success() throws CrowdTestProjectNotExistException {
+//        // arrange
+//        crowdTestProjectCommand.setId(1L);
+//        crowdTestProjectCommand.setStatus(CrowdTestProjectStatus.FINISHED);
+//        // action
+//        CrowdTestProject crowdTestProject = crowdTestProjectRepo.updateCrowdTestProjectStatus(crowdTestProjectCommand.getId(), crowdTestProjectCommand.getStatus());
+//        // assert
+//        assertEquals(crowdTestProject.getStatus(), crowdTestProjectCommand.getStatus());
+//    }
+//
+//    @Test(expected = CrowdTestProjectNotExistException.class)
+//    public void should_throw_when_submit_crowd_test_project_not_exist() throws CrowdTestProjectNotExistException {
+//        // arrange
+//        crowdTestProjectCommand.setId(2L);
+//        crowdTestProjectCommand.setStatus(CrowdTestProjectStatus.FINISHED);
+//        // action
+//        crowdTestProjectRepo.updateCrowdTestProjectStatus(crowdTestProjectCommand.getId(), crowdTestProjectCommand.getStatus());
+//    }
+//}

core/src/test/java/com/mooctest/crowd/domain/domainobject/SystemAdministratorTest.java

@@ -1,27 +1,27 @@
-package com.mooctest.crowd.domain.domainobject;
-
-import com.mooctest.crowd.domain.command.CrowdTestProjectCommand;
-import com.mooctest.crowd.domain.exception.CrowdTestProjectNotExistException;
-import com.mooctest.crowd.domain.repository.CrowdTestProjectRepo;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-/**
- * @author guochao
- * @date 2019/7/16 16:12
- */
-public class SystemAdministratorTest {
-    private CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
-    private CrowdTestProject crowdTestProject = new CrowdTestProject();
-    private CrowdTestProjectCommand crowdTestProjectCommand = new CrowdTestProjectCommand();
-    @Test
-    public void should_modify_crowd_test_project_status_when_finished_crowd_test_project() throws CrowdTestProjectNotExistException {
-        // arrange
-        crowdTestProjectCommand.setId(1L);
-        // action
-        CrowdTestProject crowdTestProject = this.crowdTestProject.updateCrowdTestProjectStatusToFinish(crowdTestProjectCommand.getId(), CrowdTestProjectStatus.FINISHED);
-        // assert
-        assertEquals(crowdTestProject.getStatus(), CrowdTestProjectStatus.FINISHED);
-    }
-}
+//package com.mooctest.crowd.domain.domainobject;
+//
+//import com.mooctest.crowd.domain.command.CrowdTestProjectCommand;
+//import com.mooctest.crowd.domain.exception.CrowdTestProjectNotExistException;
+//import com.mooctest.crowd.domain.repository.CrowdTestProjectRepo;
+//import org.junit.Test;
+//
+//import static org.junit.Assert.assertEquals;
+//
+///**
+// * @author guochao
+// * @date 2019/7/16 16:12
+// */
+//public class SystemAdministratorTest {
+//    private CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
+//    private CrowdTestProject crowdTestProject = new CrowdTestProject();
+//    private CrowdTestProjectCommand crowdTestProjectCommand = new CrowdTestProjectCommand();
+//    @Test
+//    public void should_modify_crowd_test_project_status_when_finished_crowd_test_project() throws CrowdTestProjectNotExistException {
+//        // arrange
+//        crowdTestProjectCommand.setId(1L);
+//        // action
+//        CrowdTestProject crowdTestProject = this.crowdTestProject.updateCrowdTestProjectStatusToFinish(crowdTestProjectCommand.getId(), CrowdTestProjectStatus.FINISHED);
+//        // assert
+//        assertEquals(crowdTestProject.getStatus(), CrowdTestProjectStatus.FINISHED);
+//    }
+//}

core/src/test/java/com/mooctest/crowd/domain/domainobject/UserTest.java

@@ -0,0 +1,233 @@
+//package com.mooctest.crowd.domain.domainobject;
+//
+//import com.mooctest.crowd.domain.command.LoginCommand;
+//import com.mooctest.crowd.domain.repository.UserRepo;
+//import org.junit.Before;
+//import org.junit.Rule;
+//import org.junit.rules.ExpectedException;
+//import org.junit.runner.RunWith;
+//import org.mockito.InjectMocks;
+//import org.mockito.Mock;
+//import org.mockito.MockitoAnnotations;
+//import org.mockito.runners.MockitoJUnitRunner;
+//
+//@RunWith(MockitoJUnitRunner.class)
+//public class UserTest {
+//    @InjectMocks
+//    private User user = new User();
+//
+//    @Mock
+//    private UserRepo userRepo;
+//
+//    private LoginCommand loginCommand = new LoginCommand();
+//
+//    @Rule
+//    public ExpectedException thrown = ExpectedException.none();
+//
+//    @Before
+//    public void setUp(){
+//        MockitoAnnotations.initMocks(this);
+//
+//        loginCommand.setMobileNum("13657094936");
+//        loginCommand.setPassword("123456");
+//
+//        user.setMobile("13657094936");
+//        user.setPassword("4QrcOUm6Wau+VuBX8g+IPg==");
+//
+//    }
+//
+//    @Test
+//    public void should_return_true_when_login_success() throws PasswordErrorException, UserNotExistException {
+//        // arrange
+//        when(userRepo.getByMobileNum("13657094936")).thenReturn(user);
+//        // action
+//        boolean success = user.login(loginCommand.getMobileNum(),loginCommand.getPassword());
+//        // assert
+//        assertTrue(success);
+//    }
+//
+//    @Test(expected = UserNotExistException.class)
+//    public void should_throw_when_user_not_exist() throws UserNotExistException, PasswordErrorException {
+//        // arrange
+//        loginCommand.setMobileNum("NOT_EXIST");
+//        when(userRepo.getByMobileNum("NOT_EXIST")).thenReturn(null);
+//        user.login(loginCommand.getMobileNum(),loginCommand.getPassword());
+//    }
+
+//
+//    @Test(expected = PasswordErrorException.class)
+//    public void should_throw_exception_when_password_error() throws PasswordErrorException, AccountNotExistException {
+//        // arrange
+//        LoginCommand loginCommand = new LoginCommand();
+//        loginCommand.setMobileNum("EXIST_ACCOUNT");
+//        loginCommand.setPassword("ERROR_PASSWORD");
+//        IAccountRepo IAccountRepo = new AccountUTRepo();
+//        Account account = IAccountRepo.getByMobileNum(loginCommand.getMobileNum());
+//        // assert
+//        account.login(loginCommand);
+//    }
+//
+//    @Test
+//    public void should_update_password_when_modify_password() throws AccountNotExistException, PasswordErrorException {
+//        // arrange
+//        ModifyPasswordCommand modifyPasswordCommand = new ModifyPasswordCommand();
+//        modifyPasswordCommand.setMobileNum("EXIST_ACCOUNT");
+//        modifyPasswordCommand.setOldPassword("PASSWORD");
+//        modifyPasswordCommand.setNewPassword("654321");
+//
+//        Account account = accountUTRepo.getByMobileNum(modifyPasswordCommand.getMobileNum());
+//        // action
+//        boolean result = account.modifyPassword(modifyPasswordCommand);
+//        // assert
+//        assertTrue(result);
+//    }
+//
+//    @Test
+//    public void should_return_permissions_when_account_login_success() throws AccountNotExistException {
+//        // arrange
+//        Account account = this.getSuccessAccount();
+//        // action
+//        List<Permission> permissions = account.distributePermission();
+//        // assert
+//        assertEquals(permissions.get(0).getId(), new Long(1));
+//    }
+//
+//    @Test
+//    public void should_return_roles_when_account_login_success() throws AccountNotExistException {
+//        // arrange
+//        Account account = this.getSuccessAccount();
+//        // action
+//        List<Role> roles = account.distributeRole();
+//        // assert
+//        assertEquals(roles.get(0).getId(), new Long(1));
+//    }
+//
+//    @Test
+//    public void should_return_account_when_view_by_account_id() throws AccountNotExistException {
+//        // arrange
+//        AccountCommand accountCommand = new AccountCommand();
+//        accountCommand.setId(123L);
+//
+//        // action
+//        Account accountUTRepoByID = accountUTRepo.getByID(accountCommand.getId());
+//        // assert
+//        assertEquals(accountUTRepoByID.getId(), accountCommand.getId());
+//    }
+//
+//    @Test(expected = AccountNotExistException.class)
+//    public void should_throw_when_view_account_not_exist_by_account_id() throws AccountNotExistException {
+//        // arrange
+//        AccountCommand accountCommand = new AccountCommand();
+//        accountCommand.setId(111L);
+//        // action
+//        accountUTRepo.getByID(accountCommand.getId());
+//    }
+//
+//    @Test
+//    public void should_return_account_list_when_view_by_account_ids() throws AccountNotExistException {
+//        // arrange
+//        Long[] ids = {123L};
+//        // action
+//        List<Account> accountList = accountUTRepo.getByIDList(ids);
+//        // assert
+//        assertEquals(accountList.get(0).getId(), ids[0]);
+//    }
+//
+//    @Test(expected = AccountNotExistException.class)
+//    public void should_throw_when_view_not_exist_account_by_account_ids() throws AccountNotExistException {
+//        // arrange
+//        Long[] ids = {123L,111L};
+//
+//        // action
+//        accountUTRepo.getByIDList(ids);
+//    }
+//
+//    @Test
+//    public void should_return_false_when_add_exist_account(){
+//        // arrange
+//        Account account = this.createCorrectAccount();
+//        // action
+//        Account resultAccount = accountUTRepo.addAccount(account);
+//        // assert
+//        assertEquals(resultAccount.getMobileNum(),account.getMobileNum());
+//    }
+//
+//    //    @Test(expected = AccountNotExistException.class)
+////    public void should_throw_when_add_account_success() throws AccountNotExistException {
+////        // arrange
+////        Account account = this.createDiscorrectAccount();
+////        // action
+////        accountUTRepo.addAccount(account);
+////    }
+//    @Test
+//    public void should_return_true_when_remove_account_success() throws AccountNotExistException {
+//        // arrange
+//        Account account = this.createCorrectAccount();
+//        // action
+//        boolean result = accountUTRepo.removeAccount(account);
+//        // assert
+//        assertTrue(result);
+//    }
+//
+//    @Test(expected = AccountNotExistException.class)
+//    public void should_throw_when_remove_not_exist_account() throws AccountNotExistException {
+//        // arrange
+//        Account account = this.createDiscorrectAccount();
+//        // action
+//        accountUTRepo.removeAccount(account);
+//    }
+//
+//    @Test
+//    public void should_return_true_when_update_account_success() throws AccountNotExistException {
+//        // arrange
+//        Account account = this.createCorrectAccount();
+//        account.setPassword("UPDATE_PASSWORD");
+//        // action
+//        Account updateAccount = accountUTRepo.updateAccount(account);
+//        // assert
+//        assertEquals(updateAccount.getPassword(),account.getPassword());
+//    }
+//
+//    @Test(expected = AccountNotExistException.class)
+//    public void should_throw_when_update_not_exist_account() throws AccountNotExistException {
+//        // arrange
+//        Account account = this.createDiscorrectAccount();
+//        // action
+//        accountUTRepo.updateAccount(account);
+//    }
+//
+//    private LoginCommand getSuccessLoginCommand() {
+//        LoginCommand loginCommand = new LoginCommand();
+//        loginCommand.setMobileNum("EXIST_ACCOUNT");
+//        loginCommand.setPassword("PASSWORD");
+//        loginCommand.setCheckCode("123456");
+//        return loginCommand;
+//    }
+//
+//    private Account getSuccessAccount() throws AccountNotExistException {
+//        LoginCommand loginCommand = getSuccessLoginCommand();
+//        IAccountRepo IAccountRepo = new AccountUTRepo();
+//        return IAccountRepo.getByMobileNum(loginCommand.getMobileNum());
+//    }
+//
+//    private Account createCorrectAccount(){
+//        AccountCommand accountCommand = new AccountCommand();
+//        accountCommand.setMobileNum("EXIST_ACCOUNT");
+//        accountCommand.setPassword("PASSWORD");
+//        Account account = new Account();
+//        account.setMobileNum(accountCommand.getMobileNum());
+//        account.setPassword(accountCommand.getPassword());
+//        return account;
+//    }
+//
+//    private Account createDiscorrectAccount(){
+//        AccountCommand accountCommand = new AccountCommand();
+//        accountCommand.setMobileNum("NOT_EXIST_ACCOUNT");
+//        accountCommand.setPassword("PASSWORD");
+//        Account account = new Account();
+//        account.setMobileNum(accountCommand.getMobileNum());
+//        account.setPassword(accountCommand.getPassword());
+//        return account;
+//    }
+//
+//}

core/src/test/java/com/mooctest/crowd/domain/domainservice/RegisterDServiceTest.java

@@ -1,69 +1,113 @@
-package com.mooctest.crowd.domain.domainservice;
-
-import com.mooctest.crowd.domain.command.RegisterCommand;
-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.junit.Before;
-import org.junit.Rule;
-import org.junit.rules.ExpectedException;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-
-import static org.junit.Assert.assertNull;
-import static org.mockito.Mockito.when;
-
-/**
- * @Author: xuexb
- * @Date: 2019.7.5 14:09
- */
-public class RegisterDServiceTest {
-    @InjectMocks
-    private RegisterDService registerDService = new RegisterDService();
-
-    @Mock
-    private AccountUTRepo accountUTRepo;
-
-    private Account account = new Account();
-
-    private RegisterCommand registerCommand = new RegisterCommand();
-
-    @Rule
-    public ExpectedException thrown = ExpectedException.none();
-
-    @Before
-    public void setUp() throws AccountNotExistException {
-        MockitoAnnotations.initMocks(this);
-
-        registerCommand.setMobileNum("13657094936");
-        registerCommand.setCheckCode("XXXX");
-        registerCommand.setPassword("12341324");
-
-        account.setMobileNum("18652040322");
-        account.setPassword("12341324");
-
-    }
-
-
-    @org.junit.Test
-    public void should_register_success_when_user_register_by_mobile_num() throws AccountNotExistException {
-
-        // action
-        when(accountUTRepo.getByMobileNum("13657094936")).thenReturn(null);
-        Account newAccount = registerDService.register(registerCommand.getMobileNum(),registerCommand.getPassword());
-
-        // assert
-        assertNull(newAccount);
-
-    }
-    @org.junit.Test
-    public void should_thow_exception_when_mobile_num_exist() throws AccountNotExistException {
-
-        when(accountUTRepo.getByMobileNum("18652040322")).thenReturn(account);
-        thrown.expect(HttpBadRequestException.class);
-        registerCommand.setMobileNum("18652040322");
-        registerDService.register(registerCommand.getMobileNum(),registerCommand.getPassword());
-    }
-}
+//package com.mooctest.crowd.domain.domainservice;
+//
+//import com.mooctest.crowd.domain.command.RegisterCommand;
+//import com.mooctest.crowd.domain.domainobject.User;
+//import com.mooctest.crowd.domain.repository.UserRepo;
+//import org.junit.Before;
+//import org.junit.Rule;
+//import org.junit.rules.ExpectedException;
+//import org.junit.runner.RunWith;
+//import org.mockito.InjectMocks;
+//import org.mockito.Mock;
+//import org.mockito.MockitoAnnotations;
+//import org.mockito.runners.MockitoJUnitRunner;
+//
+///**
+// * @Author: xuexb
+// * @Date: 2019.7.5 14:09
+// */
+//@RunWith(MockitoJUnitRunner.class)
+//public class RegisterDServiceTest {
+//    @InjectMocks
+//    private RegisterDService registerDService = new RegisterDService();
+//
+//    @Mock
+//    private UserRepo userRepo;
+//
+//    private User user =  new User();
+//
+//    private RegisterCommand registerCommand = new RegisterCommand();
+//
+//    @Rule
+//    public ExpectedException thrown = ExpectedException.none();
+//
+//    @Before
+//    public void setUp(){
+//        MockitoAnnotations.initMocks(this);
+//
+//        registerCommand.setMobileNum("13657094936");
+//        registerCommand.setPassword("123456");
+//
+//        user.setMobile("13657094936");
+//        user.setPassword("123456");
+//
+//    }
+//
+//
+////    @Test
+////    public void should_register_success_when_user_register_by_mobile_num() throws AccountNotExistException, UserNotExistException {
+////
+////        // action
+////        when(userRepo.getByMobileNum("13657094936")).thenReturn(null);
+////        when(userRepo.save(any(User.class))).thenReturn(user);
+////        User registerUser = registerDService.register(registerCommand.getMobileNum(), registerCommand.getPassword());
+////
+////        // assert
+////        assertNotNull(registerUser);
+////
+////    }
+////    @Test
+////    public void should_thow_exception_when_mobile_num_exist() throws AccountNotExistException, UserNotExistException {
+////
+////        when(userRepo.getByMobileNum("18652040322")).thenReturn(user);
+////        thrown.expect(HttpBadRequestException.class);
+////        registerCommand.setMobileNum("18652040322");
+////        registerDService.register(registerCommand.getMobileNum(),registerCommand.getPassword());
+////    }
+////    @InjectMocks
+////    private RegisterDService registerDService = new RegisterDService();
+////
+////    @Mock
+////    private UserRepo userRepo;
+////
+////    private User user =  new User();
+////
+////    private RegisterCommand registerCommand = new RegisterCommand();
+////
+////    @Rule
+////    public ExpectedException thrown = ExpectedException.none();
+////
+////    @Before
+////    public void setUp(){
+////        MockitoAnnotations.initMocks(this);
+////
+////        registerCommand.setMobileNum("13657094936");
+////        registerCommand.setPassword("123456");
+////
+////        user.setMobile("13657094936");
+////        user.setPassword("123456");
+////
+////    }
+////
+////
+////    @Test
+////    public void should_register_success_when_user_register_by_mobile_num() throws AccountNotExistException, UserNotExistException {
+////
+////        // action
+////        when(userRepo.getByMobileNum("13657094936")).thenReturn(null);
+////        when(userRepo.save(any(User.class))).thenReturn(user);
+////        User registerUser = registerDService.register(registerCommand.getMobileNum(), registerCommand.getPassword());
+////
+////        // assert
+////        assertNotNull(registerUser);
+////
+////    }
+////    @Test
+////    public void should_thow_exception_when_mobile_num_exist() throws AccountNotExistException, UserNotExistException {
+////
+////        when(userRepo.getByMobileNum("18652040322")).thenReturn(user);
+////        thrown.expect(HttpBadRequestException.class);
+////        registerCommand.setMobileNum("18652040322");
+////        registerDService.register(registerCommand.getMobileNum(),registerCommand.getPassword());
+////    }
+//}

core/src/test/java/com/mooctest/crowd/domain/repository/AccountUTRepoTest.java

@@ -0,0 +1,74 @@
+//package com.mooctest.crowd.domain.repository;
+//
+//import com.mooctest.crowd.domain.dao.UserDao;
+//import com.mooctest.crowd.domain.domainobject.User;
+//import com.mooctest.crowd.domain.exception.AccountNotExistException;
+//import com.mooctest.crowd.domain.model.UserPO;
+//import org.junit.Before;
+//import org.junit.Test;
+//import org.junit.runner.RunWith;
+//import org.mockito.InjectMocks;
+//import org.mockito.Mock;
+//import org.mockito.MockitoAnnotations;
+//import org.mockito.runners.MockitoJUnitRunner;
+//
+//import static org.junit.Assert.assertEquals;
+//import static org.mockito.Mockito.when;
+//
+//@RunWith(MockitoJUnitRunner.class)
+//public class AccountUTRepoTest {
+//
+//    @InjectMocks
+//    private AccountUTRepo accountUTRepo = new AccountUTRepo();
+//
+//    @Mock
+//    private UserDao userDao;
+//
+//    private UserPO userPO =  new UserPO();
+//
+//    private User user =  new User();
+//
+//    @Before
+//    public void setUp() {
+//        MockitoAnnotations.initMocks(this);
+//
+//        user.setMobile("13657094936");
+//        user.setPassword("123456");
+//
+//        userPO.setMobile("13657094936");
+//        userPO.setPassword("123456");
+//    }
+//
+//    @Test
+//    public void show_return_user_when_getbymobilenum_mobile_num_exist() throws AccountNotExistException {
+//
+//        when(userDao.findByMobile("13657094936")).thenReturn(userPO);
+//        User user = accountUTRepo.getByMobileNum("13657094936");
+////        assertEquals(user.getPassword(), EncryptionUtil.encryptMD5(userPO.getPassword()));
+//        assertEquals(user.getPassword(), "123456");
+//    }
+//
+//    @Test
+//    public void getByID() {
+//    }
+//
+//    @Test
+//    public void getByIDList() {
+//    }
+//
+//    @Test
+//    public void addAccount() {
+//    }
+//
+//    @Test
+//    public void removeAccount() {
+//    }
+//
+//    @Test
+//    public void updateAccount() {
+//    }
+//
+//    @Test
+//    public void save() {
+//    }
+//}

core/src/test/java/com/mooctest/crowd/domain/repository/UserRepoTest.java

@@ -0,0 +1,209 @@
+package com.mooctest.crowd.domain.repository;
+
+import com.mooctest.crowd.domain.dao.*;
+import com.mooctest.crowd.domain.domainobject.*;
+import com.mooctest.crowd.domain.exception.UserNotExistException;
+import com.mooctest.crowd.domain.model.*;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Optional;
+
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class UserRepoTest {
+    @InjectMocks
+    private UserRepo userRepo = new UserRepo();
+
+    @Mock
+    private UserDao userDao;
+    @Mock
+    private UserToRoleDao userToRoleDao;
+    @Mock
+    private RoleDao roleDao;
+    @Mock
+    private RoleToPermissionDao roleToPermissionDao;
+    @Mock
+    private PermissionDao permissionDao;
+    @Mock
+    private EvaluationAgencyDao evaluationAgencyDao;
+    @Mock
+    private RegionalManagerDao regionalManagerDao;
+    @Mock
+    private RegionalDao regionalDao;
+
+    private UserPO expectUserPO;
+    private RolePO expectRolePO;
+    private PermissionPO expectPermission;
+    private List<UserToRolePO> expectUserToRolePOList;
+    private List<RoleToPermissionPO> expectRoleToPermissionPOList;
+    private UserToRolePO expectUserToRolePO;
+
+    @Before
+    public void before() {
+        MockitoAnnotations.initMocks(this);
+
+        expectUserPO = new UserPO();
+        expectRolePO = new RolePO();
+        expectUserToRolePO = new UserToRolePO();
+        RoleToPermissionPO expectRoleToPermissionPO = new RoleToPermissionPO();
+        expectPermission = new PermissionPO();
+        expectUserToRolePOList = new LinkedList<>();
+        expectRoleToPermissionPOList = new LinkedList<>();
+        expectRoleToPermissionPOList.add(expectRoleToPermissionPO);
+        expectUserToRolePOList.add(expectUserToRolePO);
+    }
+
+    @Test
+    public void should_return_user_optional_when_get_by_id_success() {
+        //arrange
+        EvaluationAgencyPO expectEvaluationAgency = new EvaluationAgencyPO();
+        List<RegionalManagerPO> expectRegionalManagerList = new LinkedList<>();
+        RegionalManagerPO regionalManagerPO = new RegionalManagerPO();
+        expectRegionalManagerList.add(regionalManagerPO);
+        RegionalPO expectRegional = new RegionalPO();
+
+        when(userDao.findById(anyLong())).thenReturn(Optional.of(expectUserPO));
+        when(userToRoleDao.findByUserId(anyLong())).thenReturn(expectUserToRolePOList);
+        when(roleDao.findById(anyLong())).thenReturn(Optional.of(expectRolePO));
+        when(roleToPermissionDao.findAllByRoleId(anyLong())).thenReturn(expectRoleToPermissionPOList);
+        when(permissionDao.findById(anyLong())).thenReturn(Optional.of(expectPermission));
+        when(evaluationAgencyDao.findByUserId(anyLong())).thenReturn(expectEvaluationAgency);
+        when(regionalManagerDao.findByUserId(anyLong())).thenReturn(expectRegionalManagerList);
+        when(regionalDao.findById(anyLong())).thenReturn(Optional.of(expectRegional));
+        //action
+        User user = userRepo.getByID(0L);
+        //assert
+        Assert.assertNotNull(user);
+    }
+
+    @Test(expected = UserNotExistException.class)
+    public void should_throw_exception_when_get_by_id_get_null() {
+        //arrange
+        when(userDao.findById(anyLong())).thenReturn(Optional.empty());
+        //action
+        userRepo.getByID(0L);
+        //assert
+    }
+
+    @Test
+    public void should_return_user_optional_when_get_by_mobile_number_success() {
+        //arrange
+        when(userDao.findByMobile(anyString())).thenReturn(expectUserPO);
+        when(userToRoleDao.findByUserId(anyLong())).thenReturn(expectUserToRolePOList);
+        when(roleDao.findById(anyLong())).thenReturn(Optional.of(expectRolePO));
+        when(roleToPermissionDao.findAllByRoleId(anyLong())).thenReturn(expectRoleToPermissionPOList);
+        when(permissionDao.findById(anyLong())).thenReturn(Optional.of(expectPermission));
+        //action
+        User user = userRepo.getByMobileNum("123");
+        //assert
+        Assert.assertNotNull(user);
+    }
+
+    @Test(expected = UserNotExistException.class)
+    public void should_throw_exception_when_get_by_mobile_number_get_null() {
+        //arrange
+        when(userDao.findByMobile(anyString())).thenReturn(null);
+        //action
+        userRepo.getByMobileNum("123");
+        //assert
+    }
+
+    @Test
+    public void should_return_user_when_save_user_and_role() {
+        //arrange
+        Role expectRole = new Role();
+        List<Role> roleList = new LinkedList<>();
+        roleList.add(expectRole);
+        User user = new User();
+        user.setRoleList(roleList);
+        when(userDao.save(any(UserPO.class))).thenReturn(expectUserPO);
+        when(roleDao.findByName(anyString())).thenReturn(expectRolePO);
+        when(userToRoleDao.save(any(UserToRolePO.class))).thenReturn(expectUserToRolePO);
+        //action
+        User resultUser = userRepo.saveUserAndRole(user);
+        //assert
+        Assert.assertNotNull(resultUser);
+    }
+
+    @Test
+    public void should_return_user_when_save_user() {
+        //arrange
+        List<Permission> permissionList = new LinkedList<>();
+        Permission permission = new Permission();
+        permissionList.add(permission);
+        List<Role> roleList = new LinkedList<>();
+        Role role = new Role();
+        role.setPermissionList(permissionList);
+        roleList.add(role);
+        EvaluationAgency evaluationAgency = new EvaluationAgency();
+        User user = new User();
+        user.setEvaluationAgency(evaluationAgency);
+        user.setRoleList(roleList);
+
+        when(userDao.save(any(UserPO.class))).thenReturn(expectUserPO);
+        //action
+        User resultUser = userRepo.saveUser(user);
+        //assert
+        Assert.assertNotNull(resultUser);
+    }
+
+    @Test
+    public void should_return_user_list_when_get_by_id_list() {
+        //arrange
+        List<UserPO> expectUserPOList = new LinkedList<>();
+        expectUserPOList.add(new UserPO());
+        expectUserPOList.add(new UserPO());
+        when(userDao.findAllById(anyListOf(Long.class))).thenReturn(expectUserPOList);
+        //action
+        List<User> userList = userRepo.getByIdList(new LinkedList<>());
+        //assert
+        Assert.assertNotNull(userList);
+    }
+
+    @Test
+    public void should_return_user_list_when_get_all_user() {
+        //arrange
+        List<UserPO> expectUserPOList = new LinkedList<>();
+        expectUserPOList.add(new UserPO());
+        expectUserPOList.add(new UserPO());
+        when(userDao.findAll()).thenReturn(expectUserPOList);
+        //action
+        List<User> userList = userRepo.getAllUser();
+        //assert
+        Assert.assertNotNull(userList);
+    }
+
+    @Test
+    public void should_return_void_when_remove_user() {
+        //arrange
+        User user = new User();
+        //action
+        userRepo.removeUser(user);
+        //assert
+        Assert.assertNull(null);
+    }
+
+    @Test
+    public void should_return_void_when_remove_user_list() {
+        //arrange
+        List<User> userList = new LinkedList<>();
+        userList.add(new User());
+        //action
+        userRepo.removeUserList(userList);
+        //assert
+        Assert.assertNull(null);
+    }
+
+
+}

pom.xml

@@ -2,6 +2,12 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" 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>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>2.1.6.RELEASE</version>
+        <relativePath/> <!-- lookup parent from repository -->
+    </parent>
     <groupId>com.mooctest.crowd</groupId>
     <artifactId>crowd</artifactId>
     <packaging>pom</packaging>

site/pom.xml

@@ -3,10 +3,9 @@
 	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>org.springframework.boot</groupId>
-		<artifactId>spring-boot-starter-parent</artifactId>
-		<version>2.1.6.RELEASE</version>
-		<relativePath/> <!-- lookup parent from repository -->
+		<groupId>com.mooctest.crowd</groupId>
+		<artifactId>crowd</artifactId>
+		<version>1.0-SNAPSHOT</version>
 	</parent>
 	<groupId>com.mooctest.crowd</groupId>
 	<artifactId>site</artifactId>
@@ -69,14 +68,48 @@
 			<artifactId>junit</artifactId>
 			<version>4.12</version>
 		</dependency>
-
-
-		
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-data-redis</artifactId>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.commons</groupId>
+			<artifactId>commons-pool2</artifactId>
+		</dependency>
 		<dependency>
 			<groupId>org.hibernate.javax.persistence</groupId>
 			<artifactId>hibernate-jpa-2.1-api</artifactId>
 			<version>1.0.0.Final</version>
 		</dependency>
+		<dependency>
+			<groupId>com.alibaba</groupId>
+			<artifactId>fastjson</artifactId>
+			<version>1.2.58</version>
+		</dependency>
+		<dependency>
+			<groupId>com.aliyun.oss</groupId>
+			<artifactId>aliyun-sdk-oss</artifactId>
+			<version>3.5.0</version>
+		</dependency>
+		<dependency>
+			<groupId>org.springframework.session</groupId>
+			<artifactId>spring-session-data-redis</artifactId>
+		</dependency>
+		<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>
 	</dependencies>
 
 	<build>

site/src/main/java/com/mooctest/crowd/site/SiteApplication.java

@@ -2,8 +2,9 @@ package com.mooctest.crowd.site;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.ComponentScan;
 
-@SpringBootApplication
+@SpringBootApplication(scanBasePackages = "com.mooctest.crowd")
 public class SiteApplication {
 
 	public static void main(String[] args) {

site/src/main/java/com/mooctest/crowd/site/anticorruption/UserAntiCorruption.java

@@ -0,0 +1,14 @@
+package com.mooctest.crowd.site.anticorruption;
+
+import com.mooctest.crowd.domain.domainobject.User;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-08 23:40
+ */
+public interface UserAntiCorruption {
+    User register(String name, String mobile, String password);
+
+    User getUserInfo(Long userId);
+}

site/src/main/java/com/mooctest/crowd/site/anticorruption/impl/UserAntiCorruptionImpl.java

@@ -0,0 +1,88 @@
+package com.mooctest.crowd.site.anticorruption.impl;
+
+import com.alibaba.fastjson.JSONObject;
+import com.mooctest.crowd.domain.domainobject.Role;
+import com.mooctest.crowd.domain.domainobject.User;
+import com.mooctest.crowd.domain.exception.UserNotExistException;
+import com.mooctest.crowd.domain.factory.UserFactory;
+import com.mooctest.crowd.domain.repository.UserRepo;
+import com.mooctest.crowd.site.anticorruption.UserAntiCorruption;
+import com.mooctest.crowd.site.anticorruption.impl.data.UserInfo;
+import com.mooctest.crowd.site.util.EncryptionUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Component;
+import org.springframework.web.client.RestTemplate;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-08 23:40
+ */
+@Slf4j
+@Component
+public class UserAntiCorruptionImpl implements UserAntiCorruption {
+    @Autowired
+    private RestTemplate restTemplate;
+
+    @Autowired
+    private UserRepo userRepo;
+
+    @Value("${user.service.baseUrl}")
+    private String userServiceUrl;
+
+    @Override
+    public User register(String name, String mobile, String password) {
+        HttpHeaders httpHeaders = new HttpHeaders();
+        httpHeaders.setContentType(MediaType.APPLICATION_JSON);
+        JSONObject params = new JSONObject();
+        params.put("name", name);
+        params.put("mobile", mobile);
+        params.put("email", name+"."+mobile+"@mooctest.net");
+        params.put("password", EncryptionUtil.encryptMD5(password));
+        params.put("createTime", System.currentTimeMillis());
+
+        HttpEntity<String> entity = new HttpEntity<>(params.toString() , httpHeaders);
+        UserInfo userInfo = restTemplate.exchange(userServiceUrl + "/api/user", HttpMethod.POST, entity, UserInfo.class).getBody();
+        User user = UserFactory.createUser();
+        user.setId(userInfo.getId());
+        user.setName(userInfo.getName());
+        user.setUserName(userInfo.getName());
+        user.setMobile(mobile);
+        user.setPassword(userInfo.getPassword());
+        return user;
+    }
+
+    @Override
+    public User getUserInfo(Long userId) {
+        UserInfo userInfo = restTemplate.getForEntity(userServiceUrl+"/api/user/"+userId, UserInfo.class).getBody();
+        if (userInfo == null)
+            throw new UserNotExistException();
+        log.info("userInfo: " + userInfo.toString());
+        try{
+            //将用户中心的用户中心的用户数据对本系统内同步
+            User newUser = userInfo.toUser();
+            User oldUser = userRepo.getByID(userId);
+            newUser.setRoleList(oldUser.getRoleList());
+            newUser.setGender(oldUser.getGender());
+            userRepo.saveUser(newUser);
+        }catch (UserNotExistException e){   //本站不存在该用户，是未同步信息的新用户，初始化角色
+            User user = userInfo.toUser();
+            List<Role> roles = new ArrayList<>();
+            roles.add(userRepo.getRole("generalUser"));
+            user.setRoleList(roles);
+            userRepo.saveUser(user);
+        }
+        return userRepo.getByID(userId);
+    }
+}

site/src/main/java/com/mooctest/crowd/site/anticorruption/impl/data/UserInfo.java

@@ -0,0 +1,45 @@
+package com.mooctest.crowd.site.anticorruption.impl.data;
+
+import com.mooctest.crowd.domain.domainobject.User;
+import com.mooctest.crowd.domain.factory.UserFactory;
+import lombok.Data;
+
+import java.sql.Timestamp;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-12 01:47
+ */
+@Data
+public class UserInfo {
+    private Long id;
+    private String email;
+    private String name;
+    private String mobile;
+    private String password;
+    private Long createTime;
+    private String school;
+    private String photoUrl;
+    private String province;
+    private String city;
+    private Boolean manualCheckValid;
+    private Integer availability;
+    private Long integral;
+
+    public User toUser(){
+        User user = UserFactory.createUser();
+        user.setId(this.id);
+        user.setName(name);
+        user.setUserName(name);
+        user.setMobile(mobile);
+        user.setPassword(password);
+        user.setCity(city);
+        user.setProvince(province);
+        user.setPhotoUrl(photoUrl);
+        user.setCreateTime(new Timestamp(createTime));
+        user.setIsAvailable(availability);
+        user.setIsDeleted(0);
+        return user;
+    }
+}

site/src/main/java/com/mooctest/crowd/site/command/ApplyAgencyAuthCommand.java

@@ -0,0 +1,40 @@
+package com.mooctest.crowd.site.command;
+
+import com.mooctest.crowd.domain.domainobject.EvaluationAgency;
+import com.mooctest.crowd.domain.factory.UserFactory;
+import lombok.Data;
+import org.springframework.beans.BeanUtils;
+
+import javax.validation.constraints.NotNull;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-12 01:05
+ */
+@Data
+public class ApplyAgencyAuthCommand {
+
+    @NotNull(message = "手机号不可为空")
+    private String mobile;
+    @NotNull(message = "机构名称不可为空")
+    private String evaluationAgencyName;
+    @NotNull(message = "银行卡号不可为空")
+    private String bankAccount;
+    @NotNull(message = "机构地址不可为空")
+    private String address;
+    @NotNull(message = "评测能力不可为空")
+    private String abilities;
+    @NotNull(message = "机构资源不可为空")
+    private String resources;
+    @NotNull(message = "LOGO不可为空")
+    private String agencyPhoto;
+
+    public EvaluationAgency toAgency(){
+        EvaluationAgency agency = UserFactory.defaultAgency();
+        BeanUtils.copyProperties(this, agency);
+        agency.setIsDeleted(0);
+        agency.setIsAuthentication(0);
+        return agency;
+    }
+}

site/src/main/java/com/mooctest/crowd/site/command/CreateProjectCommand.java

@@ -1,12 +0,0 @@
-package com.mooctest.crowd.site.command;
-
-import lombok.Data;
-
-/**
- * @author: Diors.Po
- * @Email: 171256175@qq.com
- * @date 2019-07-25 14:37
- */
-@Data
-public class CreateProjectCommand {
-}

site/src/main/java/com/mooctest/crowd/site/command/CrowdTestProjectCommand.java

@@ -1,24 +1,94 @@
 package com.mooctest.crowd.site.command;
 
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.mooctest.crowd.domain.domainobject.CrowdTestProject;
+
+import com.mooctest.crowd.domain.factory.CrowdTestProjectFactory;
 import lombok.Data;
 
-import java.io.File;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Pattern;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.Map;
 
 /**
- * @author guochao
- * @date 2019/7/6 18:50
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-07-25 14:37
  */
 @Data
 public class CrowdTestProjectCommand {
-    private Long id;
+    @NotNull(message = "UserId不可为空")
+    private Long userId;
+
+    @NotNull(message = "项目名称不可为空")
     private String name;
-    private Long ownerId;
-    private Long managerId;
-    private Long distributeId;
-    private String description;
-    private File projectFile;
-    private File requirement;
-    private double quotedPrice;
-    private double fixedPrice;
-    private String status;
+
+    @NotNull(message = "项目服务类型不可为空")
+    private ArrayList<Integer> type;
+
+    private ArrayList<Integer> platform;
+
+    @NotNull(message = "项目描述不可为空")
+    private String desc;
+
+    @NotNull(message = "可见性选择不可为空")
+    private Long resource;
+
+    private Map<String, String> location;
+
+    private Long institution;
+
+    @NotNull(message = "项目联系人不可为空")
+    private String contactName;
+
+    @NotNull(message = "项目联系人电话不可为空")
+    @Pattern(regexp = "^[0-9]{11}$", message = "Mobile number is illegal")
+    private String contactPhone;
+
+    @NotNull(message = "请上传需求文档")
+    private String doc;
+
+    @NotNull(message = "请上传应用apk")
+    private String file;
+
+    @NotNull(message = "请填写预算价格")
+    private Double budget;
+
+    private Timestamp datetime;
+
+    private String usage;
+
+    private Double price;
+
+    public CrowdTestProject toCrowdProject(){
+        CrowdTestProject crowdTestProject = CrowdTestProjectFactory.createCrowdTestProject();
+        crowdTestProject.setUserId(this.userId);
+        crowdTestProject.setName(this.name);
+        crowdTestProject.setLinkMan(this.contactName);
+        crowdTestProject.setLinkManMobile(this.contactPhone);
+        crowdTestProject.setType(JSONObject.toJSONString(this.type));
+        crowdTestProject.setPlatform(JSONObject.toJSONString(this.platform));
+        crowdTestProject.setDescription(this.desc);
+        crowdTestProject.setRequirementFile(this.doc);
+        crowdTestProject.setProjectFile(this.file);
+        crowdTestProject.setProjectDistributionTypeId(this.resource);
+        crowdTestProject.setDistributionProvince(this.location.get("provinceCode"));
+        crowdTestProject.setDistributionCity(this.location.get("cityCode"));
+        crowdTestProject.setRegionalManagerId(this.getInstitution());
+        crowdTestProject.setDeadTime(this.datetime);
+        crowdTestProject.setQuotedPrice(this.budget);
+        crowdTestProject.setFixedPrice(this.price);
+        return crowdTestProject;
+    }
+
+    public boolean isLegal(){
+        if (this.resource == 1 && this.location == null)
+            return false;
+        else if (this.resource == 0 && this.institution == null)
+            return false;
+        return true;
+    }
 }

site/src/main/java/com/mooctest/crowd/site/command/CrowdTestReportCommand.java

@@ -1,7 +1,12 @@
 package com.mooctest.crowd.site.command;
 
+import com.mooctest.crowd.domain.domainobject.CrowdTestReport;
 import lombok.Data;
 
+import javax.validation.constraints.Max;
+import javax.validation.constraints.Min;
+import javax.validation.constraints.NotNull;
+
 /**
  * @author guochao
  * @date 2019/7/11 14:16
@@ -9,12 +14,43 @@ import lombok.Data;
 @Data
 public class CrowdTestReportCommand {
 
-    private Long id;
-    private Long projectId;
-    private Long taskId;
-    private int type;
-    private String description;
+    @NotNull(message = "请填写报告名称")
+    private String name;
+
+    @NotNull(message = "请选择报告所属范围")
+    private Integer scope;
+
+    @NotNull(message = "请选择报告类型 ")
+    private Integer type;
+
+    private String dependencyCode;
+
+    @NotNull(message = "请填写测试对象")
+    private String target;
+
+    @NotNull(message = "请填写摘要内容")
     private String content;
-    private String status;
+
+    @NotNull(message = "缺少报告文件url")
+    private String file;
+
+    @NotNull(message = "请填写结论信息")
+    private String conclusion;
+
+
+
+    public CrowdTestReport toCrowdTestReport(){
+        CrowdTestReport report = new CrowdTestReport();
+        report.setName(name);
+        report.setType(type);
+        report.setScope(scope);
+        report.setConclusion(conclusion);
+        report.setContent(content);
+        report.setFile(file);
+        report.setTestObject(target);
+        report.setDependencyCode(dependencyCode);
+        return report;
+    }
+
 
 }

site/src/main/java/com/mooctest/crowd/site/command/CrowdTestTaskCommand.java

@@ -1,8 +1,13 @@
 package com.mooctest.crowd.site.command;
 
+import com.mooctest.crowd.domain.domainobject.CrowdTestTask;
+import com.mooctest.crowd.domain.factory.CrowdTestProjectFactory;
 import lombok.Data;
 
+import javax.validation.constraints.NotNull;
 import java.io.File;
+import java.sql.Timestamp;
+import java.util.Map;
 
 /**
  * @author guochao
@@ -10,13 +15,57 @@ import java.io.File;
  */
 @Data
 public class CrowdTestTaskCommand {
-    private Long id;
+
+    @NotNull(message = "请填写任务名称")
     private String name;
-    private Long projectId;
-    private Long evaluationAgencyId;
-    private int type;
-    private String description;
-    private File requirementFile;
-    public Double price;
-    private String status;
+
+    @NotNull(message = "请填写任务描述")
+    private String desc;
+
+    @NotNull(message = "请填写任务类型")
+    private Integer type;
+
+    @NotNull(message = "请指定任务发布类型")
+    private Long resource;
+
+    private Map<String, String> location;
+
+    private Long institution;
+
+    @NotNull(message = "请填写截止时间")
+    private Timestamp datetime;
+
+    @NotNull(message = "报价不可为空")
+    private Double quotePrice;
+
+    private Double fixedPrice;
+
+    public boolean isLegal(){
+        if (this.resource == 1 && this.location == null)
+            return false;
+        else if (this.resource == 0 && this.institution == null)
+            return false;
+        return true;
+    }
+
+    public CrowdTestTask toCrowdTask(){
+        CrowdTestTask crowdTestTask = new CrowdTestTask();
+        crowdTestTask.setName(name);
+        crowdTestTask.setDeadTime(datetime);
+        crowdTestTask.setDescription(desc);
+        crowdTestTask.setDistributionProvince(location.get("provinceCode"));
+        crowdTestTask.setDistributionCity(location.get("cityCode"));
+        crowdTestTask.setDistributionType(resource);
+        crowdTestTask.setEvaluationAgencyId(institution);
+        crowdTestTask.setType(type);
+        crowdTestTask.setQuotedPrice(quotePrice);
+        crowdTestTask.setFixedPrice(fixedPrice);
+        return crowdTestTask;
+    }
+
+    public CrowdTestTask toCrowdTask(String projectCode){
+        CrowdTestTask task = toCrowdTask();
+        task.setCrowdTestProjectCode(projectCode);
+        return task;
+    }
 }

site/src/main/java/com/mooctest/crowd/site/command/GenerateProjectCommand.java

@@ -0,0 +1,99 @@
+package com.mooctest.crowd.site.command;
+
+import com.alibaba.fastjson.JSONObject;
+import com.mooctest.crowd.domain.domainobject.CrowdTestProject;
+import com.mooctest.crowd.domain.domainobject.CrowdTestProjectStatus;
+import com.mooctest.crowd.domain.domainobject.CrowdTestReport;
+import com.mooctest.crowd.domain.domainobject.ProjectDistributeType;
+import com.mooctest.crowd.domain.factory.CrowdTestProjectFactory;
+import lombok.Data;
+
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Pattern;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.Map;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-09 13:44
+ */
+@Data
+public class GenerateProjectCommand {
+    private Long userId;
+
+    @NotNull(message = "项目名称不可为空")
+    private String name;
+
+    @NotNull(message = "项目服务类型不可为空")
+    private ArrayList<Integer> type;
+
+    private ArrayList<Integer> platform;
+
+    @NotNull(message = "项目描述不可为空")
+    private String description;
+
+    @NotNull(message = "项目联系人不可为空")
+    private String contactName;
+
+    @NotNull(message = "项目联系人电话不可为空")
+    @Pattern(regexp = "^[0-9]{11}$", message = "Mobile number is illegal")
+    private String contactPhone;
+
+    @NotNull(message = "请上传需求文档")
+    private String doc;
+
+    private String file;
+
+    @NotNull(message = "请填写截止时间")
+    private Timestamp datetime;
+
+    @NotNull(message = "请填写价格")
+    private Double price;
+
+    //报告信息
+    private String reportContent;
+
+    private String reportConclusion;
+
+    private String reportUrl;
+
+    private Integer reportType=6;
+
+    public CrowdTestProject toCrowdProject() {
+        CrowdTestProject crowdTestProject = CrowdTestProjectFactory.createCrowdTestProject();
+        crowdTestProject.setName(this.name);
+        if (userId == null)
+            userId = 0L;
+        crowdTestProject.setUserId(userId);
+        crowdTestProject.setLinkMan(this.contactName);
+        crowdTestProject.setLinkManMobile(this.contactPhone);
+        crowdTestProject.setStatus(CrowdTestProjectStatus.HAS_FINISHED);
+        crowdTestProject.setType(JSONObject.toJSONString(this.type));
+        crowdTestProject.setPlatform(JSONObject.toJSONString(this.platform));
+        crowdTestProject.setDescription(this.description);
+        crowdTestProject.setRequirementFile(this.doc);
+        crowdTestProject.setProjectFile(this.file);
+        crowdTestProject.setProjectDistributionTypeId(0L);
+        crowdTestProject.setDistributionProvince("");
+        crowdTestProject.setDistributionCity("");
+        crowdTestProject.setRegionalManagerId(1L);
+        crowdTestProject.setDeadTime(this.datetime);
+        crowdTestProject.setQuotedPrice(this.price);
+        crowdTestProject.setFixedPrice(this.price);
+        return crowdTestProject;
+    }
+
+    public CrowdTestReport getReport() {
+        CrowdTestReport report = CrowdTestProjectFactory.defaultProjectReport();
+        report.setName(this.name + "-测试报告");
+        report.setType(this.reportType);
+        report.setFile(this.reportUrl);
+        report.setDescription("");
+        report.setContent(this.reportContent);
+        report.setConclusion(this.reportConclusion);
+        report.setTestObject("");
+        return report;
+    }
+}

site/src/main/java/com/mooctest/crowd/site/command/ProjectDetailsCommand.java → site/src/main/java/com/mooctest/crowd/site/command/UserUpdateCommand.java

@@ -3,7 +3,7 @@ package com.mooctest.crowd.site.command;
 /**
  * @author: Diors.Po
  * @Email: 171256175@qq.com
- * @date 2019-07-25 14:42
+ * @date 2019-07-27 11:02
  */
-public class ProjectDetailsCommand {
+public class UserUpdateCommand {
 }