public CategoryDraftDsl withExternalId(@Nullable final String externalId) { return newBuilder().externalId(externalId).build(); }
/** * Creates a new object initialized with the given values. * * @param name initial value for the {@link CategoryDraft#getName()} property * @param slug initial value for the {@link CategoryDraft#getSlug()} property * @return new object initialized with the given values */ public static CategoryDraftBuilder of(final LocalizedString name, final LocalizedString slug) { return new CategoryDraftBuilder(null, null, null, null, null, null, null, null, name, null, null, slug); }
public CategoryDraftDsl withMetaDescription(@Nullable final LocalizedString metaDescription) { return newBuilder().metaDescription(metaDescription).build(); }
private static void setupCategories() { final List<Category> rootCategories = Stream.of("A", "B", "C") .map(id -> CategoryDraftBuilder.of(en("name " + id), en("slug-" + id)).externalId(id).build()) .map(createCategory()) .collect(toList()); final List<Category> secondLevelCategories = rootCategories.stream() .flatMap(parent -> IntStream.range(1, 4) .mapToObj(i -> { final String id = parent.getExternalId() + "-" + i; return CategoryDraftBuilder.of(en("name " + id), en("slug-" + id)) .parent(parent).externalId(id).build(); }) .map(createCategory())) .collect(Collectors.toList()); final List<Category> thirdLevelCategories = secondLevelCategories.stream() .flatMap(parent -> IntStream.range(1, 4) .mapToObj(i -> { final String id = parent.getExternalId() + "-" + i; return CategoryDraftBuilder.of(en("name " + id), en("slug-" + id)).parent(parent).externalId(id).build(); }) .map(createCategory())) .collect(Collectors.toList()); final List<Category> all = new LinkedList<>(); all.addAll(rootCategories); all.addAll(secondLevelCategories); all.addAll(thirdLevelCategories); assertThat(all).hasSize(39); categoryTree = CategoryTree.of(all); }
@Test public void execution() throws Exception { final LocalizedString name = LocalizedString.of(Locale.ENGLISH, "winter clothing"); final LocalizedString slug = name.slugifiedUnique(); final String externalId = randomKey(); final LocalizedString metaDescription = LocalizedString.of(Locale.ENGLISH, "winter clothing to keep you warm"); final LocalizedString metaTitle = LocalizedString.of(Locale.ENGLISH, "winter warm clothing"); final LocalizedString metaKeywords = LocalizedString.of(Locale.ENGLISH, "winter,clothes"); final CategoryDraft categoryDraft = CategoryDraftBuilder.of(name, slug) .metaDescription(metaDescription) .metaTitle(metaTitle) .metaKeywords(metaKeywords) .externalId(externalId).build(); final Category category = client().executeBlocking(CategoryCreateCommand.of(categoryDraft)); assertThat(category.getName()).isEqualTo(name); assertThat(category.getSlug()).isEqualTo(slug); assertThat(category.getMetaTitle()).isEqualTo(metaTitle); assertThat(category.getMetaDescription()).isEqualTo(metaDescription); assertThat(category.getMetaKeywords()).isEqualTo(metaKeywords); assertThat(category.getExternalId()).contains(externalId); }
@Test public void referenceExpansion() throws Exception { final Category parent = client().executeBlocking(CategoryCreateCommand.of(CategoryDraftBuilder.of(randomSlug(), randomSlug()).build())); final Category category = client().executeBlocking(CategoryCreateCommand.of(CategoryDraftBuilder.of(randomSlug(), randomSlug()).parent(parent).build())); final CategoryDeleteCommand deleteCommand = CategoryDeleteCommand.of(category).plusExpansionPaths(m -> m.parent()); final Category deletedCategory = client().executeBlocking(deleteCommand); assertThat(deletedCategory.getParent().getObj()).isNotNull().isEqualTo(parent); client().executeBlocking(CategoryDeleteCommand.of(parent)); }
private void createCategory() { final Map<String, Object> fields = new HashMap<>(); fields.put(BOOLEAN_FIELD_NAME, BOOLEAN); fields.put(DATE_FIELD_NAME, DATE); fields.put(DATETIME_FIELD_NAME, ZONED_DATE_TIME); fields.put(DOUBLE_FIELD_NAME, DOUBLE); fields.put(BIG_DECIMAL_FIELD_NAME,BIG_DECIMAL); fields.put(ENUM_FIELD_NAME, ENUM_KEY); fields.put(INT_FIELD_NAME, INT); fields.put(LOCALIZED_ENUM_FIELD_NAME, LOC_ENUM_KEY); fields.put(LOC_STRING_FIELD_NAME, LOCALIZED_STRING); fields.put(MONEY_FIELD_NAME, MONETARY_AMOUNT); fields.put(STRING_FIELD_NAME, STRING); fields.put(TIME_FIELD_NAME, TIME); fields.put(STRING_SET_FIELD_NAME, STRING_SET); final CategoryDraft categoryDraft = CategoryDraftBuilder.of(randomSlug(), randomSlug()) .custom(CustomFieldsDraft.ofTypeIdAndObjects(type.getId(), fields)) .build(); category = client.executeBlocking(CategoryCreateCommand.of(categoryDraft)); }
public static void withCategoryAndParentCategory(final BlockingSphereClient client, final BiConsumer<Category, Category> consumer) { withCategory(client, parent -> withCategory(client, CategoryDraftBuilder.of(randomSlug(), randomSlug()).key(randomKey()).parent(parent), category -> { consumer.accept(category, parent); }) ); }
public static void withPersistentCategory(final BlockingSphereClient client, final Consumer<Category> user) { final String externalId = "persistent-category-id"; final Optional<Category> fetchedCategory = client.executeBlocking(CategoryQuery.of().byExternalId(externalId)).head(); final Category category = fetchedCategory.orElseGet(() -> { final LocalizedString name = en("name persistent-category-id"); final CategoryDraftBuilder catSupplier = CategoryDraftBuilder.of(name, name.slugified()).externalId(externalId); return client.executeBlocking(CategoryCreateCommand.of(catSupplier.build())); }); user.accept(category); }
@Test public void containsDraftGetter() { final CategoryDraft categoryDraft = CategoryDraftBuilder.of(randomSlug(), randomSlug()).build(); final CategoryCreateCommand categoryCreateCommand = CategoryCreateCommand.of(categoryDraft); assertThat(categoryCreateCommand.getDraft()).isEqualTo(categoryDraft); } }
private static CategoryDraftBuilder categorySupplier() { final LocalizedString slug = randomSlug(); return CategoryDraftBuilder.of(en(slug.get(ENGLISH) + " name"), slug).externalId(randomKey()); }
@Test public void ancestors() throws Exception { withCategory(client(), CategoryDraftBuilder.of(en("1"), en("level1")), level1 -> { withCategory(client(), CategoryDraftBuilder.of(en("2"), en("level2")).parent(level1), level2 -> { withCategory(client(), CategoryDraftBuilder.of(en("3"), en("level3")).parent(level2), level3 -> { withCategory(client(), CategoryDraftBuilder.of(en("4"), en("level4")).parent(level3), level4 -> { final ExpansionPath<Category> expansionPath = CategoryExpansionModel.of().ancestors().ancestors().expansionPaths().get(0); final Query<Category> query = CategoryQuery.of().byId(level4.getId()) .withExpansionPaths(expansionPath) .toQuery(); final PagedQueryResult<Category> queryResult = client().executeBlocking(query); final Category loadedLevel4 = queryResult.head().get(); final List<Reference<Category>> ancestors = loadedLevel4.getAncestors(); final List<String> expectedAncestorIds = ancestors.stream().map(r -> r.getObj().getId()).collect(toList()); assertThat(expectedAncestorIds).isEqualTo(asList(level1.getId(), level2.getId(), level3.getId())); final Category level3ExpandedAncestor = ancestors.get(2).getObj(); assertThat(level3ExpandedAncestor.getId()).isEqualTo(level3.getId()); assertThat(level3ExpandedAncestor.getAncestors().get(0).getObj().getId()).isEqualTo(level1.getId()); }); }); }); }); }
public CategoryDraftDsl withDescription(@Nullable final LocalizedString description) { return newBuilder().description(description).build(); }
@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(); }
public CategoryDraftBuilder externalId(final String externalId) { Objects.requireNonNull(externalId); return externalId(Optional.of(externalId)); }