Merge branch 'Test' into 'master'

Test

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

core/pom.xml

@@ -34,6 +34,12 @@
             <artifactId>powermock-api-mockito</artifactId>
             <version>1.6.4</version>
         </dependency>
+        <!--定位-->
+        <dependency>
+            <groupId>org.jsoup</groupId>
+            <artifactId>jsoup</artifactId>
+            <version>1.7.3</version>
+        </dependency>
 
         <dependency>
             <groupId>org.projectlombok</groupId>
@@ -136,6 +142,15 @@
             <artifactId>commons-fileupload</artifactId>
             <version>1.4</version>
         </dependency>
+
+      <dependency>
+        <groupId>com.alibaba</groupId>
+        <artifactId>fastjson</artifactId>
+        <version>1.2.58</version>
+    </dependency>
+
+
+
     </dependencies>
     <build>
         <plugins>

core/src/main/java/com/mooctest/crowd/domain/Application.java

@@ -7,7 +7,6 @@ import org.springframework.boot.web.servlet.ServletComponentScan;
 import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.scheduling.annotation.EnableAsync;
 import org.springframework.scheduling.annotation.EnableScheduling;
-
 @SpringBootApplication
 @EnableConfigurationProperties
 @ServletComponentScan

core/src/main/java/com/mooctest/crowd/domain/IpAddress/AddressUtils.java

@@ -0,0 +1,218 @@
+package com.mooctest.crowd.domain.IpAddress;
+
+import com.alibaba.fastjson.JSONObject;
+import lombok.extern.slf4j.Slf4j;
+import org.jsoup.Connection;
+import org.jsoup.Jsoup;
+
+
+import java.io.*;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+/**
+ *  根据IP地址获取本地定位 
+ */
+@Slf4j
+/**
+  * @author: xuxuan
+  * @date: 2020/7/10
+  * @description:
+  */
+public class AddressUtils {
+
+    /**
+     * 得到本机的外网ip，出现异常时返回空串"" 
+     * @return
+     */
+    public static String getPublicIP() {
+        String ip = "";
+
+        org.jsoup.nodes.Document doc = null;
+        Connection con = null;
+
+        con = Jsoup.connect("http://www.ip138.com/ip2city.asp").timeout(10000);
+
+        try {
+            doc = con.get();
+
+            // 获得包含本机ip的文本串：您的IP是：[xxx.xxx.xxx.xxx] 
+            org.jsoup.select.Elements els = doc.body().select("center");
+            for (org.jsoup.nodes.Element el : els) {
+                ip = el.text();
+            }
+
+            // 从文本串过滤出ip，用正则表达式将非数字和.替换成空串""  
+            ip = ip.replaceAll("[^0-9.]", "");
+        } catch (IOException e) {
+            e.printStackTrace();
+            return ip;
+        }
+        return ip;
+    }
+
+    /**
+     * @param urlStr
+     *            请求的地址
+     * @param content
+     *            请求的参数 格式为：name=xxx&pwd=xxx
+     * @param encoding
+     *            服务器端请求编码。如GBK,UTF-8等
+     * @return
+     */
+    private String getResult(String urlStr, String content, String encoding) {
+        URL url = null;
+        HttpURLConnection connection = null;
+        try {
+            url = new URL(urlStr);
+            connection = (HttpURLConnection) url.openConnection();// 新建连接实例
+            connection.setConnectTimeout(2000);// 设置连接超时时间，单位毫秒，如果运行时出现超时，可自行增大超时时间，如加到10000
+            connection.setReadTimeout(2000);// 设置读取数据超时时间，单位毫秒
+            connection.setDoOutput(true);// 是否打开输出流 true|false
+            connection.setDoInput(true);// 是否打开输入流true|false
+            connection.setRequestMethod("POST");// 提交方法POST|GET
+            connection.setUseCaches(false);// 是否缓存true|false
+            connection.connect();// 打开连接端口
+            DataOutputStream out = new DataOutputStream(connection
+                    .getOutputStream());// 打开输出流往对端服务器写数据
+            out.writeBytes(content);// 写数据
+            out.flush();// 刷新
+            out.close();// 关闭输出流
+            BufferedReader reader = new BufferedReader(new InputStreamReader(
+                    connection.getInputStream(), encoding));// 往对端写完数据对端服务器返回数据
+            // ,以BufferedReader流来读取
+            StringBuffer buffer = new StringBuffer();
+            String line = "";
+            while ((line = reader.readLine()) != null) {
+                buffer.append(line);
+            }
+            reader.close();
+            return buffer.toString();
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+            if (connection != null) {
+                connection.disconnect();// 关闭连接
+            }
+        }
+        return null;
+    }
+
+    /**
+     * unicode 转换成 中文     *
+     * @param theString
+     * @return
+     */
+    public static String decodeUnicode(String theString) {
+        char aChar;
+        int len = theString.length();
+        StringBuffer outBuffer = new StringBuffer(len);
+        for (int x = 0; x < len;) {
+            aChar = theString.charAt(x++);
+            if (aChar == '\\') {
+                aChar = theString.charAt(x++);
+                if (aChar == 'u') {
+                    int value = 0;
+                    for (int i = 0; i < 4; i++) {
+                        aChar = theString.charAt(x++);
+                        switch (aChar) {
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                                value = (value << 4) + aChar - '0';
+                                break;
+                            case 'a':
+                            case 'b':
+                            case 'c':
+                            case 'd':
+                            case 'e':
+                            case 'f':
+                                value = (value << 4) + 10 + aChar - 'a';
+                                break;
+                            case 'A':
+                            case 'B':
+                            case 'C':
+                            case 'D':
+                            case 'E':
+                            case 'F':
+                                value = (value << 4) + 10 + aChar - 'A';
+                                break;
+                            default:
+                                throw new IllegalArgumentException(
+                                        "Malformed      encoding.");
+                        }
+                    }
+                    outBuffer.append((char) value);
+                } else {
+                    if (aChar == 't') {
+                        aChar = '\t';
+                    } else if (aChar == 'r') {
+                        aChar = '\r';
+                    } else if (aChar == 'n') {
+                        aChar = '\n';
+                    } else if (aChar == 'f') {
+                        aChar = '\f';
+                    }
+                    outBuffer.append(aChar);
+                }
+            } else {
+                outBuffer.append(aChar);
+            }
+        }
+        return outBuffer.toString();
+    }
+
+    /**
+     *
+     * @param content
+     *            请求的参数 格式为：name=xxx&pwd=xxx
+     * @param encodingString
+     *            服务器端请求编码。如GBK,UTF-8等
+     * @return
+     * @throws UnsupportedEncodingException
+     */
+    public Area getAddresses(String content, String encodingString)
+            throws UnsupportedEncodingException {
+        // 这里调用PC-Online的接口
+        String urlStr = "http://whois.pconline.com.cn/ipJson.jsp?ip="+content+"&json=true";
+        log.info("urlStr=========="+urlStr);
+        // 从http://whois.pconline.com.cn取得IP所在的省市区信息
+        String returnStr = this.getResult(urlStr, content, encodingString);
+        log.info("返回数据================="+returnStr);
+        JSONObject jsonObject = JSONObject.parseObject(returnStr);
+        String  address=jsonObject.getString("addr");
+        Area  area=new Area(jsonObject.getString("pro"),jsonObject.getString("city"));
+        return  area;
+
+
+
+
+
+    }
+
+    // 这里我们举的例子是获取所在地省份名称，也可以改变上边getAddress的返回值，获取具体的市县名
+    public static Area getProvinceName(String ip){
+        AddressUtils addressUtils = new AddressUtils();
+
+        Area area = null;
+        try {
+            area = addressUtils.getAddresses("ip="+ip, "GBK");
+        } catch (UnsupportedEncodingException e) {
+            e.printStackTrace();
+        }
+        return area;
+    }
+
+    //Main,输出省名
+    public static void main(String[] args) throws Exception {
+        Area address= getProvinceName("");
+        System.out.println(address);
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/IpAddress/Area.java

@@ -0,0 +1,24 @@
+package com.mooctest.crowd.domain.IpAddress;
+
+import lombok.Data;
+
+/**
+ * @author:xx
+ * @date:2020/7/10
+ * @description:
+ */
+
+@Data
+public class Area {
+
+    private  String pro;//省
+    private  String city;
+
+
+
+    public  Area(String pro,String city){
+        this.pro=pro;
+        this.city=city;
+    }
+
+}

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

@@ -15,11 +15,7 @@ import org.springframework.web.bind.annotation.RestController;
 @RequestMapping("/project/")
 public class CrowdTestProjectController {
 
-    @Autowired
-    private CrowdTestProjectRepo crowdTestProjectRepo;
 
-    @Autowired
-    private UserRepo userRepo;
 
 //    @RequestMapping(value = "findById/{crowdTestProjectId}", method = RequestMethod.GET)
 //    public String getCrowdTestProjectById(@PathVariable("crowdTestProjectId") Long crowdTestProjectId){
@@ -201,7 +197,7 @@ public class CrowdTestProjectController {
 //        crowdTestProject.setName(projectName);
 //        crowdTestProject.setProjectDistributionTypeId(1L);
 //        crowdTestProject.setLinkMan("郭超");
-//        crowdTestProject.setPlatform("IOS");
+//        crowdTestProject.setApplicationType("IOS");
 //        crowdTestProject.setType("安卓测试");
 //        crowdTestProject.setDescription("测试内容");
 //        crowdTestProject.setLinkManMobile("13657094936");
@@ -550,7 +546,7 @@ public class CrowdTestProjectController {
 //    /**
 //     * 匹配平台类型 0,1,2 任意  ^[0-2](([,][0-2])?([,][0-2])?)$
 //     */
-//    private boolean isPlatform(String str)throws PatternSyntaxException {
+//    private boolean isApplicationType(String str)throws PatternSyntaxException {
 //        String regExp = "^[0-2](([,][0-2])?([,][0-2])?)$";
 //        Pattern p = Pattern.compile(regExp);
 //        Matcher m = p.matcher(str);

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,28 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.ApplicationTypePO;
+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;
+import java.util.List;
+import java.util.Optional;
+
+@Transactional
+public interface ApplicationTypeDao extends CrudRepository<ApplicationTypePO, Long>,PagingAndSortingRepository<ApplicationTypePO, Long>, JpaRepository<ApplicationTypePO, Long>,JpaSpecificationExecutor<ApplicationTypePO> {
+
+    Optional<ApplicationTypePO> findByCode(String code);
+
+    Optional<ApplicationTypePO> findByName(String name);
+
+    Optional<ApplicationTypePO> findById(Long id);
+
+    List<ApplicationTypePO> findAll();
+
+    Page<ApplicationTypePO> findAll(Specification<ApplicationTypePO> spec , Pageable pageable);
+}

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,23 @@
+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/CompetitionsDao.java

@@ -0,0 +1,18 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.CompetitionPO;
+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 CompetitionsDao extends CrudRepository<CompetitionPO, Long>,PagingAndSortingRepository<CompetitionPO, Long>, JpaRepository<CompetitionPO, Long>,JpaSpecificationExecutor<CompetitionPO> {
+
+    Page<CompetitionPO> findAll(Specification<CompetitionPO> spec , 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.RankInfo;
+import com.mooctest.crowd.domain.model.RankInfos;
+import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.CrudRepository;
+import org.springframework.data.repository.PagingAndSortingRepository;
 
 import javax.transaction.Transactional;
 import java.util.List;
@@ -16,12 +21,27 @@ 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);
+
+    @Query(value = "SELECT CTP_ID,CTP_CODE,CTP_NAME," +
+            "CTP_U_ID,CTP_RM_ID,CTP_PDT_ID,CTP_FIELD_TYPE,CTP_PLATFORM,CTP_TYPE,CTP_LINK_MAN," +
+            "CTP_Link_MAN_MOBILE,CTP_TYPE,CTP_DESCRIPTION,CTP_PROJECT_FILE,CTP_REQUIREMENT_FILE,CTP_DISTRIBUTION_TYPE,CTP_DISTRIBUTION_PROVINCE,CTP_DISTRIBUTION_CITY," +
+            "CTP_QUOTED_PRICE,CTP_REST_PRICE,CTP_FIXED_PRICE,CTP_STATUS,CTP_DEAD_LINE,CTP_END_TIME,CTP_IS_DELETED,CTP_JOIN_COUNT,CTP_CREATE_TIME FROM crowd_test_project ORDER BY CTP_CREATE_TIME DESC", nativeQuery = true)
+    List<CrowdTestProjectPO> findMoreHotProjects();
+
+
+    @Query(value = "SELECT CTP_ID,CTP_CODE,CTP_NAME," +
+            "CTP_U_ID,CTP_RM_ID,CTP_PDT_ID,CTP_FIELD_TYPE,CTP_PLATFORM,CTP_TYPE,CTP_LINK_MAN," +
+            "CTP_Link_MAN_MOBILE,CTP_TYPE,CTP_DESCRIPTION,CTP_PROJECT_FILE,CTP_REQUIREMENT_FILE,CTP_DISTRIBUTION_TYPE,CTP_DISTRIBUTION_PROVINCE,CTP_DISTRIBUTION_CITY," +
+            "CTP_QUOTED_PRICE,CTP_REST_PRICE,CTP_FIXED_PRICE,CTP_STATUS,CTP_DEAD_LINE,CTP_END_TIME,CTP_IS_DELETED,CTP_JOIN_COUNT,CTP_CREATE_TIME FROM crowd_test_project p WHERE CTP_STATUS !=4 ORDER BY CTP_CREATE_TIME DESC", nativeQuery = true)
     List<CrowdTestProjectPO> findAll();
 
+    Page<CrowdTestProjectPO> findAll(Specification<CrowdTestProjectPO> spec, Pageable pageable);
+
     CrowdTestProjectPO findByIdAndIsDeleted(Long id, int isDeleted);
 
     CrowdTestProjectPO findByCodeAndIsDeleted(String code, int isDeleted);
@@ -39,6 +59,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.applicationType),0L ,p.applicationType) FROM CrowdTestProjectPO p where p.status>1 GROUP BY p.applicationType ORDER BY COUNT(p.applicationType) DESC")
+    List<RankInfos> findTotalCountOfApplicationType(Pageable pageable);
+
     @Override
     void delete(CrowdTestProjectPO crowdTestProjectPO);
 
@@ -47,4 +74,5 @@ public interface CrowdTestProjectDao extends CrudRepository<CrowdTestProjectPO,
 
     @Override
     <S extends CrowdTestProjectPO> S save(S s);
+
 }

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,28 @@ 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> {
+
+
+ @Query(value = "select CTT_ID,CTT_CODE,CTT_NAME,CTT_CTP_CODE,CTT_EA_ID," +
+         "CTT_TYPE,CTT_DISTRIBUTION_TYPE,CTT_DISTRIBUTION_PROVINCE,CTT_DISTRIBUTION_CITY," +
+         "CTT_REQUIREMENT_FILE,CTT_DESCRIPTION,CTT_QUOTED_PRICE,CTT_FIXED_PRICE," +
+         "CTT_STATUS,CTT_FULL_STATUS,CTT_DEAD_LINE,CTT_IS_DELETED,CTT_PARTICIPANT_COUNT,CTT_ACCEPTED_COUNT,CTT_PARTICIPANT_HAS_COMMITTED_COUNT,CTT_CREATE_TIME,CTT_END_TIME FROM  crowd_test_task t where CTT_STATUS=1 or CTT_STATUS=2 ORDER BY CTT_CREATE_TIME DESC",nativeQuery = true)
+  List<CrowdTestTaskPO> findAll();
+
+
+
+
+
+ @Query(value = "select CTT_ID,CTT_CODE,CTT_NAME,CTT_CTP_CODE,CTT_EA_ID," +
+         "CTT_TYPE,CTT_DISTRIBUTION_TYPE,CTT_DISTRIBUTION_PROVINCE,CTT_DISTRIBUTION_CITY," +
+         "CTT_REQUIREMENT_FILE,CTT_DESCRIPTION,CTT_QUOTED_PRICE,CTT_FIXED_PRICE," +
+         "CTT_STATUS,CTT_FULL_STATUS,CTT_DEAD_LINE,CTT_IS_DELETED,CTT_PARTICIPANT_COUNT,CTT_ACCEPTED_COUNT,CTT_PARTICIPANT_HAS_COMMITTED_COUNT,CTT_CREATE_TIME,CTT_END_TIME FROM  crowd_test_task t ORDER BY CTT_CREATE_TIME DESC",nativeQuery = true)
+   List<CrowdTestTaskPO> findMoreHotTasks();
+
+   List<CrowdTestTaskPO>  findByNameLike(String name);
+
+    Page<CrowdTestTaskPO> findAll(Specification specification, Pageable pageable);
 
     CrowdTestTaskPO findByIdAndIsDeleted(Long id, int isDeleted);
 
@@ -42,6 +65,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,20 @@
+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> findByName(String name);
+
+    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,30 @@
+package com.mooctest.crowd.domain.dao;
+
+import com.mooctest.crowd.domain.model.CompetitionPO;
+import com.mooctest.crowd.domain.model.ResourcePO;
+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;
+import java.util.Optional;
+
+@Transactional
+public interface ResourceDao extends CrudRepository<ResourcePO, Long>, JpaSpecificationExecutor<ResourcePO>,PagingAndSortingRepository<ResourcePO, Long>,JpaRepository<ResourcePO, Long> {
+
+    Optional<ResourcePO> findByCode(String code);
+
+    Optional<ResourcePO> findById(Long id);
+
+    List<ResourcePO> findAll();
+
+    Page<ResourcePO> findAll(Specification<ResourcePO> spec , Pageable pageable);
+
+    List<ResourcePO> findByNameLike(String name);
+}

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

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

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,20 @@
+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> findByName(String name);
+    
+    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,19 @@
+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;
+    private Long count;
+}

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,24 @@
+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 unit;
+    private String image;
+    private int isDeleted;
+}

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

@@ -15,25 +15,27 @@ import java.util.Optional;
  */
 @Data
 public class CrowdTestProject {
-
     private Long id;
     private String name;
     private String code;
     private Long userId;
     private Long regionalManagerId;
     private Long projectDistributionTypeId;
-    private String platform;
+    private String fieldType;
+    private String applicationType;
+    private String type;
     private String linkMan;
     private String linkManMobile;
-    private String type;
     private String description;
     private String projectFile;
     private String requirementFile;
     private String distributionProvince;
     private String distributionCity;
+    private String valuationStandard;
     private Double quotedPrice;
     private Double fixedPrice;
     private Double restPrice;
+    private String entrustUnit;
     private int status;
     private Timestamp deadTime;
     private Timestamp endTime;
@@ -44,44 +46,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 +206,7 @@ public class CrowdTestProject {
 
     /**
      * 删除项目报告（区域管理员）
+     *
      * @return
      */
 //    public CrowdTestProject removeCrowdTestProjectReport(String crowdTestProjectReportCode,User user) {
@@ -252,17 +231,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 +253,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 +278,7 @@ public class CrowdTestProject {
 
     /**
      * 创建测试项目（普通用户）
+     *
      * @return
      */
     public CrowdTestProject createCrowdTestProject(User user) {
@@ -318,22 +297,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 +321,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 +379,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 +414,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 +449,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 +464,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 +477,6 @@ public class CrowdTestProject {
     }
 
 
-
     /**
      * 创建测试报告（测评机构）
      * @param crowdTestTaskCode
@@ -573,32 +556,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 +600,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 +628,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 +669,7 @@ public class CrowdTestProject {
 
     /**
      * 结束项目（项目发起者）
+     *
      * @return
      */
     public CrowdTestProject finishCrowdTestProject(User user) {
@@ -691,13 +678,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 +692,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/EvaluationAgency.java

@@ -1,6 +1,7 @@
 package com.mooctest.crowd.domain.domainobject;
 
 import com.mooctest.crowd.domain.exception.BaseException;
+import com.mooctest.crowd.domain.model.EvaluationAgencyPO;
 import lombok.Data;
 import org.springframework.beans.BeanUtils;
 
@@ -50,6 +51,24 @@ public class EvaluationAgency {
                 '}';
     }
 
+    public EvaluationAgency() {
+
+    }
+
+
+    public EvaluationAgency(EvaluationAgencyPO evaluationAgencyPO) {
+        BeanUtils.copyProperties(evaluationAgencyPO, this);
+
+
+    }
+
+
+    public EvaluationAgency EvaluationAgency(EvaluationAgencyPO evaluationAgencyPO) {
+        BeanUtils.copyProperties(evaluationAgencyPO, this);
+        return this;
+    }
+
+
     public EvaluationAgency applyAuthentication(Long userId) {
         this.setUserId(userId);
         this.setIsAuthentication(AuthenticationStatus.isAuthenIng);
@@ -61,11 +80,11 @@ public class EvaluationAgency {
     }
 
     public EvaluationAgency 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("");
@@ -75,14 +94,14 @@ public class EvaluationAgency {
     }
 
     public EvaluationAgency 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()));
@@ -94,7 +113,7 @@ public class EvaluationAgency {
     public EvaluationAgency updateAuthInfo(EvaluationAgency 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.setIsAuthentication(AuthenticationStatus.isAuthenIng);

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 IDCardPositivePhoto;//身份证正面照片
+    private String IDCardBackPhoto;//身份证反面照片
+    private String sex;
     private String bankAccount;
     private String address;
     private int isDeleted;
@@ -25,25 +28,27 @@ public class PersonalAuthentication {
     private String explain;
     private Timestamp applyTime;
     private Timestamp checkTime;
+    private Timestamp IDCardDeadTime;//身份证过期时间
+
+    /**
+     * 转换类型
+     * @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;
 
-    @Override
-    public String toString() {
-        return "PersonalAuth{" +
-                "id=" + id +
-                ", userId=" + userId +
-                ", realName='" + realName + '\'' +
-                ", IDCard='" + IDCard + '\'' +
-                ", IDCardPhoto='" + IDCardPhoto + '\'' +
-                ", bankAccount='" + bankAccount + '\'' +
-                ", address='" + address + '\'' +
-                ", isAuthentication='" + isAuthentication + '\'' +
-                ", explain=" + explain +
-                ", applyTime='" + applyTime + '\'' +
-                ", checkTime='" + checkTime + '\'' +
-                '}';
     }
 
-    public PersonalAuthentication applyAuthentication(Long userId) {
+
+
+    public PersonalAuthentication applyAuthentication(Long userId){
         this.setUserId(userId);
         this.setIsAuthentication(AuthenticationStatus.isAuthenIng);
         this.setIsDeleted(DeletedStatus.isNotDeleted);

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,28 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+
+import java.sql.Timestamp;
+
+/**
+ * @author guochao
+ * @date 2019/7/6 17:54
+ */
+@Data
+public class Resource {
+    private Long id;
+    private String code;
+    private String name;
+    private String type;
+    private int quantity;
+    private String photoUrl;
+    private String description;
+    private String scene;
+    private String unitWork;
+    private String standard;
+    private String unit;
+    private int state;
+    private Timestamp startTime;
+    private String personnel;
+    private String remarks;
+}

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

@@ -0,0 +1,9 @@
+package com.mooctest.crowd.domain.domainobject;
+
+
+public class ResourceStatus {
+    public static final int R_FREE = 0;  //空闲
+    public static final int R_OCCUPY = 1; //占用
+    public static final int R_USABLE = 2; //可用
+    public static final int R_FAULT = 4; //故障
+}

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

@@ -0,0 +1,18 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import lombok.Data;
+
+import java.sql.Date;
+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/domainobject/User.java

@@ -2,7 +2,11 @@ package com.mooctest.crowd.domain.domainobject;
 
 import com.mooctest.crowd.domain.exception.BaseException;
 import com.mooctest.crowd.domain.exception.SystemAdministratorException;
+import com.mooctest.crowd.domain.model.UserPO;
+import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.springframework.beans.BeanUtils;
 
 import java.sql.Timestamp;
 import java.util.List;
@@ -12,6 +16,7 @@ import java.util.List;
  * @date 2019/7/6 18:17
  */
 @Data
+
 public class User {
     private Long id;
     private String name;
@@ -34,6 +39,10 @@ public class User {
     private SystemAdministratorToUser systemAdministratorToUser;
     private List<Role> roleList;
 
+
+    public User() {
+    }
+
     @Override
     public String toString() {
         return "User{" +
@@ -59,6 +68,13 @@ public class User {
                 '}';
     }
 
+
+    public   User(UserPO userPO){
+        BeanUtils.copyProperties(userPO,this);
+    }
+
+
+
     /**
      * 机构认证——申请
      * @param evaluationAgency

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/factory/CrowdTestProjectFactory.java

@@ -13,17 +13,23 @@ import java.sql.Timestamp;
 @Component
 public class CrowdTestProjectFactory {
 
+//    @Value("${green.manager.id}")
+//    private static String regionalManagerId;
+//
+//    @Value("${green.agency.id}")
+//    private static String agencyId;
+
     public static CrowdTestProject createCrowdTestProject() {
         return new CrowdTestProject();
     }
 
-    public static CrowdTestProject defaulstCrowdTestProject() {
+    public static CrowdTestProject defaultCrowdTestProject() {
         CrowdTestProject project = new CrowdTestProject();
         project.setStatus(CrowdTestProjectStatus.HAS_FINISHED);
         project.setIsDeleted(0);
         project.setProjectDistributionTypeId(1L);
-        project.setDistributionProvince("江苏");
-        project.setDistributionCity("南京");
+        project.setDistributionProvince("江苏省");
+        project.setDistributionCity("南京市");
         project.setRegionalManagerId(99222L);
         project.setUserId(1L);
         project.setProjectFile("");
@@ -38,7 +44,7 @@ public class CrowdTestProjectFactory {
     public static CrowdTestTask defaultFinishedCrowdTask() {
         CrowdTestTask task = new CrowdTestTask();
         task.setStatus(CrowdTestTaskStatus.HAS_FINISHED);
-        task.setEvaluationAgencyId(1l);
+        task.setEvaluationAgencyId(20471L);
         task.setDistributionType(0l);
         return task;
     }
@@ -50,6 +56,13 @@ public class CrowdTestProjectFactory {
         return report;
     }
 
+    public static CrowdTestReport defaultTaskReport() {
+        CrowdTestReport report = new CrowdTestReport();
+        report.setScope(1);
+        report.setIsDeleted(0);
+        return report;
+    }
+
     public static CrowdTestTask defaultTask() {
         CrowdTestTask task = new CrowdTestTask();
         return task;

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

@@ -0,0 +1,30 @@
+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;
+
+    @Column(name="AT_COUNT")
+    private Long count;
+}

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,32 @@
+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_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,37 @@
+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_UNIT")
+    private String unit;
+
+    @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,8 +35,14 @@ 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;
+    private String applicationType;
+
+    @Column(name = "CTP_TYPE")
+    private String type;
 
     @Column(name = "CTP_LINK_MAN")
     private String linkMan;
@@ -44,9 +50,6 @@ public class CrowdTestProjectPO implements Serializable {
     @Column(name = "CTP_Link_MAN_MOBILE")
     private String linkManMobile;
 
-    @Column(name = "CTP_TYPE")
-    private String type;
-
     @Column(name = "CTP_DESCRIPTION")
     private String description;
 
@@ -62,6 +65,9 @@ public class CrowdTestProjectPO implements Serializable {
     @Column(name = "CTP_REQUIREMENT_FILE")
     private String requirementFile;
 
+    @Column(name = "CTP_VALUATION_STANDARD")
+    private String valuationStandard;
+
     @Column(name = "CTP_QUOTED_PRICE")
     private Double quotedPrice;
 
@@ -72,6 +78,9 @@ public class CrowdTestProjectPO implements Serializable {
     @Column(name = "CTP_REST_PRICE")
     private Double restPrice;
 
+    @Column(name = "CTP_ENTRUST_UNIT")
+    private String entrustUnit;
+
     @Column(name = "CTP_STATUS")
     private int status;
 
@@ -89,32 +98,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,18 @@ public class PersonalAuthenticationPO {
 
     @Column(name = "PA_CHECK_TIME")
     private Timestamp checkTime;
+
+    @Column(name = "PA_ID_CARD_POS_PHOTO")
+    private String  idCardPositivePhoto;//身份证正面照片
+
+
+    @Column(name = "PA_ID_CARD_BACK_PHOTO")
+    private String  idCardBackPhoto;//身份证正面照片
+
+
+    @Column(name = "PA_EXPIRE_TIME")
+    private Timestamp  IDCardDeadTime;
+
+
+
 }

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,61 @@
+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 = "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;
+
+    @Column(name = "R_RT_CODE")
+    private String type;
+
+    @Column(name = "R_QUANTITY")
+    private int quantity;
+
+    @Column(name = "R_PHOTO_URL")
+    private String photoUrl;
+
+    @Column(name = "R_DESCRIPTION")
+    private String description;
+
+    @Column(name = "R_SCENE")
+    private String scene;
+
+    @Column(name = "R_UNIT_WORK")
+    private String unitWork;
+
+    @Column(name = "R_STANDARD")
+    private String standard;
+
+    @Column(name = "R_UNIT")
+    private String unit;
+
+    @Column(name = "R_STATE")
+    private int state;
+
+    @Column(name = "R_DATE")
+    private Timestamp startTime;
+
+    @Column(name = "R_PERSONNEL")
+    private String personnel;
+
+    @Column(name = "R_REMARKS")
+    private String remarks;
+}

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

@@ -0,0 +1,24 @@
+package com.mooctest.crowd.domain.model;
+
+import lombok.Data;
+
+import javax.persistence.*;
+
+/**
+ * @author hanyuwei
+ * @date 2020/7/7
+ */
+@Data
+@Entity(name = "resource_type")
+public class ResourceTypePO {
+    @Id
+    @Column(name = "RT_ID")
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "RT_CODE")
+    private String code;
+
+    @Column(name = "RT_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,16 @@ public class UserPO {
     @Column(name = "U_CREATE_TIME")
     private Timestamp createTime;
 
+    @Column(name="U_BIRTHDAY")
+    private Date birthday;
+
+    @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/ApplicationTypeRepo.java

@@ -0,0 +1,49 @@
+package com.mooctest.crowd.domain.repository;
+
+import com.mooctest.crowd.domain.dao.ApplicationTypeDao;
+import com.mooctest.crowd.domain.domainobject.ApplicationType;
+import com.mooctest.crowd.domain.model.ApplicationTypePO;
+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 ApplicationTypeRepo implements IApplicationTypeRepo{
+
+
+    @Autowired
+    private ApplicationTypeDao applicationTypeDao;
+
+    @Override
+    public Page<ApplicationType> getHotTesting(Pageable pageable,String keyword) {
+        Specifications<ApplicationTypePO> where =  Specifications.where(getArticlesByIsNotDeleted(keyword));
+        return applicationTypeDao.findAll(where,pageable).map(ApplicationTypePO->Converter.convert(ApplicationType.class, ApplicationTypePO));
+    }
+    private Specification<ApplicationTypePO> getArticlesByIsNotDeleted(String keyword) {
+        return new Specification<ApplicationTypePO>() {
+            @Override
+            public Predicate toPredicate(Root<ApplicationTypePO> 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/CommonRepo.java

@@ -0,0 +1,218 @@
+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;
+
+    @Autowired
+    private  CompetitionsDao competitionsDao;
+
+    @Autowired
+    private CrowdTestProjectDao crowdTestProjectDao;
+
+    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 Page<Competition> findAllCompetition(Pageable pageable,String keyword) {
+        Specifications<CompetitionPO> where =  Specifications.where(getArticlesByIsNotDeleted(keyword));
+        return  competitionsDao.findAll(where,pageable).map(CompetitionPO -> Converter.convert(Competition.class, CompetitionPO));
+    }
+    private Specification<CompetitionPO> getArticlesByIsNotDeleted(String keyword) {
+        return new Specification<CompetitionPO>() {
+            @Override
+            public Predicate toPredicate(Root<CompetitionPO> a, CriteriaQuery<?> q, CriteriaBuilder cb) {
+                Predicate predicate = cb.conjunction();
+                if(keyword != null) {
+                    predicate.getExpressions().add(
+                            cb.like(a.<String>get("name"), "%" + StringUtils.trim(keyword) + "%")
+                    );
+                }
+                return predicate;
+            }
+        };
+    }
+    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;
+            }
+        };
+    }
+
+    public Page<CrowdTestProject> getProjectList(Pageable pageable, String code){
+        Specifications<CrowdTestProjectPO> where =  Specifications.where(getCode(code));
+        return crowdTestProjectDao.findAll(where, pageable).map(crowdTestProjectPO -> Converter.convert(CrowdTestProject.class, crowdTestProjectPO));
+    }
+    private Specification<CrowdTestProjectPO> getCode(String code) {
+        return new Specification<CrowdTestProjectPO>() {
+            @Override
+            public Predicate toPredicate(Root<CrowdTestProjectPO> a, CriteriaQuery<?> q, CriteriaBuilder cb) {
+                Predicate predicate = cb.conjunction();
+                if(code != null) {
+                    predicate.getExpressions().add(
+                            cb.equal(a.get("applicationType"), code)
+                    );
+                }
+                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;
@@ -38,18 +47,54 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
     @Autowired
     private UserDao userDao;
 
+    @Autowired
+    private ApplicationTypeDao applicationTypeDao;
+
+    @Override
+    public Page<CrowdTestProjectPO> findAll(Specification specification, Pageable pageable) {
+        return crowdTestProjectDao.findAll(specification, pageable);
+    }
+
     @Override
-    public List<CrowdTestProjectPO> findAll(){
+    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 +105,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 +119,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 +136,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,13 +156,28 @@ 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);
         }
     }
 
+    @Override
+    public List<CrowdTestProject> getByProject() {
+        List<CrowdTestProject> crowdTestProjectList=new ArrayList<>();
+        List<CrowdTestProjectPO>  crowdTestProjectPO=crowdTestProjectDao.findAllByIsDeleted(DeletedStatus.isNotDeleted);
+        for(int i=0;i<crowdTestProjectPO.size();i++){
+            if (crowdTestProjectPO == null) {
+                throw new CrowdTestProjectNotExistException();
+            } else {
+                CrowdTestProject crowdTestProjectResult = getCrowdTestProjectAndTaskAndReportByCrowdTestProjectPO(crowdTestProjectPO.get(i));
+                crowdTestProjectList.add(crowdTestProjectResult);
+            }
+        }
+        return crowdTestProjectList;
+    }
+
 //    @Override
 //    public void removeCrowdTestProject(String crowdTestProjectCode){
 //        CrowdTestProject crowdTestProject = getByProjectCode(crowdTestProjectCode);
@@ -126,7 +186,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 +237,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 +250,7 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
 
     /**
      * 通过项目信息获取项目-任务-报告信息
+     *
      * @param crowdTestProjectPO
      * @return
      */
@@ -197,7 +259,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 +267,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 +288,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 +298,7 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
 
     /**
      * 通过任务code和人员id获取报告列表
+     *
      * @param taskCode
      * @param userId
      * @return
@@ -247,13 +310,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 +326,7 @@ public class CrowdTestProjectRepo implements ICrowdTestProjectRepo {
 
     /**
      * 根据项目列表获取项目-任务-报告信息
+     *
      * @param crowdTestProjectPOList
      * @return
      */
@@ -274,15 +339,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/IApplicationTypeRepo.java

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

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;
 
@@ -25,6 +33,8 @@ public interface ICrowdTestProjectRepo {
 
     void saveCrowdTestProject(CrowdTestProject crowdTestProject);
 
+    List<CrowdTestProject> getByProject();
+
 //    void removeCrowdTestProject(String crowdTestProjectCode) throws CrowdTestProjectNotExistException;
 
 //    CrowdTestProject saveCreateCrowdTestProject(CrowdTestProject crowdTestProject);

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 title=cb.like(a.get("title"), "%" + StringUtils.trim(keyword) + "%");
+                    Predicate author=cb.like(a.get("authorList"), "%" + StringUtils.trim(keyword) + "%");
+                    predicate.getExpressions().add(cb.or(title,author));
+                }
+                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;
+            }
+        };
+    }
+}

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

@@ -46,7 +46,7 @@
 //        crowdTestProject.setRegionalManagerId(1L);
 //        crowdTestProject.setProjectDistributionTypeId(1L);
 //        crowdTestProject.setType("性能测试");
-//        crowdTestProject.setPlatform("IOS");
+//        crowdTestProject.setApplicationType("IOS");
 //        crowdTestProject.setLinkMan("郭超");
 //        crowdTestProject.setLinkManMobile("1233343443");
 //        crowdTestProject.setDescription("测试IOS应用");
@@ -330,7 +330,7 @@
 //        crowdTestProject.getRegionalManagerId();
 //        crowdTestProject.getUserId();
 //        crowdTestProject.getId();
-//        crowdTestProject.getPlatform();
+//        crowdTestProject.getApplicationType();
 //        crowdTestProject.getProjectDistributionTypeId();
 //        crowdTestProject.toString();
 //

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

@@ -31,7 +31,7 @@
 //        crowdTestProject.setRegionalManagerId(1L);
 //        crowdTestProject.setProjectDistributionTypeId(1L);
 //        crowdTestProject.setType("性能测试");
-//        crowdTestProject.setPlatform("IOS");
+//        crowdTestProject.setApplicationType("IOS");
 //        crowdTestProject.setLinkMan("郭超");
 //        crowdTestProject.setLinkManMobile("1233343443");
 //        crowdTestProject.setDescription("测试IOS应用");

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

@@ -31,7 +31,7 @@ public class CrowdTestTaskTest {
         crowdTestProject.setRegionalManagerId(1L);
         crowdTestProject.setProjectDistributionTypeId(1L);
         crowdTestProject.setType("性能测试");
-        crowdTestProject.setPlatform("IOS");
+        crowdTestProject.setApplicationType("IOS");
         crowdTestProject.setLinkMan("郭超");
         crowdTestProject.setLinkManMobile("1233343443");
         crowdTestProject.setDescription("测试IOS应用");

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

@@ -78,7 +78,7 @@ public class CrowdTestProjectRepoTest {
         crowdTestProjectPO.setCode("PROR-IOS");
         crowdTestProjectPO.setUserId(user.getId());
         crowdTestProjectPO.setType("性能测试");
-        crowdTestProjectPO.setPlatform("IOS");
+        crowdTestProjectPO.setApplicationType("IOS");
         crowdTestProjectPO.setLinkMan("郭超");
         crowdTestProjectPO.setLinkManMobile("1233343443");
         crowdTestProjectPO.setDescription("测试IOS应用");

site/pom.xml

@@ -110,6 +110,38 @@
 			<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>
+		<!-- Spring Cache -->
+<!--		<dependency>-->
+<!--			<groupId>org.springframework.boot</groupId>-->
+<!--			<artifactId>spring-boot-starter-cache</artifactId>-->
+<!--			<version>2.1.3.RELEASE</version>-->
+<!--		</dependency>-->
+		<dependency>
+			<groupId>org.yaml</groupId>
+			<artifactId>snakeyaml</artifactId>
+		</dependency>
 	</dependencies>
 
 	<build>
@@ -117,7 +149,6 @@
 			<plugin>
 				<groupId>org.springframework.boot</groupId>
 				<artifactId>spring-boot-maven-plugin</artifactId>
-
 			</plugin>
 		</plugins>
 	</build>

site/src/main/java/com/mooctest/crowd/site/SiteApplication.java

@@ -2,13 +2,15 @@ package com.mooctest.crowd.site;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.context.annotation.ComponentScan;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
 
 @SpringBootApplication(scanBasePackages = "com.mooctest.crowd")
+@EnableCaching
 public class SiteApplication {
 
 	public static void main(String[] args) {
 		SpringApplication.run(SiteApplication.class, args);
 	}
-
 }

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

@@ -7,7 +7,6 @@ import lombok.Data;
 import org.springframework.beans.BeanUtils;
 
 import javax.validation.constraints.NotNull;
-import javax.validation.constraints.Pattern;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -20,7 +19,7 @@ import java.util.stream.Collectors;
 public class ApplyAgencyAuthCommand {
     @NotNull(message = "机构名称不可为空")
     private String evaluationAgencyName;
-    @NotNull(message = "银行卡号不可为空")
+//    @NotNull(message = "银行卡号不可为空")
     private String bankAccount;
     @NotNull(message = "机构地址不可为空")
     private String address;

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,36 @@ 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;
 
-    @NotNull(message = "请填写银行卡号")
-    private String bankAccount;
+    @JsonProperty(value = "IDCardDeadTime")
+//    @NotNull(message = "请正确填写身份证过期时间")
+    private Timestamp IDCardDeadTime;
 
-    @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,10 +25,17 @@ public class CrowdTestProjectCommand {
     @NotNull(message = "项目名称不可为空")
     private String name;
 
+    @NotNull(message = "项目领域类型不可为空")
+    private String field;
+
+    @NotNull(message = "项目应用类型不可为空")
+    private String platform;
+
     @NotNull(message = "项目服务类型不可为空")
     private ArrayList<String> type;
 
-    private ArrayList<String> platform;
+//    @NotNull(message = "项目描述不可为空")
+    private String valuationStandard;
 
     @NotNull(message = "项目描述不可为空")
     private String desc;
@@ -68,9 +75,11 @@ public class CrowdTestProjectCommand {
         crowdTestProject.setName(this.name);
         crowdTestProject.setLinkMan(this.contactName);
         crowdTestProject.setLinkManMobile(this.contactPhone);
+        crowdTestProject.setFieldType(this.field);
         crowdTestProject.setType(JSONObject.toJSONString(this.type));
-        crowdTestProject.setPlatform(JSONObject.toJSONString(this.platform));
+        crowdTestProject.setApplicationType(this.platform);
         crowdTestProject.setDescription(this.desc);
+        crowdTestProject.setValuationStandard(this.valuationStandard);
         crowdTestProject.setRequirementFile(this.doc);
         crowdTestProject.setProjectFile(this.file);
         crowdTestProject.setProjectDistributionTypeId(this.resource);
@@ -83,6 +92,7 @@ public class CrowdTestProjectCommand {
         crowdTestProject.setQuotedPrice(this.budget);
         crowdTestProject.setRestPrice(this.budget);
         crowdTestProject.setFixedPrice(this.price);
+//        crowdTestProject.setCreateTime(new Timestamp(System.currentTimeMillis()));
         return crowdTestProject;
     }
 

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

@@ -29,7 +29,7 @@ public class GenerateProjectCommand {
     @NotNull(message = "项目服务类型不可为空")
     private ArrayList<String> type;
 
-    private ArrayList<String> platform;
+    private ArrayList<String> applicationType;
 
     @NotNull(message = "项目描述不可为空")
     private String description;
@@ -71,7 +71,7 @@ public class GenerateProjectCommand {
         crowdTestProject.setLinkManMobile(this.contactPhone);
         crowdTestProject.setStatus(CrowdTestProjectStatus.HAS_FINISHED);
         crowdTestProject.setType(JSONObject.toJSONString(this.type));
-        crowdTestProject.setPlatform(JSONObject.toJSONString(this.platform));
+        crowdTestProject.setApplicationType(JSONObject.toJSONString(this.applicationType));
         crowdTestProject.setDescription(this.description);
         crowdTestProject.setRequirementFile(this.doc);
         crowdTestProject.setProjectFile(this.file);