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

added checkstyle

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

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"
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>
<groupId>org.taskana</groupId>
<artifactId>taskana-parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>
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>
<groupId>org.taskana</groupId>
<artifactId>taskana-parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>
<properties>
<java.version>1.8</java.version>
</properties>
<properties>
<java.version>1.8</java.version>
</properties>
<modules>
<module>taskana-core</module>
<module>taskana-cdi</module>
<module>taskana-spring</module>
<module>taskana-cdi-example</module>
<module>taskana-spring-example</module>
</modules>
</project>
<modules>
<module>taskana-core</module>
<module>taskana-cdi</module>
<module>taskana-spring</module>
<module>taskana-cdi-example</module>
<module>taskana-spring-example</module>
</modules>
</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>
</dependency>
</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;
/**
* This class manages the classifications.
*/
public interface ClassificationService {
/**
* Get all available Classifications
*
* @return The List of all Classifications
*/
public List<Classification> selectClassifications();
/**
* Get all available Classifications.
* @return The List of all Classifications
*/
List<Classification> selectClassifications();
/**
* Get all Classifications with given parent
*
* @param parentId
* the ID of the parent Classification
* @return
*/
public List<Classification> selectClassificationsByParentId(String parentId);
/**
* Get all Classifications with given parent.
* @param parentId
* the ID of the parent Classification
* @return
*/
List<Classification> selectClassificationsByParentId(String parentId);
/**
* Get a Classification for a given id
*
* @param id
* @return the requested Classification
*/
public Classification selectClassificationById(String id);
/**
* Get a Classification for a given id.
* @param id
* @return the requested Classification
*/
Classification selectClassificationById(String id);
/**
* Insert a new Classification
*
* @param classification
* the classification to insert
*/
public void insertClassification(Classification classification);
/**
* Insert a new Classification.
* @param classification
* the classification to insert
*/
void insertClassification(Classification classification);
/**
* Update a Classification
*
* @param classification
* the Classification to update
*/
public void updateClassification(Classification classification);
/**
* Update a Classification.
* @param classification
* the Classification to update
*/
void updateClassification(Classification classification);
}

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.TaskStateCounter;
/**
* The Task Service manages all operations on tasks.
*/
public interface TaskService {
/**
* Claim an existing task
*
* @param id
* task id
* @param userName
* user who claims the task
* @throws TaskNotFoundException
*/
public void claim(String id, String userName) throws TaskNotFoundException;
/**
* Claim an existing task.
* @param id
* task id
* @param userName
* user who claims the task
* @throws TaskNotFoundException
*/
void claim(String id, String userName) throws TaskNotFoundException;
/**
* Set task to completed
*
* @param taskId
* the task id
* @throws TaskNotFoundException
*/
public void complete(String taskId) throws TaskNotFoundException;
/**
* Set task to completed.
* @param taskId
* the task id
* @throws TaskNotFoundException
*/
void complete(String taskId) throws TaskNotFoundException;
/**
* Create a task by a task object
*
* @param task
* @return the created task
* @throws NotAuthorizedException
*/
public Task create(Task task) throws NotAuthorizedException;
/**
* Create a task by a task object.
* @param task
* @return the created task
* @throws NotAuthorizedException
*/
Task create(Task task) throws NotAuthorizedException;
/**
* Get the details of a task
*
* @param taskId
* the id of the task
* @return the Task
*/
public Task getTaskById(String taskId) throws TaskNotFoundException;
/**
* Get the details of a task.
* @param taskId
* the id of the task
* @return the Task
*/
Task getTaskById(String taskId) throws TaskNotFoundException;
/**
* Query all tasks for a workbasket.
*
* @param workbasketId
* the workbasket to query
* @return the list of tasks, which reside in the workbasket
* @throws NotAuthorizedException
*/
public List<Task> getTasksForWorkbasket(String workbasketId) throws NotAuthorizedException;
/**
* Query all tasks for a workbasket.
* @param workbasketId
* the workbasket to query
* @return the list of tasks, which reside in the workbasket
* @throws NotAuthorizedException
*/
List<Task> getTasksForWorkbasket(String workbasketId) throws NotAuthorizedException;
/**
* Query all tasks for a workbasket.
*
* @param workbasketId
* the workbasket to query
* @return the list of tasks, which reside in the workbasket
* @throws NotAuthorizedException
*/
public List<Task> getTasksForWorkbasket(List<String> workbaskets, List<TaskState> states)
throws NotAuthorizedException;
/**
* Query all tasks for a workbasket.
* @param workbasketId
* the workbasket to query
* @return the list of tasks, which reside in the workbasket
* @throws NotAuthorizedException
*/
List<Task> getTasksForWorkbasket(List<String> workbaskets, List<TaskState> states) throws NotAuthorizedException;
/**
* This method returns all Tasks
*
* @return a {@link List<Task>} of {@link Task}
*/
public List<Task> getTasks();
/**
* This method returns all Tasks.
* @return a {@link List<Task>} of {@link Task}
*/
List<Task> getTasks();
/**
* This method counts all tasks with a given state.
*
* @param states
* the countable states
* @return a List of {@link TaskStateCounter}
*/
public List<TaskStateCounter> getTaskCountForState(List<TaskState> states);
/**
* This method counts all tasks with a given state.
* @param states
* the countable states
* @return a List of {@link TaskStateCounter}
*/
List<TaskStateCounter> getTaskCountForState(List<TaskState> states);
/**
* This method returns all tasks with the specified states
*
* @param states all List with the needed states
* @return a list of Tasks
*/
public List<Task> findTasks(List<TaskState> states);
/**
* This method returns all tasks with the specified states.
* @param states
* all List with the needed states
* @return a list of Tasks
*/
List<Task> findTasks(List<TaskState> states);
/**
* Count all Tasks in a given workbasket with daysInPast as Days from today
* in the past and a specific state.
*
* @param workbasketId
* @param daysInPast
* @param states
* @return
*/
public long getTaskCountForWorkbasketByDaysInPastAndState(String workbasketId, long daysInPast,
List<TaskState> states);
/**
* Count all Tasks in a given workbasket with daysInPast as Days from today in
* the past and a specific state.
* @param workbasketId
* @param daysInPast
* @param states
* @return
*/
long getTaskCountForWorkbasketByDaysInPastAndState(String workbasketId, long daysInPast, List<TaskState> states);
/**
* Transfer task to another workbasket.
*
* The transfer set the transferred flag and resets the read flag.
*
* @param workbasketId
* @return the updated task
* @throws NotAuthorizedException
*/
public Task transfer(String taskId, String workbasketId)
throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException;
/**
* Marks a task as read.
*
* @param taskId the id of the task to be updated
* @param isRead the new status of the read flag.
* @return Task the updated Task
*/
public Task setTaskRead(String taskId, boolean isRead) throws TaskNotFoundException;
/**
* Transfer task to another workbasket. The transfer set the transferred flag
* and resets the read flag.
* @param workbasketId
* @return the updated task
* @throws NotAuthorizedException
*/
Task transfer(String taskId, String workbasketId)
throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException;
public List<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;
/**
* The TaskanaEngine represents an overall set of all needed services
* The TaskanaEngine represents an overall set of all needed services.
*/
public interface TaskanaEngine {
/**
* The TaskService can be used for operations on all Tasks
*
* @return the TaskService
*/
public TaskService getTaskService();
/**
* The TaskService can be used for operations on all Tasks.
* @return the TaskService
*/
TaskService getTaskService();
/**
* The WorkbasketService can be used for operations on all Workbaskets
*
* @return the TaskService
*/
public WorkbasketService getWorkbasketService();
/**
* The WorkbasketService can be used for operations on all Workbaskets.
* @return the TaskService
*/
WorkbasketService getWorkbasketService();
/**
* The ClassificationService can be used for operations on all Categories
*
* @return the TaskService
*/
public ClassificationService getClassificationService();
/**
* The ClassificationService can be used for operations on all Categories.
* @return the TaskService
*/
ClassificationService getClassificationService();
/**
* The Taskana configuration
* @return the TaskanaConfiguration
*/
public TaskanaEngineConfiguration getConfiguration();
/**
* The Taskana configuration.
* @return the TaskanaConfiguration
*/
TaskanaEngineConfiguration getConfiguration();
}

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.WorkbasketAuthorization;
/**
* This service manages the Workbaskets.
*/
public interface WorkbasketService {
/**
* Get Workbasket for a given id.
*
* @param workbasketId
* @return the requested Workbasket
*/
public Workbasket getWorkbasket(String workbasketId) throws WorkbasketNotFoundException;
/**
* Get Workbasket for a given id.
* @param workbasketId
* @return the requested Workbasket
*/
Workbasket getWorkbasket(String workbasketId) throws WorkbasketNotFoundException;
/**
* Get all available Workbaskets.
*
* @return List<Workbasket> the list of all workbaskets
*/
public List<Workbasket> getWorkbaskets();
/**
* Get all available Workbaskets.
* @return List<Workbasket> the list of all workbaskets
*/
List<Workbasket> getWorkbaskets();
/**
* Create a new Workbasket.
*
* @param workbasket
* The workbasket to create
* @throws NotAuthorizedException
*/
public Workbasket createWorkbasket(Workbasket workbasket);
/**
* Create a new Workbasket.
* @param workbasket
* The workbasket to create
* @throws NotAuthorizedException
*/
Workbasket createWorkbasket(Workbasket workbasket);
/**
* Update a Workbasket.
*
*
* @param workbasket
* The workbasket to update
* @throws NotAuthorizedException
*/
public Workbasket updateWorkbasket(Workbasket workbasket) throws NotAuthorizedException;
/**
* Update a Workbasket.
* @param workbasket
* The workbasket to update
* @throws NotAuthorizedException
*/
Workbasket updateWorkbasket(Workbasket workbasket) throws NotAuthorizedException;
/**
* Create a new authorization for a specific workbasket and a specific user
*
* @param workbasket
* the choosen workbasket
* @param user
* the choosen user
* @return
*/
public WorkbasketAccessItem createWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem);
/**
* Create a new authorization for a specific workbasket and a specific user.
* @param workbasket
* the choosen workbasket
* @param user
* the choosen user
* @return
*/
WorkbasketAccessItem createWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem);
/**
* This method updates an Workbasket Authorization
*
* @param workbasketAccessItem
* the Authorization
* @return the updated entity
*/
public WorkbasketAccessItem updateWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem);
/**
* This method updates an Workbasket Authorization.
* @param workbasketAccessItem
* the Authorization
* @return the updated entity
*/
WorkbasketAccessItem updateWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem);
/**
* Get all authorizations of the workbasket
*
* @return a WorkbasketAccessItem list
*/
public List<WorkbasketAccessItem> getAllAuthorizations();
/**
* Get all authorizations of the workbasket.
* @return a WorkbasketAccessItem list
*/
List<WorkbasketAccessItem> getAllAuthorizations();
/**
* Deletes a specific authorization
*
* @param id
* the specific id
*/
public void deleteWorkbasketAuthorization(String id);
/**
* Deletes a specific authorization.
* @param id
* the specific id
*/
void deleteWorkbasketAuthorization(String id);
/**
* This method checks the authorization with the saved one
*
* @param workbasket
* the workbasket to check
* @param userId
* the user to check
* @param authorization
* the needed Authorization
* @throws WorkbasketNotFoundException
* if the workbasket do not exist
* @throws NotAuthorizedException
*/
public void checkAuthorization(String workbasketId, WorkbasketAuthorization authorization)
throws NotAuthorizedException;
/**
* This method checks the authorization with the saved one.
* @param workbasket
* the workbasket to check
* @param userId
* the user to check
* @param authorization
* the needed Authorization
* @throws WorkbasketNotFoundException
* if the workbasket do not exist
* @throws NotAuthorizedException
*/
void checkAuthorization(String workbasketId, WorkbasketAuthorization authorization) throws NotAuthorizedException;
/**
* This method get one WorkbasketAuthorization with an id
*
* @param id
* the id
* @return the full {@link WorkbasketAccessItem}
*/
public WorkbasketAccessItem getWorkbasketAuthorization(String id);
/**
* This method get one WorkbasketAuthorization with an id.
* @param id
* the id
* @return the full {@link WorkbasketAccessItem}
*/
WorkbasketAccessItem getWorkbasketAuthorization(String id);
/**
* Get all authorizations for a Workbasket.
*
* @param workbasketId
* @return List<WorkbasketAccessItem>
*/
public List<WorkbasketAccessItem> getWorkbasketAuthorizations(String workbasketId);
/**
* Get all authorizations for a Workbasket.
* @param workbasketId
* @return List<WorkbasketAccessItem>
*/
List<WorkbasketAccessItem> getWorkbasketAuthorizations(String workbasketId);
/**
* This method provides workbaskets via an permission
*
* @param permission
* as String like in this enum: {@link WorkbasketAuthorization}
* @return all filtered workbaskets
*/
List<Workbasket> getWorkbaskets(List<WorkbasketAuthorization> permission);
/**
* This method provides workbaskets via an permission.
* @param permission
* as String like in this enum: {@link WorkbasketAuthorization}
* @return all filtered workbaskets
*/
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.LoggerFactory;
/**
* This class create the schema for taskana.
*/
public class DbScriptRunner {
private static final Logger logger = LoggerFactory.getLogger(DbScriptRunner.class);
private static final Logger LOGGER = LoggerFactory.getLogger(DbScriptRunner.class);
private static final String SQL = "/sql";
private static final String DB_SCHEMA = SQL + "/taskana-schema.sql";
private static final String DB_SCHEMA_DETECTION = SQL + "/schema-detection.sql";
private static final String SQL = "/sql";
private static final String DB_SCHEMA = SQL + "/taskana-schema.sql";
private static final String DB_SCHEMA_DETECTION = SQL + "/schema-detection.sql";
private DataSource dataSource;
private DataSource dataSource;
private StringWriter outWriter = new StringWriter();
private PrintWriter logWriter = new PrintWriter(outWriter);
private StringWriter errorWriter = new StringWriter();
private PrintWriter errorLogWriter = new PrintWriter(errorWriter);
private StringWriter outWriter = new StringWriter();
private PrintWriter logWriter = new PrintWriter(outWriter);
private StringWriter errorWriter = new StringWriter();
private PrintWriter errorLogWriter = new PrintWriter(errorWriter);
public DbScriptRunner(DataSource dataSource) {
super();
this.dataSource = dataSource;
}
public DbScriptRunner(DataSource dataSource) {
super();
this.dataSource = dataSource;
}
/**
* Run all db scripts.
* @throws SQLException
*/
public void run() throws SQLException {
ScriptRunner runner = new ScriptRunner(dataSource.getConnection());
LOGGER.debug(dataSource.getConnection().getMetaData().toString());
/**
* Run all db scripts
*
* @throws SQLException
*/
public void run() throws SQLException {
ScriptRunner runner = new ScriptRunner(dataSource.getConnection());
logger.debug(dataSource.getConnection().getMetaData().toString());
runner.setStopOnError(true);
runner.setLogWriter(logWriter);
runner.setErrorLogWriter(errorLogWriter);
runner.setStopOnError(true);
runner.setLogWriter(logWriter);
runner.setErrorLogWriter(errorLogWriter);
if (!isSchemaPreexisting(runner)) {
runner.runScript(new InputStreamReader(this.getClass().getResourceAsStream(DB_SCHEMA)));
}
runner.closeConnection();
if (!isSchemaPreexisting(runner)) {
runner.runScript(new InputStreamReader(this.getClass().getResourceAsStream(DB_SCHEMA)));
}
runner.closeConnection();
LOGGER.debug(outWriter.toString());
if (!errorWriter.toString().trim().isEmpty()) {
LOGGER.error(errorWriter.toString());
}
}
logger.debug(outWriter.toString());
if (!errorWriter.toString().trim().isEmpty()) {
logger.error(errorWriter.toString());
}
}
private boolean isSchemaPreexisting(ScriptRunner runner) {
try {
runner.runScript(new InputStreamReader(this.getClass().getResourceAsStream(DB_SCHEMA_DETECTION)));
} catch (Exception e) {
LOGGER.debug("Schema does not exist.");
return false;
}
LOGGER.debug("Schema does exist.");
return true;
}
private boolean isSchemaPreexisting(ScriptRunner runner) {
try {
runner.runScript(new InputStreamReader(this.getClass().getResourceAsStream(DB_SCHEMA_DETECTION)));
} catch (Exception e) {
logger.debug("Schema does not exist.");
return false;
}
logger.debug("Schema does exist.");
return true;
}
public DataSource getDataSource() {
return dataSource;
}
public DataSource getDataSource() {
return dataSource;
}
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
}

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

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

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

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

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

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

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

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

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

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

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.mappings.ObjectReferenceMapper;
import org.taskana.model.mappings.TaskMapper;
/**
* This is the implementation of TaskService.
*/
public class TaskServiceImpl implements TaskService {
private static final Logger logger = LoggerFactory.getLogger(TaskServiceImpl.class);
private static final String ID_PREFIX_OBJECTR_EFERENCE = "ORI";
private static final String ID_PREFIX_TASK = "TKI";
private static final Logger LOGGER = LoggerFactory.getLogger(TaskServiceImpl.class);
private TaskanaEngine taskanaEngine;
private TaskMapper taskMapper;
private ObjectReferenceMapper objectReferenceMapper;
private static final String ID_PREFIX_OBJECTR_EFERENCE = "ORI";
private static final String ID_PREFIX_TASK = "TKI";
public TaskServiceImpl(TaskanaEngine taskanaEngine, TaskMapper taskMapper, ObjectReferenceMapper objectReferenceMapper) {
super();
this.taskanaEngine = taskanaEngine;
this.taskMapper = taskMapper;
this.objectReferenceMapper = objectReferenceMapper;
}
private TaskanaEngine taskanaEngine;
private TaskMapper taskMapper;
private ObjectReferenceMapper objectReferenceMapper;
@Override
public void claim(String id, String userName) throws TaskNotFoundException {
Task task = taskMapper.findById(id);
if (task != null) {
Timestamp now = new Timestamp(System.currentTimeMillis());
task.setOwner(userName);
task.setModified(now);
task.setClaimed(now);
task.setState(TaskState.CLAIMED);
taskMapper.update(task);
logger.debug("User '{}' claimed task '{}'.", userName, id);
} else {
throw new TaskNotFoundException(id);
}
}
public TaskServiceImpl(TaskanaEngine taskanaEngine, TaskMapper taskMapper,
ObjectReferenceMapper objectReferenceMapper) {
super();
this.taskanaEngine = taskanaEngine;
this.taskMapper = taskMapper;
this.objectReferenceMapper = objectReferenceMapper;
}
@Override
public void complete(String id) throws TaskNotFoundException {
Task task = taskMapper.findById(id);
if (task != null) {
Timestamp now = new Timestamp(System.currentTimeMillis());
task.setCompleted(now);
task.setModified(now);
task.setState(TaskState.COMPLETED);
taskMapper.update(task);
logger.debug("Task '{}' completed.", id);
} else {
throw new TaskNotFoundException(id);
}
}
@Override
public void claim(String id, String userName) throws TaskNotFoundException {
Task task = taskMapper.findById(id);
if (task != null) {
Timestamp now = new Timestamp(System.currentTimeMillis());
task.setOwner(userName);
task.setModified(now);
task.setClaimed(now);
task.setState(TaskState.CLAIMED);
taskMapper.update(task);
LOGGER.debug("User '{}' claimed task '{}'.", userName, id);
} else {
throw new TaskNotFoundException(id);
}
}
@Override
public Task create(Task task) throws NotAuthorizedException {
taskanaEngine.getWorkbasketService().checkAuthorization(task.getWorkbasketId(), WorkbasketAuthorization.APPEND);
@Override
public void complete(String id) throws TaskNotFoundException {
Task task = taskMapper.findById(id);
if (task != null) {
Timestamp now = new Timestamp(System.currentTimeMillis());
task.setCompleted(now);
task.setModified(now);
task.setState(TaskState.COMPLETED);
taskMapper.update(task);
LOGGER.debug("Task '{}' completed.", id);
} else {
throw new TaskNotFoundException(id);
}
}
Timestamp now = new Timestamp(System.currentTimeMillis());
task.setId(IdGenerator.generateWithPrefix(ID_PREFIX_TASK));
task.setState(TaskState.READY);
task.setCreated(now);
task.setModified(now);
task.setRead(false);
task.setTransferred(false);
@Override
public Task create(Task task) throws NotAuthorizedException {
taskanaEngine.getWorkbasketService().checkAuthorization(task.getWorkbasketId(), WorkbasketAuthorization.APPEND);
// insert ObjectReference if needed.
if (task.getPrimaryObjRef() != null) {
ObjectReference objectReference = this.objectReferenceMapper.findByObjectReference(task.getPrimaryObjRef());
if (objectReference == null) {
objectReference = task.getPrimaryObjRef();
objectReference.setId(IdGenerator.generateWithPrefix(ID_PREFIX_OBJECTR_EFERENCE));
this.objectReferenceMapper.insert(objectReference);
}
task.setPrimaryObjRef(objectReference);
}
this.taskMapper.insert(task);
Timestamp now = new Timestamp(System.currentTimeMillis());
task.setId(IdGenerator.generateWithPrefix(ID_PREFIX_TASK));
task.setState(TaskState.READY);
task.setCreated(now);
task.setModified(now);
task.setRead(false);
task.setTransferred(false);
logger.debug("Task '{}' created.", task.getId());
return task;
}
// insert ObjectReference if needed.
if (task.getPrimaryObjRef() != null) {
ObjectReference objectReference = this.objectReferenceMapper.findByObjectReference(task.getPrimaryObjRef());
if (objectReference == null) {
objectReference = task.getPrimaryObjRef();
objectReference.setId(IdGenerator.generateWithPrefix(ID_PREFIX_OBJECTR_EFERENCE));
this.objectReferenceMapper.insert(objectReference);
}
task.setPrimaryObjRef(objectReference);
}
this.taskMapper.insert(task);
@Override
public Task getTaskById(String id) throws TaskNotFoundException {
Task task = taskMapper.findById(id);
if (task != null) {
return task;
} else {
throw new TaskNotFoundException(id);
}
}
LOGGER.debug("Task '{}' created.", task.getId());
return task;
}
@Override
public List<Task> getTasksForWorkbasket(String workbasketId) throws NotAuthorizedException {
taskanaEngine.getWorkbasketService().checkAuthorization(workbasketId, WorkbasketAuthorization.OPEN);
@Override
public Task getTaskById(String id) throws TaskNotFoundException {
Task task = taskMapper.findById(id);
if (task != null) {
return task;
} else {
throw new TaskNotFoundException(id);
}
}
return taskMapper.findByWorkBasketId(workbasketId);
}
@Override
public List<Task> getTasksForWorkbasket(String workbasketId) throws NotAuthorizedException {
taskanaEngine.getWorkbasketService().checkAuthorization(workbasketId, WorkbasketAuthorization.OPEN);
@Override
public List<Task> findTasks(List<TaskState> states) {
return taskMapper.findByStates(states);
}
return taskMapper.findByWorkBasketId(workbasketId);
}
@Override
public List<Task> getTasksForWorkbasket(List<String> workbasketIds, List<TaskState> states)
throws NotAuthorizedException {
@Override
public List<Task> findTasks(List<TaskState> states) {
return taskMapper.findByStates(states);
}
for (String workbasket : workbasketIds) {
taskanaEngine.getWorkbasketService().checkAuthorization(workbasket, WorkbasketAuthorization.OPEN);
}
@Override
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
public List<Task> getTasks() {
return taskMapper.findAll();
}
return taskMapper.findByWorkbasketIdsAndStates(workbasketIds, states);
}
@Override
public List<TaskStateCounter> getTaskCountForState(List<TaskState> states) {
return taskMapper.getTaskCountForState(states);
}
@Override
public List<Task> getTasks() {
return taskMapper.findAll();
}
@Override
public long getTaskCountForWorkbasketByDaysInPastAndState(String workbasketId, long daysInPast,
List<TaskState> states) {
LocalDate time = LocalDate.now();
time = time.minusDays(daysInPast);
Date fromDate = Date.valueOf(time);
return taskMapper.getTaskCountForWorkbasketByDaysInPastAndState(workbasketId, fromDate, states);
}
@Override
public List<TaskStateCounter> getTaskCountForState(List<TaskState> states) {
return taskMapper.getTaskCountForState(states);
}
@Override
public Task transfer(String taskId, String destinationWorkbasketId)
throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException {
Task task = getTaskById(taskId);
@Override
public long getTaskCountForWorkbasketByDaysInPastAndState(String workbasketId, long daysInPast,
List<TaskState> states) {
LocalDate time = LocalDate.now();
time = time.minusDays(daysInPast);
Date fromDate = Date.valueOf(time);
return taskMapper.getTaskCountForWorkbasketByDaysInPastAndState(workbasketId, fromDate, states);
}
// transfer requires TRANSFER in source and APPEND on destination
// workbasket
taskanaEngine.getWorkbasketService().checkAuthorization(destinationWorkbasketId, WorkbasketAuthorization.APPEND);
taskanaEngine.getWorkbasketService().checkAuthorization(task.getWorkbasketId(), WorkbasketAuthorization.TRANSFER);
@Override
public Task transfer(String taskId, String destinationWorkbasketId)
throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException {
Task task = getTaskById(taskId);
// if security is disabled, the implicit existance check on the
// destination workbasket has been skipped and needs to be performed
if (!taskanaEngine.getConfiguration().isSecurityEnabled()) {
taskanaEngine.getWorkbasketService().getWorkbasket(destinationWorkbasketId);
}
// transfer requires TRANSFER in source and APPEND on destination
// workbasket
taskanaEngine.getWorkbasketService().checkAuthorization(destinationWorkbasketId,
WorkbasketAuthorization.APPEND);
taskanaEngine.getWorkbasketService().checkAuthorization(task.getWorkbasketId(),
WorkbasketAuthorization.TRANSFER);
// reset read flag and set transferred flag
task.setRead(false);
task.setTransferred(true);
// if security is disabled, the implicit existance check on the
// destination workbasket has been skipped and needs to be performed
if (!taskanaEngine.getConfiguration().isSecurityEnabled()) {
taskanaEngine.getWorkbasketService().getWorkbasket(destinationWorkbasketId);
}
// transfer task from source to destination workbasket
task.setWorkbasketId(destinationWorkbasketId);
task.setModified(Timestamp.valueOf(LocalDateTime.now()));
taskMapper.update(task);
// reset read flag and set transferred flag
task.setRead(false);
task.setTransferred(true);
return getTaskById(taskId);
}
// transfer task from source to destination workbasket
task.setWorkbasketId(destinationWorkbasketId);
task.setModified(Timestamp.valueOf(LocalDateTime.now()));
taskMapper.update(task);
@Override
public List<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);
}
return getTaskById(taskId);
}
@Override
public Task setTaskRead(String taskId, boolean isRead) throws TaskNotFoundException {
Task task = getTaskById(taskId);
task.setRead(true);
task.setModified(Timestamp.valueOf(LocalDateTime.now()));
taskMapper.update(task);
return getTaskById(taskId);
}
@Override
public List<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
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.WorkbasketMapper;
/**
* This is the implementation of TaskanaEngine.
*/
public class TaskanaEngineImpl implements TaskanaEngine {
private static final String DEFAULT = "default";
private static final String DEFAULT = "default";
protected TaskanaEngineConfiguration taskanaEngineConfiguration;
protected SqlSession session;
protected TransactionFactory transactionFactory;
protected TaskanaEngineConfiguration taskanaEngineConfiguration;
protected SqlSession session;
protected TransactionFactory transactionFactory;
private TaskMapper taskMapper;
private WorkbasketMapper workbasketMapper;
private DistributionTargetMapper distributionTargetMapper;
private ClassificationMapper classificationMapper;
private WorkbasketAccessMapper workbasketAccessMapper;
private ObjectReferenceMapper objectReferenceMapper;
private TaskMapper taskMapper;
private WorkbasketMapper workbasketMapper;
private DistributionTargetMapper distributionTargetMapper;
private ClassificationMapper classificationMapper;
private WorkbasketAccessMapper workbasketAccessMapper;
private ObjectReferenceMapper objectReferenceMapper;
private TaskServiceImpl taskServiceImpl;
private WorkbasketServiceImpl workbasketServiceImpl;
private TaskServiceImpl taskServiceImpl;
private WorkbasketServiceImpl workbasketServiceImpl;
public TaskanaEngineImpl(TaskanaEngineConfiguration taskanaEngineConfiguration) {
this.taskanaEngineConfiguration = taskanaEngineConfiguration;
public TaskanaEngineImpl(TaskanaEngineConfiguration taskanaEngineConfiguration) {
this.taskanaEngineConfiguration = taskanaEngineConfiguration;
createTransactionFactory(taskanaEngineConfiguration.getUseContainerManagedTransactions());
createTransactionFactory(taskanaEngineConfiguration.getUseContainerManagedTransactions());
this.session = createSqlSessionFactory().openSession();
this.taskMapper = session.getMapper(TaskMapper.class);
this.workbasketMapper = session.getMapper(WorkbasketMapper.class);
this.distributionTargetMapper = session.getMapper(DistributionTargetMapper.class);
this.classificationMapper = session.getMapper(ClassificationMapper.class);
this.workbasketAccessMapper = session.getMapper(WorkbasketAccessMapper.class);
this.objectReferenceMapper = session.getMapper(ObjectReferenceMapper.class);
}
this.session = createSqlSessionFactory().openSession();
this.taskMapper = session.getMapper(TaskMapper.class);
this.workbasketMapper = session.getMapper(WorkbasketMapper.class);
this.distributionTargetMapper = session.getMapper(DistributionTargetMapper.class);
this.classificationMapper = session.getMapper(ClassificationMapper.class);
this.workbasketAccessMapper = session.getMapper(WorkbasketAccessMapper.class);
this.objectReferenceMapper = session.getMapper(ObjectReferenceMapper.class);
}
@Override
public TaskService getTaskService() {
this.taskServiceImpl = new TaskServiceImpl(this, this.taskMapper, this.objectReferenceMapper);
return taskServiceImpl;
}
@Override
public TaskService getTaskService() {
this.taskServiceImpl = new TaskServiceImpl(this, this.taskMapper, this.objectReferenceMapper);
return taskServiceImpl;
}
@Override
public WorkbasketService getWorkbasketService() {
this.workbasketServiceImpl = new WorkbasketServiceImpl(this, this.workbasketMapper,
this.distributionTargetMapper, this.workbasketAccessMapper);
return workbasketServiceImpl;
}
@Override
public WorkbasketService getWorkbasketService() {
this.workbasketServiceImpl = new WorkbasketServiceImpl(this, this.workbasketMapper,
this.distributionTargetMapper, this.workbasketAccessMapper);
return workbasketServiceImpl;
}
@Override
public ClassificationService getClassificationService() {
return new ClassificationServiceImpl(this.classificationMapper);
}
@Override
public ClassificationService getClassificationService() {
return new ClassificationServiceImpl(this.classificationMapper);
}
@Override
public TaskanaEngineConfiguration getConfiguration() {
return this.taskanaEngineConfiguration;
}
@Override
public TaskanaEngineConfiguration getConfiguration() {
return this.taskanaEngineConfiguration;
}
/**
* Close session manually, to be done, if a JdbcTransactionFactory is used.
* Perhaps it is better to separate the commit and the closing mechanism ...
*/
public void closeSession() {
this.session.commit();
this.session.close();
}
/**
* Close session manually, to be done, if a JdbcTransactionFactory is used.
* Perhaps it is better to separate the commit and the closing mechanism ...
*/
public void closeSession() {
this.session.commit();
this.session.close();
}
/**
* This method creates the sqlSessionFactory of myBatis. It integrates all the
* SQL mappers
*
* @return a {@link SqlSessionFactory}
*/
private SqlSessionFactory createSqlSessionFactory() {
Environment environment = new Environment(DEFAULT, this.transactionFactory,
taskanaEngineConfiguration.getDatasource());
Configuration configuration = new Configuration(environment);
// add mappers
configuration.addMapper(TaskMapper.class);
configuration.addMapper(WorkbasketMapper.class);
configuration.addMapper(DistributionTargetMapper.class);
configuration.addMapper(ClassificationMapper.class);
configuration.addMapper(WorkbasketAccessMapper.class);
configuration.addMapper(ObjectReferenceMapper.class);
return new SqlSessionFactoryBuilder().build(configuration);
}
/**
* This method creates the sqlSessionFactory of myBatis. It integrates all the
* SQL mappers
* @return a {@link SqlSessionFactory}
*/
private SqlSessionFactory createSqlSessionFactory() {
Environment environment = new Environment(DEFAULT, this.transactionFactory,
taskanaEngineConfiguration.getDatasource());
Configuration configuration = new Configuration(environment);
// add mappers
configuration.addMapper(TaskMapper.class);
configuration.addMapper(WorkbasketMapper.class);
configuration.addMapper(DistributionTargetMapper.class);
configuration.addMapper(ClassificationMapper.class);
configuration.addMapper(WorkbasketAccessMapper.class);
configuration.addMapper(ObjectReferenceMapper.class);
return new SqlSessionFactoryBuilder().build(configuration);
}
private void createTransactionFactory(boolean useContainerManagedTransactions) {
if (useContainerManagedTransactions) {
this.transactionFactory = new ManagedTransactionFactory();
} else {
this.transactionFactory = new JdbcTransactionFactory();
}
}
private void createTransactionFactory(boolean useContainerManagedTransactions) {
if (useContainerManagedTransactions) {
this.transactionFactory = new ManagedTransactionFactory();
} else {
this.transactionFactory = new JdbcTransactionFactory();
}
}
}

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.WorkbasketMapper;
import org.taskana.security.CurrentUserContext;
/**
* This is the implementation of WorkbasketService.
*/
public class WorkbasketServiceImpl implements WorkbasketService {
private static final Logger logger = LoggerFactory.getLogger(WorkbasketServiceImpl.class);
private static final String ID_PREFIX_WORKBASKET = "WBI";
private static final String ID_PREFIX_WORKBASKET_AUTHORIZATION = "WAI";
private static final Logger LOGGER = LoggerFactory.getLogger(WorkbasketServiceImpl.class);
private TaskanaEngine taskanaEngine;
private static final String ID_PREFIX_WORKBASKET = "WBI";
private static final String ID_PREFIX_WORKBASKET_AUTHORIZATION = "WAI";
private WorkbasketMapper workbasketMapper;
private DistributionTargetMapper distributionTargetMapper;
private WorkbasketAccessMapper workbasketAccessMapper;
private TaskanaEngine taskanaEngine;
public WorkbasketServiceImpl() {
}
private WorkbasketMapper workbasketMapper;
private DistributionTargetMapper distributionTargetMapper;
private WorkbasketAccessMapper workbasketAccessMapper;
public WorkbasketServiceImpl(TaskanaEngine taskanaEngine, WorkbasketMapper workbasketMapper,
DistributionTargetMapper distributionTargetMapper, WorkbasketAccessMapper workbasketAccessMapper) {
this.taskanaEngine = taskanaEngine;
this.workbasketMapper = workbasketMapper;
this.distributionTargetMapper = distributionTargetMapper;
this.workbasketAccessMapper = workbasketAccessMapper;
}
public WorkbasketServiceImpl() {
}
@Override
public Workbasket getWorkbasket(String workbasketId) throws WorkbasketNotFoundException {
Workbasket workbasket = workbasketMapper.findById(workbasketId);
if (workbasket == null) {
throw new WorkbasketNotFoundException(workbasketId);
}
return workbasket;
}
public WorkbasketServiceImpl(TaskanaEngine taskanaEngine, WorkbasketMapper workbasketMapper,
DistributionTargetMapper distributionTargetMapper, WorkbasketAccessMapper workbasketAccessMapper) {
this.taskanaEngine = taskanaEngine;
this.workbasketMapper = workbasketMapper;
this.distributionTargetMapper = distributionTargetMapper;
this.workbasketAccessMapper = workbasketAccessMapper;
}
@Override
public List<Workbasket> getWorkbaskets(List<WorkbasketAuthorization> permissions) {
return workbasketMapper.findByPermission(permissions, CurrentUserContext.getUserid());
}
@Override
public List<Workbasket> getWorkbaskets() {
return workbasketMapper.findAll();
}
@Override
public Workbasket getWorkbasket(String workbasketId) throws WorkbasketNotFoundException {
Workbasket workbasket = workbasketMapper.findById(workbasketId);
if (workbasket == null) {
throw new WorkbasketNotFoundException(workbasketId);
}
return workbasket;
}
@Override
public Workbasket createWorkbasket(Workbasket workbasket) {
Timestamp now = new Timestamp(System.currentTimeMillis());
workbasket.setCreated(now);
workbasket.setModified(now);
if (workbasket.getId() == null || workbasket.getId().isEmpty()) {
workbasket.setId(IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET));
}
workbasketMapper.insert(workbasket);
logger.debug("Workbasket '{}' created", workbasket.getId());
if (workbasket.getDistributionTargets() != null) {
for (Workbasket distributionTarget : workbasket.getDistributionTargets()) {
if (workbasketMapper.findById(distributionTarget.getId()) == null) {
distributionTarget.setCreated(now);
distributionTarget.setModified(now);
workbasketMapper.insert(distributionTarget);
logger.debug("Workbasket '{}' created", distributionTarget.getId());
}
distributionTargetMapper.insert(workbasket.getId(), distributionTarget.getId());
}
}
return workbasketMapper.findById(workbasket.getId());
}
@Override
public List<Workbasket> getWorkbaskets(List<WorkbasketAuthorization> permissions) {
return workbasketMapper.findByPermission(permissions, CurrentUserContext.getUserid());
}
@Override
public Workbasket updateWorkbasket(Workbasket workbasket) throws NotAuthorizedException {
workbasket.setModified(new Timestamp(System.currentTimeMillis()));
workbasketMapper.update(workbasket);
List<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
public List<Workbasket> getWorkbaskets() {
return workbasketMapper.findAll();
}
@Override
public WorkbasketAccessItem createWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem) {
workbasketAccessItem.setId(IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_AUTHORIZATION));
workbasketAccessMapper.insert(workbasketAccessItem);
return workbasketAccessItem;
}
@Override
public Workbasket createWorkbasket(Workbasket workbasket) {
Timestamp now = new Timestamp(System.currentTimeMillis());
workbasket.setCreated(now);
workbasket.setModified(now);
if (workbasket.getId() == null || workbasket.getId().isEmpty()) {
workbasket.setId(IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET));
}
workbasketMapper.insert(workbasket);
LOGGER.debug("Workbasket '{}' created", workbasket.getId());
if (workbasket.getDistributionTargets() != null) {
for (Workbasket distributionTarget : workbasket.getDistributionTargets()) {
if (workbasketMapper.findById(distributionTarget.getId()) == null) {
distributionTarget.setCreated(now);
distributionTarget.setModified(now);
workbasketMapper.insert(distributionTarget);
LOGGER.debug("Workbasket '{}' created", distributionTarget.getId());
}
distributionTargetMapper.insert(workbasket.getId(), distributionTarget.getId());
}
}
return workbasketMapper.findById(workbasket.getId());
}
@Override
public WorkbasketAccessItem getWorkbasketAuthorization(String id) {
return workbasketAccessMapper.findById(id);
}
@Override
public Workbasket updateWorkbasket(Workbasket workbasket) throws NotAuthorizedException {
workbasket.setModified(new Timestamp(System.currentTimeMillis()));
workbasketMapper.update(workbasket);
List<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
public void deleteWorkbasketAuthorization(String id) {
workbasketAccessMapper.delete(id);
}
@Override
public WorkbasketAccessItem createWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem) {
workbasketAccessItem.setId(IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_AUTHORIZATION));
workbasketAccessMapper.insert(workbasketAccessItem);
return workbasketAccessItem;
}
@Override
public List<WorkbasketAccessItem> getAllAuthorizations() {
return workbasketAccessMapper.findAll();
}
@Override
public WorkbasketAccessItem getWorkbasketAuthorization(String id) {
return workbasketAccessMapper.findById(id);
}
@Override
public void checkAuthorization(String workbasketId, WorkbasketAuthorization workbasketAuthorization)
throws NotAuthorizedException {
@Override
public void deleteWorkbasketAuthorization(String id) {
workbasketAccessMapper.delete(id);
}
// Skip permission check is security is not enabled
if (!taskanaEngine.getConfiguration().isSecurityEnabled()) {
logger.debug("Skipping permissions check since security is disabled.");
return;
}
@Override
public List<WorkbasketAccessItem> getAllAuthorizations() {
return workbasketAccessMapper.findAll();
}
String userId = CurrentUserContext.getUserid();
logger.debug("Verifying that {} has the permission {} on workbasket {}", userId, workbasketAuthorization.name(),
workbasketId);
@Override
public void checkAuthorization(String workbasketId, WorkbasketAuthorization workbasketAuthorization)
throws NotAuthorizedException {
List<WorkbasketAccessItem> accessItems = workbasketAccessMapper
.findByWorkbasketAndUserAndAuthorization(workbasketId, userId, workbasketAuthorization.name());
// Skip permission check is security is not enabled
if (!taskanaEngine.getConfiguration().isSecurityEnabled()) {
LOGGER.debug("Skipping permissions check since security is disabled.");
return;
}
if (accessItems.size() <= 0) {
throw new NotAuthorizedException("Not authorized. Authorization '" + workbasketAuthorization.name()
+ "' on workbasket '" + workbasketId + "' is needed.");
String userId = CurrentUserContext.getUserid();
LOGGER.debug("Verifying that {} has the permission {} on workbasket {}", userId, workbasketAuthorization.name(),
workbasketId);
}
}
List<WorkbasketAccessItem> accessItems = workbasketAccessMapper
.findByWorkbasketAndUserAndAuthorization(workbasketId, userId, workbasketAuthorization.name());
@Override
public WorkbasketAccessItem updateWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem) {
workbasketAccessMapper.update(workbasketAccessItem);
return workbasketAccessItem;
}
if (accessItems.size() <= 0) {
throw new NotAuthorizedException("Not authorized. Authorization '" + workbasketAuthorization.name()
+ "' on workbasket '" + workbasketId + "' is needed.");
@Override
public List<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;
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;
/**
* Classification entity
* Classification entity.
*/
public class Classification {
private String id;
private String tenantId;
private String parentClassificationId;
private String category;
private String type;
private Date created;
private Date modified;
private String name;
private String description;
private int priority;
private String serviceLevel; //PddDThhHmmM
private List<Classification> children = new ArrayList<>();
private String id;
private String tenantId;
private String parentClassificationId;
private String category;
private String type;
private Date created;
private Date modified;
private String name;
private String description;
private int priority;
private String serviceLevel; // PddDThhHmmM
private List<Classification> children = new ArrayList<>();
public String getId() {
return id;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public void setId(String id) {
this.id = id;
}
public String getTenantId() {
return tenantId;
}
public String getTenantId() {
return tenantId;
}
public void setTenantId(String tenantId) {
this.tenantId = tenantId;
}
public void setTenantId(String tenantId) {
this.tenantId = tenantId;
}
public String getParentClassificationId() {
return parentClassificationId;
}
public String getParentClassificationId() {
return parentClassificationId;
}
public void setParentClassificationId(String parentClassificationId) {
this.parentClassificationId = parentClassificationId;
}
public void setParentClassificationId(String parentClassificationId) {
this.parentClassificationId = parentClassificationId;
}
public String getType() {
return type;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public void setType(String type) {
this.type = type;
}
public String getCategory() {
return category;
}
public String getCategory() {
return category;
}
public void setCategory(String category) {
this.category = category;
}
public void setCategory(String category) {
this.category = category;
}
public Date getCreated() {
return created;
}
public Date getCreated() {
return created;
}
public void setCreated(Date created) {
this.created = created;
}
public void setCreated(Date created) {
this.created = created;
}
public Date getModified() {
return modified;
}
public Date getModified() {
return modified;
}
public void setModified(Date modified) {
this.modified = modified;
}
public void setModified(Date modified) {
this.modified = modified;
}
public String getName() {
return name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void setName(String name) {
this.name = name;
}
public String getDescription() {
return description;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public void setDescription(String description) {
this.description = description;
}
public int getPriority() {
return priority;
}
public int getPriority() {
return priority;
}
public void setPriority(int priority) {
this.priority = priority;
}
public void setPriority(int priority) {
this.priority = priority;
}
public String getServiceLevel() {
return serviceLevel;
}
public String getServiceLevel() {
return serviceLevel;
}
public void setServiceLevel(String serviceLevel) {
this.serviceLevel = serviceLevel;
}
public void setServiceLevel(String serviceLevel) {
this.serviceLevel = serviceLevel;
}
public List<Classification> getChildren() {
return children;
}
public List<Classification> getChildren() {
return children;
}
public void addChild(Classification child) {
children.add(child);
}
public void addChild(Classification child) {
children.add(child);
}
public void setChildren(List<Classification> children) {
this.children = children;
}
public void setChildren(List<Classification> 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;
/**
* DueWorkbasketCounter entity
* DueWorkbasketCounter entity.
*/
public class DueWorkbasketCounter {
private Date due;
private String workbasketId;
private long taskCounter;
public Date getDue() {
return due;
}
private Date due;
private String workbasketId;
private long taskCounter;
public void setDue(Date due) {
this.due = due;
}
public Date getDue() {
return due;
}
public String getWorkbasketId() {
return workbasketId;
}
public void setDue(Date due) {
this.due = due;
}
public void setWorkbasketId(String workbasketId) {
this.workbasketId = workbasketId;
}
public String getWorkbasketId() {
return workbasketId;
}
public long getTaskCounter() {
return taskCounter;
}
public void setWorkbasketId(String workbasketId) {
this.workbasketId = workbasketId;
}
public void setTaskCounter(long taskCounter) {
this.taskCounter = taskCounter;
}
public long getTaskCounter() {
return taskCounter;
}
public void setTaskCounter(long taskCounter) {
this.taskCounter = taskCounter;
}
}

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

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

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

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

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

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

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

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;
/**
* Workbasket entity
* Workbasket entity.
*/
public class Workbasket {
private String id;
private String tenantId;
private Timestamp created;
private Timestamp modified;
private String name;
private String description;
private String owner;
private List<Workbasket> distributionTargets = new ArrayList<>();
private String id;
private String tenantId;
private Timestamp created;
private Timestamp modified;
private String name;
private String description;
private String owner;
private List<Workbasket> distributionTargets = new ArrayList<>();
public String getId() {
return id;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public void setId(String id) {
this.id = id;
}
public String getTenantId() {
return tenantId;
}
public String getTenantId() {
return tenantId;
}
public void setTenantId(String tenantId) {
this.tenantId = tenantId;
}
public void setTenantId(String tenantId) {
this.tenantId = tenantId;
}
public Timestamp getCreated() {
return created;
}
public Timestamp getCreated() {
return created;
}
public void setCreated(Timestamp created) {
this.created = created;
}
public void setCreated(Timestamp created) {
this.created = created;
}
public Timestamp getModified() {
return modified;
}
public Timestamp getModified() {
return modified;
}
public void setModified(Timestamp modified) {
this.modified = modified;
}
public void setModified(Timestamp modified) {
this.modified = modified;
}
public String getName() {
return name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void setName(String name) {
this.name = name;
}
public String getDescription() {
return description;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public void setDescription(String description) {
this.description = description;
}
public String getOwner() {
return owner;
}
public String getOwner() {
return owner;
}
public void setOwner(String owner) {
this.owner = owner;
}
public void setOwner(String owner) {
this.owner = owner;
}
public List<Workbasket> getDistributionTargets() {
return distributionTargets;
}
public List<Workbasket> getDistributionTargets() {
return distributionTargets;
}
public void setDistributionTargets(List<Workbasket> distributionTargets) {
this.distributionTargets = distributionTargets;
}
public void setDistributionTargets(List<Workbasket> 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;
/**
* WorkbasketAccessItem entity
* WorkbasketAccessItem entity.
*/
public class WorkbasketAccessItem {
private String id;
private String workbasketId;
private String userId;
private String groupId;
private boolean read;
private boolean open;
private boolean append;
private boolean transfer;
private boolean distribute;
private String id;
private String workbasketId;
private String userId;
private String groupId;
private boolean read;
private boolean open;
private boolean append;
private boolean transfer;
private boolean distribute;
public String getId() {
return id;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public void setId(String id) {
this.id = id;
}
public String getWorkbasketId() {
return workbasketId;
}
public String getWorkbasketId() {
return workbasketId;
}
public void setWorkbasketId(String workbasketId) {
this.workbasketId = workbasketId;
}
public void setWorkbasketId(String workbasketId) {
this.workbasketId = workbasketId;
}
public String getUserId() {
return userId;
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getGroupId() {
return groupId;
}
public String getGroupId() {
return groupId;
}
public void setGroupId(String groupId) {
this.groupId = groupId;
}
public void setGroupId(String groupId) {
this.groupId = groupId;
}
public boolean isRead() {
return read;
}
public boolean isRead() {
return read;
}
public void setRead(boolean read) {
this.read = read;
}
public void setRead(boolean read) {
this.read = read;
}
public boolean isOpen() {
return open;
}
public boolean isOpen() {
return open;
}
public void setOpen(boolean open) {
this.open = open;
}
public void setOpen(boolean open) {
this.open = open;
}
public boolean isAppend() {
return append;
}
public boolean isAppend() {
return append;
}
public void setAppend(boolean append) {
this.append = append;
}
public void setAppend(boolean append) {
this.append = append;
}
public boolean isTransfer() {
return transfer;
}
public boolean isTransfer() {
return transfer;
}
public void setTransfer(boolean transfer) {
this.transfer = transfer;
}
public void setTransfer(boolean transfer) {
this.transfer = transfer;
}
public boolean isDistribute() {
return distribute;
}
public boolean isDistribute() {
return distribute;
}
public void setDistribute(boolean distribute) {
this.distribute = distribute;
}
public void setDistribute(boolean distribute) {
this.distribute = distribute;
}
}

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.
*/
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;
/**
* This class is the mybatis mapping of classifications.
*/
public interface ClassificationMapper {
@Select("SELECT * FROM CLASSIFICATION ORDER BY ID")
@Results({
@Result(property="id", column="ID"),
@Result(property="tenantId", column="TENANT_ID"),
@Result(property="parentClassificationId", column="PARENT_CLASSIFICATION_ID"),
@Result(property="category", column="CATEGORY"),
@Result(property="type", column="TYPE"),
@Result(property="created", column="CREATED"),
@Result(property="modified", column="MODIFIED"),
@Result(property="name", column="NAME"),
@Result(property="description", column="DESCRIPTION"),
@Result(property="priority", column="PRIORITY"),
@Result(property="serviceLevel", column="SERVICE_LEVEL")
})
List<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 ID = #{classificationId}")
Classification findById(@Param("classificationId") String classificationId);
@Insert("INSERT INTO CLASSIFICATION (ID, TENANT_ID, PARENT_CLASSIFICATION_ID, CATEGORY, TYPE, CREATED, NAME, DESCRIPTION, PRIORITY, SERVICE_LEVEL) VALUES (#{classification.id}, #{classification.tenantId}, #{classification.parentClassificationId}, #{classification.category}, #{classification.type}, #{classification.created}, #{classification.name}, #{classification.description}, #{classification.priority}, #{classification.serviceLevel})")
void insert(@Param("classification") Classification classification);
@Update(value = "UPDATE CLASSIFICATION SET TENANT_ID = #{classification.tenantId}, PARENT_CLASSIFICATION_ID = #{classification.parentClassificationId}, CATEGORY = #{classification.category}, TYPE = #{classification.type}, NAME = #{classification.name}, DESCRIPTION = #{classification.description}, PRIORITY = #{classification.priority}, SERVICE_LEVEL = #{classification.serviceLevel}, MODIFIED = #{classification.modified} WHERE ID = #{classification.id}")
void update(@Param("classification") Classification classification);
@Select("SELECT * FROM CLASSIFICATION ORDER BY ID")
@Results({ @Result(property = "id", column = "ID"),
@Result(property = "tenantId", column = "TENANT_ID"),
@Result(property = "parentClassificationId", column = "PARENT_CLASSIFICATION_ID"),
@Result(property = "category", column = "CATEGORY"),
@Result(property = "type", column = "TYPE"),
@Result(property = "created", column = "CREATED"),
@Result(property = "modified", column = "MODIFIED"),
@Result(property = "name", column = "NAME"),
@Result(property = "description", column = "DESCRIPTION"),
@Result(property = "priority", column = "PRIORITY"),
@Result(property = "serviceLevel", column = "SERVICE_LEVEL") })
List<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 ID = #{classificationId}")
Classification findById(@Param("classificationId") String classificationId);
@Insert("INSERT INTO CLASSIFICATION (ID, TENANT_ID, PARENT_CLASSIFICATION_ID, CATEGORY, TYPE, CREATED, NAME, DESCRIPTION, PRIORITY, SERVICE_LEVEL) VALUES (#{classification.id}, #{classification.tenantId}, #{classification.parentClassificationId}, #{classification.category}, #{classification.type}, #{classification.created}, #{classification.name}, #{classification.description}, #{classification.priority}, #{classification.serviceLevel})")
void insert(@Param("classification") Classification classification);
@Update(value = "UPDATE CLASSIFICATION SET TENANT_ID = #{classification.tenantId}, PARENT_CLASSIFICATION_ID = #{classification.parentClassificationId}, CATEGORY = #{classification.category}, TYPE = #{classification.type}, NAME = #{classification.name}, DESCRIPTION = #{classification.description}, PRIORITY = #{classification.priority}, SERVICE_LEVEL = #{classification.serviceLevel}, MODIFIED = #{classification.modified} WHERE ID = #{classification.id}")
void update(@Param("classification") Classification classification);
}

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

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

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.Update;
import org.taskana.model.WorkbasketAccessItem;
/**
* This class is the mybatis mapping of workbasket access items.
*/
public interface WorkbasketAccessMapper {
@Select("SELECT ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE FROM WORKBASKET_ACCESS_LIST WHERE ID = #{id}")
@Results(value = {
@Result(property = "id", column = "ID"),
@Results(value = {
@Result(property = "id", column = "ID"),
@Result(property = "workbasketId", column = "WORKBASKET_ID"),
@Result(property = "userId", column = "USER_ID"),
@Result(property = "groupId", column = "GROUP_ID"),
@ -24,12 +26,12 @@ public interface WorkbasketAccessMapper {
@Result(property = "open", column = "OPEN"),
@Result(property = "append", column = "APPEND"),
@Result(property = "transfer", column = "TRANSFER"),
@Result(property = "distribute", column = "DISTRIBUTE")})
@Result(property = "distribute", column = "DISTRIBUTE") })
WorkbasketAccessItem findById(@Param("id") String id);
@Select("SELECT ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE FROM WORKBASKET_ACCESS_LIST WHERE USER_ID = #{userId}")
@Results(value = {
@Result(property = "id", column = "ID"),
@Results(value = {
@Result(property = "id", column = "ID"),
@Result(property = "workbasketId", column = "WORKBASKET_ID"),
@Result(property = "userId", column = "USER_ID"),
@Result(property = "groupId", column = "GROUP_ID"),
@ -37,12 +39,12 @@ public interface WorkbasketAccessMapper {
@Result(property = "open", column = "OPEN"),
@Result(property = "append", column = "APPEND"),
@Result(property = "transfer", column = "TRANSFER"),
@Result(property = "distribute", column = "DISTRIBUTE")})
@Result(property = "distribute", column = "DISTRIBUTE") })
List<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}")
@Results(value = {
@Result(property = "id", column = "ID"),
@Results(value = {
@Result(property = "id", column = "ID"),
@Result(property = "workbasketId", column = "WORKBASKET_ID"),
@Result(property = "userId", column = "USER_ID"),
@Result(property = "groupId", column = "GROUP_ID"),
@ -50,12 +52,12 @@ public interface WorkbasketAccessMapper {
@Result(property = "open", column = "OPEN"),
@Result(property = "append", column = "APPEND"),
@Result(property = "transfer", column = "TRANSFER"),
@Result(property = "distribute", column = "DISTRIBUTE")})
@Result(property = "distribute", column = "DISTRIBUTE") })
List<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")
@Results(value = {
@Result(property = "id", column = "ID"),
@Results(value = {
@Result(property = "id", column = "ID"),
@Result(property = "workbasketId", column = "WORKBASKET_ID"),
@Result(property = "userId", column = "USER_ID"),
@Result(property = "groupId", column = "GROUP_ID"),
@ -63,32 +65,32 @@ public interface WorkbasketAccessMapper {
@Result(property = "open", column = "OPEN"),
@Result(property = "append", column = "APPEND"),
@Result(property = "transfer", column = "TRANSFER"),
@Result(property = "distribute", column = "DISTRIBUTE")})
@Result(property = "distribute", column = "DISTRIBUTE") })
List<WorkbasketAccessItem> findAll();
@Insert("INSERT INTO WORKBASKET_ACCESS_LIST (ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE) "
+ "VALUES (#{workbasketAccessItem.id}, #{workbasketAccessItem.workbasketId}, #{workbasketAccessItem.userId}, #{workbasketAccessItem.groupId}, #{workbasketAccessItem.read}, #{workbasketAccessItem.open}, #{workbasketAccessItem.append}, #{workbasketAccessItem.transfer}, #{workbasketAccessItem.distribute})")
@Options(keyProperty = "id", keyColumn="ID")
@Options(keyProperty = "id", keyColumn = "ID")
void insert(@Param("workbasketAccessItem") WorkbasketAccessItem workbasketAccessItem);
@Update("UPDATE WORKBASKET_ACCESS_LIST SET WORKBASKET_ID = #{workbasketAccessItem.workbasketId}, USER_ID = #{workbasketAccessItem.userId}, GROUP_ID = #{workbasketAccessItem.groupId}, READ = #{workbasketAccessItem.read}, OPEN = #{workbasketAccessItem.open}, APPEND = #{workbasketAccessItem.append}, TRANSFER = #{workbasketAccessItem.transfer}, DISTRIBUTE = #{workbasketAccessItem.distribute} "
+ "WHERE id = #{workbasketAccessItem.id}")
void update(@Param("workbasketAccessItem") WorkbasketAccessItem workbasketAccessItem);
@Delete("DELETE FROM WORKBASKET_ACCESS_LIST where id = #{id}")
void delete(@Param("id") String id);
@Select("<script>SELECT ID, WORKBASKET_ID, USER_ID, GROUP_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE "
+ "FROM WORKBASKET_ACCESS_LIST "
+ "WHERE WORKBASKET_ID = #{workbasketId} "
+ "AND USER_ID = #{userId} "
+ "AND <if test=\"authorization == 'OPEN'\">OPEN</if>"
+ "<if test=\"authorization == 'READ'\">READ</if>"
+ "<if test=\"authorization == 'APPEND'\">APPEND</if>"
+ "<if test=\"authorization == 'TRANSFER'\">TRANSFER</if>"
+ "<if test=\"authorization == 'DISTRIBUTE'\">DISTRIBUTE</if> = 1</script>")
@Results(value = {
@Result(property = "id", column = "ID"),
+ "FROM WORKBASKET_ACCESS_LIST "
+ "WHERE WORKBASKET_ID = #{workbasketId} "
+ "AND USER_ID = #{userId} "
+ "AND <if test=\"authorization == 'OPEN'\">OPEN</if>"
+ "<if test=\"authorization == 'READ'\">READ</if>"
+ "<if test=\"authorization == 'APPEND'\">APPEND</if>"
+ "<if test=\"authorization == 'TRANSFER'\">TRANSFER</if>"
+ "<if test=\"authorization == 'DISTRIBUTE'\">DISTRIBUTE</if> = 1</script>")
@Results(value = {
@Result(property = "id", column = "ID"),
@Result(property = "workbasketId", column = "WORKBASKET_ID"),
@Result(property = "userId", column = "USER_ID"),
@Result(property = "groupId", column = "GROUP_ID"),
@ -96,12 +98,12 @@ public interface WorkbasketAccessMapper {
@Result(property = "open", column = "OPEN"),
@Result(property = "append", column = "APPEND"),
@Result(property = "transfer", column = "TRANSFER"),
@Result(property = "distribute", column = "DISTRIBUTE")})
@Result(property = "distribute", column = "DISTRIBUTE") })
List<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}")
@Results(value = {
@Result(property = "id", column = "ID"),
@Results(value = {
@Result(property = "id", column = "ID"),
@Result(property = "workbasketId", column = "WORKBASKET_ID"),
@Result(property = "userId", column = "USER_ID"),
@Result(property = "groupId", column = "GROUP_ID"),
@ -109,6 +111,6 @@ public interface WorkbasketAccessMapper {
@Result(property = "open", column = "OPEN"),
@Result(property = "append", column = "APPEND"),
@Result(property = "transfer", column = "TRANSFER"),
@Result(property = "distribute", column = "DISTRIBUTE")})
@Result(property = "distribute", column = "DISTRIBUTE") })
List<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.taskana.model.Workbasket;
import org.taskana.model.WorkbasketAuthorization;
/**
* This class is the mybatis mapping of workbaskets.
*/
public interface WorkbasketMapper {
@Select("SELECT ID, TENANT_ID, CREATED, MODIFIED, NAME, DESCRIPTION, OWNER FROM WORKBASKET WHERE ID = #{id}")
@Results(value = {
@Result(property = "id", column = "ID"),
@Result(property = "tenantId", column = "TENANT_ID"),
@Result(property = "created", column = "CREATED"),
@Result(property = "modified", column = "MODIFIED"),
@Result(property = "name", column = "NAME"),
@Result(property = "description", column = "DESCRIPTION"),
@Result(property = "owner", column = "OWNER"),
@Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select="findByDistributionTargets")) })
public Workbasket findById(@Param("id") String id);
@Select("SELECT * FROM WORKBASKET WHERE id IN (SELECT TARGET_ID FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{id})")
@Results(value = {
@Result(property = "id", column = "ID"),
@Result(property = "tenantId", column = "TENANT_ID"),
@Result(property = "created", column = "CREATED"),
@Result(property = "modified", column = "MODIFIED"),
@Result(property = "name", column = "NAME"),
@Result(property = "description", column = "DESCRIPTION"),
@Result(property = "owner", column = "OWNER"),
@Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select="findByDistributionTargets")) })
public List<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);
@Select("SELECT ID, TENANT_ID, CREATED, MODIFIED, NAME, DESCRIPTION, OWNER FROM WORKBASKET WHERE ID = #{id}")
@Results(value = { @Result(property = "id", column = "ID"),
@Result(property = "tenantId", column = "TENANT_ID"),
@Result(property = "created", column = "CREATED"),
@Result(property = "modified", column = "MODIFIED"),
@Result(property = "name", column = "NAME"),
@Result(property = "description", column = "DESCRIPTION"),
@Result(property = "owner", column = "OWNER"),
@Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")) })
Workbasket findById(@Param("id") String id);
@Insert("INSERT INTO WORKBASKET (ID, TENANT_ID, CREATED, MODIFIED, NAME, DESCRIPTION, OWNER) VALUES (#{workbasket.id}, #{workbasket.tenantId}, #{workbasket.created}, #{workbasket.modified}, #{workbasket.name}, #{workbasket.description}, #{workbasket.owner})")
@Options(keyProperty = "id", keyColumn="ID")
public void insert(@Param("workbasket") Workbasket workbasket);
@Select("SELECT * FROM WORKBASKET WHERE id IN (SELECT TARGET_ID FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{id})")
@Results(value = {
@Result(property = "id", column = "ID"),
@Result(property = "tenantId", column = "TENANT_ID"),
@Result(property = "created", column = "CREATED"),
@Result(property = "modified", column = "MODIFIED"),
@Result(property = "name", column = "NAME"),
@Result(property = "description", column = "DESCRIPTION"),
@Result(property = "owner", column = "OWNER"),
@Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")) })
List<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}")
public void update(@Param("workbasket") Workbasket workbasket);
@Select("SELECT * FROM WORKBASKET ORDER BY id")
@Results(value = {
@Result(property = "id", column = "ID"),
@Result(property = "tenantId", column = "TENANT_ID"),
@Result(property = "created", column = "CREATED"),
@Result(property = "modified", column = "MODIFIED"),
@Result(property = "name", column = "NAME"),
@Result(property = "description", column = "DESCRIPTION"),
@Result(property = "owner", column = "OWNER"),
@Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")) })
List<Workbasket> findAll();
@Delete("DELETE FROM WORKBASKET where id = #{id}")
public void delete(@Param("id") String id);
@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")) })
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
* context is gathered from the JAAS subject.
*
* @author Holger Hagen
*
*/
public class CurrentUserContext {
public final class CurrentUserContext {
private static final String GET_UNIQUE_SECURITY_NAME_METHOD = "getUniqueSecurityName";
private static final String GET_CALLER_SUBJECT_METHOD = "getCallerSubject";
private static final String WSSUBJECT_CLASSNAME = "com.ibm.websphere.security.auth.WSSubject";
private static final String GET_UNIQUE_SECURITY_NAME_METHOD = "getUniqueSecurityName";
private static final String GET_CALLER_SUBJECT_METHOD = "getCallerSubject";
private static final String WSSUBJECT_CLASSNAME = "com.ibm.websphere.security.auth.WSSubject";
private static final Logger logger = LoggerFactory.getLogger(CurrentUserContext.class);
private static Boolean runningOnWebSphere = null;
private static final Logger LOGGER = LoggerFactory.getLogger(CurrentUserContext.class);
/**
* Returns the userid of the current user.
*
* @return String the userid. null if there is no JAAS subject.
*/
public static String getUserid() {
if (runningOnWebSphere()) {
return getUseridFromWSSubject();
} else {
return getUseridFromJAASSubject();
}
}
private static Boolean runningOnWebSphere = null;
/**
* Returns the unique security name of the first public credentials found in the WSSubject as userid.
*
* @return the userid of the caller. If the userid could not be obtained, null is returned.
*/
private static String getUseridFromWSSubject() {
try {
Class<?> wsSubjectClass = Class.forName(WSSUBJECT_CLASSNAME);
Method getCallerSubjectMethod = wsSubjectClass.getMethod(GET_CALLER_SUBJECT_METHOD, (Class<?>[]) null);
Subject callerSubject = (Subject) getCallerSubjectMethod.invoke(null, (Object[]) null);
logger.debug("Subject of caller: {}", callerSubject);
if (callerSubject != null) {
Set<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;
}
private CurrentUserContext() {
}
/**
* Checks, whether Taskana is running on IBM WebSphere.
*
* @return true, if it is running on IBM WebSphere
*/
private static boolean runningOnWebSphere() {
if (runningOnWebSphere == null) {
try {
Class.forName(WSSUBJECT_CLASSNAME);
logger.debug("WSSubject detected. Assuming that Taskana runs on IBM WebSphere.");
runningOnWebSphere = new Boolean(true);
} catch (ClassNotFoundException e) {
logger.debug("No WSSubject detected. Using JAAS subject further on.");
runningOnWebSphere = new Boolean(false);
}
}
return runningOnWebSphere;
}
/**
* Returns the userid of the current user.
* @return String the userid. null if there is no JAAS subject.
*/
public static String getUserid() {
if (runningOnWebSphere()) {
return getUseridFromWSSubject();
} else {
return getUseridFromJAASSubject();
}
}
private static String getUseridFromJAASSubject() {
Subject subject = Subject.getSubject(AccessController.getContext());
logger.debug("Subject of caller: {}", subject);
if (subject != null) {
Set<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;
}
/**
* 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;
}
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.Mockito.*;
/**
* Unit Test for ClassificationServiceImpl.
* @author EH
*/
@RunWith(MockitoJUnitRunner.class)
public class ClassificationServiceImplTest {
@InjectMocks
@InjectMocks
ClassificationServiceImpl classificationService;
@Mock
@Mock
ClassificationMapper classificationMapper;
@Test
public void testInsertClassification() {
doNothing().when(classificationMapper).insert(any());
@Test
public void testInsertClassification() {
doNothing().when(classificationMapper).insert(any());
Classification classification = new Classification();
classification.setId("0");
classificationService.insertClassification(classification);
when(classificationMapper.findById(any())).thenReturn(classification);
Classification classification = new Classification();
classification.setId("0");
classificationService.insertClassification(classification);
Assert.assertNotNull(classificationService.selectClassificationById(classification.getId()));
}
when(classificationMapper.findById(any())).thenReturn(classification);
@Test
public void testFindAllClassifications() {
doNothing().when(classificationMapper).insert(any());
Assert.assertNotNull(classificationService.selectClassificationById(classification.getId()));
}
Classification classification0 = new Classification();
classification0.setId("0");
classification0.setParentClassificationId("");
classificationService.insertClassification(classification0);
Classification classification1 = new Classification();
classification1.setId("1");
classification1.setParentClassificationId("");
classificationService.insertClassification(classification1);
List<Classification> classifications = new ArrayList<>();
classifications.add(classification0);
when(classificationMapper.findByParentId("")).thenReturn(classifications);
@Test
public void testFindAllClassifications() {
doNothing().when(classificationMapper).insert(any());
verify(classificationMapper, atLeast(2)).insert(any());
Assert.assertEquals(1, classificationService.selectClassifications().size());
}
Classification classification0 = new Classification();
classification0.setId("0");
classification0.setParentClassificationId("");
classificationService.insertClassification(classification0);
Classification classification1 = new Classification();
classification1.setId("1");
classification1.setParentClassificationId("");
classificationService.insertClassification(classification1);
@Test
public void testFindByParentClassification() {
doNothing().when(classificationMapper).insert(any());
List<Classification> classifications = new ArrayList<>();
classifications.add(classification0);
when(classificationMapper.findByParentId("")).thenReturn(classifications);
Classification classification0 = new Classification();
classification0.setId("0");
classification0.setParentClassificationId("0");
classificationService.insertClassification(classification0);
Classification classification1 = new Classification();
classification1.setId("1");
classification1.setParentClassificationId("0");
classificationService.insertClassification(classification1);
verify(classificationMapper, atLeast(2)).insert(any());
Assert.assertEquals(1, classificationService.selectClassifications().size());
}
List<Classification> classifications = new ArrayList<>();
classifications.add(classification0);
classifications.add(classification1);
when(classificationMapper.findByParentId(any())).thenReturn(classifications);
@Test
public void testFindByParentClassification() {
doNothing().when(classificationMapper).insert(any());
verify(classificationMapper, atLeast(2)).insert(any());
Classification classification0 = new Classification();
classification0.setId("0");
classification0.setParentClassificationId("0");
classificationService.insertClassification(classification0);
Classification classification1 = new Classification();
classification1.setId("1");
classification1.setParentClassificationId("0");
classificationService.insertClassification(classification1);
Assert.assertEquals(2, classificationService.selectClassificationsByParentId("0").size());
}
List<Classification> classifications = new ArrayList<>();
classifications.add(classification0);
classifications.add(classification1);
when(classificationMapper.findByParentId(any())).thenReturn(classifications);
@Test
public void testModifiedClassification() {
doNothing().when(classificationMapper).insert(any());
doNothing().when(classificationMapper).update(any());
verify(classificationMapper, atLeast(2)).insert(any());
Classification classification = new Classification();
classificationService.insertClassification(classification);
classification.setDescription("TEST EVERYTHING");
classificationService.updateClassification(classification);
Assert.assertEquals(2, classificationService.selectClassificationsByParentId("0").size());
}
Assert.assertEquals(classification.getModified().toString(), LocalDate.now().toString());
}
@Test
public void testModifiedClassification() {
doNothing().when(classificationMapper).insert(any());
doNothing().when(classificationMapper).update(any());
Classification classification = new Classification();
classificationService.insertClassification(classification);
classification.setDescription("TEST EVERYTHING");
classificationService.updateClassification(classification);
Assert.assertEquals(classification.getModified().toString(), LocalDate.now().toString());
}
}

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

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.WorkbasketMapper;
/**
* Unit Test for workbasketServiceImpl.
* @author EH
*/
@RunWith(MockitoJUnitRunner.class)
public class WorkbasketServiceImplTest {
@InjectMocks
WorkbasketServiceImpl workbasketServiceImpl;
private static final int THREE = 3;
@Mock
WorkbasketMapper workbasketMapper;
@Mock
DistributionTargetMapper distributionTargetMapper;
@Mock
WorkbasketAccessMapper workbasketAccessMapper;
@Mock
TaskanaEngine taskanaEngine;
@Mock
TaskanaEngineConfiguration taskanaEngineConfiguration;
private static final int SLEEP_TIME = 100;
@Test
public void should_ReturnWorkbasket_when_WorkbasketIdExists() throws WorkbasketNotFoundException {
when(workbasketMapper.findById(any())).thenReturn(new Workbasket());
@InjectMocks
WorkbasketServiceImpl workbasketServiceImpl;
Workbasket workbasket = workbasketServiceImpl.getWorkbasket("fail");
@Mock
WorkbasketMapper workbasketMapper;
@Mock
DistributionTargetMapper distributionTargetMapper;
@Mock
WorkbasketAccessMapper workbasketAccessMapper;
@Mock
TaskanaEngine taskanaEngine;
@Mock
TaskanaEngineConfiguration taskanaEngineConfiguration;
verify(workbasketMapper).findById(any());
Assert.assertNotNull(workbasket);
}
@Test
public void should_ReturnWorkbasket_when_WorkbasketIdExists() throws WorkbasketNotFoundException {
when(workbasketMapper.findById(any())).thenReturn(new Workbasket());
@Test(expected = WorkbasketNotFoundException.class)
public void should_ThrowWorkbasketNotFoundException_when_WorkbasketIdDoesNotExist()
throws WorkbasketNotFoundException {
workbasketServiceImpl.getWorkbasket("fail");
}
Workbasket workbasket = workbasketServiceImpl.getWorkbasket("fail");
@Test
public void should_ReturnListOfWorkbaskets_when_PermissionAndUserExists() {
when(workbasketMapper.findByPermission(any(), any())).thenReturn(new ArrayList<Workbasket>());
verify(workbasketMapper).findById(any());
Assert.assertNotNull(workbasket);
}
List<WorkbasketAuthorization> authorizations = new ArrayList<>();
authorizations.add(WorkbasketAuthorization.OPEN);
authorizations.add(WorkbasketAuthorization.APPEND);
List<Workbasket> workbaskets = workbasketServiceImpl.getWorkbaskets(authorizations);
@Test(expected = WorkbasketNotFoundException.class)
public void should_ThrowWorkbasketNotFoundException_when_WorkbasketIdDoesNotExist()
throws WorkbasketNotFoundException {
workbasketServiceImpl.getWorkbasket("fail");
}
verify(workbasketMapper).findByPermission(any(), any());
Assert.assertNotNull(workbaskets);
}
@Test
public void should_ReturnListOfWorkbaskets_when_PermissionAndUserExists() {
when(workbasketMapper.findByPermission(any(), any())).thenReturn(new ArrayList<Workbasket>());
@Test
public void should_ReturnAllWorkbaskets_when_AllWorkbaskets() {
when(workbasketMapper.findAll()).thenReturn(new ArrayList<Workbasket>());
List<WorkbasketAuthorization> authorizations = new ArrayList<>();
authorizations.add(WorkbasketAuthorization.OPEN);
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();
Assert.assertNotNull(workbaskets);
}
@Test
public void should_ReturnAllWorkbaskets_when_AllWorkbaskets() {
when(workbasketMapper.findAll()).thenReturn(new ArrayList<Workbasket>());
@Test
public void should_InitializeAndStoreWorkbasket_when_WorkbasketIsCreated() throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
Workbasket workbasket = new Workbasket();
workbasket.setId("1");
workbasketServiceImpl.createWorkbasket(workbasket);
List<Workbasket> workbaskets = workbasketServiceImpl.getWorkbaskets();
Assert.assertEquals("1", workbasket.getId());
Assert.assertEquals(workbasket.getModified(), workbasket.getCreated());
verify(workbasketMapper).findAll();
Assert.assertNotNull(workbaskets);
}
verify(workbasketMapper).insert(any());
}
@Test
public void should_InitializeAndStoreWorkbasket_when_WorkbasketIsCreated() throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
@SuppressWarnings("serial")
@Test
public void should_InitializeAndStoreWorkbasket_when_WorkbasketWithDistributionTargetsIsCreated() throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
doNothing().when(distributionTargetMapper).insert(any(), any());
Workbasket workbasket = new Workbasket();
workbasket.setId("1");
workbasketServiceImpl.createWorkbasket(workbasket);
Workbasket workbasket = new Workbasket();
workbasket.setId("1");
Workbasket workbasket1 = new Workbasket();
workbasket1.setId("2");
Workbasket workbasket2 = new Workbasket();
workbasket2.setId("3");
workbasket.setDistributionTargets(new ArrayList<Workbasket>() {
{
add(workbasket1);
add(workbasket2);
}
});
Assert.assertEquals("1", workbasket.getId());
Assert.assertEquals(workbasket.getModified(), workbasket.getCreated());
workbasketServiceImpl.createWorkbasket(workbasket);
verify(workbasketMapper).insert(any());
}
Assert.assertEquals("1", workbasket.getId());
Assert.assertEquals(workbasket.getModified(), workbasket.getCreated());
@SuppressWarnings("serial")
@Test
public void should_InitializeAndStoreWorkbasket_when_WorkbasketWithDistributionTargetsIsCreated()
throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
doNothing().when(distributionTargetMapper).insert(any(), any());
verify(workbasketMapper, times(3)).insert(any());
verify(distributionTargetMapper, times(2)).insert(any(), any());
}
Workbasket workbasket = new Workbasket();
workbasket.setId("1");
Workbasket workbasket1 = new Workbasket();
workbasket1.setId("2");
Workbasket workbasket2 = new Workbasket();
workbasket2.setId("3");
workbasket.setDistributionTargets(new ArrayList<Workbasket>() {
{
add(workbasket1);
add(workbasket2);
}
});
@Test
public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDescriptionIsChanged() throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
workbasketServiceImpl.createWorkbasket(workbasket);
Workbasket workbasket = new Workbasket();
workbasket.setId("0");
workbasket.setDescription("TestDescription");
workbasket.setName("Cool New WorkintheBasket");
workbasket.setOwner("Arthur Dent");
workbasketServiceImpl.createWorkbasket(workbasket);
Assert.assertEquals("1", workbasket.getId());
Assert.assertEquals(workbasket.getModified(), workbasket.getCreated());
doNothing().when(workbasketMapper).update(any());
workbasket.setDescription("42");
workbasketServiceImpl.updateWorkbasket(workbasket);
verify(workbasketMapper, times(THREE)).insert(any());
verify(distributionTargetMapper, times(2)).insert(any(), any());
}
verify(workbasketMapper).update(any());
}
@Test
public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDescriptionIsChanged()
throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
@SuppressWarnings("serial")
@Test
public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDistributionTargetIsChanged()
throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
Workbasket workbasket = new Workbasket();
workbasket.setId("0");
workbasket.setDescription("TestDescription");
workbasket.setName("Cool New WorkintheBasket");
workbasket.setOwner("Arthur Dent");
workbasketServiceImpl.createWorkbasket(workbasket);
Workbasket workbasket = new Workbasket();
workbasket.setId("0");
Workbasket workbasket1 = new Workbasket();
workbasket1.setId("1");
workbasket.setDistributionTargets(new ArrayList<Workbasket>() {
{
add(workbasket1);
}
});
workbasketServiceImpl.createWorkbasket(workbasket);
doNothing().when(workbasketMapper).update(any());
workbasket.setDescription("42");
workbasketServiceImpl.updateWorkbasket(workbasket);
doNothing().when(workbasketMapper).update(any());
when(workbasketMapper.findById(any())).thenReturn(workbasket);
workbasket.getDistributionTargets().get(0).setDescription("Test123");
Workbasket result = workbasketServiceImpl.updateWorkbasket(workbasket);
verify(workbasketMapper).update(any());
}
verify(workbasketMapper).update(any());
Assert.assertEquals("Test123", result.getDistributionTargets().get(0).getDescription());
}
@SuppressWarnings("serial")
@Test
public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDistributionTargetIsChanged()
throws NotAuthorizedException {
doNothing().when(workbasketMapper).insert(any());
@Test
public void should_UpdateModifiedTimestamp_when_ExistingWorkbasketDistributionTargetIsChanged()
throws Exception {
doNothing().when(workbasketMapper).insert(any());
Workbasket workbasket = new Workbasket();
workbasket.setId("0");
Workbasket workbasket1 = new Workbasket();
workbasket1.setId("1");
workbasket.setDistributionTargets(new ArrayList<Workbasket>() {
{
add(workbasket1);
}
});
workbasketServiceImpl.createWorkbasket(workbasket);
Workbasket workbasket0 = new Workbasket();
workbasket0.setId("0");
Workbasket workbasket1 = new Workbasket();
workbasket1.setId("1");
Workbasket workbasket2 = new Workbasket();
workbasket2.setId("2");
workbasket2.getDistributionTargets().add(workbasket0);
workbasket2.getDistributionTargets().add(workbasket1);
workbasketServiceImpl.createWorkbasket(workbasket2);
doNothing().when(workbasketMapper).update(any());
when(workbasketMapper.findById(any())).thenReturn(workbasket);
workbasket.getDistributionTargets().get(0).setDescription("Test123");
Workbasket result = workbasketServiceImpl.updateWorkbasket(workbasket);
Workbasket workbasket3 = new Workbasket();
workbasket3.setId("3");
workbasket2.getDistributionTargets().clear();
workbasket2.getDistributionTargets().add(workbasket3);
Thread.sleep(100);
verify(workbasketMapper).update(any());
Assert.assertEquals("Test123", result.getDistributionTargets().get(0).getDescription());
}
doNothing().when(workbasketMapper).update(any());
workbasketServiceImpl.updateWorkbasket(workbasket2);
@Test
public void should_UpdateModifiedTimestamp_when_ExistingWorkbasketDistributionTargetIsChanged() throws Exception {
doNothing().when(workbasketMapper).insert(any());
when(workbasketMapper.findById("2")).thenReturn(workbasket2);
Workbasket foundBasket = workbasketServiceImpl.getWorkbasket(workbasket2.getId());
Workbasket workbasket0 = new Workbasket();
workbasket0.setId("0");
Workbasket workbasket1 = new Workbasket();
workbasket1.setId("1");
Workbasket workbasket2 = new Workbasket();
workbasket2.setId("2");
workbasket2.getDistributionTargets().add(workbasket0);
workbasket2.getDistributionTargets().add(workbasket1);
workbasketServiceImpl.createWorkbasket(workbasket2);
when(workbasketMapper.findById("1")).thenReturn(workbasket1);
when(workbasketMapper.findById("3")).thenReturn(workbasket1);
Workbasket workbasket3 = new Workbasket();
workbasket3.setId("3");
workbasket2.getDistributionTargets().clear();
workbasket2.getDistributionTargets().add(workbasket3);
Thread.sleep(SLEEP_TIME);
List<Workbasket> distributionTargets = foundBasket.getDistributionTargets();
Assert.assertEquals(1, distributionTargets.size());
Assert.assertEquals("3", distributionTargets.get(0).getId());
doNothing().when(workbasketMapper).update(any());
workbasketServiceImpl.updateWorkbasket(workbasket2);
Assert.assertNotEquals(workbasketServiceImpl.getWorkbasket("2").getCreated(),
workbasketServiceImpl.getWorkbasket("2").getModified());
Assert.assertEquals(workbasketServiceImpl.getWorkbasket("1").getCreated(),
workbasketServiceImpl.getWorkbasket("1").getModified());
Assert.assertEquals(workbasketServiceImpl.getWorkbasket("3").getCreated(),
workbasketServiceImpl.getWorkbasket("3").getModified());
}
when(workbasketMapper.findById("2")).thenReturn(workbasket2);
Workbasket foundBasket = workbasketServiceImpl.getWorkbasket(workbasket2.getId());
@Test
public void should_ReturnWorkbasketAuthorization_when_NewWorkbasketAccessItemIsCreated()
throws NotAuthorizedException {
doNothing().when(workbasketAccessMapper).insert(any());
when(workbasketMapper.findById("1")).thenReturn(workbasket1);
when(workbasketMapper.findById("3")).thenReturn(workbasket1);
WorkbasketAccessItem accessItem = new WorkbasketAccessItem();
accessItem.setWorkbasketId("1");
accessItem.setUserId("Arthur Dent");
accessItem.setOpen(true);
accessItem.setRead(true);
accessItem = workbasketServiceImpl.createWorkbasketAuthorization(accessItem);
List<Workbasket> distributionTargets = foundBasket.getDistributionTargets();
Assert.assertEquals(1, distributionTargets.size());
Assert.assertEquals("3", distributionTargets.get(0).getId());
Assert.assertNotNull(accessItem.getId());
}
Assert.assertNotEquals(workbasketServiceImpl.getWorkbasket("2").getCreated(),
workbasketServiceImpl.getWorkbasket("2").getModified());
Assert.assertEquals(workbasketServiceImpl.getWorkbasket("1").getCreated(),
workbasketServiceImpl.getWorkbasket("1").getModified());
Assert.assertEquals(workbasketServiceImpl.getWorkbasket("3").getCreated(),
workbasketServiceImpl.getWorkbasket("3").getModified());
}
@Test
public void should_ReturnWorkbasketAuthorization_when_WorkbasketAccessItemIsUpdated()
throws NotAuthorizedException {
doNothing().when(workbasketAccessMapper).insert(any());
@Test
public void should_ReturnWorkbasketAuthorization_when_NewWorkbasketAccessItemIsCreated()
throws NotAuthorizedException {
doNothing().when(workbasketAccessMapper).insert(any());
WorkbasketAccessItem accessItem = new WorkbasketAccessItem();
accessItem.setWorkbasketId("1");
accessItem.setUserId("Arthur Dent");
accessItem.setOpen(true);
accessItem.setRead(true);
accessItem = workbasketServiceImpl.createWorkbasketAuthorization(accessItem);
WorkbasketAccessItem accessItem = new WorkbasketAccessItem();
accessItem.setWorkbasketId("1");
accessItem.setUserId("Arthur Dent");
accessItem.setOpen(true);
accessItem.setRead(true);
accessItem = workbasketServiceImpl.createWorkbasketAuthorization(accessItem);
Assert.assertNotNull(accessItem.getId());
Assert.assertNotNull(accessItem.getId());
}
doNothing().when(workbasketAccessMapper).update(any());
accessItem.setUserId("Zaphod Beeblebrox");
workbasketServiceImpl.updateWorkbasketAuthorization(accessItem);
@Test
public void should_ReturnWorkbasketAuthorization_when_WorkbasketAccessItemIsUpdated()
throws NotAuthorizedException {
doNothing().when(workbasketAccessMapper).insert(any());
Assert.assertEquals("Zaphod Beeblebrox", accessItem.getUserId());
}
WorkbasketAccessItem accessItem = new WorkbasketAccessItem();
accessItem.setWorkbasketId("1");
accessItem.setUserId("Arthur Dent");
accessItem.setOpen(true);
accessItem.setRead(true);
accessItem = workbasketServiceImpl.createWorkbasketAuthorization(accessItem);
@Test(expected = NotAuthorizedException.class)
public void should_ThrowNotAuthorizedException_when_OperationIsNotAuthorized() throws NotAuthorizedException {
when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration);
when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(true);
Assert.assertNotNull(accessItem.getId());
workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ);
}
doNothing().when(workbasketAccessMapper).update(any());
accessItem.setUserId("Zaphod Beeblebrox");
workbasketServiceImpl.updateWorkbasketAuthorization(accessItem);
@SuppressWarnings("serial")
@Test
public void should_Pass_when_OperationIsAuthorized() throws NotAuthorizedException {
when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration);
when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(true);
Assert.assertEquals("Zaphod Beeblebrox", accessItem.getUserId());
}
when(workbasketAccessMapper.findByWorkbasketAndUserAndAuthorization(any(), any(), any()))
.thenReturn(new ArrayList<WorkbasketAccessItem>() {
{
add(new WorkbasketAccessItem());
}
});
@Test(expected = NotAuthorizedException.class)
public void should_ThrowNotAuthorizedException_when_OperationIsNotAuthorized() throws NotAuthorizedException {
when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration);
when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(true);
workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ);
verify(workbasketAccessMapper, times(1)).findByWorkbasketAndUserAndAuthorization(any(), any(), any());
}
workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ);
}
@Test
public void should_Pass_when_SecurityIsDisabled() throws NotAuthorizedException {
when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration);
when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(false);
@SuppressWarnings("serial")
@Test
public void should_Pass_when_OperationIsAuthorized() throws NotAuthorizedException {
when(taskanaEngine.getConfiguration()).thenReturn(taskanaEngineConfiguration);
when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(true);
workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ);
}
when(workbasketAccessMapper.findByWorkbasketAndUserAndAuthorization(any(), any(), any()))
.thenReturn(new ArrayList<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.taskana.TaskanaEngine;
import org.taskana.configuration.TaskanaEngineConfiguration;
/**
* Integration Test for TaskanaEngineConfiguration.
* @author EH
*/
public class TaskanaEngineConfigurationTest {
@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.time.LocalDate;
/**
* Integration Test for ClassificationServiceImpl.
* @author EH
*/
public class ClassificationServiceImplIntTest {
static int counter = 0;
private ClassificationService classificationService;
static int counter = 0;
private ClassificationService classificationService;
@Before
public void setup() throws FileNotFoundException, SQLException, LoginException {
JdbcDataSource ds = new JdbcDataSource();
ds.setURL("jdbc:h2:mem:test-db-classification" + counter++);
ds.setPassword("sa");
ds.setUser("sa");
TaskanaEngineConfiguration taskEngineConfiguration = new TaskanaEngineConfiguration(ds, false);
@Before
public void setup() throws FileNotFoundException, SQLException, LoginException {
JdbcDataSource ds = new JdbcDataSource();
ds.setURL("jdbc:h2:mem:test-db-classification" + counter++);
ds.setPassword("sa");
ds.setUser("sa");
TaskanaEngineConfiguration taskEngineConfiguration = new TaskanaEngineConfiguration(ds, false);
TaskanaEngine te = taskEngineConfiguration.buildTaskanaEngine();
classificationService = te.getClassificationService();
}
TaskanaEngine te = taskEngineConfiguration.buildTaskanaEngine();
classificationService = te.getClassificationService();
}
@Test
public void testInsertClassification() {
Classification classification = new Classification();
classification.setId("0");
classificationService.insertClassification(classification);
@Test
public void testInsertClassification() {
Classification classification = new Classification();
classification.setId("0");
classificationService.insertClassification(classification);
Assert.assertNotNull(classificationService.selectClassificationById(classification.getId()));
}
Assert.assertNotNull(classificationService.selectClassificationById(classification.getId()));
}
@Test
public void testFindAllClassifications() {
Classification classification0 = new Classification();
classification0.setId("0");
classification0.setParentClassificationId("");
classificationService.insertClassification(classification0);
Classification classification1 = new Classification();
classification1.setId("1");
classification1.setParentClassificationId("");
classificationService.insertClassification(classification1);
@Test
public void testFindAllClassifications() {
Classification classification0 = new Classification();
classification0.setId("0");
classification0.setParentClassificationId("");
classificationService.insertClassification(classification0);
Classification classification1 = new Classification();
classification1.setId("1");
classification1.setParentClassificationId("");
classificationService.insertClassification(classification1);
Assert.assertEquals(2, classificationService.selectClassifications().size());
}
Assert.assertEquals(2, classificationService.selectClassifications().size());
}
@Test
public void testFindByParentClassification() {
Classification classification0 = new Classification();
classification0.setId("0");
classification0.setParentClassificationId("0");
classificationService.insertClassification(classification0);
Classification classification1 = new Classification();
classification1.setId("1");
classification1.setParentClassificationId("0");
classificationService.insertClassification(classification1);
@Test
public void testFindByParentClassification() {
Classification classification0 = new Classification();
classification0.setId("0");
classification0.setParentClassificationId("0");
classificationService.insertClassification(classification0);
Classification classification1 = new Classification();
classification1.setId("1");
classification1.setParentClassificationId("0");
classificationService.insertClassification(classification1);
Assert.assertEquals(2, classificationService.selectClassificationsByParentId("0").size());
}
Assert.assertEquals(2, classificationService.selectClassificationsByParentId("0").size());
}
@Test
public void testModifiedClassification() {
Classification classification = new Classification();
classificationService.insertClassification(classification);
classification.setDescription("TEST EVERYTHING");
classificationService.updateClassification(classification);
@Test
public void testModifiedClassification() {
Classification classification = new Classification();
classificationService.insertClassification(classification);
classification.setDescription("TEST EVERYTHING");
classificationService.updateClassification(classification);
Assert.assertEquals(classification.getModified().toString(), LocalDate.now().toString());
}
Assert.assertEquals(classification.getModified().toString(), LocalDate.now().toString());
}
}

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

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