/** * 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 String generateVersion(NodeGraphFieldContainer container, String branchUuid, ContainerType type) { Node node = container.getParentNode(); Project project = node.getProject(); StringBuilder builder = new StringBuilder(); builder.append(container.getElementVersion()); builder.append("|"); builder.append(branchUuid); builder.append("|"); builder.append(type.name()); builder.append("|"); builder.append(project.getUuid() + project.getName()); builder.append("|"); builder.append(node.getElementVersion()); return ETag.hash(builder.toString()); }
public static Node mockNode(Node parentNode, Project project, User user, String languageTag, Tag tagA, Tag tagB) { Node node = mock(Node.class); when(node.getParentNode(anyString())).thenReturn(parentNode); when(node.getProject()).thenReturn(project); TraversalResult<? extends Tag> tagResult = new TraversalResult<>(Arrays.asList(tagA, tagB)); Mockito.<TraversalResult<? extends Tag>>when(node.getTags(any(Branch.class))).thenReturn(tagResult); SchemaContainer schemaContainer = mockSchemaContainer("content", user); SchemaContainerVersion latestVersion = schemaContainer.getLatestVersion(); when(latestVersion.getUuid()).thenReturn(UUID_2); when(node.getSchemaContainer()).thenReturn(schemaContainer); when(node.getCreator()).thenReturn(user); when(node.getUuid()).thenReturn(NODE_DELOREAN_UUID); when(node.getRolesWithPerm(GraphPermission.READ_PERM)).thenReturn(createEmptyTraversal()); when(node.getRolesWithPerm(GraphPermission.READ_PUBLISHED_PERM)).thenReturn(createEmptyTraversal()); NodeGraphFieldContainer container = mockContainer(languageTag, user); when(container.getSchemaContainerVersion()).thenReturn(latestVersion); when(container.getParentNode()).thenReturn(node); when(container.getElementVersion()).thenReturn(UUID_5); when(node.getLatestDraftFieldContainer(languageTag)).thenReturn(container); when(node.getElementVersion()).thenReturn(UUID_4); Mockito.<Iterable<? extends NodeGraphFieldContainer>> when(node.getDraftGraphFieldContainers()).thenReturn(createEmptyTraversal()); return node; }
/** * 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()); }
/** * Step 1 - Check whether we need to handle all branches. * * @param node * @param context * @return */ private Observable<IndexBulkEntry> storeForBulk(Node node, GenericEntryContext context) { if (context.getBranchUuid() == null) { Set<Observable<IndexBulkEntry>> obs = new HashSet<>(); for (Branch branch : node.getProject().getBranchRoot().findAll()) { obs.add(storeForBulk(node, branch.getUuid(), context)); } return Observable.merge(obs); } else { return storeForBulk(node, context.getBranchUuid(), context); } }
/** * Step 1 - Check whether we need to handle all branches. * * @param obs * @param node * @param context */ private void store(Set<Single<String>> obs, Node node, GenericEntryContext context) { if (context.getBranchUuid() == null) { for (Branch branch : node.getProject().getBranchRoot().findAll()) { store(obs, node, branch.getUuid(), context); } } else { store(obs, node, context.getBranchUuid(), context); } }
Project theirProject = node.getProject(); if (ourProject != null && !ourProject.equals(theirProject)) { branchUuid = null; return "/" + node.getProject().getName() + path; case FULL: return APIRouter.API_MOUNTPOINT + "/" + node.getProject().getName() + "/webroot" + path + branchQueryParameter(theirProject.getBranchRoot().findByUuid(branchUuid)); default: throw error(BAD_REQUEST, "Cannot render link with type " + type);
document.put("created", toISO8601(node.getCreationTimestamp())); addProject(document, node.getProject()); addTags(document, node.getTags(node.getProject().getLatestBranch())); addTagFamilies(document, node.getTags(node.getProject().getLatestBranch())); addPermissionInfo(document, node, type);
/** * We need to handle permission update requests for nodes here since the action must affect multiple documents in multiple indices . */ @Override public Observable<UpdateBulkEntry> updatePermissionForBulk(UpdateDocumentEntry entry) { String uuid = entry.getElementUuid(); Node node = getRootVertex().findByUuid(uuid); if (node == null) { throw error(INTERNAL_SERVER_ERROR, "error_element_for_document_type_not_found", uuid, DEFAULT_TYPE); } else { Project project = node.getProject(); List<UpdateBulkEntry> entries = new ArrayList<>(); // Determine which documents need to be updated. The node could have multiple documents in various indices. for (Branch branch : project.getBranchRoot().findAll()) { for (ContainerType type : Arrays.asList(DRAFT, PUBLISHED)) { JsonObject json = getTransformer().toPermissionPartial(node, type); for (NodeGraphFieldContainer container : node.getGraphFieldContainersIt(branch, type)) { String indexName = container.getIndexName(project.getUuid(), branch.getUuid(), type); String documentId = container.getDocumentId(); entries.add(new UpdateBulkEntry(indexName, documentId, json, true)); } } } return Observable.fromIterable(entries); } }
public Observable<? extends BulkEntry> moveForBulk(MoveDocumentEntry entry) { MoveEntryContext context = entry.getContext(); ContainerType type = context.getContainerType(); String releaseUuid = context.getBranchUuid(); NodeGraphFieldContainer oldContainer = context.getOldContainer(); String oldProjectUuid = oldContainer.getParentNode().getProject().getUuid(); String oldIndexName = NodeGraphFieldContainer.composeIndexName(oldProjectUuid, releaseUuid, oldContainer.getSchemaContainerVersion().getUuid(), type); String oldLanguageTag = oldContainer.getLanguageTag(); String oldDocumentId = NodeGraphFieldContainer.composeDocumentId(oldContainer.getParentNode().getUuid(), oldLanguageTag); DeleteBulkEntry deleteEntry = new DeleteBulkEntry(oldIndexName, oldDocumentId); NodeGraphFieldContainer newContainer = context.getNewContainer(); String newProjectUuid = newContainer.getParentNode().getProject().getUuid(); String newIndexName = NodeGraphFieldContainer.composeIndexName(newProjectUuid, releaseUuid, newContainer.getSchemaContainerVersion().getUuid(), type); String newLanguageTag = newContainer.getLanguageTag(); String newDocumentId = NodeGraphFieldContainer.composeDocumentId(newContainer.getParentNode().getUuid(), newLanguageTag); JsonObject doc = transformer.toDocument(newContainer, releaseUuid, type); IndexBulkEntry addEntry = new IndexBulkEntry(newIndexName, newDocumentId, doc, searchProvider.hasIngestPipelinePlugin()); return Observable.fromArray(addEntry, deleteEntry); }
/** * Generate an elasticsearch document object from the given container and stores it in the search index. * * @param container * @param branchUuid * @param type * @return Single with affected index name */ public Single<String> storeContainer(NodeGraphFieldContainer container, String branchUuid, ContainerType type) { JsonObject doc = transformer.toDocument(container, branchUuid, type); String projectUuid = container.getParentNode().getProject().getUuid(); String indexName = NodeGraphFieldContainer.composeIndexName(projectUuid, branchUuid, container.getSchemaContainerVersion().getUuid(), type); if (log.isDebugEnabled()) { log.debug("Storing node {" + container.getParentNode().getUuid() + "} into index {" + indexName + "}"); } String languageTag = container.getLanguageTag(); String documentId = NodeGraphFieldContainer.composeDocumentId(container.getParentNode().getUuid(), languageTag); return searchProvider.storeDocument(indexName, documentId, doc).andThen(Single.just(indexName)); }
/** * Generate an elasticsearch document object from the given container and stores it in the search index. * * @param container * @param branchUuid * @param type * @return Single with the bulk entry */ public Single<IndexBulkEntry> storeContainerForBulk(NodeGraphFieldContainer container, String branchUuid, ContainerType type) { JsonObject doc = transformer.toDocument(container, branchUuid, type); String projectUuid = container.getParentNode().getProject().getUuid(); String indexName = NodeGraphFieldContainer.composeIndexName(projectUuid, branchUuid, container.getSchemaContainerVersion().getUuid(), type); if (log.isDebugEnabled()) { log.debug("Storing node {" + container.getParentNode().getUuid() + "} into index {" + indexName + "}"); } String languageTag = container.getLanguageTag(); String documentId = NodeGraphFieldContainer.composeDocumentId(container.getParentNode().getUuid(), languageTag); return Single.just(new IndexBulkEntry(indexName, documentId, doc, searchProvider.hasIngestPipelinePlugin())); }
if (!node.getProject().getUuid().equals(gc.getProject().getUuid())) {
return null; Project projectOfNode = content.getNode().getProject(); return gc.requiresPerm(projectOfNode, READ_PERM); }));