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

TSK-1335: Add workbasket history events

This commit is contained in:
Joerg Heffner 2020-07-15 15:16:18 +02:00 committed by gitgoodjhe
parent ef82e4f3ef
commit 29ba5fe418
100 changed files with 5279 additions and 1668 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/TaskanaHistoryEngine.java
View File

@ -1,5 +1,7 @@
package pro.taskana.simplehistory;
import pro.taskana.common.api.TaskanaRole;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.spi.history.api.TaskanaHistory;
/** The TaskanaHistoryEngine represents an overall set of all needed services. */
@ -10,4 +12,20 @@ public interface TaskanaHistoryEngine {
* @return the HistoryService
*/
TaskanaHistory getTaskanaHistoryService();
/**
* check whether the current user is member of one of the roles specified.
*
* @param roles The roles that are checked for membership of the current user
* @return true if the current user is a member of at least one of the specified groups
*/
boolean isUserInRole(TaskanaRole... roles);
/**
* Checks whether current user is member of any of the specified roles.
*
* @param 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
*/
void checkRoleMembership(TaskanaRole... roles) throws NotAuthorizedException;
}

13
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/HistoryEventImpl.java
View File

@ -1,13 +0,0 @@
package pro.taskana.simplehistory.impl;
import pro.taskana.spi.history.api.events.TaskanaHistoryEvent;
/** This entity contains the most important information about a history event. */
public class HistoryEventImpl extends TaskanaHistoryEvent {
public HistoryEventImpl() {}
public HistoryEventImpl(String id, String userId, String details) {
super(id, userId, details);
}
}

570
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/HistoryQueryImpl.java
View File

@ -1,570 +0,0 @@
package pro.taskana.simplehistory.impl;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.common.api.exceptions.SystemException;
import pro.taskana.simplehistory.impl.mappings.HistoryQueryMapper;
import pro.taskana.simplehistory.query.HistoryQuery;
import pro.taskana.simplehistory.query.HistoryQueryColumnName;
import pro.taskana.spi.history.api.events.TaskHistoryCustomField;
/** Implementation for generating dynamic sql. */
public class HistoryQueryImpl implements HistoryQuery {
private static final Logger LOGGER = LoggerFactory.getLogger(HistoryQueryImpl.class);
private final TaskanaHistoryEngineImpl taskanaHistoryEngine;
private final HistoryQueryMapper historyQueryMapper;
private final List<String> orderBy;
private final List<String> orderColumns;
private int
maxRows; // limit for rows. used to make list(offset, limit) and single() more efficient.
private HistoryQueryColumnName columnName;
private String[] idIn;
private String[] businessProcessIdIn;
private String[] parentBusinessProcessIdIn;
private String[] taskIdIn;
private String[] eventTypeIn;
private TimeInterval[] createdIn;
private String[] userIdIn;
private String[] domainIn;
private String[] workbasketKeyIn;
private String[] porCompanyIn;
private String[] porSystemIn;
private String[] porInstanceIn;
private String[] porTypeIn;
private String[] porValueIn;
private String[] taskClassificationKeyIn;
private String[] taskClassificationCategoryIn;
private String[] attachmentClassificationKeyIn;
private String[] oldValueIn;
private String[] newValueIn;
private String[] custom1In;
private String[] custom2In;
private String[] custom3In;
private String[] custom4In;
private String[] businessProcessIdLike;
private String[] parentBusinessProcessIdLike;
private String[] taskIdLike;
private String[] eventTypeLike;
private String[] userIdLike;
private String[] domainLike;
private String[] workbasketKeyLike;
private String[] porCompanyLike;
private String[] porSystemLike;
private String[] porInstanceLike;
private String[] porTypeLike;
private String[] porValueLike;
private String[] taskClassificationKeyLike;
private String[] taskClassificationCategoryLike;
private String[] attachmentClassificationKeyLike;
private String[] oldValueLike;
private String[] newValueLike;
private String[] custom1Like;
private String[] custom2Like;
private String[] custom3Like;
private String[] custom4Like;
public HistoryQueryImpl(
TaskanaHistoryEngineImpl taskanaHistoryEngineImpl, HistoryQueryMapper historyQueryMapper) {
this.taskanaHistoryEngine = taskanaHistoryEngineImpl;
this.historyQueryMapper = historyQueryMapper;
this.orderBy = new ArrayList<>();
this.orderColumns = new ArrayList<>();
this.maxRows = -1;
}
@Override
public HistoryQuery idIn(String... idIn) {
this.idIn = toUpperCopy(idIn);
return this;
}
@Override
public HistoryQuery businessProcessIdIn(String... businessProcessId) {
this.businessProcessIdIn = toUpperCopy(businessProcessId);
return this;
}
@Override
public HistoryQuery parentBusinessProcessIdIn(String... parentBusinessProcessId) {
this.parentBusinessProcessIdIn = toUpperCopy(parentBusinessProcessId);
return this;
}
@Override
public HistoryQuery taskIdIn(String... taskId) {
this.taskIdIn = toUpperCopy(taskId);
return this;
}
@Override
public HistoryQuery eventTypeIn(String... eventType) {
this.eventTypeIn = toUpperCopy(eventType);
return this;
}
@Override
public HistoryQuery createdWithin(TimeInterval... createdIn) {
this.createdIn = createdIn;
return this;
}
@Override
public HistoryQuery userIdIn(String... userId) {
this.userIdIn = toUpperCopy(userId);
return this;
}
@Override
public HistoryQuery domainIn(String... domain) {
this.domainIn = toUpperCopy(domain);
return this;
}
@Override
public HistoryQuery workbasketKeyIn(String... workbasketKey) {
this.workbasketKeyIn = toUpperCopy(workbasketKey);
return this;
}
@Override
public HistoryQuery porCompanyIn(String... porCompany) {
this.porCompanyIn = toUpperCopy(porCompany);
return this;
}
@Override
public HistoryQuery porSystemIn(String... porSystem) {
this.porSystemIn = toUpperCopy(porSystem);
return this;
}
@Override
public HistoryQuery porInstanceIn(String... porInstance) {
this.porInstanceIn = toUpperCopy(porInstance);
return this;
}
@Override
public HistoryQuery porTypeIn(String... porType) {
this.porTypeIn = toUpperCopy(porType);
return this;
}
@Override
public HistoryQuery porValueIn(String... porValue) {
this.porValueIn = toUpperCopy(porValue);
return this;
}
@Override
public HistoryQuery taskClassificationKeyIn(String... taskClassificationKey) {
this.taskClassificationKeyIn = toUpperCopy(taskClassificationKey);
return this;
}
@Override
public HistoryQuery taskClassificationCategoryIn(String... taskClassificationCategory) {
this.taskClassificationCategoryIn = toUpperCopy(taskClassificationCategory);
return this;
}
@Override
public HistoryQuery attachmentClassificationKeyIn(String... attachmentClassificationKey) {
this.attachmentClassificationKeyIn = toUpperCopy(attachmentClassificationKey);
return this;
}
@Override
public HistoryQuery oldValueIn(String... oldValueIn) {
this.oldValueIn = toUpperCopy(oldValueIn);
return this;
}
@Override
public HistoryQuery newValueIn(String... newValueIn) {
this.newValueIn = toUpperCopy(newValueIn);
return this;
}
@Override
public HistoryQuery businessProcessIdLike(String... businessProcessId) {
this.businessProcessIdLike = toUpperCopy(businessProcessId);
return this;
}
@Override
public HistoryQuery parentBusinessProcessIdLike(String... parentBusinessProcessId) {
this.parentBusinessProcessIdLike = toUpperCopy(parentBusinessProcessId);
return this;
}
@Override
public HistoryQuery taskIdLike(String... taskId) {
this.taskIdLike = toUpperCopy(taskId);
return this;
}
@Override
public HistoryQuery eventTypeLike(String... eventType) {
this.eventTypeLike = toUpperCopy(eventType);
return this;
}
@Override
public HistoryQuery userIdLike(String... userId) {
this.userIdLike = toUpperCopy(userId);
return this;
}
@Override
public HistoryQuery domainLike(String... domain) {
this.domainLike = toUpperCopy(domain);
return this;
}
@Override
public HistoryQuery workbasketKeyLike(String... workbasketKey) {
this.workbasketKeyLike = toUpperCopy(workbasketKey);
return this;
}
@Override
public HistoryQuery porCompanyLike(String... porCompany) {
this.porCompanyLike = toUpperCopy(porCompany);
return this;
}
@Override
public HistoryQuery porSystemLike(String... porSystem) {
this.porSystemLike = toUpperCopy(porSystem);
return this;
}
@Override
public HistoryQuery porInstanceLike(String... porInstance) {
this.porInstanceLike = toUpperCopy(porInstance);
return this;
}
@Override
public HistoryQuery porTypeLike(String... porType) {
this.porTypeLike = toUpperCopy(porType);
return this;
}
@Override
public HistoryQuery porValueLike(String... porValue) {
this.porValueLike = toUpperCopy(porValue);
return this;
}
@Override
public HistoryQuery taskClassificationKeyLike(String... taskClassificationKey) {
this.taskClassificationKeyLike = toUpperCopy(taskClassificationKey);
return this;
}
@Override
public HistoryQuery taskClassificationCategoryLike(String... taskClassificationCategory) {
this.taskClassificationCategoryLike = toUpperCopy(taskClassificationCategory);
return this;
}
@Override
public HistoryQuery attachmentClassificationKeyLike(String... attachmentClassificationKey) {
this.attachmentClassificationKeyLike = toUpperCopy(attachmentClassificationKey);
return this;
}
@Override
public HistoryQuery oldValueLike(String... oldValue) {
this.oldValueLike = toUpperCopy(oldValue);
return this;
}
@Override
public HistoryQuery newValueLike(String... newValue) {
this.newValueLike = toUpperCopy(newValue);
return this;
}
@Override
public HistoryQuery customAttributeIn(
TaskHistoryCustomField customField, String... searchArguments) {
switch (customField) {
case CUSTOM_1:
custom1In = toUpperCopy(searchArguments);
break;
case CUSTOM_2:
custom2In = toUpperCopy(searchArguments);
break;
case CUSTOM_3:
custom3In = toUpperCopy(searchArguments);
break;
case CUSTOM_4:
custom4In = toUpperCopy(searchArguments);
break;
default:
throw new SystemException("Unknown customField '" + customField + "'");
}
return this;
}
@Override
public HistoryQuery customAttributeLike(
TaskHistoryCustomField customField, String... searchArguments) {
switch (customField) {
case CUSTOM_1:
custom1Like = toUpperCopy(searchArguments);
break;
case CUSTOM_2:
custom2Like = toUpperCopy(searchArguments);
break;
case CUSTOM_3:
custom3Like = toUpperCopy(searchArguments);
break;
case CUSTOM_4:
custom4Like = toUpperCopy(searchArguments);
break;
default:
throw new SystemException("Unknown customField '" + customField + "'");
}
return this;
}
@Override
public HistoryQuery orderByBusinessProcessId(SortDirection sortDirection) {
return addOrderCriteria("BUSINESS_PROCESS_ID", sortDirection);
}
@Override
public HistoryQuery orderByParentBusinessProcessId(SortDirection sortDirection) {
return addOrderCriteria("PARENT_BUSINESS_PROCESS_ID", sortDirection);
}
@Override
public HistoryQuery orderByTaskId(SortDirection sortDirection) {
return addOrderCriteria("TASK_ID", sortDirection);
}
@Override
public HistoryQuery orderByEventType(SortDirection sortDirection) {
return addOrderCriteria("EVENT_TYPE", sortDirection);
}
@Override
public HistoryQuery orderByCreated(SortDirection sortDirection) {
return addOrderCriteria("CREATED", sortDirection);
}
@Override
public HistoryQuery orderByUserId(SortDirection sortDirection) {
return addOrderCriteria("USER_ID", sortDirection);
}
@Override
public HistoryQuery orderByDomain(SortDirection sortDirection) {
return addOrderCriteria("DOMAIN", sortDirection);
}
@Override
public HistoryQuery orderByWorkbasketKey(SortDirection sortDirection) {
return addOrderCriteria("WORKBASKET_KEY", sortDirection);
}
@Override
public HistoryQuery orderByPorCompany(SortDirection sortDirection) {
return addOrderCriteria("POR_COMPANY", sortDirection);
}
@Override
public HistoryQuery orderByPorSystem(SortDirection sortDirection) {
return addOrderCriteria("POR_SYSTEM", sortDirection);
}
@Override
public HistoryQuery orderByPorInstance(SortDirection sortDirection) {
return addOrderCriteria("POR_INSTANCE", sortDirection);
}
@Override
public HistoryQuery orderByPorType(SortDirection sortDirection) {
return addOrderCriteria("POR_TYPE", sortDirection);
}
@Override
public HistoryQuery orderByPorValue(SortDirection sortDirection) {
return addOrderCriteria("POR_VALUE", sortDirection);
}
@Override
public HistoryQuery orderByTaskClassificationKey(SortDirection sortDirection) {
return addOrderCriteria("TASK_CLASSIFICATION_KEY", sortDirection);
}
@Override
public HistoryQuery orderByTaskClassificationCategory(SortDirection sortDirection) {
return addOrderCriteria("TASK_CLASSIFICATION_CATEGORY", sortDirection);
}
@Override
public HistoryQuery orderByAttachmentClassificationKey(SortDirection sortDirection) {
return addOrderCriteria("ATTACHMENT_CLASSIFICATION_KEY", sortDirection);
}
@Override
public HistoryQuery orderByOldValue(SortDirection sortDirection) {
return addOrderCriteria("OLD_VALUE", sortDirection);
}
@Override
public HistoryQuery orderByNewValue(SortDirection sortDirection) {
return addOrderCriteria("NEW_VALUE", sortDirection);
}
@Override
public HistoryQuery orderByCustomAttribute(
TaskHistoryCustomField customField, SortDirection sortDirection) {
return addOrderCriteria(customField.name(), sortDirection);
}
@Override
public List<HistoryEventImpl> list() {
LOGGER.debug("entry to list(), this = {}", this);
List<HistoryEventImpl> result = new ArrayList<>();
try {
taskanaHistoryEngine.openConnection();
result = historyQueryMapper.queryHistoryEvent(this);
LOGGER.debug("transaction was successful. Result: {}", result.toString());
return result;
} catch (SQLException e) {
LOGGER.error(
"Method openConnection() could not open a connection to the database.", e.getCause());
return result;
} catch (NullPointerException npe) {
LOGGER.error("No History Event found.");
return result;
} finally {
taskanaHistoryEngine.returnConnection();
}
}
@Override
public List<HistoryEventImpl> list(int offset, int limit) {
LOGGER.debug("entry to list({},{}), this = {}", offset, limit, this);
List<HistoryEventImpl> result = new ArrayList<>();
try {
taskanaHistoryEngine.openConnection();
this.maxRows = offset + limit;
result = historyQueryMapper.queryHistoryEvent(this);
LOGGER.debug("transaction was successful. Result: {}", result.toString());
limit = Math.min(result.size() - offset, limit);
if (result.size() > offset) {
return result.subList(offset, offset + limit);
} else {
return new ArrayList<>();
}
} catch (SQLException e) {
LOGGER.error(
"Method openConnection() could not open a connection to the database.", e.getCause());
return result;
} catch (NullPointerException npe) {
LOGGER.error("No History Event found.");
return result;
} finally {
taskanaHistoryEngine.returnConnection();
this.maxRows = -1;
}
}
@Override
public List<String> listValues(HistoryQueryColumnName dbColumnName, SortDirection sortDirection) {
LOGGER.debug(
"entry to listValues() of column {} with sortDirection {}, this {}",
dbColumnName,
sortDirection,
this);
List<String> result = new ArrayList<>();
this.columnName = dbColumnName;
this.orderBy.clear();
this.addOrderCriteria(columnName.toString(), sortDirection);
try {
taskanaHistoryEngine.openConnection();
result = historyQueryMapper.queryHistoryColumnValues(this);
LOGGER.debug("transaction was successful. Result: {}", result.toString());
return result;
} catch (SQLException e) {
LOGGER.error(
"Method openConnection() could not open a connection to the database.", e.getCause());
return result;
} catch (NullPointerException npe) {
LOGGER.error("No History Event found.");
return result;
} finally {
this.orderColumns.remove(orderColumns.size() - 1);
taskanaHistoryEngine.returnConnection();
}
}
@Override
public HistoryEventImpl single() {
LOGGER.debug("entry to list(), this = {}", this);
HistoryEventImpl result = null;
try {
taskanaHistoryEngine.openConnection();
this.maxRows = 1;
result = historyQueryMapper.queryHistoryEvent(this).get(0);
LOGGER.debug("transaction was successful. Result: {}", result.toString());
return result;
} catch (SQLException e) {
LOGGER.error(
"Method openConnection() could not open a connection to the database.", e.getCause());
return result;
} catch (NullPointerException npe) {
LOGGER.error("No History Event found.");
return result;
} finally {
taskanaHistoryEngine.returnConnection();
this.maxRows = -1;
}
}
@Override
public long count() {
LOGGER.debug("entry to count(), this = {}", this);
try {
taskanaHistoryEngine.openConnection();
long result = historyQueryMapper.countHistoryEvent(this);
LOGGER.debug("transaction was successful. Result: {}", result);
return result;
} catch (SQLException e) {
LOGGER.error(
"Method openConnection() could not open a connection to the database.", e.getCause());
return -1;
} catch (NullPointerException npe) {
LOGGER.error("No History Event found.");
return -1;
} finally {
taskanaHistoryEngine.returnConnection();
}
}
private HistoryQueryImpl addOrderCriteria(String columnName, SortDirection sortDirection) {
String orderByDirection =
" " + (sortDirection == null ? SortDirection.ASCENDING : sortDirection);
orderBy.add(columnName + orderByDirection);
orderColumns.add(columnName);
return this;
}
}

66
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/SimpleHistoryServiceImpl.java
View File

@ -11,11 +11,13 @@ import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.TaskanaRole;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.simplehistory.impl.mappings.HistoryEventMapper;
import pro.taskana.simplehistory.impl.mappings.HistoryQueryMapper;
import pro.taskana.simplehistory.query.HistoryQuery;
import pro.taskana.simplehistory.impl.task.TaskHistoryEventMapper;
import pro.taskana.simplehistory.impl.task.TaskHistoryQuery;
import pro.taskana.simplehistory.impl.workbasket.WorkbasketHistoryEventMapper;
import pro.taskana.simplehistory.impl.workbasket.WorkbasketHistoryQuery;
import pro.taskana.spi.history.api.TaskanaHistory;
import pro.taskana.spi.history.api.events.TaskanaHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
import pro.taskana.spi.history.api.exceptions.TaskanaHistoryEventNotFoundException;
/** This is the implementation of TaskanaHistory. */
@ -23,35 +25,53 @@ public class SimpleHistoryServiceImpl implements TaskanaHistory {
private static final Logger LOGGER = LoggerFactory.getLogger(SimpleHistoryServiceImpl.class);
private TaskanaHistoryEngineImpl taskanaHistoryEngine;
private HistoryEventMapper historyEventMapper;
private HistoryQueryMapper historyQueryMapper;
private TaskHistoryEventMapper taskHistoryEventMapper;
private WorkbasketHistoryEventMapper workbasketHistoryEventMapper;
public void initialize(TaskanaEngine taskanaEngine) {
this.taskanaHistoryEngine = getTaskanaEngine(taskanaEngine.getConfiguration());
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(
"Simple history service implementation initialized with schemaName: {} ",
taskanaEngine.getConfiguration().getSchemaName());
}
this.historyEventMapper =
this.taskanaHistoryEngine.getSqlSession().getMapper(HistoryEventMapper.class);
this.historyQueryMapper =
this.taskanaHistoryEngine.getSqlSession().getMapper(HistoryQueryMapper.class);
this.taskHistoryEventMapper =
this.taskanaHistoryEngine.getSqlSession().getMapper(TaskHistoryEventMapper.class);
this.workbasketHistoryEventMapper =
this.taskanaHistoryEngine.getSqlSession().getMapper(WorkbasketHistoryEventMapper.class);
}
@Override
public void create(TaskanaHistoryEvent event) {
public void create(TaskHistoryEvent event) {
try {
taskanaHistoryEngine.openConnection();
if (event.getCreated() == null) {
Instant now = Instant.now();
event.setCreated(now);
}
historyEventMapper.insert(event);
taskHistoryEventMapper.insert(event);
} catch (SQLException e) {
LOGGER.error("Error while inserting history event into historyEventMapper", e);
LOGGER.error("Error while inserting task history event into database", e);
} finally {
taskanaHistoryEngine.returnConnection();
LOGGER.debug("Exit from create(TaskanaHistoryEvent event). Returning object = {}.", event);
}
}
@Override
public void create(WorkbasketHistoryEvent event) {
try {
taskanaHistoryEngine.openConnection();
if (event.getCreated() == null) {
Instant now = Instant.now();
event.setCreated(now);
}
workbasketHistoryEventMapper.insert(event);
} catch (SQLException e) {
LOGGER.error("Error while inserting workbasket history event into database", e);
} finally {
taskanaHistoryEngine.returnConnection();
LOGGER.debug("Exit from create(TaskanaHistoryEvent event). Returning object = {}.", event);
@ -75,7 +95,7 @@ public class SimpleHistoryServiceImpl implements TaskanaHistory {
try {
taskanaHistoryEngine.openConnection();
historyEventMapper.deleteMultipleByTaskIds(taskIds);
taskHistoryEventMapper.deleteMultipleByTaskIds(taskIds);
} catch (SQLException e) {
LOGGER.error("Caught exception while trying to delete history events", e);
@ -85,18 +105,18 @@ public class SimpleHistoryServiceImpl implements TaskanaHistory {
}
}
public TaskanaHistoryEvent getHistoryEvent(String historyEventId)
public TaskHistoryEvent getTaskHistoryEvent(String historyEventId)
throws TaskanaHistoryEventNotFoundException {
LOGGER.debug("entry to getHistoryEvent (id = {})", historyEventId);
TaskanaHistoryEvent resultEvent = null;
LOGGER.debug("entry to getTaskHistoryEvent (id = {})", historyEventId);
TaskHistoryEvent resultEvent = null;
try {
taskanaHistoryEngine.openConnection();
resultEvent = historyEventMapper.findById(historyEventId);
resultEvent = taskHistoryEventMapper.findById(historyEventId);
if (resultEvent == null) {
throw new TaskanaHistoryEventNotFoundException(
historyEventId,
String.format("TaskanaHistoryEvent for id %s was not found", historyEventId));
String.format("TaskHistoryEvent for id %s was not found", historyEventId));
}
return resultEvent;
@ -110,8 +130,12 @@ public class SimpleHistoryServiceImpl implements TaskanaHistory {
}
}
public HistoryQuery createHistoryQuery() {
return new HistoryQueryImpl(taskanaHistoryEngine, historyQueryMapper);
public TaskHistoryQuery createTaskHistoryQuery() {
return new TaskHistoryQueryImpl(taskanaHistoryEngine);
}
public WorkbasketHistoryQuery createWorkbasketHistoryQuery() {
return new WorkbasketHistoryQueryImpl(taskanaHistoryEngine);
}
/*

741
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/TaskHistoryQueryImpl.java Normal file
View File

@ -0,0 +1,741 @@
package pro.taskana.simplehistory.impl;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.apache.ibatis.session.RowBounds;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.common.api.exceptions.SystemException;
import pro.taskana.simplehistory.impl.task.TaskHistoryQuery;
import pro.taskana.simplehistory.impl.task.TaskHistoryQueryColumnName;
import pro.taskana.spi.history.api.events.TaskHistoryCustomField;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
/** Implementation for generating dynamic sql. */
public class TaskHistoryQueryImpl implements TaskHistoryQuery {
private static final String LINK_TO_MAPPER =
"pro.taskana.simplehistory.impl.task.TaskHistoryQueryMapper.queryHistoryEvents";
private static final String LINK_TO_VALUE_MAPPER =
"pro.taskana.simplehistory.impl.task.TaskHistoryQueryMapper.queryHistoryColumnValues";
private static final String LINK_TO_COUNTER =
"pro.taskana.simplehistory.impl.task.TaskHistoryQueryMapper.countHistoryEvents";
private static final Logger LOGGER = LoggerFactory.getLogger(TaskHistoryQueryImpl.class);
private static final String SQL_EXCEPTION_MESSAGE =
"Method openConnection() could not open a connection to the database.";
private final TaskanaHistoryEngineImpl taskanaHistoryEngine;
private final List<String> orderBy;
private final List<String> orderColumns;
private TaskHistoryQueryColumnName columnName;
private String[] idIn;
private String[] businessProcessIdIn;
private String[] parentBusinessProcessIdIn;
private String[] taskIdIn;
private String[] eventTypeIn;
private TimeInterval[] createdIn;
private String[] userIdIn;
private String[] domainIn;
private String[] workbasketKeyIn;
private String[] porCompanyIn;
private String[] porSystemIn;
private String[] porInstanceIn;
private String[] porTypeIn;
private String[] porValueIn;
private String[] taskClassificationKeyIn;
private String[] taskClassificationCategoryIn;
private String[] attachmentClassificationKeyIn;
private String[] oldValueIn;
private String[] newValueIn;
private String[] custom1In;
private String[] custom2In;
private String[] custom3In;
private String[] custom4In;
private String[] businessProcessIdLike;
private String[] parentBusinessProcessIdLike;
private String[] taskIdLike;
private String[] eventTypeLike;
private String[] userIdLike;
private String[] domainLike;
private String[] workbasketKeyLike;
private String[] porCompanyLike;
private String[] porSystemLike;
private String[] porInstanceLike;
private String[] porTypeLike;
private String[] porValueLike;
private String[] taskClassificationKeyLike;
private String[] taskClassificationCategoryLike;
private String[] attachmentClassificationKeyLike;
private String[] oldValueLike;
private String[] newValueLike;
private String[] custom1Like;
private String[] custom2Like;
private String[] custom3Like;
private String[] custom4Like;
public TaskHistoryQueryImpl(TaskanaHistoryEngineImpl taskanaHistoryEngine) {
this.taskanaHistoryEngine = taskanaHistoryEngine;
this.orderBy = new ArrayList<>();
this.orderColumns = new ArrayList<>();
}
public String[] getIdIn() {
return idIn;
}
public String[] getBusinessProcessIdIn() {
return businessProcessIdIn;
}
public String[] getParentBusinessProcessIdIn() {
return parentBusinessProcessIdIn;
}
public String[] getTaskIdIn() {
return taskIdIn;
}
public String[] getEventTypeIn() {
return eventTypeIn;
}
public TimeInterval[] getCreatedIn() {
return createdIn;
}
public String[] getUserIdIn() {
return userIdIn;
}
public String[] getDomainIn() {
return domainIn;
}
public String[] getWorkbasketKeyIn() {
return workbasketKeyIn;
}
public String[] getPorCompanyIn() {
return porCompanyIn;
}
public String[] getPorSystemIn() {
return porSystemIn;
}
public String[] getPorInstanceIn() {
return porInstanceIn;
}
public String[] getPorTypeIn() {
return porTypeIn;
}
public String[] getPorValueIn() {
return porValueIn;
}
public String[] getTaskClassificationKeyIn() {
return taskClassificationKeyIn;
}
public String[] getTaskClassificationCategoryIn() {
return taskClassificationCategoryIn;
}
public String[] getAttachmentClassificationKeyIn() {
return attachmentClassificationKeyIn;
}
public String[] getOldValueIn() {
return oldValueIn;
}
public String[] getNewValueIn() {
return newValueIn;
}
public String[] getCustom1In() {
return custom1In;
}
public String[] getCustom2In() {
return custom2In;
}
public String[] getCustom3In() {
return custom3In;
}
public String[] getCustom4In() {
return custom4In;
}
public String[] getBusinessProcessIdLike() {
return businessProcessIdLike;
}
public String[] getParentBusinessProcessIdLike() {
return parentBusinessProcessIdLike;
}
public String[] getTaskIdLike() {
return taskIdLike;
}
public String[] getEventTypeLike() {
return eventTypeLike;
}
public String[] getUserIdLike() {
return userIdLike;
}
public String[] getDomainLike() {
return domainLike;
}
public String[] getWorkbasketKeyLike() {
return workbasketKeyLike;
}
public String[] getPorCompanyLike() {
return porCompanyLike;
}
public String[] getPorSystemLike() {
return porSystemLike;
}
public String[] getPorInstanceLike() {
return porInstanceLike;
}
public String[] getPorTypeLike() {
return porTypeLike;
}
public String[] getPorValueLike() {
return porValueLike;
}
public String[] getTaskClassificationKeyLike() {
return taskClassificationKeyLike;
}
public String[] getTaskClassificationCategoryLike() {
return taskClassificationCategoryLike;
}
public String[] getAttachmentClassificationKeyLike() {
return attachmentClassificationKeyLike;
}
public String[] getOldValueLike() {
return oldValueLike;
}
public String[] getNewValueLike() {
return newValueLike;
}
public String[] getCustom1Like() {
return custom1Like;
}
public String[] getCustom2Like() {
return custom2Like;
}
public String[] getCustom3Like() {
return custom3Like;
}
public String[] getCustom4Like() {
return custom4Like;
}
@Override
public TaskHistoryQuery idIn(String... idIn) {
this.idIn = toUpperCopy(idIn);
return this;
}
@Override
public TaskHistoryQuery businessProcessIdIn(String... businessProcessId) {
this.businessProcessIdIn = toUpperCopy(businessProcessId);
return this;
}
@Override
public TaskHistoryQuery parentBusinessProcessIdIn(String... parentBusinessProcessId) {
this.parentBusinessProcessIdIn = toUpperCopy(parentBusinessProcessId);
return this;
}
@Override
public TaskHistoryQuery taskIdIn(String... taskId) {
this.taskIdIn = toUpperCopy(taskId);
return this;
}
@Override
public TaskHistoryQuery eventTypeIn(String... eventType) {
this.eventTypeIn = toUpperCopy(eventType);
return this;
}
@Override
public TaskHistoryQuery createdWithin(TimeInterval... createdIn) {
this.createdIn = createdIn;
return this;
}
@Override
public TaskHistoryQuery userIdIn(String... userId) {
this.userIdIn = toUpperCopy(userId);
return this;
}
@Override
public TaskHistoryQuery domainIn(String... domain) {
this.domainIn = toUpperCopy(domain);
return this;
}
@Override
public TaskHistoryQuery workbasketKeyIn(String... workbasketKey) {
this.workbasketKeyIn = toUpperCopy(workbasketKey);
return this;
}
@Override
public TaskHistoryQuery porCompanyIn(String... porCompany) {
this.porCompanyIn = toUpperCopy(porCompany);
return this;
}
@Override
public TaskHistoryQuery porSystemIn(String... porSystem) {
this.porSystemIn = toUpperCopy(porSystem);
return this;
}
@Override
public TaskHistoryQuery porInstanceIn(String... porInstance) {
this.porInstanceIn = toUpperCopy(porInstance);
return this;
}
@Override
public TaskHistoryQuery porTypeIn(String... porType) {
this.porTypeIn = toUpperCopy(porType);
return this;
}
@Override
public TaskHistoryQuery porValueIn(String... porValue) {
this.porValueIn = toUpperCopy(porValue);
return this;
}
@Override
public TaskHistoryQuery taskClassificationKeyIn(String... taskClassificationKey) {
this.taskClassificationKeyIn = toUpperCopy(taskClassificationKey);
return this;
}
@Override
public TaskHistoryQuery taskClassificationCategoryIn(String... taskClassificationCategory) {
this.taskClassificationCategoryIn = toUpperCopy(taskClassificationCategory);
return this;
}
@Override
public TaskHistoryQuery attachmentClassificationKeyIn(String... attachmentClassificationKey) {
this.attachmentClassificationKeyIn = toUpperCopy(attachmentClassificationKey);
return this;
}
@Override
public TaskHistoryQuery oldValueIn(String... oldValueIn) {
this.oldValueIn = toUpperCopy(oldValueIn);
return this;
}
@Override
public TaskHistoryQuery newValueIn(String... newValueIn) {
this.newValueIn = toUpperCopy(newValueIn);
return this;
}
@Override
public TaskHistoryQuery businessProcessIdLike(String... businessProcessId) {
this.businessProcessIdLike = toUpperCopy(businessProcessId);
return this;
}
@Override
public TaskHistoryQuery parentBusinessProcessIdLike(String... parentBusinessProcessId) {
this.parentBusinessProcessIdLike = toUpperCopy(parentBusinessProcessId);
return this;
}
@Override
public TaskHistoryQuery taskIdLike(String... taskId) {
this.taskIdLike = toUpperCopy(taskId);
return this;
}
@Override
public TaskHistoryQuery eventTypeLike(String... eventType) {
this.eventTypeLike = toUpperCopy(eventType);
return this;
}
@Override
public TaskHistoryQuery userIdLike(String... userId) {
this.userIdLike = toUpperCopy(userId);
return this;
}
@Override
public TaskHistoryQuery domainLike(String... domain) {
this.domainLike = toUpperCopy(domain);
return this;
}
@Override
public TaskHistoryQuery workbasketKeyLike(String... workbasketKey) {
this.workbasketKeyLike = toUpperCopy(workbasketKey);
return this;
}
@Override
public TaskHistoryQuery porCompanyLike(String... porCompany) {
this.porCompanyLike = toUpperCopy(porCompany);
return this;
}
@Override
public TaskHistoryQuery porSystemLike(String... porSystem) {
this.porSystemLike = toUpperCopy(porSystem);
return this;
}
@Override
public TaskHistoryQuery porInstanceLike(String... porInstance) {
this.porInstanceLike = toUpperCopy(porInstance);
return this;
}
@Override
public TaskHistoryQuery porTypeLike(String... porType) {
this.porTypeLike = toUpperCopy(porType);
return this;
}
@Override
public TaskHistoryQuery porValueLike(String... porValue) {
this.porValueLike = toUpperCopy(porValue);
return this;
}
@Override
public TaskHistoryQuery taskClassificationKeyLike(String... taskClassificationKey) {
this.taskClassificationKeyLike = toUpperCopy(taskClassificationKey);
return this;
}
@Override
public TaskHistoryQuery taskClassificationCategoryLike(String... taskClassificationCategory) {
this.taskClassificationCategoryLike = toUpperCopy(taskClassificationCategory);
return this;
}
@Override
public TaskHistoryQuery attachmentClassificationKeyLike(String... attachmentClassificationKey) {
this.attachmentClassificationKeyLike = toUpperCopy(attachmentClassificationKey);
return this;
}
@Override
public TaskHistoryQuery oldValueLike(String... oldValue) {
this.oldValueLike = toUpperCopy(oldValue);
return this;
}
@Override
public TaskHistoryQuery newValueLike(String... newValue) {
this.newValueLike = toUpperCopy(newValue);
return this;
}
@Override
public TaskHistoryQuery customAttributeIn(
TaskHistoryCustomField customField, String... searchArguments) {
switch (customField) {
case CUSTOM_1:
custom1In = toUpperCopy(searchArguments);
break;
case CUSTOM_2:
custom2In = toUpperCopy(searchArguments);
break;
case CUSTOM_3:
custom3In = toUpperCopy(searchArguments);
break;
case CUSTOM_4:
custom4In = toUpperCopy(searchArguments);
break;
default:
throw new SystemException("Unknown customField '" + customField + "'");
}
return this;
}
@Override
public TaskHistoryQuery customAttributeLike(
TaskHistoryCustomField customField, String... searchArguments) {
switch (customField) {
case CUSTOM_1:
custom1Like = toUpperCopy(searchArguments);
break;
case CUSTOM_2:
custom2Like = toUpperCopy(searchArguments);
break;
case CUSTOM_3:
custom3Like = toUpperCopy(searchArguments);
break;
case CUSTOM_4:
custom4Like = toUpperCopy(searchArguments);
break;
default:
throw new SystemException("Unknown customField '" + customField + "'");
}
return this;
}
@Override
public TaskHistoryQuery orderByBusinessProcessId(SortDirection sortDirection) {
return addOrderCriteria("BUSINESS_PROCESS_ID", sortDirection);
}
@Override
public TaskHistoryQuery orderByParentBusinessProcessId(SortDirection sortDirection) {
return addOrderCriteria("PARENT_BUSINESS_PROCESS_ID", sortDirection);
}
@Override
public TaskHistoryQuery orderByTaskId(SortDirection sortDirection) {
return addOrderCriteria("TASK_ID", sortDirection);
}
@Override
public TaskHistoryQuery orderByEventType(SortDirection sortDirection) {
return addOrderCriteria("EVENT_TYPE", sortDirection);
}
@Override
public TaskHistoryQuery orderByCreated(SortDirection sortDirection) {
return addOrderCriteria("CREATED", sortDirection);
}
@Override
public TaskHistoryQuery orderByUserId(SortDirection sortDirection) {
return addOrderCriteria("USER_ID", sortDirection);
}
@Override
public TaskHistoryQuery orderByDomain(SortDirection sortDirection) {
return addOrderCriteria("DOMAIN", sortDirection);
}
@Override
public TaskHistoryQuery orderByWorkbasketKey(SortDirection sortDirection) {
return addOrderCriteria("WORKBASKET_KEY", sortDirection);
}
@Override
public TaskHistoryQuery orderByPorCompany(SortDirection sortDirection) {
return addOrderCriteria("POR_COMPANY", sortDirection);
}
@Override
public TaskHistoryQuery orderByPorSystem(SortDirection sortDirection) {
return addOrderCriteria("POR_SYSTEM", sortDirection);
}
@Override
public TaskHistoryQuery orderByPorInstance(SortDirection sortDirection) {
return addOrderCriteria("POR_INSTANCE", sortDirection);
}
@Override
public TaskHistoryQuery orderByPorType(SortDirection sortDirection) {
return addOrderCriteria("POR_TYPE", sortDirection);
}
@Override
public TaskHistoryQuery orderByPorValue(SortDirection sortDirection) {
return addOrderCriteria("POR_VALUE", sortDirection);
}
@Override
public TaskHistoryQuery orderByTaskClassificationKey(SortDirection sortDirection) {
return addOrderCriteria("TASK_CLASSIFICATION_KEY", sortDirection);
}
@Override
public TaskHistoryQuery orderByTaskClassificationCategory(SortDirection sortDirection) {
return addOrderCriteria("TASK_CLASSIFICATION_CATEGORY", sortDirection);
}
@Override
public TaskHistoryQuery orderByAttachmentClassificationKey(SortDirection sortDirection) {
return addOrderCriteria("ATTACHMENT_CLASSIFICATION_KEY", sortDirection);
}
@Override
public TaskHistoryQuery orderByOldValue(SortDirection sortDirection) {
return addOrderCriteria("OLD_VALUE", sortDirection);
}
@Override
public TaskHistoryQuery orderByNewValue(SortDirection sortDirection) {
return addOrderCriteria("NEW_VALUE", sortDirection);
}
@Override
public TaskHistoryQuery orderByCustomAttribute(
TaskHistoryCustomField customField, SortDirection sortDirection) {
return addOrderCriteria(customField.name(), sortDirection);
}
@Override
public List<TaskHistoryEvent> list() {
LOGGER.debug("entry to list(), this = {}", this);
List<TaskHistoryEvent> result = new ArrayList<>();
try {
taskanaHistoryEngine.openConnection();
result = taskanaHistoryEngine.getSqlSession().selectList(LINK_TO_MAPPER, this);
return result;
} catch (SQLException e) {
LOGGER.error(SQL_EXCEPTION_MESSAGE, e.getCause());
return result;
} finally {
taskanaHistoryEngine.returnConnection();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(
"exit from list(). Returning {} resulting Objects: {} ", result.size(), result);
}
}
}
@Override
public List<TaskHistoryEvent> list(int offset, int limit) {
LOGGER.debug("entry to list({},{}), this = {}", offset, limit, this);
List<TaskHistoryEvent> result = new ArrayList<>();
try {
taskanaHistoryEngine.openConnection();
RowBounds rowBounds = new RowBounds(offset, limit);
result = taskanaHistoryEngine.getSqlSession().selectList(LINK_TO_MAPPER, this, rowBounds);
return result;
} catch (SQLException e) {
LOGGER.error(SQL_EXCEPTION_MESSAGE, e.getCause());
return result;
} finally {
taskanaHistoryEngine.returnConnection();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(
"exit from list(offset,limit). Returning {} resulting Objects: {} ",
result.size(),
result);
}
}
}
@Override
public List<String> listValues(
TaskHistoryQueryColumnName dbColumnName, SortDirection sortDirection) {
LOGGER.debug(
"entry to listValues() of column {} with sortDirection {}, this {}",
dbColumnName,
sortDirection,
this);
List<String> result = new ArrayList<>();
this.columnName = dbColumnName;
this.orderBy.clear();
this.addOrderCriteria(columnName.toString(), sortDirection);
try {
taskanaHistoryEngine.openConnection();
result = taskanaHistoryEngine.getSqlSession().selectList(LINK_TO_VALUE_MAPPER, this);
return result;
} catch (SQLException e) {
LOGGER.error(SQL_EXCEPTION_MESSAGE, e.getCause());
return result;
} finally {
this.orderColumns.remove(orderColumns.size() - 1);
taskanaHistoryEngine.returnConnection();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(
"Exit from listValues. Returning {} resulting Objects: {} ", result.size(), result);
}
}
}
@Override
public TaskHistoryEvent single() {
LOGGER.debug("entry to single(), this = {}", this);
TaskHistoryEvent result = null;
try {
taskanaHistoryEngine.openConnection();
List<TaskHistoryEvent> results =
taskanaHistoryEngine.getSqlSession().selectList(LINK_TO_MAPPER, this);
if (results.isEmpty()) {
return result;
} else {
result = results.get(0);
}
return result;
} catch (SQLException e) {
LOGGER.error(SQL_EXCEPTION_MESSAGE, e.getCause());
return result;
} finally {
taskanaHistoryEngine.returnConnection();
LOGGER.debug("exit from single(). Returning result {} ", result);
}
}
@Override
public long count() {
LOGGER.debug("entry to count(), this = {}", this);
Long rowCount = null;
try {
taskanaHistoryEngine.openConnection();
rowCount = taskanaHistoryEngine.getSqlSession().selectOne(LINK_TO_COUNTER, this);
return (rowCount == null) ? 0L : rowCount;
} catch (SQLException e) {
LOGGER.error(SQL_EXCEPTION_MESSAGE, e.getCause());
return -1;
} finally {
taskanaHistoryEngine.returnConnection();
LOGGER.debug("exit from count(). Returning result {} ", rowCount);
}
}
private TaskHistoryQueryImpl addOrderCriteria(String columnName, SortDirection sortDirection) {
String orderByDirection =
" " + (sortDirection == null ? SortDirection.ASCENDING : sortDirection);
orderBy.add(columnName + orderByDirection);
orderColumns.add(columnName);
return this;
}
}

12
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/TaskanaHistoryEngineImpl.java
View File

@ -23,8 +23,10 @@ import pro.taskana.common.api.TaskanaRole;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.CurrentUserContext;
import pro.taskana.simplehistory.TaskanaHistoryEngine;
import pro.taskana.simplehistory.impl.mappings.HistoryEventMapper;
import pro.taskana.simplehistory.impl.mappings.HistoryQueryMapper;
import pro.taskana.simplehistory.impl.task.TaskHistoryEventMapper;
import pro.taskana.simplehistory.impl.task.TaskHistoryQueryMapper;
import pro.taskana.simplehistory.impl.workbasket.WorkbasketHistoryEventMapper;
import pro.taskana.simplehistory.impl.workbasket.WorkbasketHistoryQueryMapper;
import pro.taskana.spi.history.api.TaskanaHistory;
/** This is the implementation of TaskanaHistoryEngine. */
@ -98,8 +100,10 @@ public class TaskanaHistoryEngineImpl implements TaskanaHistoryEngine {
Configuration configuration = new Configuration(environment);
// add mappers
configuration.addMapper(HistoryEventMapper.class);
configuration.addMapper(HistoryQueryMapper.class);
configuration.addMapper(TaskHistoryEventMapper.class);
configuration.addMapper(TaskHistoryQueryMapper.class);
configuration.addMapper(WorkbasketHistoryEventMapper.class);
configuration.addMapper(WorkbasketHistoryQueryMapper.class);
SqlSessionFactory localSessionFactory = new SqlSessionFactoryBuilder().build(configuration);
return SqlSessionManager.newInstance(localSessionFactory);
}

594
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/WorkbasketHistoryQueryImpl.java Normal file
View File

@ -0,0 +1,594 @@
package pro.taskana.simplehistory.impl;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.apache.ibatis.session.RowBounds;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.simplehistory.impl.workbasket.WorkbasketHistoryQuery;
import pro.taskana.simplehistory.impl.workbasket.WorkbasketHistoryQueryColumnName;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
public class WorkbasketHistoryQueryImpl implements WorkbasketHistoryQuery {
private static final String LINK_TO_MAPPER =
"pro.taskana.simplehistory.impl.workbasket.WorkbasketHistoryQueryMapper.queryHistoryEvents";
private static final String LINK_TO_VALUE_MAPPER =
"pro.taskana.simplehistory.impl.workbasket."
+ "WorkbasketHistoryQueryMapper.queryHistoryColumnValues";
private static final String LINK_TO_COUNTER =
"pro.taskana.simplehistory.impl.workbasket.WorkbasketHistoryQueryMapper.countHistoryEvents";
private static final Logger LOGGER = LoggerFactory.getLogger(WorkbasketHistoryQueryImpl.class);
private static final String SQL_EXCEPTION_MESSAGE =
"Method openConnection() could not open a connection to the database.";
private TaskanaHistoryEngineImpl taskanaHistoryEngine;
private WorkbasketHistoryQueryColumnName columnName;
private List<String> orderBy;
private List<String> orderColumns;
private String[] idIn;
private String[] workbasketIdIn;
private String[] eventTypeIn;
private TimeInterval[] createdIn;
private String[] userIdIn;
private String[] domainIn;
private String[] workbasketKeyIn;
private String[] workbasketTypeIn;
private String[] ownerIn;
private String[] custom1In;
private String[] custom2In;
private String[] custom3In;
private String[] custom4In;
private String[] orgLevel1In;
private String[] orgLevel2In;
private String[] orgLevel3In;
private String[] orgLevel4In;
private String[] workbasketIdLike;
private String[] eventTypeLike;
private String[] userIdLike;
private String[] domainLike;
private String[] workbasketKeyLike;
private String[] workbasketTypeLike;
private String[] ownerLike;
private String[] custom1Like;
private String[] custom2Like;
private String[] custom3Like;
private String[] custom4Like;
private String[] orgLevel1Like;
private String[] orgLevel2Like;
private String[] orgLevel3Like;
private String[] orgLevel4Like;
public WorkbasketHistoryQueryImpl(TaskanaHistoryEngineImpl internalTaskanaHistoryEngine) {
this.taskanaHistoryEngine = internalTaskanaHistoryEngine;
this.orderBy = new ArrayList<>();
this.orderColumns = new ArrayList<>();
}
public String[] getIdIn() {
return idIn;
}
public String[] getWorkbasketIdIn() {
return workbasketIdIn;
}
public String[] getEventTypeIn() {
return eventTypeIn;
}
public TimeInterval[] getCreatedIn() {
return createdIn;
}
public String[] getUserIdIn() {
return userIdIn;
}
public String[] getDomainIn() {
return domainIn;
}
public String[] getWorkbasketKeyIn() {
return workbasketKeyIn;
}
public String[] getWorkbasketTypeIn() {
return workbasketTypeIn;
}
public String[] getOwnerIn() {
return ownerIn;
}
public String[] getCustom1In() {
return custom1In;
}
public String[] getCustom2In() {
return custom2In;
}
public String[] getCustom3In() {
return custom3In;
}
public String[] getCustom4In() {
return custom4In;
}
public String[] getOrgLevel1In() {
return orgLevel1In;
}
public String[] getOrgLevel2In() {
return orgLevel2In;
}
public String[] getOrgLevel3In() {
return orgLevel3In;
}
public String[] getOrgLevel4In() {
return orgLevel4In;
}
public String[] getWorkbasketIdLike() {
return workbasketIdLike;
}
public String[] getEventTypeLike() {
return eventTypeLike;
}
public String[] getUserIdLike() {
return userIdLike;
}
public String[] getDomainLike() {
return domainLike;
}
public String[] getWorkbasketKeyLike() {
return workbasketKeyLike;
}
public String[] getWorkbasketTypeLike() {
return workbasketTypeLike;
}
public String[] getOwnerLike() {
return ownerLike;
}
public String[] getCustom1Like() {
return custom1Like;
}
public String[] getCustom2Like() {
return custom2Like;
}
public String[] getCustom3Like() {
return custom3Like;
}
public String[] getCustom4Like() {
return custom4Like;
}
public String[] getOrgLevel1Like() {
return orgLevel1Like;
}
public String[] getOrgLevel2Like() {
return orgLevel2Like;
}
public String[] getOrgLevel3Like() {
return orgLevel3Like;
}
public String[] getOrgLevel4Like() {
return orgLevel4Like;
}
@Override
public WorkbasketHistoryQuery idIn(String... idIn) {
this.idIn = toUpperCopy(idIn);
return this;
}
@Override
public WorkbasketHistoryQuery workbasketIdIn(String... workbasketId) {
this.workbasketIdIn = toUpperCopy(workbasketId);
return this;
}
@Override
public WorkbasketHistoryQuery eventTypeIn(String... eventType) {
this.eventTypeIn = toUpperCopy(eventType);
return this;
}
@Override
public WorkbasketHistoryQuery createdWithin(TimeInterval... createdIn) {
this.createdIn = createdIn;
return this;
}
@Override
public WorkbasketHistoryQuery userIdIn(String... userId) {
this.userIdIn = toUpperCopy(userId);
return this;
}
@Override
public WorkbasketHistoryQuery domainIn(String... domain) {
this.domainIn = toUpperCopy(domain);
return this;
}
@Override
public WorkbasketHistoryQuery workbasketKeyIn(String... workbasketKey) {
this.workbasketKeyIn = toUpperCopy(workbasketKey);
return this;
}
@Override
public WorkbasketHistoryQuery workbasketTypeIn(String... workbasketType) {
this.workbasketTypeIn = toUpperCopy(workbasketType);
return this;
}
@Override
public WorkbasketHistoryQuery ownerIn(String... oownerIn) {
this.ownerIn = toUpperCopy(ownerIn);
return this;
}
@Override
public WorkbasketHistoryQuery custom1In(String... custom1) {
this.custom1In = toUpperCopy(custom1);
return this;
}
@Override
public WorkbasketHistoryQuery custom2In(String... custom2) {
this.custom2In = toUpperCopy(custom2);
return this;
}
@Override
public WorkbasketHistoryQuery custom3In(String... custom3) {
this.custom3In = toUpperCopy(custom3);
return this;
}
@Override
public WorkbasketHistoryQuery custom4In(String... custom4) {
this.custom4In = toUpperCopy(custom4);
return this;
}
@Override
public WorkbasketHistoryQuery orgLevel1In(String... orgLevel1) {
this.orgLevel1In = toUpperCopy(orgLevel1);
return this;
}
@Override
public WorkbasketHistoryQuery orgLevel2In(String... orgLevel2) {
this.orgLevel2In = toUpperCopy(orgLevel2);
return this;
}
@Override
public WorkbasketHistoryQuery orgLevel3In(String... orgLevel3) {
this.orgLevel3In = toUpperCopy(orgLevel3);
return this;
}
@Override
public WorkbasketHistoryQuery orgLevel4In(String... orgLevel4) {
this.orgLevel4In = toUpperCopy(orgLevel4);
return this;
}
@Override
public WorkbasketHistoryQuery workbasketIdLike(String... workbasketId) {
this.workbasketIdLike = toUpperCopy(workbasketId);
return this;
}
@Override
public WorkbasketHistoryQuery eventTypeLike(String... eventType) {
this.eventTypeLike = toUpperCopy(eventType);
return this;
}
@Override
public WorkbasketHistoryQuery userIdLike(String... userId) {
this.userIdLike = toUpperCopy(userId);
return this;
}
@Override
public WorkbasketHistoryQuery domainLike(String... domain) {
this.domainLike = toUpperCopy(domain);
return this;
}
@Override
public WorkbasketHistoryQuery workbasketKeyLike(String... workbasketKey) {
this.workbasketKeyLike = toUpperCopy(workbasketKey);
return this;
}
@Override
public WorkbasketHistoryQuery workbasketTypeLike(String... workbasketType) {
this.workbasketTypeLike = toUpperCopy(workbasketType);
return this;
}
@Override
public WorkbasketHistoryQuery ownerLike(String... ownerLike) {
this.ownerLike = toUpperCopy(ownerLike);
return this;
}
@Override
public WorkbasketHistoryQuery custom1Like(String... custom1) {
this.custom1Like = toUpperCopy(custom1);
return this;
}
@Override
public WorkbasketHistoryQuery custom2Like(String... custom2) {
this.custom2Like = toUpperCopy(custom2);
return this;
}
@Override
public WorkbasketHistoryQuery custom3Like(String... custom3) {
this.custom3Like = toUpperCopy(custom3);
return this;
}
@Override
public WorkbasketHistoryQuery custom4Like(String... custom4) {
this.custom4Like = toUpperCopy(custom4);
return this;
}
@Override
public WorkbasketHistoryQuery orgLevel1Like(String... orgLevel1) {
this.orgLevel1Like = toUpperCopy(orgLevel1);
return this;
}
@Override
public WorkbasketHistoryQuery orgLevel2Like(String... orgLevel2) {
this.orgLevel2Like = toUpperCopy(orgLevel2);
return this;
}
@Override
public WorkbasketHistoryQuery orgLevel3Like(String... orgLevel3) {
this.orgLevel3Like = toUpperCopy(orgLevel3);
return this;
}
@Override
public WorkbasketHistoryQuery orgLevel4Like(String... orgLevel4) {
this.orgLevel4Like = toUpperCopy(orgLevel4);
return this;
}
@Override
public WorkbasketHistoryQuery orderByWorkbasketId(SortDirection sortDirection) {
return addOrderCriteria("WORKBASKET_ID", sortDirection);
}
@Override
public WorkbasketHistoryQuery orderByEventType(SortDirection sortDirection) {
return addOrderCriteria("EVENT_TYPE", sortDirection);
}
@Override
public WorkbasketHistoryQuery orderByCreated(SortDirection sortDirection) {
return addOrderCriteria("CREATED", sortDirection);
}
@Override
public WorkbasketHistoryQuery orderByUserId(SortDirection sortDirection) {
return addOrderCriteria("USER_ID", sortDirection);
}
@Override
public WorkbasketHistoryQuery orderByDomain(SortDirection sortDirection) {
return addOrderCriteria("DOMAIN", sortDirection);
}
@Override
public WorkbasketHistoryQuery orderByWorkbasketKey(SortDirection sortDirection) {
return addOrderCriteria("WORKBASKET_KEY", sortDirection);
}
@Override
public WorkbasketHistoryQuery orderByWorkbasketType(SortDirection sortDirection) {
return addOrderCriteria("WORKBASKET_TYPE", sortDirection);
}
@Override
public WorkbasketHistoryQuery orderByCustomAttribute(int num, SortDirection sortDirection)
throws InvalidArgumentException {
switch (num) {
case 1:
return addOrderCriteria("CUSTOM_1", sortDirection);
case 2:
return addOrderCriteria("CUSTOM_2", sortDirection);
case 3:
return addOrderCriteria("CUSTOM_3", sortDirection);
case 4:
return addOrderCriteria("CUSTOM_4", sortDirection);
default:
throw new InvalidArgumentException(
"Custom number has to be between 1 and 4, but this is: " + num);
}
}
@Override
public WorkbasketHistoryQuery orderByOrgLevel(int num, SortDirection sortDirection)
throws InvalidArgumentException {
switch (num) {
case 1:
return addOrderCriteria("ORGLEVEL_1", sortDirection);
case 2:
return addOrderCriteria("ORGLEVEL_2", sortDirection);
case 3:
return addOrderCriteria("ORGLEVEL_3", sortDirection);
case 4:
return addOrderCriteria("ORGLEVEL_4", sortDirection);
default:
throw new InvalidArgumentException(
"Org number has to be between 1 and 4, but this is: " + num);
}
}
@Override
public List<WorkbasketHistoryEvent> list() {
LOGGER.debug("entry to list(), this = {}", this);
List<WorkbasketHistoryEvent> result = new ArrayList<>();
try {
taskanaHistoryEngine.openConnection();
result = taskanaHistoryEngine.getSqlSession().selectList(LINK_TO_MAPPER, this);
return result;
} catch (SQLException e) {
LOGGER.error(SQL_EXCEPTION_MESSAGE, e.getCause());
return result;
} finally {
taskanaHistoryEngine.returnConnection();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(
"exit from list(). Returning {} resulting Objects: {} ", result.size(), result);
}
}
}
@Override
public List<WorkbasketHistoryEvent> list(int offset, int limit) {
LOGGER.debug("entry to list({},{}), this = {}", offset, limit, this);
List<WorkbasketHistoryEvent> result = new ArrayList<>();
try {
taskanaHistoryEngine.openConnection();
RowBounds rowBounds = new RowBounds(offset, limit);
result = taskanaHistoryEngine.getSqlSession().selectList(LINK_TO_MAPPER, this, rowBounds);
return result;
} catch (SQLException e) {
LOGGER.error(SQL_EXCEPTION_MESSAGE, e.getCause());
return result;
} finally {
taskanaHistoryEngine.returnConnection();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(
"exit from list(offset,limit). Returning {} resulting Objects: {} ",
result.size(),
result);
}
}
}
@Override
public List<String> listValues(
WorkbasketHistoryQueryColumnName dbColumnName, SortDirection sortDirection) {
LOGGER.debug(
"entry to listValues() of column {} with sortDirection {}, this {}",
dbColumnName,
sortDirection,
this);
List<String> result = new ArrayList<>();
this.columnName = dbColumnName;
List<String> cacheOrderBy = this.orderBy;
this.orderBy.clear();
this.addOrderCriteria(columnName.toString(), sortDirection);
try {
taskanaHistoryEngine.openConnection();
result = taskanaHistoryEngine.getSqlSession().selectList(LINK_TO_VALUE_MAPPER, this);
return result;
} catch (SQLException e) {
LOGGER.error(SQL_EXCEPTION_MESSAGE, e.getCause());
return result;
} finally {
this.orderBy = cacheOrderBy;
this.columnName = null;
this.orderColumns.remove(orderColumns.size() - 1);
taskanaHistoryEngine.returnConnection();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(
"Exit from listValues. Returning {} resulting Objects: {} ", result.size(), result);
}
}
}
@Override
public WorkbasketHistoryEvent single() {
LOGGER.debug("entry to single(), this = {}", this);
WorkbasketHistoryEvent result = null;
try {
taskanaHistoryEngine.openConnection();
List<WorkbasketHistoryEvent> results =
taskanaHistoryEngine.getSqlSession().selectList(LINK_TO_MAPPER, this);
if (results.isEmpty()) {
return result;
} else {
result = results.get(0);
}
return result;
} catch (SQLException e) {
LOGGER.error(SQL_EXCEPTION_MESSAGE, e.getCause());
return result;
} finally {
taskanaHistoryEngine.returnConnection();
LOGGER.debug("exit from single(). Returning result {} ", result);
}
}
@Override
public long count() {
LOGGER.debug("entry to count(), this = {}", this);
Long rowCount = null;
try {
taskanaHistoryEngine.openConnection();
rowCount = taskanaHistoryEngine.getSqlSession().selectOne(LINK_TO_COUNTER, this);
return (rowCount == null) ? 0L : rowCount;
} catch (SQLException e) {
LOGGER.error(SQL_EXCEPTION_MESSAGE, e.getCause());
return -1;
} finally {
taskanaHistoryEngine.returnConnection();
LOGGER.debug("exit from count(). Returning result {} ", rowCount);
}
}
private WorkbasketHistoryQueryImpl addOrderCriteria(
String columnName, SortDirection sortDirection) {
String orderByDirection =
" " + (sortDirection == null ? SortDirection.ASCENDING : sortDirection);
orderBy.add(columnName + orderByDirection);
orderColumns.add(columnName);
return this;
}
}

19
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/mappings/HistoryEventMapper.java → history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/task/TaskHistoryEventMapper.java
View File

@ -1,4 +1,4 @@
package pro.taskana.simplehistory.impl.mappings;
package pro.taskana.simplehistory.impl.task;
import java.util.List;
import org.apache.ibatis.annotations.Delete;
@ -8,14 +8,14 @@ import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import pro.taskana.spi.history.api.events.TaskanaHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
/** This class is the mybatis mapping of workbaskets. */
/** This class is the mybatis mapping of task history events. */
@SuppressWarnings("checkstyle:LineLength")
public interface HistoryEventMapper {
public interface TaskHistoryEventMapper {
@Insert(
"<script>INSERT INTO HISTORY_EVENTS (ID,BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID,"
"<script>INSERT INTO TASK_HISTORY_EVENT (ID,BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID,"
+ " EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, POR_COMPANY, POR_SYSTEM, POR_INSTANCE,"
+ " POR_TYPE, POR_VALUE, TASK_CLASSIFICATION_KEY, TASK_CLASSIFICATION_CATEGORY, ATTACHMENT_CLASSIFICATION_KEY, "
+ " OLD_VALUE, NEW_VALUE, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, DETAILS)"
@ -27,14 +27,14 @@ public interface HistoryEventMapper {
+ " #{historyEvent.custom1}, #{historyEvent.custom2}, #{historyEvent.custom3}, #{historyEvent.custom4},"
+ " #{historyEvent.details}) "
+ "</script>")
void insert(@Param("historyEvent") TaskanaHistoryEvent historyEvent);
void insert(@Param("historyEvent") TaskHistoryEvent historyEvent);
@Select(
"<script>"
+ "SELECT ID, BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID, EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, "
+ "POR_COMPANY, POR_SYSTEM, POR_INSTANCE, POR_TYPE, POR_VALUE, TASK_CLASSIFICATION_KEY, TASK_CLASSIFICATION_CATEGORY,"
+ "ATTACHMENT_CLASSIFICATION_KEY, OLD_VALUE, NEW_VALUE, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, DETAILS "
+ "FROM HISTORY_EVENTS WHERE ID = #{id} "
+ "FROM TASK_HISTORY_EVENT WHERE ID = #{id} "
+ "<if test=\"_databaseId == 'db2'\">with UR </if> "
+ "</script>")
@Results(
@ -64,10 +64,9 @@ public interface HistoryEventMapper {
@Result(property = "custom4", column = "CUSTOM_4"),
@Result(property = "details", column = "DETAILS")
})
TaskanaHistoryEvent findById(@Param("id") String id);
TaskHistoryEvent findById(@Param("id") String id);
@Delete(
"<script>DELETE FROM HISTORY_EVENTS WHERE TASK_ID IN(<foreach item='item' collection='taskIds' separator=',' >#{item}</foreach>)</script>")
"<script>DELETE FROM TASK_HISTORY_EVENT WHERE TASK_ID IN(<foreach item='item' collection='taskIds' separator=',' >#{item}</foreach>)</script>")
void deleteMultipleByTaskIds(@Param("taskIds") List<String> taskIds);
}

121
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/query/HistoryQuery.java → history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/task/TaskHistoryQuery.java
View File

@ -1,12 +1,12 @@
package pro.taskana.simplehistory.query;
package pro.taskana.simplehistory.impl.task;
import pro.taskana.common.api.BaseQuery;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.simplehistory.impl.HistoryEventImpl;
import pro.taskana.spi.history.api.events.TaskHistoryCustomField;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
/** HistoryQuery for generating dynamic sql. */
public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryColumnName> {
public interface TaskHistoryQuery extends BaseQuery<TaskHistoryEvent, TaskHistoryQueryColumnName> {
/**
* Add your Id to your query.
@ -14,7 +14,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param idIn as String
* @return the query
*/
HistoryQuery idIn(String... idIn);
TaskHistoryQuery idIn(String... idIn);
/**
* Add your businessProcessId to your query.
@ -22,7 +22,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param businessProcessId as String
* @return the query
*/
HistoryQuery businessProcessIdIn(String... businessProcessId);
TaskHistoryQuery businessProcessIdIn(String... businessProcessId);
/**
* Add your parentBusinessProcessId to your query.
@ -30,7 +30,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param parentBusinessProcessId as String
* @return the query
*/
HistoryQuery parentBusinessProcessIdIn(String... parentBusinessProcessId);
TaskHistoryQuery parentBusinessProcessIdIn(String... parentBusinessProcessId);
/**
* Add your taskId to your query.
@ -38,7 +38,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param taskId as String
* @return the query
*/
HistoryQuery taskIdIn(String... taskId);
TaskHistoryQuery taskIdIn(String... taskId);
/**
* Add your eventType to your query.
@ -46,7 +46,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param eventType as String
* @return the query
*/
HistoryQuery eventTypeIn(String... eventType);
TaskHistoryQuery eventTypeIn(String... eventType);
/**
* Add your created TimeInterval to your query.
@ -55,7 +55,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* were created.
* @return the query
*/
HistoryQuery createdWithin(TimeInterval... createdWithin);
TaskHistoryQuery createdWithin(TimeInterval... createdWithin);
/**
* Add your userId to your query.
@ -63,7 +63,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param userId as String
* @return the query
*/
HistoryQuery userIdIn(String... userId);
TaskHistoryQuery userIdIn(String... userId);
/**
* Add your domain to your query.
@ -71,7 +71,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param domain as String
* @return the query
*/
HistoryQuery domainIn(String... domain);
TaskHistoryQuery domainIn(String... domain);
/**
* Add your workbasketKey to your query.
@ -79,7 +79,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param workbasketKey as String
* @return the query
*/
HistoryQuery workbasketKeyIn(String... workbasketKey);
TaskHistoryQuery workbasketKeyIn(String... workbasketKey);
/**
* Add your porCompany to your query.
@ -87,7 +87,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param porCompany as String
* @return the query
*/
HistoryQuery porCompanyIn(String... porCompany);
TaskHistoryQuery porCompanyIn(String... porCompany);
/**
* Add your porSystem to your query.
@ -95,7 +95,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param porSystem as String
* @return the query
*/
HistoryQuery porSystemIn(String... porSystem);
TaskHistoryQuery porSystemIn(String... porSystem);
/**
* Add your porInstance to your query.
@ -103,7 +103,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param porInstance as String
* @return the query
*/
HistoryQuery porInstanceIn(String... porInstance);
TaskHistoryQuery porInstanceIn(String... porInstance);
/**
* Add your porType to your query.
@ -111,7 +111,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param porType as String
* @return the query
*/
HistoryQuery porTypeIn(String... porType);
TaskHistoryQuery porTypeIn(String... porType);
/**
* Add your porValue to your query.
@ -119,7 +119,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param porValue as String
* @return the query
*/
HistoryQuery porValueIn(String... porValue);
TaskHistoryQuery porValueIn(String... porValue);
/**
* Add your taskClassificationKey to your query.
@ -127,7 +127,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param taskClassificationKey as String
* @return the query
*/
HistoryQuery taskClassificationKeyIn(String... taskClassificationKey);
TaskHistoryQuery taskClassificationKeyIn(String... taskClassificationKey);
/**
* Add your taskClassificationCategory to your query.
@ -135,7 +135,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param taskClassificationCategory as String
* @return the query
*/
HistoryQuery taskClassificationCategoryIn(String... taskClassificationCategory);
TaskHistoryQuery taskClassificationCategoryIn(String... taskClassificationCategory);
/**
* Add your attachmentClassificationKey to your query.
@ -143,7 +143,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param attachmentClassificationKey as String
* @return the query
*/
HistoryQuery attachmentClassificationKeyIn(String... attachmentClassificationKey);
TaskHistoryQuery attachmentClassificationKeyIn(String... attachmentClassificationKey);
/**
* Add your oldValue to your query.
@ -151,7 +151,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param oldValue as String
* @return the query
*/
HistoryQuery oldValueIn(String... oldValue);
TaskHistoryQuery oldValueIn(String... oldValue);
/**
* Add your newValue to your query.
@ -159,7 +159,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param newValue as String
* @return the query
*/
HistoryQuery newValueIn(String... newValue);
TaskHistoryQuery newValueIn(String... newValue);
/**
* Add your businessProcessId to your query. It will be compared in SQL with an LIKE. If you use a
@ -168,7 +168,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param businessProcessId as String
* @return the query
*/
HistoryQuery businessProcessIdLike(String... businessProcessId);
TaskHistoryQuery businessProcessIdLike(String... businessProcessId);
/**
* Add your parentBusinessProcessId to your query. It will be compared in SQL with an LIKE. If you
@ -177,7 +177,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param parentBusinessProcessId as String
* @return the query
*/
HistoryQuery parentBusinessProcessIdLike(String... parentBusinessProcessId);
TaskHistoryQuery parentBusinessProcessIdLike(String... parentBusinessProcessId);
/**
* Add your taskId to your query. It will be compared in SQL with an LIKE. If you use a wildcard
@ -186,7 +186,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param taskId as String
* @return the query
*/
HistoryQuery taskIdLike(String... taskId);
TaskHistoryQuery taskIdLike(String... taskId);
/**
* Add your eventType to your query. It will be compared in SQL with an LIKE. If you use a
@ -195,7 +195,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param eventType as String
* @return the query
*/
HistoryQuery eventTypeLike(String... eventType);
TaskHistoryQuery eventTypeLike(String... eventType);
/**
* Add your userId to your query. It will be compared in SQL with an LIKE. If you use a wildcard
@ -204,7 +204,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param userId as String
* @return the query
*/
HistoryQuery userIdLike(String... userId);
TaskHistoryQuery userIdLike(String... userId);
/**
* Add your domain to your query. It will be compared in SQL with an LIKE. If you use a wildcard
@ -213,7 +213,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param domain as String
* @return the query
*/
HistoryQuery domainLike(String... domain);
TaskHistoryQuery domainLike(String... domain);
/**
* Add your workbasketKey to your query. It will be compared in SQL with an LIKE. If you use a
@ -222,7 +222,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param workbasketKey as String
* @return the query
*/
HistoryQuery workbasketKeyLike(String... workbasketKey);
TaskHistoryQuery workbasketKeyLike(String... workbasketKey);
/**
* Add your porCompany to your query. It will be compared in SQL with an LIKE. If you use a
@ -231,7 +231,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param porCompany as String
* @return the query
*/
HistoryQuery porCompanyLike(String... porCompany);
TaskHistoryQuery porCompanyLike(String... porCompany);
/**
* Add your porSystem to your query. It will be compared in SQL with an LIKE. If you use a
@ -240,7 +240,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param porSystem as String
* @return the query
*/
HistoryQuery porSystemLike(String... porSystem);
TaskHistoryQuery porSystemLike(String... porSystem);
/**
* Add your porInstance to your query. It will be compared in SQL with an LIKE. If you use a
@ -249,7 +249,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param porInstance as String
* @return the query
*/
HistoryQuery porInstanceLike(String... porInstance);
TaskHistoryQuery porInstanceLike(String... porInstance);
/**
* Add your porType to your query. It will be compared in SQL with an LIKE. If you use a wildcard
@ -258,7 +258,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param porType as String
* @return the query
*/
HistoryQuery porTypeLike(String... porType);
TaskHistoryQuery porTypeLike(String... porType);
/**
* Add your porValue to your query. It will be compared in SQL with an LIKE. If you use a wildcard
@ -267,7 +267,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param porValue as String
* @return the query
*/
HistoryQuery porValueLike(String... porValue);
TaskHistoryQuery porValueLike(String... porValue);
/**
* Add your taskClassificationKey to your query. It will be compared in SQL with an LIKE. If you
@ -276,7 +276,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param taskClassificationKey as String
* @return the query
*/
HistoryQuery taskClassificationKeyLike(String... taskClassificationKey);
TaskHistoryQuery taskClassificationKeyLike(String... taskClassificationKey);
/**
* Add your taskClassificationCategory to your query. It will be compared in SQL with an LIKE. If
@ -285,7 +285,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param taskClassificationCategory as String
* @return the query
*/
HistoryQuery taskClassificationCategoryLike(String... taskClassificationCategory);
TaskHistoryQuery taskClassificationCategoryLike(String... taskClassificationCategory);
/**
* Add your attachmentClassificationKey to your query. It will be compared in SQL with an LIKE. If
@ -294,7 +294,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param attachmentClassificationKey as String
* @return the query
*/
HistoryQuery attachmentClassificationKeyLike(String... attachmentClassificationKey);
TaskHistoryQuery attachmentClassificationKeyLike(String... attachmentClassificationKey);
/**
* Add your oldValue to your query. It will be compared in SQL with an LIKE. If you use a wildcard
@ -303,7 +303,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param oldValue as String
* @return the query
*/
HistoryQuery oldValueLike(String... oldValue);
TaskHistoryQuery oldValueLike(String... oldValue);
/**
* Add your newValue to your query. It will be compared in SQL with an LIKE. If you use a wildcard
@ -312,7 +312,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param newValue as String
* @return the query
*/
HistoryQuery newValueLike(String... newValue);
TaskHistoryQuery newValueLike(String... newValue);
/**
* Add the values of custom attributes for exact matching to your query.
@ -321,7 +321,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param searchArguments the customField values of the searched for tasks
* @return the query
*/
HistoryQuery customAttributeIn(TaskHistoryCustomField customField, String... searchArguments);
TaskHistoryQuery customAttributeIn(TaskHistoryCustomField customField, String... searchArguments);
/**
* Add the values of custom attributes for pattern matching to your query. They will be compared
@ -332,7 +332,8 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* @param searchArguments the customField values of the searched-for tasks
* @return the query
*/
HistoryQuery customAttributeLike(TaskHistoryCustomField customField, String... searchArguments);
TaskHistoryQuery customAttributeLike(
TaskHistoryCustomField customField, String... searchArguments);
/**
* Sort the query result by businessProcessId.
@ -341,7 +342,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByBusinessProcessId(SortDirection sortDirection);
TaskHistoryQuery orderByBusinessProcessId(SortDirection sortDirection);
/**
* Sort the query result by parentBusinessProcessId.
@ -350,7 +351,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByParentBusinessProcessId(SortDirection sortDirection);
TaskHistoryQuery orderByParentBusinessProcessId(SortDirection sortDirection);
/**
* Sort the query result by taskId.
@ -359,7 +360,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByTaskId(SortDirection sortDirection);
TaskHistoryQuery orderByTaskId(SortDirection sortDirection);
/**
* Sort the query result by eventType.
@ -368,7 +369,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByEventType(SortDirection sortDirection);
TaskHistoryQuery orderByEventType(SortDirection sortDirection);
/**
* Sort the query result by created.
@ -377,7 +378,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByCreated(SortDirection sortDirection);
TaskHistoryQuery orderByCreated(SortDirection sortDirection);
/**
* Sort the query result by userId.
@ -386,7 +387,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByUserId(SortDirection sortDirection);
TaskHistoryQuery orderByUserId(SortDirection sortDirection);
/**
* Sort the query result by Domain.
@ -395,7 +396,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByDomain(SortDirection sortDirection);
TaskHistoryQuery orderByDomain(SortDirection sortDirection);
/**
* Sort the query result by WorkbasketKey.
@ -404,7 +405,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByWorkbasketKey(SortDirection sortDirection);
TaskHistoryQuery orderByWorkbasketKey(SortDirection sortDirection);
/**
* Sort the query result by porCompany.
@ -413,7 +414,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByPorCompany(SortDirection sortDirection);
TaskHistoryQuery orderByPorCompany(SortDirection sortDirection);
/**
* Sort the query result by porSystem.
@ -422,7 +423,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByPorSystem(SortDirection sortDirection);
TaskHistoryQuery orderByPorSystem(SortDirection sortDirection);
/**
* Sort the query result by porInstance.
@ -431,7 +432,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByPorInstance(SortDirection sortDirection);
TaskHistoryQuery orderByPorInstance(SortDirection sortDirection);
/**
* Sort the query result by porType.
@ -440,7 +441,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByPorType(SortDirection sortDirection);
TaskHistoryQuery orderByPorType(SortDirection sortDirection);
/**
* Sort the query result by porValue.
@ -449,7 +450,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByPorValue(SortDirection sortDirection);
TaskHistoryQuery orderByPorValue(SortDirection sortDirection);
/**
* Sort the query result by taskClassificationKey.
@ -458,7 +459,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByTaskClassificationKey(SortDirection sortDirection);
TaskHistoryQuery orderByTaskClassificationKey(SortDirection sortDirection);
/**
* Sort the query result by taskClassificationCategory.
@ -467,7 +468,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByTaskClassificationCategory(SortDirection sortDirection);
TaskHistoryQuery orderByTaskClassificationCategory(SortDirection sortDirection);
/**
* Sort the query result by attachmentClassificationKey.
@ -476,7 +477,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByAttachmentClassificationKey(SortDirection sortDirection);
TaskHistoryQuery orderByAttachmentClassificationKey(SortDirection sortDirection);
/**
* Sort the query result by oldValue.
@ -485,7 +486,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByOldValue(SortDirection sortDirection);
TaskHistoryQuery orderByOldValue(SortDirection sortDirection);
/**
* Sort the query result by newValue.
@ -494,7 +495,7 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByNewValue(SortDirection sortDirection);
TaskHistoryQuery orderByNewValue(SortDirection sortDirection);
/**
* This method sorts the query result according to the value of a custom field.
@ -504,6 +505,6 @@ public interface HistoryQuery extends BaseQuery<HistoryEventImpl, HistoryQueryCo
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
HistoryQuery orderByCustomAttribute(
TaskHistoryQuery orderByCustomAttribute(
TaskHistoryCustomField customField, SortDirection sortDirection);
}

9
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/query/HistoryQueryColumnName.java → history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/task/TaskHistoryQueryColumnName.java
View File

@ -1,14 +1,13 @@
package pro.taskana.simplehistory.query;
package pro.taskana.simplehistory.impl.task;
import pro.taskana.common.api.QueryColumnName;
/**
* Enum containing the column names for {@link
* pro.taskana.simplehistory.impl.mappings.HistoryQueryMapper#queryHistoryColumnValues}.
* Enum containing the column names for {@link TaskHistoryQueryMapper#queryHistoryColumnValues}.
*
* @author bv
*/
public enum HistoryQueryColumnName implements QueryColumnName {
public enum TaskHistoryQueryColumnName implements QueryColumnName {
ID("id"),
BUSINESS_PROCESS_ID("business_process_id"),
PARENT_BUSINESS_PROCESS_ID("parent_business_process_id"),
@ -35,7 +34,7 @@ public enum HistoryQueryColumnName implements QueryColumnName {
private String name;
HistoryQueryColumnName(String name) {
TaskHistoryQueryColumnName(String name) {
this.name = name;
}

23
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/mappings/HistoryQueryMapper.java → history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/task/TaskHistoryQueryMapper.java
View File

@ -1,23 +1,23 @@
package pro.taskana.simplehistory.impl.mappings;
package pro.taskana.simplehistory.impl.task;
import java.util.List;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import pro.taskana.simplehistory.impl.HistoryEventImpl;
import pro.taskana.simplehistory.impl.HistoryQueryImpl;
import pro.taskana.simplehistory.impl.TaskHistoryQueryImpl;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
/** This class is the mybatis mapping of historyQueries. */
/** This class is the mybatis mapping of TaskHistoryQueries. */
@SuppressWarnings("checkstyle:LineLength")
public interface HistoryQueryMapper {
public interface TaskHistoryQueryMapper {
@Select(
"<script>"
+ "SELECT ID, BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID, EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, "
+ "POR_COMPANY, POR_SYSTEM, POR_INSTANCE, POR_TYPE, POR_VALUE, TASK_CLASSIFICATION_KEY, TASK_CLASSIFICATION_CATEGORY,"
+ "ATTACHMENT_CLASSIFICATION_KEY, OLD_VALUE, NEW_VALUE, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4 "
+ "FROM HISTORY_EVENTS"
+ "FROM TASK_HISTORY_EVENT"
+ "<where>"
// IN-Queries
+ "<if test='idIn != null'>AND UPPER(ID) IN (<foreach item='item' collection='idIn' separator=',' >#{item}</foreach>)</if> "
@ -67,7 +67,6 @@ public interface HistoryQueryMapper {
+ "<if test='custom4Like != null'>AND (<foreach item='item' collection='custom4Like' separator=' OR ' >UPPER(CUSTOM_4) LIKE #{item}</foreach>)</if> "
+ "</where>"
+ "<if test='!orderBy.isEmpty()'>ORDER BY <foreach item='item' collection='orderBy' separator=',' >${item}</foreach></if> "
+ "<if test='maxRows > 0'> FETCH FIRST #{maxRows} ROWS ONLY </if>"
+ "</script>")
@Results(
value = {
@ -95,12 +94,12 @@ public interface HistoryQueryMapper {
@Result(property = "custom3", column = "CUSTOM_3"),
@Result(property = "custom4", column = "CUSTOM_4")
})
List<HistoryEventImpl> queryHistoryEvent(HistoryQueryImpl historyEventQuery);
List<TaskHistoryEvent> queryHistoryEvents(TaskHistoryQueryImpl historyEventQuery);
@Select(
"<script>"
+ "SELECT COUNT(ID) "
+ "FROM HISTORY_EVENTS"
+ "FROM TASK_HISTORY_EVENT"
+ "<where>"
// IN-Queries
+ "<if test='businessProcessIdIn != null'>AND UPPER(BUSINESS_PROCESS_ID) IN (<foreach item='item' collection='businessProcessIdIn' separator=',' >#{item}</foreach>)</if> "
@ -149,11 +148,11 @@ public interface HistoryQueryMapper {
+ "<if test='custom4Like != null'>AND (<foreach item='item' collection='custom4Like' separator=' OR ' >UPPER(CUSTOM_4) LIKE #{item}</foreach>)</if> "
+ "</where>"
+ "</script>")
long countHistoryEvent(HistoryQueryImpl historyEventQuery);
long countHistoryEvents(TaskHistoryQueryImpl historyEventQuery);
@Select(
"<script>SELECT DISTINCT ${columnName} "
+ "FROM HISTORY_EVENTS"
+ "FROM TASK_HISTORY_EVENT"
+ "<where>"
// IN-Queries
+ "<if test='idIn != null'>AND UPPER(ID) IN (<foreach item='item' collection='idIn' separator=',' >#{item}</foreach>)</if> "
@ -204,5 +203,5 @@ public interface HistoryQueryMapper {
+ "</where>"
+ "<if test='!orderBy.isEmpty()'>ORDER BY <foreach item='item' collection='orderBy' separator=',' >${item}</foreach></if> "
+ "</script>")
List<String> queryHistoryColumnValues(HistoryQueryImpl historyQuery);
List<String> queryHistoryColumnValues(TaskHistoryQueryImpl historyQuery);
}

59
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/workbasket/WorkbasketHistoryEventMapper.java Normal file
View File

@ -0,0 +1,59 @@
package pro.taskana.simplehistory.impl.workbasket;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
/** This class is the mybatis mapping of workbasket history events. */
@SuppressWarnings("checkstyle:LineLength")
public interface WorkbasketHistoryEventMapper {
@Insert(
"<script>INSERT INTO WORKBASKET_HISTORY_EVENT (ID,WORKBASKET_ID,"
+ " EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, WORKBASKET_TYPE, OWNER, "
+ " CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, ORGLEVEL_1,"
+ " ORGLEVEL_2, ORGLEVEL_3, ORGLEVEL_4, DETAILS)"
+ " VALUES ( #{historyEvent.id}, #{historyEvent.workbasketId},"
+ " #{historyEvent.eventType}, #{historyEvent.created}, #{historyEvent.userId},"
+ " #{historyEvent.domain}, #{historyEvent.workbasketKey}, "
+ " #{historyEvent.workbasketType}, #{historyEvent.owner}, "
+ " #{historyEvent.custom1}, #{historyEvent.custom2}, #{historyEvent.custom3}, "
+ "#{historyEvent.custom4}, #{historyEvent.orgLevel1}, #{historyEvent.orgLevel2}, "
+ "#{historyEvent.orgLevel3}, #{historyEvent.orgLevel4}, #{historyEvent.details}) "
+ "</script>")
void insert(@Param("historyEvent") WorkbasketHistoryEvent historyEvent);
@Select(
"<script>"
+ "SELECT ID, WORKBASKET_ID, EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, WORKBASKET_TYPE, OWNER, "
+ "CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, ORGLEVEL_1, ORGLEVEL_2, ORGLEVEL_3, ORGLEVEL_4, DETAILS "
+ "FROM WORKBASKET_HISTORY_EVENT WHERE ID = #{id} "
+ "<if test=\"_databaseId == 'db2'\">with UR </if> "
+ "</script>")
@Results(
value = {
@Result(property = "id", column = "ID"),
@Result(property = "workbasketId", column = "WORKBASKET_ID"),
@Result(property = "eventType", column = "EVENT_TYPE"),
@Result(property = "created", column = "CREATED"),
@Result(property = "userId", column = "USER_ID"),
@Result(property = "domain", column = "DOMAIN"),
@Result(property = "workbasketKey", column = "WORKBASKET_KEY"),
@Result(property = "workbasketType", column = "WORKBASKET_TYPE"),
@Result(property = "owner", column = "OWNER"),
@Result(property = "custom1", column = "CUSTOM_1"),
@Result(property = "custom2", column = "CUSTOM_2"),
@Result(property = "custom3", column = "CUSTOM_3"),
@Result(property = "custom4", column = "CUSTOM_4"),
@Result(property = "orgLevel1", column = "ORGLEVEL_1"),
@Result(property = "orgLevel2", column = "ORGLEVEL_2"),
@Result(property = "orgLevel3", column = "ORGLEVEL_3"),
@Result(property = "orgLevel4", column = "ORGLEVEL_4"),
@Result(property = "details", column = "DETAILS")
})
WorkbasketHistoryEvent findById(@Param("id") String id);
}

371
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/workbasket/WorkbasketHistoryQuery.java Normal file
View File

@ -0,0 +1,371 @@
package pro.taskana.simplehistory.impl.workbasket;
import pro.taskana.common.api.BaseQuery;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
/** HistoryQuery for generating dynamic sql. */
public interface WorkbasketHistoryQuery
extends BaseQuery<WorkbasketHistoryEvent, WorkbasketHistoryQueryColumnName> {
/**
* Add your Id to your query.
*
* @param idIn as String
* @return the query
*/
WorkbasketHistoryQuery idIn(String... idIn);
/**
* Add your workbasketId to your query.
*
* @param workbasketId as String
* @return the query
*/
WorkbasketHistoryQuery workbasketIdIn(String... workbasketId);
/**
* Add your eventType to your query.
*
* @param eventType as String
* @return the query
*/
WorkbasketHistoryQuery eventTypeIn(String... eventType);
/**
* Add your created TimeInterval to your query.
*
* @param createdWithin the {@link TimeInterval} within which the searched-for classifications
* were created.
* @return the query
*/
WorkbasketHistoryQuery createdWithin(TimeInterval... createdWithin);
/**
* Add your userId to your query.
*
* @param userId as String
* @return the query
*/
WorkbasketHistoryQuery userIdIn(String... userId);
/**
* Add your domain to your query.
*
* @param domain as String
* @return the query
*/
WorkbasketHistoryQuery domainIn(String... domain);
/**
* Add your workbasketKey to your query.
*
* @param workbasketKey as String
* @return the query
*/
WorkbasketHistoryQuery workbasketKeyIn(String... workbasketKey);
/**
* Add your workbasketType to your query.
*
* @param workbasketType as String
* @return the query
*/
WorkbasketHistoryQuery workbasketTypeIn(String... workbasketType);
/**
* Add your owner to your query.
*
* @param owner as String
* @return the query
*/
WorkbasketHistoryQuery ownerIn(String... owner);
/**
* Add your custom1 to your query.
*
* @param custom1 as String
* @return the query
*/
WorkbasketHistoryQuery custom1In(String... custom1);
/**
* Add your custom2 to your query.
*
* @param custom2 as String
* @return the query
*/
WorkbasketHistoryQuery custom2In(String... custom2);
/**
* Add your custom3 to your query.
*
* @param custom3 as String
* @return the query
*/
WorkbasketHistoryQuery custom3In(String... custom3);
/**
* Add your custom4 to your query.
*
* @param custom4 as String
* @return the query
*/
WorkbasketHistoryQuery custom4In(String... custom4);
/**
* Add your orgLevel1 to your query.
*
* @param orgLevel1 as String
* @return the query
*/
WorkbasketHistoryQuery orgLevel1In(String... orgLevel1);
/**
* Add your orgLevel1 to your query.
*
* @param orgLevel2 as String
* @return the query
*/
WorkbasketHistoryQuery orgLevel2In(String... orgLevel2);
/**
* Add your orgLevel1 to your query.
*
* @param orgLevel3 as String
* @return the query
*/
WorkbasketHistoryQuery orgLevel3In(String... orgLevel3);
/**
* Add your orgLevel1 to your query.
*
* @param orgLevel4 as String
* @return the query
*/
WorkbasketHistoryQuery orgLevel4In(String... orgLevel4);
/**
* Add your workbasketId to your query. It will be compared in SQL with an LIKE. If you use a
* wildcard like % then it will be transmitted to the database.
*
* @param workbasketId as String
* @return the query
*/
WorkbasketHistoryQuery workbasketIdLike(String... workbasketId);
/**
* Add your eventType to your query. It will be compared in SQL with an LIKE. If you use a
* wildcard like % then it will be transmitted to the database.
*
* @param eventType as String
* @return the query
*/
WorkbasketHistoryQuery eventTypeLike(String... eventType);
/**
* Add your userId to your query. It will be compared in SQL with an LIKE. If you use a wildcard
* like % then it will be transmitted to the database.
*
* @param userId as String
* @return the query
*/
WorkbasketHistoryQuery userIdLike(String... userId);
/**
* Add your domain to your query. It will be compared in SQL with an LIKE. If you use a wildcard
* like % then it will be transmitted to the database.
*
* @param domain as String
* @return the query
*/
WorkbasketHistoryQuery domainLike(String... domain);
/**
* Add your workbasketKey to your query. It will be compared in SQL with an LIKE. If you use a
* wildcard like % then it will be transmitted to the database.
*
* @param workbasketKey as String
* @return the query
*/
WorkbasketHistoryQuery workbasketKeyLike(String... workbasketKey);
/**
* Add your workbasketType to your query. It will be compared in SQL with an LIKE. If you use a
* wildcard like % then it will be transmitted to the database.
*
* @param workbasketType as String
* @return the query
*/
WorkbasketHistoryQuery workbasketTypeLike(String... workbasketType);
/**
* Add your owner to your query. It will be compared in SQL with an LIKE. If you use a wildcard
* like % then it will be transmitted to the database.
*
* @param owner as String
* @return the query
*/
WorkbasketHistoryQuery ownerLike(String... owner);
/**
* Add your custom1 to your query. It will be compared in SQL with an LIKE. If you use a wildcard
* like % then it will be transmitted to the database.
*
* @param custom1 as String
* @return the query
*/
WorkbasketHistoryQuery custom1Like(String... custom1);
/**
* Add your custom2 to your query. It will be compared in SQL with an LIKE. If you use a wildcard
* like % then it will be transmitted to the database.
*
* @param custom2 as String
* @return the query
*/
WorkbasketHistoryQuery custom2Like(String... custom2);
/**
* Add your custom3 to your query. It will be compared in SQL with an LIKE. If you use a wildcard
* like % then it will be transmitted to the database.
*
* @param custom3 as String
* @return the query
*/
WorkbasketHistoryQuery custom3Like(String... custom3);
/**
* Add your custom4 to your query. It will be compared in SQL with an LIKE. If you use a wildcard
* like % then it will be transmitted to the database.
*
* @param custom4 as String
* @return the query
*/
WorkbasketHistoryQuery custom4Like(String... custom4);
/**
* Add your orgLevel1 to your query. It will be compared in SQL with an LIKE. If you use a
* wildcard like % then it will be transmitted to the database.
*
* @param orgLevel1 as String
* @return the query
*/
WorkbasketHistoryQuery orgLevel1Like(String... orgLevel1);
/**
* Add your orgLevel2 to your query. It will be compared in SQL with an LIKE. If you use a
* wildcard like % then it will be transmitted to the database.
*
* @param orgLevel2 as String
* @return the query
*/
WorkbasketHistoryQuery orgLevel2Like(String... orgLevel2);
/**
* Add your orgLevel3 to your query. It will be compared in SQL with an LIKE. If you use a
* wildcard like % then it will be transmitted to the database.
*
* @param orgLevel3 as String
* @return the query
*/
WorkbasketHistoryQuery orgLevel3Like(String... orgLevel3);
/**
* Add your orgLevel4 to your query. It will be compared in SQL with an LIKE. If you use a
* wildcard like % then it will be transmitted to the database.
*
* @param orgLevel4 as String
* @return the query
*/
WorkbasketHistoryQuery orgLevel4Like(String... orgLevel4);
/**
* Sort the query result by workbasketId.
*
* @param sortDirection Determines whether the result is sorted in ascending or descending order.
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
WorkbasketHistoryQuery orderByWorkbasketId(SortDirection sortDirection);
/**
* Sort the query result by eventType.
*
* @param sortDirection Determines whether the result is sorted in ascending or descending order.
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
WorkbasketHistoryQuery orderByEventType(SortDirection sortDirection);
/**
* Sort the query result by created.
*
* @param sortDirection Determines whether the result is sorted in ascending or descending order.
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
WorkbasketHistoryQuery orderByCreated(SortDirection sortDirection);
/**
* Sort the query result by userId.
*
* @param sortDirection Determines whether the result is sorted in ascending or descending order.
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
WorkbasketHistoryQuery orderByUserId(SortDirection sortDirection);
/**
* Sort the query result by Domain.
*
* @param sortDirection Determines whether the result is sorted in ascending or descending order.
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
WorkbasketHistoryQuery orderByDomain(SortDirection sortDirection);
/**
* Sort the query result by WorkbasketKey.
*
* @param sortDirection Determines whether the result is sorted in ascending or descending order.
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
WorkbasketHistoryQuery orderByWorkbasketKey(SortDirection sortDirection);
/**
* Sort the query result by WorkbasketType.
*
* @param sortDirection Determines whether the result is sorted in ascending or descending order.
* If sortDirection is null, the result is sorted in ascending order
* @return the query
*/
WorkbasketHistoryQuery orderByWorkbasketType(SortDirection sortDirection);
/**
* Sort the query result by a custom attribute.
*
* @param num the number of the custom attribute as String (eg "4")
* @param sortDirection Determines whether the result is sorted in ascending or descending order.
* If sortDirection is null, the result is sorted in ascending order
* @return the query
* @throws InvalidArgumentException when the number of the custom is incorrect.
*/
WorkbasketHistoryQuery orderByCustomAttribute(int num, SortDirection sortDirection)
throws InvalidArgumentException;
/**
* Sort the query result by an orgLevel .
*
* @param num the number of the orgLevel as String (eg "4")
* @param sortDirection Determines whether the result is sorted in ascending or descending order.
* If sortDirection is null, the result is sorted in ascending order
* @return the query
* @throws InvalidArgumentException when the number of the orgLevel is incorrect.
*/
WorkbasketHistoryQuery orderByOrgLevel(int num, SortDirection sortDirection)
throws InvalidArgumentException;
}

35
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/workbasket/WorkbasketHistoryQueryColumnName.java Normal file
View File

@ -0,0 +1,35 @@
package pro.taskana.simplehistory.impl.workbasket;
import pro.taskana.common.api.QueryColumnName;
/** Enum containing the column names for {@link WorkbasketHistoryQueryMapper}. */
public enum WorkbasketHistoryQueryColumnName implements QueryColumnName {
ID("id"),
WORKBASKET_ID("workbasket_id"),
EVENT_TYPE("event_type"),
CREATED("created"),
USER_ID("user_id"),
DOMAIN("domain"),
WORKBASKET_KEY("workbasket_key"),
WORKBASKET_TYPE("workbasket_type"),
OWNER("owner"),
CUSTOM_1("custom_1"),
CUSTOM_2("custom_2"),
CUSTOM_3("custom_3"),
CUSTOM_4("custom_4"),
ORGLEVEL_1("orgLevel_1"),
ORGLEVEL_2("orgLevel_2"),
ORGLEVEL_3("orgLevel_3"),
ORGLEVEL_4("orgLevel_4");
private String name;
WorkbasketHistoryQueryColumnName(String name) {
this.name = name;
}
@Override
public String toString() {
return name;
}
}

163
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/workbasket/WorkbasketHistoryQueryMapper.java Normal file
View File

@ -0,0 +1,163 @@
package pro.taskana.simplehistory.impl.workbasket;
import java.util.List;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import pro.taskana.simplehistory.impl.WorkbasketHistoryQueryImpl;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
/** This class is the mybatis mapping of WorkbasketHistoryQueries. */
@SuppressWarnings("checkstyle:LineLength")
public interface WorkbasketHistoryQueryMapper {
@Select(
"<script>"
+ "SELECT ID, WORKBASKET_ID, EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, WORKBASKET_TYPE,"
+ "OWNER, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, ORGLEVEL_1, ORGLEVEL_2, ORGLEVEL_3, ORGLEVEL_4 "
+ "FROM WORKBASKET_HISTORY_EVENT"
+ "<where>"
// IN-Queries
+ "<if test='idIn != null'>AND UPPER(ID) IN (<foreach item='item' collection='idIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='workbasketIdIn != null'>AND UPPER(WORKBASKET_ID) IN (<foreach item='item' collection='workbasketIdIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='eventTypeIn != null'>AND UPPER(EVENT_TYPE) IN (<foreach item='item' collection='eventTypeIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='createdIn !=null'> AND ( <foreach item='item' collection='createdIn' separator=',' > ( <if test='item.begin!=null'> CREATED &gt;= #{item.begin} </if> <if test='item.begin!=null and item.end!=null'> AND </if><if test='item.end!=null'> CREATED &lt;=#{item.end} </if>)</foreach>)</if> "
+ "<if test='userIdIn != null'>AND UPPER(USER_ID) IN (<foreach item='item' collection='userIdIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='domainIn != null'>AND UPPER(DOMAIN) IN (<foreach item='item' collection='domainIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='workbasketKeyIn != null'>AND UPPER(WORKBASKET_KEY) IN (<foreach item='item' collection='workbasketKeyIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='workbasketTypeIn != null'>AND UPPER(WORKBASKET_TYPE) IN (<foreach item='item' collection='workbasketTypeIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='ownerIn != null'>AND UPPER(OWNER) IN (<foreach item='item' collection='ownerIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='custom1In != null'>AND UPPER(CUSTOM_1) IN (<foreach item='item' collection='custom1In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='custom2In != null'>AND UPPER(CUSTOM_2) IN (<foreach item='item' collection='custom2In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='custom3In != null'>AND UPPER(CUSTOM_3) IN (<foreach item='item' collection='custom3In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='custom4In != null'>AND UPPER(CUSTOM_4) IN (<foreach item='item' collection='custom4In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='orgLevel1In != null'>AND UPPER(ORGLEVEL_1) IN (<foreach item='item' collection='orgLevel1In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='orgLevel2In != null'>AND UPPER(ORGLEVEL_2) IN (<foreach item='item' collection='orgLevel2In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='orgLevel3In != null'>AND UPPER(ORGLEVEL_3) IN (<foreach item='item' collection='orgLevel3In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='orgLevel4In != null'>AND UPPER(ORGLEVEL_4) IN (<foreach item='item' collection='orgLevel4In' separator=',' >#{item}</foreach>)</if> "
// LIKE-Queries
+ "<if test='workbasketIdLike != null'>AND (<foreach item='item' collection='workbasketIdLike' separator=' OR ' >UPPER(WORKBASKET_ID) LIKE #{item}</foreach>)</if> "
+ "<if test='eventTypeLike != null'>AND (<foreach item='item' collection='eventTypeLike' separator=' OR ' >UPPER(EVENT_TYPE) LIKE #{item}</foreach>)</if> "
+ "<if test='userIdLike != null'>AND (<foreach item='item' collection='userIdLike' separator=' OR ' >UPPER(USER_ID) LIKE #{item}</foreach>)</if> "
+ "<if test='domainLike != null'>AND (<foreach item='item' collection='domainLike' separator=' OR ' >UPPER(DOMAIN) LIKE #{item}</foreach>)</if> "
+ "<if test='workbasketKeyLike != null'>AND (<foreach item='item' collection='workbasketKeyLike' separator=' OR ' >UPPER(WORKBASKET_KEY) LIKE #{item}</foreach>)</if> "
+ "<if test='workbasketTypeLike != null'>AND (<foreach item='item' collection='workbasketTypeLike' separator=' OR ' >UPPER(WORKBASKET_TYPE) LIKE #{item}</foreach>)</if> "
+ "<if test='ownerLike != null'>AND (<foreach item='item' collection='ownerLike' separator=' OR ' >UPPER(OWNER) LIKE #{item}</foreach>)</if> "
+ "<if test='custom1Like != null'>AND (<foreach item='item' collection='custom1Like' separator=' OR ' >UPPER(CUSTOM_1) LIKE #{item}</foreach>)</if> "
+ "<if test='custom2Like != null'>AND (<foreach item='item' collection='custom2Like' separator=' OR ' >UPPER(CUSTOM_2) LIKE #{item}</foreach>)</if> "
+ "<if test='custom3Like != null'>AND (<foreach item='item' collection='custom3Like' separator=' OR ' >UPPER(CUSTOM_3) LIKE #{item}</foreach>)</if> "
+ "<if test='custom4Like != null'>AND (<foreach item='item' collection='custom4Like' separator=' OR ' >UPPER(CUSTOM_4) LIKE #{item}</foreach>)</if> "
+ "<if test='orgLevel1Like != null'>AND (<foreach item='item' collection='orgLevel1Like' separator=' OR ' >UPPER(ORGLEVEL_1) LIKE #{item}</foreach>)</if> "
+ "<if test='orgLevel2Like != null'>AND (<foreach item='item' collection='orgLevel2Like' separator=' OR ' >UPPER(ORGLEVEL_2) LIKE #{item}</foreach>)</if> "
+ "<if test='orgLevel3Like != null'>AND (<foreach item='item' collection='orgLevel3Like' separator=' OR ' >UPPER(ORGLEVEL_3) LIKE #{item}</foreach>)</if> "
+ "<if test='orgLevel4Like != null'>AND (<foreach item='item' collection='orgLevel4Like' separator=' OR ' >UPPER(ORGLEVEL_4) LIKE #{item}</foreach>)</if> "
+ "</where>"
+ "<if test='!orderBy.isEmpty()'>ORDER BY <foreach item='item' collection='orderBy' separator=',' >${item}</foreach></if> "
+ "</script>")
@Results(
value = {
@Result(property = "id", column = "ID"),
@Result(property = "workbasketId", column = "WORKBASKET_ID"),
@Result(property = "eventType", column = "EVENT_TYPE"),
@Result(property = "created", column = "CREATED"),
@Result(property = "userId", column = "USER_ID"),
@Result(property = "domain", column = "DOMAIN"),
@Result(property = "workbasketKey", column = "WORKBASKET_KEY"),
@Result(property = "workbasketType", column = "WORKBASKET_TYPE"),
@Result(property = "owner", column = "OWNER"),
@Result(property = "custom1", column = "CUSTOM_1"),
@Result(property = "custom2", column = "CUSTOM_2"),
@Result(property = "custom3", column = "CUSTOM_3"),
@Result(property = "custom4", column = "CUSTOM_4"),
@Result(property = "orgLevel1", column = "ORGLEVEL_1"),
@Result(property = "orgLevel2", column = "ORGLEVEL_2"),
@Result(property = "orgLevel3", column = "ORGLEVEL_3"),
@Result(property = "orgLevel4", column = "ORGLEVEL_4")
})
List<WorkbasketHistoryEvent> queryHistoryEvents(WorkbasketHistoryQueryImpl historyEventQuery);
@Select(
"<script>"
+ "SELECT COUNT(ID) "
+ "FROM WORKBASKET_HISTORY_EVENT"
+ "<where>"
+ "<if test='idIn != null'>AND UPPER(ID) IN (<foreach item='item' collection='idIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='workbasketIdIn != null'>AND UPPER(WORKBASKET_ID) IN (<foreach item='item' collection='workbasketIdIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='eventTypeIn != null'>AND UPPER(EVENT_TYPE) IN (<foreach item='item' collection='eventTypeIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='createdIn !=null'> AND ( <foreach item='item' collection='createdIn' separator=',' > ( <if test='item.begin!=null'> CREATED &gt;= #{item.begin} </if> <if test='item.begin!=null and item.end!=null'> AND </if><if test='item.end!=null'> CREATED &lt;=#{item.end} </if>)</foreach>)</if> "
+ "<if test='userIdIn != null'>AND UPPER(USER_ID) IN (<foreach item='item' collection='userIdIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='domainIn != null'>AND UPPER(DOMAIN) IN (<foreach item='item' collection='domainIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='workbasketKeyIn != null'>AND UPPER(WORKBASKET_KEY) IN (<foreach item='item' collection='workbasketKeyIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='workbasketTypeIn != null'>AND UPPER(WORKBASKET_TYPE) IN (<foreach item='item' collection='workbasketTypeIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='ownerIn != null'>AND UPPER(OWNER) IN (<foreach item='item' collection='ownerIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='custom1In != null'>AND UPPER(CUSTOM_1) IN (<foreach item='item' collection='custom1In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='custom2In != null'>AND UPPER(CUSTOM_2) IN (<foreach item='item' collection='custom2In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='custom3In != null'>AND UPPER(CUSTOM_3) IN (<foreach item='item' collection='custom3In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='custom4In != null'>AND UPPER(CUSTOM_4) IN (<foreach item='item' collection='custom4In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='orgLevel1In != null'>AND UPPER(ORGLEVEL_1) IN (<foreach item='item' collection='orgLevel1In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='orgLevel2In != null'>AND UPPER(ORGLEVEL_2) IN (<foreach item='item' collection='orgLevel2In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='orgLevel3In != null'>AND UPPER(ORGLEVEL_3) IN (<foreach item='item' collection='orgLevel3In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='orgLevel4In != null'>AND UPPER(ORGLEVEL_4) IN (<foreach item='item' collection='orgLevel4In' separator=',' >#{item}</foreach>)</if> "
// LIKE-Queries
+ "<if test='workbasketIdLike != null'>AND (<foreach item='item' collection='workbasketIdLike' separator=' OR ' >UPPER(WORKBASKET_ID) LIKE #{item}</foreach>)</if> "
+ "<if test='eventTypeLike != null'>AND (<foreach item='item' collection='eventTypeLike' separator=' OR ' >UPPER(EVENT_TYPE) LIKE #{item}</foreach>)</if> "
+ "<if test='userIdLike != null'>AND (<foreach item='item' collection='userIdLike' separator=' OR ' >UPPER(USER_ID) LIKE #{item}</foreach>)</if> "
+ "<if test='domainLike != null'>AND (<foreach item='item' collection='domainLike' separator=' OR ' >UPPER(DOMAIN) LIKE #{item}</foreach>)</if> "
+ "<if test='workbasketKeyLike != null'>AND (<foreach item='item' collection='workbasketKeyLike' separator=' OR ' >UPPER(WORKBASKET_KEY) LIKE #{item}</foreach>)</if> "
+ "<if test='workbasketTypeLike != null'>AND (<foreach item='item' collection='workbasketTypeLike' separator=' OR ' >UPPER(WORKBASKET_TYPE) LIKE #{item}</foreach>)</if> "
+ "<if test='ownerLike != null'>AND (<foreach item='item' collection='ownerLike' separator=' OR ' >UPPER(OWNER) LIKE #{item}</foreach>)</if> "
+ "<if test='custom1Like != null'>AND (<foreach item='item' collection='custom1Like' separator=' OR ' >UPPER(CUSTOM_1) LIKE #{item}</foreach>)</if> "
+ "<if test='custom2Like != null'>AND (<foreach item='item' collection='custom2Like' separator=' OR ' >UPPER(CUSTOM_2) LIKE #{item}</foreach>)</if> "
+ "<if test='custom3Like != null'>AND (<foreach item='item' collection='custom3Like' separator=' OR ' >UPPER(CUSTOM_3) LIKE #{item}</foreach>)</if> "
+ "<if test='custom4Like != null'>AND (<foreach item='item' collection='custom4Like' separator=' OR ' >UPPER(CUSTOM_4) LIKE #{item}</foreach>)</if> "
+ "<if test='orgLevel1Like != null'>AND (<foreach item='item' collection='orgLevel1Like' separator=' OR ' >UPPER(ORGLEVEL_1) LIKE #{item}</foreach>)</if> "
+ "<if test='orgLevel2Like != null'>AND (<foreach item='item' collection='orgLevel2Like' separator=' OR ' >UPPER(ORGLEVEL_2) LIKE #{item}</foreach>)</if> "
+ "<if test='orgLevel3Like != null'>AND (<foreach item='item' collection='orgLevel3Like' separator=' OR ' >UPPER(ORGLEVEL_3) LIKE #{item}</foreach>)</if> "
+ "<if test='orgLevel4Like != null'>AND (<foreach item='item' collection='orgLevel4Like' separator=' OR ' >UPPER(ORGLEVEL_4) LIKE #{item}</foreach>)</if> "
+ "</where>"
+ "</script>")
long countHistoryEvents(WorkbasketHistoryQueryImpl historyEventQuery);
@Select(
"<script>SELECT DISTINCT ${columnName} "
+ "FROM WORKBASKET_HISTORY_EVENT"
+ "<where>"
+ "<if test='idIn != null'>AND UPPER(ID) IN (<foreach item='item' collection='idIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='workbasketIdIn != null'>AND UPPER(WORKBASKET_ID) IN (<foreach item='item' collection='workbasketIdIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='eventTypeIn != null'>AND UPPER(EVENT_TYPE) IN (<foreach item='item' collection='eventTypeIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='createdIn !=null'> AND ( <foreach item='item' collection='createdIn' separator=',' > ( <if test='item.begin!=null'> CREATED &gt;= #{item.begin} </if> <if test='item.begin!=null and item.end!=null'> AND </if><if test='item.end!=null'> CREATED &lt;=#{item.end} </if>)</foreach>)</if> "
+ "<if test='userIdIn != null'>AND UPPER(USER_ID) IN (<foreach item='item' collection='userIdIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='domainIn != null'>AND UPPER(DOMAIN) IN (<foreach item='item' collection='domainIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='workbasketKeyIn != null'>AND UPPER(WORKBASKET_KEY) IN (<foreach item='item' collection='workbasketKeyIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='workbasketTypeIn != null'>AND UPPER(WORKBASKET_TYPE) IN (<foreach item='item' collection='workbasketTypeIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='ownerIn != null'>AND UPPER(OWNER) IN (<foreach item='item' collection='ownerIn' separator=',' >#{item}</foreach>)</if> "
+ "<if test='custom1In != null'>AND UPPER(CUSTOM_1) IN (<foreach item='item' collection='custom1In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='custom2In != null'>AND UPPER(CUSTOM_2) IN (<foreach item='item' collection='custom2In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='custom3In != null'>AND UPPER(CUSTOM_3) IN (<foreach item='item' collection='custom3In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='custom4In != null'>AND UPPER(CUSTOM_4) IN (<foreach item='item' collection='custom4In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='orgLevel1In != null'>AND UPPER(ORGLEVEL_1) IN (<foreach item='item' collection='orgLevel1In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='orgLevel2In != null'>AND UPPER(ORGLEVEL_2) IN (<foreach item='item' collection='orgLevel2In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='orgLevel3In != null'>AND UPPER(ORGLEVEL_3) IN (<foreach item='item' collection='orgLevel3In' separator=',' >#{item}</foreach>)</if> "
+ "<if test='orgLevel4In != null'>AND UPPER(ORGLEVEL_4) IN (<foreach item='item' collection='orgLevel4In' separator=',' >#{item}</foreach>)</if> "
// LIKE-Queries
+ "<if test='workbasketIdLike != null'>AND (<foreach item='item' collection='workbasketIdLike' separator=' OR ' >UPPER(WORKBASKET_ID) LIKE #{item}</foreach>)</if> "
+ "<if test='eventTypeLike != null'>AND (<foreach item='item' collection='eventTypeLike' separator=' OR ' >UPPER(EVENT_TYPE) LIKE #{item}</foreach>)</if> "
+ "<if test='userIdLike != null'>AND (<foreach item='item' collection='userIdLike' separator=' OR ' >UPPER(USER_ID) LIKE #{item}</foreach>)</if> "
+ "<if test='domainLike != null'>AND (<foreach item='item' collection='domainLike' separator=' OR ' >UPPER(DOMAIN) LIKE #{item}</foreach>)</if> "
+ "<if test='workbasketKeyLike != null'>AND (<foreach item='item' collection='workbasketKeyLike' separator=' OR ' >UPPER(WORKBASKET_KEY) LIKE #{item}</foreach>)</if> "
+ "<if test='workbasketTypeLike != null'>AND (<foreach item='item' collection='workbasketTypeLike' separator=' OR ' >UPPER(WORKBASKET_TYPE) LIKE #{item}</foreach>)</if> "
+ "<if test='ownerLike != null'>AND (<foreach item='item' collection='ownerLike' separator=' OR ' >UPPER(OWNER) LIKE #{item}</foreach>)</if> "
+ "<if test='custom1Like != null'>AND (<foreach item='item' collection='custom1Like' separator=' OR ' >UPPER(CUSTOM_1) LIKE #{item}</foreach>)</if> "
+ "<if test='custom2Like != null'>AND (<foreach item='item' collection='custom2Like' separator=' OR ' >UPPER(CUSTOM_2) LIKE #{item}</foreach>)</if> "
+ "<if test='custom3Like != null'>AND (<foreach item='item' collection='custom3Like' separator=' OR ' >UPPER(CUSTOM_3) LIKE #{item}</foreach>)</if> "
+ "<if test='custom4Like != null'>AND (<foreach item='item' collection='custom4Like' separator=' OR ' >UPPER(CUSTOM_4) LIKE #{item}</foreach>)</if> "
+ "<if test='orgLevel1Like != null'>AND (<foreach item='item' collection='orgLevel1Like' separator=' OR ' >UPPER(ORGLEVEL_1) LIKE #{item}</foreach>)</if> "
+ "<if test='orgLevel2Like != null'>AND (<foreach item='item' collection='orgLevel2Like' separator=' OR ' >UPPER(ORGLEVEL_2) LIKE #{item}</foreach>)</if> "
+ "<if test='orgLevel3Like != null'>AND (<foreach item='item' collection='orgLevel3Like' separator=' OR ' >UPPER(ORGLEVEL_3) LIKE #{item}</foreach>)</if> "
+ "<if test='orgLevel4Like != null'>AND (<foreach item='item' collection='orgLevel4Like' separator=' OR ' >UPPER(ORGLEVEL_4) LIKE #{item}</foreach>)</if> "
+ "</where>"
+ "<if test='!orderBy.isEmpty()'>ORDER BY <foreach item='item' collection='orderBy' separator=',' >${item}</foreach></if> "
+ "</script>")
List<String> queryHistoryColumnValues(WorkbasketHistoryQueryImpl historyQuery);
}

45
history/taskana-simplehistory-provider/src/test/java/acceptance/AbstractAccTest.java
View File

@ -20,10 +20,11 @@ import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.common.internal.util.IdGenerator;
import pro.taskana.sampledata.SampleDataGenerator;
import pro.taskana.simplehistory.impl.HistoryEventImpl;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.simplehistory.impl.TaskanaHistoryEngineImpl;
import pro.taskana.simplehistory.impl.mappings.HistoryQueryMapper;
import pro.taskana.simplehistory.impl.task.TaskHistoryQueryMapper;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
import pro.taskana.task.api.models.ObjectReference;
/** Set up database for tests. */
@ -55,7 +56,7 @@ public abstract class AbstractAccTest {
}
/**
* create historyEvent object.
* create taskHistoryEvent object.
*
* @param workbasketKey the workbasketKey, the task currently resides in.
* @param taskId the taskid the event belongs to.
@ -63,18 +64,19 @@ public abstract class AbstractAccTest {
* @param previousWorkbasketId the workbasketId of the previous workbasket (if applicable).
* @param userid the ID of the user that triggered the event.
* @param details the details of the changes that happened.
* @return History event object created.
* @return Task History event object created.
*/
public static HistoryEventImpl createHistoryEvent(
public static TaskHistoryEvent createTaskHistoryEvent(
String workbasketKey,
String taskId,
String type,
String previousWorkbasketId,
String userid,
String details) {
HistoryEventImpl historyEvent =
new HistoryEventImpl(
IdGenerator.generateWithPrefix(ID_PREFIX_HISTORY_EVENT), userid, details);
TaskHistoryEvent historyEvent = new TaskHistoryEvent();
historyEvent.setId(IdGenerator.generateWithPrefix(ID_PREFIX_HISTORY_EVENT));
historyEvent.setUserId(userid);
historyEvent.setDetails(details);
historyEvent.setWorkbasketKey(workbasketKey);
historyEvent.setTaskId(taskId);
historyEvent.setEventType(type);
@ -82,6 +84,29 @@ public abstract class AbstractAccTest {
return historyEvent;
}
/**
* create workbasketHistoryEvent object.
*
* @param workbasketKey the workbasketKey.
* @param type the type of the event.
* @param userid the ID of the user that triggered the event.
* @param details the details of the changes that happened.
* @return Workbasket History event object created.
*/
public static WorkbasketHistoryEvent createWorkbasketHistoryEvent(
String workbasketKey,
String type,
String userid,
String details) {
WorkbasketHistoryEvent historyEvent = new WorkbasketHistoryEvent();
historyEvent.setId(IdGenerator.generateWithPrefix(ID_PREFIX_HISTORY_EVENT));
historyEvent.setUserId(userid);
historyEvent.setDetails(details);
historyEvent.setWorkbasketKey(workbasketKey);
historyEvent.setEventType(type);
return historyEvent;
}
protected static void resetDb(String schemaName) throws Exception {
DataSource dataSource = getDataSource();
@ -135,7 +160,7 @@ public abstract class AbstractAccTest {
return historyService;
}
protected HistoryQueryMapper getHistoryQueryMapper()
protected TaskHistoryQueryMapper getHistoryQueryMapper()
throws NoSuchFieldException, IllegalAccessException {
Field sessionManagerField = TaskanaHistoryEngineImpl.class.getDeclaredField("sessionManager");
@ -143,7 +168,7 @@ public abstract class AbstractAccTest {
SqlSessionManager sqlSessionManager =
(SqlSessionManager) sessionManagerField.get(taskanaHistoryEngine);
return sqlSessionManager.getMapper(HistoryQueryMapper.class);
return sqlSessionManager.getMapper(TaskHistoryQueryMapper.class);
}
protected ObjectReference createObjectRef(

34
history/taskana-simplehistory-provider/src/test/java/acceptance/events/CreateHistoryEventOnTaskCancelClaimAccTest.java → history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskCancelClaimAccTest.java
View File

@ -1,4 +1,4 @@
package acceptance.events;
package acceptance.events.task;
import static org.assertj.core.api.Assertions.assertThat;
@ -9,10 +9,11 @@ import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.HistoryEventImpl;
import pro.taskana.simplehistory.impl.HistoryQueryImpl;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.simplehistory.impl.mappings.HistoryQueryMapper;
import pro.taskana.simplehistory.impl.TaskHistoryQueryImpl;
import pro.taskana.simplehistory.impl.task.TaskHistoryQueryMapper;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEventType;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.models.Task;
@ -29,24 +30,27 @@ class CreateHistoryEventOnTaskCancelClaimAccTest extends AbstractAccTest {
final String taskId = "TKI:000000000000000000000000000000000043";
HistoryQueryMapper historyQueryMapper = getHistoryQueryMapper();
TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
List<HistoryEventImpl> listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskId));
List<TaskHistoryEvent> events =
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
assertThat(listEvents).isEmpty();
assertThat(events).isEmpty();
assertThat(taskService.getTask(taskId).getState()).isEqualTo(TaskState.CLAIMED);
Task task = taskService.forceCancelClaim(taskId);
assertThat(task.getState()).isEqualTo(TaskState.READY);
listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskId));
events =
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
assertThat(events).hasSize(1);
String eventType = events.get(0).getEventType();
assertThat(eventType).isEqualTo(TaskHistoryEventType.TASK_CLAIM_CANCELLED.getName());
assertThat(listEvents).hasSize(1);
assertThat(historyService.getHistoryEvent(listEvents.get(0).getId()).getEventType())
.isEqualTo("TASK_CLAIM_CANCELLED");
}
}

27
history/taskana-simplehistory-provider/src/test/java/acceptance/events/CreateHistoryEventOnTaskCancellationAccTest.java → history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskCancellationAccTest.java
View File

@ -1,4 +1,4 @@
package acceptance.events;
package acceptance.events.task;
import static org.assertj.core.api.Assertions.assertThat;
@ -9,8 +9,9 @@ import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.HistoryEventImpl;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEventType;
import pro.taskana.task.api.TaskService;
@ExtendWith(JaasExtension.class)
@ -25,19 +26,20 @@ class CreateHistoryEventOnTaskCancellationAccTest extends AbstractAccTest {
final String taskId = "TKI:000000000000000000000000000000000001";
List<HistoryEventImpl> listEvents = historyService.createHistoryQuery().taskIdIn(taskId).list();
List<TaskHistoryEvent> listEvents =
historyService.createTaskHistoryQuery().taskIdIn(taskId).list();
assertThat(listEvents).isEmpty();
taskService.cancelTask(taskId);
listEvents = historyService.createHistoryQuery().taskIdIn(taskId).list();
listEvents = historyService.createTaskHistoryQuery().taskIdIn(taskId).list();
assertThat(listEvents).hasSize(1);
String eventType = historyService.getHistoryEvent(listEvents.get(0).getId()).getEventType();
String eventType = listEvents.get(0).getEventType();
assertThat(eventType).isEqualTo("TASK_CANCELLED");
assertThat(eventType).isEqualTo(TaskHistoryEventType.TASK_CANCELLED.getName());
}
@Test
@ -46,18 +48,19 @@ class CreateHistoryEventOnTaskCancellationAccTest extends AbstractAccTest {
final String taskId = "TKI:000000000000000000000000000000000003";
List<HistoryEventImpl> listEvents = historyService.createHistoryQuery().taskIdIn(taskId).list();
List<TaskHistoryEvent> events =
historyService.createTaskHistoryQuery().taskIdIn(taskId).list();
assertThat(listEvents).isEmpty();
assertThat(events).isEmpty();
taskService.cancelTask(taskId);
listEvents = historyService.createHistoryQuery().taskIdIn(taskId).list();
events = historyService.createTaskHistoryQuery().taskIdIn(taskId).list();
assertThat(listEvents).hasSize(1);
assertThat(events).hasSize(1);
String eventType = historyService.getHistoryEvent(listEvents.get(0).getId()).getEventType();
String eventType = events.get(0).getEventType();
assertThat(eventType).isEqualTo("TASK_CANCELLED");
assertThat(eventType).isEqualTo(TaskHistoryEventType.TASK_CANCELLED.getName());
}
}

31
history/taskana-simplehistory-provider/src/test/java/acceptance/events/CreateHistoryEventOnTaskClaimAccTest.java → history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskClaimAccTest.java
View File

@ -1,4 +1,4 @@
package acceptance.events;
package acceptance.events.task;
import static org.assertj.core.api.Assertions.assertThat;
@ -9,10 +9,11 @@ import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.HistoryEventImpl;
import pro.taskana.simplehistory.impl.HistoryQueryImpl;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.simplehistory.impl.mappings.HistoryQueryMapper;
import pro.taskana.simplehistory.impl.TaskHistoryQueryImpl;
import pro.taskana.simplehistory.impl.task.TaskHistoryQueryMapper;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEventType;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.models.Task;
@ -29,24 +30,24 @@ class CreateHistoryEventOnTaskClaimAccTest extends AbstractAccTest {
final String taskId = "TKI:000000000000000000000000000000000047";
HistoryQueryMapper historyQueryMapper = getHistoryQueryMapper();
TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
List<HistoryEventImpl> listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskId));
List<TaskHistoryEvent> events =
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
assertThat(listEvents).isEmpty();
assertThat(events).isEmpty();
assertThat(taskService.getTask(taskId).getState()).isEqualTo(TaskState.READY);
Task task = taskService.claim(taskId);
assertThat(task.getState()).isEqualTo(TaskState.CLAIMED);
listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskId));
events =
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
assertThat(listEvents).hasSize(1);
assertThat(historyService.getHistoryEvent(listEvents.get(0).getId()).getEventType())
.isEqualTo("TASK_CLAIMED");
String eventType = events.get(0).getEventType();
assertThat(eventType).isEqualTo(TaskHistoryEventType.TASK_CLAIMED.getName());
}
}

31
history/taskana-simplehistory-provider/src/test/java/acceptance/events/CreateHistoryEventOnTaskCompletionAccTest.java → history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskCompletionAccTest.java
View File

@ -1,4 +1,4 @@
package acceptance.events;
package acceptance.events.task;
import static org.assertj.core.api.Assertions.assertThat;
@ -9,10 +9,11 @@ import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.HistoryEventImpl;
import pro.taskana.simplehistory.impl.HistoryQueryImpl;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.simplehistory.impl.mappings.HistoryQueryMapper;
import pro.taskana.simplehistory.impl.TaskHistoryQueryImpl;
import pro.taskana.simplehistory.impl.task.TaskHistoryQueryMapper;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEventType;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.models.Task;
@ -29,24 +30,24 @@ class CreateHistoryEventOnTaskCompletionAccTest extends AbstractAccTest {
final String taskId = "TKI:000000000000000000000000000000000001";
HistoryQueryMapper historyQueryMapper = getHistoryQueryMapper();
TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
List<HistoryEventImpl> listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskId));
List<TaskHistoryEvent> events =
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
assertThat(listEvents).isEmpty();
assertThat(events).isEmpty();
assertThat(taskService.getTask(taskId).getState()).isEqualTo(TaskState.CLAIMED);
Task task = taskService.forceCompleteTask(taskId);
assertThat(task.getState()).isEqualTo(TaskState.COMPLETED);
listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskId));
events =
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
assertThat(listEvents).hasSize(1);
assertThat(historyService.getHistoryEvent(listEvents.get(0).getId()).getEventType())
.isEqualTo("TASK_COMPLETED");
String eventType = events.get(0).getEventType();
assertThat(eventType).isEqualTo(TaskHistoryEventType.TASK_COMPLETED.getName());
}
}

23
history/taskana-simplehistory-provider/src/test/java/acceptance/events/CreateHistoryEventOnTaskCreationAccTest.java → history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskCreationAccTest.java
View File

@ -1,4 +1,4 @@
package acceptance.events;
package acceptance.events.task;
import static org.assertj.core.api.Assertions.assertThat;
@ -9,10 +9,11 @@ import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.HistoryEventImpl;
import pro.taskana.simplehistory.impl.HistoryQueryImpl;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.simplehistory.impl.mappings.HistoryQueryMapper;
import pro.taskana.simplehistory.impl.TaskHistoryQueryImpl;
import pro.taskana.simplehistory.impl.task.TaskHistoryQueryMapper;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEventType;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.models.ObjectReference;
import pro.taskana.task.internal.models.TaskImpl;
@ -34,13 +35,15 @@ class CreateHistoryEventOnTaskCreationAccTest extends AbstractAccTest {
newTask.setPrimaryObjRef(objectReference);
taskService.createTask(newTask);
HistoryQueryMapper historyQueryMapper = getHistoryQueryMapper();
TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
List<HistoryEventImpl> listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(newTask.getId()));
List<TaskHistoryEvent> events =
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl)
historyService.createTaskHistoryQuery().taskIdIn(newTask.getId()));
assertThat(listEvents).hasSize(1);
assertThat(listEvents.get(0).getEventType()).isEqualTo("TASK_CREATED");
String eventType = events.get(0).getEventType();
assertThat(eventType).isEqualTo(TaskHistoryEventType.TASK_CREATED.getName());
}
}

31
history/taskana-simplehistory-provider/src/test/java/acceptance/events/CreateHistoryEventOnTaskTerminationAccTest.java → history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskTerminationAccTest.java
View File

@ -1,4 +1,4 @@
package acceptance.events;
package acceptance.events.task;
import static org.assertj.core.api.Assertions.assertThat;
@ -9,8 +9,9 @@ import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.HistoryEventImpl;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEventType;
import pro.taskana.task.api.TaskService;
@ExtendWith(JaasExtension.class)
@ -25,19 +26,20 @@ class CreateHistoryEventOnTaskTerminationAccTest extends AbstractAccTest {
final String taskId = "TKI:000000000000000000000000000000000001";
List<HistoryEventImpl> listEvents = historyService.createHistoryQuery().taskIdIn(taskId).list();
List<TaskHistoryEvent> events =
historyService.createTaskHistoryQuery().taskIdIn(taskId).list();
assertThat(listEvents).isEmpty();
assertThat(events).isEmpty();
taskService.terminateTask(taskId);
listEvents = historyService.createHistoryQuery().taskIdIn(taskId).list();
events = historyService.createTaskHistoryQuery().taskIdIn(taskId).list();
assertThat(listEvents).hasSize(1);
assertThat(events).hasSize(1);
String eventType = historyService.getHistoryEvent(listEvents.get(0).getId()).getEventType();
String eventType = events.get(0).getEventType();
assertThat(eventType).isEqualTo("TASK_TERMINATED");
assertThat(eventType).isEqualTo(TaskHistoryEventType.TASK_TERMINATED.getName());
}
@Test
@ -46,18 +48,19 @@ class CreateHistoryEventOnTaskTerminationAccTest extends AbstractAccTest {
final String taskId = "TKI:000000000000000000000000000000000003";
List<HistoryEventImpl> listEvents = historyService.createHistoryQuery().taskIdIn(taskId).list();
List<TaskHistoryEvent> events =
historyService.createTaskHistoryQuery().taskIdIn(taskId).list();
assertThat(listEvents).isEmpty();
assertThat(events).isEmpty();
taskService.terminateTask(taskId);
listEvents = historyService.createHistoryQuery().taskIdIn(taskId).list();
events = historyService.createTaskHistoryQuery().taskIdIn(taskId).list();
assertThat(listEvents).hasSize(1);
assertThat(events).hasSize(1);
String eventType = historyService.getHistoryEvent(listEvents.get(0).getId()).getEventType();
String eventType = events.get(0).getEventType();
assertThat(eventType).isEqualTo("TASK_TERMINATED");
assertThat(eventType).isEqualTo(TaskHistoryEventType.TASK_TERMINATED.getName());
}
}

33
history/taskana-simplehistory-provider/src/test/java/acceptance/events/CreateHistoryEventOnTaskTransferAccTest.java → history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskTransferAccTest.java
View File

@ -1,4 +1,4 @@
package acceptance.events;
package acceptance.events.task;
import static org.assertj.core.api.Assertions.assertThat;
@ -9,10 +9,11 @@ import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.HistoryEventImpl;
import pro.taskana.simplehistory.impl.HistoryQueryImpl;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.simplehistory.impl.mappings.HistoryQueryMapper;
import pro.taskana.simplehistory.impl.TaskHistoryQueryImpl;
import pro.taskana.simplehistory.impl.task.TaskHistoryQueryMapper;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEventType;
import pro.taskana.task.api.TaskService;
@ExtendWith(JaasExtension.class)
@ -27,22 +28,24 @@ class CreateHistoryEventOnTaskTransferAccTest extends AbstractAccTest {
final String taskId = "TKI:000000000000000000000000000000000003";
HistoryQueryMapper historyQueryMapper = getHistoryQueryMapper();
TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
List<HistoryEventImpl> listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskId));
List<TaskHistoryEvent> events =
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
assertThat(listEvents).isEmpty();
assertThat(events).isEmpty();
taskService.transfer(taskId, "WBI:100000000000000000000000000000000006");
listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskId));
events =
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
assertThat(listEvents).hasSize(1);
assertThat(historyService.getHistoryEvent(listEvents.get(0).getId()).getEventType())
.isEqualTo("TASK_TRANSFERRED");
assertThat(events).hasSize(1);
String eventType = events.get(0).getEventType();
assertThat(eventType).isEqualTo(TaskHistoryEventType.TASK_TRANSFERRED.getName());
}
}

34
history/taskana-simplehistory-provider/src/test/java/acceptance/events/CreateHistoryEventOnTaskUpdateAccTest.java → history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskUpdateAccTest.java
View File

@ -1,4 +1,4 @@
package acceptance.events;
package acceptance.events.task;
import static org.assertj.core.api.Assertions.assertThat;
@ -9,10 +9,11 @@ import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.HistoryEventImpl;
import pro.taskana.simplehistory.impl.HistoryQueryImpl;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.simplehistory.impl.mappings.HistoryQueryMapper;
import pro.taskana.simplehistory.impl.TaskHistoryQueryImpl;
import pro.taskana.simplehistory.impl.task.TaskHistoryQueryMapper;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEventType;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.models.Task;
@ -27,26 +28,27 @@ class CreateHistoryEventOnTaskUpdateAccTest extends AbstractAccTest {
void should_CreateUpdatedHistoryEvent_When_TaskIsCreated() throws Exception {
final String taskId = "TKI:000000000000000000000000000000000000";
HistoryQueryMapper historyQueryMapper = getHistoryQueryMapper();
TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
List<HistoryEventImpl> listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskId));
List<TaskHistoryEvent> events =
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
assertThat(listEvents).hasSize(2);
assertThat(events).hasSize(2);
Task task = taskService.getTask(taskId);
task.setName("someUpdatedName");
taskService.updateTask(task);
listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskId));
events =
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
assertThat(listEvents).hasSize(3);
assertThat(listEvents.get(2).getEventType()).isEqualTo("TASK_UPDATED");
assertThat(events).hasSize(3);
String eventType = events.get(0).getEventType();
assertThat(eventType).isEqualTo(TaskHistoryEventType.TASK_UPDATED.getName());
assertThat(historyService.getHistoryEvent(listEvents.get(2).getId()).getDetails())
.contains("someUpdatedName");
}
}

60
history/taskana-simplehistory-provider/src/test/java/acceptance/events/DeleteHistoryEventsOnTaskDeletionAccTest.java → history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/DeleteHistoryEventsOnTaskDeletionAccTest.java
View File

@ -1,4 +1,4 @@
package acceptance.events;
package acceptance.events.task;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
@ -12,10 +12,10 @@ import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.HistoryEventImpl;
import pro.taskana.simplehistory.impl.HistoryQueryImpl;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.simplehistory.impl.mappings.HistoryQueryMapper;
import pro.taskana.simplehistory.impl.TaskHistoryQueryImpl;
import pro.taskana.simplehistory.impl.task.TaskHistoryQueryMapper;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.exceptions.TaskNotFoundException;
@ -33,11 +33,11 @@ class DeleteHistoryEventsOnTaskDeletionAccTest extends AbstractAccTest {
final String taskid = "TKI:000000000000000000000000000000000036";
taskanaEngineConfiguration.setDeleteHistoryOnTaskDeletionEnabled(true);
HistoryQueryMapper historyQueryMapper = getHistoryQueryMapper();
TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
List<HistoryEventImpl> listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskid));
List<TaskHistoryEvent> listEvents =
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskid));
assertThat(listEvents).hasSize(2);
taskService.deleteTask(taskid);
@ -51,8 +51,8 @@ class DeleteHistoryEventsOnTaskDeletionAccTest extends AbstractAccTest {
assertThatThrownBy(getDeletedTaskCall).isInstanceOf(TaskNotFoundException.class);
listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskid));
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskid));
assertThat(listEvents).isEmpty();
}
@ -66,11 +66,12 @@ class DeleteHistoryEventsOnTaskDeletionAccTest extends AbstractAccTest {
taskanaEngineConfiguration.setDeleteHistoryOnTaskDeletionEnabled(true);
HistoryQueryMapper historyQueryMapper = getHistoryQueryMapper();
TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
List<HistoryEventImpl> listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskId_1, taskId_2));
List<TaskHistoryEvent> listEvents =
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl)
historyService.createTaskHistoryQuery().taskIdIn(taskId_1, taskId_2));
assertThat(listEvents).hasSize(3);
taskService.deleteTasks(Arrays.asList(taskId_1, taskId_2));
@ -89,8 +90,9 @@ class DeleteHistoryEventsOnTaskDeletionAccTest extends AbstractAccTest {
assertThatThrownBy(getDeletedTaskCall2).isInstanceOf(TaskNotFoundException.class);
listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskId_1, taskId_2));
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl)
historyService.createTaskHistoryQuery().taskIdIn(taskId_1, taskId_2));
assertThat(listEvents).isEmpty();
}
@ -103,11 +105,11 @@ class DeleteHistoryEventsOnTaskDeletionAccTest extends AbstractAccTest {
taskanaEngineConfiguration.setDeleteHistoryOnTaskDeletionEnabled(false);
HistoryQueryMapper historyQueryMapper = getHistoryQueryMapper();
TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
List<HistoryEventImpl> listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskId));
List<TaskHistoryEvent> listEvents =
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
assertThat(listEvents).hasSize(2);
taskService.deleteTask(taskId);
@ -121,8 +123,8 @@ class DeleteHistoryEventsOnTaskDeletionAccTest extends AbstractAccTest {
assertThatThrownBy(getDeletedTaskCall).isInstanceOf(TaskNotFoundException.class);
listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskId));
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
assertThat(listEvents).hasSize(2);
}
@ -135,11 +137,12 @@ class DeleteHistoryEventsOnTaskDeletionAccTest extends AbstractAccTest {
taskanaEngineConfiguration.setDeleteHistoryOnTaskDeletionEnabled(false);
HistoryQueryMapper historyQueryMapper = getHistoryQueryMapper();
TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
List<HistoryEventImpl> listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskId_1, taskId_2));
List<TaskHistoryEvent> listEvents =
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl)
historyService.createTaskHistoryQuery().taskIdIn(taskId_1, taskId_2));
assertThat(listEvents).hasSize(2);
taskService.deleteTasks(Arrays.asList(taskId_1, taskId_2));
@ -158,8 +161,9 @@ class DeleteHistoryEventsOnTaskDeletionAccTest extends AbstractAccTest {
assertThatThrownBy(getDeletedTaskCall2).isInstanceOf(TaskNotFoundException.class);
listEvents =
historyQueryMapper.queryHistoryEvent(
(HistoryQueryImpl) historyService.createHistoryQuery().taskIdIn(taskId_1, taskId_2));
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl)
historyService.createTaskHistoryQuery().taskIdIn(taskId_1, taskId_2));
assertThat(listEvents).hasSize(2);
}
}

11
history/taskana-simplehistory-provider/src/test/java/acceptance/events/GetHistoryEventAccTest.java → history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/GetTaskHistoryEventAccTest.java
View File

@ -1,13 +1,14 @@
package acceptance.events;
package acceptance.events.task;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import org.junit.jupiter.api.Test;
import pro.taskana.spi.history.api.events.TaskanaHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
class GetHistoryEventAccTest extends AbstractAccTest {
class GetTaskHistoryEventAccTest extends AbstractAccTest {
@Test
void should_ReturnSpecificTaskHistoryEventWithDetails_For_HistoryEventId() throws Exception {
@ -21,8 +22,8 @@ class GetHistoryEventAccTest extends AbstractAccTest {
+ "\"fieldName\":\"owner\","
+ "\"oldValue\":\"owner1\"}]}";
TaskanaHistoryEvent taskHistoryEvent =
getHistoryService().getHistoryEvent("HEI:000000000000000000000000000000000000");
TaskHistoryEvent taskHistoryEvent =
getHistoryService().getTaskHistoryEvent("HEI:000000000000000000000000000000000000");
assertThat(taskHistoryEvent.getBusinessProcessId()).isEqualTo("BPI:01");
assertThat(taskHistoryEvent.getUserId()).isEqualTo("admin");
assertThat(taskHistoryEvent.getEventType()).isEqualTo("TASK_UPDATED");

50
history/taskana-simplehistory-provider/src/test/java/acceptance/events/workbasket/CreateHistoryEventOnWorkbasketAccessItemCreationAccTest.java Normal file
View File

@ -0,0 +1,50 @@
package acceptance.events.workbasket;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import acceptance.security.JaasExtension;
import acceptance.security.WithAccessId;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEventType;
import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.models.WorkbasketAccessItem;
@ExtendWith(JaasExtension.class)
class CreateHistoryEventOnWorkbasketAccessItemCreationAccTest extends AbstractAccTest {
private final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
private final SimpleHistoryServiceImpl historyService = getHistoryService();
@WithAccessId(user = "admin")
@Test
void should_CreateWorkbasketAccessItemCreatedHistoryEvent_When_AccessItemIsCreated()
throws Exception {
final String workbasketId = "WBI:100000000000000000000000000000000004";
List<WorkbasketHistoryEvent> events =
historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasketId).list();
assertThat(events).isEmpty();
WorkbasketAccessItem newWorkbasketAccessItem =
workbasketService.newWorkbasketAccessItem(workbasketId, "peter");
workbasketService.createWorkbasketAccessItem(newWorkbasketAccessItem);
events = historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasketId).list();
assertThat(events).hasSize(1);
String eventType = events.get(0).getEventType();
assertThat(eventType)
.isEqualTo(WorkbasketHistoryEventType.WORKBASKET_ACCESS_ITEM_CREATED.getName());
}
}

70
history/taskana-simplehistory-provider/src/test/java/acceptance/events/workbasket/CreateHistoryEventOnWorkbasketAccessItemDeletionAccTest.java Normal file
View File

@ -0,0 +1,70 @@
package acceptance.events.workbasket;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import acceptance.security.JaasExtension;
import acceptance.security.WithAccessId;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEventType;
import pro.taskana.workbasket.api.WorkbasketService;
@ExtendWith(JaasExtension.class)
class CreateHistoryEventOnWorkbasketAccessItemDeletionAccTest extends AbstractAccTest {
private final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
private final SimpleHistoryServiceImpl historyService = getHistoryService();
@WithAccessId(user = "admin")
@Test
void should_CreateWorkbasketAccessItemDeletedHistoryEvent_When_AccessItemIsDeleted()
throws Exception {
final String workbasketId = "WBI:100000000000000000000000000000000004";
final String workbasketAccessItemId = "WAI:100000000000000000000000000000000001";
List<WorkbasketHistoryEvent> events =
historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasketId).list();
assertThat(events).isEmpty();
workbasketService.deleteWorkbasketAccessItem(workbasketAccessItemId);
events = historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasketId).list();
assertThat(events).hasSize(1);
String eventType = events.get(0).getEventType();
assertThat(eventType)
.isEqualTo(WorkbasketHistoryEventType.WORKBASKET_ACCESS_ITEM_DELETED.getName());
}
@WithAccessId(user = "admin")
@Test
void should_NotCreateWorkbasketAccessItemDeletedHistoryEvent_When_ProvidingInvalidAccessItemId()
throws Exception {
final String workbasketId = "WBI:100000000000000000000000000000000004";
final String workbasketAccessItemId = "NonExistingWorkbasketAccessItemID";
List<WorkbasketHistoryEvent> events =
historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasketId).list();
assertThat(events).isEmpty();
workbasketService.deleteWorkbasketAccessItem(workbasketAccessItemId);
events = historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasketId).list();
assertThat(events).isEmpty();
}
}

74
history/taskana-simplehistory-provider/src/test/java/acceptance/events/workbasket/CreateHistoryEventOnWorkbasketAccessItemsDeletionAccTest.java Normal file
View File

@ -0,0 +1,74 @@
package acceptance.events.workbasket;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import acceptance.security.JaasExtension;
import acceptance.security.WithAccessId;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEventType;
import pro.taskana.workbasket.api.WorkbasketService;
@ExtendWith(JaasExtension.class)
class CreateHistoryEventOnWorkbasketAccessItemsDeletionAccTest extends AbstractAccTest {
private final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
private final SimpleHistoryServiceImpl historyService = getHistoryService();
@WithAccessId(user = "admin")
@Test
void should_CreateWorkbasketAccessItemDeletedHistoryEvents_When_AccessItemsAreDeleted()
throws Exception {
final String accessId = "teamlead-1";
String[] workbasketIds =
new String[] {
"WBI:100000000000000000000000000000000001",
"WBI:100000000000000000000000000000000004",
"WBI:100000000000000000000000000000000005",
"WBI:100000000000000000000000000000000010"
};
List<WorkbasketHistoryEvent> events =
historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasketIds).list();
assertThat(events).isEmpty();
workbasketService.deleteWorkbasketAccessItemsForAccessId(accessId);
events = historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasketIds).list();
assertThat(events).hasSize(4);
assertThat(events)
.extracting(WorkbasketHistoryEvent::getEventType)
.containsOnly(WorkbasketHistoryEventType.WORKBASKET_ACCESS_ITEM_DELETED.getName());
}
@WithAccessId(user = "admin")
@Test
void should_NotCreateWorkbasketAccessItemDeletedHistoryEvents_When_ProvidingInvalidAccessId()
throws Exception {
final String workbasketId = "WBI:100000000000000000000000000000000011";
final String accessId = "NonExistingWorkbasketAccessItemID";
List<WorkbasketHistoryEvent> events =
historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasketId).list();
assertThat(events).isEmpty();
workbasketService.deleteWorkbasketAccessItemsForAccessId(accessId);
events = historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasketId).list();
assertThat(events).isEmpty();
}
}

64
history/taskana-simplehistory-provider/src/test/java/acceptance/events/workbasket/CreateHistoryEventOnWorkbasketAccessItemsSetAccTest.java Normal file
View File

@ -0,0 +1,64 @@
package acceptance.events.workbasket;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import acceptance.security.JaasExtension;
import acceptance.security.WithAccessId;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEventType;
import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.models.WorkbasketAccessItem;
@ExtendWith(JaasExtension.class)
class CreateHistoryEventOnWorkbasketAccessItemsSetAccTest extends AbstractAccTest {
private final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
private final SimpleHistoryServiceImpl historyService = getHistoryService();
@WithAccessId(user = "admin")
@Test
void should_CreateWorkbasketAccessItemsUpdatedHistoryEvent_When_AccessItemsAreSet()
throws Exception {
final String workbasketId = "WBI:100000000000000000000000000000000004";
final String accessId1 = "peter";
final String accessId2 = "claudia";
final String accessId3 = "sven";
List<WorkbasketHistoryEvent> events =
historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasketId).list();
assertThat(events).isEmpty();
List<WorkbasketAccessItem> newItems = new ArrayList<>();
WorkbasketAccessItem newWorkbasketAccessItem =
workbasketService.newWorkbasketAccessItem(workbasketId, accessId1);
WorkbasketAccessItem newWorkbasketAccessItem2 =
workbasketService.newWorkbasketAccessItem(workbasketId, accessId2);
WorkbasketAccessItem newWorkbasketAccessItem3 =
workbasketService.newWorkbasketAccessItem(workbasketId, accessId3);
newItems.add(newWorkbasketAccessItem);
newItems.add(newWorkbasketAccessItem2);
newItems.add(newWorkbasketAccessItem3);
workbasketService.setWorkbasketAccessItems(workbasketId, newItems);
events = historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasketId).list();
assertThat(events).hasSize(1);
String eventType = events.get(0).getEventType();
assertThat(eventType)
.isEqualTo(WorkbasketHistoryEventType.WORKBASKET_ACCESS_ITEMS_UPDATED.getName());
}
}

47
history/taskana-simplehistory-provider/src/test/java/acceptance/events/workbasket/CreateHistoryEventOnWorkbasketCreationAccTest.java Normal file
View File

@ -0,0 +1,47 @@
package acceptance.events.workbasket;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import acceptance.security.JaasExtension;
import acceptance.security.WithAccessId;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEventType;
import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.WorkbasketType;
import pro.taskana.workbasket.api.models.Workbasket;
@ExtendWith(JaasExtension.class)
class CreateHistoryEventOnWorkbasketCreationAccTest extends AbstractAccTest {
private final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
private final SimpleHistoryServiceImpl historyService = getHistoryService();
@WithAccessId(user = "admin")
@Test
void should_CreateWorkbasketAccessItemDeletedHistoryEvents_When_AccessItemsAreDeleted()
throws Exception {
Workbasket newWorkbasket = workbasketService.newWorkbasket("NT1234", "DOMAIN_A");
newWorkbasket.setName("Megabasket");
newWorkbasket.setType(WorkbasketType.GROUP);
newWorkbasket.setOrgLevel1("company");
newWorkbasket = workbasketService.createWorkbasket(newWorkbasket);
List<WorkbasketHistoryEvent> events =
historyService.createWorkbasketHistoryQuery().workbasketIdIn(newWorkbasket.getId()).list();
assertThat(events).hasSize(1);
String eventType = events.get(0).getEventType();
assertThat(eventType)
.isEqualTo(WorkbasketHistoryEventType.WORKBASKET_CREATED.getName());
}
}

45
history/taskana-simplehistory-provider/src/test/java/acceptance/events/workbasket/CreateHistoryEventOnWorkbasketDeletionAccTest.java Normal file
View File

@ -0,0 +1,45 @@
package acceptance.events.workbasket;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import acceptance.security.JaasExtension;
import acceptance.security.WithAccessId;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEventType;
import pro.taskana.workbasket.api.WorkbasketService;
@ExtendWith(JaasExtension.class)
class CreateHistoryEventOnWorkbasketDeletionAccTest extends AbstractAccTest {
private final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
private final SimpleHistoryServiceImpl historyService = getHistoryService();
@WithAccessId(user = "admin")
@Test
void should_CreateWorkbasketDeletedHistoryEvent_When_WorkbasketIsDeleted() throws Exception {
final String workbasketId = "WBI:100000000000000000000000000000000008";
List<WorkbasketHistoryEvent> events =
historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasketId).list();
assertThat(events).isEmpty();
workbasketService.deleteWorkbasket(workbasketId);
events = historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasketId).list();
assertThat(events).hasSize(1);
String eventType = events.get(0).getEventType();
assertThat(eventType)
.isEqualTo(WorkbasketHistoryEventType.WORKBASKET_DELETED.getName());
}
}

48
history/taskana-simplehistory-provider/src/test/java/acceptance/events/workbasket/CreateHistoryEventOnWorkbasketDistributionTargetAddedAccTest.java Normal file
View File

@ -0,0 +1,48 @@
package acceptance.events.workbasket;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import acceptance.security.JaasExtension;
import acceptance.security.WithAccessId;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEventType;
import pro.taskana.workbasket.api.WorkbasketService;
@ExtendWith(JaasExtension.class)
class CreateHistoryEventOnWorkbasketDistributionTargetAddedAccTest extends AbstractAccTest {
private final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
private final SimpleHistoryServiceImpl historyService = getHistoryService();
@WithAccessId(user = "admin")
@Test
void should_CreateWorkbasketDistributionTargetAddedHistoryEvent_When_DistributionTargetIsAdded()
throws Exception {
final String sourceWorkbasketId = "WBI:100000000000000000000000000000000004";
final String targetWorkbasketId = "WBI:100000000000000000000000000000000001";
List<WorkbasketHistoryEvent> events =
historyService.createWorkbasketHistoryQuery().workbasketIdIn(sourceWorkbasketId).list();
assertThat(events).isEmpty();
workbasketService.addDistributionTarget(sourceWorkbasketId, targetWorkbasketId);
events =
historyService.createWorkbasketHistoryQuery().workbasketIdIn(sourceWorkbasketId).list();
assertThat(events).hasSize(1);
String eventType = events.get(0).getEventType();
assertThat(eventType)
.isEqualTo(WorkbasketHistoryEventType.WORKBASKET_DISTRIBUTION_TARGET_ADDED.getName());
}
}

49
history/taskana-simplehistory-provider/src/test/java/acceptance/events/workbasket/CreateHistoryEventOnWorkbasketDistributionTargetRemovedAccTest.java Normal file
View File

@ -0,0 +1,49 @@
package acceptance.events.workbasket;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import acceptance.security.JaasExtension;
import acceptance.security.WithAccessId;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEventType;
import pro.taskana.workbasket.api.WorkbasketService;
@ExtendWith(JaasExtension.class)
class CreateHistoryEventOnWorkbasketDistributionTargetRemovedAccTest extends AbstractAccTest {
private final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
private final SimpleHistoryServiceImpl historyService = getHistoryService();
@WithAccessId(user = "admin")
@Test
void
should_CreateWorkbasketDistributionTargetRemovedHistoryEvent_When_RemovingDistributionTarget()
throws Exception {
final String sourceWorkbasketId = "WBI:100000000000000000000000000000000001";
final String targetWorkbasketId = "WBI:100000000000000000000000000000000002";
List<WorkbasketHistoryEvent> events =
historyService.createWorkbasketHistoryQuery().workbasketIdIn(sourceWorkbasketId).list();
assertThat(events).isEmpty();
workbasketService.removeDistributionTarget(sourceWorkbasketId, targetWorkbasketId);
events =
historyService.createWorkbasketHistoryQuery().workbasketIdIn(sourceWorkbasketId).list();
assertThat(events).hasSize(1);
String eventType = events.get(0).getEventType();
assertThat(eventType)
.isEqualTo(WorkbasketHistoryEventType.WORKBASKET_DISTRIBUTION_TARGET_REMOVED.getName());
}
}

54
history/taskana-simplehistory-provider/src/test/java/acceptance/events/workbasket/CreateHistoryEventOnWorkbasketDistributionTargetsSetAccTest.java Normal file
View File

@ -0,0 +1,54 @@
package acceptance.events.workbasket;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import acceptance.security.JaasExtension;
import acceptance.security.WithAccessId;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEventType;
import pro.taskana.workbasket.api.WorkbasketService;
@ExtendWith(JaasExtension.class)
class CreateHistoryEventOnWorkbasketDistributionTargetsSetAccTest extends AbstractAccTest {
private final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
private final SimpleHistoryServiceImpl historyService = getHistoryService();
@WithAccessId(user = "admin")
@Test
void
should_CreateWorkbasketDistributionTargetsUpdatedHistoryEvent_When_DistributionTargetsAreSet()
throws Exception {
final String sourceWorkbasketId = "WBI:100000000000000000000000000000000004";
List<String> targetWorkbaskets =
Arrays.asList(
"WBI:100000000000000000000000000000000002", "WBI:100000000000000000000000000000000003");
List<WorkbasketHistoryEvent> events =
historyService.createWorkbasketHistoryQuery().workbasketIdIn(sourceWorkbasketId).list();
assertThat(events).isEmpty();
workbasketService.setDistributionTargets(
"WBI:100000000000000000000000000000000004", targetWorkbaskets);
events =
historyService.createWorkbasketHistoryQuery().workbasketIdIn(sourceWorkbasketId).list();
assertThat(events).hasSize(1);
String eventType = events.get(0).getEventType();
assertThat(eventType)
.isEqualTo(WorkbasketHistoryEventType.WORKBASKET_DISTRIBUTION_TARGETS_UPDATED.getName());
}
}

46
history/taskana-simplehistory-provider/src/test/java/acceptance/events/workbasket/CreateHistoryEventOnWorkbasketMarkedForDeletionAccTest.java Normal file
View File

@ -0,0 +1,46 @@
package acceptance.events.workbasket;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import acceptance.security.JaasExtension;
import acceptance.security.WithAccessId;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEventType;
import pro.taskana.workbasket.api.WorkbasketService;
@ExtendWith(JaasExtension.class)
class CreateHistoryEventOnWorkbasketMarkedForDeletionAccTest extends AbstractAccTest {
private final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
private final SimpleHistoryServiceImpl historyService = getHistoryService();
@WithAccessId(user = "admin")
@Test
void should_CreateWorkbasketMarkedForDeletionHistoryEvent_When_WorkbasketIsMarkedForDeletion()
throws Exception {
final String workbasketId = "WBI:100000000000000000000000000000000004";
List<WorkbasketHistoryEvent> events =
historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasketId).list();
assertThat(events).isEmpty();
workbasketService.deleteWorkbasket(workbasketId);
events = historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasketId).list();
assertThat(events).hasSize(1);
String eventType = events.get(0).getEventType();
assertThat(eventType)
.isEqualTo(WorkbasketHistoryEventType.WORKBASKET_MARKED_FOR_DELETION.getName());
}
}

61
history/taskana-simplehistory-provider/src/test/java/acceptance/events/workbasket/CreateHistoryEventOnWorkbasketUpdateAccTest.java Normal file
View File

@ -0,0 +1,61 @@
package acceptance.events.workbasket;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import acceptance.security.JaasExtension;
import acceptance.security.WithAccessId;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEventType;
import pro.taskana.workbasket.api.WorkbasketCustomField;
import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.WorkbasketType;
import pro.taskana.workbasket.api.models.Workbasket;
@ExtendWith(JaasExtension.class)
class CreateHistoryEventOnWorkbasketUpdateAccTest extends AbstractAccTest {
private final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
private final SimpleHistoryServiceImpl historyService = getHistoryService();
@WithAccessId(user = "businessadmin")
@Test
void testUpdateWorkbasket() throws Exception {
Workbasket workbasket = workbasketService.getWorkbasket("GPK_KSC", "DOMAIN_A");
List<WorkbasketHistoryEvent> events =
historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasket.getId()).list();
assertThat(events).isEmpty();
workbasket.setName("new name");
workbasket.setDescription("new description");
workbasket.setType(WorkbasketType.TOPIC);
workbasket.setOrgLevel1("new level 1");
workbasket.setOrgLevel2("new level 2");
workbasket.setOrgLevel3("new level 3");
workbasket.setOrgLevel4("new level 4");
workbasket.setCustomAttribute(WorkbasketCustomField.CUSTOM_1, "new custom 1");
workbasket.setCustomAttribute(WorkbasketCustomField.CUSTOM_2, "new custom 2");
workbasket.setCustomAttribute(WorkbasketCustomField.CUSTOM_3, "new custom 3");
workbasket.setCustomAttribute(WorkbasketCustomField.CUSTOM_4, "new custom 4");
workbasket.setDescription("new description");
workbasketService.updateWorkbasket(workbasket);
events =
historyService.createWorkbasketHistoryQuery().workbasketIdIn(workbasket.getId()).list();
assertThat(events).hasSize(1);
String eventType = events.get(0).getEventType();
assertThat(eventType)
.isEqualTo(WorkbasketHistoryEventType.WORKBASKET_UPDATED.getName());
}
}

346
history/taskana-simplehistory-provider/src/test/java/acceptance/query/QueryHistoryAccTest.java
View File

@ -1,346 +0,0 @@
package acceptance.query;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.time.Instant;
import java.util.Collections;
import java.util.List;
import org.junit.jupiter.api.Test;
import pro.taskana.common.api.BaseQuery.SortDirection;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.simplehistory.impl.HistoryEventImpl;
import pro.taskana.simplehistory.query.HistoryQuery;
import pro.taskana.simplehistory.query.HistoryQueryColumnName;
import pro.taskana.spi.history.api.events.TaskHistoryCustomField;
import pro.taskana.spi.history.api.events.TaskanaHistoryEvent;
/** Test for History queries. */
class QueryHistoryAccTest extends AbstractAccTest {
@Test
void should_ConfirmEquality_When_UsingListValuesAscendingAndDescending() {
List<String> defaultList =
getHistoryService().createHistoryQuery().listValues(HistoryQueryColumnName.CREATED, null);
List<String> ascendingList =
getHistoryService()
.createHistoryQuery()
.listValues(HistoryQueryColumnName.CREATED, SortDirection.ASCENDING);
assertThat(ascendingList).hasSize(13);
assertThat(ascendingList).isEqualTo(defaultList);
List<String> descendingList =
getHistoryService()
.createHistoryQuery()
.listValues(HistoryQueryColumnName.CREATED, SortDirection.DESCENDING);
Collections.reverse(ascendingList);
assertThat(ascendingList).isEqualTo(descendingList);
}
@Test
void should_ReturnHistoryEvents_For_ComplexQuery() {
HistoryQuery query =
getHistoryService()
.createHistoryQuery()
.businessProcessIdLike("just some string", "BPI:%")
.domainLike("%A")
.orderByCreated(SortDirection.DESCENDING);
List<HistoryEventImpl> results = query.list();
assertThat(results)
.extracting(TaskanaHistoryEvent::getUserId)
.containsOnly("admin", "peter");
results = query.orderByUserId(SortDirection.DESCENDING).list();
assertThat(results)
.extracting(TaskanaHistoryEvent::getUserId)
.containsOnly("admin", "peter");
assertThat(query.domainLike().count()).isEqualTo(13);
}
@Test
void should_ConfirmQueryListOffset_When_ProvidingOffsetAndLimit() {
List<HistoryEventImpl> result = getHistoryService().createHistoryQuery().list(1, 2);
List<HistoryEventImpl> wrongList = getHistoryService().createHistoryQuery().list();
assertThat(result).hasSize(2);
assertThat(result.get(0).getUserId()).isNotEqualTo(wrongList.get(0).getUserId());
assertThat(result.get(0).getUserId()).isEqualTo(wrongList.get(1).getUserId());
}
@Test
void should_ReturnEmptyList_When_ProvidingWrongContraints() {
List<HistoryEventImpl> result = getHistoryService().createHistoryQuery().list(1, 1000);
assertThat(result).hasSize(12);
result = getHistoryService().createHistoryQuery().list(100, 1000);
assertThat(result).isEmpty();
}
@Test
void should_ReturnSingleHistoryEvent_When_UsingSingleMethod() {
HistoryEventImpl single = getHistoryService().createHistoryQuery().userIdIn("peter").single();
assertThat(single.getEventType()).isEqualTo("TASK_CREATED");
single = getHistoryService().createHistoryQuery().eventTypeIn("TASK_CREATED", "xy").single();
assertThat(single.getUserId()).isEqualTo("peter");
}
@Test
void should_ReturnCountOfEvents_When_UsingCountMethod() {
long count = getHistoryService().createHistoryQuery().userIdIn("peter").count();
assertThat(count).isEqualTo(6);
count = getHistoryService().createHistoryQuery().count();
assertThat(count).isEqualTo(13);
count = getHistoryService().createHistoryQuery().userIdIn("klaus", "arnold", "benni").count();
assertThat(count).isZero();
}
@Test
void should_ReturnHistoryEvents_For_DifferentInAttributes() {
List<HistoryEventImpl> returnValues =
getHistoryService().createHistoryQuery().businessProcessIdIn("BPI:01", "BPI:02").list();
assertThat(returnValues).hasSize(7);
returnValues =
getHistoryService().createHistoryQuery().parentBusinessProcessIdIn("BPI:01").list();
assertThat(returnValues).hasSize(6);
returnValues =
getHistoryService()
.createHistoryQuery()
.taskIdIn("TKI:000000000000000000000000000000000000")
.list();
assertThat(returnValues).hasSize(2);
returnValues = getHistoryService().createHistoryQuery().eventTypeIn("TASK_CREATED").list();
assertThat(returnValues).hasSize(12);
TimeInterval timeInterval = new TimeInterval(Instant.now().minusSeconds(10), Instant.now());
returnValues = getHistoryService().createHistoryQuery().createdWithin(timeInterval).list();
assertThat(returnValues).isEmpty();
returnValues = getHistoryService().createHistoryQuery().userIdIn("admin").list();
assertThat(returnValues).hasSize(7);
returnValues = getHistoryService().createHistoryQuery().domainIn("DOMAIN_A").list();
assertThat(returnValues).hasSize(12);
returnValues =
getHistoryService()
.createHistoryQuery()
.workbasketKeyIn("WBI:100000000000000000000000000000000001")
.list();
assertThat(returnValues).hasSize(7);
returnValues = getHistoryService().createHistoryQuery().porCompanyIn("00").list();
assertThat(returnValues).hasSize(7);
returnValues = getHistoryService().createHistoryQuery().porSystemIn("PASystem").list();
assertThat(returnValues).hasSize(7);
returnValues = getHistoryService().createHistoryQuery().porInstanceIn("22").list();
assertThat(returnValues).hasSize(6);
returnValues = getHistoryService().createHistoryQuery().porTypeIn("VN").list();
assertThat(returnValues).isEmpty();
returnValues = getHistoryService().createHistoryQuery().porValueIn("11223344").list();
assertThat(returnValues).hasSize(7);
returnValues =
getHistoryService().createHistoryQuery().taskClassificationKeyIn("L140101").list();
assertThat(returnValues).hasSize(7);
returnValues =
getHistoryService().createHistoryQuery().taskClassificationCategoryIn("TASK").list();
assertThat(returnValues).hasSize(7);
returnValues =
getHistoryService()
.createHistoryQuery()
.attachmentClassificationKeyIn("DOCTYPE_DEFAULT")
.list();
assertThat(returnValues).hasSize(6);
returnValues =
getHistoryService()
.createHistoryQuery()
.customAttributeIn(TaskHistoryCustomField.CUSTOM_1, "custom1")
.list();
assertThat(returnValues).hasSize(13);
returnValues =
getHistoryService()
.createHistoryQuery()
.customAttributeIn(TaskHistoryCustomField.CUSTOM_2, "custom2")
.list();
assertThat(returnValues).hasSize(1);
returnValues =
getHistoryService()
.createHistoryQuery()
.customAttributeIn(TaskHistoryCustomField.CUSTOM_3, "custom3")
.list();
assertThat(returnValues).hasSize(7);
returnValues =
getHistoryService()
.createHistoryQuery()
.customAttributeIn(TaskHistoryCustomField.CUSTOM_4, "custom4")
.list();
assertThat(returnValues).hasSize(1);
returnValues = getHistoryService().createHistoryQuery().oldValueIn("old_val").list();
assertThat(returnValues).hasSize(1);
returnValues = getHistoryService().createHistoryQuery().newValueIn("new_val").list();
assertThat(returnValues).hasSize(1);
returnValues = getHistoryService().createHistoryQuery().oldValueLike("old%").list();
assertThat(returnValues).hasSize(1);
returnValues = getHistoryService().createHistoryQuery().newValueLike("new_%").list();
assertThat(returnValues).hasSize(7);
}
@Test
void should_ReturnHistoryEvents_For_DifferentLikeAttributes() {
List<HistoryEventImpl> returnValues =
getHistoryService().createHistoryQuery().businessProcessIdLike("BPI:0%").list();
assertThat(returnValues).hasSize(13);
returnValues =
getHistoryService().createHistoryQuery().parentBusinessProcessIdLike("BPI:01", " %").list();
assertThat(returnValues).hasSize(6);
returnValues =
getHistoryService().createHistoryQuery().taskIdLike("TKI:000000000000000%").list();
assertThat(returnValues).hasSize(13);
returnValues = getHistoryService().createHistoryQuery().oldValueLike("old%").list();
assertThat(returnValues).hasSize(1);
returnValues = getHistoryService().createHistoryQuery().newValueLike("new_%").list();
assertThat(returnValues).hasSize(7);
}
@Test
void should_ReturnHistoryEvents_When_ProvidingListValues() {
List<String> returnedList =
getHistoryService().createHistoryQuery().listValues(HistoryQueryColumnName.ID, null);
assertThat(returnedList).hasSize(13);
returnedList =
getHistoryService()
.createHistoryQuery()
.listValues(HistoryQueryColumnName.BUSINESS_PROCESS_ID, null);
assertThat(returnedList).hasSize(3);
returnedList =
getHistoryService()
.createHistoryQuery()
.listValues(HistoryQueryColumnName.PARENT_BUSINESS_PROCESS_ID, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService().createHistoryQuery().listValues(HistoryQueryColumnName.TASK_ID, null);
assertThat(returnedList).hasSize(7);
returnedList =
getHistoryService()
.createHistoryQuery()
.listValues(HistoryQueryColumnName.EVENT_TYPE, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService().createHistoryQuery().listValues(HistoryQueryColumnName.CREATED, null);
assertThat(returnedList).hasSize(13);
returnedList =
getHistoryService().createHistoryQuery().listValues(HistoryQueryColumnName.USER_ID, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService().createHistoryQuery().listValues(HistoryQueryColumnName.DOMAIN, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createHistoryQuery()
.listValues(HistoryQueryColumnName.WORKBASKET_KEY, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createHistoryQuery()
.listValues(HistoryQueryColumnName.POR_COMPANY, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createHistoryQuery()
.listValues(HistoryQueryColumnName.POR_SYSTEM, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createHistoryQuery()
.listValues(HistoryQueryColumnName.POR_INSTANCE, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService().createHistoryQuery().listValues(HistoryQueryColumnName.POR_TYPE, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService().createHistoryQuery().listValues(HistoryQueryColumnName.POR_VALUE, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createHistoryQuery()
.listValues(HistoryQueryColumnName.TASK_CLASSIFICATION_KEY, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createHistoryQuery()
.listValues(HistoryQueryColumnName.TASK_CLASSIFICATION_CATEGORY, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createHistoryQuery()
.listValues(HistoryQueryColumnName.ATTACHMENT_CLASSIFICATION_KEY, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService().createHistoryQuery().listValues(HistoryQueryColumnName.OLD_VALUE, null);
assertThat(returnedList).hasSize(3);
returnedList =
getHistoryService().createHistoryQuery().listValues(HistoryQueryColumnName.NEW_VALUE, null);
assertThat(returnedList).hasSize(3);
returnedList =
getHistoryService().createHistoryQuery().listValues(HistoryQueryColumnName.CUSTOM_1, null);
assertThat(returnedList).hasSize(1);
returnedList =
getHistoryService().createHistoryQuery().listValues(HistoryQueryColumnName.CUSTOM_2, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService().createHistoryQuery().listValues(HistoryQueryColumnName.CUSTOM_3, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService().createHistoryQuery().listValues(HistoryQueryColumnName.CUSTOM_4, null);
assertThat(returnedList).hasSize(2);
}
}

380
history/taskana-simplehistory-provider/src/test/java/acceptance/query/QueryTaskHistoryAccTest.java Normal file
View File

@ -0,0 +1,380 @@
package acceptance.query;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.time.Instant;
import java.util.Collections;
import java.util.List;
import org.junit.jupiter.api.Test;
import pro.taskana.common.api.BaseQuery.SortDirection;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.simplehistory.impl.task.TaskHistoryQuery;
import pro.taskana.simplehistory.impl.task.TaskHistoryQueryColumnName;
import pro.taskana.spi.history.api.events.TaskHistoryCustomField;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
/** Test for Task History queries. */
class QueryTaskHistoryAccTest extends AbstractAccTest {
public QueryTaskHistoryAccTest() {
super();
}
@Test
void should_ConfirmEquality_When_UsingListValuesAscendingAndDescending() {
List<String> defaultList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.CREATED, null);
List<String> ascendingList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.CREATED, SortDirection.ASCENDING);
assertThat(ascendingList).hasSize(13).isEqualTo(defaultList);
List<String> descendingList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.CREATED, SortDirection.DESCENDING);
Collections.reverse(ascendingList);
assertThat(ascendingList).isEqualTo(descendingList);
}
@Test
void should_ReturnHistoryEvents_For_ComplexQuery() {
TaskHistoryQuery query =
getHistoryService()
.createTaskHistoryQuery()
.businessProcessIdLike("just some string", "BPI:%")
.domainLike("%A")
.orderByCreated(SortDirection.DESCENDING);
List<TaskHistoryEvent> results = query.list();
assertThat(results).extracting(TaskHistoryEvent::getUserId).containsOnly("admin", "peter");
results = query.orderByUserId(SortDirection.DESCENDING).list();
assertThat(results).extracting(TaskHistoryEvent::getUserId).containsOnly("admin", "peter");
assertThat(query.domainLike().count()).isEqualTo(13);
}
@Test
void should_ConfirmQueryListOffset_When_ProvidingOffsetAndLimit() {
List<TaskHistoryEvent> offsetAndLimitResult =
getHistoryService().createTaskHistoryQuery().list(1, 2);
List<TaskHistoryEvent> regularResult = getHistoryService().createTaskHistoryQuery().list();
assertThat(offsetAndLimitResult).hasSize(2);
assertThat(offsetAndLimitResult.get(0).getUserId())
.isNotEqualTo(regularResult.get(0).getUserId());
assertThat(offsetAndLimitResult.get(0).getUserId()).isEqualTo(regularResult.get(1).getUserId());
}
@Test
void should_ReturnEmptyList_When_ProvidingWrongContraints() {
List<TaskHistoryEvent> result = getHistoryService().createTaskHistoryQuery().list(1, 1000);
assertThat(result).hasSize(12);
result = getHistoryService().createTaskHistoryQuery().list(100, 1000);
assertThat(result).isEmpty();
}
@Test
void should_ReturnSingleHistoryEvent_When_UsingSingleMethod() {
TaskHistoryEvent single =
getHistoryService().createTaskHistoryQuery().userIdIn("peter").single();
assertThat(single.getEventType()).isEqualTo("TASK_CREATED");
single =
getHistoryService().createTaskHistoryQuery().eventTypeIn("TASK_CREATED", "xy").single();
assertThat(single.getUserId()).isEqualTo("peter");
}
@Test
void should_ReturnCountOfEvents_When_UsingCountMethod() {
long count = getHistoryService().createTaskHistoryQuery().userIdIn("peter").count();
assertThat(count).isEqualTo(6);
count = getHistoryService().createTaskHistoryQuery().count();
assertThat(count).isEqualTo(13);
count =
getHistoryService().createTaskHistoryQuery().userIdIn("klaus", "arnold", "benni").count();
assertThat(count).isZero();
}
@Test
void should_ReturnHistoryEvents_For_DifferentInAttributes() {
List<TaskHistoryEvent> returnValues =
getHistoryService().createTaskHistoryQuery().businessProcessIdIn("BPI:01", "BPI:02").list();
assertThat(returnValues).hasSize(7);
returnValues =
getHistoryService().createTaskHistoryQuery().parentBusinessProcessIdIn("BPI:01").list();
assertThat(returnValues).hasSize(6);
returnValues =
getHistoryService()
.createTaskHistoryQuery()
.taskIdIn("TKI:000000000000000000000000000000000000")
.list();
assertThat(returnValues).hasSize(2);
returnValues = getHistoryService().createTaskHistoryQuery().eventTypeIn("TASK_CREATED").list();
assertThat(returnValues).hasSize(12);
TimeInterval timeInterval = new TimeInterval(Instant.now().minusSeconds(10), Instant.now());
returnValues = getHistoryService().createTaskHistoryQuery().createdWithin(timeInterval).list();
assertThat(returnValues).isEmpty();
returnValues = getHistoryService().createTaskHistoryQuery().userIdIn("admin").list();
assertThat(returnValues).hasSize(7);
returnValues = getHistoryService().createTaskHistoryQuery().domainIn("DOMAIN_A").list();
assertThat(returnValues).hasSize(12);
returnValues =
getHistoryService()
.createTaskHistoryQuery()
.workbasketKeyIn("WBI:100000000000000000000000000000000001")
.list();
assertThat(returnValues).hasSize(7);
returnValues = getHistoryService().createTaskHistoryQuery().porCompanyIn("00").list();
assertThat(returnValues).hasSize(7);
returnValues = getHistoryService().createTaskHistoryQuery().porSystemIn("PASystem").list();
assertThat(returnValues).hasSize(7);
returnValues = getHistoryService().createTaskHistoryQuery().porInstanceIn("22").list();
assertThat(returnValues).hasSize(6);
returnValues = getHistoryService().createTaskHistoryQuery().porTypeIn("VN").list();
assertThat(returnValues).isEmpty();
returnValues = getHistoryService().createTaskHistoryQuery().porValueIn("11223344").list();
assertThat(returnValues).hasSize(7);
returnValues =
getHistoryService().createTaskHistoryQuery().taskClassificationKeyIn("L140101").list();
assertThat(returnValues).hasSize(7);
returnValues =
getHistoryService().createTaskHistoryQuery().taskClassificationCategoryIn("TASK").list();
assertThat(returnValues).hasSize(7);
returnValues =
getHistoryService()
.createTaskHistoryQuery()
.attachmentClassificationKeyIn("DOCTYPE_DEFAULT")
.list();
assertThat(returnValues).hasSize(6);
returnValues =
getHistoryService()
.createTaskHistoryQuery()
.customAttributeIn(TaskHistoryCustomField.CUSTOM_1, "custom1")
.list();
assertThat(returnValues).hasSize(13);
returnValues =
getHistoryService()
.createTaskHistoryQuery()
.customAttributeIn(TaskHistoryCustomField.CUSTOM_2, "custom2")
.list();
assertThat(returnValues).hasSize(1);
returnValues =
getHistoryService()
.createTaskHistoryQuery()
.customAttributeIn(TaskHistoryCustomField.CUSTOM_3, "custom3")
.list();
assertThat(returnValues).hasSize(7);
returnValues =
getHistoryService()
.createTaskHistoryQuery()
.customAttributeIn(TaskHistoryCustomField.CUSTOM_4, "custom4")
.list();
assertThat(returnValues).hasSize(1);
returnValues = getHistoryService().createTaskHistoryQuery().oldValueIn("old_val").list();
assertThat(returnValues).hasSize(1);
returnValues = getHistoryService().createTaskHistoryQuery().newValueIn("new_val").list();
assertThat(returnValues).hasSize(1);
returnValues = getHistoryService().createTaskHistoryQuery().oldValueLike("old%").list();
assertThat(returnValues).hasSize(1);
returnValues = getHistoryService().createTaskHistoryQuery().newValueLike("new_%").list();
assertThat(returnValues).hasSize(7);
}
@Test
void should_ReturnHistoryEvents_For_DifferentLikeAttributes() {
List<TaskHistoryEvent> returnValues =
getHistoryService().createTaskHistoryQuery().businessProcessIdLike("BPI:0%").list();
assertThat(returnValues).hasSize(13);
returnValues =
getHistoryService()
.createTaskHistoryQuery()
.parentBusinessProcessIdLike("BPI:01", " %")
.list();
assertThat(returnValues).hasSize(6);
returnValues =
getHistoryService().createTaskHistoryQuery().taskIdLike("TKI:000000000000000%").list();
assertThat(returnValues).hasSize(13);
returnValues = getHistoryService().createTaskHistoryQuery().oldValueLike("old%").list();
assertThat(returnValues).hasSize(1);
returnValues = getHistoryService().createTaskHistoryQuery().newValueLike("new_%").list();
assertThat(returnValues).hasSize(7);
}
@Test
void should_ReturnHistoryEvents_When_ProvidingListValues() {
List<String> returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.ID, null);
assertThat(returnedList).hasSize(13);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.BUSINESS_PROCESS_ID, null);
assertThat(returnedList).hasSize(3);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.PARENT_BUSINESS_PROCESS_ID, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.TASK_ID, null);
assertThat(returnedList).hasSize(7);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.EVENT_TYPE, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.CREATED, null);
assertThat(returnedList).hasSize(13);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.USER_ID, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.DOMAIN, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.WORKBASKET_KEY, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.POR_COMPANY, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.POR_SYSTEM, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.POR_INSTANCE, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.POR_TYPE, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.POR_VALUE, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.TASK_CLASSIFICATION_KEY, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.TASK_CLASSIFICATION_CATEGORY, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.ATTACHMENT_CLASSIFICATION_KEY, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.OLD_VALUE, null);
assertThat(returnedList).hasSize(3);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.NEW_VALUE, null);
assertThat(returnedList).hasSize(3);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.CUSTOM_1, null);
assertThat(returnedList).hasSize(1);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.CUSTOM_2, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.CUSTOM_3, null);
assertThat(returnedList).hasSize(2);
returnedList =
getHistoryService()
.createTaskHistoryQuery()
.listValues(TaskHistoryQueryColumnName.CUSTOM_4, null);
assertThat(returnedList).hasSize(2);
}
}

318
history/taskana-simplehistory-provider/src/test/java/acceptance/query/QueryWorkbasketHistoryAccTest.java Normal file
View File

@ -0,0 +1,318 @@
package acceptance.query;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.time.Instant;
import java.util.Collections;
import java.util.List;
import org.junit.jupiter.api.Test;
import pro.taskana.common.api.BaseQuery.SortDirection;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.simplehistory.impl.workbasket.WorkbasketHistoryQuery;
import pro.taskana.simplehistory.impl.workbasket.WorkbasketHistoryQueryColumnName;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEventType;
/** Test for Workbasket History queries. */
class QueryWorkbasketHistoryAccTest extends AbstractAccTest {
private final SimpleHistoryServiceImpl historyService = getHistoryService();
public QueryWorkbasketHistoryAccTest() {
super();
}
@Test
void should_ConfirmEquality_When_UsingListValuesAscendingAndDescending() {
List<String> defaultList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.CREATED, null);
List<String> ascendingList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.CREATED, SortDirection.ASCENDING);
assertThat(ascendingList).hasSize(10).isEqualTo(defaultList);
List<String> descendingList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.CREATED, SortDirection.DESCENDING);
Collections.reverse(ascendingList);
assertThat(ascendingList).isEqualTo(descendingList);
}
@Test
void should_ReturnHistoryEvents_For_ComplexQuery() {
WorkbasketHistoryQuery query =
historyService
.createWorkbasketHistoryQuery()
.eventTypeIn(WorkbasketHistoryEventType.WORKBASKET_CREATED.getName())
.domainLike("%A")
.custom1In("custom1", "otherCustom1")
.orderByCreated(SortDirection.DESCENDING);
List<WorkbasketHistoryEvent> results = query.list();
assertThat(results)
.extracting(WorkbasketHistoryEvent::getUserId)
.containsOnly("claudia", "peter", "sven");
results = query.orderByUserId(SortDirection.DESCENDING).list();
assertThat(results)
.extracting(WorkbasketHistoryEvent::getUserId)
.containsOnly("claudia", "peter", "sven");
assertThat(query.count()).isEqualTo(6);
}
@Test
void should_ConfirmQueryListOffset_When_ProvidingOffsetAndLimit() {
List<WorkbasketHistoryEvent> offsetAndLimitResult =
historyService.createWorkbasketHistoryQuery().list(1, 2);
List<WorkbasketHistoryEvent> regularResult =
historyService.createWorkbasketHistoryQuery().list();
assertThat(offsetAndLimitResult).hasSize(2);
assertThat(offsetAndLimitResult.get(0).getUserId())
.isNotEqualTo(regularResult.get(0).getUserId());
assertThat(offsetAndLimitResult.get(0).getUserId()).isEqualTo(regularResult.get(1).getUserId());
}
@Test
void should_ReturnEmptyList_When_ProvidingWrongContraints() {
List<WorkbasketHistoryEvent> result =
historyService.createWorkbasketHistoryQuery().list(1, 1000);
assertThat(result).hasSize(9);
result = historyService.createWorkbasketHistoryQuery().list(100, 1000);
assertThat(result).isEmpty();
}
@Test
void should_ReturnSingleHistoryEvent_When_UsingSingleMethod() {
WorkbasketHistoryEvent single =
historyService.createWorkbasketHistoryQuery().userIdIn("peter").single();
assertThat(single.getEventType())
.isEqualTo(WorkbasketHistoryEventType.WORKBASKET_CREATED.getName());
single =
historyService
.createWorkbasketHistoryQuery()
.eventTypeIn(WorkbasketHistoryEventType.WORKBASKET_CREATED.getName(), "xy")
.single();
assertThat(single.getUserId()).isEqualTo("peter");
}
@Test
void should_ReturnCountOfEvents_When_UsingCountMethod() {
long count = historyService.createWorkbasketHistoryQuery().userIdIn("peter").count();
assertThat(count).isEqualTo(6);
count = historyService.createWorkbasketHistoryQuery().count();
assertThat(count).isEqualTo(10);
count =
historyService.createWorkbasketHistoryQuery().userIdIn("hans", "jürgen", "klaus").count();
assertThat(count).isZero();
}
@Test
void should_ReturnHistoryEvents_For_DifferentInAttributes() {
List<WorkbasketHistoryEvent> returnValues =
historyService
.createWorkbasketHistoryQuery()
.workbasketIdIn("WBI:000000000000000000000000000000000903")
.list();
assertThat(returnValues).hasSize(5);
returnValues =
historyService
.createWorkbasketHistoryQuery()
.eventTypeIn(WorkbasketHistoryEventType.WORKBASKET_CREATED.getName())
.list();
assertThat(returnValues).hasSize(6);
TimeInterval timeInterval = new TimeInterval(Instant.now().minusSeconds(10), Instant.now());
returnValues = historyService.createWorkbasketHistoryQuery().createdWithin(timeInterval).list();
assertThat(returnValues).isEmpty();
returnValues = historyService.createWorkbasketHistoryQuery().userIdIn("peter").list();
assertThat(returnValues).hasSize(6);
returnValues = historyService.createWorkbasketHistoryQuery().domainIn("DOMAIN_A").list();
assertThat(returnValues).hasSize(10);
returnValues = historyService.createWorkbasketHistoryQuery().workbasketKeyIn("soRt003").list();
assertThat(returnValues).hasSize(5);
returnValues = historyService.createWorkbasketHistoryQuery().custom1In("custom1").list();
assertThat(returnValues).hasSize(5);
returnValues = historyService.createWorkbasketHistoryQuery().custom2In("custom2").list();
assertThat(returnValues).hasSize(5);
returnValues = historyService.createWorkbasketHistoryQuery().custom3In("custom3").list();
assertThat(returnValues).hasSize(5);
returnValues = historyService.createWorkbasketHistoryQuery().custom4In("custom4").list();
assertThat(returnValues).hasSize(5);
returnValues = historyService.createWorkbasketHistoryQuery().orgLevel1In("orgLevel1").list();
assertThat(returnValues).hasSize(5);
returnValues = historyService.createWorkbasketHistoryQuery().orgLevel2In("orgLevel2").list();
assertThat(returnValues).hasSize(5);
returnValues = historyService.createWorkbasketHistoryQuery().orgLevel3In("orgLevel3").list();
assertThat(returnValues).hasSize(5);
returnValues = historyService.createWorkbasketHistoryQuery().orgLevel4In("orgLevel4").list();
assertThat(returnValues).hasSize(5);
}
@Test
void should_ReturnHistoryEvents_For_DifferentLikeAttributes() {
List<WorkbasketHistoryEvent> returnValues =
historyService
.createWorkbasketHistoryQuery()
.workbasketIdLike("WBI:000000000000000%")
.list();
assertThat(returnValues).hasSize(10);
returnValues =
historyService.createWorkbasketHistoryQuery().eventTypeLike("WORKBASKET_C%").list();
assertThat(returnValues).hasSize(6);
returnValues = historyService.createWorkbasketHistoryQuery().userIdLike("p%", "c%").list();
assertThat(returnValues).hasSize(8);
returnValues = historyService.createWorkbasketHistoryQuery().domainLike("%_A").list();
assertThat(returnValues).hasSize(10);
returnValues = historyService.createWorkbasketHistoryQuery().workbasketKeyLike("%Rt0%").list();
assertThat(returnValues).hasSize(10);
returnValues = historyService.createWorkbasketHistoryQuery().workbasketTypeLike("TOP%").list();
assertThat(returnValues).hasSize(10);
returnValues = historyService.createWorkbasketHistoryQuery().ownerLike("adm%").list();
assertThat(returnValues).hasSize(10);
returnValues = historyService.createWorkbasketHistoryQuery().custom1Like("other%").list();
assertThat(returnValues).hasSize(5);
returnValues = historyService.createWorkbasketHistoryQuery().orgLevel1Like("org%").list();
assertThat(returnValues).hasSize(5);
}
@Test
void should_ReturnHistoryEvents_When_ProvidingListValues() {
List<String> returnedList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.ID, null);
assertThat(returnedList).hasSize(10);
returnedList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.WORKBASKET_ID, null);
assertThat(returnedList).hasSize(2);
returnedList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.EVENT_TYPE, null);
assertThat(returnedList).hasSize(3);
returnedList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.CREATED, null);
assertThat(returnedList).hasSize(10);
returnedList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.USER_ID, null);
assertThat(returnedList).hasSize(3);
returnedList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.DOMAIN, null);
assertThat(returnedList).hasSize(1);
returnedList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.WORKBASKET_KEY, null);
assertThat(returnedList).hasSize(2);
returnedList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.WORKBASKET_TYPE, null);
assertThat(returnedList).hasSize(1);
returnedList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.OWNER, null);
assertThat(returnedList).hasSize(1);
returnedList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.CUSTOM_1, null);
assertThat(returnedList).hasSize(2);
returnedList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.CUSTOM_2, null);
assertThat(returnedList).hasSize(2);
returnedList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.CUSTOM_3, null);
assertThat(returnedList).hasSize(2);
returnedList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.CUSTOM_4, null);
assertThat(returnedList).hasSize(2);
returnedList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.ORGLEVEL_1, null);
assertThat(returnedList).hasSize(2);
returnedList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.ORGLEVEL_2, null);
assertThat(returnedList).hasSize(2);
returnedList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.ORGLEVEL_3, null);
assertThat(returnedList).hasSize(2);
returnedList =
historyService
.createWorkbasketHistoryQuery()
.listValues(WorkbasketHistoryQueryColumnName.ORGLEVEL_4, null);
assertThat(returnedList).hasSize(2);
}
}

6
history/taskana-simplehistory-provider/src/test/java/configuration/TaskanaEngineConfigurationTest.java
View File

@ -30,13 +30,13 @@ class TaskanaEngineConfigurationTest extends AbstractAccTest {
@Test
void testCreateTaskanaHistoryEventWithNonDefaultSchemaName() throws Exception {
resetDb("SOMECUSTOMSCHEMANAME");
long count = getHistoryService().createHistoryQuery().workbasketKeyIn("wbKey1").count();
long count = getHistoryService().createTaskHistoryQuery().workbasketKeyIn("wbKey1").count();
assertThat(count).isZero();
getHistoryService()
.create(
AbstractAccTest.createHistoryEvent(
AbstractAccTest.createTaskHistoryEvent(
"wbKey1", "taskId1", "type1", "Some comment", "wbKey2", "someUserId"));
count = getHistoryService().createHistoryQuery().workbasketKeyIn("wbKey1").count();
count = getHistoryService().createTaskHistoryQuery().workbasketKeyIn("wbKey1").count();
assertThat(count).isOne();
}
}

96
history/taskana-simplehistory-provider/src/test/java/pro/taskana/simplehistory/impl/SimpleHistoryServiceImplTest.java
View File

@ -10,6 +10,7 @@ import static org.mockito.Mockito.when;
import acceptance.AbstractAccTest;
import java.util.ArrayList;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionManager;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -20,8 +21,13 @@ import org.mockito.junit.jupiter.MockitoExtension;
import pro.taskana.TaskanaEngineConfiguration;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.simplehistory.impl.mappings.HistoryEventMapper;
import pro.taskana.simplehistory.impl.mappings.HistoryQueryMapper;
import pro.taskana.simplehistory.impl.task.TaskHistoryEventMapper;
import pro.taskana.simplehistory.impl.task.TaskHistoryQueryMapper;
import pro.taskana.simplehistory.impl.workbasket.WorkbasketHistoryEventMapper;
import pro.taskana.simplehistory.impl.workbasket.WorkbasketHistoryQueryMapper;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEventType;
/** Unit Test for SimpleHistoryServiceImplTest. */
@ExtendWith(MockitoExtension.class)
@ -29,9 +35,13 @@ class SimpleHistoryServiceImplTest {
@InjectMocks @Spy private SimpleHistoryServiceImpl cutSpy;
@Mock private HistoryEventMapper historyEventMapperMock;
@Mock private TaskHistoryEventMapper taskHistoryEventMapperMock;
@Mock private HistoryQueryMapper historyQueryMapperMock;
@Mock private TaskHistoryQueryMapper taskHistoryQueryMapperMock;
@Mock private WorkbasketHistoryEventMapper workbasketHistoryEventMapperMock;
@Mock private WorkbasketHistoryQueryMapper workbasketHistoryQueryMapperMock;
@Mock private TaskanaHistoryEngineImpl taskanaHistoryEngineMock;
@ -41,12 +51,14 @@ class SimpleHistoryServiceImplTest {
@Mock private SqlSessionManager sqlSessionManagerMock;
@Mock private SqlSession sqlSessionMock;
@Test
void testInitializeSimpleHistoryService() {
when(sqlSessionManagerMock.getMapper(HistoryEventMapper.class))
.thenReturn(historyEventMapperMock);
when(sqlSessionManagerMock.getMapper(HistoryQueryMapper.class))
.thenReturn(historyQueryMapperMock);
when(sqlSessionManagerMock.getMapper(TaskHistoryEventMapper.class))
.thenReturn(taskHistoryEventMapperMock);
when(sqlSessionManagerMock.getMapper(WorkbasketHistoryEventMapper.class))
.thenReturn(workbasketHistoryEventMapperMock);
when(taskanaHistoryEngineMock.getSqlSession()).thenReturn(sqlSessionManagerMock);
doReturn(taskanaHistoryEngineMock).when(cutSpy).getTaskanaEngine(taskanaEngineConfiguration);
doReturn(taskanaEngine).when(taskanaEngineConfiguration).buildTaskanaEngine();
@ -60,30 +72,74 @@ class SimpleHistoryServiceImplTest {
}
@Test
void testCreateEvent() throws Exception {
HistoryEventImpl expectedWb =
AbstractAccTest.createHistoryEvent(
void should_VerifyMethodInvocations_When_CreateTaskHistoryEvent() throws Exception {
TaskHistoryEvent expectedWb =
AbstractAccTest.createTaskHistoryEvent(
"wbKey1", "taskId1", "type1", "wbKey2", "someUserId", "someDetails");
cutSpy.create(expectedWb);
verify(taskanaHistoryEngineMock, times(1)).openConnection();
verify(historyEventMapperMock, times(1)).insert(expectedWb);
verify(taskHistoryEventMapperMock, times(1)).insert(expectedWb);
verify(taskanaHistoryEngineMock, times(1)).returnConnection();
assertThat(expectedWb.getCreated()).isNotNull();
}
@Test
void testQueryEvent() throws Exception {
List<HistoryEventImpl> returnList = new ArrayList<>();
returnList.add(
AbstractAccTest.createHistoryEvent(
"wbKey1", "taskId1", "type1", "wbKey2", "someUserId", "someDetails"));
when(historyQueryMapperMock.queryHistoryEvent(any())).thenReturn(returnList);
void should_VerifyMethodInvocations_When_CreateWorkbasketHisoryEvent() throws Exception {
WorkbasketHistoryEvent expectedEvent =
AbstractAccTest.createWorkbasketHistoryEvent(
"wbKey1",
WorkbasketHistoryEventType.WORKBASKET_CREATED.getName(),
"someUserId",
"someDetails");
final List<HistoryEventImpl> result = cutSpy.createHistoryQuery().taskIdIn("taskId1").list();
cutSpy.create(expectedEvent);
verify(taskanaHistoryEngineMock, times(1)).openConnection();
verify(workbasketHistoryEventMapperMock, times(1)).insert(expectedEvent);
verify(taskanaHistoryEngineMock, times(1)).returnConnection();
assertThat(expectedEvent.getCreated()).isNotNull();
}
@Test
void should_VerifyMethodInvocations_When_QueryTaskHistoryEvent() throws Exception {
List<TaskHistoryEvent> returnList = new ArrayList<>();
returnList.add(
AbstractAccTest.createTaskHistoryEvent(
"wbKey1", "taskId1", "type1", "wbKey2", "someUserId", "someDetails"));
when(taskanaHistoryEngineMock.getSqlSession()).thenReturn(sqlSessionMock);
when(sqlSessionMock.selectList(any(), any())).thenReturn(new ArrayList<>(returnList));
final List<TaskHistoryEvent> result =
cutSpy.createTaskHistoryQuery().taskIdIn("taskId1").list();
verify(taskanaHistoryEngineMock, times(1)).openConnection();
verify(historyQueryMapperMock, times(1)).queryHistoryEvent(any());
verify(taskanaHistoryEngineMock, times(1)).getSqlSession();
verify(sqlSessionMock, times(1)).selectList(any(), any());
verify(taskanaHistoryEngineMock, times(1)).returnConnection();
assertThat(result).hasSize(returnList.size());
assertThat(result.get(0).getWorkbasketKey()).isEqualTo(returnList.get(0).getWorkbasketKey());
}
@Test
void should_VerifyMethodInvocations_When_QueryWorkbasketHisoryEvent() throws Exception {
List<WorkbasketHistoryEvent> returnList = new ArrayList<>();
returnList.add(
AbstractAccTest.createWorkbasketHistoryEvent(
"wbKey1",
WorkbasketHistoryEventType.WORKBASKET_CREATED.getName(),
"someUserId",
"someDetails"));
when(taskanaHistoryEngineMock.getSqlSession()).thenReturn(sqlSessionMock);
when(sqlSessionMock.selectList(any(), any())).thenReturn(new ArrayList<>(returnList));
final List<WorkbasketHistoryEvent> result =
cutSpy.createWorkbasketHistoryQuery().workbasketKeyIn("wbKey1").list();
verify(taskanaHistoryEngineMock, times(1)).openConnection();
verify(taskanaHistoryEngineMock, times(1)).getSqlSession();
verify(sqlSessionMock, times(1)).selectList(any(), any());
verify(taskanaHistoryEngineMock, times(1)).returnConnection();
assertThat(result).hasSize(returnList.size());
assertThat(result.get(0).getWorkbasketKey()).isEqualTo(returnList.get(0).getWorkbasketKey());

38
history/taskana-simplehistory-provider/src/test/java/pro/taskana/simplehistory/impl/HistoryQueryImplTest.java → history/taskana-simplehistory-provider/src/test/java/pro/taskana/simplehistory/impl/TaskHistoryQueryImplTest.java
View File

@ -1,13 +1,15 @@
package pro.taskana.simplehistory.impl;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.validateMockitoUsage;
import static org.mockito.Mockito.when;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -16,40 +18,37 @@ import org.mockito.junit.jupiter.MockitoExtension;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.common.internal.util.IdGenerator;
import pro.taskana.simplehistory.impl.mappings.HistoryQueryMapper;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
/**
* Unit Test for SimpleHistoryServiceImplTest.
*
* @author BV
*/
/** Unit Test for SimpleHistoryServiceImplTest. */
@ExtendWith(MockitoExtension.class)
class HistoryQueryImplTest {
class TaskHistoryQueryImplTest {
private static final String ID_PREFIX_HISTORY_EVENT = "HEI";
private HistoryQueryImpl historyQueryImpl;
private TaskHistoryQueryImpl historyQueryImpl;
@Mock private TaskanaHistoryEngineImpl taskanaHistoryEngineMock;
@Mock private HistoryQueryMapper historyQueryMock;
@Mock private SqlSession sqlSessionMock;
@BeforeEach
void setup() {
historyQueryImpl = new HistoryQueryImpl(taskanaHistoryEngineMock, historyQueryMock);
historyQueryImpl = new TaskHistoryQueryImpl(taskanaHistoryEngineMock);
}
@Test
void testShouldReturnList() throws Exception {
List<HistoryEventImpl> returnList = new ArrayList<>();
void should_returnList_When_CallingListMethodOnTaskHistoryQuery() throws Exception {
List<TaskHistoryEvent> returnList = new ArrayList<>();
returnList.add(createHistoryEvent("abcd", "T22", "car", "BV", "this was important", null));
TimeInterval interval = new TimeInterval(Instant.now().minusNanos(1000), Instant.now());
doNothing().when(taskanaHistoryEngineMock).openConnection();
doNothing().when(taskanaHistoryEngineMock).returnConnection();
doReturn(returnList).when(historyQueryMock).queryHistoryEvent(historyQueryImpl);
when(taskanaHistoryEngineMock.getSqlSession()).thenReturn(sqlSessionMock);
when(sqlSessionMock.selectList(any(), any())).thenReturn(new ArrayList<>(returnList));
List<HistoryEventImpl> result =
List<TaskHistoryEvent> result =
historyQueryImpl
.taskIdIn("TKI:01")
.workbasketKeyIn(
@ -62,16 +61,17 @@ class HistoryQueryImplTest {
assertThat(result).isEqualTo(returnList);
}
private HistoryEventImpl createHistoryEvent(
private TaskHistoryEvent createHistoryEvent(
String taskId,
String workbasketKey,
String type,
String userId,
String details,
Instant created) {
HistoryEventImpl he =
new HistoryEventImpl(
IdGenerator.generateWithPrefix(ID_PREFIX_HISTORY_EVENT), userId, details);
TaskHistoryEvent he = new TaskHistoryEvent();
he.setId(IdGenerator.generateWithPrefix(ID_PREFIX_HISTORY_EVENT));
he.setUserId(userId);
he.setDetails(details);
he.setTaskId(taskId);
he.setWorkbasketKey(workbasketKey);
he.setEventType(type);

81
history/taskana-simplehistory-provider/src/test/java/pro/taskana/simplehistory/impl/WorkbasketHistoryQueryImplTest.java Normal file
View File

@ -0,0 +1,81 @@
package pro.taskana.simplehistory.impl;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.validateMockitoUsage;
import static org.mockito.Mockito.when;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.common.internal.util.IdGenerator;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEventType;
/** Unit Test for SimpleHistoryServiceImplTest. */
@ExtendWith(MockitoExtension.class)
class WorkbasketHistoryQueryImplTest {
private static final String ID_PREFIX_HISTORY_EVENT = "WHI";
@Mock private TaskanaHistoryEngineImpl taskanaHistoryEngineMock;
private WorkbasketHistoryQueryImpl historyQueryImpl;
@Mock private SqlSession sqlSessionMock;
@BeforeEach
void setup() {
historyQueryImpl = new WorkbasketHistoryQueryImpl(taskanaHistoryEngineMock);
}
@Test
void should_ReturnList_When_CallingListMethodOnWorkbasketHistoryQuery() throws Exception {
List<WorkbasketHistoryEvent> returnList = new ArrayList<>();
returnList.add(
createHistoryEvent(
"abcd",
WorkbasketHistoryEventType.WORKBASKET_CREATED.getName(),
"someUserId",
"someDetails",
null));
TimeInterval interval = new TimeInterval(Instant.now().minusNanos(1000), Instant.now());
doNothing().when(taskanaHistoryEngineMock).openConnection();
doNothing().when(taskanaHistoryEngineMock).returnConnection();
when(taskanaHistoryEngineMock.getSqlSession()).thenReturn(sqlSessionMock);
when(sqlSessionMock.selectList(any(), any())).thenReturn(new ArrayList<>(returnList));
List<WorkbasketHistoryEvent> result =
historyQueryImpl
.workbasketIdIn("WBI:01")
.workbasketKeyIn("abcd", "some_random_string")
.userIdIn("someUserId")
.createdWithin(interval)
.list();
validateMockitoUsage();
assertThat(result).isEqualTo(returnList);
}
private WorkbasketHistoryEvent createHistoryEvent(
String workbasketKey, String type, String userId, String details, Instant created) {
WorkbasketHistoryEvent he = new WorkbasketHistoryEvent();
he.setId(IdGenerator.generateWithPrefix(ID_PREFIX_HISTORY_EVENT));
he.setUserId(userId);
he.setDetails(details);
he.setWorkbasketKey(workbasketKey);
he.setEventType(type);
he.setCreated(created);
return he;
}
}

15
history/taskana-simplehistory-rest-spring/src/main/java/pro/taskana/simplehistory/rest/TaskHistoryEventController.java
View File

@ -24,15 +24,14 @@ import pro.taskana.common.api.TimeInterval;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.rest.AbstractPagingController;
import pro.taskana.common.rest.QueryHelper;
import pro.taskana.simplehistory.impl.HistoryEventImpl;
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.simplehistory.query.HistoryQuery;
import pro.taskana.simplehistory.impl.task.TaskHistoryQuery;
import pro.taskana.simplehistory.rest.assembler.TaskHistoryEventListResourceAssembler;
import pro.taskana.simplehistory.rest.assembler.TaskHistoryEventRepresentationModelAssembler;
import pro.taskana.simplehistory.rest.models.TaskHistoryEventListResource;
import pro.taskana.simplehistory.rest.models.TaskHistoryEventRepresentationModel;
import pro.taskana.spi.history.api.events.TaskHistoryCustomField;
import pro.taskana.spi.history.api.events.TaskanaHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.spi.history.api.exceptions.TaskanaHistoryEventNotFoundException;
/** Controller for all TaskHistoryEvent related endpoints. */
@ -107,12 +106,12 @@ public class TaskHistoryEventController extends AbstractPagingController {
LOGGER.debug("Entry to getTaskHistoryEvents(params= {})", params);
}
HistoryQuery query = simpleHistoryService.createHistoryQuery();
TaskHistoryQuery query = simpleHistoryService.createTaskHistoryQuery();
applySortingParams(query, params);
applyFilterParams(query, params);
PageMetadata pageMetadata = null;
List<HistoryEventImpl> historyEvents;
List<TaskHistoryEvent> historyEvents;
final String page = params.getFirst(PAGING_PAGE);
final String pageSize = params.getFirst(PAGING_PAGE_SIZE);
params.remove(PAGING_PAGE);
@ -150,7 +149,7 @@ public class TaskHistoryEventController extends AbstractPagingController {
LOGGER.debug("Entry to getTaskHistoryEvent(historyEventId= {})", historyEventId);
}
TaskanaHistoryEvent resultEvent = simpleHistoryService.getHistoryEvent(historyEventId);
TaskHistoryEvent resultEvent = simpleHistoryService.getTaskHistoryEvent(historyEventId);
TaskHistoryEventRepresentationModel taskEventResource =
taskHistoryEventRepresentationModelAssembler.toModel(resultEvent);
@ -164,7 +163,7 @@ public class TaskHistoryEventController extends AbstractPagingController {
return new ResponseEntity<>(taskEventResource, HttpStatus.OK);
}
private void applySortingParams(HistoryQuery query, MultiValueMap<String, String> params)
private void applySortingParams(TaskHistoryQuery query, MultiValueMap<String, String> params)
throws InvalidArgumentException {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Entry to applySortingParams(params= {})", params);
@ -244,7 +243,7 @@ public class TaskHistoryEventController extends AbstractPagingController {
}
}
private void applyFilterParams(HistoryQuery query, MultiValueMap<String, String> params) {
private void applyFilterParams(TaskHistoryQuery query, MultiValueMap<String, String> params) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Entry to applyFilterParams(query= {}, params= {})", query, params);
}

6
history/taskana-simplehistory-rest-spring/src/main/java/pro/taskana/simplehistory/rest/assembler/TaskHistoryEventListResourceAssembler.java
View File

@ -9,16 +9,16 @@ import org.springframework.hateoas.Link;
import org.springframework.hateoas.PagedModel.PageMetadata;
import pro.taskana.resource.rest.AbstractRessourcesAssembler;
import pro.taskana.simplehistory.impl.HistoryEventImpl;
import pro.taskana.simplehistory.rest.TaskHistoryEventController;
import pro.taskana.simplehistory.rest.models.TaskHistoryEventListResource;
import pro.taskana.simplehistory.rest.models.TaskHistoryEventRepresentationModel;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
/** Mapper to convert from a list of HistoryEventImpl to a TaskHistoryEventResource. */
/** Mapper to convert from a list of TaskHistoryEvent to a TaskHistoryEventResource. */
public class TaskHistoryEventListResourceAssembler extends AbstractRessourcesAssembler {
public TaskHistoryEventListResource toResources(
List<HistoryEventImpl> historyEvents, PageMetadata pageMetadata) {
List<TaskHistoryEvent> historyEvents, PageMetadata pageMetadata) {
TaskHistoryEventRepresentationModelAssembler assembler =
new TaskHistoryEventRepresentationModelAssembler();

10
history/taskana-simplehistory-rest-spring/src/main/java/pro/taskana/simplehistory/rest/assembler/TaskHistoryEventRepresentationModelAssembler.java
View File

@ -7,20 +7,18 @@ import org.springframework.hateoas.server.RepresentationModelAssembler;
import org.springframework.lang.NonNull;
import pro.taskana.common.api.exceptions.SystemException;
import pro.taskana.simplehistory.impl.HistoryEventImpl;
import pro.taskana.simplehistory.rest.TaskHistoryEventController;
import pro.taskana.simplehistory.rest.models.TaskHistoryEventRepresentationModel;
import pro.taskana.spi.history.api.events.TaskHistoryCustomField;
import pro.taskana.spi.history.api.events.TaskanaHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
/** Transforms any {@link HistoryEventImpl} into its {@link TaskHistoryEventRepresentationModel}. */
/** Transforms any {@link TaskHistoryEvent} into its {@link TaskHistoryEventRepresentationModel}. */
public class TaskHistoryEventRepresentationModelAssembler
implements RepresentationModelAssembler<
TaskanaHistoryEvent, TaskHistoryEventRepresentationModel> {
implements RepresentationModelAssembler<TaskHistoryEvent, TaskHistoryEventRepresentationModel> {
@NonNull
@Override
public TaskHistoryEventRepresentationModel toModel(@NonNull TaskanaHistoryEvent historyEvent) {
public TaskHistoryEventRepresentationModel toModel(@NonNull TaskHistoryEvent historyEvent) {
TaskHistoryEventRepresentationModel repModel = new TaskHistoryEventRepresentationModel();
repModel.setTaskHistoryId(historyEvent.getId());
repModel.setBusinessProcessId(historyEvent.getBusinessProcessId());

4
history/taskana-simplehistory-rest-spring/src/main/java/pro/taskana/simplehistory/rest/models/TaskHistoryEventRepresentationModel.java
View File

@ -3,9 +3,9 @@ package pro.taskana.simplehistory.rest.models;
import java.time.Instant;
import org.springframework.hateoas.RepresentationModel;
import pro.taskana.spi.history.api.events.TaskanaHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
/** Resource class for {@link TaskanaHistoryEvent}. */
/** Resource class for {@link TaskHistoryEvent}. */
public class TaskHistoryEventRepresentationModel
extends RepresentationModel<TaskHistoryEventRepresentationModel> {

2
history/taskana-simplehistory-rest-spring/src/main/resources/sql.sample-data/clear-db.sql
View File

@ -1,3 +1,3 @@
-- the order is important!
DELETE FROM HISTORY_EVENTS;
DELETE FROM TASK_HISTORY_EVENT;
COMMIT;

2
history/taskana-simplehistory-rest-spring/src/main/resources/sql.sample-data/drop-tables.sql
View File

@ -1,3 +1,3 @@
DROP TABLE HISTORY_EVENTS;
DROP TABLE TASK_HISTORY_EVENT;
COMMIT;

2
history/taskana-simplehistory-rest-spring/src/main/resources/sql.sample-data/history-event.sql
View File

@ -1,4 +1,4 @@
INSERT INTO HISTORY_EVENTS (ID, BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID, EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, POR_COMPANY, POR_SYSTEM, POR_INSTANCE, POR_TYPE, POR_VALUE, TASK_CLASSIFICATION_KEY, TASK_CLASSIFICATION_CATEGORY, ATTACHMENT_CLASSIFICATION_KEY, OLD_VALUE, NEW_VALUE, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, DETAILS) VALUES
INSERT INTO TASK_HISTORY_EVENT (ID, BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID, EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, POR_COMPANY, POR_SYSTEM, POR_INSTANCE, POR_TYPE, POR_VALUE, TASK_CLASSIFICATION_KEY, TASK_CLASSIFICATION_CATEGORY, ATTACHMENT_CLASSIFICATION_KEY, OLD_VALUE, NEW_VALUE, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, DETAILS) VALUES
-- BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID, EVENT_TYPE, TASK_CREATEDD, USER_ID, DOMAIN, WORKBASKET_KEY, POR_COMPANY , POR_SYSTEM, POR_INSTANCE , POR_TYPE , POR_VALUE , TASK_CLASSIFICATION_KEY, TASK_CLASSIFICATION_CATEGORY , ATTACHMENT_CLASSIFICATION_KEY , OLD_VALUE , NEW_VALUE , CUSTOM_1 , CUSTOM_2 , CUSTOM_3 , CUSTOM_4
('HEI:000000000000000000000000000000000000','BPI:01' ,'', 'TKI:000000000000000000000000000000000000', 'TASK_CREATED', CURRENT_TIMESTAMP , 'USER_2_2', 'DOMAIN_B', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344' ,' L140101' , 'TASK' ,'' ,'old_val12' ,'new_val12' ,'custom1' ,'custom2' , 'custom3' ,'custom4', 'some Details'),
('HEI:000000000000000000000000000000000001','BPI:02' ,'', 'TKI:000000000000000000000000000000000000', 'TASK_UPDATED', DATEADD('DAY', -2, CURRENT_TIMESTAMP ), 'USER_1_1', 'DOMAIN_A', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '65464564' , '' , '' ,'' ,'2old_val' ,'new_val2' ,'custom1' ,'' , 'custom3' ,'','some Details'),

8
history/taskana-simplehistory-rest-spring/src/test/java/pro/taskana/simplehistory/rest/assembler/TaskHistoryEventRepresentationModelAssemblerTest.java
View File

@ -9,11 +9,10 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import pro.taskana.simplehistory.impl.HistoryEventImpl;
import pro.taskana.simplehistory.rest.TaskHistoryRestConfiguration;
import pro.taskana.simplehistory.rest.models.TaskHistoryEventRepresentationModel;
import pro.taskana.spi.history.api.events.TaskHistoryCustomField;
import pro.taskana.spi.history.api.events.TaskanaHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
/** Test for {@link TaskHistoryEventRepresentationModelAssembler}. */
@ExtendWith(SpringExtension.class)
@ -35,8 +34,7 @@ class TaskHistoryEventRepresentationModelAssemblerTest {
@Test
void taskHistoryEventModelToResource() {
HistoryEventImpl historyEvent =
new HistoryEventImpl("HEI:000000000000000000000000000000000000", "user1", "someDetails");
TaskHistoryEvent historyEvent = new TaskHistoryEvent();
historyEvent.setEventType("TASK_CREATED");
historyEvent.setBusinessProcessId("BPI:01");
@ -65,7 +63,7 @@ class TaskHistoryEventRepresentationModelAssemblerTest {
}
private void testEquality(
TaskanaHistoryEvent historyEvent,
TaskHistoryEvent historyEvent,
TaskHistoryEventRepresentationModel taskHistoryEventRepresentationModel) {
assertThat(historyEvent.getEventType())

131
lib/taskana-core/src/main/java/pro/taskana/common/internal/util/ObjectAttributeChangeDetector.java Normal file
View File

@ -0,0 +1,131 @@
package pro.taskana.common.internal.util;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pro.taskana.common.api.exceptions.SystemException;
public class ObjectAttributeChangeDetector {
private static final Logger LOGGER = LoggerFactory.getLogger(ObjectAttributeChangeDetector.class);
private ObjectAttributeChangeDetector() {}
/**
* Determines changes in fields between two objects.
*
* @param oldObject the old object for the comparison
* @param newObject the new object for the comparison
* @param <T> The generic type parameter
* @return the details of all changed fields as JSON string
*/
public static <T> String determineChangesInAttributes(T oldObject, T newObject) {
LOGGER.debug(
"Entry to determineChangesInAttributes (oldObject = {}, newObject = {}",
oldObject,
newObject);
List<Field> fields = new ArrayList<>();
if (Objects.isNull(oldObject) || Objects.isNull(newObject)) {
throw new SystemException(
"Null was provided as a parameter. Please provide two objects of the same type");
}
Class<?> currentClass = oldObject.getClass();
if (List.class.isAssignableFrom(currentClass)) {
return compareLists(oldObject, newObject);
} else {
retrieveFields(fields, currentClass);
}
Predicate<Triplet<Field, Object, Object>> areFieldsNotEqual =
fieldAndValuePairTriplet ->
!Objects.equals(
fieldAndValuePairTriplet.getMiddle(), fieldAndValuePairTriplet.getRight());
Predicate<Triplet<Field, Object, Object>> isFieldNotCustomAttributes =
fieldAndValuePairTriplet ->
!fieldAndValuePairTriplet.getLeft().getName().equals("customAttributes");
List<JSONObject> changedAttributes =
fields.stream()
.peek(field -> field.setAccessible(true))
.map(
CheckedFunction.wrap(
field -> new Triplet<>(field, field.get(oldObject), field.get(newObject))))
.filter(areFieldsNotEqual.and(isFieldNotCustomAttributes))
.map(
fieldAndValuePairTriplet -> {
JSONObject changedAttribute = new JSONObject();
changedAttribute.put("fieldName", fieldAndValuePairTriplet.getLeft().getName());
changedAttribute.put(
"oldValue",
Optional.ofNullable(fieldAndValuePairTriplet.getMiddle()).orElse(""));
changedAttribute.put(
"newValue",
Optional.ofNullable(fieldAndValuePairTriplet.getRight()).orElse(""));
return changedAttribute;
})
.collect(Collectors.toList());
JSONObject changes = new JSONObject();
changes.put("changes", changedAttributes);
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Exit from determineChangesInAttributes(), returning {}", changes);
}
return changes.toString();
}
private static void retrieveFields(List<Field> fields, Class<?> currentClass) {
while (currentClass.getSuperclass() != null) {
fields.addAll(Arrays.asList(currentClass.getDeclaredFields()));
currentClass = currentClass.getSuperclass();
}
}
private static <T> String compareLists(T oldObject, T newObject) {
LOGGER.debug(
"Entry to determineChangesInAttributes (oldObject = {}, newObject = {}",
oldObject,
newObject);
if (!oldObject.equals(newObject)) {
JSONObject changedAttribute = new JSONObject();
changedAttribute.put("oldValue", oldObject);
changedAttribute.put("newValue", newObject);
JSONObject changes = new JSONObject();
changes.put("changes", changedAttribute);
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Exit from determineChangesInAttributes(), returning {}", changes);
}
return changes.toString();
}
LOGGER.debug(
"Exit from determineChangesInAttributes(), "
+ "returning empty String because there are no changed attributes");
return "";
}
}

16
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/TaskanaHistory.java
View File

@ -5,7 +5,8 @@ import java.util.List;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.spi.history.api.events.TaskanaHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
/** Interface for TASKANA History Service Provider. */
public interface TaskanaHistory {
@ -18,11 +19,18 @@ public interface TaskanaHistory {
void initialize(TaskanaEngine taskanaEngine);
/**
* Create a new history event.
* Create a new task history event.
*
* @param event {@link TaskanaHistoryEvent} The event to be created.
* @param event {@link TaskHistoryEvent} The event to be created.
*/
void create(TaskanaHistoryEvent event);
void create(TaskHistoryEvent event);
/**
* Create a new workbasket history event.
*
* @param event {@link WorkbasketHistoryEvent} The event to be created.
*/
void create(WorkbasketHistoryEvent event);
/**
* Delete history events by taskIds. Invalid/non-existing taskIds will be ignored

4
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/CancelledEvent.java → lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TaskCancelledEvent.java
View File

@ -3,9 +3,9 @@ package pro.taskana.spi.history.api.events.task;
import pro.taskana.task.api.models.Task;
/** Event fired if a task is cancelled. */
public class CancelledEvent extends TaskEvent {
public class TaskCancelledEvent extends TaskHistoryEvent {
public CancelledEvent(String id, Task task, String userId) {
public TaskCancelledEvent(String id, Task task, String userId) {
super(id, task, userId, null);
eventType = "TASK_CANCELLED";
created = task.getCompleted();

6
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/ClaimCancelledEvent.java → lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TaskClaimCancelledEvent.java
View File

@ -3,11 +3,11 @@ package pro.taskana.spi.history.api.events.task;
import pro.taskana.task.api.models.Task;
/** Event fired if a task is cancelled to be claimed. */
public class ClaimCancelledEvent extends TaskEvent {
public class TaskClaimCancelledEvent extends TaskHistoryEvent {
public ClaimCancelledEvent(String id, Task task, String userId) {
public TaskClaimCancelledEvent(String id, Task task, String userId) {
super(id, task, userId, null);
eventType = "TASK_CLAIM_CANCELLED";
eventType = TaskHistoryEventType.TASK_CLAIM_CANCELLED.getName();
created = task.getModified();
}
}

6
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/ClaimedEvent.java → lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TaskClaimedEvent.java
View File

@ -3,11 +3,11 @@ package pro.taskana.spi.history.api.events.task;
import pro.taskana.task.api.models.Task;
/** Event fired if a task is claimed. */
public class ClaimedEvent extends TaskEvent {
public class TaskClaimedEvent extends TaskHistoryEvent {
public ClaimedEvent(String id, Task task, String userId) {
public TaskClaimedEvent(String id, Task task, String userId) {
super(id, task, userId, null);
setEventType("TASK_CLAIMED");
eventType = (TaskHistoryEventType.TASK_CLAIMED.getName());
created = task.getClaimed();
}
}

10
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/CompletedEvent.java → lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TaskCompletedEvent.java
View File

@ -4,17 +4,17 @@ import pro.taskana.task.api.models.Task;
import pro.taskana.task.api.models.TaskSummary;
/** Event fired if a task is completed. */
public class CompletedEvent extends TaskEvent {
public class TaskCompletedEvent extends TaskHistoryEvent {
public CompletedEvent(String id, Task completedTask, String userId) {
public TaskCompletedEvent(String id, Task completedTask, String userId) {
super(id, completedTask, userId, null);
eventType = "TASK_COMPLETED";
eventType = TaskHistoryEventType.TASK_COMPLETED.getName();
created = completedTask.getCompleted();
}
public CompletedEvent(String id, TaskSummary completedTask, String userId) {
public TaskCompletedEvent(String id, TaskSummary completedTask, String userId) {
super(id, completedTask, userId, null);
eventType = "TASK_COMPLETED";
eventType = TaskHistoryEventType.TASK_COMPLETED.getName();
created = completedTask.getCompleted();
}
}

6
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/CreatedEvent.java → lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TaskCreatedEvent.java
View File

@ -3,11 +3,11 @@ package pro.taskana.spi.history.api.events.task;
import pro.taskana.task.api.models.Task;
/** Event fired if a task is created. */
public class CreatedEvent extends TaskEvent {
public class TaskCreatedEvent extends TaskHistoryEvent {
public CreatedEvent(String id, Task task, String userId, String details) {
public TaskCreatedEvent(String id, Task task, String userId, String details) {
super(id, task, userId, details);
eventType = "TASK_CREATED";
eventType = TaskHistoryEventType.TASK_CREATED.getName();
created = task.getCreated();
}
}

112
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TaskEvent.java
View File

@ -1,112 +0,0 @@
package pro.taskana.spi.history.api.events.task;
import pro.taskana.spi.history.api.events.TaskanaHistoryEvent;
import pro.taskana.task.api.models.Task;
import pro.taskana.task.api.models.TaskSummary;
/** Super class for all task related events. */
public class TaskEvent extends TaskanaHistoryEvent {
public TaskEvent(String id, Task task, String userId, String details) {
super(id, userId, details);
taskId = task.getId();
businessProcessId = task.getBusinessProcessId();
parentBusinessProcessId = task.getParentBusinessProcessId();
domain = task.getDomain();
workbasketKey = task.getWorkbasketKey();
taskClassificationCategory = task.getClassificationCategory();
if (task.getClassificationSummary() != null) {
taskClassificationKey = task.getClassificationSummary().getKey();
}
if (!task.getAttachments().isEmpty()) {
attachmentClassificationKey =
task.getAttachments().get(0).getClassificationSummary().getKey();
}
if (task.getPrimaryObjRef() != null) {
porCompany = task.getPrimaryObjRef().getCompany();
porSystem = task.getPrimaryObjRef().getSystem();
porInstance = task.getPrimaryObjRef().getSystemInstance();
porType = task.getPrimaryObjRef().getType();
porValue = task.getPrimaryObjRef().getValue();
}
}
public TaskEvent(String id, TaskSummary task, String userId, String details) {
super(id, userId, details);
taskId = task.getId();
businessProcessId = task.getBusinessProcessId();
parentBusinessProcessId = task.getParentBusinessProcessId();
domain = task.getDomain();
if (task.getWorkbasketSummary() != null) {
workbasketKey = task.getWorkbasketSummary().getKey();
}
if (task.getClassificationSummary() != null) {
taskClassificationKey = task.getClassificationSummary().getKey();
taskClassificationCategory = task.getClassificationSummary().getCategory();
}
if (!task.getAttachmentSummaries().isEmpty()) {
attachmentClassificationKey =
task.getAttachmentSummaries().get(0).getClassificationSummary().getKey();
}
if (task.getPrimaryObjRef() != null) {
porCompany = task.getPrimaryObjRef().getCompany();
porSystem = task.getPrimaryObjRef().getSystem();
porInstance = task.getPrimaryObjRef().getSystemInstance();
porType = task.getPrimaryObjRef().getType();
porValue = task.getPrimaryObjRef().getValue();
}
}
@Override
public String toString() {
return "TaskEvent [id="
+ id
+ ", businessProcessId="
+ businessProcessId
+ ", parentBusinessProcessId="
+ parentBusinessProcessId
+ ", taskId="
+ taskId
+ ", eventType="
+ eventType
+ ", created="
+ created
+ ", userId="
+ userId
+ ", domain="
+ domain
+ ", workbasketKey="
+ workbasketKey
+ ", porCompany="
+ porCompany
+ ", porSystem="
+ porSystem
+ ", porInstance="
+ porInstance
+ ", porType="
+ porType
+ ", porValue="
+ porValue
+ ", taskClassificationKey="
+ taskClassificationKey
+ ", taskClassificationCategory="
+ taskClassificationCategory
+ ", attachmentClassificationKey="
+ attachmentClassificationKey
+ ", oldValue="
+ oldValue
+ ", newValue="
+ newValue
+ ", custom1="
+ custom1
+ ", custom2="
+ custom2
+ ", custom3="
+ custom3
+ ", custom4="
+ custom4
+ ", details="
+ details
+ "]";
}
}

152
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/TaskanaHistoryEvent.java → lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TaskHistoryEvent.java
View File

@ -1,12 +1,15 @@
package pro.taskana.spi.history.api.events;
package pro.taskana.spi.history.api.events.task;
import java.time.Instant;
import java.util.Objects;
import pro.taskana.common.api.exceptions.SystemException;
import pro.taskana.spi.history.api.events.TaskHistoryCustomField;
import pro.taskana.task.api.TaskCustomField;
import pro.taskana.task.api.models.TaskSummary;
/** Super class for all specific events from the TASKANA engine. */
public class TaskanaHistoryEvent {
/** Super class for all task related events. */
public class TaskHistoryEvent {
protected String id;
protected String businessProcessId;
@ -33,12 +36,36 @@ public class TaskanaHistoryEvent {
protected String custom4;
protected String details;
public TaskanaHistoryEvent() {}
public TaskHistoryEvent() {}
public TaskanaHistoryEvent(String id, String userId, String details) {
public TaskHistoryEvent(String id, TaskSummary task, String userId, String details) {
this.id = id;
this.userId = userId;
this.details = details;
taskId = task.getId();
businessProcessId = task.getBusinessProcessId();
parentBusinessProcessId = task.getParentBusinessProcessId();
domain = task.getDomain();
workbasketKey = task.getWorkbasketSummary().getKey();
taskClassificationCategory = task.getClassificationSummary().getCategory();
if (task.getClassificationSummary() != null) {
taskClassificationKey = task.getClassificationSummary().getKey();
}
if (!task.getAttachmentSummaries().isEmpty()) {
attachmentClassificationKey =
task.getAttachmentSummaries().get(0).getClassificationSummary().getKey();
}
if (task.getPrimaryObjRef() != null) {
porCompany = task.getPrimaryObjRef().getCompany();
porSystem = task.getPrimaryObjRef().getSystem();
porInstance = task.getPrimaryObjRef().getSystemInstance();
porType = task.getPrimaryObjRef().getType();
porValue = task.getPrimaryObjRef().getValue();
}
custom1 = task.getCustomAttribute(TaskCustomField.CUSTOM_1);
custom2 = task.getCustomAttribute(TaskCustomField.CUSTOM_2);
custom3 = task.getCustomAttribute(TaskCustomField.CUSTOM_3);
custom4 = task.getCustomAttribute(TaskCustomField.CUSTOM_4);
}
public void setCustomAttribute(TaskHistoryCustomField customField, String value) {
@ -75,14 +102,6 @@ public class TaskanaHistoryEvent {
}
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getBusinessProcessId() {
return businessProcessId;
}
@ -107,30 +126,6 @@ public class TaskanaHistoryEvent {
this.taskId = taskId;
}
public String getEventType() {
return eventType;
}
public void setEventType(String eventType) {
this.eventType = eventType;
}
public Instant getCreated() {
return created;
}
public void setCreated(Instant created) {
this.created = created;
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getDomain() {
return domain;
}
@ -211,6 +206,38 @@ public class TaskanaHistoryEvent {
this.attachmentClassificationKey = attachmentClassificationKey;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getEventType() {
return eventType;
}
public void setEventType(String eventType) {
this.eventType = eventType;
}
public Instant getCreated() {
return created;
}
public void setCreated(Instant created) {
this.created = created;
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getOldValue() {
return oldValue;
}
@ -309,35 +336,54 @@ public class TaskanaHistoryEvent {
@Override
public String toString() {
return "TaskanaHistoryEvent ["
+ "id="
+ this.id
return "TaskEvent [id="
+ id
+ ", businessProcessId="
+ this.businessProcessId
+ businessProcessId
+ ", parentBusinessProcessId="
+ this.parentBusinessProcessId
+ parentBusinessProcessId
+ ", taskId="
+ this.taskId
+ taskId
+ ", eventType="
+ this.eventType
+ eventType
+ ", created="
+ this.created
+ created
+ ", userId="
+ this.userId
+ userId
+ ", domain="
+ this.domain
+ domain
+ ", workbasketKey="
+ this.workbasketKey
+ workbasketKey
+ ", porCompany="
+ porCompany
+ ", porSystem="
+ porSystem
+ ", porInstance="
+ porInstance
+ ", porType="
+ porType
+ ", porValue="
+ porValue
+ ", taskClassificationKey="
+ this.taskClassificationKey
+ taskClassificationKey
+ ", taskClassificationCategory="
+ taskClassificationCategory
+ ", attachmentClassificationKey="
+ this.attachmentClassificationKey
+ attachmentClassificationKey
+ ", oldValue="
+ this.oldValue
+ oldValue
+ ", newValue="
+ this.newValue
+ newValue
+ ", custom1="
+ custom1
+ ", custom2="
+ custom2
+ ", custom3="
+ custom3
+ ", custom4="
+ custom4
+ ", details="
+ this.details
+ details
+ "]";
}
}

22
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TaskHistoryEventType.java Normal file
View File

@ -0,0 +1,22 @@
package pro.taskana.spi.history.api.events.task;
public enum TaskHistoryEventType {
TASK_CREATED("TASK_CREATED"),
TASK_UPDATED("TASK_UPDATED"),
TASK_CLAIMED("TASK_CLAIMED"),
TASK_CLAIM_CANCELLED("TASK_CLAIM_CANCELLED"),
TASK_COMPLETED("TASK_COMPLETED"),
TASK_CANCELLED("TASK_CANCELLED"),
TASK_TERMINATED("TASK_TERMINATED"),
TASK_TRANSFERRED("TASK_TRANSFERRED");
private String name;
TaskHistoryEventType(String name) {
this.name = name;
}
public String getName() {
return name;
}
}

4
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TerminatedEvent.java → lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TaskTerminatedEvent.java
View File

@ -3,9 +3,9 @@ package pro.taskana.spi.history.api.events.task;
import pro.taskana.task.api.models.Task;
/** Event fired if a task is terminated. */
public class TerminatedEvent extends TaskEvent {
public class TaskTerminatedEvent extends TaskHistoryEvent {
public TerminatedEvent(String id, Task task, String userId) {
public TaskTerminatedEvent(String id, Task task, String userId) {
super(id, task, userId, null);
eventType = "TASK_TERMINATED";
created = task.getCompleted();

6
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TransferredEvent.java → lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TaskTransferredEvent.java
View File

@ -4,16 +4,16 @@ import pro.taskana.task.api.models.Task;
import pro.taskana.workbasket.api.models.WorkbasketSummary;
/** Event fired if a task is transferred. */
public class TransferredEvent extends TaskEvent {
public class TaskTransferredEvent extends TaskHistoryEvent {
public TransferredEvent(
public TaskTransferredEvent(
String id,
Task task,
WorkbasketSummary oldWorkbasket,
WorkbasketSummary newWorkbasket,
String userId) {
super(id, task, userId, null);
eventType = "TASK_TRANSFERRED";
eventType = TaskHistoryEventType.TASK_TRANSFERRED.getName();
created = task.getModified();
this.oldValue = oldWorkbasket.getId();
this.newValue = newWorkbasket.getId();

12
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/TaskUpdatedEvent.java Normal file
View File

@ -0,0 +1,12 @@
package pro.taskana.spi.history.api.events.task;
import pro.taskana.task.api.models.Task;
public class TaskUpdatedEvent extends TaskHistoryEvent {
public TaskUpdatedEvent(String id, Task updatedTask, String userId, String details) {
super(id, updatedTask, userId, details);
eventType = TaskHistoryEventType.TASK_UPDATED.getName();
created = updatedTask.getModified();
}
}

12
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/task/UpdatedEvent.java
View File

@ -1,12 +0,0 @@
package pro.taskana.spi.history.api.events.task;
import pro.taskana.task.api.models.Task;
public class UpdatedEvent extends TaskEvent {
public UpdatedEvent(String id, Task updatedTask, String userId, String details) {
super(id, updatedTask, userId, details);
eventType = "TASK_UPDATED";
created = updatedTask.getModified();
}
}

15
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/workbasket/WorkbasketAccessItemCreatedEvent.java Normal file
View File

@ -0,0 +1,15 @@
package pro.taskana.spi.history.api.events.workbasket;
import java.time.Instant;
import pro.taskana.workbasket.api.models.Workbasket;
public class WorkbasketAccessItemCreatedEvent extends WorkbasketHistoryEvent {
public WorkbasketAccessItemCreatedEvent(
String id, Workbasket workbasket, String userId, String details) {
super(id, workbasket, userId, details);
eventType = WorkbasketHistoryEventType.WORKBASKET_ACCESS_ITEM_CREATED.getName();
created = Instant.now();
}
}

15
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/workbasket/WorkbasketAccessItemDeletedEvent.java Normal file
View File

@ -0,0 +1,15 @@
package pro.taskana.spi.history.api.events.workbasket;
import java.time.Instant;
import pro.taskana.workbasket.api.models.Workbasket;
public class WorkbasketAccessItemDeletedEvent extends WorkbasketHistoryEvent {
public WorkbasketAccessItemDeletedEvent(
String id, Workbasket workbasket, String userId, String details) {
super(id, workbasket, userId, details);
eventType = WorkbasketHistoryEventType.WORKBASKET_ACCESS_ITEM_DELETED.getName();
created = Instant.now();
}
}

15
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/workbasket/WorkbasketAccessItemDeletedForAccessIdEvent.java Normal file
View File

@ -0,0 +1,15 @@
package pro.taskana.spi.history.api.events.workbasket;
import java.time.Instant;
import pro.taskana.workbasket.api.models.Workbasket;
public class WorkbasketAccessItemDeletedForAccessIdEvent extends WorkbasketHistoryEvent {
public WorkbasketAccessItemDeletedForAccessIdEvent(
String id, Workbasket workbasket, String userId) {
super(id, workbasket, userId, null);
eventType = WorkbasketHistoryEventType.WORKBASKET_ACCESS_ITEM_DELETED_FOR_ACCESS_ID.getName();
created = Instant.now();
}
}

15
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/workbasket/WorkbasketAccessItemUpdatedEvent.java Normal file
View File

@ -0,0 +1,15 @@
package pro.taskana.spi.history.api.events.workbasket;
import java.time.Instant;
import pro.taskana.workbasket.api.models.Workbasket;
public class WorkbasketAccessItemUpdatedEvent extends WorkbasketHistoryEvent {
public WorkbasketAccessItemUpdatedEvent(
String id, Workbasket workbasket, String userId, String details) {
super(id, workbasket, userId, details);
eventType = WorkbasketHistoryEventType.WORKBASKET_ACCESS_ITEM_UPDATED.getName();
created = Instant.now();
}
}

15
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/workbasket/WorkbasketAccessItemsUpdatedEvent.java Normal file
View File

@ -0,0 +1,15 @@
package pro.taskana.spi.history.api.events.workbasket;
import java.time.Instant;
import pro.taskana.workbasket.api.models.Workbasket;
public class WorkbasketAccessItemsUpdatedEvent extends WorkbasketHistoryEvent {
public WorkbasketAccessItemsUpdatedEvent(
String id, Workbasket workbasket, String userId, String details) {
super(id, workbasket, userId, details);
eventType = WorkbasketHistoryEventType.WORKBASKET_ACCESS_ITEMS_UPDATED.getName();
created = Instant.now();
}
}

12
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/workbasket/WorkbasketCreatedEvent.java Normal file
View File

@ -0,0 +1,12 @@
package pro.taskana.spi.history.api.events.workbasket;
import pro.taskana.workbasket.api.models.Workbasket;
public class WorkbasketCreatedEvent extends WorkbasketHistoryEvent {
public WorkbasketCreatedEvent(String id, Workbasket workbasket, String userId, String details) {
super(id, workbasket, userId, details);
eventType = WorkbasketHistoryEventType.WORKBASKET_CREATED.getName();
created = workbasket.getCreated();
}
}

12
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/workbasket/WorkbasketDeletedEvent.java Normal file
View File

@ -0,0 +1,12 @@
package pro.taskana.spi.history.api.events.workbasket;
import pro.taskana.workbasket.api.models.Workbasket;
public class WorkbasketDeletedEvent extends WorkbasketHistoryEvent {
public WorkbasketDeletedEvent(String id, Workbasket workbasket, String userId, String details) {
super(id, workbasket, userId, details);
eventType = WorkbasketHistoryEventType.WORKBASKET_DELETED.getName();
created = workbasket.getModified();
}
}

15
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/workbasket/WorkbasketDistributionTargetAddedEvent.java Normal file
View File

@ -0,0 +1,15 @@
package pro.taskana.spi.history.api.events.workbasket;
import java.time.Instant;
import pro.taskana.workbasket.api.models.Workbasket;
public class WorkbasketDistributionTargetAddedEvent extends WorkbasketHistoryEvent {
public WorkbasketDistributionTargetAddedEvent(
String id, Workbasket workbasket, String userId, String details) {
super(id, workbasket, userId, details);
eventType = WorkbasketHistoryEventType.WORKBASKET_DISTRIBUTION_TARGET_ADDED.getName();
created = Instant.now();
}
}

15
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/workbasket/WorkbasketDistributionTargetRemovedEvent.java Normal file
View File

@ -0,0 +1,15 @@
package pro.taskana.spi.history.api.events.workbasket;
import java.time.Instant;
import pro.taskana.workbasket.api.models.Workbasket;
public class WorkbasketDistributionTargetRemovedEvent extends WorkbasketHistoryEvent {
public WorkbasketDistributionTargetRemovedEvent(
String id, Workbasket workbasket, String userId, String details) {
super(id, workbasket, userId, details);
eventType = WorkbasketHistoryEventType.WORKBASKET_DISTRIBUTION_TARGET_REMOVED.getName();
created = Instant.now();
}
}

16
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/workbasket/WorkbasketDistributionTargetsUpdatedEvent.java Normal file
View File

@ -0,0 +1,16 @@
package pro.taskana.spi.history.api.events.workbasket;
import java.time.Instant;
import pro.taskana.workbasket.api.models.Workbasket;
public class WorkbasketDistributionTargetsUpdatedEvent extends WorkbasketHistoryEvent {
public WorkbasketDistributionTargetsUpdatedEvent(
String id, Workbasket workbasket, String userId, String details) {
super(id, workbasket, userId, details);
eventType = WorkbasketHistoryEventType.WORKBASKET_DISTRIBUTION_TARGETS_UPDATED.getName();
created = Instant.now();
}
}

236
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/workbasket/WorkbasketHistoryEvent.java Normal file
View File

@ -0,0 +1,236 @@
package pro.taskana.spi.history.api.events.workbasket;
import java.time.Instant;
import pro.taskana.workbasket.api.WorkbasketCustomField;
import pro.taskana.workbasket.api.models.WorkbasketSummary;
/** Super class for all workbasket related events. */
public class WorkbasketHistoryEvent {
protected String id;
protected String eventType;
protected Instant created;
protected String userId;
protected String domain;
protected String workbasketId;
protected String workbasketKey;
protected String workbasketType;
protected String owner;
protected String custom1;
protected String custom2;
protected String custom3;
protected String custom4;
protected String orgLevel1;
protected String orgLevel2;
protected String orgLevel3;
protected String orgLevel4;
protected String details;
public WorkbasketHistoryEvent() {}
public WorkbasketHistoryEvent(
String id, WorkbasketSummary workbasket, String userId, String details) {
this.id = id;
this.userId = userId;
this.details = details;
workbasketId = workbasket.getId();
domain = workbasket.getDomain();
workbasketKey = workbasket.getKey();
workbasketType = workbasket.getType().name();
owner = workbasket.getOwner();
custom1 = workbasket.getCustomAttribute(WorkbasketCustomField.CUSTOM_1);
custom2 = workbasket.getCustomAttribute(WorkbasketCustomField.CUSTOM_2);
custom3 = workbasket.getCustomAttribute(WorkbasketCustomField.CUSTOM_3);
custom4 = workbasket.getCustomAttribute(WorkbasketCustomField.CUSTOM_4);
orgLevel1 = workbasket.getOrgLevel1();
orgLevel2 = workbasket.getOrgLevel2();
orgLevel3 = workbasket.getOrgLevel3();
orgLevel4 = workbasket.getOrgLevel4();
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getEventType() {
return eventType;
}
public void setEventType(String eventType) {
this.eventType = eventType;
}
public Instant getCreated() {
return created;
}
public void setCreated(Instant created) {
this.created = created;
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getDomain() {
return domain;
}
public void setDomain(String domain) {
this.domain = domain;
}
public String getWorkbasketId() {
return workbasketId;
}
public void setWorkbasketId(String workbasketId) {
this.workbasketId = workbasketId;
}
public String getWorkbasketKey() {
return workbasketKey;
}
public void setWorkbasketKey(String workbasketKey) {
this.workbasketKey = workbasketKey;
}
public String getWorkbasketType() {
return workbasketType;
}
public void setWorkbasketType(String workbasketType) {
this.workbasketType = workbasketType;
}
public String getOwner() {
return owner;
}
public void setOwner(String owner) {
this.owner = owner;
}
public String getCustom1() {
return custom1;
}
public void setCustom1(String custom1) {
this.custom1 = custom1;
}
public String getCustom2() {
return custom2;
}
public void setCustom2(String custom2) {
this.custom2 = custom2;
}
public String getCustom3() {
return custom3;
}
public void setCustom3(String custom3) {
this.custom3 = custom3;
}
public String getCustom4() {
return custom4;
}
public void setCustom4(String custom4) {
this.custom4 = custom4;
}
public String getOrgLevel1() {
return orgLevel1;
}
public void setOrgLevel1(String orgLevel1) {
this.orgLevel1 = orgLevel1;
}
public String getOrgLevel2() {
return orgLevel2;
}
public void setOrgLevel2(String orgLevel2) {
this.orgLevel2 = orgLevel2;
}
public String getOrgLevel3() {
return orgLevel3;
}
public void setOrgLevel3(String orgLevel3) {
this.orgLevel3 = orgLevel3;
}
public String getOrgLevel4() {
return orgLevel4;
}
public void setOrgLevel4(String orgLevel4) {
this.orgLevel4 = orgLevel4;
}
public String getDetails() {
return details;
}
public void setDetails(String details) {
this.details = details;
}
@Override
public String toString() {
return "WorkbasketEvent [id="
+ id
+ ", eventType="
+ eventType
+ ", created="
+ created
+ ", userId="
+ userId
+ ", domain="
+ domain
+ ", workbasketId="
+ workbasketId
+ ", workbasketKey="
+ workbasketKey
+ ", workbasketType="
+ workbasketType
+ ", owner="
+ owner
+ ", custom1="
+ custom1
+ ", custom2="
+ custom2
+ ", custom3="
+ custom3
+ ", custom4="
+ custom4
+ ", orgLevel1="
+ orgLevel1
+ ", orgLevel2="
+ orgLevel2
+ ", orgLevel3="
+ orgLevel3
+ ", orgLevel4="
+ orgLevel4
+ ", details="
+ details
+ "]";
}
}

27
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/workbasket/WorkbasketHistoryEventType.java Normal file
View File

@ -0,0 +1,27 @@
package pro.taskana.spi.history.api.events.workbasket;
public enum WorkbasketHistoryEventType {
WORKBASKET_CREATED("WORKBASKET_CREATED"),
WORKBASKET_UPDATED("WORKBASKET_UPDATED"),
WORKBASKET_DELETED("WORKBASKET_DELETED"),
WORKBASKET_MARKED_FOR_DELETION("WORKBASKET_MARKED_FOR_DELETION"),
WORKBASKET_ACCESS_ITEM_CREATED("WORKBASKET_ACCESS_ITEM_CREATED"),
WORKBASKET_ACCESS_ITEM_UPDATED("WORKBASKET_ACCESS_ITEM_UPDATED"),
WORKBASKET_ACCESS_ITEM_DELETED("WORKBASKET_ACCESS_ITEM_DELETED"),
WORKBASKET_ACCESS_ITEMS_UPDATED("WORKBASKET_ACCESS_ITEMS_UPDATED"),
WORKBASKET_ACCESS_ITEM_DELETED_FOR_ACCESS_ID("WORKBASKET_ACCESS_ITEM_DELETED_FOR_ACCESS_ID"),
WORKBASKET_DISTRIBUTION_TARGET_ADDED("WORKBASKET_DISTRIBUTION_TARGET_ADDED"),
WORKBASKET_DISTRIBUTION_TARGET_REMOVED("WORKBASKET_DISTRIBUTION_TARGET_REMOVED"),
WORKBASKET_DISTRIBUTION_TARGETS_UPDATED("WORKBASKET_DISTRIBUTION_TARGETS_UPDATED");
private String name;
WorkbasketHistoryEventType(String name) {
this.name = name;
}
public String getName() {
return name;
}
}

13
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/workbasket/WorkbasketMarkedForDeletionEvent.java Normal file
View File

@ -0,0 +1,13 @@
package pro.taskana.spi.history.api.events.workbasket;
import pro.taskana.workbasket.api.models.Workbasket;
public class WorkbasketMarkedForDeletionEvent extends WorkbasketHistoryEvent {
public WorkbasketMarkedForDeletionEvent(
String id, Workbasket workbasket, String userId, String details) {
super(id, workbasket, userId, details);
eventType = WorkbasketHistoryEventType.WORKBASKET_MARKED_FOR_DELETION.getName();
created = workbasket.getModified();
}
}

12
lib/taskana-core/src/main/java/pro/taskana/spi/history/api/events/workbasket/WorkbasketUpdatedEvent.java Normal file
View File

@ -0,0 +1,12 @@
package pro.taskana.spi.history.api.events.workbasket;
import pro.taskana.workbasket.api.models.Workbasket;
public class WorkbasketUpdatedEvent extends WorkbasketHistoryEvent {
public WorkbasketUpdatedEvent(String id, Workbasket workbasket, String userId, String details) {
super(id, workbasket, userId, details);
eventType = WorkbasketHistoryEventType.WORKBASKET_UPDATED.getName();
created = workbasket.getModified();
}
}

10
lib/taskana-core/src/main/java/pro/taskana/spi/history/internal/HistoryEventManager.java
View File

@ -10,7 +10,8 @@ import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.spi.history.api.TaskanaHistory;
import pro.taskana.spi.history.api.events.TaskanaHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
/** Creates and deletes events and emits them to the registered history service providers. */
public final class HistoryEventManager {
@ -43,7 +44,12 @@ public final class HistoryEventManager {
return Objects.nonNull(singleton) && singleton.enabled;
}
public void createEvent(TaskanaHistoryEvent event) {
public void createEvent(TaskHistoryEvent event) {
LOGGER.debug("Sending event to history service providers: {}", event);
serviceLoader.forEach(historyProvider -> historyProvider.create(event));
}
public void createEvent(WorkbasketHistoryEvent event) {
LOGGER.debug("Sending event to history service providers: {}", event);
serviceLoader.forEach(historyProvider -> historyProvider.create(event));
}

95
lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskServiceImpl.java
View File

@ -1,9 +1,7 @@
package pro.taskana.task.internal;
import java.lang.reflect.Field;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
@ -11,13 +9,11 @@ import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.apache.ibatis.exceptions.PersistenceException;
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -35,17 +31,16 @@ import pro.taskana.common.api.exceptions.TaskanaException;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.common.internal.security.CurrentUserContext;
import pro.taskana.common.internal.util.CheckedConsumer;
import pro.taskana.common.internal.util.CheckedFunction;
import pro.taskana.common.internal.util.IdGenerator;
import pro.taskana.common.internal.util.ObjectAttributeChangeDetector;
import pro.taskana.common.internal.util.Pair;
import pro.taskana.common.internal.util.Triplet;
import pro.taskana.spi.history.api.events.task.CancelledEvent;
import pro.taskana.spi.history.api.events.task.ClaimCancelledEvent;
import pro.taskana.spi.history.api.events.task.ClaimedEvent;
import pro.taskana.spi.history.api.events.task.CompletedEvent;
import pro.taskana.spi.history.api.events.task.CreatedEvent;
import pro.taskana.spi.history.api.events.task.TerminatedEvent;
import pro.taskana.spi.history.api.events.task.UpdatedEvent;
import pro.taskana.spi.history.api.events.task.TaskCancelledEvent;
import pro.taskana.spi.history.api.events.task.TaskClaimCancelledEvent;
import pro.taskana.spi.history.api.events.task.TaskClaimedEvent;
import pro.taskana.spi.history.api.events.task.TaskCompletedEvent;
import pro.taskana.spi.history.api.events.task.TaskCreatedEvent;
import pro.taskana.spi.history.api.events.task.TaskTerminatedEvent;
import pro.taskana.spi.history.api.events.task.TaskUpdatedEvent;
import pro.taskana.spi.history.internal.HistoryEventManager;
import pro.taskana.task.api.CallbackState;
import pro.taskana.task.api.TaskCustomField;
@ -233,9 +228,10 @@ public class TaskServiceImpl implements TaskService {
LOGGER.debug("Method createTask() created Task '{}'.", task.getId());
if (HistoryEventManager.isHistoryEnabled()) {
String details = determineChangesInTaskAttributes(newTask(), task);
String details =
ObjectAttributeChangeDetector.determineChangesInAttributes(newTask(), task);
historyEventManager.createEvent(
new CreatedEvent(
new TaskCreatedEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_HISTORY_EVENT),
task,
CurrentUserContext.getUserid(),
@ -440,10 +436,11 @@ public class TaskServiceImpl implements TaskService {
if (HistoryEventManager.isHistoryEnabled()) {
String changeDetails = determineChangesInTaskAttributes(oldTaskImpl, newTaskImpl);
String changeDetails =
ObjectAttributeChangeDetector.determineChangesInAttributes(oldTaskImpl, newTaskImpl);
historyEventManager.createEvent(
new UpdatedEvent(
new TaskUpdatedEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_HISTORY_EVENT),
task,
CurrentUserContext.getUserid(),
@ -807,7 +804,7 @@ public class TaskServiceImpl implements TaskService {
if (HistoryEventManager.isHistoryEnabled()) {
historyEventManager.createEvent(
new CancelledEvent(
new TaskCancelledEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_HISTORY_EVENT),
cancelledTask,
CurrentUserContext.getUserid()));
@ -835,7 +832,7 @@ public class TaskServiceImpl implements TaskService {
if (HistoryEventManager.isHistoryEnabled()) {
historyEventManager.createEvent(
new TerminatedEvent(
new TaskTerminatedEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_HISTORY_EVENT),
terminatedTask,
CurrentUserContext.getUserid()));
@ -921,58 +918,6 @@ public class TaskServiceImpl implements TaskService {
}
}
protected String determineChangesInTaskAttributes(Task oldTaskImpl, Task newTaskImpl) {
LOGGER.debug(
"Entry to determineChangesInTaskAttributes (oldTaskImpl = {}, newTaskImpl = {}",
oldTaskImpl,
newTaskImpl);
List<Field> fields = new ArrayList<>();
Class<?> currentClass = oldTaskImpl.getClass();
while (currentClass.getSuperclass() != null) {
fields.addAll(Arrays.asList(currentClass.getDeclaredFields()));
currentClass = currentClass.getSuperclass();
}
Predicate<Triplet<Field, Object, Object>> areFieldsNotEqual =
fieldAndValuePairTriplet ->
!Objects.equals(
fieldAndValuePairTriplet.getMiddle(), fieldAndValuePairTriplet.getRight());
Predicate<Triplet<Field, Object, Object>> isFieldNotCustomAttributes =
fieldAndValuePairTriplet ->
!fieldAndValuePairTriplet.getLeft().getName().equals("customAttributes");
List<JSONObject> changedAttributes =
fields.stream()
.peek(field -> field.setAccessible(true))
.map(
CheckedFunction.wrap(
field -> new Triplet<>(field, field.get(oldTaskImpl), field.get(newTaskImpl))))
.filter(areFieldsNotEqual.and(isFieldNotCustomAttributes))
.map(
fieldAndValuePairTriplet -> {
JSONObject changedAttribute = new JSONObject();
changedAttribute.put("fieldName", fieldAndValuePairTriplet.getLeft().getName());
changedAttribute.put(
"oldValue",
Optional.ofNullable(fieldAndValuePairTriplet.getMiddle()).orElse(""));
changedAttribute.put(
"newValue",
Optional.ofNullable(fieldAndValuePairTriplet.getRight()).orElse(""));
return changedAttribute;
})
.collect(Collectors.toList());
JSONObject changes = new JSONObject();
changes.put("changes", changedAttributes);
LOGGER.debug("Exit from determineChangesInTaskAttributes()");
return changes.toString();
}
Pair<List<MinimalTaskSummary>, BulkLog> getMinimalTaskSummaries(List<String> argTaskIds) {
BulkLog bulkLog = new BulkLog();
// remove duplicates
@ -1241,7 +1186,7 @@ public class TaskServiceImpl implements TaskService {
LOGGER.debug("Task '{}' claimed by user '{}'.", taskId, userId);
if (HistoryEventManager.isHistoryEnabled()) {
historyEventManager.createEvent(
new ClaimedEvent(
new TaskClaimedEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_HISTORY_EVENT),
task,
CurrentUserContext.getUserid()));
@ -1341,7 +1286,7 @@ public class TaskServiceImpl implements TaskService {
LOGGER.debug("Task '{}' unclaimed by user '{}'.", taskId, userId);
if (HistoryEventManager.isHistoryEnabled()) {
historyEventManager.createEvent(
new ClaimCancelledEvent(
new TaskClaimCancelledEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_HISTORY_EVENT),
task,
CurrentUserContext.getUserid()));
@ -1382,7 +1327,7 @@ public class TaskServiceImpl implements TaskService {
LOGGER.debug("Task '{}' completed by user '{}'.", taskId, userId);
if (HistoryEventManager.isHistoryEnabled()) {
historyEventManager.createEvent(
new CompletedEvent(
new TaskCompletedEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_HISTORY_EVENT),
task,
CurrentUserContext.getUserid()));
@ -1957,7 +1902,7 @@ public class TaskServiceImpl implements TaskService {
taskSummaries.forEach(
task ->
historyEventManager.createEvent(
new CompletedEvent(
new TaskCompletedEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_HISTORY_EVENT),
task,
CurrentUserContext.getUserid())));

4
lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskTransferrer.java
View File

@ -17,7 +17,7 @@ import pro.taskana.common.api.exceptions.TaskanaException;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.common.internal.security.CurrentUserContext;
import pro.taskana.common.internal.util.IdGenerator;
import pro.taskana.spi.history.api.events.task.TransferredEvent;
import pro.taskana.spi.history.api.events.task.TaskTransferredEvent;
import pro.taskana.spi.history.internal.HistoryEventManager;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.exceptions.InvalidStateException;
@ -367,7 +367,7 @@ public class TaskTransferrer {
private void createTaskTransferredEvent(
Task task, WorkbasketSummary oldWorkbasketSummary, WorkbasketSummary newWorkbasketSummary) {
historyEventManager.createEvent(
new TransferredEvent(
new TaskTransferredEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_HISTORY_EVENT),
task,
oldWorkbasketSummary,

32
lib/taskana-core/src/main/java/pro/taskana/workbasket/internal/WorkbasketAccessMapper.java
View File

@ -79,6 +79,38 @@ public interface WorkbasketAccessMapper {
})
List<WorkbasketAccessItemImpl> findByWorkbasketId(@Param("id") String id);
@Select(
"<script>SELECT WBA.ID, WORKBASKET_ID, WB.KEY, ACCESS_ID, ACCESS_NAME, PERM_READ, PERM_OPEN, PERM_APPEND, PERM_TRANSFER, PERM_DISTRIBUTE, PERM_CUSTOM_1, PERM_CUSTOM_2, PERM_CUSTOM_3, PERM_CUSTOM_4, PERM_CUSTOM_5, PERM_CUSTOM_6, PERM_CUSTOM_7, PERM_CUSTOM_8, PERM_CUSTOM_9, PERM_CUSTOM_10, PERM_CUSTOM_11, PERM_CUSTOM_12 "
+ "FROM WORKBASKET_ACCESS_LIST AS WBA LEFT JOIN WORKBASKET AS WB ON WORKBASKET_ID = WB.ID WHERE ACCESS_ID = #{id} "
+ "<if test=\"_databaseId == 'db2'\">with UR </if> "
+ "</script>")
@Results(
value = {
@Result(property = "id", column = "ID"),
@Result(property = "workbasketId", column = "WORKBASKET_ID"),
@Result(property = "workbasketKey", column = "KEY"),
@Result(property = "accessId", column = "ACCESS_ID"),
@Result(property = "accessName", column = "ACCESS_NAME"),
@Result(property = "permRead", column = "PERM_READ"),
@Result(property = "permOpen", column = "PERM_OPEN"),
@Result(property = "permAppend", column = "PERM_APPEND"),
@Result(property = "permTransfer", column = "PERM_TRANSFER"),
@Result(property = "permDistribute", column = "PERM_DISTRIBUTE"),
@Result(property = "permCustom1", column = "PERM_CUSTOM_1"),
@Result(property = "permCustom2", column = "PERM_CUSTOM_2"),
@Result(property = "permCustom3", column = "PERM_CUSTOM_3"),
@Result(property = "permCustom4", column = "PERM_CUSTOM_4"),
@Result(property = "permCustom5", column = "PERM_CUSTOM_5"),
@Result(property = "permCustom6", column = "PERM_CUSTOM_6"),
@Result(property = "permCustom7", column = "PERM_CUSTOM_7"),
@Result(property = "permCustom8", column = "PERM_CUSTOM_8"),
@Result(property = "permCustom9", column = "PERM_CUSTOM_9"),
@Result(property = "permCustom10", column = "PERM_CUSTOM_10"),
@Result(property = "permCustom11", column = "PERM_CUSTOM_11"),
@Result(property = "permCustom12", column = "PERM_CUSTOM_12")
})
List<WorkbasketAccessItemImpl> findByAccessId(@Param("id") String id);
@Insert(
"INSERT INTO WORKBASKET_ACCESS_LIST (ID, WORKBASKET_ID, ACCESS_ID, ACCESS_NAME, PERM_READ, PERM_OPEN, PERM_APPEND, PERM_TRANSFER, PERM_DISTRIBUTE, PERM_CUSTOM_1, PERM_CUSTOM_2, PERM_CUSTOM_3, PERM_CUSTOM_4, PERM_CUSTOM_5, PERM_CUSTOM_6, PERM_CUSTOM_7, PERM_CUSTOM_8, PERM_CUSTOM_9, PERM_CUSTOM_10, PERM_CUSTOM_11, PERM_CUSTOM_12) "
+ "VALUES (#{workbasketAccessItem.id}, #{workbasketAccessItem.workbasketId}, #{workbasketAccessItem.accessId}, #{workbasketAccessItem.accessName}, #{workbasketAccessItem.permRead}, #{workbasketAccessItem.permOpen}, #{workbasketAccessItem.permAppend}, #{workbasketAccessItem.permTransfer}, #{workbasketAccessItem.permDistribute}, #{workbasketAccessItem.permCustom1}, #{workbasketAccessItem.permCustom2}, #{workbasketAccessItem.permCustom3}, #{workbasketAccessItem.permCustom4}, #{workbasketAccessItem.permCustom5}, #{workbasketAccessItem.permCustom6}, #{workbasketAccessItem.permCustom7}, #{workbasketAccessItem.permCustom8}, #{workbasketAccessItem.permCustom9}, #{workbasketAccessItem.permCustom10}, #{workbasketAccessItem.permCustom11}, #{workbasketAccessItem.permCustom12})")

292
lib/taskana-core/src/main/java/pro/taskana/workbasket/internal/WorkbasketServiceImpl.java
View File

@ -23,6 +23,19 @@ import pro.taskana.common.api.exceptions.TaskanaException;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.common.internal.security.CurrentUserContext;
import pro.taskana.common.internal.util.IdGenerator;
import pro.taskana.common.internal.util.ObjectAttributeChangeDetector;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketAccessItemCreatedEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketAccessItemDeletedEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketAccessItemUpdatedEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketAccessItemsUpdatedEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketCreatedEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketDeletedEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketDistributionTargetAddedEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketDistributionTargetRemovedEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketDistributionTargetsUpdatedEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketMarkedForDeletionEvent;
import pro.taskana.spi.history.api.events.workbasket.WorkbasketUpdatedEvent;
import pro.taskana.spi.history.internal.HistoryEventManager;
import pro.taskana.task.api.TaskState;
import pro.taskana.workbasket.api.WorkbasketAccessItemQuery;
import pro.taskana.workbasket.api.WorkbasketPermission;
@ -46,10 +59,12 @@ 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 String ID_PREFIX_WORKBASKET_HISTORY_EVENT = "WHI";
private final InternalTaskanaEngine taskanaEngine;
private final WorkbasketMapper workbasketMapper;
private final DistributionTargetMapper distributionTargetMapper;
private final WorkbasketAccessMapper workbasketAccessMapper;
private final HistoryEventManager historyEventManager;
public WorkbasketServiceImpl(
InternalTaskanaEngine taskanaEngine,
@ -60,6 +75,7 @@ public class WorkbasketServiceImpl implements WorkbasketService {
this.workbasketMapper = workbasketMapper;
this.distributionTargetMapper = distributionTargetMapper;
this.workbasketAccessMapper = workbasketAccessMapper;
this.historyEventManager = taskanaEngine.getHistoryEventManager();
}
@Override
@ -137,6 +153,19 @@ public class WorkbasketServiceImpl implements WorkbasketService {
validateWorkbasket(workbasket);
workbasketMapper.insert(workbasket);
if (HistoryEventManager.isHistoryEnabled()) {
String details =
ObjectAttributeChangeDetector.determineChangesInAttributes(
newWorkbasket("", ""), newWorkbasket);
historyEventManager.createEvent(
new WorkbasketCreatedEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_HISTORY_EVENT),
newWorkbasket,
CurrentUserContext.getUserid(),
details));
}
LOGGER.debug("Method createWorkbasket() created Workbasket '{}'", workbasket);
return workbasket;
} finally {
@ -176,6 +205,20 @@ public class WorkbasketServiceImpl implements WorkbasketService {
workbasketMapper.update(workbasketImplToUpdate);
}
if (HistoryEventManager.isHistoryEnabled()) {
String details =
ObjectAttributeChangeDetector.determineChangesInAttributes(
oldWorkbasket, workbasketToUpdate);
historyEventManager.createEvent(
new WorkbasketUpdatedEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_HISTORY_EVENT),
workbasketToUpdate,
CurrentUserContext.getUserid(),
details));
}
LOGGER.debug(
"Method updateWorkbasket() updated workbasket '{}'", workbasketImplToUpdate.getId());
@ -231,6 +274,20 @@ public class WorkbasketServiceImpl implements WorkbasketService {
}
try {
workbasketAccessMapper.insert(accessItem);
if (HistoryEventManager.isHistoryEnabled()) {
String details =
ObjectAttributeChangeDetector.determineChangesInAttributes(
newWorkbasketAccessItem("", ""), accessItem);
historyEventManager.createEvent(
new WorkbasketAccessItemCreatedEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_HISTORY_EVENT),
wb,
CurrentUserContext.getUserid(),
details));
}
LOGGER.debug(
"Method createWorkbasketAccessItem() created workbaskteAccessItem {}", accessItem);
} catch (PersistenceException e) {
@ -276,6 +333,22 @@ public class WorkbasketServiceImpl implements WorkbasketService {
}
workbasketAccessMapper.update(accessItem);
if (HistoryEventManager.isHistoryEnabled()) {
String details =
ObjectAttributeChangeDetector.determineChangesInAttributes(originalItem, accessItem);
Workbasket workbasket = workbasketMapper.findById(accessItem.getWorkbasketId());
historyEventManager.createEvent(
new WorkbasketAccessItemUpdatedEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_HISTORY_EVENT),
workbasket,
CurrentUserContext.getUserid(),
details));
}
LOGGER.debug(
"Method updateWorkbasketAccessItem() updated workbasketAccessItem {}", accessItem);
return accessItem;
@ -292,7 +365,29 @@ public class WorkbasketServiceImpl implements WorkbasketService {
taskanaEngine.getEngine().checkRoleMembership(TaskanaRole.BUSINESS_ADMIN, TaskanaRole.ADMIN);
try {
taskanaEngine.openConnection();
WorkbasketAccessItem accessItem = null;
if (HistoryEventManager.isHistoryEnabled()) {
accessItem = workbasketAccessMapper.findById(accessItemId);
}
workbasketAccessMapper.delete(accessItemId);
if (HistoryEventManager.isHistoryEnabled() && accessItem != null) {
String details =
ObjectAttributeChangeDetector.determineChangesInAttributes(
accessItem, newWorkbasketAccessItem("", ""));
Workbasket workbasket = workbasketMapper.findById(accessItem.getWorkbasketId());
historyEventManager.createEvent(
new WorkbasketAccessItemDeletedEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_HISTORY_EVENT),
workbasket,
CurrentUserContext.getUserid(),
details));
}
LOGGER.debug(
"Method deleteWorkbasketAccessItem() deleted workbasketAccessItem wit Id {}",
accessItemId);
@ -433,44 +528,43 @@ public class WorkbasketServiceImpl implements WorkbasketService {
@Override
public void setWorkbasketAccessItems(
String workbasketId, List<WorkbasketAccessItem> wbAccessItems)
throws InvalidArgumentException, NotAuthorizedException,
WorkbasketAccessItemAlreadyExistException {
throws NotAuthorizedException, WorkbasketAccessItemAlreadyExistException,
InvalidArgumentException {
LOGGER.debug(
"entry to setWorkbasketAccessItems(workbasketAccessItems = {})", wbAccessItems);
taskanaEngine.getEngine().checkRoleMembership(TaskanaRole.BUSINESS_ADMIN, TaskanaRole.ADMIN);
Set<String> ids = new HashSet<>();
Set<WorkbasketAccessItemImpl> accessItems = new HashSet<>();
for (WorkbasketAccessItem workbasketAccessItem : wbAccessItems) {
WorkbasketAccessItemImpl wbAccessItemImpl = (WorkbasketAccessItemImpl) workbasketAccessItem;
// Check pre-conditions and set ID
if (wbAccessItemImpl.getWorkbasketId() == null) {
throw new InvalidArgumentException(
String.format(
"Checking the preconditions of the current WorkbasketAccessItem failed "
+ "- WBID is NULL. WorkbasketAccessItem=%s",
workbasketAccessItem));
} else if (!wbAccessItemImpl.getWorkbasketId().equals(workbasketId)) {
throw new InvalidArgumentException(
String.format(
"Checking the preconditions of the current WorkbasketAccessItem failed "
+ "- the WBID does not match. Target-WBID=''%s'' WorkbasketAccessItem=%s",
workbasketId, workbasketAccessItem));
}
if (wbAccessItemImpl.getId() == null || wbAccessItemImpl.getId().isEmpty()) {
wbAccessItemImpl.setId(IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_AUTHORIZATION));
}
if (ids.contains(wbAccessItemImpl.getAccessId())) {
throw new WorkbasketAccessItemAlreadyExistException(wbAccessItemImpl);
}
ids.add(wbAccessItemImpl.getAccessId());
accessItems.add(wbAccessItemImpl);
}
Set<WorkbasketAccessItemImpl> accessItems =
checkAccessItemsPreconditionsAndSetId(workbasketId, ids, wbAccessItems);
try {
taskanaEngine.openConnection();
List<WorkbasketAccessItemImpl> originalAccessItems = new ArrayList<>();
if (HistoryEventManager.isHistoryEnabled()) {
originalAccessItems = workbasketAccessMapper.findByWorkbasketId(workbasketId);
}
// delete all current ones
workbasketAccessMapper.deleteAllAccessItemsForWorkbasketId(workbasketId);
accessItems.forEach(workbasketAccessMapper::insert);
if (HistoryEventManager.isHistoryEnabled()) {
String details =
ObjectAttributeChangeDetector.determineChangesInAttributes(
originalAccessItems, new ArrayList<>(accessItems));
Workbasket workbasket = workbasketMapper.findById(workbasketId);
historyEventManager.createEvent(
new WorkbasketAccessItemsUpdatedEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_HISTORY_EVENT),
workbasket,
CurrentUserContext.getUserid(),
details));
}
} finally {
taskanaEngine.returnConnection();
LOGGER.debug("exit from setWorkbasketAccessItems(workbasketAccessItems = {})", wbAccessItems);
@ -579,6 +673,13 @@ public class WorkbasketServiceImpl implements WorkbasketService {
taskanaEngine.openConnection();
// check existence of source workbasket
WorkbasketImpl sourceWorkbasket = (WorkbasketImpl) getWorkbasket(sourceWorkbasketId);
List<String> originalTargetWorkbasketIds = new ArrayList<>();
if (HistoryEventManager.isHistoryEnabled()) {
originalTargetWorkbasketIds = distributionTargetMapper.findBySourceId(sourceWorkbasketId);
}
distributionTargetMapper.deleteAllDistributionTargetsBySourceId(sourceWorkbasketId);
sourceWorkbasket.setModified(Instant.now());
@ -595,7 +696,22 @@ public class WorkbasketServiceImpl implements WorkbasketService {
sourceWorkbasketId,
targetId);
}
if (HistoryEventManager.isHistoryEnabled() && !targetWorkbasketIds.isEmpty()) {
String details =
ObjectAttributeChangeDetector.determineChangesInAttributes(
originalTargetWorkbasketIds, targetWorkbasketIds);
historyEventManager.createEvent(
new WorkbasketDistributionTargetsUpdatedEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_HISTORY_EVENT),
sourceWorkbasket,
CurrentUserContext.getUserid(),
details));
}
}
} finally {
taskanaEngine.returnConnection();
if (LOGGER.isDebugEnabled()) {
@ -631,6 +747,19 @@ public class WorkbasketServiceImpl implements WorkbasketService {
+ "distribution target exists already. Doing nothing.");
} else {
distributionTargetMapper.insert(sourceWorkbasketId, targetWorkbasketId);
if (HistoryEventManager.isHistoryEnabled()) {
String details =
"{\"changes\":{\"newValue\":\"" + targetWorkbasketId + "\",\"oldValue\":\"\"}}";
historyEventManager.createEvent(
new WorkbasketDistributionTargetAddedEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_HISTORY_EVENT),
sourceWorkbasket,
CurrentUserContext.getUserid(),
details));
}
LOGGER.debug(
"addDistributionTarget inserted distribution target sourceId = {}, targetId = {}",
sourceWorkbasketId,
@ -663,6 +792,24 @@ public class WorkbasketServiceImpl implements WorkbasketService {
sourceWorkbasketId, targetWorkbasketId);
if (numberOfDistTargets > 0) {
distributionTargetMapper.delete(sourceWorkbasketId, targetWorkbasketId);
if (HistoryEventManager.isHistoryEnabled()) {
Workbasket workbasket = workbasketMapper.findById(sourceWorkbasketId);
if (workbasket != null) {
String details =
"{\"changes\":{\"newValue\":\"\",\"oldValue\":\"" + targetWorkbasketId + "\"}}";
historyEventManager.createEvent(
new WorkbasketDistributionTargetRemovedEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_HISTORY_EVENT),
workbasket,
CurrentUserContext.getUserid(),
details));
}
}
LOGGER.debug(
"removeDistributionTarget deleted distribution target sourceId = {}, targetId = {}",
sourceWorkbasketId,
@ -702,8 +849,9 @@ public class WorkbasketServiceImpl implements WorkbasketService {
try {
taskanaEngine.openConnection();
Workbasket workbasketToDelete;
try {
this.getWorkbasket(workbasketId);
workbasketToDelete = this.getWorkbasket(workbasketId);
} catch (WorkbasketNotFoundException ex) {
LOGGER.debug("Workbasket with workbasketId = {} is already deleted?", workbasketId);
throw ex;
@ -728,9 +876,24 @@ public class WorkbasketServiceImpl implements WorkbasketService {
if (canBeDeletedNow) {
workbasketMapper.delete(workbasketId);
deleteReferencesToWorkbasket(workbasketId);
if (HistoryEventManager.isHistoryEnabled()) {
String details =
ObjectAttributeChangeDetector.determineChangesInAttributes(
workbasketToDelete, newWorkbasket("", ""));
historyEventManager.createEvent(
new WorkbasketDeletedEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_HISTORY_EVENT),
workbasketToDelete,
CurrentUserContext.getUserid(),
details));
}
} else {
markWorkbasketForDeletion(workbasketId);
}
return canBeDeletedNow;
} finally {
taskanaEngine.returnConnection();
@ -856,7 +1019,31 @@ public class WorkbasketServiceImpl implements WorkbasketService {
if (TaskanaEngineConfiguration.shouldUseLowerCaseForAccessIds() && accessId != null) {
accessId = accessId.toLowerCase();
}
List<WorkbasketAccessItemImpl> workbasketAccessItems = new ArrayList<>();
if (HistoryEventManager.isHistoryEnabled()) {
workbasketAccessItems = workbasketAccessMapper.findByAccessId(accessId);
}
workbasketAccessMapper.deleteAccessItemsForAccessId(accessId);
if (HistoryEventManager.isHistoryEnabled()) {
for (WorkbasketAccessItemImpl workbasketAccessItem : workbasketAccessItems) {
String details =
ObjectAttributeChangeDetector.determineChangesInAttributes(
workbasketAccessItem, new WorkbasketAccessItemImpl());
Workbasket workbasket = workbasketMapper.findById(workbasketAccessItem.getWorkbasketId());
historyEventManager.createEvent(
new WorkbasketAccessItemDeletedEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_HISTORY_EVENT),
workbasket,
CurrentUserContext.getUserid(),
details));
}
}
} finally {
taskanaEngine.returnConnection();
LOGGER.debug("exit from deleteWorkbasketAccessItemsForAccessId(accessId={}).", accessId);
@ -882,6 +1069,44 @@ public class WorkbasketServiceImpl implements WorkbasketService {
}
}
private Set<WorkbasketAccessItemImpl> checkAccessItemsPreconditionsAndSetId(
String workbasketId, Set<String> ids, List<WorkbasketAccessItem> wbAccessItems)
throws InvalidArgumentException, WorkbasketAccessItemAlreadyExistException {
Set<WorkbasketAccessItemImpl> accessItems = new HashSet<>();
for (WorkbasketAccessItem workbasketAccessItem : wbAccessItems) {
if (workbasketAccessItem != null) {
WorkbasketAccessItemImpl wbAccessItemImpl = (WorkbasketAccessItemImpl) workbasketAccessItem;
if (wbAccessItemImpl.getWorkbasketId() == null) {
throw new InvalidArgumentException(
String.format(
"Checking the preconditions of the current WorkbasketAccessItem failed "
+ "- WBID is NULL. WorkbasketAccessItem=%s",
workbasketAccessItem));
} else if (!wbAccessItemImpl.getWorkbasketId().equals(workbasketId)) {
throw new InvalidArgumentException(
String.format(
"Checking the preconditions of the current WorkbasketAccessItem failed "
+ "- the WBID does not match. Target-WBID=''%s'' WorkbasketAccessItem=%s",
workbasketId, workbasketAccessItem));
}
if (wbAccessItemImpl.getId() == null || wbAccessItemImpl.getId().isEmpty()) {
wbAccessItemImpl.setId(
IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_AUTHORIZATION));
}
if (ids.contains(wbAccessItemImpl.getAccessId())) {
throw new WorkbasketAccessItemAlreadyExistException(wbAccessItemImpl);
}
ids.add(wbAccessItemImpl.getAccessId());
accessItems.add(wbAccessItemImpl);
}
}
return accessItems;
}
private void validateWorkbasketId(String workbasketId) throws InvalidArgumentException {
if (workbasketId == null) {
throw new InvalidArgumentException("The WorkbasketId can´t be NULL");
@ -981,6 +1206,15 @@ public class WorkbasketServiceImpl implements WorkbasketService {
WorkbasketImpl workbasket = workbasketMapper.findById(workbasketId);
workbasket.setMarkedForDeletion(true);
workbasketMapper.update(workbasket);
if (HistoryEventManager.isHistoryEnabled()) {
historyEventManager.createEvent(
new WorkbasketMarkedForDeletionEvent(
IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_HISTORY_EVENT),
workbasket,
CurrentUserContext.getUserid(),
null));
}
} finally {
taskanaEngine.returnConnection();
LOGGER.debug("exit from markWorkbasketForDeletion(workbasketId = {}).", workbasketId);

25
lib/taskana-core/src/main/resources/sql/db2/taskana-schema-db2.sql
View File

@ -206,7 +206,7 @@ CREATE TABLE SCHEDULED_JOB(
PRIMARY KEY (JOB_ID)
);
CREATE TABLE HISTORY_EVENTS
CREATE TABLE TASK_HISTORY_EVENT
(
ID VARCHAR(40) NOT NULL,
BUSINESS_PROCESS_ID VARCHAR(128) NULL,
@ -235,6 +235,29 @@ CREATE TABLE HISTORY_EVENTS
PRIMARY KEY (ID)
);
CREATE TABLE WORKBASKET_HISTORY_EVENT
(
ID VARCHAR(40) NOT NULL,
EVENT_TYPE VARCHAR(40) NULL,
CREATED TIMESTAMP NULL,
USER_ID VARCHAR(32) NULL,
DOMAIN VARCHAR(32) NULL,
WORKBASKET_ID VARCHAR(40) NULL,
WORKBASKET_KEY VARCHAR(64) NULL,
WORKBASKET_TYPE VARCHAR(64) NULL,
OWNER VARCHAR(32) NULL,
CUSTOM_1 VARCHAR(128) NULL,
CUSTOM_2 VARCHAR(128) NULL,
CUSTOM_3 VARCHAR(128) NULL,
CUSTOM_4 VARCHAR(128) NULL,
ORGLEVEL_1 VARCHAR(128) NULL,
ORGLEVEL_2 VARCHAR(128) NULL,
ORGLEVEL_3 VARCHAR(128) NULL,
ORGLEVEL_4 VARCHAR(128) NULL,
DETAILS CLOB NULL,
PRIMARY KEY (ID)
);
CREATE SEQUENCE SCHEDULED_JOB_SEQ
MINVALUE 1
START WITH 1

5
lib/taskana-core/src/main/resources/sql/db2/taskana_schema_update_3.0.0_4.0.0_db2.sql → lib/taskana-core/src/main/resources/sql/db2/taskana_schema_update_3.0.0_to_4.0.0_db2.sql
View File

@ -13,3 +13,8 @@ CALL SYSPROC.ADMIN_CMD ( 'REORG TABLE HISTORY_EVENTS allow read access' );
ALTER TABLE HISTORY_EVENTS ADD PRIMARY KEY (ID);
CALL SYSPROC.ADMIN_CMD ( 'REORG TABLE HISTORY_EVENTS allow read access' );
RENAME TABLE HISTORY_EVENTS TO TASK_HISTORY_EVENT;
UPDATE TASK_HISTORY_EVENT SET ID = REPLACE(ID,'HEI','THI') WHERE ID LIKE '%HEI%';

25
lib/taskana-core/src/main/resources/sql/h2/taskana-schema-h2.sql
View File

@ -209,7 +209,7 @@ CREATE TABLE SCHEDULED_JOB(
PRIMARY KEY (JOB_ID)
);
CREATE TABLE HISTORY_EVENTS
CREATE TABLE TASK_HISTORY_EVENT
(
ID VARCHAR(40) NOT NULL,
BUSINESS_PROCESS_ID VARCHAR(128) NULL,
@ -238,6 +238,29 @@ CREATE TABLE HISTORY_EVENTS
PRIMARY KEY (ID)
);
CREATE TABLE WORKBASKET_HISTORY_EVENT
(
ID VARCHAR(40) NOT NULL,
EVENT_TYPE VARCHAR(40) NULL,
CREATED TIMESTAMP NULL,
USER_ID VARCHAR(32) NULL,
DOMAIN VARCHAR(32) NULL,
WORKBASKET_ID VARCHAR(40) NULL,
WORKBASKET_KEY VARCHAR(64) NULL,
WORKBASKET_TYPE VARCHAR(64) NULL,
OWNER VARCHAR(32) NULL,
CUSTOM_1 VARCHAR(128) NULL,
CUSTOM_2 VARCHAR(128) NULL,
CUSTOM_3 VARCHAR(128) NULL,
CUSTOM_4 VARCHAR(128) NULL,
ORGLEVEL_1 VARCHAR(128) NULL,
ORGLEVEL_2 VARCHAR(128) NULL,
ORGLEVEL_3 VARCHAR(128) NULL,
ORGLEVEL_4 VARCHAR(128) NULL,
DETAILS CLOB NULL,
PRIMARY KEY (ID)
);
CREATE TABLE CONFIGURATION (
ENFORCE_SECURITY BOOLEAN NOT NULL
);

6
lib/taskana-core/src/main/resources/sql/h2/taskana_schema_update_3.0.0_4.0.0_h2.sql → lib/taskana-core/src/main/resources/sql/h2/taskana_schema_update_3.0.0_to_4.0.0_h2.sql
View File

@ -5,3 +5,9 @@ SET SCHEMA %schemaName%;
INSERT INTO TASKANA_SCHEMA_VERSION (VERSION, CREATED) VALUES ('4.0.0', CURRENT_TIMESTAMP);
ALTER TABLE HISTORY_EVENTS ALTER COLUMN ID VARCHAR(40);
ALTER TABLE HISTORY_EVENTS RENAME TO TASK_HISTORY_EVENT;
UPDATE TASK_HISTORY_EVENT SET ID = REPLACE(ID,'HEI','THI') WHERE ID LIKE '%HEI%';

27
lib/taskana-core/src/main/resources/sql/postgres/taskana-schema-postgres.sql
View File

@ -204,7 +204,7 @@ CREATE TABLE SCHEDULED_JOB(
PRIMARY KEY (JOB_ID)
);
CREATE TABLE HISTORY_EVENTS
CREATE TABLE TASK_HISTORY_EVENT
(
ID VARCHAR(40) NOT NULL,
BUSINESS_PROCESS_ID VARCHAR(128) NULL,
@ -233,6 +233,31 @@ CREATE TABLE HISTORY_EVENTS
PRIMARY KEY (ID)
);
CREATE TABLE WORKBASKET_HISTORY_EVENT
(
ID VARCHAR(40) NOT NULL,
WORKBASKET_ID VARCHAR(40) NULL,
EVENT_TYPE VARCHAR(40) NULL,
CREATED TIMESTAMP NULL,
USER_ID VARCHAR(32) NULL,
DOMAIN VARCHAR(32) NULL,
WORKBASKET_KEY VARCHAR(64) NULL,
WORKBASKET_TYPE VARCHAR(64) NULL,
OWNER VARCHAR(32) NULL,
OLD_VALUE VARCHAR(255) NULL,
NEW_VALUE VARCHAR(255) NULL,
CUSTOM_1 VARCHAR(128) NULL,
CUSTOM_2 VARCHAR(128) NULL,
CUSTOM_3 VARCHAR(128) NULL,
CUSTOM_4 VARCHAR(128) NULL,
ORGLEVEL_1 VARCHAR(128) NULL,
ORGLEVEL_2 VARCHAR(128) NULL,
ORGLEVEL_3 VARCHAR(128) NULL,
ORGLEVEL_4 VARCHAR(128) NULL,
DETAILS TEXT NULL,
PRIMARY KEY (ID)
);
CREATE TABLE CONFIGURATION (
ENFORCE_SECURITY BOOLEAN NOT NULL
);

4
lib/taskana-core/src/main/resources/sql/postgres/taskana_schema_update_3.0.0_4.0.0_postgres.sql → lib/taskana-core/src/main/resources/sql/postgres/taskana_schema_update_3.0.0_to_4.0.0_postgres.sql
View File

@ -7,3 +7,7 @@ INSERT INTO TASKANA_SCHEMA_VERSION (VERSION, CREATED) VALUES ('4.0.0', CURRENT_T
ALTER TABLE HISTORY_EVENTS ALTER COLUMN ID DROP IDENTITY;
ALTER TABLE HISTORY_EVENTS ALTER COLUMN ID TYPE VARCHAR(40);
ALTER TABLE HISTORY_EVENTS RENAME TO TASK_HISTORY_EVENT;
UPDATE TASK_HISTORY_EVENT SET ID = REPLACE(ID,'HEI','THI') WHERE ID LIKE '%HEI%';

2
lib/taskana-core/src/test/java/pro/taskana/ArchitectureTest.java
View File

@ -162,6 +162,8 @@ class ArchitectureTest {
.that()
.haveNameNotMatching(".*TaskanaEngine.*")
.and()
.haveSimpleNameNotEndingWith("ObjectAttributeChangeDetectorTest")
.and()
.haveSimpleNameNotEndingWith("AbstractTaskanaJob")
.and()
.resideInAPackage("..common..")

277
lib/taskana-core/src/test/java/pro/taskana/common/internal/util/ObjectAttributeChangeDetectorTest.java Normal file
View File

@ -0,0 +1,277 @@
package pro.taskana.common.internal.util;
import static org.assertj.core.api.Assertions.assertThat;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.json.JSONArray;
import org.json.JSONObject;
import org.junit.jupiter.api.Test;
import pro.taskana.task.api.CallbackState;
import pro.taskana.task.internal.models.TaskImpl;
import pro.taskana.workbasket.api.WorkbasketType;
import pro.taskana.workbasket.internal.models.WorkbasketAccessItemImpl;
import pro.taskana.workbasket.internal.models.WorkbasketImpl;
class ObjectAttributeChangeDetectorTest {
@Test
void should_DetermineDifferences_When_ComparingEmptyTaskWithNonEmptyTask() {
TaskImpl newTask = new TaskImpl();
newTask.setOwner("new Owner");
newTask.setCreator("new Creator");
newTask.setId("new ID");
newTask.setCreated(Instant.now());
newTask.setModified(Instant.now());
newTask.setClassificationKey("new ClassificationKey");
newTask.setWorkbasketKey("new WorkbasketKey");
newTask.setBusinessProcessId("new BusinessProcessId");
newTask.setCallbackState(CallbackState.CALLBACK_PROCESSING_REQUIRED);
TaskImpl oldTask = new TaskImpl();
JSONArray changedAttributes =
new JSONObject(ObjectAttributeChangeDetector.determineChangesInAttributes(oldTask, newTask))
.getJSONArray("changes");
assertThat(changedAttributes).hasSize(9);
changedAttributes =
new JSONObject(ObjectAttributeChangeDetector.determineChangesInAttributes(newTask, oldTask))
.getJSONArray("changes");
assertThat(changedAttributes).hasSize(9);
}
@Test
void should_DetermineDifferences_When_ComparingTasks() {
TaskImpl oldTask = new TaskImpl();
oldTask.setOwner("old Owner");
oldTask.setCreator("old Creator");
oldTask.setId("old ID");
oldTask.setCreated(Instant.now().minusMillis(100));
oldTask.setModified(Instant.now().minusMillis(100));
oldTask.setClassificationKey("old ClassificationKey");
oldTask.setWorkbasketKey("old WorkbasketKey");
oldTask.setBusinessProcessId("old BusinessProcessId");
oldTask.setCallbackState(CallbackState.NONE);
TaskImpl newTask = new TaskImpl();
newTask.setOwner("new Owner");
newTask.setCreator("new Creator");
newTask.setId("old ID");
newTask.setCreated(Instant.now());
newTask.setModified(Instant.now());
newTask.setClassificationKey("new ClassificationKey");
newTask.setWorkbasketKey("new WorkbasketKey");
newTask.setBusinessProcessId("new BusinessProcessId");
newTask.setCallbackState(CallbackState.CALLBACK_PROCESSING_REQUIRED);
JSONArray changedAttributes =
new JSONObject(ObjectAttributeChangeDetector.determineChangesInAttributes(oldTask, newTask))
.getJSONArray("changes");
assertThat(changedAttributes).hasSize(8);
}
@Test
void should_IgnoreDifferencesInCustomAttributes_When_CustomAttributesHaveChanged() {
TaskImpl oldTask = new TaskImpl();
oldTask.setOwner("old Owner");
oldTask.setCreator("old Creator");
TaskImpl newTask = new TaskImpl();
newTask.setOwner("new Owner");
newTask.setCreator("new Creator");
Map<String, String> customAttriutes = new HashMap<>();
customAttriutes.put("new key", "new value");
newTask.setCustomAttributes(customAttriutes);
JSONArray changedAttributes =
new JSONObject(ObjectAttributeChangeDetector.determineChangesInAttributes(oldTask, newTask))
.getJSONArray("changes");
assertThat(changedAttributes).hasSize(2);
}
@Test
void should_DetermineDifferences_When_ComparingWorkbaskets() {
Instant created = Instant.now();
WorkbasketImpl oldWorkbasket = new WorkbasketImpl();
oldWorkbasket.setId("oldWbId");
oldWorkbasket.setKey("oldWbKey");
oldWorkbasket.setDomain("oldWbDomain");
oldWorkbasket.setCreated(created.minus(10, ChronoUnit.SECONDS));
oldWorkbasket.setModified(created.minus(5, ChronoUnit.SECONDS));
oldWorkbasket.setName("oldWb");
oldWorkbasket.setType(WorkbasketType.PERSONAL);
oldWorkbasket.setOrgLevel1("oworgLevel1");
oldWorkbasket.setCustom1("owcustom1");
oldWorkbasket.setOrgLevel2("oworgLevel2");
oldWorkbasket.setCustom2("owcustom2");
oldWorkbasket.setOrgLevel3("oworgLevel3");
oldWorkbasket.setCustom3("owcustom3");
oldWorkbasket.setOrgLevel4("oworgLevel4");
oldWorkbasket.setCustom4("owcustom4");
WorkbasketImpl newWorkbasket = new WorkbasketImpl();
newWorkbasket.setId("newWbId");
newWorkbasket.setKey("newWbKey");
newWorkbasket.setDomain("oldWbDomain");
newWorkbasket.setName("newWb");
newWorkbasket.setCreated(created.minus(10, ChronoUnit.SECONDS));
newWorkbasket.setModified(created.minus(2, ChronoUnit.SECONDS));
newWorkbasket.setType(WorkbasketType.GROUP);
newWorkbasket.setOrgLevel1("nworgLevel1");
newWorkbasket.setCustom1("nwcustom1");
newWorkbasket.setOrgLevel2("nworgLevel2");
newWorkbasket.setCustom2("nwcustom2");
newWorkbasket.setOrgLevel3("nworgLevel3");
newWorkbasket.setCustom3("nwcustom3");
newWorkbasket.setOrgLevel4("nworgLevel4");
newWorkbasket.setCustom4("nwcustom4");
JSONArray changedAttributes =
new JSONObject(
ObjectAttributeChangeDetector.determineChangesInAttributes(
oldWorkbasket, newWorkbasket))
.getJSONArray("changes");
assertThat(changedAttributes).hasSize(13);
}
@Test
void should_DetermineDifferences_When_ComparingEmptyWorkbasketWithNonEmptyWorkbasket() {
Instant created = Instant.now();
WorkbasketImpl oldWorkbasket = new WorkbasketImpl();
WorkbasketImpl newWorkbasket = new WorkbasketImpl();
newWorkbasket.setId("newWbId");
newWorkbasket.setKey("newWbKey");
newWorkbasket.setDomain("newWbDomain");
newWorkbasket.setName("newWb");
newWorkbasket.setCreated(created.minus(10, ChronoUnit.SECONDS));
newWorkbasket.setModified(created.minus(2, ChronoUnit.SECONDS));
newWorkbasket.setType(WorkbasketType.PERSONAL);
newWorkbasket.setOrgLevel1("nworgLevel1");
newWorkbasket.setCustom1("nwcustom1");
newWorkbasket.setOrgLevel2("nworgLevel2");
newWorkbasket.setCustom2("nwcustom2");
newWorkbasket.setOrgLevel3("nworgLevel3");
newWorkbasket.setCustom3("nwcustom3");
newWorkbasket.setOrgLevel4("nworgLevel4");
newWorkbasket.setCustom4("nwcustom4");
JSONArray changedAttributes =
new JSONObject(
ObjectAttributeChangeDetector.determineChangesInAttributes(
oldWorkbasket, newWorkbasket))
.getJSONArray("changes");
assertThat(changedAttributes).hasSize(15);
changedAttributes =
new JSONObject(
ObjectAttributeChangeDetector.determineChangesInAttributes(
newWorkbasket, oldWorkbasket))
.getJSONArray("changes");
assertThat(changedAttributes).hasSize(15);
}
@Test
void should_DetermineDifferences_When_ComparingWorkbasketAccessItems() {
WorkbasketAccessItemImpl oldWorkbasketAccessItem = new WorkbasketAccessItemImpl();
oldWorkbasketAccessItem.setId("oldId");
oldWorkbasketAccessItem.setAccessId("oldAccessId");
oldWorkbasketAccessItem.setWorkbasketId("oldWorkbasketId");
WorkbasketAccessItemImpl newWorkbasketAccessItem = new WorkbasketAccessItemImpl();
newWorkbasketAccessItem.setId("newId");
newWorkbasketAccessItem.setAccessId("oldAccessId");
newWorkbasketAccessItem.setWorkbasketId("newWorkbasketId");
JSONArray changedAttributes =
new JSONObject(
ObjectAttributeChangeDetector.determineChangesInAttributes(
oldWorkbasketAccessItem, newWorkbasketAccessItem))
.getJSONArray("changes");
assertThat(changedAttributes).hasSize(2);
}
@Test
void should_DetermineDifferences_When_ComparingEmptyWorkbasketAccessItemWithNonEmptyWai() {
WorkbasketAccessItemImpl oldWorkbasketAccessItem = new WorkbasketAccessItemImpl();
oldWorkbasketAccessItem.setId("oldId");
oldWorkbasketAccessItem.setAccessId("oldAccessId");
oldWorkbasketAccessItem.setWorkbasketId("oldWorkbasketId");
WorkbasketAccessItemImpl newWorkbasketAccessItem = new WorkbasketAccessItemImpl();
JSONArray changedAttributes =
new JSONObject(
ObjectAttributeChangeDetector.determineChangesInAttributes(
oldWorkbasketAccessItem, newWorkbasketAccessItem))
.getJSONArray("changes");
assertThat(changedAttributes).hasSize(3);
changedAttributes =
new JSONObject(
ObjectAttributeChangeDetector.determineChangesInAttributes(
newWorkbasketAccessItem, oldWorkbasketAccessItem))
.getJSONArray("changes");
assertThat(changedAttributes).hasSize(3);
}
@Test
void should_DetermineDifferences_When_ComparingLists() {
List<WorkbasketAccessItemImpl> accessitems1 = new ArrayList<>();
WorkbasketAccessItemImpl workbasketAccessItem = new WorkbasketAccessItemImpl();
accessitems1.add(workbasketAccessItem);
WorkbasketAccessItemImpl workbasketAccessItem2 = new WorkbasketAccessItemImpl();
accessitems1.add(workbasketAccessItem2);
WorkbasketAccessItemImpl workbasketAccessItem3 = new WorkbasketAccessItemImpl();
accessitems1.add(workbasketAccessItem3);
List<WorkbasketAccessItemImpl> accessitems2 = new ArrayList<>();
WorkbasketAccessItemImpl workbasketAccessItem4 = new WorkbasketAccessItemImpl();
workbasketAccessItem4.setId("WAI:1000000000000000000000000000000001");
accessitems2.add(workbasketAccessItem4);
WorkbasketAccessItemImpl workbasketAccessItem5 = new WorkbasketAccessItemImpl();
workbasketAccessItem5.setId("WAI:1000000000000000000000000000000002");
accessitems2.add(workbasketAccessItem5);
JSONObject changedAttributes =
new JSONObject(
ObjectAttributeChangeDetector.determineChangesInAttributes(
accessitems1, accessitems2))
.getJSONObject("changes");
assertThat(changedAttributes.getJSONArray("newValue")).hasSize(2);
assertThat(changedAttributes.getJSONArray("oldValue")).hasSize(3);
}
}

83
lib/taskana-core/src/test/java/pro/taskana/task/internal/TaskServiceImplTest.java
View File

@ -3,11 +3,6 @@ package pro.taskana.task.internal;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
import java.time.Instant;
import java.util.HashMap;
import java.util.Map;
import org.json.JSONArray;
import org.json.JSONObject;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -18,7 +13,6 @@ import pro.taskana.classification.api.models.Classification;
import pro.taskana.classification.internal.ClassificationServiceImpl;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.task.api.CallbackState;
import pro.taskana.task.api.models.ObjectReference;
import pro.taskana.task.api.models.TaskSummary;
import pro.taskana.task.internal.models.TaskImpl;
@ -59,83 +53,6 @@ class TaskServiceImplTest {
internalTaskanaEngineMock, taskMapperMock, taskCommentMapperMock, attachmentMapperMock);
}
@Test
void should_DetermineDifferences_When_ComparingEmptyTaskWithNonEmptyTask() {
TaskImpl oldTask = (TaskImpl) cut.newTask();
TaskImpl newTask = (TaskImpl) cut.newTask();
newTask.setOwner("new Owner");
newTask.setCreator("new Creator");
newTask.setId("new ID");
newTask.setCreated(Instant.now());
newTask.setModified(Instant.now());
newTask.setClassificationKey("new ClassificationKey");
newTask.setWorkbasketKey("new WorkbasketKey");
newTask.setBusinessProcessId("new BusinessProcessId");
newTask.setCallbackState(CallbackState.CALLBACK_PROCESSING_REQUIRED);
JSONArray changedAttributes =
new JSONObject(cut.determineChangesInTaskAttributes(oldTask, newTask))
.getJSONArray("changes");
assertThat(changedAttributes).hasSize(9);
}
@Test
void should_DetermineDifferences_When_ComparingNonEmptyTaskWithNonEmptyTask() {
TaskImpl oldTask = (TaskImpl) cut.newTask();
oldTask.setOwner("old Owner");
oldTask.setCreator("old Creator");
oldTask.setId("old ID");
oldTask.setCreated(Instant.now().minusMillis(100));
oldTask.setModified(Instant.now().minusMillis(100));
oldTask.setClassificationKey("old ClassificationKey");
oldTask.setWorkbasketKey("old WorkbasketKey");
oldTask.setBusinessProcessId("old BusinessProcessId");
oldTask.setCallbackState(CallbackState.NONE);
TaskImpl newTask = (TaskImpl) cut.newTask();
newTask.setOwner("new Owner");
newTask.setCreator("new Creator");
newTask.setId("new ID");
newTask.setCreated(Instant.now());
newTask.setModified(Instant.now());
newTask.setClassificationKey("new ClassificationKey");
newTask.setWorkbasketKey("new WorkbasketKey");
newTask.setBusinessProcessId("new BusinessProcessId");
newTask.setCallbackState(CallbackState.CALLBACK_PROCESSING_REQUIRED);
JSONArray changedAttributes =
new JSONObject(cut.determineChangesInTaskAttributes(oldTask, newTask))
.getJSONArray("changes");
assertThat(changedAttributes).hasSize(9);
}
@Test
void should_IgnoreDifferencesInCustomAttributes_When_CustomAttributesHaveChanged() {
TaskImpl oldTask = (TaskImpl) cut.newTask();
oldTask.setOwner("old Owner");
oldTask.setCreator("old Creator");
TaskImpl newTask = (TaskImpl) cut.newTask();
newTask.setOwner("new Owner");
newTask.setCreator("new Creator");
Map<String, String> customAttriutes = new HashMap<>();
customAttriutes.put("new key", "new value");
newTask.setCustomAttributeMap(customAttriutes);
JSONArray changedAttributes =
new JSONObject(cut.determineChangesInTaskAttributes(oldTask, newTask))
.getJSONArray("changes");
assertThat(changedAttributes).hasSize(2);
}
@Test
void testTaskSummaryEqualsHashCode() throws Exception {
Classification classification = CreateTaskModelHelper.createDummyClassification();

3
lib/taskana-core/src/test/java/pro/taskana/workbasket/internal/WorkbasketServiceImplTest.java
View File

@ -95,6 +95,7 @@ class WorkbasketServiceImplTest {
verify(taskanaEngine, times(4)).checkRoleMembership(any());
verify(internalTaskanaEngineMock, times(4)).getEngine();
verify(internalTaskanaEngineMock, times(3)).domainExists(any());
verify(internalTaskanaEngineMock, times(1)).getHistoryEventManager();
verifyNoMoreInteractions(
taskQueryMock,
taskServiceMock,
@ -141,6 +142,8 @@ class WorkbasketServiceImplTest {
verify(distributionTargetMapperMock)
.deleteAllDistributionTargetsBySourceId(eq(expectedWb.getId()));
verify(workbasketMapperMock).update(eq(expectedWb));
verify(internalTaskanaEngineMock, times(1)).getHistoryEventManager();
verifyNoMoreInteractions(
taskQueryMock,
taskServiceMock,

3
lib/taskana-data/src/main/resources/sql/clear/clear-db.sql
View File

@ -1,7 +1,8 @@
-- the order is important!
DELETE FROM TASK_COMMENT;
DELETE FROM HISTORY_EVENTS;
DELETE FROM CONFIGURATION;
DELETE FROM TASK_HISTORY_EVENT;
DELETE FROM WORKBASKET_HISTORY_EVENT;
DELETE FROM ATTACHMENT;
DELETE FROM TASK;
DELETE FROM WORKBASKET_ACCESS_LIST;

2
lib/taskana-data/src/main/resources/sql/clear/clear-history-events.sql
View File

@ -1,2 +0,0 @@
DELETE FROM HISTORY_EVENTS;
COMMIT;

4
lib/taskana-data/src/main/resources/sql/clear/drop-tables.sql
View File

@ -1,5 +1,7 @@
DROP TABLE TASKANA_SCHEMA_VERSION;
DROP TABLE TASK_COMMENT;
DROP TABLE TASK_HISTORY_EVENT;
DROP TABLE WORKBASKET_HISTORY_EVENT;
DROP TABLE CONFIGURATION;
DROP TABLE ATTACHMENT;
DROP TABLE TASK;
@ -11,5 +13,3 @@ DROP TABLE OBJECT_REFERENCE;
DROP TABLE SCHEDULED_JOB;
DROP SEQUENCE SCHEDULED_JOB_SEQ;
COMMIT;
DROP TABLE HISTORY_EVENTS;
COMMIT;

2
lib/taskana-data/src/main/resources/sql/sample-data/history-event.sql
View File

@ -1,4 +1,4 @@
INSERT INTO HISTORY_EVENTS (BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID, EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, POR_COMPANY, POR_SYSTEM, POR_INSTANCE, POR_TYPE, POR_VALUE, TASK_CLASSIFICATION_KEY, TASK_CLASSIFICATION_CATEGORY, ATTACHMENT_CLASSIFICATION_KEY, OLD_VALUE, NEW_VALUE, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, DETAILS) VALUES
INSERT INTO TASK_HISTORY_EVENT (BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID, EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, POR_COMPANY, POR_SYSTEM, POR_INSTANCE, POR_TYPE, POR_VALUE, TASK_CLASSIFICATION_KEY, TASK_CLASSIFICATION_CATEGORY, ATTACHMENT_CLASSIFICATION_KEY, OLD_VALUE, NEW_VALUE, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, DETAILS) VALUES
-- BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID, EVENT_TYPE, TASK_CREATEDD, USER_ID, DOMAIN, WORKBASKET_KEY, POR_COMPANY , POR_SYSTEM, POR_INSTANCE , POR_TYPE , POR_VALUE , TASK_CLASSIFICATION_KEY, TASK_CLASSIFICATION_CATEGORY , ATTACHMENT_CLASSIFICATION_KEY , OLD_VALUE , NEW_VALUE , CUSTOM_1 , CUSTOM_2 , CUSTOM_3 , CUSTOM_4
('BPI:01' ,'', 'TKI:000000000000000000000000000000000000', 'TASK_CREATED', RELATIVE_DATE(0) , 'USER-2-2', 'DOMAIN_B', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344' ,' L140101' , 'TASK' ,'' ,'old_val12' ,'new_val12' ,'custom1' ,'custom2' , 'custom3' ,'custom4', 'some Details'),
('BPI:02' ,'', 'TKI:000000000000000000000000000000000000', 'TASK_UPDATED', RELATIVE_DATE(0), 'USER-1-1', 'DOMAIN_A', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '65464564' , '' , '' ,'' ,'2old_val' ,'new_val2' ,'custom1' ,'' , 'custom3' ,'','some Details'),

18
lib/taskana-data/src/main/resources/sql/test-data/history-event.sql
View File

@ -1,4 +1,4 @@
INSERT INTO HISTORY_EVENTS (ID,BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID, EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, POR_COMPANY, POR_SYSTEM, POR_INSTANCE, POR_TYPE, POR_VALUE, TASK_CLASSIFICATION_KEY,
INSERT INTO TASK_HISTORY_EVENT (ID,BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID, EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, POR_COMPANY, POR_SYSTEM, POR_INSTANCE, POR_TYPE, POR_VALUE, TASK_CLASSIFICATION_KEY,
TASK_CLASSIFICATION_CATEGORY, ATTACHMENT_CLASSIFICATION_KEY, OLD_VALUE, NEW_VALUE, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, DETAILS) VALUES
-- BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID, EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, POR_COMPANY , POR_SYSTEM, POR_INSTANCE , POR_TYPE , POR_VALUE , TASK_CLASSIFICATION_KEY, TASK_CLASSIFICATION_CATEGORY , ATTACHMENT_CLASSIFICATION_KEY , OLD_VALUE , NEW_VALUE , CUSTOM_1 , CUSTOM_2 , CUSTOM_3 , CUSTOM_4, details
('HEI:000000000000000000000000000000000000','BPI:01' ,'' ,'TKI:000000000000000000000000000000000000', 'TASK_UPDATED', '2018-01-29 15:55:00' , 'admin', 'DOMAIN_B', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344', 'L140101' , 'TASK' ,'' ,'old_val' ,'new_val' ,'custom1' ,'custom2' , 'custom3' ,'custom4', '{"changes":[{"newValue":"BPI:01","fieldName":"businessProcessId","oldValue":"BPI:02"},{"newValue":"admin","fieldName":"owner","oldValue":"owner1"}]}' ),
@ -15,3 +15,19 @@ INSERT INTO HISTORY_EVENTS (ID,BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID,
('HEI:000000000000000000000000000000000011','BPI:02' ,'' ,'TKI:000000000000000000000000000000000066', 'TASK_CREATED', '2018-01-29 15:55:11','peter', 'DOMAIN_A', 'WBI:100000000000000000000000000000000001', '00' , 'PASystem', '00' , 'VNR' , '11223344', '' , '' ,'' ,'2old_val' ,'new_val2' ,'custom1' ,'' , 'custom2' ,'' ,'someDetails' ),
('HEI:000000000000000000000000000000000012','BPI:03' ,'BPI:01','TKI:000000000000000000000000000000000066','TASK_CREATED', '2018-01-29 15:55:12' , 'admin', 'DOMAIN_A', 'WBI:100000000000000000000000000000000002', '11' , '' , '22' , '' , '' , 'L140101' , 'TASK' ,'DOCTYPE_DEFAULT' ,'' ,'' ,'custom1' ,'' , 'custom3' ,'' ,'someDetails' )
;
INSERT INTO WORKBASKET_HISTORY_EVENT (ID,EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_ID, WORKBASKET_KEY, WORKBASKET_TYPE, OWNER, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, ORGLEVEL_1, ORGLEVEL_2, ORGLEVEL_3, ORGLEVEL_4, DETAILS) VALUES
-- BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, TASK_ID, EVENT_TYPE, CREATED, USER_ID, DOMAIN, WORKBASKET_KEY, POR_COMPANY , POR_SYSTEM, POR_INSTANCE , POR_TYPE , POR_VALUE , TASK_CLASSIFICATION_KEY, TASK_CLASSIFICATION_CATEGORY , ATTACHMENT_CLASSIFICATION_KEY , OLD_VALUE , NEW_VALUE , CUSTOM_1 , CUSTOM_2 , CUSTOM_3 , CUSTOM_4, details
('WHI:000000000000000000000000000000000000','WORKBASKET_CREATED' ,'2018-01-29 15:55:00' ,'peter', 'DOMAIN_A', 'WBI:000000000000000000000000000000000903', 'soRt004', 'TOPIC', 'admin', 'custom1' ,'custom2' , 'custom3' ,'custom4', 'orgLevel1' ,'orgLevel2' , 'orgLevel3' ,'orgLevel4', '{"changes":[{"newValue":"WBI:100000000000000000000000000000001234","fieldName":"id","oldValue":""}]}' ),
('WHI:000000000000000000000000000000000001','WORKBASKET_UPDATED' ,'2018-01-29 15:55:01' ,'claudia', 'DOMAIN_A', 'WBI:000000000000000000000000000000000803', 'soRt003', 'TOPIC', 'admin', 'otherCustom1' ,'otherCustom2' , 'otherCustom3' ,'otherCustom4', 'otherOrgLevel1' ,'otherOrgLevel2' , 'otherOrgLevel3' ,'otherOrgLevel4', '{"changes":[{"newValue":"WBI:100000000000000000000000000000001234","fieldName":"id","oldValue":""}]}' ),
('WHI:000000000000000000000000000000000002','WORKBASKET_DELETED' ,'2018-01-29 15:55:02' ,'peter', 'DOMAIN_A', 'WBI:000000000000000000000000000000000903', 'soRt004', 'TOPIC','admin', 'custom1' ,'custom2' , 'custom3' ,'custom4', 'orgLevel1' ,'orgLevel2' , 'orgLevel3' ,'orgLevel4', '{"changes":[{"newValue":"WBI:100000000000000000000000000000001234","fieldName":"id","oldValue":""}]}' ),
('WHI:000000000000000000000000000000000003','WORKBASKET_CREATED' ,'2018-01-29 15:55:03' ,'claudia', 'DOMAIN_A', 'WBI:000000000000000000000000000000000803', 'soRt003', 'TOPIC','admin', 'otherCustom1' ,'otherCustom2' , 'otherCustom3' ,'otherCustom4', 'otherOrgLevel1' ,'otherOrgLevel2' , 'otherOrgLevel3' ,'otherOrgLevel4', '{"changes":[{"newValue":"WBI:100000000000000000000000000000001234","fieldName":"id","oldValue":""}]}' ),
('WHI:000000000000000000000000000000000004','WORKBASKET_CREATED' ,'2018-01-29 15:55:04' ,'peter', 'DOMAIN_A', 'WBI:000000000000000000000000000000000803', 'soRt003', 'TOPIC','admin', 'custom1' ,'custom2' , 'custom3' ,'custom4', 'orgLevel1' ,'orgLevel2' , 'orgLevel3' ,'orgLevel4', '{"changes":[{"newValue":"WBI:100000000000000000000000000000001234","fieldName":"id","oldValue":""}]}' ),
('WHI:000000000000000000000000000000000005','WORKBASKET_DELETED' ,'2018-01-29 15:55:05' ,'sven', 'DOMAIN_A', 'WBI:000000000000000000000000000000000903', 'soRt004', 'TOPIC','admin', 'otherCustom1' ,'otherCustom2' , 'otherCustom3' ,'otherCustom4', 'otherOrgLevel1' ,'otherOrgLevel2' , 'otherOrgLevel3' ,'otherOrgLevel4', '{"changes":[{"newValue":"WBI:100000000000000000000000000000001234","fieldName":"id","oldValue":""}]}' ),
('WHI:000000000000000000000000000000000006','WORKBASKET_CREATED' ,'2018-01-29 15:55:06' ,'peter', 'DOMAIN_A', 'WBI:000000000000000000000000000000000803', 'soRt003', 'TOPIC','admin', 'custom1' ,'custom2' , 'custom3' ,'custom4', 'orgLevel1' ,'orgLevel2' , 'orgLevel3' ,'orgLevel4', '{"changes":[{"newValue":"WBI:100000000000000000000000000000001234","fieldName":"id","oldValue":""}]}' ),
('WHI:000000000000000000000000000000000007','WORKBASKET_CREATED' ,'2018-01-29 15:55:07' ,'sven', 'DOMAIN_A', 'WBI:000000000000000000000000000000000903', 'soRt004', 'TOPIC','admin', 'otherCustom1' ,'otherCustom2' , 'otherCustom3' ,'otherCustom4', 'otherOrgLevel1' ,'otherOrgLevel2' , 'otherOrgLevel3' ,'otherOrgLevel4', '{"changes":[{"newValue":"WBI:100000000000000000000000000000001234","fieldName":"id","oldValue":""}]}' ),
('WHI:000000000000000000000000000000000008','WORKBASKET_UPDATED' ,'2018-01-29 15:55:08' ,'peter', 'DOMAIN_A', 'WBI:000000000000000000000000000000000803', 'soRt003', 'TOPIC','admin', 'custom1' ,'custom2' , 'custom3' ,'custom4', 'orgLevel1' ,'orgLevel2' , 'orgLevel3' ,'orgLevel4', '{"changes":[{"newValue":"WBI:100000000000000000000000000000001234","fieldName":"id","oldValue":""}]}' ),
('WHI:000000000000000000000000000000000009','WORKBASKET_CREATED' ,'2018-01-29 15:55:09' ,'peter', 'DOMAIN_A', 'WBI:000000000000000000000000000000000903', 'soRt004', 'TOPIC', 'admin','otherCustom1' ,'otherCustom2' , 'otherCustom3' ,'otherCustom4', 'otherOrgLevel1' ,'otherOrgLevel2' , 'otherOrgLevel3' ,'otherOrgLevel4', '{"changes":[{"newValue":"WBI:100000000000000000000000000000001234","fieldName":"id","oldValue":""}]}' )
;