/**
* Retrieve the attribute of an entity
*
* @param entityId the entity ID
* @param type optional entity type to avoid ambiguity when multiple entities have the same ID,
* null or zero-length for empty
* @param attributeName the attribute name
* @return
*/
public ListenableFuture<Object> getAttributeValue(
String entityId, String type, String attributeName) {
UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(baseURL);
builder.path("v2/entities/{entityId}/attrs/{attributeName}/value");
addParam(builder, "type", type);
return adapt(
request(
HttpMethod.GET,
builder.buildAndExpand(entityId, attributeName).toUriString(),
null,
Object.class));
}
private UriComponents applyContributers(
UriComponentsBuilder builder,
Method method,
Object[] argumentValues,
Map<String, Object> uriVars) {
if (this.contributors.isEmpty()) {
return builder.buildAndExpand(uriVars);
}
int paramCount = method.getParameters().length;
int argCount = argumentValues.length;
Assert.isTrue(
paramCount == argCount,
"Number of method parameters "
+ paramCount
+ " does not match number of argument values "
+ argCount);
for (int i = 0; i < paramCount; i++) {
MethodParameter param = new MethodParameter(method, i);
param.initParameterNameDiscovery(parameterNameDiscoverer);
for (UriComponentsContributor c : this.contributors) {
if (c.supportsParameter(param)) {
c.contributeMethodArgument(
param, argumentValues[i], builder, uriVars, this.conversionService);
break;
}
}
}
return builder.buildAndExpand(uriVars);
}
private String path(UriComponentsBuilder builder, Page page, boolean encode) {
Map<String, Object> params = new HashMap<>();
PageTree pageTree =
(PageTree) processingContext.getContext().getVariables().get("PAGE_TREE_ALL");
// PageTree pageTree =
// defaultModelAttributeService.readPageTree(LocaleContextHolder.getLocale().getLanguage());
List<String> codes = new LinkedList<>();
Page parent = page.getParent();
while (parent != null) {
codes.add(parent.getCode());
parent =
(parent.getParent() != null)
? pageTree.getPageByCode(parent.getParent().getCode())
: null;
}
Collections.reverse(codes);
codes.add(page.getCode());
for (int i = 0; i < codes.size(); i++) {
String key = "code" + i;
builder.path("/{" + key + "}");
params.put(key, codes.get(i));
}
UriComponents components = builder.buildAndExpand(params);
if (encode) {
components = components.encode();
}
return components.toUriString();
}
/**
* Delete an entity
*
* @param entityId the entity ID
* @param type optional entity type to avoid ambiguity when multiple entities have the same ID,
* null or zero-length for empty
* @return the listener to notify of completion
*/
public ListenableFuture<Void> deleteEntity(String entityId, String type) {
UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(baseURL);
builder.path("v2/entities/{entityId}");
addParam(builder, "type", type);
return adapt(
request(
HttpMethod.DELETE, builder.buildAndExpand(entityId).toUriString(), null, Void.class));
}
/**
* Retrieve an entity type
*
* @param entityType the entityType to retrieve
* @return an entity type
*/
public ListenableFuture<EntityType> getEntityType(String entityType) {
UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(baseURL);
builder.path("v2/types/{entityType}");
return adapt(
request(
HttpMethod.GET,
builder.buildAndExpand(entityType).toUriString(),
null,
EntityType.class));
}
/**
* Retrieve the registration by registration ID
*
* @param registrationId the registration ID
* @return registration
*/
public ListenableFuture<Registration> getRegistration(String registrationId) {
UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(baseURL);
builder.path("v2/registrations/{registrationId}");
return adapt(
request(
HttpMethod.GET,
builder.buildAndExpand(registrationId).toUriString(),
null,
Registration.class));
}
/**
* Delete the subscription by subscription ID
*
* @param subscriptionId the subscription ID
* @return
*/
public ListenableFuture<Void> deleteSubscription(String subscriptionId) {
UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(baseURL);
builder.path("v2/subscriptions/{subscriptionId}");
return adapt(
request(
HttpMethod.DELETE,
builder.buildAndExpand(subscriptionId).toUriString(),
null,
Void.class));
}
/**
* Get an entity
*
* @param entityId the entity ID
* @param type optional entity type to avoid ambiguity when multiple entities have the same ID,
* null or zero-length for empty
* @param attrs the list of attributes to retreive for this entity, null or empty means all
* attributes
* @return the entity
*/
public ListenableFuture<Entity> getEntity(
String entityId, String type, Collection<String> attrs) {
UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(baseURL);
builder.path("v2/entities/{entityId}");
addParam(builder, "type", type);
addParam(builder, "attrs", attrs);
return adapt(
request(
HttpMethod.GET, builder.buildAndExpand(entityId).toUriString(), null, Entity.class));
}
/**
* Update the registration by registration ID
*
* @param registrationId the registration ID
* @return
*/
public ListenableFuture<Void> updateRegistration(
String registrationId, Registration registration) {
UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(baseURL);
builder.path("v2/registrations/{registrationId}");
return adapt(
request(
HttpMethod.PATCH,
builder.buildAndExpand(registrationId).toUriString(),
registration,
Void.class));
}
/**
* Replace all the existing attributes of an entity with a new set of attributes
*
* @param entityId the entity ID
* @param type optional entity type to avoid ambiguity when multiple entities have the same ID,
* null or zero-length for empty
* @param attributes the new set of attributes
* @return the listener to notify of completion
*/
public ListenableFuture<Void> replaceEntity(
String entityId, String type, Map<String, Attribute> attributes) {
UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(baseURL);
builder.path("v2/entities/{entityId}");
addParam(builder, "type", type);
return adapt(
request(
HttpMethod.PUT,
builder.buildAndExpand(entityId).toUriString(),
attributes,
Void.class));
}
/**
* Delete the attribute of an entity
*
* @param entityId the entity ID
* @param type optional entity type to avoid ambiguity when multiple entities have the same ID,
* null or zero-length for empty
* @param attributeName the attribute name
* @return
*/
public ListenableFuture<Attribute> deleteAttribute(
String entityId, String type, String attributeName) {
UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(baseURL);
builder.path("v2/entities/{entityId}/attrs/{attributeName}");
addParam(builder, "type", type);
return adapt(
request(
HttpMethod.DELETE,
builder.buildAndExpand(entityId, attributeName).toUriString(),
null,
Attribute.class));
}
private String path(UriComponentsBuilder builder, Article article, boolean encode) {
Map<String, Object> params = new HashMap<>();
builder.path("/{year}/{month}/{day}/{code}");
params.put("year", String.format("%04d", article.getDate().getYear()));
params.put("month", String.format("%02d", article.getDate().getMonthOfYear()));
params.put("day", String.format("%02d", article.getDate().getDayOfMonth()));
params.put("code", article.getCode());
UriComponents components = builder.buildAndExpand(params);
if (encode) {
components = components.encode();
}
return components.toUriString();
}
/**
* Update existing or append some attributes to an entity
*
* @param entityId the entity ID
* @param type optional entity type to avoid ambiguity when multiple entities have the same ID,
* null or zero-length for empty
* @param attributes the attributes to update or to append
* @param append if true, will only allow to append new attributes
* @return the listener to notify of completion
*/
public ListenableFuture<Void> updateEntity(
String entityId, String type, Map<String, Attribute> attributes, boolean append) {
UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(baseURL);
builder.path("v2/entities/{entityId}");
addParam(builder, "type", type);
if (append) {
addParam(builder, "options", "append");
}
return adapt(
request(
HttpMethod.POST,
builder.buildAndExpand(entityId).toUriString(),
attributes,
Void.class));
}
/**
* Retrieve the attribute of an entity
*
* @param entityId the entity ID
* @param type optional entity type to avoid ambiguity when multiple entities have the same ID,
* null or zero-length for empty
* @param attributeName the attribute name
* @return
*/
public ListenableFuture<String> getAttributeValueAsString(
String entityId, String type, String attributeName) {
UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(baseURL);
builder.path("v2/entities/{entityId}/attrs/{attributeName}/value");
addParam(builder, "type", type);
HttpHeaders httpHeaders = cloneHttpHeaders();
httpHeaders.setAccept(Collections.singletonList(MediaType.TEXT_PLAIN));
return adapt(
request(
HttpMethod.GET,
builder.buildAndExpand(entityId, attributeName).toUriString(),
httpHeaders,
null,
String.class));
}
private String link(Article article) {
UriComponentsBuilder builder = ServletUriComponentsBuilder.fromCurrentContextPath();
Map<String, Object> params = new HashMap<>();
Blog blog = blogService.readBlogById(Blog.DEFAULT_ID);
if (blog.getLanguages().size() > 1) {
builder.path("/{language}");
params.put("language", LocaleContextHolder.getLocale().getLanguage());
}
builder.path("/{year}/{month}/{day}/{code}");
params.put("year", String.format("%04d", article.getDate().getYear()));
params.put("month", String.format("%02d", article.getDate().getMonthOfYear()));
params.put("day", String.format("%02d", article.getDate().getDayOfMonth()));
params.put("code", article.getCode());
return builder.buildAndExpand(params).encode().toUriString();
}
protected void buildFeedMetadata(
Map<String, Object> model, Feed feed, HttpServletRequest request) {
Blog blog = blogService.readBlogById(Blog.DEFAULT_ID);
String language = LocaleContextHolder.getLocale().getLanguage();
feed.setTitle(blog.getTitle(language));
Content info = new Content();
info.setValue(blog.getTitle(language));
feed.setInfo(info);
ArrayList<Link> links = new ArrayList<>();
Link link = new Link();
UriComponentsBuilder builder = ServletUriComponentsBuilder.fromCurrentContextPath();
link.setHref(builder.buildAndExpand().toUriString());
links.add(link);
feed.setOtherLinks(links);
// feed.setIcon("http://" + settings.getAsString(Setting.Key.SITE_URL) +
// "resources/default/img/favicon.ico");
}
@RequestMapping(method = RequestMethod.GET)
public String search(
@PathVariable String language,
@Validated ArticleSearchForm form,
BindingResult result,
@PageableDefault(50) Pageable pageable,
Model model,
HttpSession session) {
Page<Article> articles = articleService.readArticles(form.toArticleSearchRequest(), pageable);
new DomainObjectSearchCondition<>(session, form, pageable);
model.addAttribute("form", form);
model.addAttribute("articles", articles);
model.addAttribute("pageable", pageable);
UriComponentsBuilder builder = UriComponentsBuilder.fromPath(Application.ADMIN_SERVLET_PATH);
builder.path("/{language}/articles/index");
builder.queryParams(form.toQueryParams());
String url = builder.buildAndExpand(language).toString();
model.addAttribute("pagination", new Pagination<>(articles, url));
return "article/index";
}
