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

TSK-926: Define desired time period to work on a task

This commit is contained in:
Benjamin Eckstein 2019-11-18 11:11:12 +01:00 committed by Mustapha Zorgati
parent 4e095f4580
commit b6be17c0b3
11 changed files with 92 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
lib/taskana-core/src/main/java/pro/taskana/impl/DaysToWorkingDaysConverter.java
View File

@ -34,8 +34,8 @@ public final class DaysToWorkingDaysConverter {
private static final Logger LOGGER = LoggerFactory.getLogger(TaskMonitorServiceImpl.class);
private static DaysToWorkingDaysConverter instance;
private ArrayList<Integer> positiveDaysToWorkingDays;
private ArrayList<Integer> negativeDaysToWorkingDays;
private List<Integer> positiveDaysToWorkingDays;
private List<Integer> negativeDaysToWorkingDays;
private Instant dateCreated;
private LocalDate easterSunday;
private static boolean germanHolidaysEnabled;
@ -182,20 +182,19 @@ public final class DaysToWorkingDaysConverter {
}
public long convertWorkingDaysToDays(Instant startTime, long numberOfDays) {
int days = 0;
int workingDays = 0;
int direction = numberOfDays > 0 ? 1 : -1;
while (workingDays < numberOfDays * direction) {
days += direction;
workingDays += isWorkingDay(days, startTime) ? 1 : 0;
}
return days;
long limit = Math.abs(numberOfDays);
return LongStream.iterate(0, i -> i + direction)
.filter(day -> isWorkingDay(day, startTime))
.skip(limit)
.findFirst().orElse(0);
}
private ArrayList<Integer> generateNegativeDaysToWorkingDays(
private List<Integer> generateNegativeDaysToWorkingDays(
List<? extends TimeIntervalColumnHeader> columnHeaders, Instant referenceDate) {
int minUpperLimit = TimeIntervalColumnHeader.getSmallestUpperLimit(columnHeaders);
ArrayList<Integer> daysToWorkingDays = new ArrayList<>();
List<Integer> daysToWorkingDays = new ArrayList<>();
daysToWorkingDays.add(0);
int day = -1;
int workingDay = 0;
@ -206,7 +205,7 @@ public final class DaysToWorkingDaysConverter {
return daysToWorkingDays;
}
private ArrayList<Integer> generatePositiveDaysToWorkingDays(
private List<Integer> generatePositiveDaysToWorkingDays(
List<? extends TimeIntervalColumnHeader> columnHeaders, Instant referenceDate) {
int maxLowerLimit = TimeIntervalColumnHeader.getLargestLowerLimit(columnHeaders);
ArrayList<Integer> daysToWorkingDays = new ArrayList<>();
@ -221,7 +220,7 @@ public final class DaysToWorkingDaysConverter {
return daysToWorkingDays;
}
private boolean isWorkingDay(int day, Instant referenceDate) {
private boolean isWorkingDay(long day, Instant referenceDate) {
LocalDateTime dateToCheck = LocalDateTime.ofInstant(referenceDate, ZoneId.systemDefault()).plusDays(day);
return !isWeekend(dateToCheck)

9
lib/taskana-core/src/main/java/pro/taskana/impl/TaskServiceImpl.java
View File

@ -617,7 +617,7 @@ public class TaskServiceImpl implements TaskService {
}
private void standardSettings(TaskImpl task, Classification classification,
PrioDurationHolder prioDurationFromAttachments) {
PrioDurationHolder prioDurationFromAttachments) throws InvalidArgumentException {
LOGGER.debug("entry to standardSettings()");
Instant now = Instant.now();
task.setId(IdGenerator.generateWithPrefix(ID_PREFIX_TASK));
@ -642,12 +642,13 @@ public class TaskServiceImpl implements TaskService {
task.setBusinessProcessId(IdGenerator.generateWithPrefix(ID_PREFIX_BUSINESS_PROCESS));
}
// insert Classification specifications if Classification is given.
//null in case of manual tasks
if (classification == null) {
if (task.getPlanned() == null) {
task.setPlanned(now);
}
} else {
// do some Classification specific stuff (servicelevel).
// get duration in days from planned to due
PrioDurationHolder finalPrioDuration = getNewPrioDuration(prioDurationFromAttachments,
classification.getPriority(), classification.getServiceLevel());
@ -659,6 +660,10 @@ public class TaskServiceImpl implements TaskService {
long days = converter.convertWorkingDaysToDays(task.getDue(), -finalDuration.toDays());
//days < 0 -> so we ne need to add, not substract
Instant planned = task.getDue().plus(Duration.ofDays(days));
if (task.getPlanned() != null && !task.getPlanned().equals(planned)) {
throw new InvalidArgumentException(
"Cannot create a task with given planned and due date not matching the service level");
}
task.setPlanned(planned);
} else {
task.setPlanned(task.getPlanned() == null ? now : task.getPlanned());

83
lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java
View File

@ -20,6 +20,7 @@ import java.util.function.Consumer;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSession;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -54,6 +55,15 @@ import pro.taskana.security.WithAccessId;
@ExtendWith(JAASExtension.class)
class CreateTaskAccTest extends AbstractAccTest {
private TaskService taskService;
private ClassificationService classificationService;
@BeforeEach
void setup() {
taskService = taskanaEngine.getTaskService();
classificationService = taskanaEngine.getClassificationService();
}
@WithAccessId(
userName = "user_1_1",
groupNames = {"group_1"})
@ -62,7 +72,6 @@ class CreateTaskAccTest extends AbstractAccTest {
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
ObjectReference objectReference = createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR",
@ -99,7 +108,6 @@ class CreateTaskAccTest extends AbstractAccTest {
throws NotAuthorizedException, InvalidArgumentException,
ClassificationNotFoundException, WorkbasketNotFoundException, TaskAlreadyExistException {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
Instant instantPlanned = Instant.now().plus(2, ChronoUnit.HOURS);
newTask.setClassificationKey("T2100");
@ -122,6 +130,49 @@ class CreateTaskAccTest extends AbstractAccTest {
assertTrue(Math.abs(difference) < tolerance);
}
@WithAccessId(
userName = "user_1_1",
groupNames = {"group_1"})
@Test
void testCreateTaskWithInvalidPlannedAndDue() {
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
Instant instantPlanned = Instant.now().plus(2, ChronoUnit.HOURS);
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
newTask.setOwner("user_1_1");
newTask.setPlanned(instantPlanned);
newTask.setDue(instantPlanned); //due date not according to service level
Assertions.assertThrows(InvalidArgumentException.class, () -> taskService.createTask(newTask));
}
@WithAccessId(
userName = "user_1_1",
groupNames = {"group_1"})
@Test
void testCreateTaskWithValidPlannedAndDue() throws ClassificationNotFoundException {
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
long serviceLevelDays = Duration.parse(classification.getServiceLevel()).toDays();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
Instant instantPlanned = Instant.now();
newTask.setClassificationKey(classification.getKey());
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
newTask.setOwner("user_1_1");
newTask.setPlanned(instantPlanned);
//due date according to service level
Instant shouldBeDueDate = DaysToWorkingDaysConverter.getLastCreatedInstance()
.map(converter -> converter.convertWorkingDaysToDays(newTask.getPlanned(), serviceLevelDays))
.map(
calendarDays -> newTask.getPlanned().plus(Duration.ofDays(calendarDays))).orElseThrow(
RuntimeException::new);
newTask.setDue(shouldBeDueDate);
Assertions.assertDoesNotThrow(() -> taskService.createTask(newTask));
}
@WithAccessId(
userName = "user_1_1",
groupNames = {"group_1"})
@ -130,7 +181,6 @@ class CreateTaskAccTest extends AbstractAccTest {
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setExternalId("MyExternalId");
newTask.setClassificationKey("T2100");
@ -173,7 +223,6 @@ class CreateTaskAccTest extends AbstractAccTest {
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException, NoSuchFieldException,
IllegalAccessException {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
@ -241,7 +290,6 @@ class CreateTaskAccTest extends AbstractAccTest {
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException, NoSuchFieldException,
IllegalAccessException {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("L12010");
Map<String, String> customAttributesForCreate = createSimpleCustomProperties(27);
@ -306,7 +354,6 @@ class CreateTaskAccTest extends AbstractAccTest {
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("L12010");
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
@ -343,9 +390,6 @@ class CreateTaskAccTest extends AbstractAccTest {
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
TaskService taskService = taskanaEngine.getTaskService();
ClassificationService classificationService = taskanaEngine.getClassificationService();
//SL P16D
Classification classification = classificationService.getClassification("L110105", "DOMAIN_A");
long serviceLevelDays = Duration.parse(classification.getServiceLevel()).toDays();
@ -380,9 +424,6 @@ class CreateTaskAccTest extends AbstractAccTest {
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
TaskService taskService = taskanaEngine.getTaskService();
ClassificationService classificationService = taskanaEngine.getClassificationService();
//SL P16D
Classification classification = classificationService.getClassification("L110105", "DOMAIN_A");
long serviceLevelDays = Duration.parse(classification.getServiceLevel()).toDays();
@ -401,9 +442,8 @@ class CreateTaskAccTest extends AbstractAccTest {
assertNotNull(readTask);
assertEquals(due, readTask.getDue());
Optional<Long> calendarDaysToSubstract = DaysToWorkingDaysConverter.getLastCreatedInstance()
.map(converter -> converter.convertWorkingDaysToDays(readTask.getPlanned(), -serviceLevelDays));
.map(converter -> converter.convertWorkingDaysToDays(due, -serviceLevelDays));
assertTrue(calendarDaysToSubstract.isPresent());
assertTrue(calendarDaysToSubstract.get() < 0);
@ -421,7 +461,6 @@ class CreateTaskAccTest extends AbstractAccTest {
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("L12010"); // prio 8, SL P7D
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
@ -467,7 +506,7 @@ class CreateTaskAccTest extends AbstractAccTest {
throws ClassificationNotFoundException {
Consumer<Attachment> testCreateTask = (Attachment invalidAttachment) -> {
TaskService taskService = taskanaEngine.getTaskService();
Task taskWithInvalidAttachment = makeNewTask(taskService);
taskWithInvalidAttachment.addAttachment(invalidAttachment);
Assertions.assertThrows(InvalidArgumentException.class, () ->
@ -512,7 +551,6 @@ class CreateTaskAccTest extends AbstractAccTest {
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
@ -532,7 +570,6 @@ class CreateTaskAccTest extends AbstractAccTest {
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
@ -550,7 +587,6 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testGetExceptionIfWorkbasketDoesNotExist() {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("UNKNOWN");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
@ -565,7 +601,6 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testGetExceptionIfAppendIsNotPermitted() {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("GPK_KSC", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
@ -581,7 +616,7 @@ class CreateTaskAccTest extends AbstractAccTest {
void testThrowsExceptionIfMandatoryPrimaryObjectReferenceIsNotSetOrIncomplete() {
Consumer<ObjectReference> testCreateTask = (ObjectReference objectReference) -> {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
if (objectReference != null) {
@ -608,7 +643,6 @@ class CreateTaskAccTest extends AbstractAccTest {
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
TaskService taskService = taskanaEngine.getTaskService();
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Workbasket workbasket = workbasketService.getWorkbasket("USER_1_1", "DOMAIN_A");
@ -632,7 +666,6 @@ class CreateTaskAccTest extends AbstractAccTest {
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
@ -660,7 +693,6 @@ class CreateTaskAccTest extends AbstractAccTest {
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
@ -695,7 +727,6 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testCreateTaskWithSecurityButNoUserId() {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(createObjectReference("COMPANY_B", "SYSTEM_B", "INSTANCE_B", "VNR", "1234567"));
@ -711,7 +742,6 @@ class CreateTaskAccTest extends AbstractAccTest {
void testCreateTaskAlreadyExisting()
throws NotAuthorizedException, TaskNotFoundException {
TaskService taskService = taskanaEngine.getTaskService();
Task existingTask = taskService.getTask("TKI:000000000000000000000000000000000000");
Assertions.assertThrows(TaskAlreadyExistException.class, () ->
@ -724,7 +754,6 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testCreateTaskNotAuthorizedOnWorkbasket() {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.newTask("TEAMLEAD_2", "DOMAIN_A");
Assertions.assertThrows(NotAuthorizedException.class, () ->

13
rest/taskana-rest-spring-test/src/test/java/pro/taskana/RestHelper.java
View File

@ -6,9 +6,7 @@ import org.springframework.hateoas.hal.Jackson2HalModule;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponentsBuilder;
@ -44,7 +42,7 @@ public class RestHelper {
public HttpHeaders getHeaders() {
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
headers.add("Content-Type", "application/hal+json");
headers.add("Content-Type", "application/json");
return headers;
}
@ -71,13 +69,8 @@ public class RestHelper {
converter.setObjectMapper(mapper);
RestTemplate template = new RestTemplate();
template.getMessageConverters().clear();
//Parse Json Strings
template.getMessageConverters().add(new StringHttpMessageConverter());
//Parse Raw Files (Form upload)
template.getMessageConverters().add(new AllEncompassingFormHttpMessageConverter());
template.getMessageConverters().add(converter);
//important to add first to ensure priority
template.getMessageConverters().add(0, converter);
return template;
}
}

3
rest/taskana-rest-spring-test/src/test/java/pro/taskana/doc/api/BaseRestDocumentation.java
View File

@ -34,7 +34,8 @@ public abstract class BaseRestDocumentation {
@Autowired
protected MockMvc mockMvc;
@Autowired RestHelper restHelper;
@Autowired
protected RestHelper restHelper;
@BeforeEach
public void setUpMockMvc() {

3
rest/taskana-rest-spring-test/src/test/java/pro/taskana/jobs/AsyncUpdateJobIntTest.java
View File

@ -133,9 +133,8 @@ class AsyncUpdateJobIntTest {
private void verifyTaskIsModifiedAfter(String taskId, Instant before)
throws InvalidArgumentException {
RestTemplate admTemplate = RestHelper.getRestTemplate();
ResponseEntity<TaskResource> taskResponse = admTemplate.exchange(
ResponseEntity<TaskResource> taskResponse = template.exchange(
restHelper.toUrl(Mapping.URL_TASKS_ID, taskId),
HttpMethod.GET,
new HttpEntity<>(restHelper.getHeadersAdmin()),

9
rest/taskana-rest-spring-test/src/test/java/pro/taskana/rest/TaskControllerIntTest.java
View File

@ -358,8 +358,9 @@ class TaskControllerIntTest {
}
/**
* TSK-926: If Planned and Due Date is provided to create a task throw an exception
* One is calculated by other other date + service level.
* TSK-926: If Planned and Due Date is provided to create a task
* and not matching to service level throw an exception
* One is calculated by other other date +- service level.
*/
@Test
void testCreateWithPlannedAndDueDate() {
@ -401,7 +402,7 @@ class TaskControllerIntTest {
+ "\"workbasketSummaryResource\":{\"workbasketId\":\"WBI:100000000000000000000000000000000004\"},"
+ "\"primaryObjRef\":{\"company\":\"MyCompany1\",\"system\":\"MySystem1\",\"systemInstance\":\"MyInstance1\",\"type\":\"MyType1\",\"value\":\"00000001\"}}";
URL url = new URL(restHelper.toUrl("/api/v1/tasks"));
URL url = new URL(restHelper.toUrl(Mapping.URL_TASKS));
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("POST");
con.setDoOutput(true);
@ -419,7 +420,7 @@ class TaskControllerIntTest {
+ "\"workbasketSummaryResource\":{\"workbasketId\":\"\"},"
+ "\"primaryObjRef\":{\"company\":\"MyCompany1\",\"system\":\"MySystem1\",\"systemInstance\":\"MyInstance1\",\"type\":\"MyType1\",\"value\":\"00000001\"}}";
url = new URL(restHelper.toUrl("/api/v1/tasks"));
url = new URL(restHelper.toUrl(Mapping.URL_TASKS));
con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("POST");
con.setDoOutput(true);

7
rest/taskana-rest-spring-test/src/test/java/pro/taskana/rest/WorkbasketDefinitionControllerIntTest.java
View File

@ -14,7 +14,6 @@ import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -41,7 +40,6 @@ import pro.taskana.rest.resource.WorkbasketDefinitionResource;
/**
* Integration tests for WorkbasketDefinitionController.
*/
@TaskanaSpringBootTest
class WorkbasketDefinitionControllerIntTest {
@ -57,11 +55,6 @@ class WorkbasketDefinitionControllerIntTest {
template = RestHelper.getRestTemplate();
}
@BeforeEach
void before() {
LOGGER.debug("before");
}
@Test
void testExportWorkbasketFromDomain() {
ResponseEntity<List<WorkbasketDefinitionResource>> response = template.exchange(

4
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/TaskController.java
View File

@ -183,7 +183,9 @@ public class TaskController extends AbstractPagingController {
LOGGER.debug("Entry to createTask(params= {})", taskResource);
}
Task createdTask = taskService.createTask(taskResourceAssembler.toModel(taskResource));
Task fromResource = taskResourceAssembler.toModel(taskResource);
Task createdTask = taskService.createTask(fromResource);
ResponseEntity<TaskResource> result = ResponseEntity.status(HttpStatus.CREATED)
.body(taskResourceAssembler.toResource(createdTask));
if (LOGGER.isDebugEnabled()) {

2
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/resource/ClassificationSummaryResource.java
View File

@ -27,7 +27,7 @@ public class ClassificationSummaryResource extends ResourceSupport {
public String custom7;
public String custom8;
ClassificationSummaryResource() {
public ClassificationSummaryResource() {
}
public ClassificationSummaryResource(ClassificationSummary classification) {

5
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/resource/links/PageLinksAspect.java
View File

@ -19,7 +19,6 @@ import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.util.UriComponentsBuilder;
import pro.taskana.rest.WorkbasketController;
import pro.taskana.rest.resource.PagedResources.PageMetadata;
/**
@ -59,8 +58,8 @@ public class PageLinksAspect {
}
private UriComponentsBuilder originalUri(String relativeUrl, HttpServletRequest request) {
//any controller with a "root" mapping will do
UriComponentsBuilder baseUri = linkTo(WorkbasketController.class).toUriComponentsBuilder();
//argument to linkTo does not matter as we just want to have the default baseUrl
UriComponentsBuilder baseUri = linkTo(PageLinksAspect.class).toUriComponentsBuilder();
baseUri.path(relativeUrl);
for (Map.Entry<String, String[]> entry : request.getParameterMap().entrySet()) {
for (String value : entry.getValue()) {