private Property getProperty() { return this.individual.property(propertyId); }
/** * {@inheritDoc} */ @Override public Set<URI> types() { Property property = this.individual.property(RDF.TYPE.as(URI.class)); if(property==null) { return Collections.emptySet(); } TypeCollector collector = new TypeCollector(); for(Value value:property) { value.accept(collector); } return collector.collectedTypes(); }
@Override protected void configureValidationConstraints(ValidatorBuilder builder, Individual<?,?> individual, DataSet metadata) { builder.withPropertyConstraint(ValidationConstraintFactory.mandatoryPropertyValues(individual.property(RDF.TYPE.as(URI.class)))); Multimap<URI,AttachedTemplate> attachmentMap=LinkedHashMultimap.create(); for(AttachedTemplate attachedTemplate:template().attachedTemplates()) { URI propertyId = attachedTemplate.predicate().or(HAS_ATTACHMENT); attachmentMap.put(propertyId, attachedTemplate); } for(Entry<URI, Collection<AttachedTemplate>> entry:attachmentMap.asMap().entrySet()) { URI propertyId=entry.getKey(); Property property = individual.property(propertyId); if(property!=null) { configurePropertyValidationConstraints(builder,individual,metadata,property,entry.getValue()); } else { builder.withPropertyConstraint(ValidationConstraintFactory.readOnlyProperty(individual.id(),propertyId)); } } }
private boolean hasLink(Individual<?,?> individual, Serializable id) { return individual.property(URI.create(HAS_LINK)).hasIdentifiedIndividual(id); }
@Override protected void configureValidationConstraints(ValidatorBuilder builder, Individual<?, ?> individual, DataSet metadata) { super.configureValidationConstraints(builder, individual, metadata); builder.withPropertyConstraint(ValidationConstraintFactory.readOnlyProperty(individual.property(LDP.INSERTED_CONTENT_RELATION.as(URI.class)))); }
@Override protected void configureValidationConstraints(ValidatorBuilder builder, Individual<?, ?> individual, DataSet metadata) { super.configureValidationConstraints(builder, individual, metadata); builder.withPropertyConstraint(ValidationConstraintFactory.readOnlyProperty(individual.property(LDP.INSERTED_CONTENT_RELATION.as(URI.class)))); }
private void configureHasMemberValidationConstraints(ValidatorBuilder builder, Individual<?, ?> individual, DataSet metadata, URI predicate) { // NOSONAR ValidationConstraint<Property> constraint=null; Property property = individual.property(predicate); if(property!=null) { constraint=ValidationConstraintFactory.readOnlyProperty(property); } else { constraint=ValidationConstraintFactory.readOnlyProperty(individual.id(),predicate); } builder.withPropertyConstraint(constraint); }
private boolean hasTitle(Individual<?,?> individual, String title) { return individual.property(URI.create(HAS_TITLE)).hasLiteralValue(Literals.of(title)); }
@Override protected void configureValidationConstraints(ValidatorBuilder builder, Individual<?, ?> individual, DataSet metadata) { super.configureValidationConstraints(builder, individual, metadata); URI propertyId = LDP.CONTAINS.as(URI.class); Property property = individual.property(propertyId); ValidationConstraint<Property> constraint=null; if(property!=null) { constraint=ValidationConstraintFactory.readOnlyProperty(property); } else { constraint=ValidationConstraintFactory.readOnlyProperty(propertyId); } builder.withPropertyConstraint(constraint); }
private void verifyResult(final ResourceSnapshot snapshot, DynamicResourceHandler handler, boolean resolveToUri, boolean resolveRoundtrip, String roundtrip) throws UnknownResourceException { DataSet dataSet = handler.get(snapshot); Individual<?, ?> resource=dataSet.individualOfId(ManagedIndividualId.createId(RID, DynamicResourceHandler.ID)); assertThat("Could "+(resolveToUri?"not":"")+" resolve uri",resource.hasProperty(DynamicResourceResolver.SNAPSHOT_ENDPOINT),equalTo(resolveToUri)); if(resolveToUri) { assertThat("Invalid uri resolution",resource.property(DynamicResourceResolver.SNAPSHOT_ENDPOINT).hasLiteralValue(Literals.newLiteral(ENDPOINT)),equalTo(resolveRoundtrip)); } assertThat("Could "+(resolveRoundtrip?"not":"")+" resolve roundtrip",resource.hasProperty(DynamicResourceResolver.SNAPSHOT_RESOLUTION),equalTo(resolveRoundtrip)); if(resolveRoundtrip) { assertThat("Invalid roundtrip resolution",resource.property(DynamicResourceResolver.SNAPSHOT_RESOLUTION).hasLiteralValue(Literals.of(roundtrip)),equalTo(resolveRoundtrip)); } }
private void configureIsMemberOfValidationConstraints(ValidatorBuilder builder, Individual<?, ?> individual, DataSet metadata, URI predicate) { // NOSONAR if(members().isEmpty()) { builder.withPropertyConstraint(ValidationConstraintFactory.readOnlyProperty(predicate)); } else { for(PublicResource member:members()) { Individual<?,?> tmp=metadata.individualOfId(member.individualId()); builder.withPropertyConstraint(ValidationConstraintFactory.readOnlyProperty(tmp.property(predicate))); } } }
@Override protected void configureValidationConstraints(ValidatorBuilder builder, Individual<?, ?> individual, DataSet metadata) { super.configureValidationConstraints(builder, individual, metadata); builder.withPropertyConstraint(ValidationConstraintFactory.mandatoryPropertyValues(individual.property(containerTemplate().membershipRelation().term().as(URI.class)))); Property rootProperty = individual.property(LDP.MEMBERSHIP_RESOURCE.as(URI.class)); if(rootProperty!=null) { builder.withPropertyConstraint(ValidationConstraintFactory.readOnlyProperty(rootProperty)); } else { builder.withPropertyConstraint(ValidationConstraintFactory.readOnlyProperty(LDP.MEMBERSHIP_RESOURCE.as(URI.class))); } }
@Test public void testSelf() throws Exception { DataSet dataSet = exampleDataSet(); DataSetHelper newHelper = DataSetUtils.newHelper(dataSet); Individual<?,?> self = newHelper.self(); assertThat(self.property(URI.create(HAS_TITLE)).hasLiteralValue(Literals.of("self")),equalTo(true)); }
private void contains(DataSet dataSet, DataSet original) { for(Individual<?,?> individual:dataSet) { Individual<?, ?> originalInd = original.individualOfId(individual.id()); assertThat(originalInd,notNullValue()); for(Property property:individual) { assertThat(originalInd.hasProperty(property.predicate()),equalTo(true)); final Property originalProp = originalInd.property(property.predicate()); for(Value value:property) { value.accept( new ValueVisitor() { @Override public void visitLiteral(Literal<?> value) { assertThat(originalProp.hasLiteralValue(value),equalTo(true)); } @Override public void visitIndividual(Individual<?, ?> value) { assertThat(originalProp.hasIdentifiedIndividual(value.id()),equalTo(true)); } }); } } } }
@Test public void testIndividualHelperCreation() { DataSet data=exampleDataSet(); Individual<?,?> individual = data.individualOfId(BLANK_NODE); DataSetUtils.newHelper(individual).property(RDFS.LABEL).withLiteral("My label"); assertThat(individual.property(RDFS.LABEL.as(URI.class)).hasLiteralValue(Literals.of("My label")),equalTo(true)); }
@Test public void testWithIndividual$term() { DataSet data=exampleDataSet(); Individual<?,?> individual = data.individualOfId(BLANK_NODE); PropertyHelperImpl sut = new PropertyHelperImpl(RDF.TYPE.as(URI.class), individual); sut.withIndividual(LDP.CONTAINER); assertThat( individual. property(RDF.TYPE.as(URI.class)). hasIdentifiedIndividual(LDP.CONTAINER.as(URI.class)), equalTo(true)); }
individual.property(DynamicResourceUpdater.REFRESHED_ON).numberOfValues(),greaterThanOrEqualTo(1)); assertThat( individual.property(DynamicResourceResolver.SNAPSHOT_ENDPOINT).hasLiteralValue(Literals.newLiteral(ENDPOINT)),equalTo(true)); assertThat( individual.property(DynamicResourceResolver.SNAPSHOT_RESOLUTION).hasLiteralValue(Literals.of("OK")),equalTo(true));