update

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

@@ -3,9 +3,7 @@ package com.mooctest.crowd.domain.dao;
 import com.mooctest.crowd.domain.model.CrowdTestProjectPO;
 import com.mooctest.crowd.domain.model.RankInfo;
 import com.mooctest.crowd.domain.model.RankInfos;
-import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
-import org.springframework.data.jpa.domain.Specification;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
 import org.springframework.data.jpa.repository.Modifying;
@@ -49,8 +47,6 @@ public interface CrowdTestProjectDao extends CrudRepository<CrowdTestProjectPO,
     @Query(value = "SELECT * FROM crowd_test_project p WHERE CTP_STATUS !=4 and CTP_STATUS !=5 ORDER BY CTP_JOIN_COUNT DESC ,CTP_CREATE_TIME LIMIT 7; ", nativeQuery = true)
     List<CrowdTestProjectPO> findall();
 
-    Page<CrowdTestProjectPO> findAll(Specification<CrowdTestProjectPO> spec, Pageable pageable);
-
     CrowdTestProjectPO findByIdAndIsDeleted(Long id, int isDeleted);
 
     CrowdTestProjectPO findByCodeAndIsDeleted(String code, int isDeleted);

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

@@ -2,10 +2,7 @@ package com.mooctest.crowd.domain.repository;
 
 import com.mooctest.crowd.domain.dao.*;
 import com.mooctest.crowd.domain.domainobject.*;
-import com.mooctest.crowd.domain.exception.ApplicationTypeNoExistException;
-import com.mooctest.crowd.domain.exception.BadRequestException;
-import com.mooctest.crowd.domain.exception.FieldNoExistException;
-import com.mooctest.crowd.domain.exception.TestTypeNoExistException;
+import com.mooctest.crowd.domain.exception.*;
 import com.mooctest.crowd.domain.model.*;
 import com.mooctest.crowd.domain.util.Converter;
 import org.apache.commons.lang3.StringUtils;
@@ -58,43 +55,44 @@ public class CommonRepo {
     private ExpertDao expertDao;
 
     @Autowired
-    private  CompetitionsDao competitionsDao;
+    private CompetitionsDao competitionsDao;
 
     @Autowired
     private CrowdTestProjectDao crowdTestProjectDao;
 
-    public List<TestType> getAllTestType(){
+    public List<TestType> getAllTestType() {
         return testTypeDao.findAll().stream().map(testTypePO -> Converter.convert(TestType.class, testTypePO)).collect(Collectors.toList());
     }
 
-    public List<ApplicationType> getAllApplicationType(){
+    public List<ApplicationType> getAllApplicationType() {
         return applicationTypeDao.findAll().stream().map(applicationTypePO -> Converter.convert(ApplicationType.class, applicationTypePO)).collect(Collectors.toList());
     }
 
-    public List<Field> getAllFieldType(){
+    public List<Field> getAllFieldType() {
         return fieldDao.findAll().stream().map(fieldPO -> Converter.convert(Field.class, fieldPO)).collect(Collectors.toList());
     }
 
-    public List<Resource> getAllResource(){
+    public List<Resource> getAllResource() {
         return resourceDao.findAll().stream().map(resourcePO -> Converter.convert(Resource.class, resourcePO)).collect(Collectors.toList());
     }
 
-    public List<Competition> getAllCompetition(){
+    public List<Competition> getAllCompetition() {
         return competitionDao.findAll().stream()
                 .map(competitionPO -> Converter.convert(Competition.class, competitionPO))
                 .filter(competition -> competition.getIsDeleted() == DeletedStatus.isNotDeleted).collect(Collectors.toList());
     }
 
-    public Page<Competition> findAllCompetition(Pageable pageable,String keyword) {
-        Specifications<CompetitionPO> where =  Specifications.where(getArticlesByIsNotDeleted(keyword));
-        return  competitionsDao.findAll(where,pageable).map(CompetitionPO -> Converter.convert(Competition.class, CompetitionPO));
+    public Page<Competition> findAllCompetition(Pageable pageable, String keyword) {
+        Specifications<CompetitionPO> where = Specifications.where(getArticlesByIsNotDeleted(keyword));
+        return competitionsDao.findAll(where, pageable).map(CompetitionPO -> Converter.convert(Competition.class, CompetitionPO));
     }
+
     private Specification<CompetitionPO> getArticlesByIsNotDeleted(String keyword) {
         return new Specification<CompetitionPO>() {
             @Override
             public Predicate toPredicate(Root<CompetitionPO> a, CriteriaQuery<?> q, CriteriaBuilder cb) {
                 Predicate predicate = cb.conjunction();
-                if(keyword != null) {
+                if (keyword != null) {
                     predicate.getExpressions().add(
                             cb.like(a.<String>get("name"), "%" + StringUtils.trim(keyword) + "%")
                     );
@@ -103,53 +101,55 @@ public class CommonRepo {
             }
         };
     }
-    public List<Competition> getAllCompetitionTop3(Pageable pageable){
+
+    public List<Competition> getAllCompetitionTop3(Pageable pageable) {
         List<CompetitionPO> competitionPOS = competitionDao.findAll(pageable);
         return competitionPOS.stream().map(competitionPO -> Converter.convert(Competition.class, competitionPO))
                 .filter(competition -> competition.getIsDeleted() == DeletedStatus.isNotDeleted).collect(Collectors.toList());
     }
-    public List<Partner> getAllPartner(){
+
+    public List<Partner> getAllPartner() {
         return partnerDao.findAll().stream().map(partnerPO -> Converter.convert(Partner.class, partnerPO)).collect(Collectors.toList());
     }
 
-    public List<ResidentAgency> getAllResidentAgency(){
+    public List<ResidentAgency> getAllResidentAgency() {
         return residentAgencyDao.findAll().stream().map(residentAgencyPO -> Converter.convert(ResidentAgency.class, residentAgencyPO)).collect(Collectors.toList());
     }
 
-    public ApplicationType getApplicationTypeByAppCode(String appCode){
+    public ApplicationType getApplicationTypeByAppCode(String appCode) {
         Optional<ApplicationTypePO> applicationTypePO = applicationTypeDao.findByCode(appCode);
-        if(!applicationTypePO.isPresent()){
+        if (!applicationTypePO.isPresent()) {
             throw new ApplicationTypeNoExistException();
-        }else {
+        } else {
             return Converter.convert(ApplicationType.class, applicationTypePO.get());
         }
 
     }
 
-    public TestType getTestTypeByAppCode(String typeCode){
+    public TestType getTestTypeByAppCode(String typeCode) {
         Optional<TestTypePO> testTypePO = testTypeDao.findByCode(typeCode);
-        if(!testTypePO.isPresent()){
+        if (!testTypePO.isPresent()) {
             throw new TestTypeNoExistException();
-        }else {
+        } else {
             return Converter.convert(TestType.class, testTypePO.get());
         }
     }
 
-    public Field getFieldByFieldCode(String code){
+    public Field getFieldByFieldCode(String code) {
         Optional<FieldPO> fieldPO = fieldDao.findByCode(code);
-        if(!fieldPO.isPresent()){
+        if (!fieldPO.isPresent()) {
             throw new FieldNoExistException();
-        }else {
+        } else {
             return Converter.convert(Field.class, fieldPO.get());
         }
     }
 
-    public List<ApplicationTypeToTestType> getAppToTypeByAppCode(String appCode){
+    public List<ApplicationTypeToTestType> getAppToTypeByAppCode(String appCode) {
         List<ApplicationTypeToTestTypePO> appToTypeList = applicationTypeToTestTypeDao.findByApplicationTypeCode(appCode);
         return appToTypeList.stream().map(applicationTypeToTestTypePO -> Converter.convert(ApplicationTypeToTestType.class, applicationTypeToTestTypePO)).collect(Collectors.toList());
     }
 
-    public List<TestType> getTestTypeListByAppCode(String appTypeCode){
+    public List<TestType> getTestTypeListByAppCode(String appTypeCode) {
         List<ApplicationTypeToTestType> appToTypeList = getAppToTypeByAppCode(appTypeCode);
         List<TestType> testTypeList = appToTypeList.stream().map(applicationTypeToTestType -> {
             TestType testTypeByAppCode = getTestTypeByAppCode(applicationTypeToTestType.getTestTypeCode());
@@ -158,8 +158,8 @@ public class CommonRepo {
         return testTypeList;
     }
 
-    public Page<Resource> findAllResourceByPage(Pageable pageable, String keyword){
-        Specifications<ResourcePO> where =  Specifications.where(getResource(keyword));
+    public Page<Resource> findAllResourceByPage(Pageable pageable, String keyword) {
+        Specifications<ResourcePO> where = Specifications.where(getResource(keyword));
         return resourceDao.findAll(where, pageable).map(resourcePO -> Converter.convert(Resource.class, resourcePO));
     }
 
@@ -168,7 +168,7 @@ public class CommonRepo {
             @Override
             public Predicate toPredicate(Root<ResourcePO> a, CriteriaQuery<?> q, CriteriaBuilder cb) {
                 Predicate predicate = cb.conjunction();
-                if(keyword != null) {
+                if (keyword != null) {
                     predicate.getExpressions().add(
                             cb.like(a.<String>get("name"), "%" + StringUtils.trim(keyword) + "%")
                     );
@@ -178,16 +178,16 @@ public class CommonRepo {
         };
     }
 
-    public Page<Expert> findAllExpertByPage(Pageable pageable, String keyword){
-        Specifications<ExpertPO> where =  Specifications.where(getExpert(keyword));
+    public Page<Expert> findAllExpertByPage(Pageable pageable, String keyword) {
+        Specifications<ExpertPO> where = Specifications.where(getExpert(keyword));
         return expertDao.findAll(where, pageable).map(expertPO -> Converter.convert(Expert.class, expertPO));
     }
 
-    public Expert findExpertById(Long id){
+    public Expert findExpertById(Long id) {
         Optional<ExpertPO> expertPOOptional = expertDao.findById(id);
-        if(!expertPOOptional.isPresent()){
+        if (!expertPOOptional.isPresent()) {
             throw new BadRequestException("专家信息不存在！");
-        }else{
+        } else {
             return Converter.convert(Expert.class, expertPOOptional.get());
         }
     }
@@ -197,7 +197,7 @@ public class CommonRepo {
             @Override
             public Predicate toPredicate(Root<ExpertPO> a, CriteriaQuery<?> q, CriteriaBuilder cb) {
                 Predicate predicate = cb.conjunction();
-                if(keyword != null) {
+                if (keyword != null) {
                     predicate.getExpressions().add(
                             cb.like(a.<String>get("name"), "%" + StringUtils.trim(keyword) + "%")
                     );
@@ -207,22 +207,46 @@ public class CommonRepo {
         };
     }
 
-    public Page<CrowdTestProject> getProjectList(Pageable pageable, String code){
-        Specifications<CrowdTestProjectPO> where =  Specifications.where(getCode(code));
+    public Page<CrowdTestProject> getProjectList(Pageable pageable, String code, String keyword) {
+        System.out.println("code " + code);
+        Specifications<CrowdTestProjectPO> where = Specifications.where(getCode(code, keyword));
         return crowdTestProjectDao.findAll(where, pageable).map(crowdTestProjectPO -> Converter.convert(CrowdTestProject.class, crowdTestProjectPO));
     }
-    private Specification<CrowdTestProjectPO> getCode(String code) {
+
+    private Specification<CrowdTestProjectPO> getCode(String code, String keyword) {
         return new Specification<CrowdTestProjectPO>() {
             @Override
             public Predicate toPredicate(Root<CrowdTestProjectPO> a, CriteriaQuery<?> q, CriteriaBuilder cb) {
                 Predicate predicate = cb.conjunction();
-                if(code != null) {
+                if (code != null) {
+                    predicate.getExpressions().add(cb.equal(a.get("applicationType"), code));
+                }
+                if (keyword != null && keyword != "") {
                     predicate.getExpressions().add(
-                            cb.equal(a.get("applicationType"), code)
+                            cb.like(a.<String>get("name"), "%" + StringUtils.trim(keyword) + "%")
                     );
                 }
+//                q.orderBy(cb.desc(a.get("status").as(Integer.class)));
                 return predicate;
             }
         };
     }
+
+    public String getTypeNameByCode(String code) {
+        // 测试类型的转换
+        Optional<TestTypePO> testTypePO = testTypeDao.findByCode(code);
+        if (!testTypePO.isPresent()) {
+            throw new HttpBadRequestException("请选择测试类型");
+        }
+        return testTypePO.get().getName();
+    }
+
+    public String getApplicationNameByCode(String code) {
+        Optional<ApplicationTypePO> applicationTypePO = applicationTypeDao.findByCode(code);
+        if (!applicationTypePO.isPresent()) {
+            throw new HttpBadRequestException("请选择应用类型");
+        }
+        return applicationTypePO.get().getName();
+    }
+
 }

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

@@ -127,6 +127,7 @@ public class CrowdProjectController{
         } catch (IOException e) {
             e.printStackTrace();
         }
+        System.out.println("excel");
         return projectService.generateProjectByExcel(userId, file);
     }
 

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

@@ -22,7 +22,7 @@ import static com.mooctest.crowd.site.data.vo.CrowdTestProjectVO.getDistanceTime
 @NoArgsConstructor
 @AllArgsConstructor
 public class CrowdTaskVO implements Serializable{
-    private String id;
+    private long id;
     private String code;
     private String projectId;
     private String title;
@@ -50,7 +50,7 @@ public class CrowdTaskVO implements Serializable{
     private String time_interval;
 
     public CrowdTaskVO(CrowdTestTask task){
-        id = task.getCode();
+        id = task.getId();
         code = task.getCode();
         projectId = task.getCrowdTestProjectCode();
         title = task.getName();

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

@@ -1,8 +1,6 @@
 package com.mooctest.crowd.site.data.vo;
 
-import com.mooctest.crowd.domain.domainobject.CrowdTestProjectStatus;
 import com.mooctest.crowd.domain.domainobject.Resource;
-import com.mooctest.crowd.domain.domainobject.ResourceStatus;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
@@ -48,6 +46,15 @@ public class ResourceVO implements Serializable {
         startTime=resource.getStartTime();
         personnel=resource.getPersonnel();
         remarks=resource.getRemarks();
+        if(resource.getState()==0){
+            this.setState("空闲");
+        }else if(resource.getState()==1){
+            this.setState("占用");
+        }else if(resource.getState()==2){
+            this.setState("可用");
+        }else if(resource.getState()==3){
+            this.setState("故障");
+        }
     }
 
 }

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

@@ -628,11 +628,8 @@ public class WebMediatorImpl implements ViewMediator {
                                 CrowdTestTask task = new CrowdTestTask();
                                 BeanUtils.copyProperties(crowdTestTaskPO, task);
                                 // 测试类型的转换
-                                Optional<TestTypePO> testTypePO = testTypeDao.findByCode(task.getType());
-                                if (!testTypePO.isPresent()) {
-                                    throw new HttpBadRequestException("请选择测试类型");
-                                }
-                                task.setType(testTypePO.get().getName());
+                                String typeName = commonRepo.getTypeNameByCode(task.getType());
+                                task.setType(typeName);
                                 return task;
                             }
                             return null;
@@ -678,11 +675,8 @@ public class WebMediatorImpl implements ViewMediator {
                                 BeanUtils.copyProperties(crowdTestTaskPO, task);
 
                                 // 测试类型的转换
-                                Optional<TestTypePO> testTypePO = testTypeDao.findByCode(task.getType());
-                                if (!testTypePO.isPresent()) {
-                                    throw new HttpBadRequestException("请选择测试类型");
-                                }
-                                task.setType(testTypePO.get().getName());
+                                String typeName = commonRepo.getTypeNameByCode(task.getType());
+                                task.setType(typeName);
                                 CrowdTestTask taskDetail = projectRepo.getTaskDetail(task, user.getId());
                                 return taskDetail;
                             }
@@ -705,12 +699,8 @@ public class WebMediatorImpl implements ViewMediator {
 
     private CrowdProjectVO changeApplicationType(CrowdProjectVO projectVO) {
         // 应用类型值的转换
-        Optional<ApplicationTypePO> applicationTypePO = applicationTypeDao.findByCode(projectVO.getPlatform());
-        if (applicationTypePO.isPresent()) {
-            projectVO.setPlatform(applicationTypePO.get().getName());
-        } else {
-            throw new HttpBadRequestException("请选择应用类型");
-        }
+        String applicationName = commonRepo.getApplicationNameByCode(projectVO.getPlatform());
+        projectVO.setPlatform(applicationName);
         return projectVO;
     }
 
@@ -721,11 +711,8 @@ public class WebMediatorImpl implements ViewMediator {
             CrowdTestTask task = CrowdTestProjectFactory.defaultTask();
             BeanUtils.copyProperties(crowdTestTaskPO, task);
             // 测试类型的转换
-            Optional<TestTypePO> testTypePO = testTypeDao.findByCode(task.getType());
-            if (!testTypePO.isPresent()) {
-                throw new HttpBadRequestException("请选择测试类型");
-            }
-            task.setType(testTypePO.get().getName());
+            String typeName = commonRepo.getTypeNameByCode(task.getType());
+            task.setType(typeName);
             return task;
         }).collect(Collectors.toList()).stream().filter(crowdTestTask -> crowdTestTask.getStatus() == CrowdTestTaskStatus.HAS_RELEASED ||
                 (crowdTestTask.getStatus() == CrowdTestTaskStatus.HAS_RECEIVED && crowdTestTask.getFullStatus() == CrowdTestTaskAcceptStatus.NOT_FULL))
@@ -760,10 +747,9 @@ public class WebMediatorImpl implements ViewMediator {
                 EvaluationAgencyPO agencyPO = agencyDao.findByUserId(crowdTestTask.getEvaluationAgencyId());
                 crowdTaskVO.setInstitution(agencyPO == null ? "该机构已注销" : agencyPO.getEvaluationAgencyName());
             }
-
             // 测试类型的转换
-            Optional<TestTypePO> testTypePO = testTypeDao.findByCode(crowdTaskVO.getServiceType());
-            crowdTaskVO.setServiceType(testTypePO.get().getName());
+            String typeName = commonRepo.getTypeNameByCode(crowdTaskVO.getServiceType());
+            crowdTaskVO.setServiceType(typeName);
             taskVOList.add(crowdTaskVO);
         }
 
@@ -796,13 +782,15 @@ public class WebMediatorImpl implements ViewMediator {
 
         // 测试类型的转换
         List<String> testStringList = projectVO.getType().stream().map(testType -> {
-            Optional<TestTypePO> testTypePO = testTypeDao.findByCode(testType);
-            if (testTypePO.isPresent()) {
-                return testTypePO.get().getName();
-            } else {
-                throw new HttpBadRequestException("请选择测试类型");
-            }
+//            Optional<TestTypePO> testTypePO = testTypeDao.findByCode(testType);
+//            if (testTypePO.isPresent()) {
+//                return testTypePO.get().getName();
+//            } else {
+//                throw new HttpBadRequestException("请选择测试类型");
+//            }
+            return commonRepo.getTypeNameByCode(testType);
         }).collect(Collectors.toList());
+
         projectVO.setType(testStringList);
 
         projectDetailsDTO.setProjectDetails(projectVO);
@@ -895,11 +883,8 @@ public class WebMediatorImpl implements ViewMediator {
 
         CrowdTaskVO taskVO = new CrowdTaskVO(task.get());
         // 测试类型的转换
-        Optional<TestTypePO> testTypePO = testTypeDao.findByCode(taskVO.getServiceType());
-        if (!testTypePO.isPresent()) {
-            throw new HttpBadRequestException("请选择测试类型");
-        }
-        taskVO.setServiceType(testTypePO.get().getName());
+        String typeName = commonRepo.getTypeNameByCode(taskVO.getServiceType());
+        taskVO.setServiceType(typeName);
 
         System.out.println("renderTaskDetails userId：" + userId);
         if (userId == null) {

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

@@ -36,7 +36,7 @@ public interface CommonService {
 
     Page<CompetitionVO> getCompetition(Pageable pageable,String keyword);
 
-    Page<CrowdProjectVO> getProjectList(Pageable pageable,String code);
+    Page<CrowdProjectVO> getProjectList(Pageable pageable,String code,String keyword);
 
     List<ResourceVO>  getResource();
 

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

@@ -1,7 +1,9 @@
 package com.mooctest.crowd.site.service.impl;
 
 import com.mooctest.crowd.domain.dao.CrowdTestProjectDao;
+import com.mooctest.crowd.domain.dao.ResourceTypeDao;
 import com.mooctest.crowd.domain.domainobject.CrowdTestProject;
+import com.mooctest.crowd.domain.model.ResourceTypePO;
 import com.mooctest.crowd.domain.repository.*;
 import com.mooctest.crowd.site.constants.CommonConstant;
 import com.mooctest.crowd.site.data.ColumnFilter;
@@ -25,6 +27,7 @@ import org.springframework.stereotype.Service;
 
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.stream.Collectors;
 
 @Service
@@ -49,6 +52,9 @@ public class CommonServiceImpl implements CommonService {
     private CrowdTestProjectDao projectDao;
 
     @Autowired
+    private ResourceTypeDao resourceTypeDao;
+
+    @Autowired
     private CommonRepo commonRepo;
 
     @Autowired
@@ -103,7 +109,12 @@ public class CommonServiceImpl implements CommonService {
             }else if(value.equals("1")){
                 indexPageDTO.setAgencyPage(agencyRepo.findAllByPage(pageable, keyword, deletedStatus).map(agency -> new AgencyVO(agency)));
             }else if(value.equals("2")){
-                indexPageDTO.setResourcePage(commonRepo.findAllResourceByPage(pageable, keyword).map(resource -> new ResourceVO(resource)));
+                indexPageDTO.setResourcePage(commonRepo.findAllResourceByPage(pageable, keyword).map(resource -> {
+                    ResourceVO resourceVO = new ResourceVO(resource);
+                    Optional<ResourceTypePO> type = resourceTypeDao.findByCode(resourceVO.getType());
+                    resourceVO.setType(type.get().getName());
+                    return resourceVO;
+                }));
             }else if(value.equals("3")){
                 indexPageDTO.setExpertPage(commonRepo.findAllExpertByPage(pageable, keyword).map(expert -> new ExpertVO(expert)));
             }
@@ -141,8 +152,13 @@ public class CommonServiceImpl implements CommonService {
     }
 
     @Override
-    public Page<CrowdProjectVO> getProjectList(Pageable pageable, String code) {
-        return commonRepo.getProjectList(pageable,code).map(project->new CrowdProjectVO(project));
+    public Page<CrowdProjectVO> getProjectList(Pageable pageable, String code,String keyword) {
+        return commonRepo.getProjectList(pageable,code,keyword).map(project->{
+            CrowdProjectVO crowdProjectVO = new CrowdProjectVO(project);
+            String applicationName = commonRepo.getApplicationNameByCode(crowdProjectVO.getPlatform());
+            crowdProjectVO.setPlatform(applicationName);
+            return crowdProjectVO;
+        });
     }
 
     @Override

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

@@ -6,11 +6,10 @@ import com.mooctest.crowd.domain.domainobject.*;
 import com.mooctest.crowd.domain.exception.BadRequestException;
 import com.mooctest.crowd.domain.exception.BaseException;
 import com.mooctest.crowd.domain.exception.Excel2ProjectException;
-import com.mooctest.crowd.domain.exception.HttpBadRequestException;
 import com.mooctest.crowd.domain.factory.CrowdTestProjectFactory;
-import com.mooctest.crowd.domain.model.ApplicationTypePO;
 import com.mooctest.crowd.domain.model.UserTaskCountPO;
 import com.mooctest.crowd.domain.model.UserToRolePO;
+import com.mooctest.crowd.domain.repository.CommonRepo;
 import com.mooctest.crowd.domain.repository.CrowdTestProjectRepo;
 import com.mooctest.crowd.domain.repository.UserRepo;
 import com.mooctest.crowd.domain.util.Converter;
@@ -26,7 +25,6 @@ import com.mooctest.crowd.site.mediator.OperationMediator;
 import com.mooctest.crowd.site.mediator.ViewMediator;
 import com.mooctest.crowd.site.service.CrowdProjectService;
 import com.mooctest.crowd.site.service.ThemeSchedulerService;
-import com.mooctest.crowd.site.service.ThemeStatusService;
 import com.mooctest.crowd.site.util.GenerateFlowCodeUtil;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
@@ -57,13 +55,9 @@ import java.util.stream.Collectors;
 @Service
 public class CrowdProjectServiceImpl implements CrowdProjectService {
     @Autowired
-    private ThemeStatusService themeStatusService;
-    @Autowired
     private  CrowdTestProjectDao projectDao;
-    @Autowired
-    private RoleDao roleDao;
-    @Autowired
 
+    @Autowired
     private UserToRoleDao userToRoleDao;
 
     @Autowired
@@ -73,6 +67,9 @@ public class CrowdProjectServiceImpl implements CrowdProjectService {
     private CrowdTestProjectRepo projectRepo;
 
     @Autowired
+    private CommonRepo commonRepo;
+
+    @Autowired
     private UserRepo userRepo;
 
     @Autowired
@@ -115,15 +112,12 @@ public class CrowdProjectServiceImpl implements CrowdProjectService {
             CrowdTestProject crowdTestProject = new CrowdTestProject();
             BeanUtils.copyProperties(crowdTestProjectPO, crowdTestProject);
             // 应用类型值的转换
-            Optional<ApplicationTypePO> applicationTypePO = applicationTypeDao.findByCode(crowdTestProject.getApplicationType());
-            if (applicationTypePO.isPresent()) {
-                crowdTestProject.setApplicationType(applicationTypePO.get().getName());
-            } else {
-                throw new HttpBadRequestException("请选择应用类型");
-            }
+            String applicationName = commonRepo.getApplicationNameByCode(crowdTestProject.getApplicationType());
+            crowdTestProject.setApplicationType(applicationName);
             return new CrowdProjectVO(crowdTestProject);
         }).collect(Collectors.toList());
         if(keyword != null && keyword != ""){
+            System.out.println("keyword  " +  keyword);
             crowdProjectVOS = crowdProjectVOS.stream().filter(crowdProjectVO -> crowdProjectVO.getName().contains(keyword)).collect(Collectors.toList());
         }
         return crowdProjectVOS;
@@ -187,7 +181,7 @@ public class CrowdProjectServiceImpl implements CrowdProjectService {
             themeSchedulerService.createNewThemeScheduler(project);
             return projectDetailsDTO;
         }else{
-            throw new BaseException("用户权限不足无法创建项目");
+            throw new BaseException("用户权限不足无法创建项目，需要认证为发包用户或者发包机构！");
         }
     }
 

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

@@ -9,6 +9,7 @@ import com.mooctest.crowd.domain.domainobject.DistributeType;
 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.repository.CommonRepo;
 import com.mooctest.crowd.domain.repository.CrowdTestProjectRepo;
 import com.mooctest.crowd.domain.repository.CrowdTestTaskRepo;
 import com.mooctest.crowd.domain.repository.UserRepo;
@@ -59,7 +60,8 @@ public class CrowdTaskServiceImpl implements CrowdTaskService {
     @Autowired
     private EvaluationAgencyDao agencyDao;
 
-
+    @Autowired
+    private CommonRepo commonRepo;
 
 
     @Override
@@ -77,6 +79,8 @@ public class CrowdTaskServiceImpl implements CrowdTaskService {
         List<CrowdTaskVO> crowdTaskVOS = taskDao.findMoreHotTasksList().stream().map(crowdTestTaskPO -> {
             CrowdTestTask task = new CrowdTestTask();
             BeanUtils.copyProperties(crowdTestTaskPO, task);
+            String typeName = commonRepo.getTypeNameByCode(task.getType());
+            task.setType(typeName);
             return new CrowdTaskVO(task);
         }).collect(Collectors.toList());
         if(keyword != null && keyword != ""){