diff --git a/lib/pom.xml b/lib/pom.xml index dc452827b..53f93e7ba 100644 --- a/lib/pom.xml +++ b/lib/pom.xml @@ -1,20 +1,20 @@ - 4.0.0 - org.taskana - taskana-parent - 0.0.1-SNAPSHOT - pom + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + 4.0.0 + org.taskana + taskana-parent + 0.0.1-SNAPSHOT + pom - - 1.8 - + + 1.8 + - - taskana-core - taskana-cdi - taskana-spring - taskana-cdi-example - taskana-spring-example - - \ No newline at end of file + + taskana-core + taskana-cdi + taskana-spring + taskana-cdi-example + taskana-spring-example + + diff --git a/lib/taskana-core/checkstyle.xml b/lib/taskana-core/checkstyle.xml new file mode 100644 index 000000000..f867dd45c --- /dev/null +++ b/lib/taskana-core/checkstyle.xml @@ -0,0 +1,135 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/lib/taskana-core/pom.xml b/lib/taskana-core/pom.xml index f679ec525..86429595d 100644 --- a/lib/taskana-core/pom.xml +++ b/lib/taskana-core/pom.xml @@ -55,4 +55,42 @@ test - \ No newline at end of file + + + + org.apache.maven.plugins + maven-checkstyle-plugin + 2.17 + + + validate + validate + + checkstyle.xml + UTF-8 + true + true + true + true + + + check + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.5.1 + + true + true + + -Xlint:all + + + + + + diff --git a/lib/taskana-core/src/main/java/org/taskana/ClassificationService.java b/lib/taskana-core/src/main/java/org/taskana/ClassificationService.java index 7c62a342b..d9553eee2 100644 --- a/lib/taskana-core/src/main/java/org/taskana/ClassificationService.java +++ b/lib/taskana-core/src/main/java/org/taskana/ClassificationService.java @@ -4,45 +4,43 @@ import java.util.List; import org.taskana.model.Classification; +/** + * This class manages the classifications. + */ public interface ClassificationService { - /** - * Get all available Classifications - * - * @return The List of all Classifications - */ - public List selectClassifications(); + /** + * Get all available Classifications. + * @return The List of all Classifications + */ + List selectClassifications(); - /** - * Get all Classifications with given parent - * - * @param parentId - * the ID of the parent Classification - * @return - */ - public List selectClassificationsByParentId(String parentId); + /** + * Get all Classifications with given parent. + * @param parentId + * the ID of the parent Classification + * @return + */ + List selectClassificationsByParentId(String parentId); - /** - * Get a Classification for a given id - * - * @param id - * @return the requested Classification - */ - public Classification selectClassificationById(String id); + /** + * Get a Classification for a given id. + * @param id + * @return the requested Classification + */ + Classification selectClassificationById(String id); - /** - * Insert a new Classification - * - * @param classification - * the classification to insert - */ - public void insertClassification(Classification classification); + /** + * Insert a new Classification. + * @param classification + * the classification to insert + */ + void insertClassification(Classification classification); - /** - * Update a Classification - * - * @param classification - * the Classification to update - */ - public void updateClassification(Classification classification); + /** + * Update a Classification. + * @param classification + * the Classification to update + */ + void updateClassification(Classification classification); } diff --git a/lib/taskana-core/src/main/java/org/taskana/TaskService.java b/lib/taskana-core/src/main/java/org/taskana/TaskService.java index 55b63d4c6..c652ca667 100644 --- a/lib/taskana-core/src/main/java/org/taskana/TaskService.java +++ b/lib/taskana-core/src/main/java/org/taskana/TaskService.java @@ -10,125 +10,115 @@ import org.taskana.model.Task; import org.taskana.model.TaskState; import org.taskana.model.TaskStateCounter; +/** + * The Task Service manages all operations on tasks. + */ public interface TaskService { - /** - * Claim an existing task - * - * @param id - * task id - * @param userName - * user who claims the task - * @throws TaskNotFoundException - */ - public void claim(String id, String userName) throws TaskNotFoundException; + /** + * Claim an existing task. + * @param id + * task id + * @param userName + * user who claims the task + * @throws TaskNotFoundException + */ + void claim(String id, String userName) throws TaskNotFoundException; - /** - * Set task to completed - * - * @param taskId - * the task id - * @throws TaskNotFoundException - */ - public void complete(String taskId) throws TaskNotFoundException; + /** + * Set task to completed. + * @param taskId + * the task id + * @throws TaskNotFoundException + */ + void complete(String taskId) throws TaskNotFoundException; - /** - * Create a task by a task object - * - * @param task - * @return the created task - * @throws NotAuthorizedException - */ - public Task create(Task task) throws NotAuthorizedException; + /** + * Create a task by a task object. + * @param task + * @return the created task + * @throws NotAuthorizedException + */ + Task create(Task task) throws NotAuthorizedException; - /** - * Get the details of a task - * - * @param taskId - * the id of the task - * @return the Task - */ - public Task getTaskById(String taskId) throws TaskNotFoundException; + /** + * Get the details of a task. + * @param taskId + * the id of the task + * @return the Task + */ + Task getTaskById(String taskId) throws TaskNotFoundException; - /** - * Query all tasks for a workbasket. - * - * @param workbasketId - * the workbasket to query - * @return the list of tasks, which reside in the workbasket - * @throws NotAuthorizedException - */ - public List getTasksForWorkbasket(String workbasketId) throws NotAuthorizedException; + /** + * Query all tasks for a workbasket. + * @param workbasketId + * the workbasket to query + * @return the list of tasks, which reside in the workbasket + * @throws NotAuthorizedException + */ + List getTasksForWorkbasket(String workbasketId) throws NotAuthorizedException; - /** - * Query all tasks for a workbasket. - * - * @param workbasketId - * the workbasket to query - * @return the list of tasks, which reside in the workbasket - * @throws NotAuthorizedException - */ - public List getTasksForWorkbasket(List workbaskets, List states) - throws NotAuthorizedException; + /** + * Query all tasks for a workbasket. + * @param workbasketId + * the workbasket to query + * @return the list of tasks, which reside in the workbasket + * @throws NotAuthorizedException + */ + List getTasksForWorkbasket(List workbaskets, List states) throws NotAuthorizedException; - /** - * This method returns all Tasks - * - * @return a {@link List} of {@link Task} - */ - public List getTasks(); + /** + * This method returns all Tasks. + * @return a {@link List} of {@link Task} + */ + List getTasks(); - /** - * This method counts all tasks with a given state. - * - * @param states - * the countable states - * @return a List of {@link TaskStateCounter} - */ - public List getTaskCountForState(List states); + /** + * This method counts all tasks with a given state. + * @param states + * the countable states + * @return a List of {@link TaskStateCounter} + */ + List getTaskCountForState(List states); - /** - * This method returns all tasks with the specified states - * - * @param states all List with the needed states - * @return a list of Tasks - */ - public List findTasks(List states); + /** + * This method returns all tasks with the specified states. + * @param states + * all List with the needed states + * @return a list of Tasks + */ + List findTasks(List states); - /** - * Count all Tasks in a given workbasket with daysInPast as Days from today - * in the past and a specific state. - * - * @param workbasketId - * @param daysInPast - * @param states - * @return - */ - public long getTaskCountForWorkbasketByDaysInPastAndState(String workbasketId, long daysInPast, - List states); + /** + * Count all Tasks in a given workbasket with daysInPast as Days from today in + * the past and a specific state. + * @param workbasketId + * @param daysInPast + * @param states + * @return + */ + long getTaskCountForWorkbasketByDaysInPastAndState(String workbasketId, long daysInPast, List states); - /** - * Transfer task to another workbasket. - * - * The transfer set the transferred flag and resets the read flag. - * - * @param workbasketId - * @return the updated task - * @throws NotAuthorizedException - */ - public Task transfer(String taskId, String workbasketId) - throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException; - - /** - * Marks a task as read. - * - * @param taskId the id of the task to be updated - * @param isRead the new status of the read flag. - * @return Task the updated Task - */ - public Task setTaskRead(String taskId, boolean isRead) throws TaskNotFoundException; + /** + * Transfer task to another workbasket. The transfer set the transferred flag + * and resets the read flag. + * @param workbasketId + * @return the updated task + * @throws NotAuthorizedException + */ + Task transfer(String taskId, String workbasketId) + throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException; - public List getTaskCountByWorkbasketAndDaysInPastAndState(long daysInPast, - List states); + /** + * Marks a task as read. + * @param taskId + * the id of the task to be updated + * @param isRead + * the new status of the read flag. + * @return Task the updated Task + */ + Task setTaskRead(String taskId, boolean isRead) throws TaskNotFoundException; + + List getTaskCountByWorkbasketAndDaysInPastAndState(long daysInPast, List states); } diff --git a/lib/taskana-core/src/main/java/org/taskana/TaskanaEngine.java b/lib/taskana-core/src/main/java/org/taskana/TaskanaEngine.java index 62e7c9ff4..a53b99528 100644 --- a/lib/taskana-core/src/main/java/org/taskana/TaskanaEngine.java +++ b/lib/taskana-core/src/main/java/org/taskana/TaskanaEngine.java @@ -3,34 +3,31 @@ package org.taskana; import org.taskana.configuration.TaskanaEngineConfiguration; /** - * The TaskanaEngine represents an overall set of all needed services + * The TaskanaEngine represents an overall set of all needed services. */ public interface TaskanaEngine { - /** - * The TaskService can be used for operations on all Tasks - * - * @return the TaskService - */ - public TaskService getTaskService(); + /** + * The TaskService can be used for operations on all Tasks. + * @return the TaskService + */ + TaskService getTaskService(); - /** - * The WorkbasketService can be used for operations on all Workbaskets - * - * @return the TaskService - */ - public WorkbasketService getWorkbasketService(); + /** + * The WorkbasketService can be used for operations on all Workbaskets. + * @return the TaskService + */ + WorkbasketService getWorkbasketService(); - /** - * The ClassificationService can be used for operations on all Categories - * - * @return the TaskService - */ - public ClassificationService getClassificationService(); + /** + * The ClassificationService can be used for operations on all Categories. + * @return the TaskService + */ + ClassificationService getClassificationService(); - /** - * The Taskana configuration - * @return the TaskanaConfiguration - */ - public TaskanaEngineConfiguration getConfiguration(); + /** + * The Taskana configuration. + * @return the TaskanaConfiguration + */ + TaskanaEngineConfiguration getConfiguration(); } diff --git a/lib/taskana-core/src/main/java/org/taskana/WorkbasketService.java b/lib/taskana-core/src/main/java/org/taskana/WorkbasketService.java index d5f8f536a..e6beabaa3 100644 --- a/lib/taskana-core/src/main/java/org/taskana/WorkbasketService.java +++ b/lib/taskana-core/src/main/java/org/taskana/WorkbasketService.java @@ -8,117 +8,106 @@ import org.taskana.model.Workbasket; import org.taskana.model.WorkbasketAccessItem; import org.taskana.model.WorkbasketAuthorization; +/** + * This service manages the Workbaskets. + */ public interface WorkbasketService { - /** - * Get Workbasket for a given id. - * - * @param workbasketId - * @return the requested Workbasket - */ - public Workbasket getWorkbasket(String workbasketId) throws WorkbasketNotFoundException; + /** + * Get Workbasket for a given id. + * @param workbasketId + * @return the requested Workbasket + */ + Workbasket getWorkbasket(String workbasketId) throws WorkbasketNotFoundException; - /** - * Get all available Workbaskets. - * - * @return List the list of all workbaskets - */ - public List getWorkbaskets(); + /** + * Get all available Workbaskets. + * @return List the list of all workbaskets + */ + List getWorkbaskets(); - /** - * Create a new Workbasket. - * - * @param workbasket - * The workbasket to create - * @throws NotAuthorizedException - */ - public Workbasket createWorkbasket(Workbasket workbasket); + /** + * Create a new Workbasket. + * @param workbasket + * The workbasket to create + * @throws NotAuthorizedException + */ + Workbasket createWorkbasket(Workbasket workbasket); - /** - * Update a Workbasket. - * - * - * @param workbasket - * The workbasket to update - * @throws NotAuthorizedException - */ - public Workbasket updateWorkbasket(Workbasket workbasket) throws NotAuthorizedException; + /** + * Update a Workbasket. + * @param workbasket + * The workbasket to update + * @throws NotAuthorizedException + */ + Workbasket updateWorkbasket(Workbasket workbasket) throws NotAuthorizedException; - /** - * Create a new authorization for a specific workbasket and a specific user - * - * @param workbasket - * the choosen workbasket - * @param user - * the choosen user - * @return - */ - public WorkbasketAccessItem createWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem); + /** + * Create a new authorization for a specific workbasket and a specific user. + * @param workbasket + * the choosen workbasket + * @param user + * the choosen user + * @return + */ + WorkbasketAccessItem createWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem); - /** - * This method updates an Workbasket Authorization - * - * @param workbasketAccessItem - * the Authorization - * @return the updated entity - */ - public WorkbasketAccessItem updateWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem); + /** + * This method updates an Workbasket Authorization. + * @param workbasketAccessItem + * the Authorization + * @return the updated entity + */ + WorkbasketAccessItem updateWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem); - /** - * Get all authorizations of the workbasket - * - * @return a WorkbasketAccessItem list - */ - public List getAllAuthorizations(); + /** + * Get all authorizations of the workbasket. + * @return a WorkbasketAccessItem list + */ + List getAllAuthorizations(); - /** - * Deletes a specific authorization - * - * @param id - * the specific id - */ - public void deleteWorkbasketAuthorization(String id); + /** + * Deletes a specific authorization. + * @param id + * the specific id + */ + void deleteWorkbasketAuthorization(String id); - /** - * This method checks the authorization with the saved one - * - * @param workbasket - * the workbasket to check - * @param userId - * the user to check - * @param authorization - * the needed Authorization - * @throws WorkbasketNotFoundException - * if the workbasket do not exist - * @throws NotAuthorizedException - */ - public void checkAuthorization(String workbasketId, WorkbasketAuthorization authorization) - throws NotAuthorizedException; + /** + * This method checks the authorization with the saved one. + * @param workbasket + * the workbasket to check + * @param userId + * the user to check + * @param authorization + * the needed Authorization + * @throws WorkbasketNotFoundException + * if the workbasket do not exist + * @throws NotAuthorizedException + */ + void checkAuthorization(String workbasketId, WorkbasketAuthorization authorization) throws NotAuthorizedException; - /** - * This method get one WorkbasketAuthorization with an id - * - * @param id - * the id - * @return the full {@link WorkbasketAccessItem} - */ - public WorkbasketAccessItem getWorkbasketAuthorization(String id); + /** + * This method get one WorkbasketAuthorization with an id. + * @param id + * the id + * @return the full {@link WorkbasketAccessItem} + */ + WorkbasketAccessItem getWorkbasketAuthorization(String id); - /** - * Get all authorizations for a Workbasket. - * - * @param workbasketId - * @return List - */ - public List getWorkbasketAuthorizations(String workbasketId); + /** + * Get all authorizations for a Workbasket. + * @param workbasketId + * @return List + */ + List getWorkbasketAuthorizations(String workbasketId); - /** - * This method provides workbaskets via an permission - * - * @param permission - * as String like in this enum: {@link WorkbasketAuthorization} - * @return all filtered workbaskets - */ - List getWorkbaskets(List permission); + /** + * This method provides workbaskets via an permission. + * @param permission + * as String like in this enum: {@link WorkbasketAuthorization} + * @return all filtered workbaskets + */ + List getWorkbaskets(List permission); } diff --git a/lib/taskana-core/src/main/java/org/taskana/configuration/DbScriptRunner.java b/lib/taskana-core/src/main/java/org/taskana/configuration/DbScriptRunner.java index 3b3a47711..ac32342dc 100644 --- a/lib/taskana-core/src/main/java/org/taskana/configuration/DbScriptRunner.java +++ b/lib/taskana-core/src/main/java/org/taskana/configuration/DbScriptRunner.java @@ -11,67 +11,68 @@ import org.apache.ibatis.jdbc.ScriptRunner; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +/** + * This class create the schema for taskana. + */ public class DbScriptRunner { - private static final Logger logger = LoggerFactory.getLogger(DbScriptRunner.class); + private static final Logger LOGGER = LoggerFactory.getLogger(DbScriptRunner.class); - private static final String SQL = "/sql"; - private static final String DB_SCHEMA = SQL + "/taskana-schema.sql"; - private static final String DB_SCHEMA_DETECTION = SQL + "/schema-detection.sql"; + private static final String SQL = "/sql"; + private static final String DB_SCHEMA = SQL + "/taskana-schema.sql"; + private static final String DB_SCHEMA_DETECTION = SQL + "/schema-detection.sql"; - private DataSource dataSource; + private DataSource dataSource; - private StringWriter outWriter = new StringWriter(); - private PrintWriter logWriter = new PrintWriter(outWriter); - private StringWriter errorWriter = new StringWriter(); - private PrintWriter errorLogWriter = new PrintWriter(errorWriter); + private StringWriter outWriter = new StringWriter(); + private PrintWriter logWriter = new PrintWriter(outWriter); + private StringWriter errorWriter = new StringWriter(); + private PrintWriter errorLogWriter = new PrintWriter(errorWriter); - public DbScriptRunner(DataSource dataSource) { - super(); - this.dataSource = dataSource; - } + public DbScriptRunner(DataSource dataSource) { + super(); + this.dataSource = dataSource; + } + /** + * Run all db scripts. + * @throws SQLException + */ + public void run() throws SQLException { + ScriptRunner runner = new ScriptRunner(dataSource.getConnection()); + LOGGER.debug(dataSource.getConnection().getMetaData().toString()); - /** - * Run all db scripts - * - * @throws SQLException - */ - public void run() throws SQLException { - ScriptRunner runner = new ScriptRunner(dataSource.getConnection()); - logger.debug(dataSource.getConnection().getMetaData().toString()); + runner.setStopOnError(true); + runner.setLogWriter(logWriter); + runner.setErrorLogWriter(errorLogWriter); - runner.setStopOnError(true); - runner.setLogWriter(logWriter); - runner.setErrorLogWriter(errorLogWriter); + if (!isSchemaPreexisting(runner)) { + runner.runScript(new InputStreamReader(this.getClass().getResourceAsStream(DB_SCHEMA))); + } + runner.closeConnection(); - if (!isSchemaPreexisting(runner)) { - runner.runScript(new InputStreamReader(this.getClass().getResourceAsStream(DB_SCHEMA))); - } - runner.closeConnection(); + LOGGER.debug(outWriter.toString()); + if (!errorWriter.toString().trim().isEmpty()) { + LOGGER.error(errorWriter.toString()); + } + } - logger.debug(outWriter.toString()); - if (!errorWriter.toString().trim().isEmpty()) { - logger.error(errorWriter.toString()); - } - } + private boolean isSchemaPreexisting(ScriptRunner runner) { + try { + runner.runScript(new InputStreamReader(this.getClass().getResourceAsStream(DB_SCHEMA_DETECTION))); + } catch (Exception e) { + LOGGER.debug("Schema does not exist."); + return false; + } + LOGGER.debug("Schema does exist."); + return true; + } - private boolean isSchemaPreexisting(ScriptRunner runner) { - try { - runner.runScript(new InputStreamReader(this.getClass().getResourceAsStream(DB_SCHEMA_DETECTION))); - } catch (Exception e) { - logger.debug("Schema does not exist."); - return false; - } - logger.debug("Schema does exist."); - return true; - } + public DataSource getDataSource() { + return dataSource; + } - public DataSource getDataSource() { - return dataSource; - } - - public void setDataSource(DataSource dataSource) { - this.dataSource = dataSource; - } + public void setDataSource(DataSource dataSource) { + this.dataSource = dataSource; + } } diff --git a/lib/taskana-core/src/main/java/org/taskana/configuration/TaskanaEngineConfiguration.java b/lib/taskana-core/src/main/java/org/taskana/configuration/TaskanaEngineConfiguration.java index b6cd9c9a9..321fe72dc 100644 --- a/lib/taskana-core/src/main/java/org/taskana/configuration/TaskanaEngineConfiguration.java +++ b/lib/taskana-core/src/main/java/org/taskana/configuration/TaskanaEngineConfiguration.java @@ -12,85 +12,82 @@ import org.taskana.impl.TaskanaEngineImpl; /** * This central class creates the TaskanaEngine and needs all the information - * about DB and Security + * about DB and Security. */ public class TaskanaEngineConfiguration { - private static final Logger logger = LoggerFactory.getLogger(TaskanaEngineConfiguration.class); + private static final Logger LOGGER = LoggerFactory.getLogger(TaskanaEngineConfiguration.class); - private static final String USER_PASSWORD = "sa"; - private static final String JDBC_H2_MEM_TASKANA = "jdbc:h2:mem:taskana"; - private static final String H2_DRIVER = "org.h2.Driver"; + private static final String USER_PASSWORD = "sa"; + private static final String JDBC_H2_MEM_TASKANA = "jdbc:h2:mem:taskana"; + private static final String H2_DRIVER = "org.h2.Driver"; - protected DataSource dataSource; - protected DbScriptRunner dbScriptRunner; + protected DataSource dataSource; + protected DbScriptRunner dbScriptRunner; - // global switch to enable JAAS based authentication and Taskana - // authorizations - protected boolean securityEnabled; - protected boolean useContainerManagedTransactions; + // global switch to enable JAAS based authentication and Taskana + // authorizations + protected boolean securityEnabled; + protected boolean useContainerManagedTransactions; - public TaskanaEngineConfiguration() { - } + public TaskanaEngineConfiguration() { + } - public TaskanaEngineConfiguration(DataSource dataSource, boolean useContainerManagedTransactions) - throws SQLException { - this(dataSource, useContainerManagedTransactions, true); - } + public TaskanaEngineConfiguration(DataSource dataSource, boolean useContainerManagedTransactions) + throws SQLException { + this(dataSource, useContainerManagedTransactions, true); + } - public TaskanaEngineConfiguration(DataSource dataSource, boolean useContainerManagedTransactions, - boolean securityEnabled) throws SQLException { - this.useContainerManagedTransactions = useContainerManagedTransactions; - - if (dataSource != null) { - this.dataSource = dataSource; - } else { - // use default In Memory datasource - this.dataSource = createDefaultDataSource(); - } - dbScriptRunner = new DbScriptRunner(this.dataSource); - dbScriptRunner.run(); + public TaskanaEngineConfiguration(DataSource dataSource, boolean useContainerManagedTransactions, + boolean securityEnabled) throws SQLException { + this.useContainerManagedTransactions = useContainerManagedTransactions; - this.securityEnabled = securityEnabled; - } + if (dataSource != null) { + this.dataSource = dataSource; + } else { + // use default In Memory datasource + this.dataSource = createDefaultDataSource(); + } + dbScriptRunner = new DbScriptRunner(this.dataSource); + dbScriptRunner.run(); - public DataSource createDefaultDataSource() { - logger.warn("No datasource is provided. A inmemory db is used: " - + "'org.h2.Driver', 'jdbc:h2:mem:taskana', 'sa', 'sa'"); - return createDatasource(H2_DRIVER, JDBC_H2_MEM_TASKANA, USER_PASSWORD, USER_PASSWORD); - } + this.securityEnabled = securityEnabled; + } - /** - * This method creates the TaskanaEngine without an sqlSessionFactory - * - * @return the TaskanaEngine - * @throws SQLException - */ - public TaskanaEngine buildTaskanaEngine() throws SQLException { - return new TaskanaEngineImpl(this); - } + public DataSource createDefaultDataSource() { + LOGGER.warn("No datasource is provided. A inmemory db is used: " + + "'org.h2.Driver', 'jdbc:h2:mem:taskana', 'sa', 'sa'"); + return createDatasource(H2_DRIVER, JDBC_H2_MEM_TASKANA, USER_PASSWORD, USER_PASSWORD); + } - /** - * This method creates a PooledDataSource, if the needed properties are - * provided - * - * @param dbConfiguration - * @return DataSource - */ - public DataSource createDatasource(String driver, String jdbcUrl, String username, String password) { - return new PooledDataSource(driver, jdbcUrl, username, password); - } + /** + * This method creates the TaskanaEngine without an sqlSessionFactory. + * @return the TaskanaEngine + * @throws SQLException + */ + public TaskanaEngine buildTaskanaEngine() throws SQLException { + return new TaskanaEngineImpl(this); + } - public boolean isSecurityEnabled() { - return this.securityEnabled; - } + /** + * This method creates a PooledDataSource, if the needed properties are provided. + * @param dbConfiguration + * @return DataSource + */ + public DataSource createDatasource(String driver, String jdbcUrl, String username, String password) { + return new PooledDataSource(driver, jdbcUrl, username, password); + } - public DataSource getDatasource() { - return this.dataSource; - } + public boolean isSecurityEnabled() { + return this.securityEnabled; + } - public boolean getUseContainerManagedTransactions() { - return this.useContainerManagedTransactions; - } + public DataSource getDatasource() { + return this.dataSource; + } + + public boolean getUseContainerManagedTransactions() { + return this.useContainerManagedTransactions; + } } diff --git a/lib/taskana-core/src/main/java/org/taskana/exceptions/NotAuthorizedException.java b/lib/taskana-core/src/main/java/org/taskana/exceptions/NotAuthorizedException.java index f4ae9fdf8..2064668b0 100644 --- a/lib/taskana-core/src/main/java/org/taskana/exceptions/NotAuthorizedException.java +++ b/lib/taskana-core/src/main/java/org/taskana/exceptions/NotAuthorizedException.java @@ -1,10 +1,12 @@ package org.taskana.exceptions; +/** + * This exception is used to communicate a not authorized user. + */ @SuppressWarnings("serial") public class NotAuthorizedException extends Exception { - public NotAuthorizedException(String msg) { - super(msg); - } - + public NotAuthorizedException(String msg) { + super(msg); + } } diff --git a/lib/taskana-core/src/main/java/org/taskana/exceptions/NotFoundException.java b/lib/taskana-core/src/main/java/org/taskana/exceptions/NotFoundException.java index eab40a39b..5cd8ff161 100644 --- a/lib/taskana-core/src/main/java/org/taskana/exceptions/NotFoundException.java +++ b/lib/taskana-core/src/main/java/org/taskana/exceptions/NotFoundException.java @@ -1,10 +1,12 @@ package org.taskana.exceptions; +/** + * This exception will be thrown if a specific object is not in the database. + */ @SuppressWarnings("serial") public class NotFoundException extends Exception { - public NotFoundException(String id) { - super(id); - } - + public NotFoundException(String id) { + super(id); + } } diff --git a/lib/taskana-core/src/main/java/org/taskana/exceptions/TaskNotFoundException.java b/lib/taskana-core/src/main/java/org/taskana/exceptions/TaskNotFoundException.java index 8067697dd..372d48ec7 100644 --- a/lib/taskana-core/src/main/java/org/taskana/exceptions/TaskNotFoundException.java +++ b/lib/taskana-core/src/main/java/org/taskana/exceptions/TaskNotFoundException.java @@ -1,5 +1,8 @@ package org.taskana.exceptions; +/** + * This exception will be thrown if a specific task is not in the database. + */ @SuppressWarnings("serial") public class TaskNotFoundException extends NotFoundException { diff --git a/lib/taskana-core/src/main/java/org/taskana/exceptions/WorkbasketNotFoundException.java b/lib/taskana-core/src/main/java/org/taskana/exceptions/WorkbasketNotFoundException.java index ff2843647..7ced17d93 100644 --- a/lib/taskana-core/src/main/java/org/taskana/exceptions/WorkbasketNotFoundException.java +++ b/lib/taskana-core/src/main/java/org/taskana/exceptions/WorkbasketNotFoundException.java @@ -1,9 +1,12 @@ package org.taskana.exceptions; +/** + * This exception will be thrown if a specific workbasket is not in the database. + */ @SuppressWarnings("serial") public class WorkbasketNotFoundException extends NotFoundException { - public WorkbasketNotFoundException(String id) { - super("Workbasket with '" + id + "' not found"); - } + public WorkbasketNotFoundException(String id) { + super("Workbasket with '" + id + "' not found"); + } } diff --git a/lib/taskana-core/src/main/java/org/taskana/impl/ClassificationServiceImpl.java b/lib/taskana-core/src/main/java/org/taskana/impl/ClassificationServiceImpl.java index 96e0ac6d8..c05b56e03 100644 --- a/lib/taskana-core/src/main/java/org/taskana/impl/ClassificationServiceImpl.java +++ b/lib/taskana-core/src/main/java/org/taskana/impl/ClassificationServiceImpl.java @@ -10,67 +10,70 @@ import org.taskana.impl.util.IdGenerator; import org.taskana.model.Classification; import org.taskana.model.mappings.ClassificationMapper; +/** + * This is the implementation of ClassificationService. + */ public class ClassificationServiceImpl implements ClassificationService { - private static final String ID_PREFIX_CLASSIFICATION = "CLI"; - - private ClassificationMapper classificationMapper; + private static final String ID_PREFIX_CLASSIFICATION = "CLI"; - public ClassificationServiceImpl(ClassificationMapper classificationMapper) { - super(); - this.classificationMapper = classificationMapper; - } + private ClassificationMapper classificationMapper; - @Override - public List selectClassifications() { - final List rootClassifications = classificationMapper.findByParentId(""); - populateChildClassifications(rootClassifications); - return rootClassifications; - } + public ClassificationServiceImpl(ClassificationMapper classificationMapper) { + super(); + this.classificationMapper = classificationMapper; + } - private void populateChildClassifications(final List classifications) { - for (Classification classification : classifications) { - List childClassifications = classificationMapper.findByParentId(classification.getId()); - classification.setChildren(childClassifications); - populateChildClassifications(childClassifications); - } - } + @Override + public List selectClassifications() { + final List rootClassifications = classificationMapper.findByParentId(""); + populateChildClassifications(rootClassifications); + return rootClassifications; + } - @Override - public List selectClassificationsByParentId(String parentId) { - return classificationMapper.findByParentId(parentId); - } + private void populateChildClassifications(final List classifications) { + for (Classification classification : classifications) { + List childClassifications = classificationMapper.findByParentId(classification.getId()); + classification.setChildren(childClassifications); + populateChildClassifications(childClassifications); + } + } - @Override - public void insertClassification(Classification classification) { - classification.setId(IdGenerator.generateWithPrefix(ID_PREFIX_CLASSIFICATION)); - classification.setCreated(Date.valueOf(LocalDate.now())); - classification.setModified(Date.valueOf(LocalDate.now())); - this.checkServiceLevel(classification); + @Override + public List selectClassificationsByParentId(String parentId) { + return classificationMapper.findByParentId(parentId); + } - classificationMapper.insert(classification); - } + @Override + public void insertClassification(Classification classification) { + classification.setId(IdGenerator.generateWithPrefix(ID_PREFIX_CLASSIFICATION)); + classification.setCreated(Date.valueOf(LocalDate.now())); + classification.setModified(Date.valueOf(LocalDate.now())); + this.checkServiceLevel(classification); - @Override - public void updateClassification(Classification classification) { - classification.setModified(Date.valueOf(LocalDate.now())); - this.checkServiceLevel(classification); + classificationMapper.insert(classification); + } - classificationMapper.update(classification); - } + @Override + public void updateClassification(Classification classification) { + classification.setModified(Date.valueOf(LocalDate.now())); + this.checkServiceLevel(classification); - @Override - public Classification selectClassificationById(String id) { - return classificationMapper.findById(id); - } + classificationMapper.update(classification); + } - private void checkServiceLevel(Classification classification) { - if (classification.getServiceLevel() != null) { - try { - Duration.parse(classification.getServiceLevel()); - } catch (Exception e) { - throw new IllegalArgumentException("Invalid timestamp. Please use the format 'PddDThhHmmM'"); - } - } - } + @Override + public Classification selectClassificationById(String id) { + return classificationMapper.findById(id); + } + + private void checkServiceLevel(Classification classification) { + if (classification.getServiceLevel() != null) { + try { + Duration.parse(classification.getServiceLevel()); + } catch (Exception e) { + throw new IllegalArgumentException("Invalid timestamp. Please use the format 'PddDThhHmmM'"); + } + } + } } diff --git a/lib/taskana-core/src/main/java/org/taskana/impl/TaskServiceImpl.java b/lib/taskana-core/src/main/java/org/taskana/impl/TaskServiceImpl.java index c2f1eb0eb..e49a15a41 100644 --- a/lib/taskana-core/src/main/java/org/taskana/impl/TaskServiceImpl.java +++ b/lib/taskana-core/src/main/java/org/taskana/impl/TaskServiceImpl.java @@ -22,180 +22,185 @@ import org.taskana.model.TaskStateCounter; import org.taskana.model.WorkbasketAuthorization; import org.taskana.model.mappings.ObjectReferenceMapper; import org.taskana.model.mappings.TaskMapper; - +/** + * This is the implementation of TaskService. + */ public class TaskServiceImpl implements TaskService { - private static final Logger logger = LoggerFactory.getLogger(TaskServiceImpl.class); - - private static final String ID_PREFIX_OBJECTR_EFERENCE = "ORI"; - private static final String ID_PREFIX_TASK = "TKI"; + private static final Logger LOGGER = LoggerFactory.getLogger(TaskServiceImpl.class); - private TaskanaEngine taskanaEngine; - private TaskMapper taskMapper; - private ObjectReferenceMapper objectReferenceMapper; + private static final String ID_PREFIX_OBJECTR_EFERENCE = "ORI"; + private static final String ID_PREFIX_TASK = "TKI"; - public TaskServiceImpl(TaskanaEngine taskanaEngine, TaskMapper taskMapper, ObjectReferenceMapper objectReferenceMapper) { - super(); - this.taskanaEngine = taskanaEngine; - this.taskMapper = taskMapper; - this.objectReferenceMapper = objectReferenceMapper; - } + private TaskanaEngine taskanaEngine; + private TaskMapper taskMapper; + private ObjectReferenceMapper objectReferenceMapper; - @Override - public void claim(String id, String userName) throws TaskNotFoundException { - Task task = taskMapper.findById(id); - if (task != null) { - Timestamp now = new Timestamp(System.currentTimeMillis()); - task.setOwner(userName); - task.setModified(now); - task.setClaimed(now); - task.setState(TaskState.CLAIMED); - taskMapper.update(task); - logger.debug("User '{}' claimed task '{}'.", userName, id); - } else { - throw new TaskNotFoundException(id); - } - } + public TaskServiceImpl(TaskanaEngine taskanaEngine, TaskMapper taskMapper, + ObjectReferenceMapper objectReferenceMapper) { + super(); + this.taskanaEngine = taskanaEngine; + this.taskMapper = taskMapper; + this.objectReferenceMapper = objectReferenceMapper; + } - @Override - public void complete(String id) throws TaskNotFoundException { - Task task = taskMapper.findById(id); - if (task != null) { - Timestamp now = new Timestamp(System.currentTimeMillis()); - task.setCompleted(now); - task.setModified(now); - task.setState(TaskState.COMPLETED); - taskMapper.update(task); - logger.debug("Task '{}' completed.", id); - } else { - throw new TaskNotFoundException(id); - } - } + @Override + public void claim(String id, String userName) throws TaskNotFoundException { + Task task = taskMapper.findById(id); + if (task != null) { + Timestamp now = new Timestamp(System.currentTimeMillis()); + task.setOwner(userName); + task.setModified(now); + task.setClaimed(now); + task.setState(TaskState.CLAIMED); + taskMapper.update(task); + LOGGER.debug("User '{}' claimed task '{}'.", userName, id); + } else { + throw new TaskNotFoundException(id); + } + } - @Override - public Task create(Task task) throws NotAuthorizedException { - taskanaEngine.getWorkbasketService().checkAuthorization(task.getWorkbasketId(), WorkbasketAuthorization.APPEND); + @Override + public void complete(String id) throws TaskNotFoundException { + Task task = taskMapper.findById(id); + if (task != null) { + Timestamp now = new Timestamp(System.currentTimeMillis()); + task.setCompleted(now); + task.setModified(now); + task.setState(TaskState.COMPLETED); + taskMapper.update(task); + LOGGER.debug("Task '{}' completed.", id); + } else { + throw new TaskNotFoundException(id); + } + } - Timestamp now = new Timestamp(System.currentTimeMillis()); - task.setId(IdGenerator.generateWithPrefix(ID_PREFIX_TASK)); - task.setState(TaskState.READY); - task.setCreated(now); - task.setModified(now); - task.setRead(false); - task.setTransferred(false); + @Override + public Task create(Task task) throws NotAuthorizedException { + taskanaEngine.getWorkbasketService().checkAuthorization(task.getWorkbasketId(), WorkbasketAuthorization.APPEND); - // insert ObjectReference if needed. - if (task.getPrimaryObjRef() != null) { - ObjectReference objectReference = this.objectReferenceMapper.findByObjectReference(task.getPrimaryObjRef()); - if (objectReference == null) { - objectReference = task.getPrimaryObjRef(); - objectReference.setId(IdGenerator.generateWithPrefix(ID_PREFIX_OBJECTR_EFERENCE)); - this.objectReferenceMapper.insert(objectReference); - } - task.setPrimaryObjRef(objectReference); - } - this.taskMapper.insert(task); + Timestamp now = new Timestamp(System.currentTimeMillis()); + task.setId(IdGenerator.generateWithPrefix(ID_PREFIX_TASK)); + task.setState(TaskState.READY); + task.setCreated(now); + task.setModified(now); + task.setRead(false); + task.setTransferred(false); - logger.debug("Task '{}' created.", task.getId()); - return task; - } + // insert ObjectReference if needed. + if (task.getPrimaryObjRef() != null) { + ObjectReference objectReference = this.objectReferenceMapper.findByObjectReference(task.getPrimaryObjRef()); + if (objectReference == null) { + objectReference = task.getPrimaryObjRef(); + objectReference.setId(IdGenerator.generateWithPrefix(ID_PREFIX_OBJECTR_EFERENCE)); + this.objectReferenceMapper.insert(objectReference); + } + task.setPrimaryObjRef(objectReference); + } + this.taskMapper.insert(task); - @Override - public Task getTaskById(String id) throws TaskNotFoundException { - Task task = taskMapper.findById(id); - if (task != null) { - return task; - } else { - throw new TaskNotFoundException(id); - } - } + LOGGER.debug("Task '{}' created.", task.getId()); + return task; + } - @Override - public List getTasksForWorkbasket(String workbasketId) throws NotAuthorizedException { - taskanaEngine.getWorkbasketService().checkAuthorization(workbasketId, WorkbasketAuthorization.OPEN); + @Override + public Task getTaskById(String id) throws TaskNotFoundException { + Task task = taskMapper.findById(id); + if (task != null) { + return task; + } else { + throw new TaskNotFoundException(id); + } + } - return taskMapper.findByWorkBasketId(workbasketId); - } + @Override + public List getTasksForWorkbasket(String workbasketId) throws NotAuthorizedException { + taskanaEngine.getWorkbasketService().checkAuthorization(workbasketId, WorkbasketAuthorization.OPEN); - @Override - public List findTasks(List states) { - return taskMapper.findByStates(states); - } + return taskMapper.findByWorkBasketId(workbasketId); + } - @Override - public List getTasksForWorkbasket(List workbasketIds, List states) - throws NotAuthorizedException { + @Override + public List findTasks(List states) { + return taskMapper.findByStates(states); + } - for (String workbasket : workbasketIds) { - taskanaEngine.getWorkbasketService().checkAuthorization(workbasket, WorkbasketAuthorization.OPEN); - } + @Override + public List getTasksForWorkbasket(List workbasketIds, List states) + throws NotAuthorizedException { - return taskMapper.findByWorkbasketIdsAndStates(workbasketIds, states); - } + for (String workbasket : workbasketIds) { + taskanaEngine.getWorkbasketService().checkAuthorization(workbasket, WorkbasketAuthorization.OPEN); + } - @Override - public List getTasks() { - return taskMapper.findAll(); - } + return taskMapper.findByWorkbasketIdsAndStates(workbasketIds, states); + } - @Override - public List getTaskCountForState(List states) { - return taskMapper.getTaskCountForState(states); - } + @Override + public List getTasks() { + return taskMapper.findAll(); + } - @Override - public long getTaskCountForWorkbasketByDaysInPastAndState(String workbasketId, long daysInPast, - List states) { - LocalDate time = LocalDate.now(); - time = time.minusDays(daysInPast); - Date fromDate = Date.valueOf(time); - return taskMapper.getTaskCountForWorkbasketByDaysInPastAndState(workbasketId, fromDate, states); - } + @Override + public List getTaskCountForState(List states) { + return taskMapper.getTaskCountForState(states); + } - @Override - public Task transfer(String taskId, String destinationWorkbasketId) - throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { - Task task = getTaskById(taskId); + @Override + public long getTaskCountForWorkbasketByDaysInPastAndState(String workbasketId, long daysInPast, + List states) { + LocalDate time = LocalDate.now(); + time = time.minusDays(daysInPast); + Date fromDate = Date.valueOf(time); + return taskMapper.getTaskCountForWorkbasketByDaysInPastAndState(workbasketId, fromDate, states); + } - // transfer requires TRANSFER in source and APPEND on destination - // workbasket - taskanaEngine.getWorkbasketService().checkAuthorization(destinationWorkbasketId, WorkbasketAuthorization.APPEND); - taskanaEngine.getWorkbasketService().checkAuthorization(task.getWorkbasketId(), WorkbasketAuthorization.TRANSFER); + @Override + public Task transfer(String taskId, String destinationWorkbasketId) + throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { + Task task = getTaskById(taskId); - // if security is disabled, the implicit existance check on the - // destination workbasket has been skipped and needs to be performed - if (!taskanaEngine.getConfiguration().isSecurityEnabled()) { - taskanaEngine.getWorkbasketService().getWorkbasket(destinationWorkbasketId); - } + // transfer requires TRANSFER in source and APPEND on destination + // workbasket + taskanaEngine.getWorkbasketService().checkAuthorization(destinationWorkbasketId, + WorkbasketAuthorization.APPEND); + taskanaEngine.getWorkbasketService().checkAuthorization(task.getWorkbasketId(), + WorkbasketAuthorization.TRANSFER); - // reset read flag and set transferred flag - task.setRead(false); - task.setTransferred(true); + // if security is disabled, the implicit existance check on the + // destination workbasket has been skipped and needs to be performed + if (!taskanaEngine.getConfiguration().isSecurityEnabled()) { + taskanaEngine.getWorkbasketService().getWorkbasket(destinationWorkbasketId); + } - // transfer task from source to destination workbasket - task.setWorkbasketId(destinationWorkbasketId); - task.setModified(Timestamp.valueOf(LocalDateTime.now())); - taskMapper.update(task); + // reset read flag and set transferred flag + task.setRead(false); + task.setTransferred(true); - return getTaskById(taskId); - } + // transfer task from source to destination workbasket + task.setWorkbasketId(destinationWorkbasketId); + task.setModified(Timestamp.valueOf(LocalDateTime.now())); + taskMapper.update(task); - @Override - public List getTaskCountByWorkbasketAndDaysInPastAndState(long daysInPast, - List states) { - LocalDate time = LocalDate.now(); - time = time.minusDays(daysInPast); - Date fromDate = Date.valueOf(time); - return taskMapper.getTaskCountByWorkbasketIdAndDaysInPastAndState(fromDate, states); - } + return getTaskById(taskId); + } - @Override - public Task setTaskRead(String taskId, boolean isRead) throws TaskNotFoundException { - Task task = getTaskById(taskId); - task.setRead(true); - task.setModified(Timestamp.valueOf(LocalDateTime.now())); - taskMapper.update(task); - return getTaskById(taskId); - } + @Override + public List getTaskCountByWorkbasketAndDaysInPastAndState(long daysInPast, + List states) { + LocalDate time = LocalDate.now(); + time = time.minusDays(daysInPast); + Date fromDate = Date.valueOf(time); + return taskMapper.getTaskCountByWorkbasketIdAndDaysInPastAndState(fromDate, states); + } + + @Override + public Task setTaskRead(String taskId, boolean isRead) throws TaskNotFoundException { + Task task = getTaskById(taskId); + task.setRead(true); + task.setModified(Timestamp.valueOf(LocalDateTime.now())); + taskMapper.update(task); + return getTaskById(taskId); + } } diff --git a/lib/taskana-core/src/main/java/org/taskana/impl/TaskanaEngineImpl.java b/lib/taskana-core/src/main/java/org/taskana/impl/TaskanaEngineImpl.java index c6941cdd2..5303c4dc0 100644 --- a/lib/taskana-core/src/main/java/org/taskana/impl/TaskanaEngineImpl.java +++ b/lib/taskana-core/src/main/java/org/taskana/impl/TaskanaEngineImpl.java @@ -20,96 +20,98 @@ import org.taskana.model.mappings.TaskMapper; import org.taskana.model.mappings.WorkbasketAccessMapper; import org.taskana.model.mappings.WorkbasketMapper; +/** + * This is the implementation of TaskanaEngine. + */ public class TaskanaEngineImpl implements TaskanaEngine { - private static final String DEFAULT = "default"; + private static final String DEFAULT = "default"; - protected TaskanaEngineConfiguration taskanaEngineConfiguration; - protected SqlSession session; - protected TransactionFactory transactionFactory; + protected TaskanaEngineConfiguration taskanaEngineConfiguration; + protected SqlSession session; + protected TransactionFactory transactionFactory; - private TaskMapper taskMapper; - private WorkbasketMapper workbasketMapper; - private DistributionTargetMapper distributionTargetMapper; - private ClassificationMapper classificationMapper; - private WorkbasketAccessMapper workbasketAccessMapper; - private ObjectReferenceMapper objectReferenceMapper; + private TaskMapper taskMapper; + private WorkbasketMapper workbasketMapper; + private DistributionTargetMapper distributionTargetMapper; + private ClassificationMapper classificationMapper; + private WorkbasketAccessMapper workbasketAccessMapper; + private ObjectReferenceMapper objectReferenceMapper; - private TaskServiceImpl taskServiceImpl; - private WorkbasketServiceImpl workbasketServiceImpl; + private TaskServiceImpl taskServiceImpl; + private WorkbasketServiceImpl workbasketServiceImpl; - public TaskanaEngineImpl(TaskanaEngineConfiguration taskanaEngineConfiguration) { - this.taskanaEngineConfiguration = taskanaEngineConfiguration; + public TaskanaEngineImpl(TaskanaEngineConfiguration taskanaEngineConfiguration) { + this.taskanaEngineConfiguration = taskanaEngineConfiguration; - createTransactionFactory(taskanaEngineConfiguration.getUseContainerManagedTransactions()); + createTransactionFactory(taskanaEngineConfiguration.getUseContainerManagedTransactions()); - this.session = createSqlSessionFactory().openSession(); - this.taskMapper = session.getMapper(TaskMapper.class); - this.workbasketMapper = session.getMapper(WorkbasketMapper.class); - this.distributionTargetMapper = session.getMapper(DistributionTargetMapper.class); - this.classificationMapper = session.getMapper(ClassificationMapper.class); - this.workbasketAccessMapper = session.getMapper(WorkbasketAccessMapper.class); - this.objectReferenceMapper = session.getMapper(ObjectReferenceMapper.class); - } + this.session = createSqlSessionFactory().openSession(); + this.taskMapper = session.getMapper(TaskMapper.class); + this.workbasketMapper = session.getMapper(WorkbasketMapper.class); + this.distributionTargetMapper = session.getMapper(DistributionTargetMapper.class); + this.classificationMapper = session.getMapper(ClassificationMapper.class); + this.workbasketAccessMapper = session.getMapper(WorkbasketAccessMapper.class); + this.objectReferenceMapper = session.getMapper(ObjectReferenceMapper.class); + } - @Override - public TaskService getTaskService() { - this.taskServiceImpl = new TaskServiceImpl(this, this.taskMapper, this.objectReferenceMapper); - return taskServiceImpl; - } + @Override + public TaskService getTaskService() { + this.taskServiceImpl = new TaskServiceImpl(this, this.taskMapper, this.objectReferenceMapper); + return taskServiceImpl; + } - @Override - public WorkbasketService getWorkbasketService() { - this.workbasketServiceImpl = new WorkbasketServiceImpl(this, this.workbasketMapper, - this.distributionTargetMapper, this.workbasketAccessMapper); - return workbasketServiceImpl; - } + @Override + public WorkbasketService getWorkbasketService() { + this.workbasketServiceImpl = new WorkbasketServiceImpl(this, this.workbasketMapper, + this.distributionTargetMapper, this.workbasketAccessMapper); + return workbasketServiceImpl; + } - @Override - public ClassificationService getClassificationService() { - return new ClassificationServiceImpl(this.classificationMapper); - } + @Override + public ClassificationService getClassificationService() { + return new ClassificationServiceImpl(this.classificationMapper); + } - @Override - public TaskanaEngineConfiguration getConfiguration() { - return this.taskanaEngineConfiguration; - } + @Override + public TaskanaEngineConfiguration getConfiguration() { + return this.taskanaEngineConfiguration; + } - /** - * Close session manually, to be done, if a JdbcTransactionFactory is used. - * Perhaps it is better to separate the commit and the closing mechanism ... - */ - public void closeSession() { - this.session.commit(); - this.session.close(); - } + /** + * Close session manually, to be done, if a JdbcTransactionFactory is used. + * Perhaps it is better to separate the commit and the closing mechanism ... + */ + public void closeSession() { + this.session.commit(); + this.session.close(); + } - /** - * This method creates the sqlSessionFactory of myBatis. It integrates all the - * SQL mappers - * - * @return a {@link SqlSessionFactory} - */ - private SqlSessionFactory createSqlSessionFactory() { - Environment environment = new Environment(DEFAULT, this.transactionFactory, - taskanaEngineConfiguration.getDatasource()); - Configuration configuration = new Configuration(environment); - // add mappers - configuration.addMapper(TaskMapper.class); - configuration.addMapper(WorkbasketMapper.class); - configuration.addMapper(DistributionTargetMapper.class); - configuration.addMapper(ClassificationMapper.class); - configuration.addMapper(WorkbasketAccessMapper.class); - configuration.addMapper(ObjectReferenceMapper.class); - return new SqlSessionFactoryBuilder().build(configuration); - } + /** + * This method creates the sqlSessionFactory of myBatis. It integrates all the + * SQL mappers + * @return a {@link SqlSessionFactory} + */ + private SqlSessionFactory createSqlSessionFactory() { + Environment environment = new Environment(DEFAULT, this.transactionFactory, + taskanaEngineConfiguration.getDatasource()); + Configuration configuration = new Configuration(environment); + // add mappers + configuration.addMapper(TaskMapper.class); + configuration.addMapper(WorkbasketMapper.class); + configuration.addMapper(DistributionTargetMapper.class); + configuration.addMapper(ClassificationMapper.class); + configuration.addMapper(WorkbasketAccessMapper.class); + configuration.addMapper(ObjectReferenceMapper.class); + return new SqlSessionFactoryBuilder().build(configuration); + } - private void createTransactionFactory(boolean useContainerManagedTransactions) { - if (useContainerManagedTransactions) { - this.transactionFactory = new ManagedTransactionFactory(); - } else { - this.transactionFactory = new JdbcTransactionFactory(); - } - } + private void createTransactionFactory(boolean useContainerManagedTransactions) { + if (useContainerManagedTransactions) { + this.transactionFactory = new ManagedTransactionFactory(); + } else { + this.transactionFactory = new JdbcTransactionFactory(); + } + } } diff --git a/lib/taskana-core/src/main/java/org/taskana/impl/WorkbasketServiceImpl.java b/lib/taskana-core/src/main/java/org/taskana/impl/WorkbasketServiceImpl.java index 6ca217c00..5edcb7026 100644 --- a/lib/taskana-core/src/main/java/org/taskana/impl/WorkbasketServiceImpl.java +++ b/lib/taskana-core/src/main/java/org/taskana/impl/WorkbasketServiceImpl.java @@ -17,150 +17,152 @@ import org.taskana.model.mappings.DistributionTargetMapper; import org.taskana.model.mappings.WorkbasketAccessMapper; import org.taskana.model.mappings.WorkbasketMapper; import org.taskana.security.CurrentUserContext; - +/** + * This is the implementation of WorkbasketService. + */ public class WorkbasketServiceImpl implements WorkbasketService { - private static final Logger logger = LoggerFactory.getLogger(WorkbasketServiceImpl.class); - - private static final String ID_PREFIX_WORKBASKET = "WBI"; - private static final String ID_PREFIX_WORKBASKET_AUTHORIZATION = "WAI"; + private static final Logger LOGGER = LoggerFactory.getLogger(WorkbasketServiceImpl.class); - private TaskanaEngine taskanaEngine; + private static final String ID_PREFIX_WORKBASKET = "WBI"; + private static final String ID_PREFIX_WORKBASKET_AUTHORIZATION = "WAI"; - private WorkbasketMapper workbasketMapper; - private DistributionTargetMapper distributionTargetMapper; - private WorkbasketAccessMapper workbasketAccessMapper; + private TaskanaEngine taskanaEngine; - public WorkbasketServiceImpl() { - } + private WorkbasketMapper workbasketMapper; + private DistributionTargetMapper distributionTargetMapper; + private WorkbasketAccessMapper workbasketAccessMapper; - public WorkbasketServiceImpl(TaskanaEngine taskanaEngine, WorkbasketMapper workbasketMapper, - DistributionTargetMapper distributionTargetMapper, WorkbasketAccessMapper workbasketAccessMapper) { - this.taskanaEngine = taskanaEngine; - this.workbasketMapper = workbasketMapper; - this.distributionTargetMapper = distributionTargetMapper; - this.workbasketAccessMapper = workbasketAccessMapper; - } + public WorkbasketServiceImpl() { + } - @Override - public Workbasket getWorkbasket(String workbasketId) throws WorkbasketNotFoundException { - Workbasket workbasket = workbasketMapper.findById(workbasketId); - if (workbasket == null) { - throw new WorkbasketNotFoundException(workbasketId); - } - return workbasket; - } + public WorkbasketServiceImpl(TaskanaEngine taskanaEngine, WorkbasketMapper workbasketMapper, + DistributionTargetMapper distributionTargetMapper, WorkbasketAccessMapper workbasketAccessMapper) { + this.taskanaEngine = taskanaEngine; + this.workbasketMapper = workbasketMapper; + this.distributionTargetMapper = distributionTargetMapper; + this.workbasketAccessMapper = workbasketAccessMapper; + } - @Override - public List getWorkbaskets(List permissions) { - return workbasketMapper.findByPermission(permissions, CurrentUserContext.getUserid()); - } - - @Override - public List getWorkbaskets() { - return workbasketMapper.findAll(); - } + @Override + public Workbasket getWorkbasket(String workbasketId) throws WorkbasketNotFoundException { + Workbasket workbasket = workbasketMapper.findById(workbasketId); + if (workbasket == null) { + throw new WorkbasketNotFoundException(workbasketId); + } + return workbasket; + } - @Override - public Workbasket createWorkbasket(Workbasket workbasket) { - Timestamp now = new Timestamp(System.currentTimeMillis()); - workbasket.setCreated(now); - workbasket.setModified(now); - if (workbasket.getId() == null || workbasket.getId().isEmpty()) { - workbasket.setId(IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET)); - } - workbasketMapper.insert(workbasket); - logger.debug("Workbasket '{}' created", workbasket.getId()); - if (workbasket.getDistributionTargets() != null) { - for (Workbasket distributionTarget : workbasket.getDistributionTargets()) { - if (workbasketMapper.findById(distributionTarget.getId()) == null) { - distributionTarget.setCreated(now); - distributionTarget.setModified(now); - workbasketMapper.insert(distributionTarget); - logger.debug("Workbasket '{}' created", distributionTarget.getId()); - } - distributionTargetMapper.insert(workbasket.getId(), distributionTarget.getId()); - } - } - return workbasketMapper.findById(workbasket.getId()); - } + @Override + public List getWorkbaskets(List permissions) { + return workbasketMapper.findByPermission(permissions, CurrentUserContext.getUserid()); + } - @Override - public Workbasket updateWorkbasket(Workbasket workbasket) throws NotAuthorizedException { - workbasket.setModified(new Timestamp(System.currentTimeMillis())); - workbasketMapper.update(workbasket); - List oldDistributionTargets = distributionTargetMapper.findBySourceId(workbasket.getId()); - List distributionTargets = workbasket.getDistributionTargets(); - for (Workbasket distributionTarget : distributionTargets) { - if (!oldDistributionTargets.contains(distributionTarget.getId())) { - if (workbasketMapper.findById(distributionTarget.getId()) == null) { - workbasketMapper.insert(distributionTarget); - logger.debug("Workbasket '{}' created", distributionTarget.getId()); - } - distributionTargetMapper.insert(workbasket.getId(), distributionTarget.getId()); - } else { - oldDistributionTargets.remove(distributionTarget.getId()); - } - } - distributionTargetMapper.deleteMultiple(workbasket.getId(), oldDistributionTargets); - logger.debug("Workbasket '{}' updated", workbasket.getId()); - return workbasketMapper.findById(workbasket.getId()); - } + @Override + public List getWorkbaskets() { + return workbasketMapper.findAll(); + } - @Override - public WorkbasketAccessItem createWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem) { - workbasketAccessItem.setId(IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_AUTHORIZATION)); - workbasketAccessMapper.insert(workbasketAccessItem); - return workbasketAccessItem; - } + @Override + public Workbasket createWorkbasket(Workbasket workbasket) { + Timestamp now = new Timestamp(System.currentTimeMillis()); + workbasket.setCreated(now); + workbasket.setModified(now); + if (workbasket.getId() == null || workbasket.getId().isEmpty()) { + workbasket.setId(IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET)); + } + workbasketMapper.insert(workbasket); + LOGGER.debug("Workbasket '{}' created", workbasket.getId()); + if (workbasket.getDistributionTargets() != null) { + for (Workbasket distributionTarget : workbasket.getDistributionTargets()) { + if (workbasketMapper.findById(distributionTarget.getId()) == null) { + distributionTarget.setCreated(now); + distributionTarget.setModified(now); + workbasketMapper.insert(distributionTarget); + LOGGER.debug("Workbasket '{}' created", distributionTarget.getId()); + } + distributionTargetMapper.insert(workbasket.getId(), distributionTarget.getId()); + } + } + return workbasketMapper.findById(workbasket.getId()); + } - @Override - public WorkbasketAccessItem getWorkbasketAuthorization(String id) { - return workbasketAccessMapper.findById(id); - } + @Override + public Workbasket updateWorkbasket(Workbasket workbasket) throws NotAuthorizedException { + workbasket.setModified(new Timestamp(System.currentTimeMillis())); + workbasketMapper.update(workbasket); + List oldDistributionTargets = distributionTargetMapper.findBySourceId(workbasket.getId()); + List distributionTargets = workbasket.getDistributionTargets(); + for (Workbasket distributionTarget : distributionTargets) { + if (!oldDistributionTargets.contains(distributionTarget.getId())) { + if (workbasketMapper.findById(distributionTarget.getId()) == null) { + workbasketMapper.insert(distributionTarget); + LOGGER.debug("Workbasket '{}' created", distributionTarget.getId()); + } + distributionTargetMapper.insert(workbasket.getId(), distributionTarget.getId()); + } else { + oldDistributionTargets.remove(distributionTarget.getId()); + } + } + distributionTargetMapper.deleteMultiple(workbasket.getId(), oldDistributionTargets); + LOGGER.debug("Workbasket '{}' updated", workbasket.getId()); + return workbasketMapper.findById(workbasket.getId()); + } - @Override - public void deleteWorkbasketAuthorization(String id) { - workbasketAccessMapper.delete(id); - } + @Override + public WorkbasketAccessItem createWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem) { + workbasketAccessItem.setId(IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_AUTHORIZATION)); + workbasketAccessMapper.insert(workbasketAccessItem); + return workbasketAccessItem; + } - @Override - public List getAllAuthorizations() { - return workbasketAccessMapper.findAll(); - } + @Override + public WorkbasketAccessItem getWorkbasketAuthorization(String id) { + return workbasketAccessMapper.findById(id); + } - @Override - public void checkAuthorization(String workbasketId, WorkbasketAuthorization workbasketAuthorization) - throws NotAuthorizedException { + @Override + public void deleteWorkbasketAuthorization(String id) { + workbasketAccessMapper.delete(id); + } - // Skip permission check is security is not enabled - if (!taskanaEngine.getConfiguration().isSecurityEnabled()) { - logger.debug("Skipping permissions check since security is disabled."); - return; - } + @Override + public List getAllAuthorizations() { + return workbasketAccessMapper.findAll(); + } - String userId = CurrentUserContext.getUserid(); - logger.debug("Verifying that {} has the permission {} on workbasket {}", userId, workbasketAuthorization.name(), - workbasketId); + @Override + public void checkAuthorization(String workbasketId, WorkbasketAuthorization workbasketAuthorization) + throws NotAuthorizedException { - List accessItems = workbasketAccessMapper - .findByWorkbasketAndUserAndAuthorization(workbasketId, userId, workbasketAuthorization.name()); + // Skip permission check is security is not enabled + if (!taskanaEngine.getConfiguration().isSecurityEnabled()) { + LOGGER.debug("Skipping permissions check since security is disabled."); + return; + } - if (accessItems.size() <= 0) { - throw new NotAuthorizedException("Not authorized. Authorization '" + workbasketAuthorization.name() - + "' on workbasket '" + workbasketId + "' is needed."); + String userId = CurrentUserContext.getUserid(); + LOGGER.debug("Verifying that {} has the permission {} on workbasket {}", userId, workbasketAuthorization.name(), + workbasketId); - } - } + List accessItems = workbasketAccessMapper + .findByWorkbasketAndUserAndAuthorization(workbasketId, userId, workbasketAuthorization.name()); - @Override - public WorkbasketAccessItem updateWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem) { - workbasketAccessMapper.update(workbasketAccessItem); - return workbasketAccessItem; - } + if (accessItems.size() <= 0) { + throw new NotAuthorizedException("Not authorized. Authorization '" + workbasketAuthorization.name() + + "' on workbasket '" + workbasketId + "' is needed."); - @Override - public List getWorkbasketAuthorizations(String workbasketId) { - return workbasketAccessMapper.findByWorkbasketId(workbasketId); - } -} \ No newline at end of file + } + } + + @Override + public WorkbasketAccessItem updateWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem) { + workbasketAccessMapper.update(workbasketAccessItem); + return workbasketAccessItem; + } + + @Override + public List getWorkbasketAuthorizations(String workbasketId) { + return workbasketAccessMapper.findByWorkbasketId(workbasketId); + } +} diff --git a/lib/taskana-core/src/main/java/org/taskana/impl/util/IdGenerator.java b/lib/taskana-core/src/main/java/org/taskana/impl/util/IdGenerator.java index 58a87e235..fce393c78 100644 --- a/lib/taskana-core/src/main/java/org/taskana/impl/util/IdGenerator.java +++ b/lib/taskana-core/src/main/java/org/taskana/impl/util/IdGenerator.java @@ -2,12 +2,24 @@ package org.taskana.impl.util; import java.util.UUID; -public class IdGenerator { +/** + * This class contains util emthods for generating ids. + */ +public final class IdGenerator { - private static final String SEPERATOR = ":"; + private static final String SEPERATOR = ":"; - public static String generateWithPrefix(String prefix) { - return new StringBuilder().append(prefix).append(SEPERATOR).append(UUID.randomUUID().toString()).toString(); - } + /** + * This method create an id with an specific prefix. + * @param prefix + * only 3 characters! + * @return a String with a length of 40 characters + */ + public static String generateWithPrefix(String prefix) { + return new StringBuilder().append(prefix).append(SEPERATOR).append(UUID.randomUUID().toString()).toString(); + } + + private IdGenerator() { + } } diff --git a/lib/taskana-core/src/main/java/org/taskana/model/Classification.java b/lib/taskana-core/src/main/java/org/taskana/model/Classification.java index 485b13be2..6b579b3a1 100644 --- a/lib/taskana-core/src/main/java/org/taskana/model/Classification.java +++ b/lib/taskana-core/src/main/java/org/taskana/model/Classification.java @@ -5,121 +5,121 @@ import java.util.ArrayList; import java.util.List; /** - * Classification entity + * Classification entity. */ public class Classification { - private String id; - private String tenantId; - private String parentClassificationId; - private String category; - private String type; - private Date created; - private Date modified; - private String name; - private String description; - private int priority; - private String serviceLevel; //PddDThhHmmM - private List children = new ArrayList<>(); + private String id; + private String tenantId; + private String parentClassificationId; + private String category; + private String type; + private Date created; + private Date modified; + private String name; + private String description; + private int priority; + private String serviceLevel; // PddDThhHmmM + private List children = new ArrayList<>(); - public String getId() { - return id; - } + public String getId() { + return id; + } - public void setId(String id) { - this.id = id; - } + public void setId(String id) { + this.id = id; + } - public String getTenantId() { - return tenantId; - } + public String getTenantId() { + return tenantId; + } - public void setTenantId(String tenantId) { - this.tenantId = tenantId; - } + public void setTenantId(String tenantId) { + this.tenantId = tenantId; + } - public String getParentClassificationId() { - return parentClassificationId; - } + public String getParentClassificationId() { + return parentClassificationId; + } - public void setParentClassificationId(String parentClassificationId) { - this.parentClassificationId = parentClassificationId; - } + public void setParentClassificationId(String parentClassificationId) { + this.parentClassificationId = parentClassificationId; + } - public String getType() { - return type; - } + public String getType() { + return type; + } - public void setType(String type) { - this.type = type; - } + public void setType(String type) { + this.type = type; + } - public String getCategory() { - return category; - } + public String getCategory() { + return category; + } - public void setCategory(String category) { - this.category = category; - } + public void setCategory(String category) { + this.category = category; + } - public Date getCreated() { - return created; - } + public Date getCreated() { + return created; + } - public void setCreated(Date created) { - this.created = created; - } + public void setCreated(Date created) { + this.created = created; + } - public Date getModified() { - return modified; - } + public Date getModified() { + return modified; + } - public void setModified(Date modified) { - this.modified = modified; - } + public void setModified(Date modified) { + this.modified = modified; + } - public String getName() { - return name; - } + public String getName() { + return name; + } - public void setName(String name) { - this.name = name; - } + public void setName(String name) { + this.name = name; + } - public String getDescription() { - return description; - } + public String getDescription() { + return description; + } - public void setDescription(String description) { - this.description = description; - } + public void setDescription(String description) { + this.description = description; + } - public int getPriority() { - return priority; - } + public int getPriority() { + return priority; + } - public void setPriority(int priority) { - this.priority = priority; - } + public void setPriority(int priority) { + this.priority = priority; + } - public String getServiceLevel() { - return serviceLevel; - } + public String getServiceLevel() { + return serviceLevel; + } - public void setServiceLevel(String serviceLevel) { - this.serviceLevel = serviceLevel; - } + public void setServiceLevel(String serviceLevel) { + this.serviceLevel = serviceLevel; + } - public List getChildren() { - return children; - } + public List getChildren() { + return children; + } - public void addChild(Classification child) { - children.add(child); - } + public void addChild(Classification child) { + children.add(child); + } - public void setChildren(List children) { - this.children = children; - } + public void setChildren(List children) { + this.children = children; + } } diff --git a/lib/taskana-core/src/main/java/org/taskana/model/DueWorkbasketCounter.java b/lib/taskana-core/src/main/java/org/taskana/model/DueWorkbasketCounter.java index 308c299da..b4dfee7b7 100644 --- a/lib/taskana-core/src/main/java/org/taskana/model/DueWorkbasketCounter.java +++ b/lib/taskana-core/src/main/java/org/taskana/model/DueWorkbasketCounter.java @@ -3,35 +3,35 @@ package org.taskana.model; import java.sql.Date; /** - * DueWorkbasketCounter entity + * DueWorkbasketCounter entity. */ public class DueWorkbasketCounter { - - private Date due; - private String workbasketId; - private long taskCounter; - public Date getDue() { - return due; - } + private Date due; + private String workbasketId; + private long taskCounter; - public void setDue(Date due) { - this.due = due; - } + public Date getDue() { + return due; + } - public String getWorkbasketId() { - return workbasketId; - } + public void setDue(Date due) { + this.due = due; + } - public void setWorkbasketId(String workbasketId) { - this.workbasketId = workbasketId; - } + public String getWorkbasketId() { + return workbasketId; + } - public long getTaskCounter() { - return taskCounter; - } + public void setWorkbasketId(String workbasketId) { + this.workbasketId = workbasketId; + } - public void setTaskCounter(long taskCounter) { - this.taskCounter = taskCounter; - } + public long getTaskCounter() { + return taskCounter; + } + + public void setTaskCounter(long taskCounter) { + this.taskCounter = taskCounter; + } } diff --git a/lib/taskana-core/src/main/java/org/taskana/model/ObjectReference.java b/lib/taskana-core/src/main/java/org/taskana/model/ObjectReference.java index 615b92052..5b2d8984e 100644 --- a/lib/taskana-core/src/main/java/org/taskana/model/ObjectReference.java +++ b/lib/taskana-core/src/main/java/org/taskana/model/ObjectReference.java @@ -1,85 +1,85 @@ package org.taskana.model; /** - * ObjectReference entity + * ObjectReference entity. */ public class ObjectReference { - private String id; - private String tenantId; - private String company; - private String system; - private String systemInstance; - private String type; - private String value; + private String id; + private String tenantId; + private String company; + private String system; + private String systemInstance; + private String type; + private String value; - public String getId() { - return id; - } + public String getId() { + return id; + } - public void setId(String id) { - this.id = id; - } + public void setId(String id) { + this.id = id; + } - public String getTenantId() { - return tenantId; - } + public String getTenantId() { + return tenantId; + } - public void setTenantId(String tenantId) { - this.tenantId = tenantId; - } + public void setTenantId(String tenantId) { + this.tenantId = tenantId; + } - public String getCompany() { - return company; - } + public String getCompany() { + return company; + } - public void setCompany(String company) { - this.company = company; - } + public void setCompany(String company) { + this.company = company; + } - public String getSystem() { - return system; - } + public String getSystem() { + return system; + } - public void setSystem(String system) { - this.system = system; - } + public void setSystem(String system) { + this.system = system; + } - public String getSystemInstance() { - return systemInstance; - } + public String getSystemInstance() { + return systemInstance; + } - public void setSystemInstance(String systemInstance) { - this.systemInstance = systemInstance; - } + public void setSystemInstance(String systemInstance) { + this.systemInstance = systemInstance; + } - public String getType() { - return type; - } + public String getType() { + return type; + } - public void setType(String type) { - this.type = type; - } + public void setType(String type) { + this.type = type; + } - public String getValue() { - return value; - } + public String getValue() { + return value; + } - public void setValue(String value) { - this.value = value; - } + public void setValue(String value) { + this.value = value; + } - @Override - public String toString() { - StringBuffer sb = new StringBuffer(); - sb.append("ObjectReference("); - sb.append("id=" + id); - sb.append(", tenantId=" + tenantId); - sb.append(", company=" + company); - sb.append(", system=" + system); - sb.append(", systemInstance=" + systemInstance); - sb.append(", type=" + type); - sb.append(", value=" + value); - return sb.toString(); - } + @Override + public String toString() { + StringBuffer sb = new StringBuffer(); + sb.append("ObjectReference("); + sb.append("id=" + id); + sb.append(", tenantId=" + tenantId); + sb.append(", company=" + company); + sb.append(", system=" + system); + sb.append(", systemInstance=" + systemInstance); + sb.append(", type=" + type); + sb.append(", value=" + value); + return sb.toString(); + } } diff --git a/lib/taskana-core/src/main/java/org/taskana/model/Task.java b/lib/taskana-core/src/main/java/org/taskana/model/Task.java index e00d353c9..af6eb9ae6 100644 --- a/lib/taskana-core/src/main/java/org/taskana/model/Task.java +++ b/lib/taskana-core/src/main/java/org/taskana/model/Task.java @@ -3,195 +3,195 @@ package org.taskana.model; import java.sql.Timestamp; /** - * Task entity + * Task entity. */ public class Task { - private String id; - private String tenantId; - private Timestamp created; - private Timestamp claimed; - private Timestamp completed; - private Timestamp modified; - private Timestamp planned; - private Timestamp due; - private String name; - private String description; - private int priority; - private TaskState state; - private String type; - private String workbasketId; - private String owner; - private ObjectReference primaryObjRef; - private boolean isRead; - private boolean isTransferred; + private String id; + private String tenantId; + private Timestamp created; + private Timestamp claimed; + private Timestamp completed; + private Timestamp modified; + private Timestamp planned; + private Timestamp due; + private String name; + private String description; + private int priority; + private TaskState state; + private String type; + private String workbasketId; + private String owner; + private ObjectReference primaryObjRef; + private boolean isRead; + private boolean isTransferred; - public String getId() { - return id; - } + public String getId() { + return id; + } - public void setId(String id) { - this.id = id; - } + public void setId(String id) { + this.id = id; + } - public String getTenantId() { - return tenantId; - } + public String getTenantId() { + return tenantId; + } - public void setTenantId(String tenantId) { - this.tenantId = tenantId; - } + public void setTenantId(String tenantId) { + this.tenantId = tenantId; + } - public Timestamp getCreated() { - return created; - } + public Timestamp getCreated() { + return created; + } - public void setCreated(Timestamp created) { - this.created = created; - } + public void setCreated(Timestamp created) { + this.created = created; + } - public Timestamp getClaimed() { - return claimed; - } + public Timestamp getClaimed() { + return claimed; + } - public void setClaimed(Timestamp claimed) { - this.claimed = claimed; - } + public void setClaimed(Timestamp claimed) { + this.claimed = claimed; + } - public Timestamp getCompleted() { - return completed; - } + public Timestamp getCompleted() { + return completed; + } - public void setCompleted(Timestamp completed) { - this.completed = completed; - } + public void setCompleted(Timestamp completed) { + this.completed = completed; + } - public Timestamp getModified() { - return modified; - } + public Timestamp getModified() { + return modified; + } - public void setModified(Timestamp modified) { - this.modified = modified; - } + public void setModified(Timestamp modified) { + this.modified = modified; + } - public Timestamp getPlanned() { - return planned; - } + public Timestamp getPlanned() { + return planned; + } - public void setPlanned(Timestamp planned) { - this.planned = planned; - } + public void setPlanned(Timestamp planned) { + this.planned = planned; + } - public Timestamp getDue() { - return due; - } + public Timestamp getDue() { + return due; + } - public void setDue(Timestamp due) { - this.due = due; - } + public void setDue(Timestamp due) { + this.due = due; + } - public String getName() { - return name; - } + public String getName() { + return name; + } - public void setName(String name) { - this.name = name; - } + public void setName(String name) { + this.name = name; + } - public String getDescription() { - return description; - } + public String getDescription() { + return description; + } - public void setDescription(String description) { - this.description = description; - } + public void setDescription(String description) { + this.description = description; + } - public int getPriority() { - return priority; - } + public int getPriority() { + return priority; + } - public void setPriority(int priority) { - this.priority = priority; - } + public void setPriority(int priority) { + this.priority = priority; + } - public TaskState getState() { - return state; - } + public TaskState getState() { + return state; + } - public void setState(TaskState state) { - this.state = state; - } + public void setState(TaskState state) { + this.state = state; + } - public String getType() { - return type; - } + public String getType() { + return type; + } - public void setType(String type) { - this.type = type; - } + public void setType(String type) { + this.type = type; + } - public String getWorkbasketId() { - return workbasketId; - } + public String getWorkbasketId() { + return workbasketId; + } - public void setWorkbasketId(String workbasketId) { - this.workbasketId = workbasketId; - } + public void setWorkbasketId(String workbasketId) { + this.workbasketId = workbasketId; + } - public String getOwner() { - return owner; - } + public String getOwner() { + return owner; + } - public void setOwner(String owner) { - this.owner = owner; - } + public void setOwner(String owner) { + this.owner = owner; + } - public ObjectReference getPrimaryObjRef() { - return primaryObjRef; - } + public ObjectReference getPrimaryObjRef() { + return primaryObjRef; + } - public void setPrimaryObjRef(ObjectReference primaryObjRef) { - this.primaryObjRef = primaryObjRef; - } + public void setPrimaryObjRef(ObjectReference primaryObjRef) { + this.primaryObjRef = primaryObjRef; + } - public boolean isRead() { - return isRead; - } + public boolean isRead() { + return isRead; + } - public void setRead(boolean isRead) { - this.isRead = isRead; - } + public void setRead(boolean isRead) { + this.isRead = isRead; + } - public boolean isTransferred() { - return isTransferred; - } + public boolean isTransferred() { + return isTransferred; + } - public void setTransferred(boolean isTransferred) { - this.isTransferred = isTransferred; - } + public void setTransferred(boolean isTransferred) { + this.isTransferred = isTransferred; + } - public String toString() { - StringBuffer sb = new StringBuffer(); - sb.append("TASK("); - sb.append("id=" + id); - sb.append(", tenantId=" + tenantId); - sb.append(", created=" + created); - sb.append(", claimed=" + claimed); - sb.append(", completed=" + completed); - sb.append(", modified=" + modified); - sb.append(", planned=" + planned); - sb.append(", due=" + due); - sb.append(", name=" + name); - sb.append(", description=" + description); - sb.append(", priority=" + priority); - sb.append(", state=" + state); - sb.append(", type=" + type); - sb.append(", workbasketId=" + workbasketId); - sb.append(", owner=" + owner); - sb.append(", primaryObjRef=" + primaryObjRef); - sb.append(", isRead=" + isRead); - sb.append(", isTransferred=" + isTransferred); - sb.append(")"); - return sb.toString(); - } + public String toString() { + StringBuffer sb = new StringBuffer(); + sb.append("TASK("); + sb.append("id=" + id); + sb.append(", tenantId=" + tenantId); + sb.append(", created=" + created); + sb.append(", claimed=" + claimed); + sb.append(", completed=" + completed); + sb.append(", modified=" + modified); + sb.append(", planned=" + planned); + sb.append(", due=" + due); + sb.append(", name=" + name); + sb.append(", description=" + description); + sb.append(", priority=" + priority); + sb.append(", state=" + state); + sb.append(", type=" + type); + sb.append(", workbasketId=" + workbasketId); + sb.append(", owner=" + owner); + sb.append(", primaryObjRef=" + primaryObjRef); + sb.append(", isRead=" + isRead); + sb.append(", isTransferred=" + isTransferred); + sb.append(")"); + return sb.toString(); + } } diff --git a/lib/taskana-core/src/main/java/org/taskana/model/TaskState.java b/lib/taskana-core/src/main/java/org/taskana/model/TaskState.java index 01783960a..7699e0652 100644 --- a/lib/taskana-core/src/main/java/org/taskana/model/TaskState.java +++ b/lib/taskana-core/src/main/java/org/taskana/model/TaskState.java @@ -1,8 +1,8 @@ package org.taskana.model; /** - * This enum contains all status of the tasks + * This enum contains all status of the tasks. */ public enum TaskState { - READY, CLAIMED, COMPLETED + READY, CLAIMED, COMPLETED } diff --git a/lib/taskana-core/src/main/java/org/taskana/model/TaskStateCounter.java b/lib/taskana-core/src/main/java/org/taskana/model/TaskStateCounter.java index e6a4a1d73..36da12665 100644 --- a/lib/taskana-core/src/main/java/org/taskana/model/TaskStateCounter.java +++ b/lib/taskana-core/src/main/java/org/taskana/model/TaskStateCounter.java @@ -1,26 +1,26 @@ package org.taskana.model; /** - * TaskStateCounter entity + * TaskStateCounter entity. */ public class TaskStateCounter { - private TaskState state; - private long counter; + private TaskState state; + private long counter; - public long getCounter() { - return counter; - } + public long getCounter() { + return counter; + } - public void setCounter(long counter) { - this.counter = counter; - } + public void setCounter(long counter) { + this.counter = counter; + } - public TaskState getState() { - return state; - } + public TaskState getState() { + return state; + } - public void setState(TaskState state) { - this.state = state; - } + public void setState(TaskState state) { + this.state = state; + } } diff --git a/lib/taskana-core/src/main/java/org/taskana/model/Workbasket.java b/lib/taskana-core/src/main/java/org/taskana/model/Workbasket.java index 185a16917..7af1e8784 100644 --- a/lib/taskana-core/src/main/java/org/taskana/model/Workbasket.java +++ b/lib/taskana-core/src/main/java/org/taskana/model/Workbasket.java @@ -5,80 +5,80 @@ import java.util.ArrayList; import java.util.List; /** - * Workbasket entity + * Workbasket entity. */ public class Workbasket { - private String id; - private String tenantId; - private Timestamp created; - private Timestamp modified; - private String name; - private String description; - private String owner; - private List distributionTargets = new ArrayList<>(); + private String id; + private String tenantId; + private Timestamp created; + private Timestamp modified; + private String name; + private String description; + private String owner; + private List distributionTargets = new ArrayList<>(); - public String getId() { - return id; - } + public String getId() { + return id; + } - public void setId(String id) { - this.id = id; - } + public void setId(String id) { + this.id = id; + } - public String getTenantId() { - return tenantId; - } + public String getTenantId() { + return tenantId; + } - public void setTenantId(String tenantId) { - this.tenantId = tenantId; - } + public void setTenantId(String tenantId) { + this.tenantId = tenantId; + } - public Timestamp getCreated() { - return created; - } + public Timestamp getCreated() { + return created; + } - public void setCreated(Timestamp created) { - this.created = created; - } + public void setCreated(Timestamp created) { + this.created = created; + } - public Timestamp getModified() { - return modified; - } + public Timestamp getModified() { + return modified; + } - public void setModified(Timestamp modified) { - this.modified = modified; - } + public void setModified(Timestamp modified) { + this.modified = modified; + } - public String getName() { - return name; - } + public String getName() { + return name; + } - public void setName(String name) { - this.name = name; - } + public void setName(String name) { + this.name = name; + } - public String getDescription() { - return description; - } + public String getDescription() { + return description; + } - public void setDescription(String description) { - this.description = description; - } + public void setDescription(String description) { + this.description = description; + } - public String getOwner() { - return owner; - } + public String getOwner() { + return owner; + } - public void setOwner(String owner) { - this.owner = owner; - } + public void setOwner(String owner) { + this.owner = owner; + } - public List getDistributionTargets() { - return distributionTargets; - } + public List getDistributionTargets() { + return distributionTargets; + } - public void setDistributionTargets(List distributionTargets) { - this.distributionTargets = distributionTargets; - } + public void setDistributionTargets(List distributionTargets) { + this.distributionTargets = distributionTargets; + } } diff --git a/lib/taskana-core/src/main/java/org/taskana/model/WorkbasketAccessItem.java b/lib/taskana-core/src/main/java/org/taskana/model/WorkbasketAccessItem.java index 7207b775d..610c40053 100644 --- a/lib/taskana-core/src/main/java/org/taskana/model/WorkbasketAccessItem.java +++ b/lib/taskana-core/src/main/java/org/taskana/model/WorkbasketAccessItem.java @@ -1,89 +1,89 @@ package org.taskana.model; /** - * WorkbasketAccessItem entity + * WorkbasketAccessItem entity. */ public class WorkbasketAccessItem { - private String id; - private String workbasketId; - private String userId; - private String groupId; - private boolean read; - private boolean open; - private boolean append; - private boolean transfer; - private boolean distribute; + private String id; + private String workbasketId; + private String userId; + private String groupId; + private boolean read; + private boolean open; + private boolean append; + private boolean transfer; + private boolean distribute; - public String getId() { - return id; - } + public String getId() { + return id; + } - public void setId(String id) { - this.id = id; - } + public void setId(String id) { + this.id = id; + } - public String getWorkbasketId() { - return workbasketId; - } + public String getWorkbasketId() { + return workbasketId; + } - public void setWorkbasketId(String workbasketId) { - this.workbasketId = workbasketId; - } + public void setWorkbasketId(String workbasketId) { + this.workbasketId = workbasketId; + } - public String getUserId() { - return userId; - } + public String getUserId() { + return userId; + } - public void setUserId(String userId) { - this.userId = userId; - } + public void setUserId(String userId) { + this.userId = userId; + } - public String getGroupId() { - return groupId; - } + public String getGroupId() { + return groupId; + } - public void setGroupId(String groupId) { - this.groupId = groupId; - } + public void setGroupId(String groupId) { + this.groupId = groupId; + } - public boolean isRead() { - return read; - } + public boolean isRead() { + return read; + } - public void setRead(boolean read) { - this.read = read; - } + public void setRead(boolean read) { + this.read = read; + } - public boolean isOpen() { - return open; - } + public boolean isOpen() { + return open; + } - public void setOpen(boolean open) { - this.open = open; - } + public void setOpen(boolean open) { + this.open = open; + } - public boolean isAppend() { - return append; - } + public boolean isAppend() { + return append; + } - public void setAppend(boolean append) { - this.append = append; - } + public void setAppend(boolean append) { + this.append = append; + } - public boolean isTransfer() { - return transfer; - } + public boolean isTransfer() { + return transfer; + } - public void setTransfer(boolean transfer) { - this.transfer = transfer; - } + public void setTransfer(boolean transfer) { + this.transfer = transfer; + } - public boolean isDistribute() { - return distribute; - } + public boolean isDistribute() { + return distribute; + } - public void setDistribute(boolean distribute) { - this.distribute = distribute; - } + public void setDistribute(boolean distribute) { + this.distribute = distribute; + } } diff --git a/lib/taskana-core/src/main/java/org/taskana/model/WorkbasketAuthorization.java b/lib/taskana-core/src/main/java/org/taskana/model/WorkbasketAuthorization.java index 4cbd5cf95..82876ed16 100644 --- a/lib/taskana-core/src/main/java/org/taskana/model/WorkbasketAuthorization.java +++ b/lib/taskana-core/src/main/java/org/taskana/model/WorkbasketAuthorization.java @@ -4,5 +4,5 @@ package org.taskana.model; * This enum contains all permission values for the workbaskets. */ public enum WorkbasketAuthorization { - READ, OPEN, APPEND, TRANSFER, DISTRIBUTE + READ, OPEN, APPEND, TRANSFER, DISTRIBUTE } diff --git a/lib/taskana-core/src/main/java/org/taskana/model/mappings/ClassificationMapper.java b/lib/taskana-core/src/main/java/org/taskana/model/mappings/ClassificationMapper.java index a39f2674a..153d49ba9 100644 --- a/lib/taskana-core/src/main/java/org/taskana/model/mappings/ClassificationMapper.java +++ b/lib/taskana-core/src/main/java/org/taskana/model/mappings/ClassificationMapper.java @@ -5,33 +5,34 @@ import org.taskana.model.Classification; import java.util.List; +/** + * This class is the mybatis mapping of classifications. + */ public interface ClassificationMapper { - @Select("SELECT * FROM CLASSIFICATION ORDER BY ID") - @Results({ - @Result(property="id", column="ID"), - @Result(property="tenantId", column="TENANT_ID"), - @Result(property="parentClassificationId", column="PARENT_CLASSIFICATION_ID"), - @Result(property="category", column="CATEGORY"), - @Result(property="type", column="TYPE"), - @Result(property="created", column="CREATED"), - @Result(property="modified", column="MODIFIED"), - @Result(property="name", column="NAME"), - @Result(property="description", column="DESCRIPTION"), - @Result(property="priority", column="PRIORITY"), - @Result(property="serviceLevel", column="SERVICE_LEVEL") - }) - List findAll(); - - @Select("SELECT * FROM CLASSIFICATION WHERE PARENT_CLASSIFICATION_ID = #{parentClassificationId} ORDER BY ID") - List findByParentId(@Param("parentClassificationId") String parentId); - - @Select("SELECT * FROM CLASSIFICATION WHERE ID = #{classificationId}") - Classification findById(@Param("classificationId") String classificationId); - - @Insert("INSERT INTO CLASSIFICATION (ID, TENANT_ID, PARENT_CLASSIFICATION_ID, CATEGORY, TYPE, CREATED, NAME, DESCRIPTION, PRIORITY, SERVICE_LEVEL) VALUES (#{classification.id}, #{classification.tenantId}, #{classification.parentClassificationId}, #{classification.category}, #{classification.type}, #{classification.created}, #{classification.name}, #{classification.description}, #{classification.priority}, #{classification.serviceLevel})") - void insert(@Param("classification") Classification classification); - - @Update(value = "UPDATE CLASSIFICATION SET TENANT_ID = #{classification.tenantId}, PARENT_CLASSIFICATION_ID = #{classification.parentClassificationId}, CATEGORY = #{classification.category}, TYPE = #{classification.type}, NAME = #{classification.name}, DESCRIPTION = #{classification.description}, PRIORITY = #{classification.priority}, SERVICE_LEVEL = #{classification.serviceLevel}, MODIFIED = #{classification.modified} WHERE ID = #{classification.id}") - void update(@Param("classification") Classification classification); + @Select("SELECT * FROM CLASSIFICATION ORDER BY ID") + @Results({ @Result(property = "id", column = "ID"), + @Result(property = "tenantId", column = "TENANT_ID"), + @Result(property = "parentClassificationId", column = "PARENT_CLASSIFICATION_ID"), + @Result(property = "category", column = "CATEGORY"), + @Result(property = "type", column = "TYPE"), + @Result(property = "created", column = "CREATED"), + @Result(property = "modified", column = "MODIFIED"), + @Result(property = "name", column = "NAME"), + @Result(property = "description", column = "DESCRIPTION"), + @Result(property = "priority", column = "PRIORITY"), + @Result(property = "serviceLevel", column = "SERVICE_LEVEL") }) + List findAll(); + + @Select("SELECT * FROM CLASSIFICATION WHERE PARENT_CLASSIFICATION_ID = #{parentClassificationId} ORDER BY ID") + List findByParentId(@Param("parentClassificationId") String parentId); + + @Select("SELECT * FROM CLASSIFICATION WHERE ID = #{classificationId}") + Classification findById(@Param("classificationId") String classificationId); + + @Insert("INSERT INTO CLASSIFICATION (ID, TENANT_ID, PARENT_CLASSIFICATION_ID, CATEGORY, TYPE, CREATED, NAME, DESCRIPTION, PRIORITY, SERVICE_LEVEL) VALUES (#{classification.id}, #{classification.tenantId}, #{classification.parentClassificationId}, #{classification.category}, #{classification.type}, #{classification.created}, #{classification.name}, #{classification.description}, #{classification.priority}, #{classification.serviceLevel})") + void insert(@Param("classification") Classification classification); + + @Update(value = "UPDATE CLASSIFICATION SET TENANT_ID = #{classification.tenantId}, PARENT_CLASSIFICATION_ID = #{classification.parentClassificationId}, CATEGORY = #{classification.category}, TYPE = #{classification.type}, NAME = #{classification.name}, DESCRIPTION = #{classification.description}, PRIORITY = #{classification.priority}, SERVICE_LEVEL = #{classification.serviceLevel}, MODIFIED = #{classification.modified} WHERE ID = #{classification.id}") + void update(@Param("classification") Classification classification); } diff --git a/lib/taskana-core/src/main/java/org/taskana/model/mappings/DistributionTargetMapper.java b/lib/taskana-core/src/main/java/org/taskana/model/mappings/DistributionTargetMapper.java index 560032326..56f4bc197 100644 --- a/lib/taskana-core/src/main/java/org/taskana/model/mappings/DistributionTargetMapper.java +++ b/lib/taskana-core/src/main/java/org/taskana/model/mappings/DistributionTargetMapper.java @@ -6,18 +6,20 @@ import org.apache.ibatis.annotations.Delete; import org.apache.ibatis.annotations.Insert; import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Select; - +/** + * This class is the mybatis mapping of distribution targets. + */ public interface DistributionTargetMapper { - - @Insert("INSERT INTO DISTRIBUTION_TARGETS (SOURCE_ID, TARGET_ID) VALUES (#{sourceId}, #{targetId})") - void insert(@Param("sourceId") String sourceId, @Param("targetId") String targetId); - - @Delete("DELETE FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{sourceId} AND TARGET_ID = #{targetId}") - void delete(@Param("sourceId") String sourceId, @Param("targetId") String targetId); - @Select("SELECT TARGET_ID FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{sourceId}") - List findBySourceId(@Param("sourceId") String sourceId); - - @Delete("") - void deleteMultiple(@Param("sourceId") String sourceId, @Param("targetId") List targetId); + @Insert("INSERT INTO DISTRIBUTION_TARGETS (SOURCE_ID, TARGET_ID) VALUES (#{sourceId}, #{targetId})") + void insert(@Param("sourceId") String sourceId, @Param("targetId") String targetId); + + @Delete("DELETE FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{sourceId} AND TARGET_ID = #{targetId}") + void delete(@Param("sourceId") String sourceId, @Param("targetId") String targetId); + + @Select("SELECT TARGET_ID FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{sourceId}") + List findBySourceId(@Param("sourceId") String sourceId); + + @Delete("") + void deleteMultiple(@Param("sourceId") String sourceId, @Param("targetId") List targetId); } diff --git a/lib/taskana-core/src/main/java/org/taskana/model/mappings/ObjectReferenceMapper.java b/lib/taskana-core/src/main/java/org/taskana/model/mappings/ObjectReferenceMapper.java index 89600617a..4e6a2aaf3 100644 --- a/lib/taskana-core/src/main/java/org/taskana/model/mappings/ObjectReferenceMapper.java +++ b/lib/taskana-core/src/main/java/org/taskana/model/mappings/ObjectReferenceMapper.java @@ -10,62 +10,61 @@ import org.apache.ibatis.annotations.Results; import org.apache.ibatis.annotations.Select; import org.apache.ibatis.annotations.Update; import org.taskana.model.ObjectReference; - +/** + * This class is the mybatis mapping of ObjectReference. + */ public interface ObjectReferenceMapper { - @Select("SELECT ID, TENANT_ID, COMPANY, SYSTEM, SYSTEM_INSTANCE, TYPE, VALUE " - + "FROM OBJECT_REFERENCE " - + "ORDER BY ID") - @Results({ - @Result(property="id", column="ID"), - @Result(property="tenantId", column="TENANT_ID"), - @Result(property="company", column="COMPANY"), - @Result(property="system", column="SYSTEM"), - @Result(property="systemInstance", column="SYSTEM_INSTANCE"), - @Result(property="type", column="TYPE"), - @Result(property="value", column="VALUE") - }) - List findAll(); - - @Select("SELECT ID, TENANT_ID, COMPANY, SYSTEM, SYSTEM_INSTANCE, TYPE, VALUE " - + "FROM OBJECT_REFERENCE " - + "WHERE ID = #{id}") - @Results({ - @Result(property="id", column="ID"), - @Result(property="tenantId", column="TENANT_ID"), - @Result(property="company", column="COMPANY"), - @Result(property="system", column="SYSTEM"), - @Result(property="systemInstance", column="SYSTEM_INSTANCE"), - @Result(property="type", column="TYPE"), - @Result(property="value", column="VALUE") - }) - ObjectReference findById(@Param("id") String id); - - @Select("SELECT ID, TENANT_ID, COMPANY, SYSTEM, SYSTEM_INSTANCE, TYPE, VALUE " - + "FROM OBJECT_REFERENCE " - + "WHERE TENANT_ID = #{objectReference.tenantId} " - + "AND COMPANY = #{objectReference.company} " - + "AND SYSTEM = #{objectReference.system} " - + "AND SYSTEM_INSTANCE = #{objectReference.systemInstance} " - + "AND TYPE = #{objectReference.type} " - + "AND VALUE = #{objectReference.value}") - @Results({ - @Result(property="id", column="ID"), - @Result(property="tenantId", column="TENANT_ID"), - @Result(property="company", column="COMPANY"), - @Result(property="system", column="SYSTEM"), - @Result(property="systemInstance", column="SYSTEM_INSTANCE"), - @Result(property="type", column="TYPE"), - @Result(property="value", column="VALUE") - }) - ObjectReference findByObjectReference(@Param("objectReference") ObjectReference objectReference); - - @Insert("INSERT INTO OBJECT_REFERENCE (ID, TENANT_ID, COMPANY, SYSTEM, SYSTEM_INSTANCE, TYPE, VALUE) VALUES (#{ref.id}, #{ref.tenantId}, #{ref.company}, #{ref.system}, #{ref.systemInstance}, #{ref.type}, #{ref.value})") - void insert(@Param("ref") ObjectReference ref); - - @Update(value = "UPDATE OBJECT_REFERENCE SET TENANT_ID = #{ref.tenantId}, COMPANY = #{ref.company}, SYSTEM = #{ref.system}, SYSTEM_INSTANCE = #{ref.systemInstance}, TYPE = #{ref.type}, VALUE = #{ref.value} WHERE ID = #{ref.id}") - void update(@Param("ref") ObjectReference ref); - - @Delete("DELETE FROM OBJECT_REFERENCE WHERE ID = #{id}") - void delete(String id); + @Select("SELECT ID, TENANT_ID, COMPANY, SYSTEM, SYSTEM_INSTANCE, TYPE, VALUE " + + "FROM OBJECT_REFERENCE " + + "ORDER BY ID") + @Results({ + @Result(property = "id", column = "ID"), + @Result(property = "tenantId", column = "TENANT_ID"), + @Result(property = "company", column = "COMPANY"), + @Result(property = "system", column = "SYSTEM"), + @Result(property = "systemInstance", column = "SYSTEM_INSTANCE"), + @Result(property = "type", column = "TYPE"), + @Result(property = "value", column = "VALUE") }) + List findAll(); + + @Select("SELECT ID, TENANT_ID, COMPANY, SYSTEM, SYSTEM_INSTANCE, TYPE, VALUE " + + "FROM OBJECT_REFERENCE " + + "WHERE ID = #{id}") + @Results({ + @Result(property = "id", column = "ID"), + @Result(property = "tenantId", column = "TENANT_ID"), + @Result(property = "company", column = "COMPANY"), + @Result(property = "system", column = "SYSTEM"), + @Result(property = "systemInstance", column = "SYSTEM_INSTANCE"), + @Result(property = "type", column = "TYPE"), + @Result(property = "value", column = "VALUE") }) + ObjectReference findById(@Param("id") String id); + + @Select("SELECT ID, TENANT_ID, COMPANY, SYSTEM, SYSTEM_INSTANCE, TYPE, VALUE " + + "FROM OBJECT_REFERENCE " + + "WHERE TENANT_ID = #{objectReference.tenantId} " + + "AND COMPANY = #{objectReference.company} " + + "AND SYSTEM = #{objectReference.system} " + + "AND SYSTEM_INSTANCE = #{objectReference.systemInstance} " + + "AND TYPE = #{objectReference.type} " + + "AND VALUE = #{objectReference.value}") + @Results({ + @Result(property = "id", column = "ID"), + @Result(property = "tenantId", column = "TENANT_ID"), + @Result(property = "company", column = "COMPANY"), + @Result(property = "system", column = "SYSTEM"), + @Result(property = "systemInstance", column = "SYSTEM_INSTANCE"), + @Result(property = "type", column = "TYPE"), + @Result(property = "value", column = "VALUE") }) + ObjectReference findByObjectReference(@Param("objectReference") ObjectReference objectReference); + + @Insert("INSERT INTO OBJECT_REFERENCE (ID, TENANT_ID, COMPANY, SYSTEM, SYSTEM_INSTANCE, TYPE, VALUE) VALUES (#{ref.id}, #{ref.tenantId}, #{ref.company}, #{ref.system}, #{ref.systemInstance}, #{ref.type}, #{ref.value})") + void insert(@Param("ref") ObjectReference ref); + + @Update(value = "UPDATE OBJECT_REFERENCE SET TENANT_ID = #{ref.tenantId}, COMPANY = #{ref.company}, SYSTEM = #{ref.system}, SYSTEM_INSTANCE = #{ref.systemInstance}, TYPE = #{ref.type}, VALUE = #{ref.value} WHERE ID = #{ref.id}") + void update(@Param("ref") ObjectReference ref); + + @Delete("DELETE FROM OBJECT_REFERENCE WHERE ID = #{id}") + void delete(String id); } diff --git a/lib/taskana-core/src/main/java/org/taskana/model/mappings/TaskMapper.java b/lib/taskana-core/src/main/java/org/taskana/model/mappings/TaskMapper.java index e3e82c27b..1cc544186 100644 --- a/lib/taskana-core/src/main/java/org/taskana/model/mappings/TaskMapper.java +++ b/lib/taskana-core/src/main/java/org/taskana/model/mappings/TaskMapper.java @@ -17,18 +17,19 @@ import org.taskana.model.ObjectReference; import org.taskana.model.Task; import org.taskana.model.TaskState; import org.taskana.model.TaskStateCounter; - +/** + * This class is the mybatis mapping of task. + */ public interface TaskMapper { @Select("SELECT ID, TENANT_ID, CREATED, CLAIMED, COMPLETED, MODIFIED, PLANNED, DUE, NAME, DESCRIPTION, PRIORITY, STATE, TYPE, WORKBASKETID, OWNER, PRIMARY_OBJ_REF_ID, IS_READ, IS_TRANSFERRED " - + "FROM TASK " - + "WHERE ID = #{id}") - @Results(value = { - @Result(property = "id", column = "ID"), + + "FROM TASK " + "WHERE ID = #{id}") + @Results(value = { + @Result(property = "id", column = "ID"), @Result(property = "tenantId", column = "TENANT_ID"), - @Result(property = "created", column = "CREATED"), + @Result(property = "created", column = "CREATED"), @Result(property = "claimed", column = "CLAIMED"), - @Result(property = "completed", column = "COMPLETED"), + @Result(property = "completed", column = "COMPLETED"), @Result(property = "modified", column = "MODIFIED"), @Result(property = "planned", column = "PLANNED"), @Result(property = "due", column = "DUE"), @@ -39,21 +40,19 @@ public interface TaskMapper { @Result(property = "type", column = "TYPE"), @Result(property = "workbasketId", column = "WORKBASKETID"), @Result(property = "owner", column = "OWNER"), - @Result(property = "primaryObjRef", column = "PRIMARY_OBJ_REF_ID", javaType = ObjectReference.class, one = @One(select="org.taskana.model.mappings.ObjectReferenceMapper.findById")), + @Result(property = "primaryObjRef", column = "PRIMARY_OBJ_REF_ID", javaType = ObjectReference.class, one = @One(select = "org.taskana.model.mappings.ObjectReferenceMapper.findById")), @Result(property = "isRead", column = "IS_READ"), - @Result(property = "isTransferred", column = "IS_TRANSFERRED")}) - Task findById(@Param("id") String id); + @Result(property = "isTransferred", column = "IS_TRANSFERRED") }) + Task findById(@Param("id") String id); @Select("SELECT ID, TENANT_ID, CREATED, CLAIMED, COMPLETED, MODIFIED, PLANNED, DUE, NAME, DESCRIPTION, PRIORITY, STATE, TYPE, WORKBASKETID, OWNER, PRIMARY_OBJ_REF_ID, IS_READ, IS_TRANSFERRED " - + "FROM TASK " - + "WHERE WORKBASKETID = #{workbasketId} " - + "ORDER BY ID") - @Results(value = { - @Result(property = "id", column = "ID"), + + "FROM TASK " + "WHERE WORKBASKETID = #{workbasketId} " + "ORDER BY ID") + @Results(value = { + @Result(property = "id", column = "ID"), @Result(property = "tenantId", column = "TENANT_ID"), - @Result(property = "created", column = "CREATED"), + @Result(property = "created", column = "CREATED"), @Result(property = "claimed", column = "CLAIMED"), - @Result(property = "completed", column = "COMPLETED"), + @Result(property = "completed", column = "COMPLETED"), @Result(property = "modified", column = "MODIFIED"), @Result(property = "planned", column = "PLANNED"), @Result(property = "due", column = "DUE"), @@ -64,24 +63,23 @@ public interface TaskMapper { @Result(property = "type", column = "TYPE"), @Result(property = "workbasketId", column = "WORKBASKETID"), @Result(property = "owner", column = "OWNER"), - @Result(property = "primaryObjRef", column = "PRIMARY_OBJ_REF_ID", javaType = ObjectReference.class, one = @One(select="org.taskana.model.mappings.ObjectReferenceMapper.findById")), + @Result(property = "primaryObjRef", column = "PRIMARY_OBJ_REF_ID", javaType = ObjectReference.class, one = @One(select = "org.taskana.model.mappings.ObjectReferenceMapper.findById")), @Result(property = "isRead", column = "IS_READ"), - @Result(property = "isTransferred", column = "IS_TRANSFERRED")}) - List findByWorkBasketId(@Param("workbasketId") String workbasketId); + @Result(property = "isTransferred", column = "IS_TRANSFERRED") }) + List findByWorkBasketId(@Param("workbasketId") String workbasketId); @Select("") - @Results(value = { - @Result(property = "id", column = "ID"), + + "ORDER BY ID" + "") + @Results(value = { + @Result(property = "id", column = "ID"), @Result(property = "tenantId", column = "TENANT_ID"), - @Result(property = "created", column = "CREATED"), + @Result(property = "created", column = "CREATED"), @Result(property = "claimed", column = "CLAIMED"), - @Result(property = "completed", column = "COMPLETED"), + @Result(property = "completed", column = "COMPLETED"), @Result(property = "modified", column = "MODIFIED"), @Result(property = "planned", column = "PLANNED"), @Result(property = "due", column = "DUE"), @@ -92,23 +90,23 @@ public interface TaskMapper { @Result(property = "type", column = "TYPE"), @Result(property = "workbasketId", column = "WORKBASKETID"), @Result(property = "owner", column = "OWNER"), - @Result(property = "primaryObjRef", column = "PRIMARY_OBJ_REF_ID", javaType = ObjectReference.class, one = @One(select="org.taskana.model.mappings.ObjectReferenceMapper.findById")), + @Result(property = "primaryObjRef", column = "PRIMARY_OBJ_REF_ID", javaType = ObjectReference.class, one = @One(select = "org.taskana.model.mappings.ObjectReferenceMapper.findById")), @Result(property = "isRead", column = "IS_READ"), - @Result(property = "isTransferred", column = "IS_TRANSFERRED")}) - List findByWorkbasketIdsAndStates(@Param("workbasketIds") List workbasketIds, @Param("states") List states); - + @Result(property = "isTransferred", column = "IS_TRANSFERRED") }) + List findByWorkbasketIdsAndStates(@Param("workbasketIds") List workbasketIds, @Param("states") List states); + @Select("") - @Results(value = { - @Result(property = "id", column = "ID"), + @Results(value = { + @Result(property = "id", column = "ID"), @Result(property = "tenantId", column = "TENANT_ID"), - @Result(property = "created", column = "CREATED"), + @Result(property = "created", column = "CREATED"), @Result(property = "claimed", column = "CLAIMED"), - @Result(property = "completed", column = "COMPLETED"), + @Result(property = "completed", column = "COMPLETED"), @Result(property = "modified", column = "MODIFIED"), @Result(property = "planned", column = "PLANNED"), @Result(property = "due", column = "DUE"), @@ -119,78 +117,65 @@ public interface TaskMapper { @Result(property = "type", column = "TYPE"), @Result(property = "workbasketId", column = "WORKBASKETID"), @Result(property = "owner", column = "OWNER"), - @Result(property = "primaryObjRef", column = "PRIMARY_OBJ_REF_ID", javaType = ObjectReference.class, one = @One(select="org.taskana.model.mappings.ObjectReferenceMapper.findById")), + @Result(property = "primaryObjRef", column = "PRIMARY_OBJ_REF_ID", javaType = ObjectReference.class, one = @One(select = "org.taskana.model.mappings.ObjectReferenceMapper.findById")), @Result(property = "isRead", column = "IS_READ"), - @Result(property = "isTransferred", column = "IS_TRANSFERRED")}) - List findByStates(@Param("states") List states); - - @Select("SELECT ID, TENANT_ID, CREATED, CLAIMED, COMPLETED, MODIFIED, PLANNED, DUE, NAME, DESCRIPTION, PRIORITY, STATE, TYPE, WORKBASKETID, OWNER, PRIMARY_OBJ_REF_ID, IS_READ, IS_TRANSFERRED " - + "FROM TASK ") - @Results(value = { - @Result(property = "id", column = "ID"), - @Result(property = "tenantId", column = "TENANT_ID"), - @Result(property = "created", column = "CREATED"), - @Result(property = "claimed", column = "CLAIMED"), - @Result(property = "completed", column = "COMPLETED"), - @Result(property = "modified", column = "MODIFIED"), - @Result(property = "planned", column = "PLANNED"), - @Result(property = "due", column = "DUE"), - @Result(property = "name", column = "NAME"), - @Result(property = "description", column = "DESCRIPTION"), - @Result(property = "priority", column = "PRIORITY"), - @Result(property = "state", column = "STATE"), - @Result(property = "type", column = "TYPE"), - @Result(property = "workbasketId", column = "WORKBASKETID"), + @Result(property = "isTransferred", column = "IS_TRANSFERRED") }) + List findByStates(@Param("states") List states); + + @Select("SELECT ID, TENANT_ID, CREATED, CLAIMED, COMPLETED, MODIFIED, PLANNED, DUE, NAME, DESCRIPTION, PRIORITY, STATE, TYPE, WORKBASKETID, OWNER, PRIMARY_OBJ_REF_ID, IS_READ, IS_TRANSFERRED " + + "FROM TASK ") + @Results(value = { @Result(property = "id", column = "ID"), @Result(property = "tenantId", column = "TENANT_ID"), + @Result(property = "created", column = "CREATED"), @Result(property = "claimed", column = "CLAIMED"), + @Result(property = "completed", column = "COMPLETED"), @Result(property = "modified", column = "MODIFIED"), + @Result(property = "planned", column = "PLANNED"), @Result(property = "due", column = "DUE"), + @Result(property = "name", column = "NAME"), @Result(property = "description", column = "DESCRIPTION"), + @Result(property = "priority", column = "PRIORITY"), @Result(property = "state", column = "STATE"), + @Result(property = "type", column = "TYPE"), @Result(property = "workbasketId", column = "WORKBASKETID"), @Result(property = "owner", column = "OWNER"), - @Result(property = "primaryObjRef", column = "PRIMARY_OBJ_REF_ID", javaType = ObjectReference.class, one = @One(select="org.taskana.model.mappings.ObjectReferenceMapper.findById")), + @Result(property = "primaryObjRef", column = "PRIMARY_OBJ_REF_ID", javaType = ObjectReference.class, one = @One(select = "org.taskana.model.mappings.ObjectReferenceMapper.findById")), @Result(property = "isRead", column = "IS_READ"), - @Result(property = "isTransferred", column = "IS_TRANSFERRED")}) - List findAll(); + @Result(property = "isTransferred", column = "IS_TRANSFERRED") }) + List findAll(); - @Select("") - @Results({ - @Result(column="STATE", property="state"), - @Result(column="counter", property="counter") - }) - List getTaskCountForState(@Param("status") List status); + @Select("") + @Results({ @Result(column = "STATE", property = "state"), @Result(column = "counter", property = "counter") }) + List getTaskCountForState(@Param("status") List status); - @Select("") - long getTaskCountForWorkbasketByDaysInPastAndState(@Param("workbasketId")String workbasketId, @Param("fromDate") Date fromDate, @Param("status") List states); - - @Select("") - @Results({ - @Result(column="DUE_DATE", property="due"), - @Result(column="WORKBASKETID", property="workbasketId"), - @Result(column="counter", property="taskCounter") - }) - List getTaskCountByWorkbasketIdAndDaysInPastAndState(@Param("fromDate") Date fromDate, @Param("status") List states); - - @Insert("INSERT INTO TASK(ID, TENANT_ID, CREATED, CLAIMED, COMPLETED, MODIFIED, PLANNED, DUE, NAME, DESCRIPTION, PRIORITY, STATE, TYPE, WORKBASKETID, OWNER, PRIMARY_OBJ_REF_ID, IS_READ, IS_TRANSFERRED) " - + "VALUES(#{id}, #{tenantId}, #{created}, #{claimed}, #{completed}, #{modified}, #{planned}, #{due}, #{name}, #{description}, #{priority}, #{state}, #{type}, #{workbasketId}, #{owner}, #{primaryObjRef.id}, #{isRead}, #{isTransferred})") - @Options(keyProperty = "id", keyColumn="ID") - void insert(Task task); + @Select("") + long getTaskCountForWorkbasketByDaysInPastAndState(@Param("workbasketId") String workbasketId, @Param("fromDate") Date fromDate, @Param("status") List states); - @Update("UPDATE TASK SET TENANT_ID = #{tenantId}, CLAIMED = #{claimed}, COMPLETED = #{completed}, MODIFIED = #{modified}, PLANNED = #{planned}, DUE = #{due}, NAME = #{name}, DESCRIPTION = #{description}, PRIORITY = #{priority}, STATE = #{state}, TYPE = #{type}, WORKBASKETID = #{workbasketId}, OWNER = #{owner}, PRIMARY_OBJ_REF_ID = #{primaryObjRef.id}, IS_READ = #{isRead}, IS_TRANSFERRED = #{isTransferred} WHERE ID = #{id}") - void update(Task task); + @Select("") + @Results({ @Result(column = "DUE_DATE", property = "due"), + @Result(column = "WORKBASKETID", property = "workbasketId"), + @Result(column = "counter", property = "taskCounter") }) + List getTaskCountByWorkbasketIdAndDaysInPastAndState(@Param("fromDate") Date fromDate, @Param("status") List states); - @Delete("DELETE FROM TASK WHERE ID = #{id}") - void delete(String id); + @Insert("INSERT INTO TASK(ID, TENANT_ID, CREATED, CLAIMED, COMPLETED, MODIFIED, PLANNED, DUE, NAME, DESCRIPTION, PRIORITY, STATE, TYPE, WORKBASKETID, OWNER, PRIMARY_OBJ_REF_ID, IS_READ, IS_TRANSFERRED) " + + "VALUES(#{id}, #{tenantId}, #{created}, #{claimed}, #{completed}, #{modified}, #{planned}, #{due}, #{name}, #{description}, #{priority}, #{state}, #{type}, #{workbasketId}, #{owner}, #{primaryObjRef.id}, #{isRead}, #{isTransferred})") + @Options(keyProperty = "id", keyColumn = "ID") + void insert(Task task); + + @Update("UPDATE TASK SET TENANT_ID = #{tenantId}, CLAIMED = #{claimed}, COMPLETED = #{completed}, MODIFIED = #{modified}, PLANNED = #{planned}, DUE = #{due}, NAME = #{name}, DESCRIPTION = #{description}, PRIORITY = #{priority}, STATE = #{state}, TYPE = #{type}, WORKBASKETID = #{workbasketId}, OWNER = #{owner}, PRIMARY_OBJ_REF_ID = #{primaryObjRef.id}, IS_READ = #{isRead}, IS_TRANSFERRED = #{isTransferred} WHERE ID = #{id}") + void update(Task task); + + @Delete("DELETE FROM TASK WHERE ID = #{id}") + void delete(String id); } diff --git a/lib/taskana-core/src/main/java/org/taskana/model/mappings/WorkbasketAccessMapper.java b/lib/taskana-core/src/main/java/org/taskana/model/mappings/WorkbasketAccessMapper.java index f258eff62..598501fee 100644 --- a/lib/taskana-core/src/main/java/org/taskana/model/mappings/WorkbasketAccessMapper.java +++ b/lib/taskana-core/src/main/java/org/taskana/model/mappings/WorkbasketAccessMapper.java @@ -11,12 +11,14 @@ import org.apache.ibatis.annotations.Results; import org.apache.ibatis.annotations.Select; import org.apache.ibatis.annotations.Update; import org.taskana.model.WorkbasketAccessItem; - +/** + * This class is the mybatis mapping of workbasket access items. + */ public interface WorkbasketAccessMapper { - + @Select("SELECT ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE FROM WORKBASKET_ACCESS_LIST WHERE ID = #{id}") - @Results(value = { - @Result(property = "id", column = "ID"), + @Results(value = { + @Result(property = "id", column = "ID"), @Result(property = "workbasketId", column = "WORKBASKET_ID"), @Result(property = "userId", column = "USER_ID"), @Result(property = "groupId", column = "GROUP_ID"), @@ -24,12 +26,12 @@ public interface WorkbasketAccessMapper { @Result(property = "open", column = "OPEN"), @Result(property = "append", column = "APPEND"), @Result(property = "transfer", column = "TRANSFER"), - @Result(property = "distribute", column = "DISTRIBUTE")}) + @Result(property = "distribute", column = "DISTRIBUTE") }) WorkbasketAccessItem findById(@Param("id") String id); - + @Select("SELECT ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE FROM WORKBASKET_ACCESS_LIST WHERE USER_ID = #{userId}") - @Results(value = { - @Result(property = "id", column = "ID"), + @Results(value = { + @Result(property = "id", column = "ID"), @Result(property = "workbasketId", column = "WORKBASKET_ID"), @Result(property = "userId", column = "USER_ID"), @Result(property = "groupId", column = "GROUP_ID"), @@ -37,12 +39,12 @@ public interface WorkbasketAccessMapper { @Result(property = "open", column = "OPEN"), @Result(property = "append", column = "APPEND"), @Result(property = "transfer", column = "TRANSFER"), - @Result(property = "distribute", column = "DISTRIBUTE")}) + @Result(property = "distribute", column = "DISTRIBUTE") }) List findByUserId(@Param("userId") String userId); - + @Select("SELECT ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE FROM WORKBASKET_ACCESS_LIST WHERE WORKBASKET_ID = #{id}") - @Results(value = { - @Result(property = "id", column = "ID"), + @Results(value = { + @Result(property = "id", column = "ID"), @Result(property = "workbasketId", column = "WORKBASKET_ID"), @Result(property = "userId", column = "USER_ID"), @Result(property = "groupId", column = "GROUP_ID"), @@ -50,12 +52,12 @@ public interface WorkbasketAccessMapper { @Result(property = "open", column = "OPEN"), @Result(property = "append", column = "APPEND"), @Result(property = "transfer", column = "TRANSFER"), - @Result(property = "distribute", column = "DISTRIBUTE")}) + @Result(property = "distribute", column = "DISTRIBUTE") }) List findByWorkbasketId(@Param("id") String id); - + @Select("SELECT ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE FROM WORKBASKET_ACCESS_LIST ORDER BY ID") - @Results(value = { - @Result(property = "id", column = "ID"), + @Results(value = { + @Result(property = "id", column = "ID"), @Result(property = "workbasketId", column = "WORKBASKET_ID"), @Result(property = "userId", column = "USER_ID"), @Result(property = "groupId", column = "GROUP_ID"), @@ -63,32 +65,32 @@ public interface WorkbasketAccessMapper { @Result(property = "open", column = "OPEN"), @Result(property = "append", column = "APPEND"), @Result(property = "transfer", column = "TRANSFER"), - @Result(property = "distribute", column = "DISTRIBUTE")}) + @Result(property = "distribute", column = "DISTRIBUTE") }) List findAll(); - + @Insert("INSERT INTO WORKBASKET_ACCESS_LIST (ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE) " + "VALUES (#{workbasketAccessItem.id}, #{workbasketAccessItem.workbasketId}, #{workbasketAccessItem.userId}, #{workbasketAccessItem.groupId}, #{workbasketAccessItem.read}, #{workbasketAccessItem.open}, #{workbasketAccessItem.append}, #{workbasketAccessItem.transfer}, #{workbasketAccessItem.distribute})") - @Options(keyProperty = "id", keyColumn="ID") + @Options(keyProperty = "id", keyColumn = "ID") void insert(@Param("workbasketAccessItem") WorkbasketAccessItem workbasketAccessItem); - + @Update("UPDATE WORKBASKET_ACCESS_LIST SET WORKBASKET_ID = #{workbasketAccessItem.workbasketId}, USER_ID = #{workbasketAccessItem.userId}, GROUP_ID = #{workbasketAccessItem.groupId}, READ = #{workbasketAccessItem.read}, OPEN = #{workbasketAccessItem.open}, APPEND = #{workbasketAccessItem.append}, TRANSFER = #{workbasketAccessItem.transfer}, DISTRIBUTE = #{workbasketAccessItem.distribute} " + "WHERE id = #{workbasketAccessItem.id}") void update(@Param("workbasketAccessItem") WorkbasketAccessItem workbasketAccessItem); @Delete("DELETE FROM WORKBASKET_ACCESS_LIST where id = #{id}") void delete(@Param("id") String id); - + @Select("") - @Results(value = { - @Result(property = "id", column = "ID"), + + "FROM WORKBASKET_ACCESS_LIST " + + "WHERE WORKBASKET_ID = #{workbasketId} " + + "AND USER_ID = #{userId} " + + "AND OPEN" + + "READ" + + "APPEND" + + "TRANSFER" + + "DISTRIBUTE = 1") + @Results(value = { + @Result(property = "id", column = "ID"), @Result(property = "workbasketId", column = "WORKBASKET_ID"), @Result(property = "userId", column = "USER_ID"), @Result(property = "groupId", column = "GROUP_ID"), @@ -96,12 +98,12 @@ public interface WorkbasketAccessMapper { @Result(property = "open", column = "OPEN"), @Result(property = "append", column = "APPEND"), @Result(property = "transfer", column = "TRANSFER"), - @Result(property = "distribute", column = "DISTRIBUTE")}) + @Result(property = "distribute", column = "DISTRIBUTE") }) List findByWorkbasketAndUserAndAuthorization(@Param("workbasketId") String workbasketId, @Param("userId") String userId, @Param("authorization") String authorization); - + @Select("SELECT ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE FROM WORKBASKET_ACCESS_LIST WHERE WORKBASKET_ID = #{workbasketId} AND GROUP_ID = #{groupId}") - @Results(value = { - @Result(property = "id", column = "ID"), + @Results(value = { + @Result(property = "id", column = "ID"), @Result(property = "workbasketId", column = "WORKBASKET_ID"), @Result(property = "userId", column = "USER_ID"), @Result(property = "groupId", column = "GROUP_ID"), @@ -109,6 +111,6 @@ public interface WorkbasketAccessMapper { @Result(property = "open", column = "OPEN"), @Result(property = "append", column = "APPEND"), @Result(property = "transfer", column = "TRANSFER"), - @Result(property = "distribute", column = "DISTRIBUTE")}) + @Result(property = "distribute", column = "DISTRIBUTE") }) List findByWorkbasketAndGroup(@Param("workbasketId") String workbasketId, @Param("groupId") String groupId); } diff --git a/lib/taskana-core/src/main/java/org/taskana/model/mappings/WorkbasketMapper.java b/lib/taskana-core/src/main/java/org/taskana/model/mappings/WorkbasketMapper.java index 0943a969f..891082c17 100644 --- a/lib/taskana-core/src/main/java/org/taskana/model/mappings/WorkbasketMapper.java +++ b/lib/taskana-core/src/main/java/org/taskana/model/mappings/WorkbasketMapper.java @@ -14,74 +14,74 @@ import org.apache.ibatis.annotations.Update; import org.apache.ibatis.mapping.FetchType; import org.taskana.model.Workbasket; import org.taskana.model.WorkbasketAuthorization; - +/** + * This class is the mybatis mapping of workbaskets. + */ public interface WorkbasketMapper { - @Select("SELECT ID, TENANT_ID, CREATED, MODIFIED, NAME, DESCRIPTION, OWNER FROM WORKBASKET WHERE ID = #{id}") - @Results(value = { - @Result(property = "id", column = "ID"), - @Result(property = "tenantId", column = "TENANT_ID"), - @Result(property = "created", column = "CREATED"), - @Result(property = "modified", column = "MODIFIED"), - @Result(property = "name", column = "NAME"), - @Result(property = "description", column = "DESCRIPTION"), - @Result(property = "owner", column = "OWNER"), - @Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select="findByDistributionTargets")) }) - public Workbasket findById(@Param("id") String id); - - @Select("SELECT * FROM WORKBASKET WHERE id IN (SELECT TARGET_ID FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{id})") - @Results(value = { - @Result(property = "id", column = "ID"), - @Result(property = "tenantId", column = "TENANT_ID"), - @Result(property = "created", column = "CREATED"), - @Result(property = "modified", column = "MODIFIED"), - @Result(property = "name", column = "NAME"), - @Result(property = "description", column = "DESCRIPTION"), - @Result(property = "owner", column = "OWNER"), - @Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select="findByDistributionTargets")) }) - public List findByDistributionTargets(@Param("id") String id); - - @Select("SELECT * FROM WORKBASKET ORDER BY id") - @Results(value = { - @Result(property = "id", column = "ID"), - @Result(property = "tenantId", column = "TENANT_ID"), - @Result(property = "created", column = "CREATED"), - @Result(property = "modified", column = "MODIFIED"), - @Result(property = "name", column = "NAME"), - @Result(property = "description", column = "DESCRIPTION"), - @Result(property = "owner", column = "OWNER"), - @Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select="findByDistributionTargets")) }) - public List findAll(); - - @Select("") - @Results(value = { - @Result(property = "id", column = "ID"), - @Result(property = "tenantId", column = "TENANT_ID"), - @Result(property = "created", column = "CREATED"), - @Result(property = "modified", column = "MODIFIED"), - @Result(property = "name", column = "NAME"), - @Result(property = "description", column = "DESCRIPTION"), - @Result(property = "owner", column = "OWNER"), - @Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select="findByDistributionTargets")) }) - public List findByPermission(@Param("authorizations") List authorizations, @Param("userId") String userId); + @Select("SELECT ID, TENANT_ID, CREATED, MODIFIED, NAME, DESCRIPTION, OWNER FROM WORKBASKET WHERE ID = #{id}") + @Results(value = { @Result(property = "id", column = "ID"), + @Result(property = "tenantId", column = "TENANT_ID"), + @Result(property = "created", column = "CREATED"), + @Result(property = "modified", column = "MODIFIED"), + @Result(property = "name", column = "NAME"), + @Result(property = "description", column = "DESCRIPTION"), + @Result(property = "owner", column = "OWNER"), + @Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")) }) + Workbasket findById(@Param("id") String id); - @Insert("INSERT INTO WORKBASKET (ID, TENANT_ID, CREATED, MODIFIED, NAME, DESCRIPTION, OWNER) VALUES (#{workbasket.id}, #{workbasket.tenantId}, #{workbasket.created}, #{workbasket.modified}, #{workbasket.name}, #{workbasket.description}, #{workbasket.owner})") - @Options(keyProperty = "id", keyColumn="ID") - public void insert(@Param("workbasket") Workbasket workbasket); + @Select("SELECT * FROM WORKBASKET WHERE id IN (SELECT TARGET_ID FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{id})") + @Results(value = { + @Result(property = "id", column = "ID"), + @Result(property = "tenantId", column = "TENANT_ID"), + @Result(property = "created", column = "CREATED"), + @Result(property = "modified", column = "MODIFIED"), + @Result(property = "name", column = "NAME"), + @Result(property = "description", column = "DESCRIPTION"), + @Result(property = "owner", column = "OWNER"), + @Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")) }) + List findByDistributionTargets(@Param("id") String id); - @Update("UPDATE WORKBASKET SET TENANT_ID = #{workbasket.tenantId}, MODIFIED = #{workbasket.modified}, NAME = #{workbasket.name}, DESCRIPTION = #{workbasket.description}, OWNER = #{workbasket.owner} WHERE id = #{workbasket.id}") - public void update(@Param("workbasket") Workbasket workbasket); + @Select("SELECT * FROM WORKBASKET ORDER BY id") + @Results(value = { + @Result(property = "id", column = "ID"), + @Result(property = "tenantId", column = "TENANT_ID"), + @Result(property = "created", column = "CREATED"), + @Result(property = "modified", column = "MODIFIED"), + @Result(property = "name", column = "NAME"), + @Result(property = "description", column = "DESCRIPTION"), + @Result(property = "owner", column = "OWNER"), + @Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")) }) + List findAll(); - @Delete("DELETE FROM WORKBASKET where id = #{id}") - public void delete(@Param("id") String id); + @Select("") + @Results(value = { + @Result(property = "id", column = "ID"), + @Result(property = "tenantId", column = "TENANT_ID"), + @Result(property = "created", column = "CREATED"), + @Result(property = "modified", column = "MODIFIED"), + @Result(property = "name", column = "NAME"), + @Result(property = "description", column = "DESCRIPTION"), + @Result(property = "owner", column = "OWNER"), + @Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")) }) + List findByPermission(@Param("authorizations") List authorizations, @Param("userId") String userId); + + @Insert("INSERT INTO WORKBASKET (ID, TENANT_ID, CREATED, MODIFIED, NAME, DESCRIPTION, OWNER) VALUES (#{workbasket.id}, #{workbasket.tenantId}, #{workbasket.created}, #{workbasket.modified}, #{workbasket.name}, #{workbasket.description}, #{workbasket.owner})") + @Options(keyProperty = "id", keyColumn = "ID") + void insert(@Param("workbasket") Workbasket workbasket); + + @Update("UPDATE WORKBASKET SET TENANT_ID = #{workbasket.tenantId}, MODIFIED = #{workbasket.modified}, NAME = #{workbasket.name}, DESCRIPTION = #{workbasket.description}, OWNER = #{workbasket.owner} WHERE id = #{workbasket.id}") + void update(@Param("workbasket") Workbasket workbasket); + + @Delete("DELETE FROM WORKBASKET where id = #{id}") + void delete(@Param("id") String id); } diff --git a/lib/taskana-core/src/main/java/org/taskana/security/CurrentUserContext.java b/lib/taskana-core/src/main/java/org/taskana/security/CurrentUserContext.java index 56a617e65..61d8c7c9f 100644 --- a/lib/taskana-core/src/main/java/org/taskana/security/CurrentUserContext.java +++ b/lib/taskana-core/src/main/java/org/taskana/security/CurrentUserContext.java @@ -13,95 +13,96 @@ import org.slf4j.LoggerFactory; /** * Provides the context information about the current (calling) user. The * context is gathered from the JAAS subject. - * * @author Holger Hagen - * */ -public class CurrentUserContext { +public final class CurrentUserContext { - private static final String GET_UNIQUE_SECURITY_NAME_METHOD = "getUniqueSecurityName"; - private static final String GET_CALLER_SUBJECT_METHOD = "getCallerSubject"; - private static final String WSSUBJECT_CLASSNAME = "com.ibm.websphere.security.auth.WSSubject"; + private static final String GET_UNIQUE_SECURITY_NAME_METHOD = "getUniqueSecurityName"; + private static final String GET_CALLER_SUBJECT_METHOD = "getCallerSubject"; + private static final String WSSUBJECT_CLASSNAME = "com.ibm.websphere.security.auth.WSSubject"; - private static final Logger logger = LoggerFactory.getLogger(CurrentUserContext.class); - - private static Boolean runningOnWebSphere = null; + private static final Logger LOGGER = LoggerFactory.getLogger(CurrentUserContext.class); - /** - * Returns the userid of the current user. - * - * @return String the userid. null if there is no JAAS subject. - */ - public static String getUserid() { - if (runningOnWebSphere()) { - return getUseridFromWSSubject(); - } else { - return getUseridFromJAASSubject(); - } - } + private static Boolean runningOnWebSphere = null; - /** - * Returns the unique security name of the first public credentials found in the WSSubject as userid. - * - * @return the userid of the caller. If the userid could not be obtained, null is returned. - */ - private static String getUseridFromWSSubject() { - try { - Class wsSubjectClass = Class.forName(WSSUBJECT_CLASSNAME); - Method getCallerSubjectMethod = wsSubjectClass.getMethod(GET_CALLER_SUBJECT_METHOD, (Class[]) null); - Subject callerSubject = (Subject) getCallerSubjectMethod.invoke(null, (Object[]) null); - logger.debug("Subject of caller: {}", callerSubject); - if (callerSubject != null) { - Set publicCredentials = callerSubject.getPublicCredentials(); - logger.debug("Public credentials of caller: {}", publicCredentials); - for (Object pC : publicCredentials) { - Object o = pC.getClass().getMethod(GET_UNIQUE_SECURITY_NAME_METHOD, (Class[]) null).invoke(pC, (Object[]) null); - logger.debug("Returning the unique security name of first public credential: {}", o); - return o.toString(); - } - } - } catch (Exception e) { - logger.warn("Could not get user from WSSubject. Going ahead unauthorized."); - } - return null; - } + private CurrentUserContext() { + } - /** - * Checks, whether Taskana is running on IBM WebSphere. - * - * @return true, if it is running on IBM WebSphere - */ - private static boolean runningOnWebSphere() { - if (runningOnWebSphere == null) { - try { - Class.forName(WSSUBJECT_CLASSNAME); - logger.debug("WSSubject detected. Assuming that Taskana runs on IBM WebSphere."); - runningOnWebSphere = new Boolean(true); - } catch (ClassNotFoundException e) { - logger.debug("No WSSubject detected. Using JAAS subject further on."); - runningOnWebSphere = new Boolean(false); - } - } - return runningOnWebSphere; - } + /** + * Returns the userid of the current user. + * @return String the userid. null if there is no JAAS subject. + */ + public static String getUserid() { + if (runningOnWebSphere()) { + return getUseridFromWSSubject(); + } else { + return getUseridFromJAASSubject(); + } + } - private static String getUseridFromJAASSubject() { - Subject subject = Subject.getSubject(AccessController.getContext()); - logger.debug("Subject of caller: {}", subject); - if (subject != null) { - Set publicCredentials = subject.getPublicCredentials(); - logger.debug("Public credentials of caller: {}", publicCredentials); - for (Object pC : publicCredentials) { - logger.debug("Returning the first public credential: {}", pC.toString()); - return pC.toString(); - } - } - logger.debug("No userid found in subject!"); - return null; - } + /** + * Returns the unique security name of the first public credentials found in the + * WSSubject as userid. + * @return the userid of the caller. If the userid could not be obtained, null + * is returned. + */ + private static String getUseridFromWSSubject() { + try { + Class wsSubjectClass = Class.forName(WSSUBJECT_CLASSNAME); + Method getCallerSubjectMethod = wsSubjectClass.getMethod(GET_CALLER_SUBJECT_METHOD, (Class[]) null); + Subject callerSubject = (Subject) getCallerSubjectMethod.invoke(null, (Object[]) null); + LOGGER.debug("Subject of caller: {}", callerSubject); + if (callerSubject != null) { + Set publicCredentials = callerSubject.getPublicCredentials(); + LOGGER.debug("Public credentials of caller: {}", publicCredentials); + for (Object pC : publicCredentials) { + Object o = pC.getClass().getMethod(GET_UNIQUE_SECURITY_NAME_METHOD, (Class[]) null).invoke(pC, + (Object[]) null); + LOGGER.debug("Returning the unique security name of first public credential: {}", o); + return o.toString(); + } + } + } catch (Exception e) { + LOGGER.warn("Could not get user from WSSubject. Going ahead unauthorized."); + } + return null; + } - public static List getGroupIds() { - return null; - } + /** + * Checks, whether Taskana is running on IBM WebSphere. + * @return true, if it is running on IBM WebSphere + */ + private static boolean runningOnWebSphere() { + if (runningOnWebSphere == null) { + try { + Class.forName(WSSUBJECT_CLASSNAME); + LOGGER.debug("WSSubject detected. Assuming that Taskana runs on IBM WebSphere."); + runningOnWebSphere = new Boolean(true); + } catch (ClassNotFoundException e) { + LOGGER.debug("No WSSubject detected. Using JAAS subject further on."); + runningOnWebSphere = new Boolean(false); + } + } + return runningOnWebSphere; + } + + private static String getUseridFromJAASSubject() { + Subject subject = Subject.getSubject(AccessController.getContext()); + LOGGER.debug("Subject of caller: {}", subject); + if (subject != null) { + Set publicCredentials = subject.getPublicCredentials(); + LOGGER.debug("Public credentials of caller: {}", publicCredentials); + for (Object pC : publicCredentials) { + LOGGER.debug("Returning the first public credential: {}", pC.toString()); + return pC.toString(); + } + } + LOGGER.debug("No userid found in subject!"); + return null; + } + + public static List getGroupIds() { + return null; + } } diff --git a/lib/taskana-core/src/test/java/org/taskana/impl/ClassificationServiceImplTest.java b/lib/taskana-core/src/test/java/org/taskana/impl/ClassificationServiceImplTest.java index 6ae05a47a..70b1436d2 100644 --- a/lib/taskana-core/src/test/java/org/taskana/impl/ClassificationServiceImplTest.java +++ b/lib/taskana-core/src/test/java/org/taskana/impl/ClassificationServiceImplTest.java @@ -16,82 +16,86 @@ import java.util.List; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.*; +/** + * Unit Test for ClassificationServiceImpl. + * @author EH + */ @RunWith(MockitoJUnitRunner.class) public class ClassificationServiceImplTest { - @InjectMocks + @InjectMocks ClassificationServiceImpl classificationService; - @Mock + @Mock ClassificationMapper classificationMapper; - @Test - public void testInsertClassification() { - doNothing().when(classificationMapper).insert(any()); + @Test + public void testInsertClassification() { + doNothing().when(classificationMapper).insert(any()); - Classification classification = new Classification(); - classification.setId("0"); - classificationService.insertClassification(classification); - - when(classificationMapper.findById(any())).thenReturn(classification); + Classification classification = new Classification(); + classification.setId("0"); + classificationService.insertClassification(classification); - Assert.assertNotNull(classificationService.selectClassificationById(classification.getId())); - } + when(classificationMapper.findById(any())).thenReturn(classification); - @Test - public void testFindAllClassifications() { - doNothing().when(classificationMapper).insert(any()); + Assert.assertNotNull(classificationService.selectClassificationById(classification.getId())); + } - Classification classification0 = new Classification(); - classification0.setId("0"); - classification0.setParentClassificationId(""); - classificationService.insertClassification(classification0); - Classification classification1 = new Classification(); - classification1.setId("1"); - classification1.setParentClassificationId(""); - classificationService.insertClassification(classification1); - - List classifications = new ArrayList<>(); - classifications.add(classification0); - when(classificationMapper.findByParentId("")).thenReturn(classifications); + @Test + public void testFindAllClassifications() { + doNothing().when(classificationMapper).insert(any()); - verify(classificationMapper, atLeast(2)).insert(any()); - Assert.assertEquals(1, classificationService.selectClassifications().size()); - } + Classification classification0 = new Classification(); + classification0.setId("0"); + classification0.setParentClassificationId(""); + classificationService.insertClassification(classification0); + Classification classification1 = new Classification(); + classification1.setId("1"); + classification1.setParentClassificationId(""); + classificationService.insertClassification(classification1); - @Test - public void testFindByParentClassification() { - doNothing().when(classificationMapper).insert(any()); + List classifications = new ArrayList<>(); + classifications.add(classification0); + when(classificationMapper.findByParentId("")).thenReturn(classifications); - Classification classification0 = new Classification(); - classification0.setId("0"); - classification0.setParentClassificationId("0"); - classificationService.insertClassification(classification0); - Classification classification1 = new Classification(); - classification1.setId("1"); - classification1.setParentClassificationId("0"); - classificationService.insertClassification(classification1); + verify(classificationMapper, atLeast(2)).insert(any()); + Assert.assertEquals(1, classificationService.selectClassifications().size()); + } - List classifications = new ArrayList<>(); - classifications.add(classification0); - classifications.add(classification1); - when(classificationMapper.findByParentId(any())).thenReturn(classifications); + @Test + public void testFindByParentClassification() { + doNothing().when(classificationMapper).insert(any()); - verify(classificationMapper, atLeast(2)).insert(any()); + Classification classification0 = new Classification(); + classification0.setId("0"); + classification0.setParentClassificationId("0"); + classificationService.insertClassification(classification0); + Classification classification1 = new Classification(); + classification1.setId("1"); + classification1.setParentClassificationId("0"); + classificationService.insertClassification(classification1); - Assert.assertEquals(2, classificationService.selectClassificationsByParentId("0").size()); - } + List classifications = new ArrayList<>(); + classifications.add(classification0); + classifications.add(classification1); + when(classificationMapper.findByParentId(any())).thenReturn(classifications); - @Test - public void testModifiedClassification() { - doNothing().when(classificationMapper).insert(any()); - doNothing().when(classificationMapper).update(any()); + verify(classificationMapper, atLeast(2)).insert(any()); - Classification classification = new Classification(); - classificationService.insertClassification(classification); - classification.setDescription("TEST EVERYTHING"); - classificationService.updateClassification(classification); + Assert.assertEquals(2, classificationService.selectClassificationsByParentId("0").size()); + } - Assert.assertEquals(classification.getModified().toString(), LocalDate.now().toString()); - } + @Test + public void testModifiedClassification() { + doNothing().when(classificationMapper).insert(any()); + doNothing().when(classificationMapper).update(any()); + + Classification classification = new Classification(); + classificationService.insertClassification(classification); + classification.setDescription("TEST EVERYTHING"); + classificationService.updateClassification(classification); + + Assert.assertEquals(classification.getModified().toString(), LocalDate.now().toString()); + } } diff --git a/lib/taskana-core/src/test/java/org/taskana/impl/TaskServiceImplTest.java b/lib/taskana-core/src/test/java/org/taskana/impl/TaskServiceImplTest.java index 858e97aa5..23ee0f42e 100644 --- a/lib/taskana-core/src/test/java/org/taskana/impl/TaskServiceImplTest.java +++ b/lib/taskana-core/src/test/java/org/taskana/impl/TaskServiceImplTest.java @@ -26,202 +26,208 @@ import org.taskana.model.Workbasket; import org.taskana.model.mappings.ObjectReferenceMapper; import org.taskana.model.mappings.TaskMapper; +/** + * Unit Test for TaskServiceImpl. + * @author EH + */ @RunWith(MockitoJUnitRunner.class) public class TaskServiceImplTest { - @InjectMocks - TaskServiceImpl taskServiceImpl; - @Mock - TaskanaEngine taskanaEngine; - @Mock - TaskanaEngineConfiguration taskanaEngineConfiguration; - @Mock - WorkbasketServiceImpl workbasketServiceImpl; - @Mock - TaskMapper taskMapper; - @Mock - ObjectReferenceMapper objectReferenceMapper; + private static final int LIST_SIZE = 3; + private static final int SLEEP_TIME = 100; + @InjectMocks + TaskServiceImpl taskServiceImpl; + @Mock + TaskanaEngine taskanaEngine; + @Mock + TaskanaEngineConfiguration taskanaEngineConfiguration; + @Mock + WorkbasketServiceImpl workbasketServiceImpl; + @Mock + TaskMapper taskMapper; + @Mock + ObjectReferenceMapper objectReferenceMapper; - @Test - public void testCreateSimpleTask() throws NotAuthorizedException { - registerBasicMocks(false); - Mockito.doNothing().when(workbasketServiceImpl).checkAuthorization(any(), any()); - Mockito.doNothing().when(taskMapper).insert(any()); + @Test + public void testCreateSimpleTask() throws NotAuthorizedException { + registerBasicMocks(false); + Mockito.doNothing().when(workbasketServiceImpl).checkAuthorization(any(), any()); + Mockito.doNothing().when(taskMapper).insert(any()); - Task task = new Task(); - task.setName("Unit Test Task"); - task.setWorkbasketId("1"); - task = taskServiceImpl.create(task); - Assert.assertNull(task.getOwner()); - Assert.assertNotNull(task.getCreated()); - Assert.assertNotNull(task.getModified()); - Assert.assertNull(task.getCompleted()); - Assert.assertEquals(task.getWorkbasketId(), "1"); - Assert.assertEquals(task.getState(), TaskState.READY); - } + Task task = new Task(); + task.setName("Unit Test Task"); + task.setWorkbasketId("1"); + task = taskServiceImpl.create(task); + Assert.assertNull(task.getOwner()); + Assert.assertNotNull(task.getCreated()); + Assert.assertNotNull(task.getModified()); + Assert.assertNull(task.getCompleted()); + Assert.assertEquals(task.getWorkbasketId(), "1"); + Assert.assertEquals(task.getState(), TaskState.READY); + } - @Test - public void testClaim() throws Exception { - Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); + @Test + public void testClaim() throws Exception { + Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); - Thread.sleep(100); // to have different timestamps - taskServiceImpl.claim(task.getId(), "John Does"); - task = taskServiceImpl.getTaskById(task.getId()); - Assert.assertEquals(task.getState(), TaskState.CLAIMED); - Assert.assertNotEquals(task.getCreated(), task.getModified()); - Assert.assertNotNull(task.getClaimed()); - Assert.assertEquals(task.getOwner(), "John Does"); - } + Thread.sleep(SLEEP_TIME); // to have different timestamps + taskServiceImpl.claim(task.getId(), "John Does"); + task = taskServiceImpl.getTaskById(task.getId()); + Assert.assertEquals(task.getState(), TaskState.CLAIMED); + Assert.assertNotEquals(task.getCreated(), task.getModified()); + Assert.assertNotNull(task.getClaimed()); + Assert.assertEquals(task.getOwner(), "John Does"); + } - @Test(expected = TaskNotFoundException.class) - public void testClaimFailsWithNonExistingTaskId() throws TaskNotFoundException { - taskServiceImpl.claim("test", "John Doe"); - } + @Test(expected = TaskNotFoundException.class) + public void testClaimFailsWithNonExistingTaskId() throws TaskNotFoundException { + taskServiceImpl.claim("test", "John Doe"); + } - @Test - public void testComplete() throws Exception { - Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); + @Test + public void testComplete() throws Exception { + Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); - Thread.sleep(100); // to have different timestamps - taskServiceImpl.complete(task.getId()); - task = taskServiceImpl.getTaskById(task.getId()); - Assert.assertEquals(task.getState(), TaskState.COMPLETED); - Assert.assertNotEquals(task.getCreated(), task.getModified()); - Assert.assertNotNull(task.getCompleted()); - } + Thread.sleep(SLEEP_TIME); // to have different timestamps + taskServiceImpl.complete(task.getId()); + task = taskServiceImpl.getTaskById(task.getId()); + Assert.assertEquals(task.getState(), TaskState.COMPLETED); + Assert.assertNotEquals(task.getCreated(), task.getModified()); + Assert.assertNotNull(task.getCompleted()); + } - @Test(expected = TaskNotFoundException.class) - public void testCompleteFailsWithNonExistingTaskId() throws TaskNotFoundException { - taskServiceImpl.complete("test"); - } + @Test(expected = TaskNotFoundException.class) + public void testCompleteFailsWithNonExistingTaskId() throws TaskNotFoundException { + taskServiceImpl.complete("test"); + } - @Test - public void testGetTasksForWorkbasket() throws NotAuthorizedException { - registerBasicMocks(false); - ArrayList tasks = new ArrayList(); - tasks.add(createUnitTestTask("1", "Unit Test Task 1", "1")); - tasks.add(createUnitTestTask("2", "Unit Test Task 2", "1")); - tasks.add(createUnitTestTask("3", "Unit Test Task 3", "1")); - Mockito.when(taskMapper.findByWorkBasketId("1")).thenReturn(tasks); + @Test + public void testGetTasksForWorkbasket() throws NotAuthorizedException { + registerBasicMocks(false); + ArrayList tasks = new ArrayList(); + tasks.add(createUnitTestTask("1", "Unit Test Task 1", "1")); + tasks.add(createUnitTestTask("2", "Unit Test Task 2", "1")); + tasks.add(createUnitTestTask("3", "Unit Test Task 3", "1")); + Mockito.when(taskMapper.findByWorkBasketId("1")).thenReturn(tasks); - List list = taskServiceImpl.getTasksForWorkbasket("1"); - Assert.assertEquals(list.size(), 3); - } + List list = taskServiceImpl.getTasksForWorkbasket("1"); + Assert.assertEquals(LIST_SIZE, list.size()); + } - @Test - public void testTransferTaskZuDestinationWorkbasket() - throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { - registerBasicMocks(false); - Workbasket workbasket2 = createWorkbasket2(); - Mockito.when(workbasketServiceImpl.getWorkbasket("2")).thenReturn(workbasket2); + @Test + public void testTransferTaskZuDestinationWorkbasket() + throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { + registerBasicMocks(false); + Workbasket workbasket2 = createWorkbasket2(); + Mockito.when(workbasketServiceImpl.getWorkbasket("2")).thenReturn(workbasket2); - Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); - task.setRead(true); + Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); + task.setRead(true); - Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "1"); - taskServiceImpl.transfer(task.getId(), "2"); - Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "2"); + Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "1"); + taskServiceImpl.transfer(task.getId(), "2"); + Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "2"); - Assert.assertTrue(task.isTransferred()); - Assert.assertFalse(task.isRead()); - } + Assert.assertTrue(task.isTransferred()); + Assert.assertFalse(task.isRead()); + } - @Test(expected = WorkbasketNotFoundException.class) - public void testTransferFailsIfDestinationWorkbasketDoesNotExist_withSecurityDisabled() - throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { - registerBasicMocks(false); - Mockito.doThrow(WorkbasketNotFoundException.class).when(workbasketServiceImpl) - .checkAuthorization(eq("invalidWorkbasketId"), any()); + @Test(expected = WorkbasketNotFoundException.class) + public void testTransferFailsIfDestinationWorkbasketDoesNotExist_withSecurityDisabled() + throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { + registerBasicMocks(false); + Mockito.doThrow(WorkbasketNotFoundException.class).when(workbasketServiceImpl) + .checkAuthorization(eq("invalidWorkbasketId"), any()); - Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); + Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); - Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "1"); - taskServiceImpl.transfer(task.getId(), "invalidWorkbasketId"); - } + Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "1"); + taskServiceImpl.transfer(task.getId(), "invalidWorkbasketId"); + } - @Test(expected = WorkbasketNotFoundException.class) - public void testTransferFailsIfDestinationWorkbasketDoesNotExist_withSecurityEnabled() - throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { - registerBasicMocks(true); - Mockito.doThrow(WorkbasketNotFoundException.class).when(workbasketServiceImpl) - .checkAuthorization(eq("invalidWorkbasketId"), any()); + @Test(expected = WorkbasketNotFoundException.class) + public void testTransferFailsIfDestinationWorkbasketDoesNotExist_withSecurityEnabled() + throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { + registerBasicMocks(true); + Mockito.doThrow(WorkbasketNotFoundException.class).when(workbasketServiceImpl) + .checkAuthorization(eq("invalidWorkbasketId"), any()); - Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); + Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); - Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "1"); - taskServiceImpl.transfer(task.getId(), "invalidWorkbasketId"); - } + Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "1"); + taskServiceImpl.transfer(task.getId(), "invalidWorkbasketId"); + } - @Test - public void should_setTheReadFlag_when_taskIsRead() throws TaskNotFoundException { - createUnitTestTask("1", "Unit Test Task 1", "1"); + @Test + public void should_setTheReadFlag_when_taskIsRead() throws TaskNotFoundException { + createUnitTestTask("1", "Unit Test Task 1", "1"); - Task readTask = taskServiceImpl.setTaskRead("1", true); - Assert.assertTrue(readTask.isRead()); - } + Task readTask = taskServiceImpl.setTaskRead("1", true); + Assert.assertTrue(readTask.isRead()); + } - @Test - public void should_InsertObjectReference_when_TaskIsCreated() throws NotAuthorizedException { - Mockito.when(taskanaEngine.getWorkbasketService()).thenReturn(workbasketServiceImpl); - Mockito.doNothing().when(workbasketServiceImpl).checkAuthorization(any(), any()); - Mockito.when(objectReferenceMapper.findByObjectReference(any())).thenReturn(null); + @Test + public void should_InsertObjectReference_when_TaskIsCreated() throws NotAuthorizedException { + Mockito.when(taskanaEngine.getWorkbasketService()).thenReturn(workbasketServiceImpl); + Mockito.doNothing().when(workbasketServiceImpl).checkAuthorization(any(), any()); + Mockito.when(objectReferenceMapper.findByObjectReference(any())).thenReturn(null); - Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); - ObjectReference primaryObjRef = new ObjectReference(); - primaryObjRef.setSystem("Sol"); - task.setPrimaryObjRef(primaryObjRef); - Task createdTask = taskServiceImpl.create(task); + Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); + ObjectReference primaryObjRef = new ObjectReference(); + primaryObjRef.setSystem("Sol"); + task.setPrimaryObjRef(primaryObjRef); + Task createdTask = taskServiceImpl.create(task); - Assert.assertNotNull(createdTask.getPrimaryObjRef()); - Assert.assertNotNull(createdTask.getPrimaryObjRef().getId()); - Assert.assertEquals("Sol", createdTask.getPrimaryObjRef().getSystem()); - } + Assert.assertNotNull(createdTask.getPrimaryObjRef()); + Assert.assertNotNull(createdTask.getPrimaryObjRef().getId()); + Assert.assertEquals("Sol", createdTask.getPrimaryObjRef().getSystem()); + } - @Test - public void should_LinkObjectReference_when_TaskIsCreated() throws NotAuthorizedException { - Mockito.when(taskanaEngine.getWorkbasketService()).thenReturn(workbasketServiceImpl); - Mockito.doNothing().when(workbasketServiceImpl).checkAuthorization(any(), any()); + @Test + public void should_LinkObjectReference_when_TaskIsCreated() throws NotAuthorizedException { + Mockito.when(taskanaEngine.getWorkbasketService()).thenReturn(workbasketServiceImpl); + Mockito.doNothing().when(workbasketServiceImpl).checkAuthorization(any(), any()); - Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); - ObjectReference primaryObjRef = new ObjectReference(); - primaryObjRef.setSystem("Sol"); - task.setPrimaryObjRef(primaryObjRef); - - ObjectReference returnPrimaryObjRef = new ObjectReference(); - returnPrimaryObjRef.setId("1"); - returnPrimaryObjRef.setSystem("Sol"); + Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); + ObjectReference primaryObjRef = new ObjectReference(); + primaryObjRef.setSystem("Sol"); + task.setPrimaryObjRef(primaryObjRef); - Mockito.when(objectReferenceMapper.findByObjectReference(any())).thenReturn(returnPrimaryObjRef); - Task createdTask = taskServiceImpl.create(task); + ObjectReference returnPrimaryObjRef = new ObjectReference(); + returnPrimaryObjRef.setId("1"); + returnPrimaryObjRef.setSystem("Sol"); - Assert.assertNotNull(createdTask.getPrimaryObjRef()); - Assert.assertEquals("1", createdTask.getPrimaryObjRef().getId()); - Assert.assertEquals("Sol", createdTask.getPrimaryObjRef().getSystem()); - } + Mockito.when(objectReferenceMapper.findByObjectReference(any())).thenReturn(returnPrimaryObjRef); + Task createdTask = taskServiceImpl.create(task); - private Task createUnitTestTask(String id, String name, String workbasketId) { - Task task = new Task(); - task.setId(id); - task.setName(name); - task.setWorkbasketId(workbasketId); - Timestamp now = new Timestamp(System.currentTimeMillis()); - task.setCreated(now); - task.setModified(now); - Mockito.when(taskMapper.findById(any())).thenReturn(task); - return task; - } + Assert.assertNotNull(createdTask.getPrimaryObjRef()); + Assert.assertEquals("1", createdTask.getPrimaryObjRef().getId()); + Assert.assertEquals("Sol", createdTask.getPrimaryObjRef().getSystem()); + } - private Workbasket createWorkbasket2() { - Workbasket workbasket2 = new Workbasket(); - workbasket2.setId("2"); - workbasket2.setName("Workbasket 2"); - return workbasket2; - } + private Task createUnitTestTask(String id, String name, String workbasketId) { + Task task = new Task(); + task.setId(id); + task.setName(name); + task.setWorkbasketId(workbasketId); + Timestamp now = new Timestamp(System.currentTimeMillis()); + task.setCreated(now); + task.setModified(now); + Mockito.when(taskMapper.findById(any())).thenReturn(task); + return task; + } - private void registerBasicMocks(boolean securityEnabled) { - Mockito.when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration); - Mockito.when(taskanaEngineConfiguration.isSecurityEnabled()).thenReturn(securityEnabled); - Mockito.when(taskanaEngine.getWorkbasketService()).thenReturn(workbasketServiceImpl); - } + private Workbasket createWorkbasket2() { + Workbasket workbasket2 = new Workbasket(); + workbasket2.setId("2"); + workbasket2.setName("Workbasket 2"); + return workbasket2; + } + + private void registerBasicMocks(boolean securityEnabled) { + Mockito.when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration); + Mockito.when(taskanaEngineConfiguration.isSecurityEnabled()).thenReturn(securityEnabled); + Mockito.when(taskanaEngine.getWorkbasketService()).thenReturn(workbasketServiceImpl); + } } diff --git a/lib/taskana-core/src/test/java/org/taskana/impl/WorkbasketServiceImplTest.java b/lib/taskana-core/src/test/java/org/taskana/impl/WorkbasketServiceImplTest.java index c7c0d2b2a..55c64fbf1 100644 --- a/lib/taskana-core/src/test/java/org/taskana/impl/WorkbasketServiceImplTest.java +++ b/lib/taskana-core/src/test/java/org/taskana/impl/WorkbasketServiceImplTest.java @@ -26,258 +26,267 @@ import org.taskana.model.mappings.DistributionTargetMapper; import org.taskana.model.mappings.WorkbasketAccessMapper; import org.taskana.model.mappings.WorkbasketMapper; +/** + * Unit Test for workbasketServiceImpl. + * @author EH + */ @RunWith(MockitoJUnitRunner.class) public class WorkbasketServiceImplTest { - @InjectMocks - WorkbasketServiceImpl workbasketServiceImpl; + private static final int THREE = 3; - @Mock - WorkbasketMapper workbasketMapper; - @Mock - DistributionTargetMapper distributionTargetMapper; - @Mock - WorkbasketAccessMapper workbasketAccessMapper; - @Mock - TaskanaEngine taskanaEngine; - @Mock - TaskanaEngineConfiguration taskanaEngineConfiguration; + private static final int SLEEP_TIME = 100; - @Test - public void should_ReturnWorkbasket_when_WorkbasketIdExists() throws WorkbasketNotFoundException { - when(workbasketMapper.findById(any())).thenReturn(new Workbasket()); + @InjectMocks + WorkbasketServiceImpl workbasketServiceImpl; - Workbasket workbasket = workbasketServiceImpl.getWorkbasket("fail"); + @Mock + WorkbasketMapper workbasketMapper; + @Mock + DistributionTargetMapper distributionTargetMapper; + @Mock + WorkbasketAccessMapper workbasketAccessMapper; + @Mock + TaskanaEngine taskanaEngine; + @Mock + TaskanaEngineConfiguration taskanaEngineConfiguration; - verify(workbasketMapper).findById(any()); - Assert.assertNotNull(workbasket); - } + @Test + public void should_ReturnWorkbasket_when_WorkbasketIdExists() throws WorkbasketNotFoundException { + when(workbasketMapper.findById(any())).thenReturn(new Workbasket()); - @Test(expected = WorkbasketNotFoundException.class) - public void should_ThrowWorkbasketNotFoundException_when_WorkbasketIdDoesNotExist() - throws WorkbasketNotFoundException { - workbasketServiceImpl.getWorkbasket("fail"); - } + Workbasket workbasket = workbasketServiceImpl.getWorkbasket("fail"); - @Test - public void should_ReturnListOfWorkbaskets_when_PermissionAndUserExists() { - when(workbasketMapper.findByPermission(any(), any())).thenReturn(new ArrayList()); + verify(workbasketMapper).findById(any()); + Assert.assertNotNull(workbasket); + } - List authorizations = new ArrayList<>(); - authorizations.add(WorkbasketAuthorization.OPEN); - authorizations.add(WorkbasketAuthorization.APPEND); - List workbaskets = workbasketServiceImpl.getWorkbaskets(authorizations); + @Test(expected = WorkbasketNotFoundException.class) + public void should_ThrowWorkbasketNotFoundException_when_WorkbasketIdDoesNotExist() + throws WorkbasketNotFoundException { + workbasketServiceImpl.getWorkbasket("fail"); + } - verify(workbasketMapper).findByPermission(any(), any()); - Assert.assertNotNull(workbaskets); - } + @Test + public void should_ReturnListOfWorkbaskets_when_PermissionAndUserExists() { + when(workbasketMapper.findByPermission(any(), any())).thenReturn(new ArrayList()); - @Test - public void should_ReturnAllWorkbaskets_when_AllWorkbaskets() { - when(workbasketMapper.findAll()).thenReturn(new ArrayList()); + List authorizations = new ArrayList<>(); + authorizations.add(WorkbasketAuthorization.OPEN); + authorizations.add(WorkbasketAuthorization.APPEND); + List workbaskets = workbasketServiceImpl.getWorkbaskets(authorizations); - List workbaskets = workbasketServiceImpl.getWorkbaskets(); + verify(workbasketMapper).findByPermission(any(), any()); + Assert.assertNotNull(workbaskets); + } - verify(workbasketMapper).findAll(); - Assert.assertNotNull(workbaskets); - } + @Test + public void should_ReturnAllWorkbaskets_when_AllWorkbaskets() { + when(workbasketMapper.findAll()).thenReturn(new ArrayList()); - @Test - public void should_InitializeAndStoreWorkbasket_when_WorkbasketIsCreated() throws NotAuthorizedException { - doNothing().when(workbasketMapper).insert(any()); - - Workbasket workbasket = new Workbasket(); - workbasket.setId("1"); - workbasketServiceImpl.createWorkbasket(workbasket); + List workbaskets = workbasketServiceImpl.getWorkbaskets(); - Assert.assertEquals("1", workbasket.getId()); - Assert.assertEquals(workbasket.getModified(), workbasket.getCreated()); + verify(workbasketMapper).findAll(); + Assert.assertNotNull(workbaskets); + } - verify(workbasketMapper).insert(any()); - } + @Test + public void should_InitializeAndStoreWorkbasket_when_WorkbasketIsCreated() throws NotAuthorizedException { + doNothing().when(workbasketMapper).insert(any()); - @SuppressWarnings("serial") - @Test - public void should_InitializeAndStoreWorkbasket_when_WorkbasketWithDistributionTargetsIsCreated() throws NotAuthorizedException { - doNothing().when(workbasketMapper).insert(any()); - doNothing().when(distributionTargetMapper).insert(any(), any()); + Workbasket workbasket = new Workbasket(); + workbasket.setId("1"); + workbasketServiceImpl.createWorkbasket(workbasket); - Workbasket workbasket = new Workbasket(); - workbasket.setId("1"); - Workbasket workbasket1 = new Workbasket(); - workbasket1.setId("2"); - Workbasket workbasket2 = new Workbasket(); - workbasket2.setId("3"); - workbasket.setDistributionTargets(new ArrayList() { - { - add(workbasket1); - add(workbasket2); - } - }); + Assert.assertEquals("1", workbasket.getId()); + Assert.assertEquals(workbasket.getModified(), workbasket.getCreated()); - workbasketServiceImpl.createWorkbasket(workbasket); + verify(workbasketMapper).insert(any()); + } - Assert.assertEquals("1", workbasket.getId()); - Assert.assertEquals(workbasket.getModified(), workbasket.getCreated()); + @SuppressWarnings("serial") + @Test + public void should_InitializeAndStoreWorkbasket_when_WorkbasketWithDistributionTargetsIsCreated() + throws NotAuthorizedException { + doNothing().when(workbasketMapper).insert(any()); + doNothing().when(distributionTargetMapper).insert(any(), any()); - verify(workbasketMapper, times(3)).insert(any()); - verify(distributionTargetMapper, times(2)).insert(any(), any()); - } + Workbasket workbasket = new Workbasket(); + workbasket.setId("1"); + Workbasket workbasket1 = new Workbasket(); + workbasket1.setId("2"); + Workbasket workbasket2 = new Workbasket(); + workbasket2.setId("3"); + workbasket.setDistributionTargets(new ArrayList() { + { + add(workbasket1); + add(workbasket2); + } + }); - @Test - public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDescriptionIsChanged() throws NotAuthorizedException { - doNothing().when(workbasketMapper).insert(any()); + workbasketServiceImpl.createWorkbasket(workbasket); - Workbasket workbasket = new Workbasket(); - workbasket.setId("0"); - workbasket.setDescription("TestDescription"); - workbasket.setName("Cool New WorkintheBasket"); - workbasket.setOwner("Arthur Dent"); - workbasketServiceImpl.createWorkbasket(workbasket); + Assert.assertEquals("1", workbasket.getId()); + Assert.assertEquals(workbasket.getModified(), workbasket.getCreated()); - doNothing().when(workbasketMapper).update(any()); - workbasket.setDescription("42"); - workbasketServiceImpl.updateWorkbasket(workbasket); + verify(workbasketMapper, times(THREE)).insert(any()); + verify(distributionTargetMapper, times(2)).insert(any(), any()); + } - verify(workbasketMapper).update(any()); - } + @Test + public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDescriptionIsChanged() + throws NotAuthorizedException { + doNothing().when(workbasketMapper).insert(any()); - @SuppressWarnings("serial") - @Test - public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDistributionTargetIsChanged() - throws NotAuthorizedException { - doNothing().when(workbasketMapper).insert(any()); + Workbasket workbasket = new Workbasket(); + workbasket.setId("0"); + workbasket.setDescription("TestDescription"); + workbasket.setName("Cool New WorkintheBasket"); + workbasket.setOwner("Arthur Dent"); + workbasketServiceImpl.createWorkbasket(workbasket); - Workbasket workbasket = new Workbasket(); - workbasket.setId("0"); - Workbasket workbasket1 = new Workbasket(); - workbasket1.setId("1"); - workbasket.setDistributionTargets(new ArrayList() { - { - add(workbasket1); - } - }); - workbasketServiceImpl.createWorkbasket(workbasket); + doNothing().when(workbasketMapper).update(any()); + workbasket.setDescription("42"); + workbasketServiceImpl.updateWorkbasket(workbasket); - doNothing().when(workbasketMapper).update(any()); - when(workbasketMapper.findById(any())).thenReturn(workbasket); - workbasket.getDistributionTargets().get(0).setDescription("Test123"); - Workbasket result = workbasketServiceImpl.updateWorkbasket(workbasket); + verify(workbasketMapper).update(any()); + } - verify(workbasketMapper).update(any()); - Assert.assertEquals("Test123", result.getDistributionTargets().get(0).getDescription()); - } + @SuppressWarnings("serial") + @Test + public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDistributionTargetIsChanged() + throws NotAuthorizedException { + doNothing().when(workbasketMapper).insert(any()); - @Test - public void should_UpdateModifiedTimestamp_when_ExistingWorkbasketDistributionTargetIsChanged() - throws Exception { - doNothing().when(workbasketMapper).insert(any()); + Workbasket workbasket = new Workbasket(); + workbasket.setId("0"); + Workbasket workbasket1 = new Workbasket(); + workbasket1.setId("1"); + workbasket.setDistributionTargets(new ArrayList() { + { + add(workbasket1); + } + }); + workbasketServiceImpl.createWorkbasket(workbasket); - Workbasket workbasket0 = new Workbasket(); - workbasket0.setId("0"); - Workbasket workbasket1 = new Workbasket(); - workbasket1.setId("1"); - Workbasket workbasket2 = new Workbasket(); - workbasket2.setId("2"); - workbasket2.getDistributionTargets().add(workbasket0); - workbasket2.getDistributionTargets().add(workbasket1); - workbasketServiceImpl.createWorkbasket(workbasket2); + doNothing().when(workbasketMapper).update(any()); + when(workbasketMapper.findById(any())).thenReturn(workbasket); + workbasket.getDistributionTargets().get(0).setDescription("Test123"); + Workbasket result = workbasketServiceImpl.updateWorkbasket(workbasket); - Workbasket workbasket3 = new Workbasket(); - workbasket3.setId("3"); - workbasket2.getDistributionTargets().clear(); - workbasket2.getDistributionTargets().add(workbasket3); - Thread.sleep(100); + verify(workbasketMapper).update(any()); + Assert.assertEquals("Test123", result.getDistributionTargets().get(0).getDescription()); + } - doNothing().when(workbasketMapper).update(any()); - workbasketServiceImpl.updateWorkbasket(workbasket2); + @Test + public void should_UpdateModifiedTimestamp_when_ExistingWorkbasketDistributionTargetIsChanged() throws Exception { + doNothing().when(workbasketMapper).insert(any()); - when(workbasketMapper.findById("2")).thenReturn(workbasket2); - Workbasket foundBasket = workbasketServiceImpl.getWorkbasket(workbasket2.getId()); + Workbasket workbasket0 = new Workbasket(); + workbasket0.setId("0"); + Workbasket workbasket1 = new Workbasket(); + workbasket1.setId("1"); + Workbasket workbasket2 = new Workbasket(); + workbasket2.setId("2"); + workbasket2.getDistributionTargets().add(workbasket0); + workbasket2.getDistributionTargets().add(workbasket1); + workbasketServiceImpl.createWorkbasket(workbasket2); - when(workbasketMapper.findById("1")).thenReturn(workbasket1); - when(workbasketMapper.findById("3")).thenReturn(workbasket1); + Workbasket workbasket3 = new Workbasket(); + workbasket3.setId("3"); + workbasket2.getDistributionTargets().clear(); + workbasket2.getDistributionTargets().add(workbasket3); + Thread.sleep(SLEEP_TIME); - List distributionTargets = foundBasket.getDistributionTargets(); - Assert.assertEquals(1, distributionTargets.size()); - Assert.assertEquals("3", distributionTargets.get(0).getId()); + doNothing().when(workbasketMapper).update(any()); + workbasketServiceImpl.updateWorkbasket(workbasket2); - Assert.assertNotEquals(workbasketServiceImpl.getWorkbasket("2").getCreated(), - workbasketServiceImpl.getWorkbasket("2").getModified()); - Assert.assertEquals(workbasketServiceImpl.getWorkbasket("1").getCreated(), - workbasketServiceImpl.getWorkbasket("1").getModified()); - Assert.assertEquals(workbasketServiceImpl.getWorkbasket("3").getCreated(), - workbasketServiceImpl.getWorkbasket("3").getModified()); - } + when(workbasketMapper.findById("2")).thenReturn(workbasket2); + Workbasket foundBasket = workbasketServiceImpl.getWorkbasket(workbasket2.getId()); - @Test - public void should_ReturnWorkbasketAuthorization_when_NewWorkbasketAccessItemIsCreated() - throws NotAuthorizedException { - doNothing().when(workbasketAccessMapper).insert(any()); + when(workbasketMapper.findById("1")).thenReturn(workbasket1); + when(workbasketMapper.findById("3")).thenReturn(workbasket1); - WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); - accessItem.setWorkbasketId("1"); - accessItem.setUserId("Arthur Dent"); - accessItem.setOpen(true); - accessItem.setRead(true); - accessItem = workbasketServiceImpl.createWorkbasketAuthorization(accessItem); + List distributionTargets = foundBasket.getDistributionTargets(); + Assert.assertEquals(1, distributionTargets.size()); + Assert.assertEquals("3", distributionTargets.get(0).getId()); - Assert.assertNotNull(accessItem.getId()); - } + Assert.assertNotEquals(workbasketServiceImpl.getWorkbasket("2").getCreated(), + workbasketServiceImpl.getWorkbasket("2").getModified()); + Assert.assertEquals(workbasketServiceImpl.getWorkbasket("1").getCreated(), + workbasketServiceImpl.getWorkbasket("1").getModified()); + Assert.assertEquals(workbasketServiceImpl.getWorkbasket("3").getCreated(), + workbasketServiceImpl.getWorkbasket("3").getModified()); + } - @Test - public void should_ReturnWorkbasketAuthorization_when_WorkbasketAccessItemIsUpdated() - throws NotAuthorizedException { - doNothing().when(workbasketAccessMapper).insert(any()); + @Test + public void should_ReturnWorkbasketAuthorization_when_NewWorkbasketAccessItemIsCreated() + throws NotAuthorizedException { + doNothing().when(workbasketAccessMapper).insert(any()); - WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); - accessItem.setWorkbasketId("1"); - accessItem.setUserId("Arthur Dent"); - accessItem.setOpen(true); - accessItem.setRead(true); - accessItem = workbasketServiceImpl.createWorkbasketAuthorization(accessItem); + WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); + accessItem.setWorkbasketId("1"); + accessItem.setUserId("Arthur Dent"); + accessItem.setOpen(true); + accessItem.setRead(true); + accessItem = workbasketServiceImpl.createWorkbasketAuthorization(accessItem); - Assert.assertNotNull(accessItem.getId()); + Assert.assertNotNull(accessItem.getId()); + } - doNothing().when(workbasketAccessMapper).update(any()); - accessItem.setUserId("Zaphod Beeblebrox"); - workbasketServiceImpl.updateWorkbasketAuthorization(accessItem); + @Test + public void should_ReturnWorkbasketAuthorization_when_WorkbasketAccessItemIsUpdated() + throws NotAuthorizedException { + doNothing().when(workbasketAccessMapper).insert(any()); - Assert.assertEquals("Zaphod Beeblebrox", accessItem.getUserId()); - } + WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); + accessItem.setWorkbasketId("1"); + accessItem.setUserId("Arthur Dent"); + accessItem.setOpen(true); + accessItem.setRead(true); + accessItem = workbasketServiceImpl.createWorkbasketAuthorization(accessItem); - @Test(expected = NotAuthorizedException.class) - public void should_ThrowNotAuthorizedException_when_OperationIsNotAuthorized() throws NotAuthorizedException { - when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration); - when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(true); + Assert.assertNotNull(accessItem.getId()); - workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ); - } + doNothing().when(workbasketAccessMapper).update(any()); + accessItem.setUserId("Zaphod Beeblebrox"); + workbasketServiceImpl.updateWorkbasketAuthorization(accessItem); - @SuppressWarnings("serial") - @Test - public void should_Pass_when_OperationIsAuthorized() throws NotAuthorizedException { - when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration); - when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(true); + Assert.assertEquals("Zaphod Beeblebrox", accessItem.getUserId()); + } - when(workbasketAccessMapper.findByWorkbasketAndUserAndAuthorization(any(), any(), any())) - .thenReturn(new ArrayList() { - { - add(new WorkbasketAccessItem()); - } - }); + @Test(expected = NotAuthorizedException.class) + public void should_ThrowNotAuthorizedException_when_OperationIsNotAuthorized() throws NotAuthorizedException { + when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration); + when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(true); - workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ); - - verify(workbasketAccessMapper, times(1)).findByWorkbasketAndUserAndAuthorization(any(), any(), any()); - } + workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ); + } - @Test - public void should_Pass_when_SecurityIsDisabled() throws NotAuthorizedException { - when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration); - when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(false); + @SuppressWarnings("serial") + @Test + public void should_Pass_when_OperationIsAuthorized() throws NotAuthorizedException { + when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration); + when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(true); - workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ); - } + when(workbasketAccessMapper.findByWorkbasketAndUserAndAuthorization(any(), any(), any())) + .thenReturn(new ArrayList() { + { + add(new WorkbasketAccessItem()); + } + }); + + workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ); + + verify(workbasketAccessMapper, times(1)).findByWorkbasketAndUserAndAuthorization(any(), any(), any()); + } + + @Test + public void should_Pass_when_SecurityIsDisabled() throws NotAuthorizedException { + when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration); + when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(false); + + workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ); + } } diff --git a/lib/taskana-core/src/test/java/org/taskana/impl/configuration/TaskanaEngineConfigurationTest.java b/lib/taskana-core/src/test/java/org/taskana/impl/configuration/TaskanaEngineConfigurationTest.java index def44e0ed..89a39e12e 100644 --- a/lib/taskana-core/src/test/java/org/taskana/impl/configuration/TaskanaEngineConfigurationTest.java +++ b/lib/taskana-core/src/test/java/org/taskana/impl/configuration/TaskanaEngineConfigurationTest.java @@ -10,7 +10,10 @@ import org.junit.Assert; import org.junit.Test; import org.taskana.TaskanaEngine; import org.taskana.configuration.TaskanaEngineConfiguration; - +/** + * Integration Test for TaskanaEngineConfiguration. + * @author EH + */ public class TaskanaEngineConfigurationTest { @Test diff --git a/lib/taskana-core/src/test/java/org/taskana/impl/integration/ClassificationServiceImplIntTest.java b/lib/taskana-core/src/test/java/org/taskana/impl/integration/ClassificationServiceImplIntTest.java index b229d99c4..c7eef72b2 100644 --- a/lib/taskana-core/src/test/java/org/taskana/impl/integration/ClassificationServiceImplIntTest.java +++ b/lib/taskana-core/src/test/java/org/taskana/impl/integration/ClassificationServiceImplIntTest.java @@ -14,66 +14,70 @@ import java.io.FileNotFoundException; import java.sql.SQLException; import java.time.LocalDate; +/** + * Integration Test for ClassificationServiceImpl. + * @author EH + */ public class ClassificationServiceImplIntTest { - static int counter = 0; - private ClassificationService classificationService; + static int counter = 0; + private ClassificationService classificationService; - @Before - public void setup() throws FileNotFoundException, SQLException, LoginException { - JdbcDataSource ds = new JdbcDataSource(); - ds.setURL("jdbc:h2:mem:test-db-classification" + counter++); - ds.setPassword("sa"); - ds.setUser("sa"); - TaskanaEngineConfiguration taskEngineConfiguration = new TaskanaEngineConfiguration(ds, false); + @Before + public void setup() throws FileNotFoundException, SQLException, LoginException { + JdbcDataSource ds = new JdbcDataSource(); + ds.setURL("jdbc:h2:mem:test-db-classification" + counter++); + ds.setPassword("sa"); + ds.setUser("sa"); + TaskanaEngineConfiguration taskEngineConfiguration = new TaskanaEngineConfiguration(ds, false); - TaskanaEngine te = taskEngineConfiguration.buildTaskanaEngine(); - classificationService = te.getClassificationService(); - } + TaskanaEngine te = taskEngineConfiguration.buildTaskanaEngine(); + classificationService = te.getClassificationService(); + } - @Test - public void testInsertClassification() { - Classification classification = new Classification(); - classification.setId("0"); - classificationService.insertClassification(classification); + @Test + public void testInsertClassification() { + Classification classification = new Classification(); + classification.setId("0"); + classificationService.insertClassification(classification); - Assert.assertNotNull(classificationService.selectClassificationById(classification.getId())); - } + Assert.assertNotNull(classificationService.selectClassificationById(classification.getId())); + } - @Test - public void testFindAllClassifications() { - Classification classification0 = new Classification(); - classification0.setId("0"); - classification0.setParentClassificationId(""); - classificationService.insertClassification(classification0); - Classification classification1 = new Classification(); - classification1.setId("1"); - classification1.setParentClassificationId(""); - classificationService.insertClassification(classification1); + @Test + public void testFindAllClassifications() { + Classification classification0 = new Classification(); + classification0.setId("0"); + classification0.setParentClassificationId(""); + classificationService.insertClassification(classification0); + Classification classification1 = new Classification(); + classification1.setId("1"); + classification1.setParentClassificationId(""); + classificationService.insertClassification(classification1); - Assert.assertEquals(2, classificationService.selectClassifications().size()); - } + Assert.assertEquals(2, classificationService.selectClassifications().size()); + } - @Test - public void testFindByParentClassification() { - Classification classification0 = new Classification(); - classification0.setId("0"); - classification0.setParentClassificationId("0"); - classificationService.insertClassification(classification0); - Classification classification1 = new Classification(); - classification1.setId("1"); - classification1.setParentClassificationId("0"); - classificationService.insertClassification(classification1); + @Test + public void testFindByParentClassification() { + Classification classification0 = new Classification(); + classification0.setId("0"); + classification0.setParentClassificationId("0"); + classificationService.insertClassification(classification0); + Classification classification1 = new Classification(); + classification1.setId("1"); + classification1.setParentClassificationId("0"); + classificationService.insertClassification(classification1); - Assert.assertEquals(2, classificationService.selectClassificationsByParentId("0").size()); - } + Assert.assertEquals(2, classificationService.selectClassificationsByParentId("0").size()); + } - @Test - public void testModifiedClassification() { - Classification classification = new Classification(); - classificationService.insertClassification(classification); - classification.setDescription("TEST EVERYTHING"); - classificationService.updateClassification(classification); + @Test + public void testModifiedClassification() { + Classification classification = new Classification(); + classificationService.insertClassification(classification); + classification.setDescription("TEST EVERYTHING"); + classificationService.updateClassification(classification); - Assert.assertEquals(classification.getModified().toString(), LocalDate.now().toString()); - } + Assert.assertEquals(classification.getModified().toString(), LocalDate.now().toString()); + } } diff --git a/lib/taskana-core/src/test/java/org/taskana/impl/integration/TaskServiceImplTransactionTest.java b/lib/taskana-core/src/test/java/org/taskana/impl/integration/TaskServiceImplTransactionTest.java index aa1108e4b..6311b6122 100644 --- a/lib/taskana-core/src/test/java/org/taskana/impl/integration/TaskServiceImplTransactionTest.java +++ b/lib/taskana-core/src/test/java/org/taskana/impl/integration/TaskServiceImplTransactionTest.java @@ -14,69 +14,73 @@ import org.taskana.model.Task; import java.io.FileNotFoundException; import java.sql.SQLException; +/** + * Integration Test for TaskServiceImpl transactions. + * @author EH + */ public class TaskServiceImplTransactionTest { - @Test - public void testStart() throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException { - JdbcDataSource ds = new JdbcDataSource(); - ds.setURL("jdbc:h2:~/data/test-db-taskservice-int1"); - ds.setPassword("sa"); - ds.setUser("sa"); - TaskanaEngineConfiguration taskanaEngineConfiguration = new TaskanaEngineConfiguration(ds, true, false); + @Test + public void testStart() throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException { + JdbcDataSource ds = new JdbcDataSource(); + ds.setURL("jdbc:h2:~/data/test-db-taskservice-int1"); + ds.setPassword("sa"); + ds.setUser("sa"); + TaskanaEngineConfiguration taskanaEngineConfiguration = new TaskanaEngineConfiguration(ds, true, false); - TaskanaEngineImpl te = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine(); - TaskServiceImpl taskServiceImpl = (TaskServiceImpl) te.getTaskService(); + TaskanaEngineImpl te = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine(); + TaskServiceImpl taskServiceImpl = (TaskServiceImpl) te.getTaskService(); - Task task = new Task(); - task.setName("Unit Test Task"); - task.setWorkbasketId("1"); - task = taskServiceImpl.create(task); - te.closeSession(); + Task task = new Task(); + task.setName("Unit Test Task"); + task.setWorkbasketId("1"); + task = taskServiceImpl.create(task); + te.closeSession(); - TaskanaEngine te2 = taskanaEngineConfiguration.buildTaskanaEngine(); - TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService(); - Task resultTask = taskServiceImpl2.getTaskById(task.getId()); + TaskanaEngine te2 = taskanaEngineConfiguration.buildTaskanaEngine(); + TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService(); + Task resultTask = taskServiceImpl2.getTaskById(task.getId()); - Assert.assertNotNull(resultTask); - } + Assert.assertNotNull(resultTask); + } - @Test(expected = TaskNotFoundException.class) - public void testStartTransactionFail() - throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException { - JdbcDataSource ds = new JdbcDataSource(); - ds.setURL("jdbc:h2:~/data/test-db-taskservice-trans2"); - ds.setPassword("sa"); - ds.setUser("sa"); - TaskanaEngineConfiguration taskanaEngineConfiguration = new TaskanaEngineConfiguration(ds, false, false); + @Test(expected = TaskNotFoundException.class) + public void testStartTransactionFail() + throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException { + JdbcDataSource ds = new JdbcDataSource(); + ds.setURL("jdbc:h2:~/data/test-db-taskservice-trans2"); + ds.setPassword("sa"); + ds.setUser("sa"); + TaskanaEngineConfiguration taskanaEngineConfiguration = new TaskanaEngineConfiguration(ds, false, false); - TaskanaEngineImpl te = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine(); - TaskServiceImpl taskServiceImpl = (TaskServiceImpl) te.getTaskService(); + TaskanaEngineImpl te = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine(); + TaskServiceImpl taskServiceImpl = (TaskServiceImpl) te.getTaskService(); - Task task = new Task(); - task.setName("Unit Test Task"); - task.setWorkbasketId("1"); - task = taskServiceImpl.create(task); - taskServiceImpl.getTaskById("1"); - te.closeSession(); + Task task = new Task(); + task.setName("Unit Test Task"); + task.setWorkbasketId("1"); + task = taskServiceImpl.create(task); + taskServiceImpl.getTaskById("1"); + te.closeSession(); - TaskanaEngineImpl te2 = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine(); - TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService(); - taskServiceImpl2.getTaskById("1"); - } + TaskanaEngineImpl te2 = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine(); + TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService(); + taskServiceImpl2.getTaskById("1"); + } - @Test - public void testCreateTaskInTaskanaWithDefaultDb() - throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException { - TaskanaEngineConfiguration taskanaEngineConfiguration = new TaskanaEngineConfiguration(null, false, false); - TaskanaEngine te = taskanaEngineConfiguration.buildTaskanaEngine(); - TaskServiceImpl taskServiceImpl = (TaskServiceImpl) te.getTaskService(); + @Test + public void testCreateTaskInTaskanaWithDefaultDb() + throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException { + TaskanaEngineConfiguration taskanaEngineConfiguration = new TaskanaEngineConfiguration(null, false, false); + TaskanaEngine te = taskanaEngineConfiguration.buildTaskanaEngine(); + TaskServiceImpl taskServiceImpl = (TaskServiceImpl) te.getTaskService(); - Task task = new Task(); - task.setName("Unit Test Task"); - task.setWorkbasketId("1"); - task = taskServiceImpl.create(task); + Task task = new Task(); + task.setName("Unit Test Task"); + task.setWorkbasketId("1"); + task = taskServiceImpl.create(task); - Assert.assertNotNull(task); - Assert.assertNotNull(task.getId()); - } + Assert.assertNotNull(task); + Assert.assertNotNull(task.getId()); + } } diff --git a/lib/taskana-core/src/test/java/org/taskana/impl/integration/WorkbasketServiceImplIntTest.java b/lib/taskana-core/src/test/java/org/taskana/impl/integration/WorkbasketServiceImplIntTest.java index a63f7e3c4..3012dc41b 100644 --- a/lib/taskana-core/src/test/java/org/taskana/impl/integration/WorkbasketServiceImplIntTest.java +++ b/lib/taskana-core/src/test/java/org/taskana/impl/integration/WorkbasketServiceImplIntTest.java @@ -19,157 +19,166 @@ import org.taskana.exceptions.WorkbasketNotFoundException; import org.taskana.model.Workbasket; import org.taskana.model.WorkbasketAccessItem; + +/** + * Integration Test for workbasketServiceImpl. + * @author EH + */ public class WorkbasketServiceImplIntTest { - WorkbasketService workbasketServiceImpl; - static int counter = 0; + private static final int SLEEP_TIME = 100; + private static final int THREE = 3; - @Before - public void setup() throws FileNotFoundException, SQLException, LoginException { - JdbcDataSource ds = new JdbcDataSource(); - ds.setURL("jdbc:h2:mem:test-db-workbasket" + counter++); - ds.setPassword("sa"); - ds.setUser("sa"); - TaskanaEngineConfiguration taskEngineConfiguration = new TaskanaEngineConfiguration(ds, false); + WorkbasketService workbasketServiceImpl; + static int counter = 0; - TaskanaEngine te = taskEngineConfiguration.buildTaskanaEngine(); - workbasketServiceImpl = te.getWorkbasketService(); - } + @Before + public void setup() throws FileNotFoundException, SQLException, LoginException { + JdbcDataSource ds = new JdbcDataSource(); + ds.setURL("jdbc:h2:mem:test-db-workbasket" + counter++); + ds.setPassword("sa"); + ds.setUser("sa"); + TaskanaEngineConfiguration taskEngineConfiguration = new TaskanaEngineConfiguration(ds, false); - @Test - public void testInsertWorkbasket() throws NotAuthorizedException { - int before = workbasketServiceImpl.getWorkbaskets().size(); - Workbasket workbasket = new Workbasket(); - workbasket.setId("1"); - workbasket.setName("Megabasket"); - workbasketServiceImpl.createWorkbasket(workbasket); - Assert.assertEquals(before + 1, workbasketServiceImpl.getWorkbaskets().size()); - } + TaskanaEngine te = taskEngineConfiguration.buildTaskanaEngine(); + workbasketServiceImpl = te.getWorkbasketService(); + } - @Test - public void testSelectAllWorkbaskets() throws NotAuthorizedException { - int before = workbasketServiceImpl.getWorkbaskets().size(); - Workbasket workbasket0 = new Workbasket(); - workbasket0.setId("0"); - workbasket0.setName("Superbasket"); - workbasketServiceImpl.createWorkbasket(workbasket0); - Workbasket workbasket1 = new Workbasket(); - workbasket1.setId("1"); - workbasket1.setName("Megabasket"); - workbasketServiceImpl.createWorkbasket(workbasket1); - Workbasket workbasket2 = new Workbasket(); - workbasket2.setId("2"); - workbasket2.setName("Hyperbasket"); - workbasketServiceImpl.createWorkbasket(workbasket2); - Assert.assertEquals(before + 3, workbasketServiceImpl.getWorkbaskets().size()); - } + @Test + public void testInsertWorkbasket() throws NotAuthorizedException { + int before = workbasketServiceImpl.getWorkbaskets().size(); + Workbasket workbasket = new Workbasket(); + workbasket.setId("1"); + workbasket.setName("Megabasket"); + workbasketServiceImpl.createWorkbasket(workbasket); + Assert.assertEquals(before + 1, workbasketServiceImpl.getWorkbaskets().size()); + } - @Test - public void testSelectWorkbasket() throws WorkbasketNotFoundException, NotAuthorizedException { - Workbasket workbasket0 = new Workbasket(); - workbasket0.setId("0"); - workbasket0.setName("Superbasket"); - workbasketServiceImpl.createWorkbasket(workbasket0); - Workbasket workbasket1 = new Workbasket(); - workbasket1.setId("1"); - workbasket1.setName("Megabasket"); - workbasketServiceImpl.createWorkbasket(workbasket1); - Workbasket workbasket2 = new Workbasket(); - workbasket2.setId("2"); - workbasket2.setName("Hyperbasket"); - workbasketServiceImpl.createWorkbasket(workbasket2); - Workbasket foundWorkbasket = workbasketServiceImpl.getWorkbasket("2"); - Assert.assertEquals("2", foundWorkbasket.getId()); - } + @Test + public void testSelectAllWorkbaskets() throws NotAuthorizedException { + int before = workbasketServiceImpl.getWorkbaskets().size(); + Workbasket workbasket0 = new Workbasket(); + workbasket0.setId("0"); + workbasket0.setName("Superbasket"); + workbasketServiceImpl.createWorkbasket(workbasket0); + Workbasket workbasket1 = new Workbasket(); + workbasket1.setId("1"); + workbasket1.setName("Megabasket"); + workbasketServiceImpl.createWorkbasket(workbasket1); + Workbasket workbasket2 = new Workbasket(); + workbasket2.setId("2"); + workbasket2.setName("Hyperbasket"); + workbasketServiceImpl.createWorkbasket(workbasket2); + Assert.assertEquals(before + THREE, workbasketServiceImpl.getWorkbaskets().size()); + } - @Test(expected = WorkbasketNotFoundException.class) - public void testGetWorkbasketFail() throws WorkbasketNotFoundException { - workbasketServiceImpl.getWorkbasket("fail"); - } + @Test + public void testSelectWorkbasket() throws WorkbasketNotFoundException, NotAuthorizedException { + Workbasket workbasket0 = new Workbasket(); + workbasket0.setId("0"); + workbasket0.setName("Superbasket"); + workbasketServiceImpl.createWorkbasket(workbasket0); + Workbasket workbasket1 = new Workbasket(); + workbasket1.setId("1"); + workbasket1.setName("Megabasket"); + workbasketServiceImpl.createWorkbasket(workbasket1); + Workbasket workbasket2 = new Workbasket(); + workbasket2.setId("2"); + workbasket2.setName("Hyperbasket"); + workbasketServiceImpl.createWorkbasket(workbasket2); + Workbasket foundWorkbasket = workbasketServiceImpl.getWorkbasket("2"); + Assert.assertEquals("2", foundWorkbasket.getId()); + } - @Test - public void testSelectWorkbasketWithDistribution() throws WorkbasketNotFoundException, NotAuthorizedException { - Workbasket workbasket0 = new Workbasket(); - workbasket0.setId("0"); - workbasket0.setName("Superbasket"); - Workbasket workbasket1 = new Workbasket(); - workbasket1.setId("1"); - workbasket1.setName("Megabasket"); - Workbasket workbasket2 = new Workbasket(); - workbasket2.setId("2"); - workbasket2.setName("Hyperbasket"); - workbasket2.setDistributionTargets(new ArrayList<>()); - workbasket2.getDistributionTargets().add(workbasket0); - workbasket2.getDistributionTargets().add(workbasket1); - workbasketServiceImpl.createWorkbasket(workbasket2); - Workbasket foundWorkbasket = workbasketServiceImpl.getWorkbasket("2"); - Assert.assertEquals("2", foundWorkbasket.getId()); - Assert.assertEquals(2, foundWorkbasket.getDistributionTargets().size()); - } + @Test(expected = WorkbasketNotFoundException.class) + public void testGetWorkbasketFail() throws WorkbasketNotFoundException { + workbasketServiceImpl.getWorkbasket("fail"); + } - @Test - public void testUpdateWorkbasket() throws Exception { - Workbasket workbasket0 = new Workbasket(); - workbasket0.setId("0"); - workbasket0.setName("Superbasket"); - Workbasket workbasket1 = new Workbasket(); - workbasket1.setId("1"); - workbasket1.setName("Megabasket"); - Workbasket workbasket2 = new Workbasket(); - workbasket2.setId("2"); - workbasket2.setName("Hyperbasket"); - workbasket2.getDistributionTargets().add(workbasket0); - workbasket2.getDistributionTargets().add(workbasket1); - workbasketServiceImpl.createWorkbasket(workbasket2); + @Test + public void testSelectWorkbasketWithDistribution() throws WorkbasketNotFoundException, NotAuthorizedException { + Workbasket workbasket0 = new Workbasket(); + workbasket0.setId("0"); + workbasket0.setName("Superbasket"); + Workbasket workbasket1 = new Workbasket(); + workbasket1.setId("1"); + workbasket1.setName("Megabasket"); + Workbasket workbasket2 = new Workbasket(); + workbasket2.setId("2"); + workbasket2.setName("Hyperbasket"); + workbasket2.setDistributionTargets(new ArrayList<>()); + workbasket2.getDistributionTargets().add(workbasket0); + workbasket2.getDistributionTargets().add(workbasket1); + workbasketServiceImpl.createWorkbasket(workbasket2); + Workbasket foundWorkbasket = workbasketServiceImpl.getWorkbasket("2"); + Assert.assertEquals("2", foundWorkbasket.getId()); + Assert.assertEquals(2, foundWorkbasket.getDistributionTargets().size()); + } - Workbasket workbasket3 = new Workbasket(); - workbasket3.setId("3"); - workbasket3.setName("hm ... irgend ein basket"); - workbasket2.getDistributionTargets().clear(); - workbasket2.getDistributionTargets().add(workbasket3); - Thread.sleep(100); - workbasketServiceImpl.updateWorkbasket(workbasket2); + @Test + public void testUpdateWorkbasket() throws Exception { + Workbasket workbasket0 = new Workbasket(); + workbasket0.setId("0"); + workbasket0.setName("Superbasket"); + Workbasket workbasket1 = new Workbasket(); + workbasket1.setId("1"); + workbasket1.setName("Megabasket"); + Workbasket workbasket2 = new Workbasket(); + workbasket2.setId("2"); + workbasket2.setName("Hyperbasket"); + workbasket2.getDistributionTargets().add(workbasket0); + workbasket2.getDistributionTargets().add(workbasket1); + workbasketServiceImpl.createWorkbasket(workbasket2); - Workbasket foundBasket = workbasketServiceImpl.getWorkbasket(workbasket2.getId()); + Workbasket workbasket3 = new Workbasket(); + workbasket3.setId("3"); + workbasket3.setName("hm ... irgend ein basket"); + workbasket2.getDistributionTargets().clear(); + workbasket2.getDistributionTargets().add(workbasket3); + Thread.sleep(SLEEP_TIME); + workbasketServiceImpl.updateWorkbasket(workbasket2); - List distributionTargets = foundBasket.getDistributionTargets(); - Assert.assertEquals(1, distributionTargets.size()); - Assert.assertEquals("3", distributionTargets.get(0).getId()); - Assert.assertNotEquals(workbasketServiceImpl.getWorkbasket("2").getCreated(), - workbasketServiceImpl.getWorkbasket("2").getModified()); - Assert.assertEquals(workbasketServiceImpl.getWorkbasket("1").getCreated(), - workbasketServiceImpl.getWorkbasket("1").getModified()); - Assert.assertEquals(workbasketServiceImpl.getWorkbasket("3").getCreated(), - workbasketServiceImpl.getWorkbasket("3").getModified()); - } + Workbasket foundBasket = workbasketServiceImpl.getWorkbasket(workbasket2.getId()); - @Test - public void testInsertWorkbasketAccessUser() throws NotAuthorizedException { - WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); - accessItem.setWorkbasketId("1"); - accessItem.setUserId("Arthur Dent"); - accessItem.setOpen(true); - accessItem.setRead(true); - workbasketServiceImpl.createWorkbasketAuthorization(accessItem); + List distributionTargets = foundBasket.getDistributionTargets(); + Assert.assertEquals(1, distributionTargets.size()); + Assert.assertEquals("3", distributionTargets.get(0).getId()); + Assert.assertNotEquals(workbasketServiceImpl.getWorkbasket("2").getCreated(), + workbasketServiceImpl.getWorkbasket("2").getModified()); + Assert.assertEquals(workbasketServiceImpl.getWorkbasket("1").getCreated(), + workbasketServiceImpl.getWorkbasket("1").getModified()); + Assert.assertEquals(workbasketServiceImpl.getWorkbasket("3").getCreated(), + workbasketServiceImpl.getWorkbasket("3").getModified()); + } - Assert.assertEquals(1, workbasketServiceImpl.getAllAuthorizations().size()); - } - - @Test - public void testUpdateWorkbasketAccessUser() throws NotAuthorizedException { - WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); - accessItem.setWorkbasketId("1"); - accessItem.setUserId("Arthur Dent"); - accessItem.setOpen(true); - accessItem.setRead(true); - workbasketServiceImpl.createWorkbasketAuthorization(accessItem); + @Test + public void testInsertWorkbasketAccessUser() throws NotAuthorizedException { + WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); + accessItem.setWorkbasketId("1"); + accessItem.setUserId("Arthur Dent"); + accessItem.setOpen(true); + accessItem.setRead(true); + workbasketServiceImpl.createWorkbasketAuthorization(accessItem); - Assert.assertEquals(1, workbasketServiceImpl.getAllAuthorizations().size()); - - accessItem.setUserId("Zaphod Beeblebrox"); - workbasketServiceImpl.updateWorkbasketAuthorization(accessItem); - - Assert.assertEquals("Zaphod Beeblebrox", workbasketServiceImpl.getWorkbasketAuthorization(accessItem.getId()).getUserId()); - } + Assert.assertEquals(1, workbasketServiceImpl.getAllAuthorizations().size()); + } + + @Test + public void testUpdateWorkbasketAccessUser() throws NotAuthorizedException { + WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); + accessItem.setWorkbasketId("1"); + accessItem.setUserId("Arthur Dent"); + accessItem.setOpen(true); + accessItem.setRead(true); + workbasketServiceImpl.createWorkbasketAuthorization(accessItem); + + Assert.assertEquals(1, workbasketServiceImpl.getAllAuthorizations().size()); + + accessItem.setUserId("Zaphod Beeblebrox"); + workbasketServiceImpl.updateWorkbasketAuthorization(accessItem); + + Assert.assertEquals("Zaphod Beeblebrox", + workbasketServiceImpl.getWorkbasketAuthorization(accessItem.getId()).getUserId()); + } }