private Concept getOntologyConcept(String conceptType, Ontology ontology, String workspaceId) { if (conceptType == null) { return null; } return ontology == null ? ontologyRepository.getConceptByIRI(conceptType, workspaceId) : ontology.getConceptByIri(conceptType); } }
private List<String> getConceptIriWithParents(String conceptIri) { List<String> conceptIriWithParents = new ArrayList<>(); String parentConceptIRI = conceptIri; while (parentConceptIRI != null) { Concept parentConcept = ontologyRepository.getConceptByIRI(parentConceptIRI, PUBLIC); parentConceptIRI = null; if (parentConcept != null) { conceptIriWithParents.add(parentConcept.getIRI()); parentConceptIRI = parentConcept.getParentConceptIRI(); } } return conceptIriWithParents; }
public ValidationResult validateConceptBuilder(ConceptBuilder builder) { if (!verifiedClasses.contains(builder.getClass())) { LOGGER.trace("Validating Concept: %s", builder.getIri()); Concept concept = ontologyRepository.getConceptByIRI(builder.getIri(), PUBLIC); if (concept == null) { return new ValidationResult("Concept class: " + builder.getClass().getName() + " IRI: " + builder.getIri() + " is invalid"); } verifiedClasses.add(builder.getClass()); } return validateProperties(builder, builder.getPropertyAdditions()); }
protected void defineAuthorizationsProperty(OntologyRepository ontologyRepository) { List<Concept> concepts = new ArrayList<>(); concepts.add(ontologyRepository.getConceptByIRI(UserRepository.USER_CONCEPT_IRI, PUBLIC)); OntologyPropertyDefinition propertyDefinition = new OntologyPropertyDefinition( concepts, AUTHORIZATIONS_PROPERTY_IRI, "Authorizations", PropertyType.STRING ); propertyDefinition.setUserVisible(false); propertyDefinition.setTextIndexHints(TextIndexHint.NONE); ontologyRepository.getOrCreateProperty(propertyDefinition, new SystemUser(), PUBLIC); }
private void definePrivilegesProperty(OntologyRepository ontologyRepository) { List<Concept> concepts = new ArrayList<>(); concepts.add(ontologyRepository.getConceptByIRI(UserRepository.USER_CONCEPT_IRI, PUBLIC)); OntologyPropertyDefinition propertyDefinition = new OntologyPropertyDefinition( concepts, PRIVILEGES_PROPERTY_IRI, "Privileges", PropertyType.STRING ); propertyDefinition.setUserVisible(false); propertyDefinition.setTextIndexHints(TextIndexHint.NONE); ontologyRepository.getOrCreateProperty(propertyDefinition, new SystemUser(), PUBLIC); }
private Glyph getConceptImage(String conceptIri, String state, String workspaceId) { Concept concept = ontologyRepository.getConceptByIRI(conceptIri, workspaceId); if (concept == null) { return null; } Glyph glyph = getGlyph(concept, "selected".equals(state)); if (glyph.isValid()) { return glyph; } String parentConceptIri = concept.getParentConceptIRI(); if (parentConceptIri == null) { return null; } return getConceptImage(parentConceptIri, state, workspaceId); }
private String imageTitle(Vertex entityVertex, String workspaceId) { Property titleProperty = VisalloProperties.TITLE.getFirstProperty(entityVertex); Object title; if (titleProperty == null) { String conceptTypeProperty = VisalloProperties.CONCEPT_TYPE.getPropertyName(); String vertexConceptType = (String) entityVertex.getProperty(conceptTypeProperty).getValue(); Concept concept = ontologyRepository.getConceptByIRI(vertexConceptType, workspaceId); title = concept.getDisplayName(); } else { title = titleProperty.getValue(); } return String.format("Image of %s", title.toString()); }
@Test public void testGettingParentConceptReturnsParentProperties() throws Exception { loadHierarchyOwlFile(); Concept concept = getOntologyRepository().getConceptByIRI(TEST_HIERARCHY_IRI + "#person", PUBLIC); Concept parentConcept = getOntologyRepository().getParentConcept(concept, PUBLIC); assertEquals(1, parentConcept.getProperties().size()); }
@Test public void testCreatingSandboxedConcepts() { setPrivileges(user, Collections.singleton(Privilege.ONTOLOGY_ADD)); Concept thing = getOntologyRepository().getEntityConcept(workspaceId); getOntologyRepository().getOrCreateConcept(thing, SANDBOX_CONCEPT_IRI, SANDBOX_DISPLAY_NAME, null, user, workspaceId); getOntologyRepository().clearCache(); Concept noWorkspace = getOntologyRepository().getConceptByIRI(SANDBOX_CONCEPT_IRI, PUBLIC); assertNull(noWorkspace); Concept withWorkspace = getOntologyRepository().getConceptByIRI(SANDBOX_CONCEPT_IRI, workspaceId); assertEquals(SANDBOX_DISPLAY_NAME, withWorkspace.getDisplayName()); }
@Test public void testCreatingPublicConcepts() { setPrivileges(user, Sets.newHashSet(Privilege.ONTOLOGY_ADD, Privilege.ONTOLOGY_PUBLISH)); Concept thing = getOntologyRepository().getEntityConcept(workspaceId); getOntologyRepository().getOrCreateConcept(thing, PUBLIC_CONCEPT_IRI, PUBLIC_DISPLAY_NAME, null, user, PUBLIC); getOntologyRepository().clearCache(); Concept noWorkspace = getOntologyRepository().getConceptByIRI(PUBLIC_CONCEPT_IRI, PUBLIC); assertEquals(PUBLIC_DISPLAY_NAME, noWorkspace.getDisplayName()); Concept withWorkspace = getOntologyRepository().getConceptByIRI(PUBLIC_CONCEPT_IRI, workspaceId); assertEquals(PUBLIC_DISPLAY_NAME, withWorkspace.getDisplayName()); }
@Test public void testDependenciesBetweenOntologyFilesShouldNotChangeParentProperties() throws Exception { loadTestOwlFile(); importTestOntologyFile(TEST01_OWL, TEST01_IRI); validateTestOwlRelationship(); validateTestOwlConcepts(3); validateTestOwlProperties(); OntologyProperty aliasProperty = getOntologyRepository().getPropertyByIRI(TEST01_IRI + "#alias", PUBLIC); Concept person = getOntologyRepository().getConceptByIRI(TEST_IRI + "#person", PUBLIC); assertTrue(person.getProperties() .stream() .anyMatch(p -> p.getIri().equals(aliasProperty.getIri())) ); }
@Test public void testCreatingPublicConceptsAsSystem() { Concept thing = getOntologyRepository().getEntityConcept(workspaceId); getOntologyRepository().getOrCreateConcept(thing, PUBLIC_CONCEPT_IRI, PUBLIC_DISPLAY_NAME, null, systemUser, PUBLIC); getOntologyRepository().clearCache(); Concept noWorkspace = getOntologyRepository().getConceptByIRI(PUBLIC_CONCEPT_IRI, PUBLIC); assertEquals(PUBLIC_DISPLAY_NAME, noWorkspace.getDisplayName()); Concept withWorkspace = getOntologyRepository().getConceptByIRI(PUBLIC_CONCEPT_IRI, workspaceId); assertEquals(PUBLIC_DISPLAY_NAME, withWorkspace.getDisplayName()); }
@Test public void testExceptionDeletingSandboxedConceptsWithRelationshipsDomain() throws Exception { createSampleOntology(); Concept concept = getOntologyRepository().getConceptByIRI(SANDBOX_CONCEPT_IRI, workspaceId); // Add an edge type List<Concept> things = Collections.singletonList(getOntologyRepository().getEntityConcept(workspaceId)); getOntologyRepository().getOrCreateRelationshipType(null, Arrays.asList(concept), things, "sandboxed-relationship-withsandboxed-concepts", true, adminUser, workspaceId); getOntologyRepository().clearCache(workspaceId); thrown.expect(VisalloException.class); thrown.expectMessage("Unable to delete concept that is used in domain/range of relationship"); getOntologyRepository().deleteConcept(SANDBOX_CONCEPT_IRI, adminUser, workspaceId); }
@Test public void testExceptionDeletingSandboxedConceptsWithRelationshipsRange() throws Exception { createSampleOntology(); Concept concept = getOntologyRepository().getConceptByIRI(SANDBOX_CONCEPT_IRI, workspaceId); // Add an edge type List<Concept> things = Collections.singletonList(getOntologyRepository().getEntityConcept(workspaceId)); getOntologyRepository().getOrCreateRelationshipType(null, things, Arrays.asList(concept), "sandboxed-relationship-withsandboxed-concepts", true, adminUser, workspaceId); getOntologyRepository().clearCache(workspaceId); thrown.expect(VisalloException.class); thrown.expectMessage("Unable to delete concept that is used in domain/range of relationship"); getOntologyRepository().deleteConcept(SANDBOX_CONCEPT_IRI, adminUser, workspaceId); }
@Test public void testAddingSandboxedPropertyToSandboxedConceptsAndRelationships() { setPrivileges(user, Collections.singleton(Privilege.ONTOLOGY_ADD)); getWorkspaceRepository().add(workspaceId, "Junit Workspace", user); createConcept(SANDBOX_CONCEPT_IRI, SANDBOX_DISPLAY_NAME, workspaceId); createRelationship(SANDBOX_RELATIONSHIP_IRI, workspaceId); OntologyProperty sandboxedProperty = createProperty(SANDBOX_PROPERTY_IRI, SANDBOX_DISPLAY_NAME, workspaceId); getOntologyRepository().clearCache(); getOntologyRepository().updatePropertyDomainIris(sandboxedProperty, Sets.newHashSet(SANDBOX_CONCEPT_IRI, SANDBOX_RELATIONSHIP_IRI), systemUser, workspaceId); getOntologyRepository().clearCache(); Concept sandboxedConcept = getOntologyRepository().getConceptByIRI(SANDBOX_CONCEPT_IRI, workspaceId); assertEquals(1, sandboxedConcept.getProperties().size()); assertEquals(SANDBOX_PROPERTY_IRI, sandboxedConcept.getProperties().iterator().next().getIri()); Relationship sandboxedRelationship = getOntologyRepository().getRelationshipByIRI(SANDBOX_RELATIONSHIP_IRI, workspaceId); assertEquals(1, sandboxedRelationship.getProperties().size()); assertEquals(SANDBOX_PROPERTY_IRI, sandboxedRelationship.getProperties().iterator().next().getIri()); }
@Test public void testDeletingSandboxedConcepts() throws Exception { createSampleOntology(); Concept concept = getOntologyRepository().getConceptByIRI(SANDBOX_CONCEPT_IRI, workspaceId); assertTrue("Concept exists", concept != null && concept.getIRI().equals(SANDBOX_CONCEPT_IRI)); OntologyProperty property = getOntologyRepository().getPropertyByIRI(SANDBOX_PROPERTY_IRI_ONLY_SANDBOXED_CONCEPT, workspaceId); assertTrue("Property exists", property != null && property.getIri().equals(SANDBOX_PROPERTY_IRI_ONLY_SANDBOXED_CONCEPT)); assertTrue("Concept has property", concept.getProperties().stream().anyMatch(ontologyProperty -> ontologyProperty.getIri().equals(SANDBOX_PROPERTY_IRI_ONLY_SANDBOXED_CONCEPT))); getOntologyRepository().deleteConcept(SANDBOX_CONCEPT_IRI, adminUser, workspaceId); getOntologyRepository().clearCache(workspaceId); concept = getOntologyRepository().getConceptByIRI(SANDBOX_CONCEPT_IRI, workspaceId); assertTrue("Concept should have been deleted", concept == null); property = getOntologyRepository().getPropertyByIRI(SANDBOX_PROPERTY_IRI_ONLY_SANDBOXED_CONCEPT, workspaceId); assertTrue("Property only used in this concept is deleted", property == null); property = getOntologyRepository().getPropertyByIRI(SANDBOX_PROPERTY_IRI, workspaceId); assertTrue("Property used in other concepts is updated", property != null); assertEquals(1, property.getConceptIris().size()); assertEquals(PUBLIC_CONCEPT_IRI, property.getConceptIris().get(0)); }
@Test public void testPublishingConcepts() { setPrivileges(user, Sets.newHashSet(Privilege.ONTOLOGY_ADD, Privilege.ONTOLOGY_PUBLISH)); Concept thing = getOntologyRepository().getEntityConcept(workspaceId); Concept sandboxedConcept = getOntologyRepository().getOrCreateConcept(thing, SANDBOX_CONCEPT_IRI, SANDBOX_DISPLAY_NAME, null, user, workspaceId); getOntologyRepository().publishConcept(sandboxedConcept, user, workspaceId); getOntologyRepository().clearCache(); Concept publicConcept = getOntologyRepository().getConceptByIRI(SANDBOX_CONCEPT_IRI, PUBLIC); assertEquals(SANDBOX_DISPLAY_NAME, publicConcept.getDisplayName()); }
@Test public void testExceptionDeletingSandboxedConceptsWithDescendants() throws Exception { createSampleOntology(); Concept concept = getOntologyRepository().getConceptByIRI(SANDBOX_CONCEPT_IRI, workspaceId); // Add a descendant getOntologyRepository().getOrCreateConcept(concept, SANDBOX_CONCEPT_IRI + "child", SANDBOX_DISPLAY_NAME, null, systemUser, workspaceId); getOntologyRepository().clearCache(workspaceId); thrown.expect(VisalloException.class); thrown.expectMessage("Unable to delete concept that have children"); getOntologyRepository().deleteConcept(SANDBOX_CONCEPT_IRI, adminUser, workspaceId); }
@Test public void testExceptionDeletingSandboxedConceptsWithVertices() throws Exception { createSampleOntology(); Concept concept = getOntologyRepository().getConceptByIRI(SANDBOX_CONCEPT_IRI, workspaceId); assertTrue("Concept exists", concept != null && concept.getIRI().equals(SANDBOX_CONCEPT_IRI)); VisibilityJson json = VisibilityJson.updateVisibilitySourceAndAddWorkspaceId(new VisibilityJson(), "", workspaceId); Visibility visibility = getVisibilityTranslator().toVisibility(json).getVisibility(); VertexBuilder vb = getGraph().prepareVertex(visibility); vb.setProperty(VisalloProperties.CONCEPT_TYPE.getPropertyName(), SANDBOX_CONCEPT_IRI, visibility); vb.save(authorizations); thrown.expect(VisalloException.class); thrown.expectMessage("Unable to delete concept that have vertices assigned to it"); getOntologyRepository().deleteConcept(SANDBOX_CONCEPT_IRI, adminUser, workspaceId); }
private void doTestPublishVertexAdd(String conceptIri, String expectedError, SandboxStatus expectedConceptStatus) { Authorizations authorizations = getAuthorizationRepository().getGraphAuthorizations(user, workspace.getWorkspaceId()); Vertex vertex = getGraphRepository().addVertex("junit-vertex", conceptIri, "", workspace.getWorkspaceId(), null, null, user, authorizations); getWorkspaceRepository().updateEntityOnWorkspace(workspace, vertex.getId(), user); ClientApiVertexPublishItem publishItem = new ClientApiVertexPublishItem(); publishItem.setVertexId(vertex.getId()); publishItem.setAction(ClientApiPublishItem.Action.ADD_OR_UPDATE); ClientApiWorkspacePublishResponse response = getWorkspaceRepository().publish(new ClientApiPublishItem[]{publishItem}, user, workspace.getWorkspaceId(), authorizations); if (expectedError != null) { assertPublishFailure(response, workspace, getGraph().getVertex(vertex.getId(), authorizations), expectedError); } else { assertPublishSuccess(response, workspace, getGraph().getVertex(vertex.getId(), authorizations)); } if (expectedConceptStatus != null) { Concept concept = getOntologyRepository().getConceptByIRI(conceptIri, workspace.getWorkspaceId()); assertEquals(expectedConceptStatus, concept.getSandboxStatus()); } }