TaskanaEngineImpl (pro.taskana:taskana-core 1.0.7 API)

java.lang.Object
- pro.taskana.impl.TaskanaEngineImpl

All Implemented Interfaces:

TaskanaEngine
```
public class TaskanaEngineImpl
extends Object
implements TaskanaEngine
```
This is the implementation of TaskanaEngine.

Nested Class Summary
- Nested classes/interfaces inherited from interface pro.taskana.TaskanaEngine
  TaskanaEngine.ConnectionManagementMode

Field Summary

Fields
Modifier and Type	Field and Description
`protected Connection`	`connection`
`protected HistoryEventProducer`	`historyEventProducer`
`protected TaskanaEngine.ConnectionManagementMode`	`mode`
`protected org.apache.ibatis.session.SqlSessionManager`	`sessionManager`
`protected static ThreadLocal<Deque<org.apache.ibatis.session.SqlSessionManager>>`	`sessionStack`
`protected TaskanaEngineConfiguration`	`taskanaEngineConfiguration`
`protected org.apache.ibatis.transaction.TransactionFactory`	`transactionFactory`

Constructor Summary

Constructors
Modifier Constructor and Description

protected TaskanaEngineImpl(TaskanaEngineConfiguration taskanaEngineConfiguration)

Constructors
Modifier	Constructor and Description
`protected`	`TaskanaEngineImpl(TaskanaEngineConfiguration taskanaEngineConfiguration)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`checkRoleMembership(TaskanaRole... roles)` Checks whether current user is member of any of the specified roles.
`void`	`closeConnection()` closes the connection to the database in mode EXPLICIT.
`protected org.apache.ibatis.session.SqlSessionManager`	`createSqlSessionManager()` This method creates the sqlSessionManager of myBatis.
`static TaskanaEngine`	`createTaskanaEngine(TaskanaEngineConfiguration taskanaEngineConfiguration)`
`boolean`	`domainExists(String domain)` Returns true if the given domain does exist in the configuration.
`ClassificationService`	`getClassificationService()` The ClassificationService can be used for operations on all Categories.
`TaskanaEngineConfiguration`	`getConfiguration()` The Taskana configuration.
`HistoryEventProducer`	`getHistoryEventProducer()`
`JobService`	`getJobService()` The JobService can be user for all job operations.
`protected static org.apache.ibatis.session.SqlSessionManager`	`getSessionFromStack()`
`protected static Deque<org.apache.ibatis.session.SqlSessionManager>`	`getSessionStack()` With sessionStack, we maintain a Stack of SqlSessionManager objects on a per thread basis.
`TaskMonitorService`	`getTaskMonitorService()` The TaskMonitorService can be used for monitoring Tasks.
`TaskService`	`getTaskService()` The TaskService can be used for operations on all Tasks.
`WorkbasketService`	`getWorkbasketService()` The WorkbasketService can be used for operations on all Workbaskets.
`static boolean`	`isDb2(String dbProductName)`
`static boolean`	`isH2(String databaseProductName)`
`static boolean`	`isPostgreSQL(String databaseProductName)`
`boolean`	`isUserInRole(TaskanaRole... roles)` check whether the current user is member of one of the roles specified.
`protected static void`	`popSessionFromStack()`
`protected static void`	`pushSessionToStack(org.apache.ibatis.session.SqlSessionManager session)`
`void`	`setConnection(Connection connection)` Set the database connection to be used by taskana.
`void`	`setConnectionManagementMode(TaskanaEngine.ConnectionManagementMode mode)` sets the connection management mode.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - sessionStack
```
protected static ThreadLocal<Deque<org.apache.ibatis.session.SqlSessionManager>> sessionStack
```
  - taskanaEngineConfiguration
```
protected TaskanaEngineConfiguration taskanaEngineConfiguration
```
  - transactionFactory
```
protected org.apache.ibatis.transaction.TransactionFactory transactionFactory
```
  - sessionManager
```
protected org.apache.ibatis.session.SqlSessionManager sessionManager
```
  - mode
```
protected TaskanaEngine.ConnectionManagementMode mode
```
  - connection
```
protected Connection connection
```
  - historyEventProducer
```
protected HistoryEventProducer historyEventProducer
```
- Constructor Detail
  - TaskanaEngineImpl
```
protected TaskanaEngineImpl(TaskanaEngineConfiguration taskanaEngineConfiguration)
```
- Method Detail
  - createTaskanaEngine
```
public static TaskanaEngine createTaskanaEngine(TaskanaEngineConfiguration taskanaEngineConfiguration)
```
  - getSessionStack
```
protected static Deque<org.apache.ibatis.session.SqlSessionManager> getSessionStack()
```
    With sessionStack, we maintain a Stack of SqlSessionManager objects on a per thread basis. SqlSessionManager is the MyBatis object that wraps database connections. The purpose of this stack is to keep track of nested calls. Each external API call is wrapped into taskanaEngineImpl.openConnection(); ..... taskanaEngineImpl.returnConnection(); calls. In order to avoid duplicate opening / closing of connections, we use the sessionStack in the following way: Each time, an openConnection call is received, we push the current sessionManager onto the stack. On the first call to openConnection, we call sessionManager.startManagedSession() to open a database connection. On each call to returnConnection() we pop one instance of sessionManager from the stack. When the stack becomes empty, we close the database connection by calling sessionManager.close()
    
    Returns:
    
    Stack of SqlSessionManager
  - getSessionFromStack
```
protected static org.apache.ibatis.session.SqlSessionManager getSessionFromStack()
```
  - pushSessionToStack
```
protected static void pushSessionToStack(org.apache.ibatis.session.SqlSessionManager session)
```
  - popSessionFromStack
```
protected static void popSessionFromStack()
```
  - isDb2
```
public static boolean isDb2(String dbProductName)
```
  - isH2
```
public static boolean isH2(String databaseProductName)
```
  - isPostgreSQL
```
public static boolean isPostgreSQL(String databaseProductName)
```
  - getTaskService
```
public TaskService getTaskService()
```
    Description copied from interface: TaskanaEngine
    
    The TaskService can be used for operations on all Tasks.
    
    Specified by:
    
    getTaskService in interface TaskanaEngine
    
    Returns:
    
    the TaskService
  - getTaskMonitorService
```
public TaskMonitorService getTaskMonitorService()
```
    Description copied from interface: TaskanaEngine
    
    The TaskMonitorService can be used for monitoring Tasks.
    
    Specified by:
    
    getTaskMonitorService in interface TaskanaEngine
    
    Returns:
    
    the TaskMonitorService
  - getWorkbasketService
```
public WorkbasketService getWorkbasketService()
```
    Description copied from interface: TaskanaEngine
    
    The WorkbasketService can be used for operations on all Workbaskets.
    
    Specified by:
    
    getWorkbasketService in interface TaskanaEngine
    
    Returns:
    
    the TaskService
  - getClassificationService
```
public ClassificationService getClassificationService()
```
    Description copied from interface: TaskanaEngine
    
    The ClassificationService can be used for operations on all Categories.
    
    Specified by:
    
    getClassificationService in interface TaskanaEngine
    
    Returns:
    
    the TaskService
  - getJobService
```
public JobService getJobService()
```
    Description copied from interface: TaskanaEngine
    
    The JobService can be user for all job operations.
    
    Specified by:
    
    getJobService in interface TaskanaEngine
    
    Returns:
    
    the JobService
  - getConfiguration
```
public TaskanaEngineConfiguration getConfiguration()
```
    Description copied from interface: TaskanaEngine
    
    The Taskana configuration.
    
    Specified by:
    
    getConfiguration in interface TaskanaEngine
    
    Returns:
    
    the TaskanaConfiguration
  - getHistoryEventProducer
```
public HistoryEventProducer getHistoryEventProducer()
```
  - setConnectionManagementMode
```
public void setConnectionManagementMode(TaskanaEngine.ConnectionManagementMode mode)
```
    sets the connection management mode.
    Specified by:
    
    setConnectionManagementMode in interface TaskanaEngine
    
    Parameters:
    mode - - the connection management mode Valid values are:
    
    PARTICIPATE - taskana participates in global transaction. This is the default mode.
    
    AUTOCOMMIT - taskana commits each API call separately
    
    EXPLICIT - commit processing is managed explicitly by the client
  - setConnection
```
public void setConnection(Connection connection)
                   throws SQLException
```
    Set the database connection to be used by taskana. If this Api is called, taskana uses the connection passed by the client for database access in all subsequent API calls until the client resets this connection. Control over commit and rollback is the responsibility of the client. In order to close the connection, the client can call TaskanaEngine.closeConnection() or TaskanaEngine.setConnection(null). Both calls have the same effect.
    
    Specified by:
    
    setConnection in interface TaskanaEngine
    
    Parameters:
    
    connection - The connection that passed into TaskanaEngine
    
    Throws:
    
    SQLException - if a database access error occurs
  - closeConnection
```
public void closeConnection()
```
    closes the connection to the database in mode EXPLICIT. In mode EXPLICIT, closes the client's connection, sets it to null and switches to mode PARTICIPATE Has the same effect as setConnection(null)
    
    Specified by:
    
    closeConnection in interface TaskanaEngine
  - checkRoleMembership
```
public void checkRoleMembership(TaskanaRole... roles)
                         throws NotAuthorizedException
```
    Checks whether current user is member of any of the specified roles.
    
    Specified by:
    
    checkRoleMembership in interface TaskanaEngine
    
    Parameters:
    
    roles - The roles that are checked for membership of the current user
    
    Throws:
    
    NotAuthorizedException - If the current user is not member of any specified role
  - isUserInRole
```
public boolean isUserInRole(TaskanaRole... roles)
```
    check whether the current user is member of one of the roles specified.
    
    Specified by:
    
    isUserInRole in interface TaskanaEngine
    
    Parameters:
    
    roles - The roles that are checked for membership of the current user
    
    Returns:
    
    true if the current user is a member of at least one of the specified groups
  - createSqlSessionManager
```
protected org.apache.ibatis.session.SqlSessionManager createSqlSessionManager()
```
    This method creates the sqlSessionManager of myBatis. It integrates all the SQL mappers and sets the databaseId attribute.
    
    Returns:
    
    a SqlSessionFactory
  - domainExists
```
public boolean domainExists(String domain)
```
    Returns true if the given domain does exist in the configuration.
    
    Parameters:
    
    domain - the domain specified in the configuration
    
    Returns:
    
    true if the domain exists

Class TaskanaEngineImpl

Nested Class Summary

Nested classes/interfaces inherited from interface pro.taskana.TaskanaEngine

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

sessionStack

taskanaEngineConfiguration

transactionFactory

sessionManager

mode

connection

historyEventProducer

Constructor Detail

TaskanaEngineImpl

Method Detail

createTaskanaEngine

getSessionStack

getSessionFromStack

pushSessionToStack

popSessionFromStack

isDb2

isH2

isPostgreSQL

getTaskService

getTaskMonitorService

getWorkbasketService

getClassificationService

getJobService

getConfiguration

getHistoryEventProducer

setConnectionManagementMode

setConnection

closeConnection

checkRoleMembership

isUserInRole

createSqlSessionManager

domainExists