diff --git a/lib/taskana-cdi-example/src/main/java/pro/taskana/ExampleBootstrap.java b/lib/taskana-cdi-example/src/main/java/pro/taskana/ExampleBootstrap.java index d204a0db5..92d055730 100644 --- a/lib/taskana-cdi-example/src/main/java/pro/taskana/ExampleBootstrap.java +++ b/lib/taskana-cdi-example/src/main/java/pro/taskana/ExampleBootstrap.java @@ -9,6 +9,7 @@ import javax.enterprise.event.Observes; import pro.taskana.exceptions.ClassificationNotFoundException; import pro.taskana.exceptions.InvalidOwnerException; import pro.taskana.exceptions.InvalidStateException; +import pro.taskana.exceptions.InvalidWorkbasketException; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.TaskAlreadyExistException; import pro.taskana.exceptions.TaskNotFoundException; @@ -23,7 +24,8 @@ public class ExampleBootstrap { @PostConstruct public void init(@Observes @Initialized(ApplicationScoped.class) Object init) throws TaskNotFoundException, NotAuthorizedException, WorkbasketNotFoundException, - ClassificationNotFoundException, InvalidStateException, InvalidOwnerException, TaskAlreadyExistException { + ClassificationNotFoundException, InvalidStateException, InvalidOwnerException, InvalidWorkbasketException, + TaskAlreadyExistException { System.out.println("---------------------------> Start App"); Task task = taskanaEjb.getTaskService().newTask(); task = taskanaEjb.getTaskService().createTask(task); @@ -35,4 +37,5 @@ public class ExampleBootstrap { taskanaEjb.getTaskService().completeTask(task.getId()); System.out.println("---------------------------> Task completed"); } + } diff --git a/lib/taskana-cdi/src/test/java/pro/taskana/TaskanaEjb.java b/lib/taskana-cdi/src/test/java/pro/taskana/TaskanaEjb.java index aa7db4aba..51196a393 100644 --- a/lib/taskana-cdi/src/test/java/pro/taskana/TaskanaEjb.java +++ b/lib/taskana-cdi/src/test/java/pro/taskana/TaskanaEjb.java @@ -4,6 +4,7 @@ import javax.ejb.Stateless; import javax.inject.Inject; import pro.taskana.exceptions.ClassificationNotFoundException; +import pro.taskana.exceptions.InvalidWorkbasketException; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.TaskAlreadyExistException; import pro.taskana.exceptions.WorkbasketNotFoundException; @@ -33,7 +34,7 @@ public class TaskanaEjb { } public void triggerRollback() throws NotAuthorizedException, WorkbasketNotFoundException, - ClassificationNotFoundException, TaskAlreadyExistException { + ClassificationNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException { Task task = taskService.newTask(); taskService.createTask(task); System.out.println("---------------->" + task.getId()); diff --git a/lib/taskana-cdi/src/test/java/pro/taskana/TaskanaRestTest.java b/lib/taskana-cdi/src/test/java/pro/taskana/TaskanaRestTest.java index c02be8d3a..16a8cf6b7 100644 --- a/lib/taskana-cdi/src/test/java/pro/taskana/TaskanaRestTest.java +++ b/lib/taskana-cdi/src/test/java/pro/taskana/TaskanaRestTest.java @@ -16,10 +16,12 @@ import pro.taskana.exceptions.ClassificationAlreadyExistException; import pro.taskana.exceptions.ClassificationNotFoundException; import pro.taskana.exceptions.InvalidOwnerException; import pro.taskana.exceptions.InvalidStateException; +import pro.taskana.exceptions.InvalidWorkbasketException; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.TaskAlreadyExistException; import pro.taskana.exceptions.TaskNotFoundException; import pro.taskana.exceptions.WorkbasketNotFoundException; +import pro.taskana.model.WorkbasketType; @Path("/test") public class TaskanaRestTest { @@ -34,10 +36,13 @@ public class TaskanaRestTest { @GET public Response startTask() throws NotAuthorizedException, WorkbasketNotFoundException, - ClassificationNotFoundException, ClassificationAlreadyExistException, TaskAlreadyExistException { + ClassificationNotFoundException, ClassificationAlreadyExistException, InvalidWorkbasketException, + TaskAlreadyExistException { Workbasket workbasket = taskanaEjb.getWorkbasketService().newWorkbasket(); - ; workbasket.setName("wb"); + workbasket.setKey("key"); + workbasket.setDomain("cdiDomain"); + workbasket.setType(WorkbasketType.PERSONAL); taskanaEjb.getWorkbasketService().createWorkbasket(workbasket); Classification classification = classificationService.newClassification(); classification.setKey("TEST"); @@ -45,17 +50,17 @@ public class TaskanaRestTest { Task task = taskanaEjb.getTaskService().newTask(); task.setClassification(classification); - task.setWorkbasketId(workbasket.getId()); + task.setWorkbasketKey(workbasket.getKey()); + Task result = taskanaEjb.getTaskService().createTask(task); - Task resultTask = taskanaEjb.getTaskService().createTask(task); - - logger.info(resultTask.getId() + ":" + resultTask.getOwner()); - return Response.status(200).entity(resultTask.getId()).build(); + logger.info(result.getId() + ":" + result.getOwner()); + return Response.status(200).entity(result.getId()).build(); } @POST - public Response rollbackTask() throws NotAuthorizedException, WorkbasketNotFoundException, - ClassificationNotFoundException, TaskAlreadyExistException { + public Response rollbackTask() + throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, + InvalidWorkbasketException, TaskAlreadyExistException { taskanaEjb.triggerRollback(); return Response.status(204).build(); } diff --git a/lib/taskana-core/src/main/java/pro/taskana/Task.java b/lib/taskana-core/src/main/java/pro/taskana/Task.java index 493bb58f1..377594988 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/Task.java +++ b/lib/taskana-core/src/main/java/pro/taskana/Task.java @@ -13,283 +13,347 @@ public interface Task { /** * Returns the current id of the task. + * * @return taskId */ String getId(); /** * Returns the time when the task was {@link TaskState#READY}. + * * @return created as exact {@link Timestamp} */ Timestamp getCreated(); /** * Returns the time when the task was set to {@link TaskState#CLAIMED} by/to a user. + * * @return claimed as exact {@link Timestamp} */ Timestamp getClaimed(); /** * Returns the time when the task was set into {@link TaskState#COMPLETED}. + * * @return completed as exact {@link Timestamp} */ Timestamp getCompleted(); /** * Returns the time when the task was modified the last time. + * * @return modified as exact {@link Timestamp} */ Timestamp getModified(); /** * Returns the time when the work on this task was planned to be started. + * * @return planned as exact {@link Timestamp} */ Timestamp getPlanned(); /** * Sets the time when the work on this task should be started. - * @param planned as exact {@link Timestamp} + * + * @param planned + * as exact {@link Timestamp} */ void setPlanned(Timestamp planned); /** * Returns the time when this task should be finished. + * * @return due as exact {@link Timestamp} */ Timestamp getDue(); /** * Return the name of the current task. + * * @return name of the task */ String getName(); /** * Sets the name of the current task. - * @param name of the task + * + * @param name + * the name of the task */ void setName(String name); /** * Return the task-description. + * * @return description of a task */ String getDescription(); /** * Sets the description of the task. - * @param description of the task + * + * @param description + * the description of the task */ void setDescription(String description); /** * Returns the numeric priority of a task. + * * @return priority of the task */ int getPriority(); /** * Returns the current {@link TaskState} of the task. + * * @return taskState */ TaskState getState(); /** * Returns the {@link Classification} of the task. + * * @return classification for specification */ Classification getClassification(); /** * Sets the {@link Classification} to specify this kind of task. - * @param classification of the task + * + * @param classification + * the classification of the task */ void setClassification(Classification classification); /** - * Returns the id of the Workbasket where the task is stored in. - * @return workbasketId + * Returns the key of the Workbasket where the task is stored in. + * + * @return workbasketKey */ - String getWorkbasketId(); + String getWorkbasketKey(); /** - * Sets the id of the Workbasket where the task should be stored in. - * @param workbasketId + * Sets the key of the Workbasket where the task should be stored in. + * + * @param workbasketKey + * the key of the workbasket */ - void setWorkbasketId(String workbasketId); + void setWorkbasketKey(String workbasketKey); /** * Returns the businessProcessId of a task. + * * @return businessProcessId */ String getBusinessProcessId(); /** * Returns the parentBusinessProcessId of a task. + * * @return parentBusinessProcessId */ String getParentBusinessProcessId(); /** * Return the id of the task-owner. + * * @return taskOwnerId */ String getOwner(); /** * Sets the ownerId of this task. + * * @param taskOwnerId + * the user id of the task's owner */ void setOwner(String taskOwnerId); /** * Returns the {@link ObjectReference primaryObjectReference} of the task. + * * @return primaryObjRef to task main-subject */ ObjectReference getPrimaryObjRef(); /** * Sets the {@link ObjectReference primaryObjectReference} of the task. - * @param primaryObjRef to task main-subject + * + * @param primaryObjRef + * to task main-subject */ void setPrimaryObjRef(ObjectReference primaryObjRef); /** * Return the isRead-flag, which flags a task as viewed at least one time. + * * @return isRead-flag */ boolean isRead(); /** * Return the isTransferred-flag, which flags a task as transfered into an other workbasket. + * * @return isTransferred-flag */ boolean isTransferred(); /** * Returns a collection of customAttributes with a max. amount of 10 entries. + * * @return customAttributes as {@link Map} */ Map getCustomAttributes(); /** - * Return the key for the 1. customAttribute. + * Return the value for the 1. customAttribute. + * * @return custom1 */ String getCustom1(); /** - * Sets the key for customAttribute1. + * Sets the value for customAttribute1. + * * @param custom1 + * the custom1 property of the task */ void setCustom1(String custom1); /** - * Return the key for the 2. customAttribute. + * Return the value for the 2. customAttribute. + * * @return custom2 */ String getCustom2(); /** - * Sets the key for customAttribute2. + * Sets the value for customAttribute2. + * * @param custom2 + * the custom2 property of the task */ void setCustom2(String custom2); /** - * Return the key for the 3. customAttribute. + * Return the value for the 3. customAttribute. + * * @return custom3 */ String getCustom3(); /** - * Sets the key for customAttribute3. + * Sets the value for customAttribute3. + * * @param custom3 + * the custom3 property of the task */ void setCustom3(String custom3); /** - * Return the key for the 4. customAttribute. + * Return the value for the 4. customAttribute. + * * @return custom4 */ String getCustom4(); /** - * Sets the key for customAttribute4. + * Sets the value for customAttribute4. + * * @param custom4 + * the custom4 property of the task */ void setCustom4(String custom4); /** - * Return the key for the 5. customAttribute. + * Return the value for the 5. customAttribute. + * * @return custom5 */ String getCustom5(); /** - * Sets the key for customAttribute25. + * Sets the value for customAttribute25. + * * @param custom5 + * the custom5 property of the task */ void setCustom5(String custom5); /** - * Return the key for the 6. customAttribute. + * Return the value for the 6. customAttribute. + * * @return custom6 */ String getCustom6(); /** - * Sets the key for customAttribute6. + * Sets the value for customAttribute6. + * * @param custom6 + * the custom6 property of the task */ void setCustom6(String custom6); /** - * Return the key for the 7. customAttribute. + * Return the value for the 7. customAttribute. + * * @return custom7 */ String getCustom7(); /** - * Sets the key for customAttribute7. + * Sets the value for customAttribute7. + * * @param custom7 + * the custom7 property of the task */ void setCustom7(String custom7); /** - * Return the key for the 8. customAttribute. + * Return the value for the 8. customAttribute. + * * @return custom8 */ String getCustom8(); /** - * Sets the key for customAttribute8. + * Sets the value for customAttribute8. + * * @param custom8 + * the custom8 property of the task */ void setCustom8(String custom8); /** - * Return the key for the 9. customAttribute. + * Return the value for the 9. customAttribute. + * * @return custom9 */ String getCustom9(); /** - * Sets the key for customAttribute9. + * Sets the value for customAttribute9. + * * @param custom9 + * the custom9 property of the task */ void setCustom9(String custom9); /** - * Return the key for the 10. customAttribute. + * Return the value for the 10. customAttribute. + * * @return custom10 */ String getCustom10(); /** - * Sets the key for customAttribute10. + * Sets the value for customAttribute10. + * * @param custom10 + * the custom10 property of the task */ void setCustom10(String custom10); } diff --git a/lib/taskana-core/src/main/java/pro/taskana/TaskQuery.java b/lib/taskana-core/src/main/java/pro/taskana/TaskQuery.java index ffeefcb1c..6fc297b53 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/TaskQuery.java +++ b/lib/taskana-core/src/main/java/pro/taskana/TaskQuery.java @@ -10,6 +10,7 @@ public interface TaskQuery extends BaseQuery { /** * Add your names to your query. + * * @param name * the names as Strings * @return the query @@ -17,8 +18,9 @@ public interface TaskQuery extends BaseQuery { TaskQuery name(String... name); /** - * Add your description to your query. It will be compared in SQL with an LIKE. - * If you use a wildcard like % tehn it will be transmitted to the database. + * Add your description to your query. It will be compared in SQL with an LIKE. If you use a wildcard like % tehn it + * will be transmitted to the database. + * * @param description * your description * @return the query @@ -27,6 +29,7 @@ public interface TaskQuery extends BaseQuery { /** * Add your priorities to your query. + * * @param priorities * as a integer * @return the query @@ -35,6 +38,7 @@ public interface TaskQuery extends BaseQuery { /** * Add your state to your query. + * * @param states * the states as {@link TaskState} * @return the query @@ -42,8 +46,8 @@ public interface TaskQuery extends BaseQuery { TaskQuery state(TaskState... states); /** - * Add your classification to your query. The classification query can be - * obtained from the ClassificationService + * Add your classification to your query. The classification query can be obtained from the ClassificationService + * * @param classificationQuery * the classification query * @return the query @@ -51,17 +55,19 @@ public interface TaskQuery extends BaseQuery { TaskQuery classification(ClassificationQuery classificationQuery); /** - * Add your workbasket id to the query. - * @param workbasketIds - * the workbasket ids as String + * Add your workbasket key to the query. + * + * @param workbasketKeys + * the workbasket keys as String * @return the query * @throws NotAuthorizedException * if the user have no rights */ - TaskQuery workbasketId(String... workbasketIds) throws NotAuthorizedException; + TaskQuery workbasketKeyIn(String... workbasketKeys) throws NotAuthorizedException; /** * Add the owners to your query. + * * @param owners * the owners as String * @return the query @@ -69,8 +75,8 @@ public interface TaskQuery extends BaseQuery { TaskQuery owner(String... owners); /** - * Add your objectReference to your query. The objectReference query can be - * obtained from the TaskService + * Add your objectReference to your query. The objectReference query can be obtained from the TaskService + * * @param objectReferenceQuery * the objectReference query * @return the query @@ -79,25 +85,25 @@ public interface TaskQuery extends BaseQuery { /** * Add the isRead flag to the query. + * * @param isRead - * as Boolean. If null, it won't be integrated into the statement. - * You have to set false. + * as Boolean. If null, it won't be integrated into the statement. You have to set false. * @return the query */ TaskQuery read(Boolean isRead); /** * Add the isTransferred flag to the query. + * * @param isTransferred - * as Boolean. If null, it won't be integrated into the statement. - * You have to set false. + * as Boolean. If null, it won't be integrated into the statement. You have to set false. * @return the query */ TaskQuery transferred(Boolean isTransferred); /** - * Filter the custom fields with this query. The scan will be run over all 10 - * fields. + * Filter the custom fields with this query. The scan will be run over all 10 fields. + * * @param customFields * the value in the fields * @return the query @@ -106,6 +112,7 @@ public interface TaskQuery extends BaseQuery { /** * This method provides a query builder for quering the database. + * * @return a {@link ObjectReferenceQuery} */ ObjectReferenceQuery createObjectReferenceQuery(); diff --git a/lib/taskana-core/src/main/java/pro/taskana/TaskService.java b/lib/taskana-core/src/main/java/pro/taskana/TaskService.java index 1db49d126..59cfcbd81 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/TaskService.java +++ b/lib/taskana-core/src/main/java/pro/taskana/TaskService.java @@ -5,6 +5,7 @@ import java.util.List; import pro.taskana.exceptions.ClassificationNotFoundException; import pro.taskana.exceptions.InvalidOwnerException; import pro.taskana.exceptions.InvalidStateException; +import pro.taskana.exceptions.InvalidWorkbasketException; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.TaskAlreadyExistException; import pro.taskana.exceptions.TaskNotFoundException; @@ -97,10 +98,12 @@ public interface TaskService { * thrown if the work basket referenced by the task is not found * @throws ClassificationNotFoundException * thrown if the {@link Classification} referenced by the task is not found + * @throws InvalidWorkbasketException + * thrown if the referenced Workbasket has missing required properties */ Task createTask(Task taskToCreate) throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, - TaskAlreadyExistException; + TaskAlreadyExistException, InvalidWorkbasketException; /** * Get the details of a task by Id. @@ -118,8 +121,8 @@ public interface TaskService { * * @param taskId * The id of the {@link Task} to be transferred - * @param workbasketId - * The id of the target work basket + * @param workbasketKey + * The key of the target work basket * @return the transferred task * @throws TaskNotFoundException * Thrown if the {@link Task} with taskId was not found. @@ -127,9 +130,11 @@ public interface TaskService { * Thrown if the target work basket was not found. * @throws NotAuthorizedException * Thrown if the current user is not authorized to transfer this {@link Task} to the target work basket + * @throws InvalidWorkbasketException + * Thrown if either the source or the target workbasket has a missing required property */ - Task transfer(String taskId, String workbasketId) - throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException; + Task transfer(String taskId, String workbasketKey) + throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException; /** * Marks a task as read. @@ -154,8 +159,8 @@ public interface TaskService { /** * Getting a list of all Tasks which got matching workbasketIds and states. * - * @param workbasketId - * where the tasks need to be in. + * @param workbasketKey + * the key of the workbasket where the tasks need to be in. * @param taskState * which is required for the request, * @return a filled/empty list of tasks with attributes which are matching given params. @@ -164,19 +169,22 @@ public interface TaskService { * @throws NotAuthorizedException * if the current user got no rights for reading on this work basket. */ - List getTasksByWorkbasketIdAndState(String workbasketId, TaskState taskState) + List getTasksByWorkbasketKeyAndState(String workbasketKey, TaskState taskState) throws WorkbasketNotFoundException, NotAuthorizedException; /** * Getting a short summary of all tasks in a specific work basket. * - * @param workbasketId - * ID of work basket where tasks are located. + * @param workbasketKey + * Key of work basket where tasks are located. * @return TaskSummaryList with all TaskSummaries of a work basket * @throws WorkbasketNotFoundException * if a Work basket can´t be located. + * @throws InvalidWorkbasketException + * thrown if the Workbasket specified with workbasketId has a missing required property */ - List getTaskSummariesByWorkbasketId(String workbasketId) throws WorkbasketNotFoundException; + List getTaskSummariesByWorkbasketKey(String workbasketKey) + throws WorkbasketNotFoundException, InvalidWorkbasketException; /** * Returns a not persisted instance of {@link Task}. diff --git a/lib/taskana-core/src/main/java/pro/taskana/Workbasket.java b/lib/taskana-core/src/main/java/pro/taskana/Workbasket.java index 8a2071d9c..db99db4ea 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/Workbasket.java +++ b/lib/taskana-core/src/main/java/pro/taskana/Workbasket.java @@ -3,74 +3,136 @@ package pro.taskana; import java.sql.Timestamp; import java.util.List; -/** - * Workbasket entity interface. - */ - public interface Workbasket { +import pro.taskana.model.WorkbasketType; - /** - * Returns the unique id of a workbasket. - * @return workbasketId - */ +/** + * Workbasket entity interface. + */ +public interface Workbasket { + + /** + * Returns the unique id of a workbasket. + * + * @return workbasketId + */ String getId(); /** * Returns the timestamp when the workbasket was created. + * * @return created timestamp */ Timestamp getCreated(); + /** + * Returns the key of the workbasket. + * + * @return the key of the workbasket + */ + String getKey(); + + /** + * Set the key of the workbasket. + * + * @param key + * the key of the workbasket + */ + void setKey(String key); + + /** + * Returns the domain of the workbasket. + * + * @return domain of the workbasket + */ + String getDomain(); + + /** + * Set the domain of the workbasket. + * + * @param domain + * the domain of the workbasket + */ + void setDomain(String domain); + + /** + * Returns the type of the workbasket. + * + * @return the type of the workbasket + */ + WorkbasketType getType(); + + /** + * Sets the type of the workbasket. + * + * @param type + * the type of the workbasket + */ + void setType(WorkbasketType type); + /** * Returns the timestamp when the workbasket was modified the last time. + * * @return modified timestamp */ Timestamp getModified(); /** * Sets the time when the workbasket was modified the last time. - * @param modified timestamp + * + * @param modified + * the timestamp when the workbasket was last modified */ void setModified(Timestamp modified); /** * Returns the name of the workbasket. + * * @return workbasketName */ String getName(); /** * Sets the name of the workbasket. + * * @param workbasketName + * the name of the workbasket */ void setName(String workbasketName); /** * Returns the workbasket-descriptions. + * * @return description */ String getDescription(); /** * Sets the workbasket-descriptions. + * * @param description + * the description of the workbasket */ void setDescription(String description); /** * Returns the Id of the workbasket-owner. + * * @return ownerId */ String getOwner(); /** * Returns a list of all distribution targets. + * * @return distributionTargets */ List getDistributionTargets(); /** * Sets the list of distribution targets for this workbasket. + * * @param distributionTargets + * the distribution targets of the workbasket */ void setDistributionTargets(List distributionTargets); } diff --git a/lib/taskana-core/src/main/java/pro/taskana/WorkbasketQuery.java b/lib/taskana-core/src/main/java/pro/taskana/WorkbasketQuery.java index f11f69457..f57dbc7ec 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/WorkbasketQuery.java +++ b/lib/taskana-core/src/main/java/pro/taskana/WorkbasketQuery.java @@ -4,37 +4,89 @@ import java.util.Date; import pro.taskana.exceptions.InvalidArgumentException; import pro.taskana.model.WorkbasketAuthorization; +import pro.taskana.model.WorkbasketType; /** * WorkitemQuery for generating dynamic sql. */ public interface WorkbasketQuery extends BaseQuery { + /** + * Add your keys to your query. + * + * @param key + * the keys as Strings + * @return the query + */ + WorkbasketQuery keyIn(String... key); + /** * Add your names to your query. + * * @param name * the names as Strings * @return the query */ - WorkbasketQuery name(String... name); + WorkbasketQuery nameIn(String... name); /** - * Add your created-Dates to your query. - * @param created TODO - * @return TODO + * Add your domains to your query. + * + * @param domain + * the domains as Strings + * @return the query */ - WorkbasketQuery created(Date... created); + WorkbasketQuery domainIn(String... domain); /** - * Add your modified-Dates to your query. - * @param created TODO - * @return TODO + * Add your types to your query. + * + * @param type + * the types + * @return the query */ - WorkbasketQuery modified(Date... created); + WorkbasketQuery typeIn(WorkbasketType... type); /** - * Add your description to your query. It will be compared in SQL with an LIKE. - * If you use a wildcard like % tehn it will be transmitted to the database. + * Add your createdAfter-Date to your query. + * + * @param createdAfter + * the date after which the searched Workbaskets are created + * @return the query + */ + WorkbasketQuery createdAfter(Date createdAfter); + + /** + * Add your createdBefore-Date to your query. + * + * @param createdBefore + * the date before which the searched Workbaskets are created + * @return the query + */ + WorkbasketQuery createdBefore(Date createdBefore); + + /** + * Add your modifiedAfter-Date to your query. + * + * @param modifiedAfter + * the date after which the searched Workbaskets are modified + * @return the query + */ + WorkbasketQuery modifiedAfter(Date modifiedAfter); + + /** + * Add your modifiedBefore-Date to your query. + * + * @param modifiedBefore + * the date before which the searched Workbaskets are modified + * @return the query + */ + WorkbasketQuery modifiedBefore(Date modifiedBefore); + + /** + * Add your description to your query. It will be compared in SQL with an LIKE. If you use a wildcard like % tehn it + * will be transmitted to the database. + * * @param description * your description * @return the query @@ -43,20 +95,23 @@ public interface WorkbasketQuery extends BaseQuery { /** * Add the owners to your query. + * * @param owners * the owners as String * @return the query */ - WorkbasketQuery owner(String... owners); + WorkbasketQuery ownerIn(String... owners); /** * Add the access requested. + * * @param permission * the permissions requested * @param accessIds * the accessIds as String * @return the query - * @throws InvalidArgumentException TODO + * @throws InvalidArgumentException + * if any argument is not specified */ WorkbasketQuery access(WorkbasketAuthorization permission, String... accessIds) throws InvalidArgumentException; diff --git a/lib/taskana-core/src/main/java/pro/taskana/WorkbasketService.java b/lib/taskana-core/src/main/java/pro/taskana/WorkbasketService.java index 81f71986d..3742e97fc 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/WorkbasketService.java +++ b/lib/taskana-core/src/main/java/pro/taskana/WorkbasketService.java @@ -2,57 +2,91 @@ package pro.taskana; import java.util.List; +import pro.taskana.exceptions.InvalidWorkbasketException; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.WorkbasketNotFoundException; import pro.taskana.model.WorkbasketAccessItem; import pro.taskana.model.WorkbasketAuthorization; /** - * This service manages the Workbaskets. + * This service manages Workbaskets. */ public interface WorkbasketService { /** * Get Workbasket for a given id. - * @param workbasketId TODO + * + * @param workbasketId + * the Id of the Workbasket requested * @return the requested Workbasket - * @throws WorkbasketNotFoundException TODO + * @throws WorkbasketNotFoundException + * If the Workbasket with workbasketId is not found + * @throws InvalidWorkbasketException + * If required properties are missing in the found Workbasket */ - Workbasket getWorkbasket(String workbasketId) throws WorkbasketNotFoundException; + Workbasket getWorkbasket(String workbasketId) throws WorkbasketNotFoundException, InvalidWorkbasketException; + + /** + * Get Workbasket for a given key. + * + * @param workbasketKey + * the Key of the Workbasket requested + * @return the requested Workbasket + * @throws WorkbasketNotFoundException + * If the Workbasket with workbasketId is not found + * @throws InvalidWorkbasketException + * If required properties are missing in the found Workbasket + */ + Workbasket getWorkbasketByKey(String workbasketKey) throws WorkbasketNotFoundException, InvalidWorkbasketException; /** * Get all available Workbaskets. - * @return a list containing all workbaskets + * + * @return a list containing all Workbaskets */ List getWorkbaskets(); /** * Create a new Workbasket. + * * @param workbasket - * The workbasket to create - * @return TODO + * The Workbasket to create + * @return the created and persisted Workbasket + * @throws InvalidWorkbasketException + * If a required property of the Workbasket is not set. + * @throws WorkbasketNotFoundException + * If the to be created work basket references a distribution target that does not exist */ - Workbasket createWorkbasket(Workbasket workbasket); + Workbasket createWorkbasket(Workbasket workbasket) throws InvalidWorkbasketException, WorkbasketNotFoundException; /** * Update a Workbasket. + * * @param workbasket - * The workbasket to update - * @return TODO - * @throws NotAuthorizedException TODO + * The Workbasket to update + * @return the updated Workbasket + * @throws InvalidWorkbasketException + * if a required property of the workbasket is not set + * @throws WorkbasketNotFoundException + * if the updated work basket references a distribution target that does not exist + * @throws NotAuthorizedException + * if the current user is not authorized to update the work basket */ - Workbasket updateWorkbasket(Workbasket workbasket) throws NotAuthorizedException; + Workbasket updateWorkbasket(Workbasket workbasket) + throws InvalidWorkbasketException, WorkbasketNotFoundException, NotAuthorizedException; /** - * Create a new Workbasket Authorization with a Workbasket and a AccessId. + * Create and persist a new Workbasket Authorization with a Workbasket and a AccessId. + * * @param workbasketAccessItem * the new workbasketAccessItem - * @return TODO + * @return the created WorkbasketAccessItem */ WorkbasketAccessItem createWorkbasketAuthorization(WorkbasketAccessItem workbasketAccessItem); /** * This method updates an Workbasket Authorization. + * * @param workbasketAccessItem * the Authorization * @return the updated entity @@ -61,61 +95,69 @@ public interface WorkbasketService { /** * Get all authorizations of the workbasket. + * * @return a WorkbasketAccessItem list */ List getAllAuthorizations(); /** * Deletes a specific authorization. + * * @param id - * the specific id + * the id of the WorbasketAccessItem to be deleted */ void deleteWorkbasketAuthorization(String id); /** * This method checks the authorization with the saved one for the actual User. * - * @param workbasketId - * the workbasket we want to access + * @param workbasketKey + * the key of the workbasket we want to access * @param authorization * the needed Authorization - * @throws NotAuthorizedException TODO + * @throws NotAuthorizedException + * if the current user has not the requested authorization fot the specified workbasket */ - void checkAuthorization(String workbasketId, WorkbasketAuthorization authorization) throws NotAuthorizedException; + void checkAuthorization(String workbasketKey, WorkbasketAuthorization authorization) throws NotAuthorizedException; /** - * This method get one WorkbasketAuthorization with an id. + * This method get one WorkbasketAccessItem with an id. + * * @param id - * the id + * the id of the requested WorkbasketAccessItem * @return the full {@link WorkbasketAccessItem} */ WorkbasketAccessItem getWorkbasketAuthorization(String id); /** * Get all authorizations for a Workbasket. - * @param workbasketId TODO - * @return List of WorkbasketAccessItems + * + * @param workbasketKey + * the key of the Workbasket + * @return List of WorkbasketAccessItems for the Workbasket with workbasketKey */ - List getWorkbasketAuthorizations(String workbasketId); + List getWorkbasketAuthorizations(String workbasketKey); /** - * This method returns the workbaskets for which the current user has all permissions - * specified in the permissions list. + * This method returns the workbaskets for which the current user has all permissions specified in the permissions + * list. * * @param permission * a List of WorkbasketAuthorization enums - * @return all filtered workbaskets + * @return all Workbaskets for which the current user has the specified authorizations */ List getWorkbaskets(List permission); /** - * This method provides a query builder for quering the database. + * This method provides a query builder for querying the database. + * * @return a {@link WorkbasketQuery} */ WorkbasketQuery createWorkbasketQuery(); /** * Returns a new workbasket which is not persisted. + * * @return newWorkbasket */ Workbasket newWorkbasket(); diff --git a/lib/taskana-core/src/main/java/pro/taskana/exceptions/InvalidWorkbasketException.java b/lib/taskana-core/src/main/java/pro/taskana/exceptions/InvalidWorkbasketException.java new file mode 100644 index 000000000..112afadf0 --- /dev/null +++ b/lib/taskana-core/src/main/java/pro/taskana/exceptions/InvalidWorkbasketException.java @@ -0,0 +1,17 @@ +package pro.taskana.exceptions; + +/** + * This exception is thrown when a request is made to insert or update a workbasket that is missing a required property. + * + * @author bbr + */ + +public class InvalidWorkbasketException extends TaskanaException { + + public InvalidWorkbasketException(String msg) { + super(msg); + } + + private static final long serialVersionUID = 1L; + +} diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/TaskImpl.java b/lib/taskana-core/src/main/java/pro/taskana/impl/TaskImpl.java index 5e908c533..ae8ea677a 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/TaskImpl.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/TaskImpl.java @@ -26,7 +26,7 @@ public class TaskImpl implements Task { private int priority; private TaskState state; private Classification classification; - private String workbasketId; + private String workbasketKey; private String businessProcessId; private String parentBusinessProcessId; private String owner; @@ -46,7 +46,8 @@ public class TaskImpl implements Task { private String custom9; private String custom10; - TaskImpl() { } + TaskImpl() { + } @Override public String getId() { @@ -89,7 +90,6 @@ public class TaskImpl implements Task { return modified; } - public void setModified(Timestamp modified) { this.modified = modified; } @@ -162,13 +162,13 @@ public class TaskImpl implements Task { } @Override - public String getWorkbasketId() { - return workbasketId; + public String getWorkbasketKey() { + return workbasketKey; } @Override - public void setWorkbasketId(String workbasketId) { - this.workbasketId = workbasketId; + public void setWorkbasketKey(String workbasketKey) { + this.workbasketKey = workbasketKey; } @Override @@ -176,7 +176,6 @@ public class TaskImpl implements Task { return businessProcessId; } - public void setBusinessProcessId(String businessProcessId) { this.businessProcessId = businessProcessId; } @@ -364,8 +363,8 @@ public class TaskImpl implements Task { builder.append(state); builder.append(", classification="); builder.append(classification); - builder.append(", workbasketId="); - builder.append(workbasketId); + builder.append(", workbasketKey="); + builder.append(workbasketKey); builder.append(", businessProcessId="); builder.append(businessProcessId); builder.append(", parentBusinessProcessId="); diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/TaskQueryImpl.java b/lib/taskana-core/src/main/java/pro/taskana/impl/TaskQueryImpl.java index f8ec5d5e6..a21599e04 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/TaskQueryImpl.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/TaskQueryImpl.java @@ -32,7 +32,7 @@ public class TaskQueryImpl implements TaskQuery { private int[] priority; private TaskState[] states; private ClassificationQuery classificationQuery; - private String[] workbasketId; + private String[] workbasketKey; private String[] owner; private ObjectReferenceQuery objectReferenceQuery; private Boolean isRead; @@ -74,8 +74,8 @@ public class TaskQueryImpl implements TaskQuery { } @Override - public TaskQuery workbasketId(String... workbasketIds) { - this.workbasketId = workbasketIds; + public TaskQuery workbasketKeyIn(String... workbasketKeys) { + this.workbasketKey = workbasketKeys; return this; } @@ -127,7 +127,8 @@ public class TaskQueryImpl implements TaskQuery { taskanaEngineImpl.returnConnection(); if (LOGGER.isDebugEnabled()) { int numberOfResultObjects = result == null ? 0 : result.size(); - LOGGER.debug("exit from list(). Returning {} resulting Objects: {} ", numberOfResultObjects, LoggerUtils.listToString(result)); + LOGGER.debug("exit from list(). Returning {} resulting Objects: {} ", numberOfResultObjects, + LoggerUtils.listToString(result)); } } } @@ -146,7 +147,8 @@ public class TaskQueryImpl implements TaskQuery { taskanaEngineImpl.returnConnection(); if (LOGGER.isDebugEnabled()) { int numberOfResultObjects = result == null ? 0 : result.size(); - LOGGER.debug("exit from list(offset,limit). Returning {} resulting Objects: {} ", numberOfResultObjects, LoggerUtils.listToString(result)); + LOGGER.debug("exit from list(offset,limit). Returning {} resulting Objects: {} ", numberOfResultObjects, + LoggerUtils.listToString(result)); } } } @@ -167,8 +169,8 @@ public class TaskQueryImpl implements TaskQuery { } private void checkAuthorization() throws NotAuthorizedException { - if (this.workbasketId != null && this.workbasketId.length > 0) { - for (String workbasket : this.workbasketId) { + if (this.workbasketKey != null && this.workbasketKey.length > 0) { + for (String workbasket : this.workbasketKey) { taskanaEngineImpl.getWorkbasketService().checkAuthorization(workbasket, WorkbasketAuthorization.OPEN); } } @@ -222,12 +224,12 @@ public class TaskQueryImpl implements TaskQuery { this.classificationQuery = classificationQuery; } - public String[] getWorkbasketId() { - return workbasketId; + public String[] getWorkbasketKey() { + return workbasketKey; } - public void setWorkbasketId(String[] workbasketId) { - this.workbasketId = workbasketId; + public void setWorkbasketKey(String[] workbasketKey) { + this.workbasketKey = workbasketKey; } public String[] getOwner() { @@ -285,8 +287,8 @@ public class TaskQueryImpl implements TaskQuery { builder.append(Arrays.toString(states)); builder.append(", classificationQuery="); builder.append(classificationQuery); - builder.append(", workbasketId="); - builder.append(Arrays.toString(workbasketId)); + builder.append(", workbasketKey="); + builder.append(Arrays.toString(workbasketKey)); builder.append(", owner="); builder.append(Arrays.toString(owner)); builder.append(", objectReferenceQuery="); diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/TaskServiceImpl.java b/lib/taskana-core/src/main/java/pro/taskana/impl/TaskServiceImpl.java index e1f24c7b8..f692732fe 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/TaskServiceImpl.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/TaskServiceImpl.java @@ -14,10 +14,12 @@ import pro.taskana.Task; import pro.taskana.TaskQuery; import pro.taskana.TaskService; import pro.taskana.TaskanaEngine; +import pro.taskana.Workbasket; import pro.taskana.WorkbasketService; import pro.taskana.exceptions.ClassificationNotFoundException; import pro.taskana.exceptions.InvalidOwnerException; import pro.taskana.exceptions.InvalidStateException; +import pro.taskana.exceptions.InvalidWorkbasketException; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.TaskAlreadyExistException; import pro.taskana.exceptions.TaskNotFoundException; @@ -38,21 +40,14 @@ import pro.taskana.security.CurrentUserContext; public class TaskServiceImpl implements TaskService { private static final Logger LOGGER = LoggerFactory.getLogger(TaskServiceImpl.class); - private static final String ID_PREFIX_OBJECT_REFERENCE = "ORI"; - private static final String ID_PREFIX_TASK = "TKI"; - private static final String ID_PREFIX_BUSINESS_PROCESS = "BPI"; private TaskanaEngine taskanaEngine; - private TaskanaEngineImpl taskanaEngineImpl; - private WorkbasketService workbasketService; - private TaskMapper taskMapper; - private ObjectReferenceMapper objectReferenceMapper; public TaskServiceImpl(TaskanaEngine taskanaEngine, TaskMapper taskMapper, @@ -155,7 +150,7 @@ public class TaskServiceImpl implements TaskService { @Override public Task createTask(Task taskToCreate) throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, - TaskAlreadyExistException { + TaskAlreadyExistException, InvalidWorkbasketException { LOGGER.debug("entry to createTask(task = {})", taskToCreate); try { taskanaEngineImpl.openConnection(); @@ -163,15 +158,15 @@ public class TaskServiceImpl implements TaskService { if (task.getId() != "" && task.getId() != null) { throw new TaskAlreadyExistException(taskToCreate.getId()); } else { - LOGGER.debug("Task {} can´t be be found, so it can be created.", taskToCreate.getId()); - workbasketService.getWorkbasket(task.getWorkbasketId()); - workbasketService.checkAuthorization(task.getWorkbasketId(), WorkbasketAuthorization.APPEND); + LOGGER.debug("Task {} cannot be be found, so it can be created.", taskToCreate.getId()); + Workbasket workbasket = workbasketService.getWorkbasketByKey(task.getWorkbasketKey()); + workbasketService.checkAuthorization(task.getWorkbasketKey(), WorkbasketAuthorization.APPEND); Classification classification = task.getClassification(); if (classification == null) { throw new ClassificationNotFoundException(null); } taskanaEngine.getClassificationService().getClassification(classification.getKey(), - classification.getDomain()); + workbasket.getDomain()); standardSettings(task); this.taskMapper.insert(task); @@ -204,22 +199,22 @@ public class TaskServiceImpl implements TaskService { } @Override - public Task transfer(String taskId, String destinationWorkbasketId) - throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException { - LOGGER.debug("entry to transfer(taskId = {}, destinationWorkbasketId = {})", taskId, destinationWorkbasketId); + public Task transfer(String taskId, String destinationWorkbasketKey) + throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException { + LOGGER.debug("entry to transfer(taskId = {}, destinationWorkbasketKey = {})", taskId, destinationWorkbasketKey); Task result = null; try { taskanaEngineImpl.openConnection(); TaskImpl task = (TaskImpl) getTaskById(taskId); // transfer requires TRANSFER in source and APPEND on destination workbasket - workbasketService.checkAuthorization(destinationWorkbasketId, WorkbasketAuthorization.APPEND); - workbasketService.checkAuthorization(task.getWorkbasketId(), WorkbasketAuthorization.TRANSFER); + workbasketService.checkAuthorization(destinationWorkbasketKey, WorkbasketAuthorization.APPEND); + workbasketService.checkAuthorization(task.getWorkbasketKey(), WorkbasketAuthorization.TRANSFER); // if security is disabled, the implicit existance check on the // destination workbasket has been skipped and needs to be performed if (!taskanaEngine.getConfiguration().isSecurityEnabled()) { - workbasketService.getWorkbasket(destinationWorkbasketId); + workbasketService.getWorkbasketByKey(destinationWorkbasketKey); } // reset read flag and set transferred flag @@ -227,13 +222,13 @@ public class TaskServiceImpl implements TaskService { task.setTransferred(true); // transfer task from source to destination workbasket - task.setWorkbasketId(destinationWorkbasketId); + task.setWorkbasketKey(destinationWorkbasketKey); task.setModified(Timestamp.valueOf(LocalDateTime.now())); taskMapper.update(task); result = getTaskById(taskId); LOGGER.debug("Method transfer() transferred Task '{}' to destination workbasket {}", taskId, - destinationWorkbasketId); + destinationWorkbasketKey); return result; } finally { taskanaEngineImpl.returnConnection(); @@ -266,15 +261,15 @@ public class TaskServiceImpl implements TaskService { } @Override - public List getTasksByWorkbasketIdAndState(String workbasketId, TaskState taskState) + public List getTasksByWorkbasketKeyAndState(String workbasketKey, TaskState taskState) throws WorkbasketNotFoundException, NotAuthorizedException { - LOGGER.debug("entry to getTasksByWorkbasketIdAndState(workbasketId = {}, taskState = {})", workbasketId, + LOGGER.debug("entry to getTasksByWorkbasketKeyAndState(workbasketId = {}, taskState = {})", workbasketKey, taskState); List results = new ArrayList<>(); try { taskanaEngineImpl.openConnection(); - workbasketService.checkAuthorization(workbasketId, WorkbasketAuthorization.READ); - List tasks = taskMapper.findTasksByWorkbasketIdAndState(workbasketId, taskState); + workbasketService.checkAuthorization(workbasketKey, WorkbasketAuthorization.READ); + List tasks = taskMapper.findTasksByWorkbasketIdAndState(workbasketKey, taskState); tasks.stream().forEach(t -> results.add(t)); } finally { taskanaEngineImpl.returnConnection(); @@ -341,13 +336,14 @@ public class TaskServiceImpl implements TaskService { } @Override - public List getTaskSummariesByWorkbasketId(String workbasketId) throws WorkbasketNotFoundException { - LOGGER.debug("entry to getTaskSummariesByWorkbasketId(workbasketId = {}", workbasketId); + public List getTaskSummariesByWorkbasketKey(String workbasketKey) + throws WorkbasketNotFoundException, InvalidWorkbasketException { + LOGGER.debug("entry to getTaskSummariesByWorkbasketId(workbasketId = {}", workbasketKey); List taskSummaries = new ArrayList<>(); - workbasketService.getWorkbasket(workbasketId); + workbasketService.getWorkbasketByKey(workbasketKey); try { taskanaEngineImpl.openConnection(); - taskSummaries = taskMapper.findTaskSummariesByWorkbasketId(workbasketId); + taskSummaries = taskMapper.findTaskSummariesByWorkbasketKey(workbasketKey); } catch (Exception ex) { LOGGER.error("Getting TASKSUMMARY failed internally.", ex); } finally { diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/WorkbasketImpl.java b/lib/taskana-core/src/main/java/pro/taskana/impl/WorkbasketImpl.java index bc42ad3c3..d48abfbd7 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/WorkbasketImpl.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/WorkbasketImpl.java @@ -5,6 +5,7 @@ import java.util.ArrayList; import java.util.List; import pro.taskana.Workbasket; +import pro.taskana.model.WorkbasketType; /** * Workbasket entity. @@ -12,14 +13,26 @@ import pro.taskana.Workbasket; public class WorkbasketImpl implements Workbasket { private String id; + private String key; private Timestamp created; private Timestamp modified; private String name; private String description; private String owner; + private String domain; + private WorkbasketType type; private List distributionTargets = new ArrayList<>(); + private String custom1; + private String custom2; + private String custom3; + private String custom4; + private String orgLevel1; + private String orgLevel2; + private String orgLevel3; + private String orgLevel4; - WorkbasketImpl() { } + WorkbasketImpl() { + } @Override public String getId() { @@ -30,6 +43,16 @@ public class WorkbasketImpl implements Workbasket { this.id = id; } + @Override + public String getKey() { + return key; + } + + @Override + public void setKey(String key) { + this.key = key; + } + @Override public Timestamp getCreated() { return created; @@ -78,6 +101,26 @@ public class WorkbasketImpl implements Workbasket { this.owner = owner; } + @Override + public String getDomain() { + return domain; + } + + @Override + public void setDomain(String domain) { + this.domain = domain; + } + + @Override + public WorkbasketType getType() { + return type; + } + + @Override + public void setType(WorkbasketType type) { + this.type = type; + } + @Override public List getDistributionTargets() { return distributionTargets; @@ -88,11 +131,77 @@ public class WorkbasketImpl implements Workbasket { this.distributionTargets = distributionTargets; } + 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; + } + @Override public String toString() { StringBuilder builder = new StringBuilder(); builder.append("Workbasket [id="); builder.append(id); + builder.append(", key="); + builder.append(key); builder.append(", created="); builder.append(created); builder.append(", modified="); @@ -103,11 +212,29 @@ public class WorkbasketImpl implements Workbasket { builder.append(description); builder.append(", owner="); builder.append(owner); + builder.append(", domain="); + builder.append(domain); + builder.append(", type="); + builder.append(type); builder.append(", distributionTargets="); builder.append(distributionTargets); + builder.append(", custom1="); + builder.append(custom1); + builder.append(", custom2="); + builder.append(custom2); + builder.append(", custom3="); + builder.append(custom3); + builder.append(", custom4="); + builder.append(custom4); + builder.append(", orgLevel1="); + builder.append(orgLevel1); + builder.append(", orgLevel2="); + builder.append(orgLevel2); + builder.append(", orgLevel3="); + builder.append(orgLevel3); + builder.append(", orgLevel4="); + builder.append(orgLevel4); builder.append("]"); return builder.toString(); } } - - diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/WorkbasketQueryImpl.java b/lib/taskana-core/src/main/java/pro/taskana/impl/WorkbasketQueryImpl.java index 7556a9609..6a04a093e 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/WorkbasketQueryImpl.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/WorkbasketQueryImpl.java @@ -15,20 +15,29 @@ import pro.taskana.exceptions.InvalidArgumentException; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.impl.util.LoggerUtils; import pro.taskana.model.WorkbasketAuthorization; +import pro.taskana.model.WorkbasketType; /** * WorkbasketQuery for generating dynamic SQL. - * @author bbr * + * @author bbr */ public class WorkbasketQueryImpl implements WorkbasketQuery { + private static final String LINK_TO_MAPPER = "pro.taskana.model.mappings.QueryMapper.queryWorkbasket"; + private static final Logger LOGGER = LoggerFactory.getLogger(WorkbasketQueryImpl.class); + private String[] accessId; private WorkbasketAuthorization authorization; private String[] name; - private Date[] created; - private Date[] modified; + private String[] key; + private String[] domain; + private WorkbasketType[] type; + private Date createdAfter; + private Date createdBefore; + private Date modifiedAfter; + private Date modifiedBefore; private String description; private String[] owner; private TaskanaEngineImpl taskanaEngineImpl; @@ -38,20 +47,50 @@ public class WorkbasketQueryImpl implements WorkbasketQuery { } @Override - public WorkbasketQuery name(String... names) { + public WorkbasketQuery keyIn(String... key) { + this.key = key; + return this; + } + + @Override + public WorkbasketQuery domainIn(String... domain) { + this.domain = domain; + return this; + } + + @Override + public WorkbasketQuery typeIn(WorkbasketType... type) { + this.type = type; + return this; + } + + @Override + public WorkbasketQuery nameIn(String... names) { this.name = names; return this; } @Override - public WorkbasketQuery created(Date... created) { - this.created = created; + public WorkbasketQuery createdAfter(Date createdAfter) { + this.createdAfter = createdAfter; return this; } @Override - public WorkbasketQuery modified(Date... modified) { - this.modified = modified; + public WorkbasketQuery createdBefore(Date createdBefore) { + this.createdBefore = createdBefore; + return this; + } + + @Override + public WorkbasketQuery modifiedAfter(Date modifiedAfter) { + this.modifiedAfter = modifiedAfter; + return this; + } + + @Override + public WorkbasketQuery modifiedBefore(Date modifiedBefore) { + this.modifiedBefore = modifiedBefore; return this; } @@ -62,13 +101,14 @@ public class WorkbasketQueryImpl implements WorkbasketQuery { } @Override - public WorkbasketQuery owner(String... owners) { + public WorkbasketQuery ownerIn(String... owners) { this.owner = owners; return this; } @Override - public WorkbasketQuery access(WorkbasketAuthorization permission, String... accessIds) throws InvalidArgumentException { + public WorkbasketQuery access(WorkbasketAuthorization permission, String... accessIds) + throws InvalidArgumentException { if (permission == null) { throw new InvalidArgumentException("permission must not be null"); } @@ -92,7 +132,8 @@ public class WorkbasketQueryImpl implements WorkbasketQuery { taskanaEngineImpl.returnConnection(); if (LOGGER.isDebugEnabled()) { int numberOfResultObjects = result == null ? 0 : result.size(); - LOGGER.debug("exit from list(). Returning {} resulting Objects: {} ", numberOfResultObjects, LoggerUtils.listToString(result)); + LOGGER.debug("exit from list(). Returning {} resulting Objects: {} ", numberOfResultObjects, + LoggerUtils.listToString(result)); } } } @@ -110,7 +151,8 @@ public class WorkbasketQueryImpl implements WorkbasketQuery { taskanaEngineImpl.returnConnection(); if (LOGGER.isDebugEnabled()) { int numberOfResultObjects = result == null ? 0 : result.size(); - LOGGER.debug("exit from list(offset,limit). Returning {} resulting Objects: {} ", numberOfResultObjects, LoggerUtils.listToString(result)); + LOGGER.debug("exit from list(offset,limit). Returning {} resulting Objects: {} ", numberOfResultObjects, + LoggerUtils.listToString(result)); } } } @@ -153,20 +195,60 @@ public class WorkbasketQueryImpl implements WorkbasketQuery { this.name = name; } - public Date[] getCreated() { - return created; + public String[] getKey() { + return key; } - public void setCreated(Date[] created) { - this.created = created; + public void setKey(String[] key) { + this.key = key; } - public Date[] getModified() { - return modified; + public String[] getDomain() { + return domain; } - public void setModified(Date[] modified) { - this.modified = modified; + public void setDomain(String[] domain) { + this.domain = domain; + } + + public WorkbasketType[] getType() { + return type; + } + + public void setType(WorkbasketType[] type) { + this.type = type; + } + + public Date getCreatedAfter() { + return createdAfter; + } + + public void setCreatedAfter(Date createdAfter) { + this.createdAfter = createdAfter; + } + + public Date getCreatedBefore() { + return createdBefore; + } + + public void setCreatedBefore(Date createdBefore) { + this.createdBefore = createdBefore; + } + + public Date getModifiedAfter() { + return modifiedAfter; + } + + public void setModifiedAfter(Date modifiedAfter) { + this.modifiedAfter = modifiedAfter; + } + + public Date getModifiedBefore() { + return modifiedBefore; + } + + public void setModifiedBefore(Date modifiedBefore) { + this.modifiedBefore = modifiedBefore; } public String getDescription() { @@ -194,16 +276,24 @@ public class WorkbasketQueryImpl implements WorkbasketQuery { builder.append(authorization); builder.append(", name="); builder.append(Arrays.toString(name)); - builder.append(", created="); - builder.append(Arrays.toString(created)); - builder.append(", modified="); - builder.append(Arrays.toString(modified)); + builder.append(", key="); + builder.append(Arrays.toString(key)); + builder.append(", domain="); + builder.append(Arrays.toString(domain)); + builder.append(", type="); + builder.append(Arrays.toString(type)); + builder.append(", createdAfter="); + builder.append(createdAfter); + builder.append(", createdBefore="); + builder.append(createdBefore); + builder.append(", modifiedAfter="); + builder.append(modifiedAfter); + builder.append(", modifiedBefore="); + builder.append(modifiedBefore); builder.append(", description="); builder.append(description); builder.append(", owner="); builder.append(Arrays.toString(owner)); - builder.append(", taskanaEngineImpl="); - builder.append(taskanaEngineImpl); builder.append("]"); return builder.toString(); } diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/WorkbasketServiceImpl.java b/lib/taskana-core/src/main/java/pro/taskana/impl/WorkbasketServiceImpl.java index 5db9491f6..1848de851 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/WorkbasketServiceImpl.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/WorkbasketServiceImpl.java @@ -13,6 +13,7 @@ import pro.taskana.TaskanaEngine; import pro.taskana.Workbasket; import pro.taskana.WorkbasketQuery; import pro.taskana.WorkbasketService; +import pro.taskana.exceptions.InvalidWorkbasketException; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.WorkbasketNotFoundException; import pro.taskana.impl.util.IdGenerator; @@ -30,13 +31,11 @@ import pro.taskana.security.CurrentUserContext; 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 TaskanaEngine taskanaEngine; private TaskanaEngineImpl taskanaEngineImpl; - private WorkbasketMapper workbasketMapper; private DistributionTargetMapper distributionTargetMapper; private WorkbasketAccessMapper workbasketAccessMapper; @@ -45,7 +44,7 @@ public class WorkbasketServiceImpl implements WorkbasketService { } public WorkbasketServiceImpl(TaskanaEngine taskanaEngine, WorkbasketMapper workbasketMapper, - DistributionTargetMapper distributionTargetMapper, WorkbasketAccessMapper workbasketAccessMapper) { + DistributionTargetMapper distributionTargetMapper, WorkbasketAccessMapper workbasketAccessMapper) { this.taskanaEngine = taskanaEngine; this.taskanaEngineImpl = (TaskanaEngineImpl) taskanaEngine; this.workbasketMapper = workbasketMapper; @@ -54,16 +53,46 @@ public class WorkbasketServiceImpl implements WorkbasketService { } @Override - public Workbasket getWorkbasket(String workbasketId) throws WorkbasketNotFoundException { + public Workbasket getWorkbasket(String workbasketId) + throws WorkbasketNotFoundException, InvalidWorkbasketException { LOGGER.debug("entry to getWorkbasket(workbasketId = {})", workbasketId); Workbasket result = null; try { taskanaEngineImpl.openConnection(); result = workbasketMapper.findById(workbasketId); if (result == null) { - LOGGER.warn("Method getWorkbasket() didn't find workbasket with id {}. Throwing WorkbasketNotFoundException", workbasketId); + LOGGER.warn( + "Method getWorkbasket() didn't find workbasket with id {}. Throwing WorkbasketNotFoundException", + workbasketId); throw new WorkbasketNotFoundException(workbasketId); + } else { + validateWorkbasket(result); } + + return result; + } finally { + taskanaEngineImpl.returnConnection(); + LOGGER.debug("exit from getWorkbasket(workbasketId). Returning result {} ", result); + } + } + + @Override + public Workbasket getWorkbasketByKey(String workbasketKey) + throws WorkbasketNotFoundException, InvalidWorkbasketException { + LOGGER.debug("entry to getWorkbasketByKey(workbasketKey = {})", workbasketKey); + Workbasket result = null; + try { + taskanaEngineImpl.openConnection(); + result = workbasketMapper.findByKey(workbasketKey); + if (result == null) { + LOGGER.warn( + "Method getWorkbasket() didn't find workbasket with key {}. Throwing WorkbasketNotFoundException", + workbasketKey); + throw new WorkbasketNotFoundException(workbasketKey); + } else { + validateWorkbasket(result); + } + return result; } finally { taskanaEngineImpl.returnConnection(); @@ -79,7 +108,7 @@ public class WorkbasketServiceImpl implements WorkbasketService { List result = null; try { taskanaEngineImpl.openConnection(); - //use a set to avoid duplicates + // use a set to avoid duplicates Set workbaskets = new HashSet<>(); for (String accessId : CurrentUserContext.getAccessIds()) { workbaskets.addAll(workbasketMapper.findByPermission(permissions, accessId)); @@ -91,7 +120,8 @@ public class WorkbasketServiceImpl implements WorkbasketService { taskanaEngineImpl.returnConnection(); if (LOGGER.isDebugEnabled()) { int numberOfResultObjects = result == null ? 0 : result.size(); - LOGGER.debug("exit from getWorkbaskets(permissions). Returning {} resulting Objects: {} ", numberOfResultObjects, LoggerUtils.listToString(result)); + LOGGER.debug("exit from getWorkbaskets(permissions). Returning {} resulting Objects: {} ", + numberOfResultObjects, LoggerUtils.listToString(result)); } } } @@ -109,13 +139,16 @@ public class WorkbasketServiceImpl implements WorkbasketService { taskanaEngineImpl.returnConnection(); if (LOGGER.isDebugEnabled()) { int numberOfResultObjects = workbaskets == null ? 0 : workbaskets.size(); - LOGGER.debug("exit from getWorkbaskets(). Returning {} resulting Objects: {} ", numberOfResultObjects, LoggerUtils.listToString(workbaskets)); + LOGGER.debug("exit from getWorkbaskets(). Returning {} resulting Objects: {} ", numberOfResultObjects, + LoggerUtils.listToString(workbaskets)); } } } @Override - public Workbasket createWorkbasket(Workbasket newWorkbasket) { + + public Workbasket createWorkbasket(Workbasket newWorkbasket) + throws InvalidWorkbasketException, WorkbasketNotFoundException { LOGGER.debug("entry to createtWorkbasket(workbasket)", newWorkbasket); Workbasket result = null; WorkbasketImpl workbasket = (WorkbasketImpl) newWorkbasket; @@ -127,20 +160,17 @@ public class WorkbasketServiceImpl implements WorkbasketService { if (workbasket.getId() == null || workbasket.getId().isEmpty()) { workbasket.setId(IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET)); } + validateWorkbasket(workbasket); + workbasketMapper.insert(workbasket); LOGGER.debug("Method createWorkbasket() created Workbasket '{}'", workbasket); if (workbasket.getDistributionTargets() != null) { for (Workbasket distributionTarget : workbasket.getDistributionTargets()) { - if (workbasketMapper.findById(distributionTarget.getId()) == null) { - WorkbasketImpl tempBasket = (WorkbasketImpl) distributionTarget; - tempBasket.setCreated(now); - tempBasket.setModified(now); - workbasketMapper.insert(tempBasket); - distributionTarget = tempBasket; - LOGGER.debug("Method createWorkbasket() created distributionTarget '{}'", distributionTarget); - } + // validate that all distribution targets exist + getWorkbasket(distributionTarget.getId()); distributionTargetMapper.insert(workbasket.getId(), distributionTarget.getId()); - LOGGER.debug("Method createWorkbasket() created distributiontarget for source '{}' and target {}", workbasket.getId(), distributionTarget.getId()); + LOGGER.debug("Method createWorkbasket() created distributiontarget for source '{}' and target {}", + workbasket.getId(), distributionTarget.getId()); } } result = workbasketMapper.findById(workbasket.getId()); @@ -152,7 +182,8 @@ public class WorkbasketServiceImpl implements WorkbasketService { } @Override - public Workbasket updateWorkbasket(Workbasket workbasketToUpdate) throws NotAuthorizedException { + public Workbasket updateWorkbasket(Workbasket workbasketToUpdate) + throws NotAuthorizedException, WorkbasketNotFoundException, InvalidWorkbasketException { LOGGER.debug("entry to updateWorkbasket(workbasket)", workbasketToUpdate); Workbasket result = null; WorkbasketImpl workbasket = (WorkbasketImpl) workbasketToUpdate; @@ -162,25 +193,23 @@ public class WorkbasketServiceImpl implements WorkbasketService { workbasketMapper.update(workbasket); LOGGER.debug("Method updateWorkbasket() updated workbasket '{}'", workbasket.getId()); List oldDistributionTargets = distributionTargetMapper.findBySourceId(workbasket.getId()); - List distributionTargets = workbasket.getDistributionTargets(); - for (Workbasket distributionTarget : distributionTargets) { + List newDistributionTargets = workbasket.getDistributionTargets(); + for (Workbasket distributionTarget : newDistributionTargets) { if (!oldDistributionTargets.contains(distributionTarget.getId())) { - if (workbasketMapper.findById(distributionTarget.getId()) == null) { - WorkbasketImpl tempBasket = (WorkbasketImpl) distributionTarget; - workbasketMapper.insert(tempBasket); - distributionTarget = tempBasket; - LOGGER.debug(" Method updateWorkbasket() created distributionTarget '{}'", distributionTarget); - } + // check that old distribution target exists + getWorkbasket(distributionTarget.getId()); distributionTargetMapper.insert(workbasket.getId(), distributionTarget.getId()); - LOGGER.debug("Method updateWorkbasket() created distributionTarget for '{}' and '{}'", workbasket.getId(), distributionTarget.getId()); + LOGGER.debug("Method updateWorkbasket() created distributionTarget for '{}' and '{}'", + workbasket.getId(), distributionTarget.getId()); } else { oldDistributionTargets.remove(distributionTarget.getId()); } } distributionTargetMapper.deleteMultiple(workbasket.getId(), oldDistributionTargets); if (LOGGER.isInfoEnabled()) { - LOGGER.debug("Method updateWorkbasket() deleted distributionTargets for '{}' and old distribution targets {}", - workbasket.getId(), LoggerUtils.listToString(oldDistributionTargets)); + LOGGER.debug( + "Method updateWorkbasket() deleted distributionTargets for '{}' and old distribution targets {}", + workbasket.getId(), LoggerUtils.listToString(oldDistributionTargets)); } result = workbasketMapper.findById(workbasket.getId()); return result; @@ -197,19 +226,21 @@ public class WorkbasketServiceImpl implements WorkbasketService { taskanaEngineImpl.openConnection(); workbasketAccessItem.setId(IdGenerator.generateWithPrefix(ID_PREFIX_WORKBASKET_AUTHORIZATION)); workbasketAccessMapper.insert(workbasketAccessItem); - LOGGER.debug("Method createWorkbasketAuthorization() created workbaskteAccessItem {}", workbasketAccessItem); + LOGGER.debug("Method createWorkbasketAuthorization() created workbaskteAccessItem {}", + workbasketAccessItem); return workbasketAccessItem; } finally { taskanaEngineImpl.returnConnection(); - LOGGER.debug("exit from createWorkbasketAuthorization(workbasketAccessItem). Returning result {}", workbasketAccessItem); + LOGGER.debug("exit from createWorkbasketAuthorization(workbasketAccessItem). Returning result {}", + workbasketAccessItem); } } @Override public WorkbasketAccessItem getWorkbasketAuthorization(String id) { - LOGGER.debug("entry to getWorkbasketAuthorization(id = {})", id); - WorkbasketAccessItem result = null; - try { + LOGGER.debug("entry to getWorkbasketAuthorization(id = {})", id); + WorkbasketAccessItem result = null; + try { taskanaEngineImpl.openConnection(); result = workbasketAccessMapper.findById(id); return result; @@ -244,15 +275,17 @@ public class WorkbasketServiceImpl implements WorkbasketService { taskanaEngineImpl.returnConnection(); if (LOGGER.isDebugEnabled()) { int numberOfResultObjects = result == null ? 0 : result.size(); - LOGGER.debug("exit from getAllAuthorizations(). Returning {} resulting Objects: {} ", numberOfResultObjects, LoggerUtils.listToString(result)); + LOGGER.debug("exit from getAllAuthorizations(). Returning {} resulting Objects: {} ", + numberOfResultObjects, LoggerUtils.listToString(result)); } } } @Override - public void checkAuthorization(String workbasketId, WorkbasketAuthorization workbasketAuthorization) - throws NotAuthorizedException { - LOGGER.debug("entry to checkAuthorization(workbasketId = {}, workbasketAuthorization = {})", workbasketId, workbasketAuthorization); + public void checkAuthorization(String workbasketKey, WorkbasketAuthorization workbasketAuthorization) + throws NotAuthorizedException { + LOGGER.debug("entry to checkAuthorization(workbasketId = {}, workbasketAuthorization = {})", workbasketKey, + workbasketAuthorization); boolean isAuthorized = false; try { taskanaEngineImpl.openConnection(); @@ -265,14 +298,14 @@ public class WorkbasketServiceImpl implements WorkbasketService { List accessIds = CurrentUserContext.getAccessIds(); LOGGER.debug("checkAuthorization: Verifying that {} has the permission {} on workbasket {}", - CurrentUserContext.getUserid(), workbasketAuthorization.name(), workbasketId); + CurrentUserContext.getUserid(), workbasketAuthorization.name(), workbasketKey); List accessItems = workbasketAccessMapper - .findByWorkbasketAndAccessIdAndAuthorizations(workbasketId, accessIds, workbasketAuthorization.name()); + .findByWorkbasketAndAccessIdAndAuthorizations(workbasketKey, accessIds, workbasketAuthorization.name()); if (accessItems.size() <= 0) { throw new NotAuthorizedException("Not authorized. Authorization '" + workbasketAuthorization.name() - + "' on workbasket '" + workbasketId + "' is needed."); + + "' on workbasket '" + workbasketKey + "' is needed."); } isAuthorized = true; @@ -289,27 +322,30 @@ public class WorkbasketServiceImpl implements WorkbasketService { try { taskanaEngineImpl.openConnection(); workbasketAccessMapper.update(workbasketAccessItem); - LOGGER.debug("Method updateWorkbasketAuthorization() updated workbasketAccessItem {}", workbasketAccessItem); + LOGGER.debug("Method updateWorkbasketAuthorization() updated workbasketAccessItem {}", + workbasketAccessItem); return workbasketAccessItem; } finally { taskanaEngineImpl.returnConnection(); - LOGGER.debug("exit from updateWorkbasketAuthorization(workbasketAccessItem). Returning {}", workbasketAccessItem); + LOGGER.debug("exit from updateWorkbasketAuthorization(workbasketAccessItem). Returning {}", + workbasketAccessItem); } } @Override - public List getWorkbasketAuthorizations(String workbasketId) { - LOGGER.debug("entry to getWorkbasketAuthorizations(workbasketId = {})", workbasketId); + public List getWorkbasketAuthorizations(String workbasketKey) { + LOGGER.debug("entry to getWorkbasketAuthorizations(workbasketId = {})", workbasketKey); List result = null; try { taskanaEngineImpl.openConnection(); - result = workbasketAccessMapper.findByWorkbasketId(workbasketId); + result = workbasketAccessMapper.findByWorkbasketKey(workbasketKey); return result; } finally { taskanaEngineImpl.returnConnection(); if (LOGGER.isDebugEnabled()) { int numberOfResultObjects = result == null ? 0 : result.size(); - LOGGER.debug("exit from getWorkbasketAuthorizations(workbasketId). Returning {} resulting Objects: {} ", numberOfResultObjects, LoggerUtils.listToString(result)); + LOGGER.debug("exit from getWorkbasketAuthorizations(workbasketId). Returning {} resulting Objects: {} ", + numberOfResultObjects, LoggerUtils.listToString(result)); } } } @@ -319,6 +355,24 @@ public class WorkbasketServiceImpl implements WorkbasketService { return new WorkbasketQueryImpl(taskanaEngine); } + private void validateWorkbasket(Workbasket workbasket) throws InvalidWorkbasketException { + // check that required properties (database not null) are set + if (workbasket.getId() == null || workbasket.getId().length() == 0) { + throw new InvalidWorkbasketException("Id must not be null for " + workbasket); + } else if (workbasket.getKey() == null || workbasket.getKey().length() == 0) { + throw new InvalidWorkbasketException("Key must not be null for " + workbasket); + } + if (workbasket.getName() == null || workbasket.getName().length() == 0) { + throw new InvalidWorkbasketException("Name must not be null for " + workbasket); + } + if (workbasket.getDomain() == null) { + throw new InvalidWorkbasketException("Domain must not be null for " + workbasket); + } + if (workbasket.getType() == null) { + throw new InvalidWorkbasketException("Type must not be null for " + workbasket); + } + } + @Override public Workbasket newWorkbasket() { return new WorkbasketImpl(); diff --git a/lib/taskana-core/src/main/java/pro/taskana/model/TaskSummary.java b/lib/taskana-core/src/main/java/pro/taskana/model/TaskSummary.java index 73e7c2dbe..0b872fa2b 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/model/TaskSummary.java +++ b/lib/taskana-core/src/main/java/pro/taskana/model/TaskSummary.java @@ -8,7 +8,7 @@ public class TaskSummary { private String taskId; private String taskName; - private String workbasketId; + private String workbasketKey; private String workbasketName; private String classificationKey; private String classificationName; @@ -25,11 +25,13 @@ public class TaskSummary { public void setTaskName(String taskName) { this.taskName = taskName; } - public String getWorkbasketId() { - return workbasketId; + + public String getWorkbasketKey() { + return workbasketKey; } - public void setWorkbasketId(String workbasketId) { - this.workbasketId = workbasketId; + + public void setWorkbasketKey(String workbasketKey) { + this.workbasketKey = workbasketKey; } public String getWorkbasketName() { return workbasketName; @@ -58,7 +60,7 @@ public class TaskSummary { result = prime * result + ((classificationName == null) ? 0 : classificationName.hashCode()); result = prime * result + ((taskId == null) ? 0 : taskId.hashCode()); result = prime * result + ((taskName == null) ? 0 : taskName.hashCode()); - result = prime * result + ((workbasketId == null) ? 0 : workbasketId.hashCode()); + result = prime * result + ((workbasketKey == null) ? 0 : workbasketKey.hashCode()); result = prime * result + ((workbasketName == null) ? 0 : workbasketName.hashCode()); return result; } @@ -103,11 +105,11 @@ public class TaskSummary { } else if (!taskName.equals(other.taskName)) { return false; } - if (workbasketId == null) { - if (other.workbasketId != null) { + if (workbasketKey == null) { + if (other.workbasketKey != null) { return false; } - } else if (!workbasketId.equals(other.workbasketId)) { + } else if (!workbasketKey.equals(other.workbasketKey)) { return false; } if (workbasketName == null) { @@ -122,8 +124,20 @@ public class TaskSummary { @Override public String toString() { - return "TaskSummary [taskId=" + taskId + ", taskName=" + taskName + ", workbasketId=" + workbasketId - + ", workbasketName=" + workbasketName + ", classificationKey=" + classificationKey - + ", classificationName=" + classificationName + "]"; + StringBuilder builder = new StringBuilder(); + builder.append("TaskSummary [taskId="); + builder.append(taskId); + builder.append(", taskName="); + builder.append(taskName); + builder.append(", workbasketKey="); + builder.append(workbasketKey); + builder.append(", workbasketName="); + builder.append(workbasketName); + builder.append(", classificationKey="); + builder.append(classificationKey); + builder.append(", classificationName="); + builder.append(classificationName); + builder.append("]"); + return builder.toString(); } } diff --git a/lib/taskana-core/src/main/java/pro/taskana/model/WorkbasketAccessItem.java b/lib/taskana-core/src/main/java/pro/taskana/model/WorkbasketAccessItem.java index 135ade1a2..4e7a46f43 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/model/WorkbasketAccessItem.java +++ b/lib/taskana-core/src/main/java/pro/taskana/model/WorkbasketAccessItem.java @@ -6,7 +6,7 @@ package pro.taskana.model; public class WorkbasketAccessItem { private String id; - private String workbasketId; + private String workbasketKey; private String accessId; private boolean permRead; private boolean permOpen; @@ -31,12 +31,12 @@ public class WorkbasketAccessItem { this.id = id; } - public String getWorkbasketId() { - return workbasketId; + public String getWorkbasketKey() { + return workbasketKey; } - public void setWorkbasketId(String workbasketId) { - this.workbasketId = workbasketId; + public void setWorkbasketKey(String workbasketKey) { + this.workbasketKey = workbasketKey; } public String getAccessId() { @@ -156,8 +156,8 @@ public class WorkbasketAccessItem { StringBuilder builder = new StringBuilder(); builder.append("WorkbasketAccessItem [id="); builder.append(id); - builder.append(", workbasketId="); - builder.append(workbasketId); + builder.append(", workbasketKey="); + builder.append(workbasketKey); builder.append(", accessId="); builder.append(accessId); builder.append(", permRead="); diff --git a/lib/taskana-core/src/main/java/pro/taskana/model/WorkbasketType.java b/lib/taskana-core/src/main/java/pro/taskana/model/WorkbasketType.java new file mode 100644 index 000000000..b3d37c375 --- /dev/null +++ b/lib/taskana-core/src/main/java/pro/taskana/model/WorkbasketType.java @@ -0,0 +1,8 @@ +package pro.taskana.model; + +/** + * This enum contains the supported work basket types. + */ +public enum WorkbasketType { + GROUP, PERSONAL, TOPIC, CLEARANCE +} diff --git a/lib/taskana-core/src/main/java/pro/taskana/model/mappings/QueryMapper.java b/lib/taskana-core/src/main/java/pro/taskana/model/mappings/QueryMapper.java index d2307edb9..ef7b985be 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/model/mappings/QueryMapper.java +++ b/lib/taskana-core/src/main/java/pro/taskana/model/mappings/QueryMapper.java @@ -26,184 +26,201 @@ public interface QueryMapper { String CLASSIFICATION_FINDBYIDANDDOMAIN = "pro.taskana.model.mappings.ClassificationMapper.findByKeyAndDomain"; String CLASSIFICATION_FINDBYID = "pro.taskana.model.mappings.ClassificationMapper.findById"; - @Select("") - @Results(value = { @Result(property = "id", column = "ID"), - @Result(property = "created", column = "CREATED"), - @Result(property = "claimed", column = "CLAIMED"), - @Result(property = "completed", column = "COMPLETED"), - @Result(property = "planned", column = "PLANNED"), - @Result(property = "due", column = "DUE"), - @Result(property = "name", column = "NAME"), - @Result(property = "description", column = "DESCRIPTION"), - @Result(property = "priority", column = "PRIORITY"), - @Result(property = "state", column = "STATE"), - @Result(property = "classification", column = "CLASSIFICATION_ID", javaType = ClassificationImpl.class, one = @One(select = CLASSIFICATION_FINDBYID)), - @Result(property = "workbasketId", column = "WORKBASKETID"), - @Result(property = "owner", column = "OWNER"), - @Result(property = "primaryObjRef", column = "PRIMARY_OBJ_REF_ID", javaType = ObjectReference.class, one = @One(select = OBJECTREFERENCEMAPPER_FINDBYID)), - @Result(property = "isRead", column = "IS_READ"), - @Result(property = "isTransferred", column = "IS_TRANSFERRED"), - @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 = "custom5", column = "CUSTOM_5"), - @Result(property = "custom6", column = "CUSTOM_6"), - @Result(property = "custom7", column = "CUSTOM_7"), - @Result(property = "custom8", column = "CUSTOM_8"), - @Result(property = "custom9", column = "CUSTOM_9"), - @Result(property = "custom10", column = "CUSTOM_10") }) + @Select("") + @Results(value = {@Result(property = "id", column = "ID"), + @Result(property = "created", column = "CREATED"), + @Result(property = "claimed", column = "CLAIMED"), + @Result(property = "completed", column = "COMPLETED"), + @Result(property = "planned", column = "PLANNED"), + @Result(property = "due", column = "DUE"), + @Result(property = "name", column = "NAME"), + @Result(property = "description", column = "DESCRIPTION"), + @Result(property = "priority", column = "PRIORITY"), + @Result(property = "state", column = "STATE"), + @Result(property = "classification", column = "CLASSIFICATION_ID", javaType = ClassificationImpl.class, + one = @One(select = CLASSIFICATION_FINDBYID)), + @Result(property = "workbasketKey", column = "WORKBASKET_KEY"), + @Result(property = "owner", column = "OWNER"), + @Result(property = "primaryObjRef", column = "PRIMARY_OBJ_REF_ID", javaType = ObjectReference.class, + one = @One(select = OBJECTREFERENCEMAPPER_FINDBYID)), + @Result(property = "isRead", column = "IS_READ"), + @Result(property = "isTransferred", column = "IS_TRANSFERRED"), + @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 = "custom5", column = "CUSTOM_5"), + @Result(property = "custom6", column = "CUSTOM_6"), + @Result(property = "custom7", column = "CUSTOM_7"), + @Result(property = "custom8", column = "CUSTOM_8"), + @Result(property = "custom9", column = "CUSTOM_9"), + @Result(property = "custom10", column = "CUSTOM_10")}) List queryTasks(TaskQueryImpl taskQuery); @Select("") - @Results({ @Result(property = "id", column = "ID"), - @Result(property = "parentClassificationId", column = "PARENT_CLASSIFICATION_ID"), - @Result(property = "category", column = "CATEGORY"), - @Result(property = "type", column = "TYPE"), - @Result(property = "domain", column = "DOMAIN"), - @Result(property = "isValidInDomain", column = "VALID_IN_DOMAIN"), - @Result(property = "created", column = "CREATED"), - @Result(property = "name", column = "NAME"), - @Result(property = "description", column = "DESCRIPTION"), - @Result(property = "priority", column = "PRIORITY"), - @Result(property = "serviceLevel", column = "SERVICE_LEVEL"), - @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 = "custom5", column = "CUSTOM_5"), - @Result(property = "custom6", column = "CUSTOM_6"), - @Result(property = "custom7", column = "CUSTOM_7"), - @Result(property = "custom8", column = "CUSTOM_8"), - @Result(property = "validFrom", column = "VALID_FROM"), - @Result(property = "validUntil", column = "VALID_UNTIL") }) + + "FROM CLASSIFICATION " + + "" + + "AND KEY IN(#{item}) " + + "AND PARENT_CLASSIFICATION_KEY IN(#{item}) " + + "AND CATEGORY IN(#{item}) " + + "AND TYPE IN(#{item}) " + + "AND DOMAIN IN(#{item}) " + + "AND VALID_IN_DOMAIN = #{validInDomain} " + + "AND CREATED IN(#{item}) " + + "AND NAME IN(#{item}) " + + "AND DESCRIPTION like #{description} " + + "AND PRIORITY IN(#{item}) " + + "AND SERVICE_LEVEL IN(#{item}) " + + "AND APPLICATION_ENTRY_POINT IN(#{item}) " + + "AND (CUSTOM_1 IN(#{item}) OR CUSTOM_2 IN(#{item}) OR CUSTOM_3 IN(#{item}) OR CUSTOM_4 IN(#{item}) OR CUSTOM_5 IN(#{item}) OR CUSTOM_6 IN(#{item}) OR CUSTOM_7 IN(#{item}) OR CUSTOM_8 IN(#{item})) " + + "AND VALID_FROM IN(#{item}) " + + "AND VALID_UNTIL IN(#{item}) " + + "" + + "") + @Results({@Result(property = "id", column = "ID"), + @Result(property = "parentClassificationId", column = "PARENT_CLASSIFICATION_ID"), + @Result(property = "category", column = "CATEGORY"), + @Result(property = "type", column = "TYPE"), + @Result(property = "domain", column = "DOMAIN"), + @Result(property = "isValidInDomain", column = "VALID_IN_DOMAIN"), + @Result(property = "created", column = "CREATED"), + @Result(property = "name", column = "NAME"), + @Result(property = "description", column = "DESCRIPTION"), + @Result(property = "priority", column = "PRIORITY"), + @Result(property = "serviceLevel", column = "SERVICE_LEVEL"), + @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 = "custom5", column = "CUSTOM_5"), + @Result(property = "custom6", column = "CUSTOM_6"), + @Result(property = "custom7", column = "CUSTOM_7"), + @Result(property = "custom8", column = "CUSTOM_8"), + @Result(property = "validFrom", column = "VALID_FROM"), + @Result(property = "validUntil", column = "VALID_UNTIL")}) List queryClassification(ClassificationQueryImpl classificationQuery); - @Select("") + + "FROM OBJECT_REFERENCE " + + "" + + "AND COMPANY IN(#{item}) " + + "AND SYSTEM IN(#{item}) " + + "AND SYSTEM_INSTANCE IN(#{item}) " + + "AND TYPE IN(#{item}) " + + "AND VALUE IN(#{item}) " + + "" + + "") @Results({ @Result(property = "id", column = "ID"), @Result(property = "company", column = "COMPANY"), @Result(property = "system", column = "SYSTEM"), @Result(property = "systemInstance", column = "SYSTEM_INSTANCE"), @Result(property = "type", column = "TYPE"), - @Result(property = "value", column = "VALUE") }) + @Result(property = "value", column = "VALUE")}) List queryObjectReference(ObjectReferenceQueryImpl objectReference); - @Select("") + @Select("") @Results({ @Result(property = "id", column = "ID"), + @Result(property = "key", column = "KEY"), @Result(property = "name", column = "NAME"), @Result(property = "created", column = "CREATED"), @Result(property = "modified", column = "MODIFIED"), + @Result(property = "domain", column = "DOMAIN"), + @Result(property = "type", column = "TYPE"), @Result(property = "description", column = "DESCRIPTION"), @Result(property = "owner", column = "OWNER"), - @Result(property = "distributionTargets", column = "id", javaType = List.class, many = @Many(select = "findDistributionTargets"))}) + @Result(property = "distributionTargets", column = "id", javaType = List.class, + many = @Many(select = "findDistributionTargets")), + @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 = "ORG_LEVEL_1"), + @Result(property = "orgLevel2", column = "ORG_LEVEL_2"), + @Result(property = "orgLevel3", column = "ORG_LEVEL_3"), + @Result(property = "orgLevel4", column = "ORG_LEVEL_4")}) List queryWorkbasket(WorkbasketQueryImpl workbasketQuery); @Select("") + + "" + + "SOURCE_ID = #{sourceId}" + + "" + + "") @Results(value = { @Result(property = "distributionTarget", column = "TARGET_ID")}) List findDistributionTargets(String sourceId); - } diff --git a/lib/taskana-core/src/main/java/pro/taskana/model/mappings/TaskMapper.java b/lib/taskana-core/src/main/java/pro/taskana/model/mappings/TaskMapper.java index 8b8f5d38a..e44c569d9 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/model/mappings/TaskMapper.java +++ b/lib/taskana-core/src/main/java/pro/taskana/model/mappings/TaskMapper.java @@ -31,7 +31,7 @@ public interface TaskMapper { String CLASSIFICATION_FINDBYKEYROOTDOMAIN = "pro.taskana.model.mappings.ClassificationMapper.findByKeyRootDomain"; - @Select("SELECT ID, CREATED, CLAIMED, COMPLETED, MODIFIED, PLANNED, DUE, NAME, DESCRIPTION, PRIORITY, STATE, CLASSIFICATION_KEY, WORKBASKETID, BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, OWNER, PRIMARY_OBJ_REF_ID, IS_READ, IS_TRANSFERRED, CUSTOM_ATTRIBUTES, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, CUSTOM_5, CUSTOM_6, CUSTOM_7, CUSTOM_8, CUSTOM_9, CUSTOM_10 " + @Select("SELECT ID, CREATED, CLAIMED, COMPLETED, MODIFIED, PLANNED, DUE, NAME, DESCRIPTION, PRIORITY, STATE, CLASSIFICATION_KEY, WORKBASKET_KEY, BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, OWNER, PRIMARY_OBJ_REF_ID, IS_READ, IS_TRANSFERRED, CUSTOM_ATTRIBUTES, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, CUSTOM_5, CUSTOM_6, CUSTOM_7, CUSTOM_8, CUSTOM_9, CUSTOM_10 " + "FROM TASK " + "WHERE ID = #{id}") @Results(value = { @@ -48,7 +48,7 @@ public interface TaskMapper { @Result(property = "state", column = "STATE"), @Result(property = "classification", column = "CLASSIFICATION_KEY", javaType = ClassificationImpl.class, one = @One(select = CLASSIFICATION_FINDBYKEYROOTDOMAIN)), - @Result(property = "workbasketId", column = "WORKBASKETID"), + @Result(property = "workbasketKey", column = "WORKBASKET_KEY"), @Result(property = "businessProcessId", column = "BUSINESS_PROCESS_ID"), @Result(property = "parentBusinessProcessId", column = "PARENT_BUSINESS_PROCESS_ID"), @Result(property = "owner", column = "OWNER"), @@ -71,21 +71,21 @@ public interface TaskMapper { }) TaskImpl findById(@Param("id") String id); - @Insert("INSERT INTO TASK(ID, CREATED, CLAIMED, COMPLETED, MODIFIED, PLANNED, DUE, NAME, DESCRIPTION, PRIORITY, STATE, CLASSIFICATION_KEY, WORKBASKETID, BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, OWNER, PRIMARY_OBJ_REF_ID, IS_READ, IS_TRANSFERRED, CUSTOM_ATTRIBUTES, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, CUSTOM_5, CUSTOM_6, CUSTOM_7, CUSTOM_8, CUSTOM_9, CUSTOM_10) " - + "VALUES(#{id}, #{created}, #{claimed}, #{completed}, #{modified}, #{planned}, #{due}, #{name}, #{description}, #{priority}, #{state}, #{classification.key}, #{workbasketId}, #{businessProcessId}, #{parentBusinessProcessId}, #{owner}, #{primaryObjRef.id}, #{isRead}, #{isTransferred}, #{customAttributes,jdbcType=BLOB,javaType=java.util.Map,typeHandler=pro.taskana.impl.persistence.MapTypeHandler}, #{custom1}, #{custom2}, #{custom3}, #{custom4}, #{custom5}, #{custom6}, #{custom7}, #{custom8}, #{custom9}, #{custom10})") + @Insert("INSERT INTO TASK(ID, CREATED, CLAIMED, COMPLETED, MODIFIED, PLANNED, DUE, NAME, DESCRIPTION, PRIORITY, STATE, CLASSIFICATION_KEY, WORKBASKET_KEY, BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, OWNER, PRIMARY_OBJ_REF_ID, IS_READ, IS_TRANSFERRED, CUSTOM_ATTRIBUTES, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, CUSTOM_5, CUSTOM_6, CUSTOM_7, CUSTOM_8, CUSTOM_9, CUSTOM_10) " + + "VALUES(#{id}, #{created}, #{claimed}, #{completed}, #{modified}, #{planned}, #{due}, #{name}, #{description}, #{priority}, #{state}, #{classification.key}, #{workbasketKey}, #{businessProcessId}, #{parentBusinessProcessId}, #{owner}, #{primaryObjRef.id}, #{isRead}, #{isTransferred}, #{customAttributes,jdbcType=BLOB,javaType=java.util.Map,typeHandler=pro.taskana.impl.persistence.MapTypeHandler}, #{custom1}, #{custom2}, #{custom3}, #{custom4}, #{custom5}, #{custom6}, #{custom7}, #{custom8}, #{custom9}, #{custom10})") @Options(keyProperty = "id", keyColumn = "ID") void insert(TaskImpl task); - @Update("UPDATE TASK SET CLAIMED = #{claimed}, COMPLETED = #{completed}, MODIFIED = #{modified}, PLANNED = #{planned}, DUE = #{due}, NAME = #{name}, DESCRIPTION = #{description}, PRIORITY = #{priority}, STATE = #{state}, CLASSIFICATION_KEY = #{classification.key}, WORKBASKETID = #{workbasketId}, BUSINESS_PROCESS_ID = #{businessProcessId}, PARENT_BUSINESS_PROCESS_ID = #{parentBusinessProcessId}, OWNER = #{owner}, PRIMARY_OBJ_REF_ID = #{primaryObjRef.id}, IS_READ = #{isRead}, IS_TRANSFERRED = #{isTransferred}, CUSTOM_ATTRIBUTES = #{customAttributes,jdbcType=BLOB,javaType=java.util.Map,typeHandler=pro.taskana.impl.persistence.MapTypeHandler}, CUSTOM_1 = #{custom1}, CUSTOM_2 = #{custom2}, CUSTOM_3 = #{custom3}, CUSTOM_4 = #{custom4}, CUSTOM_5 = #{custom5}, CUSTOM_6 = #{custom6}, CUSTOM_7 = #{custom7}, CUSTOM_8 = #{custom8}, CUSTOM_9 = #{custom9}, CUSTOM_10 = #{custom10} " + @Update("UPDATE TASK SET CLAIMED = #{claimed}, COMPLETED = #{completed}, MODIFIED = #{modified}, PLANNED = #{planned}, DUE = #{due}, NAME = #{name}, DESCRIPTION = #{description}, PRIORITY = #{priority}, STATE = #{state}, CLASSIFICATION_KEY = #{classification.key}, WORKBASKET_KEY = #{workbasketKey}, BUSINESS_PROCESS_ID = #{businessProcessId}, PARENT_BUSINESS_PROCESS_ID = #{parentBusinessProcessId}, OWNER = #{owner}, PRIMARY_OBJ_REF_ID = #{primaryObjRef.id}, IS_READ = #{isRead}, IS_TRANSFERRED = #{isTransferred}, CUSTOM_ATTRIBUTES = #{customAttributes,jdbcType=BLOB,javaType=java.util.Map,typeHandler=pro.taskana.impl.persistence.MapTypeHandler}, CUSTOM_1 = #{custom1}, CUSTOM_2 = #{custom2}, CUSTOM_3 = #{custom3}, CUSTOM_4 = #{custom4}, CUSTOM_5 = #{custom5}, CUSTOM_6 = #{custom6}, CUSTOM_7 = #{custom7}, CUSTOM_8 = #{custom8}, CUSTOM_9 = #{custom9}, CUSTOM_10 = #{custom10} " + "WHERE ID = #{id}") void update(TaskImpl task); @Delete("DELETE FROM TASK WHERE ID = #{id}") void delete(String id); - @Select("SELECT ID, CREATED, CLAIMED, COMPLETED, MODIFIED, PLANNED, DUE, NAME, DESCRIPTION, PRIORITY, STATE, CLASSIFICATION_KEY, WORKBASKETID, OWNER, PRIMARY_OBJ_REF_ID, IS_READ, IS_TRANSFERRED, CUSTOM_ATTRIBUTES, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, CUSTOM_5, CUSTOM_6, CUSTOM_7, CUSTOM_8, CUSTOM_9, CUSTOM_10 " + @Select("SELECT ID, CREATED, CLAIMED, COMPLETED, MODIFIED, PLANNED, DUE, NAME, DESCRIPTION, PRIORITY, STATE, CLASSIFICATION_KEY, WORKBASKET_KEY, OWNER, PRIMARY_OBJ_REF_ID, IS_READ, IS_TRANSFERRED, CUSTOM_ATTRIBUTES, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, CUSTOM_5, CUSTOM_6, CUSTOM_7, CUSTOM_8, CUSTOM_9, CUSTOM_10 " + "FROM TASK " - + "WHERE WORKBASKETID = #{workbasketId} " + + "WHERE WORKBASKET_KEY = #{workbasketKey} " + "AND STATE = #{taskState}") @Results(value = { @Result(property = "id", column = "ID"), @@ -101,7 +101,7 @@ public interface TaskMapper { @Result(property = "state", column = "STATE"), @Result(property = "classification", column = "CLASSIFICATION_KEY", javaType = Classification.class, one = @One(select = CLASSIFICATION_FINDBYKEYROOTDOMAIN)), - @Result(property = "workbasketId", column = "WORKBASKETID"), + @Result(property = "workbasketKey", column = "WORKBASKET_KEY"), @Result(property = "owner", column = "OWNER"), @Result(property = "primaryObjRef", column = "PRIMARY_OBJ_REF_ID", javaType = ObjectReference.class, one = @One(select = OBJECTREFERENCEMAPPER_FINDBYID)), @@ -120,22 +120,22 @@ public interface TaskMapper { @Result(property = "custom9", column = "CUSTOM_9"), @Result(property = "custom10", column = "CUSTOM_10") }) - List findTasksByWorkbasketIdAndState(@Param("workbasketId") String workbasketId, + List findTasksByWorkbasketIdAndState(@Param("workbasketKey") String workbasketKey, @Param("taskState") TaskState taskState); - @Select("SELECT TASK.ID AS taskId, TASK.NAME AS taskName, TASK.WORKBASKETID AS workId, TASK.CLASSIFICATION_KEY AS classificationKey, " + @Select("SELECT TASK.ID AS taskId, TASK.NAME AS taskName, TASK.WORKBASKET_KEY AS workId, TASK.CLASSIFICATION_KEY AS classificationKey, " + "WORKBASKET.NAME AS workName, CLASSIFICATION.NAME AS classificationName " + "FROM TASK " - + "LEFT JOIN WORKBASKET ON WORKBASKET.ID = TASK.WORKBASKETID " + + "LEFT JOIN WORKBASKET ON WORKBASKET.KEY = TASK.WORKBASKET_KEY " + "LEFT JOIN CLASSIFICATION ON CLASSIFICATION.KEY = TASK.CLASSIFICATION_KEY " - + "WHERE TASK.WORKBASKETID = #{workbasketId}") + + "WHERE TASK.WORKBASKET_KEY = #{workbasketKey}") @Results({ @Result(property = "taskId", column = "taskId"), @Result(property = "taskName", column = "taskName"), - @Result(property = "workbasketId", column = "workId"), + @Result(property = "workbasketKey", column = "workKey"), @Result(property = "workbasketName", column = "workName"), @Result(property = "classificationKey", column = "classificationKey"), @Result(property = "classificationName", column = "classificationName") }) - List findTaskSummariesByWorkbasketId(@Param("workbasketId") String workbasketId); + List findTaskSummariesByWorkbasketKey(@Param("workbasketKey") String workbasketKey); } diff --git a/lib/taskana-core/src/main/java/pro/taskana/model/mappings/WorkbasketAccessMapper.java b/lib/taskana-core/src/main/java/pro/taskana/model/mappings/WorkbasketAccessMapper.java index ce6d97429..d98def48b 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/model/mappings/WorkbasketAccessMapper.java +++ b/lib/taskana-core/src/main/java/pro/taskana/model/mappings/WorkbasketAccessMapper.java @@ -9,132 +9,134 @@ import java.util.List; */ public interface WorkbasketAccessMapper { - @Select("SELECT ID, WORKBASKET_ID, ACCESS_ID, 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 FROM WORKBASKET_ACCESS_LIST WHERE ID = #{id}") + @Select("SELECT ID, WORKBASKET_KEY, ACCESS_ID, 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 FROM WORKBASKET_ACCESS_LIST WHERE ID = #{id}") @Results(value = { - @Result(property = "id", column = "ID"), - @Result(property = "workbasketId", column = "WORKBASKET_ID"), - @Result(property = "accessId", column = "ACCESS_ID"), - @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 = "id", column = "ID"), + @Result(property = "workbasketKey", column = "WORKBASKET_KEY"), + @Result(property = "accessId", column = "ACCESS_ID"), + @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")}) WorkbasketAccessItem findById(@Param("id") String id); - @Select("SELECT ID, WORKBASKET_ID, ACCESS_ID, 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 FROM WORKBASKET_ACCESS_LIST WHERE ACCESS_ID = #{accessId}") + @Select("SELECT ID, WORKBASKET_KEY, ACCESS_ID, 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 FROM WORKBASKET_ACCESS_LIST WHERE ACCESS_ID = #{accessId}") @Results(value = { - @Result(property = "id", column = "ID"), - @Result(property = "workbasketId", column = "WORKBASKET_ID"), - @Result(property = "accessId", column = "ACCESS_ID"), - @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 = "id", column = "ID"), + @Result(property = "workbasketKey", column = "WORKBASKET_KEY"), + @Result(property = "accessId", column = "ACCESS_ID"), + @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")}) List findByAccessId(@Param("accessId") String accessId); - @Select("SELECT ID, WORKBASKET_ID, ACCESS_ID, 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 FROM WORKBASKET_ACCESS_LIST WHERE WORKBASKET_ID = #{id}") + @Select("SELECT ID, WORKBASKET_KEY, ACCESS_ID, 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 FROM WORKBASKET_ACCESS_LIST WHERE WORKBASKET_KEY = #{key}") @Results(value = { - @Result(property = "id", column = "ID"), - @Result(property = "workbasketId", column = "WORKBASKET_ID"), - @Result(property = "accessId", column = "ACCESS_ID"), - @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")}) - List findByWorkbasketId(@Param("id") String id); + @Result(property = "id", column = "ID"), + @Result(property = "workbasketKey", column = "WORKBASKET_KEY"), + @Result(property = "accessId", column = "ACCESS_ID"), + @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")}) + List findByWorkbasketKey(@Param("key") String key); - @Select("SELECT ID, WORKBASKET_ID, ACCESS_ID, 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 FROM WORKBASKET_ACCESS_LIST ORDER BY ID") + @Select("SELECT ID, WORKBASKET_KEY, ACCESS_ID, 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 FROM WORKBASKET_ACCESS_LIST ORDER BY ID") @Results(value = { - @Result(property = "id", column = "ID"), - @Result(property = "workbasketId", column = "WORKBASKET_ID"), - @Result(property = "accessId", column = "ACCESS_ID"), - @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 = "id", column = "ID"), + @Result(property = "workbasketKey", column = "WORKBASKET_KEY"), + @Result(property = "accessId", column = "ACCESS_ID"), + @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")}) List findAll(); - @Insert("INSERT INTO WORKBASKET_ACCESS_LIST (ID, WORKBASKET_ID, ACCESS_ID, 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) " - + "VALUES (#{workbasketAccessItem.id}, #{workbasketAccessItem.workbasketId}, #{workbasketAccessItem.accessId}, #{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})") + @Insert("INSERT INTO WORKBASKET_ACCESS_LIST (ID, WORKBASKET_KEY, ACCESS_ID, 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) " + + "VALUES (#{workbasketAccessItem.id}, #{workbasketAccessItem.workbasketKey}, #{workbasketAccessItem.accessId}, #{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})") @Options(keyProperty = "id", keyColumn = "ID") void insert(@Param("workbasketAccessItem") WorkbasketAccessItem workbasketAccessItem); - @Update("UPDATE WORKBASKET_ACCESS_LIST SET WORKBASKET_ID = #{workbasketAccessItem.workbasketId}, ACCESS_ID = #{workbasketAccessItem.accessId}, PERM_READ = #{workbasketAccessItem.permRead}, PERM_OPEN = #{workbasketAccessItem.permOpen}, PERM_APPEND = #{workbasketAccessItem.permAppend}, PERM_TRANSFER = #{workbasketAccessItem.permTransfer}, PERM_DISTRIBUTE = #{workbasketAccessItem.permDistribute}, PERM_CUSTOM_1 = #{workbasketAccessItem.permCustom1}, PERM_CUSTOM_2 = #{workbasketAccessItem.permCustom2}, PERM_CUSTOM_3 = #{workbasketAccessItem.permCustom3}, PERM_CUSTOM_4 = #{workbasketAccessItem.permCustom4}, PERM_CUSTOM_5 = #{workbasketAccessItem.permCustom5}, PERM_CUSTOM_6 = #{workbasketAccessItem.permCustom6}, PERM_CUSTOM_7 = #{workbasketAccessItem.permCustom7}, PERM_CUSTOM_8 = #{workbasketAccessItem.permCustom8} " - + "WHERE id = #{workbasketAccessItem.id}") + @Update("UPDATE WORKBASKET_ACCESS_LIST SET WORKBASKET_KEY = #{workbasketAccessItem.workbasketKey}, ACCESS_ID = #{workbasketAccessItem.accessId}, PERM_READ = #{workbasketAccessItem.permRead}, PERM_OPEN = #{workbasketAccessItem.permOpen}, PERM_APPEND = #{workbasketAccessItem.permAppend}, PERM_TRANSFER = #{workbasketAccessItem.permTransfer}, PERM_DISTRIBUTE = #{workbasketAccessItem.permDistribute}, PERM_CUSTOM_1 = #{workbasketAccessItem.permCustom1}, PERM_CUSTOM_2 = #{workbasketAccessItem.permCustom2}, PERM_CUSTOM_3 = #{workbasketAccessItem.permCustom3}, PERM_CUSTOM_4 = #{workbasketAccessItem.permCustom4}, PERM_CUSTOM_5 = #{workbasketAccessItem.permCustom5}, PERM_CUSTOM_6 = #{workbasketAccessItem.permCustom6}, PERM_CUSTOM_7 = #{workbasketAccessItem.permCustom7}, PERM_CUSTOM_8 = #{workbasketAccessItem.permCustom8} " + + "WHERE id = #{workbasketAccessItem.id}") void update(@Param("workbasketAccessItem") WorkbasketAccessItem workbasketAccessItem); @Delete("DELETE FROM WORKBASKET_ACCESS_LIST where id = #{id}") void delete(@Param("id") String id); - @Select("") + @Select("") @Results(value = { - @Result(property = "id", column = "ID"), - @Result(property = "workbasketId", column = "WORKBASKET_ID"), - @Result(property = "accessId", column = "ACCESS_ID"), - @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")}) - List findByWorkbasketAndAccessIdAndAuthorizations(@Param("workbasketId") String workbasketId, @Param("accessIds") List accessIds, @Param("authorization") String authorization); + @Result(property = "id", column = "ID"), + @Result(property = "workbasketKey", column = "WORKBASKET_KEY"), + @Result(property = "accessId", column = "ACCESS_ID"), + @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")}) + List findByWorkbasketAndAccessIdAndAuthorizations( + @Param("workbasketKey") String workbasketKey, @Param("accessIds") List accessIds, + @Param("authorization") String authorization); } diff --git a/lib/taskana-core/src/main/java/pro/taskana/model/mappings/WorkbasketMapper.java b/lib/taskana-core/src/main/java/pro/taskana/model/mappings/WorkbasketMapper.java index aaace2563..9e1ee2ead 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/model/mappings/WorkbasketMapper.java +++ b/lib/taskana-core/src/main/java/pro/taskana/model/mappings/WorkbasketMapper.java @@ -1,81 +1,172 @@ package pro.taskana.model.mappings; -import org.apache.ibatis.annotations.*; +import java.util.List; + +import org.apache.ibatis.annotations.Delete; +import org.apache.ibatis.annotations.Insert; +import org.apache.ibatis.annotations.Many; +import org.apache.ibatis.annotations.Options; +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 org.apache.ibatis.annotations.Update; import org.apache.ibatis.mapping.FetchType; import pro.taskana.impl.WorkbasketImpl; import pro.taskana.model.WorkbasketAuthorization; -import java.util.List; /** * This class is the mybatis mapping of workbaskets. */ public interface WorkbasketMapper { - @Select("SELECT ID, CREATED, MODIFIED, NAME, DESCRIPTION, OWNER FROM WORKBASKET WHERE ID = #{id}") - @Results(value = { @Result(property = "id", column = "ID"), - @Result(property = "created", column = "CREATED"), - @Result(property = "modified", column = "MODIFIED"), - @Result(property = "name", column = "NAME"), - @Result(property = "description", column = "DESCRIPTION"), - @Result(property = "owner", column = "OWNER"), - @Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")) }) + @Select("SELECT ID, KEY, CREATED, MODIFIED, NAME, DOMAIN, TYPE, DESCRIPTION, OWNER, CUSTOM_1 ,CUSTOM_2 ,CUSTOM_3 ,CUSTOM_4 ,ORG_LEVEL_1 ,ORG_LEVEL_2 ,ORG_LEVEL_3 ,ORG_LEVEL_4 FROM WORKBASKET WHERE ID = #{id}") + @Results(value = {@Result(property = "id", column = "ID"), + @Result(property = "key", column = "KEY"), + @Result(property = "created", column = "CREATED"), + @Result(property = "modified", column = "MODIFIED"), + @Result(property = "name", column = "NAME"), + @Result(property = "domain", column = "DOMAIN"), + @Result(property = "type", column = "TYPE"), + @Result(property = "description", column = "DESCRIPTION"), + @Result(property = "owner", column = "OWNER"), + @Result(property = "distributionTargets", column = "ID", javaType = List.class, + many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")), + @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 = "custom5", column = "CUSTOM_5"), + @Result(property = "custom6", column = "CUSTOM_6"), + @Result(property = "custom7", column = "CUSTOM_7"), + @Result(property = "custom8", column = "CUSTOM_8"), + @Result(property = "custom9", column = "CUSTOM_9"), + @Result(property = "custom10", column = "CUSTOM_10")}) WorkbasketImpl findById(@Param("id") String id); + @Select("SELECT ID, KEY, CREATED, MODIFIED, NAME, DOMAIN, TYPE, DESCRIPTION, OWNER, CUSTOM_1 ,CUSTOM_2 ,CUSTOM_3 ,CUSTOM_4 ,ORG_LEVEL_1 ,ORG_LEVEL_2 ,ORG_LEVEL_3 ,ORG_LEVEL_4 FROM WORKBASKET WHERE KEY = #{key}") + @Results(value = {@Result(property = "id", column = "ID"), + @Result(property = "key", column = "KEY"), + @Result(property = "created", column = "CREATED"), + @Result(property = "modified", column = "MODIFIED"), + @Result(property = "name", column = "NAME"), + @Result(property = "domain", column = "DOMAIN"), + @Result(property = "type", column = "TYPE"), + @Result(property = "description", column = "DESCRIPTION"), + @Result(property = "owner", column = "OWNER"), + @Result(property = "distributionTargets", column = "ID", javaType = List.class, + many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")), + @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 = "custom5", column = "CUSTOM_5"), + @Result(property = "custom6", column = "CUSTOM_6"), + @Result(property = "custom7", column = "CUSTOM_7"), + @Result(property = "custom8", column = "CUSTOM_8"), + @Result(property = "custom9", column = "CUSTOM_9"), + @Result(property = "custom10", column = "CUSTOM_10")}) + WorkbasketImpl findByKey(@Param("key") String key); + @Select("SELECT * FROM WORKBASKET WHERE id IN (SELECT TARGET_ID FROM DISTRIBUTION_TARGETS WHERE SOURCE_ID = #{id})") @Results(value = { - @Result(property = "id", column = "ID"), - @Result(property = "created", column = "CREATED"), - @Result(property = "modified", column = "MODIFIED"), - @Result(property = "name", column = "NAME"), - @Result(property = "description", column = "DESCRIPTION"), - @Result(property = "owner", column = "OWNER"), - @Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")) }) + @Result(property = "id", column = "ID"), + @Result(property = "key", column = "KEY"), + @Result(property = "created", column = "CREATED"), + @Result(property = "modified", column = "MODIFIED"), + @Result(property = "name", column = "NAME"), + @Result(property = "domain", column = "DOMAIN"), + @Result(property = "type", column = "TYPE"), + @Result(property = "description", column = "DESCRIPTION"), + @Result(property = "owner", column = "OWNER"), + @Result(property = "distributionTargets", column = "ID", javaType = List.class, + many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")), + @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 = "custom5", column = "CUSTOM_5"), + @Result(property = "custom6", column = "CUSTOM_6"), + @Result(property = "custom7", column = "CUSTOM_7"), + @Result(property = "custom8", column = "CUSTOM_8"), + @Result(property = "custom9", column = "CUSTOM_9"), + @Result(property = "custom10", column = "CUSTOM_10")}) List findByDistributionTargets(@Param("id") String id); @Select("SELECT * FROM WORKBASKET ORDER BY id") @Results(value = { - @Result(property = "id", column = "ID"), - @Result(property = "created", column = "CREATED"), - @Result(property = "modified", column = "MODIFIED"), - @Result(property = "name", column = "NAME"), - @Result(property = "description", column = "DESCRIPTION"), - @Result(property = "owner", column = "OWNER"), - @Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")) }) + @Result(property = "id", column = "ID"), + @Result(property = "key", column = "KEY"), + @Result(property = "created", column = "CREATED"), + @Result(property = "modified", column = "MODIFIED"), + @Result(property = "name", column = "NAME"), + @Result(property = "domain", column = "DOMAIN"), + @Result(property = "type", column = "TYPE"), + @Result(property = "description", column = "DESCRIPTION"), + @Result(property = "owner", column = "OWNER"), + @Result(property = "distributionTargets", column = "ID", javaType = List.class, + many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")), + @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 = "custom5", column = "CUSTOM_5"), + @Result(property = "custom6", column = "CUSTOM_6"), + @Result(property = "custom7", column = "CUSTOM_7"), + @Result(property = "custom8", column = "CUSTOM_8"), + @Result(property = "custom9", column = "CUSTOM_9"), + @Result(property = "custom10", column = "CUSTOM_10")}) List findAll(); - @Select("") + @Select("") @Results(value = { - @Result(property = "id", column = "ID"), - @Result(property = "created", column = "CREATED"), - @Result(property = "modified", column = "MODIFIED"), - @Result(property = "name", column = "NAME"), - @Result(property = "description", column = "DESCRIPTION"), - @Result(property = "owner", column = "OWNER"), - @Result(property = "distributionTargets", column = "ID", javaType = List.class, many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")) }) - List findByPermission(@Param("authorizations") List authorizations, @Param("accessId") String accessId); + @Result(property = "id", column = "ID"), + @Result(property = "key", column = "KEY"), + @Result(property = "created", column = "CREATED"), + @Result(property = "modified", column = "MODIFIED"), + @Result(property = "name", column = "NAME"), + @Result(property = "domain", column = "DOMAIN"), + @Result(property = "type", column = "TYPE"), + @Result(property = "description", column = "DESCRIPTION"), + @Result(property = "owner", column = "OWNER"), + @Result(property = "distributionTargets", column = "ID", javaType = List.class, + many = @Many(fetchType = FetchType.DEFAULT, select = "findByDistributionTargets")), + @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 = "custom5", column = "CUSTOM_5"), + @Result(property = "custom6", column = "CUSTOM_6"), + @Result(property = "custom7", column = "CUSTOM_7"), + @Result(property = "custom8", column = "CUSTOM_8"), + @Result(property = "custom9", column = "CUSTOM_9"), + @Result(property = "custom10", column = "CUSTOM_10")}) + List findByPermission(@Param("authorizations") List authorizations, + @Param("accessId") String accessId); - @Insert("INSERT INTO WORKBASKET (ID, CREATED, MODIFIED, NAME, DESCRIPTION, OWNER) VALUES (#{workbasket.id}, #{workbasket.created}, #{workbasket.modified}, #{workbasket.name}, #{workbasket.description}, #{workbasket.owner})") + @Insert("INSERT INTO WORKBASKET (ID, KEY, CREATED, MODIFIED, NAME, DOMAIN, TYPE, DESCRIPTION, OWNER, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, ORG_LEVEL_1, ORG_LEVEL_2, ORG_LEVEL_3, ORG_LEVEL_4) VALUES (#{workbasket.id}, #{workbasket.key}, #{workbasket.created}, #{workbasket.modified}, #{workbasket.name}, #{workbasket.domain}, #{workbasket.type}, #{workbasket.description}, #{workbasket.owner}, #{workbasket.custom1}, #{workbasket.custom2}, #{workbasket.custom3}, #{workbasket.custom4}, #{workbasket.orgLevel1}, #{workbasket.orgLevel2}, #{workbasket.orgLevel3}, #{workbasket.orgLevel4})") @Options(keyProperty = "id", keyColumn = "ID") void insert(@Param("workbasket") WorkbasketImpl workbasket); - @Update("UPDATE WORKBASKET SET MODIFIED = #{workbasket.modified}, NAME = #{workbasket.name}, DESCRIPTION = #{workbasket.description}, OWNER = #{workbasket.owner} WHERE id = #{workbasket.id}") + @Update("UPDATE WORKBASKET SET MODIFIED = #{workbasket.modified}, KEY = #{workbasket.key}, NAME = #{workbasket.name}, DOMAIN = #{workbasket.domain}, TYPE = #{workbasket.type}, DESCRIPTION = #{workbasket.description}, OWNER = #{workbasket.owner}, CUSTOM_1 = #{workbasket.custom1}, CUSTOM_2 = #{workbasket.custom2}, CUSTOM_3 = #{workbasket.custom3}, CUSTOM_4 = #{workbasket.custom4}, ORG_LEVEL_1 = #{workbasket.orgLevel1}, ORG_LEVEL_2 = #{workbasket.orgLevel2}, ORG_LEVEL_3 = #{workbasket.orgLevel3}, ORG_LEVEL_4 = #{workbasket.orgLevel4} WHERE id = #{workbasket.id}") void update(@Param("workbasket") WorkbasketImpl workbasket); @Delete("DELETE FROM WORKBASKET where id = #{id}") diff --git a/lib/taskana-core/src/main/resources/sql/taskana-schema.sql b/lib/taskana-core/src/main/resources/sql/taskana-schema.sql index ec62cc7a1..7eef67f19 100644 --- a/lib/taskana-core/src/main/resources/sql/taskana-schema.sql +++ b/lib/taskana-core/src/main/resources/sql/taskana-schema.sql @@ -18,7 +18,7 @@ CREATE TABLE TASK ( PRIORITY INT NULL, STATE VARCHAR(20) NULL, CLASSIFICATION_KEY VARCHAR(32) NULL, - WORKBASKETID CHAR(40) NULL, + WORKBASKET_KEY VARCHAR(32) NULL, BUSINESS_PROCESS_ID VARCHAR(128) NULL, PARENT_BUSINESS_PROCESS_ID VARCHAR(128) NULL, OWNER VARCHAR(255) NULL, @@ -41,11 +41,22 @@ CREATE TABLE TASK ( CREATE TABLE WORKBASKET( ID CHAR(40) NOT NULL, + KEY VARCHAR(32) NOT NULL, CREATED TIMESTAMP NULL, MODIFIED TIMESTAMP NULL, NAME VARCHAR(255) NOT NULL, + DOMAIN VARCHAR(32) NOT NULL, + TYPE VARCHAR(16) NOT NULL, DESCRIPTION VARCHAR(255) NULL, OWNER VARCHAR(255) NULL, + CUSTOM_1 VARCHAR(255) NULL, + CUSTOM_2 VARCHAR(255) NULL, + CUSTOM_3 VARCHAR(255) NULL, + CUSTOM_4 VARCHAR(255) NULL, + ORG_LEVEL_1 VARCHAR(255) NULL, + ORG_LEVEL_2 VARCHAR(255) NULL, + ORG_LEVEL_3 VARCHAR(255) NULL, + ORG_LEVEL_4 VARCHAR(255) NULL, PRIMARY KEY (ID), CONSTRAINT UC_NAME UNIQUE (NAME) ); @@ -84,7 +95,7 @@ CREATE TABLE CLASSIFICATION( CREATE TABLE WORKBASKET_ACCESS_LIST( ID CHAR(40) NOT NULL, - WORKBASKET_ID CHAR(40) NOT NULL, + WORKBASKET_KEY VARCHAR(32) NOT NULL, ACCESS_ID VARCHAR(255) NULL, PERM_READ BOOLEAN NOT NULL, PERM_OPEN BOOLEAN NOT NULL, diff --git a/lib/taskana-core/src/test/java/pro/taskana/impl/TaskServiceImplTest.java b/lib/taskana-core/src/test/java/pro/taskana/impl/TaskServiceImplTest.java index b4405eedd..63ea2dc5a 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/impl/TaskServiceImplTest.java +++ b/lib/taskana-core/src/test/java/pro/taskana/impl/TaskServiceImplTest.java @@ -34,12 +34,14 @@ import org.powermock.modules.junit4.PowerMockRunner; import pro.taskana.Classification; import pro.taskana.ClassificationService; import pro.taskana.Task; +import pro.taskana.Workbasket; import pro.taskana.WorkbasketService; import pro.taskana.configuration.TaskanaEngineConfiguration; import pro.taskana.exceptions.ClassificationAlreadyExistException; import pro.taskana.exceptions.ClassificationNotFoundException; import pro.taskana.exceptions.InvalidOwnerException; import pro.taskana.exceptions.InvalidStateException; +import pro.taskana.exceptions.InvalidWorkbasketException; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.TaskAlreadyExistException; import pro.taskana.exceptions.TaskNotFoundException; @@ -107,21 +109,22 @@ public class TaskServiceImplTest { @Test public void testCreateSimpleTask() throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, ClassificationAlreadyExistException, TaskAlreadyExistException, - TaskNotFoundException { + TaskNotFoundException, InvalidWorkbasketException { TaskServiceImpl cutSpy = Mockito.spy(cut); - TaskImpl expectedTask = createUnitTestTask("", "DUMMYTASK", "1"); + TaskImpl expectedTask = createUnitTestTask("", "DUMMYTASK", "k1"); WorkbasketImpl wb = new WorkbasketImpl(); wb.setId("1"); + wb.setKey("k1"); wb.setName("workbasket"); doThrow(TaskNotFoundException.class).when(cutSpy).getTaskById(expectedTask.getId()); - doReturn(wb).when(workbasketServiceMock).getWorkbasket(wb.getId()); + doReturn(wb).when(workbasketServiceMock).getWorkbasketByKey(wb.getKey()); doNothing().when(taskMapperMock).insert(expectedTask); Task actualTask = cutSpy.createTask(expectedTask); verify(taskanaEngineImpl, times(1)).openConnection(); verify(workbasketServiceMock, times(1)).checkAuthorization(any(), any()); - verify(workbasketServiceMock, times(1)).getWorkbasket(any()); + verify(workbasketServiceMock, times(1)).getWorkbasketByKey(any()); verify(taskanaEngineMock, times(1)).getClassificationService(); verify(classificationServiceMock, times(1)).getClassification(any(), any()); verify(taskMapperMock, times(1)).insert(expectedTask); @@ -134,7 +137,7 @@ public class TaskServiceImplTest { assertNotNull(actualTask.getCreated()); assertNotNull(actualTask.getModified()); assertNull(actualTask.getCompleted()); - assertThat(actualTask.getWorkbasketId(), equalTo(expectedTask.getWorkbasketId())); + assertThat(actualTask.getWorkbasketKey(), equalTo(expectedTask.getWorkbasketKey())); assertThat(actualTask.getName(), equalTo(expectedTask.getName())); assertThat(actualTask.getState(), equalTo(TaskState.READY)); } @@ -142,7 +145,7 @@ public class TaskServiceImplTest { @Test public void testCreateSimpleTaskWithObjectReference() throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, ClassificationAlreadyExistException, TaskAlreadyExistException, - TaskNotFoundException { + TaskNotFoundException, InvalidWorkbasketException { TaskServiceImpl cutSpy = Mockito.spy(cut); ObjectReference expectedObjectReference = new ObjectReference(); expectedObjectReference.setId("1"); @@ -150,11 +153,14 @@ public class TaskServiceImplTest { WorkbasketImpl wb = new WorkbasketImpl(); wb.setId("1"); wb.setName("workbasket"); - TaskImpl expectedTask = createUnitTestTask(null, "DUMMYTASK", wb.getId()); + wb.setKey("k33"); + wb.setDomain("dummy-domain"); + + TaskImpl expectedTask = createUnitTestTask("", "DUMMYTASK", wb.getKey()); expectedTask.setPrimaryObjRef(expectedObjectReference); Classification classification = expectedTask.getClassification(); doThrow(TaskNotFoundException.class).when(cutSpy).getTaskById(expectedTask.getId()); - doReturn(wb).when(workbasketServiceMock).getWorkbasket(wb.getId()); + doReturn(wb).when(workbasketServiceMock).getWorkbasketByKey(expectedTask.getWorkbasketKey()); doReturn(expectedObjectReference).when(objectReferenceMapperMock) .findByObjectReference(expectedObjectReference); doNothing().when(taskMapperMock).insert(expectedTask); @@ -162,11 +168,11 @@ public class TaskServiceImplTest { Task actualTask = cutSpy.createTask(expectedTask); verify(taskanaEngineImpl, times(1)).openConnection(); - verify(workbasketServiceMock, times(1)).getWorkbasket(wb.getId()); - verify(workbasketServiceMock, times(1)).checkAuthorization(wb.getId(), WorkbasketAuthorization.APPEND); + verify(workbasketServiceMock, times(1)).getWorkbasketByKey(wb.getKey()); + verify(workbasketServiceMock, times(1)).checkAuthorization(wb.getKey(), WorkbasketAuthorization.APPEND); verify(taskanaEngineMock, times(1)).getClassificationService(); verify(classificationServiceMock, times(1)).getClassification(classification.getKey(), - classification.getDomain()); + wb.getDomain()); verify(objectReferenceMapperMock, times(1)).findByObjectReference(expectedObjectReference); verify(taskMapperMock, times(1)).insert(expectedTask); verify(taskanaEngineImpl, times(1)).returnConnection(); @@ -177,7 +183,7 @@ public class TaskServiceImplTest { assertNotNull(actualTask.getCreated()); assertNotNull(actualTask.getModified()); assertNull(actualTask.getCompleted()); - assertThat(actualTask.getWorkbasketId(), equalTo(expectedTask.getWorkbasketId())); + assertThat(actualTask.getWorkbasketKey(), equalTo(expectedTask.getWorkbasketKey())); assertThat(actualTask.getName(), equalTo(expectedTask.getName())); assertThat(actualTask.getState(), equalTo(TaskState.READY)); assertThat(actualTask.getPrimaryObjRef(), equalTo(expectedObjectReference)); @@ -186,16 +192,18 @@ public class TaskServiceImplTest { @Test public void testCreateSimpleTaskWithObjectReferenceIsNull() throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, ClassificationAlreadyExistException, - TaskAlreadyExistException, TaskNotFoundException { + TaskAlreadyExistException, TaskNotFoundException, InvalidWorkbasketException { TaskServiceImpl cutSpy = Mockito.spy(cut); ObjectReference expectedObjectReference = new ObjectReference(); expectedObjectReference.setId("1"); expectedObjectReference.setType("DUMMY"); WorkbasketImpl wb = new WorkbasketImpl(); wb.setId("1"); + wb.setKey("key1"); wb.setName("workbasket"); - doReturn(wb).when(workbasketServiceMock).getWorkbasket(wb.getId()); - TaskImpl expectedTask = createUnitTestTask("", "DUMMYTASK", "1"); + + doReturn(wb).when(workbasketServiceMock).getWorkbasketByKey(wb.getKey()); + TaskImpl expectedTask = createUnitTestTask("", "DUMMYTASK", "key1"); expectedTask.setPrimaryObjRef(expectedObjectReference); Classification classification = expectedTask.getClassification(); doThrow(TaskNotFoundException.class).when(cutSpy).getTaskById(expectedTask.getId()); @@ -209,12 +217,12 @@ public class TaskServiceImplTest { expectedTask.getPrimaryObjRef().setId(actualTask.getPrimaryObjRef().getId()); // get only new ID verify(taskanaEngineImpl, times(1)).openConnection(); - verify(workbasketServiceMock, times(1)).getWorkbasket(expectedTask.getWorkbasketId()); - verify(workbasketServiceMock, times(1)).checkAuthorization(expectedTask.getWorkbasketId(), + verify(workbasketServiceMock, times(1)).getWorkbasketByKey(expectedTask.getWorkbasketKey()); + verify(workbasketServiceMock, times(1)).checkAuthorization(expectedTask.getWorkbasketKey(), WorkbasketAuthorization.APPEND); verify(taskanaEngineMock, times(1)).getClassificationService(); verify(classificationServiceMock, times(1)).getClassification(classification.getKey(), - classification.getDomain()); + wb.getDomain()); verify(objectReferenceMapperMock, times(1)).findByObjectReference(expectedObjectReference); verify(objectReferenceMapperMock, times(1)).insert(expectedObjectReference); verify(taskMapperMock, times(1)).insert(expectedTask); @@ -226,7 +234,7 @@ public class TaskServiceImplTest { assertNotNull(actualTask.getCreated()); assertNotNull(actualTask.getModified()); assertNull(actualTask.getCompleted()); - assertThat(actualTask.getWorkbasketId(), equalTo(expectedTask.getWorkbasketId())); + assertThat(actualTask.getWorkbasketKey(), equalTo(expectedTask.getWorkbasketKey())); assertThat(actualTask.getName(), equalTo(expectedTask.getName())); assertThat(actualTask.getState(), equalTo(TaskState.READY)); assertThat(actualTask.getPrimaryObjRef(), equalTo(expectedObjectReference)); @@ -235,8 +243,9 @@ public class TaskServiceImplTest { @Test public void testCreateTaskWithPlanned() throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, - TaskAlreadyExistException, TaskNotFoundException { + TaskAlreadyExistException, TaskNotFoundException, InvalidWorkbasketException { TaskServiceImpl cutSpy = Mockito.spy(cut); + ObjectReference expectedObjectReference = new ObjectReference(); expectedObjectReference.setId("1"); expectedObjectReference.setType("DUMMY"); @@ -245,14 +254,15 @@ public class TaskServiceImplTest { classification.setCategory("MANUAL"); WorkbasketImpl wb = new WorkbasketImpl(); wb.setId("workbasketId"); + wb.setKey("workbasketKey"); wb.setName("workbasket"); TaskImpl task = new TaskImpl(); - task.setWorkbasketId(wb.getId()); + task.setWorkbasketKey(wb.getKey()); task.setClassification(classification); task.setPrimaryObjRef(expectedObjectReference); task.setDescription("simply awesome task"); doThrow(TaskNotFoundException.class).when(cutSpy).getTaskById(task.getId()); - doReturn(wb).when(workbasketServiceMock).getWorkbasket(wb.getId()); + doReturn(wb).when(workbasketServiceMock).getWorkbasketByKey(wb.getKey()); doReturn(classification).when(classificationServiceMock).getClassification(classification.getKey(), classification.getDomain()); doReturn(expectedObjectReference).when(objectReferenceMapperMock) @@ -262,7 +272,7 @@ public class TaskServiceImplTest { cutSpy.createTask(task); TaskImpl task2 = new TaskImpl(); - task2.setWorkbasketId(wb.getId()); + task2.setWorkbasketKey(wb.getKey()); task2.setClassification(classification); task2.setPrimaryObjRef(expectedObjectReference); task2.setPlanned(Timestamp.valueOf(LocalDateTime.now().minusHours(1))); @@ -271,8 +281,8 @@ public class TaskServiceImplTest { cutSpy.createTask(task2); verify(taskanaEngineImpl, times(2)).openConnection(); - verify(workbasketServiceMock, times(2)).getWorkbasket(any()); verify(workbasketServiceMock, times(2)).checkAuthorization(any(), any()); + verify(workbasketServiceMock, times(2)).getWorkbasketByKey(any()); verify(taskanaEngineMock, times(2)).getClassificationService(); verify(classificationServiceMock, times(2)).getClassification(any(), any()); verify(objectReferenceMapperMock, times(2)).findByObjectReference(expectedObjectReference); @@ -288,7 +298,7 @@ public class TaskServiceImplTest { assertNotNull(task.getModified()); assertNull(task.getCompleted()); assertNull(task.getDue()); - assertThat(task.getWorkbasketId(), equalTo(task2.getWorkbasketId())); + assertThat(task.getWorkbasketKey(), equalTo(task2.getWorkbasketKey())); assertThat(task.getName(), equalTo(classification.getName())); assertThat(task.getState(), equalTo(TaskState.READY)); assertThat(task.getPrimaryObjRef(), equalTo(expectedObjectReference)); @@ -299,7 +309,8 @@ public class TaskServiceImplTest { @Test(expected = TaskAlreadyExistException.class) public void testCreateTaskThrowingAlreadyExistException() throws WorkbasketNotFoundException, - ClassificationNotFoundException, NotAuthorizedException, TaskAlreadyExistException, TaskNotFoundException { + ClassificationNotFoundException, NotAuthorizedException, TaskAlreadyExistException, TaskNotFoundException, + InvalidWorkbasketException { TaskServiceImpl cutSpy = Mockito.spy(cut); TaskImpl task = createUnitTestTask("12", "Task Name", "1"); doReturn(task).when(cutSpy).getTaskById(task.getId()); @@ -319,18 +330,18 @@ public class TaskServiceImplTest { @Test(expected = NotAuthorizedException.class) public void testCreateThrowingAuthorizedOnWorkbasket() throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, - TaskAlreadyExistException, TaskNotFoundException { + TaskAlreadyExistException, TaskNotFoundException, InvalidWorkbasketException { TaskServiceImpl cutSpy = Mockito.spy(cut); TaskImpl task = createUnitTestTask("", "dummyTask", "1"); doThrow(TaskNotFoundException.class).when(cutSpy).getTaskById(task.getId()); - doThrow(NotAuthorizedException.class).when(workbasketServiceMock).checkAuthorization(task.getWorkbasketId(), + doThrow(NotAuthorizedException.class).when(workbasketServiceMock).checkAuthorization(task.getWorkbasketKey(), WorkbasketAuthorization.APPEND); try { cutSpy.createTask(task); } catch (NotAuthorizedException e) { verify(taskanaEngineImpl, times(1)).openConnection(); - verify(workbasketServiceMock, times(1)).getWorkbasket(task.getWorkbasketId()); - verify(workbasketServiceMock, times(1)).checkAuthorization(task.getWorkbasketId(), + verify(workbasketServiceMock, times(1)).getWorkbasketByKey(task.getWorkbasketKey()); + verify(workbasketServiceMock, times(1)).checkAuthorization(task.getWorkbasketKey(), WorkbasketAuthorization.APPEND); verify(taskanaEngineImpl, times(1)).returnConnection(); verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, @@ -343,16 +354,16 @@ public class TaskServiceImplTest { @Test(expected = WorkbasketNotFoundException.class) public void testCreateThrowsWorkbasketNotFoundException() throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, - TaskAlreadyExistException, TaskNotFoundException { + InvalidWorkbasketException, TaskAlreadyExistException, TaskNotFoundException { TaskServiceImpl cutSpy = Mockito.spy(cut); TaskImpl task = createUnitTestTask("", "dumma-task", "1"); doThrow(TaskNotFoundException.class).when(cutSpy).getTaskById(task.getId()); - doThrow(WorkbasketNotFoundException.class).when(workbasketServiceMock).getWorkbasket(any()); + doThrow(WorkbasketNotFoundException.class).when(workbasketServiceMock).getWorkbasketByKey(any()); try { cutSpy.createTask(task); } catch (WorkbasketNotFoundException e) { verify(taskanaEngineImpl, times(1)).openConnection(); - verify(workbasketServiceMock, times(1)).getWorkbasket(task.getWorkbasketId()); + verify(workbasketServiceMock, times(1)).getWorkbasketByKey(task.getWorkbasketKey()); verify(taskanaEngineImpl, times(1)).returnConnection(); verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, taskMapperMock, objectReferenceMapperMock, workbasketServiceMock, @@ -593,29 +604,31 @@ public class TaskServiceImplTest { @Test public void testTransferTaskToDestinationWorkbasketWithoutSecurity() throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, - ClassificationAlreadyExistException { + ClassificationAlreadyExistException, InvalidWorkbasketException { TaskServiceImpl cutSpy = Mockito.spy(cut); - TaskImpl task = createUnitTestTask("1", "Unit Test Task 1", "1"); - WorkbasketImpl destinationWorkbasket = createWorkbasket("2"); + Workbasket destinationWorkbasket = createWorkbasket("2", "k1"); + TaskImpl task = createUnitTestTask("1", "Unit Test Task 1", "k1"); task.setRead(true); - doReturn(destinationWorkbasket).when(workbasketServiceMock).getWorkbasket(destinationWorkbasket.getId()); + doReturn(destinationWorkbasket).when(workbasketServiceMock).getWorkbasketByKey(destinationWorkbasket.getKey()); doReturn(taskanaEngineConfigurationMock).when(taskanaEngineMock).getConfiguration(); doReturn(false).when(taskanaEngineConfigurationMock).isSecurityEnabled(); doReturn(task).when(cutSpy).getTaskById(task.getId()); doNothing().when(taskMapperMock).update(any()); - doNothing().when(workbasketServiceMock).checkAuthorization(destinationWorkbasket.getId(), + doNothing().when(workbasketServiceMock).checkAuthorization(destinationWorkbasket.getKey(), WorkbasketAuthorization.APPEND); - doNothing().when(workbasketServiceMock).checkAuthorization(task.getId(), WorkbasketAuthorization.TRANSFER); + doNothing().when(workbasketServiceMock).checkAuthorization(task.getWorkbasketKey(), + WorkbasketAuthorization.TRANSFER); - Task actualTask = cutSpy.transfer(task.getId(), destinationWorkbasket.getId()); + Task actualTask = cutSpy.transfer(task.getId(), destinationWorkbasket.getKey()); verify(taskanaEngineImpl, times(1)).openConnection(); - verify(workbasketServiceMock, times(1)).checkAuthorization(destinationWorkbasket.getId(), + verify(workbasketServiceMock, times(1)).checkAuthorization(destinationWorkbasket.getKey(), WorkbasketAuthorization.APPEND); - verify(workbasketServiceMock, times(1)).checkAuthorization(task.getId(), WorkbasketAuthorization.TRANSFER); + verify(workbasketServiceMock, times(1)).checkAuthorization(task.getWorkbasketKey(), + WorkbasketAuthorization.TRANSFER); verify(taskanaEngineMock, times(1)).getConfiguration(); verify(taskanaEngineConfigurationMock, times(1)).isSecurityEnabled(); - verify(workbasketServiceMock, times(1)).getWorkbasket(destinationWorkbasket.getId()); + verify(workbasketServiceMock, times(1)).getWorkbasketByKey(destinationWorkbasket.getKey()); verify(taskMapperMock, times(1)).update(any()); verify(taskanaEngineImpl, times(1)).returnConnection(); verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, @@ -623,31 +636,33 @@ public class TaskServiceImplTest { assertThat(actualTask.isRead(), equalTo(false)); assertThat(actualTask.isTransferred(), equalTo(true)); - assertThat(actualTask.getWorkbasketId(), equalTo(destinationWorkbasket.getId())); + assertThat(actualTask.getWorkbasketKey(), equalTo(destinationWorkbasket.getKey())); } @Test public void testTransferTaskToDestinationWorkbasketUsingSecurityTrue() throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, - ClassificationAlreadyExistException { + ClassificationAlreadyExistException, InvalidWorkbasketException { TaskServiceImpl cutSpy = Mockito.spy(cut); - TaskImpl task = createUnitTestTask("1", "Unit Test Task 1", "1"); - WorkbasketImpl destinationWorkbasket = createWorkbasket("2"); + Workbasket destinationWorkbasket = createWorkbasket("2", "k2"); + TaskImpl task = createUnitTestTask("1", "Unit Test Task 1", "k1"); task.setRead(true); doReturn(taskanaEngineConfigurationMock).when(taskanaEngineMock).getConfiguration(); doReturn(true).when(taskanaEngineConfigurationMock).isSecurityEnabled(); doReturn(task).when(cutSpy).getTaskById(task.getId()); doNothing().when(taskMapperMock).update(any()); - doNothing().when(workbasketServiceMock).checkAuthorization(destinationWorkbasket.getId(), + doNothing().when(workbasketServiceMock).checkAuthorization(destinationWorkbasket.getKey(), WorkbasketAuthorization.APPEND); - doNothing().when(workbasketServiceMock).checkAuthorization(task.getId(), WorkbasketAuthorization.TRANSFER); + doNothing().when(workbasketServiceMock).checkAuthorization(task.getWorkbasketKey(), + WorkbasketAuthorization.TRANSFER); - Task actualTask = cutSpy.transfer(task.getId(), destinationWorkbasket.getId()); + Task actualTask = cutSpy.transfer(task.getId(), destinationWorkbasket.getKey()); verify(taskanaEngineImpl, times(1)).openConnection(); - verify(workbasketServiceMock, times(1)).checkAuthorization(destinationWorkbasket.getId(), + verify(workbasketServiceMock, times(1)).checkAuthorization(destinationWorkbasket.getKey(), WorkbasketAuthorization.APPEND); - verify(workbasketServiceMock, times(1)).checkAuthorization(task.getId(), WorkbasketAuthorization.TRANSFER); + verify(workbasketServiceMock, times(1)).checkAuthorization("k1", + WorkbasketAuthorization.TRANSFER); verify(taskanaEngineMock, times(1)).getConfiguration(); verify(taskanaEngineConfigurationMock, times(1)).isSecurityEnabled(); verify(taskMapperMock, times(1)).update(any()); @@ -657,26 +672,25 @@ public class TaskServiceImplTest { assertThat(actualTask.isRead(), equalTo(false)); assertThat(actualTask.isTransferred(), equalTo(true)); - assertThat(actualTask.getWorkbasketId(), equalTo(destinationWorkbasket.getId())); + assertThat(actualTask.getWorkbasketKey(), equalTo(destinationWorkbasket.getKey())); } @Test(expected = WorkbasketNotFoundException.class) public void testTransferDestinationWorkbasketDoesNotExist() - throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, - ClassificationAlreadyExistException { + throws Exception { - String destinationWorkbasketId = "2"; - TaskImpl task = createUnitTestTask("1", "Unit Test Task 1", "1"); + String destinationWorkbasketKey = "2"; + Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); TaskServiceImpl cutSpy = Mockito.spy(cut); doThrow(WorkbasketNotFoundException.class).when(workbasketServiceMock) - .checkAuthorization(destinationWorkbasketId, WorkbasketAuthorization.APPEND); + .checkAuthorization(destinationWorkbasketKey, WorkbasketAuthorization.APPEND); doReturn(task).when(cutSpy).getTaskById(task.getId()); try { - cutSpy.transfer(task.getId(), destinationWorkbasketId); + cutSpy.transfer(task.getId(), destinationWorkbasketKey); } catch (Exception e) { verify(taskanaEngineImpl, times(1)).openConnection(); - verify(workbasketServiceMock, times(1)).checkAuthorization(destinationWorkbasketId, + verify(workbasketServiceMock, times(1)).checkAuthorization(destinationWorkbasketKey, WorkbasketAuthorization.APPEND); verify(taskanaEngineImpl, times(1)).returnConnection(); verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, @@ -687,10 +701,9 @@ public class TaskServiceImplTest { @Test(expected = TaskNotFoundException.class) public void testTransferTaskDoesNotExist() - throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, - ClassificationAlreadyExistException { + throws Exception { - TaskImpl task = createUnitTestTask("1", "Unit Test Task 1", "1"); + Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); TaskServiceImpl cutSpy = Mockito.spy(cut); doThrow(TaskNotFoundException.class).when(cutSpy).getTaskById(task.getId()); @@ -707,20 +720,19 @@ public class TaskServiceImplTest { @Test(expected = NotAuthorizedException.class) public void testTransferNotAuthorizationOnWorkbasketAppend() - throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, - ClassificationAlreadyExistException { - String destinationWorkbasketId = "2"; - TaskImpl task = createUnitTestTask("1", "Unit Test Task 1", "1"); + throws Exception { + String destinationWorkbasketKey = "2"; + Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); TaskServiceImpl cutSpy = Mockito.spy(cut); doReturn(task).when(cutSpy).getTaskById(task.getId()); - doThrow(NotAuthorizedException.class).when(workbasketServiceMock).checkAuthorization(destinationWorkbasketId, + doThrow(NotAuthorizedException.class).when(workbasketServiceMock).checkAuthorization(destinationWorkbasketKey, WorkbasketAuthorization.APPEND); try { - cutSpy.transfer(task.getId(), destinationWorkbasketId); + cutSpy.transfer(task.getId(), destinationWorkbasketKey); } catch (Exception e) { verify(taskanaEngineImpl, times(1)).openConnection(); - verify(workbasketServiceMock, times(1)).checkAuthorization(destinationWorkbasketId, + verify(workbasketServiceMock, times(1)).checkAuthorization(destinationWorkbasketKey, WorkbasketAuthorization.APPEND); verify(taskanaEngineImpl, times(1)).returnConnection(); verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, @@ -731,24 +743,24 @@ public class TaskServiceImplTest { @Test(expected = NotAuthorizedException.class) public void testTransferNotAuthorizationOnWorkbasketTransfer() - throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, - ClassificationAlreadyExistException { - String destinationWorkbasketId = "2"; - TaskImpl task = createUnitTestTask("1", "Unit Test Task 1", "1"); + throws Exception { + String destinationWorkbasketKey = "2"; + Task task = createUnitTestTask("1", "Unit Test Task 1", "1"); TaskServiceImpl cutSpy = Mockito.spy(cut); doReturn(task).when(cutSpy).getTaskById(task.getId()); - doNothing().when(workbasketServiceMock).checkAuthorization(destinationWorkbasketId, + doNothing().when(workbasketServiceMock).checkAuthorization(destinationWorkbasketKey, WorkbasketAuthorization.APPEND); - doThrow(NotAuthorizedException.class).when(workbasketServiceMock).checkAuthorization(task.getWorkbasketId(), + doThrow(NotAuthorizedException.class).when(workbasketServiceMock).checkAuthorization(task.getWorkbasketKey(), WorkbasketAuthorization.TRANSFER); try { - cutSpy.transfer(task.getId(), destinationWorkbasketId); + cutSpy.transfer(task.getId(), destinationWorkbasketKey); } catch (Exception e) { verify(taskanaEngineImpl, times(1)).openConnection(); - verify(workbasketServiceMock, times(1)).checkAuthorization(destinationWorkbasketId, + verify(workbasketServiceMock, times(1)).checkAuthorization(destinationWorkbasketKey, WorkbasketAuthorization.APPEND); - verify(workbasketServiceMock, times(1)).checkAuthorization(task.getId(), WorkbasketAuthorization.TRANSFER); + verify(workbasketServiceMock, times(1)).checkAuthorization(task.getWorkbasketKey(), + WorkbasketAuthorization.TRANSFER); verify(taskanaEngineImpl, times(1)).returnConnection(); verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl, taskMapperMock, objectReferenceMapperMock, workbasketServiceMock); @@ -795,7 +807,7 @@ public class TaskServiceImplTest { @Test public void testGetTaskByIdWithExistingTask() throws TaskNotFoundException, ClassificationAlreadyExistException { - TaskImpl expectedTask = createUnitTestTask("1", "DUMMY-TASK", "1"); + Task expectedTask = createUnitTestTask("1", "DUMMY-TASK", "1"); doReturn(expectedTask).when(taskMapperMock).findById(expectedTask.getId()); Task actualTask = cut.getTaskById(expectedTask.getId()); @@ -810,7 +822,7 @@ public class TaskServiceImplTest { @Test(expected = TaskNotFoundException.class) public void testGetTaskByIdWhereTaskDoesNotExist() throws Exception { - TaskImpl task = createUnitTestTask("1", "DUMMY-TASK", "1"); + Task task = createUnitTestTask("1", "DUMMY-TASK", "1"); doThrow(TaskNotFoundException.class).when(taskMapperMock).findById(task.getId()); try { @@ -826,43 +838,45 @@ public class TaskServiceImplTest { } @Test - public void testGetTaskSummariesByWorkbasketIdWithInternalException() throws WorkbasketNotFoundException { + public void testGetTaskSummariesByWorkbasketIdWithInternalException() + throws WorkbasketNotFoundException, InvalidWorkbasketException { // given - set behaviour and expected result - String workbasketId = "1"; + String workbasketKey = "1"; List expectedResultList = new ArrayList<>(); doNothing().when(taskanaEngineImpl).openConnection(); - doThrow(new IllegalArgumentException("Invalid ID: " + workbasketId)).when(taskMapperMock) - .findTaskSummariesByWorkbasketId(workbasketId); + doThrow(new IllegalArgumentException("Invalid ID: " + workbasketKey)).when(taskMapperMock) + .findTaskSummariesByWorkbasketKey(workbasketKey); doNothing().when(taskanaEngineImpl).returnConnection(); doReturn(new WorkbasketImpl()).when(workbasketServiceMock).getWorkbasket(any()); // when - make the call - List actualResultList = cut.getTaskSummariesByWorkbasketId(workbasketId); + List actualResultList = cut.getTaskSummariesByWorkbasketKey(workbasketKey); // then - verify external communications and assert result verify(taskanaEngineImpl, times(1)).openConnection(); - verify(taskMapperMock, times(1)).findTaskSummariesByWorkbasketId(workbasketId); + verify(taskMapperMock, times(1)).findTaskSummariesByWorkbasketKey(workbasketKey); verify(taskanaEngineImpl, times(1)).returnConnection(); - verify(workbasketServiceMock, times(1)).getWorkbasket(any()); + verify(workbasketServiceMock, times(1)).getWorkbasketByKey(any()); verifyNoMoreInteractions(taskMapperMock, taskanaEngineImpl, workbasketServiceMock); assertThat(actualResultList, equalTo(expectedResultList)); } @Test - public void testGetTaskSummariesByWorkbasketIdGettingResults() throws WorkbasketNotFoundException { - String workbasketId = "1"; + public void testGetTaskSummariesByWorkbasketIdGettingResults() + throws WorkbasketNotFoundException, InvalidWorkbasketException { + String workbasketKey = "1"; List expectedResultList = Arrays.asList(new TaskSummary(), new TaskSummary()); doNothing().when(taskanaEngineImpl).openConnection(); doNothing().when(taskanaEngineImpl).returnConnection(); - doReturn(new WorkbasketImpl()).when(workbasketServiceMock).getWorkbasket(any()); - doReturn(expectedResultList).when(taskMapperMock).findTaskSummariesByWorkbasketId(workbasketId); + doReturn(new WorkbasketImpl()).when(workbasketServiceMock).getWorkbasketByKey(any()); + doReturn(expectedResultList).when(taskMapperMock).findTaskSummariesByWorkbasketKey(workbasketKey); - List actualResultList = cut.getTaskSummariesByWorkbasketId(workbasketId); + List actualResultList = cut.getTaskSummariesByWorkbasketKey(workbasketKey); - verify(workbasketServiceMock, times(1)).getWorkbasket(any()); + verify(workbasketServiceMock, times(1)).getWorkbasketByKey(any()); verify(taskanaEngineImpl, times(1)).openConnection(); - verify(taskMapperMock, times(1)).findTaskSummariesByWorkbasketId(workbasketId); + verify(taskMapperMock, times(1)).findTaskSummariesByWorkbasketKey(workbasketKey); verify(taskanaEngineImpl, times(1)).returnConnection(); verifyNoMoreInteractions(taskMapperMock, taskanaEngineImpl, workbasketServiceMock); assertThat(actualResultList, equalTo(expectedResultList)); @@ -870,31 +884,32 @@ public class TaskServiceImplTest { } @Test - public void testGetTaskSummariesByWorkbasketIdGettingNull() throws WorkbasketNotFoundException { - String workbasketId = "1"; + public void testGetTaskSummariesByWorkbasketIdGettingNull() + throws WorkbasketNotFoundException, InvalidWorkbasketException { + String workbasketKey = "1"; List expectedResultList = new ArrayList<>(); doNothing().when(taskanaEngineImpl).openConnection(); doNothing().when(taskanaEngineImpl).returnConnection(); - doReturn(null).when(taskMapperMock).findTaskSummariesByWorkbasketId(workbasketId); - doReturn(new WorkbasketImpl()).when(workbasketServiceMock).getWorkbasket(any()); + doReturn(null).when(taskMapperMock).findTaskSummariesByWorkbasketKey(workbasketKey); + doReturn(new WorkbasketImpl()).when(workbasketServiceMock).getWorkbasketByKey(any()); - List actualResultList = cut.getTaskSummariesByWorkbasketId(workbasketId); + List actualResultList = cut.getTaskSummariesByWorkbasketKey(workbasketKey); verify(taskanaEngineImpl, times(1)).openConnection(); - verify(taskMapperMock, times(1)).findTaskSummariesByWorkbasketId(workbasketId); + verify(taskMapperMock, times(1)).findTaskSummariesByWorkbasketKey(workbasketKey); verify(taskanaEngineImpl, times(1)).returnConnection(); - verify(workbasketServiceMock, times(1)).getWorkbasket(any()); + verify(workbasketServiceMock, times(1)).getWorkbasketByKey(any()); verifyNoMoreInteractions(taskMapperMock, taskanaEngineImpl, workbasketServiceMock); assertThat(actualResultList, equalTo(expectedResultList)); assertThat(actualResultList.size(), equalTo(expectedResultList.size())); } - private TaskImpl createUnitTestTask(String taskId, String taskName, String workbasketId) { + private TaskImpl createUnitTestTask(String id, String name, String workbasketKey) { TaskImpl task = new TaskImpl(); - task.setId(taskId); - task.setName(taskName); - task.setWorkbasketId(workbasketId); + task.setId(id); + task.setName(name); + task.setWorkbasketKey(workbasketKey); Timestamp now = new Timestamp(System.currentTimeMillis()); task.setCreated(now); task.setModified(now); @@ -905,9 +920,10 @@ public class TaskServiceImplTest { return task; } - private WorkbasketImpl createWorkbasket(String id) { + private WorkbasketImpl createWorkbasket(String id, String key) { WorkbasketImpl workbasket = new WorkbasketImpl(); workbasket.setId(id); + workbasket.setKey(key); workbasket.setName("Workbasket " + id); return workbasket; } diff --git a/lib/taskana-core/src/test/java/pro/taskana/impl/TaskanaEngineProxyForTest.java b/lib/taskana-core/src/test/java/pro/taskana/impl/TaskanaEngineProxyForTest.java new file mode 100644 index 000000000..18bd10ee0 --- /dev/null +++ b/lib/taskana-core/src/test/java/pro/taskana/impl/TaskanaEngineProxyForTest.java @@ -0,0 +1,30 @@ +package pro.taskana.impl; + +import org.apache.ibatis.session.SqlSession; + +/** + * Utility class to enable unit tests to access mappers directly. + * + * @author bbr + */ +public class TaskanaEngineProxyForTest { + + TaskanaEngineImpl engine; + + public TaskanaEngineProxyForTest(TaskanaEngineImpl taskanaEngine) { + engine = taskanaEngine; + } + + public SqlSession getSqlSession() { + return engine.sessionManager; + } + + public void openConnection() { + engine.openConnection(); + } + + public void returnConnection() { + engine.returnConnection(); + } + +} diff --git a/lib/taskana-core/src/test/java/pro/taskana/impl/WorkbasketServiceImplTest.java b/lib/taskana-core/src/test/java/pro/taskana/impl/WorkbasketServiceImplTest.java index c25c8400f..97a0277cd 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/impl/WorkbasketServiceImplTest.java +++ b/lib/taskana-core/src/test/java/pro/taskana/impl/WorkbasketServiceImplTest.java @@ -20,16 +20,19 @@ import org.mockito.junit.MockitoJUnitRunner; import pro.taskana.Workbasket; import pro.taskana.configuration.TaskanaEngineConfiguration; +import pro.taskana.exceptions.InvalidWorkbasketException; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.WorkbasketNotFoundException; import pro.taskana.model.WorkbasketAccessItem; import pro.taskana.model.WorkbasketAuthorization; +import pro.taskana.model.WorkbasketType; import pro.taskana.model.mappings.DistributionTargetMapper; import pro.taskana.model.mappings.WorkbasketAccessMapper; import pro.taskana.model.mappings.WorkbasketMapper; /** * Unit Test for workbasketServiceImpl. + * * @author EH */ @RunWith(MockitoJUnitRunner.class) @@ -44,14 +47,19 @@ public class WorkbasketServiceImplTest { @Mock WorkbasketMapper workbasketMapper; + @Mock DistributionTargetMapper distributionTargetMapper; + @Mock WorkbasketAccessMapper workbasketAccessMapper; + @Mock TaskanaEngineImpl taskanaEngine; + @Mock TaskanaEngineImpl taskanaEngineImpl; + @Mock TaskanaEngineConfiguration taskanaEngineConfiguration; @@ -59,19 +67,19 @@ public class WorkbasketServiceImplTest { public void setup() { MockitoAnnotations.initMocks(this); } - @Test - public void should_ReturnWorkbasket_when_WorkbasketIdExists() throws WorkbasketNotFoundException { + + @Test(expected = InvalidWorkbasketException.class) + public void should_throw_InvalidWorkbasketException_when_empty_Workbasket_is_found() + throws WorkbasketNotFoundException, InvalidWorkbasketException { when(workbasketMapper.findById(any())).thenReturn(new WorkbasketImpl()); Workbasket workbasket = workbasketServiceImpl.getWorkbasket("fail"); - - verify(workbasketMapper).findById(any()); - Assert.assertNotNull(workbasket); + Assert.assertNull(workbasket); } @Test(expected = WorkbasketNotFoundException.class) public void should_ThrowWorkbasketNotFoundException_when_WorkbasketIdDoesNotExist() - throws WorkbasketNotFoundException { + throws WorkbasketNotFoundException, InvalidWorkbasketException { workbasketServiceImpl.getWorkbasket("fail"); } @@ -99,11 +107,16 @@ public class WorkbasketServiceImplTest { } @Test - public void should_InitializeAndStoreWorkbasket_when_WorkbasketIsCreated() throws NotAuthorizedException { + public void should_InitializeAndStoreWorkbasket_when_WorkbasketIsCreated() + throws NotAuthorizedException, InvalidWorkbasketException, WorkbasketNotFoundException { doNothing().when(workbasketMapper).insert(any()); WorkbasketImpl workbasket = new WorkbasketImpl(); workbasket.setId("1"); + workbasket.setKey("myKey"); + workbasket.setName("workbasket"); + workbasket.setType(WorkbasketType.PERSONAL); + workbasket.setDomain("generali"); workbasketServiceImpl.createWorkbasket(workbasket); Assert.assertEquals("1", workbasket.getId()); @@ -115,23 +128,43 @@ public class WorkbasketServiceImplTest { @SuppressWarnings("serial") @Test public void should_InitializeAndStoreWorkbasket_when_WorkbasketWithDistributionTargetsIsCreated() - throws NotAuthorizedException { + throws NotAuthorizedException, InvalidWorkbasketException, WorkbasketNotFoundException { doNothing().when(workbasketMapper).insert(any()); doNothing().when(distributionTargetMapper).insert(any(), any()); WorkbasketImpl workbasket = new WorkbasketImpl(); workbasket.setId("1"); + workbasket.setKey("myKey1"); WorkbasketImpl workbasket1 = new WorkbasketImpl(); workbasket1.setId("2"); WorkbasketImpl workbasket2 = new WorkbasketImpl(); + workbasket1.setKey("myKey2"); + workbasket1.setName("workbasket2"); + workbasket1.setType(WorkbasketType.PERSONAL); + workbasket1.setDomain("generali"); + workbasketServiceImpl.createWorkbasket(workbasket1); + when(workbasketMapper.findById("2")).thenReturn(workbasket1); + workbasket2.setId("3"); + workbasket2.setKey("myKey3"); + workbasket2.setName("workbasket3"); + workbasket2.setType(WorkbasketType.PERSONAL); + workbasket2.setDomain("generali"); + workbasketServiceImpl.createWorkbasket(workbasket2); + when(workbasketMapper.findById("3")).thenReturn(workbasket2); + workbasket.setDistributionTargets(new ArrayList() { + { add(workbasket1); add(workbasket2); } }); + workbasket.setKey("myKey"); + workbasket.setName("workbasket"); + workbasket.setType(WorkbasketType.PERSONAL); + workbasket.setDomain("generali"); workbasketServiceImpl.createWorkbasket(workbasket); Assert.assertEquals("1", workbasket.getId()); @@ -143,7 +176,7 @@ public class WorkbasketServiceImplTest { @Test public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDescriptionIsChanged() - throws NotAuthorizedException { + throws NotAuthorizedException, InvalidWorkbasketException, WorkbasketNotFoundException { doNothing().when(workbasketMapper).insert(any()); WorkbasketImpl workbasket = new WorkbasketImpl(); @@ -151,6 +184,9 @@ public class WorkbasketServiceImplTest { workbasket.setDescription("TestDescription"); workbasket.setName("Cool New WorkintheBasket"); workbasket.setOwner("Arthur Dent"); + workbasket.setKey("myKey"); + workbasket.setType(WorkbasketType.PERSONAL); + workbasket.setDomain("generali"); workbasketServiceImpl.createWorkbasket(workbasket); doNothing().when(workbasketMapper).update(any()); @@ -163,18 +199,30 @@ public class WorkbasketServiceImplTest { @SuppressWarnings("serial") @Test public void should_ReturnUpdatedWorkbasket_when_ExistingWorkbasketDistributionTargetIsChanged() - throws NotAuthorizedException { + throws NotAuthorizedException, InvalidWorkbasketException, WorkbasketNotFoundException { doNothing().when(workbasketMapper).insert(any()); WorkbasketImpl workbasket = new WorkbasketImpl(); workbasket.setId("0"); WorkbasketImpl workbasket1 = new WorkbasketImpl(); workbasket1.setId("1"); + workbasket1.setKey("myKey1"); + workbasket1.setName("workbasket1"); + workbasket1.setType(WorkbasketType.PERSONAL); + workbasket1.setDomain("generali"); + workbasketServiceImpl.createWorkbasket(workbasket1); + when(workbasketMapper.findById("1")).thenReturn(workbasket1); + workbasket.setDistributionTargets(new ArrayList() { + { add(workbasket1); } }); + workbasket.setKey("myKey0"); + workbasket.setName("workbasket0"); + workbasket.setType(WorkbasketType.PERSONAL); + workbasket.setDomain("generali"); workbasketServiceImpl.createWorkbasket(workbasket); doNothing().when(workbasketMapper).update(any()); @@ -192,16 +240,43 @@ public class WorkbasketServiceImplTest { WorkbasketImpl workbasket0 = new WorkbasketImpl(); workbasket0.setId("0"); + workbasket0.setKey("myKey0"); + workbasket0.setName("workbasket0"); + workbasket0.setType(WorkbasketType.PERSONAL); + workbasket0.setDomain("generali"); + workbasketServiceImpl.createWorkbasket(workbasket0); + when(workbasketMapper.findById("0")).thenReturn(workbasket0); + WorkbasketImpl workbasket1 = new WorkbasketImpl(); + workbasket1.setKey("myKey1"); + workbasket1.setName("workbasket1"); + workbasket1.setType(WorkbasketType.PERSONAL); + workbasket1.setDomain("generali"); + workbasket1.setId("1"); + workbasketServiceImpl.createWorkbasket(workbasket1); + when(workbasketMapper.findById("1")).thenReturn(workbasket1); + WorkbasketImpl workbasket2 = new WorkbasketImpl(); workbasket2.setId("2"); + workbasket2.setKey("myKey2"); + workbasket2.setName("workbasket2"); + workbasket2.setType(WorkbasketType.PERSONAL); + workbasket2.setDomain("generali"); + workbasket2.getDistributionTargets().add(workbasket0); workbasket2.getDistributionTargets().add(workbasket1); workbasketServiceImpl.createWorkbasket(workbasket2); WorkbasketImpl workbasket3 = new WorkbasketImpl(); workbasket3.setId("3"); + workbasket3.setKey("myKey3"); + workbasket3.setName("workbasket3"); + workbasket3.setType(WorkbasketType.PERSONAL); + workbasket3.setDomain("generali"); + workbasketServiceImpl.createWorkbasket(workbasket3); + when(workbasketMapper.findById("3")).thenReturn(workbasket3); + workbasket2.getDistributionTargets().clear(); workbasket2.getDistributionTargets().add(workbasket3); Thread.sleep(SLEEP_TIME); @@ -220,20 +295,20 @@ public class WorkbasketServiceImplTest { Assert.assertEquals("3", distributionTargets.get(0).getId()); Assert.assertNotEquals(workbasketServiceImpl.getWorkbasket("2").getCreated(), - workbasketServiceImpl.getWorkbasket("2").getModified()); + workbasketServiceImpl.getWorkbasket("2").getModified()); Assert.assertEquals(workbasketServiceImpl.getWorkbasket("1").getCreated(), - workbasketServiceImpl.getWorkbasket("1").getModified()); + workbasketServiceImpl.getWorkbasket("1").getModified()); Assert.assertEquals(workbasketServiceImpl.getWorkbasket("3").getCreated(), - workbasketServiceImpl.getWorkbasket("3").getModified()); + workbasketServiceImpl.getWorkbasket("3").getModified()); } @Test public void should_ReturnWorkbasketAuthorization_when_NewWorkbasketAccessItemIsCreated() - throws NotAuthorizedException { + throws NotAuthorizedException { doNothing().when(workbasketAccessMapper).insert(any()); WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); - accessItem.setWorkbasketId("1"); + accessItem.setWorkbasketKey("1"); accessItem.setAccessId("Arthur Dent"); accessItem.setPermOpen(true); accessItem.setPermRead(true); @@ -244,11 +319,11 @@ public class WorkbasketServiceImplTest { @Test public void should_ReturnWorkbasketAuthorization_when_WorkbasketAccessItemIsUpdated() - throws NotAuthorizedException { + throws NotAuthorizedException { doNothing().when(workbasketAccessMapper).insert(any()); WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); - accessItem.setWorkbasketId("1"); + accessItem.setWorkbasketKey("1"); accessItem.setAccessId("Arthur Dent"); accessItem.setPermOpen(true); accessItem.setPermRead(true); @@ -278,11 +353,12 @@ public class WorkbasketServiceImplTest { when(taskanaEngine.getConfiguration().isSecurityEnabled()).thenReturn(true); when(workbasketAccessMapper.findByWorkbasketAndAccessIdAndAuthorizations(any(), any(), any())) - .thenReturn(new ArrayList() { - { - add(new WorkbasketAccessItem()); - } - }); + .thenReturn(new ArrayList() { + + { + add(new WorkbasketAccessItem()); + } + }); workbasketServiceImpl.checkAuthorization("1", WorkbasketAuthorization.READ); diff --git a/lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntAutocommitTest.java b/lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntAutocommitTest.java index ddcd213a9..71193ec0d 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntAutocommitTest.java +++ b/lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntAutocommitTest.java @@ -34,6 +34,7 @@ import pro.taskana.WorkbasketService; import pro.taskana.configuration.TaskanaEngineConfiguration; import pro.taskana.exceptions.ClassificationAlreadyExistException; import pro.taskana.exceptions.ClassificationNotFoundException; +import pro.taskana.exceptions.InvalidWorkbasketException; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.TaskAlreadyExistException; import pro.taskana.exceptions.TaskNotFoundException; @@ -51,6 +52,7 @@ import pro.taskana.model.ClassificationImpl; import pro.taskana.model.TaskState; import pro.taskana.model.TaskSummary; import pro.taskana.model.WorkbasketAccessItem; +import pro.taskana.model.WorkbasketType; import pro.taskana.security.CurrentUserContext; import pro.taskana.security.JAASRunner; import pro.taskana.security.WithAccessId; @@ -64,17 +66,11 @@ import pro.taskana.security.WithAccessId; public class TaskServiceImplIntAutocommitTest { private DataSource dataSource; - private TaskServiceImpl taskServiceImpl; - private TaskanaEngineConfiguration taskanaEngineConfiguration; - private TaskanaEngine taskanaEngine; - private TaskanaEngineImpl taskanaEngineImpl; - private ClassificationService classificationService; - private WorkbasketService workbasketService; @BeforeClass @@ -102,9 +98,12 @@ public class TaskServiceImplIntAutocommitTest { @Test public void testStart() throws FileNotFoundException, SQLException, TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, ClassificationNotFoundException, - ClassificationAlreadyExistException, TaskAlreadyExistException { + ClassificationAlreadyExistException, TaskAlreadyExistException, InvalidWorkbasketException { Workbasket wb = workbasketService.newWorkbasket(); + wb.setKey("workbasket"); wb.setName("workbasket"); + wb.setType(WorkbasketType.GROUP); + wb.setDomain("novatec"); taskanaEngine.getWorkbasketService().createWorkbasket(wb); Classification classification = classificationService.newClassification(); classification.setKey("TEST"); @@ -112,7 +111,8 @@ public class TaskServiceImplIntAutocommitTest { Task task = taskServiceImpl.newTask(); task.setName("Unit Test Task"); - task.setWorkbasketId(wb.getId()); + task.setWorkbasketKey(wb.getKey()); + task.setClassification(classification); task = taskServiceImpl.createTask(task); @@ -128,9 +128,12 @@ public class TaskServiceImplIntAutocommitTest { public void testStartTransactionFail() throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, ClassificationAlreadyExistException, - TaskAlreadyExistException { + TaskAlreadyExistException, InvalidWorkbasketException { Workbasket wb = workbasketService.newWorkbasket(); wb.setName("sdf"); + wb.setType(WorkbasketType.GROUP); + wb.setDomain("novatec"); + wb.setKey("wb1k1"); taskanaEngine.getWorkbasketService().createWorkbasket(wb); Classification classification = classificationService.newClassification(); classification.setKey("TEST"); @@ -138,7 +141,7 @@ public class TaskServiceImplIntAutocommitTest { Task task = taskServiceImpl.newTask(); task.setName("Unit Test Task"); - task.setWorkbasketId(wb.getId()); + task.setWorkbasketKey(wb.getKey()); task.setClassification(classification); taskServiceImpl.createTask(task); taskServiceImpl.getTaskById(task.getId()); @@ -152,17 +155,25 @@ public class TaskServiceImplIntAutocommitTest { public void testCreateTaskInTaskanaWithDefaultDb() throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, ClassificationAlreadyExistException, - TaskAlreadyExistException { + TaskAlreadyExistException, InvalidWorkbasketException { + TaskanaEngineConfiguration taskanaEngineConfiguration = new TaskanaEngineConfiguration(null, false, false); + TaskanaEngine te = taskanaEngineConfiguration.buildTaskanaEngine(); + ((TaskanaEngineImpl) te).setConnectionManagementMode(ConnectionManagementMode.AUTOCOMMIT); + TaskServiceImpl taskServiceImpl = (TaskServiceImpl) te.getTaskService(); + Workbasket wb = workbasketService.newWorkbasket(); + wb.setKey("workbasket"); wb.setName("workbasket"); - wb = taskanaEngine.getWorkbasketService().createWorkbasket(wb); - Classification classification = classificationService.newClassification(); + wb.setType(WorkbasketType.GROUP); + wb.setDomain("novatec"); + te.getWorkbasketService().createWorkbasket(wb); + Classification classification = te.getClassificationService().newClassification(); classification.setKey("TEST"); - taskanaEngine.getClassificationService().createClassification(classification); + te.getClassificationService().createClassification(classification); Task task = taskServiceImpl.newTask(); task.setName("Unit Test Task"); - task.setWorkbasketId(wb.getId()); + task.setWorkbasketKey(wb.getKey()); task.setClassification(classification); task = taskServiceImpl.createTask(task); @@ -173,9 +184,12 @@ public class TaskServiceImplIntAutocommitTest { @Test public void should_ReturnList_when_BuilderIsUsed() throws SQLException, NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, ClassificationAlreadyExistException, - TaskAlreadyExistException { + TaskAlreadyExistException, InvalidWorkbasketException { Workbasket wb = workbasketService.newWorkbasket(); + wb.setKey("key"); wb.setName("workbasket"); + wb.setType(WorkbasketType.GROUP); + wb.setDomain("novatec"); taskanaEngine.getWorkbasketService().createWorkbasket(wb); Classification classification = classificationService.newClassification(); classification.setKey("TEST"); @@ -183,7 +197,7 @@ public class TaskServiceImplIntAutocommitTest { Task task = taskServiceImpl.newTask(); task.setName("Unit Test Task"); - task.setWorkbasketId(wb.getId()); + task.setWorkbasketKey(wb.getKey()); task.setClassification(classification); taskServiceImpl.createTask(task); @@ -209,7 +223,7 @@ public class TaskServiceImplIntAutocommitTest { .descriptionLike("test") .priority(1, 2, 2) .state(TaskState.CLAIMED) - .workbasketId("asd", "asdasdasd") + .workbasketKeyIn("asd", "asdasdasd") .owner("test", "test2", "bla") .customFields("test") .classification(classificationQuery) @@ -222,7 +236,10 @@ public class TaskServiceImplIntAutocommitTest { @Test public void shouldReturnTaskSummaryListWithValues() throws Exception { Workbasket dummyWorkbasket = workbasketService.newWorkbasket(); + dummyWorkbasket.setKey("Dummy-Key"); dummyWorkbasket.setName("Dummy-Basket"); + dummyWorkbasket.setType(WorkbasketType.GROUP); + dummyWorkbasket.setDomain("novatec"); dummyWorkbasket = workbasketService.createWorkbasket(dummyWorkbasket); Classification dummyClassification = classificationService.newClassification(); @@ -234,44 +251,48 @@ public class TaskServiceImplIntAutocommitTest { dummyTask.setId(null); dummyTask.setName("Dummy-Task"); dummyTask.setClassification(dummyClassification); - dummyTask.setWorkbasketId(dummyWorkbasket.getId()); + dummyTask.setWorkbasketKey(dummyWorkbasket.getKey()); dummyTask = (TaskImpl) taskServiceImpl.createTask(dummyTask); List expectedTaskSumamries = new ArrayList<>(); TaskSummary taskSummary = new TaskSummary(); taskSummary.setTaskId(dummyTask.getId()); taskSummary.setTaskName(dummyTask.getName()); - taskSummary.setWorkbasketId(dummyWorkbasket.getId()); + taskSummary.setWorkbasketKey(dummyWorkbasket.getKey()); taskSummary.setWorkbasketName(dummyWorkbasket.getName()); taskSummary.setClassificationKey(dummyClassification.getKey()); taskSummary.setClassificationName(dummyClassification.getName()); expectedTaskSumamries.add(taskSummary); List actualTaskSumamryResult = taskServiceImpl - .getTaskSummariesByWorkbasketId(dummyWorkbasket.getId()); + .getTaskSummariesByWorkbasketKey(dummyWorkbasket.getKey()); assertThat(actualTaskSumamryResult.size(), equalTo(expectedTaskSumamries.size())); } @Test(expected = WorkbasketNotFoundException.class) - public void shouldThrowWorkbasketNotFoundExceptionByNullParameter() throws WorkbasketNotFoundException { - taskServiceImpl.getTaskSummariesByWorkbasketId(null); + public void shouldThrowWorkbasketNotFoundExceptionByNullParameter() + throws WorkbasketNotFoundException, InvalidWorkbasketException { + taskServiceImpl.getTaskSummariesByWorkbasketKey(null); } @Test(expected = WorkbasketNotFoundException.class) public void shouldThrowWorkbasketNotFoundExceptionByInvalidWorkbasketParameter() - throws WorkbasketNotFoundException { + throws WorkbasketNotFoundException, InvalidWorkbasketException { WorkbasketImpl wb = (WorkbasketImpl) workbasketService.newWorkbasket(); + wb.setKey("key"); wb.setName("wb"); + wb.setType(WorkbasketType.GROUP); + wb.setDomain("novatec"); wb = (WorkbasketImpl) workbasketService.createWorkbasket(wb); - wb.setId(wb.getId() + " - 1"); - taskServiceImpl.getTaskSummariesByWorkbasketId(wb.getId()); + taskServiceImpl.getTaskSummariesByWorkbasketKey("1"); } @Test public void shouldTransferTaskToOtherWorkbasket() throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException, - ClassificationAlreadyExistException, TaskNotFoundException, InterruptedException, TaskAlreadyExistException { + ClassificationAlreadyExistException, TaskNotFoundException, InterruptedException, TaskAlreadyExistException, + InvalidWorkbasketException { Workbasket sourceWB; Workbasket destinationWB; WorkbasketImpl wb; @@ -284,12 +305,18 @@ public class TaskServiceImplIntAutocommitTest { wb = (WorkbasketImpl) workbasketService.newWorkbasket(); wb.setName("Basic-Workbasket"); wb.setDescription("Just used as base WB for Task here"); + wb.setKey("key1"); + wb.setDomain("domain"); + wb.setType(WorkbasketType.GROUP); wb.setOwner("The Tester ID"); sourceWB = workbasketService.createWorkbasket(wb); // Destination Workbasket wb = (WorkbasketImpl) workbasketService.newWorkbasket(); wb.setName("Desination-WorkBasket"); + wb.setKey("k1"); + wb.setDomain("domain"); + wb.setType(WorkbasketType.CLEARANCE); wb.setDescription("Destination WB where Task should be transfered to"); wb.setOwner("The Tester ID"); destinationWB = workbasketService.createWorkbasket(wb); @@ -306,7 +333,7 @@ public class TaskServiceImplIntAutocommitTest { task = (TaskImpl) taskServiceImpl.newTask(); task.setName("Task Name"); task.setDescription("Task used for transfer Test"); - task.setWorkbasketId(sourceWB.getId()); + task.setWorkbasketKey(sourceWB.getKey()); task.setRead(true); task.setTransferred(false); task.setModified(null); @@ -314,10 +341,10 @@ public class TaskServiceImplIntAutocommitTest { task = (TaskImpl) taskServiceImpl.createTask(task); Thread.sleep(sleepTime); // Sleep for modification-timestamp - resultTask = taskServiceImpl.transfer(task.getId(), destinationWB.getId()); + resultTask = taskServiceImpl.transfer(task.getId(), destinationWB.getKey()); assertThat(resultTask.isRead(), equalTo(false)); assertThat(resultTask.isTransferred(), equalTo(true)); - assertThat(resultTask.getWorkbasketId(), equalTo(destinationWB.getId())); + assertThat(resultTask.getWorkbasketKey(), equalTo(destinationWB.getKey())); assertThat(resultTask.getModified(), not(equalTo(null))); assertThat(resultTask.getModified(), not(equalTo(task.getModified()))); assertThat(resultTask.getCreated(), not(equalTo(null))); @@ -326,7 +353,7 @@ public class TaskServiceImplIntAutocommitTest { @Test(expected = TaskNotFoundException.class) public void shouldNotTransferAnyTask() - throws WorkbasketNotFoundException, NotAuthorizedException, TaskNotFoundException { + throws WorkbasketNotFoundException, NotAuthorizedException, TaskNotFoundException, InvalidWorkbasketException { taskServiceImpl.transfer(UUID.randomUUID() + "_X", "1"); } @@ -334,7 +361,7 @@ public class TaskServiceImplIntAutocommitTest { @Test public void shouldNotTransferByFailingSecurity() throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException, ClassificationAlreadyExistException, SQLException, - TaskNotFoundException, TaskAlreadyExistException { + TaskNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException { final String user = CurrentUserContext.getUserid(); // Set up Security for this Test @@ -358,6 +385,9 @@ public class TaskServiceImplIntAutocommitTest { wb.setName("BASE WB"); wb.setDescription("Normal base WB"); wb.setOwner(user); + wb.setKey("k5"); + wb.setDomain("d1"); + wb.setType(WorkbasketType.TOPIC); wb = (WorkbasketImpl) workbasketService.createWorkbasket(wb); createWorkbasketWithSecurity(wb, wb.getOwner(), true, true, true, true); @@ -365,6 +395,9 @@ public class TaskServiceImplIntAutocommitTest { wbNoAppend.setName("Test-Security-WorkBasket-APPEND"); wbNoAppend.setDescription("Workbasket without permission APPEND on Task"); wbNoAppend.setOwner(user); + wbNoAppend.setDomain("d2"); + wbNoAppend.setType(WorkbasketType.PERSONAL); + wbNoAppend.setKey("key77"); wbNoAppend = (WorkbasketImpl) workbasketService.createWorkbasket(wbNoAppend); createWorkbasketWithSecurity(wbNoAppend, wbNoAppend.getOwner(), true, true, false, true); @@ -372,43 +405,46 @@ public class TaskServiceImplIntAutocommitTest { wbNoTransfer.setName("Test-Security-WorkBasket-TRANSFER"); wbNoTransfer.setDescription("Workbasket without permission TRANSFER on Task"); wbNoTransfer.setOwner(user); + wbNoTransfer.setDomain("d3"); + wbNoTransfer.setType(WorkbasketType.CLEARANCE); + wbNoTransfer.setKey("k99"); wbNoTransfer = (WorkbasketImpl) workbasketService.createWorkbasket(wbNoTransfer); createWorkbasketWithSecurity(wbNoTransfer, wbNoTransfer.getOwner(), true, true, true, false); TaskImpl task = (TaskImpl) taskServiceImpl.newTask(); task.setName("Task Name"); task.setDescription("Task used for transfer Test"); - task.setWorkbasketId(wb.getId()); + task.setWorkbasketKey(wb.getKey()); task.setOwner(user); task.setClassification(classification); task = (TaskImpl) taskServiceImpl.createTask(task); // Check failing with missing APPEND try { - task = (TaskImpl) taskServiceImpl.transfer(task.getId(), wbNoAppend.getId()); + task = (TaskImpl) taskServiceImpl.transfer(task.getId(), wbNoAppend.getKey()); fail("Transfer Task should be FAILD, because there are no APPEND-Rights on destination WB."); } catch (NotAuthorizedException e) { if (!e.getMessage().contains("APPEND")) { fail("Transfer Task should be FAILD, because there are no APPEND-Rights on destination WB."); } assertThat(task.isTransferred(), equalTo(false)); - assertThat(task.getWorkbasketId(), not(equalTo(wbNoAppend.getId()))); - assertThat(task.getWorkbasketId(), equalTo(wb.getId())); + assertThat(task.getWorkbasketKey(), not(equalTo(wbNoAppend.getKey()))); + assertThat(task.getWorkbasketKey(), equalTo(wb.getKey())); } // Check failing with missing TRANSFER task.setId(""); - task.setWorkbasketId(wbNoTransfer.getId()); + task.setWorkbasketKey(wbNoTransfer.getKey()); task = (TaskImpl) taskServiceImpl.createTask(task); try { - task = (TaskImpl) taskServiceImpl.transfer(task.getId(), wb.getId()); + task = (TaskImpl) taskServiceImpl.transfer(task.getId(), wb.getKey()); fail("Transfer Task should be FAILD, because there are no TRANSFER-Rights on current WB."); } catch (NotAuthorizedException e) { if (!e.getMessage().contains("TRANSFER")) { fail("Transfer Task should be FAILD, because there are no APPEND-Rights on current WB."); } assertThat(task.isTransferred(), equalTo(false)); - assertThat(task.getWorkbasketId(), not(equalTo(wbNoAppend.getId()))); + assertThat(task.getWorkbasketKey(), not(equalTo(wbNoAppend.getKey()))); } } @@ -416,7 +452,7 @@ public class TaskServiceImplIntAutocommitTest { boolean permRead, boolean permAppend, boolean permTransfer) { WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); accessItem.setId(IdGenerator.generateWithPrefix("WAI")); - accessItem.setWorkbasketId(wb.getId()); + accessItem.setWorkbasketKey(wb.getKey()); accessItem.setAccessId(accessId); accessItem.setPermOpen(permOpen); accessItem.setPermRead(permRead); diff --git a/lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntExplicitTest.java b/lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntExplicitTest.java index 4260eba29..ebb807d87 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntExplicitTest.java +++ b/lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntExplicitTest.java @@ -37,6 +37,7 @@ import pro.taskana.WorkbasketService; import pro.taskana.configuration.TaskanaEngineConfiguration; import pro.taskana.exceptions.ClassificationAlreadyExistException; import pro.taskana.exceptions.ClassificationNotFoundException; +import pro.taskana.exceptions.InvalidWorkbasketException; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.TaskAlreadyExistException; import pro.taskana.exceptions.TaskNotFoundException; @@ -56,6 +57,7 @@ import pro.taskana.model.ClassificationImpl; import pro.taskana.model.ObjectReference; import pro.taskana.model.TaskState; import pro.taskana.model.WorkbasketAccessItem; +import pro.taskana.model.WorkbasketType; import pro.taskana.security.CurrentUserContext; import pro.taskana.security.JAASRunner; import pro.taskana.security.WithAccessId; @@ -108,7 +110,7 @@ public class TaskServiceImplIntExplicitTest { public void testStartTransactionFail() throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, ClassificationAlreadyExistException, - TaskAlreadyExistException { + TaskAlreadyExistException, InvalidWorkbasketException { Connection connection = dataSource.getConnection(); taskanaEngineImpl.setConnection(connection); @@ -117,6 +119,9 @@ public class TaskServiceImplIntExplicitTest { WorkbasketImpl workbasket = (WorkbasketImpl) workbasketService.newWorkbasket(); workbasket.setName("workbasket"); workbasket.setId("1"); // set id manually for authorization tests + workbasket.setKey("k1"); + workbasket.setType(WorkbasketType.GROUP); + workbasket.setDomain("novatec"); Classification classification = classificationService.newClassification(); classification.setKey("TEST"); taskanaEngine.getWorkbasketService().createWorkbasket(workbasket); @@ -124,7 +129,7 @@ public class TaskServiceImplIntExplicitTest { connection.commit(); Task task = taskServiceImpl.newTask(); task.setName("Unit Test Task"); - task.setWorkbasketId(workbasket.getId()); + task.setWorkbasketKey(workbasket.getKey()); task.setClassification(classification); task = taskServiceImpl.createTask(task); connection.commit(); @@ -141,7 +146,7 @@ public class TaskServiceImplIntExplicitTest { public void testCreateTask() throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, ClassificationAlreadyExistException, - TaskAlreadyExistException { + TaskAlreadyExistException, InvalidWorkbasketException { Connection connection = dataSource.getConnection(); taskanaEngineImpl.setConnection(connection); @@ -149,6 +154,15 @@ public class TaskServiceImplIntExplicitTest { Task task = this.generateDummyTask(); connection.commit(); + + WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); + accessItem.setId(IdGenerator.generateWithPrefix("WAI")); + accessItem.setWorkbasketKey("wb"); + accessItem.setAccessId("Elena"); + accessItem.setPermAppend(true); + accessItem.setPermOpen(true); + workbasketService.createWorkbasketAuthorization(accessItem); + task = taskServiceImpl.createTask(task); connection.commit(); // needed so that the change is visible in the other session @@ -163,7 +177,7 @@ public class TaskServiceImplIntExplicitTest { public void testCreateTaskInTaskanaWithDefaultDb() throws FileNotFoundException, SQLException, TaskNotFoundException, NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, ClassificationAlreadyExistException, - TaskAlreadyExistException { + TaskAlreadyExistException, InvalidWorkbasketException { DataSource ds = TaskanaEngineConfiguration.createDefaultDataSource(); TaskanaEngineConfiguration taskanaEngineConfiguration = new TaskanaEngineConfiguration(ds, false, false); TaskanaEngine te = taskanaEngineConfiguration.buildTaskanaEngine(); @@ -175,15 +189,19 @@ public class TaskServiceImplIntExplicitTest { Workbasket workbasket = workbasketService.newWorkbasket(); workbasket.setName("workbasket"); + workbasket.setKey("K99"); + workbasket.setName("workbasket99"); + workbasket.setType(WorkbasketType.GROUP); + workbasket.setDomain("novatec"); + workBasketServiceImpl.createWorkbasket(workbasket); Classification classification = classificationService.newClassification(); classification.setKey("TEST"); workbasket.setName("workbasket99"); - workBasketServiceImpl.createWorkbasket(workbasket); classificationServiceImpl.createClassification(classification); Task task = taskServiceImpl.newTask(); task.setName("Unit Test Task"); - task.setWorkbasketId(workbasket.getId()); + task.setWorkbasketKey(workbasket.getKey()); task.setClassification(classification); task = taskServiceImpl.createTask(task); @@ -197,7 +215,7 @@ public class TaskServiceImplIntExplicitTest { @Test public void testCreateTaskWithPlannedAndName() throws SQLException, NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, ClassificationAlreadyExistException, - TaskAlreadyExistException { + TaskAlreadyExistException, InvalidWorkbasketException { Connection connection = dataSource.getConnection(); taskanaEngineImpl.setConnection(connection); @@ -217,20 +235,34 @@ public class TaskServiceImplIntExplicitTest { objectReference.setValue("4444"); objectReference.setType("type"); + WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); + accessItem.setId(IdGenerator.generateWithPrefix("WAI")); + accessItem.setWorkbasketKey("wb"); + accessItem.setAccessId("Elena"); + accessItem.setPermAppend(true); + accessItem.setPermOpen(true); + workbasketService.createWorkbasketAuthorization(accessItem); + Timestamp tomorrow = Timestamp.valueOf(LocalDateTime.now().plusDays(1)); + Workbasket wb = workbasketService.newWorkbasket(); + wb.setDomain("novatec"); + wb.setName("wbk1"); + wb.setType(WorkbasketType.PERSONAL); + wb.setKey("k1"); + workbasketService.createWorkbasket(wb); + Task task = this.generateDummyTask(); task.setClassification(classification); task.setName("Name"); task.setPrimaryObjRef(objectReference); task.setPlanned(tomorrow); Task resultTask = taskServiceImpl.createTask(task); - Assert.assertNotEquals(resultTask.getPlanned(), resultTask.getCreated()); Assert.assertNotNull(resultTask.getDue()); Task task2 = taskServiceImpl.newTask(); - task2.setWorkbasketId(task.getWorkbasketId()); + task2.setWorkbasketKey(task.getWorkbasketKey()); task2.setClassification(classification); task2.setPrimaryObjRef(objectReference); task2.setDescription("desc"); @@ -248,14 +280,14 @@ public class TaskServiceImplIntExplicitTest { @Test(expected = WorkbasketNotFoundException.class) public void createTaskShouldThrowWorkbasketNotFoundException() throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, SQLException, - ClassificationAlreadyExistException, TaskAlreadyExistException { + ClassificationAlreadyExistException, TaskAlreadyExistException, InvalidWorkbasketException { Connection connection = dataSource.getConnection(); taskanaEngineImpl.setConnection(connection); generateSampleAccessItems(); Task test = this.generateDummyTask(); - test.setWorkbasketId("2"); + test.setWorkbasketKey("2"); taskServiceImpl.createTask(test); } @@ -263,7 +295,7 @@ public class TaskServiceImplIntExplicitTest { @Test(expected = ClassificationNotFoundException.class) public void createManualTaskShouldThrowClassificationNotFoundException() throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, SQLException, - ClassificationAlreadyExistException, TaskAlreadyExistException { + ClassificationAlreadyExistException, TaskAlreadyExistException, InvalidWorkbasketException { Connection connection = dataSource.getConnection(); taskanaEngineImpl.setConnection(connection); @@ -271,14 +303,23 @@ public class TaskServiceImplIntExplicitTest { Task test = this.generateDummyTask(); test.setClassification(new ClassificationImpl()); + + WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); + accessItem.setId(IdGenerator.generateWithPrefix("WAI")); + accessItem.setWorkbasketKey("wb"); + accessItem.setAccessId("Elena"); + accessItem.setPermAppend(true); + accessItem.setPermOpen(true); + workbasketService.createWorkbasketAuthorization(accessItem); + taskServiceImpl.createTask(test); } - @WithAccessId(userName = "Elena", groupNames = { "DummyGroup" }) + @WithAccessId(userName = "Elena", groupNames = {"DummyGroup"}) @Test public void should_ReturnList_when_BuilderIsUsed() throws SQLException, NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException, ClassificationAlreadyExistException, - TaskAlreadyExistException { + TaskAlreadyExistException, InvalidWorkbasketException { Connection connection = dataSource.getConnection(); taskanaEngineImpl.setConnection(connection); @@ -288,13 +329,16 @@ public class TaskServiceImplIntExplicitTest { workbasket.setName("workbasket"); Classification classification = classificationService.newClassification(); classification.setKey("TEST"); + classificationService.createClassification(classification); workbasket.setId("1"); // set id manually for authorization tests - taskanaEngine.getWorkbasketService().createWorkbasket(workbasket); - taskanaEngine.getClassificationService().createClassification(classification); + workbasket.setKey("k1"); + workbasket.setType(WorkbasketType.GROUP); + workbasket.setDomain("novatec"); + workbasketService.createWorkbasket(workbasket); Task task = taskServiceImpl.newTask(); task.setName("Unit Test Task"); - task.setWorkbasketId(workbasket.getId()); + task.setWorkbasketKey(workbasket.getKey()); task.setClassification(classification); task = taskServiceImpl.createTask(task); @@ -320,7 +364,7 @@ public class TaskServiceImplIntExplicitTest { .descriptionLike("test") .priority(1, 2, 2) .state(TaskState.CLAIMED) - .workbasketId("1", "2") + .workbasketKeyIn("k1", "k2") .owner("test", "test2", "bla") .customFields("test") .classification(classificationQuery) @@ -336,7 +380,7 @@ public class TaskServiceImplIntExplicitTest { public void shouldTransferTaskToOtherWorkbasket() throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException, ClassificationAlreadyExistException, TaskNotFoundException, InterruptedException, TaskAlreadyExistException, - SQLException { + SQLException, InvalidWorkbasketException { Workbasket sourceWB; Workbasket destinationWB; WorkbasketImpl wb; @@ -353,7 +397,11 @@ public class TaskServiceImplIntExplicitTest { wb.setName("Basic-Workbasket"); wb.setDescription("Just used as base WB for Task here"); wb.setOwner(user); + wb.setDomain("domain"); + wb.setKey("sourceWbKey"); + wb.setType(WorkbasketType.PERSONAL); sourceWB = workbasketService.createWorkbasket(wb); + createWorkbasketWithSecurity(wb, wb.getOwner(), false, false, false, false); createWorkbasketWithSecurity(sourceWB, sourceWB.getOwner(), false, false, true, true); @@ -362,6 +410,9 @@ public class TaskServiceImplIntExplicitTest { wb.setName("Desination-WorkBasket"); wb.setDescription("Destination WB where Task should be transfered to"); wb.setOwner(user); + wb.setDomain("dd11"); + wb.setType(WorkbasketType.TOPIC); + wb.setKey("wb2Key"); destinationWB = workbasketService.createWorkbasket(wb); createWorkbasketWithSecurity(destinationWB, destinationWB.getOwner(), false, false, true, true); @@ -377,7 +428,7 @@ public class TaskServiceImplIntExplicitTest { task = (TaskImpl) taskServiceImpl.newTask(); task.setName("Task Name"); task.setDescription("Task used for transfer Test"); - task.setWorkbasketId(sourceWB.getId()); + task.setWorkbasketKey(sourceWB.getKey()); task.setRead(true); task.setTransferred(false); task.setModified(null); @@ -387,11 +438,11 @@ public class TaskServiceImplIntExplicitTest { Thread.sleep(sleepTime); // Sleep for modification-timestamp connection.commit(); - resultTask = taskServiceImpl.transfer(task.getId(), destinationWB.getId()); + resultTask = taskServiceImpl.transfer(task.getId(), destinationWB.getKey()); connection.commit(); assertThat(resultTask.isRead(), equalTo(false)); assertThat(resultTask.isTransferred(), equalTo(true)); - assertThat(resultTask.getWorkbasketId(), equalTo(destinationWB.getId())); + assertThat(resultTask.getWorkbasketKey(), equalTo(destinationWB.getKey())); assertThat(resultTask.getModified(), not(equalTo(null))); assertThat(resultTask.getModified(), not(equalTo(task.getModified()))); assertThat(resultTask.getCreated(), not(equalTo(null))); @@ -400,7 +451,8 @@ public class TaskServiceImplIntExplicitTest { @Test(expected = TaskNotFoundException.class) public void shouldNotTransferAnyTask() - throws WorkbasketNotFoundException, NotAuthorizedException, TaskNotFoundException, SQLException { + throws WorkbasketNotFoundException, NotAuthorizedException, TaskNotFoundException, SQLException, + InvalidWorkbasketException { Connection connection = dataSource.getConnection(); taskanaEngineImpl.setConnection(connection); taskServiceImpl.transfer(UUID.randomUUID() + "_X", "1"); @@ -410,7 +462,7 @@ public class TaskServiceImplIntExplicitTest { @Test public void shouldNotTransferByFailingSecurity() throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException, ClassificationAlreadyExistException, SQLException, - TaskNotFoundException, TaskAlreadyExistException { + TaskNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException { final String user = "User"; // Set up Security for this Test @@ -434,6 +486,9 @@ public class TaskServiceImplIntExplicitTest { wb.setName("BASE WB"); wb.setDescription("Normal base WB"); wb.setOwner(user); + wb.setKey("wbKey1"); + wb.setDomain("myDomain"); + wb.setType(WorkbasketType.GROUP); wb = (WorkbasketImpl) workbasketService.createWorkbasket(wb); createWorkbasketWithSecurity(wb, wb.getOwner(), true, true, true, true); @@ -441,6 +496,9 @@ public class TaskServiceImplIntExplicitTest { wbNoAppend.setName("Test-Security-WorkBasket-APPEND"); wbNoAppend.setDescription("Workbasket without permission APPEND on Task"); wbNoAppend.setOwner(user); + wbNoAppend.setKey("keyNoAppend"); + wbNoAppend.setDomain("anotherDomain"); + wbNoAppend.setType(WorkbasketType.CLEARANCE); wbNoAppend = (WorkbasketImpl) workbasketService.createWorkbasket(wbNoAppend); createWorkbasketWithSecurity(wbNoAppend, wbNoAppend.getOwner(), true, true, false, true); @@ -448,50 +506,57 @@ public class TaskServiceImplIntExplicitTest { wbNoTransfer.setName("Test-Security-WorkBasket-TRANSFER"); wbNoTransfer.setDescription("Workbasket without permission TRANSFER on Task"); wbNoTransfer.setOwner(user); + wbNoTransfer.setKey("keyNoTransfer"); + wbNoTransfer.setDomain("domNoTrans"); + wbNoTransfer.setType(WorkbasketType.GROUP); wbNoTransfer = (WorkbasketImpl) workbasketService.createWorkbasket(wbNoTransfer); createWorkbasketWithSecurity(wbNoTransfer, wbNoTransfer.getOwner(), true, true, true, false); TaskImpl task = (TaskImpl) taskServiceImpl.newTask(); task.setName("Task Name"); task.setDescription("Task used for transfer Test"); - task.setWorkbasketId(wb.getId()); + task.setWorkbasketKey(wb.getKey()); task.setOwner(user); task.setClassification(classification); task = (TaskImpl) taskServiceImpl.createTask(task); // Check failing with missing APPEND try { - task = (TaskImpl) taskServiceImpl.transfer(task.getId(), wbNoAppend.getId()); + task = (TaskImpl) taskServiceImpl.transfer(task.getId(), wbNoAppend.getKey()); fail("Transfer Task should be FAILD, because there are no APPEND-Rights on destination WB."); } catch (NotAuthorizedException e) { if (!e.getMessage().contains("APPEND")) { fail("Transfer Task should be FAILD, because there are no APPEND-Rights on destination WB."); } assertThat(task.isTransferred(), equalTo(false)); - assertThat(task.getWorkbasketId(), not(equalTo(wbNoAppend.getId()))); - assertThat(task.getWorkbasketId(), equalTo(wb.getId())); + assertThat(task.getWorkbasketKey(), not(equalTo(wbNoAppend.getKey()))); + assertThat(task.getWorkbasketKey(), equalTo(wb.getKey())); } // Check failing with missing TRANSFER task.setId(""); - task.setWorkbasketId(wbNoTransfer.getId()); + task.setWorkbasketKey(wbNoTransfer.getKey()); task = (TaskImpl) taskServiceImpl.createTask(task); try { - task = (TaskImpl) taskServiceImpl.transfer(task.getId(), wb.getId()); + task = (TaskImpl) taskServiceImpl.transfer(task.getId(), wb.getKey()); fail("Transfer Task should be FAILD, because there are no TRANSFER-Rights on current WB."); } catch (NotAuthorizedException e) { if (!e.getMessage().contains("TRANSFER")) { fail("Transfer Task should be FAILD, because there are no APPEND-Rights on current WB."); } assertThat(task.isTransferred(), equalTo(false)); - assertThat(task.getWorkbasketId(), not(equalTo(wbNoAppend.getId()))); + assertThat(task.getWorkbasketKey(), not(equalTo(wbNoAppend.getKey()))); } } - private Task generateDummyTask() throws ClassificationAlreadyExistException { + private Task generateDummyTask() + throws ClassificationAlreadyExistException, InvalidWorkbasketException, WorkbasketNotFoundException { WorkbasketImpl workbasket = (WorkbasketImpl) workbasketService.newWorkbasket(); + workbasket.setKey("wb"); workbasket.setName("wb"); workbasket.setId("1"); // set id manually for authorization tests + workbasket.setType(WorkbasketType.GROUP); + workbasket.setDomain("novatec"); taskanaEngine.getWorkbasketService().createWorkbasket(workbasket); Classification classification = classificationService.newClassification(); @@ -499,7 +564,7 @@ public class TaskServiceImplIntExplicitTest { taskanaEngine.getClassificationService().createClassification(classification); Task task = taskServiceImpl.newTask(); - task.setWorkbasketId(workbasket.getId()); + task.setWorkbasketKey(workbasket.getKey()); task.setClassification(classification); return task; } @@ -507,7 +572,7 @@ public class TaskServiceImplIntExplicitTest { private void generateSampleAccessItems() { WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); accessItem.setId(IdGenerator.generateWithPrefix("WAI")); - accessItem.setWorkbasketId("1"); + accessItem.setWorkbasketKey("k1"); accessItem.setAccessId("Elena"); accessItem.setPermAppend(true); accessItem.setPermOpen(true); @@ -515,7 +580,7 @@ public class TaskServiceImplIntExplicitTest { WorkbasketAccessItem accessItem2 = new WorkbasketAccessItem(); accessItem2.setId(IdGenerator.generateWithPrefix("WAI")); - accessItem2.setWorkbasketId("2"); + accessItem2.setWorkbasketKey("k2"); accessItem2.setAccessId("DummyGroup"); accessItem2.setPermOpen(true); workbasketService.createWorkbasketAuthorization(accessItem2); @@ -525,7 +590,7 @@ public class TaskServiceImplIntExplicitTest { boolean permRead, boolean permAppend, boolean permTransfer) { WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); accessItem.setId(IdGenerator.generateWithPrefix("WAI")); - accessItem.setWorkbasketId(wb.getId()); + accessItem.setWorkbasketKey(wb.getKey()); accessItem.setAccessId(accessId); accessItem.setPermOpen(permOpen); accessItem.setPermRead(permRead); diff --git a/lib/taskana-core/src/test/java/pro/taskana/impl/integration/WorkbasketServiceImplIntAutocommitTest.java b/lib/taskana-core/src/test/java/pro/taskana/impl/integration/WorkbasketServiceImplIntAutocommitTest.java index ea474ed76..dc91bc12b 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/impl/integration/WorkbasketServiceImplIntAutocommitTest.java +++ b/lib/taskana-core/src/test/java/pro/taskana/impl/integration/WorkbasketServiceImplIntAutocommitTest.java @@ -1,5 +1,7 @@ package pro.taskana.impl.integration; +import static org.junit.Assert.assertTrue; + import java.io.FileNotFoundException; import java.security.Principal; import java.security.PrivilegedActionException; @@ -14,6 +16,7 @@ import javax.security.auth.Subject; import javax.security.auth.login.LoginException; import javax.sql.DataSource; +import org.apache.ibatis.session.SqlSession; import org.h2.store.fs.FileUtils; import org.junit.AfterClass; import org.junit.Assert; @@ -29,40 +32,56 @@ import pro.taskana.WorkbasketService; import pro.taskana.configuration.TaskanaEngineConfiguration; import pro.taskana.exceptions.ClassificationNotFoundException; import pro.taskana.exceptions.InvalidArgumentException; +import pro.taskana.exceptions.InvalidWorkbasketException; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.TaskNotFoundException; import pro.taskana.exceptions.WorkbasketNotFoundException; import pro.taskana.impl.TaskanaEngineImpl; +import pro.taskana.impl.TaskanaEngineProxyForTest; import pro.taskana.impl.WorkbasketImpl; import pro.taskana.impl.configuration.DBCleaner; import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest; import pro.taskana.impl.util.IdGenerator; import pro.taskana.model.WorkbasketAccessItem; import pro.taskana.model.WorkbasketAuthorization; +import pro.taskana.model.WorkbasketType; +import pro.taskana.model.mappings.WorkbasketMapper; import pro.taskana.security.GroupPrincipal; import pro.taskana.security.UserPrincipal; - /** * Integration Test for workbasketServiceImpl with connection management mode AUTOCOMMIT. + * * @author EH */ public class WorkbasketServiceImplIntAutocommitTest { private static final int SLEEP_TIME = 100; + private static final int THREE = 3; - private static final int DIFF1 = 200000; - private static final int DIFF2 = 400000; + private static final long ONE_DAY = 24 * 3600 * 1000; + + private static final long TEN_DAYS = 10 * ONE_DAY; + + private static final long FIFTEEN_DAYS = 15 * ONE_DAY; + + private static final long TWENTY_DAYS = 2 * TEN_DAYS; static int counter = 0; private DataSource dataSource; + private TaskanaEngineConfiguration taskanaEngineConfiguration; + private TaskanaEngine taskanaEngine; + private TaskanaEngineImpl taskanaEngineImpl; + private WorkbasketService workBasketService; + private Date workBasketsCreated; + @BeforeClass public static void resetDb() throws SQLException { DataSource ds = TaskanaEngineConfigurationTest.getDataSource(); @@ -83,77 +102,113 @@ public class WorkbasketServiceImplIntAutocommitTest { } @Test - public void testInsertWorkbasket() throws NotAuthorizedException { + public void testInsertWorkbasket() + throws NotAuthorizedException, InvalidWorkbasketException, WorkbasketNotFoundException { int before = workBasketService.getWorkbaskets().size(); WorkbasketImpl workbasket = (WorkbasketImpl) workBasketService.newWorkbasket(); String id1 = IdGenerator.generateWithPrefix("TWB"); workbasket.setId(id1); + workbasket.setKey("key"); workbasket.setName("Megabasket"); + workbasket.setType(WorkbasketType.GROUP); + workbasket.setDomain("novatec"); workBasketService.createWorkbasket(workbasket); Assert.assertEquals(before + 1, workBasketService.getWorkbaskets().size()); } @Test - public void testSelectAllWorkbaskets() throws NotAuthorizedException { + public void testSelectAllWorkbaskets() + throws NotAuthorizedException, InvalidWorkbasketException, WorkbasketNotFoundException { int before = workBasketService.getWorkbaskets().size(); WorkbasketImpl workbasket0 = (WorkbasketImpl) workBasketService.newWorkbasket(); String id0 = IdGenerator.generateWithPrefix("TWB"); workbasket0.setId(id0); + workbasket0.setKey("key0"); workbasket0.setName("Superbasket"); + workbasket0.setType(WorkbasketType.PERSONAL); + workbasket0.setDomain("novatec"); workBasketService.createWorkbasket(workbasket0); WorkbasketImpl workbasket1 = (WorkbasketImpl) workBasketService.newWorkbasket(); String id1 = IdGenerator.generateWithPrefix("TWB"); workbasket1.setId(id1); + workbasket1.setKey("key1"); workbasket1.setName("Megabasket"); + workbasket1.setType(WorkbasketType.GROUP); + workbasket1.setDomain("novatec"); workBasketService.createWorkbasket(workbasket1); WorkbasketImpl workbasket2 = (WorkbasketImpl) workBasketService.newWorkbasket(); String id2 = IdGenerator.generateWithPrefix("TWB"); workbasket2.setId(id2); + workbasket2.setKey("key2"); workbasket2.setName("Hyperbasket"); + workbasket2.setType(WorkbasketType.GROUP); + workbasket2.setDomain("novatec"); workBasketService.createWorkbasket(workbasket2); Assert.assertEquals(before + THREE, workBasketService.getWorkbaskets().size()); } @Test - public void testSelectWorkbasket() throws WorkbasketNotFoundException, NotAuthorizedException { + public void testSelectWorkbasket() + throws WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException { WorkbasketImpl workbasket0 = (WorkbasketImpl) workBasketService.newWorkbasket(); String id0 = IdGenerator.generateWithPrefix("TWB"); workbasket0.setId(id0); + workbasket0.setKey("key0"); workbasket0.setName("Superbasket"); + workbasket0.setType(WorkbasketType.GROUP); + workbasket0.setDomain("novatec"); workBasketService.createWorkbasket(workbasket0); WorkbasketImpl workbasket1 = (WorkbasketImpl) workBasketService.newWorkbasket(); String id1 = IdGenerator.generateWithPrefix("TWB"); workbasket1.setId(id1); + workbasket1.setKey("key1"); workbasket1.setName("Megabasket"); + workbasket1.setType(WorkbasketType.GROUP); + workbasket1.setDomain("novatec"); workBasketService.createWorkbasket(workbasket1); WorkbasketImpl workbasket2 = (WorkbasketImpl) workBasketService.newWorkbasket(); String id2 = IdGenerator.generateWithPrefix("TWB"); workbasket2.setId(id2); + workbasket2.setKey("key2"); workbasket2.setName("Hyperbasket"); + workbasket2.setType(WorkbasketType.GROUP); + workbasket2.setDomain("novatec"); workBasketService.createWorkbasket(workbasket2); Workbasket foundWorkbasket = workBasketService.getWorkbasket(id2); Assert.assertEquals(id2, foundWorkbasket.getId()); } @Test(expected = WorkbasketNotFoundException.class) - public void testGetWorkbasketFail() throws WorkbasketNotFoundException { + public void testGetWorkbasketFail() throws WorkbasketNotFoundException, InvalidWorkbasketException { workBasketService.getWorkbasket("fail"); } @Test - public void testSelectWorkbasketWithDistribution() throws WorkbasketNotFoundException, NotAuthorizedException { + public void testSelectWorkbasketWithDistribution() + throws WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException { WorkbasketImpl workbasket0 = (WorkbasketImpl) workBasketService.newWorkbasket(); String id0 = IdGenerator.generateWithPrefix("TWB"); workbasket0.setId(id0); + workbasket0.setKey("key0"); workbasket0.setName("Superbasket"); WorkbasketImpl workbasket1 = (WorkbasketImpl) workBasketService.newWorkbasket(); + workbasket0.setType(WorkbasketType.GROUP); + workbasket0.setDomain("novatec"); + workBasketService.createWorkbasket(workbasket0); String id1 = IdGenerator.generateWithPrefix("TWB"); workbasket1.setId(id1); + workbasket1.setKey("key1"); workbasket1.setName("Megabasket"); WorkbasketImpl workbasket2 = (WorkbasketImpl) workBasketService.newWorkbasket(); + workbasket1.setType(WorkbasketType.GROUP); + workbasket1.setDomain("novatec"); + workBasketService.createWorkbasket(workbasket1); String id2 = IdGenerator.generateWithPrefix("TWB"); workbasket2.setId(id2); + workbasket2.setKey("key2"); workbasket2.setName("Hyperbasket"); + workbasket2.setType(WorkbasketType.GROUP); + workbasket2.setDomain("novatec"); workbasket2.setDistributionTargets(new ArrayList<>()); workbasket2.getDistributionTargets().add(workbasket0); workbasket2.getDistributionTargets().add(workbasket1); @@ -168,15 +223,26 @@ public class WorkbasketServiceImplIntAutocommitTest { WorkbasketImpl workbasket0 = (WorkbasketImpl) workBasketService.newWorkbasket(); String id0 = IdGenerator.generateWithPrefix("TWB"); workbasket0.setId(id0); + workbasket0.setKey("key0"); workbasket0.setName("Superbasket"); WorkbasketImpl workbasket1 = (WorkbasketImpl) workBasketService.newWorkbasket(); + workbasket0.setType(WorkbasketType.GROUP); + workbasket0.setDomain("novatec"); + workBasketService.createWorkbasket(workbasket0); String id1 = IdGenerator.generateWithPrefix("TWB"); workbasket1.setId(id1); + workbasket1.setKey("key1"); workbasket1.setName("Megabasket"); WorkbasketImpl workbasket2 = (WorkbasketImpl) workBasketService.newWorkbasket(); + workbasket1.setType(WorkbasketType.GROUP); + workbasket1.setDomain("novatec"); + workBasketService.createWorkbasket(workbasket1); String id2 = IdGenerator.generateWithPrefix("TWB"); workbasket2.setId(id2); + workbasket2.setKey("key2"); workbasket2.setName("Hyperbasket"); + workbasket2.setType(WorkbasketType.GROUP); + workbasket2.setDomain("novatec"); workbasket2.getDistributionTargets().add(workbasket0); workbasket2.getDistributionTargets().add(workbasket1); workBasketService.createWorkbasket(workbasket2); @@ -184,7 +250,11 @@ public class WorkbasketServiceImplIntAutocommitTest { WorkbasketImpl workbasket3 = (WorkbasketImpl) workBasketService.newWorkbasket(); String id3 = IdGenerator.generateWithPrefix("TWB"); workbasket3.setId(id3); + workbasket3.setKey("key3"); workbasket3.setName("hm ... irgend ein basket"); + workbasket3.setType(WorkbasketType.GROUP); + workbasket3.setDomain("novatec"); + workBasketService.createWorkbasket(workbasket3); workbasket2.getDistributionTargets().clear(); workbasket2.getDistributionTargets().add(workbasket3); Thread.sleep(SLEEP_TIME); @@ -196,18 +266,17 @@ public class WorkbasketServiceImplIntAutocommitTest { Assert.assertEquals(1, distributionTargets.size()); Assert.assertEquals(id3, distributionTargets.get(0).getId()); Assert.assertNotEquals(workBasketService.getWorkbasket(id2).getCreated(), - workBasketService.getWorkbasket(id2).getModified()); + workBasketService.getWorkbasket(id2).getModified()); Assert.assertEquals(workBasketService.getWorkbasket(id1).getCreated(), - workBasketService.getWorkbasket(id1).getModified()); + workBasketService.getWorkbasket(id1).getModified()); Assert.assertEquals(workBasketService.getWorkbasket(id3).getCreated(), - workBasketService.getWorkbasket(id3).getModified()); + workBasketService.getWorkbasket(id3).getModified()); } @Test public void testInsertWorkbasketAccessUser() throws NotAuthorizedException { WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); - String id1 = IdGenerator.generateWithPrefix("TWB"); - accessItem.setWorkbasketId(id1); + accessItem.setWorkbasketKey("k1"); accessItem.setAccessId("Arthur Dent"); accessItem.setPermOpen(true); accessItem.setPermRead(true); @@ -219,8 +288,7 @@ public class WorkbasketServiceImplIntAutocommitTest { @Test public void testUpdateWorkbasketAccessUser() throws NotAuthorizedException { WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); - String id1 = IdGenerator.generateWithPrefix("TWB"); - accessItem.setWorkbasketId(id1); + accessItem.setWorkbasketKey("k2"); accessItem.setAccessId("Arthur Dent"); accessItem.setPermOpen(true); accessItem.setPermRead(true); @@ -232,37 +300,88 @@ public class WorkbasketServiceImplIntAutocommitTest { workBasketService.updateWorkbasketAuthorization(accessItem); Assert.assertEquals("Zaphod Beeblebrox", - workBasketService.getWorkbasketAuthorization(accessItem.getId()).getAccessId()); + workBasketService.getWorkbasketAuthorization(accessItem.getId()).getAccessId()); } @Test - public void testWorkbasketQuery() throws NotAuthorizedException, InvalidArgumentException { + public void testWorkbasketQuery() + throws NotAuthorizedException, InvalidArgumentException, InvalidWorkbasketException, + WorkbasketNotFoundException { generateSampleDataForQuery(); - WorkbasketQuery query1 = workBasketService.createWorkbasketQuery().access(WorkbasketAuthorization.OPEN, "Bernd").name("Basket1"); + Date tomorrow = new Date(workBasketsCreated.getTime() + ONE_DAY); + Date yesterday = new Date(workBasketsCreated.getTime() - ONE_DAY); + Date tenDaysAgo = new Date(workBasketsCreated.getTime() - TEN_DAYS); + Date fifteenDaysAgo = new Date(workBasketsCreated.getTime() - FIFTEEN_DAYS); + Date twentyDaysAgo = new Date(workBasketsCreated.getTime() - TWENTY_DAYS); + Date thirtyDaysAgo = new Date(workBasketsCreated.getTime() - THREE * TEN_DAYS); + + WorkbasketQuery query1 = workBasketService.createWorkbasketQuery() + .access(WorkbasketAuthorization.OPEN, "Bernd") + .nameIn("Basket1"); List result1 = query1.list(); - int numDistTargets = 1 + 1 + 1; Assert.assertEquals(1, result1.size()); - Assert.assertEquals(numDistTargets, result1.get(0).getDistributionTargets().size()); + Assert.assertEquals(THREE, result1.get(0).getDistributionTargets().size()); - WorkbasketQuery query2 = workBasketService.createWorkbasketQuery().access(WorkbasketAuthorization.OPEN, "Bernd", "Konstantin"); + WorkbasketQuery query2 = workBasketService.createWorkbasketQuery().access(WorkbasketAuthorization.OPEN, "Bernd", + "Konstantin"); List result2 = query2.list(); Assert.assertEquals(1, result2.size()); - WorkbasketQuery query3 = workBasketService.createWorkbasketQuery().access(WorkbasketAuthorization.CUSTOM_5, "Bernd", "Konstantin"); + WorkbasketQuery query3 = workBasketService.createWorkbasketQuery().access(WorkbasketAuthorization.CUSTOM_5, + "Bernd", "Konstantin"); List result3 = query3.list(); Assert.assertEquals(0, result3.size()); - WorkbasketQuery query4 = workBasketService.createWorkbasketQuery().access(WorkbasketAuthorization.CUSTOM_1, "Bernd"); + WorkbasketQuery query4 = workBasketService.createWorkbasketQuery().access(WorkbasketAuthorization.CUSTOM_1, + "Bernd"); List result4 = query4.list(); Assert.assertEquals(0, result4.size()); + + WorkbasketQuery query0 = workBasketService.createWorkbasketQuery() + .createdBefore(tomorrow) + .createdAfter(yesterday) + .nameIn("Basket1", "Basket2", "Basket3"); + List result0 = query0.list(); + assertTrue(result0.size() == THREE); + for (Workbasket workbasket : result0) { + String name = workbasket.getName(); + assertTrue("Basket1".equals(name) || "Basket2".equals(name) || "Basket3".equals(name)); + } + + WorkbasketQuery query5 = workBasketService.createWorkbasketQuery() + .modifiedAfter(thirtyDaysAgo) + .modifiedBefore(tenDaysAgo); + List result5 = query5.list(); + assertTrue(result5.size() == 2); + for (Workbasket workbasket : result5) { + String name = workbasket.getName(); + assertTrue("Basket2".equals(name) || "Basket3".equals(name)); + } + + WorkbasketQuery query6 = workBasketService.createWorkbasketQuery() + .modifiedAfter(twentyDaysAgo) + .domainIn("novatec", "consulting"); + List result6 = query6.list(); + assertTrue(result6.size() == 1); + assertTrue("Basket2".equals(result6.get(0).getName())); + + WorkbasketQuery query7 = workBasketService.createWorkbasketQuery() + .typeIn(WorkbasketType.GROUP, WorkbasketType.CLEARANCE); + List result7 = query7.list(); + assertTrue(result7.size() == 2); + for (Workbasket workbasket : result7) { + String name = workbasket.getName(); + assertTrue("Basket2".equals(name) || "Basket3".equals(name)); + } + } - @Test - public void testGetWorkbasketsForCurrentUserAndPermission() throws NotAuthorizedException { + public void testGetWorkbasketsForCurrentUserAndPermission() + throws NotAuthorizedException, InvalidWorkbasketException, WorkbasketNotFoundException { generateSampleDataForQuery(); String userName = "eberhardt"; @@ -276,17 +395,17 @@ public class WorkbasketServiceImplIntAutocommitTest { Assert.assertTrue(2 == getWorkbasketsForPrincipalesAndPermissions(userName, groupNames, authorizations)); authorizations.add(WorkbasketAuthorization.CUSTOM_4); - Assert.assertTrue(0 == getWorkbasketsForPrincipalesAndPermissions(userName, groupNames, authorizations)); + Assert.assertTrue(0 == getWorkbasketsForPrincipalesAndPermissions(userName, groupNames, authorizations)); userName = "Holger"; authorizations = new ArrayList(); authorizations.add(WorkbasketAuthorization.APPEND); - Assert.assertTrue(1 == getWorkbasketsForPrincipalesAndPermissions(userName, groupNames, authorizations)); + Assert.assertTrue(1 == getWorkbasketsForPrincipalesAndPermissions(userName, groupNames, authorizations)); } private int getWorkbasketsForPrincipalesAndPermissions(String userName, String[] groupNames, - List authorizations) throws NotAuthorizedException { + List authorizations) throws NotAuthorizedException { Subject subject = new Subject(); List principalList = new ArrayList<>(); principalList.add(new UserPrincipal(userName)); @@ -298,7 +417,10 @@ public class WorkbasketServiceImplIntAutocommitTest { int result = -1; try { result = Subject.doAs(subject, new PrivilegedExceptionAction() { - public Integer run() throws TaskNotFoundException, FileNotFoundException, NotAuthorizedException, SQLException, WorkbasketNotFoundException, ClassificationNotFoundException { + + @Override + public Integer run() throws TaskNotFoundException, FileNotFoundException, NotAuthorizedException, + SQLException, WorkbasketNotFoundException, ClassificationNotFoundException { List wbsResult = workBasketService.getWorkbaskets(authorizations); return wbsResult.size(); } @@ -313,45 +435,55 @@ public class WorkbasketServiceImplIntAutocommitTest { return result; } - public void generateSampleDataForQuery() { - Date now = new Date(); + public void generateSampleDataForQuery() throws InvalidWorkbasketException, WorkbasketNotFoundException { + workBasketsCreated = new Date(); WorkbasketImpl basket2 = (WorkbasketImpl) workBasketService.newWorkbasket(); - basket2.setCreated(new Timestamp(now.getTime() - DIFF2)); basket2.setId("2"); + basket2.setKey("k2"); basket2.setName("Basket2"); basket2.setOwner("Eberhardt"); - workBasketService.createWorkbasket(basket2); + basket2.setType(WorkbasketType.GROUP); + basket2.setDomain("novatec"); + basket2 = (WorkbasketImpl) workBasketService.createWorkbasket(basket2); WorkbasketImpl basket3 = (WorkbasketImpl) workBasketService.newWorkbasket(); - basket3.setCreated(new Timestamp(now.getTime() - DIFF1)); basket3.setId("3"); + basket3.setKey("k3"); basket3.setName("Basket3"); basket3.setOwner("Konstantin"); - workBasketService.createWorkbasket(basket3); + basket3.setType(WorkbasketType.CLEARANCE); + basket3.setDomain("consulting"); + basket3 = (WorkbasketImpl) workBasketService.createWorkbasket(basket3); WorkbasketImpl basket4 = (WorkbasketImpl) workBasketService.newWorkbasket(); - basket4.setCreated(new Timestamp(now.getTime() - DIFF1)); basket4.setId("4"); + basket4.setKey("k4"); basket4.setName("Basket4"); basket4.setOwner("Holger"); - workBasketService.createWorkbasket(basket4); + basket4.setType(WorkbasketType.TOPIC); + basket4.setDomain("develop"); + basket4 = (WorkbasketImpl) workBasketService.createWorkbasket(basket4); WorkbasketImpl basket1 = (WorkbasketImpl) workBasketService.newWorkbasket(); - basket1.setCreated(new Timestamp(now.getTime() - DIFF1)); basket1.setId("1"); + basket1.setKey("k1"); basket1.setName("Basket1"); basket1.setOwner("Holger"); + basket1.setType(WorkbasketType.PERSONAL); + basket1.setDomain(""); List distTargets = new ArrayList(); distTargets.add(basket2); distTargets.add(basket3); distTargets.add(basket4); basket1.setDistributionTargets(distTargets); - workBasketService.createWorkbasket(basket1); + basket1 = (WorkbasketImpl) workBasketService.createWorkbasket(basket1); + + updateModifiedTimestamps(basket2, basket3, basket4, basket1); WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); accessItem.setId(IdGenerator.generateWithPrefix("WAI")); - accessItem.setWorkbasketId("1"); + accessItem.setWorkbasketKey("k1"); accessItem.setAccessId("Bernd"); accessItem.setPermOpen(true); accessItem.setPermRead(true); @@ -359,7 +491,7 @@ public class WorkbasketServiceImplIntAutocommitTest { WorkbasketAccessItem accessItem2 = new WorkbasketAccessItem(); accessItem2.setId(IdGenerator.generateWithPrefix("WAI")); - accessItem2.setWorkbasketId("2"); + accessItem2.setWorkbasketKey("k2"); accessItem2.setAccessId("Eberhardt"); accessItem2.setPermTransfer(true); accessItem2.setPermCustom1(true); @@ -367,7 +499,7 @@ public class WorkbasketServiceImplIntAutocommitTest { WorkbasketAccessItem accessItem3 = new WorkbasketAccessItem(); accessItem3.setId(IdGenerator.generateWithPrefix("WAI")); - accessItem3.setWorkbasketId("3"); + accessItem3.setWorkbasketKey("k3"); accessItem3.setAccessId("group2"); accessItem3.setPermCustom4(true); accessItem3.setPermCustom1(true); @@ -375,7 +507,7 @@ public class WorkbasketServiceImplIntAutocommitTest { WorkbasketAccessItem accessItem4 = new WorkbasketAccessItem(); accessItem4.setId(IdGenerator.generateWithPrefix("WAI")); - accessItem4.setWorkbasketId("1"); + accessItem4.setWorkbasketKey("k4"); accessItem4.setAccessId("group3"); accessItem4.setPermOpen(true); accessItem4.setPermRead(true); @@ -384,6 +516,31 @@ public class WorkbasketServiceImplIntAutocommitTest { } + private void updateModifiedTimestamps(Workbasket basket2, Workbasket basket3, Workbasket basket4, + Workbasket basket1) { + // created and modified timestamps are set by WorkbasketServiceImpl to 'now' when the workbasket is created + // in order to create timestamps distict from the current time, we must use the mapper directly to bypass + // WorkbasketServiceImpl + TaskanaEngineProxyForTest engineProxy = new TaskanaEngineProxyForTest(taskanaEngineImpl); + SqlSession session = engineProxy.getSqlSession(); + WorkbasketMapper mapper = session.getMapper(WorkbasketMapper.class); + + WorkbasketImpl wb1 = (WorkbasketImpl) basket1; + WorkbasketImpl wb2 = (WorkbasketImpl) basket2; + WorkbasketImpl wb3 = (WorkbasketImpl) basket3; + WorkbasketImpl wb4 = (WorkbasketImpl) basket4; + engineProxy.openConnection(); + wb1.setModified(new Timestamp(workBasketsCreated.getTime() - TEN_DAYS)); + mapper.update(wb1); + wb2.setModified(new Timestamp(workBasketsCreated.getTime() - FIFTEEN_DAYS)); + mapper.update(wb2); + wb3.setModified(new Timestamp(workBasketsCreated.getTime() - TWENTY_DAYS)); + mapper.update(wb3); + wb4.setModified(new Timestamp(workBasketsCreated.getTime() - (2 * FIFTEEN_DAYS))); + mapper.update(wb4); + engineProxy.returnConnection(); + } + @AfterClass public static void cleanUpClass() { FileUtils.deleteRecursive("~/data", true); diff --git a/lib/taskana-core/src/test/java/pro/taskana/impl/integration/WorkbasketServiceImplIntExplicitTest.java b/lib/taskana-core/src/test/java/pro/taskana/impl/integration/WorkbasketServiceImplIntExplicitTest.java index c3bf6e04a..17e0a5105 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/impl/integration/WorkbasketServiceImplIntExplicitTest.java +++ b/lib/taskana-core/src/test/java/pro/taskana/impl/integration/WorkbasketServiceImplIntExplicitTest.java @@ -22,30 +22,38 @@ import pro.taskana.TaskanaEngine.ConnectionManagementMode; import pro.taskana.Workbasket; import pro.taskana.WorkbasketService; import pro.taskana.configuration.TaskanaEngineConfiguration; +import pro.taskana.exceptions.InvalidWorkbasketException; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.WorkbasketNotFoundException; import pro.taskana.impl.TaskanaEngineImpl; +import pro.taskana.impl.WorkbasketImpl; import pro.taskana.impl.configuration.DBCleaner; import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest; import pro.taskana.impl.util.IdGenerator; import pro.taskana.model.WorkbasketAccessItem; +import pro.taskana.model.WorkbasketType; /** * Integration Test for workbasketServiceImpl with connection mode EXPLICIT. - * @author bbr * + * @author bbr */ public class WorkbasketServiceImplIntExplicitTest { private static final int SLEEP_TIME = 100; + private static final int THREE = 3; static int counter = 0; private DataSource dataSource; + private TaskanaEngineConfiguration taskanaEngineConfiguration; + private TaskanaEngine taskanaEngine; + private TaskanaEngineImpl taskanaEngineImpl; + private WorkbasketService workBasketService; @BeforeClass @@ -67,53 +75,90 @@ public class WorkbasketServiceImplIntExplicitTest { } @Test - public void testInsertWorkbasket() throws NotAuthorizedException, SQLException { + public void testInsertWorkbasket() + throws NotAuthorizedException, SQLException, InvalidWorkbasketException, WorkbasketNotFoundException { Connection connection = dataSource.getConnection(); taskanaEngineImpl.setConnection(connection); workBasketService = taskanaEngine.getWorkbasketService(); int before = workBasketService.getWorkbaskets().size(); - Workbasket workbasket = workBasketService.newWorkbasket(); + WorkbasketImpl workbasket = (WorkbasketImpl) workBasketService.newWorkbasket(); + String id1 = IdGenerator.generateWithPrefix("TWB"); + workbasket.setId(id1); + workbasket.setKey("key"); workbasket.setName("Megabasket"); - workbasket = workBasketService.createWorkbasket(workbasket); + workbasket.setType(WorkbasketType.GROUP); + workbasket.setDomain("novatec"); + workBasketService.createWorkbasket(workbasket); Assert.assertEquals(before + 1, workBasketService.getWorkbaskets().size()); taskanaEngineImpl.closeConnection(); } @Test - public void testSelectAllWorkbaskets() throws NotAuthorizedException, SQLException { + public void testSelectAllWorkbaskets() + throws NotAuthorizedException, SQLException, InvalidWorkbasketException, WorkbasketNotFoundException { Connection connection = dataSource.getConnection(); taskanaEngineImpl.setConnection(connection); workBasketService = taskanaEngine.getWorkbasketService(); int before = workBasketService.getWorkbaskets().size(); - Workbasket workbasket0 = workBasketService.newWorkbasket(); + WorkbasketImpl workbasket0 = (WorkbasketImpl) workBasketService.newWorkbasket(); + String id0 = IdGenerator.generateWithPrefix("TWB"); + workbasket0.setId(id0); + workbasket0.setKey("key0"); workbasket0.setName("Superbasket"); - workbasket0 = workBasketService.createWorkbasket(workbasket0); - Workbasket workbasket1 = workBasketService.newWorkbasket(); + workbasket0.setType(WorkbasketType.GROUP); + workbasket0.setDomain("novatec"); + workBasketService.createWorkbasket(workbasket0); + WorkbasketImpl workbasket1 = (WorkbasketImpl) workBasketService.newWorkbasket(); + String id1 = IdGenerator.generateWithPrefix("TWB"); + workbasket1.setId(id1); + workbasket1.setKey("key1"); workbasket1.setName("Megabasket"); - workbasket1 = workBasketService.createWorkbasket(workbasket1); - Workbasket workbasket2 = workBasketService.newWorkbasket(); + workbasket1.setType(WorkbasketType.GROUP); + workbasket1.setDomain("novatec"); + workbasket1 = (WorkbasketImpl) workBasketService.createWorkbasket(workbasket1); + WorkbasketImpl workbasket2 = (WorkbasketImpl) workBasketService.newWorkbasket(); + String id2 = IdGenerator.generateWithPrefix("TWB"); + workbasket2.setId(id2); + workbasket2.setKey("key2"); workbasket2.setName("Hyperbasket"); - workbasket2 = workBasketService.createWorkbasket(workbasket2); + workbasket2.setType(WorkbasketType.GROUP); + workbasket2.setDomain("novatec"); + workBasketService.createWorkbasket(workbasket2); Assert.assertEquals(before + THREE, workBasketService.getWorkbaskets().size()); connection.commit(); taskanaEngineImpl.closeConnection(); } @Test - public void testSelectWorkbasket() throws WorkbasketNotFoundException, NotAuthorizedException, SQLException { + public void testSelectWorkbasket() + throws WorkbasketNotFoundException, NotAuthorizedException, SQLException, InvalidWorkbasketException { Connection connection = dataSource.getConnection(); taskanaEngineImpl.setConnection(connection); workBasketService = taskanaEngine.getWorkbasketService(); - Workbasket workbasket0 = workBasketService.newWorkbasket(); + WorkbasketImpl workbasket0 = (WorkbasketImpl) workBasketService.newWorkbasket(); + String id0 = IdGenerator.generateWithPrefix("TWB"); + workbasket0.setId(id0); + workbasket0.setKey("key0"); workbasket0.setName("Superbasket"); - workbasket0 = workBasketService.createWorkbasket(workbasket0); - Workbasket workbasket1 = workBasketService.newWorkbasket(); + workbasket0.setType(WorkbasketType.GROUP); + workbasket0.setDomain("novatec"); + workbasket0 = (WorkbasketImpl) workBasketService.createWorkbasket(workbasket0); + WorkbasketImpl workbasket1 = (WorkbasketImpl) workBasketService.newWorkbasket(); + String id1 = IdGenerator.generateWithPrefix("TWB"); + workbasket1.setId(id1); + workbasket1.setKey("key1"); workbasket1.setName("Megabasket"); - workbasket1 = workBasketService.createWorkbasket(workbasket1); - Workbasket workbasket2 = workBasketService.newWorkbasket(); + workbasket1.setType(WorkbasketType.GROUP); + workbasket1.setDomain("novatec"); + workbasket1 = (WorkbasketImpl) workBasketService.createWorkbasket(workbasket1); + WorkbasketImpl workbasket2 = (WorkbasketImpl) workBasketService.newWorkbasket(); + String id2 = IdGenerator.generateWithPrefix("TWB"); + workbasket2.setId(id2); + workbasket2.setKey("key2"); workbasket2.setName("Hyperbasket"); - workbasket2 = workBasketService.createWorkbasket(workbasket2); - String id2 = workbasket2.getId(); + workbasket2.setType(WorkbasketType.GROUP); + workbasket2.setDomain("novatec"); + workbasket2 = (WorkbasketImpl) workBasketService.createWorkbasket(workbasket2); Workbasket foundWorkbasket = workBasketService.getWorkbasket(id2); Assert.assertEquals(id2, foundWorkbasket.getId()); connection.commit(); @@ -121,7 +166,7 @@ public class WorkbasketServiceImplIntExplicitTest { } @Test(expected = WorkbasketNotFoundException.class) - public void testGetWorkbasketFail() throws WorkbasketNotFoundException, SQLException { + public void testGetWorkbasketFail() throws WorkbasketNotFoundException, SQLException, InvalidWorkbasketException { Connection connection = dataSource.getConnection(); taskanaEngineImpl.setConnection(connection); workBasketService = taskanaEngine.getWorkbasketService(); @@ -131,23 +176,40 @@ public class WorkbasketServiceImplIntExplicitTest { } @Test - public void testSelectWorkbasketWithDistribution() throws WorkbasketNotFoundException, NotAuthorizedException, SQLException { + public void testSelectWorkbasketWithDistribution() + throws WorkbasketNotFoundException, NotAuthorizedException, SQLException, InvalidWorkbasketException { Connection connection = dataSource.getConnection(); taskanaEngineImpl.setConnection(connection); workBasketService = taskanaEngine.getWorkbasketService(); - Workbasket workbasket0 = workBasketService.newWorkbasket(); + WorkbasketImpl workbasket0 = (WorkbasketImpl) workBasketService.newWorkbasket(); + String id0 = IdGenerator.generateWithPrefix("TWB"); + workbasket0.setId(id0); + workbasket0.setKey("key0"); workbasket0.setName("Superbasket"); - workbasket0 = workBasketService.createWorkbasket(workbasket0); - Workbasket workbasket1 = workBasketService.newWorkbasket(); + workbasket0.setType(WorkbasketType.GROUP); + workbasket0.setDomain("novatec"); + workbasket0 = (WorkbasketImpl) workBasketService.createWorkbasket(workbasket0); + WorkbasketImpl workbasket1 = (WorkbasketImpl) workBasketService.newWorkbasket(); + String id1 = IdGenerator.generateWithPrefix("TWB"); + workbasket1.setId(id1); + workbasket1.setKey("key1"); workbasket1.setName("Megabasket"); - workbasket1 = workBasketService.createWorkbasket(workbasket1); - Workbasket workbasket2 = workBasketService.newWorkbasket(); + workbasket1.setDomain("D2"); + workbasket1.setType(WorkbasketType.GROUP); + workBasketService.createWorkbasket(workbasket1); + WorkbasketImpl workbasket2 = (WorkbasketImpl) workBasketService.newWorkbasket(); + workbasket1.setType(WorkbasketType.GROUP); + workbasket1.setDomain("novatec"); + String id2 = IdGenerator.generateWithPrefix("TWB"); + workbasket2.setId(id2); + workbasket2.setKey("key2"); workbasket2.setName("Hyperbasket"); + workbasket2.setType(WorkbasketType.GROUP); + workbasket2.setDomain("novatec"); workbasket2.setDistributionTargets(new ArrayList<>()); workbasket2.getDistributionTargets().add(workbasket0); workbasket2.getDistributionTargets().add(workbasket1); - workbasket2 = workBasketService.createWorkbasket(workbasket2); - String id2 = workbasket2.getId(); + workBasketService.createWorkbasket(workbasket2); Workbasket foundWorkbasket = workBasketService.getWorkbasket(id2); Assert.assertEquals(id2, foundWorkbasket.getId()); Assert.assertEquals(2, foundWorkbasket.getDistributionTargets().size()); @@ -159,40 +221,56 @@ public class WorkbasketServiceImplIntExplicitTest { Connection connection = dataSource.getConnection(); taskanaEngineImpl.setConnection(connection); workBasketService = taskanaEngine.getWorkbasketService(); - Workbasket workbasket0 = workBasketService.newWorkbasket(); + WorkbasketImpl workbasket0 = (WorkbasketImpl) workBasketService.newWorkbasket(); + String id0 = IdGenerator.generateWithPrefix("TWB"); + workbasket0.setId(id0); + workbasket0.setKey("key0"); workbasket0.setName("Superbasket"); - workbasket0 = workBasketService.createWorkbasket(workbasket0); - Workbasket workbasket1 = workBasketService.newWorkbasket(); + workbasket0.setType(WorkbasketType.GROUP); + workbasket0.setDomain("novatec"); + + workBasketService.createWorkbasket(workbasket0); + WorkbasketImpl workbasket1 = (WorkbasketImpl) workBasketService.newWorkbasket(); + workbasket0.setType(WorkbasketType.GROUP); + workbasket0.setDomain("novatec"); + String id1 = IdGenerator.generateWithPrefix("TWB"); + workbasket1.setId(id1); + workbasket1.setKey("key1"); workbasket1.setName("Megabasket"); - workbasket1 = workBasketService.createWorkbasket(workbasket1); - String id1 = workbasket1.getId(); - Workbasket workbasket2 = workBasketService.newWorkbasket(); + workbasket1.setType(WorkbasketType.GROUP); + workbasket1.setDomain("novatec"); + workBasketService.createWorkbasket(workbasket1); + WorkbasketImpl workbasket2 = (WorkbasketImpl) workBasketService.newWorkbasket(); + String id2 = IdGenerator.generateWithPrefix("TWB"); + workbasket2.setId(id2); + workbasket2.setKey("key2"); workbasket2.setName("Hyperbasket"); workbasket2.setDistributionTargets(new ArrayList<>()); + workbasket2.setType(WorkbasketType.GROUP); + workbasket2.setDomain("novatec"); workbasket2.getDistributionTargets().add(workbasket0); workbasket2.getDistributionTargets().add(workbasket1); - workbasket2 = workBasketService.createWorkbasket(workbasket2); - String id2 = workbasket2.getId(); + workBasketService.createWorkbasket(workbasket2); Workbasket workbasket3 = workBasketService.newWorkbasket(); + workbasket3.setKey("key3"); workbasket3.setName("hm ... irgend ein basket"); + workbasket3.setType(WorkbasketType.GROUP); + workbasket3.setDomain("novatec"); workbasket3 = workBasketService.createWorkbasket(workbasket3); - String id3 = workbasket3.getId(); workbasket2.getDistributionTargets().clear(); workbasket2.getDistributionTargets().add(workbasket3); Thread.sleep(SLEEP_TIME); - workbasket2 = workBasketService.updateWorkbasket(workbasket2); + workBasketService.updateWorkbasket(workbasket2); Workbasket foundBasket = workBasketService.getWorkbasket(workbasket2.getId()); List distributionTargets = foundBasket.getDistributionTargets(); Assert.assertEquals(1, distributionTargets.size()); - Assert.assertEquals(id3, distributionTargets.get(0).getId()); + Assert.assertEquals(workbasket3.getId(), distributionTargets.get(0).getId()); Assert.assertNotEquals(workBasketService.getWorkbasket(id2).getCreated(), - workBasketService.getWorkbasket(id2).getModified()); + workBasketService.getWorkbasket(id2).getModified()); Assert.assertEquals(workBasketService.getWorkbasket(id1).getCreated(), - workBasketService.getWorkbasket(id1).getModified()); - Assert.assertEquals(workBasketService.getWorkbasket(id3).getCreated(), - workBasketService.getWorkbasket(id3).getModified()); + workBasketService.getWorkbasket(id1).getModified()); connection.commit(); } @@ -202,8 +280,7 @@ public class WorkbasketServiceImplIntExplicitTest { taskanaEngineImpl.setConnection(connection); workBasketService = taskanaEngine.getWorkbasketService(); WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); - String id1 = IdGenerator.generateWithPrefix("TWB"); - accessItem.setWorkbasketId(id1); + accessItem.setWorkbasketKey("Key1"); accessItem.setAccessId("Arthur Dent"); accessItem.setPermOpen(true); accessItem.setPermRead(true); @@ -219,8 +296,7 @@ public class WorkbasketServiceImplIntExplicitTest { taskanaEngineImpl.setConnection(connection); workBasketService = taskanaEngine.getWorkbasketService(); WorkbasketAccessItem accessItem = new WorkbasketAccessItem(); - String id1 = IdGenerator.generateWithPrefix("TWB"); - accessItem.setWorkbasketId(id1); + accessItem.setWorkbasketKey("key2"); accessItem.setAccessId("Arthur Dent"); accessItem.setPermOpen(true); accessItem.setPermRead(true); @@ -232,9 +308,9 @@ public class WorkbasketServiceImplIntExplicitTest { workBasketService.updateWorkbasketAuthorization(accessItem); Assert.assertEquals("Zaphod Beeblebrox", - workBasketService.getWorkbasketAuthorization(accessItem.getId()).getAccessId()); + workBasketService.getWorkbasketAuthorization(accessItem.getId()).getAccessId()); connection.commit(); - } + } @After public void cleanUp() { diff --git a/lib/taskana-core/src/test/java/pro/taskana/security/JAASRunner.java b/lib/taskana-core/src/test/java/pro/taskana/security/JAASRunner.java index 76f7b5cf7..e20d61733 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/security/JAASRunner.java +++ b/lib/taskana-core/src/test/java/pro/taskana/security/JAASRunner.java @@ -13,7 +13,6 @@ import org.junit.runners.model.FrameworkMethod; import org.junit.runners.model.InitializationError; import org.junit.runners.model.Statement; - /** * Runner for integration tests that enables JAAS subject. */ @@ -30,7 +29,7 @@ public class JAASRunner extends BlockJUnit4ClassRunner { List principalList = new ArrayList<>(); if (test != null) { - WithAccessId withAccessId = method.getMethod().getAnnotation(WithAccessId.class); + WithAccessId withAccessId = method.getMethod().getAnnotation(WithAccessId.class); if (withAccessId != null) { if (withAccessId.userName() != null) { principalList.add(new UserPrincipal(withAccessId.userName())); @@ -51,13 +50,18 @@ public class JAASRunner extends BlockJUnit4ClassRunner { public void evaluate() throws Throwable { try { Subject.doAs(subject, new PrivilegedExceptionAction() { + @Override public Object run() throws Exception { try { base.evaluate(); } catch (Throwable e) { - throw (Exception) e; + if (e instanceof Exception) { + throw (Exception) e; + } else { + throw new Exception(e); + } } return null; } diff --git a/lib/taskana-spring-example/src/main/java/pro/taskana/ExampleBootstrap.java b/lib/taskana-spring-example/src/main/java/pro/taskana/ExampleBootstrap.java index b8f1eccdb..4f478a472 100644 --- a/lib/taskana-spring-example/src/main/java/pro/taskana/ExampleBootstrap.java +++ b/lib/taskana-spring-example/src/main/java/pro/taskana/ExampleBootstrap.java @@ -9,6 +9,7 @@ import org.springframework.transaction.annotation.Transactional; import pro.taskana.exceptions.ClassificationNotFoundException; import pro.taskana.exceptions.InvalidOwnerException; import pro.taskana.exceptions.InvalidStateException; +import pro.taskana.exceptions.InvalidWorkbasketException; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.TaskAlreadyExistException; import pro.taskana.exceptions.TaskNotFoundException; @@ -23,11 +24,12 @@ public class ExampleBootstrap { @PostConstruct public void test() throws TaskNotFoundException, NotAuthorizedException, WorkbasketNotFoundException, - ClassificationNotFoundException, InvalidStateException, InvalidOwnerException, TaskAlreadyExistException { + ClassificationNotFoundException, InvalidStateException, InvalidOwnerException, InvalidWorkbasketException, + TaskAlreadyExistException { System.out.println("---------------------------> Start App"); Task task = taskService.newTask(); task.setName("Spring example task"); - task.setWorkbasketId("1"); + task.setWorkbasketKey("1"); task = taskService.createTask(task); System.out.println("---------------------------> Task started: " + task.getId()); taskService.claim(task.getId()); diff --git a/lib/taskana-spring/src/test/java/pro/taskana/TaskanaComponent.java b/lib/taskana-spring/src/test/java/pro/taskana/TaskanaComponent.java index 1c87c7bb9..e0d596eae 100644 --- a/lib/taskana-spring/src/test/java/pro/taskana/TaskanaComponent.java +++ b/lib/taskana-spring/src/test/java/pro/taskana/TaskanaComponent.java @@ -5,6 +5,7 @@ import org.springframework.stereotype.Component; import org.springframework.transaction.annotation.Transactional; import pro.taskana.exceptions.ClassificationNotFoundException; +import pro.taskana.exceptions.InvalidWorkbasketException; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.TaskAlreadyExistException; import pro.taskana.exceptions.WorkbasketNotFoundException; @@ -21,11 +22,12 @@ public class TaskanaComponent { } public void triggerRollback() throws NotAuthorizedException, WorkbasketNotFoundException, - ClassificationNotFoundException, TaskAlreadyExistException { + ClassificationNotFoundException, InvalidWorkbasketException, TaskAlreadyExistException { Task task = taskService.newTask(); task.setName("Unit Test Task"); - task.setWorkbasketId("1"); + task.setWorkbasketKey("1"); task = taskService.createTask(task); throw new RuntimeException(); } + } diff --git a/rest/src/main/java/pro/taskana/rest/TaskController.java b/rest/src/main/java/pro/taskana/rest/TaskController.java index 5e3e3a54e..070240a6b 100644 --- a/rest/src/main/java/pro/taskana/rest/TaskController.java +++ b/rest/src/main/java/pro/taskana/rest/TaskController.java @@ -31,7 +31,7 @@ import pro.taskana.model.TaskSummary; import pro.taskana.rest.query.TaskFilter; @RestController -@RequestMapping(path = "/v1/tasks", produces = { MediaType.APPLICATION_JSON_VALUE }) +@RequestMapping(path = "/v1/tasks", produces = {MediaType.APPLICATION_JSON_VALUE}) public class TaskController { private static final Logger logger = LoggerFactory.getLogger(TaskController.class); @@ -44,7 +44,7 @@ public class TaskController { @RequestMapping public ResponseEntity> getTasks(@RequestParam MultiValueMap params) - throws LoginException { + throws LoginException { try { if (params.keySet().size() == 0) { // get all @@ -68,11 +68,12 @@ public class TaskController { } } - @RequestMapping(value = "/workbasket/{workbasketId}/state/{taskState}") + @RequestMapping(value = "/workbasket/{workbasketKey}/state/{taskState}") public ResponseEntity> getTasksByWorkbasketIdAndState( - @PathVariable(value = "workbasketId") String workbasketId, @PathVariable(value = "taskState") TaskState taskState) { + @PathVariable(value = "workbasketKey") String workbasketKey, + @PathVariable(value = "taskState") TaskState taskState) { try { - List taskList = taskService.getTasksByWorkbasketIdAndState(workbasketId, taskState); + List taskList = taskService.getTasksByWorkbasketKeyAndState(workbasketKey, taskState); return ResponseEntity.status(HttpStatus.OK).body(taskList); } catch (WorkbasketNotFoundException e) { return ResponseEntity.status(HttpStatus.NOT_FOUND).build(); @@ -99,7 +100,7 @@ public class TaskController { } catch (InvalidOwnerException e) { logger.error("The given Task could not be claimed. Reason: {}", e); return ResponseEntity.status(HttpStatus.CONFLICT).build(); - } + } } @RequestMapping(method = RequestMethod.POST, value = "/{taskId}/complete") @@ -110,7 +111,7 @@ public class TaskController { return ResponseEntity.status(HttpStatus.OK).body(updatedTask); } catch (TaskNotFoundException e) { return ResponseEntity.status(HttpStatus.NOT_FOUND).build(); - } catch(InvalidStateException | InvalidOwnerException e) { + } catch (InvalidStateException | InvalidOwnerException e) { return ResponseEntity.status(HttpStatus.PRECONDITION_FAILED).build(); } } @@ -137,13 +138,14 @@ public class TaskController { } } - @RequestMapping(value = "/workbasket/{workbasketId}", method = RequestMethod.GET) - public ResponseEntity> getTasksummariesByWorkbasketId(@PathVariable(value="workbasketId") String workbasketId) { + @RequestMapping(value = "/workbasket/{workbasketKey}", method = RequestMethod.GET) + public ResponseEntity> getTasksummariesByWorkbasketId( + @PathVariable(value = "workbasketKey") String workbasketKey) { List taskSummaries = null; try { - taskSummaries = taskService.getTaskSummariesByWorkbasketId(workbasketId); + taskSummaries = taskService.getTaskSummariesByWorkbasketKey(workbasketKey); return ResponseEntity.status(HttpStatus.OK).body(taskSummaries); - } catch(Exception ex) { + } catch (Exception ex) { if (taskSummaries == null) { taskSummaries = Collections.emptyList(); } diff --git a/rest/src/main/java/pro/taskana/rest/WorkbasketController.java b/rest/src/main/java/pro/taskana/rest/WorkbasketController.java index f794e66e8..a6519ed93 100644 --- a/rest/src/main/java/pro/taskana/rest/WorkbasketController.java +++ b/rest/src/main/java/pro/taskana/rest/WorkbasketController.java @@ -19,96 +19,110 @@ import org.springframework.web.bind.annotation.RestController; import pro.taskana.Workbasket; import pro.taskana.WorkbasketService; +import pro.taskana.exceptions.InvalidWorkbasketException; import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.WorkbasketNotFoundException; import pro.taskana.model.WorkbasketAccessItem; import pro.taskana.model.WorkbasketAuthorization; @RestController -@RequestMapping(path = "/v1/workbaskets", produces = { MediaType.APPLICATION_JSON_VALUE }) +@RequestMapping(path = "/v1/workbaskets", produces = {MediaType.APPLICATION_JSON_VALUE}) public class WorkbasketController { - @Autowired - private WorkbasketService workbasketService; - - @GetMapping - public List getWorkbaskets(@RequestParam MultiValueMap params) { - if (params.containsKey("requiredPermission")) { - List authorizations = new ArrayList<>(); - params.get("requiredPermission").stream().forEach(item -> { - for (String authorization : Arrays.asList(item.split(","))) { - switch (authorization) { - case "READ": - authorizations.add(WorkbasketAuthorization.READ); - break; - case "OPEN": - authorizations.add(WorkbasketAuthorization.OPEN); - break; - case "APPEND": - authorizations.add(WorkbasketAuthorization.APPEND); - break; - case "TRANSFER": - authorizations.add(WorkbasketAuthorization.TRANSFER); - break; - case "DISTRIBUTE": - authorizations.add(WorkbasketAuthorization.DISTRIBUTE); - break; - } - } - }); - return workbasketService.getWorkbaskets(authorizations); - } else { - return workbasketService.getWorkbaskets(); - } - } + @Autowired + private WorkbasketService workbasketService; - @RequestMapping(value = "/{workbasketid}") - public ResponseEntity getWorkbasketById(@PathVariable(value = "workbasketid") String workbasketId) { - try { - Workbasket workbasket = workbasketService.getWorkbasket(workbasketId); - return new ResponseEntity<>(workbasket, HttpStatus.OK); - } catch (WorkbasketNotFoundException e) { - return new ResponseEntity<>(HttpStatus.NOT_FOUND); - } - } - - @RequestMapping(method = RequestMethod.POST) - public ResponseEntity createWorkbasket(@RequestBody Workbasket workbasket) { - Workbasket createdWorkbasket = workbasketService.createWorkbasket(workbasket); - return new ResponseEntity<>(createdWorkbasket, HttpStatus.CREATED); - } + @GetMapping + public List getWorkbaskets(@RequestParam MultiValueMap params) { + if (params.containsKey("requiredPermission")) { + List authorizations = new ArrayList<>(); + params.get("requiredPermission").stream().forEach(item -> { + for (String authorization : Arrays.asList(item.split(","))) { + switch (authorization) { + case "READ": + authorizations.add(WorkbasketAuthorization.READ); + break; + case "OPEN": + authorizations.add(WorkbasketAuthorization.OPEN); + break; + case "APPEND": + authorizations.add(WorkbasketAuthorization.APPEND); + break; + case "TRANSFER": + authorizations.add(WorkbasketAuthorization.TRANSFER); + break; + case "DISTRIBUTE": + authorizations.add(WorkbasketAuthorization.DISTRIBUTE); + break; + } + } + }); + return workbasketService.getWorkbaskets(authorizations); + } else { + return workbasketService.getWorkbaskets(); + } + } - @RequestMapping(value = "/{workbasketid}", method = RequestMethod.PUT) - public ResponseEntity updateWorkbasket(@PathVariable(value = "workbasketid") String workbasketId, - @RequestBody Workbasket workbasket) { - try { - Workbasket updatedWorkbasket = workbasketService.updateWorkbasket(workbasket); - return new ResponseEntity<>(updatedWorkbasket, HttpStatus.OK); - } catch (NotAuthorizedException e) { - return new ResponseEntity<>(HttpStatus.UNAUTHORIZED); - } - } + @RequestMapping(value = "/{workbasketid}") + public ResponseEntity getWorkbasketById(@PathVariable(value = "workbasketid") String workbasketId) { + try { + Workbasket workbasket = workbasketService.getWorkbasket(workbasketId); + return new ResponseEntity<>(workbasket, HttpStatus.OK); + } catch (WorkbasketNotFoundException e) { + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + } catch (InvalidWorkbasketException e) { + return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR); + } + } - @RequestMapping(value = "/{workbasketid}/authorizations", method = RequestMethod.GET) - public List getWorkbasketAuthorizations( - @PathVariable(value = "workbasketid") String workbasketId) { - return workbasketService.getWorkbasketAuthorizations(workbasketId); - } + @RequestMapping(method = RequestMethod.POST) + public ResponseEntity createWorkbasket(@RequestBody Workbasket workbasket) { + Workbasket createdWorkbasket; + try { + createdWorkbasket = workbasketService.createWorkbasket(workbasket); + } catch (InvalidWorkbasketException e) { + return new ResponseEntity<>(HttpStatus.CONFLICT); + } catch (WorkbasketNotFoundException e) { + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + } + return new ResponseEntity<>(createdWorkbasket, HttpStatus.CREATED); + } - @RequestMapping(value = "/authorizations", method = RequestMethod.POST) - public WorkbasketAccessItem createWorkbasketAuthorization(@RequestBody WorkbasketAccessItem workbasketAccessItem) { - return workbasketService.createWorkbasketAuthorization(workbasketAccessItem); - } + @RequestMapping(value = "/{workbasketkey}", method = RequestMethod.PUT) + public ResponseEntity updateWorkbasket(@PathVariable(value = "workbasketkey") String workbasketKey, + @RequestBody Workbasket workbasket) { + try { + Workbasket updatedWorkbasket = workbasketService.updateWorkbasket(workbasket); + return new ResponseEntity<>(updatedWorkbasket, HttpStatus.OK); + } catch (InvalidWorkbasketException e) { + return new ResponseEntity<>(HttpStatus.CONFLICT); + } catch (WorkbasketNotFoundException e) { + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + } catch (NotAuthorizedException e) { + return new ResponseEntity<>(HttpStatus.CONFLICT); + } + } - @RequestMapping(value = "/authorizations/{authid}", method = RequestMethod.PUT) - public WorkbasketAccessItem updateWorkbasketAuthorization(@PathVariable(value = "authid") String authId, - @RequestBody WorkbasketAccessItem workbasketAccessItem) { - return workbasketService.updateWorkbasketAuthorization(workbasketAccessItem); - } + @RequestMapping(value = "/{workbasketid}/authorizations", method = RequestMethod.GET) + public List getWorkbasketAuthorizations( + @PathVariable(value = "workbasketid") String workbasketId) { + return workbasketService.getWorkbasketAuthorizations(workbasketId); + } - @RequestMapping(value = "/authorizations/{authid}", method = RequestMethod.DELETE) - public ResponseEntity deleteWorkbasketAuthorization(@PathVariable(value = "authid") String authId) { - workbasketService.deleteWorkbasketAuthorization(authId); - return ResponseEntity.status(HttpStatus.NO_CONTENT).build(); - } + @RequestMapping(value = "/authorizations", method = RequestMethod.POST) + public WorkbasketAccessItem createWorkbasketAuthorization(@RequestBody WorkbasketAccessItem workbasketAccessItem) { + return workbasketService.createWorkbasketAuthorization(workbasketAccessItem); + } + + @RequestMapping(value = "/authorizations/{authid}", method = RequestMethod.PUT) + public WorkbasketAccessItem updateWorkbasketAuthorization(@PathVariable(value = "authid") String authId, + @RequestBody WorkbasketAccessItem workbasketAccessItem) { + return workbasketService.updateWorkbasketAuthorization(workbasketAccessItem); + } + + @RequestMapping(value = "/authorizations/{authid}", method = RequestMethod.DELETE) + public ResponseEntity deleteWorkbasketAuthorization(@PathVariable(value = "authid") String authId) { + workbasketService.deleteWorkbasketAuthorization(authId); + return ResponseEntity.status(HttpStatus.NO_CONTENT).build(); + } } diff --git a/rest/src/main/java/pro/taskana/rest/query/TaskFilter.java b/rest/src/main/java/pro/taskana/rest/query/TaskFilter.java index bba78adac..3ba02f276 100644 --- a/rest/src/main/java/pro/taskana/rest/query/TaskFilter.java +++ b/rest/src/main/java/pro/taskana/rest/query/TaskFilter.java @@ -29,7 +29,7 @@ public class TaskFilter { private static final String DESCRIPTION = "description"; private static final String NAME = "name"; private static final String OWNER = "owner"; - private static final String WORKBASKET_ID = "workbasketId"; + private static final String WORKBASKET_KEY = "workbasketKey"; private static final String CUSTOM = "custom"; private static final String IS_TRANSFERRED = "isTransferred"; private static final String IS_READ = "isRead"; @@ -116,9 +116,9 @@ public class TaskFilter { } taskQuery.classification(classificationQuery); } - if (params.containsKey(WORKBASKET_ID)) { - String[] workbaskets = extractCommaSeperatedFields(params.get(WORKBASKET_ID)); - taskQuery.workbasketId(workbaskets); + if (params.containsKey(WORKBASKET_KEY)) { + String[] workbaskets = extractCommaSeperatedFields(params.get(WORKBASKET_KEY)); + taskQuery.workbasketKeyIn(workbaskets); } if (params.containsKey(OWNER)) { String[] owners = extractCommaSeperatedFields(params.get(OWNER)); @@ -186,15 +186,15 @@ public class TaskFilter { params.get(STATE).stream().forEach(item -> { Arrays.asList(item.split(COMMA)).stream().forEach(state -> { switch (state) { - case READY: - states.add(TaskState.READY); - break; - case COMPLETED: - states.add(TaskState.COMPLETED); - break; - case CLAIMED: - states.add(TaskState.CLAIMED); - break; + case READY: + states.add(TaskState.READY); + break; + case COMPLETED: + states.add(TaskState.COMPLETED); + break; + case CLAIMED: + states.add(TaskState.CLAIMED); + break; } }); }); diff --git a/rest/src/main/java/pro/taskana/rest/serialization/DistributionTargetDeserializer.java b/rest/src/main/java/pro/taskana/rest/serialization/DistributionTargetDeserializer.java index 01c78660f..b5539aa8e 100644 --- a/rest/src/main/java/pro/taskana/rest/serialization/DistributionTargetDeserializer.java +++ b/rest/src/main/java/pro/taskana/rest/serialization/DistributionTargetDeserializer.java @@ -17,41 +17,45 @@ import com.fasterxml.jackson.databind.deser.std.StdDeserializer; import pro.taskana.Workbasket; import pro.taskana.WorkbasketService; +import pro.taskana.exceptions.InvalidWorkbasketException; import pro.taskana.exceptions.WorkbasketNotFoundException; /** * This class deserializes the string list to real workbaskets */ public class DistributionTargetDeserializer extends StdDeserializer> { - - private static final long serialVersionUID = 4226950057149602129L; - private static final Logger logger = LoggerFactory.getLogger(DistributionTargetDeserializer.class); + private static final long serialVersionUID = 4226950057149602129L; - @Autowired - private WorkbasketService workbasketService; + private static final Logger logger = LoggerFactory.getLogger(DistributionTargetDeserializer.class); - public DistributionTargetDeserializer() { - this(null); - SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this); - } + @Autowired + private WorkbasketService workbasketService; - public DistributionTargetDeserializer(Class vc) { - super(vc); - } + public DistributionTargetDeserializer() { + this(null); + SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this); + } - @Override - public List deserialize(JsonParser jsonparser, DeserializationContext context) - throws IOException, JsonProcessingException { - List distributionTargets = new ArrayList(); - while (jsonparser.nextToken() != JsonToken.END_ARRAY) { - String id = jsonparser.getText(); - try { - distributionTargets.add(workbasketService.getWorkbasket(id)); - } catch (WorkbasketNotFoundException e) { - logger.error("The workbasket with the id '" + id + "' is not found in database."); - } - } - return distributionTargets; - } + public DistributionTargetDeserializer(Class vc) { + super(vc); + } + + @Override + public List deserialize(JsonParser jsonparser, DeserializationContext context) + throws IOException, JsonProcessingException { + List distributionTargets = new ArrayList(); + while (jsonparser.nextToken() != JsonToken.END_ARRAY) { + String id = jsonparser.getText(); + try { + distributionTargets.add(workbasketService.getWorkbasket(id)); + } catch (WorkbasketNotFoundException e) { + logger.error("The workbasket with the id '" + id + "' is not found in database."); + } catch (InvalidWorkbasketException e) { + logger.error("The workbasket with the id '" + id + "' misses some required properties. Exception = {}.", + e); + } + } + return distributionTargets; + } } diff --git a/rest/src/main/resources/sql/sample-data/task.sql b/rest/src/main/resources/sql/sample-data/task.sql index ab9ebd2cb..1a3619507 100644 --- a/rest/src/main/resources/sql/sample-data/task.sql +++ b/rest/src/main/resources/sql/sample-data/task.sql @@ -1,16 +1,16 @@ -INSERT INTO TASK VALUES('1', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, 'Task1', 'Lorem ipsum dolor sit amet.', 1, 'READY', '1', '1', 'BPI1', 'PBPI1', 'Stefan', '1', true, false, null, null, null, null, null, null, null, null, null, null, null); -INSERT INTO TASK VALUES('2', CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task2', 'Lorem ipsum dolor sit amet. ', 1, 'READY', '2', '1', 'BPI2', 'PBPI2', 'Frank', '2', false, false, null, null, null, null, null, null, null, null, null, null, null); -INSERT INTO TASK VALUES('3', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task3', 'Lorem ipsum dolor sit amet. ', 1, 'CLAIMED', '3', '1', 'BPI3', 'PBPI3', 'Stefan', '3', true, false, null, null, null, null, null, null, null, null, null, null, null); -INSERT INTO TASK VALUES('4', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task4', 'Lorem ipsum dolor sit amet.', 1, 'CLAIMED', '4', '1', 'BPI4', 'PBPI4', 'Frank', '1', false, true, null, null, null, null, null, null, null, null, null, null, null); -INSERT INTO TASK VALUES('5', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task5', 'Lorem ipsum dolor sit amet. ', 1, 'COMPLETED', '15', '1', 'BPI5', 'PBPI5', 'Stefan', '2', false, false, null, null, null, null, null, null, null, null, null, null, null); -INSERT INTO TASK VALUES('6', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task6', 'Lorem ipsum dolor sit amet.', 1, 'COMPLETED', '16', '1', 'BPI6', 'PBPI6', 'Frank', '3', false, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('1', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, 'Task1', 'Lorem ipsum dolor sit amet.', 1, 'READY', '1', 'key1', 'BPI1', 'PBPI1', 'Stefan', '1', true, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('2', CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task2', 'Lorem ipsum dolor sit amet. ', 1, 'READY', '2', 'key1', 'BPI2', 'PBPI2', 'Frank', '2', false, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('3', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task3', 'Lorem ipsum dolor sit amet. ', 1, 'CLAIMED', '3', 'key1', 'BPI3', 'PBPI3', 'Stefan', '3', true, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('4', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task4', 'Lorem ipsum dolor sit amet.', 1, 'CLAIMED', '4', 'key1', 'BPI4', 'PBPI4', 'Frank', '1', false, true, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('5', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task5', 'Lorem ipsum dolor sit amet. ', 1, 'COMPLETED', '15', 'key1', 'BPI5', 'PBPI5', 'Stefan', '2', false, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('6', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task6', 'Lorem ipsum dolor sit amet.', 1, 'COMPLETED', '16', 'key1', 'BPI6', 'PBPI6', 'Frank', '3', false, false, null, null, null, null, null, null, null, null, null, null, null); -INSERT INTO TASK VALUES('7', CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task7', 'Lorem ipsum dolor sit amet.', 1, 'READY', '13', '2', 'BPI7', 'PBPI7', 'Stefan', '1', false, false, null, null, null, null, null, null, null, null, null, null, null); -INSERT INTO TASK VALUES('8', CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task8', 'Lorem ipsum dolor sit amet. ', 1, 'READY', '14', '2', 'BPI8', 'PBPI8', 'Frank', '2', false, false, null, null, null, null, null, null, null, null, null, null, null); -INSERT INTO TASK VALUES('9', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task9', 'Lorem ipsum dolor sit amet. ', 1, 'CLAIMED', '1', '2', 'BPI9', 'PBPI9', 'Stefan', '3', true, false, null, null, null, null, null, null, null, null, null, null, null); -INSERT INTO TASK VALUES('10', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task10', 'Lorem ipsum dolor sit amet.', 1, 'CLAIMED', '2', '2', 'BPI10', 'PBPI10', 'Frank', '1', false, false, null, null, null, null, null, null, null, null, null, null, null); -INSERT INTO TASK VALUES('11', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task11', 'Lorem ipsum dolor sit amet. ', 1, 'COMPLETED', '3', '2', 'BPI11', 'PBPI11', 'Stefan', '2', false, false, null, null, null, null, null, null, null, null, null, null, null); -INSERT INTO TASK VALUES('12', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task12', 'Lorem ipsum dolor sit amet.', 1, 'COMPLETED', '4', '2', 'BPI12', 'PBPI12', 'Frank', '3', false, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('7', CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task7', 'Lorem ipsum dolor sit amet.', 1, 'READY', '13', 'key2', 'BPI7', 'PBPI7', 'Stefan', '1', false, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('8', CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task8', 'Lorem ipsum dolor sit amet. ', 1, 'READY', '14', 'key2', 'BPI8', 'PBPI8', 'Frank', '2', false, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('9', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task9', 'Lorem ipsum dolor sit amet. ', 1, 'CLAIMED', '1', 'key2', 'BPI9', 'PBPI9', 'Stefan', '3', true, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('10', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task10', 'Lorem ipsum dolor sit amet.', 1, 'CLAIMED', '2', 'key2', 'BPI10', 'PBPI10', 'Frank', '1', false, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('11', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task11', 'Lorem ipsum dolor sit amet. ', 1, 'COMPLETED', '3', 'key2', 'BPI11', 'PBPI11', 'Stefan', '2', false, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('12', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task12', 'Lorem ipsum dolor sit amet.', 1, 'COMPLETED', '4', 'key2', 'BPI12', 'PBPI12', 'Frank', '3', false, false, null, null, null, null, null, null, null, null, null, null, null); -INSERT INTO TASK VALUES('13', CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task12', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Phasellus massa turpis, pellentesque ut libero sit aet, malesuada suscipit dolor. Sed volutpat euismod felis sit amet molestie. Fusce ornare purus dui. ', 1, 'READY', '13', '2', 'BPI13', 'PBPI13', 'Frank', '1', false, false, null, null, null, null, null, null, null, null, null, null, null); -INSERT INTO TASK VALUES('14', CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task6', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis vulputate nibh ut malesuada. Etiam ac dictum tellus, nec cursus nunc. Curabitur velit eros, feugiat volutpat laoreet vitae, cursus eu dui. Nulla ut purus sem. Vivamus aliquet odio vitae erat cursus, vitae mattis urna mollis. Nam quam tellus, auctor id volutpat congue, viverra vitae ante. Duis nisi dolor, elementum et mattis at, maximus id velit. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Duis eu condimentum risus. Praesent libero velit, facilisis sit amet maximus non, scelerisque ullamcorper leo. Ut sit amet iaculis eros. Mauris sagittis nibh lacus, at facilisis magna suscipit at. Aliquam finibus tempor odio id commodo. Vivamus aliquam, justo id porta imperdiet, mi.', 1, 'READY', '14', '1', 'BPI14', 'PBPI14', 'Frank', '2', false, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('13', CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task12', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Phasellus massa turpis, pellentesque ut libero sit aet, malesuada suscipit dolor. Sed volutpat euismod felis sit amet molestie. Fusce ornare purus dui. ', 1, 'READY', '13', 'key2', 'BPI13', 'PBPI13', 'Frank', '1', false, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('14', CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task6', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis vulputate nibh ut malesuada. Etiam ac dictum tellus, nec cursus nunc. Curabitur velit eros, feugiat volutpat laoreet vitae, cursus eu dui. Nulla ut purus sem. Vivamus aliquet odio vitae erat cursus, vitae mattis urna mollis. Nam quam tellus, auctor id volutpat congue, viverra vitae ante. Duis nisi dolor, elementum et mattis at, maximus id velit. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Duis eu condimentum risus. Praesent libero velit, facilisis sit amet maximus non, scelerisque ullamcorper leo. Ut sit amet iaculis eros. Mauris sagittis nibh lacus, at facilisis magna suscipit at. Aliquam finibus tempor odio id commodo. Vivamus aliquam, justo id porta imperdiet, mi.', 1, 'READY', '14', 'key1', 'BPI14', 'PBPI14', 'Frank', '2', false, false, null, null, null, null, null, null, null, null, null, null, null); diff --git a/rest/src/main/resources/sql/sample-data/workbasket-access-list.sql b/rest/src/main/resources/sql/sample-data/workbasket-access-list.sql index 3fea0afb8..31e4c09be 100644 --- a/rest/src/main/resources/sql/sample-data/workbasket-access-list.sql +++ b/rest/src/main/resources/sql/sample-data/workbasket-access-list.sql @@ -1,3 +1,3 @@ -INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('1', '1', 'Elena', true, true, true, true, true, false, false, false, false, false, false, false, false); -INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('2', '2', 'Max', true, true, true, true, true, true, true, true, true, false, false, false, false); -INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('3', '3', 'Simone', true, true, true, true, true, true, true, true, true, true, true, true, true); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('1', 'key1', 'Elena', true, true, true, true, true, false, false, false, false, false, false, false, false); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('2', 'key2', 'Max', true, true, true, true, true, true, true, true, true, false, false, false, false); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('3', 'key3', 'Simone', true, true, true, true, true, true, true, true, true, true, true, true, true); diff --git a/rest/src/main/resources/sql/sample-data/workbasket.sql b/rest/src/main/resources/sql/sample-data/workbasket.sql index 14ecd62b2..6ec78e88b 100644 --- a/rest/src/main/resources/sql/sample-data/workbasket.sql +++ b/rest/src/main/resources/sql/sample-data/workbasket.sql @@ -1,3 +1,3 @@ -INSERT INTO WORKBASKET VALUES ('1', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'Basket1', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', 'Peter'); -INSERT INTO WORKBASKET VALUES ('2', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'Basket2', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', 'Susanne'); -INSERT INTO WORKBASKET VALUES ('3', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'Basket3', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', 'Max'); +INSERT INTO WORKBASKET VALUES ('1', 'key1', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'Basket1', 'domain1', 'GROUP', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', 'Peter', '', '', '', '', '', '', '', '' ); +INSERT INTO WORKBASKET VALUES ('2', 'key2', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'Basket2', 'domain2', 'CLEARANCE', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', 'Susanne', '', '', '', '', '', '', '', ''); +INSERT INTO WORKBASKET VALUES ('3', 'key3', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'Basket3', 'domain3', 'TOPIC', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', 'Max', '', '', '', '', '', '', '', ''); diff --git a/workplace/src/app/model/workbasket.ts b/workplace/src/app/model/workbasket.ts index 43a79fa2f..9f4a63e00 100644 --- a/workplace/src/app/model/workbasket.ts +++ b/workplace/src/app/model/workbasket.ts @@ -1,5 +1,5 @@ export class Workbasket { - id: string; + key: string; created: string; modified: string; name: string; diff --git a/workplace/src/app/services/data.service.ts b/workplace/src/app/services/data.service.ts index b9f2fbfd5..1da9af335 100644 --- a/workplace/src/app/services/data.service.ts +++ b/workplace/src/app/services/data.service.ts @@ -2,6 +2,6 @@ import { Injectable } from '@angular/core'; @Injectable() export class DataService { - workbasketId: string; + workbasketKey: string; workbasketName: string; } diff --git a/workplace/src/app/services/rest-connector.service.ts b/workplace/src/app/services/rest-connector.service.ts index df9d2f700..488f3f33d 100644 --- a/workplace/src/app/services/rest-connector.service.ts +++ b/workplace/src/app/services/rest-connector.service.ts @@ -16,9 +16,9 @@ export class RestConnectorService { .map(res => res.json()); } - findTaskWithWorkbaskets(basketName: string): Observable { - return this.http.get(environment.taskanaRestUrl + '/v1/tasks?workbasketid=' - + basketName + '&state=READY&state=CLAIMED', this.createAuthorizationHeader()) + findTaskWithWorkbaskets(basketKey: string): Observable { + return this.http.get(environment.taskanaRestUrl + '/v1/tasks?workbasketkey=' + + basketKey + '&state=READY&state=CLAIMED', this.createAuthorizationHeader()) .map(res => res.json()); } @@ -37,9 +37,9 @@ export class RestConnectorService { .map(res => res.json()); } - transferTask(taskId: string, workbasketId: string) { + transferTask(taskId: string, workbasketKey: string) { return this.http.post(environment.taskanaRestUrl + '/v1/tasks/' + taskId - + '/transfer/' + workbasketId, '', this.createAuthorizationHeader()) + + '/transfer/' + workbasketKey, '', this.createAuthorizationHeader()) .map(res => res.json()); } diff --git a/workplace/src/app/task/task.component.ts b/workplace/src/app/task/task.component.ts index ed5c4e40e..eb0987aa1 100644 --- a/workplace/src/app/task/task.component.ts +++ b/workplace/src/app/task/task.component.ts @@ -17,7 +17,7 @@ export class TaskComponent implements OnInit { link: SafeResourceUrl = this.sanitizer.bypassSecurityTrustResourceUrl('https://duckduckgo.com/?q='); autoCompleteData: string[] = new Array; workbasket: string = null; - workbasketId: string; + workbasketKey: string; workbaskets: Workbasket[]; private sub: any; @@ -35,7 +35,7 @@ export class TaskComponent implements OnInit { this.restConnectorService.getAllWorkBaskets().subscribe( w => { this.workbaskets = w; this.workbaskets.forEach(workbasket => { - if (workbasket.id !== this.task.workbasket) { + if (workbasket.key !== this.task.workbasket) { this.autoCompleteData.push(workbasket.name); } }); @@ -47,10 +47,10 @@ export class TaskComponent implements OnInit { if (this.workbasket) { this.workbaskets.forEach(workbasket => { if (workbasket.name === this.workbasket) { - this.workbasketId = workbasket.id; + this.workbasketKey = workbasket.key; } }); - this.restConnectorService.transferTask(this.task.id, this.workbasketId).subscribe( + this.restConnectorService.transferTask(this.task.id, this.workbasketKey).subscribe( task => {this.task = task}); this.router.navigate(['tasks/']); } diff --git a/workplace/src/app/workbasket-selector/workbasket-selector.component.ts b/workplace/src/app/workbasket-selector/workbasket-selector.component.ts index 31bf9fa39..ceedc35c1 100644 --- a/workplace/src/app/workbasket-selector/workbasket-selector.component.ts +++ b/workplace/src/app/workbasket-selector/workbasket-selector.component.ts @@ -15,7 +15,7 @@ export class SelectorComponent implements OnInit { autoCompleteData: string[] = new Array; result: string; - resultId: string; + resultKey: string; workbaskets: Workbasket[]; constructor(private restConnectorService: RestConnectorService, private dataService: DataService) { } @@ -27,8 +27,8 @@ export class SelectorComponent implements OnInit { this.autoCompleteData.push(workbasket.name); }); }); - if (this.dataService.workbasketId) { - this.getTasks(this.dataService.workbasketId); + if (this.dataService.workbasketKey) { + this.getTasks(this.dataService.workbasketKey); this.result = this.dataService.workbasketName; } } @@ -37,17 +37,17 @@ export class SelectorComponent implements OnInit { if (this.workbaskets) { this.workbaskets.forEach(workbasket => { if (workbasket.name === this.result) { - this.resultId = workbasket.id; + this.resultKey = workbasket.key; } }); - this.getTasks(this.resultId); - this.dataService.workbasketId = this.resultId; + this.getTasks(this.resultKey); + this.dataService.workbasketKey = this.resultKey; this.dataService.workbasketName = this.result; } } - getTasks(id: string) { - this.restConnectorService.findTaskWithWorkbaskets(id).subscribe( + getTasks(workbasketKey: string) { + this.restConnectorService.findTaskWithWorkbaskets(workbasketKey).subscribe( tasks2 => {this.tasks.next(tasks2)}); } }