/// <summary>
/// Searches for vocabulary annotations specified by this model.
/// </summary>
/// <param name="element">The annotated element.</param>
/// <returns>The vocabulary annotations for the element.</returns>
public override IEnumerable <IEdmVocabularyAnnotation> FindDeclaredVocabularyAnnotations(IEdmVocabularyAnnotatable element)
{
// Include the inline annotations only if this model is the one that defined them.
CsdlSemanticsElement semanticsElement = element as CsdlSemanticsElement;
IEnumerable <IEdmVocabularyAnnotation> inlineAnnotations = semanticsElement != null && semanticsElement.Model == this ? semanticsElement.InlineVocabularyAnnotations : Enumerable.Empty <IEdmVocabularyAnnotation>();
List <CsdlSemanticsAnnotations> elementAnnotations;
string fullName = EdmUtil.FullyQualifiedName(element);
if (fullName != null && this.outOfLineAnnotations.TryGetValue(fullName, out elementAnnotations))
{
List <IEdmVocabularyAnnotation> result = new List <IEdmVocabularyAnnotation>();
foreach (CsdlSemanticsAnnotations annotations in elementAnnotations)
{
foreach (CsdlAnnotation annotation in annotations.Annotations.Annotations)
{
result.Add(this.WrapVocabularyAnnotation(annotation, annotations.Context, null, annotations, annotations.Annotations.Qualifier));
}
}
return(inlineAnnotations.Concat(result));
}
return(inlineAnnotations);
// TODO: REF
// find annotation in referenced models
}
public void FunctionImportShouldProduceCorrectFullyQualifiedNameAndNotHaveParameters()
{
var function = new EdmFunction("d.s", "testFunction", EdmCoreModel.Instance.GetString(true));
function.AddParameter("param1", EdmCoreModel.Instance.GetString(false));
var functionImport = new EdmFunctionImport(new EdmEntityContainer("d.s", "container"), "testFunction", function);
EdmUtil.FullyQualifiedName(functionImport).Should().Be("d.s.container/testFunction");
}
public override IEnumerable <IEdmVocabularyAnnotation> FindDeclaredVocabularyAnnotations(IEdmVocabularyAnnotatable element)
{
List <CsdlSemanticsAnnotations> list;
CsdlSemanticsElement element2 = element as CsdlSemanticsElement;
IEnumerable <IEdmVocabularyAnnotation> first = ((element2 != null) && (element2.Model == this)) ? element2.InlineVocabularyAnnotations : Enumerable.Empty <IEdmVocabularyAnnotation>();
string key = EdmUtil.FullyQualifiedName(element);
if ((key == null) || !this.outOfLineAnnotations.TryGetValue(key, out list))
{
return(first);
}
List <IEdmVocabularyAnnotation> second = new List <IEdmVocabularyAnnotation>();
foreach (CsdlSemanticsAnnotations annotations in list)
{
foreach (CsdlVocabularyAnnotationBase base2 in annotations.Annotations.Annotations)
{
second.Add(this.WrapVocabularyAnnotation(base2, annotations.Context, null, annotations, annotations.Annotations.Qualifier));
}
}
return(first.Concat <IEdmVocabularyAnnotation>(second));
}
internal static string TargetString(this IEdmVocabularyAnnotation annotation)
{
return(EdmUtil.FullyQualifiedName(annotation.Target));
}
/// <summary>
/// Searches for vocabulary annotations specified by this model.
/// </summary>
/// <param name="element">The annotated element.</param>
/// <returns>The vocabulary annotations for the element.</returns>
public override IEnumerable <IEdmVocabularyAnnotation> FindDeclaredVocabularyAnnotations(IEdmVocabularyAnnotatable element)
{
// Include the inline annotations only if this model is the one that defined them.
CsdlSemanticsReference semanticsReference = element as CsdlSemanticsReference;
if (semanticsReference != null)
{
if (semanticsReference.Model == this)
{
return(semanticsReference.InlineVocabularyAnnotations);
}
else
{
return(Enumerable.Empty <IEdmVocabularyAnnotation>());
}
}
CsdlSemanticsInclude semanticsInclude = element as CsdlSemanticsInclude;
if (semanticsInclude != null)
{
if (semanticsInclude.Model == this)
{
return(semanticsInclude.InlineVocabularyAnnotations);
}
else
{
return(Enumerable.Empty <IEdmVocabularyAnnotation>());
}
}
CsdlSemanticsElement semanticsElement = element as CsdlSemanticsElement;
IEnumerable <IEdmVocabularyAnnotation> inlineAnnotations = semanticsElement != null && semanticsElement.Model == this ? semanticsElement.InlineVocabularyAnnotations : Enumerable.Empty <IEdmVocabularyAnnotation>();
if (this.outOfLineAnnotations.Count > 0)
{
List <CsdlSemanticsAnnotations> elementAnnotations;
string fullName = semanticsElement != null?semanticsElement.GetAnnotationFullQualifiedName(element) : EdmUtil.FullyQualifiedName(element);
if (fullName != null && this.outOfLineAnnotations.TryGetValue(fullName, out elementAnnotations))
{
List <IEdmVocabularyAnnotation> result = new List <IEdmVocabularyAnnotation>();
foreach (CsdlSemanticsAnnotations annotations in elementAnnotations)
{
foreach (CsdlAnnotation annotation in annotations.Annotations.Annotations)
{
IEdmVocabularyAnnotation vocabAnnotation = this.WrapVocabularyAnnotation(annotation, annotations.Context, null, annotations, annotations.Annotations.Qualifier);
vocabAnnotation.SetSerializationLocation(this, EdmVocabularyAnnotationSerializationLocation.OutOfLine);
result.Add(vocabAnnotation);
}
}
return(inlineAnnotations.Concat(result));
}
}
return(inlineAnnotations);
// TODO: REF
// find annotation in referenced models
}
public void EntitySetShouldProduceCorrectFullyQualifiedName()
{
var entitySet = new EdmEntitySet(new EdmEntityContainer("d.s", "container"), "entitySet", new EdmEntityType("foo", "type"));
EdmUtil.FullyQualifiedName(entitySet).Should().Be("d.s.container/entitySet");
}
/// <summary>
/// Gets the cached annotation full qualified name.
/// </summary>
/// <param name="element">This element as <see cref="IEdmVocabularyAnnotatable"/>.</param>
/// <returns>The cached annotation full qualified name.</returns>
public string GetAnnotationFullQualifiedName(IEdmVocabularyAnnotatable element)
{
Debug.Assert(object.ReferenceEquals(this as IEdmVocabularyAnnotatable, element));
this.annotationFullName = this.annotationFullName ?? EdmUtil.FullyQualifiedName(element);
return(this.annotationFullName);
}
static SerializationValidator()
{
SerializationValidator.TypeReferenceTargetMustHaveValidName = new ValidationRule <IEdmTypeReference>((ValidationContext context, IEdmTypeReference typeReference) => {
IEdmSchemaType definition = typeReference.Definition as IEdmSchemaType;
if (definition != null && !EdmUtil.IsQualifiedName(definition.FullName()))
{
context.AddError(typeReference.Location(), EdmErrorCode.ReferencedTypeMustHaveValidName, Strings.Serializer_ReferencedTypeMustHaveValidName(definition.FullName()));
}
}
);
SerializationValidator.EntityReferenceTargetMustHaveValidName = new ValidationRule <IEdmEntityReferenceType>((ValidationContext context, IEdmEntityReferenceType entityReference) => {
if (!EdmUtil.IsQualifiedName(entityReference.EntityType.FullName()))
{
context.AddError(entityReference.Location(), EdmErrorCode.ReferencedTypeMustHaveValidName, Strings.Serializer_ReferencedTypeMustHaveValidName(entityReference.EntityType.FullName()));
}
}
);
SerializationValidator.EntitySetTypeMustHaveValidName = new ValidationRule <IEdmEntitySet>((ValidationContext context, IEdmEntitySet set) => {
if (!EdmUtil.IsQualifiedName(set.ElementType.FullName()))
{
context.AddError(set.Location(), EdmErrorCode.ReferencedTypeMustHaveValidName, Strings.Serializer_ReferencedTypeMustHaveValidName(set.ElementType.FullName()));
}
}
);
SerializationValidator.StructuredTypeBaseTypeMustHaveValidName = new ValidationRule <IEdmStructuredType>((ValidationContext context, IEdmStructuredType type) => {
IEdmSchemaType baseType = type.BaseType as IEdmSchemaType;
if (baseType != null && !EdmUtil.IsQualifiedName(baseType.FullName()))
{
context.AddError(type.Location(), EdmErrorCode.ReferencedTypeMustHaveValidName, Strings.Serializer_ReferencedTypeMustHaveValidName(baseType.FullName()));
}
}
);
SerializationValidator.NavigationPropertyVerifyAssociationName = new ValidationRule <IEdmNavigationProperty>((ValidationContext context, IEdmNavigationProperty property) => {
if (!EdmUtil.IsQualifiedName(context.Model.GetAssociationFullName(property)))
{
context.AddError(property.Location(), EdmErrorCode.ReferencedTypeMustHaveValidName, Strings.Serializer_ReferencedTypeMustHaveValidName(context.Model.GetAssociationFullName(property)));
}
}
);
SerializationValidator.VocabularyAnnotationOutOfLineMustHaveValidTargetName = new ValidationRule <IEdmVocabularyAnnotation>((ValidationContext context, IEdmVocabularyAnnotation annotation) => {
bool hasValue;
EdmVocabularyAnnotationSerializationLocation?serializationLocation = annotation.GetSerializationLocation(context.Model);
if (serializationLocation.GetValueOrDefault() != EdmVocabularyAnnotationSerializationLocation.OutOfLine)
{
hasValue = false;
}
else
{
hasValue = serializationLocation.HasValue;
}
if (hasValue && !EdmUtil.IsQualifiedName(annotation.TargetString()))
{
context.AddError(annotation.Location(), EdmErrorCode.InvalidName, Strings.Serializer_OutOfLineAnnotationTargetMustHaveValidName(EdmUtil.FullyQualifiedName(annotation.Target)));
}
}
);
SerializationValidator.VocabularyAnnotationMustHaveValidTermName = new ValidationRule <IEdmVocabularyAnnotation>((ValidationContext context, IEdmVocabularyAnnotation annotation) => {
if (!EdmUtil.IsQualifiedName(annotation.Term.FullName()))
{
context.AddError(annotation.Location(), EdmErrorCode.InvalidName, Strings.Serializer_OutOfLineAnnotationTargetMustHaveValidName(annotation.Term.FullName()));
}
}
);
ValidationRule[] typeReferenceTargetMustHaveValidName = new ValidationRule[18];
typeReferenceTargetMustHaveValidName[0] = SerializationValidator.TypeReferenceTargetMustHaveValidName;
typeReferenceTargetMustHaveValidName[1] = SerializationValidator.EntityReferenceTargetMustHaveValidName;
typeReferenceTargetMustHaveValidName[2] = SerializationValidator.EntitySetTypeMustHaveValidName;
typeReferenceTargetMustHaveValidName[3] = SerializationValidator.StructuredTypeBaseTypeMustHaveValidName;
typeReferenceTargetMustHaveValidName[4] = SerializationValidator.VocabularyAnnotationOutOfLineMustHaveValidTargetName;
typeReferenceTargetMustHaveValidName[5] = SerializationValidator.VocabularyAnnotationMustHaveValidTermName;
typeReferenceTargetMustHaveValidName[6] = SerializationValidator.NavigationPropertyVerifyAssociationName;
typeReferenceTargetMustHaveValidName[7] = ValidationRules.FunctionImportEntitySetExpressionIsInvalid;
typeReferenceTargetMustHaveValidName[8] = ValidationRules.FunctionImportParametersCannotHaveModeOfNone;
typeReferenceTargetMustHaveValidName[9] = ValidationRules.FunctionOnlyInputParametersAllowedInFunctions;
typeReferenceTargetMustHaveValidName[10] = ValidationRules.TypeMustNotHaveKindOfNone;
typeReferenceTargetMustHaveValidName[11] = ValidationRules.PrimitiveTypeMustNotHaveKindOfNone;
typeReferenceTargetMustHaveValidName[12] = ValidationRules.PropertyMustNotHaveKindOfNone;
typeReferenceTargetMustHaveValidName[13] = ValidationRules.TermMustNotHaveKindOfNone;
typeReferenceTargetMustHaveValidName[14] = ValidationRules.SchemaElementMustNotHaveKindOfNone;
typeReferenceTargetMustHaveValidName[15] = ValidationRules.EntityContainerElementMustNotHaveKindOfNone;
typeReferenceTargetMustHaveValidName[16] = ValidationRules.EnumMustHaveIntegerUnderlyingType;
typeReferenceTargetMustHaveValidName[17] = ValidationRules.EnumMemberValueMustHaveSameTypeAsUnderlyingType;
SerializationValidator.serializationRuleSet = new ValidationRuleSet(typeReferenceTargetMustHaveValidName);
}
