static String toString(final Category category) { return new ToStringBuilder(category, SdkDefaults.TO_STRING_STYLE) .append("id", category.getId()) .append("version", category.getVersion()) .append("createdAt", category.getCreatedAt()) .append("lastModifiedAt", category.getLastModifiedAt()) .append("name", category.getName()) .append("slug", category.getSlug()) .append("description", category.getDescription()) .append("ancestors", join(category.getAncestors())) .append("parent", category.getParent()) .append("orderHint", category.getOrderHint()) .toString(); }
/** * Creates a new object initialized with the fields of the template parameter. * * @param template the template * @return a new object initialized from the template */ public static CategoryDraftBuilder of(final Category template) { return new CategoryDraftBuilder(copyAssets(template.getAssets()), copyCustom(template.getCustom()), template.getDescription(), template.getExternalId(), template.getKey(), template.getMetaDescription(), template.getMetaKeywords(), template.getMetaTitle(), template.getName(), template.getOrderHint(), template.getParent(), template.getSlug()); } }
@Override public LocalizedString getSlug() { return delegate.getSlug(); }
@Test public void createByJson() { final JsonNodeReferenceResolver referenceResolver = new JsonNodeReferenceResolver(); withCategory(client(), parent -> { referenceResolver.addResourceByKey("example-category-parent", parent); final CategoryDraft categoryDraft = draftFromJsonResource("drafts-tests/category.json", CategoryDraft.class, referenceResolver); withCategory(client(), () -> categoryDraft, category -> { assertThat(category.getName().get(Locale.ENGLISH)).isEqualTo("example category"); assertThat(category.getParent().getId()).isEqualTo(parent.getId()); }); }); } }
@Override public Optional<String> getExternalId() { return delegate.getExternalId(); }
@Override public boolean test(final Category category){ return category.getParent() != null; } }
@Test public void queryByName() throws Exception { withCategory(client(), category -> { final LocalizedStringEntry name = category.getName().stream().findAny().get(); final Query<Category> query = CategoryQuery.of().byName(name.getLocale(), name.getValue()); assertThat(client().executeBlocking(query).head().get().getId()).isEqualTo(category.getId()); }); }
@Test public void isNotInPredicates() throws Exception { final QueryPredicate<Category> predicate = CategoryQueryModel.of().name().lang(Locale.ENGLISH).isNotIn(asList("x10", "x2")); final Consumer<List<Category>> assertions = categories -> { final List<String> names = categories.stream().map(c -> c.getName().get(Locale.ENGLISH)).collect(toList()); assertThat(names).contains("x1"); assertThat(names.contains("x2")).isFalse(); assertThat(names.contains("x10")).isFalse(); }; predicateTestCase(predicate, assertions); }
@Override public List<Reference<Category>> getAncestors() { return delegate.getAncestors(); }
@Override public Optional<String> getOrderHint() { return delegate.getOrderHint(); }
@Override public Long getVersion() { return delegate.getVersion(); }
private static Map<String, Category> buildByIdMap(Collection<Category> categories) { final Map<String, Category> map = new HashMap<>(categories.size()); for (Category c: categories) { map.put(c.getId(), c); } return map; }
private static void appendToBuilder(final Category category, final StringBuilder stringBuilder, final CategoryTree categoryTree, final int level) { final String name = category.getName().get(ENGLISH); final String externalId = category.getExternalId(); final String offset = StringUtils.repeat(' ', level * 4); stringBuilder.append(offset).append(externalId).append(" ").append(name).append("\n"); final List<Category> children = categoryTree.findChildren(category); children.stream() .sorted(EXTERNALID_COMPARATOR) .forEach(child -> appendToBuilder(child, stringBuilder, categoryTree, level + 1)); } }
@Override public Optional<LocalizedStrings> getDescription() { return delegate.getDescription(); }
@Override public ZonedDateTime getCreatedAt() { return delegate.getCreatedAt(); }
@Test public void executionForDeletionByKey() throws Exception { final String key = randomKey(); final CategoryDraft draft = CategoryDraftBuilder.of(randomLocalizedString(), randomSlug()).key(key).build(); final Category category = client().executeBlocking(CategoryCreateCommand.of(draft)); client().executeBlocking(CategoryDeleteCommand.ofKey(key,category.getVersion())); assertThat(client().executeBlocking(CategoryQuery.of().byId(category.getId())).head()).isEmpty(); }
@Test public void referenceExpansionForDeletionByKey() throws Exception { final String key = randomKey(); final Category parent = client().executeBlocking(CategoryCreateCommand.of(CategoryDraftBuilder.of(randomLocalizedString(), randomSlug()).build())); final Category category = client().executeBlocking(CategoryCreateCommand.of(CategoryDraftBuilder.of(randomLocalizedString(), randomSlug()).key(key).parent(parent).build())); final CategoryDeleteCommand deleteCommand = CategoryDeleteCommand.ofKey(key, category.getVersion()).plusExpansionPaths(m -> m.parent()); final Category deletedCategory = client().executeBlocking(deleteCommand); assertThat(deletedCategory.getParent().getObj()).isNotNull().isEqualTo(parent); client().executeBlocking(CategoryDeleteCommand.of(parent)); } }
private void createdAtTest(final BiFunction<TimestampSortingModel<Category>, ZonedDateTime, QueryPredicate<Category>> predicateFunction) { withCategory(client(), category -> { final QueryPredicate<Category> predicate = predicateFunction.apply(CategoryQueryModel.of().createdAt(), category.getCreatedAt()); final CategoryQuery baseQuery = CategoryQuery.of() .withPredicates(predicate) .plusPredicates(m -> m.id().is(category.getId())); final Optional<Category> fetched = client().executeBlocking(baseQuery).head(); assertThat(fetched).contains(category); }); }
@Test public void toReference() { final Category category = getCategory1(); final Reference<Category> categoryReference = category.toReference(); assertThat(category.getId()).isEqualTo(categoryReference.getId()); }
@Override public LocalizedString getSlug() { return delegate.getSlug(); }