public static ConstraintReportTransformer create(Resource resource, ConstraintReport report) { checkNotNull(resource,"Resource cannot be null"); checkNotNull(report,"Constraint report cannot be null"); return new ConstraintReportTransformer(resource, report); }
public DataSet transform(Endpoint endpoint) { checkNotNull(endpoint,"Endpoint cannot be null"); populateResourceIndividual(endpoint); populateConstraintReportIndividual(); populateHttpRequestIndividual(this.report.getRequest()); return dataSet(); }
private void populateDatatype(LocalIndividual constraint, URI datatype) { if(datatype!=null) { constraint.addValue(shaclTerm("datatype"),externalIndividual(datatype)); } }
private ExternalIndividual headerType(Header header) { return externalIndividual(httpTerm(HeaderHelper.getHeaderType(header.name()))); }
private Set<Shape> populateShapeDefinition(Shape shape, ShapeIndividualCache cache, IndividualTranslator translator) { LocalIndividual shapeInd = cache.individual(shape); String shapeId = cache.id(shape); reportInd().addValue(ldp4jTerm("hasShape"), shapeInd); shapeInd.addValue(vocabularyTerm(RDF.TYPE), externalIndividual(shaclTerm("Shape"))); populateDescription(shapeInd, shape); List<PropertyConstraint> pcs = shape.propertyConstraints(); Set<Shape> shapes=Sets.newLinkedHashSet(); for(int j=0;j<pcs.size();j++) { PropertyConstraint pc = pcs.get(j); LocalIndividual pcInd = localIndividual(shapeId+"_pc"+j); shapeInd.addValue(shaclTerm("property"), pcInd); pcInd.addValue(vocabularyTerm(RDF.TYPE), externalIndividual(shaclTerm("PropertyConstraint"))); pcInd.addValue(shaclTerm("predicate"), externalIndividual(pc.predicate())); populateDescription(pcInd, pc); populateCardinality(pcInd, pc.cardinality()); populateNodeKind(pcInd, pc.nodeKind()); populateHasValues(pcInd, pc.literals(), translator); populateHasValues(pcInd, pc.individuals(dataset), translator); Set<Value> allowedValues=Sets.newHashSet(); allowedValues.addAll(pc.allowedLiterals()); allowedValues.addAll(pc.allowedIndividuals(dataset)); populateAllowedValues(pcInd, allowedValues, translator); populateValueType(pcInd,pc.valueType()); populateDatatype(pcInd,pc.datatype()); Shape valueShape = pc.valueShape(); if(valueShape!=null) { populateValueShape(pcInd,cache.individual(valueShape)); shapes.add(valueShape);
private void populateHttpRequestIndividual(HttpRequest request) { requestInd().addValue(vocabularyTerm(RDF.TYPE), externalIndividual(httpTerm("Request"))); requestInd().addValue(httpTerm("methodName"),literal(request.method().toString())); requestInd().addValue(httpTerm("mthd"),externalIndividual(methodsTerm(request.method().toString()))); requestInd().addValue(httpTerm("absolutePath"),literal(request.absolutePath())); String protocolVersion="1.1"; if(!ProtocolVersion.HTTP_1_1.equals(request.protocolVersion())) { protocolVersion="1.0"; requestInd().addValue(httpTerm("httpVersion"),literal(protocolVersion)); requestInd().addValue(dctTerm("date"),literal(clientDate)); if(headers.hasNext()) { int i=0; Individual<?,?> current=localIndividual("n"+i); requestInd().addValue(httpTerm("headers"), current); while(headers.hasNext()) { Header header=headers.next(); LocalIndividual headerInd=localIndividual("header"+i); current.addValue(vocabularyTerm(RDF.FIRST),headerInd); headerInd.addValue(vocabularyTerm(RDF.TYPE),headerType(header)); headerInd.addValue(httpTerm("fieldName"),literal(header.name())); headerInd.addValue(httpTerm("fieldValue"),literal(header.rawValue())); headerInd.addValue(httpTerm("hdrName"),externalIndividual(headersTerm(header.name()))); i++; if(headers.hasNext()) { Individual<?,?> last=current; current=localIndividual("n"+i); last.addValue(vocabularyTerm(RDF.REST),current);
private void populateConstraintReportIndividual() { Constraints constraints = this.report.getConstraints(); LOGGER.debug("Populating constraints: {}",constraints); reportInd().addValue(vocabularyTerm(RDF.TYPE), externalIndividual(ldp4jTerm("ConstraintReport"))); reportInd().addValue(ldp4jTerm("failureId"), literal(this.report.id().failureId())); reportInd().addValue(ldp4jTerm("failureDate"), literal(this.report.getDate())); reportInd().addValue(ldp4jTerm("failureRequest"), requestInd()); IndividualTranslator translator = new IndividualTranslator(); ShapeIndividualCache shapeCache=new ShapeIndividualCache(); Queue<Shape> pendingShapes=Lists.newLinkedList(constraints.shapes()); while(!pendingShapes.isEmpty()) { Shape shape=pendingShapes.poll(); if(!shapeCache.isPopulated(shape)) { shapeCache.populate(shape); Set<Shape> foundShapes = populateShapeDefinition(shape, shapeCache, translator); pendingShapes.addAll(foundShapes); } } for(URI type:constraints.types()) { Individual<?,?> typeInd=externalIndividual(type); typeInd.addValue(shaclTerm("typeShape"), shapeCache.individual(constraints.typeShape(type))); } for(Individual<?, ?> node:constraints.nodes(dataset)) { Individual<?, ?> individual = translator.translate(node); individual.addValue(shaclTerm("nodeShape"), shapeCache.individual(constraints.nodeShape(node))); } }
DataSet getConstraintReport(Endpoint endpoint, String constraintsId) throws ApplicationExecutionException { ResourceId resourceId=endpoint.resourceId(); // TODO: Check if it is really necessary Resource resource = loadResource(resourceId); if(resource==null) { String errorMessage = applicationFailureMessage(COULD_NOT_FIND_RESOURCE_FOR_ENDPOINT,endpoint); LOGGER.error(errorMessage); throw new ApplicationExecutionException(errorMessage); } ConstraintReport report= this.constraintReportRepository. constraintReportOfId( ConstraintReportId. create(resource.id(),constraintsId)); if(report==null) { return null; } return ConstraintReportTransformer. create(resource, report). transform(endpoint); }
int i=0; String prefix = individual.id().id()+"_allowedValues_"; Individual<?,?> current=localIndividual(prefix+i); individual.addValue(shaclTerm("allowedValues"), current); while(values.hasNext()) { Value value=values.next(); value.accept(adapter); current.addValue(vocabularyTerm(RDF.FIRST),adapter.value); if(values.hasNext()) { Individual<?,?> last=current; current=localIndividual(prefix+(++i)); last.addValue(vocabularyTerm(RDF.REST),current); } else { current. addValue( vocabularyTerm(RDF.REST), externalIndividual(RDF.NIL.as(URI.class)));
@Test public void test() { Resource resource = TestHelper. createResource( TestHelper.name("name"), "template"); ConstraintReport report= resource. addConstraintReport( TestHelper.constraints(), new Date(), TestHelper.httpRequest()); ConstraintReportTransformer sut= ConstraintReportTransformer.create(resource,report); DataSet result = sut.transform( TestHelper. createEndpoint( "path", resource, new Date(), EntityTag.createStrong("mytag"))); assertThat(result,notNullValue()); assertThat(result.individualOfId(TestHelper.managedIndividualId(resource.id())),notNullValue()); assertThat(result.individualOfId(TestHelper.name("s0")),notNullValue()); assertThat(result.individualOfId(TestHelper.name("s1")),notNullValue()); }
private void populateValueType(LocalIndividual constraint, URI valueType) { if(valueType!=null) { constraint.addValue(shaclTerm("valueType"),externalIndividual(valueType)); } }
private void populateNodeKind(Individual<?,?> individual, NodeKind nodeKind) { if(nodeKind!=null) { individual.addValue(shaclTerm("nodeKind"), externalIndividual(shaclTerm(nodeKind.localName()))); } }