/// <summary>
/// Evaluates this constraint against the given data graph
/// </summary>
internal override RDFValidationReport ValidateConstraint(RDFShapesGraph shapesGraph, RDFGraph dataGraph, RDFShape shape, RDFPatternMember focusNode, List <RDFPatternMember> valueNodes)
{
RDFValidationReport report = new RDFValidationReport();
#region Evaluation
List <RDFPatternMember> predicateNodes = dataGraph.Where(t => t.Subject.Equals(focusNode) &&
t.Predicate.Equals(this.LessThanPredicate))
.Select(x => x.Object)
.ToList();
foreach (RDFPatternMember valueNode in valueNodes)
{
foreach (RDFPatternMember predicateNode in predicateNodes)
{
int comparison = RDFQueryUtilities.CompareRDFPatternMembers(valueNode, predicateNode);
if (comparison == -99 || comparison >= 0)
{
report.AddResult(new RDFValidationResult(shape,
RDFVocabulary.SHACL.LESS_THAN_CONSTRAINT_COMPONENT,
focusNode,
shape is RDFPropertyShape ? ((RDFPropertyShape)shape).Path : null,
valueNode,
shape.Messages,
shape.Severity));
}
}
}
#endregion
return(report);
}
/// <summary>
/// Detects the non validating attributes of the given property shape
/// </summary>
private static void DetectShapeNonValidatingAttributes(RDFGraph graph, RDFPropertyShape propertyShape)
{
RDFGraph shapeDefinition = graph.SelectTriplesBySubject(propertyShape);
//sh:description (accepted occurrences: N)
RDFGraph shapeDescriptions = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.DESCRIPTION);
foreach (RDFTriple shapeDescription in shapeDescriptions.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPL))
{
propertyShape.AddDescription((RDFLiteral)shapeDescription.Object);
}
//sh:name (accepted occurrences: N)
RDFGraph shapeNames = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.NAME);
foreach (RDFTriple shapeName in shapeNames.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPL))
{
propertyShape.AddName((RDFLiteral)shapeName.Object);
}
//sh:group (accepted occurrences: 1)
RDFTriple shapeGroup = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.GROUP).FirstOrDefault();
if (shapeGroup != null)
{
if (shapeGroup.Object is RDFResource)
{
propertyShape.SetGroup((RDFResource)shapeGroup.Object);
}
}
//sh:order (accepted occurrences: 1)
RDFTriple shapeOrder = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.ORDER).FirstOrDefault();
if (shapeOrder != null)
{
if (shapeOrder.Object is RDFTypedLiteral shapeOrderLiteral &&
shapeOrderLiteral.Datatype.Equals(RDFModelEnums.RDFDatatypes.XSD_INTEGER))
{
propertyShape.SetOrder(int.Parse(shapeOrderLiteral.Value));
}
}
}
/// <summary>
/// Evaluates this constraint against the given data graph
/// </summary>
internal override RDFValidationReport ValidateConstraint(RDFShapesGraph shapesGraph, RDFGraph dataGraph, RDFShape shape, RDFPatternMember focusNode, List <RDFPatternMember> valueNodes)
{
RDFValidationReport report = new RDFValidationReport();
#region Evaluation
if (this.Closed)
{
//Extend ignored properties with paths of property constraints
List <RDFResource> allowedProperties = new List <RDFResource>(this.IgnoredProperties.Values);
IEnumerable <RDFPropertyConstraint> propertyConstraints = shape.Constraints.OfType <RDFPropertyConstraint>();
foreach (RDFPropertyConstraint propertyConstraint in propertyConstraints)
{
RDFPropertyShape propertyShape = shapesGraph.SelectShape(propertyConstraint.PropertyShapeUri.ToString()) as RDFPropertyShape;
if (propertyShape != null)
{
allowedProperties.Add(propertyShape.Path);
}
}
//Detect unallowed predicates
foreach (RDFPatternMember valueNode in valueNodes)
{
if (valueNode is RDFResource valueNodeResource)
{
RDFGraph valuenodeResourceGraph = dataGraph.SelectTriplesBySubject(valueNodeResource);
IEnumerable <RDFTriple> unallowedTriples = valuenodeResourceGraph.Where(t => !allowedProperties.Any(p => p.Equals(t.Predicate)));
foreach (RDFTriple unallowedTriple in unallowedTriples)
{
report.AddResult(new RDFValidationResult(shape,
RDFVocabulary.SHACL.CLOSED_CONSTRAINT_COMPONENT,
valueNodeResource,
unallowedTriple.Predicate as RDFResource,
unallowedTriple.Object,
shape.Messages,
shape.Severity));
}
}
}
}
#endregion
return(report);
}
/// <summary>
/// Evaluates this constraint against the given data graph
/// </summary>
internal override RDFValidationReport ValidateConstraint(RDFShapesGraph shapesGraph, RDFGraph dataGraph, RDFShape shape, RDFPatternMember focusNode, List <RDFPatternMember> valueNodes)
{
RDFValidationReport report = new RDFValidationReport();
#region Evaluation
List <RDFPatternMember> predicateNodes = dataGraph.Where(t => t.Subject.Equals(focusNode) &&
t.Predicate.Equals(this.EqualsPredicate))
.Select(x => x.Object)
.ToList();
foreach (RDFPatternMember predicateNode in predicateNodes)
{
if (!valueNodes.Any(v => v.Equals(predicateNode)))
{
report.AddResult(new RDFValidationResult(shape,
RDFVocabulary.SHACL.EQUALS_CONSTRAINT_COMPONENT,
focusNode,
shape is RDFPropertyShape ? ((RDFPropertyShape)shape).Path : null,
predicateNode,
shape.Messages,
shape.Severity));
}
}
foreach (RDFPatternMember valueNode in valueNodes)
{
if (!predicateNodes.Any(p => p.Equals(valueNode)))
{
report.AddResult(new RDFValidationResult(shape,
RDFVocabulary.SHACL.EQUALS_CONSTRAINT_COMPONENT,
focusNode,
shape is RDFPropertyShape ? ((RDFPropertyShape)shape).Path : null,
valueNode,
shape.Messages,
shape.Severity));
}
}
#endregion
return(report);
}
/// <summary>
/// Detects the attributes of the given shape
/// </summary>
private static void DetectShapeAttributes(RDFGraph graph, RDFShape shape)
{
RDFGraph shapeDefinition = graph.SelectTriplesBySubject(shape);
//sh:severity (accepted occurrences: 1)
RDFTriple shapeSeverity = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.SEVERITY_PROPERTY).FirstOrDefault();
if (shapeSeverity != null)
{
if (shapeSeverity.Object.Equals(RDFVocabulary.SHACL.INFO))
{
shape.SetSeverity(RDFValidationEnums.RDFShapeSeverity.Info);
}
else if (shapeSeverity.Object.Equals(RDFVocabulary.SHACL.WARNING))
{
shape.SetSeverity(RDFValidationEnums.RDFShapeSeverity.Warning);
}
}
//sh:deactivated (accepted occurrences: 1)
RDFTriple shapeDeactivated = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.DEACTIVATED).FirstOrDefault();
if (shapeDeactivated != null)
{
if (shapeDeactivated.Object is RDFTypedLiteral shapeDeactivatedLiteral &&
shapeDeactivatedLiteral.HasBooleanDatatype() && bool.Parse(shapeDeactivatedLiteral.Value))
{
shape.Deactivate();
}
}
//sh:message (accepted occurrences: N)
RDFGraph shapeMessages = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.MESSAGE);
foreach (RDFTriple shapeMessage in shapeMessages.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPL))
{
shape.AddMessage((RDFLiteral)shapeMessage.Object);
}
}
/// <summary>
/// Detects the targets of the given shape
/// </summary>
private static void DetectShapeTargets(RDFGraph graph, RDFShape shape)
{
RDFGraph shapeDefinition = graph.SelectTriplesBySubject(shape);
//sh:TargetClass (accepted occurrences: N)
RDFGraph targetClasses = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.TARGET_CLASS);
foreach (RDFTriple targetClass in targetClasses.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
shape.AddTarget(new RDFTargetClass((RDFResource)targetClass.Object));
}
//sh:TargetNode (accepted occurrences: N)
RDFGraph targetNodes = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.TARGET_NODE);
foreach (RDFTriple targetNode in targetNodes.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
shape.AddTarget(new RDFTargetNode((RDFResource)targetNode.Object));
}
//sh:TargetSubjectsOf (accepted occurrences: N)
RDFGraph targetSubjectsOf = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.TARGET_SUBJECTS_OF);
foreach (RDFTriple targetSubjectOf in targetSubjectsOf.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
shape.AddTarget(new RDFTargetSubjectsOf((RDFResource)targetSubjectOf.Object));
}
//sh:TargetObjectsOf (accepted occurrences: N)
RDFGraph targetObjectsOf = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.TARGET_OBJECTS_OF);
foreach (RDFTriple targetObjectOf in targetObjectsOf.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
shape.AddTarget(new RDFTargetObjectsOf((RDFResource)targetObjectOf.Object));
}
}
/// <summary>
/// Detects the constraints of the given shape
/// </summary>
private static void DetectShapeConstraints(RDFGraph graph, RDFShape shape)
{
RDFGraph shapeDefinition = graph.SelectTriplesBySubject(shape);
//sh:and (accepted occurrences: N)
RDFGraph shapeAndConstraints = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.AND);
foreach (RDFTriple shapeAndConstraint in shapeAndConstraints.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
RDFAndConstraint andConstraint = new RDFAndConstraint();
RDFCollection andConstraintCollection = RDFModelUtilities.DeserializeCollectionFromGraph(graph, (RDFResource)shapeAndConstraint.Object, RDFModelEnums.RDFTripleFlavors.SPO);
andConstraintCollection.Items.ForEach(item => andConstraint.AddShape((RDFResource)item));
shape.AddConstraint(andConstraint);
}
//sh:class (accepted occurrences: N)
RDFGraph shapeClassConstraints = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.CLASS);
foreach (RDFTriple shapeClassConstraint in shapeClassConstraints.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
shape.AddConstraint(new RDFClassConstraint((RDFResource)shapeClassConstraint.Object));
}
//sh:closed (accepted occurrences: 1)
RDFTriple shapeClosedConstraint = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.CLOSED).FirstOrDefault();
if (shapeClosedConstraint != null)
{
if (shapeClosedConstraint.Object is RDFTypedLiteral shapeClosedConstraintLiteral &&
shapeClosedConstraintLiteral.HasBooleanDatatype())
{
RDFClosedConstraint closedConstraint = new RDFClosedConstraint(bool.Parse(shapeClosedConstraintLiteral.Value));
//sh:ignoredProperties (accepted occurrences: 1)
RDFTriple shapeIgnoredPropertiesConstraint = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.IGNORED_PROPERTIES).FirstOrDefault();
if (shapeIgnoredPropertiesConstraint != null)
{
if (shapeIgnoredPropertiesConstraint.Object is RDFResource shapeIgnoredPropertiesConstraintResource)
{
RDFCollection shapeIgnoredPropertiesConstraintCollection = RDFModelUtilities.DeserializeCollectionFromGraph(graph, shapeIgnoredPropertiesConstraintResource, RDFModelEnums.RDFTripleFlavors.SPO);
shapeIgnoredPropertiesConstraintCollection.Items.ForEach(item => closedConstraint.AddIgnoredProperty((RDFResource)item));
}
}
shape.AddConstraint(closedConstraint);
}
}
//sh:datatype (accepted occurrences: N)
RDFGraph shapeDatatypeConstraints = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.DATATYPE);
foreach (RDFTriple shapeDatatypeConstraint in shapeDatatypeConstraints.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
shape.AddConstraint(new RDFDatatypeConstraint(RDFModelUtilities.GetDatatypeFromString(shapeDatatypeConstraint.Object.ToString())));
}
//sh:disjoint (accepted occurrences: N)
RDFGraph shapeDisjointConstraints = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.DISJOINT);
foreach (RDFTriple shapeDisjointConstraint in shapeDisjointConstraints.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
shape.AddConstraint(new RDFDisjointConstraint((RDFResource)shapeDisjointConstraint.Object));
}
//sh:equals (accepted occurrences: N)
RDFGraph shapeEqualsConstraints = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.EQUALS);
foreach (RDFTriple shapeEqualsConstraint in shapeEqualsConstraints.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
shape.AddConstraint(new RDFEqualsConstraint((RDFResource)shapeEqualsConstraint.Object));
}
//sh:hasValue (accepted occurrences: N)
RDFGraph shapeHasValueConstraints = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.HAS_VALUE);
foreach (RDFTriple shapeHasValueConstraint in shapeHasValueConstraints)
{
if (shapeHasValueConstraint.Object is RDFResource)
{
shape.AddConstraint(new RDFHasValueConstraint((RDFResource)shapeHasValueConstraint.Object));
}
else if (shapeHasValueConstraint.Object is RDFLiteral)
{
shape.AddConstraint(new RDFHasValueConstraint((RDFLiteral)shapeHasValueConstraint.Object));
}
}
//sh:in (accepted occurrences: N)
RDFGraph shapeInConstraints = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.IN);
foreach (RDFTriple shapeInConstraint in shapeInConstraints.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
RDFModelEnums.RDFTripleFlavors shapeInConstraintCollectionFlavor = RDFModelUtilities.DetectCollectionFlavorFromGraph(graph, (RDFResource)shapeInConstraint.Object);
RDFCollection shapeInConstraintCollection = RDFModelUtilities.DeserializeCollectionFromGraph(graph, (RDFResource)shapeInConstraint.Object, shapeInConstraintCollectionFlavor);
RDFInConstraint inConstraint = new RDFInConstraint(shapeInConstraintCollection.ItemType);
shapeInConstraintCollection.Items.ForEach(item =>
{
if (item is RDFResource)
{
inConstraint.AddValue((RDFResource)item);
}
else if (item is RDFLiteral)
{
inConstraint.AddValue((RDFLiteral)item);
}
});
shape.AddConstraint(inConstraint);
}
//sh:languageIn (accepted occurrences: N)
RDFGraph shapeLanguageInConstraints = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.LANGUAGE_IN);
foreach (RDFTriple shapeLanguageInConstraint in shapeLanguageInConstraints.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
RDFCollection shapeLanguageInConstraintCollection = RDFModelUtilities.DeserializeCollectionFromGraph(graph, (RDFResource)shapeLanguageInConstraint.Object, RDFModelEnums.RDFTripleFlavors.SPL);
shape.AddConstraint(new RDFLanguageInConstraint(shapeLanguageInConstraintCollection.Select(x => x.ToString()).ToList()));
}
//sh:lessThan (accepted occurrences: N)
RDFGraph shapeLessThanConstraints = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.LESS_THAN);
foreach (RDFTriple shapeLessThanConstraint in shapeLessThanConstraints.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
shape.AddConstraint(new RDFLessThanConstraint((RDFResource)shapeLessThanConstraint.Object));
}
//sh:lessThanOrEquals (accepted occurrences: N)
RDFGraph shapeLessThanOrEqualsConstraints = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.LESS_THAN_OR_EQUALS);
foreach (RDFTriple shapeLessThanOrEqualsConstraint in shapeLessThanOrEqualsConstraints.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
shape.AddConstraint(new RDFLessThanOrEqualsConstraint((RDFResource)shapeLessThanOrEqualsConstraint.Object));
}
//sh:maxCount (accepted occurrences: 1)
RDFTriple shapeMaxCountConstraint = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.MAX_COUNT).FirstOrDefault();
if (shapeMaxCountConstraint != null)
{
if (shapeMaxCountConstraint.Object is RDFTypedLiteral shaclMaxCountConstraintLiteral &&
shaclMaxCountConstraintLiteral.Datatype.Equals(RDFModelEnums.RDFDatatypes.XSD_INTEGER))
{
shape.AddConstraint(new RDFMaxCountConstraint(int.Parse(shaclMaxCountConstraintLiteral.Value)));
}
}
//sh:maxExclusive (accepted occurrences: 1)
RDFTriple shapeMaxExclusiveConstraint = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.MAX_EXCLUSIVE).FirstOrDefault();
if (shapeMaxExclusiveConstraint != null)
{
if (shapeMaxExclusiveConstraint.Object is RDFResource)
{
shape.AddConstraint(new RDFMaxExclusiveConstraint((RDFResource)shapeMaxExclusiveConstraint.Object));
}
else if (shapeMaxExclusiveConstraint.Object is RDFLiteral)
{
shape.AddConstraint(new RDFMaxExclusiveConstraint((RDFLiteral)shapeMaxExclusiveConstraint.Object));
}
}
//sh:maxInclusive (accepted occurrences: 1)
RDFTriple shapeMaxInclusiveConstraint = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.MAX_INCLUSIVE).FirstOrDefault();
if (shapeMaxInclusiveConstraint != null)
{
if (shapeMaxInclusiveConstraint.Object is RDFResource)
{
shape.AddConstraint(new RDFMaxInclusiveConstraint((RDFResource)shapeMaxInclusiveConstraint.Object));
}
else if (shapeMaxInclusiveConstraint.Object is RDFLiteral)
{
shape.AddConstraint(new RDFMaxInclusiveConstraint((RDFLiteral)shapeMaxInclusiveConstraint.Object));
}
}
//sh:maxLength (accepted occurrences: 1)
RDFTriple shapeMaxLengthConstraint = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.MAX_LENGTH).FirstOrDefault();
if (shapeMaxLengthConstraint != null)
{
if (shapeMaxLengthConstraint.Object is RDFTypedLiteral shaclMaxLengthConstraintLiteral &&
shaclMaxLengthConstraintLiteral.Datatype.Equals(RDFModelEnums.RDFDatatypes.XSD_INTEGER))
{
shape.AddConstraint(new RDFMaxLengthConstraint(int.Parse(shaclMaxLengthConstraintLiteral.Value)));
}
}
//sh:minCount (accepted occurrences: 1)
RDFTriple shapeMinCountConstraint = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.MIN_COUNT).FirstOrDefault();
if (shapeMinCountConstraint != null)
{
if (shapeMinCountConstraint.Object is RDFTypedLiteral shaclMinCountConstraintLiteral &&
shaclMinCountConstraintLiteral.Datatype.Equals(RDFModelEnums.RDFDatatypes.XSD_INTEGER))
{
shape.AddConstraint(new RDFMinCountConstraint(int.Parse(shaclMinCountConstraintLiteral.Value)));
}
}
//sh:minExclusive (accepted occurrences: 1)
RDFTriple shapeMinExclusiveConstraint = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.MIN_EXCLUSIVE).FirstOrDefault();
if (shapeMinExclusiveConstraint != null)
{
if (shapeMinExclusiveConstraint.Object is RDFResource)
{
shape.AddConstraint(new RDFMinExclusiveConstraint((RDFResource)shapeMinExclusiveConstraint.Object));
}
else if (shapeMinExclusiveConstraint.Object is RDFLiteral)
{
shape.AddConstraint(new RDFMinExclusiveConstraint((RDFLiteral)shapeMinExclusiveConstraint.Object));
}
}
//sh:minInclusive (accepted occurrences: 1)
RDFTriple shapeMinInclusiveConstraint = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.MIN_INCLUSIVE).FirstOrDefault();
if (shapeMinInclusiveConstraint != null)
{
if (shapeMinInclusiveConstraint.Object is RDFResource)
{
shape.AddConstraint(new RDFMinInclusiveConstraint((RDFResource)shapeMinInclusiveConstraint.Object));
}
else if (shapeMinInclusiveConstraint.Object is RDFLiteral)
{
shape.AddConstraint(new RDFMinInclusiveConstraint((RDFLiteral)shapeMinInclusiveConstraint.Object));
}
}
//sh:minLength (accepted occurrences: 1)
RDFTriple shapeMinLengthConstraint = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.MIN_LENGTH).FirstOrDefault();
if (shapeMinLengthConstraint != null)
{
if (shapeMinLengthConstraint.Object is RDFTypedLiteral shaclMinLengthConstraintLiteral &&
shaclMinLengthConstraintLiteral.Datatype.Equals(RDFModelEnums.RDFDatatypes.XSD_INTEGER))
{
shape.AddConstraint(new RDFMinLengthConstraint(int.Parse(shaclMinLengthConstraintLiteral.Value)));
}
}
//sh:node (accepted occurrences: N)
RDFGraph shapeNodeConstraints = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.NODE);
foreach (RDFTriple shapeNodeConstraint in shapeNodeConstraints.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
shape.AddConstraint(new RDFNodeConstraint((RDFResource)shapeNodeConstraint.Object));
}
//sh:nodeKind (accepted occurrences: 1)
RDFTriple shapeNodeKindConstraint = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.NODE_KIND).FirstOrDefault();
if (shapeNodeKindConstraint != null)
{
if (shapeNodeKindConstraint.Object.Equals(RDFVocabulary.SHACL.BLANK_NODE))
{
shape.AddConstraint(new RDFNodeKindConstraint(RDFValidationEnums.RDFNodeKinds.BlankNode));
}
else if (shapeNodeKindConstraint.Object.Equals(RDFVocabulary.SHACL.BLANK_NODE_OR_IRI))
{
shape.AddConstraint(new RDFNodeKindConstraint(RDFValidationEnums.RDFNodeKinds.BlankNodeOrIRI));
}
else if (shapeNodeKindConstraint.Object.Equals(RDFVocabulary.SHACL.BLANK_NODE_OR_LITERAL))
{
shape.AddConstraint(new RDFNodeKindConstraint(RDFValidationEnums.RDFNodeKinds.BlankNodeOrLiteral));
}
else if (shapeNodeKindConstraint.Object.Equals(RDFVocabulary.SHACL.IRI))
{
shape.AddConstraint(new RDFNodeKindConstraint(RDFValidationEnums.RDFNodeKinds.IRI));
}
else if (shapeNodeKindConstraint.Object.Equals(RDFVocabulary.SHACL.IRI_OR_LITERAL))
{
shape.AddConstraint(new RDFNodeKindConstraint(RDFValidationEnums.RDFNodeKinds.IRIOrLiteral));
}
else if (shapeNodeKindConstraint.Object.Equals(RDFVocabulary.SHACL.LITERAL))
{
shape.AddConstraint(new RDFNodeKindConstraint(RDFValidationEnums.RDFNodeKinds.Literal));
}
}
//sh:not (accepted occurrences: N)
RDFGraph shapeNotConstraints = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.NOT);
foreach (RDFTriple shapeNotConstraint in shapeNotConstraints.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
shape.AddConstraint(new RDFNotConstraint((RDFResource)shapeNotConstraint.Object));
}
//sh:or (accepted occurrences: N)
RDFGraph shapeOrConstraints = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.OR);
foreach (RDFTriple shapeOrConstraint in shapeOrConstraints.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
RDFOrConstraint orConstraint = new RDFOrConstraint();
RDFCollection orConstraintCollection = RDFModelUtilities.DeserializeCollectionFromGraph(graph, (RDFResource)shapeOrConstraint.Object, RDFModelEnums.RDFTripleFlavors.SPO);
orConstraintCollection.Items.ForEach(item => orConstraint.AddShape((RDFResource)item));
shape.AddConstraint(orConstraint);
}
//sh:pattern (accepted occurrences: 1)
RDFTriple shapePatternConstraint = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.PATTERN).FirstOrDefault();
if (shapePatternConstraint != null)
{
if (shapePatternConstraint.Object is RDFTypedLiteral shapePatternConstraintLiteral &&
shapePatternConstraintLiteral.Datatype.Equals(RDFModelEnums.RDFDatatypes.XSD_STRING))
{
//sh:flags (accepted occurrences: 1)
RegexOptions regexOptions = RegexOptions.None;
RDFTriple shapeFlagsConstraint = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.FLAGS).FirstOrDefault();
if (shapeFlagsConstraint != null)
{
if (shapeFlagsConstraint.Object is RDFTypedLiteral shapeFlagsConstraintLiteral &&
shapeFlagsConstraintLiteral.Datatype.Equals(RDFModelEnums.RDFDatatypes.XSD_STRING))
{
if (shapeFlagsConstraintLiteral.Value.Contains("i"))
{
regexOptions |= RegexOptions.IgnoreCase;
}
if (shapeFlagsConstraintLiteral.Value.Contains("s"))
{
regexOptions |= RegexOptions.Singleline;
}
if (shapeFlagsConstraintLiteral.Value.Contains("m"))
{
regexOptions |= RegexOptions.Multiline;
}
if (shapeFlagsConstraintLiteral.Value.Contains("x"))
{
regexOptions |= RegexOptions.IgnorePatternWhitespace;
}
}
}
shape.AddConstraint(new RDFPatternConstraint(new Regex(shapePatternConstraintLiteral.Value, regexOptions)));
}
}
//sh:property (accepted occurrences: N)
RDFGraph shapePropertyConstraints = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.PROPERTY);
foreach (RDFTriple shapePropertyConstraint in shapePropertyConstraints.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
shape.AddConstraint(new RDFPropertyConstraint((RDFResource)shapePropertyConstraint.Object));
}
//sh:qualifiedValueShape (accepted occurrences: 1)
RDFTriple shapeQualifiedValueConstraint = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.QUALIFIED_VALUE_SHAPE).FirstOrDefault();
if (shapeQualifiedValueConstraint != null)
{
if (shapeQualifiedValueConstraint.Object is RDFResource)
{
//sh:qualifiedMinCount (accepted occurrences: 1)
int? qualifiedMinCountValue = null;
RDFTriple shapeQualifiedMinCountConstraint = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.QUALIFIED_MIN_COUNT).FirstOrDefault();
if (shapeQualifiedMinCountConstraint != null)
{
if (shapeQualifiedMinCountConstraint.Object is RDFTypedLiteral shapeQualifiedMinCountConstraintLiteral &&
shapeQualifiedMinCountConstraintLiteral.Datatype.Equals(RDFModelEnums.RDFDatatypes.XSD_INTEGER))
{
qualifiedMinCountValue = int.Parse(shapeQualifiedMinCountConstraintLiteral.Value);
}
}
//sh:qualifiedMaxCount (accepted occurrences: 1)
int? qualifiedMaxCountValue = null;
RDFTriple shapeQualifiedMaxCountConstraint = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.QUALIFIED_MAX_COUNT).FirstOrDefault();
if (shapeQualifiedMaxCountConstraint != null)
{
if (shapeQualifiedMaxCountConstraint.Object is RDFTypedLiteral shapeQualifiedMaxCountConstraintLiteral &&
shapeQualifiedMaxCountConstraintLiteral.Datatype.Equals(RDFModelEnums.RDFDatatypes.XSD_INTEGER))
{
qualifiedMaxCountValue = int.Parse(shapeQualifiedMaxCountConstraintLiteral.Value);
}
}
shape.AddConstraint(new RDFQualifiedValueShapeConstraint((RDFResource)shapeQualifiedValueConstraint.Object, qualifiedMinCountValue, qualifiedMaxCountValue));
}
}
//sh:uniqueLang (accepted occurrences: 1)
RDFTriple shapeUniqueLangConstraint = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.UNIQUE_LANG).FirstOrDefault();
if (shapeUniqueLangConstraint != null)
{
if (shapeUniqueLangConstraint.Object is RDFTypedLiteral shapeUniqueLangConstraintLiteral &&
shapeUniqueLangConstraintLiteral.HasBooleanDatatype())
{
shape.AddConstraint(new RDFUniqueLangConstraint(bool.Parse(shapeUniqueLangConstraintLiteral.Value)));
}
}
//sh:xone (accepted occurrences: N)
RDFGraph shapeXoneConstraints = shapeDefinition.SelectTriplesByPredicate(RDFVocabulary.SHACL.XONE);
foreach (RDFTriple shapeXoneConstraint in shapeXoneConstraints.Where(t => t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO))
{
RDFXoneConstraint xoneConstraint = new RDFXoneConstraint();
RDFCollection xoneConstraintCollection = RDFModelUtilities.DeserializeCollectionFromGraph(graph, (RDFResource)shapeXoneConstraint.Object, RDFModelEnums.RDFTripleFlavors.SPO);
xoneConstraintCollection.Items.ForEach(item => xoneConstraint.AddShape((RDFResource)item));
shape.AddConstraint(xoneConstraint);
}
}