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

Merge pull request #19 from eberhardmayer/master 

added checkstyle
This commit is contained in:
Holger Hagen 2017-07-05 14:58:38 +02:00 committed by GitHub
parent 29126778ec a251158ca1
commit e84170ce88
41 changed files with 2520 additions and 2312 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
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>

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

@ -55,4 +55,42 @@
<scope>test</scope> <scope>test</scope>
</dependency> </dependency>
</dependencies> </dependencies>
</project> <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>

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);
} }

204
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.
*
* @param taskId the id of the task to be updated
* @param isRead the new status of the read flag.
* @return Task the updated Task
*/
public Task setTaskRead(String taskId, boolean isRead) throws TaskNotFoundException;
public List<DueWorkbasketCounter> getTaskCountByWorkbasketAndDaysInPastAndState(long daysInPast, /**
List<TaskState> states); * Marks a task as read.
* @param taskId
* the id of the task to be updated
* @param isRead
* the new status of the read flag.
* @return Task the updated Task
*/
Task setTaskRead(String taskId, boolean isRead) throws TaskNotFoundException;
List<DueWorkbasketCounter> getTaskCountByWorkbasketAndDaysInPastAndState(long daysInPast, 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;
}
} }

125
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) {
this.dataSource = dataSource;
} else {
// use default In Memory datasource
this.dataSource = createDefaultDataSource();
}
dbScriptRunner = new DbScriptRunner(this.dataSource);
dbScriptRunner.run();
this.securityEnabled = securityEnabled; if (dataSource != null) {
} this.dataSource = dataSource;
} else {
// use default In Memory datasource
this.dataSource = createDefaultDataSource();
}
dbScriptRunner = new DbScriptRunner(this.dataSource);
dbScriptRunner.run();
public DataSource createDefaultDataSource() { this.securityEnabled = securityEnabled;
logger.warn("No datasource is provided. A inmemory db is used: " }
+ "'org.h2.Driver', 'jdbc:h2:mem:taskana', 'sa', 'sa'");
return createDatasource(H2_DRIVER, JDBC_H2_MEM_TASKANA, USER_PASSWORD, USER_PASSWORD);
}
/** public DataSource createDefaultDataSource() {
* This method creates the TaskanaEngine without an sqlSessionFactory LOGGER.warn("No datasource is provided. A inmemory db is used: "
* + "'org.h2.Driver', 'jdbc:h2:mem:taskana', 'sa', 'sa'");
* @return the TaskanaEngine return createDatasource(H2_DRIVER, JDBC_H2_MEM_TASKANA, USER_PASSWORD, USER_PASSWORD);
* @throws SQLException }
*/
public TaskanaEngine buildTaskanaEngine() throws SQLException {
return new TaskanaEngineImpl(this);
}
/** /**
* This method creates a PooledDataSource, if the needed properties are * This method creates the TaskanaEngine without an sqlSessionFactory.
* provided * @return the TaskanaEngine
* * @throws SQLException
* @param dbConfiguration */
* @return DataSource public TaskanaEngine buildTaskanaEngine() throws SQLException {
*/ return new TaskanaEngineImpl(this);
public DataSource createDatasource(String driver, String jdbcUrl, String username, String password) { }
return new PooledDataSource(driver, jdbcUrl, username, password);
}
public boolean isSecurityEnabled() { /**
return this.securityEnabled; * This method creates a PooledDataSource, if the needed properties are provided.
} * @param dbConfiguration
* @return DataSource
*/
public DataSource createDatasource(String driver, String jdbcUrl, String username, String password) {
return new PooledDataSource(driver, jdbcUrl, username, password);
}
public DataSource getDatasource() { public boolean isSecurityEnabled() {
return this.dataSource; return this.securityEnabled;
} }
public boolean getUseContainerManagedTransactions() { public DataSource getDatasource() {
return this.useContainerManagedTransactions; return this.dataSource;
} }
public boolean getUseContainerManagedTransactions() {
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");
} }
} }

105
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;
public ClassificationServiceImpl(ClassificationMapper classificationMapper) { private ClassificationMapper classificationMapper;
super();
this.classificationMapper = classificationMapper;
}
@Override public ClassificationServiceImpl(ClassificationMapper classificationMapper) {
public List<Classification> selectClassifications() { super();
final List<Classification> rootClassifications = classificationMapper.findByParentId(""); this.classificationMapper = classificationMapper;
populateChildClassifications(rootClassifications); }
return rootClassifications;
}
private void populateChildClassifications(final List<Classification> classifications) { @Override
for (Classification classification : classifications) { public List<Classification> selectClassifications() {
List<Classification> childClassifications = classificationMapper.findByParentId(classification.getId()); final List<Classification> rootClassifications = classificationMapper.findByParentId("");
classification.setChildren(childClassifications); populateChildClassifications(rootClassifications);
populateChildClassifications(childClassifications); return rootClassifications;
} }
}
@Override private void populateChildClassifications(final List<Classification> classifications) {
public List<Classification> selectClassificationsByParentId(String parentId) { for (Classification classification : classifications) {
return classificationMapper.findByParentId(parentId); List<Classification> childClassifications = classificationMapper.findByParentId(classification.getId());
} classification.setChildren(childClassifications);
populateChildClassifications(childClassifications);
}
}
@Override @Override
public void insertClassification(Classification classification) { public List<Classification> selectClassificationsByParentId(String parentId) {
classification.setId(IdGenerator.generateWithPrefix(ID_PREFIX_CLASSIFICATION)); return classificationMapper.findByParentId(parentId);
classification.setCreated(Date.valueOf(LocalDate.now())); }
classification.setModified(Date.valueOf(LocalDate.now()));
this.checkServiceLevel(classification);
classificationMapper.insert(classification); @Override
} public void insertClassification(Classification classification) {
classification.setId(IdGenerator.generateWithPrefix(ID_PREFIX_CLASSIFICATION));
classification.setCreated(Date.valueOf(LocalDate.now()));
classification.setModified(Date.valueOf(LocalDate.now()));
this.checkServiceLevel(classification);
@Override classificationMapper.insert(classification);
public void updateClassification(Classification classification) { }
classification.setModified(Date.valueOf(LocalDate.now()));
this.checkServiceLevel(classification);
classificationMapper.update(classification); @Override
} public void updateClassification(Classification classification) {
classification.setModified(Date.valueOf(LocalDate.now()));
this.checkServiceLevel(classification);
@Override classificationMapper.update(classification);
public Classification selectClassificationById(String id) { }
return classificationMapper.findById(id);
}
private void checkServiceLevel(Classification classification) { @Override
if (classification.getServiceLevel() != null) { public Classification selectClassificationById(String id) {
try { return classificationMapper.findById(id);
Duration.parse(classification.getServiceLevel()); }
} catch (Exception e) {
throw new IllegalArgumentException("Invalid timestamp. Please use the format 'PddDThhHmmM'"); private void checkServiceLevel(Classification classification) {
} if (classification.getServiceLevel() != null) {
} try {
} Duration.parse(classification.getServiceLevel());
} catch (Exception e) {
throw new IllegalArgumentException("Invalid timestamp. Please use the format 'PddDThhHmmM'");
}
}
}
} }

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

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();
} }
} }
} }

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

46
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 String workbasketId;
private long taskCounter;
public Date getDue() { private Date due;
return due; private String workbasketId;
} private long taskCounter;
public void setDue(Date due) { public Date getDue() {
this.due = due; return due;
} }
public String getWorkbasketId() { public void setDue(Date due) {
return workbasketId; this.due = due;
} }
public void setWorkbasketId(String workbasketId) { public String getWorkbasketId() {
this.workbasketId = workbasketId; return workbasketId;
} }
public long getTaskCounter() { public void setWorkbasketId(String workbasketId) {
return taskCounter; this.workbasketId = workbasketId;
} }
public void setTaskCounter(long taskCounter) { public long getTaskCounter() {
this.taskCounter = taskCounter; return taskCounter;
} }
public void setTaskCounter(long 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
} }

55
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")
List<Classification> findByParentId(@Param("parentClassificationId") String parentId);
@Select("SELECT * FROM CLASSIFICATION WHERE PARENT_CLASSIFICATION_ID = #{parentClassificationId} ORDER BY ID")
List<Classification> findByParentId(@Param("parentClassificationId") String parentId); @Select("SELECT * FROM CLASSIFICATION WHERE ID = #{classificationId}")
Classification findById(@Param("classificationId") String classificationId);
@Select("SELECT * FROM CLASSIFICATION WHERE ID = #{classificationId}")
Classification findById(@Param("classificationId") String classificationId); @Insert("INSERT INTO CLASSIFICATION (ID, TENANT_ID, PARENT_CLASSIFICATION_ID, CATEGORY, TYPE, CREATED, NAME, DESCRIPTION, PRIORITY, SERVICE_LEVEL) VALUES (#{classification.id}, #{classification.tenantId}, #{classification.parentClassificationId}, #{classification.category}, #{classification.type}, #{classification.created}, #{classification.name}, #{classification.description}, #{classification.priority}, #{classification.serviceLevel})")
void insert(@Param("classification") Classification classification);
@Insert("INSERT INTO CLASSIFICATION (ID, TENANT_ID, PARENT_CLASSIFICATION_ID, CATEGORY, TYPE, CREATED, NAME, DESCRIPTION, PRIORITY, SERVICE_LEVEL) VALUES (#{classification.id}, #{classification.tenantId}, #{classification.parentClassificationId}, #{classification.category}, #{classification.type}, #{classification.created}, #{classification.name}, #{classification.description}, #{classification.priority}, #{classification.serviceLevel})")
void insert(@Param("classification") Classification classification); @Update(value = "UPDATE CLASSIFICATION SET TENANT_ID = #{classification.tenantId}, PARENT_CLASSIFICATION_ID = #{classification.parentClassificationId}, CATEGORY = #{classification.category}, TYPE = #{classification.type}, NAME = #{classification.name}, DESCRIPTION = #{classification.description}, PRIORITY = #{classification.priority}, SERVICE_LEVEL = #{classification.serviceLevel}, MODIFIED = #{classification.modified} WHERE ID = #{classification.id}")
void update(@Param("classification") Classification classification);
@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);
} }

26
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})")
void insert(@Param("sourceId") String sourceId, @Param("targetId") String targetId);
@Delete("DELETE FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{sourceId} AND TARGET_ID = #{targetId}")
void delete(@Param("sourceId") String sourceId, @Param("targetId") String targetId);
@Select("SELECT TARGET_ID FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{sourceId}") @Insert("INSERT INTO DISTRIBUTION_TARGETS (SOURCE_ID, TARGET_ID) VALUES (#{sourceId}, #{targetId})")
List<String> findBySourceId(@Param("sourceId") String sourceId); void insert(@Param("sourceId") String sourceId, @Param("targetId") String targetId);
@Delete("<script>DELETE FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{sourceId} AND TARGET_ID IN (<foreach item='target' collection='targetId' separator=',' > #{target} </foreach>)</script>") @Delete("DELETE FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{sourceId} AND TARGET_ID = #{targetId}")
void deleteMultiple(@Param("sourceId") String sourceId, @Param("targetId") List<String> targetId); void delete(@Param("sourceId") String sourceId, @Param("targetId") String targetId);
@Select("SELECT TARGET_ID FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{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>")
void deleteMultiple(@Param("sourceId") String sourceId, @Param("targetId") List<String> targetId);
} }

111
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 "
+ "FROM OBJECT_REFERENCE "
@Select("SELECT ID, TENANT_ID, COMPANY, SYSTEM, SYSTEM_INSTANCE, TYPE, VALUE " + "WHERE TENANT_ID = #{objectReference.tenantId} "
+ "FROM OBJECT_REFERENCE " + "AND COMPANY = #{objectReference.company} "
+ "WHERE TENANT_ID = #{objectReference.tenantId} " + "AND SYSTEM = #{objectReference.system} "
+ "AND COMPANY = #{objectReference.company} " + "AND SYSTEM_INSTANCE = #{objectReference.systemInstance} "
+ "AND SYSTEM = #{objectReference.system} " + "AND TYPE = #{objectReference.type} "
+ "AND SYSTEM_INSTANCE = #{objectReference.systemInstance} " + "AND VALUE = #{objectReference.value}")
+ "AND TYPE = #{objectReference.type} " @Results({
+ "AND VALUE = #{objectReference.value}") @Result(property = "id", column = "ID"),
@Results({ @Result(property = "tenantId", column = "TENANT_ID"),
@Result(property="id", column="ID"), @Result(property = "company", column = "COMPANY"),
@Result(property="tenantId", column="TENANT_ID"), @Result(property = "system", column = "SYSTEM"),
@Result(property="company", column="COMPANY"), @Result(property = "systemInstance", column = "SYSTEM_INSTANCE"),
@Result(property="system", column="SYSTEM"), @Result(property = "type", column = "TYPE"),
@Result(property="systemInstance", column="SYSTEM_INSTANCE"), @Result(property = "value", column = "VALUE") })
@Result(property="type", column="TYPE"), ObjectReference findByObjectReference(@Param("objectReference") ObjectReference objectReference);
@Result(property="value", column="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})")
ObjectReference findByObjectReference(@Param("objectReference") ObjectReference objectReference); void insert(@Param("ref") ObjectReference ref);
@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})") @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 insert(@Param("ref") ObjectReference ref); void update(@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}") @Delete("DELETE FROM OBJECT_REFERENCE WHERE ID = #{id}")
void update(@Param("ref") ObjectReference ref); void delete(String id);
@Delete("DELETE FROM OBJECT_REFERENCE WHERE ID = #{id}")
void delete(String id);
} }

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

@ -17,18 +17,19 @@ 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"),
@Result(property = "created", column = "CREATED"), @Result(property = "created", column = "CREATED"),
@Result(property = "claimed", column = "CLAIMED"), @Result(property = "claimed", column = "CLAIMED"),
@Result(property = "completed", column = "COMPLETED"), @Result(property = "completed", column = "COMPLETED"),
@Result(property = "modified", column = "MODIFIED"), @Result(property = "modified", column = "MODIFIED"),
@Result(property = "planned", column = "PLANNED"), @Result(property = "planned", column = "PLANNED"),
@Result(property = "due", column = "DUE"), @Result(property = "due", column = "DUE"),
@ -39,21 +40,19 @@ 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} " @Results(value = {
+ "ORDER BY ID") @Result(property = "id", column = "ID"),
@Results(value = {
@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 = "claimed", column = "CLAIMED"), @Result(property = "claimed", column = "CLAIMED"),
@Result(property = "completed", column = "COMPLETED"), @Result(property = "completed", column = "COMPLETED"),
@Result(property = "modified", column = "MODIFIED"), @Result(property = "modified", column = "MODIFIED"),
@Result(property = "planned", column = "PLANNED"), @Result(property = "planned", column = "PLANNED"),
@Result(property = "due", column = "DUE"), @Result(property = "due", column = "DUE"),
@ -64,24 +63,23 @@ 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"),
@Result(property = "created", column = "CREATED"), @Result(property = "created", column = "CREATED"),
@Result(property = "claimed", column = "CLAIMED"), @Result(property = "claimed", column = "CLAIMED"),
@Result(property = "completed", column = "COMPLETED"), @Result(property = "completed", column = "COMPLETED"),
@Result(property = "modified", column = "MODIFIED"), @Result(property = "modified", column = "MODIFIED"),
@Result(property = "planned", column = "PLANNED"), @Result(property = "planned", column = "PLANNED"),
@Result(property = "due", column = "DUE"), @Result(property = "due", column = "DUE"),
@ -92,23 +90,23 @@ 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 "
+ "FROM TASK " + "FROM TASK "
+ "WHERE STATE IN (<foreach item='item' collection='states' separator=',' >#{item}</foreach>) " + "WHERE 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"),
@Result(property = "created", column = "CREATED"), @Result(property = "created", column = "CREATED"),
@Result(property = "claimed", column = "CLAIMED"), @Result(property = "claimed", column = "CLAIMED"),
@Result(property = "completed", column = "COMPLETED"), @Result(property = "completed", column = "COMPLETED"),
@Result(property = "modified", column = "MODIFIED"), @Result(property = "modified", column = "MODIFIED"),
@Result(property = "planned", column = "PLANNED"), @Result(property = "planned", column = "PLANNED"),
@Result(property = "due", column = "DUE"), @Result(property = "due", column = "DUE"),
@ -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 CAST(DUE AS DATE) as DUE_DATE, WORKBASKETID, COUNT (*) as counter "
+ "FROM TASK "
+ "WHERE DUE >= #{fromDate} "
+ "AND STATE IN (<foreach collection='status' item='state' separator=','>#{state}</foreach>) "
+ "GROUP BY DUE_DATE, WORKBASKETID"
+ "</script>")
@Results({
@Result(column="DUE_DATE", property="due"),
@Result(column="WORKBASKETID", property="workbasketId"),
@Result(column="counter", property="taskCounter")
})
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) "
+ "VALUES(#{id}, #{tenantId}, #{created}, #{claimed}, #{completed}, #{modified}, #{planned}, #{due}, #{name}, #{description}, #{priority}, #{state}, #{type}, #{workbasketId}, #{owner}, #{primaryObjRef.id}, #{isRead}, #{isTransferred})")
@Options(keyProperty = "id", keyColumn="ID")
void insert(Task task);
@Update("UPDATE TASK SET TENANT_ID = #{tenantId}, CLAIMED = #{claimed}, COMPLETED = #{completed}, MODIFIED = #{modified}, PLANNED = #{planned}, DUE = #{due}, NAME = #{name}, DESCRIPTION = #{description}, PRIORITY = #{priority}, STATE = #{state}, TYPE = #{type}, WORKBASKETID = #{workbasketId}, OWNER = #{owner}, PRIMARY_OBJ_REF_ID = #{primaryObjRef.id}, IS_READ = #{isRead}, IS_TRANSFERRED = #{isTransferred} WHERE ID = #{id}") @Select("<script>"
void update(Task task); + "SELECT CAST(DUE AS DATE) as DUE_DATE, WORKBASKETID, COUNT (*) as counter "
+ "FROM TASK "
+ "WHERE DUE >= #{fromDate} "
+ "AND STATE IN (<foreach collection='status' item='state' separator=','>#{state}</foreach>) "
+ "GROUP BY DUE_DATE, WORKBASKETID"
+ "</script>")
@Results({ @Result(column = "DUE_DATE", property = "due"),
@Result(column = "WORKBASKETID", property = "workbasketId"),
@Result(column = "counter", property = "taskCounter") })
List<DueWorkbasketCounter> getTaskCountByWorkbasketIdAndDaysInPastAndState(@Param("fromDate") Date fromDate, @Param("status") List<TaskState> states);
@Delete("DELETE FROM TASK WHERE ID = #{id}") @Insert("INSERT INTO TASK(ID, TENANT_ID, CREATED, CLAIMED, COMPLETED, MODIFIED, PLANNED, DUE, NAME, DESCRIPTION, PRIORITY, STATE, TYPE, WORKBASKETID, OWNER, PRIMARY_OBJ_REF_ID, IS_READ, IS_TRANSFERRED) "
void delete(String id); + "VALUES(#{id}, #{tenantId}, #{created}, #{claimed}, #{completed}, #{modified}, #{planned}, #{due}, #{name}, #{description}, #{priority}, #{state}, #{type}, #{workbasketId}, #{owner}, #{primaryObjRef.id}, #{isRead}, #{isTransferred})")
@Options(keyProperty = "id", keyColumn = "ID")
void insert(Task task);
@Update("UPDATE TASK SET TENANT_ID = #{tenantId}, CLAIMED = #{claimed}, COMPLETED = #{completed}, MODIFIED = #{modified}, PLANNED = #{planned}, DUE = #{due}, NAME = #{name}, DESCRIPTION = #{description}, PRIORITY = #{priority}, STATE = #{state}, TYPE = #{type}, WORKBASKETID = #{workbasketId}, OWNER = #{owner}, PRIMARY_OBJ_REF_ID = #{primaryObjRef.id}, IS_READ = #{isRead}, IS_TRANSFERRED = #{isTransferred} WHERE ID = #{id}")
void update(Task task);
@Delete("DELETE FROM TASK WHERE ID = #{id}")
void delete(String id);
} }

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

@ -11,12 +11,14 @@ 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}")
@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"),
@Result(property = "userId", column = "USER_ID"), @Result(property = "userId", column = "USER_ID"),
@Result(property = "groupId", column = "GROUP_ID"), @Result(property = "groupId", column = "GROUP_ID"),
@ -24,12 +26,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") })
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}")
@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"),
@Result(property = "userId", column = "USER_ID"), @Result(property = "userId", column = "USER_ID"),
@Result(property = "groupId", column = "GROUP_ID"), @Result(property = "groupId", column = "GROUP_ID"),
@ -37,12 +39,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> 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}")
@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"),
@Result(property = "userId", column = "USER_ID"), @Result(property = "userId", column = "USER_ID"),
@Result(property = "groupId", column = "GROUP_ID"), @Result(property = "groupId", column = "GROUP_ID"),
@ -50,12 +52,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> 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")
@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"),
@Result(property = "userId", column = "USER_ID"), @Result(property = "userId", column = "USER_ID"),
@Result(property = "groupId", column = "GROUP_ID"), @Result(property = "groupId", column = "GROUP_ID"),
@ -63,32 +65,32 @@ 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} "
+ "WHERE id = #{workbasketAccessItem.id}") + "WHERE id = #{workbasketAccessItem.id}")
void update(@Param("workbasketAccessItem") WorkbasketAccessItem workbasketAccessItem); void update(@Param("workbasketAccessItem") WorkbasketAccessItem workbasketAccessItem);
@Delete("DELETE FROM WORKBASKET_ACCESS_LIST where id = #{id}") @Delete("DELETE FROM WORKBASKET_ACCESS_LIST where id = #{id}")
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"),
@Result(property = "userId", column = "USER_ID"), @Result(property = "userId", column = "USER_ID"),
@Result(property = "groupId", column = "GROUP_ID"), @Result(property = "groupId", column = "GROUP_ID"),
@ -96,12 +98,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> 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}")
@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"),
@Result(property = "userId", column = "USER_ID"), @Result(property = "userId", column = "USER_ID"),
@Result(property = "groupId", column = "GROUP_ID"), @Result(property = "groupId", column = "GROUP_ID"),
@ -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);
} }

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

163
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;
* Returns the userid of the current user.
*
* @return String the userid. null if there is no JAAS subject.
*/
public static String getUserid() {
if (runningOnWebSphere()) {
return getUseridFromWSSubject();
} else {
return getUseridFromJAASSubject();
}
}
/** private CurrentUserContext() {
* Returns the unique security name of the first public credentials found in the WSSubject as userid. }
*
* @return the userid of the caller. If the userid could not be obtained, null is returned.
*/
private static String getUseridFromWSSubject() {
try {
Class<?> wsSubjectClass = Class.forName(WSSUBJECT_CLASSNAME);
Method getCallerSubjectMethod = wsSubjectClass.getMethod(GET_CALLER_SUBJECT_METHOD, (Class<?>[]) null);
Subject callerSubject = (Subject) getCallerSubjectMethod.invoke(null, (Object[]) null);
logger.debug("Subject of caller: {}", callerSubject);
if (callerSubject != null) {
Set<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 userid of the current user.
* * @return String the userid. null if there is no JAAS subject.
* @return true, if it is running on IBM WebSphere */
*/ public static String getUserid() {
private static boolean runningOnWebSphere() { if (runningOnWebSphere()) {
if (runningOnWebSphere == null) { return getUseridFromWSSubject();
try { } else {
Class.forName(WSSUBJECT_CLASSNAME); return getUseridFromJAASSubject();
logger.debug("WSSubject detected. Assuming that Taskana runs on IBM WebSphere."); }
runningOnWebSphere = new Boolean(true); }
} catch (ClassNotFoundException e) {
logger.debug("No WSSubject detected. Using JAAS subject further on.");
runningOnWebSphere = new Boolean(false);
}
}
return runningOnWebSphere;
}
private static String getUseridFromJAASSubject() { /**
Subject subject = Subject.getSubject(AccessController.getContext()); * Returns the unique security name of the first public credentials found in the
logger.debug("Subject of caller: {}", subject); * WSSubject as userid.
if (subject != null) { * @return the userid of the caller. If the userid could not be obtained, null
Set<Object> publicCredentials = subject.getPublicCredentials(); * is returned.
logger.debug("Public credentials of caller: {}", publicCredentials); */
for (Object pC : publicCredentials) { private static String getUseridFromWSSubject() {
logger.debug("Returning the first public credential: {}", pC.toString()); try {
return pC.toString(); Class<?> wsSubjectClass = Class.forName(WSSUBJECT_CLASSNAME);
} Method getCallerSubjectMethod = wsSubjectClass.getMethod(GET_CALLER_SUBJECT_METHOD, (Class<?>[]) null);
} Subject callerSubject = (Subject) getCallerSubjectMethod.invoke(null, (Object[]) null);
logger.debug("No userid found in subject!"); LOGGER.debug("Subject of caller: {}", callerSubject);
return null; 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;
}
public static List<String> getGroupIds() { /**
return null; * Checks, whether Taskana is running on IBM WebSphere.
} * @return true, if it is running on IBM WebSphere
*/
private static boolean runningOnWebSphere() {
if (runningOnWebSphere == null) {
try {
Class.forName(WSSUBJECT_CLASSNAME);
LOGGER.debug("WSSubject detected. Assuming that Taskana runs on IBM WebSphere.");
runningOnWebSphere = new Boolean(true);
} catch (ClassNotFoundException e) {
LOGGER.debug("No WSSubject detected. Using JAAS subject further on.");
runningOnWebSphere = new Boolean(false);
}
}
return runningOnWebSphere;
}
private static String getUseridFromJAASSubject() {
Subject subject = Subject.getSubject(AccessController.getContext());
LOGGER.debug("Subject of caller: {}", subject);
if (subject != null) {
Set<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;
}
} }

120
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);
Assert.assertNotNull(classificationService.selectClassificationById(classification.getId())); when(classificationMapper.findById(any())).thenReturn(classification);
}
@Test Assert.assertNotNull(classificationService.selectClassificationById(classification.getId()));
public void testFindAllClassifications() { }
doNothing().when(classificationMapper).insert(any());
Classification classification0 = new Classification(); @Test
classification0.setId("0"); public void testFindAllClassifications() {
classification0.setParentClassificationId(""); doNothing().when(classificationMapper).insert(any());
classificationService.insertClassification(classification0);
Classification classification1 = new Classification();
classification1.setId("1");
classification1.setParentClassificationId("");
classificationService.insertClassification(classification1);
List<Classification> classifications = new ArrayList<>();
classifications.add(classification0);
when(classificationMapper.findByParentId("")).thenReturn(classifications);
verify(classificationMapper, atLeast(2)).insert(any()); Classification classification0 = new Classification();
Assert.assertEquals(1, classificationService.selectClassifications().size()); classification0.setId("0");
} classification0.setParentClassificationId("");
classificationService.insertClassification(classification0);
Classification classification1 = new Classification();
classification1.setId("1");
classification1.setParentClassificationId("");
classificationService.insertClassification(classification1);
@Test List<Classification> classifications = new ArrayList<>();
public void testFindByParentClassification() { classifications.add(classification0);
doNothing().when(classificationMapper).insert(any()); when(classificationMapper.findByParentId("")).thenReturn(classifications);
Classification classification0 = new Classification(); verify(classificationMapper, atLeast(2)).insert(any());
classification0.setId("0"); Assert.assertEquals(1, classificationService.selectClassifications().size());
classification0.setParentClassificationId("0"); }
classificationService.insertClassification(classification0);
Classification classification1 = new Classification();
classification1.setId("1");
classification1.setParentClassificationId("0");
classificationService.insertClassification(classification1);
List<Classification> classifications = new ArrayList<>(); @Test
classifications.add(classification0); public void testFindByParentClassification() {
classifications.add(classification1); doNothing().when(classificationMapper).insert(any());
when(classificationMapper.findByParentId(any())).thenReturn(classifications);
verify(classificationMapper, atLeast(2)).insert(any()); Classification classification0 = new Classification();
classification0.setId("0");
classification0.setParentClassificationId("0");
classificationService.insertClassification(classification0);
Classification classification1 = new Classification();
classification1.setId("1");
classification1.setParentClassificationId("0");
classificationService.insertClassification(classification1);
Assert.assertEquals(2, classificationService.selectClassificationsByParentId("0").size()); List<Classification> classifications = new ArrayList<>();
} classifications.add(classification0);
classifications.add(classification1);
when(classificationMapper.findByParentId(any())).thenReturn(classifications);
@Test verify(classificationMapper, atLeast(2)).insert(any());
public void testModifiedClassification() {
doNothing().when(classificationMapper).insert(any());
doNothing().when(classificationMapper).update(any());
Classification classification = new Classification(); Assert.assertEquals(2, classificationService.selectClassificationsByParentId("0").size());
classificationService.insertClassification(classification); }
classification.setDescription("TEST EVERYTHING");
classificationService.updateClassification(classification);
Assert.assertEquals(classification.getModified().toString(), LocalDate.now().toString()); @Test
} public void testModifiedClassification() {
doNothing().when(classificationMapper).insert(any());
doNothing().when(classificationMapper).update(any());
Classification classification = new Classification();
classificationService.insertClassification(classification);
classification.setDescription("TEST EVERYTHING");
classificationService.updateClassification(classification);
Assert.assertEquals(classification.getModified().toString(), LocalDate.now().toString());
}
} }

330
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();
returnPrimaryObjRef.setId("1");
returnPrimaryObjRef.setSystem("Sol");
Mockito.when(objectReferenceMapper.findByObjectReference(any())).thenReturn(returnPrimaryObjRef); ObjectReference returnPrimaryObjRef = new ObjectReference();
Task createdTask = taskServiceImpl.create(task); returnPrimaryObjRef.setId("1");
returnPrimaryObjRef.setSystem("Sol");
Assert.assertNotNull(createdTask.getPrimaryObjRef()); Mockito.when(objectReferenceMapper.findByObjectReference(any())).thenReturn(returnPrimaryObjRef);
Assert.assertEquals("1", createdTask.getPrimaryObjRef().getId()); Task createdTask = taskServiceImpl.create(task);
Assert.assertEquals("Sol", createdTask.getPrimaryObjRef().getSystem());
}
private Task createUnitTestTask(String id, String name, String workbasketId) { Assert.assertNotNull(createdTask.getPrimaryObjRef());
Task task = new Task(); Assert.assertEquals("1", createdTask.getPrimaryObjRef().getId());
task.setId(id); Assert.assertEquals("Sol", createdTask.getPrimaryObjRef().getSystem());
task.setName(name); }
task.setWorkbasketId(workbasketId);
Timestamp now = new Timestamp(System.currentTimeMillis());
task.setCreated(now);
task.setModified(now);
Mockito.when(taskMapper.findById(any())).thenReturn(task);
return task;
}
private Workbasket createWorkbasket2() { private Task createUnitTestTask(String id, String name, String workbasketId) {
Workbasket workbasket2 = new Workbasket(); Task task = new Task();
workbasket2.setId("2"); task.setId(id);
workbasket2.setName("Workbasket 2"); task.setName(name);
return workbasket2; task.setWorkbasketId(workbasketId);
} Timestamp now = new Timestamp(System.currentTimeMillis());
task.setCreated(now);
task.setModified(now);
Mockito.when(taskMapper.findById(any())).thenReturn(task);
return task;
}
private void registerBasicMocks(boolean securityEnabled) { private Workbasket createWorkbasket2() {
Mockito.when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration); Workbasket workbasket2 = new Workbasket();
Mockito.when(taskanaEngineConfiguration.isSecurityEnabled()).thenReturn(securityEnabled); workbasket2.setId("2");
Mockito.when(taskanaEngine.getWorkbasketService()).thenReturn(workbasketServiceImpl); workbasket2.setName("Workbasket 2");
} return workbasket2;
}
private void registerBasicMocks(boolean securityEnabled) {
Mockito.when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration);
Mockito.when(taskanaEngineConfiguration.isSecurityEnabled()).thenReturn(securityEnabled);
Mockito.when(taskanaEngine.getWorkbasketService()).thenReturn(workbasketServiceImpl);
}
} }

409
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();
workbasket.setId("1");
workbasketServiceImpl.createWorkbasket(workbasket);
Assert.assertEquals("1", workbasket.getId()); verify(workbasketMapper).findAll();
Assert.assertEquals(workbasket.getModified(), workbasket.getCreated()); Assert.assertNotNull(workbaskets);
}
verify(workbasketMapper).insert(any()); @Test
} public void should_InitializeAndStoreWorkbasket_when_WorkbasketIsCreated() throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
@SuppressWarnings("serial") Workbasket workbasket = new Workbasket();
@Test workbasket.setId("1");
public void should_InitializeAndStoreWorkbasket_when_WorkbasketWithDistributionTargetsIsCreated() throws NotAuthorizedException { workbasketServiceImpl.createWorkbasket(workbasket);
doNothing().when(workbasketMapper).insert(any());
doNothing().when(distributionTargetMapper).insert(any(), any());
Workbasket workbasket = new Workbasket(); Assert.assertEquals("1", workbasket.getId());
workbasket.setId("1"); Assert.assertEquals(workbasket.getModified(), workbasket.getCreated());
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); verify(workbasketMapper).insert(any());
}
Assert.assertEquals("1", workbasket.getId()); @SuppressWarnings("serial")
Assert.assertEquals(workbasket.getModified(), workbasket.getCreated()); @Test
public void should_InitializeAndStoreWorkbasket_when_WorkbasketWithDistributionTargetsIsCreated()
throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
doNothing().when(distributionTargetMapper).insert(any(), any());
verify(workbasketMapper, times(3)).insert(any()); Workbasket workbasket = new Workbasket();
verify(distributionTargetMapper, times(2)).insert(any(), 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);
}
});
@Test workbasketServiceImpl.createWorkbasket(workbasket);
public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDescriptionIsChanged() throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
Workbasket workbasket = new Workbasket(); Assert.assertEquals("1", workbasket.getId());
workbasket.setId("0"); Assert.assertEquals(workbasket.getModified(), workbasket.getCreated());
workbasket.setDescription("TestDescription");
workbasket.setName("Cool New WorkintheBasket");
workbasket.setOwner("Arthur Dent");
workbasketServiceImpl.createWorkbasket(workbasket);
doNothing().when(workbasketMapper).update(any()); verify(workbasketMapper, times(THREE)).insert(any());
workbasket.setDescription("42"); verify(distributionTargetMapper, times(2)).insert(any(), any());
workbasketServiceImpl.updateWorkbasket(workbasket); }
verify(workbasketMapper).update(any()); @Test
} public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDescriptionIsChanged()
throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
@SuppressWarnings("serial") Workbasket workbasket = new Workbasket();
@Test workbasket.setId("0");
public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDistributionTargetIsChanged() workbasket.setDescription("TestDescription");
throws NotAuthorizedException { workbasket.setName("Cool New WorkintheBasket");
doNothing().when(workbasketMapper).insert(any()); workbasket.setOwner("Arthur Dent");
workbasketServiceImpl.createWorkbasket(workbasket);
Workbasket workbasket = new Workbasket(); doNothing().when(workbasketMapper).update(any());
workbasket.setId("0"); workbasket.setDescription("42");
Workbasket workbasket1 = new Workbasket(); workbasketServiceImpl.updateWorkbasket(workbasket);
workbasket1.setId("1");
workbasket.setDistributionTargets(new ArrayList<Workbasket>() {
{
add(workbasket1);
}
});
workbasketServiceImpl.createWorkbasket(workbasket);
doNothing().when(workbasketMapper).update(any()); verify(workbasketMapper).update(any());
when(workbasketMapper.findById(any())).thenReturn(workbasket); }
workbasket.getDistributionTargets().get(0).setDescription("Test123");
Workbasket result = workbasketServiceImpl.updateWorkbasket(workbasket);
verify(workbasketMapper).update(any()); @SuppressWarnings("serial")
Assert.assertEquals("Test123", result.getDistributionTargets().get(0).getDescription()); @Test
} public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDistributionTargetIsChanged()
throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
@Test Workbasket workbasket = new Workbasket();
public void should_UpdateModifiedTimestamp_when_ExistingWorkbasketDistributionTargetIsChanged() workbasket.setId("0");
throws Exception { Workbasket workbasket1 = new Workbasket();
doNothing().when(workbasketMapper).insert(any()); workbasket1.setId("1");
workbasket.setDistributionTargets(new ArrayList<Workbasket>() {
{
add(workbasket1);
}
});
workbasketServiceImpl.createWorkbasket(workbasket);
Workbasket workbasket0 = new Workbasket(); doNothing().when(workbasketMapper).update(any());
workbasket0.setId("0"); when(workbasketMapper.findById(any())).thenReturn(workbasket);
Workbasket workbasket1 = new Workbasket(); workbasket.getDistributionTargets().get(0).setDescription("Test123");
workbasket1.setId("1"); Workbasket result = workbasketServiceImpl.updateWorkbasket(workbasket);
Workbasket workbasket2 = new Workbasket();
workbasket2.setId("2");
workbasket2.getDistributionTargets().add(workbasket0);
workbasket2.getDistributionTargets().add(workbasket1);
workbasketServiceImpl.createWorkbasket(workbasket2);
Workbasket workbasket3 = new Workbasket(); verify(workbasketMapper).update(any());
workbasket3.setId("3"); Assert.assertEquals("Test123", result.getDistributionTargets().get(0).getDescription());
workbasket2.getDistributionTargets().clear(); }
workbasket2.getDistributionTargets().add(workbasket3);
Thread.sleep(100);
doNothing().when(workbasketMapper).update(any()); @Test
workbasketServiceImpl.updateWorkbasket(workbasket2); public void should_UpdateModifiedTimestamp_when_ExistingWorkbasketDistributionTargetIsChanged() throws Exception {
doNothing().when(workbasketMapper).insert(any());
when(workbasketMapper.findById("2")).thenReturn(workbasket2); Workbasket workbasket0 = new Workbasket();
Workbasket foundBasket = workbasketServiceImpl.getWorkbasket(workbasket2.getId()); workbasket0.setId("0");
Workbasket workbasket1 = new Workbasket();
workbasket1.setId("1");
Workbasket workbasket2 = new Workbasket();
workbasket2.setId("2");
workbasket2.getDistributionTargets().add(workbasket0);
workbasket2.getDistributionTargets().add(workbasket1);
workbasketServiceImpl.createWorkbasket(workbasket2);
when(workbasketMapper.findById("1")).thenReturn(workbasket1); Workbasket workbasket3 = new Workbasket();
when(workbasketMapper.findById("3")).thenReturn(workbasket1); workbasket3.setId("3");
workbasket2.getDistributionTargets().clear();
workbasket2.getDistributionTargets().add(workbasket3);
Thread.sleep(SLEEP_TIME);
List<Workbasket> distributionTargets = foundBasket.getDistributionTargets(); doNothing().when(workbasketMapper).update(any());
Assert.assertEquals(1, distributionTargets.size()); workbasketServiceImpl.updateWorkbasket(workbasket2);
Assert.assertEquals("3", distributionTargets.get(0).getId());
Assert.assertNotEquals(workbasketServiceImpl.getWorkbasket("2").getCreated(), when(workbasketMapper.findById("2")).thenReturn(workbasket2);
workbasketServiceImpl.getWorkbasket("2").getModified()); Workbasket foundBasket = workbasketServiceImpl.getWorkbasket(workbasket2.getId());
Assert.assertEquals(workbasketServiceImpl.getWorkbasket("1").getCreated(),
workbasketServiceImpl.getWorkbasket("1").getModified());
Assert.assertEquals(workbasketServiceImpl.getWorkbasket("3").getCreated(),
workbasketServiceImpl.getWorkbasket("3").getModified());
}
@Test when(workbasketMapper.findById("1")).thenReturn(workbasket1);
public void should_ReturnWorkbasketAuthorization_when_NewWorkbasketAccessItemIsCreated() when(workbasketMapper.findById("3")).thenReturn(workbasket1);
throws NotAuthorizedException {
doNothing().when(workbasketAccessMapper).insert(any());
WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); List<Workbasket> distributionTargets = foundBasket.getDistributionTargets();
accessItem.setWorkbasketId("1"); Assert.assertEquals(1, distributionTargets.size());
accessItem.setUserId("Arthur Dent"); Assert.assertEquals("3", distributionTargets.get(0).getId());
accessItem.setOpen(true);
accessItem.setRead(true);
accessItem = workbasketServiceImpl.createWorkbasketAuthorization(accessItem);
Assert.assertNotNull(accessItem.getId()); Assert.assertNotEquals(workbasketServiceImpl.getWorkbasket("2").getCreated(),
} workbasketServiceImpl.getWorkbasket("2").getModified());
Assert.assertEquals(workbasketServiceImpl.getWorkbasket("1").getCreated(),
workbasketServiceImpl.getWorkbasket("1").getModified());
Assert.assertEquals(workbasketServiceImpl.getWorkbasket("3").getCreated(),
workbasketServiceImpl.getWorkbasket("3").getModified());
}
@Test @Test
public void should_ReturnWorkbasketAuthorization_when_WorkbasketAccessItemIsUpdated() public void should_ReturnWorkbasketAuthorization_when_NewWorkbasketAccessItemIsCreated()
throws NotAuthorizedException { throws NotAuthorizedException {
doNothing().when(workbasketAccessMapper).insert(any()); doNothing().when(workbasketAccessMapper).insert(any());
WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); WorkbasketAccessItem accessItem = new WorkbasketAccessItem();
accessItem.setWorkbasketId("1"); accessItem.setWorkbasketId("1");
accessItem.setUserId("Arthur Dent"); accessItem.setUserId("Arthur Dent");
accessItem.setOpen(true); accessItem.setOpen(true);
accessItem.setRead(true); accessItem.setRead(true);
accessItem = workbasketServiceImpl.createWorkbasketAuthorization(accessItem); accessItem = workbasketServiceImpl.createWorkbasketAuthorization(accessItem);
Assert.assertNotNull(accessItem.getId()); Assert.assertNotNull(accessItem.getId());
}
doNothing().when(workbasketAccessMapper).update(any()); @Test
accessItem.setUserId("Zaphod Beeblebrox"); public void should_ReturnWorkbasketAuthorization_when_WorkbasketAccessItemIsUpdated()
workbasketServiceImpl.updateWorkbasketAuthorization(accessItem); throws NotAuthorizedException {
doNothing().when(workbasketAccessMapper).insert(any());
Assert.assertEquals("Zaphod Beeblebrox", accessItem.getUserId()); WorkbasketAccessItem accessItem = new WorkbasketAccessItem();
} accessItem.setWorkbasketId("1");
accessItem.setUserId("Arthur Dent");
accessItem.setOpen(true);
accessItem.setRead(true);
accessItem = workbasketServiceImpl.createWorkbasketAuthorization(accessItem);
@Test(expected = NotAuthorizedException.class) Assert.assertNotNull(accessItem.getId());
public void should_ThrowNotAuthorizedException_when_OperationIsNotAuthorized() throws NotAuthorizedException {
when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration);
when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(true);
workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ); doNothing().when(workbasketAccessMapper).update(any());
} accessItem.setUserId("Zaphod Beeblebrox");
workbasketServiceImpl.updateWorkbasketAuthorization(accessItem);
@SuppressWarnings("serial") Assert.assertEquals("Zaphod Beeblebrox", accessItem.getUserId());
@Test }
public void should_Pass_when_OperationIsAuthorized() throws NotAuthorizedException {
when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration);
when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(true);
when(workbasketAccessMapper.findByWorkbasketAndUserAndAuthorization(any(), any(), any())) @Test(expected = NotAuthorizedException.class)
.thenReturn(new ArrayList<WorkbasketAccessItem>() { public void should_ThrowNotAuthorizedException_when_OperationIsNotAuthorized() throws NotAuthorizedException {
{ when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration);
add(new WorkbasketAccessItem()); when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(true);
}
});
workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ); workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ);
}
verify(workbasketAccessMapper, times(1)).findByWorkbasketAndUserAndAuthorization(any(), any(), any());
}
@Test @SuppressWarnings("serial")
public void should_Pass_when_SecurityIsDisabled() throws NotAuthorizedException { @Test
when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration); public void should_Pass_when_OperationIsAuthorized() throws NotAuthorizedException {
when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(false); when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration);
when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(true);
workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ); when(workbasketAccessMapper.findByWorkbasketAndUserAndAuthorization(any(), any(), any()))
} .thenReturn(new ArrayList<WorkbasketAccessItem>() {
{
add(new WorkbasketAccessItem());
}
});
workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ);
verify(workbasketAccessMapper, times(1)).findByWorkbasketAndUserAndAuthorization(any(), any(), any());
}
@Test
public void should_Pass_when_SecurityIsDisabled() throws NotAuthorizedException {
when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration);
when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(false);
workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ);
}
} }

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());
} }
} }

281
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();
@Test accessItem.setWorkbasketId("1");
public void testUpdateWorkbasketAccessUser() throws NotAuthorizedException { accessItem.setUserId("Arthur Dent");
WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); accessItem.setOpen(true);
accessItem.setWorkbasketId("1"); accessItem.setRead(true);
accessItem.setUserId("Arthur Dent"); workbasketServiceImpl.createWorkbasketAuthorization(accessItem);
accessItem.setOpen(true);
accessItem.setRead(true);
workbasketServiceImpl.createWorkbasketAuthorization(accessItem);
Assert.assertEquals(1, workbasketServiceImpl.getAllAuthorizations().size()); Assert.assertEquals(1, workbasketServiceImpl.getAllAuthorizations().size());
}
accessItem.setUserId("Zaphod Beeblebrox");
workbasketServiceImpl.updateWorkbasketAuthorization(accessItem); @Test
public void testUpdateWorkbasketAccessUser() throws NotAuthorizedException {
Assert.assertEquals("Zaphod Beeblebrox", workbasketServiceImpl.getWorkbasketAuthorization(accessItem.getId()).getUserId()); WorkbasketAccessItem accessItem = new WorkbasketAccessItem();
} accessItem.setWorkbasketId("1");
accessItem.setUserId("Arthur Dent");
accessItem.setOpen(true);
accessItem.setRead(true);
workbasketServiceImpl.createWorkbasketAuthorization(accessItem);
Assert.assertEquals(1, workbasketServiceImpl.getAllAuthorizations().size());
accessItem.setUserId("Zaphod Beeblebrox");
workbasketServiceImpl.updateWorkbasketAuthorization(accessItem);
Assert.assertEquals("Zaphod Beeblebrox",
workbasketServiceImpl.getWorkbasketAuthorization(accessItem.getId()).getUserId());
}
} }