Merge pull request #28 from aquality-automation/develop

0.3.3

Author: VladislavKostyukevich

CHANGELOG.md

@@ -1,6 +1,16 @@
 # CHANGELOG
 
-## 0.3.2 (unreleased)
+## 0.3.3 (unreleased)
+
+Features:
+  - Rename Import Token to API Token -> [View Issue](https://github.com/aquality-automation/aquality-tracking-ui/issues/23)
+  - Steps Feature -> [View Issue](https://github.com/aquality-automation/aquality-tracking-ui/issues/46)
+  - Regex Search by Errors for Import -> [View Issue](https://github.com/aquality-automation/aquality-tracking/issues/17)
+
+Bugfixes:
+  - Local Manager can see Local Permissions page -> [View Issue](https://github.com/aquality-automation/aquality-tracking-ui/issues/22)
+
+## 0.3.2 (2019-09-10)
 
 Features:
 

pom.xml

@@ -6,7 +6,7 @@
     <groupId>unifi_reporting_api</groupId>
     <artifactId>api</artifactId>
     <packaging>war</packaging>
-    <version>0.3.2</version>
+    <version>0.3.3</version>
 
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

src/main/java/main/Session.java

@@ -38,10 +38,10 @@ public Session(UserDto user) throws AqualityException {
     }
 
     @Deprecated
-    public Session(String importToken, int projectId) throws AqualityException {
+    public Session(String apiToken, int projectId) throws AqualityException {
         user = new UserDto();
         controllerFactory = new ControllerFactory(user);
-        if(controllerFactory.getHandler(new ImportTokenDto()).isTokenValid(importToken, projectId)){
+        if(controllerFactory.getHandler(new APITokenDto()).isTokenValid(apiToken, projectId)){
             ProjectUserDto projectUser = new ProjectUserDto();
             projectUser.setProject_id(projectId);
             projectUser.setEngineer(1);

src/main/java/main/controllers/Administration/StepTypeController.java

@@ -0,0 +1,33 @@
+package main.controllers.Administration;
+
+import main.controllers.BaseController;
+import main.exceptions.AqualityException;
+import main.model.db.dao.project.StepTypeDao;
+import main.model.dto.StepTypeDto;
+import main.model.dto.UserDto;
+
+import java.util.List;
+
+public class StepTypeController extends BaseController<StepTypeDto> {
+    private StepTypeDao stepTypeDao;
+
+    public StepTypeController(UserDto user) {
+        super(user);
+        stepTypeDao = new StepTypeDao();
+    }
+
+    @Override
+    public List<StepTypeDto> get(StepTypeDto entity) throws AqualityException {
+        return stepTypeDao.searchAll(entity);
+    }
+
+    @Override
+    public StepTypeDto create(StepTypeDto entity) throws AqualityException {
+        return stepTypeDao.create(entity);
+    }
+
+    @Override
+    public boolean delete(StepTypeDto entity) throws AqualityException {
+        return stepTypeDao.delete(entity);
+    }
+}

src/main/java/main/controllers/ControllerFactory.java

@@ -1,6 +1,7 @@
 package main.controllers;
 
 import main.controllers.Administration.EmailSettingsController;
+import main.controllers.Administration.StepTypeController;
 import main.controllers.Administration.UserController;
 import main.controllers.Project.*;
 import main.model.dto.*;
@@ -24,8 +25,8 @@ public FinalResultController getHandler(FinalResultDto entity) {
     public ImportController getHandler(ImportDto entity) {
         return new ImportController(user);
     }
-    public ImportTokenController getHandler(ImportTokenDto entity) {
-        return new ImportTokenController(user);
+    public APITokenController getHandler(APITokenDto entity) {
+        return new APITokenController(user);
     }
     public MilestoneController getHandler(MilestoneDto entity) {
         return new MilestoneController(user);
@@ -60,4 +61,13 @@ public UserController getHandler(UserDto entity) {
     public EmailSettingsController getHandler(EmailSettingsDto entity) {
         return new EmailSettingsController(user);
     }
+    public StepController getHandler(StepDto entity) {
+        return new StepController(user);
+    }
+    public StepResultController getHandler(StepResultDto entity) {
+        return new StepResultController(user);
+    }
+    public StepTypeController getHandler(StepTypeDto entity) {
+        return new StepTypeController(user);
+    }
 }

src/main/java/main/controllers/Project/ImportTokenController.java renamed to src/main/java/main/controllers/Project/APITokenController.java

@@ -3,49 +3,49 @@
 import main.controllers.BaseController;
 import main.exceptions.AqualityException;
 import main.exceptions.AqualityPermissionsException;
-import main.model.db.dao.project.ImportTokenDao;
-import main.model.dto.ImportTokenDto;
+import main.model.db.dao.project.APITokenDao;
+import main.model.dto.APITokenDto;
 import main.model.dto.UserDto;
 import org.apache.commons.codec.digest.DigestUtils;
 import org.apache.poi.util.NotImplemented;
 
 import java.util.List;
 import java.util.Objects;
 
-public class ImportTokenController extends BaseController<ImportTokenDto> {
-    private ImportTokenDao importTokenDao;
-    public ImportTokenController(UserDto user) {
+public class APITokenController extends BaseController<APITokenDto> {
+    private APITokenDao apiTokenDao;
+    public APITokenController(UserDto user) {
         super(user);
-        importTokenDao = new ImportTokenDao();
+        apiTokenDao = new APITokenDao();
     }
 
     @Override
-    public List<ImportTokenDto> get(ImportTokenDto entity) throws AqualityException {
+    public List<APITokenDto> get(APITokenDto entity) throws AqualityException {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public ImportTokenDto create(ImportTokenDto template) throws AqualityException {
+    public APITokenDto create(APITokenDto template) throws AqualityException {
         if(baseUser.isAdmin() || baseUser.isManager() || baseUser.getProjectUser(template.getId()).isManager() || baseUser.getProjectUser(template.getId()).isAdmin()){
-            return importTokenDao.create(template);
+            return apiTokenDao.create(template);
         }else{
-            throw new AqualityPermissionsException("Account is not allowed to create Import Token", baseUser);
+            throw new AqualityPermissionsException("Account is not allowed to create API Token", baseUser);
         }
     }
 
     @Override @NotImplemented
-    public boolean delete(ImportTokenDto entity) throws AqualityException {
+    public boolean delete(APITokenDto entity) throws AqualityException {
         throw new UnsupportedOperationException();
     }
 
     public boolean isTokenValid(String token, Integer projectId) throws AqualityException {
         String actualHash = DigestUtils.md5Hex(token + "advbc1671-nlksdui-ff");
-        ImportTokenDto tokenDTO = new ImportTokenDto();
+        APITokenDto tokenDTO = new APITokenDto();
         tokenDTO.setId(projectId);
-        List<ImportTokenDto> importTokens = importTokenDao.searchAll(tokenDTO);
+        List<APITokenDto> apiTokens = apiTokenDao.searchAll(tokenDTO);
 
-        if(importTokens.size() > 0){
-            String expectedHash = (importTokens.get(0)).getImport_token();
+        if(apiTokens.size() > 0){
+            String expectedHash = (apiTokens.get(0)).getApi_token();
             return Objects.equals(actualHash, expectedHash);
         }
 

src/main/java/main/controllers/Project/ProjectController.java

@@ -21,7 +21,7 @@ public ProjectController(UserDto user) {
 
     @Override
     public ProjectDto create(ProjectDto template) throws AqualityException {
-        if(baseUser.isAdmin()){
+        if(baseUser.isAdmin() || allowUpdateProject(template)){
             ProjectDto project = projectDao.create(template);
             updateProjectPermissions(project);
             return project;
@@ -50,12 +50,32 @@ public boolean delete(ProjectDto template) throws AqualityException {
         }
     }
 
+    public boolean isStepsEnabled(Integer projectId) throws AqualityException {
+        ProjectDto project = new ProjectDto();
+        project.setId(projectId);
+        List<ProjectDto> projects = get(project);
+
+        if(projects.size() < 1) {
+            throw new AqualityException("Project with id %s does not exists!", projectId);
+        }
+
+        return projects.get(0).getSteps() == 1;
+    }
+
     private void updateProjectPermissions(ProjectDto entity) throws AqualityException {
         if(entity.getCustomer() != null && entity.getCustomer().getAccounting() == 1 && entity.getId() != 0){
             updatePermissions(entity.getCustomer().getId(), entity.getId());
         }
     }
 
+    private boolean allowUpdateProject(ProjectDto template) {
+        if(template.getId() != null) {
+            ProjectUserDto projectUser = baseUser.getProjectUser(template.getId());
+            return baseUser.isManager() || projectUser.isManager() || projectUser.isAdmin();
+        }
+        return false;
+    }
+
     //TODO create
     private void updatePermissions(Integer customer_id, Integer project_id) throws AqualityException {
     }

src/main/java/main/controllers/Project/ProjectUserController.java

@@ -22,7 +22,7 @@ public ProjectUserController(UserDto user) {
 
     @Override
     public ProjectUserDto create(ProjectUserDto template) throws AqualityException {
-        if(baseUser.isAdmin() || baseUser.getProjectUser(template.getProject_id()).isAdmin()){
+        if(isEditorSession(template)){
             return projectUserDao.create(template);
         }else{
             throw new AqualityPermissionsException("Account is not allowed to create Project User", baseUser);
@@ -40,7 +40,7 @@ public List<ProjectUserDto> get(ProjectUserDto template) throws AqualityExceptio
 
     @Override
     public boolean delete(ProjectUserDto template) throws AqualityException {
-        if(baseUser.isAdmin() || baseUser.getProjectUser(template.getProject_id()).isAdmin()){
+        if(isEditorSession(template)){
             return projectUserDao.delete(template);
         }else{
             throw new AqualityPermissionsException("Account is not allowed to delete Project User", baseUser);
@@ -59,4 +59,10 @@ private List<ProjectUserDto> fillProjectUsers(List<ProjectUserDto> projectUsers)
         }
         return projectUsers;
     }
+
+    private boolean isEditorSession(ProjectUserDto template){
+        return baseUser.isAdmin() || baseUser.isManager()
+                || baseUser.getProjectUser(template.getProject_id()).isAdmin()
+                || baseUser.getProjectUser(template.getProject_id()).isManager();
+    }
 }

src/main/java/main/controllers/Project/ResultController.java

@@ -17,6 +17,9 @@ public class ResultController extends BaseController<TestResultDto> {
     private ProjectUserController projectUserController;
     private ResultResolutionController resultResolutionController;
     private FinalResultController finalResultController;
+    private ProjectController projectController;
+    private StepController stepController;
+    private StepResultController stepResultController;
 
     public ResultController(UserDto user) {
         super(user);
@@ -26,12 +29,19 @@ public ResultController(UserDto user) {
         testDao = new TestDao();
         resultResolutionController = new ResultResolutionController(user);
         finalResultController = new FinalResultController(user);
+        projectController = new ProjectController(user);
+        stepController = new StepController(user);
+        stepResultController = new StepResultController(user);
     }
 
     @Override
     public TestResultDto create(TestResultDto template) throws AqualityException {
         if(baseUser.isManager() || baseUser.getProjectUser(template.getProject_id()).isEditor()){
-            return testResultDao.create(template);
+            TestResultDto testResult = testResultDao.create(template);
+            if(projectController.isStepsEnabled(testResult.getProject_id()) && template.getId() == null){
+                createPendingStepResults(testResult);
+            }
+            return testResult;
         }else{
             throw new AqualityPermissionsException("Account is not allowed to create Test Result", baseUser);
         }
@@ -75,7 +85,23 @@ public List<TestResultStatDto> get(TestResultStatDto template) throws AqualityEx
         }
     }
 
-    //TODO Refactoring
+    private void createPendingStepResults(TestResultDto template) throws AqualityException {
+        Step2TestDto step2TestTemplate = new Step2TestDto();
+        step2TestTemplate.setProject_id(template.getProject_id());
+        step2TestTemplate.setTest_id(template.getTest_id());
+        List<StepDto> testSteps = stepController.getTestSteps(step2TestTemplate);
+        for (StepDto step : testSteps) {
+            StepResultDto stepResult = new StepResultDto();
+            stepResult.setProject_id(template.getProject_id());
+            stepResult.setResult_id(template.getId());
+            stepResult.setType_id(step.getType_id());
+            stepResult.setName(step.getName());
+            stepResult.setFinal_result_id(3);
+            stepResult.setOrder(step.getOrder());
+            stepResultController.create(stepResult);
+        }
+    }
+
     private List<TestResultDto> fillResults(List<TestResultDto> results) throws AqualityException {
 
         if(results.size() > 0){
@@ -86,20 +112,38 @@ private List<TestResultDto> fillResults(List<TestResultDto> results) throws Aqua
             List<TestDto> tests = testDao.searchAll(testTemplate);
 
             for (TestResultDto result: results){
-
-                result.setFinal_result(finalResults.stream().filter( x -> x.getId().equals(result.getFinal_result_id())).findFirst().orElse(null));
-                result.setTest(tests.stream().filter(x -> x.getId().equals(result.getTest_id())).findFirst().orElse(null));
-                result.setTest_resolution(resolutions.stream().filter( x -> x.getId().equals(result.getTest_resolution_id())).findFirst().orElse(null));
-
-                if(result.getAssignee() != null){
-                    ProjectUserDto projectUserDto = new ProjectUserDto();
-                    projectUserDto.setUser_id(result.getAssignee());
-                    projectUserDto.setProject_id(result.getProject_id());
-                    result.setAssigned_user(projectUserController.get(projectUserDto).get(0));
-                }
+                fillResult(result, finalResults, resolutions, tests);
             }
         }
 
         return results;
     }
+
+    private void fillResult(TestResultDto result, List<FinalResultDto> finalResults, List<ResultResolutionDto> resolutions, List<TestDto> tests) throws AqualityException {
+        if (projectController.isStepsEnabled(result.getProject_id())) {
+            fillResultSteps(result);
+        }
+
+        result.setFinal_result(finalResults.stream().filter(x -> x.getId().equals(result.getFinal_result_id())).findFirst().orElse(null));
+        result.setTest(tests.stream().filter(x -> x.getId().equals(result.getTest_id())).findFirst().orElse(null));
+        result.setTest_resolution(resolutions.stream().filter(x -> x.getId().equals(result.getTest_resolution_id())).findFirst().orElse(null));
+        fillResultAssignee(result);
+    }
+
+    private void fillResultSteps(TestResultDto result) throws AqualityException {
+        StepResultDto stepResultTemplate = new StepResultDto();
+        stepResultTemplate.setResult_id(result.getId());
+        stepResultTemplate.setProject_id(result.getProject_id());
+        result.setSteps(stepResultController.get(stepResultTemplate));
+    }
+
+    private void fillResultAssignee(TestResultDto result) throws AqualityException {
+        if (result.getAssignee() != null) {
+            ProjectUserDto projectUserDto = new ProjectUserDto();
+            projectUserDto.setUser_id(result.getAssignee());
+            projectUserDto.setProject_id(result.getProject_id());
+            result.setAssigned_user(projectUserController.get(projectUserDto).get(0));
+        }
+    }
+
 }