nosu
/
taskana
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

added checkstyle

This commit is contained in:
Eberhard Mayer 2017-07-05 13:00:22 +02:00
parent 29126778ec
commit a251158ca1
41 changed files with 2520 additions and 2312 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
lib/pom.xml
View File

@ -1,20 +1,20 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion> <modelVersion>4.0.0</modelVersion>
<groupId>org.taskana</groupId> <groupId>org.taskana</groupId>
<artifactId>taskana-parent</artifactId> <artifactId>taskana-parent</artifactId>
<version>0.0.1-SNAPSHOT</version> <version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging> <packaging>pom</packaging>
<properties> <properties>
<java.version>1.8</java.version> <java.version>1.8</java.version>
</properties> </properties>
<modules> <modules>
<module>taskana-core</module> <module>taskana-core</module>
<module>taskana-cdi</module> <module>taskana-cdi</module>
<module>taskana-spring</module> <module>taskana-spring</module>
<module>taskana-cdi-example</module> <module>taskana-cdi-example</module>
<module>taskana-spring-example</module> <module>taskana-spring-example</module>
</modules> </modules>
</project> </project>

135
lib/taskana-core/checkstyle.xml Normal file
View File

@ -0,0 +1,135 @@
<?xml version="1.0"?>
<!DOCTYPE module PUBLIC
"-//Puppy Crawl//DTD Check Configuration 1.2//EN"
"http://www.puppycrawl.com/dtds/configuration_1_2.dtd">
<!--
Checkstyle configuration that checks the coding conventions based on http://maven.apache.org/plugins-archives/maven-checkstyle-plugin-2.14/config/sun_checks.html.
Checkstyle is very configurable. Be sure to read the documentation at
http://checkstyle.sf.net (or in your downloaded distribution).
Most Checks are configurable, be sure to consult the documentation.
To completely disable a check, just comment it out or delete it from the file.
Finally, it is worth reading the documentation.
-->
<module name="Checker">
<!-- Checks whether files end with a new line. -->
<!-- See http://checkstyle.sf.net/config_misc.html#NewlineAtEndOfFile -->
<module name="NewlineAtEndOfFile">
<property name="lineSeparator" value="lf_cr_crlf"/>
</module>
<!-- Checks that property files contain the same keys. -->
<!-- See http://checkstyle.sf.net/config_misc.html#Translation -->
<module name="Translation"/>
<module name="FileLength"/>
<module name="FileTabCharacter">
<property name="eachLine" value="true"/>
</module>
<module name="RegexpSingleline">
<!-- \s matches whitespace character, $ matches end of line. -->
<property name="format" value="\s+$"/>
<property name="message" value="Line has trailing spaces."/>
</module>
<module name="TreeWalker">
<property name="cacheFile" value="${checkstyle.cache.file}"/>
<!-- required for SuppressWarningsFilter (and other Suppress* rules not used here) -->
<!-- see http://checkstyle.sourceforge.net/config_annotation.html#SuppressWarningsHolder -->
<module name="SuppressWarningsHolder"/>
<!-- Checks for Javadoc comments. -->
<!-- See http://checkstyle.sf.net/config_javadoc.html -->
<module name="JavadocType"/>
<module name="JavadocStyle"/>
<!-- Checks for Naming Conventions. -->
<!-- See http://checkstyle.sf.net/config_naming.html -->
<module name="ConstantName"/>
<module name="LocalFinalVariableName"/>
<module name="LocalVariableName"/>
<module name="MemberName"/>
<!-- Removed because of _ not allowed in test method names -->
<!-- <module name="MethodName"/> -->
<module name="PackageName"/>
<module name="ParameterName"/>
<module name="StaticVariableName"/>
<module name="TypeName"/>
<!-- Checks for imports -->
<!-- See http://checkstyle.sf.net/config_import.html -->
<module name="IllegalImport"/> <!-- defaults to sun.* packages -->
<module name="RedundantImport"/>
<module name="UnusedImports"/>
<!-- Checks for whitespace -->
<!-- See http://checkstyle.sf.net/config_whitespace.html -->
<module name="EmptyForIteratorPad"/>
<module name="MethodParamPad"/>
<module name="NoWhitespaceAfter"/>
<module name="NoWhitespaceBefore"/>
<module name="OperatorWrap"/>
<module name="ParenPad"/>
<module name="TypecastParenPad"/>
<module name="WhitespaceAfter"/>
<module name="WhitespaceAround"/>
<!-- Modifier Checks -->
<!-- See http://checkstyle.sf.net/config_modifiers.html -->
<module name="ModifierOrder"/>
<module name="RedundantModifier"/>
<!-- Checks for blocks. You know, those {}'s -->
<!-- See http://checkstyle.sf.net/config_blocks.html -->
<module name="AvoidNestedBlocks"/>
<module name="EmptyBlock"/>
<module name="LeftCurly"/>
<module name="NeedBraces"/>
<module name="RightCurly"/>
<!-- Checks for common coding problems -->
<!-- See http://checkstyle.sf.net/config_coding.html -->
<module name="EmptyStatement"/>
<module name="EqualsHashCode"/>
<module name="IllegalInstantiation"/>
<module name="InnerAssignment"/>
<module name="MagicNumber"/>
<module name="MissingSwitchDefault"/>
<module name="SimplifyBooleanExpression"/>
<module name="SimplifyBooleanReturn"/>
<!-- Checks for class design -->
<!-- See http://checkstyle.sf.net/config_design.html -->
<module name="FinalClass"/>
<module name="HideUtilityClassConstructor"/>
<module name="InterfaceIsType"/>
<!-- Miscellaneous other checks. -->
<!-- See http://checkstyle.sf.net/config_misc.html -->
<module name="ArrayTypeStyle"/>
<module name="TodoComment"/>
<module name="UpperEll"/>
</module>
<!-- Support @SuppressWarnings (added in Checkstyle 5.7) -->
<!-- see http://checkstyle.sourceforge.net/config.html#SuppressWarningsFilter -->
<module name="SuppressWarningsFilter"/>
<!-- Checks properties file for a duplicated properties. -->
<!-- See http://checkstyle.sourceforge.net/config_misc.html#UniqueProperties -->
<module name="UniqueProperties"/>
</module>

38
lib/taskana-core/pom.xml
View File

@ -55,4 +55,42 @@
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
</dependencies> </dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-checkstyle-plugin</artifactId>
<version>2.17</version>
<executions>
<execution>
<id>validate</id>
<phase>validate</phase>
<configuration>
<configLocation>checkstyle.xml</configLocation>
<encoding>UTF-8</encoding>
<consoleOutput>true</consoleOutput>
<failsOnError>true</failsOnError>
<failOnViolation>true</failOnViolation>
<includeTestSourceDirectory>true</includeTestSourceDirectory>
</configuration>
<goals>
<goal>check</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<showWarnings>true</showWarnings>
<failOnWarning>true</failOnWarning>
<compilerArgs>
<arg>-Xlint:all</arg>
</compilerArgs>
</configuration>
</plugin>
</plugins>
</build>
</project> </project>

68
lib/taskana-core/src/main/java/org/taskana/ClassificationService.java
View File

@ -4,45 +4,43 @@ import java.util.List;
import org.taskana.model.Classification; import org.taskana.model.Classification;
/**
* This class manages the classifications.
*/
public interface ClassificationService { public interface ClassificationService {
/** /**
* Get all available Classifications * Get all available Classifications.
* * @return The List of all Classifications
* @return The List of all Classifications */
*/ List<Classification> selectClassifications();
public List<Classification> selectClassifications();
/** /**
* Get all Classifications with given parent * Get all Classifications with given parent.
* * @param parentId
* @param parentId * the ID of the parent Classification
* the ID of the parent Classification * @return
* @return */
*/ List<Classification> selectClassificationsByParentId(String parentId);
public List<Classification> selectClassificationsByParentId(String parentId);
/** /**
* Get a Classification for a given id * Get a Classification for a given id.
* * @param id
* @param id * @return the requested Classification
* @return the requested Classification */
*/ Classification selectClassificationById(String id);
public Classification selectClassificationById(String id);
/** /**
* Insert a new Classification * Insert a new Classification.
* * @param classification
* @param classification * the classification to insert
* the classification to insert */
*/ void insertClassification(Classification classification);
public void insertClassification(Classification classification);
/** /**
* Update a Classification * Update a Classification.
* * @param classification
* @param classification * the Classification to update
* the Classification to update */
*/ void updateClassification(Classification classification);
public void updateClassification(Classification classification);
} }

202
lib/taskana-core/src/main/java/org/taskana/TaskService.java
View File

@ -10,125 +10,115 @@ import org.taskana.model.Task;
import org.taskana.model.TaskState; import org.taskana.model.TaskState;
import org.taskana.model.TaskStateCounter; import org.taskana.model.TaskStateCounter;
/**
* The Task Service manages all operations on tasks.
*/
public interface TaskService { public interface TaskService {
/** /**
* Claim an existing task * Claim an existing task.
* * @param id
* @param id * task id
* task id * @param userName
* @param userName * user who claims the task
* user who claims the task * @throws TaskNotFoundException
* @throws TaskNotFoundException */
*/ void claim(String id, String userName) throws TaskNotFoundException;
public void claim(String id, String userName) throws TaskNotFoundException;
/** /**
* Set task to completed * Set task to completed.
* * @param taskId
* @param taskId * the task id
* the task id * @throws TaskNotFoundException
* @throws TaskNotFoundException */
*/ void complete(String taskId) throws TaskNotFoundException;
public void complete(String taskId) throws TaskNotFoundException;
/** /**
* Create a task by a task object * Create a task by a task object.
* * @param task
* @param task * @return the created task
* @return the created task * @throws NotAuthorizedException
* @throws NotAuthorizedException */
*/ Task create(Task task) throws NotAuthorizedException;
public Task create(Task task) throws NotAuthorizedException;
/** /**
* Get the details of a task * Get the details of a task.
* * @param taskId
* @param taskId * the id of the task
* the id of the task * @return the Task
* @return the Task */
*/ Task getTaskById(String taskId) throws TaskNotFoundException;
public Task getTaskById(String taskId) throws TaskNotFoundException;
/** /**
* Query all tasks for a workbasket. * Query all tasks for a workbasket.
* * @param workbasketId
* @param workbasketId * the workbasket to query
* the workbasket to query * @return the list of tasks, which reside in the workbasket
* @return the list of tasks, which reside in the workbasket * @throws NotAuthorizedException
* @throws NotAuthorizedException */
*/ List<Task> getTasksForWorkbasket(String workbasketId) throws NotAuthorizedException;
public List<Task> getTasksForWorkbasket(String workbasketId) throws NotAuthorizedException;
/** /**
* Query all tasks for a workbasket. * Query all tasks for a workbasket.
* * @param workbasketId
* @param workbasketId * the workbasket to query
* the workbasket to query * @return the list of tasks, which reside in the workbasket
* @return the list of tasks, which reside in the workbasket * @throws NotAuthorizedException
* @throws NotAuthorizedException */
*/ List<Task> getTasksForWorkbasket(List<String> workbaskets, List<TaskState> states) throws NotAuthorizedException;
public List<Task> getTasksForWorkbasket(List<String> workbaskets, List<TaskState> states)
throws NotAuthorizedException;
/** /**
* This method returns all Tasks * This method returns all Tasks.
* * @return a {@link List<Task>} of {@link Task}
* @return a {@link List<Task>} of {@link Task} */
*/ List<Task> getTasks();
public List<Task> getTasks();
/** /**
* This method counts all tasks with a given state. * This method counts all tasks with a given state.
* * @param states
* @param states * the countable states
* the countable states * @return a List of {@link TaskStateCounter}
* @return a List of {@link TaskStateCounter} */
*/ List<TaskStateCounter> getTaskCountForState(List<TaskState> states);
public List<TaskStateCounter> getTaskCountForState(List<TaskState> states);
/** /**
* This method returns all tasks with the specified states * This method returns all tasks with the specified states.
* * @param states
* @param states all List with the needed states * all List with the needed states
* @return a list of Tasks * @return a list of Tasks
*/ */
public List<Task> findTasks(List<TaskState> states); List<Task> findTasks(List<TaskState> states);
/** /**
* Count all Tasks in a given workbasket with daysInPast as Days from today * Count all Tasks in a given workbasket with daysInPast as Days from today in
* in the past and a specific state. * the past and a specific state.
* * @param workbasketId
* @param workbasketId * @param daysInPast
* @param daysInPast * @param states
* @param states * @return
* @return */
*/ long getTaskCountForWorkbasketByDaysInPastAndState(String workbasketId, long daysInPast, List<TaskState> states);
public long getTaskCountForWorkbasketByDaysInPastAndState(String workbasketId, long daysInPast,
List<TaskState> states);
/** /**
* Transfer task to another workbasket. * Transfer task to another workbasket. The transfer set the transferred flag
* * and resets the read flag.
* The transfer set the transferred flag and resets the read flag. * @param workbasketId
* * @return the updated task
* @param workbasketId * @throws NotAuthorizedException
* @return the updated task */
* @throws NotAuthorizedException Task transfer(String taskId, String workbasketId)
*/ throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException;
public Task transfer(String taskId, String workbasketId)
throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException;
/** /**
* Marks a task as read. * Marks a task as read.
* * @param taskId
* @param taskId the id of the task to be updated * the id of the task to be updated
* @param isRead the new status of the read flag. * @param isRead
* @return Task the updated Task * the new status of the read flag.
*/ * @return Task the updated Task
public Task setTaskRead(String taskId, boolean isRead) throws TaskNotFoundException; */
Task setTaskRead(String taskId, boolean isRead) throws TaskNotFoundException;
public List<DueWorkbasketCounter> getTaskCountByWorkbasketAndDaysInPastAndState(long daysInPast, List<DueWorkbasketCounter> getTaskCountByWorkbasketAndDaysInPastAndState(long daysInPast, List<TaskState> states);
List<TaskState> states);
} }

45
lib/taskana-core/src/main/java/org/taskana/TaskanaEngine.java
View File

@ -3,34 +3,31 @@ package org.taskana;
import org.taskana.configuration.TaskanaEngineConfiguration; 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 { public interface TaskanaEngine {
/** /**
* The TaskService can be used for operations on all Tasks * The TaskService can be used for operations on all Tasks.
* * @return the TaskService
* @return the TaskService */
*/ TaskService getTaskService();
public TaskService getTaskService();
/** /**
* The WorkbasketService can be used for operations on all Workbaskets * The WorkbasketService can be used for operations on all Workbaskets.
* * @return the TaskService
* @return the TaskService */
*/ WorkbasketService getWorkbasketService();
public WorkbasketService getWorkbasketService();
/** /**
* The ClassificationService can be used for operations on all Categories * The ClassificationService can be used for operations on all Categories.
* * @return the TaskService
* @return the TaskService */
*/ ClassificationService getClassificationService();
public ClassificationService getClassificationService();
/** /**
* The Taskana configuration * The Taskana configuration.
* @return the TaskanaConfiguration * @return the TaskanaConfiguration
*/ */
public TaskanaEngineConfiguration getConfiguration(); TaskanaEngineConfiguration getConfiguration();
} }

187
lib/taskana-core/src/main/java/org/taskana/WorkbasketService.java
View File

@ -8,117 +8,106 @@ import org.taskana.model.Workbasket;
import org.taskana.model.WorkbasketAccessItem; import org.taskana.model.WorkbasketAccessItem;
import org.taskana.model.WorkbasketAuthorization; import org.taskana.model.WorkbasketAuthorization;
/**
* This service manages the Workbaskets.
*/
public interface WorkbasketService { public interface WorkbasketService {
/** /**
* Get Workbasket for a given id. * Get Workbasket for a given id.
* * @param workbasketId
* @param workbasketId * @return the requested Workbasket
* @return the requested Workbasket */
*/ Workbasket getWorkbasket(String workbasketId) throws WorkbasketNotFoundException;
public Workbasket getWorkbasket(String workbasketId) throws WorkbasketNotFoundException;
/** /**
* Get all available Workbaskets. * Get all available Workbaskets.
* * @return List<Workbasket> the list of all workbaskets
* @return List<Workbasket> the list of all workbaskets */
*/ List<Workbasket> getWorkbaskets();
public List<Workbasket> getWorkbaskets();
/** /**
* Create a new Workbasket. * Create a new Workbasket.
* * @param workbasket
* @param workbasket * The workbasket to create
* The workbasket to create * @throws NotAuthorizedException
* @throws NotAuthorizedException */
*/ Workbasket createWorkbasket(Workbasket workbasket);
public Workbasket createWorkbasket(Workbasket workbasket);
/** /**
* Update a Workbasket. * Update a Workbasket.
* * @param workbasket
* * The workbasket to update
* @param workbasket * @throws NotAuthorizedException
* The workbasket to update */
* @throws NotAuthorizedException Workbasket updateWorkbasket(Workbasket workbasket) throws NotAuthorizedException;
*/
public Workbasket updateWorkbasket(Workbasket workbasket) throws NotAuthorizedException;
/** /**
* Create a new authorization for a specific workbasket and a specific user * Create a new authorization for a specific workbasket and a specific user.
* * @param workbasket
* @param workbasket * the choosen workbasket
* the choosen workbasket * @param user
* @param user * the choosen user
* the choosen user * @return
* @return */
*/ WorkbasketAccessItem createWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem);
public WorkbasketAccessItem createWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem);
/** /**
* This method updates an Workbasket Authorization * This method updates an Workbasket Authorization.
* * @param workbasketAccessItem
* @param workbasketAccessItem * the Authorization
* the Authorization * @return the updated entity
* @return the updated entity */
*/ WorkbasketAccessItem updateWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem);
public WorkbasketAccessItem updateWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem);
/** /**
* Get all authorizations of the workbasket * Get all authorizations of the workbasket.
* * @return a WorkbasketAccessItem list
* @return a WorkbasketAccessItem list */
*/ List<WorkbasketAccessItem> getAllAuthorizations();
public List<WorkbasketAccessItem> getAllAuthorizations();
/** /**
* Deletes a specific authorization * Deletes a specific authorization.
* * @param id
* @param id * the specific id
* the specific id */
*/ void deleteWorkbasketAuthorization(String id);
public void deleteWorkbasketAuthorization(String id);
/** /**
* This method checks the authorization with the saved one * This method checks the authorization with the saved one.
* * @param workbasket
* @param workbasket * the workbasket to check
* the workbasket to check * @param userId
* @param userId * the user to check
* the user to check * @param authorization
* @param authorization * the needed Authorization
* the needed Authorization * @throws WorkbasketNotFoundException
* @throws WorkbasketNotFoundException * if the workbasket do not exist
* if the workbasket do not exist * @throws NotAuthorizedException
* @throws NotAuthorizedException */
*/ void checkAuthorization(String workbasketId, WorkbasketAuthorization authorization) throws NotAuthorizedException;
public void checkAuthorization(String workbasketId, WorkbasketAuthorization authorization)
throws NotAuthorizedException;
/** /**
* This method get one WorkbasketAuthorization with an id * This method get one WorkbasketAuthorization with an id.
* * @param id
* @param id * the id
* the id * @return the full {@link WorkbasketAccessItem}
* @return the full {@link WorkbasketAccessItem} */
*/ WorkbasketAccessItem getWorkbasketAuthorization(String id);
public WorkbasketAccessItem getWorkbasketAuthorization(String id);
/** /**
* Get all authorizations for a Workbasket. * Get all authorizations for a Workbasket.
* * @param workbasketId
* @param workbasketId * @return List<WorkbasketAccessItem>
* @return List<WorkbasketAccessItem> */
*/ List<WorkbasketAccessItem> getWorkbasketAuthorizations(String workbasketId);
public List<WorkbasketAccessItem> getWorkbasketAuthorizations(String workbasketId);
/** /**
* This method provides workbaskets via an permission * This method provides workbaskets via an permission.
* * @param permission
* @param permission * as String like in this enum: {@link WorkbasketAuthorization}
* as String like in this enum: {@link WorkbasketAuthorization} * @return all filtered workbaskets
* @return all filtered workbaskets */
*/ List<Workbasket> getWorkbaskets(List<WorkbasketAuthorization> permission);
List<Workbasket> getWorkbaskets(List<WorkbasketAuthorization> permission);
} }

101
lib/taskana-core/src/main/java/org/taskana/configuration/DbScriptRunner.java
View File

@ -11,67 +11,68 @@ import org.apache.ibatis.jdbc.ScriptRunner;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
/**
* This class create the schema for taskana.
*/
public class DbScriptRunner { 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 SQL = "/sql";
private static final String DB_SCHEMA = SQL + "/taskana-schema.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 DB_SCHEMA_DETECTION = SQL + "/schema-detection.sql";
private DataSource dataSource; private DataSource dataSource;
private StringWriter outWriter = new StringWriter(); private StringWriter outWriter = new StringWriter();
private PrintWriter logWriter = new PrintWriter(outWriter); private PrintWriter logWriter = new PrintWriter(outWriter);
private StringWriter errorWriter = new StringWriter(); private StringWriter errorWriter = new StringWriter();
private PrintWriter errorLogWriter = new PrintWriter(errorWriter); private PrintWriter errorLogWriter = new PrintWriter(errorWriter);
public DbScriptRunner(DataSource dataSource) { public DbScriptRunner(DataSource dataSource) {
super(); super();
this.dataSource = dataSource; 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());
/** runner.setStopOnError(true);
* Run all db scripts runner.setLogWriter(logWriter);
* runner.setErrorLogWriter(errorLogWriter);
* @throws SQLException
*/
public void run() throws SQLException {
ScriptRunner runner = new ScriptRunner(dataSource.getConnection());
logger.debug(dataSource.getConnection().getMetaData().toString());
runner.setStopOnError(true); if (!isSchemaPreexisting(runner)) {
runner.setLogWriter(logWriter); runner.runScript(new InputStreamReader(this.getClass().getResourceAsStream(DB_SCHEMA)));
runner.setErrorLogWriter(errorLogWriter); }
runner.closeConnection();
if (!isSchemaPreexisting(runner)) { LOGGER.debug(outWriter.toString());
runner.runScript(new InputStreamReader(this.getClass().getResourceAsStream(DB_SCHEMA))); if (!errorWriter.toString().trim().isEmpty()) {
} LOGGER.error(errorWriter.toString());
runner.closeConnection(); }
}
logger.debug(outWriter.toString()); private boolean isSchemaPreexisting(ScriptRunner runner) {
if (!errorWriter.toString().trim().isEmpty()) { try {
logger.error(errorWriter.toString()); 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) { public DataSource getDataSource() {
try { return dataSource;
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() { public void setDataSource(DataSource dataSource) {
return dataSource; this.dataSource = dataSource;
} }
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
} }

123
lib/taskana-core/src/main/java/org/taskana/configuration/TaskanaEngineConfiguration.java
View File

@ -12,85 +12,82 @@ import org.taskana.impl.TaskanaEngineImpl;
/** /**
* This central class creates the TaskanaEngine and needs all the information * This central class creates the TaskanaEngine and needs all the information
* about DB and Security * about DB and Security.
*/ */
public class TaskanaEngineConfiguration { 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 USER_PASSWORD = "sa";
private static final String JDBC_H2_MEM_TASKANA = "jdbc:h2:mem:taskana"; 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 H2_DRIVER = "org.h2.Driver";
protected DataSource dataSource; protected DataSource dataSource;
protected DbScriptRunner dbScriptRunner; protected DbScriptRunner dbScriptRunner;
// global switch to enable JAAS based authentication and Taskana // global switch to enable JAAS based authentication and Taskana
// authorizations // authorizations
protected boolean securityEnabled; protected boolean securityEnabled;
protected boolean useContainerManagedTransactions; protected boolean useContainerManagedTransactions;
public TaskanaEngineConfiguration() { public TaskanaEngineConfiguration() {
} }
public TaskanaEngineConfiguration(DataSource dataSource, boolean useContainerManagedTransactions) public TaskanaEngineConfiguration(DataSource dataSource, boolean useContainerManagedTransactions)
throws SQLException { throws SQLException {
this(dataSource, useContainerManagedTransactions, true); this(dataSource, useContainerManagedTransactions, true);
} }
public TaskanaEngineConfiguration(DataSource dataSource, boolean useContainerManagedTransactions, public TaskanaEngineConfiguration(DataSource dataSource, boolean useContainerManagedTransactions,
boolean securityEnabled) throws SQLException { boolean securityEnabled) throws SQLException {
this.useContainerManagedTransactions = useContainerManagedTransactions; this.useContainerManagedTransactions = useContainerManagedTransactions;
if (dataSource != null) { if (dataSource != null) {
this.dataSource = dataSource; this.dataSource = dataSource;
} else { } else {
// use default In Memory datasource // use default In Memory datasource
this.dataSource = createDefaultDataSource(); this.dataSource = createDefaultDataSource();
} }
dbScriptRunner = new DbScriptRunner(this.dataSource); dbScriptRunner = new DbScriptRunner(this.dataSource);
dbScriptRunner.run(); dbScriptRunner.run();
this.securityEnabled = securityEnabled; this.securityEnabled = securityEnabled;
} }
public DataSource createDefaultDataSource() { public DataSource createDefaultDataSource() {
logger.warn("No datasource is provided. A inmemory db is used: " LOGGER.warn("No datasource is provided. A inmemory db is used: "
+ "'org.h2.Driver', 'jdbc:h2:mem:taskana', 'sa', 'sa'"); + "'org.h2.Driver', 'jdbc:h2:mem:taskana', 'sa', 'sa'");
return createDatasource(H2_DRIVER, JDBC_H2_MEM_TASKANA, USER_PASSWORD, USER_PASSWORD); return createDatasource(H2_DRIVER, JDBC_H2_MEM_TASKANA, USER_PASSWORD, USER_PASSWORD);
} }
/** /**
* This method creates the TaskanaEngine without an sqlSessionFactory * This method creates the TaskanaEngine without an sqlSessionFactory.
* * @return the TaskanaEngine
* @return the TaskanaEngine * @throws SQLException
* @throws SQLException */
*/ public TaskanaEngine buildTaskanaEngine() throws SQLException {
public TaskanaEngine buildTaskanaEngine() throws SQLException { return new TaskanaEngineImpl(this);
return new TaskanaEngineImpl(this); }
}
/** /**
* This method creates a PooledDataSource, if the needed properties are * This method creates a PooledDataSource, if the needed properties are provided.
* provided * @param dbConfiguration
* * @return DataSource
* @param dbConfiguration */
* @return DataSource public DataSource createDatasource(String driver, String jdbcUrl, String username, String password) {
*/ return new PooledDataSource(driver, jdbcUrl, username, password);
public DataSource createDatasource(String driver, String jdbcUrl, String username, String password) { }
return new PooledDataSource(driver, jdbcUrl, username, password);
}
public boolean isSecurityEnabled() { public boolean isSecurityEnabled() {
return this.securityEnabled; return this.securityEnabled;
} }
public DataSource getDatasource() { public DataSource getDatasource() {
return this.dataSource; return this.dataSource;
} }
public boolean getUseContainerManagedTransactions() { public boolean getUseContainerManagedTransactions() {
return this.useContainerManagedTransactions; return this.useContainerManagedTransactions;
} }
} }

10
lib/taskana-core/src/main/java/org/taskana/exceptions/NotAuthorizedException.java
View File

@ -1,10 +1,12 @@
package org.taskana.exceptions; package org.taskana.exceptions;
/**
* This exception is used to communicate a not authorized user.
*/
@SuppressWarnings("serial") @SuppressWarnings("serial")
public class NotAuthorizedException extends Exception { public class NotAuthorizedException extends Exception {
public NotAuthorizedException(String msg) { public NotAuthorizedException(String msg) {
super(msg); super(msg);
} }
} }

10
lib/taskana-core/src/main/java/org/taskana/exceptions/NotFoundException.java
View File

@ -1,10 +1,12 @@
package org.taskana.exceptions; package org.taskana.exceptions;
/**
* This exception will be thrown if a specific object is not in the database.
*/
@SuppressWarnings("serial") @SuppressWarnings("serial")
public class NotFoundException extends Exception { public class NotFoundException extends Exception {
public NotFoundException(String id) { public NotFoundException(String id) {
super(id); super(id);
} }
} }

3
lib/taskana-core/src/main/java/org/taskana/exceptions/TaskNotFoundException.java
View File

@ -1,5 +1,8 @@
package org.taskana.exceptions; package org.taskana.exceptions;
/**
* This exception will be thrown if a specific task is not in the database.
*/
@SuppressWarnings("serial") @SuppressWarnings("serial")
public class TaskNotFoundException extends NotFoundException { public class TaskNotFoundException extends NotFoundException {

9
lib/taskana-core/src/main/java/org/taskana/exceptions/WorkbasketNotFoundException.java
View File

@ -1,9 +1,12 @@
package org.taskana.exceptions; package org.taskana.exceptions;
/**
* This exception will be thrown if a specific workbasket is not in the database.
*/
@SuppressWarnings("serial") @SuppressWarnings("serial")
public class WorkbasketNotFoundException extends NotFoundException { public class WorkbasketNotFoundException extends NotFoundException {
public WorkbasketNotFoundException(String id) { public WorkbasketNotFoundException(String id) {
super("Workbasket with '" + id + "' not found"); super("Workbasket with '" + id + "' not found");
} }
} }

103
lib/taskana-core/src/main/java/org/taskana/impl/ClassificationServiceImpl.java
View File

@ -10,67 +10,70 @@ import org.taskana.impl.util.IdGenerator;
import org.taskana.model.Classification; import org.taskana.model.Classification;
import org.taskana.model.mappings.ClassificationMapper; import org.taskana.model.mappings.ClassificationMapper;
/**
* This is the implementation of ClassificationService.
*/
public class ClassificationServiceImpl implements ClassificationService { public class ClassificationServiceImpl implements ClassificationService {
private static final String ID_PREFIX_CLASSIFICATION = "CLI"; private static final String ID_PREFIX_CLASSIFICATION = "CLI";
private ClassificationMapper classificationMapper; private ClassificationMapper classificationMapper;
public ClassificationServiceImpl(ClassificationMapper classificationMapper) { public ClassificationServiceImpl(ClassificationMapper classificationMapper) {
super(); super();
this.classificationMapper = classificationMapper; this.classificationMapper = classificationMapper;
} }
@Override @Override
public List<Classification> selectClassifications() { public List<Classification> selectClassifications() {
final List<Classification> rootClassifications = classificationMapper.findByParentId(""); final List<Classification> rootClassifications = classificationMapper.findByParentId("");
populateChildClassifications(rootClassifications); populateChildClassifications(rootClassifications);
return rootClassifications; return rootClassifications;
} }
private void populateChildClassifications(final List<Classification> classifications) { private void populateChildClassifications(final List<Classification> classifications) {
for (Classification classification : classifications) { for (Classification classification : classifications) {
List<Classification> childClassifications = classificationMapper.findByParentId(classification.getId()); List<Classification> childClassifications = classificationMapper.findByParentId(classification.getId());
classification.setChildren(childClassifications); classification.setChildren(childClassifications);
populateChildClassifications(childClassifications); populateChildClassifications(childClassifications);
} }
} }
@Override @Override
public List<Classification> selectClassificationsByParentId(String parentId) { public List<Classification> selectClassificationsByParentId(String parentId) {
return classificationMapper.findByParentId(parentId); return classificationMapper.findByParentId(parentId);
} }
@Override @Override
public void insertClassification(Classification classification) { public void insertClassification(Classification classification) {
classification.setId(IdGenerator.generateWithPrefix(ID_PREFIX_CLASSIFICATION)); classification.setId(IdGenerator.generateWithPrefix(ID_PREFIX_CLASSIFICATION));
classification.setCreated(Date.valueOf(LocalDate.now())); classification.setCreated(Date.valueOf(LocalDate.now()));
classification.setModified(Date.valueOf(LocalDate.now())); classification.setModified(Date.valueOf(LocalDate.now()));
this.checkServiceLevel(classification); this.checkServiceLevel(classification);
classificationMapper.insert(classification); classificationMapper.insert(classification);
} }
@Override @Override
public void updateClassification(Classification classification) { public void updateClassification(Classification classification) {
classification.setModified(Date.valueOf(LocalDate.now())); classification.setModified(Date.valueOf(LocalDate.now()));
this.checkServiceLevel(classification); this.checkServiceLevel(classification);
classificationMapper.update(classification); classificationMapper.update(classification);
} }
@Override @Override
public Classification selectClassificationById(String id) { public Classification selectClassificationById(String id) {
return classificationMapper.findById(id); return classificationMapper.findById(id);
} }
private void checkServiceLevel(Classification classification) { private void checkServiceLevel(Classification classification) {
if (classification.getServiceLevel() != null) { if (classification.getServiceLevel() != null) {
try { try {
Duration.parse(classification.getServiceLevel()); Duration.parse(classification.getServiceLevel());
} catch (Exception e) { } catch (Exception e) {
throw new IllegalArgumentException("Invalid timestamp. Please use the format 'PddDThhHmmM'"); throw new IllegalArgumentException("Invalid timestamp. Please use the format 'PddDThhHmmM'");
} }
} }
} }
} }

297
lib/taskana-core/src/main/java/org/taskana/impl/TaskServiceImpl.java
View File

@ -22,180 +22,185 @@ import org.taskana.model.TaskStateCounter;
import org.taskana.model.WorkbasketAuthorization; import org.taskana.model.WorkbasketAuthorization;
import org.taskana.model.mappings.ObjectReferenceMapper; import org.taskana.model.mappings.ObjectReferenceMapper;
import org.taskana.model.mappings.TaskMapper; import org.taskana.model.mappings.TaskMapper;
/**
* This is the implementation of TaskService.
*/
public class TaskServiceImpl implements TaskService { public class TaskServiceImpl implements TaskService {
private static final Logger logger = LoggerFactory.getLogger(TaskServiceImpl.class); private static final Logger LOGGER = LoggerFactory.getLogger(TaskServiceImpl.class);
private static final String ID_PREFIX_OBJECTR_EFERENCE = "ORI"; private static final String ID_PREFIX_OBJECTR_EFERENCE = "ORI";
private static final String ID_PREFIX_TASK = "TKI"; private static final String ID_PREFIX_TASK = "TKI";
private TaskanaEngine taskanaEngine; private TaskanaEngine taskanaEngine;
private TaskMapper taskMapper; private TaskMapper taskMapper;
private ObjectReferenceMapper objectReferenceMapper; private ObjectReferenceMapper objectReferenceMapper;
public TaskServiceImpl(TaskanaEngine taskanaEngine, TaskMapper taskMapper, ObjectReferenceMapper objectReferenceMapper) { public TaskServiceImpl(TaskanaEngine taskanaEngine, TaskMapper taskMapper,
super(); ObjectReferenceMapper objectReferenceMapper) {
this.taskanaEngine = taskanaEngine; super();
this.taskMapper = taskMapper; this.taskanaEngine = taskanaEngine;
this.objectReferenceMapper = objectReferenceMapper; this.taskMapper = taskMapper;
} this.objectReferenceMapper = objectReferenceMapper;
}
@Override @Override
public void claim(String id, String userName) throws TaskNotFoundException { public void claim(String id, String userName) throws TaskNotFoundException {
Task task = taskMapper.findById(id); Task task = taskMapper.findById(id);
if (task != null) { if (task != null) {
Timestamp now = new Timestamp(System.currentTimeMillis()); Timestamp now = new Timestamp(System.currentTimeMillis());
task.setOwner(userName); task.setOwner(userName);
task.setModified(now); task.setModified(now);
task.setClaimed(now); task.setClaimed(now);
task.setState(TaskState.CLAIMED); task.setState(TaskState.CLAIMED);
taskMapper.update(task); taskMapper.update(task);
logger.debug("User '{}' claimed task '{}'.", userName, id); LOGGER.debug("User '{}' claimed task '{}'.", userName, id);
} else { } else {
throw new TaskNotFoundException(id); throw new TaskNotFoundException(id);
} }
} }
@Override @Override
public void complete(String id) throws TaskNotFoundException { public void complete(String id) throws TaskNotFoundException {
Task task = taskMapper.findById(id); Task task = taskMapper.findById(id);
if (task != null) { if (task != null) {
Timestamp now = new Timestamp(System.currentTimeMillis()); Timestamp now = new Timestamp(System.currentTimeMillis());
task.setCompleted(now); task.setCompleted(now);
task.setModified(now); task.setModified(now);
task.setState(TaskState.COMPLETED); task.setState(TaskState.COMPLETED);
taskMapper.update(task); taskMapper.update(task);
logger.debug("Task '{}' completed.", id); LOGGER.debug("Task '{}' completed.", id);
} else { } else {
throw new TaskNotFoundException(id); throw new TaskNotFoundException(id);
} }
} }
@Override @Override
public Task create(Task task) throws NotAuthorizedException { public Task create(Task task) throws NotAuthorizedException {
taskanaEngine.getWorkbasketService().checkAuthorization(task.getWorkbasketId(), WorkbasketAuthorization.APPEND); taskanaEngine.getWorkbasketService().checkAuthorization(task.getWorkbasketId(), WorkbasketAuthorization.APPEND);
Timestamp now = new Timestamp(System.currentTimeMillis()); Timestamp now = new Timestamp(System.currentTimeMillis());
task.setId(IdGenerator.generateWithPrefix(ID_PREFIX_TASK)); task.setId(IdGenerator.generateWithPrefix(ID_PREFIX_TASK));
task.setState(TaskState.READY); task.setState(TaskState.READY);
task.setCreated(now); task.setCreated(now);
task.setModified(now); task.setModified(now);
task.setRead(false); task.setRead(false);
task.setTransferred(false); task.setTransferred(false);
// insert ObjectReference if needed. // insert ObjectReference if needed.
if (task.getPrimaryObjRef() != null) { if (task.getPrimaryObjRef() != null) {
ObjectReference objectReference = this.objectReferenceMapper.findByObjectReference(task.getPrimaryObjRef()); ObjectReference objectReference = this.objectReferenceMapper.findByObjectReference(task.getPrimaryObjRef());
if (objectReference == null) { if (objectReference == null) {
objectReference = task.getPrimaryObjRef(); objectReference = task.getPrimaryObjRef();
objectReference.setId(IdGenerator.generateWithPrefix(ID_PREFIX_OBJECTR_EFERENCE)); objectReference.setId(IdGenerator.generateWithPrefix(ID_PREFIX_OBJECTR_EFERENCE));
this.objectReferenceMapper.insert(objectReference); this.objectReferenceMapper.insert(objectReference);
} }
task.setPrimaryObjRef(objectReference); task.setPrimaryObjRef(objectReference);
} }
this.taskMapper.insert(task); this.taskMapper.insert(task);
logger.debug("Task '{}' created.", task.getId()); LOGGER.debug("Task '{}' created.", task.getId());
return task; return task;
} }
@Override @Override
public Task getTaskById(String id) throws TaskNotFoundException { public Task getTaskById(String id) throws TaskNotFoundException {
Task task = taskMapper.findById(id); Task task = taskMapper.findById(id);
if (task != null) { if (task != null) {
return task; return task;
} else { } else {
throw new TaskNotFoundException(id); throw new TaskNotFoundException(id);
} }
} }
@Override @Override
public List<Task> getTasksForWorkbasket(String workbasketId) throws NotAuthorizedException { public List<Task> getTasksForWorkbasket(String workbasketId) throws NotAuthorizedException {
taskanaEngine.getWorkbasketService().checkAuthorization(workbasketId, WorkbasketAuthorization.OPEN); taskanaEngine.getWorkbasketService().checkAuthorization(workbasketId, WorkbasketAuthorization.OPEN);
return taskMapper.findByWorkBasketId(workbasketId); return taskMapper.findByWorkBasketId(workbasketId);
} }
@Override @Override
public List<Task> findTasks(List<TaskState> states) { public List<Task> findTasks(List<TaskState> states) {
return taskMapper.findByStates(states); return taskMapper.findByStates(states);
} }
@Override @Override
public List<Task> getTasksForWorkbasket(List<String> workbasketIds, List<TaskState> states) public List<Task> getTasksForWorkbasket(List<String> workbasketIds, List<TaskState> states)
throws NotAuthorizedException { throws NotAuthorizedException {
for (String workbasket : workbasketIds) { for (String workbasket : workbasketIds) {
taskanaEngine.getWorkbasketService().checkAuthorization(workbasket, WorkbasketAuthorization.OPEN); taskanaEngine.getWorkbasketService().checkAuthorization(workbasket, WorkbasketAuthorization.OPEN);
} }
return taskMapper.findByWorkbasketIdsAndStates(workbasketIds, states); return taskMapper.findByWorkbasketIdsAndStates(workbasketIds, states);
} }
@Override @Override
public List<Task> getTasks() { public List<Task> getTasks() {
return taskMapper.findAll(); return taskMapper.findAll();
} }
@Override @Override
public List<TaskStateCounter> getTaskCountForState(List<TaskState> states) { public List<TaskStateCounter> getTaskCountForState(List<TaskState> states) {
return taskMapper.getTaskCountForState(states); return taskMapper.getTaskCountForState(states);
} }
@Override @Override
public long getTaskCountForWorkbasketByDaysInPastAndState(String workbasketId, long daysInPast, public long getTaskCountForWorkbasketByDaysInPastAndState(String workbasketId, long daysInPast,
List<TaskState> states) { List<TaskState> states) {
LocalDate time = LocalDate.now(); LocalDate time = LocalDate.now();
time = time.minusDays(daysInPast); time = time.minusDays(daysInPast);
Date fromDate = Date.valueOf(time); Date fromDate = Date.valueOf(time);
return taskMapper.getTaskCountForWorkbasketByDaysInPastAndState(workbasketId, fromDate, states); return taskMapper.getTaskCountForWorkbasketByDaysInPastAndState(workbasketId, fromDate, states);
} }
@Override @Override
public Task transfer(String taskId, String destinationWorkbasketId) public Task transfer(String taskId, String destinationWorkbasketId)
throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException {
Task task = getTaskById(taskId); Task task = getTaskById(taskId);
// transfer requires TRANSFER in source and APPEND on destination // transfer requires TRANSFER in source and APPEND on destination
// workbasket // workbasket
taskanaEngine.getWorkbasketService().checkAuthorization(destinationWorkbasketId, WorkbasketAuthorization.APPEND); taskanaEngine.getWorkbasketService().checkAuthorization(destinationWorkbasketId,
taskanaEngine.getWorkbasketService().checkAuthorization(task.getWorkbasketId(), WorkbasketAuthorization.TRANSFER); WorkbasketAuthorization.APPEND);
taskanaEngine.getWorkbasketService().checkAuthorization(task.getWorkbasketId(),
WorkbasketAuthorization.TRANSFER);
// if security is disabled, the implicit existance check on the // if security is disabled, the implicit existance check on the
// destination workbasket has been skipped and needs to be performed // destination workbasket has been skipped and needs to be performed
if (!taskanaEngine.getConfiguration().isSecurityEnabled()) { if (!taskanaEngine.getConfiguration().isSecurityEnabled()) {
taskanaEngine.getWorkbasketService().getWorkbasket(destinationWorkbasketId); taskanaEngine.getWorkbasketService().getWorkbasket(destinationWorkbasketId);
} }
// reset read flag and set transferred flag // reset read flag and set transferred flag
task.setRead(false); task.setRead(false);
task.setTransferred(true); task.setTransferred(true);
// transfer task from source to destination workbasket // transfer task from source to destination workbasket
task.setWorkbasketId(destinationWorkbasketId); task.setWorkbasketId(destinationWorkbasketId);
task.setModified(Timestamp.valueOf(LocalDateTime.now())); task.setModified(Timestamp.valueOf(LocalDateTime.now()));
taskMapper.update(task); taskMapper.update(task);
return getTaskById(taskId); return getTaskById(taskId);
} }
@Override @Override
public List<DueWorkbasketCounter> getTaskCountByWorkbasketAndDaysInPastAndState(long daysInPast, public List<DueWorkbasketCounter> getTaskCountByWorkbasketAndDaysInPastAndState(long daysInPast,
List<TaskState> states) { List<TaskState> states) {
LocalDate time = LocalDate.now(); LocalDate time = LocalDate.now();
time = time.minusDays(daysInPast); time = time.minusDays(daysInPast);
Date fromDate = Date.valueOf(time); Date fromDate = Date.valueOf(time);
return taskMapper.getTaskCountByWorkbasketIdAndDaysInPastAndState(fromDate, states); return taskMapper.getTaskCountByWorkbasketIdAndDaysInPastAndState(fromDate, states);
} }
@Override @Override
public Task setTaskRead(String taskId, boolean isRead) throws TaskNotFoundException { public Task setTaskRead(String taskId, boolean isRead) throws TaskNotFoundException {
Task task = getTaskById(taskId); Task task = getTaskById(taskId);
task.setRead(true); task.setRead(true);
task.setModified(Timestamp.valueOf(LocalDateTime.now())); task.setModified(Timestamp.valueOf(LocalDateTime.now()));
taskMapper.update(task); taskMapper.update(task);
return getTaskById(taskId); return getTaskById(taskId);
} }
} }

154
lib/taskana-core/src/main/java/org/taskana/impl/TaskanaEngineImpl.java
View File

@ -20,96 +20,98 @@ import org.taskana.model.mappings.TaskMapper;
import org.taskana.model.mappings.WorkbasketAccessMapper; import org.taskana.model.mappings.WorkbasketAccessMapper;
import org.taskana.model.mappings.WorkbasketMapper; import org.taskana.model.mappings.WorkbasketMapper;
/**
* This is the implementation of TaskanaEngine.
*/
public class TaskanaEngineImpl implements TaskanaEngine { public class TaskanaEngineImpl implements TaskanaEngine {
private static final String DEFAULT = "default"; private static final String DEFAULT = "default";
protected TaskanaEngineConfiguration taskanaEngineConfiguration; protected TaskanaEngineConfiguration taskanaEngineConfiguration;
protected SqlSession session; protected SqlSession session;
protected TransactionFactory transactionFactory; protected TransactionFactory transactionFactory;
private TaskMapper taskMapper; private TaskMapper taskMapper;
private WorkbasketMapper workbasketMapper; private WorkbasketMapper workbasketMapper;
private DistributionTargetMapper distributionTargetMapper; private DistributionTargetMapper distributionTargetMapper;
private ClassificationMapper classificationMapper; private ClassificationMapper classificationMapper;
private WorkbasketAccessMapper workbasketAccessMapper; private WorkbasketAccessMapper workbasketAccessMapper;
private ObjectReferenceMapper objectReferenceMapper; private ObjectReferenceMapper objectReferenceMapper;
private TaskServiceImpl taskServiceImpl; private TaskServiceImpl taskServiceImpl;
private WorkbasketServiceImpl workbasketServiceImpl; private WorkbasketServiceImpl workbasketServiceImpl;
public TaskanaEngineImpl(TaskanaEngineConfiguration taskanaEngineConfiguration) { public TaskanaEngineImpl(TaskanaEngineConfiguration taskanaEngineConfiguration) {
this.taskanaEngineConfiguration = taskanaEngineConfiguration; this.taskanaEngineConfiguration = taskanaEngineConfiguration;
createTransactionFactory(taskanaEngineConfiguration.getUseContainerManagedTransactions()); createTransactionFactory(taskanaEngineConfiguration.getUseContainerManagedTransactions());
this.session = createSqlSessionFactory().openSession(); this.session = createSqlSessionFactory().openSession();
this.taskMapper = session.getMapper(TaskMapper.class); this.taskMapper = session.getMapper(TaskMapper.class);
this.workbasketMapper = session.getMapper(WorkbasketMapper.class); this.workbasketMapper = session.getMapper(WorkbasketMapper.class);
this.distributionTargetMapper = session.getMapper(DistributionTargetMapper.class); this.distributionTargetMapper = session.getMapper(DistributionTargetMapper.class);
this.classificationMapper = session.getMapper(ClassificationMapper.class); this.classificationMapper = session.getMapper(ClassificationMapper.class);
this.workbasketAccessMapper = session.getMapper(WorkbasketAccessMapper.class); this.workbasketAccessMapper = session.getMapper(WorkbasketAccessMapper.class);
this.objectReferenceMapper = session.getMapper(ObjectReferenceMapper.class); this.objectReferenceMapper = session.getMapper(ObjectReferenceMapper.class);
} }
@Override @Override
public TaskService getTaskService() { public TaskService getTaskService() {
this.taskServiceImpl = new TaskServiceImpl(this, this.taskMapper, this.objectReferenceMapper); this.taskServiceImpl = new TaskServiceImpl(this, this.taskMapper, this.objectReferenceMapper);
return taskServiceImpl; return taskServiceImpl;
} }
@Override @Override
public WorkbasketService getWorkbasketService() { public WorkbasketService getWorkbasketService() {
this.workbasketServiceImpl = new WorkbasketServiceImpl(this, this.workbasketMapper, this.workbasketServiceImpl = new WorkbasketServiceImpl(this, this.workbasketMapper,
this.distributionTargetMapper, this.workbasketAccessMapper); this.distributionTargetMapper, this.workbasketAccessMapper);
return workbasketServiceImpl; return workbasketServiceImpl;
} }
@Override @Override
public ClassificationService getClassificationService() { public ClassificationService getClassificationService() {
return new ClassificationServiceImpl(this.classificationMapper); return new ClassificationServiceImpl(this.classificationMapper);
} }
@Override @Override
public TaskanaEngineConfiguration getConfiguration() { public TaskanaEngineConfiguration getConfiguration() {
return this.taskanaEngineConfiguration; return this.taskanaEngineConfiguration;
} }
/** /**
* Close session manually, to be done, if a JdbcTransactionFactory is used. * Close session manually, to be done, if a JdbcTransactionFactory is used.
* Perhaps it is better to separate the commit and the closing mechanism ... * Perhaps it is better to separate the commit and the closing mechanism ...
*/ */
public void closeSession() { public void closeSession() {
this.session.commit(); this.session.commit();
this.session.close(); this.session.close();
} }
/** /**
* This method creates the sqlSessionFactory of myBatis. It integrates all the * This method creates the sqlSessionFactory of myBatis. It integrates all the
* SQL mappers * SQL mappers
* * @return a {@link SqlSessionFactory}
* @return a {@link SqlSessionFactory} */
*/ private SqlSessionFactory createSqlSessionFactory() {
private SqlSessionFactory createSqlSessionFactory() { Environment environment = new Environment(DEFAULT, this.transactionFactory,
Environment environment = new Environment(DEFAULT, this.transactionFactory, taskanaEngineConfiguration.getDatasource());
taskanaEngineConfiguration.getDatasource()); Configuration configuration = new Configuration(environment);
Configuration configuration = new Configuration(environment); // add mappers
// add mappers configuration.addMapper(TaskMapper.class);
configuration.addMapper(TaskMapper.class); configuration.addMapper(WorkbasketMapper.class);
configuration.addMapper(WorkbasketMapper.class); configuration.addMapper(DistributionTargetMapper.class);
configuration.addMapper(DistributionTargetMapper.class); configuration.addMapper(ClassificationMapper.class);
configuration.addMapper(ClassificationMapper.class); configuration.addMapper(WorkbasketAccessMapper.class);
configuration.addMapper(WorkbasketAccessMapper.class); configuration.addMapper(ObjectReferenceMapper.class);
configuration.addMapper(ObjectReferenceMapper.class); return new SqlSessionFactoryBuilder().build(configuration);
return new SqlSessionFactoryBuilder().build(configuration); }
}
private void createTransactionFactory(boolean useContainerManagedTransactions) { private void createTransactionFactory(boolean useContainerManagedTransactions) {
if (useContainerManagedTransactions) { if (useContainerManagedTransactions) {
this.transactionFactory = new ManagedTransactionFactory(); this.transactionFactory = new ManagedTransactionFactory();
} else { } else {
this.transactionFactory = new JdbcTransactionFactory(); this.transactionFactory = new JdbcTransactionFactory();
} }
} }
} }

246
lib/taskana-core/src/main/java/org/taskana/impl/WorkbasketServiceImpl.java
View File

@ -17,150 +17,152 @@ import org.taskana.model.mappings.DistributionTargetMapper;
import org.taskana.model.mappings.WorkbasketAccessMapper; import org.taskana.model.mappings.WorkbasketAccessMapper;
import org.taskana.model.mappings.WorkbasketMapper; import org.taskana.model.mappings.WorkbasketMapper;
import org.taskana.security.CurrentUserContext; import org.taskana.security.CurrentUserContext;
/**
* This is the implementation of WorkbasketService.
*/
public class WorkbasketServiceImpl implements WorkbasketService { public class WorkbasketServiceImpl implements WorkbasketService {
private static final Logger logger = LoggerFactory.getLogger(WorkbasketServiceImpl.class); private static final Logger LOGGER = LoggerFactory.getLogger(WorkbasketServiceImpl.class);
private static final String ID_PREFIX_WORKBASKET = "WBI"; private static final String ID_PREFIX_WORKBASKET = "WBI";
private static final String ID_PREFIX_WORKBASKET_AUTHORIZATION = "WAI"; private static final String ID_PREFIX_WORKBASKET_AUTHORIZATION = "WAI";
private TaskanaEngine taskanaEngine; private TaskanaEngine taskanaEngine;
private WorkbasketMapper workbasketMapper; private WorkbasketMapper workbasketMapper;
private DistributionTargetMapper distributionTargetMapper; private DistributionTargetMapper distributionTargetMapper;
private WorkbasketAccessMapper workbasketAccessMapper; private WorkbasketAccessMapper workbasketAccessMapper;
public WorkbasketServiceImpl() { public WorkbasketServiceImpl() {
} }
public WorkbasketServiceImpl(TaskanaEngine taskanaEngine, WorkbasketMapper workbasketMapper, public WorkbasketServiceImpl(TaskanaEngine taskanaEngine, WorkbasketMapper workbasketMapper,
DistributionTargetMapper distributionTargetMapper, WorkbasketAccessMapper workbasketAccessMapper) { DistributionTargetMapper distributionTargetMapper, WorkbasketAccessMapper workbasketAccessMapper) {
this.taskanaEngine = taskanaEngine; this.taskanaEngine = taskanaEngine;
this.workbasketMapper = workbasketMapper; this.workbasketMapper = workbasketMapper;
this.distributionTargetMapper = distributionTargetMapper; this.distributionTargetMapper = distributionTargetMapper;
this.workbasketAccessMapper = workbasketAccessMapper; this.workbasketAccessMapper = workbasketAccessMapper;
} }
@Override @Override
public Workbasket getWorkbasket(String workbasketId) throws WorkbasketNotFoundException { public Workbasket getWorkbasket(String workbasketId) throws WorkbasketNotFoundException {
Workbasket workbasket = workbasketMapper.findById(workbasketId); Workbasket workbasket = workbasketMapper.findById(workbasketId);
if (workbasket == null) { if (workbasket == null) {
throw new WorkbasketNotFoundException(workbasketId); throw new WorkbasketNotFoundException(workbasketId);
} }
return workbasket; return workbasket;
} }
@Override @Override
public List<Workbasket> getWorkbaskets(List<WorkbasketAuthorization> permissions) { public List<Workbasket> getWorkbaskets(List<WorkbasketAuthorization> permissions) {
return workbasketMapper.findByPermission(permissions, CurrentUserContext.getUserid()); return workbasketMapper.findByPermission(permissions, CurrentUserContext.getUserid());
} }
@Override @Override
public List<Workbasket> getWorkbaskets() { public List<Workbasket> getWorkbaskets() {
return workbasketMapper.findAll(); return workbasketMapper.findAll();
} }
@Override @Override
public Workbasket createWorkbasket(Workbasket workbasket) { public Workbasket createWorkbasket(Workbasket workbasket) {
Timestamp now = new Timestamp(System.currentTimeMillis()); Timestamp now = new Timestamp(System.currentTimeMillis());
workbasket.setCreated(now); workbasket.setCreated(now);
workbasket.setModified(now); workbasket.setModified(now);
if (workbasket.getId() == null || workbasket.getId().isEmpty()) { if (workbasket.getId() == null || workbasket.getId().isEmpty()) {
workbasket.setId(IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET)); workbasket.setId(IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET));
} }
workbasketMapper.insert(workbasket); workbasketMapper.insert(workbasket);
logger.debug("Workbasket '{}' created", workbasket.getId()); LOGGER.debug("Workbasket '{}' created", workbasket.getId());
if (workbasket.getDistributionTargets() != null) { if (workbasket.getDistributionTargets() != null) {
for (Workbasket distributionTarget : workbasket.getDistributionTargets()) { for (Workbasket distributionTarget : workbasket.getDistributionTargets()) {
if (workbasketMapper.findById(distributionTarget.getId()) == null) { if (workbasketMapper.findById(distributionTarget.getId()) == null) {
distributionTarget.setCreated(now); distributionTarget.setCreated(now);
distributionTarget.setModified(now); distributionTarget.setModified(now);
workbasketMapper.insert(distributionTarget); workbasketMapper.insert(distributionTarget);
logger.debug("Workbasket '{}' created", distributionTarget.getId()); LOGGER.debug("Workbasket '{}' created", distributionTarget.getId());
} }
distributionTargetMapper.insert(workbasket.getId(), distributionTarget.getId()); distributionTargetMapper.insert(workbasket.getId(), distributionTarget.getId());
} }
} }
return workbasketMapper.findById(workbasket.getId()); return workbasketMapper.findById(workbasket.getId());
} }
@Override @Override
public Workbasket updateWorkbasket(Workbasket workbasket) throws NotAuthorizedException { public Workbasket updateWorkbasket(Workbasket workbasket) throws NotAuthorizedException {
workbasket.setModified(new Timestamp(System.currentTimeMillis())); workbasket.setModified(new Timestamp(System.currentTimeMillis()));
workbasketMapper.update(workbasket); workbasketMapper.update(workbasket);
List<String> oldDistributionTargets = distributionTargetMapper.findBySourceId(workbasket.getId()); List<String> oldDistributionTargets = distributionTargetMapper.findBySourceId(workbasket.getId());
List<Workbasket> distributionTargets = workbasket.getDistributionTargets(); List<Workbasket> distributionTargets = workbasket.getDistributionTargets();
for (Workbasket distributionTarget : distributionTargets) { for (Workbasket distributionTarget : distributionTargets) {
if (!oldDistributionTargets.contains(distributionTarget.getId())) { if (!oldDistributionTargets.contains(distributionTarget.getId())) {
if (workbasketMapper.findById(distributionTarget.getId()) == null) { if (workbasketMapper.findById(distributionTarget.getId()) == null) {
workbasketMapper.insert(distributionTarget); workbasketMapper.insert(distributionTarget);
logger.debug("Workbasket '{}' created", distributionTarget.getId()); LOGGER.debug("Workbasket '{}' created", distributionTarget.getId());
} }
distributionTargetMapper.insert(workbasket.getId(), distributionTarget.getId()); distributionTargetMapper.insert(workbasket.getId(), distributionTarget.getId());
} else { } else {
oldDistributionTargets.remove(distributionTarget.getId()); oldDistributionTargets.remove(distributionTarget.getId());
} }
} }
distributionTargetMapper.deleteMultiple(workbasket.getId(), oldDistributionTargets); distributionTargetMapper.deleteMultiple(workbasket.getId(), oldDistributionTargets);
logger.debug("Workbasket '{}' updated", workbasket.getId()); LOGGER.debug("Workbasket '{}' updated", workbasket.getId());
return workbasketMapper.findById(workbasket.getId()); return workbasketMapper.findById(workbasket.getId());
} }
@Override @Override
public WorkbasketAccessItem createWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem) { public WorkbasketAccessItem createWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem) {
workbasketAccessItem.setId(IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_AUTHORIZATION)); workbasketAccessItem.setId(IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_AUTHORIZATION));
workbasketAccessMapper.insert(workbasketAccessItem); workbasketAccessMapper.insert(workbasketAccessItem);
return workbasketAccessItem; return workbasketAccessItem;
} }
@Override @Override
public WorkbasketAccessItem getWorkbasketAuthorization(String id) { public WorkbasketAccessItem getWorkbasketAuthorization(String id) {
return workbasketAccessMapper.findById(id); return workbasketAccessMapper.findById(id);
} }
@Override @Override
public void deleteWorkbasketAuthorization(String id) { public void deleteWorkbasketAuthorization(String id) {
workbasketAccessMapper.delete(id); workbasketAccessMapper.delete(id);
} }
@Override @Override
public List<WorkbasketAccessItem> getAllAuthorizations() { public List<WorkbasketAccessItem> getAllAuthorizations() {
return workbasketAccessMapper.findAll(); return workbasketAccessMapper.findAll();
} }
@Override @Override
public void checkAuthorization(String workbasketId, WorkbasketAuthorization workbasketAuthorization) public void checkAuthorization(String workbasketId, WorkbasketAuthorization workbasketAuthorization)
throws NotAuthorizedException { throws NotAuthorizedException {
// Skip permission check is security is not enabled // Skip permission check is security is not enabled
if (!taskanaEngine.getConfiguration().isSecurityEnabled()) { if (!taskanaEngine.getConfiguration().isSecurityEnabled()) {
logger.debug("Skipping permissions check since security is disabled."); LOGGER.debug("Skipping permissions check since security is disabled.");
return; return;
} }
String userId = CurrentUserContext.getUserid(); String userId = CurrentUserContext.getUserid();
logger.debug("Verifying that {} has the permission {} on workbasket {}", userId, workbasketAuthorization.name(), LOGGER.debug("Verifying that {} has the permission {} on workbasket {}", userId, workbasketAuthorization.name(),
workbasketId); workbasketId);
List<WorkbasketAccessItem> accessItems = workbasketAccessMapper List<WorkbasketAccessItem> accessItems = workbasketAccessMapper
.findByWorkbasketAndUserAndAuthorization(workbasketId, userId, workbasketAuthorization.name()); .findByWorkbasketAndUserAndAuthorization(workbasketId, userId, workbasketAuthorization.name());
if (accessItems.size() <= 0) { if (accessItems.size() <= 0) {
throw new NotAuthorizedException("Not authorized. Authorization '" + workbasketAuthorization.name() throw new NotAuthorizedException("Not authorized. Authorization '" + workbasketAuthorization.name()
+ "' on workbasket '" + workbasketId + "' is needed."); + "' on workbasket '" + workbasketId + "' is needed.");
} }
} }
@Override @Override
public WorkbasketAccessItem updateWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem) { public WorkbasketAccessItem updateWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem) {
workbasketAccessMapper.update(workbasketAccessItem); workbasketAccessMapper.update(workbasketAccessItem);
return workbasketAccessItem; return workbasketAccessItem;
} }
@Override @Override
public List<WorkbasketAccessItem> getWorkbasketAuthorizations(String workbasketId) { public List<WorkbasketAccessItem> getWorkbasketAuthorizations(String workbasketId) {
return workbasketAccessMapper.findByWorkbasketId(workbasketId); return workbasketAccessMapper.findByWorkbasketId(workbasketId);
} }
} }

22
lib/taskana-core/src/main/java/org/taskana/impl/util/IdGenerator.java
View File

@ -2,12 +2,24 @@ package org.taskana.impl.util;
import java.util.UUID; 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() {
}
} }

176
lib/taskana-core/src/main/java/org/taskana/model/Classification.java
View File

@ -5,121 +5,121 @@ import java.util.ArrayList;
import java.util.List; import java.util.List;
/** /**
* Classification entity * Classification entity.
*/ */
public class Classification { public class Classification {
private String id; private String id;
private String tenantId; private String tenantId;
private String parentClassificationId; private String parentClassificationId;
private String category; private String category;
private String type; private String type;
private Date created; private Date created;
private Date modified; private Date modified;
private String name; private String name;
private String description; private String description;
private int priority; private int priority;
private String serviceLevel; //PddDThhHmmM private String serviceLevel; // PddDThhHmmM
private List<Classification> children = new ArrayList<>(); private List<Classification> children = new ArrayList<>();
public String getId() { public String getId() {
return id; return id;
} }
public void setId(String id) { public void setId(String id) {
this.id = id; this.id = id;
} }
public String getTenantId() { public String getTenantId() {
return tenantId; return tenantId;
} }
public void setTenantId(String tenantId) { public void setTenantId(String tenantId) {
this.tenantId = tenantId; this.tenantId = tenantId;
} }
public String getParentClassificationId() { public String getParentClassificationId() {
return parentClassificationId; return parentClassificationId;
} }
public void setParentClassificationId(String parentClassificationId) { public void setParentClassificationId(String parentClassificationId) {
this.parentClassificationId = parentClassificationId; this.parentClassificationId = parentClassificationId;
} }
public String getType() { public String getType() {
return type; return type;
} }
public void setType(String type) { public void setType(String type) {
this.type = type; this.type = type;
} }
public String getCategory() { public String getCategory() {
return category; return category;
} }
public void setCategory(String category) { public void setCategory(String category) {
this.category = category; this.category = category;
} }
public Date getCreated() { public Date getCreated() {
return created; return created;
} }
public void setCreated(Date created) { public void setCreated(Date created) {
this.created = created; this.created = created;
} }
public Date getModified() { public Date getModified() {
return modified; return modified;
} }
public void setModified(Date modified) { public void setModified(Date modified) {
this.modified = modified; this.modified = modified;
} }
public String getName() { public String getName() {
return name; return name;
} }
public void setName(String name) { public void setName(String name) {
this.name = name; this.name = name;
} }
public String getDescription() { public String getDescription() {
return description; return description;
} }
public void setDescription(String description) { public void setDescription(String description) {
this.description = description; this.description = description;
} }
public int getPriority() { public int getPriority() {
return priority; return priority;
} }
public void setPriority(int priority) { public void setPriority(int priority) {
this.priority = priority; this.priority = priority;
} }
public String getServiceLevel() { public String getServiceLevel() {
return serviceLevel; return serviceLevel;
} }
public void setServiceLevel(String serviceLevel) { public void setServiceLevel(String serviceLevel) {
this.serviceLevel = serviceLevel; this.serviceLevel = serviceLevel;
} }
public List<Classification> getChildren() { public List<Classification> getChildren() {
return children; return children;
} }
public void addChild(Classification child) { public void addChild(Classification child) {
children.add(child); children.add(child);
} }
public void setChildren(List<Classification> children) { public void setChildren(List<Classification> children) {
this.children = children; this.children = children;
} }
} }

44
lib/taskana-core/src/main/java/org/taskana/model/DueWorkbasketCounter.java
View File

@ -3,35 +3,35 @@ package org.taskana.model;
import java.sql.Date; import java.sql.Date;
/** /**
* DueWorkbasketCounter entity * DueWorkbasketCounter entity.
*/ */
public class DueWorkbasketCounter { public class DueWorkbasketCounter {
private Date due; private Date due;
private String workbasketId; private String workbasketId;
private long taskCounter; private long taskCounter;
public Date getDue() { public Date getDue() {
return due; return due;
} }
public void setDue(Date due) { public void setDue(Date due) {
this.due = due; this.due = due;
} }
public String getWorkbasketId() { public String getWorkbasketId() {
return workbasketId; return workbasketId;
} }
public void setWorkbasketId(String workbasketId) { public void setWorkbasketId(String workbasketId) {
this.workbasketId = workbasketId; this.workbasketId = workbasketId;
} }
public long getTaskCounter() { public long getTaskCounter() {
return taskCounter; return taskCounter;
} }
public void setTaskCounter(long taskCounter) { public void setTaskCounter(long taskCounter) {
this.taskCounter = taskCounter; this.taskCounter = taskCounter;
} }
} }

126
lib/taskana-core/src/main/java/org/taskana/model/ObjectReference.java
View File

@ -1,85 +1,85 @@
package org.taskana.model; package org.taskana.model;
/** /**
* ObjectReference entity * ObjectReference entity.
*/ */
public class ObjectReference { public class ObjectReference {
private String id; private String id;
private String tenantId; private String tenantId;
private String company; private String company;
private String system; private String system;
private String systemInstance; private String systemInstance;
private String type; private String type;
private String value; private String value;
public String getId() { public String getId() {
return id; return id;
} }
public void setId(String id) { public void setId(String id) {
this.id = id; this.id = id;
} }
public String getTenantId() { public String getTenantId() {
return tenantId; return tenantId;
} }
public void setTenantId(String tenantId) { public void setTenantId(String tenantId) {
this.tenantId = tenantId; this.tenantId = tenantId;
} }
public String getCompany() { public String getCompany() {
return company; return company;
} }
public void setCompany(String company) { public void setCompany(String company) {
this.company = company; this.company = company;
} }
public String getSystem() { public String getSystem() {
return system; return system;
} }
public void setSystem(String system) { public void setSystem(String system) {
this.system = system; this.system = system;
} }
public String getSystemInstance() { public String getSystemInstance() {
return systemInstance; return systemInstance;
} }
public void setSystemInstance(String systemInstance) { public void setSystemInstance(String systemInstance) {
this.systemInstance = systemInstance; this.systemInstance = systemInstance;
} }
public String getType() { public String getType() {
return type; return type;
} }
public void setType(String type) { public void setType(String type) {
this.type = type; this.type = type;
} }
public String getValue() { public String getValue() {
return value; return value;
} }
public void setValue(String value) { public void setValue(String value) {
this.value = value; this.value = value;
} }
@Override @Override
public String toString() { public String toString() {
StringBuffer sb = new StringBuffer(); StringBuffer sb = new StringBuffer();
sb.append("ObjectReference("); sb.append("ObjectReference(");
sb.append("id=" + id); sb.append("id=" + id);
sb.append(", tenantId=" + tenantId); sb.append(", tenantId=" + tenantId);
sb.append(", company=" + company); sb.append(", company=" + company);
sb.append(", system=" + system); sb.append(", system=" + system);
sb.append(", systemInstance=" + systemInstance); sb.append(", systemInstance=" + systemInstance);
sb.append(", type=" + type); sb.append(", type=" + type);
sb.append(", value=" + value); sb.append(", value=" + value);
return sb.toString(); return sb.toString();
} }
} }

302
lib/taskana-core/src/main/java/org/taskana/model/Task.java
View File

@ -3,195 +3,195 @@ package org.taskana.model;
import java.sql.Timestamp; import java.sql.Timestamp;
/** /**
* Task entity * Task entity.
*/ */
public class Task { public class Task {
private String id; private String id;
private String tenantId; private String tenantId;
private Timestamp created; private Timestamp created;
private Timestamp claimed; private Timestamp claimed;
private Timestamp completed; private Timestamp completed;
private Timestamp modified; private Timestamp modified;
private Timestamp planned; private Timestamp planned;
private Timestamp due; private Timestamp due;
private String name; private String name;
private String description; private String description;
private int priority; private int priority;
private TaskState state; private TaskState state;
private String type; private String type;
private String workbasketId; private String workbasketId;
private String owner; private String owner;
private ObjectReference primaryObjRef; private ObjectReference primaryObjRef;
private boolean isRead; private boolean isRead;
private boolean isTransferred; private boolean isTransferred;
public String getId() { public String getId() {
return id; return id;
} }
public void setId(String id) { public void setId(String id) {
this.id = id; this.id = id;
} }
public String getTenantId() { public String getTenantId() {
return tenantId; return tenantId;
} }
public void setTenantId(String tenantId) { public void setTenantId(String tenantId) {
this.tenantId = tenantId; this.tenantId = tenantId;
} }
public Timestamp getCreated() { public Timestamp getCreated() {
return created; return created;
} }
public void setCreated(Timestamp created) { public void setCreated(Timestamp created) {
this.created = created; this.created = created;
} }
public Timestamp getClaimed() { public Timestamp getClaimed() {
return claimed; return claimed;
} }
public void setClaimed(Timestamp claimed) { public void setClaimed(Timestamp claimed) {
this.claimed = claimed; this.claimed = claimed;
} }
public Timestamp getCompleted() { public Timestamp getCompleted() {
return completed; return completed;
} }
public void setCompleted(Timestamp completed) { public void setCompleted(Timestamp completed) {
this.completed = completed; this.completed = completed;
} }
public Timestamp getModified() { public Timestamp getModified() {
return modified; return modified;
} }
public void setModified(Timestamp modified) { public void setModified(Timestamp modified) {
this.modified = modified; this.modified = modified;
} }
public Timestamp getPlanned() { public Timestamp getPlanned() {
return planned; return planned;
} }
public void setPlanned(Timestamp planned) { public void setPlanned(Timestamp planned) {
this.planned = planned; this.planned = planned;
} }
public Timestamp getDue() { public Timestamp getDue() {
return due; return due;
} }
public void setDue(Timestamp due) { public void setDue(Timestamp due) {
this.due = due; this.due = due;
} }
public String getName() { public String getName() {
return name; return name;
} }
public void setName(String name) { public void setName(String name) {
this.name = name; this.name = name;
} }
public String getDescription() { public String getDescription() {
return description; return description;
} }
public void setDescription(String description) { public void setDescription(String description) {
this.description = description; this.description = description;
} }
public int getPriority() { public int getPriority() {
return priority; return priority;
} }
public void setPriority(int priority) { public void setPriority(int priority) {
this.priority = priority; this.priority = priority;
} }
public TaskState getState() { public TaskState getState() {
return state; return state;
} }
public void setState(TaskState state) { public void setState(TaskState state) {
this.state = state; this.state = state;
} }
public String getType() { public String getType() {
return type; return type;
} }
public void setType(String type) { public void setType(String type) {
this.type = type; this.type = type;
} }
public String getWorkbasketId() { public String getWorkbasketId() {
return workbasketId; return workbasketId;
} }
public void setWorkbasketId(String workbasketId) { public void setWorkbasketId(String workbasketId) {
this.workbasketId = workbasketId; this.workbasketId = workbasketId;
} }
public String getOwner() { public String getOwner() {
return owner; return owner;
} }
public void setOwner(String owner) { public void setOwner(String owner) {
this.owner = owner; this.owner = owner;
} }
public ObjectReference getPrimaryObjRef() { public ObjectReference getPrimaryObjRef() {
return primaryObjRef; return primaryObjRef;
} }
public void setPrimaryObjRef(ObjectReference primaryObjRef) { public void setPrimaryObjRef(ObjectReference primaryObjRef) {
this.primaryObjRef = primaryObjRef; this.primaryObjRef = primaryObjRef;
} }
public boolean isRead() { public boolean isRead() {
return isRead; return isRead;
} }
public void setRead(boolean isRead) { public void setRead(boolean isRead) {
this.isRead = isRead; this.isRead = isRead;
} }
public boolean isTransferred() { public boolean isTransferred() {
return isTransferred; return isTransferred;
} }
public void setTransferred(boolean isTransferred) { public void setTransferred(boolean isTransferred) {
this.isTransferred = isTransferred; this.isTransferred = isTransferred;
} }
public String toString() { public String toString() {
StringBuffer sb = new StringBuffer(); StringBuffer sb = new StringBuffer();
sb.append("TASK("); sb.append("TASK(");
sb.append("id=" + id); sb.append("id=" + id);
sb.append(", tenantId=" + tenantId); sb.append(", tenantId=" + tenantId);
sb.append(", created=" + created); sb.append(", created=" + created);
sb.append(", claimed=" + claimed); sb.append(", claimed=" + claimed);
sb.append(", completed=" + completed); sb.append(", completed=" + completed);
sb.append(", modified=" + modified); sb.append(", modified=" + modified);
sb.append(", planned=" + planned); sb.append(", planned=" + planned);
sb.append(", due=" + due); sb.append(", due=" + due);
sb.append(", name=" + name); sb.append(", name=" + name);
sb.append(", description=" + description); sb.append(", description=" + description);
sb.append(", priority=" + priority); sb.append(", priority=" + priority);
sb.append(", state=" + state); sb.append(", state=" + state);
sb.append(", type=" + type); sb.append(", type=" + type);
sb.append(", workbasketId=" + workbasketId); sb.append(", workbasketId=" + workbasketId);
sb.append(", owner=" + owner); sb.append(", owner=" + owner);
sb.append(", primaryObjRef=" + primaryObjRef); sb.append(", primaryObjRef=" + primaryObjRef);
sb.append(", isRead=" + isRead); sb.append(", isRead=" + isRead);
sb.append(", isTransferred=" + isTransferred); sb.append(", isTransferred=" + isTransferred);
sb.append(")"); sb.append(")");
return sb.toString(); return sb.toString();
} }
} }

4
lib/taskana-core/src/main/java/org/taskana/model/TaskState.java
View File

@ -1,8 +1,8 @@
package org.taskana.model; package org.taskana.model;
/** /**
* This enum contains all status of the tasks * This enum contains all status of the tasks.
*/ */
public enum TaskState { public enum TaskState {
READY, CLAIMED, COMPLETED READY, CLAIMED, COMPLETED
} }

30
lib/taskana-core/src/main/java/org/taskana/model/TaskStateCounter.java
View File

@ -1,26 +1,26 @@
package org.taskana.model; package org.taskana.model;
/** /**
* TaskStateCounter entity * TaskStateCounter entity.
*/ */
public class TaskStateCounter { public class TaskStateCounter {
private TaskState state; private TaskState state;
private long counter; private long counter;
public long getCounter() { public long getCounter() {
return counter; return counter;
} }
public void setCounter(long counter) { public void setCounter(long counter) {
this.counter = counter; this.counter = counter;
} }
public TaskState getState() { public TaskState getState() {
return state; return state;
} }
public void setState(TaskState state) { public void setState(TaskState state) {
this.state = state; this.state = state;
} }
} }

114
lib/taskana-core/src/main/java/org/taskana/model/Workbasket.java
View File

@ -5,80 +5,80 @@ import java.util.ArrayList;
import java.util.List; import java.util.List;
/** /**
* Workbasket entity * Workbasket entity.
*/ */
public class Workbasket { public class Workbasket {
private String id; private String id;
private String tenantId; private String tenantId;
private Timestamp created; private Timestamp created;
private Timestamp modified; private Timestamp modified;
private String name; private String name;
private String description; private String description;
private String owner; private String owner;
private List<Workbasket> distributionTargets = new ArrayList<>(); private List<Workbasket> distributionTargets = new ArrayList<>();
public String getId() { public String getId() {
return id; return id;
} }
public void setId(String id) { public void setId(String id) {
this.id = id; this.id = id;
} }
public String getTenantId() { public String getTenantId() {
return tenantId; return tenantId;
} }
public void setTenantId(String tenantId) { public void setTenantId(String tenantId) {
this.tenantId = tenantId; this.tenantId = tenantId;
} }
public Timestamp getCreated() { public Timestamp getCreated() {
return created; return created;
} }
public void setCreated(Timestamp created) { public void setCreated(Timestamp created) {
this.created = created; this.created = created;
} }
public Timestamp getModified() { public Timestamp getModified() {
return modified; return modified;
} }
public void setModified(Timestamp modified) { public void setModified(Timestamp modified) {
this.modified = modified; this.modified = modified;
} }
public String getName() { public String getName() {
return name; return name;
} }
public void setName(String name) { public void setName(String name) {
this.name = name; this.name = name;
} }
public String getDescription() { public String getDescription() {
return description; return description;
} }
public void setDescription(String description) { public void setDescription(String description) {
this.description = description; this.description = description;
} }
public String getOwner() { public String getOwner() {
return owner; return owner;
} }
public void setOwner(String owner) { public void setOwner(String owner) {
this.owner = owner; this.owner = owner;
} }
public List<Workbasket> getDistributionTargets() { public List<Workbasket> getDistributionTargets() {
return distributionTargets; return distributionTargets;
} }
public void setDistributionTargets(List<Workbasket> distributionTargets) { public void setDistributionTargets(List<Workbasket> distributionTargets) {
this.distributionTargets = distributionTargets; this.distributionTargets = distributionTargets;
} }
} }

128
lib/taskana-core/src/main/java/org/taskana/model/WorkbasketAccessItem.java
View File

@ -1,89 +1,89 @@
package org.taskana.model; package org.taskana.model;
/** /**
* WorkbasketAccessItem entity * WorkbasketAccessItem entity.
*/ */
public class WorkbasketAccessItem { public class WorkbasketAccessItem {
private String id; private String id;
private String workbasketId; private String workbasketId;
private String userId; private String userId;
private String groupId; private String groupId;
private boolean read; private boolean read;
private boolean open; private boolean open;
private boolean append; private boolean append;
private boolean transfer; private boolean transfer;
private boolean distribute; private boolean distribute;
public String getId() { public String getId() {
return id; return id;
} }
public void setId(String id) { public void setId(String id) {
this.id = id; this.id = id;
} }
public String getWorkbasketId() { public String getWorkbasketId() {
return workbasketId; return workbasketId;
} }
public void setWorkbasketId(String workbasketId) { public void setWorkbasketId(String workbasketId) {
this.workbasketId = workbasketId; this.workbasketId = workbasketId;
} }
public String getUserId() { public String getUserId() {
return userId; return userId;
} }
public void setUserId(String userId) { public void setUserId(String userId) {
this.userId = userId; this.userId = userId;
} }
public String getGroupId() { public String getGroupId() {
return groupId; return groupId;
} }
public void setGroupId(String groupId) { public void setGroupId(String groupId) {
this.groupId = groupId; this.groupId = groupId;
} }
public boolean isRead() { public boolean isRead() {
return read; return read;
} }
public void setRead(boolean read) { public void setRead(boolean read) {
this.read = read; this.read = read;
} }
public boolean isOpen() { public boolean isOpen() {
return open; return open;
} }
public void setOpen(boolean open) { public void setOpen(boolean open) {
this.open = open; this.open = open;
} }
public boolean isAppend() { public boolean isAppend() {
return append; return append;
} }
public void setAppend(boolean append) { public void setAppend(boolean append) {
this.append = append; this.append = append;
} }
public boolean isTransfer() { public boolean isTransfer() {
return transfer; return transfer;
} }
public void setTransfer(boolean transfer) { public void setTransfer(boolean transfer) {
this.transfer = transfer; this.transfer = transfer;
} }
public boolean isDistribute() { public boolean isDistribute() {
return distribute; return distribute;
} }
public void setDistribute(boolean distribute) { public void setDistribute(boolean distribute) {
this.distribute = distribute; this.distribute = distribute;
} }
} }

2
lib/taskana-core/src/main/java/org/taskana/model/WorkbasketAuthorization.java
View File

@ -4,5 +4,5 @@ package org.taskana.model;
* This enum contains all permission values for the workbaskets. * This enum contains all permission values for the workbaskets.
*/ */
public enum WorkbasketAuthorization { public enum WorkbasketAuthorization {
READ, OPEN, APPEND, TRANSFER, DISTRIBUTE READ, OPEN, APPEND, TRANSFER, DISTRIBUTE
} }

47
lib/taskana-core/src/main/java/org/taskana/model/mappings/ClassificationMapper.java
View File

@ -5,33 +5,34 @@ import org.taskana.model.Classification;
import java.util.List; import java.util.List;
/**
* This class is the mybatis mapping of classifications.
*/
public interface ClassificationMapper { public interface ClassificationMapper {
@Select("SELECT * FROM CLASSIFICATION ORDER BY ID") @Select("SELECT * FROM CLASSIFICATION ORDER BY ID")
@Results({ @Results({ @Result(property = "id", column = "ID"),
@Result(property="id", column="ID"), @Result(property = "tenantId", column = "TENANT_ID"),
@Result(property="tenantId", column="TENANT_ID"), @Result(property = "parentClassificationId", column = "PARENT_CLASSIFICATION_ID"),
@Result(property="parentClassificationId", column="PARENT_CLASSIFICATION_ID"), @Result(property = "category", column = "CATEGORY"),
@Result(property="category", column="CATEGORY"), @Result(property = "type", column = "TYPE"),
@Result(property="type", column="TYPE"), @Result(property = "created", column = "CREATED"),
@Result(property="created", column="CREATED"), @Result(property = "modified", column = "MODIFIED"),
@Result(property="modified", column="MODIFIED"), @Result(property = "name", column = "NAME"),
@Result(property="name", column="NAME"), @Result(property = "description", column = "DESCRIPTION"),
@Result(property="description", column="DESCRIPTION"), @Result(property = "priority", column = "PRIORITY"),
@Result(property="priority", column="PRIORITY"), @Result(property = "serviceLevel", column = "SERVICE_LEVEL") })
@Result(property="serviceLevel", column="SERVICE_LEVEL") List<Classification> findAll();
})
List<Classification> findAll();
@Select("SELECT * FROM CLASSIFICATION WHERE PARENT_CLASSIFICATION_ID = #{parentClassificationId} ORDER BY ID") @Select("SELECT * FROM CLASSIFICATION WHERE PARENT_CLASSIFICATION_ID = #{parentClassificationId} ORDER BY ID")
List<Classification> findByParentId(@Param("parentClassificationId") String parentId); List<Classification> findByParentId(@Param("parentClassificationId") String parentId);
@Select("SELECT * FROM CLASSIFICATION WHERE ID = #{classificationId}") @Select("SELECT * FROM CLASSIFICATION WHERE ID = #{classificationId}")
Classification findById(@Param("classificationId") String 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})") @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); 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}") @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); void update(@Param("classification") Classification classification);
} }

20
lib/taskana-core/src/main/java/org/taskana/model/mappings/DistributionTargetMapper.java
View File

@ -6,18 +6,20 @@ import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert; import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select; import org.apache.ibatis.annotations.Select;
/**
* This class is the mybatis mapping of distribution targets.
*/
public interface DistributionTargetMapper { public interface DistributionTargetMapper {
@Insert("INSERT INTO DISTRIBUTION_TARGETS (SOURCE_ID, TARGET_ID) VALUES (#{sourceId}, #{targetId})") @Insert("INSERT INTO DISTRIBUTION_TARGETS (SOURCE_ID, TARGET_ID) VALUES (#{sourceId}, #{targetId})")
void insert(@Param("sourceId") String sourceId, @Param("targetId") String targetId); void insert(@Param("sourceId") String sourceId, @Param("targetId") String targetId);
@Delete("DELETE FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{sourceId} AND TARGET_ID = #{targetId}") @Delete("DELETE FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{sourceId} AND TARGET_ID = #{targetId}")
void delete(@Param("sourceId") String sourceId, @Param("targetId") String targetId); void delete(@Param("sourceId") String sourceId, @Param("targetId") String targetId);
@Select("SELECT TARGET_ID FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{sourceId}") @Select("SELECT TARGET_ID FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{sourceId}")
List<String> findBySourceId(@Param("sourceId") String sourceId); List<String> findBySourceId(@Param("sourceId") String sourceId);
@Delete("<script>DELETE FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{sourceId} AND TARGET_ID IN (<foreach item='target' collection='targetId' separator=',' > #{target} </foreach>)</script>") @Delete("<script>DELETE FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{sourceId} AND TARGET_ID IN (<foreach item='target' collection='targetId' separator=',' > #{target} </foreach>)</script>")
void deleteMultiple(@Param("sourceId") String sourceId, @Param("targetId") List<String> targetId); void deleteMultiple(@Param("sourceId") String sourceId, @Param("targetId") List<String> targetId);
} }

101
lib/taskana-core/src/main/java/org/taskana/model/mappings/ObjectReferenceMapper.java
View File

@ -10,62 +10,61 @@ import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select; import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update; import org.apache.ibatis.annotations.Update;
import org.taskana.model.ObjectReference; import org.taskana.model.ObjectReference;
/**
* This class is the mybatis mapping of ObjectReference.
*/
public interface ObjectReferenceMapper { public interface ObjectReferenceMapper {
@Select("SELECT ID, TENANT_ID, COMPANY, SYSTEM, SYSTEM_INSTANCE, TYPE, VALUE " @Select("SELECT ID, TENANT_ID, COMPANY, SYSTEM, SYSTEM_INSTANCE, TYPE, VALUE "
+ "FROM OBJECT_REFERENCE " + "FROM OBJECT_REFERENCE "
+ "ORDER BY ID") + "ORDER BY ID")
@Results({ @Results({
@Result(property="id", column="ID"), @Result(property = "id", column = "ID"),
@Result(property="tenantId", column="TENANT_ID"), @Result(property = "tenantId", column = "TENANT_ID"),
@Result(property="company", column="COMPANY"), @Result(property = "company", column = "COMPANY"),
@Result(property="system", column="SYSTEM"), @Result(property = "system", column = "SYSTEM"),
@Result(property="systemInstance", column="SYSTEM_INSTANCE"), @Result(property = "systemInstance", column = "SYSTEM_INSTANCE"),
@Result(property="type", column="TYPE"), @Result(property = "type", column = "TYPE"),
@Result(property="value", column="VALUE") @Result(property = "value", column = "VALUE") })
}) List<ObjectReference> findAll();
List<ObjectReference> findAll();
@Select("SELECT ID, TENANT_ID, COMPANY, SYSTEM, SYSTEM_INSTANCE, TYPE, VALUE " @Select("SELECT ID, TENANT_ID, COMPANY, SYSTEM, SYSTEM_INSTANCE, TYPE, VALUE "
+ "FROM OBJECT_REFERENCE " + "FROM OBJECT_REFERENCE "
+ "WHERE ID = #{id}") + "WHERE ID = #{id}")
@Results({ @Results({
@Result(property="id", column="ID"), @Result(property = "id", column = "ID"),
@Result(property="tenantId", column="TENANT_ID"), @Result(property = "tenantId", column = "TENANT_ID"),
@Result(property="company", column="COMPANY"), @Result(property = "company", column = "COMPANY"),
@Result(property="system", column="SYSTEM"), @Result(property = "system", column = "SYSTEM"),
@Result(property="systemInstance", column="SYSTEM_INSTANCE"), @Result(property = "systemInstance", column = "SYSTEM_INSTANCE"),
@Result(property="type", column="TYPE"), @Result(property = "type", column = "TYPE"),
@Result(property="value", column="VALUE") @Result(property = "value", column = "VALUE") })
}) ObjectReference findById(@Param("id") String id);
ObjectReference findById(@Param("id") String id);
@Select("SELECT ID, TENANT_ID, COMPANY, SYSTEM, SYSTEM_INSTANCE, TYPE, VALUE " @Select("SELECT ID, TENANT_ID, COMPANY, SYSTEM, SYSTEM_INSTANCE, TYPE, VALUE "
+ "FROM OBJECT_REFERENCE " + "FROM OBJECT_REFERENCE "
+ "WHERE TENANT_ID = #{objectReference.tenantId} " + "WHERE TENANT_ID = #{objectReference.tenantId} "
+ "AND COMPANY = #{objectReference.company} " + "AND COMPANY = #{objectReference.company} "
+ "AND SYSTEM = #{objectReference.system} " + "AND SYSTEM = #{objectReference.system} "
+ "AND SYSTEM_INSTANCE = #{objectReference.systemInstance} " + "AND SYSTEM_INSTANCE = #{objectReference.systemInstance} "
+ "AND TYPE = #{objectReference.type} " + "AND TYPE = #{objectReference.type} "
+ "AND VALUE = #{objectReference.value}") + "AND VALUE = #{objectReference.value}")
@Results({ @Results({
@Result(property="id", column="ID"), @Result(property = "id", column = "ID"),
@Result(property="tenantId", column="TENANT_ID"), @Result(property = "tenantId", column = "TENANT_ID"),
@Result(property="company", column="COMPANY"), @Result(property = "company", column = "COMPANY"),
@Result(property="system", column="SYSTEM"), @Result(property = "system", column = "SYSTEM"),
@Result(property="systemInstance", column="SYSTEM_INSTANCE"), @Result(property = "systemInstance", column = "SYSTEM_INSTANCE"),
@Result(property="type", column="TYPE"), @Result(property = "type", column = "TYPE"),
@Result(property="value", column="VALUE") @Result(property = "value", column = "VALUE") })
}) ObjectReference findByObjectReference(@Param("objectReference") ObjectReference objectReference);
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})") @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); 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}") @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); void update(@Param("ref") ObjectReference ref);
@Delete("DELETE FROM OBJECT_REFERENCE WHERE ID = #{id}") @Delete("DELETE FROM OBJECT_REFERENCE WHERE ID = #{id}")
void delete(String id); void delete(String id);
} }

145
lib/taskana-core/src/main/java/org/taskana/model/mappings/TaskMapper.java
View File

@ -17,12 +17,13 @@ import org.taskana.model.ObjectReference;
import org.taskana.model.Task; import org.taskana.model.Task;
import org.taskana.model.TaskState; import org.taskana.model.TaskState;
import org.taskana.model.TaskStateCounter; import org.taskana.model.TaskStateCounter;
/**
* This class is the mybatis mapping of task.
*/
public interface TaskMapper { 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 " @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 " + "FROM TASK " + "WHERE ID = #{id}")
+ "WHERE ID = #{id}")
@Results(value = { @Results(value = {
@Result(property = "id", column = "ID"), @Result(property = "id", column = "ID"),
@Result(property = "tenantId", column = "TENANT_ID"), @Result(property = "tenantId", column = "TENANT_ID"),
@ -39,15 +40,13 @@ public interface TaskMapper {
@Result(property = "type", column = "TYPE"), @Result(property = "type", column = "TYPE"),
@Result(property = "workbasketId", column = "WORKBASKETID"), @Result(property = "workbasketId", column = "WORKBASKETID"),
@Result(property = "owner", column = "OWNER"), @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 = "isRead", column = "IS_READ"),
@Result(property = "isTransferred", column = "IS_TRANSFERRED")}) @Result(property = "isTransferred", column = "IS_TRANSFERRED") })
Task findById(@Param("id") String id); 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 " @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 " + "FROM TASK " + "WHERE WORKBASKETID = #{workbasketId} " + "ORDER BY ID")
+ "WHERE WORKBASKETID = #{workbasketId} "
+ "ORDER BY ID")
@Results(value = { @Results(value = {
@Result(property = "id", column = "ID"), @Result(property = "id", column = "ID"),
@Result(property = "tenantId", column = "TENANT_ID"), @Result(property = "tenantId", column = "TENANT_ID"),
@ -64,18 +63,17 @@ public interface TaskMapper {
@Result(property = "type", column = "TYPE"), @Result(property = "type", column = "TYPE"),
@Result(property = "workbasketId", column = "WORKBASKETID"), @Result(property = "workbasketId", column = "WORKBASKETID"),
@Result(property = "owner", column = "OWNER"), @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 = "isRead", column = "IS_READ"),
@Result(property = "isTransferred", column = "IS_TRANSFERRED")}) @Result(property = "isTransferred", column = "IS_TRANSFERRED") })
List<Task> findByWorkBasketId(@Param("workbasketId") String workbasketId); List<Task> findByWorkBasketId(@Param("workbasketId") String workbasketId);
@Select("<script>" @Select("<script>"
+ "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 " + "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 " + "FROM TASK "
+ "WHERE WORKBASKETID IN (<foreach item='item' collection='workbasketIds' separator=','>#{item}</foreach>) " + "WHERE WORKBASKETID IN (<foreach item='item' collection='workbasketIds' separator=','>#{item}</foreach>) "
+ "AND STATE IN (<foreach item='item' collection='states' separator=',' >#{item}</foreach>) " + "AND STATE IN (<foreach item='item' collection='states' separator=',' >#{item}</foreach>) "
+ "ORDER BY ID" + "ORDER BY ID" + "</script>")
+ "</script>")
@Results(value = { @Results(value = {
@Result(property = "id", column = "ID"), @Result(property = "id", column = "ID"),
@Result(property = "tenantId", column = "TENANT_ID"), @Result(property = "tenantId", column = "TENANT_ID"),
@ -92,10 +90,10 @@ public interface TaskMapper {
@Result(property = "type", column = "TYPE"), @Result(property = "type", column = "TYPE"),
@Result(property = "workbasketId", column = "WORKBASKETID"), @Result(property = "workbasketId", column = "WORKBASKETID"),
@Result(property = "owner", column = "OWNER"), @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 = "isRead", column = "IS_READ"),
@Result(property = "isTransferred", column = "IS_TRANSFERRED")}) @Result(property = "isTransferred", column = "IS_TRANSFERRED") })
List<Task> findByWorkbasketIdsAndStates(@Param("workbasketIds") List<String> workbasketIds, @Param("states") List<TaskState> states); List<Task> findByWorkbasketIdsAndStates(@Param("workbasketIds") List<String> workbasketIds, @Param("states") List<TaskState> states);
@Select("<script>" @Select("<script>"
+ "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 " + "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 "
@ -119,78 +117,65 @@ public interface TaskMapper {
@Result(property = "type", column = "TYPE"), @Result(property = "type", column = "TYPE"),
@Result(property = "workbasketId", column = "WORKBASKETID"), @Result(property = "workbasketId", column = "WORKBASKETID"),
@Result(property = "owner", column = "OWNER"), @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 = "isRead", column = "IS_READ"),
@Result(property = "isTransferred", column = "IS_TRANSFERRED")}) @Result(property = "isTransferred", column = "IS_TRANSFERRED") })
List<Task> findByStates(@Param("states") List<TaskState> states); List<Task> findByStates(@Param("states") List<TaskState> 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 " @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 ") + "FROM TASK ")
@Results(value = { @Results(value = { @Result(property = "id", column = "ID"), @Result(property = "tenantId", column = "TENANT_ID"),
@Result(property = "id", column = "ID"), @Result(property = "created", column = "CREATED"), @Result(property = "claimed", column = "CLAIMED"),
@Result(property = "tenantId", column = "TENANT_ID"), @Result(property = "completed", column = "COMPLETED"), @Result(property = "modified", column = "MODIFIED"),
@Result(property = "created", column = "CREATED"), @Result(property = "planned", column = "PLANNED"), @Result(property = "due", column = "DUE"),
@Result(property = "claimed", column = "CLAIMED"), @Result(property = "name", column = "NAME"), @Result(property = "description", column = "DESCRIPTION"),
@Result(property = "completed", column = "COMPLETED"), @Result(property = "priority", column = "PRIORITY"), @Result(property = "state", column = "STATE"),
@Result(property = "modified", column = "MODIFIED"), @Result(property = "type", column = "TYPE"), @Result(property = "workbasketId", column = "WORKBASKETID"),
@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 = "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 = "isRead", column = "IS_READ"),
@Result(property = "isTransferred", column = "IS_TRANSFERRED")}) @Result(property = "isTransferred", column = "IS_TRANSFERRED") })
List<Task> findAll(); List<Task> findAll();
@Select("<script>" @Select("<script>"
+ "SELECT STATE, COUNT (STATE) as counter " + "SELECT STATE, COUNT (STATE) as counter "
+ "FROM TASK " + "FROM TASK "
+ "WHERE STATE IN (<foreach collection='status' item='state' separator=','>#{state}</foreach>) " + "WHERE STATE IN (<foreach collection='status' item='state' separator=','>#{state}</foreach>) "
+ "GROUP BY STATE" + "GROUP BY STATE"
+ "</script>") + "</script>")
@Results({ @Results({ @Result(column = "STATE", property = "state"), @Result(column = "counter", property = "counter") })
@Result(column="STATE", property="state"), List<TaskStateCounter> getTaskCountForState(@Param("status") List<TaskState> status);
@Result(column="counter", property="counter")
})
List<TaskStateCounter> getTaskCountForState(@Param("status") List<TaskState> status);
@Select("<script>" @Select("<script>"
+ "SELECT COUNT (*) " + "SELECT COUNT (*) "
+ "FROM TASK " + "FROM TASK "
+ "WHERE WORKBASKETID = #{workbasketId} " + "WHERE WORKBASKETID = #{workbasketId} "
+ "AND DUE >= #{fromDate} " + "AND DUE >= #{fromDate} "
+ "AND STATE IN (<foreach collection='status' item='state' separator=','>#{state}</foreach>)" + "AND STATE IN (<foreach collection='status' item='state' separator=','>#{state}</foreach>)"
+ "</script>") + "</script>")
long getTaskCountForWorkbasketByDaysInPastAndState(@Param("workbasketId")String workbasketId, @Param("fromDate") Date fromDate, @Param("status") List<TaskState> states); long getTaskCountForWorkbasketByDaysInPastAndState(@Param("workbasketId") String workbasketId, @Param("fromDate") Date fromDate, @Param("status") List<TaskState> states);
@Select("<script>" @Select("<script>"
+ "SELECT CAST(DUE AS DATE) as DUE_DATE, WORKBASKETID, COUNT (*) as counter " + "SELECT CAST(DUE AS DATE) as DUE_DATE, WORKBASKETID, COUNT (*) as counter "
+ "FROM TASK " + "FROM TASK "
+ "WHERE DUE >= #{fromDate} " + "WHERE DUE >= #{fromDate} "
+ "AND STATE IN (<foreach collection='status' item='state' separator=','>#{state}</foreach>) " + "AND STATE IN (<foreach collection='status' item='state' separator=','>#{state}</foreach>) "
+ "GROUP BY DUE_DATE, WORKBASKETID" + "GROUP BY DUE_DATE, WORKBASKETID"
+ "</script>") + "</script>")
@Results({ @Results({ @Result(column = "DUE_DATE", property = "due"),
@Result(column="DUE_DATE", property="due"), @Result(column = "WORKBASKETID", property = "workbasketId"),
@Result(column="WORKBASKETID", property="workbasketId"), @Result(column = "counter", property = "taskCounter") })
@Result(column="counter", property="taskCounter") List<DueWorkbasketCounter> getTaskCountByWorkbasketIdAndDaysInPastAndState(@Param("fromDate") Date fromDate, @Param("status") List<TaskState> states);
})
List<DueWorkbasketCounter> getTaskCountByWorkbasketIdAndDaysInPastAndState(@Param("fromDate") Date fromDate, @Param("status") List<TaskState> 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) " @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})") + "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") @Options(keyProperty = "id", keyColumn = "ID")
void insert(Task task); 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}") @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); void update(Task task);
@Delete("DELETE FROM TASK WHERE ID = #{id}") @Delete("DELETE FROM TASK WHERE ID = #{id}")
void delete(String id); void delete(String id);
} }

34
lib/taskana-core/src/main/java/org/taskana/model/mappings/WorkbasketAccessMapper.java
View File

@ -11,7 +11,9 @@ import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select; import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update; import org.apache.ibatis.annotations.Update;
import org.taskana.model.WorkbasketAccessItem; import org.taskana.model.WorkbasketAccessItem;
/**
* This class is the mybatis mapping of workbasket access items.
*/
public interface WorkbasketAccessMapper { public interface WorkbasketAccessMapper {
@Select("SELECT ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE FROM WORKBASKET_ACCESS_LIST WHERE ID = #{id}") @Select("SELECT ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE FROM WORKBASKET_ACCESS_LIST WHERE ID = #{id}")
@ -24,7 +26,7 @@ public interface WorkbasketAccessMapper {
@Result(property = "open", column = "OPEN"), @Result(property = "open", column = "OPEN"),
@Result(property = "append", column = "APPEND"), @Result(property = "append", column = "APPEND"),
@Result(property = "transfer", column = "TRANSFER"), @Result(property = "transfer", column = "TRANSFER"),
@Result(property = "distribute", column = "DISTRIBUTE")}) @Result(property = "distribute", column = "DISTRIBUTE") })
WorkbasketAccessItem findById(@Param("id") String id); 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}") @Select("SELECT ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE FROM WORKBASKET_ACCESS_LIST WHERE USER_ID = #{userId}")
@ -37,7 +39,7 @@ public interface WorkbasketAccessMapper {
@Result(property = "open", column = "OPEN"), @Result(property = "open", column = "OPEN"),
@Result(property = "append", column = "APPEND"), @Result(property = "append", column = "APPEND"),
@Result(property = "transfer", column = "TRANSFER"), @Result(property = "transfer", column = "TRANSFER"),
@Result(property = "distribute", column = "DISTRIBUTE")}) @Result(property = "distribute", column = "DISTRIBUTE") })
List<WorkbasketAccessItem> findByUserId(@Param("userId") String userId); List<WorkbasketAccessItem> 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}") @Select("SELECT ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE FROM WORKBASKET_ACCESS_LIST WHERE WORKBASKET_ID = #{id}")
@ -50,7 +52,7 @@ public interface WorkbasketAccessMapper {
@Result(property = "open", column = "OPEN"), @Result(property = "open", column = "OPEN"),
@Result(property = "append", column = "APPEND"), @Result(property = "append", column = "APPEND"),
@Result(property = "transfer", column = "TRANSFER"), @Result(property = "transfer", column = "TRANSFER"),
@Result(property = "distribute", column = "DISTRIBUTE")}) @Result(property = "distribute", column = "DISTRIBUTE") })
List<WorkbasketAccessItem> findByWorkbasketId(@Param("id") String id); List<WorkbasketAccessItem> 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") @Select("SELECT ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE FROM WORKBASKET_ACCESS_LIST ORDER BY ID")
@ -63,12 +65,12 @@ public interface WorkbasketAccessMapper {
@Result(property = "open", column = "OPEN"), @Result(property = "open", column = "OPEN"),
@Result(property = "append", column = "APPEND"), @Result(property = "append", column = "APPEND"),
@Result(property = "transfer", column = "TRANSFER"), @Result(property = "transfer", column = "TRANSFER"),
@Result(property = "distribute", column = "DISTRIBUTE")}) @Result(property = "distribute", column = "DISTRIBUTE") })
List<WorkbasketAccessItem> findAll(); List<WorkbasketAccessItem> findAll();
@Insert("INSERT INTO WORKBASKET_ACCESS_LIST (ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE) " @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})") + "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); 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} " @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} "
@ -79,14 +81,14 @@ public interface WorkbasketAccessMapper {
void delete(@Param("id") String id); void delete(@Param("id") String id);
@Select("<script>SELECT ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE " @Select("<script>SELECT ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE "
+ "FROM WORKBASKET_ACCESS_LIST " + "FROM WORKBASKET_ACCESS_LIST "
+ "WHERE WORKBASKET_ID = #{workbasketId} " + "WHERE WORKBASKET_ID = #{workbasketId} "
+ "AND USER_ID = #{userId} " + "AND USER_ID = #{userId} "
+ "AND <if test=\"authorization == 'OPEN'\">OPEN</if>" + "AND <if test=\"authorization == 'OPEN'\">OPEN</if>"
+ "<if test=\"authorization == 'READ'\">READ</if>" + "<if test=\"authorization == 'READ'\">READ</if>"
+ "<if test=\"authorization == 'APPEND'\">APPEND</if>" + "<if test=\"authorization == 'APPEND'\">APPEND</if>"
+ "<if test=\"authorization == 'TRANSFER'\">TRANSFER</if>" + "<if test=\"authorization == 'TRANSFER'\">TRANSFER</if>"
+ "<if test=\"authorization == 'DISTRIBUTE'\">DISTRIBUTE</if> = 1</script>") + "<if test=\"authorization == 'DISTRIBUTE'\">DISTRIBUTE</if> = 1</script>")
@Results(value = { @Results(value = {
@Result(property = "id", column = "ID"), @Result(property = "id", column = "ID"),
@Result(property = "workbasketId", column = "WORKBASKET_ID"), @Result(property = "workbasketId", column = "WORKBASKET_ID"),
@ -96,7 +98,7 @@ public interface WorkbasketAccessMapper {
@Result(property = "open", column = "OPEN"), @Result(property = "open", column = "OPEN"),
@Result(property = "append", column = "APPEND"), @Result(property = "append", column = "APPEND"),
@Result(property = "transfer", column = "TRANSFER"), @Result(property = "transfer", column = "TRANSFER"),
@Result(property = "distribute", column = "DISTRIBUTE")}) @Result(property = "distribute", column = "DISTRIBUTE") })
List<WorkbasketAccessItem> findByWorkbasketAndUserAndAuthorization(@Param("workbasketId") String workbasketId, @Param("userId") String userId, @Param("authorization") String authorization); List<WorkbasketAccessItem> 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}") @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}")
@ -109,6 +111,6 @@ public interface WorkbasketAccessMapper {
@Result(property = "open", column = "OPEN"), @Result(property = "open", column = "OPEN"),
@Result(property = "append", column = "APPEND"), @Result(property = "append", column = "APPEND"),
@Result(property = "transfer", column = "TRANSFER"), @Result(property = "transfer", column = "TRANSFER"),
@Result(property = "distribute", column = "DISTRIBUTE")}) @Result(property = "distribute", column = "DISTRIBUTE") })
List<WorkbasketAccessItem> findByWorkbasketAndGroup(@Param("workbasketId") String workbasketId, @Param("groupId") String groupId); List<WorkbasketAccessItem> findByWorkbasketAndGroup(@Param("workbasketId") String workbasketId, @Param("groupId") String groupId);
} }

122
lib/taskana-core/src/main/java/org/taskana/model/mappings/WorkbasketMapper.java
View File

@ -14,74 +14,74 @@ import org.apache.ibatis.annotations.Update;
import org.apache.ibatis.mapping.FetchType; import org.apache.ibatis.mapping.FetchType;
import org.taskana.model.Workbasket; import org.taskana.model.Workbasket;
import org.taskana.model.WorkbasketAuthorization; import org.taskana.model.WorkbasketAuthorization;
/**
* This class is the mybatis mapping of workbaskets.
*/
public interface WorkbasketMapper { public interface WorkbasketMapper {
@Select("SELECT ID, TENANT_ID, CREATED, MODIFIED, NAME, DESCRIPTION, OWNER FROM WORKBASKET WHERE ID = #{id}") @Select("SELECT ID, TENANT_ID, CREATED, MODIFIED, NAME, DESCRIPTION, OWNER FROM WORKBASKET WHERE ID = #{id}")
@Results(value = { @Results(value = { @Result(property = "id", column = "ID"),
@Result(property = "id", column = "ID"), @Result(property = "tenantId", column = "TENANT_ID"),
@Result(property = "tenantId", column = "TENANT_ID"), @Result(property = "created", column = "CREATED"),
@Result(property = "created", column = "CREATED"), @Result(property = "modified", column = "MODIFIED"),
@Result(property = "modified", column = "MODIFIED"), @Result(property = "name", column = "NAME"),
@Result(property = "name", column = "NAME"), @Result(property = "description", column = "DESCRIPTION"),
@Result(property = "description", column = "DESCRIPTION"), @Result(property = "owner", column = "OWNER"),
@Result(property = "owner", column = "OWNER"), @Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")) })
@Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select="findByDistributionTargets")) }) Workbasket findById(@Param("id") String id);
public Workbasket findById(@Param("id") String id);
@Select("SELECT * FROM WORKBASKET WHERE id IN (SELECT TARGET_ID FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{id})") @Select("SELECT * FROM WORKBASKET WHERE id IN (SELECT TARGET_ID FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{id})")
@Results(value = { @Results(value = {
@Result(property = "id", column = "ID"), @Result(property = "id", column = "ID"),
@Result(property = "tenantId", column = "TENANT_ID"), @Result(property = "tenantId", column = "TENANT_ID"),
@Result(property = "created", column = "CREATED"), @Result(property = "created", column = "CREATED"),
@Result(property = "modified", column = "MODIFIED"), @Result(property = "modified", column = "MODIFIED"),
@Result(property = "name", column = "NAME"), @Result(property = "name", column = "NAME"),
@Result(property = "description", column = "DESCRIPTION"), @Result(property = "description", column = "DESCRIPTION"),
@Result(property = "owner", column = "OWNER"), @Result(property = "owner", column = "OWNER"),
@Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select="findByDistributionTargets")) }) @Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")) })
public List<Workbasket> findByDistributionTargets(@Param("id") String id); List<Workbasket> findByDistributionTargets(@Param("id") String id);
@Select("SELECT * FROM WORKBASKET ORDER BY id") @Select("SELECT * FROM WORKBASKET ORDER BY id")
@Results(value = { @Results(value = {
@Result(property = "id", column = "ID"), @Result(property = "id", column = "ID"),
@Result(property = "tenantId", column = "TENANT_ID"), @Result(property = "tenantId", column = "TENANT_ID"),
@Result(property = "created", column = "CREATED"), @Result(property = "created", column = "CREATED"),
@Result(property = "modified", column = "MODIFIED"), @Result(property = "modified", column = "MODIFIED"),
@Result(property = "name", column = "NAME"), @Result(property = "name", column = "NAME"),
@Result(property = "description", column = "DESCRIPTION"), @Result(property = "description", column = "DESCRIPTION"),
@Result(property = "owner", column = "OWNER"), @Result(property = "owner", column = "OWNER"),
@Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select="findByDistributionTargets")) }) @Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")) })
public List<Workbasket> findAll(); List<Workbasket> findAll();
@Select("<script>SELECT W.ID, W.TENANT_ID, W.CREATED, W.MODIFIED, W.NAME, W.DESCRIPTION, W.OWNER FROM WORKBASKET AS W " @Select("<script>SELECT W.ID, W.TENANT_ID, W.CREATED, W.MODIFIED, W.NAME, W.DESCRIPTION, W.OWNER FROM WORKBASKET AS W "
+ "INNER JOIN WORKBASKET_ACCESS_LIST AS ACL " + "INNER JOIN WORKBASKET_ACCESS_LIST AS ACL " + "ON (W.ID = ACL.WORKBASKET_ID AND USER_ID = #{userId}) "
+ "ON (W.ID = ACL.WORKBASKET_ID AND USER_ID = #{userId}) " + "WHERE <foreach collection='authorizations' item='authorization' separator=' AND '>"
+ "WHERE <foreach collection='authorizations' item='authorization' separator=' AND '>" + "<if test=\"authorization.name() == 'OPEN'\">OPEN</if>"
+ "<if test=\"authorization.name() == 'OPEN'\">OPEN</if>" + "<if test=\"authorization.name() == 'READ'\">READ</if>"
+ "<if test=\"authorization.name() == 'READ'\">READ</if>" + "<if test=\"authorization.name() == 'APPEND'\">APPEND</if>"
+ "<if test=\"authorization.name() == 'APPEND'\">APPEND</if>" + "<if test=\"authorization.name() == 'TRANSFER'\">TRANSFER</if>"
+ "<if test=\"authorization.name() == 'TRANSFER'\">TRANSFER</if>" + "<if test=\"authorization.name() == 'DISTRIBUTE'\">DISTRIBUTE</if> = 1 </foreach> "
+ "<if test=\"authorization.name() == 'DISTRIBUTE'\">DISTRIBUTE</if> = 1 </foreach> " + "ORDER BY id</script>")
+ "ORDER BY id</script>") @Results(value = {
@Results(value = { @Result(property = "id", column = "ID"),
@Result(property = "id", column = "ID"), @Result(property = "tenantId", column = "TENANT_ID"),
@Result(property = "tenantId", column = "TENANT_ID"), @Result(property = "created", column = "CREATED"),
@Result(property = "created", column = "CREATED"), @Result(property = "modified", column = "MODIFIED"),
@Result(property = "modified", column = "MODIFIED"), @Result(property = "name", column = "NAME"),
@Result(property = "name", column = "NAME"), @Result(property = "description", column = "DESCRIPTION"),
@Result(property = "description", column = "DESCRIPTION"), @Result(property = "owner", column = "OWNER"),
@Result(property = "owner", column = "OWNER"), @Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")) })
@Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select="findByDistributionTargets")) }) List<Workbasket> findByPermission(@Param("authorizations") List<WorkbasketAuthorization> authorizations, @Param("userId") String userId);
public List<Workbasket> findByPermission(@Param("authorizations") List<WorkbasketAuthorization> 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})") @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") @Options(keyProperty = "id", keyColumn = "ID")
public void insert(@Param("workbasket") Workbasket workbasket); 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}") @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); void update(@Param("workbasket") Workbasket workbasket);
@Delete("DELETE FROM WORKBASKET where id = #{id}") @Delete("DELETE FROM WORKBASKET where id = #{id}")
public void delete(@Param("id") String id); void delete(@Param("id") String id);
} }

161
lib/taskana-core/src/main/java/org/taskana/security/CurrentUserContext.java
View File

@ -13,95 +13,96 @@ import org.slf4j.LoggerFactory;
/** /**
* Provides the context information about the current (calling) user. The * Provides the context information about the current (calling) user. The
* context is gathered from the JAAS subject. * context is gathered from the JAAS subject.
*
* @author Holger Hagen * @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_UNIQUE_SECURITY_NAME_METHOD = "getUniqueSecurityName";
private static final String GET_CALLER_SUBJECT_METHOD = "getCallerSubject"; 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 WSSUBJECT_CLASSNAME = "com.ibm.websphere.security.auth.WSSubject";
private static final Logger logger = LoggerFactory.getLogger(CurrentUserContext.class); private static final Logger LOGGER = LoggerFactory.getLogger(CurrentUserContext.class);
private static Boolean runningOnWebSphere = null; private static Boolean runningOnWebSphere = null;
/** private CurrentUserContext() {
* 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();
}
}
/** /**
* Returns the unique security name of the first public credentials found in the WSSubject as userid. * Returns the userid of the current user.
* * @return String the userid. null if there is no JAAS subject.
* @return the userid of the caller. If the userid could not be obtained, null is returned. */
*/ public static String getUserid() {
private static String getUseridFromWSSubject() { if (runningOnWebSphere()) {
try { return getUseridFromWSSubject();
Class<?> wsSubjectClass = Class.forName(WSSUBJECT_CLASSNAME); } else {
Method getCallerSubjectMethod = wsSubjectClass.getMethod(GET_CALLER_SUBJECT_METHOD, (Class<?>[]) null); return getUseridFromJAASSubject();
Subject callerSubject = (Subject) getCallerSubjectMethod.invoke(null, (Object[]) null); }
logger.debug("Subject of caller: {}", callerSubject); }
if (callerSubject != null) {
Set<Object> 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;
}
/** /**
* Checks, whether Taskana is running on IBM WebSphere. * Returns the unique security name of the first public credentials found in the
* * WSSubject as userid.
* @return true, if it is running on IBM WebSphere * @return the userid of the caller. If the userid could not be obtained, null
*/ * is returned.
private static boolean runningOnWebSphere() { */
if (runningOnWebSphere == null) { private static String getUseridFromWSSubject() {
try { try {
Class.forName(WSSUBJECT_CLASSNAME); Class<?> wsSubjectClass = Class.forName(WSSUBJECT_CLASSNAME);
logger.debug("WSSubject detected. Assuming that Taskana runs on IBM WebSphere."); Method getCallerSubjectMethod = wsSubjectClass.getMethod(GET_CALLER_SUBJECT_METHOD, (Class<?>[]) null);
runningOnWebSphere = new Boolean(true); Subject callerSubject = (Subject) getCallerSubjectMethod.invoke(null, (Object[]) null);
} catch (ClassNotFoundException e) { LOGGER.debug("Subject of caller: {}", callerSubject);
logger.debug("No WSSubject detected. Using JAAS subject further on."); if (callerSubject != null) {
runningOnWebSphere = new Boolean(false); Set<Object> publicCredentials = callerSubject.getPublicCredentials();
} LOGGER.debug("Public credentials of caller: {}", publicCredentials);
} for (Object pC : publicCredentials) {
return runningOnWebSphere; 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 static String getUseridFromJAASSubject() { /**
Subject subject = Subject.getSubject(AccessController.getContext()); * Checks, whether Taskana is running on IBM WebSphere.
logger.debug("Subject of caller: {}", subject); * @return true, if it is running on IBM WebSphere
if (subject != null) { */
Set<Object> publicCredentials = subject.getPublicCredentials(); private static boolean runningOnWebSphere() {
logger.debug("Public credentials of caller: {}", publicCredentials); if (runningOnWebSphere == null) {
for (Object pC : publicCredentials) { try {
logger.debug("Returning the first public credential: {}", pC.toString()); Class.forName(WSSUBJECT_CLASSNAME);
return pC.toString(); LOGGER.debug("WSSubject detected. Assuming that Taskana runs on IBM WebSphere.");
} runningOnWebSphere = new Boolean(true);
} } catch (ClassNotFoundException e) {
logger.debug("No userid found in subject!"); LOGGER.debug("No WSSubject detected. Using JAAS subject further on.");
return null; runningOnWebSphere = new Boolean(false);
} }
}
return runningOnWebSphere;
}
public static List<String> getGroupIds() { private static String getUseridFromJAASSubject() {
return null; Subject subject = Subject.getSubject(AccessController.getContext());
} LOGGER.debug("Subject of caller: {}", subject);
if (subject != null) {
Set<Object> 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<String> getGroupIds() {
return null;
}
} }

116
lib/taskana-core/src/test/java/org/taskana/impl/ClassificationServiceImplTest.java
View File

@ -16,82 +16,86 @@ import java.util.List;
import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*; import static org.mockito.Mockito.*;
/**
* Unit Test for ClassificationServiceImpl.
* @author EH
*/
@RunWith(MockitoJUnitRunner.class) @RunWith(MockitoJUnitRunner.class)
public class ClassificationServiceImplTest { public class ClassificationServiceImplTest {
@InjectMocks @InjectMocks
ClassificationServiceImpl classificationService; ClassificationServiceImpl classificationService;
@Mock @Mock
ClassificationMapper classificationMapper; ClassificationMapper classificationMapper;
@Test @Test
public void testInsertClassification() { public void testInsertClassification() {
doNothing().when(classificationMapper).insert(any()); doNothing().when(classificationMapper).insert(any());
Classification classification = new Classification(); Classification classification = new Classification();
classification.setId("0"); classification.setId("0");
classificationService.insertClassification(classification); classificationService.insertClassification(classification);
when(classificationMapper.findById(any())).thenReturn(classification); when(classificationMapper.findById(any())).thenReturn(classification);
Assert.assertNotNull(classificationService.selectClassificationById(classification.getId())); Assert.assertNotNull(classificationService.selectClassificationById(classification.getId()));
} }
@Test @Test
public void testFindAllClassifications() { public void testFindAllClassifications() {
doNothing().when(classificationMapper).insert(any()); doNothing().when(classificationMapper).insert(any());
Classification classification0 = new Classification(); Classification classification0 = new Classification();
classification0.setId("0"); classification0.setId("0");
classification0.setParentClassificationId(""); classification0.setParentClassificationId("");
classificationService.insertClassification(classification0); classificationService.insertClassification(classification0);
Classification classification1 = new Classification(); Classification classification1 = new Classification();
classification1.setId("1"); classification1.setId("1");
classification1.setParentClassificationId(""); classification1.setParentClassificationId("");
classificationService.insertClassification(classification1); classificationService.insertClassification(classification1);
List<Classification> classifications = new ArrayList<>(); List<Classification> classifications = new ArrayList<>();
classifications.add(classification0); classifications.add(classification0);
when(classificationMapper.findByParentId("")).thenReturn(classifications); when(classificationMapper.findByParentId("")).thenReturn(classifications);
verify(classificationMapper, atLeast(2)).insert(any()); verify(classificationMapper, atLeast(2)).insert(any());
Assert.assertEquals(1, classificationService.selectClassifications().size()); Assert.assertEquals(1, classificationService.selectClassifications().size());
} }
@Test @Test
public void testFindByParentClassification() { public void testFindByParentClassification() {
doNothing().when(classificationMapper).insert(any()); doNothing().when(classificationMapper).insert(any());
Classification classification0 = new Classification(); Classification classification0 = new Classification();
classification0.setId("0"); classification0.setId("0");
classification0.setParentClassificationId("0"); classification0.setParentClassificationId("0");
classificationService.insertClassification(classification0); classificationService.insertClassification(classification0);
Classification classification1 = new Classification(); Classification classification1 = new Classification();
classification1.setId("1"); classification1.setId("1");
classification1.setParentClassificationId("0"); classification1.setParentClassificationId("0");
classificationService.insertClassification(classification1); classificationService.insertClassification(classification1);
List<Classification> classifications = new ArrayList<>(); List<Classification> classifications = new ArrayList<>();
classifications.add(classification0); classifications.add(classification0);
classifications.add(classification1); classifications.add(classification1);
when(classificationMapper.findByParentId(any())).thenReturn(classifications); when(classificationMapper.findByParentId(any())).thenReturn(classifications);
verify(classificationMapper, atLeast(2)).insert(any()); verify(classificationMapper, atLeast(2)).insert(any());
Assert.assertEquals(2, classificationService.selectClassificationsByParentId("0").size()); Assert.assertEquals(2, classificationService.selectClassificationsByParentId("0").size());
} }
@Test @Test
public void testModifiedClassification() { public void testModifiedClassification() {
doNothing().when(classificationMapper).insert(any()); doNothing().when(classificationMapper).insert(any());
doNothing().when(classificationMapper).update(any()); doNothing().when(classificationMapper).update(any());
Classification classification = new Classification(); Classification classification = new Classification();
classificationService.insertClassification(classification); classificationService.insertClassification(classification);
classification.setDescription("TEST EVERYTHING"); classification.setDescription("TEST EVERYTHING");
classificationService.updateClassification(classification); classificationService.updateClassification(classification);
Assert.assertEquals(classification.getModified().toString(), LocalDate.now().toString()); Assert.assertEquals(classification.getModified().toString(), LocalDate.now().toString());
} }
} }

328
lib/taskana-core/src/test/java/org/taskana/impl/TaskServiceImplTest.java
View File

@ -26,202 +26,208 @@ import org.taskana.model.Workbasket;
import org.taskana.model.mappings.ObjectReferenceMapper; import org.taskana.model.mappings.ObjectReferenceMapper;
import org.taskana.model.mappings.TaskMapper; import org.taskana.model.mappings.TaskMapper;
/**
* Unit Test for TaskServiceImpl.
* @author EH
*/
@RunWith(MockitoJUnitRunner.class) @RunWith(MockitoJUnitRunner.class)
public class TaskServiceImplTest { public class TaskServiceImplTest {
@InjectMocks private static final int LIST_SIZE = 3;
TaskServiceImpl taskServiceImpl; private static final int SLEEP_TIME = 100;
@Mock @InjectMocks
TaskanaEngine taskanaEngine; TaskServiceImpl taskServiceImpl;
@Mock @Mock
TaskanaEngineConfiguration taskanaEngineConfiguration; TaskanaEngine taskanaEngine;
@Mock @Mock
WorkbasketServiceImpl workbasketServiceImpl; TaskanaEngineConfiguration taskanaEngineConfiguration;
@Mock @Mock
TaskMapper taskMapper; WorkbasketServiceImpl workbasketServiceImpl;
@Mock @Mock
ObjectReferenceMapper objectReferenceMapper; TaskMapper taskMapper;
@Mock
ObjectReferenceMapper objectReferenceMapper;
@Test @Test
public void testCreateSimpleTask() throws NotAuthorizedException { public void testCreateSimpleTask() throws NotAuthorizedException {
registerBasicMocks(false); registerBasicMocks(false);
Mockito.doNothing().when(workbasketServiceImpl).checkAuthorization(any(), any()); Mockito.doNothing().when(workbasketServiceImpl).checkAuthorization(any(), any());
Mockito.doNothing().when(taskMapper).insert(any()); Mockito.doNothing().when(taskMapper).insert(any());
Task task = new Task(); Task task = new Task();
task.setName("Unit Test Task"); task.setName("Unit Test Task");
task.setWorkbasketId("1"); task.setWorkbasketId("1");
task = taskServiceImpl.create(task); task = taskServiceImpl.create(task);
Assert.assertNull(task.getOwner()); Assert.assertNull(task.getOwner());
Assert.assertNotNull(task.getCreated()); Assert.assertNotNull(task.getCreated());
Assert.assertNotNull(task.getModified()); Assert.assertNotNull(task.getModified());
Assert.assertNull(task.getCompleted()); Assert.assertNull(task.getCompleted());
Assert.assertEquals(task.getWorkbasketId(), "1"); Assert.assertEquals(task.getWorkbasketId(), "1");
Assert.assertEquals(task.getState(), TaskState.READY); Assert.assertEquals(task.getState(), TaskState.READY);
} }
@Test @Test
public void testClaim() throws Exception { public void testClaim() throws Exception {
Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); Task task = createUnitTestTask("1", "Unit Test Task 1", "1");
Thread.sleep(100); // to have different timestamps Thread.sleep(SLEEP_TIME); // to have different timestamps
taskServiceImpl.claim(task.getId(), "John Does"); taskServiceImpl.claim(task.getId(), "John Does");
task = taskServiceImpl.getTaskById(task.getId()); task = taskServiceImpl.getTaskById(task.getId());
Assert.assertEquals(task.getState(), TaskState.CLAIMED); Assert.assertEquals(task.getState(), TaskState.CLAIMED);
Assert.assertNotEquals(task.getCreated(), task.getModified()); Assert.assertNotEquals(task.getCreated(), task.getModified());
Assert.assertNotNull(task.getClaimed()); Assert.assertNotNull(task.getClaimed());
Assert.assertEquals(task.getOwner(), "John Does"); Assert.assertEquals(task.getOwner(), "John Does");
} }
@Test(expected = TaskNotFoundException.class) @Test(expected = TaskNotFoundException.class)
public void testClaimFailsWithNonExistingTaskId() throws TaskNotFoundException { public void testClaimFailsWithNonExistingTaskId() throws TaskNotFoundException {
taskServiceImpl.claim("test", "John Doe"); taskServiceImpl.claim("test", "John Doe");
} }
@Test @Test
public void testComplete() throws Exception { public void testComplete() throws Exception {
Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); Task task = createUnitTestTask("1", "Unit Test Task 1", "1");
Thread.sleep(100); // to have different timestamps Thread.sleep(SLEEP_TIME); // to have different timestamps
taskServiceImpl.complete(task.getId()); taskServiceImpl.complete(task.getId());
task = taskServiceImpl.getTaskById(task.getId()); task = taskServiceImpl.getTaskById(task.getId());
Assert.assertEquals(task.getState(), TaskState.COMPLETED); Assert.assertEquals(task.getState(), TaskState.COMPLETED);
Assert.assertNotEquals(task.getCreated(), task.getModified()); Assert.assertNotEquals(task.getCreated(), task.getModified());
Assert.assertNotNull(task.getCompleted()); Assert.assertNotNull(task.getCompleted());
} }
@Test(expected = TaskNotFoundException.class) @Test(expected = TaskNotFoundException.class)
public void testCompleteFailsWithNonExistingTaskId() throws TaskNotFoundException { public void testCompleteFailsWithNonExistingTaskId() throws TaskNotFoundException {
taskServiceImpl.complete("test"); taskServiceImpl.complete("test");
} }
@Test @Test
public void testGetTasksForWorkbasket() throws NotAuthorizedException { public void testGetTasksForWorkbasket() throws NotAuthorizedException {
registerBasicMocks(false); registerBasicMocks(false);
ArrayList<Task> tasks = new ArrayList<Task>(); ArrayList<Task> tasks = new ArrayList<Task>();
tasks.add(createUnitTestTask("1", "Unit Test Task 1", "1")); tasks.add(createUnitTestTask("1", "Unit Test Task 1", "1"));
tasks.add(createUnitTestTask("2", "Unit Test Task 2", "1")); tasks.add(createUnitTestTask("2", "Unit Test Task 2", "1"));
tasks.add(createUnitTestTask("3", "Unit Test Task 3", "1")); tasks.add(createUnitTestTask("3", "Unit Test Task 3", "1"));
Mockito.when(taskMapper.findByWorkBasketId("1")).thenReturn(tasks); Mockito.when(taskMapper.findByWorkBasketId("1")).thenReturn(tasks);
List<Task> list = taskServiceImpl.getTasksForWorkbasket("1"); List<Task> list = taskServiceImpl.getTasksForWorkbasket("1");
Assert.assertEquals(list.size(), 3); Assert.assertEquals(LIST_SIZE, list.size());
} }
@Test @Test
public void testTransferTaskZuDestinationWorkbasket() public void testTransferTaskZuDestinationWorkbasket()
throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException {
registerBasicMocks(false); registerBasicMocks(false);
Workbasket workbasket2 = createWorkbasket2(); Workbasket workbasket2 = createWorkbasket2();
Mockito.when(workbasketServiceImpl.getWorkbasket("2")).thenReturn(workbasket2); Mockito.when(workbasketServiceImpl.getWorkbasket("2")).thenReturn(workbasket2);
Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); Task task = createUnitTestTask("1", "Unit Test Task 1", "1");
task.setRead(true); task.setRead(true);
Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "1"); Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "1");
taskServiceImpl.transfer(task.getId(), "2"); taskServiceImpl.transfer(task.getId(), "2");
Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "2"); Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "2");
Assert.assertTrue(task.isTransferred()); Assert.assertTrue(task.isTransferred());
Assert.assertFalse(task.isRead()); Assert.assertFalse(task.isRead());
} }
@Test(expected = WorkbasketNotFoundException.class) @Test(expected = WorkbasketNotFoundException.class)
public void testTransferFailsIfDestinationWorkbasketDoesNotExist_withSecurityDisabled() public void testTransferFailsIfDestinationWorkbasketDoesNotExist_withSecurityDisabled()
throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException {
registerBasicMocks(false); registerBasicMocks(false);
Mockito.doThrow(WorkbasketNotFoundException.class).when(workbasketServiceImpl) Mockito.doThrow(WorkbasketNotFoundException.class).when(workbasketServiceImpl)
.checkAuthorization(eq("invalidWorkbasketId"), any()); .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"); Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "1");
taskServiceImpl.transfer(task.getId(), "invalidWorkbasketId"); taskServiceImpl.transfer(task.getId(), "invalidWorkbasketId");
} }
@Test(expected = WorkbasketNotFoundException.class) @Test(expected = WorkbasketNotFoundException.class)
public void testTransferFailsIfDestinationWorkbasketDoesNotExist_withSecurityEnabled() public void testTransferFailsIfDestinationWorkbasketDoesNotExist_withSecurityEnabled()
throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException {
registerBasicMocks(true); registerBasicMocks(true);
Mockito.doThrow(WorkbasketNotFoundException.class).when(workbasketServiceImpl) Mockito.doThrow(WorkbasketNotFoundException.class).when(workbasketServiceImpl)
.checkAuthorization(eq("invalidWorkbasketId"), any()); .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"); Assert.assertEquals(taskServiceImpl.getTaskById(task.getId()).getWorkbasketId(), "1");
taskServiceImpl.transfer(task.getId(), "invalidWorkbasketId"); taskServiceImpl.transfer(task.getId(), "invalidWorkbasketId");
} }
@Test @Test
public void should_setTheReadFlag_when_taskIsRead() throws TaskNotFoundException { public void should_setTheReadFlag_when_taskIsRead() throws TaskNotFoundException {
createUnitTestTask("1", "Unit Test Task 1", "1"); createUnitTestTask("1", "Unit Test Task 1", "1");
Task readTask = taskServiceImpl.setTaskRead("1", true); Task readTask = taskServiceImpl.setTaskRead("1", true);
Assert.assertTrue(readTask.isRead()); Assert.assertTrue(readTask.isRead());
} }
@Test @Test
public void should_InsertObjectReference_when_TaskIsCreated() throws NotAuthorizedException { public void should_InsertObjectReference_when_TaskIsCreated() throws NotAuthorizedException {
Mockito.when(taskanaEngine.getWorkbasketService()).thenReturn(workbasketServiceImpl); Mockito.when(taskanaEngine.getWorkbasketService()).thenReturn(workbasketServiceImpl);
Mockito.doNothing().when(workbasketServiceImpl).checkAuthorization(any(), any()); Mockito.doNothing().when(workbasketServiceImpl).checkAuthorization(any(), any());
Mockito.when(objectReferenceMapper.findByObjectReference(any())).thenReturn(null); Mockito.when(objectReferenceMapper.findByObjectReference(any())).thenReturn(null);
Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); Task task = createUnitTestTask("1", "Unit Test Task 1", "1");
ObjectReference primaryObjRef = new ObjectReference(); ObjectReference primaryObjRef = new ObjectReference();
primaryObjRef.setSystem("Sol"); primaryObjRef.setSystem("Sol");
task.setPrimaryObjRef(primaryObjRef); task.setPrimaryObjRef(primaryObjRef);
Task createdTask = taskServiceImpl.create(task); Task createdTask = taskServiceImpl.create(task);
Assert.assertNotNull(createdTask.getPrimaryObjRef()); Assert.assertNotNull(createdTask.getPrimaryObjRef());
Assert.assertNotNull(createdTask.getPrimaryObjRef().getId()); Assert.assertNotNull(createdTask.getPrimaryObjRef().getId());
Assert.assertEquals("Sol", createdTask.getPrimaryObjRef().getSystem()); Assert.assertEquals("Sol", createdTask.getPrimaryObjRef().getSystem());
} }
@Test @Test
public void should_LinkObjectReference_when_TaskIsCreated() throws NotAuthorizedException { public void should_LinkObjectReference_when_TaskIsCreated() throws NotAuthorizedException {
Mockito.when(taskanaEngine.getWorkbasketService()).thenReturn(workbasketServiceImpl); Mockito.when(taskanaEngine.getWorkbasketService()).thenReturn(workbasketServiceImpl);
Mockito.doNothing().when(workbasketServiceImpl).checkAuthorization(any(), any()); Mockito.doNothing().when(workbasketServiceImpl).checkAuthorization(any(), any());
Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); Task task = createUnitTestTask("1", "Unit Test Task 1", "1");
ObjectReference primaryObjRef = new ObjectReference(); ObjectReference primaryObjRef = new ObjectReference();
primaryObjRef.setSystem("Sol"); primaryObjRef.setSystem("Sol");
task.setPrimaryObjRef(primaryObjRef); task.setPrimaryObjRef(primaryObjRef);
ObjectReference returnPrimaryObjRef = new ObjectReference(); ObjectReference returnPrimaryObjRef = new ObjectReference();
returnPrimaryObjRef.setId("1"); returnPrimaryObjRef.setId("1");
returnPrimaryObjRef.setSystem("Sol"); returnPrimaryObjRef.setSystem("Sol");
Mockito.when(objectReferenceMapper.findByObjectReference(any())).thenReturn(returnPrimaryObjRef); Mockito.when(objectReferenceMapper.findByObjectReference(any())).thenReturn(returnPrimaryObjRef);
Task createdTask = taskServiceImpl.create(task); Task createdTask = taskServiceImpl.create(task);
Assert.assertNotNull(createdTask.getPrimaryObjRef()); Assert.assertNotNull(createdTask.getPrimaryObjRef());
Assert.assertEquals("1", createdTask.getPrimaryObjRef().getId()); Assert.assertEquals("1", createdTask.getPrimaryObjRef().getId());
Assert.assertEquals("Sol", createdTask.getPrimaryObjRef().getSystem()); Assert.assertEquals("Sol", createdTask.getPrimaryObjRef().getSystem());
} }
private Task createUnitTestTask(String id, String name, String workbasketId) { private Task createUnitTestTask(String id, String name, String workbasketId) {
Task task = new Task(); Task task = new Task();
task.setId(id); task.setId(id);
task.setName(name); task.setName(name);
task.setWorkbasketId(workbasketId); task.setWorkbasketId(workbasketId);
Timestamp now = new Timestamp(System.currentTimeMillis()); Timestamp now = new Timestamp(System.currentTimeMillis());
task.setCreated(now); task.setCreated(now);
task.setModified(now); task.setModified(now);
Mockito.when(taskMapper.findById(any())).thenReturn(task); Mockito.when(taskMapper.findById(any())).thenReturn(task);
return task; return task;
} }
private Workbasket createWorkbasket2() { private Workbasket createWorkbasket2() {
Workbasket workbasket2 = new Workbasket(); Workbasket workbasket2 = new Workbasket();
workbasket2.setId("2"); workbasket2.setId("2");
workbasket2.setName("Workbasket 2"); workbasket2.setName("Workbasket 2");
return workbasket2; return workbasket2;
} }
private void registerBasicMocks(boolean securityEnabled) { private void registerBasicMocks(boolean securityEnabled) {
Mockito.when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration); Mockito.when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration);
Mockito.when(taskanaEngineConfiguration.isSecurityEnabled()).thenReturn(securityEnabled); Mockito.when(taskanaEngineConfiguration.isSecurityEnabled()).thenReturn(securityEnabled);
Mockito.when(taskanaEngine.getWorkbasketService()).thenReturn(workbasketServiceImpl); Mockito.when(taskanaEngine.getWorkbasketService()).thenReturn(workbasketServiceImpl);
} }
} }

405
lib/taskana-core/src/test/java/org/taskana/impl/WorkbasketServiceImplTest.java
View File

@ -26,258 +26,267 @@ import org.taskana.model.mappings.DistributionTargetMapper;
import org.taskana.model.mappings.WorkbasketAccessMapper; import org.taskana.model.mappings.WorkbasketAccessMapper;
import org.taskana.model.mappings.WorkbasketMapper; import org.taskana.model.mappings.WorkbasketMapper;
/**
* Unit Test for workbasketServiceImpl.
* @author EH
*/
@RunWith(MockitoJUnitRunner.class) @RunWith(MockitoJUnitRunner.class)
public class WorkbasketServiceImplTest { public class WorkbasketServiceImplTest {
@InjectMocks private static final int THREE = 3;
WorkbasketServiceImpl workbasketServiceImpl;
@Mock private static final int SLEEP_TIME = 100;
WorkbasketMapper workbasketMapper;
@Mock
DistributionTargetMapper distributionTargetMapper;
@Mock
WorkbasketAccessMapper workbasketAccessMapper;
@Mock
TaskanaEngine taskanaEngine;
@Mock
TaskanaEngineConfiguration taskanaEngineConfiguration;
@Test @InjectMocks
public void should_ReturnWorkbasket_when_WorkbasketIdExists() throws WorkbasketNotFoundException { WorkbasketServiceImpl workbasketServiceImpl;
when(workbasketMapper.findById(any())).thenReturn(new Workbasket());
Workbasket workbasket = workbasketServiceImpl.getWorkbasket("fail"); @Mock
WorkbasketMapper workbasketMapper;
@Mock
DistributionTargetMapper distributionTargetMapper;
@Mock
WorkbasketAccessMapper workbasketAccessMapper;
@Mock
TaskanaEngine taskanaEngine;
@Mock
TaskanaEngineConfiguration taskanaEngineConfiguration;
verify(workbasketMapper).findById(any()); @Test
Assert.assertNotNull(workbasket); public void should_ReturnWorkbasket_when_WorkbasketIdExists() throws WorkbasketNotFoundException {
} when(workbasketMapper.findById(any())).thenReturn(new Workbasket());
@Test(expected = WorkbasketNotFoundException.class) Workbasket workbasket = workbasketServiceImpl.getWorkbasket("fail");
public void should_ThrowWorkbasketNotFoundException_when_WorkbasketIdDoesNotExist()
throws WorkbasketNotFoundException {
workbasketServiceImpl.getWorkbasket("fail");
}
@Test verify(workbasketMapper).findById(any());
public void should_ReturnListOfWorkbaskets_when_PermissionAndUserExists() { Assert.assertNotNull(workbasket);
when(workbasketMapper.findByPermission(any(), any())).thenReturn(new ArrayList<Workbasket>()); }
List<WorkbasketAuthorization> authorizations = new ArrayList<>(); @Test(expected = WorkbasketNotFoundException.class)
authorizations.add(WorkbasketAuthorization.OPEN); public void should_ThrowWorkbasketNotFoundException_when_WorkbasketIdDoesNotExist()
authorizations.add(WorkbasketAuthorization.APPEND); throws WorkbasketNotFoundException {
List<Workbasket> workbaskets = workbasketServiceImpl.getWorkbaskets(authorizations); workbasketServiceImpl.getWorkbasket("fail");
}
verify(workbasketMapper).findByPermission(any(), any()); @Test
Assert.assertNotNull(workbaskets); public void should_ReturnListOfWorkbaskets_when_PermissionAndUserExists() {
} when(workbasketMapper.findByPermission(any(), any())).thenReturn(new ArrayList<Workbasket>());
@Test List<WorkbasketAuthorization> authorizations = new ArrayList<>();
public void should_ReturnAllWorkbaskets_when_AllWorkbaskets() { authorizations.add(WorkbasketAuthorization.OPEN);
when(workbasketMapper.findAll()).thenReturn(new ArrayList<Workbasket>()); authorizations.add(WorkbasketAuthorization.APPEND);
List<Workbasket> workbaskets = workbasketServiceImpl.getWorkbaskets(authorizations);
List<Workbasket> workbaskets = workbasketServiceImpl.getWorkbaskets(); verify(workbasketMapper).findByPermission(any(), any());
Assert.assertNotNull(workbaskets);
}
verify(workbasketMapper).findAll(); @Test
Assert.assertNotNull(workbaskets); public void should_ReturnAllWorkbaskets_when_AllWorkbaskets() {
} when(workbasketMapper.findAll()).thenReturn(new ArrayList<Workbasket>());
@Test List<Workbasket> workbaskets = workbasketServiceImpl.getWorkbaskets();
public void should_InitializeAndStoreWorkbasket_when_WorkbasketIsCreated() throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
Workbasket workbasket = new Workbasket(); verify(workbasketMapper).findAll();
workbasket.setId("1"); Assert.assertNotNull(workbaskets);
workbasketServiceImpl.createWorkbasket(workbasket); }
Assert.assertEquals("1", workbasket.getId()); @Test
Assert.assertEquals(workbasket.getModified(), workbasket.getCreated()); public void should_InitializeAndStoreWorkbasket_when_WorkbasketIsCreated() throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
verify(workbasketMapper).insert(any()); Workbasket workbasket = new Workbasket();
} workbasket.setId("1");
workbasketServiceImpl.createWorkbasket(workbasket);
@SuppressWarnings("serial") Assert.assertEquals("1", workbasket.getId());
@Test Assert.assertEquals(workbasket.getModified(), workbasket.getCreated());
public void should_InitializeAndStoreWorkbasket_when_WorkbasketWithDistributionTargetsIsCreated() throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
doNothing().when(distributionTargetMapper).insert(any(), any());
Workbasket workbasket = new Workbasket(); verify(workbasketMapper).insert(any());
workbasket.setId("1"); }
Workbasket workbasket1 = new Workbasket();
workbasket1.setId("2");
Workbasket workbasket2 = new Workbasket();
workbasket2.setId("3");
workbasket.setDistributionTargets(new ArrayList<Workbasket>() {
{
add(workbasket1);
add(workbasket2);
}
});
workbasketServiceImpl.createWorkbasket(workbasket); @SuppressWarnings("serial")
@Test
public void should_InitializeAndStoreWorkbasket_when_WorkbasketWithDistributionTargetsIsCreated()
throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
doNothing().when(distributionTargetMapper).insert(any(), any());
Assert.assertEquals("1", workbasket.getId()); Workbasket workbasket = new Workbasket();
Assert.assertEquals(workbasket.getModified(), workbasket.getCreated()); workbasket.setId("1");
Workbasket workbasket1 = new Workbasket();
workbasket1.setId("2");
Workbasket workbasket2 = new Workbasket();
workbasket2.setId("3");
workbasket.setDistributionTargets(new ArrayList<Workbasket>() {
{
add(workbasket1);
add(workbasket2);
}
});
verify(workbasketMapper, times(3)).insert(any()); workbasketServiceImpl.createWorkbasket(workbasket);
verify(distributionTargetMapper, times(2)).insert(any(), any());
}
@Test Assert.assertEquals("1", workbasket.getId());
public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDescriptionIsChanged() throws NotAuthorizedException { Assert.assertEquals(workbasket.getModified(), workbasket.getCreated());
doNothing().when(workbasketMapper).insert(any());
Workbasket workbasket = new Workbasket(); verify(workbasketMapper, times(THREE)).insert(any());
workbasket.setId("0"); verify(distributionTargetMapper, times(2)).insert(any(), any());
workbasket.setDescription("TestDescription"); }
workbasket.setName("Cool New WorkintheBasket");
workbasket.setOwner("Arthur Dent");
workbasketServiceImpl.createWorkbasket(workbasket);
doNothing().when(workbasketMapper).update(any()); @Test
workbasket.setDescription("42"); public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDescriptionIsChanged()
workbasketServiceImpl.updateWorkbasket(workbasket); throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
verify(workbasketMapper).update(any()); Workbasket workbasket = new Workbasket();
} workbasket.setId("0");
workbasket.setDescription("TestDescription");
workbasket.setName("Cool New WorkintheBasket");
workbasket.setOwner("Arthur Dent");
workbasketServiceImpl.createWorkbasket(workbasket);
@SuppressWarnings("serial") doNothing().when(workbasketMapper).update(any());
@Test workbasket.setDescription("42");
public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDistributionTargetIsChanged() workbasketServiceImpl.updateWorkbasket(workbasket);
throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
Workbasket workbasket = new Workbasket(); verify(workbasketMapper).update(any());
workbasket.setId("0"); }
Workbasket workbasket1 = new Workbasket();
workbasket1.setId("1");
workbasket.setDistributionTargets(new ArrayList<Workbasket>() {
{
add(workbasket1);
}
});
workbasketServiceImpl.createWorkbasket(workbasket);
doNothing().when(workbasketMapper).update(any()); @SuppressWarnings("serial")
when(workbasketMapper.findById(any())).thenReturn(workbasket); @Test
workbasket.getDistributionTargets().get(0).setDescription("Test123"); public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDistributionTargetIsChanged()
Workbasket result = workbasketServiceImpl.updateWorkbasket(workbasket); throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
verify(workbasketMapper).update(any()); Workbasket workbasket = new Workbasket();
Assert.assertEquals("Test123", result.getDistributionTargets().get(0).getDescription()); workbasket.setId("0");
} Workbasket workbasket1 = new Workbasket();
workbasket1.setId("1");
workbasket.setDistributionTargets(new ArrayList<Workbasket>() {
{
add(workbasket1);
}
});
workbasketServiceImpl.createWorkbasket(workbasket);
@Test doNothing().when(workbasketMapper).update(any());
public void should_UpdateModifiedTimestamp_when_ExistingWorkbasketDistributionTargetIsChanged() when(workbasketMapper.findById(any())).thenReturn(workbasket);
throws Exception { workbasket.getDistributionTargets().get(0).setDescription("Test123");
doNothing().when(workbasketMapper).insert(any()); Workbasket result = workbasketServiceImpl.updateWorkbasket(workbasket);
Workbasket workbasket0 = new Workbasket(); verify(workbasketMapper).update(any());
workbasket0.setId("0"); Assert.assertEquals("Test123", result.getDistributionTargets().get(0).getDescription());
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);
Workbasket workbasket3 = new Workbasket(); @Test
workbasket3.setId("3"); public void should_UpdateModifiedTimestamp_when_ExistingWorkbasketDistributionTargetIsChanged() throws Exception {
workbasket2.getDistributionTargets().clear(); doNothing().when(workbasketMapper).insert(any());
workbasket2.getDistributionTargets().add(workbasket3);
Thread.sleep(100);
doNothing().when(workbasketMapper).update(any()); Workbasket workbasket0 = new Workbasket();
workbasketServiceImpl.updateWorkbasket(workbasket2); 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("2")).thenReturn(workbasket2); Workbasket workbasket3 = new Workbasket();
Workbasket foundBasket = workbasketServiceImpl.getWorkbasket(workbasket2.getId()); workbasket3.setId("3");
workbasket2.getDistributionTargets().clear();
workbasket2.getDistributionTargets().add(workbasket3);
Thread.sleep(SLEEP_TIME);
when(workbasketMapper.findById("1")).thenReturn(workbasket1); doNothing().when(workbasketMapper).update(any());
when(workbasketMapper.findById("3")).thenReturn(workbasket1); workbasketServiceImpl.updateWorkbasket(workbasket2);
List<Workbasket> distributionTargets = foundBasket.getDistributionTargets(); when(workbasketMapper.findById("2")).thenReturn(workbasket2);
Assert.assertEquals(1, distributionTargets.size()); Workbasket foundBasket = workbasketServiceImpl.getWorkbasket(workbasket2.getId());
Assert.assertEquals("3", distributionTargets.get(0).getId());
Assert.assertNotEquals(workbasketServiceImpl.getWorkbasket("2").getCreated(), when(workbasketMapper.findById("1")).thenReturn(workbasket1);
workbasketServiceImpl.getWorkbasket("2").getModified()); when(workbasketMapper.findById("3")).thenReturn(workbasket1);
Assert.assertEquals(workbasketServiceImpl.getWorkbasket("1").getCreated(),
workbasketServiceImpl.getWorkbasket("1").getModified());
Assert.assertEquals(workbasketServiceImpl.getWorkbasket("3").getCreated(),
workbasketServiceImpl.getWorkbasket("3").getModified());
}
@Test List<Workbasket> distributionTargets = foundBasket.getDistributionTargets();
public void should_ReturnWorkbasketAuthorization_when_NewWorkbasketAccessItemIsCreated() Assert.assertEquals(1, distributionTargets.size());
throws NotAuthorizedException { Assert.assertEquals("3", distributionTargets.get(0).getId());
doNothing().when(workbasketAccessMapper).insert(any());
WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); Assert.assertNotEquals(workbasketServiceImpl.getWorkbasket("2").getCreated(),
accessItem.setWorkbasketId("1"); workbasketServiceImpl.getWorkbasket("2").getModified());
accessItem.setUserId("Arthur Dent"); Assert.assertEquals(workbasketServiceImpl.getWorkbasket("1").getCreated(),
accessItem.setOpen(true); workbasketServiceImpl.getWorkbasket("1").getModified());
accessItem.setRead(true); Assert.assertEquals(workbasketServiceImpl.getWorkbasket("3").getCreated(),
accessItem = workbasketServiceImpl.createWorkbasketAuthorization(accessItem); workbasketServiceImpl.getWorkbasket("3").getModified());
}
Assert.assertNotNull(accessItem.getId()); @Test
} public void should_ReturnWorkbasketAuthorization_when_NewWorkbasketAccessItemIsCreated()
throws NotAuthorizedException {
doNothing().when(workbasketAccessMapper).insert(any());
@Test WorkbasketAccessItem accessItem = new WorkbasketAccessItem();
public void should_ReturnWorkbasketAuthorization_when_WorkbasketAccessItemIsUpdated() accessItem.setWorkbasketId("1");
throws NotAuthorizedException { accessItem.setUserId("Arthur Dent");
doNothing().when(workbasketAccessMapper).insert(any()); accessItem.setOpen(true);
accessItem.setRead(true);
accessItem = workbasketServiceImpl.createWorkbasketAuthorization(accessItem);
WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); Assert.assertNotNull(accessItem.getId());
accessItem.setWorkbasketId("1"); }
accessItem.setUserId("Arthur Dent");
accessItem.setOpen(true);
accessItem.setRead(true);
accessItem = workbasketServiceImpl.createWorkbasketAuthorization(accessItem);
Assert.assertNotNull(accessItem.getId()); @Test
public void should_ReturnWorkbasketAuthorization_when_WorkbasketAccessItemIsUpdated()
throws NotAuthorizedException {
doNothing().when(workbasketAccessMapper).insert(any());
doNothing().when(workbasketAccessMapper).update(any()); WorkbasketAccessItem accessItem = new WorkbasketAccessItem();
accessItem.setUserId("Zaphod Beeblebrox"); accessItem.setWorkbasketId("1");
workbasketServiceImpl.updateWorkbasketAuthorization(accessItem); accessItem.setUserId("Arthur Dent");
accessItem.setOpen(true);
accessItem.setRead(true);
accessItem = workbasketServiceImpl.createWorkbasketAuthorization(accessItem);
Assert.assertEquals("Zaphod Beeblebrox", accessItem.getUserId()); Assert.assertNotNull(accessItem.getId());
}
@Test(expected = NotAuthorizedException.class) doNothing().when(workbasketAccessMapper).update(any());
public void should_ThrowNotAuthorizedException_when_OperationIsNotAuthorized() throws NotAuthorizedException { accessItem.setUserId("Zaphod Beeblebrox");
when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration); workbasketServiceImpl.updateWorkbasketAuthorization(accessItem);
when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(true);
workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ); Assert.assertEquals("Zaphod Beeblebrox", accessItem.getUserId());
} }
@SuppressWarnings("serial") @Test(expected = NotAuthorizedException.class)
@Test public void should_ThrowNotAuthorizedException_when_OperationIsNotAuthorized() throws NotAuthorizedException {
public void should_Pass_when_OperationIsAuthorized() throws NotAuthorizedException { when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration);
when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration); when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(true);
when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(true);
when(workbasketAccessMapper.findByWorkbasketAndUserAndAuthorization(any(), any(), any())) workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ);
.thenReturn(new ArrayList<WorkbasketAccessItem>() { }
{
add(new WorkbasketAccessItem());
}
});
workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ); @SuppressWarnings("serial")
@Test
public void should_Pass_when_OperationIsAuthorized() throws NotAuthorizedException {
when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration);
when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(true);
verify(workbasketAccessMapper, times(1)).findByWorkbasketAndUserAndAuthorization(any(), any(), any()); when(workbasketAccessMapper.findByWorkbasketAndUserAndAuthorization(any(), any(), any()))
} .thenReturn(new ArrayList<WorkbasketAccessItem>() {
{
add(new WorkbasketAccessItem());
}
});
@Test workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ);
public void should_Pass_when_SecurityIsDisabled() throws NotAuthorizedException {
when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration);
when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(false);
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);
}
} }

5
lib/taskana-core/src/test/java/org/taskana/impl/configuration/TaskanaEngineConfigurationTest.java
View File

@ -10,7 +10,10 @@ import org.junit.Assert;
import org.junit.Test; import org.junit.Test;
import org.taskana.TaskanaEngine; import org.taskana.TaskanaEngine;
import org.taskana.configuration.TaskanaEngineConfiguration; import org.taskana.configuration.TaskanaEngineConfiguration;
/**
* Integration Test for TaskanaEngineConfiguration.
* @author EH
*/
public class TaskanaEngineConfigurationTest { public class TaskanaEngineConfigurationTest {
@Test @Test

106
lib/taskana-core/src/test/java/org/taskana/impl/integration/ClassificationServiceImplIntTest.java
View File

@ -14,66 +14,70 @@ import java.io.FileNotFoundException;
import java.sql.SQLException; import java.sql.SQLException;
import java.time.LocalDate; import java.time.LocalDate;
/**
* Integration Test for ClassificationServiceImpl.
* @author EH
*/
public class ClassificationServiceImplIntTest { public class ClassificationServiceImplIntTest {
static int counter = 0; static int counter = 0;
private ClassificationService classificationService; private ClassificationService classificationService;
@Before @Before
public void setup() throws FileNotFoundException, SQLException, LoginException { public void setup() throws FileNotFoundException, SQLException, LoginException {
JdbcDataSource ds = new JdbcDataSource(); JdbcDataSource ds = new JdbcDataSource();
ds.setURL("jdbc:h2:mem:test-db-classification" + counter++); ds.setURL("jdbc:h2:mem:test-db-classification" + counter++);
ds.setPassword("sa"); ds.setPassword("sa");
ds.setUser("sa"); ds.setUser("sa");
TaskanaEngineConfiguration taskEngineConfiguration = new TaskanaEngineConfiguration(ds, false); TaskanaEngineConfiguration taskEngineConfiguration = new TaskanaEngineConfiguration(ds, false);
TaskanaEngine te = taskEngineConfiguration.buildTaskanaEngine(); TaskanaEngine te = taskEngineConfiguration.buildTaskanaEngine();
classificationService = te.getClassificationService(); classificationService = te.getClassificationService();
} }
@Test @Test
public void testInsertClassification() { public void testInsertClassification() {
Classification classification = new Classification(); Classification classification = new Classification();
classification.setId("0"); classification.setId("0");
classificationService.insertClassification(classification); classificationService.insertClassification(classification);
Assert.assertNotNull(classificationService.selectClassificationById(classification.getId())); Assert.assertNotNull(classificationService.selectClassificationById(classification.getId()));
} }
@Test @Test
public void testFindAllClassifications() { public void testFindAllClassifications() {
Classification classification0 = new Classification(); Classification classification0 = new Classification();
classification0.setId("0"); classification0.setId("0");
classification0.setParentClassificationId(""); classification0.setParentClassificationId("");
classificationService.insertClassification(classification0); classificationService.insertClassification(classification0);
Classification classification1 = new Classification(); Classification classification1 = new Classification();
classification1.setId("1"); classification1.setId("1");
classification1.setParentClassificationId(""); classification1.setParentClassificationId("");
classificationService.insertClassification(classification1); classificationService.insertClassification(classification1);
Assert.assertEquals(2, classificationService.selectClassifications().size()); Assert.assertEquals(2, classificationService.selectClassifications().size());
} }
@Test @Test
public void testFindByParentClassification() { public void testFindByParentClassification() {
Classification classification0 = new Classification(); Classification classification0 = new Classification();
classification0.setId("0"); classification0.setId("0");
classification0.setParentClassificationId("0"); classification0.setParentClassificationId("0");
classificationService.insertClassification(classification0); classificationService.insertClassification(classification0);
Classification classification1 = new Classification(); Classification classification1 = new Classification();
classification1.setId("1"); classification1.setId("1");
classification1.setParentClassificationId("0"); classification1.setParentClassificationId("0");
classificationService.insertClassification(classification1); classificationService.insertClassification(classification1);
Assert.assertEquals(2, classificationService.selectClassificationsByParentId("0").size()); Assert.assertEquals(2, classificationService.selectClassificationsByParentId("0").size());
} }
@Test @Test
public void testModifiedClassification() { public void testModifiedClassification() {
Classification classification = new Classification(); Classification classification = new Classification();
classificationService.insertClassification(classification); classificationService.insertClassification(classification);
classification.setDescription("TEST EVERYTHING"); classification.setDescription("TEST EVERYTHING");
classificationService.updateClassification(classification); classificationService.updateClassification(classification);
Assert.assertEquals(classification.getModified().toString(), LocalDate.now().toString()); Assert.assertEquals(classification.getModified().toString(), LocalDate.now().toString());
} }
} }

108
lib/taskana-core/src/test/java/org/taskana/impl/integration/TaskServiceImplTransactionTest.java
View File

@ -14,69 +14,73 @@ import org.taskana.model.Task;
import java.io.FileNotFoundException; import java.io.FileNotFoundException;
import java.sql.SQLException; import java.sql.SQLException;
/**
* Integration Test for TaskServiceImpl transactions.
* @author EH
*/
public class TaskServiceImplTransactionTest { public class TaskServiceImplTransactionTest {
@Test @Test
public void testStart() throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException { public void testStart() throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException {
JdbcDataSource ds = new JdbcDataSource(); JdbcDataSource ds = new JdbcDataSource();
ds.setURL("jdbc:h2:~/data/test-db-taskservice-int1"); ds.setURL("jdbc:h2:~/data/test-db-taskservice-int1");
ds.setPassword("sa"); ds.setPassword("sa");
ds.setUser("sa"); ds.setUser("sa");
TaskanaEngineConfiguration taskanaEngineConfiguration = new TaskanaEngineConfiguration(ds, true, false); TaskanaEngineConfiguration taskanaEngineConfiguration = new TaskanaEngineConfiguration(ds, true, false);
TaskanaEngineImpl te = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine(); TaskanaEngineImpl te = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine();
TaskServiceImpl taskServiceImpl = (TaskServiceImpl) te.getTaskService(); TaskServiceImpl taskServiceImpl = (TaskServiceImpl) te.getTaskService();
Task task = new Task(); Task task = new Task();
task.setName("Unit Test Task"); task.setName("Unit Test Task");
task.setWorkbasketId("1"); task.setWorkbasketId("1");
task = taskServiceImpl.create(task); task = taskServiceImpl.create(task);
te.closeSession(); te.closeSession();
TaskanaEngine te2 = taskanaEngineConfiguration.buildTaskanaEngine(); TaskanaEngine te2 = taskanaEngineConfiguration.buildTaskanaEngine();
TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService(); TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService();
Task resultTask = taskServiceImpl2.getTaskById(task.getId()); Task resultTask = taskServiceImpl2.getTaskById(task.getId());
Assert.assertNotNull(resultTask); Assert.assertNotNull(resultTask);
} }
@Test(expected = TaskNotFoundException.class) @Test(expected = TaskNotFoundException.class)
public void testStartTransactionFail() public void testStartTransactionFail()
throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException { throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException {
JdbcDataSource ds = new JdbcDataSource(); JdbcDataSource ds = new JdbcDataSource();
ds.setURL("jdbc:h2:~/data/test-db-taskservice-trans2"); ds.setURL("jdbc:h2:~/data/test-db-taskservice-trans2");
ds.setPassword("sa"); ds.setPassword("sa");
ds.setUser("sa"); ds.setUser("sa");
TaskanaEngineConfiguration taskanaEngineConfiguration = new TaskanaEngineConfiguration(ds, false, false); TaskanaEngineConfiguration taskanaEngineConfiguration = new TaskanaEngineConfiguration(ds, false, false);
TaskanaEngineImpl te = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine(); TaskanaEngineImpl te = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine();
TaskServiceImpl taskServiceImpl = (TaskServiceImpl) te.getTaskService(); TaskServiceImpl taskServiceImpl = (TaskServiceImpl) te.getTaskService();
Task task = new Task(); Task task = new Task();
task.setName("Unit Test Task"); task.setName("Unit Test Task");
task.setWorkbasketId("1"); task.setWorkbasketId("1");
task = taskServiceImpl.create(task); task = taskServiceImpl.create(task);
taskServiceImpl.getTaskById("1"); taskServiceImpl.getTaskById("1");
te.closeSession(); te.closeSession();
TaskanaEngineImpl te2 = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine(); TaskanaEngineImpl te2 = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine();
TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService(); TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService();
taskServiceImpl2.getTaskById("1"); taskServiceImpl2.getTaskById("1");
} }
@Test @Test
public void testCreateTaskInTaskanaWithDefaultDb() public void testCreateTaskInTaskanaWithDefaultDb()
throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException { throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException {
TaskanaEngineConfiguration taskanaEngineConfiguration = new TaskanaEngineConfiguration(null, false, false); TaskanaEngineConfiguration taskanaEngineConfiguration = new TaskanaEngineConfiguration(null, false, false);
TaskanaEngine te = taskanaEngineConfiguration.buildTaskanaEngine(); TaskanaEngine te = taskanaEngineConfiguration.buildTaskanaEngine();
TaskServiceImpl taskServiceImpl = (TaskServiceImpl) te.getTaskService(); TaskServiceImpl taskServiceImpl = (TaskServiceImpl) te.getTaskService();
Task task = new Task(); Task task = new Task();
task.setName("Unit Test Task"); task.setName("Unit Test Task");
task.setWorkbasketId("1"); task.setWorkbasketId("1");
task = taskServiceImpl.create(task); task = taskServiceImpl.create(task);
Assert.assertNotNull(task); Assert.assertNotNull(task);
Assert.assertNotNull(task.getId()); Assert.assertNotNull(task.getId());
} }
} }

275
lib/taskana-core/src/test/java/org/taskana/impl/integration/WorkbasketServiceImplIntTest.java
View File

@ -19,157 +19,166 @@ import org.taskana.exceptions.WorkbasketNotFoundException;
import org.taskana.model.Workbasket; import org.taskana.model.Workbasket;
import org.taskana.model.WorkbasketAccessItem; import org.taskana.model.WorkbasketAccessItem;
/**
* Integration Test for workbasketServiceImpl.
* @author EH
*/
public class WorkbasketServiceImplIntTest { public class WorkbasketServiceImplIntTest {
WorkbasketService workbasketServiceImpl; private static final int SLEEP_TIME = 100;
static int counter = 0; private static final int THREE = 3;
@Before WorkbasketService workbasketServiceImpl;
public void setup() throws FileNotFoundException, SQLException, LoginException { static int counter = 0;
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);
TaskanaEngine te = taskEngineConfiguration.buildTaskanaEngine(); @Before
workbasketServiceImpl = te.getWorkbasketService(); 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 TaskanaEngine te = taskEngineConfiguration.buildTaskanaEngine();
public void testInsertWorkbasket() throws NotAuthorizedException { workbasketServiceImpl = te.getWorkbasketService();
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 @Test
public void testSelectAllWorkbaskets() throws NotAuthorizedException { public void testInsertWorkbasket() throws NotAuthorizedException {
int before = workbasketServiceImpl.getWorkbaskets().size(); int before = workbasketServiceImpl.getWorkbaskets().size();
Workbasket workbasket0 = new Workbasket(); Workbasket workbasket = new Workbasket();
workbasket0.setId("0"); workbasket.setId("1");
workbasket0.setName("Superbasket"); workbasket.setName("Megabasket");
workbasketServiceImpl.createWorkbasket(workbasket0); workbasketServiceImpl.createWorkbasket(workbasket);
Workbasket workbasket1 = new Workbasket(); Assert.assertEquals(before + 1, workbasketServiceImpl.getWorkbaskets().size());
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 @Test
public void testSelectWorkbasket() throws WorkbasketNotFoundException, NotAuthorizedException { public void testSelectAllWorkbaskets() throws NotAuthorizedException {
Workbasket workbasket0 = new Workbasket(); int before = workbasketServiceImpl.getWorkbaskets().size();
workbasket0.setId("0"); Workbasket workbasket0 = new Workbasket();
workbasket0.setName("Superbasket"); workbasket0.setId("0");
workbasketServiceImpl.createWorkbasket(workbasket0); workbasket0.setName("Superbasket");
Workbasket workbasket1 = new Workbasket(); workbasketServiceImpl.createWorkbasket(workbasket0);
workbasket1.setId("1"); Workbasket workbasket1 = new Workbasket();
workbasket1.setName("Megabasket"); workbasket1.setId("1");
workbasketServiceImpl.createWorkbasket(workbasket1); workbasket1.setName("Megabasket");
Workbasket workbasket2 = new Workbasket(); workbasketServiceImpl.createWorkbasket(workbasket1);
workbasket2.setId("2"); Workbasket workbasket2 = new Workbasket();
workbasket2.setName("Hyperbasket"); workbasket2.setId("2");
workbasketServiceImpl.createWorkbasket(workbasket2); workbasket2.setName("Hyperbasket");
Workbasket foundWorkbasket = workbasketServiceImpl.getWorkbasket("2"); workbasketServiceImpl.createWorkbasket(workbasket2);
Assert.assertEquals("2", foundWorkbasket.getId()); Assert.assertEquals(before + THREE, workbasketServiceImpl.getWorkbaskets().size());
} }
@Test(expected = WorkbasketNotFoundException.class) @Test
public void testGetWorkbasketFail() throws WorkbasketNotFoundException { public void testSelectWorkbasket() throws WorkbasketNotFoundException, NotAuthorizedException {
workbasketServiceImpl.getWorkbasket("fail"); 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 @Test(expected = WorkbasketNotFoundException.class)
public void testSelectWorkbasketWithDistribution() throws WorkbasketNotFoundException, NotAuthorizedException { public void testGetWorkbasketFail() throws WorkbasketNotFoundException {
Workbasket workbasket0 = new Workbasket(); workbasketServiceImpl.getWorkbasket("fail");
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 @Test
public void testUpdateWorkbasket() throws Exception { public void testSelectWorkbasketWithDistribution() throws WorkbasketNotFoundException, NotAuthorizedException {
Workbasket workbasket0 = new Workbasket(); Workbasket workbasket0 = new Workbasket();
workbasket0.setId("0"); workbasket0.setId("0");
workbasket0.setName("Superbasket"); workbasket0.setName("Superbasket");
Workbasket workbasket1 = new Workbasket(); Workbasket workbasket1 = new Workbasket();
workbasket1.setId("1"); workbasket1.setId("1");
workbasket1.setName("Megabasket"); workbasket1.setName("Megabasket");
Workbasket workbasket2 = new Workbasket(); Workbasket workbasket2 = new Workbasket();
workbasket2.setId("2"); workbasket2.setId("2");
workbasket2.setName("Hyperbasket"); workbasket2.setName("Hyperbasket");
workbasket2.getDistributionTargets().add(workbasket0); workbasket2.setDistributionTargets(new ArrayList<>());
workbasket2.getDistributionTargets().add(workbasket1); workbasket2.getDistributionTargets().add(workbasket0);
workbasketServiceImpl.createWorkbasket(workbasket2); 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(); @Test
workbasket3.setId("3"); public void testUpdateWorkbasket() throws Exception {
workbasket3.setName("hm ... irgend ein basket"); Workbasket workbasket0 = new Workbasket();
workbasket2.getDistributionTargets().clear(); workbasket0.setId("0");
workbasket2.getDistributionTargets().add(workbasket3); workbasket0.setName("Superbasket");
Thread.sleep(100); Workbasket workbasket1 = new Workbasket();
workbasketServiceImpl.updateWorkbasket(workbasket2); 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<Workbasket> distributionTargets = foundBasket.getDistributionTargets(); Workbasket foundBasket = workbasketServiceImpl.getWorkbasket(workbasket2.getId());
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());
}
@Test List<Workbasket> distributionTargets = foundBasket.getDistributionTargets();
public void testInsertWorkbasketAccessUser() throws NotAuthorizedException { Assert.assertEquals(1, distributionTargets.size());
WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); Assert.assertEquals("3", distributionTargets.get(0).getId());
accessItem.setWorkbasketId("1"); Assert.assertNotEquals(workbasketServiceImpl.getWorkbasket("2").getCreated(),
accessItem.setUserId("Arthur Dent"); workbasketServiceImpl.getWorkbasket("2").getModified());
accessItem.setOpen(true); Assert.assertEquals(workbasketServiceImpl.getWorkbasket("1").getCreated(),
accessItem.setRead(true); workbasketServiceImpl.getWorkbasket("1").getModified());
workbasketServiceImpl.createWorkbasketAuthorization(accessItem); Assert.assertEquals(workbasketServiceImpl.getWorkbasket("3").getCreated(),
workbasketServiceImpl.getWorkbasket("3").getModified());
}
Assert.assertEquals(1, workbasketServiceImpl.getAllAuthorizations().size()); @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);
@Test Assert.assertEquals(1, workbasketServiceImpl.getAllAuthorizations().size());
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()); @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);
accessItem.setUserId("Zaphod Beeblebrox"); Assert.assertEquals(1, workbasketServiceImpl.getAllAuthorizations().size());
workbasketServiceImpl.updateWorkbasketAuthorization(accessItem);
Assert.assertEquals("Zaphod Beeblebrox", workbasketServiceImpl.getWorkbasketAuthorization(accessItem.getId()).getUserId()); accessItem.setUserId("Zaphod Beeblebrox");
} workbasketServiceImpl.updateWorkbasketAuthorization(accessItem);
Assert.assertEquals("Zaphod Beeblebrox",
workbasketServiceImpl.getWorkbasketAuthorization(accessItem.getId()).getUserId());
}
} }