Merge branch 'feature-V2.0' into 'Dev'

Feature v2.0

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

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

@@ -17,7 +17,7 @@ public interface AgencyAbilityDao extends PagingAndSortingRepository<EvaluationA
 
     List<EvaluationAgencyAbilityPO> findAll();
 
-//    void deleteAll(List<EvaluationAgencyAbilityPO> evaluationAgencyAbilityPOList);
+    //    void deleteAll(List<EvaluationAgencyAbilityPO> evaluationAgencyAbilityPOList);
 
     @Override
     void deleteAll(Iterable<? extends EvaluationAgencyAbilityPO> iterable);

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

@@ -0,0 +1,18 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.ApplicationTypePO;
+import org.springframework.data.repository.CrudRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface ApplicationTypeDao extends CrudRepository<ApplicationTypePO, Long>{
+
+    Optional<ApplicationTypePO> findByCode(String code);
+
+    Optional<ApplicationTypePO> findById(Long id);
+
+    List<ApplicationTypePO> findAll();
+}

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

@@ -0,0 +1,18 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.ApplicationTypeToTestTypePO;
+import org.springframework.data.repository.CrudRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface ApplicationTypeToTestTypeDao extends CrudRepository<ApplicationTypeToTestTypePO, Long>{
+
+    Optional<ApplicationTypeToTestTypePO> findById(Long id);
+
+    List<ApplicationTypeToTestTypePO> findByApplicationTypeCode(String applicationTypeCode);
+
+    List<ApplicationTypeToTestTypePO> findAll();
+}

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

@@ -0,0 +1,20 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.BankCardPO;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+
+@Transactional
+public interface BankCardDao extends PagingAndSortingRepository<BankCardPO, Long> ,CrudRepository<BankCardPO, Long>, JpaRepository<BankCardPO, Long> ,JpaSpecificationExecutor<BankCardPO>{
+
+    Optional<BankCardPO> findById(Long id);
+
+    List<BankCardPO> findByUserIdAndIsDeleted(Long userId, int isDeleted);
+}

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

@@ -0,0 +1,13 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.BankLogoPO;
+import org.springframework.data.repository.CrudRepository;
+
+import javax.transaction.Transactional;
+import java.util.Optional;
+
+@Transactional
+public interface BankLogoDao extends CrudRepository<BankLogoPO, Long>{
+
+    Optional<BankLogoPO> findByCode(String code);
+}

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

@@ -0,0 +1,22 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.CompetitionPO;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.repository.CrudRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface CompetitionDao extends CrudRepository<CompetitionPO, Long>{
+
+    Optional<CompetitionPO> findByIdAndIsDeleted(Long id, int isNotDeleted);
+
+    List<CompetitionPO> findAll();
+
+    List<CompetitionPO> findAll(Pageable pageable);
+
+//    @Query(value = "SELECT new com.mooctest.crowd.domain.domainobject.Competition(c.id,c.name,c.linkUrl,c.startTime,c.isDeleted) FROM CompetitionPO c where c.isDeleted=0 ORDER BY c.startTime DESC")
+//    List<Competition> findTop3(Pageable pageable);
+}

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

@@ -1,11 +1,16 @@
 package com.mooctest.crowd.domain.dao;
 
-import com.mooctest.crowd.domain.domainobject.CrowdTestProject;
 import com.mooctest.crowd.domain.model.CrowdTestProjectPO;
+import com.mooctest.crowd.domain.model.RankInfos;
 import com.mooctest.crowd.domain.model.RankInfo;
+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.Query;
 import org.springframework.data.repository.CrudRepository;
+import org.springframework.data.repository.PagingAndSortingRepository;
 
 import javax.transaction.Transactional;
 import java.util.List;
@@ -16,12 +21,16 @@ import java.util.List;
  */
 
 @Transactional
-public interface CrowdTestProjectDao extends CrudRepository<CrowdTestProjectPO, Long> {
-
-//    @Override
+public interface CrowdTestProjectDao extends CrudRepository<CrowdTestProjectPO, Long>, JpaRepository<CrowdTestProjectPO,Long>, PagingAndSortingRepository<CrowdTestProjectPO,Long>, JpaSpecificationExecutor<CrowdTestProjectPO> {
+    //    @Override
 //    Optional<CrowdTestProjectPO> findById(Long id);
+
+    List<CrowdTestProjectPO> findByNameLike(String name);
+
     List<CrowdTestProjectPO> findAll();
 
+    Page<CrowdTestProjectPO> findAll(Specification<CrowdTestProjectPO> spec,Pageable pageable);
+
     CrowdTestProjectPO findByIdAndIsDeleted(Long id, int isDeleted);
 
     CrowdTestProjectPO findByCodeAndIsDeleted(String code, int isDeleted);
@@ -39,6 +48,13 @@ public interface CrowdTestProjectDao extends CrudRepository<CrowdTestProjectPO,
     @Query(value = "SELECT new com.mooctest.crowd.domain.model.RankInfo(SUM(p.quotedPrice), p.userId) FROM CrowdTestProjectPO p where p.status>1 GROUP BY p.userId ORDER BY SUM(p.quotedPrice) DESC")
     List<RankInfo> findTotalPriceOfUser(Pageable pageable);
 
+    @Query(value = "SELECT new com.mooctest.crowd.domain.model.RankInfos(COUNT(p.fieldType),0L ,p.fieldType) FROM CrowdTestProjectPO p where p.status=4 GROUP BY p.fieldType ORDER BY COUNT(p.fieldType) DESC")
+    List<RankInfos> findTotalCountOfField(Pageable pageable);
+
+
+    @Query(value = "SELECT new com.mooctest.crowd.domain.model.RankInfos(COUNT(p.platform),0L ,p.platform) FROM CrowdTestProjectPO p where p.status>1 GROUP BY p.platform ORDER BY COUNT(p.platform) DESC")
+    List<RankInfos> findTotalCountOfApplicationType(Pageable pageable);
+
     @Override
     void delete(CrowdTestProjectPO crowdTestProjectPO);
 

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

@@ -1,11 +1,13 @@
 package com.mooctest.crowd.domain.dao;
 
 import com.mooctest.crowd.domain.model.CrowdTestTaskPO;
-import com.mooctest.crowd.domain.model.RankInfo;
+import org.springframework.data.domain.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.Query;
 import org.springframework.data.repository.CrudRepository;
-
+import org.springframework.data.repository.PagingAndSortingRepository;
 import javax.transaction.Transactional;
 import java.util.List;
 
@@ -15,7 +17,11 @@ import java.util.List;
  */
 
 @Transactional
-public interface CrowdTestTaskDao extends CrudRepository<CrowdTestTaskPO, Long> {
+public interface CrowdTestTaskDao extends CrudRepository<CrowdTestTaskPO, Long>, JpaRepository<CrowdTestTaskPO, Long>, PagingAndSortingRepository<CrowdTestTaskPO, Long> {
+
+   List<CrowdTestTaskPO>  findByNameLike(String name);
+
+    Page<CrowdTestTaskPO> findAll(Specification specification, Pageable pageable);
 
     CrowdTestTaskPO findByIdAndIsDeleted(Long id, int isDeleted);
 
@@ -42,6 +48,5 @@ public interface CrowdTestTaskDao extends CrudRepository<CrowdTestTaskPO, Long>
     @Override
     <S extends CrowdTestTaskPO> S save(S s);
 
-    @Override
-    <S extends CrowdTestTaskPO> Iterable<S> saveAll(Iterable<S> iterable);
+
 }

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

@@ -0,0 +1,17 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.ExpertPO;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.repository.CrudRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface ExpertDao extends CrudRepository<ExpertPO, Long>, JpaSpecificationExecutor<ExpertPO> {
+
+    Optional<ExpertPO> findById(Long id);
+
+    List<ExpertPO> findAll();
+}

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

@@ -0,0 +1,18 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.FieldPO;
+import org.springframework.data.repository.CrudRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface FieldDao extends CrudRepository<FieldPO, Long>{
+
+    Optional<FieldPO> findByCode(String code);
+
+    Optional<FieldPO> findById(Long id);
+
+    List<FieldPO> findAll();
+}

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

@@ -0,0 +1,18 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.PartnerPO;
+import org.springframework.data.repository.CrudRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface PartnerDao extends CrudRepository<PartnerPO, Long>{
+
+    Optional<PartnerPO> findByName(String name);
+
+    Optional<PartnerPO> findById(Long id);
+
+    List<PartnerPO> findAll();
+}

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

@@ -0,0 +1,19 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.PublicationsPO;
+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.repository.CrudRepository;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import javax.transaction.Transactional;
+
+
+
+@Transactional
+public interface PublicationsDao extends PagingAndSortingRepository<PublicationsPO, Long> ,CrudRepository<PublicationsPO, Long>, JpaRepository<PublicationsPO, Long> ,JpaSpecificationExecutor<PublicationsPO>{
+
+    Page<PublicationsPO> findAll(Specification<PublicationsPO> spec, Pageable pageable);
+}

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

@@ -0,0 +1,23 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.QualificationPO;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+
+@Transactional
+public interface QualificationDao extends PagingAndSortingRepository<QualificationPO, Long> ,CrudRepository<QualificationPO, Long>, JpaRepository<QualificationPO, Long> ,JpaSpecificationExecutor<QualificationPO>{
+
+    List<QualificationPO> findByUserId(Long userId);
+
+    Optional<QualificationPO> findById(Long id);
+
+    List<QualificationPO> findByUserIdAndIsDeleted(Long userId, int isDeleted);
+
+}

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

@@ -0,0 +1,18 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.ResidentAgencyPO;
+import org.springframework.data.repository.CrudRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface ResidentAgencyDao extends CrudRepository<ResidentAgencyPO, Long>{
+
+    Optional<ResidentAgencyPO> findByAgencyId(Long agencyId);
+
+    Optional<ResidentAgencyPO> findById(Long id);
+
+    List<ResidentAgencyPO> findAll();
+}

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

@@ -0,0 +1,19 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.ResourcePO;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.repository.CrudRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface ResourceDao extends CrudRepository<ResourcePO, Long>, JpaSpecificationExecutor<ResourcePO> {
+
+    Optional<ResourcePO> findByCode(String code);
+
+    Optional<ResourcePO> findById(Long id);
+
+    List<ResourcePO> findAll();
+}

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

@@ -1,5 +1,6 @@
 package com.mooctest.crowd.domain.dao;
 
+import com.mooctest.crowd.domain.model.RankCountInfo;
 import com.mooctest.crowd.domain.model.RankInfo;
 import com.mooctest.crowd.domain.model.TaskToUserPO;
 import org.springframework.data.domain.Pageable;
@@ -26,4 +27,7 @@ public interface TaskToUserDao extends CrudRepository<TaskToUserPO,Long> {
 
     @Query(value = "SELECT new com.mooctest.crowd.domain.model.RankInfo(SUM(t.quotedPrice), t.userId) FROM TaskToUserPO t where t.userId is not null GROUP BY t.userId ORDER BY SUM(t.quotedPrice) DESC")
     List<RankInfo> findTotalPriceOfAgency(Pageable pageable);
+
+    @Query(value = "SELECT new com.mooctest.crowd.domain.model.RankCountInfo(SUM(t.isCommitted), t.userId) FROM TaskToUserPO t where t.userId is not null and t.isCommitted=1 GROUP BY t.userId ORDER BY SUM(t.isCommitted) DESC")
+    List<RankCountInfo> findTotalCountOfUser();
 }

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

@@ -0,0 +1,31 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.TechnicalArticlesPO;
+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;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.data.repository.query.Param;
+
+
+
+
+
+import javax.transaction.Transactional;
+
+
+
+@Transactional
+public interface TechnicalArticlesDao extends PagingAndSortingRepository<TechnicalArticlesPO, Long> ,CrudRepository<TechnicalArticlesPO, Long>, JpaRepository<TechnicalArticlesPO, Long> ,JpaSpecificationExecutor<TechnicalArticlesPO>{
+
+    Page<TechnicalArticlesPO> findAll(Specification<TechnicalArticlesPO> spec , Pageable pageable);
+
+    @Modifying
+    @Query(nativeQuery = true,value="update  technical_articles set TA_READING=TA_READING+1 where TA_ID=?")
+    int updateReading(@Param("id") long id);
+}

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

@@ -0,0 +1,18 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.TestTypePO;
+import org.springframework.data.repository.CrudRepository;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface TestTypeDao extends CrudRepository<TestTypePO, Long>{
+
+    Optional<TestTypePO> findByCode(String code);
+
+    Optional<TestTypePO> findById(Long id);
+
+    List<TestTypePO> findAll();
+}

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

@@ -2,13 +2,14 @@ package com.mooctest.crowd.domain.dao;
 
 import com.mooctest.crowd.domain.model.UserPO;
 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.repository.CrudRepository;
 import org.springframework.data.repository.PagingAndSortingRepository;
 
 import javax.transaction.Transactional;
 import java.util.Optional;
 
 @Transactional
-public interface UserDao extends PagingAndSortingRepository<UserPO, Long>, JpaSpecificationExecutor<UserPO> {
+public interface UserDao extends PagingAndSortingRepository<UserPO, Long>, JpaSpecificationExecutor<UserPO> ,CrudRepository<UserPO, Long> {
 
     UserPO findByMobile(String mobile);
 

core/src/main/java/com/mooctest/crowd/domain/dao/adapter/UpdateAdapter.java

@@ -0,0 +1,34 @@
+package com.mooctest.crowd.domain.dao.adapter;
+
+import com.google.common.collect.Lists;
+import org.springframework.data.repository.CrudRepository;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * @author: Diors.Po
+ * @Email: 171256175@qq.com
+ * @date 2020-01-03 21:16
+ */
+public interface UpdateAdapter<T, ID> extends CrudRepository<T, ID> {
+
+    default T findOne(ID id){
+        return findById(id).orElse(null);
+    }
+
+    @Override
+    Optional<T> findById(ID id);
+
+    default List<T> findAll(List<ID> ids){
+        return Lists.newArrayList(findAllById(ids));
+    }
+
+    default List<T> save(List<T> ts){
+        return Lists.newArrayList(saveAll(ts));
+    }
+
+    default void delete(List<T> ts){
+        deleteAll(ts);
+    }
+}

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

@@ -0,0 +1,18 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+public class ApplicationType {
+    private Long id;
+    private String code;
+    private String name;
+    private String image;
+    private List<TestType> testTypeList;
+}

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

@@ -0,0 +1,16 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+
+import javax.persistence.*;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+public class ApplicationTypeToTestType {
+    private Long id;
+    private String applicationTypeCode;
+    private String testTypeCode;
+}

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

@@ -0,0 +1,11 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+
+@Data
+public class BankLogo {
+    private Long id;
+    private  String logoUrl;
+    private String name;
+    private String code;
+}

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

@@ -0,0 +1,23 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class Competition {
+    private Long id;
+    private String name;
+    private String linkUrl;
+    private Timestamp startTime;
+    private String image;
+    private int isDeleted;
+}

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

@@ -22,10 +22,11 @@ public class CrowdTestProject {
     private Long userId;
     private Long regionalManagerId;
     private Long projectDistributionTypeId;
+    private String fieldType;
     private String platform;
+    private String type;
     private String linkMan;
     private String linkManMobile;
-    private String type;
     private String description;
     private String projectFile;
     private String requirementFile;
@@ -44,44 +45,20 @@ public class CrowdTestProject {
     private List<CrowdTestTask> crowdTestTaskList;
     private CrowdTestReport crowdTestReportForProject;
 
-    @Override
-    public String toString() {
-        return "CrowdTestProject{" +
-                "id=" + id +
-                ", name='" + name + '\'' +
-                ", code='" + code + '\'' +
-                ", userId=" + userId +
-                ", regionalManagerId=" + regionalManagerId +
-                ", projectDistributionTypeId=" + projectDistributionTypeId +
-                ", platform='" + platform + '\'' +
-                ", linkMan='" + linkMan + '\'' +
-                ", linkManMobile='" + linkManMobile + '\'' +
-                ", type='" + type + '\'' +
-                ", description='" + description + '\'' +
-                ", projectFile='" + projectFile + '\'' +
-                ", requirementFile='" + requirementFile + '\'' +
-                ", distributionProvince='" + distributionProvince + '\'' +
-                ", distributionCity='" + distributionCity + '\'' +
-                ", quotedPrice=" + quotedPrice +
-                ", fixedPrice=" + fixedPrice +
-                ", status=" + status +
-                ", deadTime=" + deadTime +
-                ", endTime=" + endTime +
-                ", isDeleted=" + isDeleted +
-                ", createTime=" + createTime +
-                ", crowdTestTaskList=" + crowdTestTaskList +
-                ", crowdTestReportForProject=" + crowdTestReportForProject +
-                '}';
-    }
+//    public CrowdTestProject wrapperCrowdTestProjectPO(CrowdTestProjectPO crowdTestProjectPO){
+//        CrowdTestProject crowdTestProject = Converter.convert(CrowdTestProject.class, crowdTestProjectPO);
+//        return 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);
     }
 
     /**
@@ -228,6 +205,7 @@ public class CrowdTestProject {
 
     /**
      * 删除项目报告（区域管理员）
+     *
      * @return
      */
 //    public CrowdTestProject removeCrowdTestProjectReport(String crowdTestProjectReportCode,User user) {
@@ -252,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());
@@ -275,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;
@@ -300,6 +277,7 @@ public class CrowdTestProject {
 
     /**
      * 创建测试项目（普通用户）
+     *
      * @return
      */
     public CrowdTestProject createCrowdTestProject(User user) {
@@ -318,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;
@@ -341,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);
             }
@@ -398,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());
@@ -432,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);
                     }
                 }
@@ -466,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();
@@ -480,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()))
@@ -493,7 +476,6 @@ public class CrowdTestProject {
     }
 
 
-
     /**
      * 创建测试报告（测评机构）
      * @param crowdTestTaskCode
@@ -573,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()));
@@ -616,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);
@@ -643,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);
@@ -683,6 +668,7 @@ public class CrowdTestProject {
 
     /**
      * 结束项目（项目发起者）
+     *
      * @return
      */
     public CrowdTestProject finishCrowdTestProject(User user) {
@@ -691,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()));
         }
@@ -705,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/domainobject/EnterpriseAuthentication.java

@@ -1,6 +1,7 @@
 package com.mooctest.crowd.domain.domainobject;
 
 import com.mooctest.crowd.domain.exception.BaseException;
+import com.mooctest.crowd.domain.model.EnterpriseAuthenticationPO;
 import lombok.Data;
 import org.springframework.beans.BeanUtils;
 
@@ -12,32 +13,30 @@ import java.sql.Timestamp;
  */
 @Data
 public class EnterpriseAuthentication {
-
     private Long id;
     private Long userId;
-    private String enterpriseName;
+    private String IDCardNum;//身份证号码
     private String legalPersonName;
     private String businessLicensePhoto;
     private String unifiedSocialCreditCode;
-    private String bankAccount;
-    private String address;
+    private String sex;//2.0新加性别
+    private String IDcardPositivePhoto;//身份证正面照
+    private String IDCardBackPhoto;//身份证反面照
     private int isDeleted;
     private int isAuthentication;
     private String explain;
     private Timestamp applyTime;
     private Timestamp checkTime;
+    private Timestamp IDCardDeadTime;//身份证过期时间
 
     @Override
     public String toString() {
         return "CompanyAuth{" +
                 "id=" + id +
                 ", userId=" + userId +
-                ", enterpriseName='" + enterpriseName + '\'' +
                 ", legalPersonName='" + legalPersonName + '\'' +
                 ", businessLicensePhoto='" + businessLicensePhoto + '\'' +
                 ", unifiedSocialCreditCode='" + unifiedSocialCreditCode + '\'' +
-                ", bankAccount='" + bankAccount + '\'' +
-                ", address='" + address + '\'' +
                 ", isDeleted=" + isDeleted +
                 ", isAuthentication=" + isAuthentication +
                 ", explain=" + explain +
@@ -46,6 +45,17 @@ public class EnterpriseAuthentication {
                 '}';
     }
 
+    public EnterpriseAuthentication getByPo(EnterpriseAuthenticationPO enterpriseAuthenticationPO) {
+        this.applyTime = enterpriseAuthenticationPO.getApplyTime();
+        this.businessLicensePhoto = enterpriseAuthenticationPO.getBusinessLicensePhoto();
+
+        this.legalPersonName = enterpriseAuthenticationPO.getLegalPersonName();
+
+         return this;
+
+    }
+
+
     public EnterpriseAuthentication applyAuthentication(Long userId) {
         this.setUserId(userId);
         this.setIsAuthentication(AuthenticationStatus.isAuthenIng);
@@ -57,28 +67,27 @@ public class EnterpriseAuthentication {
     }
 
     public EnterpriseAuthentication passAuthentication() {
-        if(this.getIsAuthentication() == AuthenticationStatus.isNotAuthenticated){
+        if (this.getIsAuthentication() == AuthenticationStatus.isNotAuthenticated) {
             throw new BaseException("当前是未通过认证状态，不可通过认证，需对认证信息进行修改后再提交认证申请");
-        }else if(this.getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+        } else if (this.getIsAuthentication() == AuthenticationStatus.isAuthenticated) {
             throw new BaseException("当前已通过认证，不可再次进行认证");
-        }else{
+        } else {
             this.setIsAuthentication(AuthenticationStatus.isAuthenticated);
             this.setCheckTime(new Timestamp(System.currentTimeMillis()));
             this.setExplain("");
             return this;
         }
-
     }
 
     public EnterpriseAuthentication rejectAuthentication(String explain) {
-        if(this.getIsDeleted() == DeletedStatus.isDeleted){
+        if (this.getIsDeleted() == DeletedStatus.isDeleted) {
             throw new BaseException("当前认证信息已被删除，不可做认证状态改变操作");
-        }else {
-            if(this.getIsAuthentication() == AuthenticationStatus.isNotAuthenticated){
+        } else {
+            if (this.getIsAuthentication() == AuthenticationStatus.isNotAuthenticated) {
                 throw new BaseException("当前已是未通过认证状态，不可再次拒绝认证");
-            }else if(this.getIsAuthentication() == AuthenticationStatus.isAuthenticated){
+            } else if (this.getIsAuthentication() == AuthenticationStatus.isAuthenticated) {
                 throw new BaseException("当前已通过认证，不可拒绝认证");
-            }else {
+            } else {
                 this.setIsAuthentication(AuthenticationStatus.isNotAuthenticated);
                 this.setExplain(explain);
                 this.setCheckTime(new Timestamp(System.currentTimeMillis()));
@@ -90,7 +99,7 @@ public class EnterpriseAuthentication {
     public EnterpriseAuthentication updateAuthInfo(EnterpriseAuthentication modifyAuth) {
         modifyAuth.userId = this.userId;
         modifyAuth.id = this.id;
-        BeanUtils.copyProperties(modifyAuth,this);
+        BeanUtils.copyProperties(modifyAuth, this);
         this.setIsAuthentication(AuthenticationStatus.isAuthenIng);
         this.setIsDeleted(DeletedStatus.isNotDeleted);
         this.setApplyTime(new Timestamp(System.currentTimeMillis()));

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

@@ -0,0 +1,16 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+public class Expert {
+    private Long id;
+    private String name;
+    private String photo;
+    private String introduction;
+
+}

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

@@ -0,0 +1,14 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+public class Field {
+    private Long id;
+    private String code;
+    private String name;
+}

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

@@ -0,0 +1,14 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+public class Partner {
+    private Long id;
+    private String name;
+    private String imageUrl;
+}

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

@@ -1,6 +1,7 @@
 package com.mooctest.crowd.domain.domainobject;
 
 import com.mooctest.crowd.domain.exception.BaseException;
+import com.mooctest.crowd.domain.model.PersonalAuthenticationPO;
 import lombok.Data;
 import org.springframework.beans.BeanUtils;
 
@@ -11,13 +12,15 @@ import java.sql.Timestamp;
  * @date 2019-08-19 15:47
  */
 @Data
-public class PersonalAuthentication {
+public class PersonalAuthentication{
 
     private Long id;
     private Long userId;
     private String realName;
     private String IDCard;
-    private String IDCardPhoto;
+    private String IDCardPostivePhoto;//身份证正面照片
+    private String IDCardBackPhoto;//身份证反面照片
+    private String sex;
     private String bankAccount;
     private String address;
     private int isDeleted;
@@ -26,23 +29,24 @@ public class PersonalAuthentication {
     private Timestamp applyTime;
     private Timestamp checkTime;
 
-    @Override
-    public String toString() {
-        return "PersonalAuth{" +
-                "id=" + id +
-                ", userId=" + userId +
-                ", realName='" + realName + '\'' +
-                ", IDCard='" + IDCard + '\'' +
-                ", IDCardPhoto='" + IDCardPhoto + '\'' +
-                ", bankAccount='" + bankAccount + '\'' +
-                ", address='" + address + '\'' +
-                ", isAuthentication='" + isAuthentication + '\'' +
-                ", explain=" + explain +
-                ", applyTime='" + applyTime + '\'' +
-                ", checkTime='" + checkTime + '\'' +
-                '}';
+    /**
+     * 转换类型
+     * @param authenticationPO
+     * @return
+     */
+
+    public  PersonalAuthentication  getByPo(PersonalAuthenticationPO authenticationPO){
+          this.realName=authenticationPO.getRealName();
+          this.address=authenticationPO.getAddress();
+          this.applyTime=authenticationPO.getApplyTime();
+          this.IDCard=authenticationPO.getIDCard();
+          this.IDCardBackPhoto=authenticationPO.getIDCardPhoto();
+          return this;
+
     }
 
+
+
     public PersonalAuthentication applyAuthentication(Long userId) {
         this.setUserId(userId);
         this.setIsAuthentication(AuthenticationStatus.isAuthenIng);

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

@@ -0,0 +1,18 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+
+import java.sql.Timestamp;
+
+@Data
+public class Publications {
+    private Long id;
+    private String title;
+    private String publicTime;
+    private String  conferenceJournal;
+    private String authorList;
+    private String longTitle;
+    private String author;
+    private Timestamp uploadedDate;
+    private String chineseBrief;
+}

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

@@ -0,0 +1,14 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+public class ResidentAgency {
+    private Long id;
+    private Long agencyId;
+    private Long userId;
+}

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

@@ -0,0 +1,14 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+public class Resource {
+    private Long id;
+    private String code;
+    private String name;
+}

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

@@ -0,0 +1,17 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+
+import java.sql.Timestamp;
+
+@Data
+public class TechnicalArticles {
+    private Long id;
+    private String name;
+    private String photoUrl;
+    private String  articlesUrl;
+    private String author;
+    private String source;
+    private int reading;
+    private Timestamp publicTime;
+}

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

@@ -0,0 +1,14 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+public class TestType {
+    private Long id;
+    private String code;
+    private String name;
+}

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

@@ -0,0 +1,8 @@
+package com.mooctest.crowd.domain.exception;
+
+/**
+ * @author guochao
+ * @date 2019/7/16 9:23
+ */
+public class ApplicationTypeNoExistException extends BaseException {
+}

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

@@ -0,0 +1,8 @@
+package com.mooctest.crowd.domain.exception;
+
+/**
+ * @author guochao
+ * @date 2019/7/16 9:23
+ */
+public class ApplicationTypeToTestTypeNoExistException extends BaseException {
+}

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

@@ -0,0 +1,8 @@
+package com.mooctest.crowd.domain.exception;
+
+/**
+ * @author guochao
+ * @date 2019/7/16 9:23
+ */
+public class FieldNoExistException extends BaseException {
+}

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

@@ -0,0 +1,8 @@
+package com.mooctest.crowd.domain.exception;
+
+/**
+ * @author guochao
+ * @date 2019/7/16 9:23
+ */
+public class ResourceNoExistException extends BaseException {
+}

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

@@ -0,0 +1,8 @@
+package com.mooctest.crowd.domain.exception;
+
+/**
+ * @author guochao
+ * @date 2019/7/16 9:23
+ */
+public class TestTypeNoExistException extends BaseException {
+}

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

@@ -0,0 +1,27 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+@Entity(name = "application_type")
+public class ApplicationTypePO {
+    @Id
+    @Column(name = "AT_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "AT_CODE")
+    private String code;
+
+    @Column(name = "AT_NAME")
+    private String name;
+
+    @Column(name = "AT_IMAGE")
+    private String image;
+}

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

@@ -0,0 +1,24 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+@Entity(name = "application_type_to_test_type")
+public class ApplicationTypeToTestTypePO {
+    @Id
+    @Column(name = "ATTTT_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "ATTTT_AT_CODE")
+    private String applicationTypeCode;
+
+    @Column(name = "ATTTT_TT_CODE")
+    private String testTypeCode;
+}

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

@@ -0,0 +1,35 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+
+
+@Data
+@Entity
+@Table(name = "bank_card")
+public class BankCardPO {
+
+    @Id
+    @Column(name = "BC_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "BC_NAME")
+    private String name;
+
+    @Column(name="BC_USER")
+    private String user;
+
+    @Column(name="BC_NUMBER")
+    private  String number;
+
+    @Column(name = "BC_BL_CODE")
+    private  String code;
+
+    @Column(name="BC_U_ID")
+    private Long userId;
+
+    @Column(name = "BC_DELETED")
+    private int isDeleted;
+}

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

@@ -0,0 +1,26 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+
+
+@Data
+@Entity
+@Table(name = "bank_logo")
+public class BankLogoPO {
+
+    @Id
+    @Column(name = "BL_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "BL_NAME")
+    private String name;
+
+    @Column(name="BL_LOGO_URL")
+    private  String logoUrl;
+
+    @Column(name="BL_CODE")
+    private String code;
+}

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

@@ -0,0 +1,34 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+@Entity(name = "competition")
+public class CompetitionPO {
+    @Id
+    @Column(name = "C_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "C_NAME")
+    private String name;
+
+    @Column(name = "C_LINK_URL")
+    private String linkUrl;
+
+    @Column(name = "C_START_TIME")
+    private Timestamp startTime;
+
+    @Column(name = "C_IMAGE")
+    private String image;
+
+    @Column(name = "C_IS_DELETED")
+    private int isDeleted;
+}

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

@@ -35,18 +35,21 @@ public class CrowdTestProjectPO implements Serializable {
     @Column(name = "CTP_PDT_ID")
     private Long projectDistributionTypeId;
 
+    @Column(name = "CTP_FIELD_TYPE")
+    private String fieldType;
+
     @Column(name = "CTP_PLATFORM")
     private String platform;
 
+    @Column(name = "CTP_TYPE")
+    private String type;
+
     @Column(name = "CTP_LINK_MAN")
     private String linkMan;
 
     @Column(name = "CTP_Link_MAN_MOBILE")
     private String linkManMobile;
 
-    @Column(name = "CTP_TYPE")
-    private String type;
-
     @Column(name = "CTP_DESCRIPTION")
     private String description;
 
@@ -89,32 +92,4 @@ public class CrowdTestProjectPO implements Serializable {
 
     @Column(name = "CTP_CREATE_TIME")
     private Timestamp createTime;
-
-    @Override
-    public String toString() {
-        return "CrowdTestProjectPO{" +
-                "id=" + id +
-                ", code='" + code + '\'' +
-                ", name='" + name + '\'' +
-                ", userId=" + userId +
-                ", regionalManagerId=" + regionalManagerId +
-                ", projectDistributionTypeId=" + projectDistributionTypeId +
-                ", description='" + description + '\'' +
-                ", platform=" + platform +
-                ", linkMan='" + linkMan + '\'' +
-                ", linkManMobile='" + linkManMobile + '\'' +
-                ", type=" + type +
-                ", distributionProvince='" + distributionProvince + '\'' +
-                ", distributionCity='" + distributionCity + '\'' +
-                ", projectFile='" + projectFile + '\'' +
-                ", requirementFile='" + requirementFile + '\'' +
-                ", quotedPrice=" + quotedPrice +
-                ", fixedPrice=" + fixedPrice +
-                ", status=" + status +
-                ", deadTime=" + deadTime +
-                ", endTime=" + endTime +
-                ", isDeleted=" + isDeleted +
-                ", createTime=" + createTime +
-                '}';
-    }
 }

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

@@ -54,4 +54,6 @@ public class EnterpriseAuthenticationPO {
 
     @Column(name = "EA_APPLY_TIME")
     private Timestamp applyTime;
+
+
 }

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

@@ -0,0 +1,28 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+@Entity(name = "expert")
+public class ExpertPO {
+    @Id
+    @Column(name = "E_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "E_NAME")
+    private String name;
+
+    @Column(name = "E_PHOTO")
+    private String photo;
+
+    @Column(name = "E_INTRODUCTION")
+    private String introduction;
+    
+}

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

@@ -0,0 +1,24 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+@Entity(name = "field")
+public class FieldPO {
+    @Id
+    @Column(name = "F_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "F_CODE")
+    private String code;
+
+    @Column(name = "F_NAME")
+    private String name;
+}

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

@@ -0,0 +1,24 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+@Entity(name = "partner")
+public class PartnerPO {
+    @Id
+    @Column(name = "P_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "P_NAME")
+    private String name;
+
+    @Column(name = "P_IMAGE")
+    private String imageUrl;
+}

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

@@ -51,4 +51,5 @@ public class PersonalAuthenticationPO {
 
     @Column(name = "PA_CHECK_TIME")
     private Timestamp checkTime;
+
 }

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

@@ -0,0 +1,42 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.sql.Timestamp;
+
+
+@Data
+@Entity
+@Table(name = "publications")
+public class PublicationsPO {
+
+    @Id
+    @Column(name = "P_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "P_TITLE")
+    private String title;
+
+    @Column(name = "P_YEAR")
+    private String publicTime;
+
+    @Column(name = "P_CONFERENCE_JOURNAL")
+    private String  conferenceJournal;
+
+    @Column(name = "P_AUTHOR_LIST")
+    private String authorList;
+
+    @Column(name = "P_SEC_LANG_TITLE")
+    private String longTitle;
+
+    @Column(name = "P_CH_AUTHORS")
+    private String author;
+
+    @Column(name = "P_UPLOADED_DATE")
+    private Timestamp uploadedDate;
+
+    @Column(name="P_CHINESE_BRIEF")
+    private  String chineseBrief;
+}

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

@@ -0,0 +1,40 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.sql.Date;
+import java.sql.Timestamp;
+
+
+@Data
+@Entity
+@Table(name = "qualification")
+public class QualificationPO {
+
+    @Id
+    @Column(name = "Q_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "Q_NAME")
+    private String name;
+
+    @Column(name = "Q_NUMBER")
+    private String  number;
+
+    @Column(name = "Q_LICENSING_AUTHORITY")
+    private String  LicensingAuthority;
+
+    @Column(name="Q_TIME")
+    private Date time;
+
+    @Column(name="Q_U_ID")
+    private Long userId;
+
+    @Column(name = "Q_DELETED")
+    private int isDeleted;
+
+    @Column(name="Q_PUBLIC")
+    private int isPublic;
+}

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

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

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

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

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

@@ -0,0 +1,24 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+@Entity(name = "resident_agency")
+public class ResidentAgencyPO {
+    @Id
+    @Column(name = "RA_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "RA_EA_ID")
+    private Long agencyId;
+
+    @Column(name = "RA_EA_U_ID")
+    private Long userId;
+}

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

@@ -0,0 +1,24 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+@Entity(name = "resource")
+public class ResourcePO {
+    @Id
+    @Column(name = "R_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "R_CODE")
+    private String code;
+
+    @Column(name = "R_NAME")
+    private String name;
+}

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

@@ -0,0 +1,40 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.sql.Timestamp;
+
+
+@Data
+@Entity
+@Table(name = "technical_articles")
+public class TechnicalArticlesPO {
+
+    @Id
+    @Column(name = "TA_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "TA_TITLE")
+    private String name;
+
+    @Column(name = "TA_PHOTO_URL")
+    private String photoUrl;
+
+    @Column(name = "TA_ARTICLES_URL")
+    private String  articlesUrl;
+
+    @Column(name = "TA_AUTHOR")
+    private String author;
+
+    @Column(name = "TA_SOURCE")
+    private String source;
+
+    @Column(name = "TA_READING")
+    private int reading;
+
+    @Column(name = "TA_CREATE_TIME")
+    private Timestamp publicTime;
+
+}

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

@@ -0,0 +1,24 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+@Entity(name = "test_type")
+public class TestTypePO {
+    @Id
+    @Column(name = "TT_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "TT_CODE")
+    private String code;
+
+    @Column(name = "TT_NAME")
+    private String name;
+}

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

@@ -3,6 +3,7 @@ package com.mooctest.crowd.domain.model;
 import lombok.Data;
 
 import javax.persistence.*;
+import java.sql.Date;
 import java.sql.Timestamp;
 
 /**
@@ -55,4 +56,19 @@ public class UserPO {
     @Column(name = "U_CREATE_TIME")
     private Timestamp createTime;
 
+    @Column(name="U_BIRTHDAY")
+    private Date birthday;
+
+    @Column(name="U_DETAILED_ADDRESS")
+    private String  detailedAddress;
+
+    @Column(name="U_PERSONAL_COMPETENCE")
+    private String personalCompetence;
+
+    @Column(name="U_UNIT")
+    private String unit;
+
+    @Column(name="U_COUNTY")
+    private String county;
+
 }

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

@@ -0,0 +1,175 @@
+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.FieldNoExistException;
+import com.mooctest.crowd.domain.exception.TestTypeNoExistException;
+import com.mooctest.crowd.domain.model.*;
+import com.mooctest.crowd.domain.util.Converter;
+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;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * @author guochao
+ * @date 2020-06-22 17:23
+ */
+@Component
+public class CommonRepo {
+    @Autowired
+    private TestTypeDao testTypeDao;
+
+    @Autowired
+    private ApplicationTypeDao applicationTypeDao;
+
+    @Autowired
+    private ApplicationTypeToTestTypeDao applicationTypeToTestTypeDao;
+
+    @Autowired
+    private FieldDao fieldDao;
+
+    @Autowired
+    private ResourceDao resourceDao;
+
+    @Autowired
+    private CompetitionDao competitionDao;
+
+    @Autowired
+    private ResidentAgencyDao residentAgencyDao;
+
+    @Autowired
+    private PartnerDao partnerDao;
+
+    @Autowired
+    private ExpertDao expertDao;
+
+    public List<TestType> getAllTestType(){
+        return testTypeDao.findAll().stream().map(testTypePO -> Converter.convert(TestType.class, testTypePO)).collect(Collectors.toList());
+    }
+
+    public List<ApplicationType> getAllApplicationType(){
+        return applicationTypeDao.findAll().stream().map(applicationTypePO -> Converter.convert(ApplicationType.class, applicationTypePO)).collect(Collectors.toList());
+    }
+
+    public List<Field> getAllFieldType(){
+        return fieldDao.findAll().stream().map(fieldPO -> Converter.convert(Field.class, fieldPO)).collect(Collectors.toList());
+    }
+
+    public List<Resource> getAllResource(){
+        return resourceDao.findAll().stream().map(resourcePO -> Converter.convert(Resource.class, resourcePO)).collect(Collectors.toList());
+    }
+
+    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 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(){
+        return partnerDao.findAll().stream().map(partnerPO -> Converter.convert(Partner.class, partnerPO)).collect(Collectors.toList());
+    }
+
+    public List<ResidentAgency> getAllResidentAgency(){
+        return residentAgencyDao.findAll().stream().map(residentAgencyPO -> Converter.convert(ResidentAgency.class, residentAgencyPO)).collect(Collectors.toList());
+    }
+
+    public ApplicationType getApplicationTypeByAppCode(String appCode){
+        Optional<ApplicationTypePO> applicationTypePO = applicationTypeDao.findByCode(appCode);
+        if(!applicationTypePO.isPresent()){
+            throw new ApplicationTypeNoExistException();
+        }else {
+            return Converter.convert(ApplicationType.class, applicationTypePO.get());
+        }
+
+    }
+
+    public TestType getTestTypeByAppCode(String typeCode){
+        Optional<TestTypePO> testTypePO = testTypeDao.findByCode(typeCode);
+        if(!testTypePO.isPresent()){
+            throw new TestTypeNoExistException();
+        }else {
+            return Converter.convert(TestType.class, testTypePO.get());
+        }
+    }
+
+    public Field getFieldByFieldCode(String code){
+        Optional<FieldPO> fieldPO = fieldDao.findByCode(code);
+        if(!fieldPO.isPresent()){
+            throw new FieldNoExistException();
+        }else {
+            return Converter.convert(Field.class, fieldPO.get());
+        }
+    }
+
+    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){
+        List<ApplicationTypeToTestType> appToTypeList = getAppToTypeByAppCode(appTypeCode);
+        List<TestType> testTypeList = appToTypeList.stream().map(applicationTypeToTestType -> {
+            TestType testTypeByAppCode = getTestTypeByAppCode(applicationTypeToTestType.getTestTypeCode());
+            return testTypeByAppCode;
+        }).collect(Collectors.toList());
+        return testTypeList;
+    }
+
+    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));
+    }
+
+    private Specification<ResourcePO> getResource(String keyword) {
+        return new Specification<ResourcePO>() {
+            @Override
+            public Predicate toPredicate(Root<ResourcePO> a, CriteriaQuery<?> q, CriteriaBuilder cb) {
+                Predicate predicate = cb.conjunction();
+                if(keyword != null) {
+                    predicate.getExpressions().add(
+                            cb.like(a.<String>get("name"), "%" + StringUtils.trim(keyword) + "%")
+                    );
+                }
+                return predicate;
+            }
+        };
+    }
+
+    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));
+    }
+
+    private Specification<ExpertPO> getExpert(String keyword) {
+        return new Specification<ExpertPO>() {
+            @Override
+            public Predicate toPredicate(Root<ExpertPO> a, CriteriaQuery<?> q, CriteriaBuilder cb) {
+                Predicate predicate = cb.conjunction();
+                if(keyword != null) {
+                    predicate.getExpressions().add(
+                            cb.like(a.<String>get("name"), "%" + StringUtils.trim(keyword) + "%")
+                    );
+                }
+                return predicate;
+            }
+        };
+    }
+}

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

@@ -7,9 +7,18 @@ import com.mooctest.crowd.domain.exception.HttpBadRequestException;
 import com.mooctest.crowd.domain.model.*;
 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;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
@@ -39,17 +48,50 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
     private UserDao userDao;
 
     @Override
-    public List<CrowdTestProjectPO> findAll(){
+    public Page<CrowdTestProjectPO> findAll(Specification specification, Pageable pageable) {
+        return crowdTestProjectDao.findAll(specification, pageable);
+    }
+
+    @Override
+    public List<CrowdTestProjectPO> findAll() {
         return crowdTestProjectDao.findAll();
     }
 
     @Override
+    public List<CrowdTestProjectPO> findByNameLike(String name) {
+        return     crowdTestProjectDao.findByNameLike("%" + name + "%");
+    }
+
+    @Override
+    public Page<CrowdTestProject> findAllByPage(Pageable pageable, String keyword, int deletedStatus) {
+        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
+            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;
+            }
+        };
+    }
+
+    @Override
     public CrowdTestProject getByID(Long crowdTestProjectId) throws CrowdTestProjectNotExistException {
 
         CrowdTestProjectPO crowdTestProjectPO = crowdTestProjectDao.findByIdAndIsDeleted(crowdTestProjectId, DeletedStatus.isNotDeleted);
         if (crowdTestProjectPO == null) {
             throw new CrowdTestProjectNotExistException();
-        }else{
+        } else {
             CrowdTestProject crowdTestProjectResult = getCrowdTestProjectAndTaskAndReportByCrowdTestProjectPO(crowdTestProjectPO);
             return crowdTestProjectResult;
         }
@@ -60,7 +102,7 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
         CrowdTestProjectPO crowdTestProjectPO = crowdTestProjectDao.findByCodeAndIsDeleted(crowdTestProjectCode, DeletedStatus.isNotDeleted);
         if (crowdTestProjectPO == null) {
             throw new CrowdTestProjectNotExistException();
-        }else{
+        } else {
             CrowdTestProject crowdTestProjectResult = getCrowdTestProjectAndTaskAndReportByCrowdTestProjectPO(crowdTestProjectPO);
             return crowdTestProjectResult;
         }
@@ -74,13 +116,13 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
 
     @Override
     public List<CrowdTestProject> getCrowdListByRegionalManagerId(Long regionalManagerId) {
-        List<CrowdTestProjectPO> crowdTestProjectPOList = crowdTestProjectDao.findByRegionalManagerIdAndIsDeleted(regionalManagerId,DeletedStatus.isNotDeleted);
+        List<CrowdTestProjectPO> crowdTestProjectPOList = crowdTestProjectDao.findByRegionalManagerIdAndIsDeleted(regionalManagerId, DeletedStatus.isNotDeleted);
         return getCrowdTestProjects(crowdTestProjectPOList);
     }
 
 
     @Override
-    public List<CrowdTestProject> getAllCrowdTestProject(){
+    public List<CrowdTestProject> getAllCrowdTestProject() {
         List<CrowdTestProjectPO> crowdTestProjectPOList = crowdTestProjectDao.findAllByIsDeleted(DeletedStatus.isNotDeleted);
         return getCrowdTestProjects(crowdTestProjectPOList);
     }
@@ -91,15 +133,15 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
         crowdTestProjectDao.save(crowdTestProjectPO);
 
         List<CrowdTestTask> crowdTestTaskList = crowdTestProject.getCrowdTestTaskList();
-        if(crowdTestTaskList != null){
-            for(CrowdTestTask crowdTestTask : crowdTestTaskList){
+        if (crowdTestTaskList != null) {
+            for (CrowdTestTask crowdTestTask : crowdTestTaskList) {
                 CrowdTestTaskPO crowdTestTaskPO = Converter.convert(CrowdTestTaskPO.class, crowdTestTask);
                 List<TaskToUser> acceptedUserList = crowdTestTask.getAcceptedUserList();
-                for(TaskToUser taskToUser : acceptedUserList){
+                for (TaskToUser taskToUser : acceptedUserList) {
                     taskToUserDao.save(Converter.convert(TaskToUserPO.class, taskToUser));
                     // 保存报告信息
                     List<CrowdTestReport> crowdTestReportList = taskToUser.getCrowdTestReportList();
-                    for(CrowdTestReport crowdTestReport : crowdTestReportList){
+                    for (CrowdTestReport crowdTestReport : crowdTestReportList) {
                         CrowdTestReportPO crowdTestReportPO = Converter.convert(CrowdTestReportPO.class, crowdTestReport);
                         crowdTestReportDao.save(crowdTestReportPO);
                     }
@@ -111,7 +153,7 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
             }
         }
         // 保存项目报告
-        if (crowdTestProject.getCrowdTestReportForProject() != null){
+        if (crowdTestProject.getCrowdTestReportForProject() != null) {
             CrowdTestReport reportForProject = crowdTestProject.getCrowdTestReportForProject();
             CrowdTestReportPO crowdTestReportPO = Converter.convert(CrowdTestReportPO.class, reportForProject);
             crowdTestReportDao.save(crowdTestReportPO);
@@ -126,7 +168,7 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
 
     public void removeCrowdTestProjectList(List<CrowdTestProject> crowdTestProjectList) {
         List<CrowdTestProjectPO> crowdTestProjectPOList = new ArrayList<>();
-        for(CrowdTestProject crowdTestProject : crowdTestProjectList){
+        for (CrowdTestProject crowdTestProject : crowdTestProjectList) {
             CrowdTestProjectPO crowdTestProjectPO = Converter.convert(CrowdTestProjectPO.class, crowdTestProject);
             crowdTestProjectPOList.add(crowdTestProjectPO);
         }
@@ -177,10 +219,11 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
 
     /**
      * 根据projectId删除Project
+     *
      * @param projectId
      * @return boolean
      */
-    public void deleteByProjectId(Long projectId){
+    public void deleteByProjectId(Long projectId) {
         Optional<CrowdTestProjectPO> project = crowdTestProjectDao.findById(projectId);
         if (!project.isPresent())
             throw new CrowdTestProjectNotExistException();
@@ -189,6 +232,7 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
 
     /**
      * 通过项目信息获取项目-任务-报告信息
+     *
      * @param crowdTestProjectPO
      * @return
      */
@@ -197,7 +241,7 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
         List<CrowdTestTaskPO> crowdTestTaskPOList = crowdTestTaskDao.findByCrowdTestProjectCodeAndIsDeleted(crowdTestProjectPO.getCode(), DeletedStatus.isNotDeleted);
 
         List<CrowdTestTask> crowdTestTaskListResult = new ArrayList<>();
-        for(CrowdTestTaskPO crowdTestTaskPO : crowdTestTaskPOList){
+        for (CrowdTestTaskPO crowdTestTaskPO : crowdTestTaskPOList) {
             CrowdTestTask crowdTestTaskResult = Converter.convert(CrowdTestTask.class, crowdTestTaskPO);
             // 检索任务中的所有已接收任务的人员信息
             List<TaskToUserPO> taskToUserPOList = taskToUserDao.findByTaskCode(crowdTestTaskResult.getCode());
@@ -205,9 +249,9 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
                 TaskToUser taskToUser = Converter.convert(TaskToUser.class, taskToUserPO);
                 // 获取人员详细信息
                 Optional<UserPO> userPOOptional = userDao.findById(taskToUser.getUserId());
-                if(userPOOptional.isPresent()){
+                if (userPOOptional.isPresent()) {
                     taskToUser.setUser(Converter.convert(User.class, userPOOptional.get()));
-                }else{
+                } else {
                     throw new HttpBadRequestException("无此人员的信息");
                 }
                 // 获取每个人员的报告信息
@@ -226,7 +270,7 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
 
         //检索出项目报告
         List<CrowdTestReportPO> crowdTestProjectReportPOList = crowdTestReportDao.findByDependencyCodeAndIsDeleted(crowdTestProjectResult.getCode(), DeletedStatus.isNotDeleted);
-        if(crowdTestProjectReportPOList.size() != 0){
+        if (crowdTestProjectReportPOList.size() != 0) {
             CrowdTestReportPO crowdTestProjectReportPO = crowdTestProjectReportPOList.get(0);
             CrowdTestReport crowdTestProjectReport = Converter.convert(CrowdTestReport.class, crowdTestProjectReportPO);
             crowdTestProjectResult.setCrowdTestReportForProject(crowdTestProjectReport);
@@ -236,6 +280,7 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
 
     /**
      * 通过任务code和人员id获取报告列表
+     *
      * @param taskCode
      * @param userId
      * @return
@@ -247,13 +292,14 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
 
     /**
      * 通过任务信息获取报告信息
+     *
      * @param crowdTestTaskCode
      * @return
      */
     public List<CrowdTestReport> getCrowdTestReportByCrowdTestTask(String crowdTestTaskCode) {
         List<CrowdTestReportPO> crowdTestReportPOList = crowdTestReportDao.findByDependencyCodeAndIsDeleted(crowdTestTaskCode, DeletedStatus.isNotDeleted);
         List<CrowdTestReport> crowdTestReportListResult = new ArrayList<>();
-        for(CrowdTestReportPO crowdTestReportPO : crowdTestReportPOList){
+        for (CrowdTestReportPO crowdTestReportPO : crowdTestReportPOList) {
             CrowdTestReport crowdTestReportResult = Converter.convert(CrowdTestReport.class, crowdTestReportPO);
             crowdTestReportListResult.add(crowdTestReportResult);
         }
@@ -262,6 +308,7 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
 
     /**
      * 根据项目列表获取项目-任务-报告信息
+     *
      * @param crowdTestProjectPOList
      * @return
      */
@@ -274,15 +321,15 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
         return crowdTestProjectListResult;
     }
 
-    public long getAllProjectNum(){
+    public long getAllProjectNum() {
         return crowdTestProjectDao.count();
     }
 
-    public long getAllTaskNum(){
+    public long getAllTaskNum() {
         return crowdTestTaskDao.count();
     }
 
-    public long getAllReportNum(){
+    public long getAllReportNum() {
         return crowdTestReportDao.count();
     }
 }

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

@@ -9,9 +9,19 @@ import com.mooctest.crowd.domain.model.EvaluationAgencyAbilityPO;
 import com.mooctest.crowd.domain.model.EvaluationAgencyPO;
 import com.mooctest.crowd.domain.model.EvaluationAgencyResourcePO;
 import com.mooctest.crowd.domain.util.Converter;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+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;
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;
@@ -31,6 +41,9 @@ public class EvaluationAgencyRepo implements IEvaluationAgencyRepo {
     @Autowired
     private EvaluationAgencyDao evaluationAgencyDao;
 
+    @Value("${agency}")
+    private String agencyId;
+
     @Override
     public EvaluationAgency findAgencyById(Long id){
         Optional<EvaluationAgencyPO> evaluationAgencyPO = evaluationAgencyDao.findById(id);
@@ -104,4 +117,29 @@ public class EvaluationAgencyRepo implements IEvaluationAgencyRepo {
         agencyAbilityDao.deleteAll(evaluationAgencyAbilityPOList);
     }
 
+    @Override
+    public Page<EvaluationAgency> findAllByPage(Pageable pageable, String keyword, int deletedStatus){
+        Specifications<EvaluationAgencyPO> where =  Specifications.where(getAgencyByIsNotDeleted(keyword, deletedStatus));
+        return evaluationAgencyDao.findAll(where, pageable).map(evaluationAgencyPO -> Converter.convert(EvaluationAgency.class, evaluationAgencyPO));
+    }
+
+    private Specification<EvaluationAgencyPO> getAgencyByIsNotDeleted(String keyword, int deletedStatus) {
+        return new Specification<EvaluationAgencyPO>() {
+            @Override
+            public Predicate toPredicate(Root<EvaluationAgencyPO> a, CriteriaQuery<?> q, CriteriaBuilder cb) {
+                Predicate predicate = cb.conjunction();
+                if(keyword != null) {
+                    predicate.getExpressions().add(
+                            cb.like(a.<String>get("evaluationAgencyName"), "%" + StringUtils.trim(keyword) + "%")
+                    );
+                }
+                EvaluationAgency agencyById = findAgencyById(Long.parseLong(agencyId));
+                predicate.getExpressions().add(cb.notEqual(a.get("evaluationAgencyName"), agencyById.getEvaluationAgencyName()));
+                predicate.getExpressions().add(cb.equal(a.get("isDeleted"), deletedStatus));
+                predicate.getExpressions().add(cb.equal(a.get("isAuthentication"), AuthenticationStatus.isAuthenticated));
+                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

@@ -1,8 +1,10 @@
 package com.mooctest.crowd.domain.repository;
-
 import com.mooctest.crowd.domain.domainobject.CrowdTestProject;
 import com.mooctest.crowd.domain.exception.CrowdTestProjectNotExistException;
 import com.mooctest.crowd.domain.model.CrowdTestProjectPO;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
 
 import java.util.List;
 
@@ -11,7 +13,13 @@ import java.util.List;
  * @date 2019/7/6 19:10
  */
 public interface ICrowdTestProjectRepo {
-      List<CrowdTestProjectPO> findAll();
+    List<CrowdTestProjectPO> findByNameLike(String name);
+
+
+    Page<CrowdTestProject> findAllByPage(Pageable pageable, String keyword, int deletedStatus);
+    Page<CrowdTestProjectPO> findAll(Specification specification,Pageable pageable);
+
+    List<CrowdTestProjectPO> findAll();
 
     CrowdTestProject getByID(Long id) throws CrowdTestProjectNotExistException;
 

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

@@ -3,6 +3,8 @@ package com.mooctest.crowd.domain.repository;
 import com.mooctest.crowd.domain.domainobject.EvaluationAgency;
 import com.mooctest.crowd.domain.domainobject.EvaluationAgencyAbility;
 import com.mooctest.crowd.domain.domainobject.EvaluationAgencyResource;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 
 import java.util.List;
 
@@ -27,4 +29,6 @@ public interface IEvaluationAgencyRepo {
     List<EvaluationAgencyAbility> findEvaluationAgencyAbility(Long evaluationAgencyId);
 
     void moveEvaluationAgencyAbility(List<EvaluationAgencyAbility> evaluationAgencyAbilityList);
+
+    Page<EvaluationAgency> findAllByPage(Pageable pageable, String keyword, int deletedStatus);
 }

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

@@ -0,0 +1,12 @@
+package com.mooctest.crowd.domain.repository;
+
+import com.mooctest.crowd.domain.domainobject.Publications;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+
+public interface IPublicationsRepo {
+
+    Page<Publications> getPublications(Pageable pageable, String keyword);
+
+}

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

@@ -0,0 +1,15 @@
+package com.mooctest.crowd.domain.repository;
+
+import com.mooctest.crowd.domain.domainobject.TechnicalArticles;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+
+
+public interface ITechnicalArticlesRepo {
+
+    Page<TechnicalArticles> getTechnicalArticles(Pageable pageable, String keyword);
+
+    Page<TechnicalArticles> articlesRanking(Pageable pageable);
+
+}

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

@@ -0,0 +1,49 @@
+package com.mooctest.crowd.domain.repository;
+
+import com.mooctest.crowd.domain.dao.PublicationsDao;
+import com.mooctest.crowd.domain.domainobject.Publications;
+import com.mooctest.crowd.domain.model.PublicationsPO;
+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;
+
+@Slf4j
+@Component
+public class PublicationsRepo implements IPublicationsRepo{
+
+
+    @Autowired
+    private PublicationsDao publicationsDao;
+
+    @Override
+    public Page<Publications> getPublications(Pageable pageable, String keyword) {
+        Specifications<PublicationsPO> where =  Specifications.where(getPublicationsByIsNotDeleted(keyword));
+        return publicationsDao.findAll(where, pageable).map(PublicationsPO->Converter.convert(Publications.class, PublicationsPO));
+    }
+
+    private Specification<PublicationsPO> getPublicationsByIsNotDeleted(String keyword) {
+        return new Specification<PublicationsPO>() {
+            @Override
+            public Predicate toPredicate(Root<PublicationsPO> a, CriteriaQuery<?> q, CriteriaBuilder cb) {
+                Predicate predicate = cb.conjunction();
+                if(keyword != null) {
+                    predicate.getExpressions().add(
+                            cb.like(a.<String>get("longTitle"), "%" + StringUtils.trim(keyword) + "%")
+                    );
+                }
+                return predicate;
+            }
+        };
+    }
+}

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

@@ -0,0 +1,54 @@
+package com.mooctest.crowd.domain.repository;
+
+import com.mooctest.crowd.domain.dao.TechnicalArticlesDao;
+import com.mooctest.crowd.domain.domainobject.TechnicalArticles;
+import com.mooctest.crowd.domain.model.TechnicalArticlesPO;
+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;
+
+@Slf4j
+@Component
+public class TechnicalArticlesRepo implements ITechnicalArticlesRepo{
+
+
+    @Autowired
+    private TechnicalArticlesDao technicalarticlesDao;
+
+    @Override
+    public Page<TechnicalArticles> getTechnicalArticles(Pageable pageable, String keyword) {
+        Specifications<TechnicalArticlesPO> where =  Specifications.where(getArticlesByIsNotDeleted(keyword));
+        return  technicalarticlesDao.findAll(where, pageable).map(TechnicalArticlesPO -> Converter.convert(TechnicalArticles.class, TechnicalArticlesPO));
+    }
+
+    @Override
+    public Page<TechnicalArticles> articlesRanking(Pageable pageable) {
+        return  technicalarticlesDao.findAll(pageable).map(TechnicalArticlesPO -> Converter.convert(TechnicalArticles.class, TechnicalArticlesPO));
+    }
+
+    private Specification<TechnicalArticlesPO> getArticlesByIsNotDeleted(String keyword) {
+        return new Specification<TechnicalArticlesPO>() {
+            @Override
+            public Predicate toPredicate(Root<TechnicalArticlesPO> a, CriteriaQuery<?> q, CriteriaBuilder cb) {
+                Predicate predicate = cb.conjunction();
+                if(keyword != null) {
+                    predicate.getExpressions().add(
+                            cb.like(a.<String>get("name"), "%" + StringUtils.trim(keyword) + "%")
+                    );
+                }
+                return predicate;
+            }
+        };
+    }
+}

site/pom.xml

@@ -110,6 +110,28 @@
 			<artifactId>easypoi-annotation</artifactId>
 			<version>3.0.3</version>
 		</dependency>
+		<!-- Shiro -->
+		<dependency>
+			<groupId>org.apache.shiro</groupId>
+			<artifactId>shiro-spring</artifactId>
+			<version>1.3.2</version>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.shiro</groupId>
+			<artifactId>shiro-ehcache</artifactId>
+			<version>1.3.2</version>
+		</dependency>
+		<dependency>
+			<groupId>commons-validator</groupId>
+			<artifactId>commons-validator</artifactId>
+			<version>1.4.1</version>
+		</dependency>
+		<!-- kaptcha verification code -->
+		<dependency>
+			<groupId>com.github.penggle</groupId>
+			<artifactId>kaptcha</artifactId>
+			<version>2.3.2</version>
+		</dependency>
 	</dependencies>
 
 	<build>

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

@@ -0,0 +1,57 @@
+package com.mooctest.crowd.site.anticorruption.impl.data;
+
+import com.mooctest.crowd.domain.domainobject.User;
+import com.mooctest.crowd.site.command.ModifyCommand;
+import com.mooctest.crowd.site.command.RestPasswordCommand;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.lang.reflect.InvocationTargetException;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class UserCommon extends UserInfo {
+   private String verifyCode;
+
+   private String password2;
+
+   private String oldPassword;
+
+   private String thirdPartyId;
+
+   private String thirdPartyName;
+
+   private String headImgUrl;
+
+   private String from;
+
+   private String openid;
+
+   private String unionid;
+
+   public void obtainValue(RestPasswordCommand command){
+      super.setId(command.getId());
+      super.setPassword(command.getPassword());
+      this.oldPassword = command.getOldPassword();
+      this.password2 = command.getPassword2();
+   }
+
+   public UserCommon(User user) throws InvocationTargetException, IllegalAccessException {
+      super(user);
+   }
+
+   public void obtainValue(ModifyCommand command) {
+      super.setId(command.getId());
+      if(command.getVerifyCode() != null) {
+         this.verifyCode = command.getVerifyCode();
+      }
+      if(command.getEmail() != null){
+         super.setEmail(command.getEmail());
+      }
+      if(command.getMobile() != null){
+         super.setMobile(command.getMobile());
+      }
+   }
+}

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

@@ -3,7 +3,10 @@ package com.mooctest.crowd.site.anticorruption.impl.data;
 import com.mooctest.crowd.domain.domainobject.User;
 import com.mooctest.crowd.domain.factory.UserFactory;
 import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.apache.commons.beanutils.BeanUtils;
 
+import java.lang.reflect.InvocationTargetException;
 import java.sql.Timestamp;
 
 /**
@@ -12,6 +15,7 @@ import java.sql.Timestamp;
  * @date 2019-08-12 01:47
  */
 @Data
+@NoArgsConstructor
 public class UserInfo {
     private Long id;
     private String email;
@@ -43,4 +47,7 @@ public class UserInfo {
         user.setIsDeleted(0);
         return user;
     }
+    public UserInfo(User user) throws InvocationTargetException, IllegalAccessException {
+        BeanUtils.copyProperties(this, user);
+    }
 }

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

@@ -14,26 +14,24 @@ import java.sql.Timestamp;
  */
 @Data
 public class ApplyEnterpriseAuthCommand {
-    @NotNull(message = "用户ID不可为空")
-    private Long userId;
 
-    @NotNull(message = "企业名称不可为空")
-    private String enterpriseName;
-
-    @NotNull(message = "企业法人不可为空")
+    @NotNull(message = "企业法人姓名不可为空")
     private String legalPersonName;
-
     @NotNull(message = "请上传营业执照")
     private String businessLicensePhoto;
-
-    @NotNull(message = "请填写社会统一信用代码")
-    private String unifiedSocialCreditCode;
-
-    @NotNull(message = "请填写对公账户")
-    private String bankAccount;
-
+    @NotNull(message = "身份证号不可为空")
+    private String IDCardNum;
     @NotNull(message = "地址不可为空")
     private String address;
+    @NotNull(message = "请选择性别")
+    private String sex;//2.0新加性别
+    @NotNull(message = "请上传身份证正面照")
+    private String IDCardPositivePhoto;//身份证正面照
+    @NotNull(message = "请上传身份证反面照")
+    private String IDCardBackPhoto;//身份证反面照
+    @NotNull(message = "请正确填写身份证过期时间")
+    private Timestamp IDCardDeadTime;
+
 
     public EnterpriseAuthentication toEnterpriseAuth() {
         EnterpriseAuthentication enterpriseAuthentication = new EnterpriseAuthentication();

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

@@ -16,28 +16,38 @@ import java.sql.Timestamp;
  */
 @Data
 public class ApplyPersonalAuthCommand {
-    @NotNull(message = "用户ID不可为空")
-    private Long userId;
+
+    private String  userId;
 
     @NotNull(message = "请填写真实姓名")
     private String realName;
 
+    @NotNull(message = "请选择性别")
+    private String sex;
+
     @JsonProperty(value = "IDCard")
     @NotNull(message = "请填写身份证号码")
     @Pattern(regexp = "\\d{15}(\\d{2}[0-9xX])?", message = "身份证号格式错误")
     private String IDCard;
 
-    @JsonProperty(value = "IDCardPhoto")
-    @NotNull(message = "请上传身份证图片")
-    private String IDCardPhoto;
+    @JsonProperty(value = "IDCardPositivePhoto")
+    @NotNull(message = "请上传身份证正面图片")
+    private String IDCardPositivePhoto;
+
+    @JsonProperty(value = "IDCardBackPhoto")
+    @NotNull(message = "请上传身份证反面图片")
+    private String IDCardBackPhoto;
+
+    @JsonProperty(value = "IDCardDeadTime")
+    @NotNull(message = "请正确填写过期时间")
+    private Timestamp IDCardDeadTime;
+
 
-    @NotNull(message = "请填写银行卡号")
-    private String bankAccount;
 
-    @NotNull(message = "地址不可为空")
+    @NotNull(message = "请填写单位或者家庭地址")
     private String address;
 
-    public PersonalAuthentication toPersonalAuth(){
+    public PersonalAuthentication toPersonalAuth() {
         PersonalAuthentication personalAuthentication = new PersonalAuthentication();
         BeanUtils.copyProperties(this, personalAuthentication);
         personalAuthentication.setApplyTime(new Timestamp(System.currentTimeMillis()));

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

@@ -25,11 +25,15 @@ public class CrowdTestProjectCommand {
     @NotNull(message = "项目名称不可为空")
     private String name;
 
+    @NotNull(message = "项目领域类型不可为空")
+    private String fieldType;
+
+    @NotNull(message = "项目应用类型不可为空")
+    private String platform;
+
     @NotNull(message = "项目服务类型不可为空")
     private ArrayList<String> type;
 
-    private ArrayList<String> platform;
-
     @NotNull(message = "项目描述不可为空")
     private String desc;
 
@@ -68,8 +72,9 @@ public class CrowdTestProjectCommand {
         crowdTestProject.setName(this.name);
         crowdTestProject.setLinkMan(this.contactName);
         crowdTestProject.setLinkManMobile(this.contactPhone);
+        crowdTestProject.setFieldType(this.fieldType);
         crowdTestProject.setType(JSONObject.toJSONString(this.type));
-        crowdTestProject.setPlatform(JSONObject.toJSONString(this.platform));
+        crowdTestProject.setPlatform(this.platform);
         crowdTestProject.setDescription(this.desc);
         crowdTestProject.setRequirementFile(this.doc);
         crowdTestProject.setProjectFile(this.file);

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

@@ -0,0 +1,19 @@
+package com.mooctest.crowd.site.command;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * @Author: xuexb
+ * @Date: 2019.7.5 14:24
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class ModifyCommand {
+    private Long id;
+    private String mobile;
+    private String email;
+    private String verifyCode;
+}

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

@@ -0,0 +1,19 @@
+package com.mooctest.crowd.site.command;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * @Author: xuexb
+ * @Date: 2019.7.5 14:24
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class RestPasswordCommand {
+    private Long id;
+    private String oldPassword;
+    private String password;
+    private String password2;
+}

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

@@ -0,0 +1,36 @@
+package com.mooctest.crowd.site.configuration;
+
+import com.google.code.kaptcha.Constants;
+import com.google.code.kaptcha.impl.DefaultKaptcha;
+import com.google.code.kaptcha.util.Config;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.util.Properties;
+
+/**
+ * @author sean
+ * @date 2017-03-21.
+ */
+@Configuration
+public class CaptchaConfiguration {
+
+    @Bean
+    public DefaultKaptcha getKaptchaBean() {
+        DefaultKaptcha defaultKaptcha = new DefaultKaptcha();
+        Properties properties = new Properties();
+        properties.setProperty(Constants.KAPTCHA_BORDER, "no");
+//        properties.setProperty(Constants.KAPTCHA_BORDER, "yes");
+//        properties.setProperty(Constants.KAPTCHA_BORDER_COLOR, "105,179,90");
+        properties.setProperty(Constants.KAPTCHA_TEXTPRODUCER_FONT_COLOR, "blue");
+        properties.setProperty(Constants.KAPTCHA_IMAGE_WIDTH, "140");
+        properties.setProperty(Constants.KAPTCHA_IMAGE_HEIGHT, "45");
+        properties.setProperty(Constants.KAPTCHA_SESSION_KEY, "code");
+        properties.setProperty(Constants.KAPTCHA_TEXTPRODUCER_CHAR_STRING, "0123456789");
+        properties.setProperty(Constants.KAPTCHA_TEXTPRODUCER_CHAR_LENGTH, "6");
+        Config config = new Config(properties);
+        defaultKaptcha.setConfig(config);
+        return defaultKaptcha;
+    }
+
+}

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

@@ -0,0 +1,177 @@
+package com.mooctest.crowd.site.configuration;
+
+import org.apache.shiro.cache.ehcache.EhCacheManager;
+import org.apache.shiro.spring.LifecycleBeanPostProcessor;
+import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
+import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.DependsOn;
+
+/**
+ * Shiro configuration
+ * Created by Liu on 2017/6/6.
+ */
+@Configuration
+public class ShiroConfiguration {
+    /**
+     * LifecycleBeanPostProcessor，这是个DestructionAwareBeanPostProcessor的子类，
+     * 负责org.apache.shiro.util.Initializable类型bean的生命周期的，初始化和销毁。
+     * 主要是AuthorizingRealm类的子类，以及EhCacheManager类。
+     */
+    @Bean(name = "lifecycleBeanPostProcessor")
+    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
+        return new LifecycleBeanPostProcessor();
+    }
+
+    /**
+     * ShiroRealm，这是个自定义的认证类，继承自AuthorizingRealm，
+     * 负责用户的认证和权限的处理，可以参考JdbcRealm的实现。
+     */
+//    @ConditionalOnProperty(prefix = "featureSwitch", name = "client.loginByUserCenter", matchIfMissing = false)
+//    @Bean(name = "shiroRealm")
+//    @DependsOn("lifecycleBeanPostProcessor")
+//    public ShiroRealmAdapt2UserCenter shiroRealmAdapt2UserCenter() {
+//        // System.out.println("\nCreate ShiroRealm Adapt to UserCenter\n");
+//        ShiroRealmAdapt2UserCenter realm = new ShiroRealmAdapt2UserCenter();
+//        return realm;
+//    }
+//
+//    @Bean(name = "shiroRealm")
+//    @DependsOn("lifecycleBeanPostProcessor")
+//    public ShiroRealm shiroRealm() {
+//        // System.out.println("\nCreate ShiroRealm don't Adapt to UserCenter\n");
+//        ShiroRealm realm = new ShiroRealm();
+//        return realm;
+//    }
+
+    /**
+     * EhCacheManager，缓存管理，用户登陆成功后，把用户信息和权限信息缓存起来，
+     * 然后每次用户请求时，放入用户的session中，如果不设置这个bean，每个请求都会查询一次数据库。
+     */
+    @Bean(name = "ehCacheManager")
+    @DependsOn("lifecycleBeanPostProcessor")
+    public EhCacheManager ehCacheManager() {
+        return new EhCacheManager();
+    }
+
+    /**
+     * SecurityManager，权限管理，这个类组合了登陆，登出，权限，session的处理，是个比较重要的类。
+     */
+//    @Bean(name = "securityManager")
+//    public DefaultWebSecurityManager securityManager(AuthorizingRealm shiroRealm) {
+//        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
+//        securityManager.setRealm(shiroRealm);
+//        securityManager.setCacheManager(ehCacheManager());
+//        //securityManager.setSessionManager(defaultWebSessionManager());
+//
+//        return securityManager;
+//    }
+
+    /**
+     * ShiroFilterFactoryBean，是个factorybean，为了生成ShiroFilter。
+     * 它主要保持了三项数据，securityManager，filters，filterChainDefinitionManager。
+     */
+//    @Bean(name = "shiroFilter")
+//    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
+//        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
+//        shiroFilterFactoryBean.setSecurityManager(securityManager);
+//
+//        Map<String, Filter> filters = new LinkedHashMap<>();
+//        filters.put("authc", new MyAuthorizationFilter());
+//        shiroFilterFactoryBean.setFilters(filters);
+//
+//        Map<String, String> filterChainDefinitionManager = new LinkedHashMap<String, String>();
+//
+//        filterChainDefinitionManager.put("/api/cookie/set", "anon");
+//        filterChainDefinitionManager.put("/api/test/login", "anon");
+//        filterChainDefinitionManager.put("/api/test/register", "anon");
+//        filterChainDefinitionManager.put("/api/featureSwitch", "anon");
+//        filterChainDefinitionManager.put("/api/ossConfiguration","anon");
+//        filterChainDefinitionManager.put("/api/common/tag/**", "authc");
+//        filterChainDefinitionManager.put("/api/common/**", "anon");
+//        filterChainDefinitionManager.put("/api/mobileLogin", "anon");
+//        filterChainDefinitionManager.put("/api/case/nodeList", "anon");
+//        filterChainDefinitionManager.put("/api/exam/**/info","anon");
+//        filterChainDefinitionManager.put("/api/payEmail", "anon");
+//        filterChainDefinitionManager.put("/api/product/send", "anon");
+//
+//        filterChainDefinitionManager.put("/logout", "anon");
+//        filterChainDefinitionManager.put("/api/dev/**", "anon");
+//        filterChainDefinitionManager.put("/api/kibug/plugin/**", "anon");
+//        filterChainDefinitionManager.put("/api/wechat/**", "anon");
+//
+//        filterChainDefinitionManager.put("/api/pythonCommunity/exercise/**", "anon");
+//        filterChainDefinitionManager.put("/api/pythonCommunity/statistic/**", "authc");
+//        filterChainDefinitionManager.put("/api/support/**", "anon");
+//        filterChainDefinitionManager.put("/api/evaluation/**", "authc");
+//
+//        filterChainDefinitionManager.put("/api/onlinejudge/**","anon");
+//
+//        filterChainDefinitionManager.put("/api/codeVisualize/**", "anon");
+//
+//        filterChainDefinitionManager.put("/api/onlinejudge/u/**","authc");
+//        filterChainDefinitionManager.put("/api/sendGetHelpEmail", "anon");
+//        filterChainDefinitionManager.put("/**", "authc");
+//        filterChainDefinitionManager.put("/api/caseExport", "anon");
+//        filterChainDefinitionManager.put("/api/caseImport", "anon");
+//
+//        filterChainDefinitionManager.put("/api/contest/enterWithoutLogin/**", "anon");
+//
+//
+//
+//
+//        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionManager);
+//
+//        shiroFilterFactoryBean.setSuccessUrl("/");
+//        shiroFilterFactoryBean.setLoginUrl("/");
+//        shiroFilterFactoryBean.setUnauthorizedUrl("");
+//        return shiroFilterFactoryBean;
+//    }
+
+    /**
+     * DefaultAdvisorAutoProxyCreator，Spring的一个bean，由Advisor决定对哪些类的方法进行AOP代理。
+     */
+    @Bean
+    @ConditionalOnMissingBean
+    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
+        DefaultAdvisorAutoProxyCreator defaultAAP = new DefaultAdvisorAutoProxyCreator();
+        defaultAAP.setProxyTargetClass(true);
+        return defaultAAP;
+    }
+
+    /**
+     * AuthorizationAttributeSourceAdvisor，shiro里实现的Advisor类，
+     * 内部使用AopAllianceAnnotationsAuthorizingMethodInterceptor来拦截用以下注解的方法。
+     */
+//    @Bean
+//    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
+//        AuthorizationAttributeSourceAdvisor aASA = new AuthorizationAttributeSourceAdvisor();
+//        aASA.setSecurityManager(securityManager);
+//        return aASA;
+//    }
+
+//    @Bean(name = "sessionDao")
+//    public MySessionDao sessionDao() {
+//        MySessionDao sessionDao = new MySessionDao();
+//        sessionDao.setSessionIdGenerator(new JavaUuidSessionIdGenerator());
+////        sessionDao.setSessionIdGenerator(JavaUuidSessionIdGenerator);
+//        return sessionDao;
+//    }
+
+    @Bean(name = "sessionManager")
+    public DefaultWebSessionManager defaultWebSessionManager() {
+        DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
+        sessionManager.setCacheManager(ehCacheManager());
+        sessionManager.setGlobalSessionTimeout(1800000);//超时时间
+        sessionManager.setSessionValidationSchedulerEnabled(true);//定时清除无效的session
+        sessionManager.setSessionValidationInterval(1800000);//半个小时清理一次失效的session
+        sessionManager.setDeleteInvalidSessions(true);//删除无效的session
+//        sessionManager.setSessionDAO(sessionDao());
+        return sessionManager;
+    }
+
+}
+
+

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

@@ -29,10 +29,10 @@ public class WebMvcConfiguration implements WebMvcConfigurer {
     public void addInterceptors(InterceptorRegistry registry) {
         registry.addInterceptor(fileCheckInterceptor)
                 .addPathPatterns("/api/files/**");
-        registry.addInterceptor(authCheckInterceptor)
-                .excludePathPatterns("/api/common/**")
-                .addPathPatterns("/**");
-        registry.addInterceptor(sysAdminCheckInterceptor)
-                .addPathPatterns("/api/user/**");
+//        registry.addInterceptor(authCheckInterceptor)
+//                .excludePathPatterns("/api/common/**")
+//                .addPathPatterns("/**");
+//        registry.addInterceptor(sysAdminCheckInterceptor)
+//                .addPathPatterns("/api/user/**");
     }
 }

site/src/main/java/com/mooctest/crowd/site/constants/CommonConstant.java

@@ -7,4 +7,12 @@ package com.mooctest.crowd.site.constants;
  */
 public class CommonConstant {
     public static final Long DEFAULT_REGIONAL_MANAGERID = 1L;
+
+    public static final Integer DEFAULT_ROWS_ON_PAGE = 10;
+
+    public static final Integer SQUARE_ROWS_ON_PAGE = 9;
+
+    public static final Integer TECHNOLOGY_ROWS_ON_PAGE = 5;
+
+    public static final Integer DEFAULT_RECOURSE_ROWS_ON_PAGE = 7;
 }

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

@@ -0,0 +1,30 @@
+package com.mooctest.crowd.site.controller;
+
+import org.apache.shiro.authz.UnauthenticatedException;
+import org.apache.shiro.authz.UnauthorizedException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * @author liuzicong
+ */
+public abstract class BaseController {
+
+    protected final Logger LOG = LoggerFactory.getLogger(getClass());
+
+    @ExceptionHandler({UnauthenticatedException.class})
+    public String authenticationException(HttpServletRequest request, HttpServletResponse response) {
+        response.setStatus(HttpServletResponse.SC_FORBIDDEN);
+        return "";
+    }
+
+    @ExceptionHandler({UnauthorizedException.class})
+    public String authorizationException(HttpServletRequest request, HttpServletResponse response){
+        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
+        return  "";
+    }
+}

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

@@ -0,0 +1,60 @@
+package com.mooctest.crowd.site.controller;
+
+import com.mooctest.crowd.site.constants.CommonConstant;
+import com.mooctest.crowd.site.data.ColumnFilter;
+import com.mooctest.crowd.site.data.enums.ColumnFilterType;
+import com.mooctest.crowd.site.data.vo.SearchConditionVO;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author henrylee
+ */
+public abstract class BaseSearchController extends BaseController{
+    public abstract Page<?> search(String searchCondition);
+    Pageable getPageable(SearchConditionVO searchConditionVO){
+        int activePage = searchConditionVO.getActivePage() == 0?1:searchConditionVO.getActivePage();
+        Sort sort = new Sort(Sort.Direction.DESC,"id");
+        if(searchConditionVO.getColumnFilters() != null){
+            for (ColumnFilter columnFilter:searchConditionVO.getColumnFilters()) {
+                if (ColumnFilterType.SORT.getName().equals(columnFilter.getType()) && columnFilter.getValue() != null) {
+                    sort = new Sort(Sort.Direction.fromString(columnFilter.getValue()),columnFilter.getField());
+                    break;
+                }
+            }
+        }
+        return new PageRequest(activePage-1, CommonConstant.SQUARE_ROWS_ON_PAGE, sort);
+    }
+    Map<String,String> getExtraCondition(SearchConditionVO searchConditionVO) {
+        Map<String,String> result = searchConditionVO.getExtraCondition();
+        if (result == null) {
+            result = new HashMap<>();
+        }
+        for (ColumnFilter columnFilter:searchConditionVO.getColumnFilters()) {
+            if (ColumnFilterType.ENUM.getName().equals(columnFilter.getType())
+                    && columnFilter.getValue() != null && !columnFilter.getValue().equals("all")) {
+                result.put(columnFilter.getField(),columnFilter.getValue());
+            }
+        }
+        return result;
+    }
+
+    Map<String, String> getExcludeCondition(SearchConditionVO searchConditionVO){
+        Map<String, String> result = new HashMap<>();
+        for (ColumnFilter columnFilter:searchConditionVO.getColumnFilters()) {
+            if (ColumnFilterType.ENUM.getName().equals(columnFilter.getType())
+                    && columnFilter.getValue().equals("all") && columnFilter.getExclude()!=null ) {
+                for(String ex: columnFilter.getExclude()){
+                    result.put(columnFilter.getField(), ex);
+                }
+            }
+        }
+        return result;
+
+    }
+}

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

@@ -0,0 +1,71 @@
+package com.mooctest.crowd.site.controller;
+
+import com.google.code.kaptcha.impl.DefaultKaptcha;
+import com.mooctest.crowd.domain.util.EncryptionUtil;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.servlet.ModelAndView;
+
+import javax.imageio.ImageIO;
+import javax.servlet.ServletOutputStream;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
+import java.awt.image.BufferedImage;
+
+/**
+ * @author sean
+ * @date 2017-03-21.
+ */
+@RestController
+public class CaptchaController extends BaseController {
+
+    @Autowired
+    private DefaultKaptcha captchaProducer;
+
+//    @Autowired
+//    private VerificationLogic verificationLogic;
+
+    @RequestMapping(value = "/api/common/captcha")
+    public ModelAndView getKaptchaImage(HttpServletRequest request,
+                                        HttpServletResponse response) throws Exception {
+
+        response.setDateHeader("Expires", 0);
+        response.setHeader("Cache-Control",
+                "no-store, no-cache, must-revalidate");
+        response.addHeader("Cache-Control", "post-check=0, pre-check=0");
+        response.setHeader("Pragma", "no-cache");
+        response.setContentType("image/jpeg");
+
+        String capText = captchaProducer.createText();
+
+        try {
+//            Session session = SecurityUtils.getSubject().getSession();
+            HttpSession session = request.getSession();
+            String md5Captcha = EncryptionUtil.encryptMD5Hex(capText);
+            session.setAttribute("captchaCode" , md5Captcha);
+
+        } catch (Exception e) {
+            LOG.error("", e);
+        }
+
+        BufferedImage bi = captchaProducer.createImage(capText);
+        System.out.println("capText " + capText);
+        ServletOutputStream out = response.getOutputStream();
+        ImageIO.write(bi, "jpg", out);
+        try {
+            out.flush();
+        } finally {
+            out.close();
+        }
+        return null;
+
+    }
+
+//    @RequestMapping(value = UrlConstants.API_COMMON + "captcha/mobile/{mobile:\\d+}", method = RequestMethod.POST)
+//    public void sendMobileCaptcha(@PathVariable("mobile") String mobile) {
+//        verificationLogic.sendMobileVerfication(mobile);
+//    }
+
+}

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

@@ -1,50 +1,119 @@
 package com.mooctest.crowd.site.controller;
 
-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.site.data.dto.CrowdTestSquareIndexDTO;
-import com.mooctest.crowd.site.data.dto.TaskSquareDTO;
+import com.mooctest.crowd.site.data.dto.ProjectAndTaskDTO;
+import com.mooctest.crowd.site.data.response.ResponseVO;
+import com.mooctest.crowd.site.data.response.ServerCode;
+import com.mooctest.crowd.site.data.vo.CrowdTaskVO;
+import com.mooctest.crowd.site.data.vo.CrowdTestProjectVO;
+import com.mooctest.crowd.site.data.vo.SearchConditionVO;
+import com.mooctest.crowd.site.service.CommonService;
 import com.mooctest.crowd.site.service.CrowdProjectService;
 import com.mooctest.crowd.site.service.CrowdTaskService;
+import com.mooctest.crowd.site.util.DataUtils;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.web.bind.annotation.*;
 
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+
 
 /**
  * @author:xx
  * @date:2020/6/20
- * @description:
+ * @description:群智慧项目2.0众测广场所有接口
  */
 
 @RestController
 @RequestMapping("/api/square")
-public class CrowTestSquareController {
+public class CrowTestSquareController extends BaseSearchController {
+
     @Autowired
     private CrowdProjectService crowdProjectService;
     @Autowired
-    private CrowdTaskService  crowdTaskService;
+    private CrowdTaskService crowdTaskService;
+    @Autowired
+    private CommonService commonService;
 
 
     /**
-     * 获取众测广场首页所有的数据包装到CrowdTestSquareIndexDTO里面
+     * 获取众测广场首页所有的数据,包装到CrowdTestSquareIndexDTO里面
      *
      * @return
      */
-
     @GetMapping("/list")
-    public CrowdTestSquareIndexDTO getAll(){
+    public ResponseVO getAll() {
         CrowdTestSquareIndexDTO crowdTestSquareIndexDTO = new CrowdTestSquareIndexDTO();
-        List<CrowdTestProjectPO> list = crowdProjectService.findAll();
-        List<CrowdTestTaskPO> crowdTestTasks= crowdTaskService.getAll();
-        crowdTestSquareIndexDTO.setCowdTestProjects(list);
-        crowdTestSquareIndexDTO.setCrowdTestTaskPOS(crowdTestTasks);
-        return crowdTestSquareIndexDTO;
+        List<CrowdTestProjectVO> list = crowdProjectService.findAll();
+        List<CrowdTaskVO> crowdTestTasks = crowdTaskService.findAll();
+        crowdTestSquareIndexDTO.setCrowdTestProjectVOs(list);
+        crowdTestSquareIndexDTO.setCrowdTestTaskVOS(crowdTestTasks);
+        crowdTestSquareIndexDTO.initHotTaskAndProject();
+        return new ResponseVO(ServerCode.SUCCESS, crowdTestSquareIndexDTO);
+    }
+
+    /**
+     * 众测项目分页查询接口
+     */
+    @PostMapping("/project/list")
+    public ResponseVO findAllprojectByPage(@RequestBody SearchConditionVO searchConditionVO) {
+        Pageable pageable = this.getPageable(searchConditionVO);
+        List<CrowdTestProjectVO> list = crowdProjectService.findAll(pageable);
+        Page<CrowdTestProjectVO> page = DataUtils.listToPage(list, pageable);
+        return new ResponseVO<>(ServerCode.SUCCESS, page);
+    }
+
+    /**
+     * 众测任务分页查询接口
+     */
+    @PostMapping("/task/list")
+    public ResponseVO<Page<CrowdTaskVO>> getAllTaskByPage(@RequestBody SearchConditionVO searchConditionVO) {
+        Pageable pageable = this.getPageable(searchConditionVO);
+        Page<CrowdTaskVO> page = commonService.getTaskinfo(pageable, null, 0);
+        return new ResponseVO<>(ServerCode.SUCCESS, page);
+    }
+
+    /**
+     * 搜索框模糊查询接口
+     */
+    @PostMapping("search/list")
+    public ResponseVO findByNameLike(@RequestBody SearchConditionVO searchConditionVO) {
+        Map<String, String> extraCondition = searchConditionVO.getColumnFilters() == null ? new HashMap<>() : super.getExtraCondition(searchConditionVO);
+        LOG.info("想要查询的是" + searchConditionVO.getColumnFilters().get(0).getType());
+        Pageable pageable = this.getPageable(searchConditionVO);
+        String keyword = searchConditionVO.getKeyword();
+        ProjectAndTaskDTO projectAndTaskDTO = new ProjectAndTaskDTO();
+        List<CrowdTestProjectVO> list = crowdProjectService.findByNameLike(keyword);
+        List<CrowdTaskVO> taskVOList = crowdTaskService.findByNameLike(keyword);
+
+        projectAndTaskDTO.setCrowdTaskVOList(taskVOList);
+        projectAndTaskDTO.setProjectVOList(list);
+        List projectAndTaskDTOList = new ArrayList<>();
+        projectAndTaskDTOList.addAll(list);
+        projectAndTaskDTOList.addAll(taskVOList);
+        Page<ProjectAndTaskDTO> projectAndTaskDTOPage = DataUtils.listToPage(projectAndTaskDTOList, pageable);
+        Page<CrowdTestProjectVO> projectVOPage = DataUtils.listToPage(list, pageable);
+        Page<CrowdTaskVO> crowdTaskVOPage = DataUtils.listToPage(taskVOList, pageable);
+        if (searchConditionVO.getColumnFilters().get(0).getType().equals("project")){
+            return new ResponseVO<>(ServerCode.SUCCESS, projectVOPage);
+        } else if (searchConditionVO.getColumnFilters().get(0).getType().equals("task")) {
+            return new ResponseVO(ServerCode.SUCCESS, crowdTaskVOPage);
+        }
+        return new ResponseVO<>(ServerCode.SUCCESS, projectAndTaskDTOPage);
+    }
+
+    @Override
+    public Page<?> search(String searchCondition) {
+        return null;
     }
 
 
 }
+
+
+
+

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

@@ -0,0 +1,65 @@
+package com.mooctest.crowd.site.controller;
+
+import com.mooctest.crowd.site.data.dto.BankCardDTO;
+import com.mooctest.crowd.site.data.dto.QualificationDTO;
+import com.mooctest.crowd.site.data.dto.UserDTO;
+import com.mooctest.crowd.site.data.vo.BankCardVO;
+import com.mooctest.crowd.site.data.vo.QualificationVO;
+import com.mooctest.crowd.site.data.vo.UserVO;
+import com.mooctest.crowd.site.service.PersonalDataService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+
+@RestController
+@RequestMapping("/api/personal")
+public class PersonalDataController {
+
+    @Autowired
+    private PersonalDataService personalDataService;
+
+    @RequestMapping(value = "/display/{userId:\\d+}", method = RequestMethod.GET)
+    public UserDTO getInformation(@PathVariable("userId") long userId){
+        return  personalDataService.getInformation(userId);
+    }
+
+    @RequestMapping(value = "/update/{userId:\\d+}", method = RequestMethod.PUT)
+    public UserDTO updateInformation(@PathVariable("userId") long userId, @RequestBody UserVO userVO) {
+        return  personalDataService.updateInformation(userId,userVO);
+    }
+
+    @RequestMapping(value = "/displayqualification/{userId:\\d+}", method = RequestMethod.GET)
+    public QualificationDTO getQualification(@PathVariable("userId") long userId){
+        return  personalDataService.getQualification(userId);
+    }
+
+    @RequestMapping(value = "/addqualification/{userId:\\d+}", method = RequestMethod.POST)
+    public QualificationDTO addQualification(@PathVariable("userId") long userId, @RequestBody QualificationVO qualificationVO){
+        return  personalDataService.addQualification(userId,qualificationVO);
+    }
+
+    @RequestMapping(value = "/updatequalification/{id:\\d+}/{userId:\\d+}", method = RequestMethod.PUT)
+    public QualificationDTO updateQualification(@PathVariable("id") long id, @PathVariable("userId") long userId,@RequestBody QualificationVO qualificationVO){
+        return  personalDataService.updateQualification(id,userId,qualificationVO);
+    }
+
+    @RequestMapping(value = "/deletequalification/{id:\\d+}/{userId:\\d+}", method = RequestMethod.DELETE)
+    public QualificationDTO deleteQualification(@PathVariable("id") long id, @PathVariable("userId") long userId){
+        return  personalDataService.deleteQualification(id,userId);
+    }
+
+    @RequestMapping(value = "/displaybankcard/{userId:\\d+}", method = RequestMethod.GET)
+    public BankCardDTO getBankCard(@PathVariable("userId") long userId){
+        return  personalDataService.getBankCard(userId);
+    }
+
+    @RequestMapping(value = "/addbankcard/{userId:\\d+}", method = RequestMethod.POST)
+    public BankCardDTO addBankCard(@PathVariable("userId") long userId, @RequestBody BankCardVO bankCardVO){
+        return  personalDataService.addBankCard(userId,bankCardVO);
+    }
+
+    @RequestMapping(value = "/deletebankcard/{id:\\d+}/{userId:\\d+}", method = RequestMethod.DELETE)
+    public BankCardDTO deleteBankCard(@PathVariable("id") long id, @PathVariable("userId") long userId){
+        return  personalDataService.deleteBankCard(id,userId);
+    }
+}

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

@@ -0,0 +1,65 @@
+package com.mooctest.crowd.site.controller;
+
+import com.mooctest.crowd.site.constants.CommonConstant;
+import com.mooctest.crowd.site.data.dto.TechnicalArticlesDTO;
+import com.mooctest.crowd.site.data.response.ResponseVO;
+import com.mooctest.crowd.site.data.response.ServerCode;
+import com.mooctest.crowd.site.data.vo.SearchConditionVO;
+import com.mooctest.crowd.site.service.TechnicalArticlesService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+
+/**
+ * @Author: hanyuwei
+ * @Date: 2020.6.22
+ */
+@RestController
+@RequestMapping("/api/technical")
+public class TechnicalArticlesController extends BaseSearchController{
+
+    @Autowired
+    private TechnicalArticlesService technical;
+
+    @RequestMapping(value = "/articles", method = RequestMethod.POST)
+    public ResponseVO<TechnicalArticlesDTO> technicalArticles(@RequestBody SearchConditionVO searchConditionVO){
+        Map<String, String> extraCondition = searchConditionVO.getColumnFilters()==null? new HashMap<>() :super.getExtraCondition(searchConditionVO);
+        Pageable pageable = this.getPageable(searchConditionVO);
+        String keyword = searchConditionVO.getKeyword();
+        return new ResponseVO<>(ServerCode.SUCCESS, technical.getArticles(pageable, keyword,extraCondition));
+    }
+
+    @Override
+    public Page<?> search(String searchCondition) {
+        return null;
+    }
+
+    Pageable getPageable(SearchConditionVO searchConditionVO){
+        int activePage = searchConditionVO.getActivePage() == 0?1:searchConditionVO.getActivePage();
+        Sort sort = new Sort(Sort.Direction.DESC,"publicTime");
+        return new PageRequest(activePage-1, CommonConstant.TECHNOLOGY_ROWS_ON_PAGE, sort);
+    }
+
+    Pageable getRanking(){
+        Sort sort = new Sort(Sort.Direction.DESC,"reading");
+        return  new PageRequest(0,10,sort);
+    }
+
+    @RequestMapping(value = "/ranking", method = RequestMethod.GET)
+    public ResponseVO<TechnicalArticlesDTO> ranking(){
+        Pageable pageable = this.getRanking();
+        return new ResponseVO<>(ServerCode.SUCCESS, technical.articlesRanking(pageable));
+    }
+
+    @RequestMapping(value = "/updateranking/{id:\\d+}", method = RequestMethod.GET)
+    public  TechnicalArticlesDTO updateRanking(@PathVariable("id") long id){
+        return  technical.updateRanking(id);
+    }
+}

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

@@ -5,16 +5,22 @@ import com.mooctest.crowd.site.annotation.LoginRequired;
 import com.mooctest.crowd.site.annotation.SysAdminRequired;
 import com.mooctest.crowd.site.command.*;
 import com.mooctest.crowd.site.data.dto.UserDTO;
+import com.mooctest.crowd.site.data.response.ResponseVO;
+import com.mooctest.crowd.site.data.response.ServerCode;
 import com.mooctest.crowd.site.data.vo.BaseAuthVO;
 import com.mooctest.crowd.site.data.vo.EnterpriseAuthVO;
 import com.mooctest.crowd.site.data.vo.PersonalAuthVO;
+import com.mooctest.crowd.site.service.EnterpriseAuthService;
+import com.mooctest.crowd.site.service.PersonalAuthService;
 import com.mooctest.crowd.site.service.UserService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.validation.BindingResult;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
 
+import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpSession;
+import java.lang.reflect.InvocationTargetException;
 import java.util.List;
 
 /**
@@ -24,7 +30,12 @@ import java.util.List;
  */
 @RestController
 @RequestMapping("/api")
-public class UserController {
+public class UserController extends BaseController {
+    @Autowired
+    private PersonalAuthService personalAuthService;
+    @Autowired
+    private EnterpriseAuthService enterpriseAuthService;
+
 
     @Autowired
     private UserService userService;
@@ -37,34 +48,83 @@ public class UserController {
     }
 
     @RequestMapping(value = "/user", method = RequestMethod.PUT)
-    public UserDTO updateUser(@Validated UserUpdateCommand command, BindingResult result){
+    public UserDTO updateUser(@Validated UserUpdateCommand command, BindingResult result) {
         return null;
     }
 
     @RequestMapping(value = "/user/{userId}", method = RequestMethod.DELETE)
-    public boolean deleteUser(@PathVariable("userId") Long userId){
+    public boolean deleteUser(@PathVariable("userId") Long userId) {
         return true;
     }
 
     @RequestMapping(value = "/user/{userId}", method = RequestMethod.GET)
-    public UserDTO getUser(@PathVariable Long userId){
+    public UserDTO getUser(@PathVariable Long userId) {
         return userService.getUser(userId);
     }
 
     @RequestMapping(value = "/user", method = RequestMethod.GET)
-    public List<UserDTO> getUsers(){
+    public List<UserDTO> getUsers() {
         return null;
     }
 
     @RequestMapping(value = "/login", method = RequestMethod.GET)
-    public UserDTO loginByMobileAndPwd(@Validated LoginCommand loginCommand, BindingResult result) throws PasswordErrorException, AccountNotExistException, BadRequestException {
+    public UserDTO loginByMobileAndPwd(@Validated @RequestBody LoginCommand loginCommand, BindingResult result, HttpServletRequest request) throws PasswordErrorException, AccountNotExistException, BadRequestException {
         if (result.hasErrors())
             throw new BadRequestException(result.getFieldError().getDefaultMessage());
         return userService.loginByMobileAndPwd(loginCommand);
     }
 
     /**
+     * 修改密码
+     */
+    @RequestMapping(value = "/password/reset", method = RequestMethod.PUT)
+    public ResponseVO<Object> resetPassword(@RequestBody RestPasswordCommand restPasswordCommand, HttpServletRequest request) throws InvocationTargetException, IllegalAccessException {
+        return userService.restPassword(restPasswordCommand, request);
+    }
+
+    /**
+     * 获取邮箱验证码
+     */
+    @RequestMapping(value = "/verify/email", method = RequestMethod.PUT)
+    public ResponseVO<Object> verifyMail(@RequestBody ModifyCommand modifyCommand, HttpServletRequest request) throws InvocationTargetException, IllegalAccessException {
+        return userService.verifyMail(modifyCommand, request);
+    }
+
+    /**
+     * 绑定邮箱
+     */
+    @RequestMapping(value = "/user/email", method = RequestMethod.PUT)
+    public ResponseVO<Object> updateEmail(@RequestBody ModifyCommand modifyCommand, HttpServletRequest request) throws InvocationTargetException, IllegalAccessException {
+        return userService.updateEmail(modifyCommand, request);
+    }
+
+    /**
+     * 获取手机验证码（新旧手机号）
+     */
+    @RequestMapping(value = "/verify/mobile", method = RequestMethod.PUT)
+    public ResponseVO<Object> verifyMobile(@RequestBody ModifyCommand mobileCommand, HttpServletRequest request) throws InvocationTargetException, IllegalAccessException {
+        return userService.getVerifyMobileCode(mobileCommand, request);
+    }
+
+    /**
+     * 验证旧手机验证码
+     */
+    @RequestMapping(value = "/verify/old/mobile", method = RequestMethod.PUT)
+    public ResponseVO<Object> verifyOldMobile(@RequestBody ModifyCommand mobileCommand, HttpServletRequest request) throws InvocationTargetException, IllegalAccessException {
+        return userService.verifyOldMobile(mobileCommand, request);
+    }
+
+    /**
+     * 修改手机号
+     */
+    @RequestMapping(value = "/user/mobile", method = RequestMethod.PUT)
+    public ResponseVO<Object> updateMobile(@RequestBody ModifyCommand mobileCommand, HttpServletRequest request) throws InvocationTargetException, IllegalAccessException {
+        return userService.updateMobile(mobileCommand, request);
+    }
+
+    /**
      * 申请个人实名认证
+     *
      * @param userId
      * @param command
      * @param result
@@ -73,19 +133,21 @@ public class UserController {
      */
     @LoginRequired
     @RequestMapping(value = "/user/{userId}/personalAuth", method = RequestMethod.POST)
-    public PersonalAuthVO applyPersonalAuthentication(@PathVariable("userId")Long userId,
+    public PersonalAuthVO applyPersonalAuthentication(@PathVariable("userId") Long userId,
                                                       @Validated @RequestBody ApplyPersonalAuthCommand command,
-                                                      BindingResult result, HttpSession session){
-        if (!userId.equals(Long.parseLong((String)session.getAttribute("userId"))))
-            throw new UnauthorizedException("没有权限对他人账号进行操作！");
+                                                      BindingResult result, HttpSession session) {
+
+//        if (!userId.equals(Long.parseLong((String) session.getAttribute("userId"))))
+//            throw new UnauthorizedException("没有权限对他人账号进行操作！");
+        LOG.info("当前用户申请的认证信息为" + command);
         if (result.hasErrors())
             throw new BaseException(result.getFieldError().getDefaultMessage());
-
         return userService.applyPersonalAuth(userId, command);
     }
 
     /**
      * 修改个人认证信息
+     *
      * @param userId
      * @param command
      * @param result
@@ -93,64 +155,73 @@ public class UserController {
      */
     @LoginRequired
     @RequestMapping(value = "/user/{userId}/personalAuth", method = RequestMethod.PUT)
-    public PersonalAuthVO updatePersonalAuthInfo(@PathVariable("userId")Long userId,
+    public PersonalAuthVO updatePersonalAuthInfo(@PathVariable("userId") Long userId,
                                                  @Validated @RequestBody ApplyPersonalAuthCommand command,
                                                  HttpSession session,
-                                                 BindingResult result){
-        if (result.hasErrors())
+                                                 BindingResult result) {
+        if (result.hasErrors()) {
             throw new BaseException(result.getFieldError().getDefaultMessage());
+        }
         return userService.updatePersonalAuthInfo(userId, command);
     }
 
 
     /**
      * 个人认证：通过审核
+     *
      * @param userId
      * @return
      */
     @LoginRequired
     @SysAdminRequired
     @RequestMapping(value = "/user/{userId}/personalAuth/status/accept", method = RequestMethod.PUT)
-    public PersonalAuthVO passPersonalAuth(@PathVariable("userId") Long userId){
+    public PersonalAuthVO passPersonalAuth(@PathVariable("userId") Long userId) {
         return userService.passPersonalAuth(userId);
     }
 
     /**
      * 个人认证：审核未通过
+     *
      * @param userId
      * @return
      */
     @LoginRequired
     @SysAdminRequired
     @RequestMapping(value = "/user/{userId}/personalAuth/status/reject", method = RequestMethod.PUT)
-    public PersonalAuthVO rejectPersonalAuth(@PathVariable("userId") Long userId, @RequestBody @Validated AuthRejectCommand command){
+    public PersonalAuthVO rejectPersonalAuth(@PathVariable("userId") Long userId, @RequestBody @Validated AuthRejectCommand command) {
         return userService.rejectPersonalAuth(userId, command.getExplain());
     }
 
+
+
+
     /**
      * 查看个人认证信息
+     *
      * @param userId
      * @return
      */
     @LoginRequired
     @RequestMapping(value = "/user/{userId}/personalAuth", method = RequestMethod.GET)
-    public PersonalAuthVO getPersonalAuthInfo(@PathVariable("userId") Long userId){
+    public PersonalAuthVO getPersonalAuthInfo(@PathVariable("userId") Long userId) {
         return userService.getPersonalAuthInfo(userId);
     }
 
     /**
      * 获取企业认证信息
+     *
      * @param userId
      * @return
      */
     @LoginRequired
     @RequestMapping(value = "/user/{userId}/enterpriseAuth", method = RequestMethod.GET)
-    public EnterpriseAuthVO getEnterpriseAuthInfo(@PathVariable("userId") Long userId){
+    public EnterpriseAuthVO getEnterpriseAuthInfo(@PathVariable("userId") Long userId) {
         return userService.getEnterpriseAuthInfo(userId);
     }
 
     /**
      * 申请企业认证接口
+     *
      * @param userId
      * @param command
      * @param result
@@ -159,10 +230,10 @@ public class UserController {
      */
     @LoginRequired
     @RequestMapping(value = "/user/{userId}/enterpriseAuth", method = RequestMethod.POST)
-    public EnterpriseAuthVO applyEnterpriseAuth(@PathVariable("userId")Long userId,
-                                                  @Validated @RequestBody ApplyEnterpriseAuthCommand command,
-                                                  BindingResult result, HttpSession session){
-        if (!userId.equals(Long.parseLong((String)session.getAttribute("userId"))))
+    public EnterpriseAuthVO applyEnterpriseAuth(@PathVariable("userId") Long userId,
+                                                @Validated @RequestBody ApplyEnterpriseAuthCommand command,
+                                                BindingResult result, HttpSession session) {
+        if (!userId.equals(Long.parseLong((String) session.getAttribute("userId"))))
             throw new UnauthorizedException("没有权限对他人账号进行操作！");
         if (result.hasErrors())
             throw new BaseException(result.getFieldError().getDefaultMessage());
@@ -171,6 +242,7 @@ public class UserController {
 
     /**
      * 更新企业认证信息
+     *
      * @param userId
      * @param command
      * @param result
@@ -178,9 +250,9 @@ public class UserController {
      */
     @LoginRequired
     @RequestMapping(value = "/user/{userId}/enterpriseAuth", method = RequestMethod.PUT)
-    public EnterpriseAuthVO updatePersonalAuthInfo(@PathVariable("userId")Long userId,
-                                                 @Validated @RequestBody ApplyEnterpriseAuthCommand command,
-                                                 BindingResult result){
+    public EnterpriseAuthVO updatePersonalAuthInfo(@PathVariable("userId") Long userId,
+                                                   @Validated @RequestBody ApplyEnterpriseAuthCommand command,
+                                                   BindingResult result) {
         if (result.hasErrors())
             throw new BaseException(result.getFieldError().getDefaultMessage());
         return userService.updateEnterpriseAuthInfo(userId, command);
@@ -188,38 +260,40 @@ public class UserController {
 
     /**
      * 企业认证：审核通过
+     *
      * @param userId
      * @return
      */
     @LoginRequired
     @SysAdminRequired
     @RequestMapping(value = "/user/{userId}/enterpriseAuth/status/accept", method = RequestMethod.PUT)
-    public EnterpriseAuthVO passEnterpriseAuth(@PathVariable("userId") Long userId){
+    public EnterpriseAuthVO passEnterpriseAuth(@PathVariable("userId") Long userId) {
         return userService.passEnterpriseAuth(userId);
     }
 
     /**
      * 企业认证：审核未通过
+     *
      * @param userId
      * @return
      */
     @LoginRequired
     @RequestMapping(value = "/user/{userId}/enterpriseAuth/status/reject", method = RequestMethod.PUT)
-    public EnterpriseAuthVO rejectEnterpriseAuth(@PathVariable("userId") Long userId, @RequestBody @Validated AuthRejectCommand command){
+    public EnterpriseAuthVO rejectEnterpriseAuth(@PathVariable("userId") Long userId, @RequestBody @Validated AuthRejectCommand command) {
         return userService.rejectEnterpriseAuth(userId, command.getExplain());
     }
 
     @LoginRequired
     @SysAdminRequired
     @RequestMapping(value = "/user/authentication/handling", method = RequestMethod.GET)
-    public List<BaseAuthVO> getAuthingList(){
+    public List<BaseAuthVO> getAuthingList() {
         return userService.getAuthingList();
     }
 
     @LoginRequired
     @SysAdminRequired
     @RequestMapping(value = "/user/authentication/handled", method = RequestMethod.GET)
-    public List<BaseAuthVO> getAuthedList(){
+    public List<BaseAuthVO> getAuthedList() {
         return userService.getAuthedList();
     }
 

site/src/main/java/com/mooctest/crowd/site/controller/advice/ExceptionAdvice.java

@@ -1,12 +1,14 @@
 package com.mooctest.crowd.site.controller.advice;
 
-import com.mooctest.crowd.site.constants.ResponseConstant;
-import com.mooctest.crowd.site.data.ResponseMessage;
 import com.mooctest.crowd.domain.exception.*;
+import com.mooctest.crowd.site.constants.ResponseConstant;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.HttpStatus;
 import org.springframework.web.HttpRequestMethodNotSupportedException;
-import org.springframework.web.bind.annotation.*;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
 
 /**
  * @author: Diors.Po
@@ -23,6 +25,8 @@ public class ExceptionAdvice {
         log.error("访问出错："+e.getMessage(), e);
         if (e instanceof AccountNotExistException){
             return ResponseConstant.USER_NOT_EXISTS;
+        } else if (e instanceof NullPointerException){
+            return "操作失败";
         } else if (e instanceof CrowdTestProjectNotExistException){
             return "项目不存在";
         } else if (e instanceof CrowdTestTaskNotExistException){
@@ -33,6 +37,16 @@ public class ExceptionAdvice {
             return "项目未设置价格";
         } else if (e instanceof PasswordErrorException){
             return "密码错误";
+        } else if (e instanceof ApplicationTypeNoExistException){
+            return "应用类型不存在";
+        } else if (e instanceof TestTypeNoExistException){
+            return "服务类型不存在";
+        } else if (e instanceof ApplicationTypeToTestTypeNoExistException){
+            return "应用类型对应的测试类型不存在";
+        } else if (e instanceof FieldNoExistException){
+            return "领域不存在";
+        } else if (e instanceof ResourceNoExistException){
+            return "资源不存在";
         } else
             return e.getMessage();
     }
@@ -56,7 +70,7 @@ public class ExceptionAdvice {
     @ResponseBody
     public String handleSystemException(Exception e){
         log.error("System Error: "+e.getMessage(), e);
-        return "There is a system error: "+e.getMessage();
+        return "系统异常 " + e.getMessage();
     }
 
     @ExceptionHandler(Excel2ProjectException.class)

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

@@ -0,0 +1,15 @@
+package com.mooctest.crowd.site.data;
+
+import lombok.Data;
+
+/**
+ * @author guochao
+ * @date 2020-06-23 17:09
+ */
+@Data
+public class ColumnFilter {
+    private String field;
+    private String value;
+    private String type;
+    private String[] exclude;
+}

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

@@ -0,0 +1,12 @@
+package com.mooctest.crowd.site.data.dto;
+
+import com.mooctest.crowd.site.data.vo.BankCardVO;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class BankCardDTO {
+    private BankCardVO bankCardVO;
+    private List<BankCardVO> bankCardVOList;
+}

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

@@ -1,34 +1,47 @@
 package com.mooctest.crowd.site.data.dto;
 
-import com.mooctest.crowd.domain.domainobject.CrowdTestProject;
-import com.mooctest.crowd.domain.domainobject.CrowdTestTask;
+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;
 import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * @author:xx
  * @date:2020/6/20
  * @description:众测广场首页所有数据
  */
-
-
 @Data
 public class CrowdTestSquareIndexDTO {
-
     //众测项目
-    private List<CrowdTestProjectPO> cowdTestProjects;
-
+    private List<CrowdTestProjectVO> crowdTestProjectVOs;
     //众测任务
-    private List<CrowdTestTaskPO>  crowdTestTaskPOS;
-
-
-
-
-
-
-
-
+    private List<CrowdTaskVO> crowdTestTaskVOS;
+    //热门项目
+    private List<CrowdTestProjectVO> hotCrowdTestProjectVOs;
+    //热门任务
+    private List<CrowdTaskVO> hotCrowdTaskVOs;
+
+
+    /**
+     * 初始化热门任务 ，热门项目
+     */
+    public void initHotTaskAndProject(){
+        List<CrowdTestProjectVO> projectVOS = this.crowdTestProjectVOs.stream().sorted(Comparator.comparing(CrowdTestProjectVO::getCreateTime).reversed()).collect(Collectors.toList());
+        this.crowdTestProjectVOs = projectVOS;
+        //根据参与人数和创建时间进行排序
+        List<CrowdTestProjectVO> list1 = projectVOS.stream().sorted(Comparator.comparing(CrowdTestProjectVO::getJoinCount).reversed()).collect(Collectors.toList());
+        //截取前七条
+        this.hotCrowdTestProjectVOs = 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.hotCrowdTaskVOs = tasklist2.subList(0, 7);
+    }
 }

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

@@ -13,7 +13,7 @@ import java.util.List;
  * @Date: 2019.7.15 20:15
  */
 @Data
-public class IndexDTO {
+public class IndexDTO{
     private List<String> imgList;
     private List<CrowdTaskVO> hotTaskList;
     private List<EvolutionAgencyVO> agencyRank;

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

@@ -0,0 +1,28 @@
+package com.mooctest.crowd.site.data.dto;
+
+import com.mooctest.crowd.site.data.vo.*;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * @Author: xuexb
+ * @Date: 2019.7.15 20:15
+ */
+@Data
+public class IndexInfoDTO {
+
+    private List<TestTypeVO> testTypeList;
+    private List<ApplicationTypeVO> applicationTypeList;
+    private List<ApplicationTypeVO> applicationTypeRank;
+    private List<EvolutionAgencyVO> agencyRank;
+    private List<UserVO> userRank;
+    private List<FieldVO> fieldList;
+    private List<CompetitionVO> competitionList;
+    private List<ResourceVO> resourceList;
+    private List<EvolutionAgencyVO> residentAgencyList;
+    private List<PartnerVO> partnerList;
+//    private List<String> imgList;
+//    private List<CrowdTaskVO> hotTaskList;
+//    private List<PieChartDataVO> systemStatistics;
+}

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

@@ -0,0 +1,16 @@
+package com.mooctest.crowd.site.data.dto;
+
+import com.mooctest.crowd.site.data.vo.AgencyVO;
+import com.mooctest.crowd.site.data.vo.CrowdProjectVO;
+import com.mooctest.crowd.site.data.vo.ExpertVO;
+import com.mooctest.crowd.site.data.vo.ResourceVO;
+import lombok.Data;
+import org.springframework.data.domain.Page;
+
+@Data
+public class IndexPageDTO {
+    Page<CrowdProjectVO> crowdProjectPage;
+    Page<AgencyVO> agencyPage;
+    Page<ResourceVO> resourcePage;
+    Page<ExpertVO> expertPage;
+}