修改规范代码。

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

@@ -1,5 +1,6 @@
 package com.mooctest.crowd.domain.dao;
 
+import com.mooctest.crowd.domain.domainobject.CrowdTestTask;
 import com.mooctest.crowd.domain.model.CrowdTestProjectPO;
 import com.mooctest.crowd.domain.model.CrowdTestTaskPO;
 import com.mooctest.crowd.domain.model.RankInfo;
@@ -23,6 +24,7 @@ import java.util.List;
 public interface CrowdTestTaskDao extends CrudRepository<CrowdTestTaskPO, Long>, JpaRepository<CrowdTestTaskPO, Long>, PagingAndSortingRepository<CrowdTestTaskPO, Long> {
 
 
+
     Page<CrowdTestTaskPO> findAll(Specification specification, Pageable pageable);
 
     CrowdTestTaskPO findByIdAndIsDeleted(Long id, int isDeleted);

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

@@ -52,12 +52,13 @@ public class CrowdTestProject {
 
     /**
      * 更新项目信息
+     *
      * @param crowdTestProjectModify
      * @return
      */
-    public CrowdTestProject updateCrowdTestProject( CrowdTestProject crowdTestProjectModify){
+    public CrowdTestProject updateCrowdTestProject(CrowdTestProject crowdTestProjectModify) {
         Gson gson = new Gson();
-        return gson.fromJson(gson.toJson(crowdTestProjectModify),CrowdTestProject.class);
+        return gson.fromJson(gson.toJson(crowdTestProjectModify), CrowdTestProject.class);
     }
 
     /**
@@ -204,6 +205,7 @@ public class CrowdTestProject {
 
     /**
      * 删除项目报告（区域管理员）
+     *
      * @return
      */
 //    public CrowdTestProject removeCrowdTestProjectReport(String crowdTestProjectReportCode,User user) {
@@ -228,17 +230,16 @@ public class CrowdTestProject {
 //        }
 //        return this;
 //    }
-
-    public void addTask(CrowdTestTask task){
-        if (!(this.getStatus() >= CrowdTestProjectStatus.HAS_RECEIVED || this.getStatus()<=CrowdTestTaskStatus.HAS_COMMITED))
+    public void addTask(CrowdTestTask task) {
+        if (!(this.getStatus() >= CrowdTestProjectStatus.HAS_RECEIVED || this.getStatus() <= CrowdTestTaskStatus.HAS_COMMITED))
             throw new BaseException("当前阶段不允许创建新任务");
-        if (this.getRestPrice() < task.getQuotedPrice()){
+        if (this.getRestPrice() < task.getQuotedPrice()) {
             throw new BaseException("任务的报价不能超过项目的剩余价格，项目的剩余价格为：" + this.getRestPrice());
         }
-        if (this.getDeadTime().getTime() < task.getDeadTime().getTime()){
+        if (this.getDeadTime().getTime() < task.getDeadTime().getTime()) {
             throw new BaseException("任务截止时间不能超过项目的截止时间，项目的截止时间为：" + this.getDeadTime());
         }
-        if (task.getDeadTime().getTime() < System.currentTimeMillis()){
+        if (task.getDeadTime().getTime() < System.currentTimeMillis()) {
             throw new BaseException("任务截止时间不能小于当前时间");
         }
         this.setRestPrice(this.getRestPrice() - task.getQuotedPrice());
@@ -251,24 +252,24 @@ public class CrowdTestProject {
         this.getCrowdTestTaskList().remove(task);
     }
 
-    public CrowdTestTask getTask(String taskCode){
+    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){
+    public CrowdTestReport getTaskReport(String taskCode, String reportCode) {
         List<TaskToUser> acceptedUserList = getTask(taskCode).getAcceptedUserList();
         boolean flag = false;
-        for(TaskToUser taskToUser : acceptedUserList){
+        for (TaskToUser taskToUser : acceptedUserList) {
             Optional<CrowdTestReport> report = taskToUser.getCrowdTestReportList().stream().filter(crowdTestReport -> crowdTestReport.getCode().equals(reportCode)
                     && crowdTestReport.getUserId().equals(userId)).findFirst();
-            if (report.isPresent()){
+            if (report.isPresent()) {
                 return report.get();
             }
         }
-        if(!flag){
+        if (!flag) {
             throw new CrowdTestReportNotExistException();
         }
         return null;
@@ -276,6 +277,7 @@ public class CrowdTestProject {
 
     /**
      * 创建测试项目（普通用户）
+     *
      * @return
      */
     public CrowdTestProject createCrowdTestProject(User user) {
@@ -294,22 +296,23 @@ public class CrowdTestProject {
 
     /**
      * 发布项目（普通用户）
+     *
      * @return
      */
     public CrowdTestProject releaseCrowdTestProject(User user) {
         //判断用户是否认证
-        if(user.getPersonalAuthentication() == null && user.getEnterpriseAuthentication() == null && user.getRegionalManager() == null && user.getEvaluationAgency() == null){
+        if (user.getPersonalAuthentication() == null && user.getEnterpriseAuthentication() == null && user.getRegionalManager() == null && user.getEvaluationAgency() == null) {
             throw new CrowdTestProjectException("当前用户未进行认证，无权限对项目操作");
         }
         //判断用户是否为项目发起者
-        if(!this.getUserId().equals(user.getId())){
+        if (!this.getUserId().equals(user.getId())) {
             throw new CrowdTestProjectException("当前用户无权限发布此项目");
         }
 
         //判断项目状态
-        if(this.status != (CrowdTestProjectStatus.HAS_RELEASED-1)){
-            throw new CrowdTestProjectException("当前项目状态不能被发布，当前状态为："+this.getStatus());
-        }else{
+        if (this.status != (CrowdTestProjectStatus.HAS_RELEASED - 1)) {
+            throw new CrowdTestProjectException("当前项目状态不能被发布，当前状态为：" + this.getStatus());
+        } else {
             this.setStatus(CrowdTestProjectStatus.HAS_RELEASED);
         }
         return this;
@@ -317,54 +320,55 @@ public class CrowdTestProject {
 
     /**
      * 接收项目（区域管理员）
+     *
      * @return
      */
     public CrowdTestProject receiveProject(User user) {
         //判断是否为区域管理员
         RegionalManager regionalManager = user.getRegionalManager();
-        if(regionalManager == null){
+        if (regionalManager == null) {
             throw new UserNotExistException("当前用户不是区域管理员，没有权限接收项目");
         }
 
         //判断项目状态
-        if(this.getStatus() != CrowdTestProjectStatus.HAS_RELEASED){
-            throw new CrowdTestProjectException("项目不能被接收，项目已被接收" );
-        }else{
+        if (this.getStatus() != CrowdTestProjectStatus.HAS_RELEASED) {
+            throw new CrowdTestProjectException("项目不能被接收，项目已被接收");
+        } else {
             //项目是定向发布
-            if(this.getProjectDistributionTypeId() == 0){
-                if(!this.getRegionalManagerId().equals(user.getId())){
+            if (this.getProjectDistributionTypeId() == 0) {
+                if (!this.getRegionalManagerId().equals(user.getId())) {
                     throw new CrowdTestProjectException("当前用户没有权限接收此定向发布的项目！");
-                }else{
+                } else {
                     this.setStatus(CrowdTestProjectStatus.HAS_RECEIVED);
                 }
             }
             //项目是区域发布
-            else if(this.getProjectDistributionTypeId() == 1){
+            else if (this.getProjectDistributionTypeId() == 1) {
                 List<RegionalManagerToRegional> regionalList = regionalManager.getRegionalList();
                 boolean isValidCity = false;
                 //判断管理员管辖的区域是否符合要求
-                for(RegionalManagerToRegional regional : regionalList){
+                for (RegionalManagerToRegional regional : regionalList) {
                     //判断市是否相同
-                    if(this.getDistributionCity().equals(regional.getCity())){
+                    if (this.getDistributionCity().equals(regional.getCity())) {
                         isValidCity = true;
                     }
                     //如果市区是"*",则判断省份是否相同
-                    if(regional.getCity().equals("*")){
-                        if(this.getDistributionProvince().equals(regional.getProvince())){
+                    if (regional.getCity().equals("*")) {
+                        if (this.getDistributionProvince().equals(regional.getProvince())) {
                             isValidCity = true;
                         }
                     }
                 }
 
-                if(!isValidCity){
+                if (!isValidCity) {
                     throw new CrowdTestProjectException("项目发布的区域不符合当前区域管理员所管辖的区域！");
-                }else{
+                } else {
                     this.setRegionalManagerId(user.getId());
                     this.setStatus(CrowdTestProjectStatus.HAS_RECEIVED);
                 }
             }
             //项目是广场发布
-            else{
+            else {
                 this.setRegionalManagerId(user.getId());
                 this.setStatus(CrowdTestProjectStatus.HAS_RECEIVED);
             }
@@ -374,24 +378,25 @@ public class CrowdTestProject {
 
     /**
      * 创建测试任务（区域管理员）
+     *
      * @param crowdTestTask
      * @return
      */
     public CrowdTestProject createCrowdTestTask(CrowdTestTask crowdTestTask, User user) {
         //判断是否为区域管理员
         RegionalManager regionalManager = user.getRegionalManager();
-        if(regionalManager == null){
+        if (regionalManager == null) {
             throw new UserNotExistException("当前用户不是区域管理员，没有权限创建测试任务");
         }
 
         //判断是否是当前项目的区域管理员
-        if(!this.getRegionalManagerId().equals(user.getId())){
+        if (!this.getRegionalManagerId().equals(user.getId())) {
             throw new CrowdTestTaskException("当前用户没有权限为此项目创建测试任务！");
-        }else{
+        } else {
             //判断项目状态
-            if(this.getStatus() != (CrowdTestProjectStatus.HAS_COMMITED-1)){
+            if (this.getStatus() != (CrowdTestProjectStatus.HAS_COMMITED - 1)) {
                 throw new CrowdTestProjectException("当前项目状态不能创建任务，项目状态为: " + this.getStatus());
-            }else{
+            } else {
                 List<CrowdTestTask> crowdTestTaskList = this.getCrowdTestTaskList();
 //            //增加设置任务code -------需要加上
 //            String taskCode = GenerateFlowCodeUtil.generateFlowCode("TASK-"+ command.getType());
@@ -408,28 +413,29 @@ public class CrowdTestProject {
 
     /**
      * 发布任务（区域管理员）
+     *
      * @param crowdTestTaskCode
      * @return
      */
     public CrowdTestProject releaseCrowdTestTask(String crowdTestTaskCode, User user) {
         //判断是否为区域管理员
         RegionalManager regionalManager = user.getRegionalManager();
-        if(regionalManager == null){
+        if (regionalManager == null) {
             throw new UserNotExistException("当前用户不是区域管理员，没有权限发布测试任务");
         }
 
         //判断是否是当前项目的区域管理员
-        if(!this.regionalManagerId.equals(user.getId())){
+        if (!this.regionalManagerId.equals(user.getId())) {
             throw new CrowdTestProjectException("当前用户没有权限发布的当前项目下的任务！");
-        }else {
+        } 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{
+            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);
                     }
                 }
@@ -442,12 +448,13 @@ public class CrowdTestProject {
 
     /**
      * 接收任务（测评机构）
+     *
      * @return
      */
     public CrowdTestProject receiveTask(String crowdTestTaskCode, User user) {
         //判断是否为测评机构
         EvaluationAgency evaluationAgency = user.getEvaluationAgency();
-        if(evaluationAgency == null){
+        if (evaluationAgency == null) {
             throw new UnauthorizedException("当前用户不是测评机构，没有权限接收任务");
         }
         Optional<CrowdTestTask> taskOp = this.getCrowdTestTaskList().stream().filter(task -> task.getCode().equals(crowdTestTaskCode)).findFirst();
@@ -456,8 +463,8 @@ public class CrowdTestProject {
             throw new CrowdTestTaskNotExistException();
         CrowdTestTask task = taskOp.get();
         //任务当前状态
-        if (task.getStatus()!=CrowdTestTaskStatus.HAS_RELEASED)
-            throw new CrowdTestTaskException("任务当前状态不能被接收，当前状态为："+task.getStatus());
+        if (task.getStatus() != CrowdTestTaskStatus.HAS_RELEASED)
+            throw new CrowdTestTaskException("任务当前状态不能被接收，当前状态为：" + task.getStatus());
         //定向发布类型
         if (task.getDistributionType() == 0) {
             if (!task.getEvaluationAgencyId().equals(user.getId()))
@@ -469,7 +476,6 @@ public class CrowdTestProject {
     }
 
 
-
     /**
      * 创建测试报告（测评机构）
      * @param crowdTestTaskCode
@@ -549,32 +555,33 @@ public class CrowdTestProject {
 
     /**
      * 结束任务（区域管理员）
+     *
      * @return
      */
     public CrowdTestProject finishCrowdTestTask(String crowdTestTaskCode, User user) {
         //判断是否为区域管理员
         RegionalManager regionalManager = user.getRegionalManager();
-        if(regionalManager == null){
+        if (regionalManager == null) {
             throw new UserNotExistException("当前用户不是区域管理员，没有权限结束测试任务");
         }
 
         //判断是否是当前项目的区域管理员
-        if(!this.regionalManagerId.equals(user.getId())){
+        if (!this.regionalManagerId.equals(user.getId())) {
             throw new CrowdTestProjectException("当前用户没有权限结束当前项目下的任务！");
         }
 
         //项目状态判断
-        if(this.getStatus() != (CrowdTestProjectStatus.HAS_COMMITED-1)){
+        if (this.getStatus() != (CrowdTestProjectStatus.HAS_COMMITED - 1)) {
             throw new CrowdTestProjectException("当前项目状态不可结束任务！");
-        }else {
+        } 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{
+            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()));
@@ -592,24 +599,25 @@ public class CrowdTestProject {
 
     /**
      * 创建项目报告（区域管理员）
+     *
      * @param crowdTestReport
      * @return
      */
     public CrowdTestProject createCrowdTestProjectReport(CrowdTestReport crowdTestReport, User user) {
         //判断是否为区域管理员
         RegionalManager regionalManager = user.getRegionalManager();
-        if(regionalManager == null){
+        if (regionalManager == null) {
             throw new UserNotExistException("当前用户不是区域管理员，没有权限创建项目报告");
         }
 
         //判断是否是当前项目的区域管理员
-        if(!this.regionalManagerId.equals(user.getId())){
+        if (!this.regionalManagerId.equals(user.getId())) {
             throw new CrowdTestProjectException("当前用户没有权限创建项目报告！");
         }
         //项目状态判断
-        if(this.getStatus() != (CrowdTestProjectStatus.HAS_COMMITED-1)){
-            throw new CrowdTestProjectException("当前项目状态不可创建项目报告！状态为："+this.getStatus());
-        }else{
+        if (this.getStatus() != (CrowdTestProjectStatus.HAS_COMMITED - 1)) {
+            throw new CrowdTestProjectException("当前项目状态不可创建项目报告！状态为：" + this.getStatus());
+        } else {
             crowdTestReport.setScope(0);
             crowdTestReport.setDependencyCode(this.getCode());
             this.setCrowdTestReportForProject(crowdTestReport);
@@ -619,38 +627,39 @@ public class CrowdTestProject {
 
     /**
      * 提交项目（区域管理员）
+     *
      * @return
      */
     public CrowdTestProject commitCrowdTestProject(User user) {
         //判断是否为区域管理员
         RegionalManager regionalManager = user.getRegionalManager();
-        if(regionalManager == null){
+        if (regionalManager == null) {
             throw new UserNotExistException("当前用户不是区域管理员，没有权限提交项目");
         }
 
         //判断是否是当前项目的区域管理员
-        if(!this.regionalManagerId.equals(user.getId())){
+        if (!this.regionalManagerId.equals(user.getId())) {
             throw new CrowdTestProjectException("当前用户没有权限操作此项目！");
         }
 
         //项目状态判断
-        if(this.getStatus() != CrowdTestProjectStatus.HAS_RECEIVED){
-            throw new CrowdTestProjectException("当前项目状态不可提交项目！状态为："+this.getStatus());
+        if (this.getStatus() != CrowdTestProjectStatus.HAS_RECEIVED) {
+            throw new CrowdTestProjectException("当前项目状态不可提交项目！状态为：" + this.getStatus());
         }
 
         //判断项目下是否有任务
-        if(this.getCrowdTestTaskList()==null || this.getCrowdTestTaskList().size() < 1){
+        if (this.getCrowdTestTaskList() == null || this.getCrowdTestTaskList().size() < 1) {
             throw new CrowdTestProjectException("还未创建任务，项目不能被提交");
-        }else{
+        } else {
             //结束项目时查看是否已结束任务
-            if(this.getCrowdTestTaskList().stream().filter(task -> task.getStatus()!=CrowdTestTaskStatus.HAS_REJECTED)
+            if (this.getCrowdTestTaskList().stream().filter(task -> task.getStatus() != CrowdTestTaskStatus.HAS_REJECTED)
                     .filter(task -> task.getStatus() != CrowdTestTaskStatus.HAS_TIME_OUT)
-                    .anyMatch(task -> task.getStatus()!=CrowdTestTaskStatus.HAS_FINISHED)){
+                    .anyMatch(task -> task.getStatus() != CrowdTestTaskStatus.HAS_FINISHED)) {
                 throw new CrowdTestTaskException("存在未结束的任务，项目不能被提交");
             }
         }
         //判断项目下是否有项目报告
-        if(this.getCrowdTestReportForProject() == null){
+        if (this.getCrowdTestReportForProject() == null) {
             throw new CrowdTestProjectException("还未创建项目报告，项目不能被提交");
         }
         this.setStatus(CrowdTestProjectStatus.HAS_COMMITED);
@@ -659,6 +668,7 @@ public class CrowdTestProject {
 
     /**
      * 结束项目（项目发起者）
+     *
      * @return
      */
     public CrowdTestProject finishCrowdTestProject(User user) {
@@ -667,13 +677,13 @@ public class CrowdTestProject {
 //            throw new CrowdTestProjectException("当前用户未进行认证，无权限对项目操作");
 //        }
         //判断是否为项目发起者
-        if(!this.getUserId().equals(user.getId())){
+        if (!this.getUserId().equals(user.getId())) {
             throw new CrowdTestProjectException("当前用户没有权限结束项目!");
         }
 
-        if(this.getStatus() != CrowdTestProjectStatus.HAS_COMMITED){
-            throw new CrowdTestProjectException("项目不能确认结束，当前状态为："+this.getStatus());
-        }else{
+        if (this.getStatus() != CrowdTestProjectStatus.HAS_COMMITED) {
+            throw new CrowdTestProjectException("项目不能确认结束，当前状态为：" + this.getStatus());
+        } else {
             this.setStatus(CrowdTestProjectStatus.HAS_FINISHED);
             this.setEndTime(new Timestamp(System.currentTimeMillis()));
         }
@@ -681,9 +691,9 @@ public class CrowdTestProject {
     }
 
     public void reject(Long userId) {
-        if (this.getProjectDistributionTypeId()!=0
+        if (this.getProjectDistributionTypeId() != 0
                 || this.getStatus() != CrowdTestProjectStatus.HAS_RELEASED
-                || !this.getRegionalManagerId().equals(userId)){
+                || !this.getRegionalManagerId().equals(userId)) {
             throw new CrowdTestProjectException("非法的操作");
         }
         this.setStatus(CrowdTestProjectStatus.HAS_REJECTED);

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

@@ -9,9 +9,9 @@ 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_REPORTED = 3; //存在任务报告
     public static final int HAS_COMMITED = 3;   //区域管理员提交任务
-//    public static final int HAS_COMMITED_MANAGER = 4;   //区域管理员提交任务
+    //    public static final int HAS_COMMITED_MANAGER = 4;   //区域管理员提交任务
     public static final int HAS_FINISHED = 4;   //结束任务
     public static final int HAS_TIME_OUT = 5; //时间截止
 }

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

@@ -62,7 +62,7 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
         Specifications<CrowdTestProjectPO> where =  Specifications.where(getProjectByIsNotDeleted(keyword, deletedStatus));
         return crowdTestProjectDao.findAll(where, pageable).map(crowdTestProjectPO -> Converter.convert(CrowdTestProject.class, crowdTestProjectPO));
     }
-
+  //搜索
     private Specification<CrowdTestProjectPO> getProjectByIsNotDeleted(String keyword, int deletedStatus) {
         return new Specification<CrowdTestProjectPO>() {
             @Override

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

@@ -0,0 +1,57 @@
+package com.mooctest.crowd.domain.repository;
+
+import com.mooctest.crowd.domain.dao.CrowdTestTaskDao;
+import com.mooctest.crowd.domain.domainobject.CrowdTestProject;
+import com.mooctest.crowd.domain.domainobject.CrowdTestTask;
+import com.mooctest.crowd.domain.model.CrowdTestProjectPO;
+import com.mooctest.crowd.domain.model.CrowdTestTaskPO;
+import com.mooctest.crowd.domain.util.Converter;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.data.jpa.domain.Specifications;
+import org.springframework.stereotype.Component;
+
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Predicate;
+import javax.persistence.criteria.Root;
+
+/**
+ * @author:xx
+ * @date:2020/6/24
+ * @description:
+ */
+
+@Slf4j
+@Component
+public class CrowdTestTaskRepo  implements  ICrowdTaskRepo{
+    @Autowired
+    private CrowdTestTaskDao taskDao;
+
+
+
+    @Override
+    public Page<CrowdTestTask> findAllByPage(Pageable pageable, String keyword, int deletedStatus){
+        Specifications<CrowdTestProjectPO> where =  Specifications.where(getProjectByIsNotDeleted(keyword, deletedStatus));
+        return  taskDao.findAll(where, pageable).map(crowdTestTaskPO -> Converter.convert(CrowdTestTask.class,crowdTestTaskPO));
+    }
+    private Specification<CrowdTestProjectPO> getProjectByIsNotDeleted(String keyword, int deletedStatus) {
+        return new Specification<CrowdTestProjectPO>() {
+            @Override
+            public Predicate toPredicate(Root<CrowdTestProjectPO> a, CriteriaQuery<?> q, CriteriaBuilder cb) {
+                Predicate predicate = cb.conjunction();
+                if(keyword != null) {
+                    predicate.getExpressions().add(
+                            cb.like(a.<String>get("name"), "%" + StringUtils.trim(keyword) + "%")
+                    );
+                }
+                predicate.getExpressions().add(cb.equal(a.get("isDeleted"), deletedStatus));
+                return predicate;
+            }
+        };
+    }
+}

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

@@ -0,0 +1,13 @@
+package com.mooctest.crowd.domain.repository;
+
+import com.mooctest.crowd.domain.domainobject.CrowdTestTask;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+public interface ICrowdTaskRepo {
+
+     Page<CrowdTestTask> findAllByPage(Pageable pageable, String keyword, int deletedStatus);
+
+
+
+}

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

@@ -14,7 +14,6 @@ import java.util.List;
  * @date 2019/7/6 19:10
  */
 public interface ICrowdTestProjectRepo {
-
     Page<CrowdTestProject> findAllByPage(Pageable pageable, String keyword, int deletedStatus);
     Page<CrowdTestProjectPO> findAll(Specification specification,Pageable pageable);
 

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

@@ -1,8 +1,13 @@
 package com.mooctest.crowd.site.controller;
 
+import com.mooctest.crowd.domain.domainobject.CrowdTestProject;
 import com.mooctest.crowd.domain.model.CrowdTestProjectPO;
 import com.mooctest.crowd.domain.model.CrowdTestTaskPO;
 import com.mooctest.crowd.site.data.dto.CrowdTestSquareIndexDTO;
+import com.mooctest.crowd.site.data.vo.CrowdProjectVO;
+import com.mooctest.crowd.site.data.vo.CrowdTaskVO;
+import com.mooctest.crowd.site.data.vo.CrowdTestProjectVO;
+import com.mooctest.crowd.site.service.CommonService;
 import com.mooctest.crowd.site.service.CrowdProjectService;
 import com.mooctest.crowd.site.service.CrowdTaskService;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -29,6 +34,8 @@ public class CrowTestSquareController {
     private CrowdProjectService crowdProjectService;
     @Autowired
     private CrowdTaskService crowdTaskService;
+    @Autowired
+    private CommonService commonService;
 
 
     /**
@@ -36,14 +43,13 @@ public class CrowTestSquareController {
      *
      * @return
      */
-
     @GetMapping("/list")
     public CrowdTestSquareIndexDTO getAll() {
         CrowdTestSquareIndexDTO crowdTestSquareIndexDTO = new CrowdTestSquareIndexDTO();
-        List<CrowdTestProjectPO> list = crowdProjectService.findAll();
-        List<CrowdTestTaskPO> crowdTestTasks = crowdTaskService.findAll();
-        crowdTestSquareIndexDTO.setCrowdTestProjects(list);
-        crowdTestSquareIndexDTO.setCrowdTestTaskPOS(crowdTestTasks);
+        List<CrowdTestProjectVO> list = crowdProjectService.findAll();
+        List<CrowdTaskVO> crowdTestTasks = crowdTaskService.findAll();
+        crowdTestSquareIndexDTO.setCrowdTestProjectVOs(list);
+        crowdTestSquareIndexDTO.setCrowdTestTaskVOS(crowdTestTasks);
         crowdTestSquareIndexDTO.initHotTaskAndProject();
         return crowdTestSquareIndexDTO;
     }
@@ -53,10 +59,10 @@ public class CrowTestSquareController {
      */
 
     @GetMapping("/project/list")
-    public Page<CrowdTestProjectPO> findAllprojectByPage(
+    public Page<CrowdProjectVO> findAllprojectByPage(
             @RequestParam("pageNum") int pageNum, @RequestParam("pageSize") int pageSize) {
         Pageable pageable = PageRequest.of(pageNum - 1, pageSize);
-        Page<CrowdTestProjectPO> page = crowdProjectService.findAll(pageable);
+        Page<CrowdProjectVO> page = commonService.getProjectInfo(pageable, null, 0);
         return page;
     }
 
@@ -64,12 +70,20 @@ public class CrowTestSquareController {
      * 众测任务分页查询接口
      */
     @GetMapping("/task/list")
-    public Page<CrowdTestTaskPO> getAllTaskByPage(
+    public Page<CrowdTaskVO> getAllTaskByPage(
             @RequestParam("pageNum") int pageNum, @RequestParam("pageSize") int pageSize) {
         Pageable pageable = PageRequest.of(pageNum - 1, pageSize);
-        Page<CrowdTestTaskPO> page = crowdTaskService.findAll(pageable);
+        Page<CrowdTaskVO> page = commonService.getTaskInfo(pageable, null, 0);
         return page;
+
     }
+    /**
+     *  搜索框模糊查询
+     */
+
+
+
+
 
 
 }

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

@@ -3,6 +3,8 @@ package com.mooctest.crowd.site.data.dto;
 import com.mooctest.crowd.domain.domainobject.CrowdTestTaskStatus;
 import com.mooctest.crowd.domain.model.CrowdTestProjectPO;
 import com.mooctest.crowd.domain.model.CrowdTestTaskPO;
+import com.mooctest.crowd.site.data.vo.CrowdTaskVO;
+import com.mooctest.crowd.site.data.vo.CrowdTestProjectVO;
 import lombok.Data;
 
 import java.util.Comparator;
@@ -16,35 +18,30 @@ import java.util.stream.Collectors;
  */
 @Data
 public class CrowdTestSquareIndexDTO {
-
     //众测项目
-    private List<CrowdTestProjectPO> crowdTestProjects;
-
+    private List<CrowdTestProjectVO> crowdTestProjectVOs;
     //众测任务
-    private List<CrowdTestTaskPO> crowdTestTaskPOS;
-
-
+    private List<CrowdTaskVO> crowdTestTaskVOS;
     //热门项目
-    private List<CrowdTestProjectPO> hotCrowdTestProject;
-
+    private List<CrowdTestProjectVO> hotCrowdTestProjectVOs;
     //热门任务
-    private List<CrowdTestTaskPO> hotCrowdTask;
+    private List<CrowdTaskVO> hotCrowdTaskVOs;
 
 
     /**
      * 初始化热门任务 ，热门项目
      */
     public void initHotTaskAndProject(){
-        List<CrowdTestProjectPO>  projectPOS=this.crowdTestProjects.stream().sorted(Comparator.comparing(CrowdTestProjectPO::getCreateTime)).collect(Collectors.toList());
-        this.crowdTestProjects=projectPOS;
+        List<CrowdTestProjectVO> projectVOS = this.crowdTestProjectVOs.stream().sorted(Comparator.comparing(CrowdTestProjectVO::getCreateTime)).collect(Collectors.toList());
+        this.crowdTestProjectVOs = projectVOS;
         //根据参与人数和创建时间进行排序
-        List<CrowdTestProjectPO> list1 = this.crowdTestProjects.stream().sorted(Comparator.comparing(CrowdTestProjectPO::getCreateTime).reversed().thenComparing(Comparator.comparing(CrowdTestProjectPO::getJoinCount).reversed())).collect(Collectors.toList());
+        List<CrowdTestProjectVO> list1 = this.crowdTestProjectVOs.stream().sorted(Comparator.comparing(CrowdTestProjectVO::getCreateTime).reversed().thenComparing(Comparator.comparing(CrowdTestProjectVO::getJoinCount).reversed())).collect(Collectors.toList());
         //截取前七条
-        this.hotCrowdTestProject = list1.subList(0,7);
-        List<CrowdTestTaskPO> tasklist1 = crowdTestTaskPOS.stream().sorted(Comparator.comparing(CrowdTestTaskPO::getAcceptedCount).reversed()).collect(Collectors.toList());
-        List<CrowdTestTaskPO> tasklist2 = tasklist1.stream().sorted(Comparator.comparing(CrowdTestTaskPO::getCreateTime).reversed()).collect(Collectors.toList());
+        this.crowdTestProjectVOs = list1.subList(0, 7);
+        List<CrowdTaskVO> tasklist1 = crowdTestTaskVOS.stream().sorted(Comparator.comparing(CrowdTaskVO::getAcceptedCount).reversed()).collect(Collectors.toList());
+        List<CrowdTaskVO> tasklist2 = tasklist1.stream().sorted(Comparator.comparing(CrowdTaskVO::getCreateTime).reversed()).collect(Collectors.toList());
         //过滤掉已完成的
         tasklist2.stream().filter(ct -> ct.getStatus() != CrowdTestTaskStatus.HAS_FINISHED);
-        this.hotCrowdTask = tasklist2.subList(0,7);
+        this.hotCrowdTaskVOs = tasklist2.subList(0, 7);
     }
 }

site/src/main/java/com/mooctest/crowd/site/data/vo/CrowdTaskVO.java

@@ -19,7 +19,7 @@ import java.util.Map;
 @Data
 public class CrowdTaskVO {
 
-    private String id;
+    private long id;
     private String projectId;
     private String title;
     private String description;
@@ -43,8 +43,11 @@ public class CrowdTaskVO {
     private Timestamp createTime;
     private List<TaskToUserVO> taskToUserVOS = new ArrayList<>();
 
+
+
+
     public CrowdTaskVO(CrowdTestTask task){
-        id = task.getCode();
+        id = task.getId();
         projectId = task.getCrowdTestProjectCode();
         title = task.getName();
         description = task.getDescription();

site/src/main/java/com/mooctest/crowd/site/data/vo/CrowdTestProjectVO.java

@@ -1,11 +1,13 @@
 package com.mooctest.crowd.site.data.vo;
 
+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.model.CrowdTestProjectPO;
 import com.mooctest.crowd.domain.model.TechnicalArticlesPO;
 import lombok.Data;
 
+import javax.persistence.Column;
 import java.sql.Timestamp;
 import java.util.List;
 
@@ -18,8 +20,8 @@ import java.util.List;
 @Data
 public class CrowdTestProjectVO {
     private Long id;
-    private String name;
     private String code;
+    private String name;
     private Long userId;
     private Long regionalManagerId;
     private Long projectDistributionTypeId;
@@ -27,11 +29,12 @@ public class CrowdTestProjectVO {
     private String linkMan;
     private String linkManMobile;
     private String type;
+    private String fieldType;
     private String description;
-    private String projectFile;
-    private String requirementFile;
     private String distributionProvince;
     private String distributionCity;
+    private String projectFile;
+    private String requirementFile;
     private Double quotedPrice;
     private Double fixedPrice;
     private Double restPrice;
@@ -42,10 +45,33 @@ public class CrowdTestProjectVO {
     private int joinCount;
     private Timestamp createTime;
 
-    private List<CrowdTestTask> crowdTestTaskList;
-    private CrowdTestReport crowdTestReportForProject;
+    public CrowdTestProjectVO(CrowdTestProject crowdTestProject) {
+        id=crowdTestProject.getId();
+        code=crowdTestProject.getCode();
+        name = crowdTestProject.getName();
+        userId = crowdTestProject.getUserId();
+        regionalManagerId = crowdTestProject.getRegionalManagerId();
+        projectDistributionTypeId = crowdTestProject.getProjectDistributionTypeId();
+        platform = crowdTestProject.getPlatform();
+        linkMan = crowdTestProject.getLinkMan();
+        linkManMobile = crowdTestProject.getLinkManMobile();
+        type = crowdTestProject.getType();
+        fieldType = crowdTestProject.getFieldType();
+        description = crowdTestProject.getDescription();
+        distributionProvince = crowdTestProject.getDistributionProvince();
+        distributionCity = crowdTestProject.getDistributionCity();
+        projectFile = crowdTestProject.getProjectFile();
+        requirementFile = crowdTestProject.getRequirementFile();
+        quotedPrice = crowdTestProject.getQuotedPrice();
+        fixedPrice = crowdTestProject.getFixedPrice();
+        restPrice = crowdTestProject.getRestPrice();
+        status = crowdTestProject.getStatus();
+        deadTime = crowdTestProject.getDeadTime();
+        endTime = crowdTestProject.getEndTime();
+        isDeleted = crowdTestProject.getIsDeleted();
+        joinCount = crowdTestProject.getJoinCount();
+        createTime = crowdTestProject.getCreateTime();
 
-    public void setName(Iterable<CrowdTestProjectPO> crowdTestProjectPO) {
 
     }
 }

site/src/main/java/com/mooctest/crowd/site/mediator/OperationMediator.java

@@ -14,4 +14,5 @@ public interface OperationMediator {
     ProjectDetailsDTO createCrowdProject(CrowdTestProjectCommand command);
 
     CrowdTestProject updateProject(CrowdTestProject project, CrowdTestProjectCommand crowdTestProjectCommand);
+
 }

site/src/main/java/com/mooctest/crowd/site/mediator/ViewMediator.java

@@ -54,4 +54,11 @@ public interface ViewMediator {
     List<BaseAuthVO> renderAuthedList();
 
     List<TechnicalArticlesVO> technicalArticles(Pageable pageable);
+
+    List<CrowdTestProjectVO>   crowdTestProjects();
+
+    List<CrowdTaskVO>    crowdTaskVos();
+
+
+
 }

site/src/main/java/com/mooctest/crowd/site/mediator/impl/WebMediatorImpl.java

@@ -27,8 +27,13 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
 import org.springframework.stereotype.Component;
 
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Predicate;
+import javax.persistence.criteria.Root;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -44,7 +49,8 @@ public class WebMediatorImpl implements ViewMediator {
     private CrowdTestProjectRepo projectRepo;
 
     @Autowired
-    private UserRepo userRepo;
+    private UserRepo
+            userRepo;
 
     @Autowired
     private EvaluationAgencyRepo evaluationAgencyRepo;
@@ -113,7 +119,7 @@ public class WebMediatorImpl implements ViewMediator {
         String agencyName = agencyDao.findById(Long.parseLong(agencyId)).get().getEvaluationAgencyName();
         List<EvolutionAgencyVO> agencyRanks = taskToUserDao.findTotalCountOfUser().stream().map(rankInfo -> {
             EvaluationAgencyPO agency = agencyDao.findByUserId(rankInfo.getEntityId());
-            if (agency!=null && !agency.getEvaluationAgencyName().equals(agencyName)) {
+            if (agency != null && !agency.getEvaluationAgencyName().equals(agencyName)) {
                 EvolutionAgencyVO agencyVO = new EvolutionAgencyVO();
                 agencyVO.setName(agency.getEvaluationAgencyName());
                 agencyVO.setLogo(agency.getAgencyPhoto());
@@ -124,14 +130,14 @@ public class WebMediatorImpl implements ViewMediator {
             }
             return null;
         }).filter(Objects::nonNull).collect(Collectors.toList());
-        if(agencyRanks.size() > top){
-            agencyRanks = agencyRanks.subList(0,top);
+        if (agencyRanks.size() > top) {
+            agencyRanks = agencyRanks.subList(0, top);
         }
 
         //获取众测人员排名
         List<UserVO> userRanks = taskToUserDao.findTotalCountOfUser().stream().map(rankInfo -> {
             EvaluationAgencyPO agency = agencyDao.findByUserId(rankInfo.getEntityId());
-            if (agency!=null && agency.getEvaluationAgencyName().equals(agencyName)) {
+            if (agency != null && agency.getEvaluationAgencyName().equals(agencyName)) {
                 User user = userRepo.getByID(agency.getUserId());
                 UserVO userVO = new UserVO(user);
                 userVO.setTaskCount(rankInfo.getCount());
@@ -139,14 +145,14 @@ public class WebMediatorImpl implements ViewMediator {
             }
             return null;
         }).filter(Objects::nonNull).collect(Collectors.toList());
-        if(userRanks.size() > top){
-            userRanks = userRanks.subList(0,top);
+        if (userRanks.size() > top) {
+            userRanks = userRanks.subList(0, top);
         }
 
         // 获取大赛信息
         List<Competition> competitionList = commonRepo.getAllCompetition();
-        if(competitionList.size() > top){
-            competitionList = competitionList.subList(0,top);
+        if (competitionList.size() > top) {
+            competitionList = competitionList.subList(0, top);
         }
         List<CompetitionVO> competitionVOS = competitionList.stream().map(competition -> {
             CompetitionVO competitionVO = new CompetitionVO(competition);
@@ -221,22 +227,22 @@ public class WebMediatorImpl implements ViewMediator {
     public IndexDTO renderIndex() {
 
         Pageable pageable = PageRequest.of(0, 10);
-            //获取用户排名
-            List<UserVO> userRanks = projectDao.findTotalPriceOfUser(pageable).stream().map(rankInfo -> {
-                Optional<UserPO> userPO = userDao.findById(rankInfo.getEntityId());
-                if (userPO.isPresent()) {
-                    UserVO userVO = new UserVO();
-                    userVO.setName(userPO.get().getName());
-                    userVO.setUserName(userPO.get().getUserName());
-                    userVO.setAllProjectPrice(rankInfo.getTotalPrice());
-                    return userVO;
-                }
+        //获取用户排名
+        List<UserVO> userRanks = projectDao.findTotalPriceOfUser(pageable).stream().map(rankInfo -> {
+            Optional<UserPO> userPO = userDao.findById(rankInfo.getEntityId());
+            if (userPO.isPresent()) {
+                UserVO userVO = new UserVO();
+                userVO.setName(userPO.get().getName());
+                userVO.setUserName(userPO.get().getUserName());
+                userVO.setAllProjectPrice(rankInfo.getTotalPrice());
+                return userVO;
+            }
             return null;
         }).filter(Objects::nonNull).collect(Collectors.toList());
         //获取机构排名
         List<EvolutionAgencyVO> agencyRanks = taskToUserDao.findTotalPriceOfAgency(pageable).stream().map(rankInfo -> {
             EvaluationAgencyPO agency = agencyDao.findByUserId(rankInfo.getEntityId());
-            if (agency!=null) {
+            if (agency != null) {
                 EvolutionAgencyVO agencyVO = new EvolutionAgencyVO();
                 agencyVO.setName(agency.getEvaluationAgencyName());
                 agencyVO.setLogo(agency.getAgencyPhoto());
@@ -296,16 +302,16 @@ public class WebMediatorImpl implements ViewMediator {
                     return projectVO;
                 }).collect(Collectors.toList());
         //对于区域管理员
-        if (user.getRoleList().stream().anyMatch(role -> role.getName().equals("RegionalManager"))){
+        if (user.getRoleList().stream().anyMatch(role -> role.getName().equals("RegionalManager"))) {
             List<CrowdTestProjectPO> crowdTestProjectPOList = projectDao.findByRegionalManagerIdAndIsDeleted(userId, DeletedStatus.isNotDeleted)
                     .stream().sorted(Comparator.comparing(CrowdTestProjectPO::getCreateTime).thenComparing(CrowdTestProjectPO::getStatus).reversed()).collect(Collectors.toList());
             //获取区域管理员正在处理中的项目列表
-            myCrowdDTO.setHandlingProjects(crowdTestProjectPOList.stream().filter(crowdTestProjectPO -> crowdTestProjectPO.getStatus()>CrowdTestProjectStatus.HAS_RELEASED).map(crowdTestProjectPO -> {
+            myCrowdDTO.setHandlingProjects(crowdTestProjectPOList.stream().filter(crowdTestProjectPO -> crowdTestProjectPO.getStatus() > CrowdTestProjectStatus.HAS_RELEASED).map(crowdTestProjectPO -> {
                 CrowdTestProject project = new CrowdTestProject();
                 BeanUtils.copyProperties(crowdTestProjectPO, project);
                 CrowdProjectVO projectVO = new CrowdProjectVO(project);
                 List<CrowdTestTaskPO> tasksOfProject = taskDao.findByCrowdTestProjectCodeAndIsDeleted(project.getCode(), DeletedStatus.isNotDeleted);
-                if (tasksOfProject!=null && tasksOfProject.stream().anyMatch(task -> task.getStatus()==CrowdTestTaskStatus.HAS_COMMITED)) {
+                if (tasksOfProject != null && tasksOfProject.stream().anyMatch(task -> task.getStatus() == CrowdTestTaskStatus.HAS_COMMITED)) {
                     log.info("\n\n需要处理！！！\n\n");
                     projectVO.setNeedHandle(true);
                 }
@@ -313,25 +319,26 @@ public class WebMediatorImpl implements ViewMediator {
             }).collect(Collectors.toList()));
             //获取区域管理员可以接收领取的项目列表
             //定向
-            List<CrowdTestProjectPO> acceptableProject = crowdTestProjectPOList.stream().filter(crowdTestProjectPO -> crowdTestProjectPO.getStatus()==CrowdTestProjectStatus.HAS_RELEASED).collect(Collectors.toList());
+            List<CrowdTestProjectPO> acceptableProject = crowdTestProjectPOList.stream().filter(crowdTestProjectPO -> crowdTestProjectPO.getStatus() == CrowdTestProjectStatus.HAS_RELEASED).collect(Collectors.toList());
             //广场的
-            acceptableProject.addAll(projectDao.findAllByStatusLessThanAndProjectDistributionTypeIdAndIsDeletedAndUserIdIsNot(CrowdTestProjectStatus.HAS_RECEIVED, 2L,DeletedStatus.isNotDeleted, userId));
+            acceptableProject.addAll(projectDao.findAllByStatusLessThanAndProjectDistributionTypeIdAndIsDeletedAndUserIdIsNot(CrowdTestProjectStatus.HAS_RECEIVED, 2L, DeletedStatus.isNotDeleted, userId));
             //区域的
-            acceptableProject.addAll(projectDao.findByStatusLessThanAndProjectDistributionTypeIdAndIsDeletedAndUserIdIsNot(CrowdTestProjectStatus.HAS_RECEIVED, 1L,DeletedStatus.isNotDeleted, userId)
+            acceptableProject.addAll(projectDao.findByStatusLessThanAndProjectDistributionTypeIdAndIsDeletedAndUserIdIsNot(CrowdTestProjectStatus.HAS_RECEIVED, 1L, DeletedStatus.isNotDeleted, userId)
                     .stream().filter(crowdTestProjectPO -> user.getRegionalManager().getRegionalList().stream()
-                            .anyMatch(reg -> (reg.getProvince().equals("*") || reg.getProvince().equals(crowdTestProjectPO.getDistributionProvince())) && (reg.getCity().equals("*")||reg.getCity().equals(crowdTestProjectPO.getDistributionCity())))).collect(Collectors.toList()));
+                            .anyMatch(reg -> (reg.getProvince().equals("*") || reg.getProvince().equals(crowdTestProjectPO.getDistributionProvince())) && (reg.getCity().equals("*") || reg.getCity().equals(crowdTestProjectPO.getDistributionCity())))).collect(Collectors.toList()));
             myCrowdDTO.setAcceptableProjects(acceptableProject.stream().sorted(Comparator.comparing(CrowdTestProjectPO::getCreateTime).thenComparing(CrowdTestProjectPO::getStatus).reversed())
                     .map(crowdTestProjectPO -> {
                         CrowdTestProject project = new CrowdTestProject();
                         BeanUtils.copyProperties(crowdTestProjectPO, project);
-                        return new CrowdProjectVO(project); }).collect(Collectors.toList()));
-            myCrowdDTO.setAcceptableProjectNoticeCount(Long.parseLong(""+acceptableProject.size()));
+                        return new CrowdProjectVO(project);
+                    }).collect(Collectors.toList()));
+            myCrowdDTO.setAcceptableProjectNoticeCount(Long.parseLong("" + acceptableProject.size()));
         }
         UserVO userVO = new UserVO(user);
         myCrowdDTO.setMyProjects(myProejcts);
         myCrowdDTO.setUserVO(userVO);
         myCrowdDTO.setMyProjectNoticeCount(myProejcts.stream().filter(CrowdProjectVO::getNeedHandle).count());
-        myCrowdDTO.setProcessProjectNoticeCount(myCrowdDTO.getHandlingProjects()==null?0:myCrowdDTO
+        myCrowdDTO.setProcessProjectNoticeCount(myCrowdDTO.getHandlingProjects() == null ? 0 : myCrowdDTO
                 .getHandlingProjects().stream().filter(CrowdProjectVO::getNeedHandle).count());
         if (user.getRoleList().stream().noneMatch(role -> role.getName().equals("evaluationAgency")))
             return myCrowdDTO;
@@ -340,11 +347,11 @@ public class WebMediatorImpl implements ViewMediator {
         List<CrowdTaskVO> finishedTasks = null;
         if (user.getRoleList().stream().anyMatch(role -> role.getName().equals("evaluationAgency"))) {
             List<TaskToUserPO> taskToUserPOS = taskToUserDao.findByUserId(user.getId());
-            if(taskToUserPOS != null && taskToUserPOS.size() > 0){
+            if (taskToUserPOS != null && taskToUserPOS.size() > 0) {
                 allTaskOfAgency = taskToUserPOS.stream().sorted(Comparator.comparing(TaskToUserPO::getAcceptTime))
                         .map(taskToUserPO -> {
                             CrowdTestTaskPO crowdTestTaskPO = taskDao.findByCodeAndIsDeleted(taskToUserPO.getTaskCode(), DeletedStatus.isNotDeleted);
-                            if(crowdTestTaskPO != null){
+                            if (crowdTestTaskPO != null) {
                                 CrowdTestTask task = new CrowdTestTask();
                                 BeanUtils.copyProperties(crowdTestTaskPO, task);
                                 return task;
@@ -352,11 +359,11 @@ public class WebMediatorImpl implements ViewMediator {
                             return null;
                         }).collect(Collectors.toList());
                 unfinishedTasks = allTaskOfAgency.stream()
-                        .filter(crowdTestTask -> crowdTestTask.getStatus()>=CrowdTestTaskStatus.HAS_RELEASED && crowdTestTask.getStatus()<CrowdTestTaskStatus.HAS_FINISHED)
+                        .filter(crowdTestTask -> crowdTestTask.getStatus() >= CrowdTestTaskStatus.HAS_RELEASED && crowdTestTask.getStatus() < CrowdTestTaskStatus.HAS_FINISHED)
                         .map(CrowdTaskVO::new).collect(Collectors.toList());
 
                 finishedTasks = allTaskOfAgency.stream()
-                        .filter(crowdTestTask -> crowdTestTask.getStatus()==CrowdTestTaskStatus.HAS_FINISHED)
+                        .filter(crowdTestTask -> crowdTestTask.getStatus() == CrowdTestTaskStatus.HAS_FINISHED)
                         .map(CrowdTaskVO::new).collect(Collectors.toList());
             }
         }
@@ -374,7 +381,7 @@ public class WebMediatorImpl implements ViewMediator {
             return task;
         }).collect(Collectors.toList()).stream().filter(crowdTestTask -> crowdTestTask.getStatus() == CrowdTestTaskStatus.HAS_RELEASED ||
                 (crowdTestTask.getStatus() == CrowdTestTaskStatus.HAS_RECEIVED && crowdTestTask.getFullStatus() == CrowdTestTaskAcceptStatus.NOT_FULL))
-                .filter(crowdTestTask -> crowdTestTask.getDistributionType()==2)
+                .filter(crowdTestTask -> crowdTestTask.getDistributionType() == 2)
                 .map(CrowdTaskVO::new).sorted(Comparator.comparing(CrowdTaskVO::getCreateTime).reversed()).collect(Collectors.toList());
         TaskSquareDTO taskSquareDTO = new TaskSquareDTO();
         taskSquareDTO.setCrowdTaskVOList(taskVOList);
@@ -385,7 +392,7 @@ public class WebMediatorImpl implements ViewMediator {
     public ProjectDetailsDTO renderProjectDetails(CrowdTestProject project, User user) {
         boolean saveFlag = false;
         // 判断项目是否截止
-        if (project.getDeadTime().getTime() <= System.currentTimeMillis() && project.getStatus() < CrowdTestProjectStatus.HAS_FINISHED){
+        if (project.getDeadTime().getTime() <= System.currentTimeMillis() && project.getStatus() < CrowdTestProjectStatus.HAS_FINISHED) {
             project.setStatus(CrowdTestProjectStatus.HAS_TIME_OUT);
             saveFlag = true;
         }
@@ -393,17 +400,17 @@ public class WebMediatorImpl implements ViewMediator {
         ProjectDetailsDTO projectDetailsDTO = new ProjectDetailsDTO();
         List<CrowdTestTask> crowdTestTaskList = project.getCrowdTestTaskList();
         List<CrowdTaskVO> taskVOList = new ArrayList<>();
-        for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+        for (CrowdTestTask crowdTestTask : crowdTestTaskList) {
             // 判断任务是否截止
-            if(crowdTestTask.getDeadTime().getTime() <= System.currentTimeMillis() && crowdTestTask.getStatus() < CrowdTestTaskStatus.HAS_FINISHED){
+            if (crowdTestTask.getDeadTime().getTime() <= System.currentTimeMillis() && crowdTestTask.getStatus() < CrowdTestTaskStatus.HAS_FINISHED) {
                 crowdTestTask.setStatus(CrowdTestTaskStatus.HAS_TIME_OUT);
                 saveFlag = true;
             }
 
             CrowdTaskVO crowdTaskVO = new CrowdTaskVO(crowdTestTask);
-            if (crowdTestTask.getDistributionType()==0){
+            if (crowdTestTask.getDistributionType() == 0) {
                 EvaluationAgencyPO agencyPO = agencyDao.findByUserId(crowdTestTask.getEvaluationAgencyId());
-                crowdTaskVO.setInstitution(agencyPO==null?"该机构已注销":agencyPO.getEvaluationAgencyName());
+                crowdTaskVO.setInstitution(agencyPO == null ? "该机构已注销" : agencyPO.getEvaluationAgencyName());
             }
             taskVOList.add(crowdTaskVO);
         }
@@ -414,22 +421,22 @@ public class WebMediatorImpl implements ViewMediator {
             reportVOList.add(new CrowdReportVO(project.getCrowdTestReportForProject()));
         }
         CrowdProjectVO projectVO = new CrowdProjectVO(project);
-        if (project.getStatus() > CrowdTestProjectStatus.HAS_RELEASED && project.getRegionalManagerId() != null){
+        if (project.getStatus() > CrowdTestProjectStatus.HAS_RELEASED && project.getRegionalManagerId() != null) {
             Optional<UserPO> regionManager = userDao.findById(project.getRegionalManagerId());
-            projectVO.setInstitution(regionManager.isPresent()?regionManager.get().getName():"区域管理员已注销");
+            projectVO.setInstitution(regionManager.isPresent() ? regionManager.get().getName() : "区域管理员已注销");
         }
         List<PieChartDataVO> progress = new ArrayList<>();
         progress.add(new PieChartDataVO("已完成", crowdTestTaskList
-                .stream().filter(task -> task.getStatus()==CrowdTestTaskStatus.HAS_FINISHED).count()));
+                .stream().filter(task -> task.getStatus() == CrowdTestTaskStatus.HAS_FINISHED).count()));
         progress.add(new PieChartDataVO("进行中", crowdTestTaskList
-                .stream().filter(task -> task.getStatus()>CrowdTestTaskStatus.HAS_CREATED&&task.getStatus()<CrowdTestTaskStatus.HAS_FINISHED).count()));
+                .stream().filter(task -> task.getStatus() > CrowdTestTaskStatus.HAS_CREATED && task.getStatus() < CrowdTestTaskStatus.HAS_FINISHED).count()));
         projectDetailsDTO.setProjectDetails(projectVO);
         projectDetailsDTO.setTaskList(taskVOList);
         projectDetailsDTO.setReportList(reportVOList);
         projectDetailsDTO.setProjectOperationControl(initProjectPermission(project, user));
         projectDetailsDTO.setProgress(progress);
 
-        if(saveFlag){
+        if (saveFlag) {
             projectRepo.saveCrowdTestProject(project);
         }
         return projectDetailsDTO;
@@ -442,24 +449,24 @@ public class WebMediatorImpl implements ViewMediator {
         if (!task.isPresent())
             throw new CrowdTestTaskNotExistException();
         System.out.println("renderTaskReportDetails userID: " + userId);
-        ReportDetailsDTO reportDetailsDTO  = new ReportDetailsDTO();
-        if(userId.equals(projectRepo.getByProjectCode(projectCode).getRegionalManagerId())){
+        ReportDetailsDTO reportDetailsDTO = new ReportDetailsDTO();
+        if (userId.equals(projectRepo.getByProjectCode(projectCode).getRegionalManagerId())) {
             // 区域管理员
             reportDetailsDTO.setCrowdReportVO(new CrowdReportVO(Converter.convert(CrowdTestReport.class, crowdTestReportDao.findByCodeAndIsDeleted(reportCode, DeletedStatus.isNotDeleted))));
-            if (task.get().getStatus()<CrowdTestTaskStatus.HAS_FINISHED)
+            if (task.get().getStatus() < CrowdTestTaskStatus.HAS_FINISHED)
                 reportDetailsDTO.setOperational(false);
-        }else if(!userRepo.getByID(userId).getRoleList().stream().anyMatch(role -> role.getName().equals(RoleType.REGIONAL_MANAGER))){
+        } else if (!userRepo.getByID(userId).getRoleList().stream().anyMatch(role -> role.getName().equals(RoleType.REGIONAL_MANAGER))) {
             // 测评机构
             Optional<TaskToUser> taskToUserOptional = task.get().getAcceptedUserList().stream().filter(taskToUser -> taskToUser.getUserId().equals(userId)).findFirst();
-            if(!taskToUserOptional.isPresent())
+            if (!taskToUserOptional.isPresent())
                 throw new HttpBadRequestException("当前用户无法查看此报告！");
             Optional<CrowdTestReport> report = taskToUserOptional.get().getCrowdTestReportList().stream().filter(crowdTestReport -> crowdTestReport.getCode().equals(reportCode)).findFirst();
             if (!report.isPresent())
                 throw new CrowdTestReportNotExistException();
             reportDetailsDTO.setCrowdReportVO(new CrowdReportVO(report.get()));
-            if (task.get().getStatus()<CrowdTestTaskStatus.HAS_FINISHED)
+            if (task.get().getStatus() < CrowdTestTaskStatus.HAS_FINISHED)
                 reportDetailsDTO.setOperational(true);
-        }else{
+        } else {
             // 区域管理员
             throw new HttpBadRequestException("当前用户无法查看此报告！");
         }
@@ -471,11 +478,11 @@ public class WebMediatorImpl implements ViewMediator {
     public ReportDetailsDTO renderProjectReportDetails(String projectCode, String reportCode, Long userId) {
         CrowdTestProject project = projectRepo.getByProjectCode(projectCode);
         CrowdTestReport report = project.getCrowdTestReportForProject();
-        if (report==null)
+        if (report == null)
             throw new CrowdTestReportNotExistException();
-        ReportDetailsDTO reportDetailsDTO  = new ReportDetailsDTO();
+        ReportDetailsDTO reportDetailsDTO = new ReportDetailsDTO();
         reportDetailsDTO.setCrowdReportVO(new CrowdReportVO(report));
-        if (project.getStatus()<CrowdTestProjectStatus.HAS_FINISHED && project.getRegionalManagerId().equals(userId))
+        if (project.getStatus() < CrowdTestProjectStatus.HAS_FINISHED && project.getRegionalManagerId().equals(userId))
             reportDetailsDTO.setOperational(true);
         return reportDetailsDTO;
     }
@@ -487,17 +494,17 @@ public class WebMediatorImpl implements ViewMediator {
 
         boolean saveFlag = false;
         // 判断项目是否截止
-        if (project.getDeadTime().getTime() <= System.currentTimeMillis() && project.getStatus() < CrowdTestProjectStatus.HAS_FINISHED){
+        if (project.getDeadTime().getTime() <= System.currentTimeMillis() && project.getStatus() < CrowdTestProjectStatus.HAS_FINISHED) {
             project.setStatus(CrowdTestProjectStatus.HAS_TIME_OUT);
             saveFlag = true;
         }
 
-        Optional<CrowdTestTask> task =  project.getCrowdTestTaskList().stream().filter(crowdTestTask -> crowdTestTask.getCode().equals(taskCode)).findFirst();
+        Optional<CrowdTestTask> task = project.getCrowdTestTaskList().stream().filter(crowdTestTask -> crowdTestTask.getCode().equals(taskCode)).findFirst();
         if (!task.isPresent())
             throw new CrowdTestTaskNotExistException();
 
         // 判断任务是否截止
-        if(task.get().getDeadTime().getTime() <= System.currentTimeMillis() && task.get().getStatus() < CrowdTestTaskStatus.HAS_FINISHED){
+        if (task.get().getDeadTime().getTime() <= System.currentTimeMillis() && task.get().getStatus() < CrowdTestTaskStatus.HAS_FINISHED) {
             task.get().setStatus(CrowdTestTaskStatus.HAS_TIME_OUT);
             saveFlag = true;
         }
@@ -506,17 +513,17 @@ public class WebMediatorImpl implements ViewMediator {
         System.out.println("renderTaskDetails userId：" + userId);
         if (userId == null) {
             taskDetailsDTO.setTaskOperationControl(this.initTaskPermission(project, task.get(), null));
-        } else{
+        } else {
             taskDetailsDTO.setTaskOperationControl(this.initTaskPermission(project, task.get(), userRepo.getByID(userId)));
             // 区域管理员视图
             List<TaskToUserVO> taskToUserVOS = new ArrayList<>();
-            if(userId.equals(project.getRegionalManagerId())){
+            if (userId.equals(project.getRegionalManagerId())) {
                 taskToUserVOS = task.get().getAcceptedUserList().stream().map(taskToUser -> {
                     TaskToUserVO taskToUserVO = new TaskToUserVO(taskToUser);
                     taskToUserVO.setUserVO(Converter.convert(UserVO.class, taskToUser.getUser()));
                     // 获取每个人员的报告信息
                     List<CrowdTestReport> crowdTestReportList = taskToUser.getCrowdTestReportList();
-                    if(crowdTestReportList.size() > 0){
+                    if (crowdTestReportList.size() > 0) {
                         List<CrowdReportVO> crowdReportVOS = crowdTestReportList.stream().map(crowdTestReport -> new CrowdReportVO(crowdTestReport)).collect(Collectors.toList());
                         taskToUserVO.setCrowdReportVOS(crowdReportVOS);
                     }
@@ -524,34 +531,34 @@ public class WebMediatorImpl implements ViewMediator {
                 }).collect(Collectors.toList());
             }
             // 测评机构视图
-            else if(userRepo.getByID(userId).getRoleList().stream().anyMatch(role -> role.getName().equals(RoleType.AGENCY.getName()))){
+            else if (userRepo.getByID(userId).getRoleList().stream().anyMatch(role -> role.getName().equals(RoleType.AGENCY.getName()))) {
 //                Optional<TaskToUser> taskToUserOptional = task.get().getAcceptedUserList().stream().filter(taskToUser -> taskToUser.getUserId().equals(userId)).findFirst();
 //                if(!taskToUserOptional.isPresent())
 //                    throw new HttpBadRequestException("当前用户没有接收此任务！");
 
                 taskToUserVOS = task.get().getAcceptedUserList().stream()
                         .filter(taskToUser -> taskToUser.getUserId().equals(userId)).map(taskToUser -> {
-                    TaskToUserVO taskToUserVO = new TaskToUserVO(taskToUser);
-                    taskToUserVO.setUserVO(Converter.convert(UserVO.class, taskToUser.getUser()));
-                    if(taskToUser.getIsCommitted() == 1){
-                        StatusVO statusVO = new StatusVO();
-                        statusVO.setText("已提交");
-                        statusVO.setStyle("primary");
-                        taskVO.setStatusVO(statusVO);
-                    }
-                    // 获取当前用户的报告信息
-                    List<CrowdTestReport> crowdTestReportList = taskToUser.getCrowdTestReportList();
-                    if(crowdTestReportList.size() > 0){
-                        List<CrowdReportVO> crowdReportVOS = crowdTestReportList.stream().map(crowdTestReport -> new CrowdReportVO(crowdTestReport)).collect(Collectors.toList());
-                        taskToUserVO.setCrowdReportVOS(crowdReportVOS);
-                    }
-                    return taskToUserVO;
-                }).collect(Collectors.toList());
+                            TaskToUserVO taskToUserVO = new TaskToUserVO(taskToUser);
+                            taskToUserVO.setUserVO(Converter.convert(UserVO.class, taskToUser.getUser()));
+                            if (taskToUser.getIsCommitted() == 1) {
+                                StatusVO statusVO = new StatusVO();
+                                statusVO.setText("已提交");
+                                statusVO.setStyle("primary");
+                                taskVO.setStatusVO(statusVO);
+                            }
+                            // 获取当前用户的报告信息
+                            List<CrowdTestReport> crowdTestReportList = taskToUser.getCrowdTestReportList();
+                            if (crowdTestReportList.size() > 0) {
+                                List<CrowdReportVO> crowdReportVOS = crowdTestReportList.stream().map(crowdTestReport -> new CrowdReportVO(crowdTestReport)).collect(Collectors.toList());
+                                taskToUserVO.setCrowdReportVOS(crowdReportVOS);
+                            }
+                            return taskToUserVO;
+                        }).collect(Collectors.toList());
             }
             taskDetailsDTO.setAcceptedUserList(taskToUserVOS);
         }
 
-        if(saveFlag){
+        if (saveFlag) {
             projectRepo.saveCrowdTestProject(project);
         }
         taskDetailsDTO.setCrowdTaskVO(taskVO);
@@ -568,11 +575,11 @@ public class WebMediatorImpl implements ViewMediator {
         userDTO.setUserVO(new UserVO(user));
         userDTO.setAuthStatus(new StatusVO());
         userDTO.getAuthStatus().initUserAuthStatus(user);
-        if (user.getEvaluationAgency()!=null)
+        if (user.getEvaluationAgency() != null)
             userDTO.setAgencyVO(new AgencyVO(user.getEvaluationAgency()));
-        if (user.getPersonalAuthentication()!=null)
+        if (user.getPersonalAuthentication() != null)
             userDTO.setPersonalAuthVO(new PersonalAuthVO(user.getPersonalAuthentication()));
-        if (user.getEnterpriseAuthentication()!=null)
+        if (user.getEnterpriseAuthentication() != null)
             userDTO.setEnterpriseAuthVO(new EnterpriseAuthVO(user.getEnterpriseAuthentication()));
         List<PermissionVO> permissionList = new ArrayList<>();
         user.getRoleList().forEach(role -> role.getPermissionList().forEach(permission -> permissionList.add(new PermissionVO(permission))));
@@ -674,52 +681,76 @@ public class WebMediatorImpl implements ViewMediator {
         return results;
     }
 
-    private ProjectOperationControl initProjectPermission(CrowdTestProject project, User user){
+
+    public List<CrowdTestProjectVO> crowdTestProjects() {
+        List<CrowdTestProjectVO> authingList = new ArrayList<>();
+        authingList.addAll(projectDao.findAll().stream().map(crowdTestProjectPO -> {
+            CrowdTestProject crowdTestProject = new CrowdTestProject();
+            BeanUtils.copyProperties(crowdTestProjectPO, crowdTestProject);
+            return new CrowdTestProjectVO(crowdTestProject);
+        }).collect(Collectors.toList()));
+        return authingList;
+    }
+
+    @Override
+    public List<CrowdTaskVO> crowdTaskVos() {
+
+
+        List<CrowdTaskVO> authingList = new ArrayList<>();
+        authingList.addAll(taskDao.findAll().stream().map(crowdTestTaskPO -> {
+            CrowdTestTask crowdTestTask = new CrowdTestTask();
+            BeanUtils.copyProperties(crowdTestTaskPO, crowdTestTask);
+            return new CrowdTaskVO(crowdTestTask);
+        }).collect(Collectors.toList()));
+        return authingList;
+    }
+
+    private ProjectOperationControl initProjectPermission(CrowdTestProject project, User user) {
         ProjectOperationControl operationControl = new ProjectOperationControl();
-        if (user==null)
+        if (user == null)
             return operationControl;
         //需求提出者和系统管理员视角
-        if (project.getUserId().equals(user.getId())||user.getRoleList().stream().anyMatch(role -> role.getName().equals("SystemAdministrator"))){
-            if (project.getStatus() < CrowdTestProjectStatus.HAS_RECEIVED){
+        if (project.getUserId().equals(user.getId()) || user.getRoleList().stream().anyMatch(role -> role.getName().equals("SystemAdministrator"))) {
+            if (project.getStatus() < CrowdTestProjectStatus.HAS_RECEIVED) {
                 operationControl.setUpdate(true);
-            } else if (project.getStatus() == CrowdTestProjectStatus.HAS_COMMITED){
+            } else if (project.getStatus() == CrowdTestProjectStatus.HAS_COMMITED) {
                 operationControl.setConfirmFinish(true);
             }
         }
         //区域管理员视角
-        if (user.getRoleList().stream().anyMatch(role -> role.getName().equals("RegionalManager"))){
+        if (user.getRoleList().stream().anyMatch(role -> role.getName().equals("RegionalManager"))) {
             if ((project.getProjectDistributionTypeId() == 0 && project.getRegionalManagerId().equals(user.getId()))
-                    || (project.getProjectDistributionTypeId()>0 && project.getStatus()>=CrowdTestProjectStatus.HAS_RECEIVED && project.getRegionalManagerId().equals(user.getId()))){
-                if (project.getStatus() == CrowdTestProjectStatus.HAS_RELEASED){
+                    || (project.getProjectDistributionTypeId() > 0 && project.getStatus() >= CrowdTestProjectStatus.HAS_RECEIVED && project.getRegionalManagerId().equals(user.getId()))) {
+                if (project.getStatus() == CrowdTestProjectStatus.HAS_RELEASED) {
                     operationControl.setReceive(true);
                     operationControl.setReject(true);
-                } else if (project.getStatus() == CrowdTestProjectStatus.HAS_RECEIVED){
+                } else if (project.getStatus() == CrowdTestProjectStatus.HAS_RECEIVED) {
                     operationControl.setCreateTask(true);
                     // 无任务
-                    if(project.getCrowdTestTaskList() == null || project.getCrowdTestTaskList().size() == 0){
+                    if (project.getCrowdTestTaskList() == null || project.getCrowdTestTaskList().size() == 0) {
                         operationControl.setUploadReport(false);
-                    }else {
-                        if(project.getCrowdTestTaskList()
-                                .stream().allMatch(task -> task.getStatus()==CrowdTestTaskStatus.HAS_REJECTED||task.getStatus()==CrowdTestTaskStatus.HAS_FINISHED)) {
+                    } else {
+                        if (project.getCrowdTestTaskList()
+                                .stream().allMatch(task -> task.getStatus() == CrowdTestTaskStatus.HAS_REJECTED || task.getStatus() == CrowdTestTaskStatus.HAS_FINISHED)) {
                             operationControl.setUploadReport(true);
                         }
                     }
-                    if (project.getCrowdTestReportForProject()!=null){
+                    if (project.getCrowdTestReportForProject() != null) {
                         operationControl.setFinish(true);
                     }
-                } else if (project.getStatus() == CrowdTestProjectStatus.HAS_COMMITED){
+                } else if (project.getStatus() == CrowdTestProjectStatus.HAS_COMMITED) {
                     operationControl.setCreateTask(false);
                 }
             } //下面两种情况为非定向未被接收
-            else if (project.getProjectDistributionTypeId()==1){
-                if (project.getStatus()==CrowdTestProjectStatus.HAS_RELEASED
+            else if (project.getProjectDistributionTypeId() == 1) {
+                if (project.getStatus() == CrowdTestProjectStatus.HAS_RELEASED
                         && user.getRegionalManager().getRegionalList()
-                        .stream().anyMatch(regional -> (regional.getProvince().equals("*")||regional.getProvince().equals(project.getDistributionProvince()))
-                                && (regional.getCity().equals("*")||regional.getCity().equals(project.getDistributionCity())))){
+                        .stream().anyMatch(regional -> (regional.getProvince().equals("*") || regional.getProvince().equals(project.getDistributionProvince()))
+                                && (regional.getCity().equals("*") || regional.getCity().equals(project.getDistributionCity())))) {
                     operationControl.setReceive(true);
                 }
-            } else if (project.getProjectDistributionTypeId() == 2){
-                if (project.getStatus() == CrowdTestProjectStatus.HAS_RELEASED){
+            } else if (project.getProjectDistributionTypeId() == 2) {
+                if (project.getStatus() == CrowdTestProjectStatus.HAS_RELEASED) {
                     operationControl.setReceive(true);
                 }
             }
@@ -727,70 +758,70 @@ public class WebMediatorImpl implements ViewMediator {
         return operationControl;
     }
 
-    private TaskOperationControl initTaskPermission(CrowdTestProject project, CrowdTestTask task, User user){
+    private TaskOperationControl initTaskPermission(CrowdTestProject project, CrowdTestTask task, User user) {
         TaskOperationControl taskOperationControl = new TaskOperationControl();
-        if (user==null)
+        if (user == null)
             return taskOperationControl;
         //区域管理员或系统管理员视角
         if (user.getRoleList().stream().anyMatch(role -> role.getName().equals("SystemAdministrator"))
-                ||(user.getRegionalManager()!=null&&user.getId().equals(project.getRegionalManagerId()))){
-            if ((task.getParticipantHasCommittedCount() == task.getAcceptedCount() && task.getStatus() == CrowdTestTaskStatus.HAS_RECEIVED)|| (task.getParticipantHasCommittedCount() == task.getParticipantCount() && task.getStatus() == CrowdTestTaskStatus.HAS_COMMITED)){
+                || (user.getRegionalManager() != null && user.getId().equals(project.getRegionalManagerId()))) {
+            if ((task.getParticipantHasCommittedCount() == task.getAcceptedCount() && task.getStatus() == CrowdTestTaskStatus.HAS_RECEIVED) || (task.getParticipantHasCommittedCount() == task.getParticipantCount() && task.getStatus() == CrowdTestTaskStatus.HAS_COMMITED)) {
                 taskOperationControl.setConfirmFinish(true);
             }
-            if (task.getStatus()<CrowdTestTaskStatus.HAS_RECEIVED){
+            if (task.getStatus() < CrowdTestTaskStatus.HAS_RECEIVED) {
                 taskOperationControl.setUpdate(true);
             }
             taskOperationControl.setFinish(false);
-            if (task.getStatus() == CrowdTestTaskStatus.HAS_FINISHED || task.getStatus() == CrowdTestTaskStatus.HAS_TIME_OUT){
+            if (task.getStatus() == CrowdTestTaskStatus.HAS_FINISHED || task.getStatus() == CrowdTestTaskStatus.HAS_TIME_OUT) {
                 taskOperationControl.setConfirmFinish(false);
             }
         }
         //评测机构视角
-        if (user.getRoleList().stream().anyMatch(role -> role.getName().equals("evaluationAgency")) && task.getStatus()!=CrowdTestTaskStatus.HAS_REJECTED){
-            if ((task.getDistributionType()==0 && task.getEvaluationAgencyId().equals(user.getId()))
-                    ||(task.getDistributionType()==2 && task.getStatus()>=CrowdTestTaskStatus.HAS_RECEIVED)){
+        if (user.getRoleList().stream().anyMatch(role -> role.getName().equals("evaluationAgency")) && task.getStatus() != CrowdTestTaskStatus.HAS_REJECTED) {
+            if ((task.getDistributionType() == 0 && task.getEvaluationAgencyId().equals(user.getId()))
+                    || (task.getDistributionType() == 2 && task.getStatus() >= CrowdTestTaskStatus.HAS_RECEIVED)) {
                 List<TaskToUser> acceptedUserList = task.getAcceptedUserList();
                 Optional<TaskToUser> taskToUserOptional = acceptedUserList.stream().filter(taskToUser -> taskToUser.getUserId().equals(user.getId())).findFirst();
 
-                if(taskToUserOptional.isPresent()){
+                if (taskToUserOptional.isPresent()) {
                     // 已接收用户
-                    if (task.getStatus()==CrowdTestTaskStatus.HAS_RELEASED){
+                    if (task.getStatus() == CrowdTestTaskStatus.HAS_RELEASED) {
                         taskOperationControl.setReceive(true);
-                        if (task.getDistributionType()==0)
+                        if (task.getDistributionType() == 0)
                             taskOperationControl.setReject(true);
-                    } else if (task.getStatus() == CrowdTestTaskStatus.HAS_RECEIVED){
+                    } else if (task.getStatus() == CrowdTestTaskStatus.HAS_RECEIVED) {
                         taskOperationControl.setUploadReport(true);
-                        if (taskToUserOptional.get().getHasReport() == 1 && taskToUserOptional.get().getIsCommitted() == 0){
+                        if (taskToUserOptional.get().getHasReport() == 1 && taskToUserOptional.get().getIsCommitted() == 0) {
                             taskOperationControl.setFinish(true);
-                        }else if (taskToUserOptional.get().getHasReport() == 1 && taskToUserOptional.get().getIsCommitted() == 1){
+                        } else if (taskToUserOptional.get().getHasReport() == 1 && taskToUserOptional.get().getIsCommitted() == 1) {
                             taskOperationControl.setFinish(false);
                             taskOperationControl.setUploadReport(false);
                         }
-                    } else if (task.getStatus() == CrowdTestTaskStatus.HAS_COMMITED){
+                    } else if (task.getStatus() == CrowdTestTaskStatus.HAS_COMMITED) {
                         taskOperationControl.setUploadReport(false);
                     }
-                }else{
+                } else {
                     // 未接收用户
                     taskOperationControl.setReceive(true);
-                    if (task.getStatus()==CrowdTestTaskStatus.HAS_RELEASED){
+                    if (task.getStatus() == CrowdTestTaskStatus.HAS_RELEASED) {
                         // 定向的
-                        if (task.getDistributionType()==0) {
+                        if (task.getDistributionType() == 0) {
                             taskOperationControl.setReject(true);
                         }
                     }
                 }
 
-            } else if (task.getDistributionType()==2){
-                if (task.getStatus()==CrowdTestTaskStatus.HAS_RELEASED){
+            } else if (task.getDistributionType() == 2) {
+                if (task.getStatus() == CrowdTestTaskStatus.HAS_RELEASED) {
                     taskOperationControl.setReceive(true);
                     // 项目发起者
-                    if(project.getUserId().equals(user.getId())){
+                    if (project.getUserId().equals(user.getId())) {
                         taskOperationControl.setReceive(false);
                     }
                 }
             }
         }
-        if(task.getStatus() == CrowdTestTaskStatus.HAS_FINISHED || task.getStatus() == CrowdTestTaskStatus.HAS_TIME_OUT){
+        if (task.getStatus() == CrowdTestTaskStatus.HAS_FINISHED || task.getStatus() == CrowdTestTaskStatus.HAS_TIME_OUT) {
             taskOperationControl.noAll();
         }
         System.out.println(taskOperationControl);

site/src/main/java/com/mooctest/crowd/site/service/CommonService.java

@@ -4,6 +4,7 @@ import com.mooctest.crowd.site.data.dto.IndexDTO;
 import com.mooctest.crowd.site.data.dto.IndexInfoDTO;
 import com.mooctest.crowd.site.data.dto.MyCrowdDTO;
 import com.mooctest.crowd.site.data.vo.CrowdProjectVO;
+import com.mooctest.crowd.site.data.vo.CrowdTaskVO;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
@@ -17,4 +18,6 @@ public interface CommonService {
     IndexInfoDTO getIndexInfos();
 
     Page<CrowdProjectVO> getProjectInfo(Pageable pageable, String keyword, int deletedStatus);
+
+    Page<CrowdTaskVO>   getTaskInfo(Pageable pageable,String keyword,int deletedstatus);
 }

site/src/main/java/com/mooctest/crowd/site/service/CrowdProjectService.java

@@ -5,6 +5,7 @@ import com.mooctest.crowd.domain.model.CrowdTestProjectPO;
 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.CrowdTestProjectVO;
 import com.mooctest.crowd.site.data.vo.RegionalManagerVO;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
@@ -21,9 +22,9 @@ import java.util.List;
  */
 public interface CrowdProjectService {
 
-    Page<CrowdTestProjectPO> findAll(Pageable pageable);
+    Page<CrowdTestProject> findAll(Pageable pageable);
 
-    List<CrowdTestProjectPO> findAll( );
+    List<CrowdTestProjectVO> findAll();
 
     ProjectDetailsDTO getProjectDetails(String projectCode, Long userId);
 

site/src/main/java/com/mooctest/crowd/site/service/CrowdTaskService.java

@@ -1,9 +1,10 @@
 package com.mooctest.crowd.site.service;
 
-import com.mooctest.crowd.domain.model.CrowdTestTaskPO;
+import com.mooctest.crowd.domain.domainobject.CrowdTestTask;
 import com.mooctest.crowd.site.command.CrowdTestTaskCommand;
 import com.mooctest.crowd.site.data.dto.TaskDetailsDTO;
 import com.mooctest.crowd.site.data.dto.TaskSquareDTO;
+import com.mooctest.crowd.site.data.vo.CrowdTaskVO;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import java.util.List;
@@ -15,9 +16,9 @@ import java.util.List;
  */
 public interface CrowdTaskService {
 
-    Page<CrowdTestTaskPO> findAll(Pageable pageable);
 
-    List<CrowdTestTaskPO> findAll();
+     List<CrowdTaskVO> findAll();
+
 
     TaskDetailsDTO getTaskDetails(String projectCode, String taskCode, Long userId);
 

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

@@ -1,10 +1,13 @@
 package com.mooctest.crowd.site.service.impl;
 
+import com.mooctest.crowd.domain.domainobject.CrowdTestTask;
 import com.mooctest.crowd.domain.repository.CrowdTestProjectRepo;
+import com.mooctest.crowd.domain.repository.CrowdTestTaskRepo;
 import com.mooctest.crowd.site.data.dto.IndexDTO;
 import com.mooctest.crowd.site.data.dto.IndexInfoDTO;
 import com.mooctest.crowd.site.data.dto.MyCrowdDTO;
 import com.mooctest.crowd.site.data.vo.CrowdProjectVO;
+import com.mooctest.crowd.site.data.vo.CrowdTaskVO;
 import com.mooctest.crowd.site.mediator.ViewMediator;
 import com.mooctest.crowd.site.service.CommonService;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -23,6 +26,9 @@ public class CommonServiceImpl implements CommonService {
     @Autowired
     private CrowdTestProjectRepo projectRepo;
 
+    @Autowired
+    private CrowdTestTaskRepo    taskRepo;
+
     @Override
     public IndexDTO getIndexInfo() {
         return viewMediator.renderIndex();
@@ -43,4 +49,10 @@ public class CommonServiceImpl implements CommonService {
         return projectRepo.findAllByPage(pageable, keyword, deletedStatus).map(crowdTestProject -> new CrowdProjectVO(crowdTestProject));
     }
 
+    @Override
+    public Page<CrowdTaskVO> getTaskInfo(Pageable pageable, String keyword, int deletedstatus) {
+
+      return  taskRepo.findAllByPage(pageable,keyword,deletedstatus).map(crowdTestTask -> new CrowdTaskVO(crowdTestTask));
+    }
+
 }

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

@@ -15,6 +15,7 @@ import com.mooctest.crowd.site.command.GenerateProjectCommand;
 import com.mooctest.crowd.site.data.dto.ProjectDetailsDTO;
 import com.mooctest.crowd.site.data.enums.ProjectType;
 import com.mooctest.crowd.site.data.vo.CrowdProjectVO;
+import com.mooctest.crowd.site.data.vo.CrowdTestProjectVO;
 import com.mooctest.crowd.site.data.vo.RegionalManagerVO;
 import com.mooctest.crowd.site.mediator.OperationMediator;
 import com.mooctest.crowd.site.mediator.ViewMediator;
@@ -24,6 +25,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
 import org.apache.poi.ss.usermodel.*;
 import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
@@ -47,7 +49,7 @@ import java.util.stream.Collectors;
  */
 @Slf4j
 @Service
-public class CrowdProjectServiceImpl implements CrowdProjectService{
+public class CrowdProjectServiceImpl implements CrowdProjectService {
 
     @Autowired
     private ViewMediator viewMediator;
@@ -69,24 +71,27 @@ public class CrowdProjectServiceImpl implements CrowdProjectService{
      * @return
      */
     @Override
-    public Page<CrowdTestProjectPO> findAll(Pageable pageable) {
+    public Page<CrowdTestProject> findAll(Pageable pageable) {
 
-        Specification<CrowdTestProjectPO> queryContion = new Specification<CrowdTestProjectPO>() {
+        Specification<CrowdTestProject> queryContion = new Specification<CrowdTestProject>() {
             @Override
-            public Predicate toPredicate(Root<CrowdTestProjectPO> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
+            public Predicate toPredicate(Root<CrowdTestProject> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                 Path<Object> custName = root.get("status");
                 Predicate predicate = cb.notEqual(custName, CrowdTestProjectStatus.HAS_FINISHED);
+
                 return predicate;
             }
         };
-        return projectRepo.findAll(queryContion, pageable);
+
+        return  projectRepo.findAllByPage(pageable,null,0);
     }
 
     @Override
-    public List<CrowdTestProjectPO> findAll() {
-        return projectRepo.findAll();
+    public List<CrowdTestProjectVO> findAll() {
+        return viewMediator.crowdTestProjects();
     }
 
+
     @Override
     public ProjectDetailsDTO getProjectDetails(String projectCode, Long userId) {
         if (userId == null)
@@ -444,7 +449,7 @@ public class CrowdProjectServiceImpl implements CrowdProjectService{
     /**
      * 香港手机号码8位数，5|6|8|9开头+7位任意数
      */
-    private boolean isHKPhoneLegal(String str) throws PatternSyntaxException{
+    private boolean isHKPhoneLegal(String str) throws PatternSyntaxException {
         String regExp = "^(5|6|8|9)\\d{7}$";
         Pattern p = Pattern.compile(regExp);
         Matcher m = p.matcher(str);
@@ -454,7 +459,7 @@ public class CrowdProjectServiceImpl implements CrowdProjectService{
     /**
      * 座机号
      */
-    private boolean isTel(String str) throws PatternSyntaxException{
+    private boolean isTel(String str) throws PatternSyntaxException {
         String regExp = "^0[1-9](\\d{1,2}\\-?)\\d{7,8}";
         Pattern p = Pattern.compile(regExp);
         Matcher m = p.matcher(str);

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

@@ -6,15 +6,15 @@ import com.mooctest.crowd.domain.domainobject.*;
 import com.mooctest.crowd.domain.exception.BaseException;
 import com.mooctest.crowd.domain.exception.CrowdTestTaskNotExistException;
 import com.mooctest.crowd.domain.exception.UnauthorizedException;
-import com.mooctest.crowd.domain.model.CrowdTestProjectPO;
-import com.mooctest.crowd.domain.model.CrowdTestTaskPO;
 import com.mooctest.crowd.domain.repository.CrowdTestProjectRepo;
+import com.mooctest.crowd.domain.repository.CrowdTestTaskRepo;
 import com.mooctest.crowd.domain.repository.UserRepo;
 import com.mooctest.crowd.site.command.CrowdTestTaskCommand;
 import com.mooctest.crowd.site.data.dto.TaskDetailsDTO;
 import com.mooctest.crowd.site.data.dto.TaskSquareDTO;
 import com.mooctest.crowd.site.data.enums.ProjectType;
 import com.mooctest.crowd.site.data.enums.RoleType;
+import com.mooctest.crowd.site.data.vo.CrowdTaskVO;
 import com.mooctest.crowd.site.mediator.ViewMediator;
 import com.mooctest.crowd.site.service.CrowdTaskService;
 import com.mooctest.crowd.site.util.GenerateFlowCodeUtil;
@@ -22,11 +22,8 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
-import org.springframework.data.jpa.domain.Specification;
 import org.springframework.stereotype.Service;
 
-import javax.persistence.criteria.*;
-
 
 import java.util.List;
 import java.util.Optional;
@@ -41,6 +38,10 @@ import java.util.Optional;
 public class CrowdTaskServiceImpl implements CrowdTaskService {
 
     @Autowired
+    private CrowdTestTaskRepo taskRepo;
+
+
+    @Autowired
     CrowdTestProjectRepo projectRepo;
 
     @Autowired
@@ -57,24 +58,8 @@ public class CrowdTaskServiceImpl implements CrowdTaskService {
 
 
     @Override
-    public Page<CrowdTestTaskPO> findAll(Pageable pageable) {
-
-        Specification<CrowdTestTaskPO> queryContion = new Specification<CrowdTestTaskPO>() {
-            @Override
-            public Predicate toPredicate(Root<CrowdTestTaskPO> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
-                Path<Object> custName = root.get("status");
-                Predicate predicate = cb.notEqual(custName, CrowdTestTaskStatus.HAS_FINISHED);
-                return predicate;
-            }
-        };
-        return taskDao.findAll(queryContion, pageable);
-    }
-
-
-    @Override
-    public List<CrowdTestTaskPO> findAll() {
-
-        return  taskDao.findAllByIsDeleted(0);
+    public List<CrowdTaskVO> findAll() {
+        return   viewMediator.crowdTaskVos();
     }
 
     @Override

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

@@ -11,7 +11,7 @@ import org.springframework.stereotype.Service;
 import java.util.List;
 
 @Service
-public class TechnicalArticlesServiceImpl implements TechnicalArticlesService {
+public class TechnicalArticlesServiceImpl implements TechnicalArticlesService{