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

TSK-947: Extract Url mappings

This commit is contained in:
Benjamin Eckstein 2019-11-07 12:06:43 +01:00 committed by Mustapha Zorgati
parent ad3342a68a
commit f848bf4f4e
30 changed files with 620 additions and 811 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
rest/taskana-rest-spring-test/src/test/java/pro/taskana/RestHelper.java Normal file
View File

@ -0,0 +1,83 @@
package pro.taskana;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
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;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
/**
* Helps to simplify rest api testing.
*/
@Component
public class RestHelper {
@Autowired
Environment environment;
public static RestTemplate template = getRestTemplate();
public String toUrl(String relativeUrl, Object... uriVariables) {
return UriComponentsBuilder.fromPath(relativeUrl)
.scheme("http")
.host("127.0.0.1")
.port(environment.getProperty("local.server.port"))
.build(uriVariables)
.toString();
}
public HttpEntity<String> defaultRequest() {
return new HttpEntity<>(getHeaders());
}
public HttpHeaders getHeaders() {
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
headers.add("Content-Type", "application/hal+json");
return headers;
}
public HttpHeaders getHeadersAdmin() {
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic YWRtaW46YWRtaW4="); // admin:admin
headers.add("Content-Type", "application/hal+json");
return headers;
}
/**
* Return a REST template which is capable of dealing with responses in HAL format.
*
* @return RestTemplate
*/
public static RestTemplate getRestTemplate() {
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
mapper.registerModule(new Jackson2HalModule());
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
converter.setSupportedMediaTypes(MediaType.parseMediaTypes("application/hal+json"));
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);
return template;
}
}

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

@ -3,37 +3,29 @@ package pro.taskana.jobs;
import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNotNull;
import java.io.IOException;
import java.time.Instant; import java.time.Instant;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.List; import java.util.List;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.core.ParameterizedTypeReference; import org.springframework.core.ParameterizedTypeReference;
import org.springframework.core.env.Environment;
import org.springframework.hateoas.Link; import org.springframework.hateoas.Link;
import org.springframework.hateoas.hal.Jackson2HalModule;
import org.springframework.http.HttpEntity; import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod; import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.client.RestTemplate; import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import pro.taskana.Classification; import pro.taskana.Classification;
import pro.taskana.RestHelper;
import pro.taskana.Task; import pro.taskana.Task;
import pro.taskana.TaskanaSpringBootTest; import pro.taskana.TaskanaSpringBootTest;
import pro.taskana.exceptions.InvalidArgumentException; import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.rest.Mapping;
import pro.taskana.rest.resource.ClassificationResource; import pro.taskana.rest.resource.ClassificationResource;
import pro.taskana.rest.resource.ClassificationResourceAssembler; import pro.taskana.rest.resource.ClassificationResourceAssembler;
import pro.taskana.rest.resource.TaskResource; import pro.taskana.rest.resource.TaskResource;
@ -56,36 +48,29 @@ class AsyncUpdateJobIntTest {
@Autowired @Autowired
JobScheduler jobScheduler; JobScheduler jobScheduler;
@Autowired @Autowired RestHelper restHelper;
Environment env;
@LocalServerPort static RestTemplate template;
int port;
private String server; @BeforeAll
static void init() {
private RestTemplate template; template = RestHelper.getRestTemplate();
@BeforeEach
void before() {
template = getRestTemplate();
server = "http://127.0.0.1:" + port;
} }
@Test @Test
void testUpdateClassificationPrioServiceLevel() void testUpdateClassificationPrioServiceLevel()
throws IOException, InvalidArgumentException { throws Exception {
// 1st step: get old classification : // 1st step: get old classification :
Instant before = Instant.now(); Instant before = Instant.now();
ObjectMapper mapper = new ObjectMapper(); ObjectMapper mapper = new ObjectMapper();
ResponseEntity<ClassificationResource> response = template.exchange( ResponseEntity<ClassificationResource> response = template.exchange(
server + "/api/v1/classifications/{classificationId}", restHelper.toUrl(Mapping.URL_CLASSIFICATIONS_ID, CLASSIFICATION_ID),
HttpMethod.GET, HttpMethod.GET,
new HttpEntity<String>(getHeaders()), new HttpEntity<String>(restHelper.getHeaders()),
ParameterizedTypeReference.forType(ClassificationResource.class), ParameterizedTypeReference.forType(ClassificationResource.class)
CLASSIFICATION_ID); );
assertNotNull(response.getBody()); assertNotNull(response.getBody());
ClassificationResource classification = response.getBody(); ClassificationResource classification = response.getBody();
@ -97,9 +82,9 @@ class AsyncUpdateJobIntTest {
classification.setPriority(1000); classification.setPriority(1000);
template.put( template.put(
server + "/api/v1/classifications/{classificationId}", restHelper.toUrl(Mapping.URL_CLASSIFICATIONS_ID, CLASSIFICATION_ID),
new HttpEntity<>(mapper.writeValueAsString(classification), getHeaders()), new HttpEntity<>(mapper.writeValueAsString(classification), restHelper.getHeaders())
CLASSIFICATION_ID); );
//trigger jobs twice to refresh all entries. first entry on the first call and follow up on the seconds call //trigger jobs twice to refresh all entries. first entry on the first call and follow up on the seconds call
jobScheduler.triggerJobs(); jobScheduler.triggerJobs();
@ -107,11 +92,11 @@ class AsyncUpdateJobIntTest {
// verify the classification modified timestamp is after 'before' // verify the classification modified timestamp is after 'before'
ResponseEntity<ClassificationResource> repeatedResponse = template.exchange( ResponseEntity<ClassificationResource> repeatedResponse = template.exchange(
server + "/api/v1/classifications/{classificationId}", restHelper.toUrl(Mapping.URL_CLASSIFICATIONS_ID, CLASSIFICATION_ID),
HttpMethod.GET, HttpMethod.GET,
new HttpEntity<String>(getHeaders()), new HttpEntity<String>(restHelper.getHeaders()),
ParameterizedTypeReference.forType(ClassificationResource.class), ParameterizedTypeReference.forType(ClassificationResource.class)
CLASSIFICATION_ID); );
assertNotNull(repeatedResponse.getBody()); assertNotNull(repeatedResponse.getBody());
@ -148,17 +133,13 @@ class AsyncUpdateJobIntTest {
private void verifyTaskIsModifiedAfter(String taskId, Instant before) private void verifyTaskIsModifiedAfter(String taskId, Instant before)
throws InvalidArgumentException { throws InvalidArgumentException {
RestTemplate admTemplate = getRestTemplate(); RestTemplate admTemplate = RestHelper.getRestTemplate();
HttpHeaders admHeaders = new HttpHeaders();
admHeaders.add("Authorization", "Basic YWRtaW46YWRtaW4="); // admin:admin
HttpEntity<String> admRequest = new HttpEntity<>(admHeaders);
ResponseEntity<TaskResource> taskResponse = admTemplate.exchange( ResponseEntity<TaskResource> taskResponse = admTemplate.exchange(
server + "/api/v1/tasks/{taskId}", restHelper.toUrl(Mapping.URL_TASKS_ID,taskId),
HttpMethod.GET, HttpMethod.GET,
admRequest, new HttpEntity<>(restHelper.getHeadersAdmin()),
ParameterizedTypeReference.forType(TaskResource.class), taskId); ParameterizedTypeReference.forType(TaskResource.class));
TaskResource taskResource = taskResponse.getBody(); TaskResource taskResource = taskResponse.getBody();
Task task = taskResourceAssembler.toModel(taskResource); Task task = taskResourceAssembler.toModel(taskResource);
@ -166,33 +147,4 @@ class AsyncUpdateJobIntTest {
assertFalse("Task " + task.getId() + " has not been refreshed.", before.isAfter(task.getModified())); assertFalse("Task " + task.getId() + " has not been refreshed.", before.isAfter(task.getModified()));
} }
/**
* Return a REST template which is capable of dealing with responses in HAL format.
*
* @return RestTemplate
*/
private RestTemplate getRestTemplate() {
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
mapper.registerModule(new Jackson2HalModule());
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
converter.setSupportedMediaTypes(MediaType.parseMediaTypes("application/hal+json"));
converter.setObjectMapper(mapper);
RestTemplate template = new RestTemplate();
template.getMessageConverters().clear();
template.getMessageConverters().add(new StringHttpMessageConverter());
template.getMessageConverters().add(converter);
return template;
}
private HttpHeaders getHeaders() {
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
headers.add("Content-Type", "application/hal+json");
return headers;
}
} }

59
rest/taskana-rest-spring-test/src/test/java/pro/taskana/rest/AccessIdValidationControllerIntTest.java
View File

@ -6,27 +6,20 @@ import static org.junit.Assert.assertTrue;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collections;
import java.util.List; import java.util.List;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.boot.web.server.LocalServerPort; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.ParameterizedTypeReference; import org.springframework.core.ParameterizedTypeReference;
import org.springframework.hateoas.hal.Jackson2HalModule;
import org.springframework.http.HttpEntity; import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod; import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.client.HttpClientErrorException; import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate; import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.DeserializationFeature; import pro.taskana.RestHelper;
import com.fasterxml.jackson.databind.ObjectMapper;
import pro.taskana.TaskanaSpringBootTest; import pro.taskana.TaskanaSpringBootTest;
import pro.taskana.ldap.LdapCacheTestImpl; import pro.taskana.ldap.LdapCacheTestImpl;
import pro.taskana.rest.resource.AccessIdResource; import pro.taskana.rest.resource.AccessIdResource;
@ -37,18 +30,23 @@ import pro.taskana.rest.resource.AccessIdResource;
@TaskanaSpringBootTest @TaskanaSpringBootTest
class AccessIdValidationControllerIntTest { class AccessIdValidationControllerIntTest {
@LocalServerPort @Autowired RestHelper restHelper;
int port;
static RestTemplate template;
@BeforeAll
static void init() {
template = RestHelper.getRestTemplate();
}
@Test @Test
void testGetMatches() { void testGetMatches() {
AccessIdController.setLdapCache(new LdapCacheTestImpl()); AccessIdController.setLdapCache(new LdapCacheTestImpl());
RestTemplate template = getRestTemplate(); HttpEntity<String> request = new HttpEntity<String>(restHelper.getHeaders());
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
HttpEntity<String> request = new HttpEntity<String>(headers);
ResponseEntity<List<AccessIdResource>> response = template.exchange( ResponseEntity<List<AccessIdResource>> response = template.exchange(
"http://127.0.0.1:" + port + "/api/v1/access-ids?search-for=ali", HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_ACCESSID) + "?search-for=ali",
HttpMethod.GET,
request,
new ParameterizedTypeReference<List<AccessIdResource>>() { new ParameterizedTypeReference<List<AccessIdResource>>() {
}); });
@ -64,13 +62,12 @@ class AccessIdValidationControllerIntTest {
@Test @Test
void testBadRequestWhenSearchForIsTooShort() { void testBadRequestWhenSearchForIsTooShort() {
AccessIdController.setLdapCache(new LdapCacheTestImpl()); AccessIdController.setLdapCache(new LdapCacheTestImpl());
RestTemplate template = getRestTemplate(); HttpEntity<String> request = new HttpEntity<String>(restHelper.getHeaders());
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
HttpEntity<String> request = new HttpEntity<String>(headers);
try { try {
template.exchange( template.exchange(
"http://127.0.0.1:" + port + "/api/v1/access-ids?search-for=al", HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_ACCESSID) + "?search-for=al",
HttpMethod.GET,
request,
ParameterizedTypeReference.forType(List.class)); ParameterizedTypeReference.forType(List.class));
} catch (HttpClientErrorException e) { } catch (HttpClientErrorException e) {
assertEquals(HttpStatus.BAD_REQUEST, e.getStatusCode()); assertEquals(HttpStatus.BAD_REQUEST, e.getStatusCode());
@ -79,22 +76,4 @@ class AccessIdValidationControllerIntTest {
} }
/**
* Return a REST template which is capable of dealing with responses in HAL format.
*
* @return RestTemplate
*/
private RestTemplate getRestTemplate() {
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.registerModule(new Jackson2HalModule());
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
converter.setSupportedMediaTypes(MediaType.parseMediaTypes("application/hal+json"));
converter.setObjectMapper(mapper);
RestTemplate template = new RestTemplate(Collections.<HttpMessageConverter<?>>singletonList(converter));
return template;
}
} }

287
rest/taskana-rest-spring-test/src/test/java/pro/taskana/rest/ClassificationControllerIntTest.java
View File

@ -5,44 +5,27 @@ import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertThrows;
import java.io.BufferedWriter;
import java.io.IOException; import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.time.Instant;
import java.util.Collections;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.core.ParameterizedTypeReference; import org.springframework.core.ParameterizedTypeReference;
import org.springframework.core.env.Environment;
import org.springframework.hateoas.Link; import org.springframework.hateoas.Link;
import org.springframework.hateoas.hal.Jackson2HalModule;
import org.springframework.http.HttpEntity; import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod; import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.test.annotation.DirtiesContext; import org.springframework.test.annotation.DirtiesContext;
import org.springframework.web.client.HttpClientErrorException; import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate; import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.DeserializationFeature; import pro.taskana.RestHelper;
import com.fasterxml.jackson.databind.ObjectMapper;
import pro.taskana.Task;
import pro.taskana.TaskanaSpringBootTest; import pro.taskana.TaskanaSpringBootTest;
import pro.taskana.exceptions.InvalidArgumentException; import pro.taskana.rest.resource.ClassificationResource;
import pro.taskana.rest.resource.ClassificationSummaryListResource; import pro.taskana.rest.resource.ClassificationSummaryListResource;
import pro.taskana.rest.resource.ClassificationSummaryResource; import pro.taskana.rest.resource.ClassificationSummaryResource;
import pro.taskana.rest.resource.TaskResource;
import pro.taskana.rest.resource.TaskResourceAssembler;
/** /**
* Test ClassificationController. * Test ClassificationController.
@ -52,30 +35,19 @@ import pro.taskana.rest.resource.TaskResourceAssembler;
@TaskanaSpringBootTest @TaskanaSpringBootTest
class ClassificationControllerIntTest { class ClassificationControllerIntTest {
@Autowired @Autowired RestHelper restHelper;
private TaskResourceAssembler taskResourceAssembler;
@Autowired static RestTemplate template;
Environment env;
String server = "http://127.0.0.1:"; @BeforeAll
RestTemplate template; static void init() {
HttpEntity<String> request; template = RestHelper.getRestTemplate();
HttpHeaders headers = new HttpHeaders();
@LocalServerPort
int port;
@BeforeEach
void before() {
template = getRestTemplate();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
request = new HttpEntity<String>(headers);
} }
@Test @Test
void testGetAllClassifications() { void testGetAllClassifications() {
ResponseEntity<ClassificationSummaryListResource> response = template.exchange( ResponseEntity<ClassificationSummaryListResource> response = template.exchange(
server + port + "/api/v1/classifications", HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_CLASSIFICATIONS), HttpMethod.GET, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(ClassificationSummaryListResource.class)); ParameterizedTypeReference.forType(ClassificationSummaryListResource.class));
assertNotNull(response.getBody().getLink(Link.REL_SELF)); assertNotNull(response.getBody().getLink(Link.REL_SELF));
} }
@ -83,8 +55,8 @@ class ClassificationControllerIntTest {
@Test @Test
void testGetAllClassificationsFilterByCustomAttribute() { void testGetAllClassificationsFilterByCustomAttribute() {
ResponseEntity<ClassificationSummaryListResource> response = template.exchange( ResponseEntity<ClassificationSummaryListResource> response = template.exchange(
server + port + "/api/v1/classifications?domain=DOMAIN_A&custom-1-like=RVNR", HttpMethod.GET, restHelper.toUrl(Mapping.URL_CLASSIFICATIONS) + "?domain=DOMAIN_A&custom-1-like=RVNR", HttpMethod.GET,
request, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(ClassificationSummaryListResource.class)); ParameterizedTypeReference.forType(ClassificationSummaryListResource.class));
assertNotNull(response.getBody().getLink(Link.REL_SELF)); assertNotNull(response.getBody().getLink(Link.REL_SELF));
assertEquals(13, response.getBody().getContent().size()); assertEquals(13, response.getBody().getContent().size());
@ -93,8 +65,8 @@ class ClassificationControllerIntTest {
@Test @Test
void testGetAllClassificationsKeepingFilters() { void testGetAllClassificationsKeepingFilters() {
ResponseEntity<ClassificationSummaryListResource> response = template.exchange( ResponseEntity<ClassificationSummaryListResource> response = template.exchange(
server + port + "/api/v1/classifications?domain=DOMAIN_A&sort-by=key&order=asc", HttpMethod.GET, restHelper.toUrl(Mapping.URL_CLASSIFICATIONS) + "?domain=DOMAIN_A&sort-by=key&order=asc", HttpMethod.GET,
request, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(ClassificationSummaryListResource.class)); ParameterizedTypeReference.forType(ClassificationSummaryListResource.class));
assertNotNull(response.getBody().getLink(Link.REL_SELF)); assertNotNull(response.getBody().getLink(Link.REL_SELF));
assertTrue(response.getBody() assertTrue(response.getBody()
@ -108,9 +80,9 @@ class ClassificationControllerIntTest {
@Test @Test
void testGetSecondPageSortedByKey() { void testGetSecondPageSortedByKey() {
ResponseEntity<ClassificationSummaryListResource> response = template.exchange( ResponseEntity<ClassificationSummaryListResource> response = template.exchange(
server + port + "/api/v1/classifications?domain=DOMAIN_A&sort-by=key&order=asc&page=2&page-size=5", restHelper.toUrl(Mapping.URL_CLASSIFICATIONS) + "?domain=DOMAIN_A&sort-by=key&order=asc&page=2&page-size=5",
HttpMethod.GET, HttpMethod.GET,
request, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(ClassificationSummaryListResource.class)); ParameterizedTypeReference.forType(ClassificationSummaryListResource.class));
assertEquals(5, response.getBody().getContent().size()); assertEquals(5, response.getBody().getContent().size());
assertEquals("L1050", response.getBody().getContent().iterator().next().key); assertEquals("L1050", response.getBody().getContent().iterator().next().key);
@ -127,70 +99,61 @@ class ClassificationControllerIntTest {
@Test @Test
@DirtiesContext @DirtiesContext
void testCreateClassification() throws IOException { void testCreateClassification() {
String newClassification = "{\"classificationId\":\"\",\"category\":\"MANUAL\",\"domain\":\"DOMAIN_A\",\"key\":\"NEW_CLASS\",\"name\":\"new classification\",\"type\":\"TASK\"}"; String newClassification = "{\"classificationId\":\"\",\"category\":\"MANUAL\",\"domain\":\"DOMAIN_A\",\"key\":\"NEW_CLASS\",\"name\":\"new classification\",\"type\":\"TASK\"}";
URL url = new URL(server + port + "/api/v1/classifications");
HttpURLConnection con = (HttpURLConnection) url.openConnection(); ResponseEntity<ClassificationResource> responseEntity = template.exchange(
con.setRequestMethod("POST"); restHelper.toUrl(Mapping.URL_CLASSIFICATIONS),
con.setRequestProperty("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x"); HttpMethod.POST,
con.setDoOutput(true); new HttpEntity<>(newClassification, restHelper.getHeaders()),
con.setRequestProperty("Content-Type", "application/json"); ParameterizedTypeReference.forType(ClassificationResource.class)
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(con.getOutputStream())); );
out.write(newClassification);
out.flush(); assertNotNull(responseEntity);
out.close(); assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode());
assertEquals(201, con.getResponseCode());
con.disconnect();
newClassification = "{\"classificationId\":\"\",\"category\":\"MANUAL\",\"domain\":\"DOMAIN_A\",\"key\":\"NEW_CLASS_2\",\"name\":\"new classification\",\"type\":\"TASK\"}"; newClassification = "{\"classificationId\":\"\",\"category\":\"MANUAL\",\"domain\":\"DOMAIN_A\",\"key\":\"NEW_CLASS_2\",\"name\":\"new classification\",\"type\":\"TASK\"}";
url = new URL(server + port + "/api/v1/classifications");
con = (HttpURLConnection) url.openConnection(); responseEntity = template.exchange(restHelper.toUrl(Mapping.URL_CLASSIFICATIONS),
con.setRequestMethod("POST"); HttpMethod.POST,
con.setRequestProperty("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x"); new HttpEntity<>(newClassification, restHelper.getHeaders()),
con.setDoOutput(true); ParameterizedTypeReference.forType(ClassificationResource.class)
con.setRequestProperty("Content-Type", "application/json"); );
out = new BufferedWriter(new OutputStreamWriter(con.getOutputStream()));
out.write(newClassification); assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode());
out.flush();
out.close();
assertEquals(201, con.getResponseCode());
con.disconnect();
} }
@Test @Test
@DirtiesContext @DirtiesContext
void testCreateClassificationWithParentId() throws IOException { void testCreateClassificationWithParentId() {
String newClassification = "{\"classificationId\":\"\",\"category\":\"MANUAL\",\"domain\":\"DOMAIN_B\",\"key\":\"NEW_CLASS_P1\",\"name\":\"new classification\",\"type\":\"TASK\",\"parentId\":\"CLI:200000000000000000000000000000000015\"}"; String newClassification = "{\"classificationId\":\"\",\"category\":\"MANUAL\",\"domain\":\"DOMAIN_B\",\"key\":\"NEW_CLASS_P1\",\"name\":\"new classification\",\"type\":\"TASK\",\"parentId\":\"CLI:200000000000000000000000000000000015\"}";
URL url = new URL(server + port + "/api/v1/classifications");
HttpURLConnection con = (HttpURLConnection) url.openConnection(); ResponseEntity<ClassificationResource> responseEntity = template.exchange(
con.setRequestMethod("POST"); restHelper.toUrl(Mapping.URL_CLASSIFICATIONS),
con.setRequestProperty("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x"); HttpMethod.POST,
con.setDoOutput(true); new HttpEntity<>(newClassification, restHelper.getHeaders()),
con.setRequestProperty("Content-Type", "application/json"); ParameterizedTypeReference.forType(ClassificationResource.class)
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(con.getOutputStream())); );
out.write(newClassification);
out.flush(); assertNotNull(responseEntity);
out.close(); assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode());
assertEquals(201, con.getResponseCode());
con.disconnect();
} }
@Test @Test
@DirtiesContext @DirtiesContext
void testCreateClassificationWithParentKey() throws IOException { void testCreateClassificationWithParentKey() {
String newClassification = "{\"classificationId\":\"\",\"category\":\"MANUAL\",\"domain\":\"DOMAIN_B\",\"key\":\"NEW_CLASS_P2\",\"name\":\"new classification\",\"type\":\"TASK\",\"parentKey\":\"T2100\"}"; String newClassification = "{\"classificationId\":\"\",\"category\":\"MANUAL\",\"domain\":\"DOMAIN_B\",\"key\":\"NEW_CLASS_P2\",\"name\":\"new classification\",\"type\":\"TASK\",\"parentKey\":\"T2100\"}";
URL url = new URL(server + port + "/api/v1/classifications");
HttpURLConnection con = (HttpURLConnection) url.openConnection(); ResponseEntity<ClassificationResource> responseEntity = template.exchange(
con.setRequestMethod("POST"); restHelper.toUrl(Mapping.URL_CLASSIFICATIONS),
con.setRequestProperty("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x"); HttpMethod.POST,
con.setDoOutput(true); new HttpEntity<>(newClassification, restHelper.getHeaders()),
con.setRequestProperty("Content-Type", "application/json"); ParameterizedTypeReference.forType(ClassificationResource.class)
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(con.getOutputStream())); );
out.write(newClassification);
out.flush(); assertNotNull(responseEntity);
out.close(); assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode());
assertEquals(201, con.getResponseCode());
con.disconnect();
} }
@Test @Test
@ -199,22 +162,19 @@ class ClassificationControllerIntTest {
throws IOException { throws IOException {
String newClassification = "{\"classificationId\":\"\",\"category\":\"MANUAL\",\"domain\":\"DOMAIN_A\",\"key\":\"NEW_CLASS_P2\",\"name\":\"new classification\",\"type\":\"TASK\",\"parentKey\":\"T2100\"}"; String newClassification = "{\"classificationId\":\"\",\"category\":\"MANUAL\",\"domain\":\"DOMAIN_A\",\"key\":\"NEW_CLASS_P2\",\"name\":\"new classification\",\"type\":\"TASK\",\"parentKey\":\"T2100\"}";
URL url = new URL(server + port + "/api/v1/classifications"); ResponseEntity<ClassificationResource> responseEntity = template.exchange(
HttpURLConnection con = (HttpURLConnection) url.openConnection(); restHelper.toUrl(Mapping.URL_CLASSIFICATIONS),
con.setRequestMethod("POST"); HttpMethod.POST,
con.setRequestProperty("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x"); new HttpEntity<>(newClassification, restHelper.getHeaders()),
con.setDoOutput(true); ParameterizedTypeReference.forType(ClassificationResource.class)
con.setRequestProperty("Content-Type", "application/json"); );
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(con.getOutputStream()));
out.write(newClassification); assertNotNull(responseEntity);
out.flush(); assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode());
out.close();
assertEquals(201, con.getResponseCode());
con.disconnect();
ResponseEntity<ClassificationSummaryListResource> response = template.exchange( ResponseEntity<ClassificationSummaryListResource> response = template.exchange(
server + port + "/api/v1/classifications", HttpMethod.GET, restHelper.toUrl(Mapping.URL_CLASSIFICATIONS), HttpMethod.GET,
request, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(ClassificationSummaryListResource.class)); ParameterizedTypeReference.forType(ClassificationSummaryListResource.class));
assertNotNull(response.getBody().getLink(Link.REL_SELF)); assertNotNull(response.getBody().getLink(Link.REL_SELF));
boolean foundClassificationCreated = false; boolean foundClassificationCreated = false;
@ -232,112 +192,67 @@ class ClassificationControllerIntTest {
@DirtiesContext @DirtiesContext
void testReturn400IfCreateClassificationWithIncompatibleParentIdAndKey() throws IOException { void testReturn400IfCreateClassificationWithIncompatibleParentIdAndKey() throws IOException {
String newClassification = "{\"classificationId\":\"\",\"category\":\"MANUAL\",\"domain\":\"DOMAIN_B\",\"key\":\"NEW_CLASS_P3\",\"name\":\"new classification\",\"type\":\"TASK\",\"parentId\":\"CLI:200000000000000000000000000000000015\",\"parentKey\":\"T2000\"}"; String newClassification = "{\"classificationId\":\"\",\"category\":\"MANUAL\",\"domain\":\"DOMAIN_B\",\"key\":\"NEW_CLASS_P3\",\"name\":\"new classification\",\"type\":\"TASK\",\"parentId\":\"CLI:200000000000000000000000000000000015\",\"parentKey\":\"T2000\"}";
URL url = new URL(server + port + "/api/v1/classifications");
HttpURLConnection con = (HttpURLConnection) url.openConnection(); HttpClientErrorException e = Assertions.assertThrows(HttpClientErrorException.class, () -> template.exchange(
con.setRequestMethod("POST"); restHelper.toUrl(Mapping.URL_CLASSIFICATIONS),
con.setRequestProperty("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x"); HttpMethod.POST,
con.setDoOutput(true); new HttpEntity<>(newClassification, restHelper.getHeaders()),
con.setRequestProperty("Content-Type", "application/json"); ParameterizedTypeReference.forType(ClassificationResource.class)
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(con.getOutputStream())); ));
out.write(newClassification);
out.flush(); assertNotNull(e);
out.close(); assertEquals(HttpStatus.BAD_REQUEST, e.getStatusCode());
assertEquals(400, con.getResponseCode());
con.disconnect();
} }
@Test @Test
@DirtiesContext @DirtiesContext
void testCreateClassificationWithClassificationIdReturnsError400() throws IOException { void testCreateClassificationWithClassificationIdReturnsError400() throws IOException {
String newClassification = "{\"classificationId\":\"someId\",\"category\":\"MANUAL\",\"domain\":\"DOMAIN_A\",\"key\":\"NEW_CLASS\",\"name\":\"new classification\",\"type\":\"TASK\"}"; String newClassification = "{\"classificationId\":\"someId\",\"category\":\"MANUAL\",\"domain\":\"DOMAIN_A\",\"key\":\"NEW_CLASS\",\"name\":\"new classification\",\"type\":\"TASK\"}";
URL url = new URL("http://127.0.0.1:" + port + "/api/v1/classifications");
HttpURLConnection con = (HttpURLConnection) url.openConnection(); HttpClientErrorException e = Assertions.assertThrows(HttpClientErrorException.class, () -> template.exchange(
con.setRequestMethod("POST"); restHelper.toUrl(Mapping.URL_CLASSIFICATIONS),
con.setRequestProperty("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x"); HttpMethod.POST,
con.setDoOutput(true); new HttpEntity<>(newClassification, restHelper.getHeaders()),
con.setRequestProperty("Content-Type", "application/json"); ParameterizedTypeReference.forType(ClassificationResource.class)
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(con.getOutputStream())); ));
out.write(newClassification);
out.flush(); assertNotNull(e);
out.close(); assertEquals(HttpStatus.BAD_REQUEST, e.getStatusCode());
assertEquals(400, con.getResponseCode());
con.disconnect();
} }
@Test @Test
void testGetClassificationWithSpecialCharacter() { void testGetClassificationWithSpecialCharacter() {
RestTemplate template = getRestTemplate();
HttpHeaders headers = new HttpHeaders(); HttpEntity<String> request = new HttpEntity<String>(restHelper.getHeadersAdmin());
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
HttpEntity<String> request = new HttpEntity<String>(headers);
ResponseEntity<ClassificationSummaryResource> response = template.exchange( ResponseEntity<ClassificationSummaryResource> response = template.exchange(
"http://127.0.0.1:" + port + "/api/v1/classifications/CLI:100000000000000000000000000000000009", restHelper.toUrl(Mapping.URL_CLASSIFICATIONS_ID, "CLI:100000000000000000000000000000000009"),
HttpMethod.GET, HttpMethod.GET,
request, request,
ParameterizedTypeReference.forType(ClassificationSummaryResource.class)); ParameterizedTypeReference.forType(ClassificationSummaryResource.class)
);
assertEquals("Zustimmungserklärung", response.getBody().name); assertEquals("Zustimmungserklärung", response.getBody().name);
} }
@Test @Test
@DirtiesContext @DirtiesContext
void testDeleteClassification() { void testDeleteClassification() {
RestTemplate template = getRestTemplate(); HttpEntity<String> request = new HttpEntity<String>(restHelper.getHeaders());
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
HttpEntity<String> request = new HttpEntity<String>(headers);
ResponseEntity<ClassificationSummaryResource> response = template.exchange( ResponseEntity<ClassificationSummaryResource> response = template.exchange(
"http://127.0.0.1:" + port + "/api/v1/classifications/CLI:200000000000000000000000000000000004", restHelper.toUrl(Mapping.URL_CLASSIFICATIONS_ID, "CLI:200000000000000000000000000000000004"),
HttpMethod.DELETE, HttpMethod.DELETE,
request, request,
ParameterizedTypeReference.forType(ClassificationSummaryResource.class)); ParameterizedTypeReference.forType(ClassificationSummaryResource.class)
);
assertEquals(HttpStatus.NO_CONTENT, response.getStatusCode()); assertEquals(HttpStatus.NO_CONTENT, response.getStatusCode());
assertThrows(HttpClientErrorException.class, () -> { assertThrows(HttpClientErrorException.class, () -> {
template.exchange( template.exchange(
"http://127.0.0.1:" + port + "/api/v1/classifications/CLI:200000000000000000000000000000000004", restHelper.toUrl(Mapping.URL_CLASSIFICATIONS_ID, "CLI:200000000000000000000000000000000004"),
HttpMethod.GET, HttpMethod.GET,
request, request,
ParameterizedTypeReference.forType(ClassificationSummaryResource.class)); ParameterizedTypeReference.forType(ClassificationSummaryResource.class)
);
}); });
} }
private void verifyTaskIsModifiedAfter(String taskId, Instant before)
throws InvalidArgumentException {
RestTemplate admTemplate = getRestTemplate();
HttpHeaders admHeaders = new HttpHeaders();
admHeaders.add("Authorization", "Basic YWRtaW46YWRtaW4="); // admin:admin
HttpEntity<String> admRequest = new HttpEntity<String>(admHeaders);
ResponseEntity<TaskResource> taskResponse = admTemplate.exchange(
"http://127.0.0.1:" + port + "/api/v1/tasks/" + taskId,
HttpMethod.GET,
admRequest,
ParameterizedTypeReference.forType(TaskResource.class));
TaskResource taskResource = taskResponse.getBody();
Task task = taskResourceAssembler.toModel(taskResource);
assertTrue(!before.isAfter(task.getModified()));
}
/**
* Return a REST template which is capable of dealing with responses in HAL format.
*
* @return RestTemplate
*/
private RestTemplate getRestTemplate() {
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.registerModule(new Jackson2HalModule());
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
converter.setSupportedMediaTypes(MediaType.parseMediaTypes("application/hal+json"));
converter.setObjectMapper(mapper);
RestTemplate template = new RestTemplate(Collections.<HttpMessageConverter<?>>singletonList(converter));
return template;
}
} }

76
rest/taskana-rest-spring-test/src/test/java/pro/taskana/rest/ClassificationDefinitionControllerIntTest.java
View File

@ -14,35 +14,29 @@ import java.io.IOException;
import java.io.OutputStreamWriter; import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections;
import java.util.List; import java.util.List;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.core.ParameterizedTypeReference; import org.springframework.core.ParameterizedTypeReference;
import org.springframework.core.env.Environment;
import org.springframework.core.io.FileSystemResource; import org.springframework.core.io.FileSystemResource;
import org.springframework.hateoas.hal.Jackson2HalModule;
import org.springframework.http.HttpEntity; import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders; import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod; import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType; import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.util.LinkedMultiValueMap; import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap; import org.springframework.util.MultiValueMap;
import org.springframework.web.client.HttpClientErrorException; import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate; import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.ObjectMapper;
import pro.taskana.RestHelper;
import pro.taskana.TaskanaSpringBootTest; import pro.taskana.TaskanaSpringBootTest;
import pro.taskana.rest.resource.ClassificationResource; import pro.taskana.rest.resource.ClassificationResource;
import pro.taskana.rest.resource.ClassificationSummaryListResource; import pro.taskana.rest.resource.ClassificationSummaryListResource;
@ -57,35 +51,23 @@ class ClassificationDefinitionControllerIntTest {
private static final Logger LOGGER = LoggerFactory.getLogger(ClassificationController.class); private static final Logger LOGGER = LoggerFactory.getLogger(ClassificationController.class);
String server = "http://127.0.0.1:"; private ObjectMapper objMapper = new ObjectMapper();
RestTemplate template; @Autowired RestHelper restHelper;
HttpEntity<String> request; private static RestTemplate template;
HttpHeaders headers = new HttpHeaders(); @BeforeAll
static void init() {
ObjectMapper objMapper = new ObjectMapper(); template = RestHelper.getRestTemplate();
@LocalServerPort
int port;
@Autowired
Environment env;
@BeforeEach
void before() {
LOGGER.debug("before");
template = getRestTemplate();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
request = new HttpEntity<String>(headers);
} }
@Test @Test
void testExportClassifications() { void testExportClassifications() {
ResponseEntity<ClassificationResource[]> response = template.exchange( ResponseEntity<ClassificationResource[]> response = template.exchange(
server + port + "/api/v1/classification-definitions?domain=DOMAIN_B", restHelper.toUrl(Mapping.URL_CLASSIFICATIONDEFINITION) + "?domain=DOMAIN_B",
HttpMethod.GET, request, ParameterizedTypeReference.forType(ClassificationResource[].class)); HttpMethod.GET, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(ClassificationResource[].class));
assertEquals(HttpStatus.OK, response.getStatusCode()); assertEquals(HttpStatus.OK, response.getStatusCode());
assertTrue(response.getBody().length >= 5); assertTrue(response.getBody().length >= 5);
assertTrue(response.getBody().length <= 7); assertTrue(response.getBody().length <= 7);
@ -95,8 +77,9 @@ class ClassificationDefinitionControllerIntTest {
@Test @Test
void testExportClassificationsFromWrongDomain() { void testExportClassificationsFromWrongDomain() {
ResponseEntity<ClassificationResource[]> response = template.exchange( ResponseEntity<ClassificationResource[]> response = template.exchange(
server + port + "/api/v1/classification-definitions?domain=ADdfe", restHelper.toUrl(Mapping.URL_CLASSIFICATIONDEFINITION) + "?domain=ADdfe",
HttpMethod.GET, request, ParameterizedTypeReference.forType(ClassificationResource[].class)); HttpMethod.GET, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(ClassificationResource[].class));
assertEquals(0, response.getBody().length); assertEquals(0, response.getBody().length);
} }
@ -403,12 +386,9 @@ class ClassificationDefinitionControllerIntTest {
private ClassificationSummaryResource getClassificationWithKeyAndDomain(String key, String domain) { private ClassificationSummaryResource getClassificationWithKeyAndDomain(String key, String domain) {
LOGGER.debug("Request classification with key={} in domain={}", key, domain); LOGGER.debug("Request classification with key={} in domain={}", key, domain);
RestTemplate template = getRestTemplate(); HttpEntity<String> request = new HttpEntity<String>(restHelper.getHeaders());
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
HttpEntity<String> request = new HttpEntity<String>(headers);
ResponseEntity<ClassificationSummaryListResource> response = template.exchange( ResponseEntity<ClassificationSummaryListResource> response = template.exchange(
"http://127.0.0.1:" + port + "/api/v1/classifications?key=" + key + "&domain=" + domain, restHelper.toUrl(Mapping.URL_CLASSIFICATIONS) + "?key=" + key + "&domain=" + domain,
HttpMethod.GET, HttpMethod.GET,
request, request,
ParameterizedTypeReference.forType(ClassificationSummaryListResource.class)); ParameterizedTypeReference.forType(ClassificationSummaryListResource.class));
@ -423,31 +403,15 @@ class ClassificationDefinitionControllerIntTest {
writer.close(); writer.close();
MultiValueMap<String, Object> body = new LinkedMultiValueMap<>(); MultiValueMap<String, Object> body = new LinkedMultiValueMap<>();
HttpHeaders headers = restHelper.getHeaders();
headers.setContentType(MediaType.MULTIPART_FORM_DATA); headers.setContentType(MediaType.MULTIPART_FORM_DATA);
body.add("file", new FileSystemResource(tmpFile)); body.add("file", new FileSystemResource(tmpFile));
HttpEntity<MultiValueMap<String, Object>> requestEntity = new HttpEntity<>(body, headers); HttpEntity<MultiValueMap<String, Object>> requestEntity = new HttpEntity<>(body, headers);
String serverUrl = server + port + "/api/v1/classification-definitions"; String serverUrl = restHelper.toUrl(Mapping.URL_CLASSIFICATIONDEFINITION);
RestTemplate restTemplate = new RestTemplate();
return restTemplate.postForEntity(serverUrl, requestEntity, Void.class); return template.postForEntity(serverUrl, requestEntity, Void.class);
} }
/**
* Return a REST template which is capable of dealing with responses in HAL format.
*
* @return RestTemplate
*/
private RestTemplate getRestTemplate() {
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.registerModule(new Jackson2HalModule());
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
converter.setSupportedMediaTypes(MediaType.parseMediaTypes("application/haljson,*/*"));
converter.setObjectMapper(mapper);
RestTemplate template = new RestTemplate(Collections.<HttpMessageConverter<?>>singletonList(converter));
return template;
}
} }

59
rest/taskana-rest-spring-test/src/test/java/pro/taskana/rest/GenenalExceptionHandlingTest.java
View File

@ -3,34 +3,26 @@ package pro.taskana.rest;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verify;
import java.util.Collections;
import java.util.List; import java.util.List;
import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor; import org.mockito.ArgumentCaptor;
import org.mockito.Captor; import org.mockito.Captor;
import org.mockito.Mock; import org.mockito.Mock;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import org.springframework.boot.web.server.LocalServerPort; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.ParameterizedTypeReference; import org.springframework.core.ParameterizedTypeReference;
import org.springframework.hateoas.hal.Jackson2HalModule;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod; import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.client.RestTemplate; import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import ch.qos.logback.classic.Logger; import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.ILoggingEvent; import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.classic.spi.LoggingEvent; import ch.qos.logback.classic.spi.LoggingEvent;
import ch.qos.logback.core.Appender; import ch.qos.logback.core.Appender;
import pro.taskana.RestHelper;
import pro.taskana.TaskanaSpringBootTest; import pro.taskana.TaskanaSpringBootTest;
import pro.taskana.ldap.LdapCacheTestImpl; import pro.taskana.ldap.LdapCacheTestImpl;
import pro.taskana.rest.resource.ClassificationSummaryListResource; import pro.taskana.rest.resource.ClassificationSummaryListResource;
@ -42,23 +34,24 @@ import pro.taskana.rest.resource.ClassificationSummaryListResource;
@TaskanaSpringBootTest @TaskanaSpringBootTest
class GenenalExceptionHandlingTest { class GenenalExceptionHandlingTest {
String server = "http://127.0.0.1:";
RestTemplate template;
HttpEntity<String> request;
HttpHeaders headers = new HttpHeaders();
@LocalServerPort
int port;
@Mock @Mock
private Appender<ILoggingEvent> mockAppender; private Appender<ILoggingEvent> mockAppender;
@Captor @Captor
private ArgumentCaptor<LoggingEvent> captorLoggingEvent; private ArgumentCaptor<LoggingEvent> captorLoggingEvent;
@Autowired RestHelper restHelper;
private static RestTemplate template;
@BeforeAll
static void init() {
template = RestHelper.getRestTemplate();
}
@BeforeEach @BeforeEach
void before() { void before() {
template = getRestTemplate();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
request = new HttpEntity<String>(headers);
final Logger logger = (Logger) LoggerFactory.getLogger(TaskanaRestExceptionHandler.class); final Logger logger = (Logger) LoggerFactory.getLogger(TaskanaRestExceptionHandler.class);
logger.addAppender(mockAppender); logger.addAppender(mockAppender);
} }
@ -77,7 +70,7 @@ class GenenalExceptionHandlingTest {
AccessIdController.setLdapCache(new LdapCacheTestImpl()); AccessIdController.setLdapCache(new LdapCacheTestImpl());
template.exchange( template.exchange(
server + port + "/api/v1/access-ids?search-for=al", HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_ACCESSID) + "?search-for=al", HttpMethod.GET, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(List.class)); ParameterizedTypeReference.forType(List.class));
} catch (Exception ex) { } catch (Exception ex) {
verify(mockAppender).doAppend(captorLoggingEvent.capture()); verify(mockAppender).doAppend(captorLoggingEvent.capture());
@ -90,8 +83,10 @@ class GenenalExceptionHandlingTest {
void testDeleteNonExisitingClassificationExceptionIsLogged() { void testDeleteNonExisitingClassificationExceptionIsLogged() {
try { try {
template.exchange( template.exchange(
server + port + "/api/v1/classifications/non-existing-id", HttpMethod.DELETE, request, restHelper.toUrl(Mapping.URL_CLASSIFICATIONS_ID, "non-existing-id"), HttpMethod.DELETE,
ParameterizedTypeReference.forType(ClassificationSummaryListResource.class)); restHelper.defaultRequest(),
ParameterizedTypeReference.forType(ClassificationSummaryListResource.class)
);
} catch (Exception ex) { } catch (Exception ex) {
verify(mockAppender).doAppend(captorLoggingEvent.capture()); verify(mockAppender).doAppend(captorLoggingEvent.capture());
assertTrue(captorLoggingEvent.getValue() assertTrue(captorLoggingEvent.getValue()
@ -100,22 +95,4 @@ class GenenalExceptionHandlingTest {
} }
} }
/**
* Return a REST template which is capable of dealing with responses in HAL format.
*
* @return RestTemplate
*/
private RestTemplate getRestTemplate() {
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.registerModule(new Jackson2HalModule());
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
converter.setSupportedMediaTypes(MediaType.parseMediaTypes("application/hal+json"));
converter.setObjectMapper(mapper);
RestTemplate template = new RestTemplate(Collections.<HttpMessageConverter<?>>singletonList(converter));
return template;
}
} }

35
rest/taskana-rest-spring-test/src/test/java/pro/taskana/rest/MappingTest.java Normal file
View File

@ -0,0 +1,35 @@
package pro.taskana.rest;
import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;
import static org.springframework.hateoas.mvc.ControllerLinkBuilder.methodOn;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.web.util.UriComponentsBuilder;
import pro.taskana.TaskanaSpringBootTest;
/**
* Test Mapping and Linkbuilder.
*/
class MappingTest {
@Test
void testMapping() throws Exception {
String mapUrl = Mapping.URL_TASKS;
String buildUrl = linkTo(methodOn(TaskController.class).getTasks(new LinkedMultiValueMap<>())).toString();
Assertions.assertEquals(mapUrl, buildUrl);
}
@Test
void testMappingWithVariable() throws Exception {
String id = "25";
String mapUrl = UriComponentsBuilder.fromPath(Mapping.URL_TASKS_ID).buildAndExpand(id).toUriString();
String buildUrl = linkTo(methodOn(TaskController.class).getTask(id)).toString();
Assertions.assertEquals(mapUrl, buildUrl);
}
}

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

@ -15,25 +15,22 @@ import java.io.OutputStreamWriter;
import java.net.HttpURLConnection; import java.net.HttpURLConnection;
import java.net.URL; import java.net.URL;
import java.sql.SQLException; import java.sql.SQLException;
import java.util.Collections; import java.time.Instant;
import javax.sql.DataSource; import javax.sql.DataSource;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value; import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.core.ParameterizedTypeReference; import org.springframework.core.ParameterizedTypeReference;
import org.springframework.hateoas.Link; import org.springframework.hateoas.Link;
import org.springframework.hateoas.hal.Jackson2HalModule;
import org.springframework.http.HttpEntity; import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders; import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod; import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.client.HttpClientErrorException; import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate; import org.springframework.web.client.RestTemplate;
@ -41,10 +38,14 @@ import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.ObjectMapper;
import pro.taskana.ObjectReference;
import pro.taskana.RestHelper;
import pro.taskana.TaskanaSpringBootTest; import pro.taskana.TaskanaSpringBootTest;
import pro.taskana.exceptions.SystemException; import pro.taskana.exceptions.SystemException;
import pro.taskana.rest.resource.ClassificationSummaryResource;
import pro.taskana.rest.resource.TaskResource; import pro.taskana.rest.resource.TaskResource;
import pro.taskana.rest.resource.TaskSummaryListResource; import pro.taskana.rest.resource.TaskSummaryListResource;
import pro.taskana.rest.resource.WorkbasketSummaryResource;
import pro.taskana.sampledata.SampleDataGenerator; import pro.taskana.sampledata.SampleDataGenerator;
/** /**
@ -57,8 +58,14 @@ class TaskControllerIntTest {
@Value("${taskana.schemaName:TASKANA}") @Value("${taskana.schemaName:TASKANA}")
public String schemaName; public String schemaName;
@LocalServerPort @Autowired RestHelper restHelper;
int port;
private static RestTemplate template;
@BeforeAll
static void init() {
template = RestHelper.getRestTemplate();
}
@Autowired @Autowired
private DataSource dataSource; private DataSource dataSource;
@ -75,12 +82,8 @@ class TaskControllerIntTest {
@Test @Test
void testGetAllTasks() { void testGetAllTasks() {
RestTemplate template = getRestTemplate();
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
HttpEntity<String> request = new HttpEntity<String>(headers);
ResponseEntity<TaskSummaryListResource> response = template.exchange( ResponseEntity<TaskSummaryListResource> response = template.exchange(
"http://127.0.0.1:" + port + "/api/v1/tasks", HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_TASKS), HttpMethod.GET, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(TaskSummaryListResource.class)); ParameterizedTypeReference.forType(TaskSummaryListResource.class));
assertNotNull(response.getBody().getLink(Link.REL_SELF)); assertNotNull(response.getBody().getLink(Link.REL_SELF));
assertEquals(25, response.getBody().getContent().size()); assertEquals(25, response.getBody().getContent().size());
@ -88,13 +91,9 @@ class TaskControllerIntTest {
@Test @Test
void testGetAllTasksByWorkbasketId() { void testGetAllTasksByWorkbasketId() {
RestTemplate template = getRestTemplate();
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x"); // teamlead_1
HttpEntity<String> request = new HttpEntity<String>(headers);
ResponseEntity<TaskSummaryListResource> response = template.exchange( ResponseEntity<TaskSummaryListResource> response = template.exchange(
"http://127.0.0.1:" + port + "/api/v1/tasks?workbasket-id=WBI:100000000000000000000000000000000001", restHelper.toUrl(Mapping.URL_TASKS) + "?workbasket-id=WBI:100000000000000000000000000000000001",
HttpMethod.GET, request, HttpMethod.GET, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(TaskSummaryListResource.class)); ParameterizedTypeReference.forType(TaskSummaryListResource.class));
assertNotNull(response.getBody().getLink(Link.REL_SELF)); assertNotNull(response.getBody().getLink(Link.REL_SELF));
assertEquals(22, response.getBody().getContent().size()); assertEquals(22, response.getBody().getContent().size());
@ -102,12 +101,11 @@ class TaskControllerIntTest {
@Test @Test
void testGetAllTasksByWorkbasketKeyAndDomain() { void testGetAllTasksByWorkbasketKeyAndDomain() {
RestTemplate template = getRestTemplate();
HttpHeaders headers = new HttpHeaders(); HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dXNlcl8xXzI6dXNlcl8xXzI="); // user_1_2 headers.add("Authorization", "Basic dXNlcl8xXzI6dXNlcl8xXzI="); // user_1_2
HttpEntity<String> request = new HttpEntity<String>(headers); HttpEntity<String> request = new HttpEntity<String>(headers);
ResponseEntity<TaskSummaryListResource> response = template.exchange( ResponseEntity<TaskSummaryListResource> response = template.exchange(
"http://127.0.0.1:" + port + "/api/v1/tasks?workbasket-key=USER_1_2&domain=DOMAIN_A", restHelper.toUrl(Mapping.URL_TASKS) + "?workbasket-key=USER_1_2&domain=DOMAIN_A",
HttpMethod.GET, request, HttpMethod.GET, request,
ParameterizedTypeReference.forType(TaskSummaryListResource.class)); ParameterizedTypeReference.forType(TaskSummaryListResource.class));
assertNotNull(response.getBody().getLink(Link.REL_SELF)); assertNotNull(response.getBody().getLink(Link.REL_SELF));
@ -116,13 +114,13 @@ class TaskControllerIntTest {
@Test @Test
void testExceptionIfKeyIsSetButDomainIsMissing() { void testExceptionIfKeyIsSetButDomainIsMissing() {
RestTemplate template = getRestTemplate();
HttpHeaders headers = new HttpHeaders(); HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dXNlcl8xXzI6dXNlcl8xXzI="); // user_1_2 headers.add("Authorization", "Basic dXNlcl8xXzI6dXNlcl8xXzI="); // user_1_2
HttpEntity<String> request = new HttpEntity<String>(headers); HttpEntity<String> request = new HttpEntity<String>(headers);
try { try {
ResponseEntity<TaskSummaryListResource> response = template.exchange( ResponseEntity<TaskSummaryListResource> response = template.exchange(
"http://127.0.0.1:" + port + "/api/v1/tasks?workbasket-key=USER_1_2", restHelper.toUrl(Mapping.URL_TASKS) + "?workbasket-key=USER_1_2",
HttpMethod.GET, request, HttpMethod.GET, request,
ParameterizedTypeReference.forType(TaskSummaryListResource.class)); ParameterizedTypeReference.forType(TaskSummaryListResource.class));
fail(); fail();
@ -133,12 +131,8 @@ class TaskControllerIntTest {
@Test @Test
void testGetAllTasksWithAdminRole() { void testGetAllTasksWithAdminRole() {
RestTemplate template = getRestTemplate();
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic YWRtaW46YWRtaW4="); // Role Admin
HttpEntity<String> request = new HttpEntity<String>(headers);
ResponseEntity<TaskSummaryListResource> response = template.exchange( ResponseEntity<TaskSummaryListResource> response = template.exchange(
"http://127.0.0.1:" + port + "/api/v1/tasks", HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_TASKS), HttpMethod.GET, new HttpEntity<>(restHelper.getHeadersAdmin()),
ParameterizedTypeReference.forType(TaskSummaryListResource.class)); ParameterizedTypeReference.forType(TaskSummaryListResource.class));
assertNotNull(response.getBody().getLink(Link.REL_SELF)); assertNotNull(response.getBody().getLink(Link.REL_SELF));
assertEquals(73, response.getBody().getContent().size()); assertEquals(73, response.getBody().getContent().size());
@ -146,13 +140,9 @@ class TaskControllerIntTest {
@Test @Test
void testGetAllTasksKeepingFilters() { void testGetAllTasksKeepingFilters() {
RestTemplate template = getRestTemplate();
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
HttpEntity<String> request = new HttpEntity<String>(headers);
ResponseEntity<TaskSummaryListResource> response = template.exchange( ResponseEntity<TaskSummaryListResource> response = template.exchange(
"http://127.0.0.1:" + port + "/api/v1/tasks?por.type=VNR&por.value=22334455&sort-by=por.value&order=desc", restHelper.toUrl(Mapping.URL_TASKS) + "?por.type=VNR&por.value=22334455&sort-by=por.value&order=desc",
HttpMethod.GET, request, HttpMethod.GET, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(TaskSummaryListResource.class)); ParameterizedTypeReference.forType(TaskSummaryListResource.class));
assertNotNull(response.getBody().getLink(Link.REL_SELF)); assertNotNull(response.getBody().getLink(Link.REL_SELF));
assertTrue(response.getBody() assertTrue(response.getBody()
@ -163,14 +153,10 @@ class TaskControllerIntTest {
@Test @Test
void testThrowsExceptionIfInvalidFilterIsUsed() { void testThrowsExceptionIfInvalidFilterIsUsed() {
RestTemplate template = getRestTemplate();
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
HttpEntity<String> request = new HttpEntity<String>(headers);
try { try {
template.exchange( template.exchange(
"http://127.0.0.1:" + port + "/api/v1/tasks?invalid=VNR", restHelper.toUrl(Mapping.URL_TASKS) + "?invalid=VNR",
HttpMethod.GET, request, HttpMethod.GET, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(TaskSummaryListResource.class)); ParameterizedTypeReference.forType(TaskSummaryListResource.class));
fail(); fail();
} catch (HttpClientErrorException e) { } catch (HttpClientErrorException e) {
@ -181,13 +167,11 @@ class TaskControllerIntTest {
@Test @Test
void testGetLastPageSortedByPorValue() { void testGetLastPageSortedByPorValue() {
RestTemplate template = getRestTemplate();
HttpHeaders headers = new HttpHeaders(); HttpEntity<String> request = new HttpEntity<String>(restHelper.getHeadersAdmin());
headers.add("Authorization", "Basic YWRtaW46YWRtaW4="); // Role Admin
HttpEntity<String> request = new HttpEntity<String>(headers);
ResponseEntity<TaskSummaryListResource> response = template.exchange( ResponseEntity<TaskSummaryListResource> response = template.exchange(
"http://127.0.0.1:" + port restHelper.toUrl(Mapping.URL_TASKS)
+ "/api/v1/tasks?state=READY,CLAIMED&sort-by=por.value&order=desc&page=15&page-size=5", + "?state=READY,CLAIMED&sort-by=por.value&order=desc&page=15&page-size=5",
HttpMethod.GET, HttpMethod.GET,
request, request,
ParameterizedTypeReference.forType(TaskSummaryListResource.class)); ParameterizedTypeReference.forType(TaskSummaryListResource.class));
@ -209,19 +193,19 @@ class TaskControllerIntTest {
void testGetLastPageSortedByDueWithHiddenTasksRemovedFromResult() { void testGetLastPageSortedByDueWithHiddenTasksRemovedFromResult() {
resetDb(); // required because ClassificationControllerIntTest.testGetQueryByPorSecondPageSortedByType changes resetDb(); // required because ClassificationControllerIntTest.testGetQueryByPorSecondPageSortedByType changes
// tasks and this test depends on the tasks as they are in sampledata // tasks and this test depends on the tasks as they are in sampledata
RestTemplate template = getRestTemplate();
HttpHeaders headers = new HttpHeaders(); HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x"); headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
HttpEntity<String> request = new HttpEntity<String>(headers); HttpEntity<String> request = new HttpEntity<String>(headers);
ResponseEntity<TaskSummaryListResource> response = template.exchange( ResponseEntity<TaskSummaryListResource> response = template.exchange(
"http://127.0.0.1:" + port + "/api/v1/tasks?sort-by=due&order=desc", HttpMethod.GET, restHelper.toUrl(Mapping.URL_TASKS) + "?sort-by=due&order=desc", HttpMethod.GET,
request, request,
ParameterizedTypeReference.forType(TaskSummaryListResource.class)); ParameterizedTypeReference.forType(TaskSummaryListResource.class));
assertEquals(25, response.getBody().getContent().size()); assertEquals(25, response.getBody().getContent().size());
response = template.exchange( response = template.exchange(
"http://127.0.0.1:" + port + "/api/v1/tasks?sort-by=due&order=desc&page=5&page-size=5", HttpMethod.GET, restHelper.toUrl(Mapping.URL_TASKS) + "?sort-by=due&order=desc&page=5&page-size=5", HttpMethod.GET,
request, request,
ParameterizedTypeReference.forType(TaskSummaryListResource.class)); ParameterizedTypeReference.forType(TaskSummaryListResource.class));
assertEquals(5, response.getBody().getContent().size()); assertEquals(5, response.getBody().getContent().size());
@ -242,13 +226,13 @@ class TaskControllerIntTest {
void testGetQueryByPorSecondPageSortedByType() { void testGetQueryByPorSecondPageSortedByType() {
resetDb(); // required because ClassificationControllerIntTest.testGetQueryByPorSecondPageSortedByType changes resetDb(); // required because ClassificationControllerIntTest.testGetQueryByPorSecondPageSortedByType changes
// tasks and this test depends on the tasks as they are in sampledata // tasks and this test depends on the tasks as they are in sampledata
RestTemplate template = getRestTemplate();
HttpHeaders headers = new HttpHeaders(); HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x"); headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
HttpEntity<String> request = new HttpEntity<String>(headers); HttpEntity<String> request = new HttpEntity<String>(headers);
ResponseEntity<TaskSummaryListResource> response = template.exchange( ResponseEntity<TaskSummaryListResource> response = template.exchange(
"http://127.0.0.1:" + port restHelper.toUrl(Mapping.URL_TASKS)
+ "/api/v1/tasks?por.company=00&por.system=PASystem&por.instance=00&por.type=VNR&por.value=22334455&sort-by=por.type&order=asc&page=2&page-size=5", + "?por.company=00&por.system=PASystem&por.instance=00&por.type=VNR&por.value=22334455&sort-by=por.type&order=asc&page=2&page-size=5",
HttpMethod.GET, HttpMethod.GET,
request, request,
ParameterizedTypeReference.forType(TaskSummaryListResource.class)); ParameterizedTypeReference.forType(TaskSummaryListResource.class));
@ -268,7 +252,7 @@ class TaskControllerIntTest {
@Test @Test
void testGetTaskWithAttachments() throws IOException { void testGetTaskWithAttachments() throws IOException {
URL url = new URL("http://127.0.0.1:" + port + "/api/v1/tasks/TKI:000000000000000000000000000000000002"); URL url = new URL(restHelper.toUrl("/api/v1/tasks/TKI:000000000000000000000000000000000002"));
HttpURLConnection con = (HttpURLConnection) url.openConnection(); HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET"); con.setRequestMethod("GET");
con.setRequestProperty("Authorization", "Basic YWRtaW46YWRtaW4="); con.setRequestProperty("Authorization", "Basic YWRtaW46YWRtaW4=");
@ -294,7 +278,7 @@ class TaskControllerIntTest {
@Test @Test
void testGetAndUpdateTask() throws IOException { void testGetAndUpdateTask() throws IOException {
URL url = new URL("http://127.0.0.1:" + port + "/api/v1/tasks/TKI:100000000000000000000000000000000000"); URL url = new URL(restHelper.toUrl("/api/v1/tasks/TKI:100000000000000000000000000000000000"));
HttpURLConnection con = (HttpURLConnection) url.openConnection(); HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET"); con.setRequestMethod("GET");
con.setRequestProperty("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x"); con.setRequestProperty("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
@ -323,7 +307,7 @@ class TaskControllerIntTest {
assertEquals(200, con.getResponseCode()); assertEquals(200, con.getResponseCode());
con.disconnect(); con.disconnect();
url = new URL("http://127.0.0.1:" + port + "/api/v1/tasks/TKI:100000000000000000000000000000000000"); url = new URL(restHelper.toUrl("/api/v1/tasks/TKI:100000000000000000000000000000000000"));
con = (HttpURLConnection) url.openConnection(); con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET"); con.setRequestMethod("GET");
con.setRequestProperty("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x"); con.setRequestProperty("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
@ -350,47 +334,66 @@ class TaskControllerIntTest {
} }
@Test @Test
void testCreateAndDeleteTask() throws IOException { void testCreateAndDeleteTask() {
String taskToCreateJson = "{\"classificationSummaryResource\":{\"key\":\"L11010\"},"
+ "\"workbasketSummaryResource\":{\"workbasketId\":\"WBI:100000000000000000000000000000000004\"},"
+ "\"primaryObjRef\":{\"company\":\"MyCompany1\",\"system\":\"MySystem1\",\"systemInstance\":\"MyInstance1\",\"type\":\"MyType1\",\"value\":\"00000001\"}}";
URL url = new URL("http://127.0.0.1:" + port + "/api/v1/tasks"); TaskResource taskResource = getTaskResourceSample();
HttpURLConnection con = (HttpURLConnection) url.openConnection(); ResponseEntity<TaskResource> responseCreate = template.exchange(restHelper.toUrl(Mapping.URL_TASKS),
con.setRequestMethod("POST"); HttpMethod.POST,
con.setDoOutput(true); new HttpEntity<>(taskResource, restHelper.getHeaders()),
con.setRequestProperty("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x"); ParameterizedTypeReference.forType(TaskResource.class));
con.setRequestProperty("Content-Type", "application/json"); assertEquals(responseCreate.getStatusCode(), HttpStatus.CREATED);
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(con.getOutputStream())); assertNotNull(responseCreate.getBody());
out.write(taskToCreateJson);
out.flush();
out.close();
assertEquals(201, con.getResponseCode());
// con.disconnect();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
StringBuffer responsePayload = new StringBuffer();
String inputLine;
while ((inputLine = in.readLine()) != null) {
responsePayload.append(inputLine);
}
in.close();
con.disconnect();
String createdTask = responsePayload.toString();
String taskIdOfCreatedTask = createdTask.substring(createdTask.indexOf("TKI:"),
createdTask.indexOf("TKI:") + 40);
String taskIdOfCreatedTask = responseCreate.getBody().getTaskId();
assertNotNull(taskIdOfCreatedTask); assertNotNull(taskIdOfCreatedTask);
assertTrue(taskIdOfCreatedTask.startsWith("TKI:")); assertTrue(taskIdOfCreatedTask.startsWith("TKI:"));
// delete task again to clean test data ResponseEntity<TaskResource> responseDeleted = template.exchange(
url = new URL("http://127.0.0.1:" + port + "/api/v1/tasks/" + taskIdOfCreatedTask); restHelper.toUrl(Mapping.URL_TASKS_ID, taskIdOfCreatedTask),
con = (HttpURLConnection) url.openConnection(); HttpMethod.DELETE,
con.setRequestMethod("DELETE"); new HttpEntity<>(restHelper.getHeadersAdmin()),
con.setRequestProperty("Authorization", "Basic YWRtaW46YWRtaW4="); // admin ParameterizedTypeReference.forType(Void.class)
assertEquals(204, con.getResponseCode()); );
con.disconnect();
assertEquals(HttpStatus.NO_CONTENT, responseDeleted.getStatusCode());
}
/**
* 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.
*/
@Test
void testCreateWithPlannedAndDueDate() {
TaskResource taskResource = getTaskResourceSample();
Instant now = Instant.now();
taskResource.setPlanned(now.toString());
taskResource.setDue(now.toString());
HttpClientErrorException ex = Assertions.assertThrows(HttpClientErrorException.class,
() -> template.exchange(restHelper.toUrl(Mapping.URL_TASKS), HttpMethod.POST,
new HttpEntity<>(taskResource, restHelper.getHeaders()),
ParameterizedTypeReference.forType(TaskResource.class)));
}
private TaskResource getTaskResourceSample() {
ClassificationSummaryResource classificationResource = new ClassificationSummaryResource();
classificationResource.key = "L11010";
WorkbasketSummaryResource workbasketSummaryResource = new WorkbasketSummaryResource();
workbasketSummaryResource.setWorkbasketId("WBI:100000000000000000000000000000000004");
ObjectReference objectReference = new ObjectReference();
objectReference.setCompany("MyCompany1");
objectReference.setSystem("MySystem1");
objectReference.setSystemInstance("MyInstance1");
objectReference.setType("MyType1");
objectReference.setValue("00000001");
TaskResource taskResource = new TaskResource();
taskResource.setClassificationSummaryResource(classificationResource);
taskResource.setWorkbasketSummaryResource(workbasketSummaryResource);
taskResource.setPrimaryObjRef(objectReference);
return taskResource;
} }
@Test @Test
@ -399,7 +402,7 @@ class TaskControllerIntTest {
+ "\"workbasketSummaryResource\":{\"workbasketId\":\"WBI:100000000000000000000000000000000004\"}," + "\"workbasketSummaryResource\":{\"workbasketId\":\"WBI:100000000000000000000000000000000004\"},"
+ "\"primaryObjRef\":{\"company\":\"MyCompany1\",\"system\":\"MySystem1\",\"systemInstance\":\"MyInstance1\",\"type\":\"MyType1\",\"value\":\"00000001\"}}"; + "\"primaryObjRef\":{\"company\":\"MyCompany1\",\"system\":\"MySystem1\",\"systemInstance\":\"MyInstance1\",\"type\":\"MyType1\",\"value\":\"00000001\"}}";
URL url = new URL("http://127.0.0.1:" + port + "/api/v1/tasks"); URL url = new URL(restHelper.toUrl("/api/v1/tasks"));
HttpURLConnection con = (HttpURLConnection) url.openConnection(); HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("POST"); con.setRequestMethod("POST");
con.setDoOutput(true); con.setDoOutput(true);
@ -417,7 +420,7 @@ class TaskControllerIntTest {
+ "\"workbasketSummaryResource\":{\"workbasketId\":\"\"}," + "\"workbasketSummaryResource\":{\"workbasketId\":\"\"},"
+ "\"primaryObjRef\":{\"company\":\"MyCompany1\",\"system\":\"MySystem1\",\"systemInstance\":\"MyInstance1\",\"type\":\"MyType1\",\"value\":\"00000001\"}}"; + "\"primaryObjRef\":{\"company\":\"MyCompany1\",\"system\":\"MySystem1\",\"systemInstance\":\"MyInstance1\",\"type\":\"MyType1\",\"value\":\"00000001\"}}";
url = new URL("http://127.0.0.1:" + port + "/api/v1/tasks"); url = new URL(restHelper.toUrl("/api/v1/tasks"));
con = (HttpURLConnection) url.openConnection(); con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("POST"); con.setRequestMethod("POST");
con.setDoOutput(true); con.setDoOutput(true);
@ -432,23 +435,4 @@ class TaskControllerIntTest {
} }
/**
* Return a REST template which is capable of dealing with responses in HAL format.
*
* @return RestTemplate
*/
private RestTemplate getRestTemplate() {
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.registerModule(new Jackson2HalModule());
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
converter.setSupportedMediaTypes(MediaType.parseMediaTypes("application/hal+json"));
// converter.setSupportedMediaTypes(ImmutableList.of(MediaTypes.HAL_JSON));
converter.setObjectMapper(mapper);
RestTemplate template = new RestTemplate(Collections.<HttpMessageConverter<?>>singletonList(converter));
return template;
}
} }

64
rest/taskana-rest-spring-test/src/test/java/pro/taskana/rest/TaskanaEngineControllerIntTest.java
View File

@ -4,25 +4,19 @@ import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
import java.util.Collections;
import java.util.List; import java.util.List;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.boot.web.server.LocalServerPort; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.ParameterizedTypeReference; import org.springframework.core.ParameterizedTypeReference;
import org.springframework.hateoas.hal.Jackson2HalModule;
import org.springframework.http.HttpEntity; import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders; import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod; import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.client.RestTemplate; import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.DeserializationFeature; import pro.taskana.RestHelper;
import com.fasterxml.jackson.databind.ObjectMapper;
import pro.taskana.TaskanaRole; import pro.taskana.TaskanaRole;
import pro.taskana.TaskanaSpringBootTest; import pro.taskana.TaskanaSpringBootTest;
import pro.taskana.rest.resource.TaskanaUserInfoResource; import pro.taskana.rest.resource.TaskanaUserInfoResource;
@ -32,31 +26,29 @@ import pro.taskana.rest.resource.TaskanaUserInfoResource;
*/ */
@TaskanaSpringBootTest @TaskanaSpringBootTest
public class TaskanaEngineControllerIntTest { class TaskanaEngineControllerIntTest {
@LocalServerPort @Autowired RestHelper restHelper;
int port;
private static RestTemplate template;
@BeforeAll
static void init() {
template = RestHelper.getRestTemplate();
}
@Test @Test
void testDomains() { void testDomains() {
RestTemplate template = getRestTemplate();
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
HttpEntity<String> request = new HttpEntity<String>(headers);
ResponseEntity<List<String>> response = template.exchange( ResponseEntity<List<String>> response = template.exchange(
"http://127.0.0.1:" + port + "/api/v1/domains", HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_DOMAIN), HttpMethod.GET, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(List.class)); ParameterizedTypeReference.forType(List.class));
assertTrue(response.getBody().contains("DOMAIN_A")); assertTrue(response.getBody().contains("DOMAIN_A"));
} }
@Test @Test
void testClassificationTypes() { void testClassificationTypes() {
RestTemplate template = getRestTemplate();
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
HttpEntity<String> request = new HttpEntity<String>(headers);
ResponseEntity<List<String>> response = template.exchange( ResponseEntity<List<String>> response = template.exchange(
"http://127.0.0.1:" + port + "/api/v1/classification-types", HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_CLASSIFICATIONTYPES), HttpMethod.GET, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(List.class)); ParameterizedTypeReference.forType(List.class));
assertTrue(response.getBody().contains("TASK")); assertTrue(response.getBody().contains("TASK"));
assertTrue(response.getBody().contains("DOCUMENT")); assertTrue(response.getBody().contains("DOCUMENT"));
@ -65,12 +57,11 @@ public class TaskanaEngineControllerIntTest {
@Test @Test
void testClassificationCategories() { void testClassificationCategories() {
RestTemplate template = getRestTemplate();
HttpHeaders headers = new HttpHeaders(); HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x"); headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
HttpEntity<String> request = new HttpEntity<String>(headers); HttpEntity<String> request = new HttpEntity<String>(headers);
ResponseEntity<List<String>> response = template.exchange( ResponseEntity<List<String>> response = template.exchange(
"http://127.0.0.1:" + port + "/api/v1/classification-categories/?type=TASK", HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_CLASSIFICATIONCATEGORIES), HttpMethod.GET, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(List.class)); ParameterizedTypeReference.forType(List.class));
assertTrue(response.getBody().contains("MANUAL")); assertTrue(response.getBody().contains("MANUAL"));
assertTrue(response.getBody().contains("EXTERNAL")); assertTrue(response.getBody().contains("EXTERNAL"));
@ -81,35 +72,12 @@ public class TaskanaEngineControllerIntTest {
@Test @Test
void testGetCurrentUserInfo() { void testGetCurrentUserInfo() {
RestTemplate template = getRestTemplate();
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
HttpEntity<String> request = new HttpEntity<String>(headers);
ResponseEntity<TaskanaUserInfoResource> response = template.exchange( ResponseEntity<TaskanaUserInfoResource> response = template.exchange(
"http://127.0.0.1:" + port + "/api/v1/current-user-info", HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_CURRENTUSER), HttpMethod.GET, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(TaskanaUserInfoResource.class)); ParameterizedTypeReference.forType(TaskanaUserInfoResource.class));
assertEquals("teamlead_1", response.getBody().getUserId()); assertEquals("teamlead_1", response.getBody().getUserId());
assertTrue(response.getBody().getGroupIds().contains("businessadmin")); assertTrue(response.getBody().getGroupIds().contains("businessadmin"));
assertTrue(response.getBody().getRoles().contains(TaskanaRole.BUSINESS_ADMIN)); assertTrue(response.getBody().getRoles().contains(TaskanaRole.BUSINESS_ADMIN));
assertFalse(response.getBody().getRoles().contains(TaskanaRole.ADMIN)); assertFalse(response.getBody().getRoles().contains(TaskanaRole.ADMIN));
} }
/**
* Return a REST template which is capable of dealing with responses in HAL format.
*
* @return RestTemplate
*/
private RestTemplate getRestTemplate() {
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.registerModule(new Jackson2HalModule());
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
converter.setSupportedMediaTypes(MediaType.parseMediaTypes("application/hal+json, application/json"));
converter.setObjectMapper(mapper);
RestTemplate template = new RestTemplate(Collections.<HttpMessageConverter<?>>singletonList(converter));
return template;
}
} }

29
rest/taskana-rest-spring-test/src/test/java/pro/taskana/rest/TestSchemaNameCustomizable.java
View File

@ -3,21 +3,12 @@ package pro.taskana.rest;
import java.sql.ResultSet; import java.sql.ResultSet;
import java.sql.SQLException; import java.sql.SQLException;
import java.sql.Statement; import java.sql.Statement;
import java.util.Collections;
import javax.sql.DataSource; import javax.sql.DataSource;
import org.junit.Assert; import org.junit.Assert;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.hateoas.hal.Jackson2HalModule;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import pro.taskana.TaskanaSpringBootTest; import pro.taskana.TaskanaSpringBootTest;
import pro.taskana.configuration.SpringTaskanaEngineConfiguration; import pro.taskana.configuration.SpringTaskanaEngineConfiguration;
@ -78,24 +69,4 @@ class TestSchemaNameCustomizable {
e.printStackTrace(); e.printStackTrace();
} }
} }
/**
* Return a REST template which is capable of dealing with responses in HAL format.
*
* @return RestTemplate
*/
private RestTemplate getRestTemplate() {
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.registerModule(new Jackson2HalModule());
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
converter.setSupportedMediaTypes(MediaType.parseMediaTypes("application/hal+json"));
// converter.setSupportedMediaTypes(ImmutableList.of(MediaTypes.HAL_JSON));
converter.setObjectMapper(mapper);
RestTemplate template = new RestTemplate(Collections.<HttpMessageConverter<?>>singletonList(converter));
return template;
}
} }

79
rest/taskana-rest-spring-test/src/test/java/pro/taskana/rest/WorkbasketAccessItemControllerIntTest.java
View File

@ -6,30 +6,20 @@ import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail; import static org.junit.Assert.fail;
import java.util.Collections; import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.MethodOrderer; import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder; import org.junit.jupiter.api.TestMethodOrder;
import org.springframework.boot.web.server.LocalServerPort; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.ParameterizedTypeReference; import org.springframework.core.ParameterizedTypeReference;
import org.springframework.hateoas.Link; import org.springframework.hateoas.Link;
import org.springframework.hateoas.hal.Jackson2HalModule;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod; import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.client.HttpClientErrorException; import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate; import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.DeserializationFeature; import pro.taskana.RestHelper;
import com.fasterxml.jackson.databind.ObjectMapper;
import pro.taskana.TaskanaSpringBootTest; import pro.taskana.TaskanaSpringBootTest;
import pro.taskana.rest.resource.WorkbasketAccessItemListResource; import pro.taskana.rest.resource.WorkbasketAccessItemListResource;
import pro.taskana.rest.resource.WorkbasketAccessItemPaginatedListResource; import pro.taskana.rest.resource.WorkbasketAccessItemPaginatedListResource;
@ -41,33 +31,29 @@ import pro.taskana.rest.resource.WorkbasketAccessItemPaginatedListResource;
@TaskanaSpringBootTest @TaskanaSpringBootTest
class WorkbasketAccessItemControllerIntTest { class WorkbasketAccessItemControllerIntTest {
String url = "http://127.0.0.1:"; @Autowired RestHelper restHelper;
RestTemplate template;
HttpEntity<String> request;
@LocalServerPort
int port;
@BeforeEach private static RestTemplate template;
void before() {
template = getRestTemplate(); @BeforeAll
HttpHeaders headers = new HttpHeaders(); static void init() {
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x"); template = RestHelper.getRestTemplate();
request = new HttpEntity<String>(headers);
} }
@Test @Test
void testGetAllWorkbasketAccessItems() { void testGetAllWorkbasketAccessItems() {
ResponseEntity<WorkbasketAccessItemListResource> response = template.exchange( ResponseEntity<WorkbasketAccessItemListResource> response = template.exchange(
url + port + "/api/v1/workbasket-access-items", HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_WORKBASKETACCESSITEMS), HttpMethod.GET, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(WorkbasketAccessItemListResource.class)); ParameterizedTypeReference.forType(WorkbasketAccessItemListResource.class));
assertNotNull(response.getBody().getLink(Link.REL_SELF)); assertNotNull(response.getBody().getLink(Link.REL_SELF));
} }
@Test @Test
void testGetWorkbasketAccessItemsKeepingFilters() { void testGetWorkbasketAccessItemsKeepingFilters() {
String parameters = "/api/v1/workbasket-access-items?sort-by=workbasket-key&order=asc&page=1&page-size=9&access-ids=user_1_1"; String parameters = "?sort-by=workbasket-key&order=asc&page=1&page-size=9&access-ids=user_1_1";
ResponseEntity<WorkbasketAccessItemListResource> response = template.exchange( ResponseEntity<WorkbasketAccessItemListResource> response = template.exchange(
url + port + parameters, HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_WORKBASKETACCESSITEMS) + parameters, HttpMethod.GET,
restHelper.defaultRequest(),
ParameterizedTypeReference.forType(WorkbasketAccessItemListResource.class)); ParameterizedTypeReference.forType(WorkbasketAccessItemListResource.class));
assertNotNull(response.getBody().getLink(Link.REL_SELF)); assertNotNull(response.getBody().getLink(Link.REL_SELF));
assertTrue(response.getBody() assertTrue(response.getBody()
@ -80,9 +66,9 @@ class WorkbasketAccessItemControllerIntTest {
void testThrowsExceptionIfInvalidFilterIsUsed() { void testThrowsExceptionIfInvalidFilterIsUsed() {
try { try {
template.exchange( template.exchange(
url + port restHelper.toUrl(Mapping.URL_WORKBASKETACCESSITEMS)
+ "/api/v1/workbasket-access-items/?sort-by=workbasket-key&order=asc&page=1&page-size=9&invalid=user_1_1", + "?sort-by=workbasket-key&order=asc&page=1&page-size=9&invalid=user_1_1", HttpMethod.GET,
HttpMethod.GET, request, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(WorkbasketAccessItemListResource.class)); ParameterizedTypeReference.forType(WorkbasketAccessItemListResource.class));
fail(); fail();
} catch (HttpClientErrorException e) { } catch (HttpClientErrorException e) {
@ -93,9 +79,10 @@ class WorkbasketAccessItemControllerIntTest {
@Test @Test
void testGetSecondPageSortedByWorkbasketKey() { void testGetSecondPageSortedByWorkbasketKey() {
String parameters = "/api/v1/workbasket-access-items?sort-by=workbasket-key&order=asc&page=2&page-size=9&access-ids=user_1_1"; String parameters = "?sort-by=workbasket-key&order=asc&page=2&page-size=9&access-ids=user_1_1";
ResponseEntity<WorkbasketAccessItemPaginatedListResource> response = template.exchange( ResponseEntity<WorkbasketAccessItemPaginatedListResource> response = template.exchange(
url + port + parameters, HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_WORKBASKETACCESSITEMS) + parameters, HttpMethod.GET,
restHelper.defaultRequest(),
ParameterizedTypeReference.forType(WorkbasketAccessItemPaginatedListResource.class)); ParameterizedTypeReference.forType(WorkbasketAccessItemPaginatedListResource.class));
assertEquals(1, response.getBody().getContent().size()); assertEquals(1, response.getBody().getContent().size());
assertEquals("user_1_1", response.getBody().getContent().iterator().next().accessId); assertEquals("user_1_1", response.getBody().getContent().iterator().next().accessId);
@ -115,9 +102,10 @@ class WorkbasketAccessItemControllerIntTest {
@Test @Test
void testRemoveWorkbasketAccessItemsOfUser() { void testRemoveWorkbasketAccessItemsOfUser() {
String parameters = "/api/v1/workbasket-access-items/?access-id=user_1_1"; String parameters = "?access-id=user_1_1";
ResponseEntity<Void> response = template.exchange( ResponseEntity<Void> response = template.exchange(
url + port + parameters, HttpMethod.DELETE, request, restHelper.toUrl(Mapping.URL_WORKBASKETACCESSITEMS) + parameters, HttpMethod.DELETE,
restHelper.defaultRequest(),
ParameterizedTypeReference.forType(Void.class)); ParameterizedTypeReference.forType(Void.class));
assertNull(response.getBody()); assertNull(response.getBody());
assertEquals(HttpStatus.NO_CONTENT, response.getStatusCode()); assertEquals(HttpStatus.NO_CONTENT, response.getStatusCode());
@ -125,31 +113,14 @@ class WorkbasketAccessItemControllerIntTest {
@Test @Test
void testGetBadRequestIfTryingToDeleteAccessItemsForGroup() { void testGetBadRequestIfTryingToDeleteAccessItemsForGroup() {
String parameters = "/api/v1/workbasket-access-items?access-id=cn=DevelopersGroup,ou=groups,o=TaskanaTest"; String parameters = "?access-id=cn=DevelopersGroup,ou=groups,o=TaskanaTest";
try { try {
ResponseEntity<Void> response = template.exchange( ResponseEntity<Void> response = template.exchange(
url + port + parameters, HttpMethod.DELETE, request, restHelper.toUrl(Mapping.URL_WORKBASKETACCESSITEMS) + parameters, HttpMethod.DELETE,
restHelper.defaultRequest(),
ParameterizedTypeReference.forType(Void.class)); ParameterizedTypeReference.forType(Void.class));
} catch (HttpClientErrorException e) { } catch (HttpClientErrorException e) {
assertEquals(HttpStatus.BAD_REQUEST, e.getStatusCode()); assertEquals(HttpStatus.BAD_REQUEST, e.getStatusCode());
} }
} }
/**
* Return a REST template which is capable of dealing with responses in HAL format.
*
* @return RestTemplate
*/
private RestTemplate getRestTemplate() {
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.registerModule(new Jackson2HalModule());
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
converter.setSupportedMediaTypes(MediaType.parseMediaTypes("application/hal+json"));
converter.setObjectMapper(mapper);
RestTemplate template = new RestTemplate(Collections.<HttpMessageConverter<?>>singletonList(converter));
return template;
}
} }

81
rest/taskana-rest-spring-test/src/test/java/pro/taskana/rest/WorkbasketControllerIntTest.java
View File

@ -6,29 +6,20 @@ import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail; import static org.junit.Assert.fail;
import java.util.Collections;
import java.util.Iterator; import java.util.Iterator;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.boot.web.server.LocalServerPort; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.ParameterizedTypeReference; import org.springframework.core.ParameterizedTypeReference;
import org.springframework.hateoas.Link; import org.springframework.hateoas.Link;
import org.springframework.hateoas.hal.Jackson2HalModule;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod; import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.client.HttpClientErrorException; import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate; import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.DeserializationFeature; import pro.taskana.RestHelper;
import com.fasterxml.jackson.databind.ObjectMapper;
import pro.taskana.TaskanaSpringBootTest; import pro.taskana.TaskanaSpringBootTest;
import pro.taskana.rest.resource.DistributionTargetListResource; import pro.taskana.rest.resource.DistributionTargetListResource;
import pro.taskana.rest.resource.DistributionTargetResource; import pro.taskana.rest.resource.DistributionTargetResource;
@ -41,24 +32,19 @@ import pro.taskana.rest.resource.WorkbasketSummaryListResource;
@TaskanaSpringBootTest @TaskanaSpringBootTest
class WorkbasketControllerIntTest { class WorkbasketControllerIntTest {
String url = "http://127.0.0.1:"; @Autowired RestHelper restHelper;
RestTemplate template;
HttpEntity<String> request;
@LocalServerPort
int port;
@BeforeEach private static RestTemplate template;
void before() {
template = getRestTemplate(); @BeforeAll
HttpHeaders headers = new HttpHeaders(); static void init() {
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x"); template = RestHelper.getRestTemplate();
request = new HttpEntity<String>(headers);
} }
@Test @Test
void testGetAllWorkbaskets() { void testGetAllWorkbaskets() {
ResponseEntity<WorkbasketSummaryListResource> response = template.exchange( ResponseEntity<WorkbasketSummaryListResource> response = template.exchange(
url + port + "/api/v1/workbaskets", HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_WORKBASKET), HttpMethod.GET, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(WorkbasketSummaryListResource.class)); ParameterizedTypeReference.forType(WorkbasketSummaryListResource.class));
assertNotNull(response.getBody().getLink(Link.REL_SELF)); assertNotNull(response.getBody().getLink(Link.REL_SELF));
} }
@ -66,7 +52,8 @@ class WorkbasketControllerIntTest {
@Test @Test
void testGetAllWorkbasketsBusinessAdminHasOpenPermission() { void testGetAllWorkbasketsBusinessAdminHasOpenPermission() {
ResponseEntity<WorkbasketSummaryListResource> response = template.exchange( ResponseEntity<WorkbasketSummaryListResource> response = template.exchange(
url + port + "/api/v1/workbaskets?required-permission=OPEN", HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_WORKBASKET) + "?required-permission=OPEN", HttpMethod.GET,
restHelper.defaultRequest(),
ParameterizedTypeReference.forType(WorkbasketSummaryListResource.class)); ParameterizedTypeReference.forType(WorkbasketSummaryListResource.class));
assertNotNull(response.getBody().getLink(Link.REL_SELF)); assertNotNull(response.getBody().getLink(Link.REL_SELF));
assertEquals(3, response.getBody().getContent().size()); assertEquals(3, response.getBody().getContent().size());
@ -74,9 +61,9 @@ class WorkbasketControllerIntTest {
@Test @Test
void testGetAllWorkbasketsKeepingFilters() { void testGetAllWorkbasketsKeepingFilters() {
String parameters = "/api/v1/workbaskets?type=PERSONAL&sort-by=key&order=desc"; String parameters = "?type=PERSONAL&sort-by=key&order=desc";
ResponseEntity<WorkbasketSummaryListResource> response = template.exchange( ResponseEntity<WorkbasketSummaryListResource> response = template.exchange(
url + port + parameters, HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_WORKBASKET) + parameters, HttpMethod.GET, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(WorkbasketSummaryListResource.class)); ParameterizedTypeReference.forType(WorkbasketSummaryListResource.class));
assertNotNull(response.getBody().getLink(Link.REL_SELF)); assertNotNull(response.getBody().getLink(Link.REL_SELF));
assertTrue(response.getBody() assertTrue(response.getBody()
@ -89,7 +76,8 @@ class WorkbasketControllerIntTest {
void testThrowsExceptionIfInvalidFilterIsUsed() { void testThrowsExceptionIfInvalidFilterIsUsed() {
try { try {
template.exchange( template.exchange(
url + port + "/api/v1/workbaskets?invalid=PERSONAL", HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_WORKBASKET) + "?invalid=PERSONAL", HttpMethod.GET,
restHelper.defaultRequest(),
ParameterizedTypeReference.forType(WorkbasketSummaryListResource.class)); ParameterizedTypeReference.forType(WorkbasketSummaryListResource.class));
fail(); fail();
} catch (HttpClientErrorException e) { } catch (HttpClientErrorException e) {
@ -101,9 +89,9 @@ class WorkbasketControllerIntTest {
@Test @Test
void testGetSecondPageSortedByKey() { void testGetSecondPageSortedByKey() {
String parameters = "/api/v1/workbaskets?sort-by=key&order=desc&page=2&page-size=5"; String parameters = "?sort-by=key&order=desc&page=2&page-size=5";
ResponseEntity<WorkbasketSummaryListResource> response = template.exchange( ResponseEntity<WorkbasketSummaryListResource> response = template.exchange(
url + port + parameters, HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_WORKBASKET) + parameters, HttpMethod.GET, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(WorkbasketSummaryListResource.class)); ParameterizedTypeReference.forType(WorkbasketSummaryListResource.class));
assertEquals(5, response.getBody().getContent().size()); assertEquals(5, response.getBody().getContent().size());
assertEquals("USER_1_1", response.getBody().getContent().iterator().next().getKey()); assertEquals("USER_1_1", response.getBody().getContent().iterator().next().getKey());
@ -120,39 +108,22 @@ class WorkbasketControllerIntTest {
@Test @Test
void testRemoveWorkbasketAsDistributionTarget() { void testRemoveWorkbasketAsDistributionTarget() {
String parameters = "/api/v1/workbaskets/distribution-targets/WBI:100000000000000000000000000000000007";
ResponseEntity<?> response = template.exchange( ResponseEntity<?> response = template.exchange(
url + port + parameters, HttpMethod.DELETE, request, restHelper.toUrl(Mapping.URL_WORKBASKET_DISTRIBUTION_ID, "WBI:100000000000000000000000000000000007"),
Void.class); HttpMethod.DELETE, restHelper.defaultRequest(),
Void.class
);
assertEquals(HttpStatus.NO_CONTENT, response.getStatusCode()); assertEquals(HttpStatus.NO_CONTENT, response.getStatusCode());
ResponseEntity<DistributionTargetListResource> response2 = template.exchange( ResponseEntity<DistributionTargetListResource> response2 = template.exchange(
url + port + "/api/v1/workbaskets/WBI:100000000000000000000000000000000002/distribution-targets", restHelper.toUrl(Mapping.URL_WORKBASKET_ID_DISTRIBUTION, "WBI:100000000000000000000000000000000002"),
HttpMethod.GET, request, HttpMethod.GET, restHelper.defaultRequest(),
ParameterizedTypeReference.forType(DistributionTargetListResource.class)); ParameterizedTypeReference.forType(DistributionTargetListResource.class)
);
assertEquals(HttpStatus.OK, response2.getStatusCode()); assertEquals(HttpStatus.OK, response2.getStatusCode());
Iterator<DistributionTargetResource> iterator = response2.getBody().getContent().iterator(); Iterator<DistributionTargetResource> iterator = response2.getBody().getContent().iterator();
while (iterator.hasNext()) { while (iterator.hasNext()) {
assertNotEquals("WBI:100000000000000000000000000000000007", iterator.next().getWorkbasketId()); assertNotEquals("WBI:100000000000000000000000000000000007", iterator.next().getWorkbasketId());
} }
} }
/**
* Return a REST template which is capable of dealing with responses in HAL format.
*
* @return RestTemplate
*/
private RestTemplate getRestTemplate() {
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.registerModule(new Jackson2HalModule());
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
converter.setSupportedMediaTypes(MediaType.parseMediaTypes("application/hal+json"));
converter.setObjectMapper(mapper);
RestTemplate template = new RestTemplate(Collections.<HttpMessageConverter<?>>singletonList(converter));
return template;
}
} }

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

@ -11,33 +11,30 @@ import java.io.File;
import java.io.FileWriter; import java.io.FileWriter;
import java.io.IOException; import java.io.IOException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections;
import java.util.List; import java.util.List;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import org.springframework.boot.web.server.LocalServerPort; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.ParameterizedTypeReference; import org.springframework.core.ParameterizedTypeReference;
import org.springframework.core.io.FileSystemResource; import org.springframework.core.io.FileSystemResource;
import org.springframework.hateoas.hal.Jackson2HalModule;
import org.springframework.http.HttpEntity; import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders; import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod; import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType; import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.util.LinkedMultiValueMap; import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap; import org.springframework.util.MultiValueMap;
import org.springframework.web.client.HttpClientErrorException; import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate; import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.ObjectMapper;
import pro.taskana.RestHelper;
import pro.taskana.TaskanaSpringBootTest; import pro.taskana.TaskanaSpringBootTest;
import pro.taskana.rest.resource.WorkbasketDefinitionResource; import pro.taskana.rest.resource.WorkbasketDefinitionResource;
@ -49,26 +46,27 @@ import pro.taskana.rest.resource.WorkbasketDefinitionResource;
class WorkbasketDefinitionControllerIntTest { class WorkbasketDefinitionControllerIntTest {
private static final Logger LOGGER = LoggerFactory.getLogger(ClassificationController.class); private static final Logger LOGGER = LoggerFactory.getLogger(ClassificationController.class);
private String server = "http://127.0.0.1:";
private RestTemplate template;
private HttpEntity<String> request;
private HttpHeaders headers = new HttpHeaders();
private ObjectMapper objMapper = new ObjectMapper(); private ObjectMapper objMapper = new ObjectMapper();
@LocalServerPort
private int port; @Autowired RestHelper restHelper;
private static RestTemplate template;
@BeforeAll
static void init() {
template = RestHelper.getRestTemplate();
}
@BeforeEach @BeforeEach
void before() { void before() {
LOGGER.debug("before"); LOGGER.debug("before");
template = getRestTemplate();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
request = new HttpEntity<String>(headers);
} }
@Test @Test
void testExportWorkbasketFromDomain() { void testExportWorkbasketFromDomain() {
ResponseEntity<List<WorkbasketDefinitionResource>> response = template.exchange( ResponseEntity<List<WorkbasketDefinitionResource>> response = template.exchange(
server + port + "/api/v1/workbasket-definitions?domain=DOMAIN_A", HttpMethod.GET, request, restHelper.toUrl(Mapping.URL_WORKBASKETDEFIITIONS) + "?domain=DOMAIN_A", HttpMethod.GET,
restHelper.defaultRequest(),
new ParameterizedTypeReference<List<WorkbasketDefinitionResource>>() { new ParameterizedTypeReference<List<WorkbasketDefinitionResource>>() {
}); });
@ -95,16 +93,19 @@ class WorkbasketDefinitionControllerIntTest {
@Test @Test
void testExportWorkbasketsFromWrongDomain() { void testExportWorkbasketsFromWrongDomain() {
ResponseEntity<List<WorkbasketDefinitionResource>> response = template.exchange( ResponseEntity<List<WorkbasketDefinitionResource>> response = template.exchange(
server + port + "/api/v1/workbasket-definitions?domain=wrongDomain", restHelper.toUrl(Mapping.URL_WORKBASKETDEFIITIONS) + "?domain=wrongDomain", HttpMethod.GET,
HttpMethod.GET, request, ParameterizedTypeReference.forType(List.class)); restHelper.defaultRequest(),
ParameterizedTypeReference.forType(List.class));
assertEquals(0, response.getBody().size()); assertEquals(0, response.getBody().size());
} }
@Test @Test
void testImportWorkbasket() throws IOException { void testImportWorkbasket() throws IOException {
ResponseEntity<List<WorkbasketDefinitionResource>> response = template.exchange( ResponseEntity<List<WorkbasketDefinitionResource>> response = template.exchange(
server + port + "/api/v1/workbasket-definitions?domain=DOMAIN_A",
HttpMethod.GET, request, ParameterizedTypeReference.forType(List.class)); restHelper.toUrl(Mapping.URL_WORKBASKETDEFIITIONS) + "?domain=DOMAIN_A", HttpMethod.GET,
restHelper.defaultRequest(),
ParameterizedTypeReference.forType(List.class));
List<String> list = new ArrayList<>(); List<String> list = new ArrayList<>();
list.add(objMapper.writeValueAsString(response.getBody().get(0))); list.add(objMapper.writeValueAsString(response.getBody().get(0)));
@ -115,8 +116,9 @@ class WorkbasketDefinitionControllerIntTest {
@Test @Test
void testFailOnImportDuplicates() throws IOException { void testFailOnImportDuplicates() throws IOException {
ResponseEntity<List<WorkbasketDefinitionResource>> response = template.exchange( ResponseEntity<List<WorkbasketDefinitionResource>> response = template.exchange(
server + port + "/api/v1/workbasket-definitions?domain=DOMAIN_A", restHelper.toUrl(Mapping.URL_WORKBASKETDEFIITIONS) + "?domain=DOMAIN_A", HttpMethod.GET,
HttpMethod.GET, request, new ParameterizedTypeReference<List<WorkbasketDefinitionResource>>() { restHelper.defaultRequest(),
new ParameterizedTypeReference<List<WorkbasketDefinitionResource>>() {
}); });
@ -135,8 +137,10 @@ class WorkbasketDefinitionControllerIntTest {
void testNoErrorWhenImportWithSameIdButDifferentKeyAndDomain() void testNoErrorWhenImportWithSameIdButDifferentKeyAndDomain()
throws IOException { throws IOException {
ResponseEntity<List<WorkbasketDefinitionResource>> response = template.exchange( ResponseEntity<List<WorkbasketDefinitionResource>> response = template.exchange(
server + port + "/api/v1/workbasket-definitions?domain=DOMAIN_A",
HttpMethod.GET, request, new ParameterizedTypeReference<List<WorkbasketDefinitionResource>>() { restHelper.toUrl(Mapping.URL_WORKBASKETDEFIITIONS) + "?domain=DOMAIN_A", HttpMethod.GET,
restHelper.defaultRequest(),
new ParameterizedTypeReference<List<WorkbasketDefinitionResource>>() {
}); });
@ -156,30 +160,13 @@ class WorkbasketDefinitionControllerIntTest {
writer.close(); writer.close();
MultiValueMap<String, Object> body = new LinkedMultiValueMap<>(); MultiValueMap<String, Object> body = new LinkedMultiValueMap<>();
HttpHeaders headers = restHelper.getHeaders();
headers.setContentType(MediaType.MULTIPART_FORM_DATA); headers.setContentType(MediaType.MULTIPART_FORM_DATA);
body.add("file", new FileSystemResource(tmpFile)); body.add("file", new FileSystemResource(tmpFile));
HttpEntity<MultiValueMap<String, Object>> requestEntity = new HttpEntity<>(body, headers); HttpEntity<MultiValueMap<String, Object>> requestEntity = new HttpEntity<>(body, headers);
String serverUrl = server + port + "/api/v1/workbasket-definitions"; String serverUrl = restHelper.toUrl(Mapping.URL_WORKBASKETDEFIITIONS);
RestTemplate restTemplate = new RestTemplate();
return restTemplate.postForEntity(serverUrl, requestEntity, Void.class); return template.postForEntity(serverUrl, requestEntity, Void.class);
}
/**
* Return a REST template which is capable of dealing with responses in HAL format.
*
* @return RestTemplate
*/
private RestTemplate getRestTemplate() {
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.registerModule(new Jackson2HalModule());
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
converter.setSupportedMediaTypes(MediaType.parseMediaTypes("application/haljson,*/*"));
converter.setObjectMapper(mapper);
return new RestTemplate(Collections.<HttpMessageConverter<?>>singletonList(converter));
} }
} }

6
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/AccessIdController.java
View File

@ -9,7 +9,6 @@ import org.springframework.hateoas.config.EnableHypermediaSupport;
import org.springframework.hateoas.config.EnableHypermediaSupport.HypermediaType; import org.springframework.hateoas.config.EnableHypermediaSupport.HypermediaType;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
@ -25,7 +24,6 @@ import pro.taskana.rest.resource.AccessIdResource;
*/ */
@RestController @RestController
@EnableHypermediaSupport(type = HypermediaType.HAL) @EnableHypermediaSupport(type = HypermediaType.HAL)
@RequestMapping(path = "/api/v1/access-ids", produces = "application/hal+json")
public class AccessIdController { public class AccessIdController {
private static final Logger LOGGER = LoggerFactory.getLogger(AccessIdController.class); private static final Logger LOGGER = LoggerFactory.getLogger(AccessIdController.class);
@ -35,7 +33,7 @@ public class AccessIdController {
private static LdapCache ldapCache; private static LdapCache ldapCache;
@GetMapping @GetMapping(path = Mapping.URL_ACCESSID)
public ResponseEntity<List<AccessIdResource>> validateAccessIds( public ResponseEntity<List<AccessIdResource>> validateAccessIds(
@RequestParam("search-for") String searchFor) throws InvalidArgumentException { @RequestParam("search-for") String searchFor) throws InvalidArgumentException {
LOGGER.debug("Entry to validateAccessIds(search-for= {})", searchFor); LOGGER.debug("Entry to validateAccessIds(search-for= {})", searchFor);
@ -68,7 +66,7 @@ public class AccessIdController {
} }
} }
@GetMapping(path = "/groups") @GetMapping(path = Mapping.URL_ACCESSID_GROUPS)
public ResponseEntity<List<AccessIdResource>> getGroupsByAccessId( public ResponseEntity<List<AccessIdResource>> getGroupsByAccessId(
@RequestParam("access-id") String accessId) throws InvalidArgumentException { @RequestParam("access-id") String accessId) throws InvalidArgumentException {
LOGGER.debug("Entry to getGroupsByAccessId(access-id= {})", accessId); LOGGER.debug("Entry to getGroupsByAccessId(access-id= {})", accessId);

12
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/ClassificationController.java
View File

@ -16,7 +16,6 @@ import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping; import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
@ -43,7 +42,6 @@ import pro.taskana.rest.resource.PagedResources.PageMetadata;
*/ */
@RestController @RestController
@EnableHypermediaSupport(type = HypermediaType.HAL) @EnableHypermediaSupport(type = HypermediaType.HAL)
@RequestMapping(path = "/api/v1/classifications", produces = "application/hal+json")
public class ClassificationController extends AbstractPagingController { public class ClassificationController extends AbstractPagingController {
private static final Logger LOGGER = LoggerFactory.getLogger(ClassificationController.class); private static final Logger LOGGER = LoggerFactory.getLogger(ClassificationController.class);
@ -97,7 +95,7 @@ public class ClassificationController extends AbstractPagingController {
this.classificationSummaryResourceAssembler = classificationSummaryResourceAssembler; this.classificationSummaryResourceAssembler = classificationSummaryResourceAssembler;
} }
@GetMapping @GetMapping(path = Mapping.URL_CLASSIFICATIONS)
@Transactional(readOnly = true, rollbackFor = Exception.class) @Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<ClassificationSummaryListResource> getClassifications( public ResponseEntity<ClassificationSummaryListResource> getClassifications(
@RequestParam MultiValueMap<String, String> params) throws InvalidArgumentException { @RequestParam MultiValueMap<String, String> params) throws InvalidArgumentException {
@ -123,7 +121,7 @@ public class ClassificationController extends AbstractPagingController {
return response; return response;
} }
@GetMapping(path = "/{classificationId}") @GetMapping(path = Mapping.URL_CLASSIFICATIONS_ID)
@Transactional(readOnly = true, rollbackFor = Exception.class) @Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<ClassificationResource> getClassification(@PathVariable String classificationId) public ResponseEntity<ClassificationResource> getClassification(@PathVariable String classificationId)
throws ClassificationNotFoundException { throws ClassificationNotFoundException {
@ -141,7 +139,7 @@ public class ClassificationController extends AbstractPagingController {
return response; return response;
} }
@PostMapping @PostMapping(path = Mapping.URL_CLASSIFICATIONS)
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public ResponseEntity<ClassificationResource> createClassification( public ResponseEntity<ClassificationResource> createClassification(
@RequestBody ClassificationResource resource) @RequestBody ClassificationResource resource)
@ -162,7 +160,7 @@ public class ClassificationController extends AbstractPagingController {
return response; return response;
} }
@PutMapping(path = "/{classificationId}") @PutMapping(path = Mapping.URL_CLASSIFICATIONS_ID)
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public ResponseEntity<ClassificationResource> updateClassification( public ResponseEntity<ClassificationResource> updateClassification(
@PathVariable(value = "classificationId") String classificationId, @RequestBody ClassificationResource resource) @PathVariable(value = "classificationId") String classificationId, @RequestBody ClassificationResource resource)
@ -191,7 +189,7 @@ public class ClassificationController extends AbstractPagingController {
return result; return result;
} }
@DeleteMapping(path = "/{classificationId}") @DeleteMapping(path = Mapping.URL_CLASSIFICATIONS_ID)
@Transactional(readOnly = true, rollbackFor = Exception.class) @Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<?> deleteClassification(@PathVariable String classificationId) public ResponseEntity<?> deleteClassification(@PathVariable String classificationId)
throws ClassificationNotFoundException, ClassificationInUseException, NotAuthorizedException { throws ClassificationNotFoundException, ClassificationInUseException, NotAuthorizedException {

9
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/ClassificationDefinitionController.java
View File

@ -12,12 +12,11 @@ import java.util.stream.Collectors;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import org.springframework.dao.DuplicateKeyException; import org.springframework.dao.DuplicateKeyException;
import org.springframework.http.MediaType; import org.springframework.hateoas.config.EnableHypermediaSupport;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile; import org.springframework.web.multipart.MultipartFile;
@ -44,7 +43,7 @@ import pro.taskana.rest.resource.ClassificationResourceAssembler;
* Controller for Importing / Exporting classifications. * Controller for Importing / Exporting classifications.
*/ */
@RestController @RestController
@RequestMapping(path = "/api/v1/classification-definitions", produces = {MediaType.APPLICATION_JSON_VALUE}) @EnableHypermediaSupport(type = EnableHypermediaSupport.HypermediaType.HAL)
public class ClassificationDefinitionController { public class ClassificationDefinitionController {
private static final Logger LOGGER = LoggerFactory.getLogger(ClassificationDefinitionController.class); private static final Logger LOGGER = LoggerFactory.getLogger(ClassificationDefinitionController.class);
@ -60,7 +59,7 @@ public class ClassificationDefinitionController {
this.classificationResourceAssembler = classificationResourceAssembler; this.classificationResourceAssembler = classificationResourceAssembler;
} }
@GetMapping @GetMapping(path = Mapping.URL_CLASSIFICATIONDEFINITION)
@Transactional(readOnly = true, rollbackFor = Exception.class) @Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<List<ClassificationResource>> exportClassifications( public ResponseEntity<List<ClassificationResource>> exportClassifications(
@RequestParam(required = false) String domain) @RequestParam(required = false) String domain)
@ -86,7 +85,7 @@ public class ClassificationDefinitionController {
return response; return response;
} }
@PostMapping @PostMapping(path = Mapping.URL_CLASSIFICATIONDEFINITION)
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public ResponseEntity<Void> importClassifications( public ResponseEntity<Void> importClassifications(
@RequestParam("file") MultipartFile file) @RequestParam("file") MultipartFile file)

53
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/Mapping.java Normal file
View File

@ -0,0 +1,53 @@
package pro.taskana.rest;
/**
* Collection of Url to Controller mappings.
*/
public final class Mapping {
private static final String PRE = "/api/v1/";
public static final String URL_ACCESSID = PRE + "access-ids";
public static final String URL_ACCESSID_GROUPS = URL_ACCESSID + "/groups";
public static final String URL_CLASSIFICATIONS = PRE + "classifications";
public static final String URL_CLASSIFICATIONS_ID = URL_CLASSIFICATIONS + "/{classificationId}";
public static final String URL_CLASSIFICATIONDEFINITION = PRE + "classification-definitions";
public static final String URL_MONITOR = PRE + "monitor";
public static final String URL_MONITOR_TASKSSTATUS = URL_MONITOR + "/tasks-status-report";
public static final String URL_MONITOR_TASKSWORKBASKET = URL_MONITOR + "/tasks-workbasket-report";
public static final String URL_MONITOR_TASKSWORKBASKETPLANNED =
URL_MONITOR + "/tasks-workbasket-planned-date-report";
public static final String URL_MONITOR_TASKSCLASSIFICATION = URL_MONITOR + "/tasks-classification-report";
public static final String URL_MONITOR_TIMESTAMP = URL_MONITOR + "/timestamp-report";
public static final String URL_DOMAIN = PRE + "domains";
public static final String URL_CLASSIFICATIONCATEGORIES = PRE + "classification-categories";
public static final String URL_CLASSIFICATIONTYPES = PRE + "classification-types";
public static final String URL_CURRENTUSER = PRE + "current-user-info";
public static final String URL_HISTORYENABLED = PRE + "history-provider-enabled";
public static final String URL_VERSION = PRE + "version";
public static final String URL_TASKS = PRE + "tasks";
public static final String URL_TASKS_ID = URL_TASKS + "/{taskId}";
public static final String URL_TASKS_ID_CLAIM = URL_TASKS_ID + "/claim";
public static final String URL_TASKS_ID_COMPLETE = URL_TASKS_ID + "/complete";
public static final String URL_TASKS_ID_TRANSFER_WORKBASKETID = URL_TASKS_ID + "/transfer/{workbasketId}";
public static final String URL_WORKBASKETACCESSITEMS = PRE + "workbasket-access-items";
public static final String URL_WORKBASKET = PRE + "workbaskets";
public static final String URL_WORKBASKET_ID = URL_WORKBASKET + "/{workbasketId}";
public static final String URL_WORKBASKET_ID_ACCESSITEMS = URL_WORKBASKET_ID + "/workbasketAccessItems";
public static final String URL_WORKBASKET_ID_DISTRIBUTION = URL_WORKBASKET_ID + "/distribution-targets";
//TODO @Deprecated
public static final String URL_WORKBASKET_DISTRIBUTION_ID = URL_WORKBASKET + "/distribution-targets/{workbasketId}";
public static final String URL_WORKBASKETDEFIITIONS = PRE + "workbasket-definitions";
private Mapping() {
}
}

14
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/MonitorController.java
View File

@ -8,11 +8,11 @@ import java.util.stream.Stream;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import org.springframework.hateoas.config.EnableHypermediaSupport;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
@ -28,7 +28,7 @@ import pro.taskana.rest.resource.ReportResourceAssembler;
* Controller for all monitoring endpoints. * Controller for all monitoring endpoints.
*/ */
@RestController @RestController
@RequestMapping(path = "/api/v1/monitor", produces = "application/hal+json") @EnableHypermediaSupport(type = EnableHypermediaSupport.HypermediaType.HAL)
public class MonitorController { public class MonitorController {
private static final Logger LOGGER = LoggerFactory.getLogger(MonitorController.class); private static final Logger LOGGER = LoggerFactory.getLogger(MonitorController.class);
@ -42,7 +42,7 @@ public class MonitorController {
this.reportResourceAssembler = reportResourceAssembler; this.reportResourceAssembler = reportResourceAssembler;
} }
@GetMapping(path = "/tasks-status-report") @GetMapping(path = Mapping.URL_MONITOR_TASKSSTATUS)
@Transactional(readOnly = true, rollbackFor = Exception.class) @Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<ReportResource> getTasksStatusReport(@RequestParam(required = false) List<String> domains, public ResponseEntity<ReportResource> getTasksStatusReport(@RequestParam(required = false) List<String> domains,
@RequestParam(required = false) List<TaskState> states) throws NotAuthorizedException, @RequestParam(required = false) List<TaskState> states) throws NotAuthorizedException,
@ -58,7 +58,7 @@ public class MonitorController {
return response; return response;
} }
@GetMapping(path = "/tasks-workbasket-report") @GetMapping(path = Mapping.URL_MONITOR_TASKSWORKBASKET)
@Transactional(readOnly = true, rollbackFor = Exception.class) @Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<?> getTasksWorkbasketReport( public ResponseEntity<?> getTasksWorkbasketReport(
@RequestParam(value = "states") List<TaskState> states) @RequestParam(value = "states") List<TaskState> states)
@ -80,7 +80,7 @@ public class MonitorController {
} }
@GetMapping(path = "/tasks-workbasket-planned-date-report") @GetMapping(path = Mapping.URL_MONITOR_TASKSWORKBASKETPLANNED)
@Transactional(readOnly = true, rollbackFor = Exception.class) @Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<?> getTasksWorkbasketPlannedDateReport( public ResponseEntity<?> getTasksWorkbasketPlannedDateReport(
@RequestParam(value = "daysInPast") int daysInPast, @RequestParam(value = "daysInPast") int daysInPast,
@ -103,7 +103,7 @@ public class MonitorController {
} }
@GetMapping(path = "/tasks-classification-report") @GetMapping(path = Mapping.URL_MONITOR_TASKSCLASSIFICATION)
@Transactional(readOnly = true, rollbackFor = Exception.class) @Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<ReportResource> getTasksClassificationReport() public ResponseEntity<ReportResource> getTasksClassificationReport()
throws NotAuthorizedException, InvalidArgumentException { throws NotAuthorizedException, InvalidArgumentException {
@ -122,7 +122,7 @@ public class MonitorController {
.body(report); .body(report);
} }
@GetMapping(path = "/timestamp-report") @GetMapping(path = Mapping.URL_MONITOR_TIMESTAMP)
@Transactional(readOnly = true, rollbackFor = Exception.class) @Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<ReportResource> getDailyEntryExitReport() public ResponseEntity<ReportResource> getDailyEntryExitReport()
throws NotAuthorizedException, InvalidArgumentException { throws NotAuthorizedException, InvalidArgumentException {

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

@ -11,13 +11,13 @@ import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.MultiValueMap; import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping; import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
@ -49,7 +49,6 @@ import pro.taskana.rest.resource.TaskSummaryResourceAssembler;
*/ */
@RestController @RestController
@EnableHypermediaSupport(type = HypermediaType.HAL) @EnableHypermediaSupport(type = HypermediaType.HAL)
@RequestMapping(path = "/api/v1/tasks", produces = "application/hal+json")
public class TaskController extends AbstractPagingController { public class TaskController extends AbstractPagingController {
private static final Logger LOGGER = LoggerFactory.getLogger(TaskController.class); private static final Logger LOGGER = LoggerFactory.getLogger(TaskController.class);
@ -94,7 +93,7 @@ public class TaskController extends AbstractPagingController {
this.taskSummaryResourceAssembler = taskSummaryResourceAssembler; this.taskSummaryResourceAssembler = taskSummaryResourceAssembler;
} }
@GetMapping @GetMapping(path = Mapping.URL_TASKS)
@Transactional(readOnly = true, rollbackFor = Exception.class) @Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<TaskSummaryListResource> getTasks( public ResponseEntity<TaskSummaryListResource> getTasks(
@RequestParam MultiValueMap<String, String> params) throws InvalidArgumentException { @RequestParam MultiValueMap<String, String> params) throws InvalidArgumentException {
@ -119,7 +118,7 @@ public class TaskController extends AbstractPagingController {
return response; return response;
} }
@GetMapping(path = "/{taskId}") @GetMapping(path = Mapping.URL_TASKS_ID)
@Transactional(readOnly = true, rollbackFor = Exception.class) @Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<TaskResource> getTask(@PathVariable String taskId) public ResponseEntity<TaskResource> getTask(@PathVariable String taskId)
throws TaskNotFoundException, NotAuthorizedException { throws TaskNotFoundException, NotAuthorizedException {
@ -133,7 +132,7 @@ public class TaskController extends AbstractPagingController {
return result; return result;
} }
@PostMapping(path = "/{taskId}/claim") @PostMapping(path = Mapping.URL_TASKS_ID_CLAIM)
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public ResponseEntity<TaskResource> claimTask(@PathVariable String taskId, @RequestBody String userName) public ResponseEntity<TaskResource> claimTask(@PathVariable String taskId, @RequestBody String userName)
throws TaskNotFoundException, InvalidStateException, InvalidOwnerException, NotAuthorizedException { throws TaskNotFoundException, InvalidStateException, InvalidOwnerException, NotAuthorizedException {
@ -149,7 +148,7 @@ public class TaskController extends AbstractPagingController {
return result; return result;
} }
@RequestMapping(method = RequestMethod.POST, value = "/{taskId}/complete") @PostMapping(path = Mapping.URL_TASKS_ID_COMPLETE)
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public ResponseEntity<TaskResource> completeTask(@PathVariable String taskId) public ResponseEntity<TaskResource> completeTask(@PathVariable String taskId)
throws TaskNotFoundException, InvalidOwnerException, InvalidStateException, NotAuthorizedException { throws TaskNotFoundException, InvalidOwnerException, InvalidStateException, NotAuthorizedException {
@ -164,7 +163,7 @@ public class TaskController extends AbstractPagingController {
return result; return result;
} }
@RequestMapping(method = RequestMethod.DELETE, value = "/{taskId}") @DeleteMapping(path = Mapping.URL_TASKS_ID)
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public ResponseEntity<TaskResource> deleteTask(@PathVariable String taskId) public ResponseEntity<TaskResource> deleteTask(@PathVariable String taskId)
throws TaskNotFoundException, InvalidStateException, NotAuthorizedException { throws TaskNotFoundException, InvalidStateException, NotAuthorizedException {
@ -175,7 +174,7 @@ public class TaskController extends AbstractPagingController {
return result; return result;
} }
@RequestMapping(method = RequestMethod.POST) @PostMapping(path = Mapping.URL_TASKS)
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public ResponseEntity<TaskResource> createTask(@RequestBody TaskResource taskResource) public ResponseEntity<TaskResource> createTask(@RequestBody TaskResource taskResource)
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException, throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
@ -194,7 +193,7 @@ public class TaskController extends AbstractPagingController {
return result; return result;
} }
@RequestMapping(path = "/{taskId}/transfer/{workbasketId}") @RequestMapping(path = Mapping.URL_TASKS_ID_TRANSFER_WORKBASKETID)
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public ResponseEntity<TaskResource> transferTask(@PathVariable String taskId, @PathVariable String workbasketId) public ResponseEntity<TaskResource> transferTask(@PathVariable String taskId, @PathVariable String workbasketId)
throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, InvalidStateException { throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException, InvalidStateException {
@ -208,7 +207,7 @@ public class TaskController extends AbstractPagingController {
return result; return result;
} }
@PutMapping(path = "/{taskId}") @PutMapping(path = Mapping.URL_TASKS_ID)
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public ResponseEntity<TaskResource> updateTask( public ResponseEntity<TaskResource> updateTask(
@PathVariable(value = "taskId") String taskId, @PathVariable(value = "taskId") String taskId,

17
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/TaskanaEngineController.java
View File

@ -5,10 +5,9 @@ import java.util.List;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value; import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType; import org.springframework.hateoas.config.EnableHypermediaSupport;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
import pro.taskana.TaskanaEngine; import pro.taskana.TaskanaEngine;
@ -22,7 +21,7 @@ import pro.taskana.security.CurrentUserContext;
* Controller for TaskanaEngine related tasks. * Controller for TaskanaEngine related tasks.
*/ */
@RestController @RestController
@RequestMapping(path = "/api/v1", produces = MediaType.APPLICATION_JSON_VALUE) @EnableHypermediaSupport(type = EnableHypermediaSupport.HypermediaType.HAL)
public class TaskanaEngineController { public class TaskanaEngineController {
private static final Logger LOGGER = LoggerFactory.getLogger(TaskanaEngineController.class); private static final Logger LOGGER = LoggerFactory.getLogger(TaskanaEngineController.class);
@ -38,7 +37,7 @@ public class TaskanaEngineController {
this.taskanaEngine = taskanaEngine; this.taskanaEngine = taskanaEngine;
} }
@GetMapping(path = "/domains") @GetMapping(path = Mapping.URL_DOMAIN)
public ResponseEntity<List<String>> getDomains() { public ResponseEntity<List<String>> getDomains() {
ResponseEntity<List<String>> response = ResponseEntity.ok(taskanaEngineConfiguration.getDomains()); ResponseEntity<List<String>> response = ResponseEntity.ok(taskanaEngineConfiguration.getDomains());
if (LOGGER.isDebugEnabled()) { if (LOGGER.isDebugEnabled()) {
@ -47,7 +46,7 @@ public class TaskanaEngineController {
return response; return response;
} }
@GetMapping(path = "/classification-categories") @GetMapping(path = Mapping.URL_CLASSIFICATIONCATEGORIES)
public ResponseEntity<List<String>> getClassificationCategories(String type) { public ResponseEntity<List<String>> getClassificationCategories(String type) {
LOGGER.debug("Entry to getClassificationCategories(type = {})", type); LOGGER.debug("Entry to getClassificationCategories(type = {})", type);
ResponseEntity<List<String>> response; ResponseEntity<List<String>> response;
@ -65,7 +64,7 @@ public class TaskanaEngineController {
return response; return response;
} }
@GetMapping(path = "/classification-types") @GetMapping(path = Mapping.URL_CLASSIFICATIONTYPES)
public ResponseEntity<List<String>> getClassificationTypes() { public ResponseEntity<List<String>> getClassificationTypes() {
ResponseEntity<List<String>> response = ResponseEntity.ok( ResponseEntity<List<String>> response = ResponseEntity.ok(
taskanaEngineConfiguration.getClassificationTypes()); taskanaEngineConfiguration.getClassificationTypes());
@ -75,7 +74,7 @@ public class TaskanaEngineController {
return response; return response;
} }
@GetMapping(path = "/current-user-info") @GetMapping(path = Mapping.URL_CURRENTUSER)
public ResponseEntity<TaskanaUserInfoResource> getCurrentUserInfo() { public ResponseEntity<TaskanaUserInfoResource> getCurrentUserInfo() {
LOGGER.debug("Entry to getCurrentUserInfo()"); LOGGER.debug("Entry to getCurrentUserInfo()");
TaskanaUserInfoResource resource = new TaskanaUserInfoResource(); TaskanaUserInfoResource resource = new TaskanaUserInfoResource();
@ -94,7 +93,7 @@ public class TaskanaEngineController {
return response; return response;
} }
@GetMapping(path = "/history-provider-enabled") @GetMapping(path = Mapping.URL_HISTORYENABLED)
public ResponseEntity<Boolean> getIsHistoryProviderEnabled() { public ResponseEntity<Boolean> getIsHistoryProviderEnabled() {
ResponseEntity<Boolean> response = ResponseEntity.ok(taskanaEngine.isHistoryEnabled()); ResponseEntity<Boolean> response = ResponseEntity.ok(taskanaEngine.isHistoryEnabled());
LOGGER.debug("Exit from getIsHistoryProviderEnabled(), returning {}", response); LOGGER.debug("Exit from getIsHistoryProviderEnabled(), returning {}", response);
@ -106,7 +105,7 @@ public class TaskanaEngineController {
* *
* @return The current version. * @return The current version.
*/ */
@GetMapping(path = "/version") @GetMapping(path = Mapping.URL_VERSION)
public ResponseEntity<VersionResource> currentVersion() { public ResponseEntity<VersionResource> currentVersion() {
LOGGER.debug("Entry to currentVersion()"); LOGGER.debug("Entry to currentVersion()");
VersionResource resource = new VersionResource(); VersionResource resource = new VersionResource();

3
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/TaskanaRestExceptionHandler.java
View File

@ -124,7 +124,8 @@ public class TaskanaRestExceptionHandler extends ResponseEntityExceptionHandler
} }
@ExceptionHandler(MaxUploadSizeExceededException.class) @ExceptionHandler(MaxUploadSizeExceededException.class)
protected ResponseEntity<Object> handleMaxUploadSizeExceededException(MaxUploadSizeExceededException ex, WebRequest req) { protected ResponseEntity<Object> handleMaxUploadSizeExceededException(MaxUploadSizeExceededException ex,
WebRequest req) {
return buildResponse(ex, req, HttpStatus.PAYLOAD_TOO_LARGE); return buildResponse(ex, req, HttpStatus.PAYLOAD_TOO_LARGE);
} }

6
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/WorkbasketAccessItemController.java
View File

@ -12,7 +12,6 @@ import org.springframework.http.ResponseEntity;
import org.springframework.util.MultiValueMap; import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.DeleteMapping; import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
@ -32,7 +31,6 @@ import pro.taskana.rest.resource.WorkbasketAccessItemResourceAssembler;
*/ */
@RestController @RestController
@EnableHypermediaSupport(type = EnableHypermediaSupport.HypermediaType.HAL) @EnableHypermediaSupport(type = EnableHypermediaSupport.HypermediaType.HAL)
@RequestMapping(path = "/api/v1/workbasket-access-items", produces = "application/hal+json")
public class WorkbasketAccessItemController extends AbstractPagingController { public class WorkbasketAccessItemController extends AbstractPagingController {
private static final Logger LOGGER = LoggerFactory.getLogger(WorkbasketAccessItemController.class); private static final Logger LOGGER = LoggerFactory.getLogger(WorkbasketAccessItemController.class);
@ -67,7 +65,7 @@ public class WorkbasketAccessItemController extends AbstractPagingController {
* @throws InvalidArgumentException * @throws InvalidArgumentException
* if some argument is invalid. * if some argument is invalid.
*/ */
@GetMapping @GetMapping(path = Mapping.URL_WORKBASKETACCESSITEMS)
public ResponseEntity<WorkbasketAccessItemPaginatedListResource> getWorkbasketAccessItems( public ResponseEntity<WorkbasketAccessItemPaginatedListResource> getWorkbasketAccessItems(
@RequestParam MultiValueMap<String, String> params) @RequestParam MultiValueMap<String, String> params)
throws NotAuthorizedException, InvalidArgumentException { throws NotAuthorizedException, InvalidArgumentException {
@ -106,7 +104,7 @@ public class WorkbasketAccessItemController extends AbstractPagingController {
* @throws InvalidArgumentException * @throws InvalidArgumentException
* if some argument is invalid. * if some argument is invalid.
*/ */
@DeleteMapping @DeleteMapping(path = Mapping.URL_WORKBASKETACCESSITEMS)
public ResponseEntity<Void> removeWorkbasketAccessItems( public ResponseEntity<Void> removeWorkbasketAccessItems(
@RequestParam("access-id") String accessId) @RequestParam("access-id") String accessId)
throws NotAuthorizedException, InvalidArgumentException { throws NotAuthorizedException, InvalidArgumentException {

24
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/WorkbasketController.java
View File

@ -19,7 +19,6 @@ import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping; import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
@ -54,9 +53,9 @@ import pro.taskana.rest.resource.WorkbasketSummaryResourceAssembler;
/** /**
* Controller for all {@link Workbasket} related endpoints. * Controller for all {@link Workbasket} related endpoints.
*/ */
@RestController @RestController
@EnableHypermediaSupport(type = HypermediaType.HAL) @EnableHypermediaSupport(type = HypermediaType.HAL)
@RequestMapping(path = "/api/v1/workbaskets", produces = "application/hal+json")
public class WorkbasketController extends AbstractPagingController { public class WorkbasketController extends AbstractPagingController {
private static final Logger LOGGER = LoggerFactory.getLogger(WorkbasketController.class); private static final Logger LOGGER = LoggerFactory.getLogger(WorkbasketController.class);
@ -99,7 +98,7 @@ public class WorkbasketController extends AbstractPagingController {
this.workbasketAccessItemResourceAssembler = workbasketAccessItemResourceAssembler; this.workbasketAccessItemResourceAssembler = workbasketAccessItemResourceAssembler;
} }
@GetMapping @GetMapping(path = Mapping.URL_WORKBASKET)
@Transactional(readOnly = true, rollbackFor = Exception.class) @Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<WorkbasketSummaryListResource> getWorkbaskets( public ResponseEntity<WorkbasketSummaryListResource> getWorkbaskets(
@RequestParam MultiValueMap<String, String> params) throws InvalidArgumentException { @RequestParam MultiValueMap<String, String> params) throws InvalidArgumentException {
@ -125,7 +124,7 @@ public class WorkbasketController extends AbstractPagingController {
return response; return response;
} }
@GetMapping(path = "/{workbasketId}") @GetMapping(path = Mapping.URL_WORKBASKET_ID)
@Transactional(readOnly = true, rollbackFor = Exception.class) @Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<WorkbasketResource> getWorkbasket(@PathVariable(value = "workbasketId") String workbasketId) public ResponseEntity<WorkbasketResource> getWorkbasket(@PathVariable(value = "workbasketId") String workbasketId)
throws WorkbasketNotFoundException, NotAuthorizedException { throws WorkbasketNotFoundException, NotAuthorizedException {
@ -140,7 +139,7 @@ public class WorkbasketController extends AbstractPagingController {
return result; return result;
} }
@DeleteMapping(path = "/{workbasketId}") @DeleteMapping(path = Mapping.URL_WORKBASKET_ID)
@Transactional(rollbackFor = Exception.class, noRollbackFor = WorkbasketNotFoundException.class) @Transactional(rollbackFor = Exception.class, noRollbackFor = WorkbasketNotFoundException.class)
public ResponseEntity<?> markWorkbasketForDeletion(@PathVariable(value = "workbasketId") String workbasketId) public ResponseEntity<?> markWorkbasketForDeletion(@PathVariable(value = "workbasketId") String workbasketId)
throws NotAuthorizedException, InvalidArgumentException, throws NotAuthorizedException, InvalidArgumentException,
@ -152,7 +151,7 @@ public class WorkbasketController extends AbstractPagingController {
return response; return response;
} }
@PostMapping @PostMapping(path = Mapping.URL_WORKBASKET)
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public ResponseEntity<WorkbasketResource> createWorkbasket(@RequestBody WorkbasketResource workbasketResource) public ResponseEntity<WorkbasketResource> createWorkbasket(@RequestBody WorkbasketResource workbasketResource)
throws InvalidWorkbasketException, NotAuthorizedException, WorkbasketAlreadyExistException, throws InvalidWorkbasketException, NotAuthorizedException, WorkbasketAlreadyExistException,
@ -172,7 +171,7 @@ public class WorkbasketController extends AbstractPagingController {
return response; return response;
} }
@PutMapping(path = "/{workbasketId}") @PutMapping(path = Mapping.URL_WORKBASKET_ID)
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public ResponseEntity<WorkbasketResource> updateWorkbasket( public ResponseEntity<WorkbasketResource> updateWorkbasket(
@PathVariable(value = "workbasketId") String workbasketId, @PathVariable(value = "workbasketId") String workbasketId,
@ -198,7 +197,7 @@ public class WorkbasketController extends AbstractPagingController {
return result; return result;
} }
@GetMapping(path = "/{workbasketId}/workbasketAccessItems") @GetMapping(path = Mapping.URL_WORKBASKET_ID_ACCESSITEMS)
@Transactional(readOnly = true, rollbackFor = Exception.class) @Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<WorkbasketAccessItemListResource> getWorkbasketAccessItems( public ResponseEntity<WorkbasketAccessItemListResource> getWorkbasketAccessItems(
@PathVariable(value = "workbasketId") String workbasketId) @PathVariable(value = "workbasketId") String workbasketId)
@ -215,7 +214,7 @@ public class WorkbasketController extends AbstractPagingController {
return result; return result;
} }
@PutMapping(value = "/{workbasketId}/workbasketAccessItems") @PutMapping(path = Mapping.URL_WORKBASKET_ID_ACCESSITEMS)
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public ResponseEntity<WorkbasketAccessItemListResource> setWorkbasketAccessItems( public ResponseEntity<WorkbasketAccessItemListResource> setWorkbasketAccessItems(
@PathVariable(value = "workbasketId") String workbasketId, @PathVariable(value = "workbasketId") String workbasketId,
@ -241,7 +240,7 @@ public class WorkbasketController extends AbstractPagingController {
return response; return response;
} }
@GetMapping(path = "/{workbasketId}/distribution-targets") @GetMapping(path = Mapping.URL_WORKBASKET_ID_DISTRIBUTION)
@Transactional(readOnly = true, rollbackFor = Exception.class) @Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<DistributionTargetListResource> getDistributionTargets( public ResponseEntity<DistributionTargetListResource> getDistributionTargets(
@PathVariable(value = "workbasketId") String workbasketId) @PathVariable(value = "workbasketId") String workbasketId)
@ -259,7 +258,7 @@ public class WorkbasketController extends AbstractPagingController {
return result; return result;
} }
@PutMapping(path = "/{workbasketId}/distribution-targets") @PutMapping(path = Mapping.URL_WORKBASKET_ID_DISTRIBUTION)
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public ResponseEntity<DistributionTargetListResource> setDistributionTargetsForWorkbasketId( public ResponseEntity<DistributionTargetListResource> setDistributionTargetsForWorkbasketId(
@PathVariable(value = "workbasketId") String sourceWorkbasketId, @PathVariable(value = "workbasketId") String sourceWorkbasketId,
@ -282,7 +281,8 @@ public class WorkbasketController extends AbstractPagingController {
return response; return response;
} }
@DeleteMapping(path = "/distribution-targets/{workbasketId}") // TODO - schema inconsistent with PUT and GET
@DeleteMapping(path = Mapping.URL_WORKBASKET_DISTRIBUTION_ID)
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public ResponseEntity<Resources<DistributionTargetResource>> removeDistributionTargetForWorkbasketId( public ResponseEntity<Resources<DistributionTargetResource>> removeDistributionTargetForWorkbasketId(
@PathVariable(value = "workbasketId") String targetWorkbasketId) @PathVariable(value = "workbasketId") String targetWorkbasketId)

10
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/WorkbasketDefinitionController.java
View File

@ -12,12 +12,11 @@ import java.util.stream.Collectors;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import org.springframework.dao.DuplicateKeyException; import org.springframework.dao.DuplicateKeyException;
import org.springframework.http.MediaType; import org.springframework.hateoas.config.EnableHypermediaSupport;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile; import org.springframework.web.multipart.MultipartFile;
@ -45,8 +44,9 @@ import pro.taskana.rest.resource.WorkbasketResource;
/** /**
* Controller for all {@link WorkbasketDefinitionResource} related endpoints. * Controller for all {@link WorkbasketDefinitionResource} related endpoints.
*/ */
@RestController @RestController
@RequestMapping(path = "/api/v1/workbasket-definitions", produces = {MediaType.APPLICATION_JSON_VALUE}) @EnableHypermediaSupport(type = EnableHypermediaSupport.HypermediaType.HAL)
public class WorkbasketDefinitionController { public class WorkbasketDefinitionController {
private static final Logger LOGGER = LoggerFactory.getLogger(WorkbasketDefinitionController.class); private static final Logger LOGGER = LoggerFactory.getLogger(WorkbasketDefinitionController.class);
@ -62,7 +62,7 @@ public class WorkbasketDefinitionController {
this.workbasketDefinitionAssembler = workbasketDefinitionAssembler; this.workbasketDefinitionAssembler = workbasketDefinitionAssembler;
} }
@GetMapping @GetMapping(path = Mapping.URL_WORKBASKETDEFIITIONS)
@Transactional(readOnly = true, rollbackFor = Exception.class) @Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<List<WorkbasketDefinitionResource>> exportWorkbaskets( public ResponseEntity<List<WorkbasketDefinitionResource>> exportWorkbaskets(
@RequestParam(required = false) String domain) @RequestParam(required = false) String domain)
@ -110,7 +110,7 @@ public class WorkbasketDefinitionController {
* @throws InvalidArgumentException * @throws InvalidArgumentException
* if authorization information in workbaskets definitions is incorrect. * if authorization information in workbaskets definitions is incorrect.
*/ */
@PostMapping @PostMapping(path = Mapping.URL_WORKBASKETDEFIITIONS)
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public ResponseEntity<Void> importWorkbaskets(@RequestParam("file") MultipartFile file) public ResponseEntity<Void> importWorkbaskets(@RequestParam("file") MultipartFile file)
throws IOException, NotAuthorizedException, DomainNotFoundException, InvalidWorkbasketException, throws IOException, NotAuthorizedException, DomainNotFoundException, InvalidWorkbasketException,

3
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/resource/ClassificationSummaryResourceAssembler.java
View File

@ -11,6 +11,7 @@ import pro.taskana.ClassificationService;
import pro.taskana.ClassificationSummary; import pro.taskana.ClassificationSummary;
import pro.taskana.impl.ClassificationImpl; import pro.taskana.impl.ClassificationImpl;
import pro.taskana.rest.ClassificationController; import pro.taskana.rest.ClassificationController;
import pro.taskana.rest.Mapping;
import pro.taskana.rest.resource.PagedResources.PageMetadata; import pro.taskana.rest.resource.PagedResources.PageMetadata;
import pro.taskana.rest.resource.links.PageLinks; import pro.taskana.rest.resource.links.PageLinks;
@ -43,7 +44,7 @@ public class ClassificationSummaryResourceAssembler
return classification.asSummary(); return classification.asSummary();
} }
@PageLinks(ClassificationController.class) @PageLinks(Mapping.URL_CLASSIFICATIONS)
public ClassificationSummaryListResource toResources(Collection<ClassificationSummary> entities, public ClassificationSummaryListResource toResources(Collection<ClassificationSummary> entities,
PageMetadata pageMetadata) { PageMetadata pageMetadata) {
return new ClassificationSummaryListResource(toResources(entities), pageMetadata); return new ClassificationSummaryListResource(toResources(entities), pageMetadata);

3
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/resource/TaskSummaryResourceAssembler.java
View File

@ -8,6 +8,7 @@ import org.springframework.stereotype.Component;
import pro.taskana.TaskSummary; import pro.taskana.TaskSummary;
import pro.taskana.exceptions.InvalidArgumentException; import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.SystemException; import pro.taskana.exceptions.SystemException;
import pro.taskana.rest.Mapping;
import pro.taskana.rest.TaskController; import pro.taskana.rest.TaskController;
import pro.taskana.rest.resource.PagedResources.PageMetadata; import pro.taskana.rest.resource.PagedResources.PageMetadata;
import pro.taskana.rest.resource.links.PageLinks; import pro.taskana.rest.resource.links.PageLinks;
@ -34,7 +35,7 @@ public class TaskSummaryResourceAssembler
} }
} }
@PageLinks(TaskController.class) @PageLinks(Mapping.URL_TASKS)
public TaskSummaryListResource toResources(List<TaskSummary> taskSummaries, PageMetadata pageMetadata) { public TaskSummaryListResource toResources(List<TaskSummary> taskSummaries, PageMetadata pageMetadata) {
return new TaskSummaryListResource(toResources(taskSummaries), pageMetadata); return new TaskSummaryListResource(toResources(taskSummaries), pageMetadata);
} }

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

@ -15,7 +15,7 @@ import pro.taskana.WorkbasketService;
import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.exceptions.WorkbasketNotFoundException; import pro.taskana.exceptions.WorkbasketNotFoundException;
import pro.taskana.impl.WorkbasketAccessItemImpl; import pro.taskana.impl.WorkbasketAccessItemImpl;
import pro.taskana.rest.WorkbasketAccessItemController; import pro.taskana.rest.Mapping;
import pro.taskana.rest.WorkbasketController; import pro.taskana.rest.WorkbasketController;
import pro.taskana.rest.resource.PagedResources.PageMetadata; import pro.taskana.rest.resource.PagedResources.PageMetadata;
import pro.taskana.rest.resource.links.PageLinks; import pro.taskana.rest.resource.links.PageLinks;
@ -48,7 +48,7 @@ public class WorkbasketAccessItemResourceAssembler extends
return wbAccItemModel; return wbAccItemModel;
} }
@PageLinks(WorkbasketAccessItemController.class) @PageLinks(Mapping.URL_WORKBASKETACCESSITEMS)
public WorkbasketAccessItemPaginatedListResource toResources( public WorkbasketAccessItemPaginatedListResource toResources(
List<WorkbasketAccessItem> entities, PageMetadata pageMetadata) { List<WorkbasketAccessItem> entities, PageMetadata pageMetadata) {
return new WorkbasketAccessItemPaginatedListResource(toResources(entities), pageMetadata); return new WorkbasketAccessItemPaginatedListResource(toResources(entities), pageMetadata);

3
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/resource/WorkbasketSummaryResourceAssembler.java
View File

@ -10,6 +10,7 @@ import org.springframework.stereotype.Component;
import pro.taskana.WorkbasketService; import pro.taskana.WorkbasketService;
import pro.taskana.WorkbasketSummary; import pro.taskana.WorkbasketSummary;
import pro.taskana.impl.WorkbasketImpl; import pro.taskana.impl.WorkbasketImpl;
import pro.taskana.rest.Mapping;
import pro.taskana.rest.WorkbasketController; import pro.taskana.rest.WorkbasketController;
import pro.taskana.rest.resource.PagedResources.PageMetadata; import pro.taskana.rest.resource.PagedResources.PageMetadata;
import pro.taskana.rest.resource.links.PageLinks; import pro.taskana.rest.resource.links.PageLinks;
@ -33,7 +34,7 @@ public class WorkbasketSummaryResourceAssembler
return new WorkbasketSummaryResource(workbasketSummary); return new WorkbasketSummaryResource(workbasketSummary);
} }
@PageLinks(WorkbasketController.class) @PageLinks(Mapping.URL_WORKBASKET)
public WorkbasketSummaryListResource toResources(List<WorkbasketSummary> entities, public WorkbasketSummaryListResource toResources(List<WorkbasketSummary> entities,
PageMetadata pageMetadata) { PageMetadata pageMetadata) {
return new WorkbasketSummaryListResource(toResources(entities), pageMetadata); return new WorkbasketSummaryListResource(toResources(entities), pageMetadata);

3
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/resource/links/PageLinks.java
View File

@ -11,5 +11,6 @@ import java.lang.annotation.Target;
@Target(ElementType.METHOD) @Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME) @Retention(RetentionPolicy.RUNTIME)
public @interface PageLinks { public @interface PageLinks {
Class<?> value();
String value();
} }

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

@ -19,6 +19,7 @@ import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes; import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.util.UriComponentsBuilder; import org.springframework.web.util.UriComponentsBuilder;
import pro.taskana.rest.WorkbasketController;
import pro.taskana.rest.resource.PagedResources.PageMetadata; import pro.taskana.rest.resource.PagedResources.PageMetadata;
/** /**
@ -35,8 +36,8 @@ public class PageLinksAspect {
.getRequest(); .getRequest();
Method method = ((MethodSignature) joinPoint.getSignature()).getMethod(); Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
PageLinks pageLinks = method.getAnnotation(PageLinks.class); PageLinks pageLinks = method.getAnnotation(PageLinks.class);
Class<?> controller = pageLinks.value(); String relativeUrl = pageLinks.value();
UriComponentsBuilder original = originalUri(controller, request); UriComponentsBuilder original = originalUri(relativeUrl, request);
ResourceSupport resourceSupport = (ResourceSupport) joinPoint.proceed(); ResourceSupport resourceSupport = (ResourceSupport) joinPoint.proceed();
resourceSupport.add(new Link(original.toUriString()).withSelfRel()); resourceSupport.add(new Link(original.toUriString()).withSelfRel());
if (page != null) { if (page != null) {
@ -57,8 +58,10 @@ public class PageLinksAspect {
return resourceSupport; return resourceSupport;
} }
private UriComponentsBuilder originalUri(Class<?> controller, HttpServletRequest request) { private UriComponentsBuilder originalUri(String relativeUrl, HttpServletRequest request) {
UriComponentsBuilder baseUri = linkTo(controller).toUriComponentsBuilder(); //any controller with a "root" mapping will do
UriComponentsBuilder baseUri = linkTo(WorkbasketController.class).toUriComponentsBuilder();
baseUri.path(relativeUrl);
for (Map.Entry<String, String[]> entry : request.getParameterMap().entrySet()) { for (Map.Entry<String, String[]> entry : request.getParameterMap().entrySet()) {
for (String value : entry.getValue()) { for (String value : entry.getValue()) {
baseUri.queryParam(entry.getKey(), value); baseUri.queryParam(entry.getKey(), value);