Added feature to integrate aq entities with 3rd party systems (#83)

* added different reference types
* added DataBaseRequired annotation. Allows to mark some fields as required and they will always be sent (for UPDATE especially).
refactored method getIdAndProjectIdSearchParameters
* created common class ProjectEntityController to be base for most of the Controllers related to the project
as result, SystemController and ReferenceController were refactored
added Roles policies and implemented RoleValidator class to check roles
added Procedure to remove references
ReferenceType was extended by adding a method that creates empty DTO
ReferenceServlet has been extended by the support of get and delete methods

* added URL to the table with a list of systems

* generified controllers to use the same for different servlets
added ControlType class to manage a list of supported controllers
extended ProjectEntityController by the new logic of processing permissions and by new additional methods (createTable, deleteInProject)
ReadonlyController has been unified to use Generics
added TestTrackingTypes and TestTrackingStatus tables
added REMOVE_INT_SYSTEMS procedure
DAO extended by new projects
added new interface IEntity
added 3 servlets that provide necessary methods for almost any concrete servlet

* changed the structure of the DB by replacing the int_system_statuses table.
useless classes and methods were removed.
added new tables for storing system workflow statuses

* added publishing controller and related classes

* added triggers on deleting tests, test_runs, issues

* updated trigger on removing resolution
refactored TtsType and SystemType to re-use common logic

* get changed to post in RefStatusServlet as we are going to consume data in this method
added support of options method to be able to support CORS policies

* fixed and removed todos

* CORS policies reverted in BaseServlet
updated version and changelog

Co-authored-by: d.bogatko <[email protected]>

Author: DmitryBogatko

CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## 1.3.0 (2021-02-26)
+ - Added feature that allows to link aquality entities (tests, issues and test runs) with 3rd party systems like Jira, Xray, TestRail and etc.
+ In this version only Jira and Xray support has been added.
+ - Improved and generified work with controllers
+
 ## 1.1.1 (2020-12-15)
 Bugfixes:
 - Added handling of non utf-8 body in the request

pom.xml

@@ -6,7 +6,7 @@
     <groupId>unifi_reporting_api</groupId>
     <artifactId>api</artifactId>
     <packaging>war</packaging>
-    <version>1.1.1</version>
+    <version>1.3.0</version>
 
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
@@ -93,20 +93,21 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-war-plugin</artifactId>
-                <version>3.2.0</version><configuration>
-                <webResources>
-                    <resource>
-                        <filtering>true</filtering>
-                        <directory>src/main/webapp</directory>
-                        <includes>
-                            <include>**/META-INF/context.xml</include>
-                        </includes>
-                    </resource>
-                </webResources>
-                <warSourceDirectory>src/main/webapp</warSourceDirectory>
-                <webXml>src/main/webapp/WEB-INF/web.xml</webXml>
-                <warName>api</warName>
-            </configuration>
+                <version>3.2.0</version>
+                <configuration>
+                    <webResources>
+                        <resource>
+                            <filtering>true</filtering>
+                            <directory>src/main/webapp</directory>
+                            <includes>
+                                <include>**/META-INF/context.xml</include>
+                            </includes>
+                        </resource>
+                    </webResources>
+                    <warSourceDirectory>src/main/webapp</warSourceDirectory>
+                    <webXml>src/main/webapp/WEB-INF/web.xml</webXml>
+                    <warName>api</warName>
+                </configuration>
             </plugin>
         </plugins>
     </build>
@@ -215,5 +216,12 @@
             <artifactId>javax.ws.rs-api</artifactId>
             <version>2.0</version>
         </dependency>
+
+        <!-- JIRA client -->
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+            <version>4.5.8</version>
+        </dependency>
     </dependencies>
 </project>

src/main/java/main/annotations/DataBaseRequired.java

@@ -0,0 +1,12 @@
+package main.annotations;
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(value= ElementType.FIELD)
+@Retention(value= RetentionPolicy.RUNTIME)
+public @interface DataBaseRequired {
+}

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

@@ -4,81 +4,113 @@
 import main.controllers.Administration.StepTypeController;
 import main.controllers.Administration.UserController;
 import main.controllers.Project.*;
+import main.model.db.dao.DAO;
+import main.model.dto.BaseDto;
+import main.model.dto.interfaces.IProjectEntity;
 import main.model.dto.project.*;
 import main.model.dto.settings.EmailSettingsDto;
 import main.model.dto.settings.UserDto;
 
 public class ControllerFactory {
     private UserDto user;
 
-    public ControllerFactory(UserDto user){
+    public ControllerFactory(UserDto user) {
         this.user = user;
     }
 
     public ProjectController getHandler(ProjectDto entity) {
         return new ProjectController(user);
     }
+
     public BodyPatternController getHandler(BodyPatternDto entity) {
         return new BodyPatternController(user);
     }
+
     public FinalResultController getHandler(FinalResultDto entity) {
         return new FinalResultController(user);
     }
+
     public ImportController getHandler(ImportDto entity) {
         return new ImportController(user);
     }
+
     public APITokenController getHandler(APITokenDto entity) {
         return new APITokenController(user);
     }
+
     public MilestoneController getHandler(MilestoneDto entity) {
         return new MilestoneController(user);
     }
+
     public ProjectUserController getHandler(ProjectUserDto entity) {
         return new ProjectUserController(user);
     }
+
     public ResultController getHandler(TestResultDto entity) {
         return new ResultController(user);
     }
+
     public ResultResolutionController getHandler(ResultResolutionDto entity) {
         return new ResultResolutionController(user);
     }
+
     public SuiteController getHandler(TestSuiteDto entity) {
         return new SuiteController(user);
     }
+
     public SuiteDashboardController getHandler(SuiteDashboardDto entity) {
         return new SuiteDashboardController(user);
     }
+
     public Test2SuiteController getHandler(Test2SuiteDto entity) {
         return new Test2SuiteController(user);
     }
+
     public TestController getHandler(TestDto entity) {
         return new TestController(user);
     }
+
     public TestRunController getHandler(TestRunDto entity) {
         return new TestRunController(user);
     }
+
     public UserController getHandler(UserDto entity) {
         return new UserController(user);
     }
+
     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);
     }
+
     public PredefinedResolutionController getHandler(PredefinedResolutionDto entity) {
         return new PredefinedResolutionController(user);
     }
+
     public IssueController getHandler(IssueDto entity) {
         return new IssueController(user);
     }
+
     public TestResultAttachmentController getHandler(TestResultAttachmentDto entity) {
         return new TestResultAttachmentController(user);
     }
-}
+
+    public <T extends BaseDto & IProjectEntity, D extends DAO<T>> ProjectEntityController<T, D> getProjectEntityHandler(ControllerType<T, D> controllerType) {
+        return new ProjectEntityController<>(user, controllerType.createDao());
+    }
+
+    public <T extends BaseDto, D extends DAO<T>> ReadonlyController<T, D> getReadonlyHandler(ControllerType<T, D> controllerType) {
+        return new ReadonlyController<>(user, controllerType.createDao());
+    }
+}

src/main/java/main/controllers/ControllerType.java

@@ -0,0 +1,61 @@
+package main.controllers;
+
+import main.model.db.dao.DAO;
+import main.model.db.dao.integrations.ReferenceDao;
+import main.model.db.dao.integrations.PubItemDao;
+import main.model.db.dao.integrations.systems.SystemDao;
+import main.model.db.dao.integrations.systems.SystemTypeDao;
+import main.model.db.dao.integrations.systems.workflow.SystemWorkflowStatusDao;
+import main.model.db.dao.integrations.systems.workflow.SystemWorkflowStatusTypeDao;
+import main.model.db.dao.integrations.tts.TestTrackingStatusDao;
+import main.model.db.dao.integrations.tts.TestTrackingTypeDao;
+import main.model.dto.BaseDto;
+import main.model.dto.integrations.publishing.PubItemDto;
+import main.model.dto.integrations.references.IssueReferenceDto;
+import main.model.dto.integrations.references.ReferenceType;
+import main.model.dto.integrations.references.TestReferenceDto;
+import main.model.dto.integrations.references.TestRunReferenceDto;
+import main.model.dto.integrations.systems.SystemDto;
+import main.model.dto.integrations.systems.SystemTypeDto;
+import main.model.dto.integrations.systems.workflow.SystemWorkflowStatusDto;
+import main.model.dto.integrations.systems.workflow.SystemWorkflowStatusTypeDto;
+import main.model.dto.integrations.tts.TestTrackingStatusDto;
+import main.model.dto.integrations.tts.TestTrackingTypeDto;
+
+import java.util.function.Supplier;
+
+public class ControllerType<T extends BaseDto, D extends DAO<T>> {
+
+    public static final ControllerType<TestReferenceDto, ReferenceDao<TestReferenceDto>> REF_TEST_CONTROLLER = new ControllerType<TestReferenceDto, ReferenceDao<TestReferenceDto>>(TestReferenceDto::new, () -> new ReferenceDao<>(ReferenceType.TEST), TestReferenceDto.class);
+    public static final ControllerType<TestRunReferenceDto, ReferenceDao<TestRunReferenceDto>> REF_TESTRUN_CONTROLLER = new ControllerType<TestRunReferenceDto, ReferenceDao<TestRunReferenceDto>>(TestRunReferenceDto::new, () -> new ReferenceDao<>(ReferenceType.TEST_RUN), TestRunReferenceDto.class);
+    public static final ControllerType<IssueReferenceDto, ReferenceDao<IssueReferenceDto>> REF_ISSUE_CONTROLLER = new ControllerType<IssueReferenceDto, ReferenceDao<IssueReferenceDto>>(IssueReferenceDto::new, () -> new ReferenceDao<>(ReferenceType.ISSUE), IssueReferenceDto.class);
+    public static final ControllerType<TestTrackingStatusDto, TestTrackingStatusDao> TTS_STATUS_CONTROLLER = new ControllerType<>(TestTrackingStatusDto::new, TestTrackingStatusDao::new, TestTrackingStatusDto.class);
+    public static final ControllerType<SystemDto, SystemDao> SYSTEM_CONTROLLER = new ControllerType<>(SystemDto::new, SystemDao::new, SystemDto.class);
+    public static final ControllerType<SystemTypeDto, SystemTypeDao> SYSTEM_TYPE_CONTROLLER = new ControllerType<>(SystemTypeDto::new, SystemTypeDao::new, SystemTypeDto.class);
+    public static final ControllerType<SystemWorkflowStatusTypeDto, SystemWorkflowStatusTypeDao> SYSTEM_WORKFLOW_STATUS_TYPE_CONTROLLER = new ControllerType<>(SystemWorkflowStatusTypeDto::new, SystemWorkflowStatusTypeDao::new, SystemWorkflowStatusTypeDto.class);
+    public static final ControllerType<SystemWorkflowStatusDto, SystemWorkflowStatusDao> SYSTEM_WORKFLOW_STATUS_CONTROLLER = new ControllerType<>(SystemWorkflowStatusDto::new, SystemWorkflowStatusDao::new, SystemWorkflowStatusDto.class);
+    public static final ControllerType<TestTrackingTypeDto, TestTrackingTypeDao> TTS_TYPE_CONTROLLER = new ControllerType<>(TestTrackingTypeDto::new, TestTrackingTypeDao::new, TestTrackingTypeDto.class);
+    public static final ControllerType<PubItemDto, PubItemDao> PUBLISHING_CONTROLLER = new ControllerType<>(PubItemDto::new, PubItemDao::new, PubItemDto.class);
+
+    private final Supplier<T> dtoSupplier;
+    private final Supplier<D> daoSupplier;
+    private final Class<T> dtoClass;
+
+    private ControllerType(Supplier<T> dtoSupplier, Supplier<D> daoSupplier, Class<T> dtoClass) {
+        this.dtoSupplier = dtoSupplier;
+        this.daoSupplier = daoSupplier;
+        this.dtoClass = dtoClass;
+    }
+
+    D createDao() {
+        return daoSupplier.get();
+    }
+
+    public T createDto() {
+        return dtoSupplier.get();
+    }
+
+    public Class<T> getDtoClass() {
+        return dtoClass;
+    }
+}

src/main/java/main/controllers/Project/TestController.java

@@ -155,7 +155,6 @@ protected List<TestResultDto> getResultsToMove(TestDto from, TestDto to) {
         return resultsToMove;
     }
 
-    //TODO Refactoring
     private List<TestDto> fillTests(List<TestDto> tests) throws AqualityException {
         List<TestDto> filledTests = new ArrayList<>();
         if (tests.size() > 0) {
@@ -186,7 +185,6 @@ private List<TestDto> fillTests(List<TestDto> tests) throws AqualityException {
         return filledTests;
     }
 
-    //TODO Refactoring
     private void updateSuites(TestDto test) throws AqualityException {
         Test2SuiteDto test2SuiteDto = new Test2SuiteDto();
         test2SuiteDto.setTest_id(test.getId());

src/main/java/main/controllers/ProjectEntityController.java

@@ -0,0 +1,63 @@
+package main.controllers;
+
+import main.exceptions.AqualityException;
+import main.exceptions.AqualityPermissionsException;
+import main.model.db.dao.DAO;
+import main.model.dto.BaseDto;
+import main.model.dto.interfaces.IProjectEntity;
+import main.model.dto.project.ProjectUserDto;
+import main.model.dto.roles.GlobalRole;
+import main.model.dto.roles.ProjectRole;
+import main.model.dto.roles.RolePair;
+import main.model.dto.roles.RoleValidator;
+import main.model.dto.settings.UserDto;
+
+import java.util.List;
+
+public class ProjectEntityController<DTO extends BaseDto & IProjectEntity, D extends DAO<DTO>> extends ReadonlyController<DTO, D> {
+
+    public ProjectEntityController(UserDto user, D dao) {
+        super(user, dao);
+    }
+
+    @Override
+    public DTO create(DTO entity) throws AqualityException {
+        validateRoles(entity, getRolesPermittedToCreate());
+        return dao.create(entity);
+    }
+
+    @Override
+    public List<DTO> get(DTO entity) throws AqualityException {
+        validateRoles(entity, getRolesPermittedToGet());
+        return dao.searchAll(entity);
+    }
+
+    @Override
+    public boolean delete(DTO entity) throws AqualityException {
+        validateRoles(entity, getRolesPermittedToDelete());
+        return dao.delete(entity);
+    }
+
+    private RolePair getRolesPermittedToGet() {
+        return new RolePair(GlobalRole.ADMIN, ProjectRole.VIEWER);
+    }
+
+    private RolePair getRolesPermittedToCreate() {
+        return new RolePair(GlobalRole.ADMIN, ProjectRole.ENGINEER);
+    }
+
+    protected RolePair getRolesPermittedToDelete() {
+        return new RolePair(GlobalRole.ADMIN, ProjectRole.ENGINEER);
+    }
+
+    private void validateRoles(DTO entity, RolePair roles) throws AqualityException {
+        GlobalRole globalRole = roles.getGlobal();
+        ProjectRole projectRole = roles.getProject();
+        ProjectUserDto projectUser = baseUser.getProjectUser(entity.getProjectId());
+        if (!(RoleValidator.atLeastInRole(globalRole, baseUser) || RoleValidator.atLeastInRole(projectRole, projectUser))) {
+            throw new AqualityPermissionsException(String.format("You should be global '%1$s' or at least project '%2$s' to perform this action",
+                    globalRole.getName(), projectRole.getName()),
+                    baseUser);
+        }
+    }
+}

src/main/java/main/controllers/ReadonlyController.java

@@ -0,0 +1,36 @@
+package main.controllers;
+
+import main.exceptions.AqualityException;
+import main.model.db.dao.DAO;
+import main.model.dto.BaseDto;
+import main.model.dto.settings.UserDto;
+
+import java.util.List;
+
+public class ReadonlyController<T extends BaseDto, D extends DAO<T>> extends BaseController<T> {
+    protected D dao;
+
+    public ReadonlyController(UserDto user, D dao) {
+        super(user);
+        this.dao = dao;
+    }
+
+    @Override
+    public List<T> get(T entity) throws AqualityException {
+        return dao.searchAll(entity);
+    }
+
+    @Override
+    public T create(T entity) throws AqualityException {
+        throw getUnsupportedException("CREATE");
+    }
+
+    @Override
+    public boolean delete(T entity) throws AqualityException {
+        throw getUnsupportedException("DELETE");
+    }
+
+    private AqualityException getUnsupportedException(String operationName) {
+        return new AqualityException("Operation " + operationName + " is not supported for integration_systems table. This table includes list of constants.");
+    }
+}