修改项目DO中状态的判断

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

@@ -1,8 +1,10 @@
 package com.mooctest.crowd.domain.controller;
 
 import com.google.gson.Gson;
-import com.mooctest.crowd.domain.domainobject.*;
-import com.mooctest.crowd.domain.exception.BadRequestException;
+import com.mooctest.crowd.domain.domainobject.CrowdTestProject;
+import com.mooctest.crowd.domain.domainobject.CrowdTestReport;
+import com.mooctest.crowd.domain.domainobject.CrowdTestTask;
+import com.mooctest.crowd.domain.domainobject.User;
 import com.mooctest.crowd.domain.repository.CrowdTestProjectRepo;
 import com.mooctest.crowd.domain.repository.UserRepo;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -211,14 +213,13 @@ public class CrowdTestProjectController {
         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.setUserId(user.getId());
         crowdTestProject.setDistributionProvince(user.getProvince());
         crowdTestProject.setDistributionCity(user.getCity());
 
-        CrowdTestProject crowdTestProjectResult = crowdTestProject.createCrowdTestProject();
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.createCrowdTestProject(user);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
@@ -232,13 +233,10 @@ public class CrowdTestProjectController {
     @RequestMapping(value = "releaseProject/{userId}/{crowdTestProjectCode}", method = RequestMethod.GET)
     public String releaseCrowdTestProject(@PathVariable("userId") Long userId,@PathVariable("crowdTestProjectCode") String crowdTestProjectCode){
         CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
-        if(crowdTestProject.getUserId().equals(userId)){
-            CrowdTestProject  crowdTestProjectResult = crowdTestProject.releaseCrowdTestProject();
-            crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
-            return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
-        }else{
-            throw new BadRequestException("当前项目不属于此用户");
-        }
+        User user = userRepo.getByID(userId);
+        CrowdTestProject  crowdTestProjectResult = crowdTestProject.releaseCrowdTestProject(user);
+        crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
+        return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
 
 
@@ -257,11 +255,11 @@ public class CrowdTestProjectController {
     public String receiveTaskByProjectCode(@PathVariable("userForRegionalManagerId") Long userForRegionalManagerId, @PathVariable("crowdTestProjectCode") String crowdTestProjectCode) {
         CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
 
-//        User userForRegionalManager = userRepo.getByID(regionalManagerId);
+        User userForRegionalManager = userRepo.getByID(userForRegionalManagerId);
 //        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
 //        CrowdTestProject crowdTestProjectResult = regionalManager.receiveProject(crowdTestProject);
 
-        CrowdTestProject crowdTestProjectResult = crowdTestProject.receiveProject();
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.receiveProject(userForRegionalManager);
         crowdTestProjectResult.setRegionalManagerId(userForRegionalManagerId);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProject);
         return crowdTestProjectResult.toString();
@@ -291,10 +289,10 @@ public class CrowdTestProjectController {
         //具体操作
         CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
 
-//        User userForRegionalManager = userRepo.getByID(regionalManagerId);
+        User userForRegionalManager = userRepo.getByID(regionalManagerId);
 //        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
 //        CrowdTestProject crowdTestProjectResult = regionalManager.createCrowdTestTask(crowdTestProject, crowdTestTask);
-        CrowdTestProject crowdTestProjectResult = crowdTestProject.createCrowdTestTask(crowdTestTask);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.createCrowdTestTask(crowdTestTask, userForRegionalManager);
         crowdTestTask.setDistributionProvince(crowdTestProject.getDistributionProvince());
         crowdTestTask.setDistributionCity(crowdTestProject.getDistributionCity());
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
@@ -310,8 +308,8 @@ public class CrowdTestProjectController {
     public String releaseCrowdTestTask(@PathVariable("regionalManagerId") Long regionalManagerId,@PathVariable("crowdTestProjectCode") String crowdTestProjectCode,
                                        @PathVariable("crowdTestTaskCode") String crowdTestTaskCode){
         CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
-
-        CrowdTestProject crowdTestProjectResult = crowdTestProject.releaseCrowdTestTask(crowdTestTaskCode);
+        User user = userRepo.getByID(regionalManagerId);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.releaseCrowdTestTask(crowdTestTaskCode, user);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
@@ -332,10 +330,10 @@ public class CrowdTestProjectController {
                                                     @PathVariable("crowdTestTaskCode") String crowdTestTaskCode) {
         CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
 
-//        User userForEvaluationAgency = userRepo.getByID(userForEvaluationAgencyId);
+        User userForEvaluationAgency = userRepo.getByID(userForEvaluationAgencyId);
 //        CrowdTestProject crowdTestProjectResult = userForEvaluationAgency.receiveTask(crowdTestProject, crowdTestTaskCode);
 
-        CrowdTestProject crowdTestProjectResult = crowdTestProject.receiveTask(userForEvaluationAgencyId, crowdTestTaskCode);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.receiveTask(crowdTestTaskCode, userForEvaluationAgency);
 
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
@@ -359,9 +357,9 @@ public class CrowdTestProjectController {
         crowdTestReport.setCreateTime(new Timestamp(System.currentTimeMillis()));
 
         CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
-//        User userForEvaluationAgency = userRepo.getByID(userForEvaluationAgencyId);
+        User userForEvaluationAgency = userRepo.getByID(userForEvaluationAgencyId);
 //        CrowdTestProject crowdTestProjectResult = userForEvaluationAgency.createCrowdTestReport(crowdTestProject, crowdTestTaskCode, crowdTestReport);
-        CrowdTestProject crowdTestProjectResult = crowdTestProject.createCrowdTestReport(crowdTestTaskCode, crowdTestReport);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.createCrowdTestReport(crowdTestTaskCode, crowdTestReport, userForEvaluationAgency);
 
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
@@ -379,10 +377,10 @@ public class CrowdTestProjectController {
                                         @PathVariable("crowdTestTaskCode") String crowdTestTaskCode){
 
         CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
-//        User userForEvaluationAgency = userRepo.getByID(userForEvaluationAgencyId);
+        User userForEvaluationAgency = userRepo.getByID(userForEvaluationAgencyId);
 //        CrowdTestProject crowdTestProjectResult = userForEvaluationAgency.commitCrowdTestTask(crowdTestProject, crowdTestTaskCode);
 
-        CrowdTestProject crowdTestProjectResult = crowdTestProject.commitCrowdTestTask(crowdTestTaskCode);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.commitCrowdTestTask(crowdTestTaskCode, userForEvaluationAgency);
 
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
@@ -398,10 +396,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);
-        CrowdTestProject crowdTestProjectResult = crowdTestProject.finishCrowdTestTask();
+        User user = userRepo.getByID(regionalManagerId);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.finishCrowdTestTask(crowdTestTaskCode,user);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
@@ -425,11 +425,11 @@ public class CrowdTestProjectController {
         crowdTestReport.setDependencyCode(crowdTestProjectCode);
         crowdTestReport.setCreateTime(new Timestamp(System.currentTimeMillis()));
 
-//        User userForRegionalManager = userRepo.getByID(regionalManagerId);
+        User userForRegionalManager = userRepo.getByID(regionalManagerId);
 //        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
 //        CrowdTestProject crowdTestProjectResult = regionalManager.createCrowdTestProjectReport(crowdTestProject, crowdTestReport);
 
-        CrowdTestProject crowdTestProjectResult = crowdTestProject.createCrowdTestProjectReport(crowdTestReport);
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.createCrowdTestProjectReport(crowdTestReport, userForRegionalManager);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
@@ -442,10 +442,10 @@ public class CrowdTestProjectController {
     @RequestMapping(value = "commitProject/{regionalManagerId}/{crowdTestProjectCode}", method = RequestMethod.GET)
     public String commitProject(@PathVariable("regionalManagerId") Long regionalManagerId,@PathVariable("crowdTestProjectCode") String crowdTestProjectCode){
         CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
-//        User userForRegionalManager = userRepo.getByID(regionalManagerId);
+        User userForRegionalManager = userRepo.getByID(regionalManagerId);
 //        RegionalManager regionalManager = userForRegionalManager.getRegionalManager();
 //        CrowdTestProject crowdTestProjectResult = regionalManager.commitCrowdTestProject(crowdTestProject);
-        CrowdTestProject crowdTestProjectResult = crowdTestProject.commitCrowdTestProject();
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.commitCrowdTestProject(userForRegionalManager);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }
@@ -462,9 +462,9 @@ public class CrowdTestProjectController {
     @RequestMapping(value = "finishProject/{userId}/{crowdTestProjectCode}", method = RequestMethod.GET)
     public String finishProject(@PathVariable("userId") Long userId,@PathVariable("crowdTestProjectCode") String crowdTestProjectCode){
         CrowdTestProject crowdTestProject = crowdTestProjectRepo.getByProjectCode(crowdTestProjectCode);
-//        User user = userRepo.getByID(userId);
+        User user = userRepo.getByID(userId);
 //        CrowdTestProject crowdTestProjectResult = user.finishCrowdTestProject(crowdTestProject);
-        CrowdTestProject crowdTestProjectResult = crowdTestProject.finishCrowdTestProject();
+        CrowdTestProject crowdTestProjectResult = crowdTestProject.finishCrowdTestProject(user);
         crowdTestProjectRepo.saveCrowdTestProject(crowdTestProjectResult);
         return crowdTestProjectRepo.getByProjectCode(crowdTestProjectResult.getCode()).toString();
     }

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

@@ -1,10 +1,7 @@
 package com.mooctest.crowd.domain.dao;
 
 import com.mooctest.crowd.domain.model.EvaluationAgencyPO;
-import com.mooctest.crowd.domain.model.RankInfo;
-import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
-import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.PagingAndSortingRepository;
 
 import javax.transaction.Transactional;
@@ -18,6 +15,8 @@ public interface EvaluationAgencyDao extends PagingAndSortingRepository<Evaluati
 
     EvaluationAgencyPO findByUserId(Long userId);
 
+    EvaluationAgencyPO findByUserIdAndIsDeleted(Long userId, int deletedStatus);
+
     List<EvaluationAgencyPO> findByIsAuthentication(int isAuthentication);
 
     @Override

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

@@ -15,6 +15,8 @@ public interface RegionalManagerDao extends PagingAndSortingRepository<RegionalM
 
     List<RegionalManagerPO> findByUserId(Long userId);
 
+    List<RegionalManagerPO> findByUserIdAndIsDeleted(Long userId, int deletedStatus);
+
     RegionalManagerPO findByRegionalId(Long regionalId);
 
     @Override

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

@@ -240,9 +240,7 @@ public class CrowdTestProject {
             crowdTestReportForProject.setIsDeleted(DeletedStatus.isDeleted);
         }
 
-        if(CrowdTestProjectStatus.HAS_REPORTED == this.getStatus()){
-            this.setStatus(CrowdTestProjectStatus.HAS_SPLITED);
-        }else{
+        if((CrowdTestProjectStatus.HAS_COMMITED-1) != this.getStatus()){
             throw new CrowdTestProjectException("项目当前状态不可进行报告删除，当前项目状态为："+this.getStatus());
         }
         return this;
@@ -250,10 +248,9 @@ public class CrowdTestProject {
 
 
     public void addTask(CrowdTestTask task){
-        if (this.getStatus() != CrowdTestProjectStatus.HAS_RECEIVED && this.getStatus() != CrowdTestProjectStatus.HAS_SPLITED)
+        if (this.getStatus() != CrowdTestProjectStatus.HAS_RECEIVED)
             throw new BaseException("当前阶段不允许创建新任务");
         this.getCrowdTestTaskList().add(task);
-        this.setStatus(CrowdTestProjectStatus.HAS_SPLITED);
     }
 
     public CrowdTestTask getTask(String taskCode){
@@ -274,12 +271,18 @@ public class CrowdTestProject {
      * 创建测试项目（普通用户）
      * @return
      */
-    public CrowdTestProject createCrowdTestProject() {
-        //增加设置项目code
+    public CrowdTestProject createCrowdTestProject(User user) {
+        //判断用户是否认证
+        List<Role> roleList = user.getRoleList();
+        if(roleList.size() == 1 && roleList.get(0).getId() == 6L){
+            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;
     }
 
@@ -287,9 +290,20 @@ public class CrowdTestProject {
      * 发布项目（普通用户）
      * @return
      */
-    public CrowdTestProject releaseCrowdTestProject() {
+    public CrowdTestProject releaseCrowdTestProject(User user) {
+        //判断用户是否认证
+        List<Role> roleList = user.getRoleList();
+        if(roleList.size() == 1 && roleList.get(0).getId() == 6L){
+            throw new CrowdTestProjectException("当前用户未进行认证，无创建项目权限");
+        }
+        //判断用户是否为项目发起者
+        if(!this.getUserId().equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户无权限发布此项目");
+        }
+
+        //判断项目状态
         if(this.status != (CrowdTestProjectStatus.HAS_RELEASED-1)){
-            throw new CrowdTestProjectException("当前项目状态不能被发布");
+            throw new CrowdTestProjectException("当前项目状态不能被发布，当前状态为："+this.getStatus());
         }else{
             this.setStatus(CrowdTestProjectStatus.HAS_RELEASED);
         }
@@ -297,41 +311,85 @@ public class CrowdTestProject {
     }
 
     /**
-     * 创建测试任务
-     * @param crowdTestTask
+     * 接收项目（区域管理员）
      * @return
      */
-    public CrowdTestProject createCrowdTestTask(CrowdTestTask crowdTestTask) {
-        List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
-
-        //增加设置任务code
-//        String taskCode = GenerateFlowCodeUtil.generateFlowCode("TASK-"+ command.getType());
-//        crowdTestTask.setCode(taskCode);
-
-        crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_CREATED);
+    public CrowdTestProject receiveProject(User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限接收此项目");
+        }
 
-        //添加测试任务
-        crowdTestTaskList.add(crowdTestTask);
+        //判断项目状态
+        if(this.getStatus() != (CrowdTestProjectStatus.HAS_RECEIVED-1)){
+            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<Regional> regionalList = regionalManager.getRegionalList();
+                boolean isValidCity = false;
+                //判断管理员管辖的区域是否符合要求
+                for(Regional regional : regionalList){
+                    if(this.getDistributionCity().equals(regional.getName())){
+                        isValidCity = true;
+                    }
+                }
 
-        //修改项目状态
-        if(CrowdTestProjectStatus.HAS_SPLITED != this.getStatus()){
-            this.setStatus(CrowdTestProjectStatus.HAS_SPLITED);
+                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);
+            }
         }
-        this.setCrowdTestTaskList(crowdTestTaskList);
         return this;
     }
 
     /**
-     * 接收项目（区域管理员）
+     * 创建测试任务（区域管理员）
+     * @param crowdTestTask
      * @return
      */
-    public CrowdTestProject receiveProject() {
-        if(this.getRegionalManagerId() != null){
-            throw new CrowdTestProjectException("项目已被接收");
-        }else if(this.getStatus() != (CrowdTestProjectStatus.HAS_RECEIVED-1)){
-            throw new CrowdTestProjectException("项目不能被接收，项目状态为: " + this.getStatus());
+    public CrowdTestProject createCrowdTestTask(CrowdTestTask crowdTestTask, User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限创建测试任务");
+        }
+
+        //判断是否是当前项目的区域管理员
+        if(!this.getRegionalManagerId().equals(user.getId())){
+            throw new CrowdTestTaskException("当前用户没有权限为此项目创建测试任务！");
         }else{
-            this.setStatus(CrowdTestProjectStatus.HAS_RECEIVED);
+            //判断项目状态
+            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;
     }
@@ -341,23 +399,33 @@ public class CrowdTestProject {
      * @param crowdTestTaskCode
      * @return
      */
-    public CrowdTestProject releaseCrowdTestTask(String crowdTestTaskCode) {
-        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);
+    public CrowdTestProject releaseCrowdTestTask(String crowdTestTaskCode, User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限发布测试任务");
+        }
+
+        //判断是否是当前项目的区域管理员
+        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);
             }
-            crowdTestTaskListResult.add(crowdTestTask);
+            this.setCrowdTestTaskList(crowdTestTaskListResult);
+            return this;
         }
-
-        this.setCrowdTestTaskList(crowdTestTaskListResult);
-        return this;
     }
 
 
@@ -365,17 +433,44 @@ public class CrowdTestProject {
      * 接收任务（测评机构）
      * @return
      */
-    public CrowdTestProject receiveTask(Long userForEvaluationAgencyId, String crowdTestTaskCode) {
+    public CrowdTestProject receiveTask(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(crowdTestTaskCode.equals(crowdTestTask.getCode())){
+                //判断任务状态
                 if(crowdTestTask.getStatus() != (CrowdTestTaskStatus.HAS_RECEIVED - 1)){
                     throw new CrowdTestTaskException("任务当前状态不能被接收，当前状态为："+crowdTestTask.getStatus());
                 }else{
-                    crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_RECEIVED);
-                    crowdTestTask.setEvaluationAgencyId(userForEvaluationAgencyId);
+                    //任务是定向发布
+                    if(crowdTestTask.getDistributionType() == 0){
+                        if(!crowdTestTask.getEvaluationAgencyId().equals(user.getId())){
+                            throw new CrowdTestTaskException("当前用户没有权限接收此定向发布的任务！");
+                        }else{
+                            crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_RECEIVED);
+                        }
+                    }
+                    //任务是区域发布
+                    else if(crowdTestTask.getDistributionType() == 1){
+                        //判断测评机构的区域是否符合要求
+                        if(!crowdTestTask.getDistributionCity().equals(user.getCity())){
+                            throw new CrowdTestTaskException("任务发布的区域不符合当前测评机构的区域！");
+                        }else{
+                            crowdTestTask.setEvaluationAgencyId(user.getId());
+                            crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_RECEIVED);
+                        }
+                    }
+                    //任务是广场发布
+                    else{
+                        crowdTestTask.setEvaluationAgencyId(user.getId());
+                        crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_RECEIVED);
+                    }
                 }
             }
             crowdTestTaskListResult.add(crowdTestTask);
@@ -391,46 +486,69 @@ public class CrowdTestProject {
      * @param crowdTestReport
      * @return
      */
-    public CrowdTestProject createCrowdTestReport(String crowdTestTaskCode, CrowdTestReport crowdTestReport) {
+    public CrowdTestProject createCrowdTestReport(String crowdTestTaskCode, CrowdTestReport crowdTestReport, User user) {
+        //判断是否为测评机构
+        EvaluationAgency evaluationAgency = user.getEvaluationAgency();
+        if(evaluationAgency == null){
+            throw new UserNotExistException("当前用户不是测评机构，没有权限创建测试报告");
+        }
         List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
         List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
         for(CrowdTestTask crowdTestTask : crowdTestTaskList){
             if(crowdTestTask.getCode().equals(crowdTestTaskCode)){
-//                //设置报告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);
+                //判断是否是当前任务的测评机构
+                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);
+                    }
+                }
             }
-            crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_REPORTED);
-            crowdTestTaskListResult.add(crowdTestTask);
         }
         this.setCrowdTestTaskList(crowdTestTaskListResult);
         return this;
     }
 
     /**
-     * 提交测试任务
+     * 提交测试任务（测评机构）
      * @param crowdTestTaskCode
      * @return
      */
-    public CrowdTestProject commitCrowdTestTask(String crowdTestTaskCode) {
+    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)){
-                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);
-                    crowdTestTask.setEndTime(new Timestamp(System.currentTimeMillis()));
+                //判断是否是当前任务的测评机构
+                if(!crowdTestTask.getEvaluationAgencyId().equals(user.getId())){
+                    throw new CrowdTestTaskException("当前用户没有权限提交任务！");
+                }else{
+                    if(crowdTestTask.getCrowdTestReportList().size() == 0){
+                        throw new CrowdTestTaskException("当前任务中没有报告，不能提交此任务");
+                    }
+                    if(crowdTestTask.getStatus() != (CrowdTestTaskStatus.HAS_COMMITED-1)){
+                        throw new CrowdTestTaskException("当前任务无法提交，任务状态为："+crowdTestTask.getStatus());
+                    }else{
+                        crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_COMMITED);
+                    }
                 }
             }
             crowdTestTaskListResult.add(crowdTestTask);
@@ -443,75 +561,136 @@ public class CrowdTestProject {
      * 结束任务（区域管理员）
      * @return
      */
-    public CrowdTestProject finishCrowdTestTask() {
-        List<CrowdTestTask> crowdTestTaskList = this.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);
+    public CrowdTestProject finishCrowdTestTask(String crowdTestTaskCode, User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限结束测试任务");
+        }
+
+        //判断是否是当前项目的区域管理员
+        if(!this.regionalManagerId.equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户没有权限结束当前项目下的任务！");
+        }
+
+        //项目状态判断
+        if(this.getStatus() != (CrowdTestProjectStatus.HAS_COMMITED-1)){
+            throw new CrowdTestProjectException("当前项目状态不可结束任务！");
+        }else {
+            List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
+            List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
+
+            for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+                if(crowdTestTaskCode.equals(crowdTestTask.getCode())){
+                    if(crowdTestTask.getStatus() != (CrowdTestTaskStatus.HAS_FINISHED-1)){
+                        throw new CrowdTestTaskException("当前任务不能被结束，任务状态为："+crowdTestTask.getStatus());
+                    }else{
+                        //结束任务时修改任务状态为"已结束"
+                        crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_FINISHED);
+                        crowdTestTask.setEndTime(new Timestamp(System.currentTimeMillis()));
+                    }
+                }
+                crowdTestTaskListResult.add(crowdTestTask);
             }
-            crowdTestTaskListResult.add(crowdTestTask);
+
+            this.setCrowdTestTaskList(crowdTestTaskListResult);
         }
 
-        this.setCrowdTestTaskList(crowdTestTaskListResult);
+
         return this;
     }
 
     /**
-     * 创建项目报告
+     * 创建项目报告（区域管理员）
      * @param crowdTestReport
      * @return
      */
-    public CrowdTestProject createCrowdTestProjectReport(CrowdTestReport crowdTestReport) {
-        crowdTestReport.setScope(0);
-        crowdTestReport.setDependencyCode(this.getCode());
+    public CrowdTestProject createCrowdTestProjectReport(CrowdTestReport crowdTestReport, User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限创建项目报告");
+        }
 
-        this.setCrowdTestReportForProject(crowdTestReport);
-        if(this.getStatus() != (CrowdTestProjectStatus.HAS_REPORTED - 1)){
-            throw new CrowdTestProjectException("项目报告不能被提交，当前状态为："+this.getStatus());
-        }else {
-            this.setStatus(CrowdTestProjectStatus.HAS_REPORTED);
+        //判断是否是当前项目的区域管理员
+        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 this;
     }
 
     /**
-     * 提交项目
+     * 提交项目（区域管理员）
      * @return
      */
-    public CrowdTestProject commitCrowdTestProject() {
-        List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
-        if(this.getCrowdTestReportForProject() == null){
-            throw new CrowdTestProjectException("还未创建项目报告，项目不能被提交");
+    public CrowdTestProject commitCrowdTestProject(User user) {
+        //判断是否为区域管理员
+        RegionalManager regionalManager = user.getRegionalManager();
+        if(regionalManager == null){
+            throw new UserNotExistException("当前用户不是区域管理员，没有权限提交项目");
         }
 
-        //结束项目时查看是否已结束任务
-        if(this.getStatus() != (CrowdTestProjectStatus.HAS_COMMITED - 1)){
-            throw new CrowdTestProjectException("项目不能被结束，状态为："+this.getStatus());
+        //判断是否是当前项目的区域管理员
+        if(!this.regionalManagerId.equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户没有权限提交项目！");
+        }
+
+        //项目状态判断
+        if(this.getStatus() != (CrowdTestProjectStatus.HAS_COMMITED-1)){
+            throw new CrowdTestProjectException("当前项目状态不可提交项目！状态为："+this.getStatus());
+        }
+
+        //判断项目下是否有任务
+        List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
+        if(crowdTestTaskList.size() < 1){
+            throw new CrowdTestProjectException("还未创建任务，项目不能被提交");
         }else{
+            //结束项目时查看是否已结束任务
             for(CrowdTestTask crowdTestTask : crowdTestTaskList){
                 if(crowdTestTask.getStatus() != CrowdTestTaskStatus.HAS_FINISHED){
                     throw new CrowdTestTaskException("存在未结束的任务，项目不能被提交");
                 }
             }
         }
+
+        //判断项目下是否有项目报告
+        if(this.getCrowdTestReportForProject() == null){
+            throw new CrowdTestProjectException("还未创建项目报告，项目不能被提交");
+        }
+
         this.setStatus(CrowdTestProjectStatus.HAS_COMMITED);
         this.setEndTime(new Timestamp(System.currentTimeMillis()));
         return this;
     }
 
     /**
-     * 结束项目
+     * 结束项目（项目发起者）
      * @return
      */
-    public CrowdTestProject finishCrowdTestProject() {
+    public CrowdTestProject finishCrowdTestProject(User user) {
+        //判断用户是否认证
+        List<Role> roleList = user.getRoleList();
+        if(roleList.size() == 1 && roleList.get(0).getId() == 6L){
+            throw new CrowdTestProjectException("当前用户未进行认证，无创建项目权限");
+        }
+        //判断是否为项目发起者
+        if(!this.getUserId().equals(user.getId())){
+            throw new CrowdTestProjectException("当前用户没有权限结束项目!");
+        }
+
         if(this.getStatus() != (CrowdTestProjectStatus.HAS_FINISHED - 1)){
             throw new CrowdTestProjectException("项目不能被提交，当前状态为："+this.getStatus());
         }else{
             this.setStatus(CrowdTestProjectStatus.HAS_FINISHED);
+            this.setEndTime(new Timestamp(System.currentTimeMillis()));
         }
         return this;
     }

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

@@ -8,8 +8,8 @@ public class CrowdTestProjectStatus {
     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/CrowdTestTaskStatus.java

@@ -8,7 +8,7 @@ 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_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/RegionalManager.java

@@ -2,6 +2,7 @@ package com.mooctest.crowd.domain.domainobject;
 
 import lombok.Data;
 
+import java.sql.Timestamp;
 import java.util.List;
 
 /**
@@ -12,21 +13,21 @@ import java.util.List;
 public class RegionalManager {
     private Long id;
     private Long userId;
-//    private Long regionalId;
-
-//    private Regional regional;
+    private int isDeleted;
     private List<Regional> regionalList;
+    private Timestamp createTime;
 
     @Override
     public String toString() {
         return "RegionalManager{" +
                 "id=" + id +
                 ", userId=" + userId +
+                ", isDeleted=" + isDeleted +
                 ", regionalList=" + regionalList +
+                ", createTime=" + createTime +
                 '}';
     }
 
-
 //    /**
 //     * 区域管理员接收项目
 //     * @param crowdTestProject

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

@@ -198,6 +198,7 @@ public class User {
         personalAuth.setIsAuthentication(AuthenticationStatus.isAuthenIng);
         personalAuth.setIsDeleted(DeletedStatus.isNotDeleted);
         personalAuth.setApplyTime(new Timestamp(System.currentTimeMillis()));
+        personalAuth.setExplain("");
         this.setPersonalAuth(personalAuth);
         return this;
     }
@@ -213,6 +214,7 @@ public class User {
             }else{
                 this.getPersonalAuth().setIsAuthentication(AuthenticationStatus.isAuthenticated);
                 this.getPersonalAuth().setCheckTime(new Timestamp(System.currentTimeMillis()));
+                this.getPersonalAuth().setExplain("");
                 List<Role> roleList = this.getRoleList();
                 Role role = new Role();
                 role.setId(1L);

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

@@ -5,4 +5,7 @@ package com.mooctest.crowd.domain.exception;
  * @Date: 2019.7.5 14:36
  */
 public class UserNotExistException extends BaseException {
+    public UserNotExistException(String msg){
+        super(msg);
+    }
 }

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

@@ -3,6 +3,7 @@ package com.mooctest.crowd.domain.model;
 import lombok.Data;
 
 import javax.persistence.*;
+import java.sql.Timestamp;
 
 /**
  * @author guochao
@@ -24,12 +25,10 @@ public class RegionalManagerPO {
     @Column(name = "RMTP_R_CODE")
     private Long regionalId;
 
-    @Override
-    public String toString() {
-        return "RegionalManagerPO{" +
-                "id=" + id +
-                ", userId=" + userId +
-                ", regionalId='" + regionalId + '\'' +
-                '}';
-    }
+    @Column(name = "RMTP_IS_DELETED")
+    private int isDeleted;
+
+    @Column(name = "RMTP_CREATED_TIME")
+    private Timestamp createTime;
+
 }

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

@@ -71,7 +71,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;
@@ -82,7 +82,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;
@@ -328,7 +328,7 @@ 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);
 
@@ -364,31 +364,27 @@ public class UserRepo implements IUserRepo {
         }
 
         /*获取区域管理员信息*/
-        List<RegionalManagerPO> regionalManagerPOList = regionalManagerDao.findByUserId(userPO.getId());
-//        List<RegionalManager> regionalManagerListResult = new ArrayList<>();
-        List<Regional> regionalList = new ArrayList<>();
-        RegionalManager regionalManager = new RegionalManager();
-        regionalManager.setUserId(userPO.getId());
-        for(RegionalManagerPO regionalManagerPO : regionalManagerPOList){
-
-            if(regionalManagerPO != null){
-                /*获取区域管理员管理的区域信息*/
-                RegionalManager regionalManagerResult = Converter.convert(RegionalManager.class, regionalManagerPO);
-                Optional<RegionalPO> regionalPOOptional = regionalDao.findById(regionalManagerPO.getRegionalId());
-                if(regionalPOOptional.isPresent()){
-                    RegionalPO regionalPO = regionalPOOptional.get();
-                    Regional regionalResult = Converter.convert(Regional.class, regionalPO);
-                    regionalList.add(regionalResult);
-//                    regionalManagerResult.setRegional(regionalResult);
+        List<RegionalManagerPO> regionalManagerPOList = regionalManagerDao.findByUserIdAndIsDeleted(userPO.getId(), DeletedStatus.isNotDeleted);
+        if(regionalManagerPOList.size() > 0){
+            List<Regional> regionalList = new ArrayList<>();
+            RegionalManager regionalManager = new RegionalManager();
+            regionalManager.setUserId(userPO.getId());
+            for(RegionalManagerPO regionalManagerPO : regionalManagerPOList){
+                if(regionalManagerPO != null){
+                    regionalManager.setId(regionalManagerPO.getId());
+                    /*获取区域管理员管理的区域信息*/
+                    Optional<RegionalPO> regionalPOOptional = regionalDao.findById(regionalManagerPO.getRegionalId());
+                    if(regionalPOOptional.isPresent()){
+                        RegionalPO regionalPO = regionalPOOptional.get();
+                        Regional regionalResult = Converter.convert(Regional.class, regionalPO);
+                        regionalList.add(regionalResult);
+                    }
                 }
-//                regionalManagerListResult.add(regionalManagerResult);
-            }
 
+            }
+            regionalManager.setRegionalList(regionalList);
+            userResult.setRegionalManager(regionalManager);
         }
-
-        regionalManager.setRegionalList(regionalList);
-//        userResult.setRegionalManagerInfo(regionalManagerListResult);
-        userResult.setRegionalManager(regionalManager);
         return userResult;
     }
 

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

@@ -226,12 +226,12 @@ public class CrowdTestProjectTest {
     public void should_return_project_when_remove_project_report() {
         //arrange
         crowdTestProject.getCrowdTestReportForProject().setIsDeleted(DeletedStatus.isNotDeleted);
-        crowdTestProject.setStatus(CrowdTestProjectStatus.HAS_REPORTED);
+//        crowdTestProject.setStatus(CrowdTestProjectStatus.HAS_REPORTED);
         //action
         CrowdTestProject crowdTestProjectResult = this.crowdTestProject.removeCrowdTestProjectReport();
         //assert
         Assert.assertEquals(crowdTestProjectResult.getCrowdTestReportForProject().getIsDeleted(),DeletedStatus.isDeleted);
-        Assert.assertEquals(crowdTestProjectResult.getStatus(),CrowdTestProjectStatus.HAS_SPLITED);
+//        Assert.assertEquals(crowdTestProjectResult.getStatus(),CrowdTestProjectStatus.HAS_SPLITED);
     }
 
     @Test(expected = CrowdTestProjectException.class)

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

@@ -18,9 +18,7 @@ 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
@@ -71,7 +69,7 @@ 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{
             //将用户中心的用户中心的用户数据对本系统内同步,直同步用户邮箱、手机号、密码

site/src/main/java/com/mooctest/crowd/site/service/impl/CrowdProjectServiceImpl.java

@@ -28,8 +28,8 @@ import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
 
 import java.io.IOException;
-import java.sql.Timestamp;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;
@@ -177,7 +177,8 @@ public class CrowdProjectServiceImpl implements CrowdProjectService {
     public void receiveProject(String projectCode, Long userId) {
         CrowdTestProject project = projectRepo.getByProjectCode(projectCode);
 //        if (project.getProjectDistributionTypeId())
-        project.receiveProject();
+        User user = userRepo.getByID(userId);
+        project.receiveProject(user);
         projectRepo.saveCrowdTestProject(project);
     }
 

site/src/main/java/com/mooctest/crowd/site/service/impl/CrowdReportServiceImpl.java

@@ -108,7 +108,7 @@ public class CrowdReportServiceImpl implements CrowdReportService {
     @Override
     public ReportDetailsDTO createProjectReport(String projectCode, CrowdTestReportCommand command) {
         CrowdTestProject project = projectRepo.getByProjectCode(projectCode);
-        if (project.getStatus() >= CrowdTestProjectStatus.HAS_REPORTED)
+        if (project.getStatus() >= CrowdTestProjectStatus.HAS_COMMITED)
             throw new BaseException("当前阶段无法创建报告");
         CrowdTestReport report = command.toCrowdTestReport();
         String reportCode = GenerateFlowCodeUtil.generateFlowCode("REPORT");
@@ -122,7 +122,7 @@ public class CrowdReportServiceImpl implements CrowdReportService {
     @Override
     public ReportDetailsDTO updatePorjctReport(String projectCode, String reportCode, CrowdTestReportCommand command) {
         CrowdTestProject project = projectRepo.getByProjectCode(projectCode);
-        if (project.getStatus() >= CrowdTestProjectStatus.HAS_REPORTED)
+        if (project.getStatus() >= CrowdTestProjectStatus.HAS_COMMITED)
             throw new BaseException("当前阶段无法修改报告");
         CrowdTestReport report = project.getCrowdTestReportForProject();
         if (report==null)

site/src/main/java/com/mooctest/crowd/site/service/impl/CrowdTaskServiceImpl.java

@@ -19,7 +19,6 @@ import com.mooctest.crowd.site.data.dto.TaskSquareDTO;
 import com.mooctest.crowd.site.data.enums.ProjectType;
 import com.mooctest.crowd.site.data.vo.CrowdReportVO;
 import com.mooctest.crowd.site.data.vo.CrowdTaskVO;
-import com.mooctest.crowd.site.data.vo.EvolutionAgencyVO;
 import com.mooctest.crowd.site.mediator.ViewMediator;
 import com.mooctest.crowd.site.service.CrowdTaskService;
 import com.mooctest.crowd.site.util.GenerateFlowCodeUtil;
@@ -28,7 +27,6 @@ import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;
@@ -148,10 +146,12 @@ public class CrowdTaskServiceImpl implements CrowdTaskService {
                     taskOperationControl.setReceive(true);
                 } else if (task.getStatus() == CrowdTestTaskStatus.HAS_RECEIVED){
                     taskOperationControl.setUploadReport(true);
-                } else if (task.getStatus() == CrowdTestTaskStatus.HAS_REPORTED){
-                    taskOperationControl.setFinish(true);
-                    taskOperationControl.setUploadReport(true);
-                } else if (task.getStatus() == CrowdTestTaskStatus.HAS_COMMITED){
+                }
+//                else if (task.getStatus() == CrowdTestTaskStatus.HAS_REPORTED){
+//                    taskOperationControl.setFinish(true);
+//                    taskOperationControl.setUploadReport(true);
+//                }
+                else if (task.getStatus() == CrowdTestTaskStatus.HAS_COMMITED){
                     taskOperationControl.setUploadReport(true);
                 }
             } else if (task.getDistributionType()==2){