private void addPaginationParams(UriComponentsBuilder builder, int offset, int limit) {
if (offset > 0) {
builder.queryParam("offset", offset);
}
if (limit > 0) {
builder.queryParam("limit", limit);
}
}
@RequestMapping("/drug/enforcements")
@ResponseBody
public JsonNode getDrugRecallsForUnii(
@RequestParam(value = "unii", defaultValue = "") String unii,
@RequestParam(value = "limit", defaultValue = "0") int limit)
throws Exception {
JsonNode node;
HttpHeaders headers = new HttpHeaders();
ObjectMapper mapper = new ObjectMapper();
headers.set("Accept", MediaType.APPLICATION_JSON_VALUE);
UriComponentsBuilder builder =
UriComponentsBuilder.fromHttpUrl(searchDrugEnfrcmntUrl)
.queryParam("limit", uniiRecallsLimit);
this.apiKey.addToUriComponentsBuilder(builder);
if (unii != null && unii.trim().length() > 0) {
builder.queryParam("search", "openfda.unii:" + unii);
try {
node = mapper.readTree(rest.getForObject(builder.build().toUri(), String.class));
((ObjectNode) node).set("results", getSortedResults(node.get("results"), limit));
} catch (HttpClientErrorException ex) {
if (ex.getStatusCode().value() == 404) {
node =
new ObjectMapper()
.readTree(
"{\"error\":{\"code\":\"NOT_FOUND\", \"message\":\"No matches found!\"}}");
} else {
throw ex;
}
}
} else {
node = getDrugRecalls(limit == 0 ? 10 : limit, null, null);
}
return node;
}
private void addGeoQueryParams(UriComponentsBuilder builder, GeoQuery geoQuery) {
if (geoQuery != null) {
StringBuilder georel = new StringBuilder(geoQuery.getRelation().name());
if (geoQuery.getRelation() == GeoQuery.Relation.near) {
georel.append(';').append(geoQuery.getModifier());
georel.append(':').append(geoQuery.getDistance());
}
builder.queryParam("georel", georel.toString());
builder.queryParam("geometry", geoQuery.getGeometry());
builder.queryParam(
"coords",
geoQuery
.getCoordinates()
.stream()
.map(Coordinate::toString)
.collect(Collectors.joining(";")));
}
}
private String append(
String base, Map<String, ?> query, Map<String, String> keys, boolean fragment) {
UriComponentsBuilder template = UriComponentsBuilder.newInstance();
UriComponentsBuilder builder = UriComponentsBuilder.fromUriString(base);
URI redirectUri;
try {
// assume it's encoded to start with (if it came in over the wire)
redirectUri = builder.build(true).toUri();
} catch (Exception e) {
// ... but allow client registrations to contain hard-coded non-encoded values
redirectUri = builder.build().toUri();
builder = UriComponentsBuilder.fromUri(redirectUri);
}
template
.scheme(redirectUri.getScheme())
.port(redirectUri.getPort())
.host(redirectUri.getHost())
.userInfo(redirectUri.getUserInfo())
.path(redirectUri.getPath());
if (fragment) {
StringBuilder values = new StringBuilder();
if (redirectUri.getFragment() != null) {
String append = redirectUri.getFragment();
values.append(append);
}
for (String key : query.keySet()) {
if (values.length() > 0) {
values.append("&");
}
String name = key;
if (keys != null && keys.containsKey(key)) {
name = keys.get(key);
}
values.append(name + "={" + key + "}");
}
if (values.length() > 0) {
template.fragment(values.toString());
}
UriComponents encoded = template.build().expand(query).encode();
builder.fragment(encoded.getFragment());
} else {
for (String key : query.keySet()) {
String name = key;
if (keys != null && keys.containsKey(key)) {
name = keys.get(key);
}
template.queryParam(name, "{" + key + "}");
}
template.fragment(redirectUri.getFragment());
UriComponents encoded = template.build().expand(query).encode();
builder.query(encoded.getQuery());
}
return builder.build().toUriString();
}
@RequestMapping("/completion")
public String completion(
@Validated OrderForm form,
@RequestParam(value = "productCode") String productCode,
UriComponentsBuilder uriBuilder) {
orderService.order(productCode, form.getQuantity());
uriBuilder.path("/menu");
uriBuilder.queryParam("orderedCode", productCode);
return "redirect:" + uriBuilder.build().toUriString();
}
/*
* (non-Javadoc)
* @see org.springframework.hateoas.MethodLinkBuilderFactory#linkTo(java.lang.Object)
*/
@Override
public ControllerLinkBuilder linkTo(Object invocationValue) {
Assert.isInstanceOf(LastInvocationAware.class, invocationValue);
LastInvocationAware invocations = (LastInvocationAware) invocationValue;
MethodInvocation invocation = invocations.getLastInvocation();
Iterator<Object> classMappingParameters = invocations.getObjectParameters();
Method method = invocation.getMethod();
String mapping = DISCOVERER.getMapping(method);
UriComponentsBuilder builder = ControllerLinkBuilder.getBuilder().path(mapping);
UriTemplate template = new UriTemplate(mapping);
Map<String, Object> values = new HashMap<String, Object>();
Iterator<String> names = template.getVariableNames().iterator();
while (classMappingParameters.hasNext()) {
values.put(names.next(), classMappingParameters.next());
}
for (BoundMethodParameter parameter : PATH_VARIABLE_ACCESSOR.getBoundParameters(invocation)) {
values.put(parameter.getVariableName(), parameter.asString());
}
for (BoundMethodParameter parameter : REQUEST_PARAM_ACCESSOR.getBoundParameters(invocation)) {
Object value = parameter.getValue();
String key = parameter.getVariableName();
if (value instanceof Collection) {
for (Object element : (Collection<?>) value) {
builder.queryParam(key, element);
}
} else {
builder.queryParam(key, parameter.asString());
}
}
UriComponents components =
applyUriComponentsContributer(builder, invocation).buildAndExpand(values);
return new ControllerLinkBuilder(UriComponentsBuilder.fromUri(components.toUri()));
}
private String getHref(int pageParameter) {
UriComponentsBuilder localBuilder = baseComponent.cloneBuilder();
if (queryString == null) {
return localBuilder
.queryParam(HalResourceMetadata.PARAM_PAGE, pageParameter)
.build()
.toString();
} else {
return localBuilder
.query(queryString)
.queryParam(HalResourceMetadata.PARAM_PAGE, pageParameter)
.build()
.toString();
}
}
/*
* (non-Javadoc)
* @see org.springframework.hateoas.mvc.UriComponentsContributor#enhance(org.springframework.web.util.UriComponentsBuilder, org.springframework.core.MethodParameter, java.lang.Object)
*/
@Override
public void enhance(UriComponentsBuilder builder, MethodParameter parameter, Object value) {
if (!(value instanceof Sort)) {
return;
}
Sort sort = (Sort) value;
String sortParameter = getSortParameter(parameter);
builder.replaceQueryParam(sortParameter);
for (String expression : foldIntoExpressions(sort)) {
builder.queryParam(sortParameter, expression);
}
}
/**
* Augments a {@link UriComponentsBuilder} with queries based on the methods annotated with {@link
* FilterParameter}
*
* @param builder the builder to augment
* @param instance the instance to inspect and invoke
*/
@SuppressWarnings("unchecked")
public static void augment(UriComponentsBuilder builder, Object instance) {
Method[] methods = ReflectionUtils.getAllDeclaredMethods(instance.getClass());
Arrays.sort(methods, MethodNameComparator.INSTANCE);
for (Method method : methods) {
FilterParameter filterParameter =
AnnotationUtils.getAnnotation(method, FilterParameter.class);
if (filterParameter == null) {
continue;
}
String value = getValue(method, instance);
if (StringUtils.hasText(value)) {
builder.queryParam(filterParameter.value(), value);
}
}
}
private void addParam(
UriComponentsBuilder builder, String key, Collection<? extends CharSequence> value) {
if (!nullOrEmpty(value)) {
builder.queryParam(key, String.join(",", value));
}
}
private void addParam(UriComponentsBuilder builder, String key, String value) {
if (!nullOrEmpty(value)) {
builder.queryParam(key, value);
}
}