/** * Create a child node in this node in the given branch * * @param creator * @param schemaVersion * @param project * @param branch * @return */ default Node create(User creator, SchemaContainerVersion schemaVersion, Project project, Branch branch) { return create(creator, schemaVersion, project, branch, null); }
/** * Iterate the version chain from the back in order to find the given version. * * @param languageTag * @param branchUuid * @param version * @return Found version or null when no version could be found. */ default NodeGraphFieldContainer findVersion(String languageTag, String branchUuid, String version) { return findVersion(Arrays.asList(languageTag), branchUuid, version); }
/** * Return the draft field containers of the node in the latest branch. * * @return */ default TraversalResult<? extends NodeGraphFieldContainer> getDraftGraphFieldContainers() { // FIX ME: We should not rely on specific branches. return getGraphFieldContainersIt(getProject().getLatestBranch(), DRAFT); }
public NodeAssert matches(NodeCreateRequest request) { assertNotNull(request); assertNotNull(actual); // for (Entry<String, String> entry : request.getProperties().entrySet()) { // // Language language = languageService.findByLanguageTag(languageTag); // String propValue = node.getI18nProperties(language).getProperty(entry.getKey()); // assertEquals("The property {" + entry.getKey() + "} did not match with the response object property", entry.getValue(), propValue); // } assertNotNull(actual.getUuid()); assertNotNull(actual.getCreator()); return this; }
public static Node mockNodeBasic(String schemaType, User user) { Node node = mock(Node.class); when(node.getUuid()).thenReturn(NODE_DELOREAN_UUID); SchemaContainer schemaContainer = mockSchemaContainer(schemaType, user); when(node.getSchemaContainer()).thenReturn(schemaContainer); return node; }
public Object breadcrumbFetcher(DataFetchingEnvironment env) { GraphQLContext gc = env.getContext(); NodeContent content = env.getSource(); if (content == null) { return null; } return content.getNode().getBreadcrumbNodes(gc).stream().map(node -> { List<String> languageTags = getLanguageArgument(env, content); return new NodeContent(node, node.findVersion(gc, languageTags), languageTags); }).collect(Collectors.toList()); }
/** * Use the given node to populate the parent node fields within the source map. * * @param document * @param parentNode */ private void addParentNodeInfo(JsonObject document, Node parentNode) { JsonObject info = new JsonObject(); info.put(UUID_KEY, parentNode.getUuid()); // TODO check whether nesting of nested elements would also work // TODO FIXME MIGRATE: How to add this reference info? The schema is now linked to the node. Should we add another reference: // (n:Node)->(sSchemaContainer) ? // parentNodeInfo.put("schema.name", parentNode.getSchemaContainer().getName()); // parentNodeInfo.put("schema.uuid", parentNode.getSchemaContainer().getUuid()); document.put("parentNode", info); }
/** * Fetcher for the project base node. * * @param env * @return */ private NodeContent baseNodeFetcher(DataFetchingEnvironment env) { GraphQLContext gc = env.getContext(); Project project = env.getSource(); Node node = project.getBaseNode(); gc.requiresPerm(node, READ_PERM, READ_PUBLISHED_PERM); List<String> languageTags = getLanguageArgument(env); NodeGraphFieldContainer container = node.findVersion(gc, languageTags); return new NodeContent(node, container, languageTags); }
/** * Return containers of the given type and branch. * * @param branch * @param type * @return */ default TraversalResult<? extends NodeGraphFieldContainer> getGraphFieldContainersIt(Branch branch, ContainerType type) { return getGraphFieldContainersIt(branch.getUuid(), type); }
/** * Deletes the container for the index in which it should reside. * * @param container * @param branchUuid * @param type * @return */ private Completable deleteContainer(NodeGraphFieldContainer container, String branchUuid, ContainerType type) { String projectUuid = container.getParentNode().getProject().getUuid(); return searchProvider.deleteDocument(container.getIndexName(projectUuid, branchUuid, type), container.getDocumentId()); }
/** * Assert that the micronode uses the given microschema. * * @param microschemaContainerVersion * microschema container * @return Fluent API */ public MicronodeAssert isOf(MicroschemaContainerVersion microschemaContainerVersion) { assertTrue(actual.getSchemaContainerVersion().getUuid().equals(microschemaContainerVersion.getUuid())); return this; }
/** * Assert that the node does not have a translation in the given language. * * @param languageTag * language tag * @return fluent API */ public NodeAssert doesNotHaveTranslation(String languageTag) { assertThat(actual.getAvailableLanguageNames()).as(descriptionText() + " languages").doesNotContain(languageTag); return this; }
/** * Return a traversal of graph field containers of given type for the node in the given branch. * * @param branch * @param type * @return */ default TraversalResult<? extends NodeGraphFieldContainer> getGraphFieldContainers(Branch branch, ContainerType type) { return getGraphFieldContainers(branch.getUuid(), type); }
/** * Generate a language fallback list and utilize any existing language fallback list from the given content. * * @param env * @param content * @return */ public List<String> getLanguageArgument(DataFetchingEnvironment env, NodeContent content) { return getLanguageArgument(env, content.getLanguageFallback()); }
/** * Assert that the response contains the given node * * @param node * node * @return Fluent API */ public NodeResponseAssert is(Node node) { assertThat(actual.getUuid()).as("Uuid").isEqualTo(node.getUuid()); return this; }
/** * Data fetcher for the root node of the current project. * * @param env * @return */ public Object rootNodeFetcher(DataFetchingEnvironment env) { GraphQLContext gc = env.getContext(); Project project = gc.getProject(); if (project != null) { Node node = project.getBaseNode(); gc.requiresPerm(node, READ_PERM, READ_PUBLISHED_PERM); List<String> languageTags = getLanguageArgument(env); NodeGraphFieldContainer container = node.findVersion(gc, languageTags); return new NodeContent(node, container, languageTags); } return null; }
/** * Tests if the node has at least one content that is published. * @param branchUuid */ default boolean hasPublishedContent(String branchUuid) { return getGraphFieldContainersIt(branchUuid, ContainerType.PUBLISHED).iterator().hasNext(); }
/** * Find a node field container that matches the nearest possible value for the language parameter. * * @param ac * @param languageTags * @return Next matching field container or null when no language matches */ default NodeGraphFieldContainer findVersion(InternalActionContext ac, List<String> languageTags) { return findVersion(languageTags, ac.getBranch().getUuid(), ac.getVersioningParameters().getVersion()); }
/** * Assert that the node has a translation in the given language. * * @param languageTag * language tag * @return fluent API */ public NodeAssert hasTranslation(String languageTag) { assertThat(actual.getAvailableLanguageNames()).as(descriptionText() + " languages").contains(languageTag); return this; }
/** * Return the document id for the container. * * @return */ default String getDocumentId() { return composeDocumentId(getParentNode().getUuid(), getLanguageTag()); }