public static String getContentType(HttpHeaders headers) {
Variant v = getVariant(headers);
String contentType = v.getMediaType().getSubtype();
List<String> kieContentTypeHeader =
headers.getRequestHeader(KieServerConstants.KIE_CONTENT_TYPE_HEADER);
if (kieContentTypeHeader != null && !kieContentTypeHeader.isEmpty()) {
contentType = kieContentTypeHeader.get(0);
}
return contentType;
}
public Object getTasks(
Request request, UriInfo uriInfo, Integer firstResult, Integer maxResults) {
Variant variant = request.selectVariant(VARIANTS);
if (variant != null) {
if (MediaType.APPLICATION_JSON_TYPE.equals(variant.getMediaType())) {
return getJsonTasks(uriInfo, firstResult, maxResults);
} else if (Hal.APPLICATION_HAL_JSON_TYPE.equals(variant.getMediaType())) {
return getHalTasks(uriInfo, firstResult, maxResults);
}
}
throw new InvalidRequestException(
Response.Status.NOT_ACCEPTABLE, "No acceptable content-type found");
}
public static boolean isPaged(HttpServletRequest httpRequest, Request request) {
String accept = httpRequest.getHeader("Accept");
if (StringHelper.containsNonWhitespace(accept)) {
MediaType requestMediaType = MediaType.valueOf(accept);
if (APPLICATION_JSON_PAGED.equals(requestMediaType)
|| APPLICATION_XML_PAGED.equals(requestMediaType)) {
return true;
}
}
Variant variant = request.selectVariant(variants);
return (variant != null
&& (variant.equals(APPLICATION_JSON_PAGED) || variant.equals(APPLICATION_XML_PAGED)));
}
@Singleton
@Provider
public class WebApplicationExceptionMapper implements ExceptionMapper<WebApplicationException> {
private static final Logger LOG = LoggerFactory.getLogger(GenericExceptionMapper.class);
private static List<Variant> supportedMediaTypes =
Variant.mediaTypes(MediaType.APPLICATION_JSON_TYPE, MediaType.TEXT_HTML_TYPE).add().build();
@Context private HttpContext context;
public WebApplicationExceptionMapper() {
LOG.info("GenericExceptionMapper Created");
}
@Override
public Response toResponse(WebApplicationException error) {
if (error.getResponse() != null && (error.getResponse().getStatus() / 100) == 3) {
LOG.warn("Code: " + error.getResponse().getStatus());
return error.getResponse();
}
MediaType mediaType = context.getRequest().selectVariant(supportedMediaTypes).getMediaType();
if (mediaType != null && MediaType.APPLICATION_JSON_TYPE == mediaType) {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
PrintStream ps = new PrintStream(baos);
error.printStackTrace(ps);
return Response.status(error.getResponse().getStatus())
.entity(
new JSONObject()
.put("code", error.getResponse().getStatus())
.put("url", context.getUriInfo().getPath())
.put("error", error.toString())
.put("message", error.getMessage())
.put("trace", baos.toString()))
.build();
} catch (JSONException e) {
// TODO:
}
}
final int statusCode = error.getResponse().getStatus();
if (statusCode == Responses.NOT_FOUND) {
return Response.status(Responses.NOT_FOUND).entity(error.getMessage()).build();
} else {
// internal error
LOG.warn(
"WebApplicationExceptionMapper "
+ error.getResponse().getStatus()
+ " "
+ error.getMessage(),
error);
Map<String, Object> model = Maps.newHashMap();
model.put("exception", error);
return Response.status(error.getResponse().getStatus())
.entity(new Viewable("/errors/internal_error.ftl", model))
.build();
}
}
}
private static LinkedList<VariantHolder> getVariantHolderList(final List<Variant> variants) {
final LinkedList<VariantHolder> l = new LinkedList<VariantHolder>();
for (Variant v : variants) {
final MediaType mt = v.getMediaType();
if (mt != null) {
if (mt instanceof QualitySourceMediaType
|| mt.getParameters().containsKey(QualitySourceMediaType.QUALITY_SOURCE_FACTOR)) {
int qs = QualitySourceMediaType.getQualitySource(mt);
l.add(new VariantHolder(v, qs));
} else {
l.add(new VariantHolder(v));
}
} else {
l.add(new VariantHolder(v));
}
}
return l;
}
@Test
public void testGetVersionList() {
when(mockRequest.selectVariant(POSSIBLE_RDF_VARIANTS)).thenReturn(mockVariant);
when(mockNodes.find(any(Session.class), anyString())).thenReturn(mockResource);
when(mockResource.getTriples(any(IdentifierConverter.class), eq(VersionsRdfContext.class)))
.thenReturn(mockRdfStream);
when(mockResource.isVersioned()).thenReturn(true);
when(mockVariant.getMediaType()).thenReturn(new MediaType("text", "turtle"));
final RdfStream response = testObj.getVersionList();
assertEquals("Got wrong RdfStream!", mockRdfStream, response);
}
@Test
public void testGetVersionList() throws RepositoryException {
final String pid = "FedoraVersioningTest";
when(mockRequest.selectVariant(POSSIBLE_RDF_VARIANTS)).thenReturn(mockVariant);
when(mockNodes.getObject(any(Session.class), anyString())).thenReturn(mockResource);
when(mockResource.getVersionTriples(any(HttpIdentifierTranslator.class)))
.thenReturn(mockRdfStream);
when(mockVariant.getMediaType()).thenReturn(new MediaType("text", "turtle"));
final RdfStream response =
testObj.getVersionList(createPathList(pid), mockRequest, getUriInfoImpl());
assertEquals("Got wrong RdfStream!", mockRdfStream, response);
}
@Test
public void testSelectVariant() {
MutableRequest mr = new MutableRequest("", "http://example.org/app/resource", "GET");
mr.header(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON);
mr.header(HttpHeaders.ACCEPT_LANGUAGE, "en");
Request r = mr.toJaxrsRequest();
List<Variant> lv =
Variant.mediaTypes(MediaType.APPLICATION_XML_TYPE, MediaType.APPLICATION_JSON_TYPE)
.languages(Locale.ENGLISH, Locale.FRENCH)
.add()
.build();
assertEquals(r.selectVariant(lv).getMediaType(), MediaType.APPLICATION_JSON_TYPE);
assertEquals(r.selectVariant(lv).getLanguage(), Locale.ENGLISH);
}
public class RestUtils {
public static Variant defaultVariant =
Variant.mediaTypes(MediaType.APPLICATION_JSON_TYPE).add().build().get(0);
private static MarshallerHelper marshallerHelper = new MarshallerHelper(null);
public static Response createCorrectVariant(Object responseObj, HttpHeaders headers) {
return createCorrectVariant(responseObj, headers, null);
}
public static Response createCorrectVariant(
Object responseObj, HttpHeaders headers, javax.ws.rs.core.Response.Status status) {
Response.ResponseBuilder responseBuilder = null;
Variant v = getVariant(headers);
String contentType = getContentType(headers);
if (status != null) {
responseBuilder =
Response.status(status)
.entity(marshallerHelper.marshal(contentType, responseObj))
.variant(v);
} else {
responseBuilder = Response.ok(marshallerHelper.marshal(contentType, responseObj), v);
}
return responseBuilder.build();
}
public static Response createResponse(
Object responseObj, Variant v, javax.ws.rs.core.Response.Status status) {
Response.ResponseBuilder responseBuilder = null;
if (status != null) {
responseBuilder = Response.status(status).entity(responseObj).variant(v);
} else {
responseBuilder = Response.ok(responseObj, v);
}
return responseBuilder.build();
}
public static Variant getVariant(HttpHeaders headers) {
Variant v = RestEasy960Util.getVariant(headers);
if (v == null) {
v = defaultVariant;
}
return v;
}
public static String getClassType(HttpHeaders headers) {
String classType = Object.class.getName();
List<String> header = headers.getRequestHeader(KieServerConstants.CLASS_TYPE_HEADER);
if (header != null && !header.isEmpty()) {
classType = header.get(0);
}
return classType;
}
public static String getContentType(HttpHeaders headers) {
Variant v = getVariant(headers);
String contentType = v.getMediaType().getSubtype();
List<String> kieContentTypeHeader =
headers.getRequestHeader(KieServerConstants.KIE_CONTENT_TYPE_HEADER);
if (kieContentTypeHeader != null && !kieContentTypeHeader.isEmpty()) {
contentType = kieContentTypeHeader.get(0);
}
return contentType;
}
}
public class TaskRestServiceImpl extends AbstractRestProcessEngineAware implements TaskRestService {
public static final List<Variant> VARIANTS =
Variant.mediaTypes(MediaType.APPLICATION_JSON_TYPE, Hal.APPLICATION_HAL_JSON_TYPE)
.add()
.build();
public TaskRestServiceImpl(String engineName, final ObjectMapper objectMapper) {
super(engineName, objectMapper);
}
public Object getTasks(
Request request, UriInfo uriInfo, Integer firstResult, Integer maxResults) {
Variant variant = request.selectVariant(VARIANTS);
if (variant != null) {
if (MediaType.APPLICATION_JSON_TYPE.equals(variant.getMediaType())) {
return getJsonTasks(uriInfo, firstResult, maxResults);
} else if (Hal.APPLICATION_HAL_JSON_TYPE.equals(variant.getMediaType())) {
return getHalTasks(uriInfo, firstResult, maxResults);
}
}
throw new InvalidRequestException(
Response.Status.NOT_ACCEPTABLE, "No acceptable content-type found");
}
public List<TaskDto> getJsonTasks(UriInfo uriInfo, Integer firstResult, Integer maxResults) {
TaskQueryDto queryDto = new TaskQueryDto(getObjectMapper(), uriInfo.getQueryParameters());
return queryTasks(queryDto, firstResult, maxResults);
}
public HalTaskList getHalTasks(UriInfo uriInfo, Integer firstResult, Integer maxResults) {
TaskQueryDto queryDto = new TaskQueryDto(getObjectMapper(), uriInfo.getQueryParameters());
ProcessEngine engine = getProcessEngine();
TaskQuery query = queryDto.toQuery(engine);
// get list of tasks
List<Task> matchingTasks = executeTaskQuery(firstResult, maxResults, query);
// get total count
long count = query.count();
return HalTaskList.generate(matchingTasks, count, engine);
}
@Override
public List<TaskDto> queryTasks(TaskQueryDto queryDto, Integer firstResult, Integer maxResults) {
ProcessEngine engine = getProcessEngine();
queryDto.setObjectMapper(getObjectMapper());
TaskQuery query = queryDto.toQuery(engine);
List<Task> matchingTasks = executeTaskQuery(firstResult, maxResults, query);
List<TaskDto> tasks = new ArrayList<TaskDto>();
for (Task task : matchingTasks) {
TaskDto returnTask = TaskDto.fromEntity(task);
tasks.add(returnTask);
}
return tasks;
}
protected List<Task> executeTaskQuery(Integer firstResult, Integer maxResults, TaskQuery query) {
// enable initialization of form key:
query.initializeFormKeys();
List<Task> matchingTasks;
if (firstResult != null || maxResults != null) {
matchingTasks = executePaginatedQuery(query, firstResult, maxResults);
} else {
matchingTasks = query.list();
}
return matchingTasks;
}
protected List<Task> executePaginatedQuery(
TaskQuery query, Integer firstResult, Integer maxResults) {
if (firstResult == null) {
firstResult = 0;
}
if (maxResults == null) {
maxResults = Integer.MAX_VALUE;
}
return query.listPage(firstResult, maxResults);
}
@Override
public CountResultDto getTasksCount(UriInfo uriInfo) {
TaskQueryDto queryDto = new TaskQueryDto(getObjectMapper(), uriInfo.getQueryParameters());
return queryTasksCount(queryDto);
}
@Override
public CountResultDto queryTasksCount(TaskQueryDto queryDto) {
ProcessEngine engine = getProcessEngine();
queryDto.setObjectMapper(getObjectMapper());
TaskQuery query = queryDto.toQuery(engine);
long count = query.count();
CountResultDto result = new CountResultDto();
result.setCount(count);
return result;
}
@Override
public TaskResource getTask(String id) {
return new TaskResourceImpl(
getProcessEngine(), id, relativeRootResourcePath, getObjectMapper());
}
public void createTask(TaskDto taskDto) {
ProcessEngine engine = getProcessEngine();
TaskService taskService = engine.getTaskService();
Task newTask = taskService.newTask(taskDto.getId());
taskDto.updateTask(newTask);
try {
taskService.saveTask(newTask);
} catch (NotValidException e) {
throw new InvalidRequestException(
Status.BAD_REQUEST, e, "Could not save task: " + e.getMessage());
}
}
}
public class RestUtils {
public static Variant defaultVariant =
Variant.mediaTypes(MediaType.APPLICATION_JSON_TYPE).add().build().get(0);
private static MarshallerHelper marshallerHelper = new MarshallerHelper(null);
public static Response createCorrectVariant(Object responseObj, HttpHeaders headers) {
return createCorrectVariant(responseObj, headers, null);
}
public static Response createCorrectVariant(
Object responseObj, HttpHeaders headers, javax.ws.rs.core.Response.Status status) {
Response.ResponseBuilder responseBuilder = null;
Variant v = getVariant(headers);
String contentType = getContentType(headers);
if (status != null) {
responseBuilder =
Response.status(status)
.entity(marshallerHelper.marshal(contentType, responseObj))
.variant(v);
} else {
responseBuilder = Response.ok(marshallerHelper.marshal(contentType, responseObj), v);
}
return responseBuilder.build();
}
public static Response createCorrectVariant(
MarshallerHelper marshallerHelper,
String containerId,
Object responseObj,
HttpHeaders headers,
javax.ws.rs.core.Response.Status status) {
Response.ResponseBuilder responseBuilder = null;
Variant v = getVariant(headers);
String contentType = getContentType(headers);
String marshalledResponse;
if (marshallerHelper.getRegistry().getContainer(containerId) == null) {
marshalledResponse = marshallerHelper.marshal(contentType, responseObj);
} else {
marshalledResponse = marshallerHelper.marshal(containerId, contentType, responseObj);
}
if (status != null) {
responseBuilder = Response.status(status).entity(marshalledResponse).variant(v);
} else {
responseBuilder = Response.ok(marshalledResponse, v);
}
return responseBuilder.build();
}
public static Response createResponse(
Object responseObj, Variant v, javax.ws.rs.core.Response.Status status) {
Response.ResponseBuilder responseBuilder = null;
if (status != null) {
responseBuilder = Response.status(status).entity(responseObj).variant(v);
} else {
responseBuilder = Response.ok(responseObj, v);
}
return responseBuilder.build();
}
public static Variant getVariant(HttpHeaders headers) {
Variant v = RestEasy960Util.getVariant(headers);
if (v == null) {
v = defaultVariant;
}
return v;
}
public static String getClassType(HttpHeaders headers) {
String classType = null;
List<String> header = headers.getRequestHeader(KieServerConstants.CLASS_TYPE_HEADER);
if (header != null && !header.isEmpty()) {
classType = header.get(0);
}
return classType;
}
public static String getContentType(HttpHeaders headers) {
Variant v = getVariant(headers);
String contentType = v.getMediaType().getSubtype();
List<String> kieContentTypeHeader =
headers.getRequestHeader(KieServerConstants.KIE_CONTENT_TYPE_HEADER);
if (kieContentTypeHeader != null && !kieContentTypeHeader.isEmpty()) {
contentType = kieContentTypeHeader.get(0);
}
return contentType;
}
public static Response notFound(String message, Variant v) {
return createResponse(message, v, Response.Status.NOT_FOUND);
}
public static Response internalServerError(String message, Variant v) {
return createResponse(message, v, Response.Status.INTERNAL_SERVER_ERROR);
}
public static Response alreadyExists(String message, Variant v) {
return createResponse(message, v, Response.Status.CONFLICT);
}
}