Merge branch 'Dev' into 'Test'

Dev

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

Jenkinsfile

@@ -1,26 +0,0 @@
-pipeline {
-    agent any
-    stages {
-        stage('拉取代码') {
-            //拉后端代码
-            steps{
-                echo "[backend] git pull..."
-                git branch: 'Test', credentialsId: '74f4c153-f4fa-4ccd-83c5-1597c8dce407', url: 'ssh://git@git.mooctest.com:1022/crowd-2019/crowd-test-service-backend.git'
-            }
-
-        }
-        stage('Maven构建') {
-            //后端构建
-            steps{
-                echo "[backend] mvn package..."
-                sh 'mvn clean package -DskipTests'
-                //target/mooctest-site-server.jar
-                sh 'cp ./site/target/site-0.0.1-SNAPSHOT.jar ./tool4deploy/'
-            }
-        }
-        stage('发布') {
-            //上传服务器，部署Docker
-            sh 'scp -r ./tool4deploy/ ubuntu@129.211.26.227:~/crowd_service_pre/'
-        }
-    }
-}

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

@@ -1,16 +0,0 @@
-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/configuration/RoleConfiguration.java

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

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

@@ -1,28 +1,22 @@
 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.domainobject.CrowdTestProject;
+import com.mooctest.crowd.domain.domainobject.CrowdTestReport;
+import com.mooctest.crowd.domain.domainobject.CrowdTestTask;
+import com.mooctest.crowd.domain.domainobject.User;
 import com.mooctest.crowd.domain.repository.CrowdTestProjectRepo;
 import com.mooctest.crowd.domain.repository.UserRepo;
-import 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.ArrayList;
+import java.util.Date;
+import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;
@@ -33,7 +27,7 @@ import java.util.regex.PatternSyntaxException;
  */
 
 @RestController
-@RequestMapping("/api/project/")
+@RequestMapping("/project/")
 public class CrowdTestProjectController {
 
     @Autowired
@@ -77,12 +71,14 @@ public class CrowdTestProjectController {
      * @param crowdTestProjectCode
      * @return
      */
-    @RequestMapping(value = "deleteProject/{crowdTestProjectCode}", method = RequestMethod.GET)
-    public String deleteCrowdTestProjectByProjectCode(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode) {
+    @RequestMapping(value = "deleteProject/{userId}/{crowdTestProjectCode}", method = RequestMethod.GET)
+    public String deleteCrowdTestProjectByProjectCode(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode,@PathVariable("userId") Long userId) {
+
+        User user = userRepo.getByID(userId);
         CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
-        CrowdTestProject crowdTestProjectResult = crowdTestProject.removeCrowdTestProject();
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.removeCrowdTestProject(user);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
-        return crowdTestProjectRepo.getAllCrowdTestProject().toString();
+        return "success";
     }
 
     /**
@@ -91,13 +87,15 @@ public class CrowdTestProjectController {
      * @param crowdTestTaskCode
      * @return
      */
-    @RequestMapping(value = "deleteTask/{crowdTestProjectCode}/{crowdTestTaskCode}", method = RequestMethod.GET)
+    @RequestMapping(value = "deleteTask/{userId}/{crowdTestProjectCode}/{crowdTestTaskCode}", method = RequestMethod.GET)
     public String deleteCrowdTestTask(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode,
-                                      @PathVariable("crowdTestTaskCode") String crowdTestTaskCode) {
+                                      @PathVariable("crowdTestTaskCode") String crowdTestTaskCode,
+                                      @PathVariable("userId") Long userId) {
+        User user = userRepo.getByID(userId);
         CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
-        CrowdTestProject crowdTestProjectResult = crowdTestProject.removeCrowdTestTask(crowdTestTaskCode);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.removeCrowdTestTask(crowdTestTaskCode,user);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
-        return crowdTestProjectRepo.getAllCrowdTestProject().toString();
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
 
     /**
@@ -107,14 +105,16 @@ public class CrowdTestProjectController {
      * @param crowdTestReportCode
      * @return
      */
-    @RequestMapping(value = "deleteReport/{crowdTestProjectCode}/{crowdTestTaskCode}/{crowdTestReportCode}", method = RequestMethod.GET)
+    @RequestMapping(value = "deleteReport/{userId}/{crowdTestProjectCode}/{crowdTestTaskCode}/{crowdTestReportCode}", method = RequestMethod.GET)
     public String deleteCrowdTestReport(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode,
                                         @PathVariable("crowdTestTaskCode") String crowdTestTaskCode,
-                                        @PathVariable("crowdTestReportCode") String crowdTestReportCode) {
+                                        @PathVariable("crowdTestReportCode") String crowdTestReportCode,
+                                        @PathVariable("userId") Long userId) {
+        User user = userRepo.getByID(userId);
         CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
-        CrowdTestProject crowdTestProjectResult = crowdTestProject.removeCrowdTestReport(crowdTestTaskCode,crowdTestReportCode);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.removeCrowdTestReport(crowdTestTaskCode,crowdTestReportCode,user);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
-        return crowdTestProjectRepo.getAllCrowdTestProject().toString();
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
 
     /**
@@ -122,12 +122,15 @@ public class CrowdTestProjectController {
      * @param crowdTestProjectCode
      * @return
      */
-    @RequestMapping(value = "deleteProjectReport/{crowdTestProjectCode}", method = RequestMethod.GET)
-    public String deleteCrowdTestReport(@PathVariable("crowdTestProjectCode") String crowdTestProjectCode) {
+    @RequestMapping(value = "deleteProjectReport/{userId}/{crowdTestProjectCode}/{crowdTestProjectReportCode}", method = RequestMethod.GET)
+    public String deleteCrowdTestReport(@PathVariable("userId") Long userId,
+                                        @PathVariable("crowdTestProjectCode") String crowdTestProjectCode,
+                                        @PathVariable("crowdTestProjectReportCode") String crowdTestProjectReportCode) {
+        User user = userRepo.getByID(userId);
         CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
-        CrowdTestProject crowdTestProjectResult = crowdTestProject.removeCrowdTestProjectReport();
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.removeCrowdTestProjectReport(crowdTestProjectReportCode,user);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
-        return crowdTestProjectRepo.getAllCrowdTestProject().toString();
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
 
 
@@ -155,7 +158,7 @@ public class CrowdTestProjectController {
         Gson gson = new Gson();
         crowdTestProjectModify = gson.fromJson(gson.toJson(crowdTestProject), CrowdTestProject.class);
         crowdTestProjectModify.setLinkMan(linkMan);
-        CrowdTestProject updateCrowdTestProject = crowdTestProject.updateCrowdTestProject(crowdTestProject, crowdTestProjectModify);
+        CrowdTestProject updateCrowdTestProject = crowdTestProject.updateCrowdTestProject(crowdTestProjectModify);
         crowdTestProjectRepo.saveCrowdTestProject(updateCrowdTestProject);
     }
 
@@ -174,7 +177,7 @@ public class CrowdTestProjectController {
             }
         }
         crowdTestTaskModify.setName(taskName);
-        CrowdTestProject updateCrowdTestProject = crowdTestProject.updateCrowdTestTask(crowdTestProject, crowdTestTaskCode, crowdTestTaskModify);
+        CrowdTestProject updateCrowdTestProject = crowdTestProject.updateCrowdTestTask(crowdTestTaskCode, crowdTestTaskModify);
         crowdTestProjectRepo.saveCrowdTestProject(updateCrowdTestProject);
     }
 
@@ -194,7 +197,7 @@ public class CrowdTestProjectController {
             }
         }
         crowdTestReportModify.setName(reportName);
-        CrowdTestProject updateCrowdTestProject = crowdTestProject.updateCrowdTestReport(crowdTestProject, crowdTestTaskCode, crowdTestReportCode, crowdTestReportModify);
+        CrowdTestProject updateCrowdTestProject = crowdTestProject.updateCrowdTestReport(crowdTestTaskCode, crowdTestReportCode, crowdTestReportModify);
         crowdTestProjectRepo.saveCrowdTestProject(updateCrowdTestProject);
     }
 
@@ -213,13 +216,19 @@ public class CrowdTestProjectController {
         crowdTestProject.setName(projectName);
         crowdTestProject.setProjectDistributionTypeId(1L);
         crowdTestProject.setLinkMan("郭超");
+        crowdTestProject.setPlatform("IOS");
+        crowdTestProject.setType("安卓测试");
+        crowdTestProject.setDescription("测试内容");
         crowdTestProject.setLinkManMobile("13657094936");
         crowdTestProject.setQuotedPrice(200.00);
         crowdTestProject.setDeadTime(new Timestamp(getNextDay(new Date(System.currentTimeMillis()),1).getTime()));
-        crowdTestProject.setCreateTime(new Timestamp(System.currentTimeMillis()));
 
         User user = userRepo.getByID(userId);
-        CrowdTestProject crowdTestProjectResult = user.createCrowdTestProject(crowdTestProject);
+        crowdTestProject.setUserId(user.getId());
+        crowdTestProject.setDistributionProvince(user.getProvince());
+        crowdTestProject.setDistributionCity(user.getCity());
+
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.createCrowdTestProject(user);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
@@ -234,7 +243,7 @@ public class CrowdTestProjectController {
     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);
+        CrowdTestProject  crowdTestProjectResult = crowdTestProject.releaseCrowdTestProject(user);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
@@ -244,25 +253,28 @@ public class CrowdTestProjectController {
      * 对区域管理员的操作
      */
 
+
     /**
      * 接收项目（区域管理员）
-     * @param regionalManagerId
+     * @param userForRegionalManagerId
      * @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();
-
+    @RequestMapping(value = "receiveProject/{userForRegionalManagerId}/{crowdTestProjectCode}", method = RequestMethod.GET)
+    public String receiveTaskByProjectCode(@PathVariable("userForRegionalManagerId") Long userForRegionalManagerId, @PathVariable("crowdTestProjectCode") String crowdTestProjectCode) {
         CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
 
-        CrowdTestProject crowdTestProjectResult = regionalManager.receiveProject(crowdTestProject);
+        User userForRegionalManager = userRepo.getByID(userForRegionalManagerId);
+//        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
+//        CrowdTestProject crowdTestProjectResult = regionalManager.receiveProject(crowdTestProject);
+
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.receiveProject(userForRegionalManager);
+        crowdTestProjectResult.setRegionalManagerId(userForRegionalManagerId);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProject);
         return crowdTestProjectResult.toString();
-
     }
 
+
     /**
      * 项目中新建任务（区域管理员拆分项目）
      * @param crowdTestProjectCode
@@ -271,22 +283,27 @@ public class CrowdTestProjectController {
      */
     @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.setType("接口测试");
+        crowdTestTask.setDescription("测试任务");
+        crowdTestTask.setDistributionType(0L);
         crowdTestTask.setQuotedPrice(200.00);
         crowdTestTask.setDeadTime(new Timestamp(getNextDay(new Date(System.currentTimeMillis()),1).getTime()));
         crowdTestTask.setCreateTime(new Timestamp(System.currentTimeMillis()));
 
         //具体操作
-        User userForRegionalManager = userRepo.getByID(regionalManagerId);
-        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
 
-        CrowdTestProject crowdTestProjectResult = regionalManager.createCrowdTestTask(crowdTestProject, crowdTestTask);
+        User userForRegionalManager = userRepo.getByID(regionalManagerId);
+//        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
+//        CrowdTestProject crowdTestProjectResult = regionalManager.createCrowdTestTask(crowdTestProject, crowdTestTask);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.createCrowdTestTask(crowdTestTask, userForRegionalManager);
+        crowdTestTask.setDistributionProvince(crowdTestProject.getDistributionProvince());
+        crowdTestTask.setDistributionCity(crowdTestProject.getDistributionCity());
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
@@ -300,10 +317,8 @@ public class CrowdTestProjectController {
     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);
+        User user = userRepo.getByID(regionalManagerId);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.releaseCrowdTestTask(crowdTestTaskCode, user);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
@@ -325,8 +340,10 @@ public class CrowdTestProjectController {
         CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
 
         User userForEvaluationAgency = userRepo.getByID(userForEvaluationAgencyId);
-        CrowdTestProject crowdTestProjectResult = userForEvaluationAgency.receiveTask(crowdTestProject, crowdTestTaskCode);
-        System.out.println(crowdTestProjectResult);
+//        CrowdTestProject crowdTestProjectResult = userForEvaluationAgency.receiveTask(crowdTestProject, crowdTestTaskCode);
+
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.receiveTask(crowdTestTaskCode, userForEvaluationAgency);
+
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
@@ -341,17 +358,18 @@ public class CrowdTestProjectController {
     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()));
 
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
         User userForEvaluationAgency = userRepo.getByID(userForEvaluationAgencyId);
-        CrowdTestProject crowdTestProjectResult = userForEvaluationAgency.createCrowdTestReport(crowdTestProject, crowdTestTaskCode, crowdTestReport);
+//        CrowdTestProject crowdTestProjectResult = userForEvaluationAgency.createCrowdTestReport(crowdTestProject, crowdTestTaskCode, crowdTestReport);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.createCrowdTestReport(crowdTestTaskCode, crowdTestReport, userForEvaluationAgency);
+
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
@@ -369,7 +387,10 @@ public class CrowdTestProjectController {
 
         CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
         User userForEvaluationAgency = userRepo.getByID(userForEvaluationAgencyId);
-        CrowdTestProject crowdTestProjectResult = userForEvaluationAgency.commitCrowdTestTask(crowdTestProject, crowdTestTaskCode);
+//        CrowdTestProject crowdTestProjectResult = userForEvaluationAgency.commitCrowdTestTask(crowdTestProject, crowdTestTaskCode);
+
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.commitCrowdTestTask(crowdTestTaskCode, userForEvaluationAgency);
+
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
@@ -384,13 +405,12 @@ public class CrowdTestProjectController {
      * @param crowdTestProjectCode
      * @return
      */
-    @RequestMapping(value = "finishTask/{regionalManagerId}/{crowdTestProjectCode}", method = RequestMethod.GET)
-    public String commitCrowdTestTask(@PathVariable("regionalManagerId") Long regionalManagerId,@PathVariable("crowdTestProjectCode") String crowdTestProjectCode){
+    @RequestMapping(value = "finishTask/{regionalManagerId}/{crowdTestProjectCode}/{crowdTestTaskCode}", method = RequestMethod.GET)
+    public String commitCrowdTestTask(@PathVariable("regionalManagerId") Long regionalManagerId,@PathVariable("crowdTestProjectCode") String crowdTestProjectCode,
+                                      @PathVariable("crowdTestTaskCode") String crowdTestTaskCode){
         CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
-        User userForRegionalManager = userRepo.getByID(regionalManagerId);
-        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
-
-        CrowdTestProject crowdTestProjectResult = regionalManager.finishCrowdTestTask(crowdTestProject);
+        User user = userRepo.getByID(regionalManagerId);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.finishCrowdTestTask(crowdTestTaskCode,user);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
@@ -415,10 +435,10 @@ public class CrowdTestProjectController {
         crowdTestReport.setCreateTime(new Timestamp(System.currentTimeMillis()));
 
         User userForRegionalManager = userRepo.getByID(regionalManagerId);
-        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
-
-        CrowdTestProject crowdTestProjectResult = regionalManager.createCrowdTestProjectReport(crowdTestProject, crowdTestReport);
+//        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
+//        CrowdTestProject crowdTestProjectResult = regionalManager.createCrowdTestProjectReport(crowdTestProject, crowdTestReport);
 
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.createCrowdTestProjectReport(crowdTestReport, userForRegionalManager);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
@@ -432,9 +452,9 @@ public class CrowdTestProjectController {
     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);
+//        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
+//        CrowdTestProject crowdTestProjectResult = regionalManager.commitCrowdTestProject(crowdTestProject);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.commitCrowdTestProject(userForRegionalManager);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
@@ -452,208 +472,18 @@ public class CrowdTestProjectController {
     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);
+//        CrowdTestProject crowdTestProjectResult = user.finishCrowdTestProject(crowdTestProject);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.finishCrowdTestProject(user);
         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";
+    @RequestMapping(value = "getNum", method = RequestMethod.GET)
+    public String getNum(){
+        return "项目数：" + crowdTestProjectRepo.getAllProjectNum() + " 任务数：" + crowdTestProjectRepo.getAllTaskNum() + " 报告数：" + crowdTestProjectRepo.getAllReportNum() ;
     }
 
-
-
     /**
      * 计算指定时间的后几天
      */
@@ -751,4 +581,9 @@ public class CrowdTestProjectController {
         Matcher m = p.matcher(str);
         return m.matches();
     }
+
+    @RequestMapping(value = "getAllNum", method = RequestMethod.GET)
+    public String getAllUserNum(){
+        return "用户数：" + userRepo.getAllUserNum() + " 测评机构数：" + userRepo.getAllAgencyNum() + " 测试资源数量：" + userRepo.getAllResourceNum() ;
+    }
 }

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

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

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

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

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

@@ -1,6 +1,9 @@
 package com.mooctest.crowd.domain.dao;
 
 import com.mooctest.crowd.domain.model.CrowdTestProjectPO;
+import com.mooctest.crowd.domain.model.RankInfo;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.CrudRepository;
 
 import javax.transaction.Transactional;
@@ -27,6 +30,13 @@ public interface CrowdTestProjectDao extends CrudRepository<CrowdTestProjectPO,
 
     List<CrowdTestProjectPO> findByRegionalManagerIdAndIsDeleted(Long regionalManagerId, int isDeleted);
 
+    List<CrowdTestProjectPO> findAllByStatusLessThanAndProjectDistributionTypeId(Integer status, Long distribution);
+
+    List<CrowdTestProjectPO> findByStatusLessThanAndProjectDistributionTypeId(Integer status, Long distributionType);
+
+    @Query(value = "SELECT new com.mooctest.crowd.domain.model.RankInfo(SUM(p.quotedPrice), p.userId) FROM CrowdTestProjectPO p where p.status>1 GROUP BY p.userId ORDER BY SUM(p.quotedPrice) DESC")
+    List<RankInfo> findTotalPriceOfUser(Pageable pageable);
+
     @Override
     void delete(CrowdTestProjectPO crowdTestProjectPO);
 

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

@@ -1,6 +1,9 @@
 package com.mooctest.crowd.domain.dao;
 
 import com.mooctest.crowd.domain.model.CrowdTestTaskPO;
+import com.mooctest.crowd.domain.model.RankInfo;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.CrudRepository;
 
 import javax.transaction.Transactional;
@@ -24,6 +27,12 @@ public interface CrowdTestTaskDao extends CrudRepository<CrowdTestTaskPO, Long>
 
     List<CrowdTestTaskPO> findAllByIsDeleted(int isDeleted);
 
+    @Query(value = "SELECT new com.mooctest.crowd.domain.model.RankInfo(SUM(p.quotedPrice), p.evaluationAgencyId) FROM CrowdTestTaskPO p where p.evaluationAgencyId is not null and p.status>1 GROUP BY p.evaluationAgencyId ORDER BY SUM(p.quotedPrice) DESC")
+    List<RankInfo> findTotalPriceOfAgency(Pageable pageable);
+
+    @Query(nativeQuery = true, value = "select * from crowd_test_task where CTT_STATUS=1 and CTT_DISTRIBUTION_TYPE=2 order by CTT_QUOTED_PRICE DESC LIMIT 4")
+    List<CrowdTestTaskPO> findHotTask();
+
     @Override
     void delete(CrowdTestTaskPO crowdTestProjectPO);
 

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

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

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

@@ -15,8 +15,12 @@ public interface EvaluationAgencyDao extends PagingAndSortingRepository<Evaluati
 
     EvaluationAgencyPO findByUserId(Long userId);
 
+    EvaluationAgencyPO findByUserIdAndIsDeleted(Long userId, int deletedStatus);
+
     List<EvaluationAgencyPO> findByIsAuthentication(int isAuthentication);
 
+    List<EvaluationAgencyPO> findByIsAuthenticationIsNot(int isAuthentication);
+
     @Override
     Iterable<EvaluationAgencyPO> findAllById(Iterable<Long> iterable);
 

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

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

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

@@ -12,7 +12,7 @@ public interface RegionalDao extends PagingAndSortingRepository<RegionalPO, Long
 
     Optional<RegionalPO> findById(Long Id);
 
-    RegionalPO findByProvince(String province);
+//    RegionalPO findByProvince(String province);
 
     @Override
     Iterable<RegionalPO> findAllById(Iterable<Long> iterable);

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

@@ -1,33 +0,0 @@
-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/RegionalManagerToRegionalDao.java

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

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

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

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

@@ -27,4 +27,6 @@ public interface UserDao extends PagingAndSortingRepository<UserPO, Long>, JpaSp
 
     UserPO save(UserPO userPo);
 
+    @Override
+    long count();
 }

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

@@ -1,14 +1,13 @@
 package com.mooctest.crowd.domain.domainobject;
 
 import com.google.gson.Gson;
-import com.mooctest.crowd.domain.exception.BaseException;
-import com.mooctest.crowd.domain.exception.CrowdTestProjectException;
+import com.mooctest.crowd.domain.exception.*;
 import lombok.Data;
 
 import java.sql.Timestamp;
 import java.util.ArrayList;
-import java.util.Date;
 import java.util.List;
+import java.util.Optional;
 
 /**
  * @author guochao
@@ -63,39 +62,35 @@ public class CrowdTestProject {
                 ", distributionCity='" + distributionCity + '\'' +
                 ", quotedPrice=" + quotedPrice +
                 ", fixedPrice=" + fixedPrice +
-                ", status='" + status + '\'' +
+                ", status=" + status +
                 ", deadTime=" + deadTime +
                 ", endTime=" + endTime +
-                ", createTime=" + createTime +
                 ", isDeleted=" + isDeleted +
+                ", createTime=" + createTime +
                 ", crowdTestTaskList=" + crowdTestTaskList +
                 ", crowdTestReportForProject=" + crowdTestReportForProject +
                 '}';
     }
 
-
     /**
      * 更新项目信息
-     * @param crowdTestProject
      * @param crowdTestProjectModify
      * @return
      */
-    public CrowdTestProject updateCrowdTestProject(CrowdTestProject crowdTestProject, CrowdTestProject crowdTestProjectModify){
+    public CrowdTestProject updateCrowdTestProject( CrowdTestProject crowdTestProjectModify){
         Gson gson = new Gson();
-        crowdTestProject = gson.fromJson(gson.toJson(crowdTestProjectModify),CrowdTestProject.class);
-        return crowdTestProject;
+        return gson.fromJson(gson.toJson(crowdTestProjectModify),CrowdTestProject.class);
     }
 
     /**
      * 更新项目中的指定任务信息
-     * @param crowdTestProject
      * @param crowdTestTaskCode
      * @param crowdTestTaskModify
      * @return
      */
-    public CrowdTestProject updateCrowdTestTask(CrowdTestProject crowdTestProject, String crowdTestTaskCode, CrowdTestTask crowdTestTaskModify){
+    public CrowdTestProject updateCrowdTestTask(String crowdTestTaskCode, CrowdTestTask crowdTestTaskModify){
         List<CrowdTestTask> crowdTestTaskListNew = new ArrayList<>();
-        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
+        List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
         for(CrowdTestTask crowdTestTaskSelect : crowdTestTaskList){
             List<CrowdTestReport> crowdTestReportList = crowdTestTaskSelect.getCrowdTestReportList();
             if(crowdTestTaskCode.equals(crowdTestTaskSelect.getCode())){
@@ -105,21 +100,20 @@ public class CrowdTestProject {
             crowdTestTaskSelect.setCrowdTestReportList(crowdTestReportList);
             crowdTestTaskListNew.add(crowdTestTaskSelect);
         }
-        crowdTestProject.setCrowdTestTaskList(crowdTestTaskListNew);
-        return crowdTestProject;
+        this.setCrowdTestTaskList(crowdTestTaskListNew);
+        return this;
     }
 
     /**
      * 更新项目中任务的指定报告信息
-     * @param crowdTestProject
      * @param crowdTestTaskCode
      * @param crowdTestReportCode
      * @param crowdTestReportModify
      * @return
      */
-    public CrowdTestProject updateCrowdTestReport(CrowdTestProject crowdTestProject, String crowdTestTaskCode, String crowdTestReportCode, CrowdTestReport crowdTestReportModify) {
+    public CrowdTestProject updateCrowdTestReport( String crowdTestTaskCode, String crowdTestReportCode, CrowdTestReport crowdTestReportModify) {
         List<CrowdTestTask> crowdTestTaskListNew = new ArrayList<>();
-        List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
+        List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
         for(CrowdTestTask crowdTestTaskSelect : crowdTestTaskList){
             List<CrowdTestReport> crowdTestReportListNew = new ArrayList<>();
             if(crowdTestTaskCode.equals(crowdTestTaskSelect.getCode())){
@@ -135,225 +129,559 @@ public class CrowdTestProject {
             crowdTestTaskSelect.setCrowdTestReportList(crowdTestReportListNew);
             crowdTestTaskListNew.add(crowdTestTaskSelect);
         }
-        crowdTestProject.setCrowdTestTaskList(crowdTestTaskListNew);
-        return crowdTestProject;
+        this.setCrowdTestTaskList(crowdTestTaskListNew);
+        return this;
+    }
+
+    /**
+     * 逻辑删除项目（项目发布者）
+     * @return
+     */
+    public CrowdTestProject removeCrowdTestProject(User user) {
+        //判断用户是否认证
+        if(user.getPersonalAuthentication() == null && user.getEnterpriseAuthentication() == null && user.getRegionalManager() == null && user.getEvaluationAgency() == null){
+            throw new CrowdTestProjectException("当前用户未进行认证，无权限对项目操作");
+        }
+        //判断用户是否为项目发起者
+        if(!this.getUserId().equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户无权限发布此项目");
+        }
+
+        this.getCrowdTestTaskList()
+                .stream().forEach(crowdTestTask -> crowdTestTask.removeCrowdTestTask());
+        this.getCrowdTestTaskList()
+                .stream().forEach(crowdTestTask -> crowdTestTask.getCrowdTestReportList().stream().forEach(crowdTestReport -> crowdTestReport.removeCrowdTestReport()));
+
+        CrowdTestReport crowdTestReportForProject = this.getCrowdTestReportForProject();
+        if(crowdTestReportForProject != null){
+            crowdTestReportForProject.removeCrowdTestReport();
+        }
+        this.setIsDeleted(DeletedStatus.isDeleted);
+        return this;
     }
 
     /**
-     * 逻辑删除项目
+     * 逻辑删除任务（区域管理员）
+     * @param crowdTestTaskCode
      * @return
      */
-    public CrowdTestProject removeCrowdTestProject() {
-        if(this.getIsDeleted() == DeletedStatus.isDeleted){
-            throw new CrowdTestProjectException("项目已被删除，不能再次删除");
+    public CrowdTestProject removeCrowdTestTask(String crowdTestTaskCode, User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限对任务进行操作");
+        }
+
+        //判断是否是当前项目的区域管理员
+        if(!this.getRegionalManagerId().equals(user.getId())){
+            throw new CrowdTestTaskException("当前用户没有权限删除此测试任务！");
+        }
+
+        Optional<CrowdTestTask> task = this.getCrowdTestTaskList()
+                .stream().filter(crowdTestTask -> crowdTestTask.getCode().equals(crowdTestTaskCode)).findFirst();
+        if(!task.isPresent()){
+            throw new CrowdTestTaskException("当前项目下没有此测试任务！");
         }else{
-            List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
-            for(CrowdTestTask crowdTestTask : crowdTestTaskList){
-                crowdTestTask.removeCrowdTestTask();
-                List<CrowdTestReport> crowdTestReportList = crowdTestTask.getCrowdTestReportList();
-                for(CrowdTestReport crowdTestReport : crowdTestReportList){
-                    crowdTestReport.removeCrowdTestReport();
+            task.get().removeCrowdTestTask();
+            task.get().getCrowdTestReportList().stream().forEach(crowdTestReport -> crowdTestReport.removeCrowdTestReport());
+        }
+        return this;
+    }
+
+    /**
+     * 逻辑删除报告（测评机构）
+     * @param crowdTestTaskCode
+     * @param crowdTestReportCode
+     * @return
+     */
+    public CrowdTestProject removeCrowdTestReport(String crowdTestTaskCode, String crowdTestReportCode, User user) {
+
+        //判断是否为测评机构
+        EvaluationAgency evaluationAgency = user.getEvaluationAgency();
+        if(evaluationAgency == null){
+            throw new UserNotExistException("当前用户不是测评机构，没有权限操作测试报告");
+        }
+
+        Optional<CrowdTestTask> task = this.getCrowdTestTaskList()
+                .stream().filter(crowdTestTask -> crowdTestTask.getCode().equals(crowdTestTaskCode)).findFirst();
+        if(!task.isPresent()){
+            throw new CrowdTestTaskException("当前项目下没有此测试任务！");
+        }else{
+            //判断是否是当前任务的测评机构
+            if(!task.get().getEvaluationAgencyId().equals(user.getId())){
+                throw new CrowdTestTaskException("当前用户没有权限删除此任务的测试报告！");
+            }else{
+                Optional<CrowdTestReport> report = task.get().getCrowdTestReportList()
+                        .stream().filter(crowdTestReport -> crowdTestReport.getCode().equals(crowdTestReportCode)).findFirst();
+                if(!report.isPresent()){
+                    throw new CrowdTestReportException("当前任务下没有此测试报告！");
+                }else{
+                    report.get().removeCrowdTestReport();
                 }
             }
-            this.setStatus(DeletedStatus.isDeleted);
         }
         return this;
     }
 
+
     /**
-     * 逻辑删除任务
-     * @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();
+    public CrowdTestProject removeCrowdTestProjectReport(String crowdTestProjectReportCode,User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限对项目进行操作");
+        }
+
+        //判断是否是当前项目的区域管理员
+        if(!this.getRegionalManagerId().equals(user.getId())){
+            throw new CrowdTestTaskException("当前用户没有权限删除此测试任务！");
+        }
+
+        CrowdTestReport crowdTestReportForProject = this.getCrowdTestReportForProject();
+        if(crowdTestReportForProject == null){
+            throw new CrowdTestProjectException("当前项目下没有项目报告！");
+        }else if(!crowdTestProjectReportCode.equals(crowdTestReportForProject.getCode())){
+            throw new CrowdTestProjectException("当前项目下没有此项目报告！");
+        }else{
+            crowdTestReportForProject.setIsDeleted(DeletedStatus.isDeleted);
+        }
+        return this;
+    }
+
+    public void addTask(CrowdTestTask task){
+        if (!(this.getStatus() >= CrowdTestProjectStatus.HAS_RECEIVED || this.getStatus()<=CrowdTestTaskStatus.HAS_COMMITED))
+            throw new BaseException("当前阶段不允许创建新任务");
+        this.getCrowdTestTaskList().add(task);
+    }
+
+    public CrowdTestTask getTask(String taskCode){
+        Optional<CrowdTestTask> testTask = this.getCrowdTestTaskList().stream().filter(crowdTestTask -> crowdTestTask.getCode().equals(taskCode)).findFirst();
+        if (!testTask.isPresent())
+            throw new CrowdTestTaskNotExistException();
+        return testTask.get();
+    }
+
+    public CrowdTestReport getTaskReport(String taskCode, String reportCode){
+        Optional<CrowdTestReport> report = getTask(taskCode).getCrowdTestReportList().stream().filter(crowdTestReport -> crowdTestReport.getCode().equals(reportCode)).findFirst();
+        if (!report.isPresent())
+            throw new CrowdTestReportNotExistException();
+        return report.get();
+    }
+
+    /**
+     * 创建测试项目（普通用户）
+     * @return
+     */
+    public CrowdTestProject createCrowdTestProject(User user) {
+//        //判断用户是否认证
+//        if(user.getPersonalAuthentication() == null && user.getEnterpriseAuthentication() == null && user.getRegionalManager() == null && user.getEvaluationAgency() == null){
+//            throw new CrowdTestProjectException("当前用户未进行认证，无权限对项目操作");
+//        }
+        //增加设置项目code ---------需要补上
+//        String projectCode = GenerateFlowCodeUtil.generateFlowCode("PROJ");
+//        this.setCode(projectCode);
+
+        this.setStatus(CrowdTestProjectStatus.HAS_CREATED);
+        this.setCreateTime(new Timestamp(System.currentTimeMillis()));
+        return this;
+    }
+
+    /**
+     * 发布项目（普通用户）
+     * @return
+     */
+    public CrowdTestProject releaseCrowdTestProject(User user) {
+        //判断用户是否认证
+        if(user.getPersonalAuthentication() == null && user.getEnterpriseAuthentication() == null && user.getRegionalManager() == null && user.getEvaluationAgency() == null){
+            throw new CrowdTestProjectException("当前用户未进行认证，无权限对项目操作");
+        }
+        //判断用户是否为项目发起者
+        if(!this.getUserId().equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户无权限发布此项目");
+        }
+
+        //判断项目状态
+        if(this.status != (CrowdTestProjectStatus.HAS_RELEASED-1)){
+            throw new CrowdTestProjectException("当前项目状态不能被发布，当前状态为："+this.getStatus());
+        }else{
+            this.setStatus(CrowdTestProjectStatus.HAS_RELEASED);
+        }
+        return this;
+    }
+
+    /**
+     * 接收项目（区域管理员）
+     * @return
+     */
+    public CrowdTestProject receiveProject(User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限接收项目");
+        }
+
+        //判断项目状态
+        if(this.getStatus() != CrowdTestProjectStatus.HAS_RELEASED){
+            throw new CrowdTestProjectException("项目不能被接收，项目状态为: " + this.getStatus());
+        }else{
+            //项目是定向发布
+            if(this.getProjectDistributionTypeId() == 0){
+                if(!this.getRegionalManagerId().equals(user.getId())){
+                    throw new CrowdTestProjectException("当前用户没有权限接收此定向发布的项目！");
+                }else{
+                    this.setStatus(CrowdTestProjectStatus.HAS_RECEIVED);
+                }
+            }
+            //项目是区域发布
+            else if(this.getProjectDistributionTypeId() == 1){
+                List<RegionalManagerToRegional> regionalList = regionalManager.getRegionalList();
+                boolean isValidCity = false;
+                //判断管理员管辖的区域是否符合要求
+                for(RegionalManagerToRegional regional : regionalList){
+                    //判断市是否相同
+                    if(this.getDistributionCity().equals(regional.getCity())){
+                        isValidCity = true;
+                    }
+                    //如果市区是"*",则判断省份是否相同
+                    if(regional.getCity().equals("*")){
+                        if(this.getDistributionProvince().equals(regional.getProvince())){
+                            isValidCity = true;
+                        }
+                    }
+                }
+
+                if(!isValidCity){
+                    throw new CrowdTestProjectException("项目发布的区域不符合当前区域管理员所管辖的区域！");
+                }else{
+                    this.setRegionalManagerId(user.getId());
+                    this.setStatus(CrowdTestProjectStatus.HAS_RECEIVED);
                 }
             }
+            //项目是广场发布
+            else{
+                this.setRegionalManagerId(user.getId());
+                this.setStatus(CrowdTestProjectStatus.HAS_RECEIVED);
+            }
+        }
+        return this;
+    }
+
+    /**
+     * 创建测试任务（区域管理员）
+     * @param crowdTestTask
+     * @return
+     */
+    public CrowdTestProject createCrowdTestTask(CrowdTestTask crowdTestTask, User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限创建测试任务");
         }
 
-        boolean judgeHasCrowdTestTask = false;
-        for(CrowdTestTask crowdTestTask : this.getCrowdTestTaskList()){
-            if(crowdTestTask.getIsDeleted() == DeletedStatus.isNotDeleted){
-                judgeHasCrowdTestTask = true;
+        //判断是否是当前项目的区域管理员
+        if(!this.getRegionalManagerId().equals(user.getId())){
+            throw new CrowdTestTaskException("当前用户没有权限为此项目创建测试任务！");
+        }else{
+            //判断项目状态
+            if(this.getStatus() != (CrowdTestProjectStatus.HAS_COMMITED-1)){
+                throw new CrowdTestProjectException("当前项目状态不能创建任务，项目状态为: " + this.getStatus());
+            }else{
+                List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
+//            //增加设置任务code -------需要加上
+//            String taskCode = GenerateFlowCodeUtil.generateFlowCode("TASK-"+ command.getType());
+//            crowdTestTask.setCode(taskCode);
+
+                crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_CREATED);
+                //添加测试任务
+                crowdTestTaskList.add(crowdTestTask);
+                this.setCrowdTestTaskList(crowdTestTaskList);
             }
         }
+        return this;
+    }
+
+    /**
+     * 发布任务（区域管理员）
+     * @param crowdTestTaskCode
+     * @return
+     */
+    public CrowdTestProject releaseCrowdTestTask(String crowdTestTaskCode, User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限发布测试任务");
+        }
 
-        // 如果删除任务后，项目中不存在任务，把项目状态从HAS_SPLITED改为HAS_RECEIVED
-        if(!judgeHasCrowdTestTask){
-            this.setStatus(CrowdTestProjectStatus.HAS_RECEIVED);
+        //判断是否是当前项目的区域管理员
+        if(!this.regionalManagerId.equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户没有权限发布的当前项目下的任务！");
+        }else {
+            List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
+            List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
+            //发布任务时修改任务状态
+            for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+                if(crowdTestTaskCode.equals(crowdTestTask.getCode())){
+                    if(crowdTestTask.getStatus() != (CrowdTestTaskStatus.HAS_RELEASED-1)){
+                        throw new CrowdTestTaskException("当前任务不能被发布，当前任务状态为："+crowdTestTask.getStatus());
+                    }else{
+                        crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_RELEASED);
+                    }
+                }
+                crowdTestTaskListResult.add(crowdTestTask);
+            }
+            this.setCrowdTestTaskList(crowdTestTaskListResult);
+            return this;
         }
+    }
+
+    /**
+     * 接收任务（测评机构）
+     * @return
+     */
+    public CrowdTestProject receiveTask(String crowdTestTaskCode, User user) {
+        //判断是否为测评机构
+        EvaluationAgency evaluationAgency = user.getEvaluationAgency();
+        if(evaluationAgency == null){
+            throw new UnauthorizedException("当前用户不是测评机构，没有权限接收任务");
+        }
+        Optional<CrowdTestTask> taskOp = this.getCrowdTestTaskList().stream().filter(task -> task.getCode().equals(crowdTestTaskCode)).findFirst();
+        //任务是否不存在
+        if (!taskOp.isPresent())
+            throw new CrowdTestTaskNotExistException();
+        CrowdTestTask task = taskOp.get();
+        //任务当前状态
+        if (task.getStatus()!=CrowdTestTaskStatus.HAS_RELEASED)
+            throw new CrowdTestTaskException("任务当前状态不能被接收，当前状态为："+task.getStatus());
+        //定向发布类型
+        if (task.getDistributionType() == 0) {
+            if (!task.getEvaluationAgencyId().equals(user.getId()))
+                throw new CrowdTestTaskException("当前用户没有权限接收此定向发布的任务！");
+        }
+        task.setEvaluationAgencyId(user.getId());
+        task.setStatus(CrowdTestTaskStatus.HAS_RECEIVED);
         return this;
     }
 
+
+
     /**
-     * 逻辑删除报告
+     * 创建测试报告（测评机构）
      * @param crowdTestTaskCode
-     * @param crowdTestReportCode
+     * @param crowdTestReport
      * @return
      */
-    public CrowdTestProject removeCrowdTestReport(String crowdTestTaskCode, String crowdTestReportCode) {
+    public CrowdTestProject createCrowdTestReport(String crowdTestTaskCode, CrowdTestReport crowdTestReport, User user) {
+        //判断是否为测评机构
+        EvaluationAgency evaluationAgency = user.getEvaluationAgency();
+        if(evaluationAgency == null){
+            throw new UserNotExistException("当前用户不是测评机构，没有权限创建测试报告");
+        }
         List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
+        List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
         for(CrowdTestTask crowdTestTask : crowdTestTaskList){
-            if(crowdTestTaskCode.equals(crowdTestTask.getCode())){
-                List<CrowdTestReport> crowdTestReportList = crowdTestTask.getCrowdTestReportList();
-                for(CrowdTestReport crowdTestReport : crowdTestReportList){
-                    if(crowdTestReportCode.equals(crowdTestReport.getCode())){
-                        crowdTestReport.removeCrowdTestReport();
+            if(crowdTestTask.getCode().equals(crowdTestTaskCode)){
+                //判断是否是当前任务的测评机构
+                if(!crowdTestTask.getEvaluationAgencyId().equals(user.getId())){
+                    throw new CrowdTestTaskException("当前用户没有权限创建任务测试报告！");
+                }else{
+                    if(crowdTestTask.getStatus() != (CrowdTestTaskStatus.HAS_COMMITED-1)){
+                        throw new CrowdTestTaskException("当前任务无法创建测试报告，任务状态为："+crowdTestTask.getStatus());
+                    }else{
+                        //设置报告code ----------需要添加
+//                        String reportCode = GenerateFlowCodeUtil.generateFlowCode("REPORT");
+//                        crowdTestReport.setCode(reportCode);
+
+                        crowdTestReport.setScope(1);
+                        crowdTestReport.setDependencyCode(crowdTestTaskCode);
+                        List<CrowdTestReport> crowdTestReportList = crowdTestTask.getCrowdTestReportList();
+                        crowdTestReportList.add(crowdTestReport);
+                        crowdTestTask.setCrowdTestReportList(crowdTestReportList);
+                        crowdTestTaskListResult.add(crowdTestTask);
                     }
                 }
             }
         }
+        this.setCrowdTestTaskList(crowdTestTaskListResult);
+        return this;
+    }
 
-        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;
+    /**
+     * 提交测试任务（测评机构）
+     * @param crowdTestTaskCode
+     * @return
+     */
+    public CrowdTestProject commitCrowdTestTask(String crowdTestTaskCode, User user) {
+        //判断是否为测评机构
+        EvaluationAgency evaluationAgency = user.getEvaluationAgency();
+        if(evaluationAgency == null){
+            throw new UserNotExistException("当前用户不是测评机构，没有权限提交测试任务");
+        }
+
+        List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
+        List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
+        for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+            if(crowdTestTask.getCode().equals(crowdTestTaskCode)){
+                //判断是否是当前任务的测评机构
+                if(!crowdTestTask.getEvaluationAgencyId().equals(user.getId())){
+                    throw new CrowdTestTaskException("当前用户没有权限提交任务！");
+                }else{
+                    if(crowdTestTask.getCrowdTestReportList().size() == 0){
+                        throw new CrowdTestTaskException("当前任务中没有报告，不能提交此任务");
+                    }
+                    if(crowdTestTask.getStatus() != (CrowdTestTaskStatus.HAS_COMMITED-1)){
+                        throw new CrowdTestTaskException("当前任务无法提交，任务状态为："+crowdTestTask.getStatus());
+                    }else{
+                        crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_COMMITED);
                     }
-                }
-                // 删除报告后，如果任务中不存在报告，把任务状态从HAS_REPORTED改为HAS_RECEIVED
-                if(!judgeHasCrowdTestReport){
-                    crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_RECEIVED);
                 }
             }
+            crowdTestTaskListResult.add(crowdTestTask);
         }
+        this.setCrowdTestTaskList(crowdTestTaskListResult);
         return this;
     }
 
-
     /**
-     * 删除项目报告，并修改项目转态
+     * 结束任务（区域管理员）
      * @return
      */
-    public CrowdTestProject removeCrowdTestProjectReport() {
-        CrowdTestReport crowdTestReportForProject = this.getCrowdTestReportForProject();
-        if(crowdTestReportForProject.getIsDeleted() != DeletedStatus.isNotDeleted){
-            throw new CrowdTestProjectException("项目报告已经被删除，不可重复删除");
-        }else{
-            crowdTestReportForProject.setIsDeleted(DeletedStatus.isDeleted);
+    public CrowdTestProject finishCrowdTestTask(String crowdTestTaskCode, User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限结束测试任务");
         }
 
-        if(CrowdTestProjectStatus.HAS_REPORTED == this.getStatus()){
-            this.setStatus(CrowdTestProjectStatus.HAS_SPLITED);
-        }else{
-            throw new CrowdTestProjectException("项目当前状态不可进行报告删除，当前状态为："+this.getStatus());
+        //判断是否是当前项目的区域管理员
+        if(!this.regionalManagerId.equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户没有权限结束当前项目下的任务！");
         }
+
+        //项目状态判断
+        if(this.getStatus() != (CrowdTestProjectStatus.HAS_COMMITED-1)){
+            throw new CrowdTestProjectException("当前项目状态不可结束任务！");
+        }else {
+            List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
+            List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
+
+            for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+                if(crowdTestTaskCode.equals(crowdTestTask.getCode())){
+                    if(crowdTestTask.getStatus() != (CrowdTestTaskStatus.HAS_FINISHED-1)){
+                        throw new CrowdTestTaskException("当前任务不能被结束，任务状态为："+crowdTestTask.getStatus());
+                    }else{
+                        //结束任务时修改任务状态为"已结束"
+                        crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_FINISHED);
+                        crowdTestTask.setEndTime(new Timestamp(System.currentTimeMillis()));
+                    }
+                }
+                crowdTestTaskListResult.add(crowdTestTask);
+            }
+
+            this.setCrowdTestTaskList(crowdTestTaskListResult);
+        }
+
+
         return this;
     }
 
-    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);
+    /**
+     * 创建项目报告（区域管理员）
+     * @param crowdTestReport
+     * @return
+     */
+    public CrowdTestProject createCrowdTestProjectReport(CrowdTestReport crowdTestReport, User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限创建项目报告");
+        }
+
+        //判断是否是当前项目的区域管理员
+        if(!this.regionalManagerId.equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户没有权限创建项目报告！");
+        }
+        //项目状态判断
+        if(this.getStatus() != (CrowdTestProjectStatus.HAS_COMMITED-1)){
+            throw new CrowdTestProjectException("当前项目状态不可创建项目报告！状态为："+this.getStatus());
+        }else{
+            crowdTestReport.setScope(0);
+            crowdTestReport.setDependencyCode(this.getCode());
+            this.setCrowdTestReportForProject(crowdTestReport);
+            return this;
+        }
     }
 
     /**
-     * 设置任务和报告的数据
+     * 提交项目（区域管理员）
      * @return
      */
-    public CrowdTestProject 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.setCrowdTestReportList(crowdTestReportList);
-            crowdTestTaskList.add(crowdTestTask);
-        }
-        //初始化项目报告
-        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);
+    public CrowdTestProject commitCrowdTestProject(User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限提交项目");
+        }
 
+        //判断是否是当前项目的区域管理员
+        if(!this.regionalManagerId.equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户没有权限操作此项目！");
+        }
+
+        //项目状态判断
+        if(this.getStatus() != CrowdTestProjectStatus.HAS_RECEIVED){
+            throw new CrowdTestProjectException("当前项目状态不可提交项目！状态为："+this.getStatus());
+        }
+
+        //判断项目下是否有任务
+        if(this.getCrowdTestTaskList()==null || this.getCrowdTestTaskList().size() < 1){
+            throw new CrowdTestProjectException("还未创建任务，项目不能被提交");
+        }else{
+            //结束项目时查看是否已结束任务
+            if(this.getCrowdTestTaskList().stream().filter(task -> task.getStatus()!=CrowdTestTaskStatus.HAS_REJECTED)
+                    .anyMatch(task -> task.getStatus()!=CrowdTestTaskStatus.HAS_FINISHED)){
+                throw new CrowdTestTaskException("存在未结束的任务，项目不能被提交");
+            }
+        }
+        //判断项目下是否有项目报告
+        if(this.getCrowdTestReportForProject() == null){
+            throw new CrowdTestProjectException("还未创建项目报告，项目不能被提交");
+        }
+        this.setStatus(CrowdTestProjectStatus.HAS_COMMITED);
         return this;
     }
 
     /**
-     * 计算指定时间的后几天
+     * 结束项目（项目发起者）
+     * @return
      */
-    private Date getNextDay(Date date, int day){
-        //计算相关的时间间隔
-        long addTime = 24*3600*1000;
-        addTime *= day;
-        //把时间间隔转换为毫秒数
-        Date nextDate=new Date(date.getTime() + addTime);
-        return nextDate;
+    public CrowdTestProject finishCrowdTestProject(User user) {
+        //判断用户是否认证
+//        if(user.getPersonalAuthentication() == null && user.getEnterpriseAuthentication() == null && user.getRegionalManager() == null && user.getEvaluationAgency() == null){
+//            throw new CrowdTestProjectException("当前用户未进行认证，无权限对项目操作");
+//        }
+        //判断是否为项目发起者
+        if(!this.getUserId().equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户没有权限结束项目!");
+        }
+
+        if(this.getStatus() != CrowdTestProjectStatus.HAS_COMMITED){
+            throw new CrowdTestProjectException("项目不能确认结束，当前状态为："+this.getStatus());
+        }else{
+            this.setStatus(CrowdTestProjectStatus.HAS_FINISHED);
+            this.setEndTime(new Timestamp(System.currentTimeMillis()));
+        }
+        return this;
     }
 
-    /**
-     * 计算指定时间的前几天
-     */
-    private Date getBeforeDay(Date date, int day){
-        //计算相关的时间间隔
-        long subTime = 24*3600*1000;
-        subTime *= day;
-        //把时间间隔转换为毫秒数
-        Date beforeDate=new Date(date.getTime() - subTime);
-        return beforeDate;
+    public void reject(Long userId) {
+        if (this.getProjectDistributionTypeId()!=0
+                || this.getStatus() != CrowdTestProjectStatus.HAS_RELEASED
+                || !this.getRegionalManagerId().equals(userId)){
+            throw new CrowdTestProjectException("非法的操作");
+        }
+        this.setStatus(CrowdTestProjectStatus.HAS_REJECTED);
     }
 }

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

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

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

@@ -15,7 +15,7 @@ public class CrowdTestReport {
     private String name;
     private String code;
     private String dependencyCode; //所依赖的项目或者任务
-    private int type;
+    private String type;
     private int scope;
     private String testObject;
     private String description;

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

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

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

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

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

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

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

@@ -1,8 +1,11 @@
 package com.mooctest.crowd.domain.domainobject;
 
+import com.mooctest.crowd.domain.exception.BaseException;
 import lombok.Data;
+import org.springframework.beans.BeanUtils;
 
 import java.sql.Timestamp;
+import java.util.List;
 
 /**
  * @author guochao
@@ -15,14 +18,16 @@ public class EvaluationAgency {
     private String evaluationAgencyName;
     private String bankAccount;
     private String address;
-    private String abilities;
-    private String resources;
+    private List<EvaluationAgencyAbility> evaluationAgencyAbilityList;
+    private List<EvaluationAgencyResource> evaluationAgencyResourceList;
     private String agencyPhoto;
     private int isAuthentication;
+    private String explain;
     private int isDeleted;
     private Timestamp updateTime;
     private Timestamp expireTime;
-    private Timestamp createTime;
+    private Timestamp checkTime;
+    private Timestamp applyTime;
 
     @Override
     public String toString() {
@@ -32,14 +37,78 @@ public class EvaluationAgency {
                 ", evaluationAgencyName='" + evaluationAgencyName + '\'' +
                 ", bankAccount='" + bankAccount + '\'' +
                 ", address='" + address + '\'' +
-                ", abilities='" + abilities + '\'' +
-                ", resources='" + resources + '\'' +
+                ", evaluationAgencyAbilityList=" + evaluationAgencyAbilityList +
+                ", evaluationAgencyResourceList=" + evaluationAgencyResourceList +
                 ", agencyPhoto='" + agencyPhoto + '\'' +
                 ", isAuthentication=" + isAuthentication +
+                ", explain='" + explain + '\'' +
                 ", isDeleted=" + isDeleted +
                 ", updateTime=" + updateTime +
                 ", expireTime=" + expireTime +
-                ", createTime=" + createTime +
+                ", applyTime=" + applyTime +
+                ", checkTime=" + checkTime +
                 '}';
     }
+
+    public EvaluationAgency applyAuthentication(Long userId) {
+        this.setUserId(userId);
+        this.setIsAuthentication(AuthenticationStatus.isAuthenIng);
+        this.setIsDeleted(DeletedStatus.isNotDeleted);
+        this.setApplyTime(new Timestamp(System.currentTimeMillis()));
+        this.setCheckTime(null);
+        this.setExplain("");
+        return this;
+    }
+
+    public EvaluationAgency passAuthentication() {
+        if(this.getIsAuthentication() == AuthenticationStatus.isNotAuthenticated){
+            throw new BaseException("当前是未通过认证状态，不可通过认证，需对认证信息进行修改后再提交认证申请");
+        }else if(this.getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+            throw new BaseException("当前已通过认证，不可再次进行认证");
+        }else{
+            this.setIsAuthentication(AuthenticationStatus.isAuthenticated);
+            this.setCheckTime(new Timestamp(System.currentTimeMillis()));
+            this.setExplain("");
+            return this;
+        }
+
+    }
+
+    public EvaluationAgency rejectAuthentication(String explain) {
+        if(this.getIsDeleted() == DeletedStatus.isDeleted){
+            throw new BaseException("当前认证信息已被删除，不可做认证状态改变操作");
+        }else {
+            if(this.getIsAuthentication() == AuthenticationStatus.isNotAuthenticated){
+                throw new BaseException("当前已是未通过认证状态，不可再次拒绝认证");
+            }else if(this.getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+                throw new BaseException("当前已通过认证，不可拒绝认证");
+            }else {
+                this.setIsAuthentication(AuthenticationStatus.isNotAuthenticated);
+                this.setExplain(explain);
+                this.setCheckTime(new Timestamp(System.currentTimeMillis()));
+                return this;
+            }
+        }
+    }
+
+    public EvaluationAgency updateAuthInfo(EvaluationAgency modifyAuth) {
+        modifyAuth.userId = this.userId;
+        modifyAuth.id = this.id;
+        BeanUtils.copyProperties(modifyAuth,this);
+        this.setIsAuthentication(AuthenticationStatus.isAuthenIng);
+        this.setIsDeleted(DeletedStatus.isNotDeleted);
+        this.setIsAuthentication(AuthenticationStatus.isAuthenIng);
+        this.setApplyTime(new Timestamp(System.currentTimeMillis()));
+        this.setCheckTime(null);
+        this.setExplain("");
+        return this;
+    }
+
+    public EvaluationAgency deleteAuth() {
+        this.isDeleted = DeletedStatus.isDeleted;
+        //删除资源和能力
+        this.getEvaluationAgencyResourceList().stream().forEach(evaluationAgencyResource -> evaluationAgencyResource.deleteResource());
+        this.getEvaluationAgencyAbilityList().stream().forEach(evaluationAgencyAbility -> evaluationAgencyAbility.deleteAbility());
+        return this;
+    }
 }

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

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

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

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

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

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

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

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

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

@@ -9,15 +9,15 @@ import lombok.Data;
 @Data
 public class Regional {
     private Long id;
-    private String province;
-    private String city;
+    private Long provinceCode;
+    private String name;
 
     @Override
     public String toString() {
         return "Regional{" +
                 "id=" + id +
-                ", province='" + province + '\'' +
-                ", city='" + city + '\'' +
+                ", provinceCode=" + provinceCode +
+                ", name='" + name + '\'' +
                 '}';
     }
 }

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

@@ -1,10 +1,7 @@
 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.util.ArrayList;
 import java.util.List;
 
 /**
@@ -15,10 +12,7 @@ import java.util.List;
 public class RegionalManager {
     private Long id;
     private Long userId;
-//    private Long regionalId;
-
-//    private Regional regional;
-    private List<Regional> regionalList;
+    private List<RegionalManagerToRegional> regionalList;
 
     @Override
     public String toString() {
@@ -28,147 +22,4 @@ public class RegionalManager {
                 ", 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 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);
-                }
-            }
-            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);
-        }
-
-        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/RegionalManagerToRegional.java

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

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

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

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

@@ -1,11 +1,10 @@
 package com.mooctest.crowd.domain.domainobject;
 
-import com.mooctest.crowd.domain.exception.CrowdTestProjectException;
-import com.mooctest.crowd.domain.exception.CrowdTestTaskException;
+import com.mooctest.crowd.domain.exception.BaseException;
+import com.mooctest.crowd.domain.exception.SystemAdministratorException;
 import lombok.Data;
 
 import java.sql.Timestamp;
-import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -20,6 +19,7 @@ public class User {
     private String password;
     private String gender;
     private String mobile;
+    private String email;
     private String province;
     private String city;
     private String photoUrl;
@@ -28,8 +28,11 @@ public class User {
     private Timestamp createTime;
 
     private RegionalManager regionalManager;
-    private List<Role> roleList;
     private EvaluationAgency evaluationAgency;
+    private PersonalAuthentication personalAuthentication;
+    private EnterpriseAuthentication enterpriseAuthentication;
+    private SystemAdministratorToUser systemAdministratorToUser;
+    private List<Role> roleList;
 
     @Override
     public String toString() {
@@ -40,6 +43,7 @@ public class User {
                 ", password='" + password + '\'' +
                 ", gender='" + gender + '\'' +
                 ", mobile='" + mobile + '\'' +
+                ", email='" + email + '\'' +
                 ", province='" + province + '\'' +
                 ", city='" + city + '\'' +
                 ", photoUrl='" + photoUrl + '\'' +
@@ -47,208 +51,231 @@ public class User {
                 ", isDeleted=" + isDeleted +
                 ", createTime=" + createTime +
                 ", regionalManager=" + regionalManager +
-                ", roleList=" + roleList +
                 ", evaluationAgency=" + evaluationAgency +
+                ", personalAuthentication=" + personalAuthentication +
+                ", enterpriseAuthentication=" + enterpriseAuthentication +
+                ", systemAdministratorToUser=" + systemAdministratorToUser +
+                ", roleList=" + roleList +
                 '}';
     }
 
     /**
-     * 创建测试项目（普通用户）
-     * @param crowdTestProject
+     * 机构认证——申请
+     * @param evaluationAgency
      * @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;
+    public User applyAgencyAuthentication(EvaluationAgency evaluationAgency) {
+        if (this.getPersonalAuthentication()!=null || this.getEnterpriseAuthentication()!=null || this.getPersonalAuthentication() != null)
+            throw new BaseException("已有认证信息，不可再次认证");
+        this.setEvaluationAgency(evaluationAgency.applyAuthentication(this.id));
+        return this;
     }
 
 
     /**
-     * 发布项目（普通用户）
-     * @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;
+    public User passAgencyAuthApplication(User agencyUser) {
+        //判断是否为系统管理员
+        judgeIsSystemAdministrator();
+
+        EvaluationAgency evaluationAgency = agencyUser.getEvaluationAgency();
+        evaluationAgency.passAuthentication();
+        List<Role> roleList = this.getRoleList();
+        Role role = new Role();
+        role.setId(2L);
+        roleList.add(role);
+        agencyUser.setRoleList(roleList);
+        return agencyUser;
     }
 
     /**
-     * 接收任务（测评机构）
-     * @param crowdTestProject
-     * @param crowdTestTaskCode
+     * 机构认证——驳回，并说明驳回原因
+     * @param explain
      * @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;
+    public User rejectAgencyAuth(User agencyUser, String explain) {
+        //判断是否为系统管理员
+        judgeIsSystemAdministrator();
 
+        EvaluationAgency evaluationAgency = agencyUser.getEvaluationAgency();
+        evaluationAgency.rejectAuthentication(explain);
+        return agencyUser;
     }
 
     /**
-     * 创建测试报告（测评机构）
-     * @param crowdTestTaskCode
-     * @param crowdTestReport
+     * 机构认证——信息修改
+     * @param modifyAuth
      * @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);
+    public User updateAgencyAuthInfo(EvaluationAgency modifyAuth){
+        if (this.getEnterpriseAuthentication()!=null || this.getPersonalAuthentication()!=null)
+            throw new BaseException("已有其他认证信息，不可对认证未企业用户");
+        if (this.getEvaluationAgency().getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+            throw new BaseException("已通过认证，不可修改认证信息");
         }
-        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;
-//    }
+        this.getEvaluationAgency().updateAuthInfo(modifyAuth);
+        return this;
+    }
+
+    /**
+     * 机构认证——删除
+     * @return
+     */
+    public User deleteAgencyAuthInfo() {
+        EvaluationAgency evaluationAgency = this.getEvaluationAgency();
+//        RoleConfiguration roleConfiguration = new RoleConfiguration();
+//        final Long num = roleConfiguration.getGeneralUser();
+        evaluationAgency.deleteAuth();
+        return this;
+    }
+
 
     /**
-     * 提交测试任务
-     * @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);
+    public User applyPersonalAuthentication(PersonalAuthentication personalAuth) {
+        if (this.getPersonalAuthentication()!=null || this.getEnterpriseAuthentication()!=null || this.getEvaluationAgency() != null)
+            throw new BaseException("已有认证信息，不可再次认证");
+        this.setPersonalAuthentication(personalAuth.applyAuthentication(this.id));
+        return this;
+    }
 
+    /**
+     * 个人认证——通过
+     * @return
+     */
+    public User passPersonalAuthApplication(User personalUser) {
+        //判断是否为系统管理员
+        judgeIsSystemAdministrator();
+
+        PersonalAuthentication personalAuth = personalUser.getPersonalAuthentication();
+        personalAuth.passAuthentication();
+        return personalUser;
+    }
+
+    /**
+     * 个人认证——驳回，并说明驳回原因
+     * @param explain
+     * @return
+     */
+    public User personalAuthReject(User personalUser, String explain) {
+        //判断是否为系统管理员
+        judgeIsSystemAdministrator();
+
+        PersonalAuthentication personalAuth = personalUser.getPersonalAuthentication();
+        personalAuth.rejectAuthentication(explain);
+        return personalUser;
+    }
+
+    /**
+     * 个人认证——信息修改
+     * @param modifyAuth
+     * @return
+     */
+    public User updatePersonalAuthInfo(PersonalAuthentication modifyAuth){
+        if (this.getPersonalAuthentication() == null)
+            throw new BaseException("当前用户未申请个人认证，无法修改");
+        if (this.getEvaluationAgency()!=null || this.getEnterpriseAuthentication()!=null)
+            throw new BaseException("已有其他认证信息，不可对个人认证进行操作");
+        if (this.getPersonalAuthentication().getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+            throw new BaseException("已通过认证，不可修改认证信息");
         }
-        crowdTestProject.setCrowdTestTaskList(crowdTestTaskListResult);
-        return crowdTestProject;
+        this.getPersonalAuthentication().updateAuthInfo(modifyAuth);
+        return this;
+    }
+
+    /**
+     * 个人认证——删除
+     * @return
+     */
+    public User deletePersonalAuthInfo() {
+        this.getPersonalAuthentication().deleteAuth();
+        return this;
     }
 
     /**
-     * 结束项目
-     * @param crowdTestProject
+     * 企业认证——申请
      * @return
      */
-    public CrowdTestProject finishCrowdTestProjet(CrowdTestProject crowdTestProject) {
-        if(crowdTestProject.getStatus() != (CrowdTestProjectStatus.HAS_FINISHED - 1)){
-            throw new CrowdTestProjectException("项目不能被提交，当前状态为："+crowdTestProject.getStatus());
+    public User applyEnterpriseAuthentication(EnterpriseAuthentication enterpriseAuth) {
+        if (this.getEvaluationAgency()!=null || this.getPersonalAuthentication()!=null || this.getEnterpriseAuthentication()!=null)
+            throw new BaseException("已有认证信息，不可再次认证");
+        this.setEnterpriseAuthentication(enterpriseAuth.applyAuthentication(this.id));
+        return this;
+    }
+
+    /**
+     * 企业认证——通过
+     * @return
+     */
+    public User passEnterpriseAuthApplication(User enterpriseUser) {
+        //判断是否为系统管理员
+        judgeIsSystemAdministrator();
+
+        EnterpriseAuthentication enterpriseAuth = enterpriseUser.getEnterpriseAuthentication();
+        if(enterpriseAuth.getIsAuthentication() == AuthenticationStatus.isNotAuthenticated){
+            throw new BaseException("当前是未通过认证状态，不可通过认证，需对认证信息进行修改后再提交认证申请");
+        }else if(enterpriseAuth.getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+            throw new BaseException("当前已通过认证，不可再次进行认证");
         }else{
-            crowdTestProject.setStatus(CrowdTestProjectStatus.HAS_FINISHED);
+            enterpriseAuth.passAuthentication();
+            List<Role> roleList = this.getRoleList();
+            Role role = new Role();
+            role.setId(5L);
+            roleList.add(role);
+            enterpriseUser.setRoleList(roleList);
+            return enterpriseUser;
         }
-        return crowdTestProject;
     }
 
+    /**
+     * 企业认证——驳回，并说明驳回原因
+     * @param explain
+     * @return
+     */
+    public User enterpriseAuthReject(User enterpriseUser, String explain) {
+        //判断是否为系统管理员
+        judgeIsSystemAdministrator();
 
-    public User applyAgencyAuthentication(EvaluationAgency evaluationAgency) {
-        evaluationAgency.setUserId(this.id);
-        evaluationAgency.setIsAuthentication(AuthenticationStatus.isAuthenIng);
-        evaluationAgency.setIsDeleted(DeletedStatus.isNotDeleted);
-        this.setEvaluationAgency(evaluationAgency);
+        EnterpriseAuthentication enterpriseAuth = enterpriseUser.getEnterpriseAuthentication();
+        enterpriseAuth.rejectAuthentication(explain);
+        return enterpriseUser;
+    }
+
+    /**
+     * 企业认证——修改
+     * @param modifyAuth
+     * @return
+     */
+    public User updateEnterpriseAuthInfo(EnterpriseAuthentication modifyAuth){
+        if (this.getEnterpriseAuthentication() == null){
+            throw new BaseException("该用户未申请企业认证，无法修改");
+        }
+        if (this.getEvaluationAgency()!=null || this.getPersonalAuthentication()!=null)
+            throw new BaseException("已有其他认证信息，不可对认证未企业用户");
+        if (this.getEnterpriseAuthentication().getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+            throw new BaseException("已通过认证，不可修改认证信息");
+        }
+        this.getEnterpriseAuthentication().updateAuthInfo(modifyAuth);
         return this;
     }
 
-    public User passApplication() {
-        this.getEvaluationAgency().setIsAuthentication(AuthenticationStatus.isAuthenticated);
+    /**
+     * 企业认证——删除
+     * @return
+     */
+    public User deleteEnterpriseAuthInfo() {
+        this.getEnterpriseAuthentication().deleteAuth();
         return this;
     }
+
+    //判断是否为系统管理员
+    private void judgeIsSystemAdministrator(){
+        if(this.getSystemAdministratorToUser() == null){
+            throw new SystemAdministratorException("当前用户不是系统管理员，没有权限进行认证审核操作");
+        }
+    }
 }

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

@@ -17,10 +17,6 @@ import java.util.List;
 @Service
 public class RegisterDService {
 
-//    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);
@@ -36,10 +32,4 @@ public class RegisterDService {
         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});
-//    }
-
 }

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

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

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

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

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

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

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

@@ -9,4 +9,8 @@ public class UnauthorizedException extends BaseException {
     public UnauthorizedException(){
         super("请登录后访问");
     }
+
+    public UnauthorizedException(String msg){
+        super(msg);
+    }
 }

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

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

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

@@ -24,7 +24,7 @@ public class CrowdTestProjectFactory {
         project.setProjectDistributionTypeId(1L);
         project.setDistributionProvince("江苏");
         project.setDistributionCity("南京");
-        project.setRegionalManagerId(1L);
+        project.setRegionalManagerId(99222L);
         project.setUserId(1L);
         project.setProjectFile("");
         project.setRequirementFile("");
@@ -40,8 +40,6 @@ public class CrowdTestProjectFactory {
         task.setStatus(CrowdTestTaskStatus.HAS_FINISHED);
         task.setEvaluationAgencyId(1l);
         task.setDistributionType(0l);
-        task.setDistributionProvince("江苏");
-        task.setDistributionCity("南京");
         return task;
     }
 
@@ -51,4 +49,9 @@ public class CrowdTestProjectFactory {
         report.setIsDeleted(0);
         return report;
     }
+
+    public static CrowdTestTask defaultTask() {
+        CrowdTestTask task = new CrowdTestTask();
+        return task;
+    }
 }

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

@@ -1,6 +1,7 @@
 package com.mooctest.crowd.domain.factory;
 
 import com.mooctest.crowd.domain.domainobject.EvaluationAgency;
+import com.mooctest.crowd.domain.domainobject.Role;
 import com.mooctest.crowd.domain.domainobject.User;
 
 /**

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

@@ -1,6 +1,5 @@
 package com.mooctest.crowd.domain.model;
 
-import cn.afterturn.easypoi.excel.annotation.Excel;
 import lombok.Data;
 
 import javax.persistence.*;
@@ -24,7 +23,6 @@ public class CrowdTestProjectPO implements Serializable {
     @Column(name = "CTP_CODE")
     private String code;
 
-    @Excel(name="项目名称")
     @Column(name = "CTP_NAME")
     private String name;
 
@@ -37,23 +35,18 @@ public class CrowdTestProjectPO implements Serializable {
     @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;
 

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

@@ -29,7 +29,7 @@ public class CrowdTestReportPO {
     private String dependencyCode;
 
     @Column(name = "CTR_TYPE")
-    private int type;
+    private String type;
 
     @Column(name = "CTR_CONTENT")
     private String content;

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

@@ -10,7 +10,8 @@ import java.sql.Timestamp;
  * @date 2019/7/11 14:14
  */
 @Data
-@Entity(name = "crowd_test_task")
+@Entity
+@Table(name = "crowd_test_task")
 public class
 CrowdTestTaskPO {
     @Id
@@ -31,7 +32,7 @@ CrowdTestTaskPO {
     private Long evaluationAgencyId;
 
     @Column(name = "CTT_TYPE")
-    private int type;
+    private String type;
 
     @Column(name = "CTT_DESCRIPTION")
     private String description;

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

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

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

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

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

@@ -30,46 +30,27 @@ public class EvaluationAgencyPO{
     @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_UPDATE_TIME")
+    private Timestamp updateTime;
+
+    @Column(name = "EA_EXPIRE_TIME")
+    private Timestamp expireTime;
+
     @Column(name = "EA_IS_AUTHENTICATION")
     private int isAuthentication;
 
+    @Column(name = "EA_NOT_PASS_EXPLAIN")
+    private String explain;
+
     @Column(name = "EA_IS_DELETED")
     private int isDeleted;
 
-    @Column(name = "EA_UPDATE_TIME")
-    private Timestamp updateTime;
-
-    @Column(name = "EA_EXPIRE_TIME")
-    private Timestamp expireTime;
+    @Column(name = "EA_APPLY_TIME")
+    private Timestamp applyTime;
 
-    @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 +
-                '}';
-    }
+    @Column(name = "EA_CHECK_TIME")
+    private Timestamp checkTime;
 }

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

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

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

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

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

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

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

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

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

@@ -1,35 +0,0 @@
-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/RegionalManagerToRegionalPO.java

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

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

@@ -13,22 +13,22 @@ import javax.persistence.*;
 @Table(name = "regional")
 public class RegionalPO {
     @Id
-    @Column(name = "RL_ID")
+    @Column(name = "R_CODE")
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
-    @Column(name = "RL_PROVINCE")
-    private String province;
+    @Column(name = "R_P_CODE")
+    private Long provinceCode;
 
-    @Column(name = "RL_CITY")
-    private String city;
+    @Column(name = "R_NAME")
+    private String name;
 
     @Override
     public String toString() {
-        return "Regional{" +
+        return "RegionalPO{" +
                 "id=" + id +
-                ", province='" + province + '\'' +
-                ", city='" + city + '\'' +
+                ", provinceCode=" + provinceCode +
+                ", name='" + name + '\'' +
                 '}';
     }
 }

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

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

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

@@ -233,4 +233,16 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
         }
         return crowdTestProjectListResult;
     }
+
+    public long getAllProjectNum(){
+        return crowdTestProjectDao.count();
+    }
+
+    public long getAllTaskNum(){
+        return crowdTestTaskDao.count();
+    }
+
+    public long getAllReportNum(){
+        return crowdTestReportDao.count();
+    }
 }

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

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

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

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

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

@@ -44,10 +44,25 @@ public class UserRepo implements IUserRepo {
     private EvaluationAgencyDao evaluationAgencyDao;
 
     @Autowired
-    private RegionalManagerDao regionalManagerDao;
+    private RegionalManagerToRegionalDao regionalManagerToRegionalDao;
 
     @Autowired
-    private RegionalDao regionalDao;
+    private AgencyResourceDao agencyResourceDao;
+
+    @Autowired
+    private AgencyAbilityDao agencyAbilityDao;
+
+    @Autowired
+    private EvaluationAgencyRepo resourceRepo;
+
+    @Autowired
+    private PersonalAuthenticationDao personalAuthenticationDao;
+
+    @Autowired
+    private EnterpriseAuthenticationDao enterpriseAuthenticationDao;
+
+    @Autowired
+    private SystemAdministratorToUserDao systemAdministratorToUserDao;
 
     private Timestamp currentTime = new Timestamp(System.currentTimeMillis());
 
@@ -55,7 +70,7 @@ public class UserRepo implements IUserRepo {
     public User getByID(Long userId) throws UserNotExistException, RoleNotFoundException {
         Optional<UserPO> userPOOptional = userDao.findById(userId);
         if (!userPOOptional.isPresent()) {
-            throw new UserNotExistException();
+            throw new UserNotExistException("用户不存在");
         }else{
             User user = getUserAndRoleAndPermissionByUserPO(userPOOptional.get());
             return user;
@@ -66,7 +81,7 @@ public class UserRepo implements IUserRepo {
     public User getByMobileNum(String mobileNum) throws UserNotExistException, RoleNotFoundException {
         UserPO userPO = userDao.findByMobile(mobileNum);
         if (userPO == null) {
-            throw new UserNotExistException();
+            throw new UserNotExistException("用户不存在");
         }else {
             User user = getUserAndRoleAndPermissionByUserPO(userPO);
             return user;
@@ -202,20 +217,52 @@ public class UserRepo implements IUserRepo {
             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);
+        if(roleList != null){
+            for(Role role : roleList){
+                if (userToRolePOList.stream().noneMatch(userToRolePO -> userToRolePO.getRoleId().equals(role.getId()))) {
+                    UserToRolePO userToRolePO = new UserToRolePO();
+                    userToRolePO.setRoleId(role.getId());
+                    userToRolePO.setUserId(userPO.getId());
+                    userToRoleDao.save(userToRolePO);
+                }
             }
         }
+
+        /*机构认证保存机构信息*/
         EvaluationAgency evaluationAgency = user.getEvaluationAgency();
         if(evaluationAgency != null){
             EvaluationAgencyPO evaluationAgencyPO = Converter.convert(EvaluationAgencyPO.class, evaluationAgency);
             evaluationAgencyPO.setUserId(userPO.getId());
-            evaluationAgencyDao.save(evaluationAgencyPO);
+            evaluationAgencyPO = evaluationAgencyDao.save(evaluationAgencyPO);
+            List<EvaluationAgencyResource> resources = evaluationAgency.getEvaluationAgencyResourceList();
+            List<EvaluationAgencyAbility> abilities = evaluationAgency.getEvaluationAgencyAbilityList();
+            for (EvaluationAgencyResource resource : resources) {
+                resource.setEvaluationAgencyId(evaluationAgencyPO.getId());
+                resourceRepo.saveEvaluationAgencyResource(resource);
+            }
+            for (EvaluationAgencyAbility ability : abilities) {
+                ability.setEvaluationAgencyId(evaluationAgencyPO.getId());
+                resourceRepo.saveEvaluationAgencyAbility(ability);
+            }
+//            // save测评机构资源
+//            EvaluationAgencyResource evaluationAgencyResource = evaluationAgency.getEvaluationAgencyResource();
+//            if(evaluationAgencyResource != null){
+//                EvaluationAgencyResourcePO evaluationAgencyResourcePO = Converter.convert(EvaluationAgencyResourcePO.class, evaluationAgencyResource);
+//                evaluationAgencyResourcePO.setEvaluationAgencyId(evaluationAgencyPO.getId());
+//                evaluationAgencyResourceDao.save(evaluationAgencyResourcePO);
+//            }
+        }
+
+        /*实名认证保存个人信息*/
+        if(user.getPersonalAuthentication() != null){
+            personalAuthenticationDao.save(Converter.convert(PersonalAuthenticationPO.class, user.getPersonalAuthentication()));
+        }
+
+        /*企业认证保存企业信息*/
+        if(user.getEnterpriseAuthentication() != null){
+            enterpriseAuthenticationDao.save(Converter.convert(EnterpriseAuthenticationPO.class, user.getEnterpriseAuthentication()));
         }
+
         return getByID(userPO.getId());
     }
 
@@ -280,38 +327,71 @@ public class UserRepo implements IUserRepo {
         userResult.setRoleList(roleResultList);
 
         /*获取测评机构信息*/
-        EvaluationAgencyPO evaluationAgencyPO = evaluationAgencyDao.findByUserId(userPO.getId());
+        EvaluationAgencyPO evaluationAgencyPO = evaluationAgencyDao.findByUserIdAndIsDeleted(userPO.getId(), DeletedStatus.isNotDeleted);
         if(evaluationAgencyPO != null){
             EvaluationAgency evaluationAgencyResult = Converter.convert(EvaluationAgency.class, evaluationAgencyPO);
+
+            /*获取测评机构能力*/
+            List<EvaluationAgencyAbilityPO> evaluationAgencyAbilityPOList = agencyAbilityDao.findByEvaluationAgencyIdAndIsDeleted(evaluationAgencyResult.getId(), DeletedStatus.isNotDeleted);
+            List<EvaluationAgencyAbility> evaluationAgencyAbilityList = new ArrayList<>();
+            if(evaluationAgencyAbilityPOList.size() != 0){
+                for(EvaluationAgencyAbilityPO evaluationAgencyAbilityPO : evaluationAgencyAbilityPOList){
+                    EvaluationAgencyAbility evaluationAgencyAbility = Converter.convert(EvaluationAgencyAbility.class, evaluationAgencyAbilityPO);
+                    evaluationAgencyAbilityList.add(evaluationAgencyAbility);
+                }
+            }
+            evaluationAgencyResult.setEvaluationAgencyAbilityList(evaluationAgencyAbilityList);
+
+            /*获取测评机构资源*/
+            List<EvaluationAgencyResourcePO> evaluationAgencyResourcePOList = agencyResourceDao.findByEvaluationAgencyIdAndIsDeleted(evaluationAgencyResult.getId(), DeletedStatus.isNotDeleted);
+            List<EvaluationAgencyResource> evaluationAgencyResourceList = new ArrayList<>();
+            if(evaluationAgencyResourcePOList.size() != 0){
+                for(EvaluationAgencyResourcePO evaluationAgencyResourcePO : evaluationAgencyResourcePOList){
+                    EvaluationAgencyResource evaluationAgencyResource = Converter.convert(EvaluationAgencyResource.class, evaluationAgencyResourcePO);
+                    evaluationAgencyResourceList.add(evaluationAgencyResource);
+                }
+            }
+            evaluationAgencyResult.setEvaluationAgencyResourceList(evaluationAgencyResourceList);
             userResult.setEvaluationAgency(evaluationAgencyResult);
         }
 
+        /*获取个人认证的信息*/
+        PersonalAuthenticationPO personalAuthenticationPO = personalAuthenticationDao.findByUserIdAndIsDeleted(userPO.getId(), DeletedStatus.isNotDeleted);
+        if(personalAuthenticationPO != null){
+            userResult.setPersonalAuthentication(Converter.convert(PersonalAuthentication.class, personalAuthenticationPO));
+        }
+
+        /*获取企业认证的信息*/
+        EnterpriseAuthenticationPO enterpriseAuthenticationPO = enterpriseAuthenticationDao.findByUserIdAndIsDeleted(userPO.getId(), DeletedStatus.isNotDeleted);
+        if(enterpriseAuthenticationPO != null){
+            userResult.setEnterpriseAuthentication(Converter.convert(EnterpriseAuthentication.class, enterpriseAuthenticationPO));
+        }
+
         /*获取区域管理员信息*/
-        List<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);
+        List<RegionalManagerToRegionalPO> regionalManagerToRegionalPOList = regionalManagerToRegionalDao.findByUserIdAndIsDeleted(userPO.getId(), DeletedStatus.isNotDeleted);
+        if(regionalManagerToRegionalPOList.size() > 0){
+            List<RegionalManagerToRegional> regionalList = new ArrayList<>();
+            RegionalManager regionalManager = new RegionalManager();
+            regionalManager.setUserId(userPO.getId());
+            for(RegionalManagerToRegionalPO regionalManagerToRegionalPO : regionalManagerToRegionalPOList){
+                if(regionalManagerToRegionalPO != null){
+                    regionalManager.setId(regionalManagerToRegionalPO.getId());
+                    /*获取区域管理员管理的区域信息*/
+                    RegionalManagerToRegional regionalResult = Converter.convert(RegionalManagerToRegional.class, regionalManagerToRegionalPO);
                     regionalList.add(regionalResult);
-//                    regionalManagerResult.setRegional(regionalResult);
                 }
-//                regionalManagerListResult.add(regionalManagerResult);
+
             }
+            regionalManager.setRegionalList(regionalList);
+            userResult.setRegionalManager(regionalManager);
+        }
 
+        //获取系统管理员信息
+        SystemAdministratorToUserPO systemAdministratorToUserPO = systemAdministratorToUserDao.findByUserIdAndIsDeleted(userPO.getId(), DeletedStatus.isNotDeleted);
+        if(systemAdministratorToUserPO != null){
+            userResult.setSystemAdministratorToUser(Converter.convert(SystemAdministratorToUser.class, systemAdministratorToUserPO));
         }
 
-        regionalManager.setRegionalList(regionalList);
-//        userResult.setRegionalManagerInfo(regionalManagerListResult);
-        userResult.setRegionalManager(regionalManager);
         return userResult;
     }
 
@@ -320,4 +400,16 @@ public class UserRepo implements IUserRepo {
         BeanUtils.copyProperties(roleDao.findByName(roleName), role);
         return role;
     }
+
+    public long getAllUserNum(){
+        return userDao.count();
+    }
+
+    public long getAllAgencyNum(){
+        return evaluationAgencyDao.count();
+    }
+
+    public long getAllResourceNum(){
+        return agencyResourceDao.count();
+    }
 }

core/src/main/resources/application.yml

@@ -30,9 +30,13 @@ 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
+role-list:
+  general-user: 1
+  evaluation-agency: 2
+  regional-manager: 3
+  system-administrator: 4
+  enterprise-user: 5
+
 
 #swagger:
 #  enable: true

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

@@ -1,219 +0,0 @@
-//package com.mooctest.crowd.domain.domainobject;
-//
-//import com.mooctest.crowd.domain.command.AccountCommand;
-//import com.mooctest.crowd.domain.command.LoginCommand;
-//import com.mooctest.crowd.domain.command.ModifyPasswordCommand;
-//import com.mooctest.crowd.domain.exception.AccountNotExistException;
-//import com.mooctest.crowd.domain.exception.PasswordErrorException;
-//import com.mooctest.crowd.domain.repository.AccountUTRepo;
-//import com.mooctest.crowd.domain.repository.IAccountRepo;
-//import org.junit.Test;
-//
-//import java.util.List;
-//
-//import static org.junit.Assert.assertEquals;
-//import static org.junit.Assert.assertTrue;
-//
-///**
-// * @Author: xuexb
-// * @Date: 2019.7.5 14:25
-// */
-//public class AccountTest {
-//
-//    private AccountUTRepo accountUTRepo = new AccountUTRepo();
-//
-//    @Test
-//    public void should_return_true_when_login_success() throws AccountNotExistException, PasswordErrorException {
-//        // arrange
-//        LoginCommand loginCommand = this.getSuccessLoginCommand();
-//        Account account = this.getSuccessAccount();
-//        // action
-//        boolean success = account.login(loginCommand);
-//        // assert
-//        assertTrue(success);
-//    }
-//
-//    @Test(expected = AccountNotExistException.class)
-//    public void should_throw_when_account_not_exist() throws AccountNotExistException {
-//        // arrange
-//        LoginCommand loginCommand = new LoginCommand();
-//        loginCommand.setMobileNum("NOT_EXIST");
-//        IAccountRepo IAccountRepo = new AccountUTRepo();
-//        Account account = IAccountRepo.getByMobileNum(loginCommand.getMobileNum());
-//    }
-//
-//    @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/domainobject/CrowdTestProjectTest.java

@@ -0,0 +1,338 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import com.mooctest.crowd.domain.exception.BaseException;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author guochao
+ * @date 2019-08-14 21:41
+ */
+public class CrowdTestProjectTest {
+    
+    private CrowdTestProject crowdTestProject = new CrowdTestProject();
+    private CrowdTestTask crowdTestTask = new CrowdTestTask();
+    private CrowdTestReport crowdTestReport = new CrowdTestReport();
+    private CrowdTestReport crowdTestProjectReport = new CrowdTestReport();
+    private List<CrowdTestReport> crowdTestReportList = new ArrayList<>();
+    private List<CrowdTestTask> crowdTestTaskList = new ArrayList<>();
+
+    private User user = new User();
+    private RegionalManager regionalManager = new RegionalManager();
+    private EvaluationAgency evaluationAgency = new EvaluationAgency();
+    private Role role = new Role();
+    private List<Role> roleList = new ArrayList<>();
+    private Permission permission = new Permission();
+    private List<Permission> permissionList = new ArrayList<>();
+    private RegionalManagerToRegional regional = new RegionalManagerToRegional();
+    private List<RegionalManagerToRegional> regionalList = new ArrayList<>();
+    private EvaluationAgencyAbility evaluationAgencyAbility = new EvaluationAgencyAbility();
+    private List<EvaluationAgencyAbility> evaluationAgencyAbilityList = new ArrayList<>();
+    private EvaluationAgencyResource evaluationAgencyResource = new EvaluationAgencyResource();
+    private List<EvaluationAgencyResource> evaluationAgencyResourceList = new ArrayList<>();
+    
+    @Before
+    public void before(){
+        //测试项目
+        crowdTestProject.setId(1L);
+        crowdTestProject.setName("慕测科技");
+        crowdTestProject.setCode("PROR-IOS");
+        crowdTestProject.setUserId(1L);
+        crowdTestProject.setRegionalManagerId(1L);
+        crowdTestProject.setProjectDistributionTypeId(1L);
+        crowdTestProject.setType("性能测试");
+        crowdTestProject.setPlatform("IOS");
+        crowdTestProject.setLinkMan("郭超");
+        crowdTestProject.setLinkManMobile("1233343443");
+        crowdTestProject.setDescription("测试IOS应用");
+        crowdTestProject.setRequirementFile("https://mooctestfile.com");
+        crowdTestProject.setProjectFile("https://mooctestfile.com");
+        crowdTestProject.setQuotedPrice(1000.00);
+        crowdTestProject.setFixedPrice(1000.00);
+        crowdTestProject.setDeadTime(new Timestamp(System.currentTimeMillis()));
+        crowdTestProject.setEndTime(new Timestamp(System.currentTimeMillis()));
+        crowdTestProject.setCreateTime(new Timestamp(System.currentTimeMillis()));
+        crowdTestProject.setStatus(0);
+        crowdTestProject.setIsDeleted(0);
+        crowdTestProject.setDistributionProvince("江苏");
+        crowdTestProject.setDistributionCity("南京");
+
+        //测试报告一
+        crowdTestReport.setCode("PROR-IOS-TASK-ONE-RE-ONE");
+        crowdTestReport.setId(1L);
+        crowdTestReport.setDependencyCode(crowdTestTask.getCode());
+        crowdTestReport.setName(crowdTestTask.getName()+"报告一");
+        crowdTestReport.setCreateTime(crowdTestTask.getCreateTime());
+        crowdTestReport.setScope(1);
+        crowdTestReport.setFile(crowdTestTask.getRequirementFile());
+        crowdTestReport.setType(crowdTestTask.getType());
+        crowdTestReport.setContent("测试报告正确");
+        crowdTestReport.setConclusion("测试完美");
+        crowdTestReport.setScope(1);
+        crowdTestReport.setTestObject("test");
+        crowdTestReport.setIsDeleted(0);
+        crowdTestReportList.add(crowdTestReport);
+
+        //测试任务一
+        crowdTestTask.setCode("PROR-IOS-TASK-ONE");
+        crowdTestTask.setId(1L);
+        crowdTestTask.setCrowdTestProjectCode(crowdTestProject.getCode());
+        crowdTestTask.setDistributionProvince(crowdTestProject.getDistributionProvince());
+        crowdTestTask.setDistributionCity(crowdTestProject.getDistributionCity());
+        crowdTestTask.setEvaluationAgencyId(1L);
+        crowdTestTask.setType(crowdTestProject.getType());
+        crowdTestTask.setName(crowdTestProject.getName()+"任务一");
+        crowdTestTask.setDescription(crowdTestProject.getDescription()+"任务一");
+        crowdTestTask.setRequirementFile(crowdTestProject.getRequirementFile());
+        crowdTestTask.setQuotedPrice(crowdTestProject.getQuotedPrice()/2);
+        crowdTestTask.setFixedPrice(crowdTestProject.getFixedPrice()/2);
+        crowdTestTask.setCreateTime(crowdTestProject.getCreateTime());
+        crowdTestTask.setEndTime(crowdTestProject.getEndTime());
+        crowdTestTask.setDeadTime(crowdTestProject.getDeadTime());
+        crowdTestTask.setDescription("测试任务一");
+        crowdTestTask.setStatus(0);
+        crowdTestTask.setIsDeleted(0);
+        crowdTestTaskList.add(crowdTestTask);
+
+        crowdTestTask.setCrowdTestReportList(crowdTestReportList);
+        crowdTestProject.setCrowdTestTaskList(crowdTestTaskList);
+
+        //项目报告
+        crowdTestProjectReport.setCode(crowdTestProject.getCode());
+        crowdTestProjectReport.setId(2L);
+        crowdTestProjectReport.setContent("项目报告正确");
+        crowdTestProjectReport.setConclusion("项目完美");
+        crowdTestProjectReport.setScope(0);
+        crowdTestProjectReport.setIsDeleted(0);
+        crowdTestProject.setCrowdTestReportForProject(crowdTestProjectReport);
+
+        user.setId(1L);
+        user.setName("郭超");
+        user.setEmail("1021172957@qq.com");
+        user.setPassword("123456");
+        user.setMobile("13657094936");
+        user.setProvince("江苏");
+        user.setCity("南京");
+        user.setPhotoUrl("https://mooctest.phone.com");
+        user.setGender("男");
+        user.setUserName("guochao");
+        user.setIsAvailable(1);
+        user.setIsDeleted(DeletedStatus.isNotDeleted);
+
+        permission.setId(1L);
+        permission.setName("查看项目");
+        permission.setOperation("查看项目");
+        permission.setResource("项目");
+        permission.setCreateTime(role.getCreateTime());
+        permissionList.add(permission);
+
+        role.setId(1L);
+        role.setName("generalUser");
+        role.setCreateTime(user.getCreateTime());
+        role.setPermissionList(permissionList);
+        roleList.add(role);
+        user.setRoleList(roleList);
+
+        regional.setProvince("江苏省");
+//        regional.set(user.getCity());
+//        regional.setProvince(user.getProvince());
+        regionalList.add(regional);
+
+        regionalManager.setId(1L);
+        regionalManager.setUserId(user.getId());
+        regionalManager.setRegionalList(regionalList);
+        user.setRegionalManager(regionalManager);
+
+        evaluationAgency.setId(1L);
+        evaluationAgency.setUserId(user.getId());
+        evaluationAgency.setEvaluationAgencyName("测评机构");
+        evaluationAgency.setBankAccount("111111111");
+        evaluationAgency.setAgencyPhoto("https://mooctest.phone.com");
+        evaluationAgency.setAddress(user.getProvince()+user.getCity());
+        evaluationAgency.setIsDeleted(DeletedStatus.isNotDeleted);
+        evaluationAgency.setIsAuthentication(AuthenticationStatus.isAuthenticated);
+        evaluationAgency.setExpireTime(user.getCreateTime());
+        evaluationAgency.setUpdateTime(user.getCreateTime());
+        evaluationAgency.setApplyTime(user.getCreateTime());
+
+        evaluationAgencyAbility.setId(1L);
+        evaluationAgencyAbility.setAbilityName("IOS");
+        evaluationAgencyAbility.setEvaluationAgencyId(evaluationAgency.getId());
+        evaluationAgencyAbilityList.add(evaluationAgencyAbility);
+
+        evaluationAgencyResource.setId(1L);
+        evaluationAgencyResource.setEvaluationAgencyId(evaluationAgency.getId());
+        evaluationAgencyResource.setType("人力资源");
+        evaluationAgencyResourceList.add(evaluationAgencyResource);
+
+        evaluationAgency.setEvaluationAgencyAbilityList(evaluationAgencyAbilityList);
+        evaluationAgency.setEvaluationAgencyResourceList(evaluationAgencyResourceList);
+        user.setEvaluationAgency(evaluationAgency);
+    }
+
+    @Test
+    public void should_return_project_when_update_project() {
+        //arrange
+        CrowdTestProject crowdTestProjectModify = crowdTestProject;
+        crowdTestProjectModify.setCode("Project-Modify");
+        //action
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.updateCrowdTestProject(crowdTestProjectModify);
+        //assert
+        Assert.assertEquals(crowdTestProjectResult.getCode(), crowdTestProjectModify.getCode());
+    }
+
+    @Test
+    public void should_return_project_when_update_task() {
+        //arrange
+        CrowdTestTask crowdTestTaskModify = new CrowdTestTask();
+        crowdTestTaskModify.setCode(crowdTestTask.getCode());
+        crowdTestTaskModify.setName("modify_task");
+        //action
+        CrowdTestProject crowdTestProjectResult = this.crowdTestProject.updateCrowdTestTask(crowdTestTask.getCode(), crowdTestTaskModify);
+        //assert
+        Assert.assertEquals(crowdTestProjectResult.getCrowdTestTaskList().get(0).getName(), crowdTestTaskModify.getName());
+    }
+
+    @Test
+    public void should_return_project_when_update_report() {
+        //arrange
+        CrowdTestReport crowdTestReportModify = new CrowdTestReport();
+        crowdTestReportModify.setCode(crowdTestReport.getCode());
+        crowdTestReportModify.setName("modify_report");
+        //action
+        CrowdTestProject crowdTestProjectResult = this.crowdTestProject.updateCrowdTestReport(crowdTestTask.getCode(), crowdTestReport.getCode(), crowdTestReportModify);
+        //assert
+        Assert.assertEquals(crowdTestProjectResult.getCrowdTestTaskList().get(0).getCrowdTestReportList().get(0).getName(), crowdTestReportModify.getName());
+    }
+
+
+    @Test
+    public void should_return_project_when_remove_project() {
+        //action
+        CrowdTestProject crowdTestProjectResult = this.crowdTestProject.removeCrowdTestProject(user);
+        //assert
+        Assert.assertEquals(crowdTestProjectResult.getIsDeleted(), DeletedStatus.isDeleted);
+    }
+
+    @Test
+    public void should_return_project_when_remove_task() {
+        //arrange
+        this.crowdTestProject.getCrowdTestTaskList().get(0).setIsDeleted(DeletedStatus.isNotDeleted);
+        //action
+        CrowdTestProject crowdTestProjectResult = this.crowdTestProject.removeCrowdTestTask(crowdTestTask.getCode(),user);
+        //assert
+        Assert.assertEquals(crowdTestProjectResult.getCrowdTestTaskList().get(0).getIsDeleted(), DeletedStatus.isDeleted);
+    }
+
+    @Test
+    public void should_return_project_when_remove_task_exist_is_not_deleted() {
+        //arrange
+        this.crowdTestProject.getCrowdTestTaskList().get(0).setIsDeleted(DeletedStatus.isNotDeleted);
+        //测试报告二
+        CrowdTestReport crowdTestReportTwo = new CrowdTestReport();
+        crowdTestReportTwo.setCode("PROR-IOS-TASK-ONE-RE-TWO");
+        crowdTestReportTwo.setIsDeleted(0);
+        crowdTestReportList.add(crowdTestReportTwo);
+
+        //测试任务二
+        CrowdTestTask crowdTestTaskTwo = new CrowdTestTask();
+        crowdTestTaskTwo.setCode("PROR-IOS-TASK-TWO");
+        crowdTestTaskTwo.setIsDeleted(0);
+        crowdTestTaskList.add(crowdTestTaskTwo);
+        crowdTestTask.setCrowdTestReportList(crowdTestReportList);
+        crowdTestProject.setCrowdTestTaskList(crowdTestTaskList);
+        //action
+        CrowdTestProject crowdTestProjectResult = this.crowdTestProject.removeCrowdTestTask(crowdTestTask.getCode(),user);
+        //assert
+        Assert.assertEquals(crowdTestProjectResult.getCrowdTestTaskList().get(0).getIsDeleted(), DeletedStatus.isDeleted);
+    }
+
+    @Test
+    public void should_return_project_when_remove_task_report() {
+        //arrange
+        this.crowdTestProject.getCrowdTestTaskList().get(0).getCrowdTestReportList().get(0).setIsDeleted(DeletedStatus.isNotDeleted);
+
+        //action
+        CrowdTestProject crowdTestProjectResult = this.crowdTestProject.removeCrowdTestReport(crowdTestTask.getCode(), crowdTestReport.getCode(),user);
+        //assert
+        Assert.assertEquals(crowdTestProjectResult.getCrowdTestTaskList().get(0).getCrowdTestReportList().get(0).getIsDeleted(), DeletedStatus.isDeleted);
+    }
+
+
+    @Test
+    public void should_return_project_when_remove_task_report_exist_is_not_deleted() {
+        //arrange
+        this.crowdTestProject.getCrowdTestTaskList().get(0).getCrowdTestReportList().get(0).setIsDeleted(DeletedStatus.isNotDeleted);
+        //测试报告二
+        CrowdTestReport crowdTestReportTwo = new CrowdTestReport();
+        crowdTestReportTwo.setCode("PROR-IOS-TASK-ONE-RE-TWO");
+        crowdTestReportTwo.setIsDeleted(0);
+        crowdTestReportList.add(crowdTestReportTwo);
+
+        //测试任务二
+        CrowdTestTask crowdTestTaskTwo = new CrowdTestTask();
+        crowdTestTaskTwo.setCode("PROR-IOS-TASK-TWO");
+        crowdTestTaskTwo.setIsDeleted(0);
+        crowdTestTaskList.add(crowdTestTaskTwo);
+        crowdTestTask.setCrowdTestReportList(crowdTestReportList);
+        crowdTestProject.setCrowdTestTaskList(crowdTestTaskList);
+        //action
+        CrowdTestProject crowdTestProjectResult = this.crowdTestProject.removeCrowdTestReport(crowdTestTask.getCode(), crowdTestReport.getCode(),user);
+        //assert
+        Assert.assertEquals(crowdTestProjectResult.getCrowdTestTaskList().get(0).getCrowdTestReportList().get(0).getIsDeleted(), DeletedStatus.isDeleted);
+    }
+
+    @Test
+    public void should_return_project_when_remove_project_report() {
+        //arrange
+        crowdTestProject.getCrowdTestReportForProject().setIsDeleted(DeletedStatus.isNotDeleted);
+//        crowdTestProject.setStatus(CrowdTestProjectStatus.HAS_REPORTED);
+        //action
+        CrowdTestProject crowdTestProjectResult = this.crowdTestProject.removeCrowdTestProjectReport(this.crowdTestProjectReport.getCode(),user);
+        //assert
+        Assert.assertEquals(crowdTestProjectResult.getCrowdTestReportForProject().getIsDeleted(),DeletedStatus.isDeleted);
+//        Assert.assertEquals(crowdTestProjectResult.getStatus(),CrowdTestProjectStatus.HAS_SPLITED);
+    }
+
+    @Test
+    public void should_return_project_when_add_task() {
+        //arrange
+        crowdTestProject.setStatus(CrowdTestProjectStatus.HAS_RECEIVED);
+        CrowdTestTask crowdTestTaskTwo = new CrowdTestTask();
+        crowdTestTaskTwo.setCode("PROR-IOS-TASK-TWO");
+        crowdTestTaskTwo.setIsDeleted(0);
+        crowdTestTaskList.add(crowdTestTaskTwo);
+        //action
+        crowdTestProject.addTask(crowdTestTaskTwo);
+    }
+
+    @Test(expected = BaseException.class)
+    public void should_throw_when_add_task() {
+        //arrange
+        CrowdTestTask crowdTestTaskTwo = new CrowdTestTask();
+        crowdTestTaskTwo.setCode("PROR-IOS-TASK-TWO");
+        crowdTestTaskTwo.setIsDeleted(0);
+        crowdTestTaskList.add(crowdTestTaskTwo);
+        //action
+        crowdTestProject.addTask(crowdTestTaskTwo);
+    }
+
+    @Test
+    public void should_return_project_infor_when_get_field() {
+        crowdTestProject.getLinkMan();
+        crowdTestProject.getLinkManMobile();
+        crowdTestProject.getProjectFile();
+        crowdTestProject.getRegionalManagerId();
+        crowdTestProject.getUserId();
+        crowdTestProject.getId();
+        crowdTestProject.getPlatform();
+        crowdTestProject.getProjectDistributionTypeId();
+        crowdTestProject.toString();
+
+    }
+}

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

@@ -0,0 +1,116 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author guochao
+ * @date 2019-08-15 14:49
+ */
+public class CrowdTestReportTest {
+
+    private CrowdTestProject crowdTestProject = new CrowdTestProject();
+    private CrowdTestTask crowdTestTask = new CrowdTestTask();
+    private CrowdTestReport crowdTestReport = new CrowdTestReport();
+    private CrowdTestReport crowdTestProjectReport = new CrowdTestReport();
+    private List<CrowdTestReport> crowdTestReportList = new ArrayList<>();
+    private List<CrowdTestTask> crowdTestTaskList = new ArrayList<>();
+
+
+    @Before
+    public void before(){
+        //测试项目
+        crowdTestProject.setId(1L);
+        crowdTestProject.setName("慕测科技");
+        crowdTestProject.setCode("PROR-IOS");
+        crowdTestProject.setUserId(1L);
+        crowdTestProject.setRegionalManagerId(1L);
+        crowdTestProject.setProjectDistributionTypeId(1L);
+        crowdTestProject.setType("性能测试");
+        crowdTestProject.setPlatform("IOS");
+        crowdTestProject.setLinkMan("郭超");
+        crowdTestProject.setLinkManMobile("1233343443");
+        crowdTestProject.setDescription("测试IOS应用");
+        crowdTestProject.setRequirementFile("https://mooctestfile.com");
+        crowdTestProject.setProjectFile("https://mooctestfile.com");
+        crowdTestProject.setQuotedPrice(1000.00);
+        crowdTestProject.setFixedPrice(1000.00);
+        crowdTestProject.setDeadTime(new Timestamp(System.currentTimeMillis()));
+        crowdTestProject.setEndTime(new Timestamp(System.currentTimeMillis()));
+        crowdTestProject.setCreateTime(new Timestamp(System.currentTimeMillis()));
+        crowdTestProject.setStatus(0);
+        crowdTestProject.setIsDeleted(0);
+        crowdTestProject.setDistributionProvince("江苏");
+        crowdTestProject.setDistributionCity("南京");
+
+        //测试报告一
+        crowdTestReport.setCode("PROR-IOS-TASK-ONE-RE-ONE");
+        crowdTestReport.setId(1L);
+        crowdTestReport.setDependencyCode(crowdTestTask.getCode());
+        crowdTestReport.setName(crowdTestTask.getName()+"报告一");
+        crowdTestReport.setCreateTime(crowdTestTask.getCreateTime());
+        crowdTestReport.setScope(1);
+        crowdTestReport.setFile(crowdTestTask.getRequirementFile());
+        crowdTestReport.setType(crowdTestTask.getType());
+        crowdTestReport.setContent("测试报告正确");
+        crowdTestReport.setConclusion("测试完美");
+        crowdTestReport.setScope(1);
+        crowdTestReport.setTestObject("test");
+        crowdTestReport.setIsDeleted(0);
+        crowdTestReportList.add(crowdTestReport);
+
+        //测试任务一
+        crowdTestTask.setCode("PROR-IOS-TASK-ONE");
+        crowdTestTask.setId(1L);
+        crowdTestTask.setCrowdTestProjectCode(crowdTestProject.getCode());
+        crowdTestTask.setDistributionProvince(crowdTestProject.getDistributionProvince());
+        crowdTestTask.setDistributionCity(crowdTestProject.getDistributionCity());
+        crowdTestTask.setEvaluationAgencyId(1L);
+        crowdTestTask.setType(crowdTestProject.getType());
+        crowdTestTask.setName(crowdTestProject.getName()+"任务一");
+        crowdTestTask.setDescription(crowdTestProject.getDescription()+"任务一");
+        crowdTestTask.setRequirementFile(crowdTestProject.getRequirementFile());
+        crowdTestTask.setQuotedPrice(crowdTestProject.getQuotedPrice()/2);
+        crowdTestTask.setFixedPrice(crowdTestProject.getFixedPrice()/2);
+        crowdTestTask.setCreateTime(crowdTestProject.getCreateTime());
+        crowdTestTask.setEndTime(crowdTestProject.getEndTime());
+        crowdTestTask.setDeadTime(crowdTestProject.getDeadTime());
+        crowdTestTask.setDescription("测试任务一");
+        crowdTestTask.setStatus(0);
+        crowdTestTask.setIsDeleted(0);
+        crowdTestTaskList.add(crowdTestTask);
+
+        crowdTestTask.setCrowdTestReportList(crowdTestReportList);
+        crowdTestProject.setCrowdTestTaskList(crowdTestTaskList);
+
+        //项目报告
+        crowdTestProjectReport.setCode(crowdTestProject.getCode());
+        crowdTestProjectReport.setId(2L);
+        crowdTestProjectReport.setContent("项目报告正确");
+        crowdTestProjectReport.setConclusion("项目完美");
+        crowdTestProjectReport.setScope(0);
+        crowdTestProjectReport.setIsDeleted(0);
+        crowdTestProject.setCrowdTestReportForProject(crowdTestProjectReport);
+    }
+
+    @Test
+    public void should_return_report_detail_when_get_field(){
+        crowdTestReport.getId();
+        crowdTestReport.getConclusion();
+        crowdTestReport.getContent();
+        crowdTestReport.getCreateTime();
+        crowdTestReport.getDependencyCode();
+        crowdTestReport.getScope();
+        crowdTestReport.getTestObject();
+        crowdTestReport.getDescription();
+        crowdTestReport.getFile();
+        crowdTestReport.getType();
+        crowdTestReport.toString();
+
+    }
+
+}

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

@@ -0,0 +1,115 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author guochao
+ * @date 2019-08-15 14:31
+ */
+public class CrowdTestTaskTest {
+
+    private CrowdTestProject crowdTestProject = new CrowdTestProject();
+    private CrowdTestTask crowdTestTask = new CrowdTestTask();
+    private CrowdTestReport crowdTestReport = new CrowdTestReport();
+    private CrowdTestReport crowdTestProjectReport = new CrowdTestReport();
+    private List<CrowdTestReport> crowdTestReportList = new ArrayList<>();
+    private List<CrowdTestTask> crowdTestTaskList = new ArrayList<>();
+
+
+    @Before
+    public void before(){
+        //测试项目
+        crowdTestProject.setId(1L);
+        crowdTestProject.setName("慕测科技");
+        crowdTestProject.setCode("PROR-IOS");
+        crowdTestProject.setUserId(1L);
+        crowdTestProject.setRegionalManagerId(1L);
+        crowdTestProject.setProjectDistributionTypeId(1L);
+        crowdTestProject.setType("性能测试");
+        crowdTestProject.setPlatform("IOS");
+        crowdTestProject.setLinkMan("郭超");
+        crowdTestProject.setLinkManMobile("1233343443");
+        crowdTestProject.setDescription("测试IOS应用");
+        crowdTestProject.setRequirementFile("https://mooctestfile.com");
+        crowdTestProject.setProjectFile("https://mooctestfile.com");
+        crowdTestProject.setQuotedPrice(1000.00);
+        crowdTestProject.setFixedPrice(1000.00);
+        crowdTestProject.setDeadTime(new Timestamp(System.currentTimeMillis()));
+        crowdTestProject.setEndTime(new Timestamp(System.currentTimeMillis()));
+        crowdTestProject.setCreateTime(new Timestamp(System.currentTimeMillis()));
+        crowdTestProject.setStatus(0);
+        crowdTestProject.setIsDeleted(0);
+        crowdTestProject.setDistributionProvince("江苏");
+        crowdTestProject.setDistributionCity("南京");
+
+        //测试报告一
+        crowdTestReport.setCode("PROR-IOS-TASK-ONE-RE-ONE");
+        crowdTestReport.setId(1L);
+        crowdTestReport.setDependencyCode(crowdTestTask.getCode());
+        crowdTestReport.setName(crowdTestTask.getName()+"报告一");
+        crowdTestReport.setCreateTime(crowdTestTask.getCreateTime());
+        crowdTestReport.setScope(1);
+        crowdTestReport.setFile(crowdTestTask.getRequirementFile());
+        crowdTestReport.setType(crowdTestTask.getType());
+        crowdTestReport.setContent("测试报告正确");
+        crowdTestReport.setConclusion("测试完美");
+        crowdTestReport.setScope(1);
+        crowdTestReport.setTestObject("test");
+        crowdTestReport.setIsDeleted(0);
+        crowdTestReportList.add(crowdTestReport);
+
+        //测试任务一
+        crowdTestTask.setCode("PROR-IOS-TASK-ONE");
+        crowdTestTask.setId(1L);
+        crowdTestTask.setCrowdTestProjectCode(crowdTestProject.getCode());
+        crowdTestTask.setDistributionProvince(crowdTestProject.getDistributionProvince());
+        crowdTestTask.setDistributionCity(crowdTestProject.getDistributionCity());
+        crowdTestTask.setEvaluationAgencyId(1L);
+        crowdTestTask.setType(crowdTestProject.getType());
+        crowdTestTask.setName(crowdTestProject.getName()+"任务一");
+        crowdTestTask.setDescription(crowdTestProject.getDescription()+"任务一");
+        crowdTestTask.setRequirementFile(crowdTestProject.getRequirementFile());
+        crowdTestTask.setQuotedPrice(crowdTestProject.getQuotedPrice()/2);
+        crowdTestTask.setFixedPrice(crowdTestProject.getFixedPrice()/2);
+        crowdTestTask.setCreateTime(crowdTestProject.getCreateTime());
+        crowdTestTask.setEndTime(crowdTestProject.getEndTime());
+        crowdTestTask.setDeadTime(crowdTestProject.getDeadTime());
+        crowdTestTask.setDescription("测试任务一");
+        crowdTestTask.setStatus(0);
+        crowdTestTask.setIsDeleted(0);
+        crowdTestTaskList.add(crowdTestTask);
+
+        crowdTestTask.setCrowdTestReportList(crowdTestReportList);
+        crowdTestProject.setCrowdTestTaskList(crowdTestTaskList);
+
+        //项目报告
+        crowdTestProjectReport.setCode(crowdTestProject.getCode());
+        crowdTestProjectReport.setId(2L);
+        crowdTestProjectReport.setContent("项目报告正确");
+        crowdTestProjectReport.setConclusion("项目完美");
+        crowdTestProjectReport.setScope(0);
+        crowdTestProjectReport.setIsDeleted(0);
+        crowdTestProject.setCrowdTestReportForProject(crowdTestProjectReport);
+    }
+    @Test
+    public void should_return_task_detail_when_get_field() {
+        crowdTestTask.getId();
+        crowdTestTask.getQuotedPrice();
+        crowdTestTask.getFixedPrice();
+        crowdTestTask.getRequirementFile();
+        crowdTestTask.getEndTime();
+        crowdTestTask.getDeadTime();
+        crowdTestTask.getCrowdTestProjectCode();
+        crowdTestTask.getDistributionProvince();
+        crowdTestTask.getDistributionCity();
+        crowdTestTask.getDescription();
+        crowdTestTask.getEvaluationAgencyId();
+        crowdTestTask.getDistributionType();
+        crowdTestTask.toString();
+    }
+}

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

@@ -1,154 +0,0 @@
-//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,218 +0,0 @@
-package com.mooctest.crowd.domain.domainobject;
-
-import org.junit.runner.RunWith;
-import org.mockito.runners.MockitoJUnitRunner;
-
-/**
- * @author guochao
- * @date 2019/7/6 18:17
- */
-@RunWith(MockitoJUnitRunner.class)
-public class GeneralUserTest {
-//    @InjectMocks
-//    private  GeneralUser generalUser = new GeneralUser();
-//
-//    @Mock
-//    private CrowdTestProjectRepo testProjectRepo = new CrowdTestProjectRepo();
-//
-////    @Mock
-//    private CrowdTestProject testProject = new CrowdTestProject();
-//
-//    @Before
-//    public void setUp() throws CrowdTestProjectNotExistException {
-//        MockitoAnnotations.initMocks(this);
-//
-//        testProject.setId(1L);
-//        testProject.setName("PROJECT_ONE");
-//        testProject.setDescription("DESCRIPTION");
-//        testProject.setProjectFile(new File("PROJECTFILE.TXT"));
-//        testProject.setRequirement(new File("REQUIREMENT.TXT"));
-//        testProject.setQuotedPrice(200.00);
-//        testProject.setCreatTime(new Date());
-//
-//        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
-////        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 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 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;
-//    }
-}

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

@@ -1,217 +0,0 @@
-//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 +0,0 @@
-//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

@@ -1,233 +1,94 @@
-//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());
-//    }
+package com.mooctest.crowd.domain.domainobject;
 
-//
-//    @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;
-//    }
-//
-//}
+import org.junit.Before;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author guochao
+ * @date 2019-08-15 14:53
+ */
+public class UserTest {
+
+    private User user = new User();
+    private RegionalManager regionalManager = new RegionalManager();
+    private EvaluationAgency evaluationAgency = new EvaluationAgency();
+    private Role role = new Role();
+    private List<Role> roleList = new ArrayList<>();
+    private Permission permission = new Permission();
+    private List<Permission> permissionList = new ArrayList<>();
+    private RegionalManagerToRegional regional = new RegionalManagerToRegional();
+    private List<RegionalManagerToRegional> regionalList = new ArrayList<>();
+    private EvaluationAgencyAbility evaluationAgencyAbility = new EvaluationAgencyAbility();
+    private List<EvaluationAgencyAbility> evaluationAgencyAbilityList = new ArrayList<>();
+    private EvaluationAgencyResource evaluationAgencyResource = new EvaluationAgencyResource();
+    private List<EvaluationAgencyResource> evaluationAgencyResourceList = new ArrayList<>();
+
+    @Before
+    public void before() {
+        user.setId(1L);
+        user.setName("郭超");
+        user.setEmail("1021172957@qq.com");
+        user.setPassword("123456");
+        user.setMobile("13657094936");
+        user.setProvince("江苏");
+        user.setCity("南京");
+        user.setPhotoUrl("https://mooctest.phone.com");
+        user.setGender("男");
+        user.setUserName("guochao");
+        user.setIsAvailable(1);
+        user.setIsDeleted(DeletedStatus.isNotDeleted);
+
+        permission.setId(1L);
+        permission.setName("查看项目");
+        permission.setOperation("查看项目");
+        permission.setResource("项目");
+        permission.setCreateTime(role.getCreateTime());
+        permissionList.add(permission);
+
+        role.setId(1L);
+        role.setName("generalUser");
+        role.setCreateTime(user.getCreateTime());
+        role.setPermissionList(permissionList);
+        roleList.add(role);
+        user.setRoleList(roleList);
+
+        regional.setProvince("江苏省");
+//        regional.set(user.getCity());
+//        regional.setProvince(user.getProvince());
+        regionalList.add(regional);
+
+        regionalManager.setId(1L);
+        regionalManager.setUserId(user.getId());
+        regionalManager.setRegionalList(regionalList);
+        user.setRegionalManager(regionalManager);
+
+        evaluationAgency.setId(1L);
+        evaluationAgency.setUserId(user.getId());
+        evaluationAgency.setEvaluationAgencyName("测评机构");
+        evaluationAgency.setBankAccount("111111111");
+        evaluationAgency.setAgencyPhoto("https://mooctest.phone.com");
+        evaluationAgency.setAddress(user.getProvince()+user.getCity());
+        evaluationAgency.setIsDeleted(DeletedStatus.isNotDeleted);
+        evaluationAgency.setIsAuthentication(AuthenticationStatus.isAuthenticated);
+        evaluationAgency.setExpireTime(user.getCreateTime());
+        evaluationAgency.setUpdateTime(user.getCreateTime());
+        evaluationAgency.setApplyTime(user.getCreateTime());
+
+        evaluationAgencyAbility.setId(1L);
+        evaluationAgencyAbility.setAbilityName("IOS");
+        evaluationAgencyAbility.setEvaluationAgencyId(evaluationAgency.getId());
+        evaluationAgencyAbilityList.add(evaluationAgencyAbility);
+
+        evaluationAgencyResource.setId(1L);
+        evaluationAgencyResource.setEvaluationAgencyId(evaluationAgency.getId());
+        evaluationAgencyResource.setType("人力资源");
+        evaluationAgencyResourceList.add(evaluationAgencyResource);
+
+        evaluationAgency.setEvaluationAgencyAbilityList(evaluationAgencyAbilityList);
+        evaluationAgency.setEvaluationAgencyResourceList(evaluationAgencyResourceList);
+        user.setEvaluationAgency(evaluationAgency);
+
+    }
+}

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

@@ -1,74 +0,0 @@
-//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/CrowdTestProjectRepoTest.java

@@ -0,0 +1,248 @@
+package com.mooctest.crowd.domain.repository;
+
+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.*;
+import com.mooctest.crowd.domain.exception.CrowdTestProjectNotExistException;
+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 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.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class CrowdTestProjectRepoTest {
+
+    @InjectMocks
+    private CrowdTestProjectRepo crowdTestProjectRepo = new CrowdTestProjectRepo();
+
+    @Mock
+    private CrowdTestProjectDao crowdTestProjectDao;
+
+    @Mock
+    private CrowdTestTaskDao crowdTestTaskDao;
+
+    @Mock
+    private CrowdTestReportDao crowdTestReportDao;
+
+    private CrowdTestProjectPO crowdTestProjectPO = new CrowdTestProjectPO();
+    private List<CrowdTestProjectPO> crowdTestProjectPOList = new ArrayList<>();
+    private CrowdTestTaskPO crowdTestTaskPO = new CrowdTestTaskPO();
+    private List<CrowdTestTaskPO> crowdTestTaskPOList = new ArrayList<>();
+    private CrowdTestReportPO crowdTestReportPO = new CrowdTestReportPO();
+    private List<CrowdTestReportPO> crowdTestReportPOList = new ArrayList<>();
+    private CrowdTestReportPO crowdTestProjectReportPO = new CrowdTestReportPO();
+    private List<CrowdTestReportPO> crowdTestProjectReportPOList = new ArrayList<>();
+
+    private User user = new User();
+    private EvaluationAgency evaluationAgency = new EvaluationAgency();
+    private RegionalManager regionalManager = new RegionalManager();
+    private CrowdTestProject crowdTestProject = new CrowdTestProject();
+    private CrowdTestTask crowdTestTask = new CrowdTestTask();
+    private List<CrowdTestTask> crowdTestTaskList = new ArrayList<>();
+    private List<CrowdTestProject> crowdTestProjectList = new ArrayList<>();
+
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+
+        user.setId(1L);
+        user.setName("guochao");
+
+        evaluationAgency.setId(1L);
+        evaluationAgency.setEvaluationAgencyName("慕测科技");
+        evaluationAgency.setUserId(user.getId());
+
+        regionalManager.setId(1L);
+        regionalManager.setUserId(user.getId());
+        user.setEvaluationAgency(evaluationAgency);
+        user.setRegionalManager(regionalManager);
+
+        //测试项目
+        crowdTestProjectPO.setId(1L);
+        crowdTestProjectPO.setCode("PROR-IOS");
+        crowdTestProjectPO.setUserId(user.getId());
+        crowdTestProjectPO.setType("性能测试");
+        crowdTestProjectPO.setPlatform("IOS");
+        crowdTestProjectPO.setLinkMan("郭超");
+        crowdTestProjectPO.setLinkManMobile("1233343443");
+        crowdTestProjectPO.setDescription("测试IOS应用");
+        crowdTestProjectPO.setStatus(0);
+        crowdTestProjectPO.setIsDeleted(0);
+        crowdTestProjectPO.setDistributionProvince("江苏");
+        crowdTestProjectPO.setDistributionCity("南京");
+
+        //测试任务
+        crowdTestTaskPO.setCode("PROR-IOS-TASK-ONE");
+        crowdTestTaskPO.setId(1L);
+        crowdTestTaskPO.setCrowdTestProjectCode(crowdTestProjectPO.getCode());
+        crowdTestTaskPO.setDistributionProvince(crowdTestProjectPO.getDistributionProvince());
+        crowdTestTaskPO.setDistributionCity(crowdTestProjectPO.getDistributionCity());
+        crowdTestTaskPO.setDescription("测试任务一");
+        crowdTestTaskPO.setStatus(0);
+        crowdTestTaskPO.setIsDeleted(0);
+
+        crowdTestTaskPOList.add(crowdTestTaskPO);
+
+
+        //测试报告
+        crowdTestReportPO.setCode("PROR-IOS-TASK-ONE-REPO-ONE");
+        crowdTestReportPO.setId(1L);
+        crowdTestReportPO.setContent("测试报告正确");
+        crowdTestReportPO.setConclusion("测试完美");
+        crowdTestReportPO.setScope(1);
+        crowdTestReportPO.setIsDeleted(0);
+        crowdTestReportPOList.add(crowdTestReportPO);
+
+        //项目报告
+        crowdTestProjectReportPO.setCode("PROR-IOS");
+        crowdTestProjectReportPO.setId(2L);
+        crowdTestProjectReportPO.setContent("项目报告正确");
+        crowdTestProjectReportPO.setConclusion("项目完美");
+        crowdTestProjectReportPO.setScope(0);
+        crowdTestProjectReportPO.setIsDeleted(0);
+        crowdTestProjectReportPOList.add(crowdTestProjectReportPO);
+        crowdTestProjectPOList.add(crowdTestProjectPO);
+
+        //项目DO
+        crowdTestTask.setCrowdTestReportList(crowdTestReportPOList.stream().map(crowdTestReportPO -> Converter.convert(CrowdTestReport.class, crowdTestReportPO)).collect(Collectors.toList()));
+        crowdTestTaskList.add(crowdTestTask);
+        crowdTestProject.setCrowdTestTaskList(crowdTestTaskList);
+        crowdTestProject.setCrowdTestReportForProject(Converter.convert(CrowdTestReport.class, crowdTestProjectReportPO));
+
+        crowdTestProjectList.add(crowdTestProject);
+
+    }
+
+    @Test
+    public void should_return_project_when_get_by_project_id(){
+
+        //arrange
+        when(crowdTestProjectDao.findByIdAndIsDeleted(1L,0)).thenReturn(crowdTestProjectPO);
+        when(crowdTestTaskDao.findByCrowdTestProjectCodeAndIsDeleted("PROR-IOS",0)).thenReturn(crowdTestTaskPOList);
+        when(crowdTestReportDao.findByDependencyCodeAndIsDeleted("PROR-IOS-TASK-ONE",0)).thenReturn(crowdTestReportPOList);
+        when(crowdTestReportDao.findByDependencyCodeAndIsDeleted("PROR-IOS",0)).thenReturn(crowdTestProjectReportPOList);
+        //action
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByID(crowdTestProjectPO.getId());
+
+        //assert
+        Assert.assertEquals(crowdTestProject.getCrowdTestTaskList().get(0).getCrowdTestReportList().get(0).getDescription(),crowdTestReportPO.getDescription());
+    }
+
+    @Test(expected = CrowdTestProjectNotExistException.class)
+    public void should_throw_when_get_by_project_id_not_exist(){
+        //arrange
+        when(crowdTestProjectDao.findByIdAndIsDeleted(1L,0)).thenReturn(null);
+        //action
+        crowdTestProjectRepo.getByID(crowdTestProjectPO.getId());
+    }
+
+    @Test
+    public void should_return_project_when_get_by_project_code(){
+
+        //arrange
+        when(crowdTestProjectDao.findByCodeAndIsDeleted("PROR-IOS",0)).thenReturn(crowdTestProjectPO);
+        when(crowdTestTaskDao.findByCrowdTestProjectCodeAndIsDeleted("PROR-IOS",0)).thenReturn(crowdTestTaskPOList);
+        when(crowdTestReportDao.findByDependencyCodeAndIsDeleted("PROR-IOS-TASK-ONE",0)).thenReturn(crowdTestReportPOList);
+        when(crowdTestReportDao.findByDependencyCodeAndIsDeleted("PROR-IOS",0)).thenReturn(crowdTestProjectReportPOList);
+        //action
+        CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectPO.getCode());
+
+        //assert
+        Assert.assertEquals(crowdTestProject.getCrowdTestTaskList().get(0).getCrowdTestReportList().get(0).getDescription(),crowdTestReportPO.getDescription());
+    }
+
+    @Test(expected = CrowdTestProjectNotExistException.class)
+    public void should_throw_when_get_by_project_code_not_exist(){
+
+        //arrange
+        when(crowdTestProjectDao.findByCodeAndIsDeleted("PROR-IOS",0)).thenReturn(null);
+        //action
+        crowdTestProjectRepo.getByProjectCode(crowdTestProjectPO.getCode());
+    }
+
+    @Test
+    public void should_return_project_list_when_get_by_user_id(){
+
+        //arrange
+        when(crowdTestProjectDao.findByUserIdAndIsDeleted(1L,0)).thenReturn(crowdTestProjectPOList);
+        //action
+        List<CrowdTestProject> crowdTestProjectList = crowdTestProjectRepo.getCrowdListByUserId(user.getId());
+
+        //assert
+        Assert.assertEquals(crowdTestProjectList.get(0).getCode(), crowdTestProjectPOList.get(0).getCode());
+    }
+
+    @Test
+    public void should_return_project_list_when_get_by_regional_manmger_id(){
+
+        //arrange
+        when(crowdTestProjectDao.findByRegionalManagerIdAndIsDeleted(1L,0)).thenReturn(crowdTestProjectPOList);
+        //action
+        List<CrowdTestProject> crowdTestProjectList = crowdTestProjectRepo.getCrowdListByRegionalManagerId(regionalManager.getId());
+
+        //assert
+        Assert.assertEquals(crowdTestProjectList.get(0).getCode(), crowdTestProjectPOList.get(0).getCode());
+    }
+
+    @Test
+    public void should_return_project_list_when_get_all_project(){
+
+        //arrange
+        when(crowdTestProjectDao.findAllByIsDeleted(0)).thenReturn(crowdTestProjectPOList);
+        //action
+        List<CrowdTestProject> crowdTestProjectList = crowdTestProjectRepo.getAllCrowdTestProject();
+
+        //assert
+        Assert.assertEquals(crowdTestProjectList.get(0).getCode(), crowdTestProjectPOList.get(0).getCode());
+    }
+
+    @Test
+    public void should_return_void_when_save_project(){
+
+        //arrange
+        when(crowdTestProjectDao.save(crowdTestProjectPO)).thenReturn(crowdTestProjectPO);
+        when(crowdTestTaskDao.save(crowdTestTaskPO)).thenReturn(crowdTestTaskPO);
+        when(crowdTestReportDao.save(crowdTestReportPO)).thenReturn(crowdTestReportPO);
+        //action
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProject);
+    }
+
+    @Test
+    public void should_return_void_when_remove_project_list(){
+        //action
+        crowdTestProjectRepo.removeCrowdTestProjectList(crowdTestProjectList);
+    }
+
+    @Test
+    public void should_return_void_when_remove_project_by_id(){
+        //arrange
+        when(crowdTestProjectDao.findById(1L)).thenReturn(Optional.of(crowdTestProjectPO));
+        //action
+        crowdTestProjectRepo.deleteByProjectId(crowdTestProjectPO.getId());
+    }
+
+    @Test(expected = CrowdTestProjectNotExistException.class)
+    public void should_throw_when_remove_project_by_id_not_exist(){
+        //arrange
+        when(crowdTestProjectDao.findById(1L)).thenReturn(Optional.empty());
+        //action
+        crowdTestProjectRepo.deleteByProjectId(crowdTestProjectPO.getId());
+    }
+}

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

@@ -2,6 +2,8 @@ package com.mooctest.crowd.domain.repository;
 
 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 org.junit.Assert;
@@ -13,6 +15,7 @@ import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.mockito.runners.MockitoJUnitRunner;
 
+import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Optional;
@@ -38,9 +41,18 @@ public class UserRepoTest {
     @Mock
     private EvaluationAgencyDao evaluationAgencyDao;
     @Mock
-    private RegionalManagerDao regionalManagerDao;
+    private RegionalManagerToRegionalDao regionalManagerToRegionalDao;
     @Mock
     private RegionalDao regionalDao;
+    @Mock
+    private AgencyAbilityDao agencyAbilityDao;
+    @Mock
+    private AgencyResourceDao agencyResourceDao;
+    @Mock
+    private PersonalAuthenticationDao personalAuthenticationDao;
+
+    @Mock
+    private EvaluationAgencyRepo resourceRepo;
 
     private UserPO expectUserPO;
     private RolePO expectRolePO;
@@ -48,43 +60,108 @@ public class UserRepoTest {
     private List<UserToRolePO> expectUserToRolePOList;
     private List<RoleToPermissionPO> expectRoleToPermissionPOList;
     private UserToRolePO expectUserToRolePO;
+    private RoleToPermissionPO expectRoleToPermissionPO;
+    private RegionalManagerToRegionalPO expectRegionalPOManagerPO;
+    private EvaluationAgencyPO expectEvaluationAgencyPO;
+    private RegionalPO expectRegionalPO;
+    private EvaluationAgencyAbilityPO evaluationAgencyAbilityPO;
+    private EvaluationAgencyResourcePO evaluationAgencyResourcePO;
+    private PersonalAuthenticationPO personalAuthenticationPO;
+    private List<RegionalManagerToRegionalPO> expectRegionalPOManagerList = new ArrayList<>();
+    private List<EvaluationAgencyPO> evaluationAgencyPOList = new ArrayList<>();
+    private List<EvaluationAgencyAbilityPO> evaluationAgencyAbilityPOList = new ArrayList<>();
+    private List<EvaluationAgencyResourcePO> evaluationAgencyResourcePOList = new ArrayList<>();
+
+
+
 
     @Before
     public void before() {
         MockitoAnnotations.initMocks(this);
 
         expectUserPO = new UserPO();
+        expectUserPO.setId(1L);
+        expectUserPO.setName("郭超");
+        expectUserPO.setEmail("1021172957@qq.com");
+        expectUserPO.setPassword("123456");
+        expectUserPO.setMobile("13657094936");
+
         expectRolePO = new RolePO();
+        expectRolePO.setId(1L);
+        expectRolePO.setName("generalUser");
+
         expectUserToRolePO = new UserToRolePO();
-        RoleToPermissionPO expectRoleToPermissionPO = new RoleToPermissionPO();
+        expectUserToRolePO.setId(1L);
+        expectUserToRolePO.setRoleId(1L);
+        expectUserToRolePO.setUserId(1L);
+
         expectPermission = new PermissionPO();
+        expectPermission.setId(1L);
+        expectPermission.setName("查看项目");
+
+        expectRoleToPermissionPO = new RoleToPermissionPO();
+        expectRoleToPermissionPO.setId(1L);
+        expectRoleToPermissionPO.setPermissionId(1L);
+
         expectUserToRolePOList = new LinkedList<>();
+        expectUserToRolePOList.add(expectUserToRolePO);
+
         expectRoleToPermissionPOList = new LinkedList<>();
         expectRoleToPermissionPOList.add(expectRoleToPermissionPO);
-        expectUserToRolePOList.add(expectUserToRolePO);
+
+        expectEvaluationAgencyPO = new EvaluationAgencyPO();
+        expectEvaluationAgencyPO.setId(1L);
+        expectEvaluationAgencyPO.setIsAuthentication(-1);
+        expectEvaluationAgencyPO.setBankAccount("123445666");
+        expectEvaluationAgencyPO.setAgencyPhoto("http://mooctest.png");
+        expectEvaluationAgencyPO.setUserId(1L);
+        evaluationAgencyPOList.add(expectEvaluationAgencyPO);
+
+        expectRegionalPO = new RegionalPO();
+        expectRegionalPO.setId(1L);
+
+        expectRegionalPOManagerPO = new RegionalManagerToRegionalPO();
+        expectRegionalPOManagerPO.setId(1L);
+        expectRegionalPOManagerPO.setUserId(1L);
+//        expectRegionalPOManagerPO.set(1L);
+        expectRegionalPOManagerList.add(expectRegionalPOManagerPO);
+
+        evaluationAgencyAbilityPO = new EvaluationAgencyAbilityPO();
+        evaluationAgencyAbilityPO.setId(1L);
+        evaluationAgencyAbilityPO.setEvaluationAgencyId(1L);
+        evaluationAgencyAbilityPO.setAbilityName("web测试");
+        evaluationAgencyAbilityPOList.add(evaluationAgencyAbilityPO);
+
+        evaluationAgencyResourcePO = new EvaluationAgencyResourcePO();
+        evaluationAgencyResourcePO.setId(1L);
+        evaluationAgencyResourcePO.setEvaluationAgencyId(1L);
+        evaluationAgencyResourcePO.setTotalNum(10);
+        evaluationAgencyResourcePO.setAvailableNum(5);
+        evaluationAgencyResourcePOList.add(evaluationAgencyResourcePO);
+
+        personalAuthenticationPO = new PersonalAuthenticationPO();
+        personalAuthenticationPO.setUserId(expectUserPO.getId());
+        when(personalAuthenticationDao.findByUserIdAndIsDeleted(expectUserPO.getId(),0)).thenReturn(personalAuthenticationPO);
+
     }
 
     @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));
+        when(evaluationAgencyDao.findByUserId(anyLong())).thenReturn(expectEvaluationAgencyPO);
+        when(agencyAbilityDao.findByEvaluationAgencyIdAndIsDeleted(anyLong(), anyInt())).thenReturn(evaluationAgencyAbilityPOList);
+        when(agencyResourceDao.findByEvaluationAgencyIdAndIsDeleted(anyLong(), anyInt())).thenReturn(evaluationAgencyResourcePOList);
+        when(regionalManagerToRegionalDao.findByUserId(anyLong())).thenReturn(expectRegionalPOManagerList);
+        when(regionalDao.findById(anyLong())).thenReturn(Optional.of(expectRegionalPO));
         //action
-        User user = userRepo.getByID(0L);
+        User user = userRepo.getByID(1L);
         //assert
-        Assert.assertNotNull(user);
+        Assert.assertEquals(user.getId(),expectUserPO.getId());
     }
 
     @Test(expected = UserNotExistException.class)
@@ -92,22 +169,38 @@ public class UserRepoTest {
         //arrange
         when(userDao.findById(anyLong())).thenReturn(Optional.empty());
         //action
-        userRepo.getByID(0L);
-        //assert
+        userRepo.getByID(1L);
+    }
+
+    @Test(expected = RoleNotFoundException.class)
+    public void should_throw_when_get_by_id_role_not_exist(){
+        //arrange
+        //arrange
+        when(userDao.findById(anyLong())).thenReturn(Optional.of(expectUserPO));
+        when(userToRoleDao.findByUserId(anyLong())).thenReturn(expectUserToRolePOList);
+        when(roleToPermissionDao.findAllByRoleId(anyLong())).thenReturn(expectRoleToPermissionPOList);
+        when(permissionDao.findById(anyLong())).thenReturn(Optional.of(expectPermission));
+        when(evaluationAgencyDao.findByUserId(anyLong())).thenReturn(expectEvaluationAgencyPO);
+        when(agencyAbilityDao.findByEvaluationAgencyIdAndIsDeleted(anyLong(), anyInt())).thenReturn(evaluationAgencyAbilityPOList);
+        when(regionalManagerToRegionalDao.findByUserId(anyLong())).thenReturn(expectRegionalPOManagerList);
+        when(regionalDao.findById(anyLong())).thenReturn(Optional.of(expectRegionalPO));
+        when(roleDao.findById(anyLong())).thenReturn(Optional.empty());
+        //action
+        userRepo.getByID(1L);
     }
 
     @Test
     public void should_return_user_optional_when_get_by_mobile_number_success() {
         //arrange
-        when(userDao.findByMobile(anyString())).thenReturn(expectUserPO);
+        when(userDao.findByMobile("13657094936")).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");
+        User user = userRepo.getByMobileNum(expectUserPO.getMobile());
         //assert
-        Assert.assertNotNull(user);
+        Assert.assertEquals(user.getId(),expectUserPO.getId());
     }
 
     @Test(expected = UserNotExistException.class)
@@ -116,7 +209,6 @@ public class UserRepoTest {
         when(userDao.findByMobile(anyString())).thenReturn(null);
         //action
         userRepo.getByMobileNum("123");
-        //assert
     }
 
     @Test
@@ -130,10 +222,29 @@ public class UserRepoTest {
         when(userDao.save(any(UserPO.class))).thenReturn(expectUserPO);
         when(roleDao.findByName(anyString())).thenReturn(expectRolePO);
         when(userToRoleDao.save(any(UserToRolePO.class))).thenReturn(expectUserToRolePO);
+        when(roleToPermissionDao.findAllByRoleId(anyLong())).thenReturn(expectRoleToPermissionPOList);
+        when(permissionDao.findById(anyLong())).thenReturn(Optional.of(expectPermission));
         //action
         User resultUser = userRepo.saveUserAndRole(user);
         //assert
-        Assert.assertNotNull(resultUser);
+        Assert.assertEquals(resultUser.getId(), expectUserPO.getId());
+    }
+
+    @Test(expected = PermissionNotFoundException.class)
+    public void should_return_expert_when_save_user_and_role_permission_not_found() {
+        //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);
+        when(roleToPermissionDao.findAllByRoleId(1L)).thenReturn(expectRoleToPermissionPOList);
+        when(permissionDao.findById(anyLong())).thenReturn(Optional.empty());
+        //action
+        userRepo.saveUserAndRole(user);
     }
 
     @Test
@@ -144,18 +255,84 @@ public class UserRepoTest {
         permissionList.add(permission);
         List<Role> roleList = new LinkedList<>();
         Role role = new Role();
+        role.setId(1L);
         role.setPermissionList(permissionList);
         roleList.add(role);
         EvaluationAgency evaluationAgency = new EvaluationAgency();
+        evaluationAgency.setId(1L);
+        EvaluationAgencyAbility evaluationAgencyAbility = new EvaluationAgencyAbility();
+        EvaluationAgencyResource evaluationAgencyResource = new EvaluationAgencyResource();
+        List<EvaluationAgencyResource> evaluationAgencyResourceList = new ArrayList<>();
+        List<EvaluationAgencyAbility> evaluationAgencyAbilityList = new ArrayList<>();
+        evaluationAgencyAbility.setId(1L);
+        evaluationAgencyAbility.setEvaluationAgencyId(1L);
+        evaluationAgencyAbilityList.add(evaluationAgencyAbility);
+
+        evaluationAgencyResource.setId(1L);
+        evaluationAgencyResource.setEvaluationAgencyId(1L);
+        evaluationAgencyResourceList.add(evaluationAgencyResource);
+
+        evaluationAgency.setEvaluationAgencyAbilityList(evaluationAgencyAbilityList);
+        evaluationAgency.setEvaluationAgencyResourceList(evaluationAgencyResourceList);
+
         User user = new User();
         user.setEvaluationAgency(evaluationAgency);
         user.setRoleList(roleList);
 
+        expectUserPO.setId(0L);
+
+        when(userDao.save(any(UserPO.class))).thenReturn(expectUserPO);
+        when(userDao.findById(any(Long.class))).thenReturn(Optional.of(expectUserPO));
+        when(evaluationAgencyDao.save(any(EvaluationAgencyPO.class))).thenReturn(expectEvaluationAgencyPO);
+        when(resourceRepo.saveEvaluationAgencyResource(any())).thenReturn(null);
+        //action
+        User resultUser = userRepo.saveUser(user);
+        //assert
+        Assert.assertEquals(resultUser.getId(),expectUserPO.getId());
+    }
+
+    @Test
+    public void should_return_user_when_save_user_role_is_null() {
+        //arrange
+        List<Permission> permissionList = new LinkedList<>();
+        Permission permission = new Permission();
+        permissionList.add(permission);
+        List<Role> roleList = new LinkedList<>();
+        Role role = new Role();
+        role.setId(1L);
+        role.setPermissionList(permissionList);
+        roleList.add(role);
+        EvaluationAgency evaluationAgency = new EvaluationAgency();
+        evaluationAgency.setId(1L);
+        EvaluationAgencyAbility evaluationAgencyAbility = new EvaluationAgencyAbility();
+        EvaluationAgencyResource evaluationAgencyResource = new EvaluationAgencyResource();
+        List<EvaluationAgencyResource> evaluationAgencyResourceList = new ArrayList<>();
+        List<EvaluationAgencyAbility> evaluationAgencyAbilityList = new ArrayList<>();
+        evaluationAgencyAbility.setId(1L);
+        evaluationAgencyAbility.setEvaluationAgencyId(1L);
+        evaluationAgencyAbilityList.add(evaluationAgencyAbility);
+
+        evaluationAgencyResource.setId(1L);
+        evaluationAgencyResource.setEvaluationAgencyId(1L);
+        evaluationAgencyResourceList.add(evaluationAgencyResource);
+
+        evaluationAgency.setEvaluationAgencyAbilityList(evaluationAgencyAbilityList);
+        evaluationAgency.setEvaluationAgencyResourceList(evaluationAgencyResourceList);
+
+        User user = new User();
+        user.setEvaluationAgency(evaluationAgency);
+        user.setRoleList(null);
+
+        expectUserPO.setId(0L);
+
         when(userDao.save(any(UserPO.class))).thenReturn(expectUserPO);
+        when(userDao.findById(any(Long.class))).thenReturn(Optional.of(expectUserPO));
+        when(evaluationAgencyDao.save(any(EvaluationAgencyPO.class))).thenReturn(expectEvaluationAgencyPO);
+        when(resourceRepo.saveEvaluationAgencyResource(any())).thenReturn(null);
         //action
         User resultUser = userRepo.saveUser(user);
         //assert
-        Assert.assertNotNull(resultUser);
+        Assert.assertEquals(resultUser.getId(),expectUserPO.getId());
     }
 
     @Test
@@ -205,5 +382,25 @@ public class UserRepoTest {
         Assert.assertNull(null);
     }
 
+    @Test
+    public void should_return_user_list_when_get_apply_agency() {
+        //arrange
+        when(evaluationAgencyDao.findByIsAuthentication(-1)).thenReturn(evaluationAgencyPOList);
+        when(userDao.findById(any(Long.class))).thenReturn(Optional.of(expectUserPO));
+        //action
+        List<User> applyAgencyList = userRepo.getApplyEvaluationAgencyByIsAuthenticated();
+        //assert
+        Assert.assertNotNull(applyAgencyList);
+    }
+
+    @Test
+    public void should_return_role_when_get_role(){
+        //arrange
+        when(roleDao.findByName(anyString())).thenReturn(expectRolePO);
+        //action
+        Role role = userRepo.getRole(expectRolePO.getName());
+        Assert.assertEquals(role.getName(),expectRolePO.getName());
+
+    }
 
 }

site/src/main/java/com/mooctest/crowd/site/annotation/SysAdminRequired.java

@@ -0,0 +1,16 @@
+package com.mooctest.crowd.site.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-28 00:42
+ */
+@Target({ElementType.METHOD, ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface SysAdminRequired {
+}

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

@@ -3,6 +3,7 @@ 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.BaseException;
 import com.mooctest.crowd.domain.exception.UserNotExistException;
 import com.mooctest.crowd.domain.factory.UserFactory;
 import com.mooctest.crowd.domain.repository.UserRepo;
@@ -12,17 +13,12 @@ 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.http.*;
 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
@@ -53,7 +49,13 @@ public class UserAntiCorruptionImpl implements UserAntiCorruption {
         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();
+        ResponseEntity<UserInfo> checkResult = restTemplate.getForEntity(userServiceUrl + "/api/userByEmail/" + email, UserInfo.class);
+        if (checkResult.getStatusCode().is2xxSuccessful() && checkResult.getBody()!=null)
+            throw new BaseException("邮箱已存在，请更改或直接登录");
+        ResponseEntity<UserInfo> responseEntity = restTemplate.exchange(userServiceUrl + "/api/user", HttpMethod.POST, entity, UserInfo.class);
+        if (!responseEntity.getStatusCode().is2xxSuccessful())
+            throw new BaseException("手机或邮箱已存在，请直接登录");
+        UserInfo userInfo = responseEntity.getBody();
         User user = UserFactory.createUser();
         user.setId(userInfo.getId());
         user.setName(userInfo.getName());
@@ -67,15 +69,15 @@ public class UserAntiCorruptionImpl implements UserAntiCorruption {
     public User getUserInfo(Long userId) {
         UserInfo userInfo = restTemplate.getForEntity(userServiceUrl+"/api/user/"+userId, UserInfo.class).getBody();
         if (userInfo == null)
-            throw new UserNotExistException();
+            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);
+            oldUser.setEmail(userInfo.getEmail());
+            oldUser.setMobile(userInfo.getMobile());
+            oldUser.setPassword(userInfo.getPassword());
+            userRepo.saveUser(oldUser);
         }catch (UserNotExistException e){   //本站不存在该用户，是未同步信息的新用户，初始化角色
             User user = userInfo.toUser();
             List<Role> roles = new ArrayList<>();

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

@@ -32,6 +32,7 @@ public class UserInfo {
         user.setId(this.id);
         user.setName(name);
         user.setUserName(name);
+        user.setEmail(email);
         user.setMobile(mobile);
         user.setPassword(password);
         user.setCity(city);

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

@@ -0,0 +1,28 @@
+package com.mooctest.crowd.site.command;
+
+import lombok.Data;
+
+import javax.validation.constraints.NotNull;
+import java.util.List;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-12 01:05
+ */
+@Data
+public class AgencyResourceAbilityUpdateCommand {
+//    @NotNull(message = "机构名称不可为空")
+//    private String evaluationAgencyName;
+//    @NotNull(message = "银行卡号不可为空")
+//    private String bankAccount;
+//    @NotNull(message = "机构地址不可为空")
+//    private String address;
+    @NotNull(message = "评测能力不可为空")
+    private List<String> evaluationAgencyAbilityList;
+    @NotNull(message = "机构资源不可为空")
+    private List<AgencyResourceCommand> evaluationAgencyResourceList;
+//    @NotNull(message = "LOGO不可为空")
+//    private String agencyPhoto;
+
+}

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

@@ -0,0 +1,24 @@
+package com.mooctest.crowd.site.command;
+
+import com.mooctest.crowd.domain.domainobject.EvaluationAgencyResource;
+import lombok.Data;
+import org.springframework.beans.BeanUtils;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-15 20:56
+ */
+@Data
+public class AgencyResourceCommand {
+    private String type;
+    private String name;
+    private int totalNum;
+    private int availableNum;
+
+    public EvaluationAgencyResource toAgencyResource(){
+        EvaluationAgencyResource resource = new EvaluationAgencyResource();
+        BeanUtils.copyProperties(this, resource);
+        return resource;
+    }
+}

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

@@ -1,12 +1,15 @@
 package com.mooctest.crowd.site.command;
 
 import com.mooctest.crowd.domain.domainobject.EvaluationAgency;
+import com.mooctest.crowd.domain.domainobject.EvaluationAgencyAbility;
 import com.mooctest.crowd.domain.factory.UserFactory;
 import lombok.Data;
 import org.springframework.beans.BeanUtils;
 
 import javax.validation.constraints.NotNull;
 import javax.validation.constraints.Pattern;
+import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * @author: Diors.Po
@@ -15,15 +18,6 @@ import javax.validation.constraints.Pattern;
  */
 @Data
 public class ApplyAgencyAuthCommand {
-
-    @NotNull(message = "邮箱不可为空")
-    @Pattern(regexp = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$", message = "邮箱非法")
-    private String email;
-
-    @NotNull(message = "手机号不可为空")
-    @Pattern(regexp = "^1[3|4|5|7|8][0-9]\\d{4,8}$", message = "手机号非法")
-    private String mobile;
-
     @NotNull(message = "机构名称不可为空")
     private String evaluationAgencyName;
     @NotNull(message = "银行卡号不可为空")
@@ -31,15 +25,17 @@ public class ApplyAgencyAuthCommand {
     @NotNull(message = "机构地址不可为空")
     private String address;
     @NotNull(message = "评测能力不可为空")
-    private String abilities;
+    private List<String> evaluationAgencyAbilityList;
     @NotNull(message = "机构资源不可为空")
-    private String resources;
+    private List<AgencyResourceCommand> evaluationAgencyResourceList;
     @NotNull(message = "LOGO不可为空")
     private String agencyPhoto;
 
     public EvaluationAgency toAgency(){
         EvaluationAgency agency = UserFactory.defaultAgency();
-        BeanUtils.copyProperties(this, agency);
+        BeanUtils.copyProperties(this, agency, "evaluationAgencyAbilityList", "evaluationAgencyResourceList");
+        agency.setEvaluationAgencyAbilityList(this.evaluationAgencyAbilityList.stream().map(EvaluationAgencyAbility::new).collect(Collectors.toList()));
+        agency.setEvaluationAgencyResourceList(this.evaluationAgencyResourceList.stream().map(AgencyResourceCommand::toAgencyResource).collect(Collectors.toList()));
         agency.setIsDeleted(0);
         agency.setIsAuthentication(0);
         return agency;

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

@@ -0,0 +1,44 @@
+package com.mooctest.crowd.site.command;
+
+import com.mooctest.crowd.domain.domainobject.EnterpriseAuthentication;
+import lombok.Data;
+import org.springframework.beans.BeanUtils;
+
+import javax.validation.constraints.NotNull;
+import java.sql.Timestamp;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-28 01:20
+ */
+@Data
+public class ApplyEnterpriseAuthCommand {
+    @NotNull(message = "用户ID不可为空")
+    private Long userId;
+
+    @NotNull(message = "企业名称不可为空")
+    private String enterpriseName;
+
+    @NotNull(message = "企业法人不可为空")
+    private String legalPersonName;
+
+    @NotNull(message = "请上传营业执照")
+    private String businessLicensePhoto;
+
+    @NotNull(message = "请填写社会统一信用代码")
+    private String unifiedSocialCreditCode;
+
+    @NotNull(message = "请填写对公账户")
+    private String bankAccount;
+
+    @NotNull(message = "地址不可为空")
+    private String address;
+
+    public EnterpriseAuthentication toEnterpriseAuth() {
+        EnterpriseAuthentication enterpriseAuthentication = new EnterpriseAuthentication();
+        BeanUtils.copyProperties(this, enterpriseAuthentication);
+        enterpriseAuthentication.setApplyTime(new Timestamp(System.currentTimeMillis()));
+        return enterpriseAuthentication;
+    }
+}

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

@@ -0,0 +1,46 @@
+package com.mooctest.crowd.site.command;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.mooctest.crowd.domain.domainobject.PersonalAuthentication;
+import lombok.Data;
+import org.springframework.beans.BeanUtils;
+
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Pattern;
+import java.sql.Timestamp;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-27 01:23
+ */
+@Data
+public class ApplyPersonalAuthCommand {
+    @NotNull(message = "用户ID不可为空")
+    private Long userId;
+
+    @NotNull(message = "请填写真实姓名")
+    private String realName;
+
+    @JsonProperty(value = "IDCard")
+    @NotNull(message = "请填写身份证号码")
+    @Pattern(regexp = "\\d{15}(\\d{2}[0-9xX])?", message = "身份证号格式错误")
+    private String IDCard;
+
+    @JsonProperty(value = "IDCardPhoto")
+    @NotNull(message = "请上传身份证图片")
+    private String IDCardPhoto;
+
+    @NotNull(message = "请填写银行卡号")
+    private String bankAccount;
+
+    @NotNull(message = "地址不可为空")
+    private String address;
+
+    public PersonalAuthentication toPersonalAuth(){
+        PersonalAuthentication personalAuthentication = new PersonalAuthentication();
+        BeanUtils.copyProperties(this, personalAuthentication);
+        personalAuthentication.setApplyTime(new Timestamp(System.currentTimeMillis()));
+        return personalAuthentication;
+    }
+}

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

@@ -0,0 +1,16 @@
+package com.mooctest.crowd.site.command;
+
+import lombok.Data;
+
+import javax.validation.constraints.NotNull;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-29 17:14
+ */
+@Data
+public class AuthRejectCommand {
+    @NotNull(message = "请输入驳回原因")
+    private String explain;
+}

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

@@ -1,6 +1,5 @@
 package com.mooctest.crowd.site.command;
 
-import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import com.mooctest.crowd.domain.domainobject.CrowdTestProject;
 
@@ -27,9 +26,9 @@ public class CrowdTestProjectCommand {
     private String name;
 
     @NotNull(message = "项目服务类型不可为空")
-    private ArrayList<Integer> type;
+    private ArrayList<String> type;
 
-    private ArrayList<Integer> platform;
+    private ArrayList<String> platform;
 
     @NotNull(message = "项目描述不可为空")
     private String desc;
@@ -75,8 +74,10 @@ public class CrowdTestProjectCommand {
         crowdTestProject.setRequirementFile(this.doc);
         crowdTestProject.setProjectFile(this.file);
         crowdTestProject.setProjectDistributionTypeId(this.resource);
-        crowdTestProject.setDistributionProvince(this.location.get("provinceCode"));
-        crowdTestProject.setDistributionCity(this.location.get("cityCode"));
+        if (resource==1) {
+            crowdTestProject.setDistributionProvince(this.location.get("provinceCode"));
+            crowdTestProject.setDistributionCity(this.location.get("cityCode"));
+        }
         crowdTestProject.setRegionalManagerId(this.getInstitution());
         crowdTestProject.setDeadTime(this.datetime);
         crowdTestProject.setQuotedPrice(this.budget);

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

@@ -17,11 +17,10 @@ public class CrowdTestReportCommand {
     @NotNull(message = "请填写报告名称")
     private String name;
 
-    @NotNull(message = "请选择报告所属范围")
-    private Integer scope;
+    private Integer scope=0;
 
     @NotNull(message = "请选择报告类型 ")
-    private Integer type;
+    private String type;
 
     private String dependencyCode;
 

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

@@ -23,13 +23,15 @@ public class CrowdTestTaskCommand {
     private String desc;
 
     @NotNull(message = "请填写任务类型")
-    private Integer type;
+    private String type;
 
     @NotNull(message = "请指定任务发布类型")
     private Long resource;
 
     private Map<String, String> location;
 
+    private String requirementFile;
+
     private Long institution;
 
     @NotNull(message = "请填写截止时间")
@@ -53,19 +55,23 @@ public class CrowdTestTaskCommand {
         crowdTestTask.setName(name);
         crowdTestTask.setDeadTime(datetime);
         crowdTestTask.setDescription(desc);
-        crowdTestTask.setDistributionProvince(location.get("provinceCode"));
-        crowdTestTask.setDistributionCity(location.get("cityCode"));
+        if (resource==1) {
+            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);
+        crowdTestTask.setRequirementFile(requirementFile);
         return crowdTestTask;
     }
 
     public CrowdTestTask toCrowdTask(String projectCode){
         CrowdTestTask task = toCrowdTask();
         task.setCrowdTestProjectCode(projectCode);
+        task.setCreateTime(new Timestamp(System.currentTimeMillis()));
         return task;
     }
 }

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

@@ -0,0 +1,52 @@
+package com.mooctest.crowd.site.command;
+
+import com.mooctest.crowd.domain.domainobject.EvaluationAgency;
+import com.mooctest.crowd.domain.domainobject.EvaluationAgencyAbility;
+import com.mooctest.crowd.domain.factory.UserFactory;
+import lombok.Data;
+import org.springframework.beans.BeanUtils;
+
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Pattern;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-15 22:19
+ */
+@Data
+public class GenerateAgencyCommand {
+
+    @NotNull(message = "邮箱不可为空")
+    @Pattern(regexp = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$", message = "邮箱非法")
+    private String email;
+
+    @NotNull(message = "手机号不可为空")
+    @Pattern(regexp = "^1[3|4|5|7|8][0-9]\\d{4,8}$", message = "手机号非法")
+    private String mobile;
+
+    @NotNull(message = "机构名称不可为空")
+    private String evaluationAgencyName;
+    @NotNull(message = "银行卡号不可为空")
+    private String bankAccount;
+    @NotNull(message = "机构地址不可为空")
+    private String address;
+    @NotNull(message = "评测能力不可为空")
+    private List<String> evaluationAgencyAbilityList;
+    @NotNull(message = "机构资源不可为空")
+    private List<AgencyResourceCommand> evaluationAgencyResourceList;
+    @NotNull(message = "LOGO不可为空")
+    private String agencyPhoto;
+
+    public EvaluationAgency toAgency(){
+        EvaluationAgency agency = UserFactory.defaultAgency();
+        BeanUtils.copyProperties(this, agency, "evaluationAgencyAbilityList", "evaluationAgencyResourceList");
+        agency.setEvaluationAgencyAbilityList(this.evaluationAgencyAbilityList.stream().map(EvaluationAgencyAbility::new).collect(Collectors.toList()));
+        agency.setEvaluationAgencyResourceList(this.evaluationAgencyResourceList.stream().map(AgencyResourceCommand::toAgencyResource).collect(Collectors.toList()));
+        agency.setIsDeleted(0);
+        agency.setIsAuthentication(0);
+        return agency;
+    }
+}

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

@@ -27,9 +27,9 @@ public class GenerateProjectCommand {
     private String name;
 
     @NotNull(message = "项目服务类型不可为空")
-    private ArrayList<Integer> type;
+    private ArrayList<String> type;
 
-    private ArrayList<Integer> platform;
+    private ArrayList<String> platform;
 
     @NotNull(message = "项目描述不可为空")
     private String description;
@@ -59,13 +59,13 @@ public class GenerateProjectCommand {
 
     private String reportUrl;
 
-    private Integer reportType=6;
+    private String reportType="项目测试报告";
 
     public CrowdTestProject toCrowdProject() {
         CrowdTestProject crowdTestProject = CrowdTestProjectFactory.createCrowdTestProject();
         crowdTestProject.setName(this.name);
         if (userId == null)
-            userId = 0L;
+            userId = 1L;
         crowdTestProject.setUserId(userId);
         crowdTestProject.setLinkMan(this.contactName);
         crowdTestProject.setLinkManMobile(this.contactPhone);

site/src/main/java/com/mooctest/crowd/site/configuration/WebMvcConfiguration.java

@@ -2,6 +2,7 @@ package com.mooctest.crowd.site.configuration;
 
 import com.mooctest.crowd.site.controller.interceptor.AuthCheckInterceptor;
 import com.mooctest.crowd.site.controller.interceptor.FileCheckInterceptor;
+import com.mooctest.crowd.site.controller.interceptor.SysAdminCheckInterceptor;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
@@ -21,6 +22,9 @@ public class WebMvcConfiguration implements WebMvcConfigurer {
     @Autowired
     private AuthCheckInterceptor authCheckInterceptor;
 
+    @Autowired
+    private SysAdminCheckInterceptor sysAdminCheckInterceptor;
+
     @Override
     public void addInterceptors(InterceptorRegistry registry) {
         registry.addInterceptor(fileCheckInterceptor)
@@ -28,5 +32,7 @@ public class WebMvcConfiguration implements WebMvcConfigurer {
         registry.addInterceptor(authCheckInterceptor)
                 .excludePathPatterns("/api/common/**")
                 .addPathPatterns("/**");
+        registry.addInterceptor(sysAdminCheckInterceptor)
+                .addPathPatterns("/api/user/**");
     }
 }

site/src/main/java/com/mooctest/crowd/site/controller/AgencyController.java

@@ -1,15 +1,26 @@
 package com.mooctest.crowd.site.controller;
 
+import com.alibaba.druid.sql.visitor.functions.Bin;
 import com.mooctest.crowd.domain.exception.BaseException;
+import com.mooctest.crowd.site.annotation.LoginRequired;
+import com.mooctest.crowd.site.annotation.SysAdminRequired;
+import com.mooctest.crowd.site.command.AgencyResourceAbilityUpdateCommand;
 import com.mooctest.crowd.site.command.ApplyAgencyAuthCommand;
+import com.mooctest.crowd.site.command.AuthRejectCommand;
+import com.mooctest.crowd.site.command.GenerateAgencyCommand;
 import com.mooctest.crowd.site.data.dto.UserDTO;
+import com.mooctest.crowd.site.data.vo.AgencyVO;
+import com.mooctest.crowd.site.data.vo.EvolutionAgencyVO;
 import com.mooctest.crowd.site.service.AgencyService;
+import lombok.extern.java.Log;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.validation.BindingResult;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
 
-import javax.validation.Valid;
+import javax.servlet.http.HttpSession;
+import javax.validation.constraints.Pattern;
+import java.util.List;
 
 /**
  * @author: Diors.Po
@@ -29,33 +40,97 @@ public class AgencyController {
      * @return
      */
     @RequestMapping(value = "/greenChannel/agency", method = RequestMethod.POST)
-    public UserDTO generateAgency(@RequestBody @Validated ApplyAgencyAuthCommand command, BindingResult result){
+    public UserDTO generateAgency(@RequestBody @Validated GenerateAgencyCommand command, BindingResult result){
         if (result.hasErrors())
             throw new BaseException(result.getFieldError().getDefaultMessage());
         return agencyService.generateAgency(command);
     }
 
     /**
-     * 申请认证为机构
+     * 申请机构认证
      * @param userId
      * @param command
+     * @param result
      * @return
      */
+    @LoginRequired
     @RequestMapping(value = "/user/{userId}/agency", method = RequestMethod.POST)
-    public UserDTO authAgency(@PathVariable("userId") Long userId, @RequestBody ApplyAgencyAuthCommand command){
+    public UserDTO applyAgencyAuth(@PathVariable("userId") Long userId, @RequestBody @Validated ApplyAgencyAuthCommand command, BindingResult result){
+        if (result.hasErrors())
+            throw new BaseException(result.getFieldError().getDefaultMessage());
         return agencyService.applyAgency(userId, command);
     }
 
     /**
+     * 更新机构认证信息
+     * @param userId
+     * @param command
+     * @param result
+     * @return
+     */
+    @LoginRequired
+    @RequestMapping(value = "/user/{userId}/agency", method = RequestMethod.PUT)
+    public AgencyVO updateAgencyInfo(@PathVariable("userId") Long userId, @RequestBody @Validated ApplyAgencyAuthCommand command, BindingResult result){
+        if (result.hasErrors())
+            throw new BaseException(result.getFieldError().getDefaultMessage());
+        return agencyService.updateAgencyInfo(userId, command);
+    }
+
+    /**
      * 审核认证请求（修改认证申请的状态）
      * @param userId
      * @param status
      * @return
      */
-    @RequestMapping(value = "/user/{userId}/agency/status/{status}", method = RequestMethod.PUT)
+    @LoginRequired
+    @RequestMapping(value = "/user/{userId}/agency/status/", method = RequestMethod.PUT)
     public UserDTO checkAuth(@PathVariable("userId") Long userId, @PathVariable("status") Integer status){
         if (status > 1 || status < -1)
             throw new BaseException("错误的状态信息，无法更新认证状态为所选状态");
         return agencyService.updateAgencyStatus(userId, status);
     }
+
+    @LoginRequired
+    @SysAdminRequired
+    @RequestMapping(value = "/user/{userId}/agency/status/accept", method = RequestMethod.PUT)
+    public AgencyVO passAuth(@PathVariable("userId") Long userId){
+        return agencyService.passAuth(userId);
+    }
+
+    @LoginRequired
+    @SysAdminRequired
+    @RequestMapping(value = "/user/{userId}/agency/status/reject", method = RequestMethod.PUT)
+    public AgencyVO rejectAuth(@PathVariable("userId") Long userId, @RequestBody @Validated AuthRejectCommand command){
+        return agencyService.rejectAuth(userId, command.getExplain());
+    }
+
+    /**
+     * 测评机构修改能力和资源信息
+     * @param userId
+     * @param command
+     * @return
+     */
+    @LoginRequired
+    @RequestMapping(value = "/user/{userId}/agency/resource", method = RequestMethod.POST)
+    public AgencyVO updateAgencyResourceAndAbility(@PathVariable("userId") Long userId, @RequestBody @Validated AgencyResourceAbilityUpdateCommand command, BindingResult result){
+        if (result.hasErrors())
+            throw new BaseException(result.getFieldError().getDefaultMessage());
+        return agencyService.upadteResourceAndAbility(userId, command);
+    }
+
+    /**
+     * 获取机构认证信息
+     * @param userId
+     * @return
+     */
+    @LoginRequired
+    @RequestMapping(value = "/user/{userId}/agency", method = RequestMethod.GET)
+    public AgencyVO getAgencyInfo(@PathVariable("userId") Long userId){
+        return agencyService.getAgencyDetails(userId);
+    }
+
+    @RequestMapping(value = "/agency/list", method = RequestMethod.GET)
+    public List<EvolutionAgencyVO> getAgencyList(){
+        return agencyService.getAgencyList();
+    }
 }

site/src/main/java/com/mooctest/crowd/site/controller/CrowdProjectController.java

@@ -3,9 +3,11 @@ package com.mooctest.crowd.site.controller;
 import com.mooctest.crowd.domain.domainobject.CrowdTestProject;
 import com.mooctest.crowd.domain.exception.BadRequestException;
 import com.mooctest.crowd.domain.exception.BaseException;
+import com.mooctest.crowd.site.annotation.LoginRequired;
 import com.mooctest.crowd.site.command.CrowdTestProjectCommand;
 import com.mooctest.crowd.site.command.GenerateProjectCommand;
 import com.mooctest.crowd.site.data.dto.ProjectDetailsDTO;
+import com.mooctest.crowd.site.data.vo.RegionalManagerVO;
 import com.mooctest.crowd.site.service.CrowdProjectService;
 import com.mooctest.crowd.site.util.FileUtil;
 import lombok.extern.slf4j.Slf4j;
@@ -31,6 +33,12 @@ public class CrowdProjectController {
     @Autowired
     private CrowdProjectService projectService;
 
+    /**
+     *  创建项目接口
+     * @param crowdTestProjectCommand
+     * @param result
+     * @return
+     */
     @RequestMapping(value = "/api/project", method = RequestMethod.POST)
     public ProjectDetailsDTO createProject(@Validated @RequestBody CrowdTestProjectCommand crowdTestProjectCommand, BindingResult result){
         if (result.hasErrors())
@@ -40,17 +48,38 @@ public class CrowdProjectController {
         return projectService.createCrowdProject(crowdTestProjectCommand);
     }
 
+    /**
+     * 获取项目详情接口
+     * @param projectCode
+     * @return
+     */
     @RequestMapping(value = "/api/project/{projectCode}", method = RequestMethod.GET)
-    public ProjectDetailsDTO getProject(@PathVariable("projectCode") String projectCode){
+    public ProjectDetailsDTO getProject(@PathVariable("projectCode") String projectCode, HttpSession session){
         log.info("访问Project详情，projectId："+projectCode);
-        return projectService.getProjectDetails(projectCode);
+        Object loginUser = session.getAttribute("userId");
+        Long userId = null;
+        if (loginUser!=null)
+            userId = Long.parseLong((String)loginUser);
+        return projectService.getProjectDetails(projectCode, userId);
     }
 
+    /**
+     * 获取全部项目
+     * @return
+     */
     @RequestMapping(value = "/api/project", method = RequestMethod.GET)
     public List<ProjectDetailsDTO> getProjects(){
+        //todo 获取所有项目列表
         return null;
     }
 
+    /**
+     * 更新项目信息接口
+     * @param crowdTestProjectCommand
+     * @param projectCode
+     * @param result
+     * @return
+     */
     @RequestMapping(value = "/api/project/{projectCode}", method = RequestMethod.PUT)
     public ProjectDetailsDTO updateProject(@Validated @RequestBody CrowdTestProjectCommand crowdTestProjectCommand, @PathVariable("projectCode") String projectCode, BindingResult result){
         if (result.hasErrors())
@@ -60,24 +89,92 @@ public class CrowdProjectController {
         return projectService.updateProject(projectCode, crowdTestProjectCommand);
     }
 
+    /**
+     * 删除项目
+     * @param projectId
+     * @param session
+     */
     @RequestMapping(value = "/api/project/{projectId}", method = RequestMethod.DELETE)
     public void deleteProject(@PathVariable("projectId") Long projectId, HttpSession session){
         projectService.deleteProject(projectId, (Long)session.getAttribute("userId"));
     }
 
+    /**
+     * 通过表单填写，生成项目
+     * @param command
+     * @return
+     */
     @RequestMapping(value = "/api/greenChannel/project", method = RequestMethod.POST)
     public ProjectDetailsDTO generateProjectWithData(@RequestBody GenerateProjectCommand command){
         return projectService.generateProjectWithData(command);
     }
 
-    @RequestMapping(value = "/api/greenChannel/projects", method = RequestMethod.POST)
-    public List<ProjectDetailsDTO> multiProjectsImport(MultipartFile file){
+    /**
+     * 将Excel解析为多个项目
+     * @param file
+     * @return
+     */
+    @RequestMapping(value = "/api/greenChannel/excel/{userId}/projects", method = RequestMethod.POST)
+    public List<CrowdTestProject> parseExcel2Projects(@PathVariable("userId")Long userId, MultipartFile file){
         try {
             if (!FileUtil.checkExcel(file.getInputStream()))
                 throw new BadRequestException("请上传Excel文件，xls/xlsx");
         } catch (IOException e) {
             e.printStackTrace();
         }
-        return projectService.importMultiProjectsByExcel(file);
+        return projectService.generateProjectByExcel(userId, file);
+    }
+
+    /**
+     * 导入由Excel解析而来的多个项目
+     * @param projects
+     * @return
+     */
+    @RequestMapping(value = "/api/greenChannel/projects", method = RequestMethod.POST)
+    public List<ProjectDetailsDTO> multiProjectsImport(@RequestBody List<CrowdTestProject> projects){
+        return projectService.importMultiProjectsByExcel(projects);
+    }
+
+    /**
+     * 区域管理员接收项目
+     * @param projectCode
+     * @param userId
+     * @return
+     */
+    @LoginRequired
+    @RequestMapping(value = "/api/project/{projectCode}/regionManager/{userId}", method = RequestMethod.PUT)
+    public ProjectDetailsDTO acceptProject(@PathVariable("projectCode") String projectCode, @PathVariable("userId") Long userId){
+        return projectService.receiveProject(projectCode, userId);
+    }
+
+    @LoginRequired
+    @RequestMapping(value = "/api/project/{projectCode}/status/rejected", method = RequestMethod.PUT)
+    public void rejectProejct(@PathVariable("projectCode") String projectCode, HttpSession session){
+        Long userId = Long.parseLong((String)session.getAttribute("userId"));
+        projectService.rejectProject(projectCode, userId);
     }
+
+    @LoginRequired
+    @RequestMapping(value = "/api/project/{projectCode}/status/committed", method = RequestMethod.PUT)
+    public ProjectDetailsDTO commitProject(@PathVariable("projectCode") String projectCode, HttpSession session){
+        Long userId = Long.parseLong((String)session.getAttribute("userId"));
+        return projectService.commitProject(projectCode, userId);
+    }
+
+    @LoginRequired
+    @RequestMapping(value = "/api/project/{projectCode}/status/finished", method = RequestMethod.PUT)
+    public ProjectDetailsDTO confirmFinished(@PathVariable("projectCode") String projectCode, HttpSession session){
+        Long userId = Long.parseLong((String)session.getAttribute("userId"));
+        return projectService.confirmFinished(projectCode, userId);
+    }
+
+    /**
+     * 获取区域管理员列表
+     * @return
+     */
+    @RequestMapping(value = "/api/regionalManager", method = RequestMethod.GET)
+    public List<RegionalManagerVO> getRegionalManagerList(){
+        return projectService.getRegionalManagerList();
+    }
+
 }

site/src/main/java/com/mooctest/crowd/site/controller/CrowdReportController.java

@@ -10,6 +10,7 @@ import org.springframework.validation.BindingResult;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
 
+import javax.servlet.http.HttpSession;
 import java.util.List;
 
 /**
@@ -28,8 +29,11 @@ public class CrowdReportController {
     @RequestMapping(value = "/project/{projectCode}/task/{taskCode}/report/{reportCode}", method = RequestMethod.GET)
     public ReportDetailsDTO getTaskReport(@PathVariable("projectCode") String projectCode,
                                           @PathVariable("taskCode") String taskCode,
-                                          @PathVariable("reportCode") String reportCode){
-        return reportService.getTaskReport(projectCode, taskCode, reportCode);
+                                          @PathVariable("reportCode") String reportCode,
+                                          HttpSession session){
+        if (session.getAttribute("userId")==null)
+            return reportService.getTaskReport(projectCode, taskCode, reportCode, null);
+        return reportService.getTaskReport(projectCode, taskCode, reportCode, Long.parseLong((String)session.getAttribute("userId")));
     }
 
     @RequestMapping(value = "/project/{projectCode}/task/{taskCode}/report", method = RequestMethod.POST)
@@ -54,19 +58,28 @@ public class CrowdReportController {
     }
 
     @RequestMapping(value = "/project/{projectCode}/task/{taskCode}/report/{reportCode}", method = RequestMethod.DELETE)
-    public boolean deleteTaskReport(@PathVariable("reportCode")String reportCode){
-        return true;
+    public void deleteTaskReport(@PathVariable("projectCode") String projectCode,
+                                 @PathVariable("taskCode") String taskCode,
+                                 @PathVariable("reportCode") String reportCode){
+        reportService.deleteTaskReport(projectCode, taskCode, reportCode);
     }
 
 
     @RequestMapping(value = "/project/{projectCode}/report", method = RequestMethod.POST)
-    public ReportDetailsDTO createProjectReport(CrowdTestReportCommand command){
-        return null;
+    public ReportDetailsDTO createProjectReport(@PathVariable("projectCode") String projectCode,
+                                                @RequestBody @Validated CrowdTestReportCommand command, BindingResult result){
+        if (result.hasErrors())
+            throw new BaseException(result.getFieldError().getDefaultMessage());
+        return reportService.createProjectReport(projectCode, command);
     }
 
     @RequestMapping(value = "/project/{projectCode}/report/{reportCode}", method = RequestMethod.GET)
-    public ReportDetailsDTO getProjectReport(@PathVariable("projectCode") String projectCode, @PathVariable("reportCode") String reportCode){
-        return null;
+    public ReportDetailsDTO getProjectReport(@PathVariable("projectCode") String projectCode,
+                                             @PathVariable("reportCode") String reportCode,
+                                             HttpSession session){
+        if (session.getAttribute("userId")==null)
+            return reportService.getProjectReport(projectCode, reportCode, null);
+        return reportService.getProjectReport(projectCode, reportCode, Long.parseLong((String)session.getAttribute("userId")));
     }
 
     @RequestMapping(value = "/project/{projectCode}/report/{reportCode}", method = RequestMethod.DELETE)
@@ -74,14 +87,15 @@ public class CrowdReportController {
         return true;
     }
 
-    @RequestMapping(value = "/api/report", method = RequestMethod.GET)
-    public List<ReportDetailsDTO> getReports(){
-        return null;
-    }
 
-    @RequestMapping(value = "/api/report", method = RequestMethod.PUT)
-    public ReportDetailsDTO updateReport(CrowdTestReportCommand command){
-        return null;
+    @RequestMapping(value = "/project/{projectCode}/report/{reportCode}", method = RequestMethod.PUT)
+    public ReportDetailsDTO updateProjectReport(@PathVariable("projectCode") String projectCode,
+                                                @PathVariable("reportCode") String reportCode,
+                                                @RequestBody @Validated CrowdTestReportCommand command, BindingResult result){
+        log.info("更行项目报告，projectCode: " + projectCode);
+        if (result.hasErrors())
+            throw new BaseException(result.getFieldError().getDefaultMessage());
+        return reportService.updatePorjctReport(projectCode, reportCode, command);
     }
 
 

site/src/main/java/com/mooctest/crowd/site/controller/CrowdTaskController.java

@@ -1,6 +1,8 @@
 package com.mooctest.crowd.site.controller;
 
 import com.mooctest.crowd.domain.exception.BaseException;
+import com.mooctest.crowd.domain.exception.UnauthorizedException;
+import com.mooctest.crowd.site.annotation.LoginRequired;
 import com.mooctest.crowd.site.command.CrowdTestTaskCommand;
 import com.mooctest.crowd.site.data.dto.TaskDetailsDTO;
 import com.mooctest.crowd.site.data.dto.TaskSquareDTO;
@@ -11,7 +13,7 @@ import org.springframework.validation.BindingResult;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
 
-import java.util.List;
+import javax.servlet.http.HttpSession;
 
 /**
  * @author: Diors.Po
@@ -27,17 +29,22 @@ public class CrowdTaskController {
     private CrowdTaskService taskService;
 
     @RequestMapping(value = "/project/{projectCode}/task/{taskCode}", method = RequestMethod.GET)
-    public TaskDetailsDTO getTask(@PathVariable("projectCode") String projectCode, @PathVariable("taskCode") String taskCode){
-        return taskService.getTaskDetails(projectCode, taskCode);
+    public TaskDetailsDTO getTask(@PathVariable("projectCode") String projectCode, @PathVariable("taskCode") String taskCode, HttpSession session){
+        Object user = session.getAttribute("userId");
+        if (user == null)
+            return taskService.getTaskDetails(projectCode, taskCode, null);
+        Long userId = Long.parseLong((String)user );
+        return taskService.getTaskDetails(projectCode, taskCode, userId);
     }
 
+    @LoginRequired
     @RequestMapping(value = "/project/{projectCode}/task", method = RequestMethod.POST)
-    public TaskDetailsDTO createTask(@PathVariable("projectCode") String projectCode, @Validated @RequestBody CrowdTestTaskCommand command, BindingResult result){
+    public TaskDetailsDTO createTask(@PathVariable("projectCode") String projectCode, @Validated @RequestBody CrowdTestTaskCommand command, BindingResult result, HttpSession session){
         if (result.hasErrors())
             throw new BaseException(result.getFieldError().getDefaultMessage());
         else if (!command.isLegal())
             throw new BaseException("信息不合法，项目可见性选择存在问题");
-        return taskService.createTask(projectCode, command);
+        return taskService.createTask(projectCode, command, Long.parseLong((String)session.getAttribute("userId")));
     }
 
     @RequestMapping(value = "/task/{taskCode}", method = RequestMethod.DELETE)
@@ -50,16 +57,51 @@ public class CrowdTaskController {
         return taskService.getAllTasks();
     }
 
+    @LoginRequired
     @RequestMapping(value = "/project/{projectCode}/task/{taskCode}", method = RequestMethod.PUT)
     public TaskDetailsDTO updateTask(@PathVariable("projectCode") String projectCode,
                                      @PathVariable("taskCode") String taskCode,
                                      @Validated @RequestBody CrowdTestTaskCommand command,
-                                     BindingResult result){
+                                     BindingResult result,
+                                     HttpSession session){
         log.info("修改Task信息");
         if (result.hasErrors())
             throw new BaseException(result.getFieldError().getDefaultMessage());
         else if (!command.isLegal())
             throw new BaseException("信息不合法，项目可见性选择存在问题");
-        return taskService.updateTask(projectCode, taskCode, command);
+        return taskService.updateTask(projectCode, taskCode, command, Long.parseLong((String)session.getAttribute("userId")));
+    }
+
+    @LoginRequired
+    @RequestMapping(value = "/project/{projectCode}/task/{taskCode}/agency/{userId}", method = RequestMethod.PUT)
+    public TaskDetailsDTO acceptTask(@PathVariable("projectCode") String projectCode, @PathVariable("taskCode") String taskCode,
+                                     @PathVariable("userId") Long userId, HttpSession session){
+        Long loginUserId = Long.parseLong((String)session.getAttribute("userId"));
+        log.info("userId in Url: " + userId + ", userId in session: " + loginUserId);
+        if(!loginUserId.equals(userId)) {
+            throw new UnauthorizedException("非法操作，操作用户不一致");
+        }
+        return taskService.acceptTask(projectCode, taskCode, userId);
+    }
+
+    @LoginRequired
+    @RequestMapping(value = "/project/{projectCode}/task/{taskCode}/status/reject", method = RequestMethod.PUT)
+    public void rejectTask(@PathVariable("projectCode") String projectCode, @PathVariable("taskCode") String taskCode, HttpSession session){
+        Long userId = Long.parseLong((String)session.getAttribute("userId"));
+        taskService.rejectDirectionalTask(projectCode, taskCode, userId);
+    }
+
+    @LoginRequired
+    @RequestMapping(value = "/project/{projectCode}/task/{taskCode}/status/commit", method = RequestMethod.PUT)
+    public TaskDetailsDTO commitTask(@PathVariable("projectCode") String projectCode, @PathVariable("taskCode") String taskCode, HttpSession session){
+        Long userId = Long.parseLong((String)session.getAttribute("userId"));
+        return taskService.commitTask(projectCode, taskCode, userId);
+    }
+
+    @LoginRequired
+    @RequestMapping(value = "/project/{projectCode}/task/{taskCode}/status/finished", method = RequestMethod.PUT)
+    public TaskDetailsDTO confirmFinishTask(@PathVariable("projectCode") String projectCode, @PathVariable("taskCode") String taskCode, HttpSession session){
+        Long userId = Long.parseLong((String)session.getAttribute("userId"));
+        return taskService.confirmFinish(projectCode, taskCode, userId);
     }
 }

site/src/main/java/com/mooctest/crowd/site/controller/TestController.java

@@ -1,19 +1,24 @@
 package com.mooctest.crowd.site.controller;
 
 import com.alibaba.fastjson.JSONObject;
+import com.mooctest.crowd.domain.dao.AgencyResourceDao;
+import com.mooctest.crowd.domain.dao.CrowdTestProjectDao;
+import com.mooctest.crowd.domain.dao.CrowdTestTaskDao;
+import com.mooctest.crowd.domain.dao.UserDao;
+import com.mooctest.crowd.domain.domainobject.CrowdTestProjectStatus;
 import com.mooctest.crowd.site.annotation.LoginRequired;
 import com.mooctest.crowd.site.anticorruption.impl.data.UserInfo;
+import com.mooctest.crowd.site.command.AuthRejectCommand;
 import com.mooctest.crowd.site.service.CrowdProjectService;
-import com.mooctest.crowd.site.service.UploadService;
-import com.mooctest.crowd.site.util.FileUtil;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
 import org.springframework.http.HttpEntity;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
 import org.springframework.http.MediaType;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.client.RestTemplate;
-import org.springframework.web.multipart.MultipartFile;
 
 import javax.servlet.http.HttpServletRequest;
 import java.io.IOException;
@@ -33,6 +38,15 @@ public class TestController {
     private CrowdProjectService projectService;
 
     @Autowired
+    private CrowdTestProjectDao projectDao;
+
+    @Autowired
+    private CrowdTestTaskDao taskDao;
+
+    @Autowired
+    private AgencyResourceDao agencyResourceDao;
+
+    @Autowired
     private RestTemplate restTemplate;
 
     @RequestMapping(value = "/test/rest", method = RequestMethod.POST)
@@ -51,14 +65,11 @@ public class TestController {
         return restTemplate.exchange(url, HttpMethod.POST,entity, UserInfo.class).getBody();
     }
 
-    @RequestMapping(value = "/test", method = RequestMethod.POST)
-    public Object exceptionTest(MultipartFile file) throws IOException {
-        return FileUtil.checkFile(file.getInputStream());
-    }
-
-    @RequestMapping(value = "/test/excel", method = RequestMethod.POST)
-    public Object excelTest(MultipartFile file) throws IOException {
-        return projectService.importMultiProjectsByExcel(file);
+    @RequestMapping(value = "/test/{userId}", method = RequestMethod.POST)
+    public Object exceptionTest(@PathVariable("userId") Long userId, AuthRejectCommand command) throws IOException {
+        System.out.println(command.getExplain());
+        return null;
+//        return agencyResourceDao.getTotalResourceByType("服务器资源");
     }
 
     @RequestMapping(value = "/session/put", method = RequestMethod.GET)

site/src/main/java/com/mooctest/crowd/site/controller/UserController.java

@@ -1,19 +1,20 @@
 package com.mooctest.crowd.site.controller;
 
+import com.mooctest.crowd.domain.exception.*;
+import com.mooctest.crowd.site.annotation.LoginRequired;
+import com.mooctest.crowd.site.annotation.SysAdminRequired;
 import com.mooctest.crowd.site.command.*;
 import com.mooctest.crowd.site.data.dto.UserDTO;
-import com.mooctest.crowd.domain.exception.AccountNotExistException;
-import com.mooctest.crowd.domain.exception.BadRequestException;
-import com.mooctest.crowd.domain.exception.PasswordErrorException;
+import com.mooctest.crowd.site.data.vo.BaseAuthVO;
+import com.mooctest.crowd.site.data.vo.EnterpriseAuthVO;
+import com.mooctest.crowd.site.data.vo.PersonalAuthVO;
 import com.mooctest.crowd.site.service.UserService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.validation.BindingResult;
 import org.springframework.validation.annotation.Validated;
-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.bind.annotation.*;
 
+import javax.servlet.http.HttpSession;
 import java.util.List;
 
 /**
@@ -47,7 +48,7 @@ public class UserController {
 
     @RequestMapping(value = "/user/{userId}", method = RequestMethod.GET)
     public UserDTO getUser(@PathVariable Long userId){
-        return null;
+        return userService.getUser(userId);
     }
 
     @RequestMapping(value = "/user", method = RequestMethod.GET)
@@ -61,4 +62,164 @@ public class UserController {
             throw new BadRequestException(result.getFieldError().getDefaultMessage());
         return userService.loginByMobileAndPwd(loginCommand);
     }
+
+    /**
+     * 申请个人实名认证
+     * @param userId
+     * @param command
+     * @param result
+     * @param session
+     * @return
+     */
+    @LoginRequired
+    @RequestMapping(value = "/user/{userId}/personalAuth", method = RequestMethod.POST)
+    public PersonalAuthVO applyPersonalAuthentication(@PathVariable("userId")Long userId,
+                                                      @Validated @RequestBody ApplyPersonalAuthCommand command,
+                                                      BindingResult result, HttpSession session){
+        if (!userId.equals(Long.parseLong((String)session.getAttribute("userId"))))
+            throw new UnauthorizedException("没有权限对他人账号进行操作！");
+        if (result.hasErrors())
+            throw new BaseException(result.getFieldError().getDefaultMessage());
+        return userService.applyPersonalAuth(userId, command);
+    }
+
+    /**
+     * 修改个人认证信息
+     * @param userId
+     * @param command
+     * @param result
+     * @return
+     */
+    @LoginRequired
+    @RequestMapping(value = "/user/{userId}/personalAuth", method = RequestMethod.PUT)
+    public PersonalAuthVO updatePersonalAuthInfo(@PathVariable("userId")Long userId,
+                                                 @Validated @RequestBody ApplyPersonalAuthCommand command,
+                                                 HttpSession session,
+                                                 BindingResult result){
+        if (result.hasErrors())
+            throw new BaseException(result.getFieldError().getDefaultMessage());
+        return userService.updatePersonalAuthInfo(userId, command);
+    }
+
+
+    /**
+     * 个人认证：通过审核
+     * @param userId
+     * @return
+     */
+    @LoginRequired
+    @SysAdminRequired
+    @RequestMapping(value = "/user/{userId}/personalAuth/status/accept", method = RequestMethod.PUT)
+    public PersonalAuthVO passPersonalAuth(@PathVariable("userId") Long userId){
+        return userService.passPersonalAuth(userId);
+    }
+
+    /**
+     * 个人认证：审核未通过
+     * @param userId
+     * @return
+     */
+    @LoginRequired
+    @SysAdminRequired
+    @RequestMapping(value = "/user/{userId}/personalAuth/status/reject", method = RequestMethod.PUT)
+    public PersonalAuthVO rejectPersonalAuth(@PathVariable("userId") Long userId, @RequestBody @Validated AuthRejectCommand command){
+        return userService.rejectPersonalAuth(userId, command.getExplain());
+    }
+
+    /**
+     * 查看个人认证信息
+     * @param userId
+     * @return
+     */
+    @LoginRequired
+    @RequestMapping(value = "/user/{userId}/personalAuth", method = RequestMethod.GET)
+    public PersonalAuthVO getPersonalAuthInfo(@PathVariable("userId") Long userId){
+        return userService.getPersonalAuthInfo(userId);
+    }
+
+    /**
+     * 获取企业认证信息
+     * @param userId
+     * @return
+     */
+    @LoginRequired
+    @RequestMapping(value = "/user/{userId}/enterpriseAuth", method = RequestMethod.GET)
+    public EnterpriseAuthVO getEnterpriseAuthInfo(@PathVariable("userId") Long userId){
+        return userService.getEnterpriseAuthInfo(userId);
+    }
+
+    /**
+     * 申请企业认证接口
+     * @param userId
+     * @param command
+     * @param result
+     * @param session
+     * @return
+     */
+    @LoginRequired
+    @RequestMapping(value = "/user/{userId}/enterpriseAuth", method = RequestMethod.POST)
+    public EnterpriseAuthVO applyEnterpriseAuth(@PathVariable("userId")Long userId,
+                                                  @Validated @RequestBody ApplyEnterpriseAuthCommand command,
+                                                  BindingResult result, HttpSession session){
+        if (!userId.equals(Long.parseLong((String)session.getAttribute("userId"))))
+            throw new UnauthorizedException("没有权限对他人账号进行操作！");
+        if (result.hasErrors())
+            throw new BaseException(result.getFieldError().getDefaultMessage());
+        return userService.applyEnterpriseAuth(userId, command);
+    }
+
+    /**
+     * 更新企业认证信息
+     * @param userId
+     * @param command
+     * @param result
+     * @return
+     */
+    @LoginRequired
+    @RequestMapping(value = "/user/{userId}/enterpriseAuth", method = RequestMethod.PUT)
+    public EnterpriseAuthVO updatePersonalAuthInfo(@PathVariable("userId")Long userId,
+                                                 @Validated @RequestBody ApplyEnterpriseAuthCommand command,
+                                                 BindingResult result){
+        if (result.hasErrors())
+            throw new BaseException(result.getFieldError().getDefaultMessage());
+        return userService.updateEnterpriseAuthInfo(userId, command);
+    }
+
+    /**
+     * 企业认证：审核通过
+     * @param userId
+     * @return
+     */
+    @LoginRequired
+    @SysAdminRequired
+    @RequestMapping(value = "/user/{userId}/enterpriseAuth/status/accept", method = RequestMethod.PUT)
+    public EnterpriseAuthVO passEnterpriseAuth(@PathVariable("userId") Long userId){
+        return userService.passEnterpriseAuth(userId);
+    }
+
+    /**
+     * 企业认证：审核未通过
+     * @param userId
+     * @return
+     */
+    @LoginRequired
+    @RequestMapping(value = "/user/{userId}/enterpriseAuth/status/reject", method = RequestMethod.PUT)
+    public EnterpriseAuthVO rejectEnterpriseAuth(@PathVariable("userId") Long userId, @RequestBody @Validated AuthRejectCommand command){
+        return userService.rejectEnterpriseAuth(userId, command.getExplain());
+    }
+
+    @LoginRequired
+    @SysAdminRequired
+    @RequestMapping(value = "/user/authentication/handling", method = RequestMethod.GET)
+    public List<BaseAuthVO> getAuthingList(){
+        return userService.getAuthingList();
+    }
+
+    @LoginRequired
+    @SysAdminRequired
+    @RequestMapping(value = "/user/authentication/handled", method = RequestMethod.GET)
+    public List<BaseAuthVO> getAuthedList(){
+        return userService.getAuthedList();
+    }
+
 }

site/src/main/java/com/mooctest/crowd/site/controller/interceptor/SysAdminCheckInterceptor.java

@@ -0,0 +1,57 @@
+package com.mooctest.crowd.site.controller.interceptor;
+
+import com.mooctest.crowd.domain.domainobject.User;
+import com.mooctest.crowd.domain.exception.UnauthorizedException;
+import com.mooctest.crowd.domain.repository.UserRepo;
+import com.mooctest.crowd.site.annotation.SysAdminRequired;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.web.method.HandlerMethod;
+import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-28 00:42
+ */
+@Slf4j
+@Component
+public class SysAdminCheckInterceptor extends HandlerInterceptorAdapter {
+
+    @Autowired
+    private UserRepo userRepo;
+
+    @Override
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
+        if (hasSysAdminRequired(handler)){
+            log.info("系统管理员相关接口，进行身份检测");
+            if (request.getSession().getAttribute("userId") == null)
+                throw new UnauthorizedException("请登录后操作");
+            Long userId = Long.parseLong((String)request.getSession().getAttribute("userId"));
+            User user = userRepo.getByID(userId);
+            if (user.getRoleList().stream().anyMatch(role -> role.getName().equals("SystemAdministrator"))){
+                return true;
+            } else {
+                log.warn("无权限的访问，userId: " + userId);
+                throw new UnauthorizedException("仅有系统管理可进行此操作！");
+            }
+        }
+        return true;
+    }
+
+    private boolean hasSysAdminRequired(Object handler) {
+        if(handler instanceof HandlerMethod) {
+            HandlerMethod handlerMethod = (HandlerMethod) handler;
+            SysAdminRequired sysAdminRequired = handlerMethod.getMethod().getAnnotation(SysAdminRequired.class);
+            if(sysAdminRequired==null){
+                sysAdminRequired = handlerMethod.getBeanType().getAnnotation(SysAdminRequired.class);
+            }
+            return !(sysAdminRequired == null);
+        }
+        return false;
+    }
+}

site/src/main/java/com/mooctest/crowd/site/data/ProjectOperationControl.java

@@ -0,0 +1,19 @@
+package com.mooctest.crowd.site.data;
+
+import lombok.Data;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-23 16:04
+ */
+@Data
+public class ProjectOperationControl {
+    private boolean receive = false;
+    private boolean reject = false;
+    private boolean update = false;
+    private boolean uploadReport = false;
+    private boolean createTask = false;
+    private boolean finish = false;
+    private boolean confirmFinish = false;
+}

site/src/main/java/com/mooctest/crowd/site/data/TaskOperationControl.java

@@ -0,0 +1,31 @@
+package com.mooctest.crowd.site.data;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2019-08-21 20:55
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class TaskOperationControl {
+    private boolean receive = false;
+    private boolean reject = false;
+    private boolean update = false;
+    private boolean uploadReport = false;
+    private boolean finish = false;
+    private boolean confirmFinish = false;
+
+    public void hasAll(){
+        this.receive = true;
+        this.reject = true;
+        this.confirmFinish = true;
+        this.update = true;
+        this.finish = true;
+        this.uploadReport = true;
+    }
+}

site/src/main/java/com/mooctest/crowd/site/data/dto/IndexDTO.java

@@ -2,6 +2,7 @@ package com.mooctest.crowd.site.data.dto;
 
 import com.mooctest.crowd.site.data.vo.EvolutionAgencyVO;
 import com.mooctest.crowd.site.data.vo.CrowdTaskVO;
+import com.mooctest.crowd.site.data.vo.PieChartDataVO;
 import com.mooctest.crowd.site.data.vo.UserVO;
 import lombok.Data;
 
@@ -17,4 +18,5 @@ public class IndexDTO {
     private List<CrowdTaskVO> hotTaskList;
     private List<EvolutionAgencyVO> agencyRank;
     private List<UserVO> userRank;
+    private List<PieChartDataVO> systemStatistics;
 }

site/src/main/java/com/mooctest/crowd/site/data/dto/MyCrowdDTO.java

@@ -2,6 +2,7 @@ package com.mooctest.crowd.site.data.dto;
 
 import com.mooctest.crowd.site.data.vo.CrowdProjectVO;
 import com.mooctest.crowd.site.data.vo.CrowdTaskVO;
+import com.mooctest.crowd.site.data.vo.PieChartDataVO;
 import com.mooctest.crowd.site.data.vo.UserVO;
 import lombok.Data;
 
@@ -16,5 +17,11 @@ public class MyCrowdDTO {
     private UserVO userVO;
     private List<CrowdTaskVO> unfinishedTasks;
     private List<CrowdTaskVO> finishedTasks;
-    private List<CrowdProjectVO> crowdProjectVOList;
+    private List<CrowdProjectVO> myProjects;
+    private List<CrowdProjectVO> handlingProjects;
+    private List<CrowdProjectVO> acceptableProjects;
+    private Long myProjectNoticeCount;
+    private Long processProjectNoticeCount;
+    private Long acceptableProjectNoticeCount;
+
 }

site/src/main/java/com/mooctest/crowd/site/data/dto/ProjectDetailsDTO.java

@@ -1,8 +1,10 @@
 package com.mooctest.crowd.site.data.dto;
 
+import com.mooctest.crowd.site.data.ProjectOperationControl;
 import com.mooctest.crowd.site.data.vo.CrowdProjectVO;
 import com.mooctest.crowd.site.data.vo.CrowdReportVO;
 import com.mooctest.crowd.site.data.vo.CrowdTaskVO;
+import com.mooctest.crowd.site.data.vo.PieChartDataVO;
 import lombok.Data;
 
 import java.util.List;
@@ -16,4 +18,6 @@ public class ProjectDetailsDTO {
     private CrowdProjectVO projectDetails;
     private List<CrowdTaskVO> taskList;
     private List<CrowdReportVO> reportList;
+    private ProjectOperationControl projectOperationControl;
+    private List<PieChartDataVO> progress;
 }