[Fix-5518]: The data analysis state count interface, projectId change to projectCode (#5837)

* fix: the data analysis state count interface, projectId change to projectCode

* fix: the data analysis state count interface, projectId change to projectCode

* fix checkstyle

* fix checkstyle

* fix: the process state count page use "projectCode"

* fix: English comments

Co-authored-by: wen-hemin <wenhemin@apache.com>

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/DataAnalysisController.java

@@ -64,14 +64,14 @@ public class DataAnalysisController extends BaseController {
      * @param loginUser login user
      * @param startDate count start date
      * @param endDate   count end date
-     * @param projectId project id
+     * @param projectCode project code
      * @return task instance count data
      */
     @ApiOperation(value = "countTaskState", notes = "COUNT_TASK_STATE_NOTES")
     @ApiImplicitParams({
-            @ApiImplicitParam(name = "startDate", value = "START_DATE", dataType = "String"),
-            @ApiImplicitParam(name = "endDate", value = "END_DATE", dataType = "String"),
-            @ApiImplicitParam(name = "projectId", value = "PROJECT_ID", dataType = "Int", example = "100")
+        @ApiImplicitParam(name = "startDate", value = "START_DATE", dataType = "String"),
+        @ApiImplicitParam(name = "endDate", value = "END_DATE", dataType = "String"),
+        @ApiImplicitParam(name = "projectCode", value = "PROJECT_CODE", dataType = "Long", example = "100")
     })
     @GetMapping(value = "/task-state-count")
     @ResponseStatus(HttpStatus.OK)
@@ -80,9 +80,9 @@ public class DataAnalysisController extends BaseController {
     public Result countTaskState(@ApiIgnore @RequestAttribute(value = Constants.SESSION_USER) User loginUser,
                                  @RequestParam(value = "startDate", required = false) String startDate,
                                  @RequestParam(value = "endDate", required = false) String endDate,
-                                 @RequestParam(value = "projectId", required = false, defaultValue = "0") int projectId) {
+                                 @RequestParam(value = "projectCode", required = false, defaultValue = "0") long projectCode) {
 
-        Map<String, Object> result = dataAnalysisService.countTaskStateByProject(loginUser, projectId, startDate, endDate);
+        Map<String, Object> result = dataAnalysisService.countTaskStateByProject(loginUser, projectCode, startDate, endDate);
         return returnDataList(result);
     }
 
@@ -92,14 +92,14 @@ public class DataAnalysisController extends BaseController {
      * @param loginUser login user
      * @param startDate start date
      * @param endDate   end date
-     * @param projectId project id
+     * @param projectCode project code
      * @return process instance data
      */
     @ApiOperation(value = "countProcessInstanceState", notes = "COUNT_PROCESS_INSTANCE_NOTES")
     @ApiImplicitParams({
-            @ApiImplicitParam(name = "startDate", value = "START_DATE", dataType = "String"),
-            @ApiImplicitParam(name = "endDate", value = "END_DATE", dataType = "String"),
-            @ApiImplicitParam(name = "projectId", value = "PROJECT_ID", dataType = "Int", example = "100")
+        @ApiImplicitParam(name = "startDate", value = "START_DATE", dataType = "String"),
+        @ApiImplicitParam(name = "endDate", value = "END_DATE", dataType = "String"),
+        @ApiImplicitParam(name = "projectCode", value = "PROJECT_CODE", dataType = "Long", example = "100")
     })
     @GetMapping(value = "/process-state-count")
     @ResponseStatus(HttpStatus.OK)
@@ -108,9 +108,9 @@ public class DataAnalysisController extends BaseController {
     public Result countProcessInstanceState(@ApiIgnore @RequestAttribute(value = Constants.SESSION_USER) User loginUser,
                                             @RequestParam(value = "startDate", required = false) String startDate,
                                             @RequestParam(value = "endDate", required = false) String endDate,
-                                            @RequestParam(value = "projectId", required = false, defaultValue = "0") int projectId) {
+                                            @RequestParam(value = "projectCode", required = false, defaultValue = "0") long projectCode) {
 
-        Map<String, Object> result = dataAnalysisService.countProcessInstanceStateByProject(loginUser, projectId, startDate, endDate);
+        Map<String, Object> result = dataAnalysisService.countProcessInstanceStateByProject(loginUser, projectCode, startDate, endDate);
         return returnDataList(result);
     }
 
@@ -187,5 +187,4 @@ public class DataAnalysisController extends BaseController {
         return returnDataList(result);
     }
 
-
 }

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/DataAnalysisService.java

@@ -30,23 +30,23 @@ public interface DataAnalysisService {
      * statistical task instance status data
      *
      * @param loginUser login user
-     * @param projectId project id
+     * @param projectCode project code
      * @param startDate start date
      * @param endDate end date
      * @return task state count data
      */
-    Map<String, Object> countTaskStateByProject(User loginUser, int projectId, String startDate, String endDate);
+    Map<String, Object> countTaskStateByProject(User loginUser, long projectCode, String startDate, String endDate);
 
     /**
      * statistical process instance status data
      *
      * @param loginUser login user
-     * @param projectId project id
+     * @param projectCode project code
      * @param startDate start date
      * @param endDate end date
      * @return process instance state count data
      */
-    Map<String, Object> countProcessInstanceStateByProject(User loginUser, int projectId, String startDate, String endDate);
+    Map<String, Object> countProcessInstanceStateByProject(User loginUser, long projectCode, String startDate, String endDate);
 
     /**
      * statistics the process definition quantities of certain person

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/DataAnalysisServiceImpl.java

@@ -90,17 +90,17 @@ public class DataAnalysisServiceImpl extends BaseServiceImpl implements DataAnal
      * statistical task instance status data
      *
      * @param loginUser login user
-     * @param projectId project id
+     * @param projectCode project code
      * @param startDate start date
      * @param endDate end date
      * @return task state count data
      */
     @Override
-    public Map<String, Object> countTaskStateByProject(User loginUser, int projectId, String startDate, String endDate) {
+    public Map<String, Object> countTaskStateByProject(User loginUser, long projectCode, String startDate, String endDate) {
 
         return countStateByProject(
                 loginUser,
-                projectId,
+                projectCode,
                 startDate,
                 endDate,
             (start, end, projectCodes) -> this.taskInstanceMapper.countTaskInstanceStateByUser(start, end, projectCodes));
@@ -110,16 +110,16 @@ public class DataAnalysisServiceImpl extends BaseServiceImpl implements DataAnal
      * statistical process instance status data
      *
      * @param loginUser login user
-     * @param projectId project id
+     * @param projectCode project code
      * @param startDate start date
      * @param endDate end date
      * @return process instance state count data
      */
     @Override
-    public Map<String, Object> countProcessInstanceStateByProject(User loginUser, int projectId, String startDate, String endDate) {
+    public Map<String, Object> countProcessInstanceStateByProject(User loginUser, long projectCode, String startDate, String endDate) {
         Map<String, Object> result =  this.countStateByProject(
                 loginUser,
-                projectId,
+                projectCode,
                 startDate,
                 endDate,
             (start, end, projectCodes) -> this.processInstanceMapper.countInstanceStateByUser(start, end, projectCodes));
@@ -130,11 +130,11 @@ public class DataAnalysisServiceImpl extends BaseServiceImpl implements DataAnal
         return result;
     }
 
-    private Map<String, Object> countStateByProject(User loginUser, int projectId, String startDate, String endDate
+    private Map<String, Object> countStateByProject(User loginUser, long projectCode, String startDate, String endDate
             , TriFunction<Date, Date, Long[], List<ExecuteStatusCount>> instanceStateCounter) {
-        Map<String, Object> result = new HashMap<>();
-        boolean checkProject = checkProject(loginUser, projectId, result);
-        if (!checkProject) {
+        Project project = projectMapper.queryByCode(projectCode);
+        Map<String, Object> result = projectService.checkProjectAndAuth(loginUser, project, project.getName());
+        if (result.get(Constants.STATUS) != Status.SUCCESS) {
             return result;
         }
 
@@ -149,8 +149,8 @@ public class DataAnalysisServiceImpl extends BaseServiceImpl implements DataAnal
             }
         }
 
-        Long[] projectCodeArray = projectId == 0 ? getProjectCodesArrays(loginUser)
-                : new Long[] { projectMapper.selectById(projectId).getCode() };
+        Long[] projectCodeArray = projectCode == 0 ? getProjectCodesArrays(loginUser)
+                : new Long[] { projectCode };
         List<ExecuteStatusCount> processInstanceStateCounts =
                 instanceStateCounter.apply(start, end, projectCodeArray);
 
@@ -280,7 +280,7 @@ public class DataAnalysisServiceImpl extends BaseServiceImpl implements DataAnal
             return result;
         }
 
-        //TODO need to add detail data info 
+        //TODO need to add detail data info
         Map<String, Integer> dataMap = new HashMap<>();
         dataMap.put("taskQueue", 0);
         dataMap.put("taskKill", 0);

dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/controller/DataAnalysisControllerTest.java

@@ -24,11 +24,16 @@ import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.
 import org.apache.dolphinscheduler.api.enums.Status;
 import org.apache.dolphinscheduler.api.utils.Result;
 import org.apache.dolphinscheduler.common.utils.JSONUtils;
+import org.apache.dolphinscheduler.dao.entity.Project;
+import org.apache.dolphinscheduler.dao.mapper.ProjectMapper;
 
 import org.junit.Assert;
 import org.junit.Test;
+import org.mockito.Mockito;
+import org.powermock.api.mockito.PowerMockito;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.boot.test.mock.mockito.MockBean;
 import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.MvcResult;
 import org.springframework.util.LinkedMultiValueMap;
@@ -37,17 +42,21 @@ import org.springframework.util.MultiValueMap;
 /**
  * data analysis controller test
  */
-public class DataAnalysisControllerTest extends AbstractControllerTest{
+public class DataAnalysisControllerTest extends AbstractControllerTest {
 
     private static Logger logger = LoggerFactory.getLogger(DataAnalysisControllerTest.class);
 
+    @MockBean
+    ProjectMapper projectMapper;
+
     @Test
     public void testCountTaskState() throws Exception {
+        PowerMockito.when(projectMapper.queryByCode(Mockito.any())).thenReturn(getProject("test"));
 
         MultiValueMap<String, String> paramsMap = new LinkedMultiValueMap<>();
         paramsMap.add("startDate","2019-12-01 00:00:00");
         paramsMap.add("endDate","2019-12-28 00:00:00");
-        paramsMap.add("projectId","16");
+        paramsMap.add("projectCode","16");
 
         MvcResult mvcResult = mockMvc.perform(get("/projects/analysis/task-state-count")
                 .header("sessionId", sessionId)
@@ -56,17 +65,19 @@ public class DataAnalysisControllerTest extends AbstractControllerTest{
                 .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8))
                 .andReturn();
         Result result = JSONUtils.parseObject(mvcResult.getResponse().getContentAsString(), Result.class);
-        Assert.assertEquals(Status.SUCCESS.getCode(),result.getCode().intValue());
+        Assert.assertEquals(
+                Status.SUCCESS.getCode(),result.getCode().intValue());
         logger.info(mvcResult.getResponse().getContentAsString());
     }
 
     @Test
     public void testCountProcessInstanceState() throws Exception {
+        PowerMockito.when(projectMapper.queryByCode(Mockito.any())).thenReturn(getProject("test"));
 
         MultiValueMap<String, String> paramsMap = new LinkedMultiValueMap<>();
         paramsMap.add("startDate","2019-12-01 00:00:00");
         paramsMap.add("endDate","2019-12-28 00:00:00");
-        paramsMap.add("projectId","16");
+        paramsMap.add("projectCode","16");
 
         MvcResult mvcResult = mockMvc.perform(get("/projects/analysis/process-state-count")
                 .header("sessionId", sessionId)
@@ -81,6 +92,7 @@ public class DataAnalysisControllerTest extends AbstractControllerTest{
 
     @Test
     public void testCountDefinitionByUser() throws Exception {
+        PowerMockito.when(projectMapper.selectById(Mockito.any())).thenReturn(getProject("test"));
 
         MultiValueMap<String, String> paramsMap = new LinkedMultiValueMap<>();
         paramsMap.add("projectId","16");
@@ -98,9 +110,11 @@ public class DataAnalysisControllerTest extends AbstractControllerTest{
 
     @Test
     public void testCountCommandState() throws Exception {
+        PowerMockito.when(projectMapper.selectById(Mockito.any())).thenReturn(getProject("test"));
+
         MultiValueMap<String, String> paramsMap = new LinkedMultiValueMap<>();
-        paramsMap.add("startDate","2019-12-01");
-        paramsMap.add("endDate","2019-12-15");
+        paramsMap.add("startDate","2019-12-01 00:00:00");
+        paramsMap.add("endDate","2019-12-15 23:59:59");
         paramsMap.add("projectId","16");
         MvcResult mvcResult = mockMvc.perform(get("/projects/analysis/command-state-count")
                 .header("sessionId", sessionId)
@@ -116,6 +130,7 @@ public class DataAnalysisControllerTest extends AbstractControllerTest{
 
     @Test
     public void testCountQueueState() throws Exception {
+        PowerMockito.when(projectMapper.selectById(Mockito.any())).thenReturn(getProject("test"));
 
         MultiValueMap<String, String> paramsMap = new LinkedMultiValueMap<>();
         paramsMap.add("projectId","16");
@@ -129,4 +144,19 @@ public class DataAnalysisControllerTest extends AbstractControllerTest{
         Assert.assertEquals(Status.SUCCESS.getCode(),result.getCode().intValue());
         logger.info(mvcResult.getResponse().getContentAsString());
     }
+
+    /**
+     * get mock Project
+     *
+     * @param projectName projectName
+     * @return Project
+     */
+    private Project getProject(String projectName) {
+        Project project = new Project();
+        project.setCode(11L);
+        project.setId(1);
+        project.setName(projectName);
+        project.setUserId(1);
+        return project;
+    }
 }

dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/DataAnalysisServiceTest.java

@@ -22,16 +22,15 @@ import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyInt;
 
 import org.apache.dolphinscheduler.api.dto.CommandStateCount;
-import org.apache.dolphinscheduler.api.dto.TaskStateCount;
 import org.apache.dolphinscheduler.api.enums.Status;
 import org.apache.dolphinscheduler.api.service.impl.DataAnalysisServiceImpl;
-import org.apache.dolphinscheduler.api.service.impl.ProjectServiceImpl;
 import org.apache.dolphinscheduler.common.Constants;
 import org.apache.dolphinscheduler.common.enums.CommandType;
 import org.apache.dolphinscheduler.common.enums.ExecutionStatus;
 import org.apache.dolphinscheduler.common.enums.UserType;
 import org.apache.dolphinscheduler.common.utils.DateUtils;
 import org.apache.dolphinscheduler.dao.entity.CommandCount;
+import org.apache.dolphinscheduler.dao.entity.DefinitionGroupByUser;
 import org.apache.dolphinscheduler.dao.entity.ExecuteStatusCount;
 import org.apache.dolphinscheduler.dao.entity.Project;
 import org.apache.dolphinscheduler.dao.entity.User;
@@ -43,6 +42,7 @@ import org.apache.dolphinscheduler.dao.mapper.ProjectMapper;
 import org.apache.dolphinscheduler.dao.mapper.TaskInstanceMapper;
 import org.apache.dolphinscheduler.service.process.ProcessService;
 
+import java.text.MessageFormat;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -57,6 +57,7 @@ import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.powermock.api.mockito.PowerMockito;
 import org.powermock.modules.junit4.PowerMockRunner;
 
 /**
@@ -66,13 +67,13 @@ import org.powermock.modules.junit4.PowerMockRunner;
 public class DataAnalysisServiceTest {
 
     @InjectMocks
-    private DataAnalysisServiceImpl dataAnalysisService;
+    private DataAnalysisServiceImpl dataAnalysisServiceImpl;
 
     @Mock
     ProjectMapper projectMapper;
 
     @Mock
-    ProjectServiceImpl projectService;
+    ProjectService projectService;
 
     @Mock
     ProcessInstanceMapper processInstanceMapper;
@@ -102,134 +103,144 @@ public class DataAnalysisServiceTest {
         user = new User();
         Project project = new Project();
         project.setId(1);
+        project.setName("test");
         resultMap = new HashMap<>();
         Mockito.when(projectMapper.selectById(1)).thenReturn(project);
         Mockito.when(projectService.hasProjectAndPerm(user, project, resultMap)).thenReturn(true);
 
+        Mockito.when(projectMapper.queryByCode(1L)).thenReturn(project);
     }
 
-
     @After
     public void after() {
-
         user = null;
         projectMapper = null;
         resultMap = null;
     }
 
     @Test
-    public void testCountTaskStateByProject() {
-
+    public void testCountTaskStateByProject_success() {
         String startDate = "2020-02-11 16:02:18";
         String endDate = "2020-02-11 16:03:18";
 
-        //checkProject false
-        Map<String, Object> result = dataAnalysisService.countTaskStateByProject(user, 2, startDate, endDate);
-        Assert.assertTrue(result.isEmpty());
-
+        Map<String, Object> result = new HashMap<>();
+        putMsg(result, Status.SUCCESS, null);
+        Mockito.when(projectService.checkProjectAndAuth(any(), any(), any())).thenReturn(result);
+        Mockito.when(projectMapper.queryByCode(Mockito.any())).thenReturn(getProject("test"));
 
-        //SUCCESS
+        // SUCCESS
         Mockito.when(taskInstanceMapper.countTaskInstanceStateByUser(DateUtils.getScheduleDate(startDate),
-                DateUtils.getScheduleDate(endDate), new Long[]{1L})).thenReturn(getTaskInstanceStateCounts());
-        Mockito.when(projectMapper.selectById(Mockito.any())).thenReturn(getProject("test"));
-        Mockito.when(projectService.hasProjectAndPerm(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(true);
-
-        result = dataAnalysisService.countTaskStateByProject(user, 1, startDate, endDate);
+                DateUtils.getScheduleDate(endDate), new Long[] {1L})).thenReturn(getTaskInstanceStateCounts());
+        Mockito.when(projectMapper.queryByCode(Mockito.any())).thenReturn(getProject("test"));
+        result = dataAnalysisServiceImpl.countTaskStateByProject(user, 1, startDate, endDate);
         Assert.assertEquals(Status.SUCCESS, result.get(Constants.STATUS));
+    }
+
+    @Test
+    public void testCountTaskStateByProject_projectNotFound() {
+        String startDate = "2020-02-11 16:02:18";
+        String endDate = "2020-02-11 16:03:18";
+
+        // checkProject false
+        Map<String, Object> failResult = new HashMap<>();
+        putMsg(failResult, Status.PROJECT_NOT_FOUNT, 1);
+        Mockito.when(projectService.checkProjectAndAuth(any(), any(), any())).thenReturn(failResult);
+        failResult = dataAnalysisServiceImpl.countTaskStateByProject(user, 1, startDate, endDate);
+        Assert.assertEquals(Status.PROJECT_NOT_FOUNT, failResult.get(Constants.STATUS));
+    }
+
+    @Test
+    public void testCountTaskStateByProject_paramValid() {
+        Map<String, Object> result = new HashMap<>();
+        putMsg(result, Status.SUCCESS, null);
+        Mockito.when(projectService.checkProjectAndAuth(any(), any(), any())).thenReturn(result);
+        Mockito.when(projectMapper.queryByCode(Mockito.any())).thenReturn(getProject("test"));
 
         // when date in illegal format then return error message
         String startDate2 = "illegalDateString";
         String endDate2 = "illegalDateString";
-        result = dataAnalysisService.countTaskStateByProject(user, 0, startDate2, endDate2);
+        result = dataAnalysisServiceImpl.countTaskStateByProject(user, 1, startDate2, endDate2);
         Assert.assertEquals(Status.REQUEST_PARAMS_NOT_VALID_ERROR, result.get(Constants.STATUS));
 
         // when one of date in illegal format then return error message
         String startDate3 = "2020-08-28 14:13:40";
         String endDate3 = "illegalDateString";
-        result = dataAnalysisService.countTaskStateByProject(user, 0, startDate3, endDate3);
+        result = dataAnalysisServiceImpl.countTaskStateByProject(user, 1, startDate3, endDate3);
         Assert.assertEquals(Status.REQUEST_PARAMS_NOT_VALID_ERROR, result.get(Constants.STATUS));
 
         // when one of date in illegal format then return error message
         String startDate4 = "illegalDateString";
         String endDate4 = "2020-08-28 14:13:40";
-        result = dataAnalysisService.countTaskStateByProject(user, 0, startDate4, endDate4);
+        result = dataAnalysisServiceImpl.countTaskStateByProject(user, 1, startDate4, endDate4);
         Assert.assertEquals(Status.REQUEST_PARAMS_NOT_VALID_ERROR, result.get(Constants.STATUS));
+    }
 
-        // when counting general user's task status then return user's task status count
-        user.setUserType(UserType.GENERAL_USER);
-        Mockito.when(processService.getProjectIdListHavePerm(anyInt()))
-                .thenReturn(Collections.singletonList(123L));
-        ExecuteStatusCount executeStatusCount = new ExecuteStatusCount();
-        executeStatusCount.setExecutionStatus(ExecutionStatus.RUNNING_EXECUTION);
-        executeStatusCount.setCount(10);
-        Mockito.when(taskInstanceMapper.countTaskInstanceStateByUser(any(), any(), any()))
-                .thenReturn(Collections.singletonList(executeStatusCount));
-        result = dataAnalysisService.countTaskStateByProject(user, 0, startDate, null);
-        assertThat(result.get(Constants.DATA_LIST)).extracting("taskCountDtos").first().asList()
-                .hasSameSizeAs(ExecutionStatus.values());
-        assertThat(result.get(Constants.DATA_LIST)).extracting("totalCount").first().isEqualTo(10);
-        TaskStateCount taskStateCount = new TaskStateCount(ExecutionStatus.RUNNING_EXECUTION, 10);
-        assertThat(result.get(Constants.DATA_LIST)).extracting("taskCountDtos").first().asList().containsOnlyOnce(taskStateCount);
+    @Test
+    public void testCountTaskStateByProject_allCountZero() {
+        Map<String, Object> result = new HashMap<>();
+        putMsg(result, Status.SUCCESS, null);
+        Mockito.when(projectService.checkProjectAndAuth(any(), any(), any())).thenReturn(result);
+        Mockito.when(projectMapper.queryByCode(Mockito.any())).thenReturn(getProject("test"));
 
         // when general user doesn't have any task then return all count are 0
         user.setUserType(UserType.GENERAL_USER);
-        Mockito.when(processService.getProjectIdListHavePerm(anyInt()))
-                .thenReturn(new ArrayList<>());
-        Mockito.when(taskInstanceMapper.countTaskInstanceStateByUser(any(), any(), any()))
-                .thenReturn(Collections.emptyList());
-        result = dataAnalysisService.countTaskStateByProject(user, 0, null, null);
+        Mockito.when(taskInstanceMapper.countTaskInstanceStateByUser(any(), any(), any())).thenReturn(
+                Collections.emptyList());
+        result = dataAnalysisServiceImpl.countTaskStateByProject(user, 1, null, null);
         assertThat(result.get(Constants.DATA_LIST)).extracting("totalCount").first().isEqualTo(0);
-        assertThat(result.get(Constants.DATA_LIST)).extracting("taskCountDtos").first().asList()
-                .hasSameSizeAs(ExecutionStatus.values());
-        assertThat(result.get(Constants.DATA_LIST)).extracting("taskCountDtos").first().asList()
-                .extracting("count").allMatch(count -> count.equals(0));
+        assertThat(result.get(Constants.DATA_LIST)).extracting("taskCountDtos").first().asList().hasSameSizeAs(
+                ExecutionStatus.values());
+        assertThat(result.get(Constants.DATA_LIST)).extracting("taskCountDtos").first().asList().extracting(
+                "count").allMatch(count -> count.equals(0));
+    }
 
-        // when general user doesn't have any task then return all count are 0
-        user.setUserType(UserType.GENERAL_USER);
-        Mockito.when(processService.getProjectIdListHavePerm(anyInt()))
-                .thenReturn(new ArrayList<>());
-        Mockito.when(taskInstanceMapper.countTaskInstanceStateByUser(any(), any(), any()))
-                .thenReturn(Collections.emptyList());
-        result = dataAnalysisService.countTaskStateByProject(user, 0, null, null);
-        assertThat(result.get(Constants.DATA_LIST)).extracting("totalCount").first().isEqualTo(0);
-        assertThat(result.get(Constants.DATA_LIST)).extracting("taskCountDtos").first().asList()
-                .hasSameSizeAs(ExecutionStatus.values());
-        assertThat(result.get(Constants.DATA_LIST)).extracting("taskCountDtos").first().asList()
-                .extracting("count").allMatch(count -> count.equals(0));
+    @Test
+    public void testCountTaskStateByProject_noData() {
+        Map<String, Object> result = new HashMap<>();
+        putMsg(result, Status.SUCCESS, null);
+        Mockito.when(projectService.checkProjectAndAuth(any(), any(), any())).thenReturn(result);
+        Mockito.when(projectMapper.queryByCode(Mockito.any())).thenReturn(getProject("test"));
 
         // when instanceStateCounter return null, then return nothing
         user.setUserType(UserType.GENERAL_USER);
-        Mockito.when(processService.getProjectIdListHavePerm(anyInt()))
-                .thenReturn(new ArrayList<>());
-        Mockito.when(taskInstanceMapper.countTaskInstanceStateByUser(any(), any(), any()))
-                .thenReturn(null);
-        result = dataAnalysisService.countTaskStateByProject(user, 0, null, null);
-        assertThat(result).isEmpty();
+        PowerMockito.when(taskInstanceMapper.countTaskInstanceStateByUser(any(), any(), any())).thenReturn(null);
+        result = dataAnalysisServiceImpl.countTaskStateByProject(user, 1, null, null);
+        Assert.assertNull(result.get(Constants.DATA_LIST));
     }
 
     @Test
     public void testCountProcessInstanceStateByProject() {
-
         String startDate = "2020-02-11 16:02:18";
         String endDate = "2020-02-11 16:03:18";
+
+        Mockito.when(projectMapper.queryByCode(Mockito.any())).thenReturn(getProject("test"));
+
         //checkProject false
-        Map<String, Object> result = dataAnalysisService.countProcessInstanceStateByProject(user, 2, startDate, endDate);
-        Assert.assertTrue(result.isEmpty());
+        Map<String, Object> failResult = new HashMap<>();
+        putMsg(failResult, Status.PROJECT_NOT_FOUNT, 1);
+        Mockito.when(projectService.checkProjectAndAuth(any(), any(), any())).thenReturn(failResult);
+        failResult = dataAnalysisServiceImpl.countProcessInstanceStateByProject(user, 2, startDate, endDate);
+        Assert.assertEquals(Status.PROJECT_NOT_FOUNT, failResult.get(Constants.STATUS));
+
+        Map<String, Object> result = new HashMap<>();
+        putMsg(result, Status.SUCCESS, null);
+        Mockito.when(projectService.checkProjectAndAuth(any(), any(), any())).thenReturn(result);
 
         //SUCCESS
-        Mockito.when(projectMapper.selectById(Mockito.any())).thenReturn(getProject("test"));
         Mockito.when(processInstanceMapper.countInstanceStateByUser(DateUtils.getScheduleDate(startDate),
                 DateUtils.getScheduleDate(endDate), new Long[]{1L})).thenReturn(getTaskInstanceStateCounts());
         Mockito.when(projectService.hasProjectAndPerm(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(true);
 
-        result = dataAnalysisService.countProcessInstanceStateByProject(user, 1, startDate, endDate);
+        result = dataAnalysisServiceImpl.countProcessInstanceStateByProject(user, 1, startDate, endDate);
         Assert.assertEquals(Status.SUCCESS, result.get(Constants.STATUS));
     }
 
     @Test
     public void testCountDefinitionByUser() {
         Mockito.when(projectMapper.selectById(Mockito.any())).thenReturn(getProject("test"));
-        Map<String, Object> result = dataAnalysisService.countDefinitionByUser(user, 0);
+        Mockito.when(processDefinitionMapper.countDefinitionGroupByUser(Mockito.anyInt(), Mockito.any(Long[].class),
+            Mockito.anyBoolean())).thenReturn(new ArrayList<DefinitionGroupByUser>());
+        Map<String, Object> result = dataAnalysisServiceImpl.countDefinitionByUser(user, 0);
         Assert.assertEquals(Status.SUCCESS, result.get(Constants.STATUS));
     }
 
@@ -239,7 +250,7 @@ public class DataAnalysisServiceTest {
         String startDate = "2020-02-11 16:02:18";
         String endDate = "2020-02-11 16:03:18";
         //checkProject false
-        Map<String, Object> result = dataAnalysisService.countCommandState(user, 2, startDate, endDate);
+        Map<String, Object> result = dataAnalysisServiceImpl.countCommandState(user, 2, startDate, endDate);
         Assert.assertTrue(result.isEmpty());
         List<CommandCount> commandCounts = new ArrayList<>(1);
         CommandCount commandCount = new CommandCount();
@@ -253,31 +264,31 @@ public class DataAnalysisServiceTest {
         Mockito.when(projectMapper.selectById(Mockito.any())).thenReturn(getProject("test"));
         Mockito.when(projectService.hasProjectAndPerm(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(true);
 
-        result = dataAnalysisService.countCommandState(user, 1, startDate, endDate);
+        result = dataAnalysisServiceImpl.countCommandState(user, 1, startDate, endDate);
         Assert.assertEquals(Status.SUCCESS, result.get(Constants.STATUS));
 
         // when all date in illegal format then return error message
         String startDate2 = "illegalDateString";
         String endDate2 = "illegalDateString";
-        Map<String, Object> result2 = dataAnalysisService.countCommandState(user, 0, startDate2, endDate2);
+        Map<String, Object> result2 = dataAnalysisServiceImpl.countCommandState(user, 0, startDate2, endDate2);
         Assert.assertEquals(Status.REQUEST_PARAMS_NOT_VALID_ERROR, result2.get(Constants.STATUS));
 
         // when one of date in illegal format then return error message
         String startDate3 = "2020-08-22 09:23:10";
         String endDate3 = "illegalDateString";
-        Map<String, Object> result3 = dataAnalysisService.countCommandState(user, 0, startDate3, endDate3);
+        Map<String, Object> result3 = dataAnalysisServiceImpl.countCommandState(user, 0, startDate3, endDate3);
         Assert.assertEquals(Status.REQUEST_PARAMS_NOT_VALID_ERROR, result3.get(Constants.STATUS));
 
         // when one of date in illegal format then return error message
         String startDate4 = "illegalDateString";
         String endDate4 = "2020-08-22 09:23:10";
-        Map<String, Object> result4 = dataAnalysisService.countCommandState(user, 0, startDate4, endDate4);
+        Map<String, Object> result4 = dataAnalysisServiceImpl.countCommandState(user, 0, startDate4, endDate4);
         Assert.assertEquals(Status.REQUEST_PARAMS_NOT_VALID_ERROR, result4.get(Constants.STATUS));
 
         // when no command found then return all count are 0
         Mockito.when(commandMapper.countCommandState(anyInt(), any(), any(), any())).thenReturn(Collections.emptyList());
         Mockito.when(errorCommandMapper.countCommandState(any(), any(), any())).thenReturn(Collections.emptyList());
-        Map<String, Object> result5 = dataAnalysisService.countCommandState(user, 0, startDate, null);
+        Map<String, Object> result5 = dataAnalysisServiceImpl.countCommandState(user, 0, startDate, null);
         assertThat(result5).containsEntry(Constants.STATUS, Status.SUCCESS);
         assertThat(result5.get(Constants.DATA_LIST)).asList().extracting("errorCount").allMatch(count -> count.equals(0));
         assertThat(result5.get(Constants.DATA_LIST)).asList().extracting("normalCount").allMatch(count -> count.equals(0));
@@ -292,7 +303,7 @@ public class DataAnalysisServiceTest {
         Mockito.when(commandMapper.countCommandState(anyInt(), any(), any(), any())).thenReturn(Collections.singletonList(normalCommandCount));
         Mockito.when(errorCommandMapper.countCommandState(any(), any(), any())).thenReturn(Collections.singletonList(errorCommandCount));
 
-        Map<String, Object> result6 = dataAnalysisService.countCommandState(user, 0, null, null);
+        Map<String, Object> result6 = dataAnalysisServiceImpl.countCommandState(user, 0, null, null);
 
         assertThat(result6).containsEntry(Constants.STATUS, Status.SUCCESS);
         CommandStateCount commandStateCount = new CommandStateCount();
@@ -305,11 +316,11 @@ public class DataAnalysisServiceTest {
     @Test
     public void testCountQueueState() {
         // when project check fail then return nothing
-        Map<String, Object> result1 = dataAnalysisService.countQueueState(user, 2);
+        Map<String, Object> result1 = dataAnalysisServiceImpl.countQueueState(user, 2);
         Assert.assertTrue(result1.isEmpty());
 
         // when project check success when return all count are 0
-        Map<String, Object> result2 = dataAnalysisService.countQueueState(user, 1);
+        Map<String, Object> result2 = dataAnalysisServiceImpl.countQueueState(user, 1);
         assertThat(result2.get(Constants.DATA_LIST)).extracting("taskQueue", "taskKill")
                 .isNotEmpty()
                 .allMatch(count -> count.equals(0));
@@ -342,4 +353,13 @@ public class DataAnalysisServiceTest {
         project.setUserId(1);
         return project;
     }
-}
+
+    private void putMsg(Map<String, Object> result, Status status, Object... statusParams) {
+        result.put(Constants.STATUS, status);
+        if (statusParams != null && statusParams.length > 0) {
+            result.put(Constants.MSG, MessageFormat.format(status.getMsg(), statusParams));
+        } else {
+            result.put(Constants.MSG, status.getMsg());
+        }
+    }
+}

dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java

@@ -1993,21 +1993,6 @@ public class ProcessService {
         return createProjects;
     }
 
-    /**
-     * get have perm project ids
-     *
-     * @param userId userId
-     * @return project codes
-     */
-    public List<Long> getProjectIdListHavePerm(int userId) {
-
-        List<Long> projectCodeList = new ArrayList<>();
-        for (Project project : getProjectListHavePerm(userId)) {
-            projectCodeList.add(project.getCode());
-        }
-        return projectCodeList;
-    }
-
     /**
      * list unauthorized udf function
      *

dolphinscheduler-ui/src/js/conf/home/pages/projects/pages/index/_source/processStateCount.vue

@@ -33,7 +33,7 @@
                 <td><span>{{$index+1}}</span></td>
                 <td>
                   <a v-if="currentName === 'home'" style="cursor: default">{{item.value}}</a>
-                  <span v-else><a href="javascript:" @click="searchParams.projectId && _goProcess(item.key)">{{item.value}}</a></span>
+                  <span v-else><a href="javascript:" @click="searchParams.projectCode && _goProcess(item.key)">{{item.value}}</a></span>
                 </td>
                 <td><span class="ellipsis" style="width: 98%;" :title="item.key">{{item.key}}</span></td>
               </tr>
@@ -90,8 +90,8 @@
         })
         const myChart = Chart.pie('#process-state-pie', this.processStateList, { title: '' })
         myChart.echart.setOption(pie)
-        // 首页不允许跳转
-        if (this.searchParams.projectId) {
+        // Jump not allowed on home page
+        if (this.searchParams.projectCode) {
           myChart.echart.on('click', e => {
             this._goProcess(e.data.name)
           })

dolphinscheduler-ui/src/js/conf/home/pages/projects/pages/index/_source/taskStatusCount.vue

@@ -33,7 +33,7 @@
                 <td><span>{{$index+1}}</span></td>
                 <td>
                   <span>
-                    <a href="javascript:" @click="searchParams.projectId && _goTask(item.key)" :class="searchParams.projectId ?'links':''">{{item.value}}</a>
+                    <a href="javascript:" @click="searchParams.projectCode && _goTask(item.key)" :class="searchParams.projectCode ?'links':''">{{item.value}}</a>
                   </span>
                 </td>
                 <td><span class="ellipsis" style="width: 98%;" :title="item.key">{{item.key}}</span></td>
@@ -94,7 +94,7 @@
         myChart.echart.setOption(pie)
 
         // Jump forbidden in index page
-        if (this.searchParams.projectId) {
+        if (this.searchParams.projectCode) {
           myChart.echart.on('click', e => {
             this._goTask(e.data.name)
           })

dolphinscheduler-ui/src/js/conf/home/pages/projects/pages/index/index.vue

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 <template>
-  <m-list-construction :title="searchParams.projectId ? `${$t('Project Home')} - ${projectName}` : $t('Home')">
+  <m-list-construction :title="searchParams.projectCode ? `${$t('Project Home')} - ${projectName}` : $t('Home')">
     <template slot="content">
       <div class="perject-home-content">
         <div class="time-model">
@@ -80,6 +80,7 @@
       return {
         searchParams: {
           projectId: null,
+          projectCode: null,
           startDate: '',
           endDate: ''
         },
@@ -97,6 +98,7 @@
     },
     created () {
       this.searchParams.projectId = this.id === 0 ? 0 : localStore.getItem('projectId')
+      this.searchParams.projectCode = this.id === 0 ? 0 : localStore.getItem('projectCode')
       this.dataTime[0] = dayjs().format('YYYY-MM-DD 00:00:00')
       this.dataTime[1] = dayjs().format('YYYY-MM-DD HH:mm:ss')
       this.searchParams.startDate = this.dataTime[0]