javax.ws.rs.core.HttpHeaders Java Examples

@GET
@Path("realm")
@Produces(MediaType.APPLICATION_JSON)
public RealmRepresentation exportRealm(@Context final HttpHeaders headers, @Context final UriInfo uriInfo) {
    //retrieving the realm should be done before authentication
    // authentication overrides the value with master inside the context
    // this is done this way to avoid changing the copied code below (authenticateRealmAdminRequest)
    RealmModel realm = session.getContext().getRealm();
    AdminAuth adminAuth = authenticateRealmAdminRequest(headers, uriInfo);
    RealmManager realmManager = new RealmManager(session);
    RoleModel roleModel = adminAuth.getRealm().getRole(AdminRoles.ADMIN);
    AdminPermissionEvaluator realmAuth = AdminPermissions.evaluator(session, realm, adminAuth);
    if (roleModel != null && adminAuth.getUser().hasRole(roleModel)
            && adminAuth.getRealm().equals(realmManager.getKeycloakAdminstrationRealm())
            && realmAuth.realm().canManageRealm()) {
        RealmRepresentation realmRep = ExportUtils.exportRealm(session, realm, true, true);
        //correct users
        if (realmRep.getUsers() != null) {
            setCorrectCredentials(realmRep.getUsers(), realm);
        }
        return realmRep;
    } else {
        throw new ForbiddenException();
    }
}
 

/**
 * Retrieve profile information about the authenticated oauth end-user and authenticate it in Gravitee.
 *
 * @return
 */
private Response authenticateUser(final SocialIdentityProviderEntity socialProvider,
                                  final HttpServletResponse servletResponse,
                                  final String accessToken,
                                  final String state) {
    // Step 2. Retrieve profile information about the authenticated end-user.
    Response response = client
            .target(socialProvider.getUserInfoEndpoint())
            .request(javax.ws.rs.core.MediaType.APPLICATION_JSON_TYPE)
            .header(HttpHeaders.AUTHORIZATION, String.format(socialProvider.getAuthorizationHeader(), accessToken))
            .get();


    // Step 3. Process the authenticated user.
    final String userInfo = getResponseEntityAsString(response);
    if (response.getStatus() == Response.Status.OK.getStatusCode()) {
        return processUser(socialProvider, servletResponse, userInfo, state);
    } else {
        LOGGER.error("User info failed with status {}: {}\n{}", response.getStatus(), response.getStatusInfo(), userInfo);

    }

    return Response.status(response.getStatusInfo()).build();
}
 

/**
 * LDP 1.0 - 4.2.6.1 LDP servers must support the HTTP HEAD method.
 * @param uriInfo the full URL details of the resource
 * @param path the path of the resource
 * @param headers the headers included in the request
 * @param request the request itself
 * @return an LDP compliant response to the HEAD request
 */
@HEAD
@Path(ENDPOINT_PATH)
public Response head(
	@Context UriInfo uriInfo,
	@PathParam(ENDPOINT_PATH_PARAM) String path,
	@Context HttpHeaders headers,
	@Context Request request) {
	OperationContext context =
		newOperationBuilder(HttpMethod.HEAD).
			withEndpointPath(path).
			withUriInfo(uriInfo).
			withHeaders(headers).
			withRequest(request).
			build();
	return
		EndpointControllerFactory.
			newController().
				head(context);
}
 

@Test
public void testGetWidgetList_3() throws Exception {
    UserDetails user = new OAuth2TestUtils.UserBuilder("jack_bauer", "0x24").grantedToRoleAdmin().build();
    String accessToken = mockOAuthInterceptor(user);
    // @formatter:off
    ResultActions result = mockMvc.perform(
            get("/widgets").param("pageSize", "5")
                    .param("sort", "code").param("direction", "DESC")
                    .param("filters[0].attribute", "typology").param("filters[0].value", "oc")
                    .header(HttpHeaders.AUTHORIZATION, "Bearer " + accessToken));
    result.andExpect(status().isOk());
    result.andExpect(jsonPath("$.payload", Matchers.hasSize(4)));
    result.andExpect(jsonPath("$.metaData.pageSize", is(5)));
    result.andExpect(jsonPath("$.metaData.totalItems", is(4)));
    result.andExpect(jsonPath("$.payload[0].code", is("messages_system")));
    String response = result.andReturn().getResponse().getContentAsString();
    assertNotNull(response);
}
 

@RunAsClient
@Test(groups = TEST_GROUP_CDI_PROVIDER,
    description = "Verify that the injected customString claim is as expected")
public void verifyInjectedCustomString() throws Exception {
    Reporter.log("Begin verifyInjectedCustomString\n");
    String uri = baseURL.toExternalForm() + "endp/verifyInjectedCustomString";
    WebTarget echoEndpointTarget = ClientBuilder.newClient()
        .target(uri)
        .queryParam("value", "customStringValue")
        .queryParam(Claims.auth_time.name(), authTimeClaim);
    Response response = echoEndpointTarget.request(MediaType.APPLICATION_JSON).header(HttpHeaders.AUTHORIZATION, "Bearer " + token).get();
    Assert.assertEquals(response.getStatus(), HttpURLConnection.HTTP_OK);
    String replyString = response.readEntity(String.class);
    JsonReader jsonReader = Json.createReader(new StringReader(replyString));
    JsonObject reply = jsonReader.readObject();
    Reporter.log(reply.toString());
    Assert.assertTrue(reply.getBoolean("pass"), reply.getString("msg"));
}
 

/**
 * Upon detecting a redirect, either add cookie to response or re-write URL of new
 * location to co-relate next request.
 *
 * @param event the event.
 */
public void controllerRedirectEvent(@Observes ControllerRedirectEvent event) {
    if (request.getAttribute(SCOPE_ID) != null) {
        if (usingCookies()) {
            Cookie cookie = new Cookie(COOKIE_NAME, request.getAttribute(SCOPE_ID).toString());
            cookie.setPath(request.getContextPath());
            cookie.setMaxAge(600);
            cookie.setHttpOnly(true);
            response.addCookie(cookie);
        } else {
            final ContainerResponseContext crc = ((ControllerRedirectEventImpl) event).getContainerResponseContext();
            final UriBuilder builder = UriBuilder.fromUri(crc.getStringHeaders().getFirst(HttpHeaders.LOCATION));
            builder.queryParam(SCOPE_ID, request.getAttribute(SCOPE_ID).toString());
            crc.getHeaders().putSingle(HttpHeaders.LOCATION, builder.build());
        }
    }
}
 

@Test
public void testAsynch() throws Exception
{
   Client client = ClientBuilder.newClient();
   WebTarget target = client.target("http://localhost:9095/resource?asynch=true");
   Entity<String> entity = Entity.entity("content", "text/plain");
   Invocation.Builder builder = target.request(); 
   Response response = builder.post(entity);//.readEntity(String.class);

   Assert.assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatus());
   String jobUrl1 = response.getStringHeaders().getFirst(HttpHeaders.LOCATION);
   System.out.println("jobUrl1: " + jobUrl1);
   response.close();
   
   target = client.target(jobUrl1);
   Response jobResponse = target.request().get();

   Assert.assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatus());
   jobResponse.close();
   
   Thread.sleep(1500);
   response = client.target(jobUrl1).request().get();
   Assert.assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
   Assert.assertEquals("content", response.readEntity(String.class));
}
 

@RunAsClient
@Test(groups = TEST_GROUP_CDI_PROVIDER,
    description = "Verify that the injected customDouble claim is as expected")
public void verifyInjectedCustomDouble2() throws Exception {
    Reporter.log("Begin verifyInjectedCustomDouble\n");
    String uri = baseURL.toExternalForm() + "endp/verifyInjectedCustomDouble";
    WebTarget echoEndpointTarget = ClientBuilder.newClient()
        .target(uri)
        .queryParam("value", 3.141592653589793)
        .queryParam(Claims.auth_time.name(), authTimeClaim);
    Response response = echoEndpointTarget.request(MediaType.APPLICATION_JSON).header(HttpHeaders.AUTHORIZATION, "Bearer " + token).get();
    Assert.assertEquals(response.getStatus(), HttpURLConnection.HTTP_OK);
    String replyString = response.readEntity(String.class);
    JsonReader jsonReader = Json.createReader(new StringReader(replyString));
    JsonObject reply = jsonReader.readObject();
    Reporter.log(reply.toString());
    Assert.assertTrue(reply.getBoolean("pass"), reply.getString("msg"));
}
 

@SuppressWarnings("unchecked")
@Override
public Response getListContacts(HttpServletRequest request, HttpHeaders header, Company company, Locale locale,
		User user, ServiceContext serviceContext, long id) {

	DossierActions actions = new DossierActionsImpl();
	List<ListContacts> listContacts = new ArrayList<ListContacts>();

	try {
		long groupId = GetterUtil.getLong(header.getHeaderString("groupId"));
		long dossierId = GetterUtil.getLong(id);
		String referenceUid = null;
		if (dossierId == 0) {
			referenceUid = id + "";
		}

		JSONObject jsonData = (JSONObject) actions.getContacts(groupId, dossierId, referenceUid);

		listContacts = DossierActionUtils.mappingToDoListContacts((List<Dossier>) jsonData.get("ListContacts"));

		return Response.status(200).entity(listContacts).build();

	} catch (Exception e) {
		return BusinessExceptionImpl.processException(e);
	}
}
 

/**
 * $batchの登録でchangesetのContentTypeに許可しない文字列を指定した場合400が返却されること.
 */
@Test
public final void $batchの登録でchangesetのContentTypeに許可しない文字列を指定した場合400が返却されること() {
    String contentType = "Content-Type: text/html;\n";
    String body = START_BOUNDARY
            + BatchUtils.retrievePostBodyChangesetHeaderError("Supplier", "testBatch", contentType)
            + END_BOUNDARY;

    TResponse res = Http.request("box/odatacol/batch.txt")
            .with("cell", cellName)
            .with("box", boxName)
            .with("collection", colName)
            .with("boundary", BOUNDARY)
            .with("token", DcCoreConfig.getMasterToken())
            .with("body", body)
            .returns()
            .debug()
            .statusCode(HttpStatus.SC_BAD_REQUEST);

    ODataCommon.checkErrorResponseBody(res, DcCoreException.OData.BATCH_BODY_FORMAT_HEADER_ERROR.getCode(),
            DcCoreException.OData.BATCH_BODY_FORMAT_HEADER_ERROR.params(HttpHeaders.CONTENT_TYPE).getMessage());
}
 

@Override
public Response getFormReportByRegistrationTemplateId(HttpServletRequest request, HttpHeaders header,
		Company company, Locale locale, User user, ServiceContext serviceContext, long registrationTemplateId) {
	// Get FormReport of RegistrationTemplates
	BackendAuth auth = new BackendAuthImpl();

	RegistrationTemplateFormReportInputUpdateModel result = new RegistrationTemplateFormReportInputUpdateModel();

	try {

		if (!auth.isAuth(serviceContext)) {
			throw new UnauthenticationException();
		}
		long groupId = GetterUtil.getLong(header.getHeaderString("groupId"));
		RegistrationTemplates registrationTemplate = RegistrationTemplatesLocalServiceUtil
				.getRegTempbyRegId(groupId, registrationTemplateId);

		result.setFormReport(registrationTemplate.getFormReport());

		return Response.status(200).entity(result).build();

	} catch (Exception e) {
		return BusinessExceptionImpl.processException(e);
	}
}
 

@RunAsClient
@Test(groups = TEST_GROUP_CONFIG,
    description = "Validate specifying the mp.jwt.verify.publickey.location is a resource location of a PEM EC public key")
public void testKeyAsLocationResource() throws Exception {
    Reporter.log("testKeyAsLocationResource, expect HTTP_OK");

    PrivateKey privateKey = TokenUtils.readECPrivateKey("/ecPrivateKey.pem");
    String kid = "/ecPrivateKey.pem";
    String token = TokenUtils.signClaims(privateKey, kid, "/Token1.json");

    String uri = baseURL.toExternalForm() + "pem/endp/verifyKeyLocationAsPEMResource";
    WebTarget echoEndpointTarget = ClientBuilder.newClient()
        .target(uri)
        ;
    Response response = echoEndpointTarget.request(APPLICATION_JSON).header(HttpHeaders.AUTHORIZATION, "Bearer "+token).get();
    Assert.assertEquals(response.getStatus(), HttpURLConnection.HTTP_OK);
    String replyString = response.readEntity(String.class);
    JsonReader jsonReader = Json.createReader(new StringReader(replyString));
    JsonObject reply = jsonReader.readObject();
    Reporter.log(reply.toString());
    Assert.assertTrue(reply.getBoolean("pass"), reply.getString("msg"));
}
 

@RunAsClient
@Test(groups = TEST_GROUP_JAXRS,
      description = "Validate a request with a valid JWT")
public void validJwt() throws Exception {
    String token = TokenUtils.generateTokenString("/Token1.json");

    String uri = baseURL.toExternalForm() + "endp/echo";
    WebTarget echoEndpointTarget = ClientBuilder.newClient()
                                                .target(uri)
                                                .queryParam("input", "hello");
    Response response = echoEndpointTarget
        .request(TEXT_PLAIN)
        .header(HttpHeaders.AUTHORIZATION, "Bearer " + token)
        .get();
    Assert.assertEquals(response.getStatus(), HttpURLConnection.HTTP_OK);
    String reply = response.readEntity(String.class);
    Assert.assertEquals(reply, "hello, [email protected]");
}
 

@RunAsClient
@Test(groups = TEST_GROUP_CDI_JSON,
    description = "Verify that the injected customDouble claim is as expected")
public void verifyInjectedCustomDouble2() throws Exception {
    Reporter.log("Begin verifyInjectedCustomDouble2\n");
    String token2 = TokenUtils.generateTokenString("/Token2.json");
    String uri = baseURL.toExternalForm() + "endp/verifyInjectedCustomDouble";
    WebTarget echoEndpointTarget = ClientBuilder.newClient()
        .target(uri)
        .queryParam("value", 3.241592653589793)
        .queryParam(Claims.auth_time.name(), authTimeClaim);
    Response response = echoEndpointTarget.request(MediaType.APPLICATION_JSON).header(HttpHeaders.AUTHORIZATION, "Bearer " + token2).get();
    Assert.assertEquals(response.getStatus(), HttpURLConnection.HTTP_OK);
    String replyString = response.readEntity(String.class);
    JsonReader jsonReader = Json.createReader(new StringReader(replyString));
    JsonObject reply = jsonReader.readObject();
    Reporter.log(reply.toString());
    Assert.assertTrue(reply.getBoolean("pass"), reply.getString("msg"));
}
 

@Override
public void filter(final ContainerRequestContext reqCtx, final ContainerResponseContext resCtx) throws IOException {
    if (resCtx.getEntityTag() == null) {
        AnyTO annotated = null;
        if (resCtx.getEntity() instanceof AnyTO) {
            annotated = (AnyTO) resCtx.getEntity();
        } else if (resCtx.getEntity() instanceof ProvisioningResult) {
            EntityTO entity = ((ProvisioningResult<?>) resCtx.getEntity()).getEntity();
            if (entity instanceof AnyTO) {
                annotated = (AnyTO) entity;
            }
        }
        if (annotated != null) {
            String etagValue = annotated.getETagValue();
            if (StringUtils.isNotBlank(etagValue)) {
                resCtx.getHeaders().add(HttpHeaders.ETAG, new EntityTag(etagValue).toString());
            }
        }
    }
}
 

private Response evaluateCsvForm(String id) throws IOException {
	Response response;

	try(InputStream is = openCSV(id)){
		FormDataMultiPart formData = new FormDataMultiPart();
		formData.bodyPart(new FormDataBodyPart("csv", is, MediaType.TEXT_PLAIN_TYPE));

		Entity<FormDataMultiPart> entity = Entity.entity(formData, MediaType.MULTIPART_FORM_DATA);

		response = target("model/" + id + "/csv")
			.request(MediaType.APPLICATION_JSON, MediaType.TEXT_PLAIN)
			.header(HttpHeaders.AUTHORIZATION, "Bearer " + ModelResourceTest.USER_TOKEN)
			.post(entity);

		formData.close();
	}

	assertEquals(200, response.getStatus());
	assertEquals(MediaType.TEXT_PLAIN_TYPE.withCharset(CHARSET_UTF_8), response.getMediaType());

	return response;
}
 

@GET
@RolesAllowed({ Role.USER, Role.ADMIN })
@Path("/items/{itemname: [a-zA-Z_0-9]+}")
@Produces({ MediaType.APPLICATION_JSON })
@ApiOperation(value = "Gets item persistence data from the persistence service.", response = ItemHistoryDTO.class)
@ApiResponses(value = { @ApiResponse(code = 200, message = "OK", response = ItemHistoryDTO.class),
        @ApiResponse(code = 404, message = "Unknown Item or persistence service") })
public Response httpGetPersistenceItemData(@Context HttpHeaders headers,
        @ApiParam(value = "Id of the persistence service. If not provided the default service will be used") @QueryParam("serviceId") @Nullable String serviceId,
        @ApiParam(value = "The item name") @PathParam("itemname") String itemName,
        @ApiParam(value = "Start time of the data to return. Will default to 1 day before endtime. ["
                + DateTimeType.DATE_PATTERN_WITH_TZ_AND_MS
                + "]") @QueryParam("starttime") @Nullable String startTime,
        @ApiParam(value = "End time of the data to return. Will default to current time. ["
                + DateTimeType.DATE_PATTERN_WITH_TZ_AND_MS + "]") @QueryParam("endtime") @Nullable String endTime,
        @ApiParam(value = "Page number of data to return. This parameter will enable paging.") @QueryParam("page") int pageNumber,
        @ApiParam(value = "The length of each page.") @QueryParam("pagelength") int pageLength,
        @ApiParam(value = "Gets one value before and after the requested period.") @QueryParam("boundary") boolean boundary) {
    return getItemHistoryDTO(serviceId, itemName, startTime, endTime, pageNumber, pageLength, boundary);
}
 

@Test
public void readRequest_contentCharset_setsDefaultCharsetWhenNotSpecified() {
    String requestCharset = "application/json";
    AwsProxyRequest request = new AwsProxyRequestBuilder(ENCODED_REQUEST_PATH, "GET").header(HttpHeaders.CONTENT_TYPE, requestCharset).build();
    try {
        HttpServletRequest servletRequest = reader.readRequest(request, null, null, ContainerConfig.defaultConfig());
        assertNotNull(servletRequest);
        assertNotNull(servletRequest.getHeader(HttpHeaders.CONTENT_TYPE));
        String contentAndCharset = requestCharset + "; charset=" + LambdaContainerHandler.getContainerConfig().getDefaultContentCharset();
        assertEquals(contentAndCharset, servletRequest.getHeader(HttpHeaders.CONTENT_TYPE));
        assertEquals(LambdaContainerHandler.getContainerConfig().getDefaultContentCharset(), servletRequest.getCharacterEncoding());
    } catch (InvalidRequestEventException e) {
        e.printStackTrace();
        fail("Could not read request");
    }
}
 

@Test
void testTrellisRequestXForwarded() {
    final URI uri = create("http://example.com/");

    final MultivaluedMap<String, String> headers = new MultivaluedHashMap<>();
    headers.putSingle("X-Forwarded-Proto", "https");
    headers.putSingle("X-Forwarded-Host", "app.example.com");

    final Request mockRequest = mock(Request.class);
    final UriInfo mockUriInfo = mock(UriInfo.class);
    final HttpHeaders mockHeaders = mock(HttpHeaders.class);

    when(mockUriInfo.getPath()).thenReturn("resource");
    when(mockUriInfo.getPathParameters()).thenReturn(new MultivaluedHashMap<>());
    when(mockUriInfo.getQueryParameters()).thenReturn(new MultivaluedHashMap<>());
    when(mockUriInfo.getBaseUri()).thenReturn(uri);
    when(mockHeaders.getRequestHeaders()).thenReturn(headers);

    final TrellisRequest req = new TrellisRequest(mockRequest, mockUriInfo, mockHeaders);
    assertEquals("https://app.example.com/", req.getBaseUrl());
}
 

public Optional<AmforeasResponse> update (String resource, String pk, String id, String json) {
    final URI url = this.build(String.format(item_path, root, alias, resource, id)).orElseThrow();
    final HttpPut req = new HttpPut(url);
    req.addHeader(this.accept);
    req.addHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON);
    req.addHeader("Primary-Key", pk);

    try {
        req.setEntity(new StringEntity(json));
    } catch (UnsupportedEncodingException e) {
        final String msg = "Failed to encode JSON body " + e.getMessage();
        l.error(msg);
        return Optional.of(new ErrorResponse(resource, Response.Status.BAD_REQUEST, msg));
    }

    return this.execute(req);
}
 

@Override
	public Response getFormScript(HttpServletRequest request, HttpHeaders header, Company company, Locale locale,
			User user, ServiceContext serviceContext, Long id) {

		// TODO Add Deliverable Type
		BackendAuth auth = new BackendAuthImpl();

//		long groupId = GetterUtil.getLong(header.getHeaderString("groupId"));

		try {
			if (!auth.isAuth(serviceContext)) {
				throw new UnauthenticationException();
			}

			DeliverableActions actions = new DeliverableActionsImpl();
			String results;

			Deliverable deliverableInfo = actions.getDetailById(id);

			if (Validator.isNotNull(deliverableInfo)) {
				results = deliverableInfo.getFormScript();
			} else {
				throw new Exception();
			}

			return Response.status(200).entity(JSONFactoryUtil.looseSerialize(results)).build();

		} catch (Exception e) {
			return BusinessExceptionImpl.processException(e);
		}

	}
 

@Override
public boolean handleSecurity(HttpServletRequest request, HttpServletResponse response) throws IOException {
    // Add the Content-Encoding: gzip header to the response for selected resources
    // (Disclaimer: I know, this is not the intended purpose of this method...)
    if (useGzipCompression && isGzipVersionAvailable(request.getRequestURI())) {
        response.addHeader(HttpHeaders.CONTENT_ENCODING, "gzip");
    }
    return defaultHttpContext.handleSecurity(request, response);
}
 

@GET
public Response get(@Context HttpHeaders headers) {
  if (token != null && !headers.getRequestHeader(HttpHeaders.AUTHORIZATION).get(0).equals("Bearer " + token)) {
    return Response.status(Response.Status.FORBIDDEN).build();
  }
  return Response.ok(getBody("http/get_response.json"))
      .header("x-test-header", "StreamSets")
      .header("x-list-header", ImmutableList.of("a", "b"))
      .build();
}
 

@GET
public String format(@QueryParam("helloTo") String helloTo, @Context HttpHeaders httpHeaders) {
    Span span =  Tracing.startServerSpan(tracer, httpHeaders, "format");
    try (Scope scope = tracer.scopeManager().activate(span)) {
        String helloStr = String.format("Hello, %s!", helloTo);
        span.log(ImmutableMap.of("event", "string-format", "value", helloStr));
        return helloStr;
    } finally {
        span.finish();
    }
}
 

@POST
@Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON, MediaType.APPLICATION_FORM_URLENCODED})
@Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
@ApiResponses(value = {
		@ApiResponse(code = HttpURLConnection.HTTP_OK, message = ""),
		@ApiResponse(code = HttpURLConnection.HTTP_UNAUTHORIZED, message = "Unauthorized", response = ExceptionModel.class),
		@ApiResponse(code = HttpURLConnection.HTTP_FORBIDDEN, message = "Access denied", response = ExceptionModel.class),
		@ApiResponse(code = HttpURLConnection.HTTP_INTERNAL_ERROR, message = "Internal error", response = ExceptionModel.class) })
public Response addUserLog(@Context HttpServletRequest request, @Context HttpHeaders header,
		@Context Company company, @Context Locale locale, @Context User user, @Context ServiceContext serviceContext, 
		@BeanParam UserInfoLogInputModel input);
 

@GET
@Path("/{screenname_email}/forgot/confirm/{code}")
@Consumes({ MediaType.APPLICATION_FORM_URLENCODED })
@Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
public Response getForgotConfirm(@Context HttpServletRequest request, @Context HttpHeaders header,
		@Context Company company, @Context Locale locale, @Context User user,
		@Context ServiceContext serviceContext, 
		@PathParam("screenname_email") String screenname_email, @PathParam("code") String code, @QueryParam("j_captcha_response") String jCaptchaResponse);
 

public Item(@Context UriInfo uriInfo, @Context Request request, @Context MediaTypes mediaTypes,
        @Context Service service, @Context com.atomgraph.processor.model.Application application, @Context Ontology ontology, @Context TemplateCall templateCall,
        @Context HttpHeaders httpHeaders, @Context ResourceContext resourceContext)
{
    super(uriInfo, request, mediaTypes,
            service, application, ontology, templateCall,
            httpHeaders, resourceContext);
    if (log.isDebugEnabled()) log.debug("Constructing {} as direct indication of GRAPH {}", getClass(), uriInfo.getAbsolutePath());
}
 

@Override
public Response handleRequest(Message message, ClassResourceInfo classResourceInfo) {
    HttpHeaders headers = new HttpHeadersImpl(message);

    if (!StringUtils.isEmpty(headers.getRequestHeaders().getFirst(HttpHeaders.AUTHORIZATION))) {
        return handle(message, classResourceInfo);
    }else{
        // Currently there is only one handler
        return Response.status(Response.Status.FORBIDDEN).build();
    }
}
 

@GET
@Produces({"application/xml", "text/xml", "application/json", "text/yaml", "text/x-yaml", "application/x-yaml", "application/x-protobuf",
        "application/x-protostuff"})
@Path("/lookupUUID/{uuidType}/{uuid}")
@Interceptors({RequiredInterceptor.class, ResponseInterceptor.class})
@Override
@Timed(name = "dw.query.lookupUUID", absolute = true)
public <T> T lookupUUID(@Required("uuidType") @PathParam("uuidType") String uuidType, @Required("uuid") @PathParam("uuid") String uuid,
                @Context UriInfo uriInfo, @Required("httpHeaders") @Context HttpHeaders httpHeaders) {
    MultivaluedMapImpl<String,String> queryParameters = new MultivaluedMapImpl<>();
    queryParameters.putAll(uriInfo.getQueryParameters());
    return this.lookupUUID(uuidType, uuid, queryParameters, httpHeaders);
}
 

@Test
public void dollarFormatUnknown() throws Exception {
  MultivaluedMap<String, String> queryParameters = new MultivaluedHashMap<String, String>();
  queryParameters.putSingle("$format", "someFormat");
  when(exceptionMapper.uriInfo.getQueryParameters()).thenReturn(queryParameters);

  Response response = exceptionMapper.toResponse(new Exception("text"));
  assertNotNull(response);
  String contentTypeHeader = response.getHeaderString(com.sap.core.odata.api.commons.HttpHeaders.CONTENT_TYPE);
  assertEquals("application/xml", contentTypeHeader);
  String errorMessage = StringHelper.inputStreamToString((InputStream) response.getEntity());
  assertXpathExists("/a:error/a:code", errorMessage);
  assertXpathEvaluatesTo("text", "/a:error/a:message", errorMessage);
}