@Override public void filter(final ContainerRequestContext req, final ContainerResponseContext res) throws IOException { if (READ_METHODS.contains(req.getMethod())) { if (res.getLinks().stream().filter(l -> l.getRel().equals(TYPE)).map(Link::getUri).map(URI::toString) .anyMatch(uri -> uri.equals(Container.getIRIString()) || uri.equals(NonRDFSource.getIRIString()))) { final String urlBase = nonNull(baseUrl) ? baseUrl : req.getUriInfo().getBaseUri().toString(); final String identifier = urlBase + req.getUriInfo().getPath(); res.getHeaders().add("Link", fromUri(identifier + "?ext=" + UPLOADS) .rel(multipartUploadService.getIRIString()).build()); } final List<String> exts = req.getUriInfo().getQueryParameters().getOrDefault("ext", emptyList()); if (exts.contains(UPLOADS)) { res.getHeaders().putSingle(ALLOW, join(",", POST, OPTIONS)); } } }
static String extractCompensator(String linkStr) { for (String lnk : linkStr.split(",")) { Link link; try { link = Link.valueOf(lnk); } catch (Exception e) { LRALogger.logger.infof(e, "Cannot extract compensator from link'%s'", linkStr); return linkStr; } if ("compensate".equals(link.getRel())) return link.getUri().toString(); } return linkStr; }
private ServerResponse patchServer(Server serverPatch, Link serverLink, Optional<Integer> mergeDepth) { final Response response = RestHelper.queryParam(client.target(serverLink), mergeDepth, "mergedepth") .request(MediaType.APPLICATION_JSON) .build("PATCH", Entity.json(serverPatch)) .invoke(); TestHelper.assertSuccessful(response); final ServerLink link = response.readEntity(ServerLink.class); final Document db = servers.find( Filters.and( Filters.eq("hostname", link.hostname), Filters.eq("environment", link.environment) )).first(); return new ServerResponse(link, db); }
@JsonCreator public ServerSearchResult( @JsonProperty("hostname") String hostname, @JsonProperty("environment") String environment, @JsonProperty("fqdn") String fqdn, @JsonProperty("description") String description, @JsonProperty("score") Double score, @JsonProperty("link") Link link ) { this.hostname = hostname; this.environment = environment; this.fqdn = fqdn; this.description = description; this.score = score; this.link = link; }
public Response getOrder(int id, UriInfo uriInfo) { OrderEntity entity = em.getReference(OrderEntity.class, id); Order order = entity2domain(entity); URI self = uriInfo.getAbsolutePathBuilder().build(); Link selfLink = Link.fromUri(self).rel("self").type("application/xml").build(); order.addLink(selfLink); if (!order.isCancelled()) { URI cancel = uriInfo.getAbsolutePathBuilder().path("cancel").build(); Link cancelLink = Link.fromUri(cancel).rel("cancel").type("application/xml").build(); order.addLink(cancelLink); } Response.ResponseBuilder builder = Response.ok(order); if (!order.isCancelled()) addCancelHeader(uriInfo, builder); return builder.build(); }
/** * Create a response builder for a TimeMap response. * * @param baseUrl the base URL * @param req the LDP request * @param serializer the serializer to use * @return a response builder object */ public Response.ResponseBuilder getTimeMapBuilder(final LdpRequest req, final IOService serializer, final String baseUrl) { final List<MediaType> acceptableTypes = req.getHeaders().getAcceptableMediaTypes(); final String identifier = getBaseUrl(baseUrl, req) + req.getPath(); final List<Link> links = getMementoLinks(identifier, resource.getMementos()).collect(toList()); final Response.ResponseBuilder builder = Response.ok().link(identifier, ORIGINAL + " " + TIMEGATE); builder.links(links.toArray(new Link[0])).link(Resource.getIRIString(), "type") .link(RDFSource.getIRIString(), "type").header(ALLOW, join(",", GET, HEAD, OPTIONS)); final RDFSyntax syntax = getSyntax(acceptableTypes, of(APPLICATION_LINK_FORMAT)).orElse(null); if (nonNull(syntax)) { final IRI profile = ofNullable(getProfile(acceptableTypes, syntax)).orElse(expanded); final List<Triple> extraData = getExtraTriples(identifier); for (final Link l : links) { if (l.getRels().contains(MEMENTO)) { extraData.add(rdf.createTriple(rdf.createIRI(identifier), Memento.memento, rdf.createIRI(l.getUri().toString()))); } } final StreamingOutput stream = new StreamingOutput() { @Override public void write(final OutputStream out) throws IOException { serializer.write(concat(links.stream().flatMap(linkToTriples), extraData.stream()), out, syntax, profile); } }; return builder.type(syntax.mediaType()).entity(stream); } return builder.type(APPLICATION_LINK_FORMAT) .entity(links.stream().map(Link::toString).collect(joining(",\n")) + "\n"); }
/** * Create a response builder for a TimeGate response. * * @param req the LDP request * @param baseUrl the base URL * @return a response builder object */ public Response.ResponseBuilder getTimeGateBuilder(final LdpRequest req, final String baseUrl) { final String identifier = getBaseUrl(baseUrl, req) + req.getPath(); return Response.status(FOUND) .location(fromUri(identifier + "?version=" + req.getDatetime().getInstant().toEpochMilli()).build()) .link(identifier, ORIGINAL + " " + TIMEGATE) .links(getMementoLinks(identifier, resource.getMementos()).toArray(Link[]::new)) .header(VARY, ACCEPT_DATETIME); }
private static Stream<Link> getTimeMap(final String identifier, final Stream<Range<Instant>> mementos) { return mementos.reduce((acc, x) -> between(acc.getMinimum(), x.getMaximum())) .map(x -> Link.fromUri(identifier + TIMEMAP_PARAM).rel(TIMEMAP).type(APPLICATION_LINK_FORMAT) .param(FROM, ofInstant(x.getMinimum().minusNanos(1L).plusSeconds(1L), UTC).format(RFC_1123_DATE_TIME)) .param(UNTIL, ofInstant(x.getMaximum(), UTC).format(RFC_1123_DATE_TIME)).build()) // TODO use Optional::stream with JDK9 .map(Stream::of).orElseGet(Stream::empty); }
/** * Check if this is a deleted resource, and if so return an appropriate response. * * @param res the resource * @param identifier the identifier * @throws WebApplicationException a 410 Gone exception */ protected static void checkDeleted(final Resource res, final String identifier) { if (res.isDeleted()) { throw new WebApplicationException(status(GONE) .links(MementoResource.getMementoLinks(identifier, res.getMementos()) .toArray(Link[]::new)).build()); } }
@Test public void testGetDatetime() { final Response res = target(RESOURCE_PATH).request() .header(ACCEPT_DATETIME, RFC_1123_DATE_TIME.withZone(UTC).format(time)).get(); assertEquals(OK, res.getStatusInfo()); assertNotNull(res.getHeaderString(MEMENTO_DATETIME)); assertEquals(time, parse(res.getHeaderString(MEMENTO_DATETIME), RFC_1123_DATE_TIME).toInstant()); // Jersey's client doesn't parse complex link headers correctly final List<Link> links = res.getStringHeaders().get(LINK).stream().map(Link::valueOf).collect(toList()); assertTrue(links.stream().anyMatch(l -> l.getRels().contains("memento") && RFC_1123_DATE_TIME.withZone(UTC).format(ofEpochSecond(timestamp - 2000)) .equals(l.getParams().get("datetime")) && l.getUri().toString().equals(BASE_URL + RESOURCE_PATH + "?version=1496260729000"))); assertTrue(links.stream().anyMatch(l -> l.getRels().contains("memento") && RFC_1123_DATE_TIME.withZone(UTC).format(ofEpochSecond(timestamp - 1000)) .equals(l.getParams().get("datetime")) && l.getUri().toString().equals(BASE_URL + RESOURCE_PATH + "?version=1496261729000"))); assertTrue(links.stream().anyMatch(l -> l.getRels().contains("memento") && RFC_1123_DATE_TIME.withZone(UTC).format(time).equals(l.getParams().get("datetime")) && l.getUri().toString().equals(BASE_URL + RESOURCE_PATH + "?version=1496262729000"))); assertTrue(links.stream().anyMatch(l -> l.getRels().contains("timemap") && RFC_1123_DATE_TIME.withZone(UTC).format(ofEpochSecond(timestamp - 2000)) .equals(l.getParams().get("from")) && RFC_1123_DATE_TIME.withZone(UTC).format(ofEpochSecond(timestamp + 1000)) .equals(l.getParams().get("until")) && APPLICATION_LINK_FORMAT.equals(l.getType()) && l.getUri().toString().equals(BASE_URL + RESOURCE_PATH + "?ext=timemap"))); assertTrue(links.stream().anyMatch(l -> l.getRels().contains("timegate") && l.getUri().toString().equals(BASE_URL + RESOURCE_PATH))); assertTrue(links.stream().anyMatch(l -> l.getRels().contains("original") && l.getUri().toString().equals(BASE_URL + RESOURCE_PATH))); assertFalse(links.stream().anyMatch(hasLink(rdf.createIRI(BASE_URL + RESOURCE_PATH + "?ext=upload"), Trellis.multipartUploadService.getIRIString()))); assertTrue(links.stream().anyMatch(hasType(LDP.Resource))); assertTrue(links.stream().anyMatch(hasType(LDP.RDFSource))); assertFalse(links.stream().anyMatch(hasType(LDP.Container))); }
public String getBatchToken() { Link link = this.response.getLink("'next'"); if (link != null) { MultivaluedMap<String, String> parameters = UriComponent.decodeQuery(link.getUri(), true); return parameters.getFirst("batch_token"); } return null; }
private <T, LT extends ObjectList<T, LT>> LT followPageable(Link next, LT responseBody, Class<LT> responseType) { while (next != null) { Response nextResponse = client.target(next).request(APPLICATION_JSON_TYPE).get(); LT nextResponseBody = nextResponse.readEntity(responseType); responseBody = responseBody.merge(nextResponseBody); next = nextResponse.getLink("next"); } return responseBody; }
private boolean isLink(String linkString) { try { Link.valueOf(linkString); return true; } catch (IllegalArgumentException e) { return false; } }
private static String cannonicalForm(String linkStr) { if (linkStr.indexOf(',') == -1) return linkStr; SortedMap<String, String> lm = new TreeMap<>(); Arrays.stream(linkStr.split(",")).forEach(link -> lm.put(Link.valueOf(link).getRel(), link)); StringBuilder sb = new StringBuilder(); lm.forEach((k, v) -> appendLink(sb, v)); return sb.toString(); }
public Link unmarshal(CustomJaxbLink p1) { Link.Builder builder = Link.fromUri(p1.getUri()); for (Map.Entry<QName, Object> entry : p1.getParams().entrySet()) { builder.param(entry.getKey().getLocalPart(), entry.getValue().toString()); } return builder.build(); }
public CustomJaxbLink marshal(Link p1) { Map<QName, Object> params = new HashMap<>(); for (Map.Entry<String, String> entry : p1.getParams().entrySet()) { params.put(new QName("", entry.getKey()), entry.getValue()); } return new CustomJaxbLink(p1.getUri(), params); }
public Link[] getLinks(PaginatedList pagedList) { List<Link> result = Lists.newArrayList(); int pageNum = pagedList.getPage(); int perPage = pagedList.getPerPage(); long totalCount = pagedList.getTotalCount(); int maxPages = Math.toIntExact((totalCount + perPage - 1) / perPage); // Check first if (pageNum > 1) { result.add(createLink("first", 1, perPage)); } // Check prev if (pageNum - 1 > 0) { result.add(createLink("prev", pageNum - 1, perPage)); } // Check next if (pageNum + 1 <= maxPages) { result.add(createLink("next", pageNum + 1, perPage)); } // Check last if (maxPages > 1 && pageNum < maxPages) { result.add(createLink("last", maxPages, perPage)); } return result.toArray(new Link[result.size()]); }
private Link createLink(String rel, int pageNum, int perPage) { UriBuilder uriBuilder = uriBuilderSupplier.get().clone() .queryParam(RouterObjectService.PAGE_NUMBER_PARAM, String.valueOf(pageNum)); if (perPage != 10) { uriBuilder.queryParam(RouterObjectService.ITEMS_PER_PAGE_PARAM, String.valueOf(perPage)); } return linkCreator.apply(Link.fromUriBuilder(uriBuilder).rel(rel)); }
@SuppressWarnings("boxing") @GET @Produces(MediaType.APPLICATION_JSON) public PaginatedResponse<SummaryJsonType> getListing(@BeanParam @NotNull @Valid SearchQueryBean searchQueryBean) { final ListingResult<SummaryJsonType> summaries = getSummaryListing(searchQueryBean); final LinkFactory<ImplementationType> lf = getImplementationLinkFactory(); final List<ObjectWithSchema<SummaryJsonType>> listForResponse = summaries.getResultList().stream() .map(r -> getResponse(r, lf)).collect(Collectors.toList()); List<Link> links = Lists.newArrayList(); lf.forCall(REL_INSTANCE, r -> r.get(IdParameterBean.of(null))).ifPresent(links::add); int offset = searchQueryBean.getOffset(); int limit = searchQueryBean.getLimit(); PaginationLinkBuilder paginationLinkBuilder = PaginationLinkBuilder.of(summaries.getTotalNumberOfHits(), searchQueryBean.getOffset(), searchQueryBean.getLimit()); links.addAll(paginationLinkBuilder.generateLinks((rel, off, lim) -> { searchQueryBean.setLimit(lim); searchQueryBean.setOffset(off); return lf.forCall(rel, r -> r.getListing(searchQueryBean)); })); links.addAll(createAdditionalLinksForListing(searchQueryBean)); return PaginatedResponse.create(listForResponse, summaries.getTotalNumberOfHits(), offset, limit, JsonHyperSchema.from(links)); }
private List<Optional<Link>> createSchemaForSummary(SummaryJsonType summaryJson, LinkFactory<ImplementationType> factoryForImplementation) { final Optional<Link> selfLink = factoryForImplementation.forCall(Rel.SELF, r -> r.getSummary(IdParameterBean.of(summaryJson.getId()))); final Optional<Link> canonicalLink = factoryForImplementation.forCall(Rel.CANONICAL, r -> r.get(IdParameterBean.of(summaryJson.getId()))); final ArrayList<Optional<Link>> result = Lists.newArrayList(selfLink, canonicalLink); final List<Optional<Link>> additionalLinks = createAdditionalLinksForSummaryType(summaryJson, factoryForImplementation); result.addAll(additionalLinks); return result; }
protected ObjectWithSchema<FullJsonType> getResponse(FullJsonType json) { final LinkFactory<ImplementationType> factoryForImplementation = getImplementationLinkFactory(); final Optional<Link> selfLink = factoryForImplementation.forCall(Rel.SELF, r -> r.get(IdParameterBean.of(json.getId()))); final ArrayList<Optional<Link>> result = Lists.newArrayList(selfLink); final List<Optional<Link>> additionalLinks = createAdditionalLinksForFullType(json, factoryForImplementation); result.addAll(additionalLinks); final JsonHyperSchema hyperSchema = JsonHyperSchema.fromOptional(result); return ObjectWithSchema.create(json, hyperSchema); }
/** * Convert a {@link Link.JaxbLink} into a {@link Link}. * * @param v instance of type {@link Link.JaxbLink}. * @return mapped instance of type {@link Link.JaxbLink} */ @Override public Link unmarshal(Link.JaxbLink v) { if (v == null) { return null; } Link.Builder lb = Link.fromUri(v.getUri()); for (Map.Entry<QName, Object> e : v.getParams().entrySet()) { lb.param(e.getKey().getLocalPart(), e.getValue().toString()); } return lb.build(); }
/** * Convert a {@link Link} into a {@link Link.JaxbLink}. * * @param v instance of type {@link Link}. * @return mapped instance of type {@link Link.JaxbLink}. */ @Override public Link.JaxbLink marshal(Link v) { if (v == null) { return null; } Link.JaxbLink jl = new Link.JaxbLink(v.getUri()); for (Map.Entry<String, String> e : v.getParams().entrySet()) { final String name = e.getKey(); jl.getParams().put(new QName("", name), e.getValue()); } return jl; }
@Override public Link createLink(final VersionedFlowSnapshotMetadata snapshotMetadata) { if (snapshotMetadata == null) { return null; } final URI uri = UriBuilder.fromPath(PATH) .resolveTemplate("bucketId", snapshotMetadata.getBucketIdentifier()) .resolveTemplate("flowId", snapshotMetadata.getFlowIdentifier()) .resolveTemplate("versionNumber", snapshotMetadata.getVersion()) .build(); return Link.fromUri(uri).rel("content").build(); }
@Override public Link createLink(final Bucket bucket) { if (bucket == null) { return null; } final URI uri = UriBuilder.fromPath(PATH) .resolveTemplate("id", bucket.getIdentifier()) .build(); return Link.fromUri(uri).rel("self").build(); }
@Override public Link createLink(final VersionedFlow versionedFlow) { if (versionedFlow == null) { return null; } final URI uri = UriBuilder.fromPath(PATH) .resolveTemplate("bucketId", versionedFlow.getBucketIdentifier()) .resolveTemplate("flowId", versionedFlow.getIdentifier()) .build(); return Link.fromUri(uri).rel("self").build(); }
/** * Creates pagination links for linkRef in response header. Note that duplicate parameters or irrelevant parameters will be ignored. * * @param pageUrlTemplate the page URL template * @param pageNum the page number to create links with * @param includeNext true if you should include the next link * @return pagination links * @throws RMapApiException the RMap API exception */ public Link[] generatePageLinks(String pageUrlTemplate, Integer pageNum, boolean includeNext) throws RMapApiException{ try { //now build the pagination links HttpLinkBuilder paginationLinks = new HttpLinkBuilder(); if (pageNum>1){ String firstUrl = pageUrlTemplate.toString(); firstUrl = firstUrl.replace(Constants.PAGENUM_PLACEHOLDER, Constants.FIRST_PAGE); paginationLinks.addLink(firstUrl,LinkRels.FIRST); Integer previousPage = pageNum-1; String previousUrl = pageUrlTemplate.replace(Constants.PAGENUM_PLACEHOLDER, previousPage.toString()); paginationLinks.addLink(previousUrl,LinkRels.PREVIOUS); } if (includeNext){ String nextUrl = pageUrlTemplate.toString(); Integer nextPage = pageNum+1; nextUrl = nextUrl.replace(Constants.PAGENUM_PLACEHOLDER, nextPage.toString()); paginationLinks.addLink(nextUrl,LinkRels.NEXT); } return paginationLinks.getLinkArray(); } catch (Exception ex) { throw RMapApiException.wrap(ex, ErrorCode.ER_BAD_PARAMETER_IN_REQUEST); } }
@XmlTransient public URI getPrevious() { if (links == null) return null; for (Link link : links) { if ("previous".equals(link.getRel())) return link.getUri(); } return null; }
/** * Create Link using the URI as a String, the relationship (rel) and a datetime, * then add it to the links list * @param discoUri a Link URI as a String * @param rel a Link relationship * @param date a Link datetime */ public void addLinkWithDate(String url, String rel, Date date) { Link link = Link.fromUri(url) .rel(rel) .param(LinkRels.DATETIME, HttpHeaderDateUtils.convertDateToString(date)) .build(); links.add(link); }
/** * Convert current Link list into a Link array (Link[]) * @return Array of Links */ public Link[] getLinkArray() { int listSize = this.links.size(); if (listSize == 0){ return null; } Link[] arrayLinks = new Link[listSize]; int count = 0; for (Link link : this.links){ arrayLinks[count] = link; count = count + 1; } return arrayLinks; }
@XmlTransient public URI getNext() { if (links == null) return null; for (Link link : links) { if ("next".equals(link.getRel())) return link.getUri(); } return null; }
protected void send(UriBuilder base, AsyncResponse async, Message message) { URI nextUri = base.clone().path(CustomerChat.class) .queryParam("current", message.id).build(); Link next = Link.fromUri(nextUri).rel("next").build(); Response response = Response.ok(message.message, MediaType.TEXT_PLAIN_TYPE).links(next).build(); async.resume(response); }
@Test public void testJAXRSTypes() { // MediaType#toString and Link.Builder call RuntimeDelegate final RuntimeDelegate delegateMock = mock(RuntimeDelegate.class); final RuntimeDelegate.HeaderDelegate<MediaType> headerDelegateMock = mock(RuntimeDelegate.HeaderDelegate.class); when(delegateMock.createHeaderDelegate(MediaType.class)).thenReturn(headerDelegateMock); final Link.Builder linkBuilderMock = mock(Link.Builder.class); when(delegateMock.createLinkBuilder()).thenReturn(linkBuilderMock); when(headerDelegateMock.toString(any())).thenReturn("application/json"); when(linkBuilderMock.uri(anyString())).thenReturn(linkBuilderMock); when(linkBuilderMock.rel(anyString())).thenReturn(linkBuilderMock); when(linkBuilderMock.build()).thenReturn(new DummyLink("https://api.example.com/books/1", "self"), new DummyLink("https://api.example.com/books/123", "one", "two")); injectRuntimeDelegate(delegateMock); final String actual = Siren.createEntityBuilder() .setSubEntityType(MediaType.APPLICATION_JSON_TYPE) .setSubEntityHref(URI.create("https://api.example.com/books/1")) .addLink(Link.fromUri("https://api.example.com/books/1").rel("self").build()) .addLink(Link.fromUri("https://api.example.com/books/123").rel("one two").build()) .build().toString(); final String expected = "{" + "\"type\":\"application/json\"," + "\"href\":\"https://api.example.com/books/1\"," + "\"links\":[{" + "\"rel\":[\"self\"]," + "\"href\":\"https://api.example.com/books/1\"" + "},{" + "\"rel\":[\"one\",\"two\"]," + "\"href\":\"https://api.example.com/books/123\"}]" + "}"; assertThat(actual, is(expected)); }