private static void EnumMemberExpressionDemo()
{
Console.WriteLine("EnumMemberExpressionDemo");
var model = new EdmModel();
var personType = new EdmEntityType("TestNS", "Person");
model.AddElement(personType);
var pid = personType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false);
personType.AddKeys(pid);
personType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
var colorType = new EdmEnumType("TestNS2", "Color", true);
model.AddElement(colorType);
colorType.AddMember("Cyan", new EdmIntegerConstant(1));
colorType.AddMember("Blue", new EdmIntegerConstant(2));
var outColorTerm = new EdmTerm("TestNS", "OutColor", new EdmEnumTypeReference(colorType, true));
model.AddElement(outColorTerm);
var exp = new EdmEnumMemberExpression(
new EdmEnumMember(colorType, "Blue", new EdmIntegerConstant(2))
);
var annotation = new EdmAnnotation(personType, outColorTerm, exp);
annotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline);
model.SetVocabularyAnnotation(annotation);
ShowModel(model);
var ann = model.FindVocabularyAnnotations<IEdmValueAnnotation>(personType, "TestNS.OutColor").First();
var memberExp = (IEdmEnumMemberExpression)ann.Value;
foreach (var member in memberExp.EnumMembers)
{
Console.WriteLine(member.Name);
}
}
public static void SetScaleMeasuresAnnotation(this EdmModel model, IEdmProperty property, byte scale)
{
if (model == null) throw new ArgumentNullException("model");
if (property == null) throw new ArgumentNullException("property");
var target = property;
var term = ScaleTerm;
var expression = new EdmIntegerConstant(scale);
var annotation = new EdmAnnotation(target, term, expression);
annotation.SetSerializationLocation(model, property.ToSerializationLocation());
model.AddVocabularyAnnotation(annotation);
}
public static void SetISOCurrencyMeasuresAnnotation(this EdmModel model, IEdmProperty property, string isoCurrency)
{
if (model == null) throw new ArgumentNullException("model");
if (property == null) throw new ArgumentNullException("property");
var target = property;
var term = ISOCurrencyTerm;
var expression = new EdmStringConstant(isoCurrency);
var annotation = new EdmAnnotation(target, term, expression);
annotation.SetSerializationLocation(model, property.ToSerializationLocation());
model.AddVocabularyAnnotation(annotation);
}
public static void SetComputedAnnotation(EdmModel model, IEdmProperty target)
{
EdmUtil.CheckArgumentNull(model, "model");
EdmUtil.CheckArgumentNull(target, "target");
IEdmBooleanConstantExpression val = new EdmBooleanConstant(true);
IEdmValueTerm term = CoreVocabularyModel.ComputedTerm;
Debug.Assert(term != null, "term!=null");
EdmAnnotation annotation = new EdmAnnotation(target, term, val);
annotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline);
model.SetVocabularyAnnotation(annotation);
}
public static IEdmModel EdmExpressionKindInterfaceCriticalKindValueUnexpectedOnlyModel()
{
var model = new EdmModel();
var valueTerm = new EdmTerm("DefaultNamespace", "Note", EdmCoreModel.Instance.GetString(true));
model.AddElement(valueTerm);
var badString = new CustomStringConstant("foo", EdmExpressionKind.None, EdmValueKind.String);
var valueAnnotation = new EdmAnnotation(
valueTerm,
valueTerm,
badString);
model.AddVocabularyAnnotation(valueAnnotation);
return model;
}
public void ReferencedModelUnresolvedTermValidationTest()
{
var mainModel = new FunctionalUtilities.ModelWithRemovableElements<EdmModel>(ValidationTestModelBuilder.ReferenceBasicTestMainModel() as EdmModel);
var referencedModel = ValidationTestModelBuilder.ReferenceBasicTestReferencedModel();
var valueAnnotation = new EdmAnnotation(
mainModel.FindEntityType("NS1.Customer"),
referencedModel.FindValueTerm("NS1.Title"),
"q1",
new EdmStringConstant("Hello world!"));
mainModel.WrappedModel.AddVocabularyAnnotation(valueAnnotation);
var expectedErrors = new EdmLibTestErrors()
{
{ null, null, EdmErrorCode.BadUnresolvedTerm},
};
IEnumerable<EdmError> edmErrors;
mainModel.Validate(out edmErrors);
this.CompareErrors(edmErrors, expectedErrors);
mainModel.WrappedModel.AddReferencedModel(referencedModel);
expectedErrors = null;
mainModel.Validate(out edmErrors);
this.CompareErrors(edmErrors, expectedErrors);
mainModel.RemoveReference(referencedModel);
expectedErrors = new EdmLibTestErrors()
{
{ null, null, EdmErrorCode.BadUnresolvedTerm},
};
mainModel.Validate(out edmErrors);
this.CompareErrors(edmErrors, expectedErrors);
}
public void ExceptionThrowForInvalidPropertyPath()
{
EdmModel model = new EdmModel();
EdmEntityType personType = new EdmEntityType("MyNs", "Person", null, false, false, true);
personType.AddKeys(personType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
personType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(isNullable: true));
var container = new EdmEntityContainer("MyNs", "Container");
model.AddElement(personType);
container.AddEntitySet("People", personType);
model.AddElement(container);
IEdmEntitySet peopleSet = model.FindDeclaredEntitySet("People");
IEdmPathExpression nameExpression = new EdmPropertyPathExpression("NameName");
IEdmCollectionExpression collection = new EdmCollectionExpression(new[] { nameExpression });
IEdmValueTerm term = null;
foreach (var referencedModel in model.ReferencedModels)
{
term = referencedModel.FindDeclaredValueTerm("Org.OData.Core.V1.OptimisticConcurrencyControl");
if (term != null)
{
break;
}
}
Assert.NotNull(term);
EdmAnnotation valueAnnotationOnEntitySet = new EdmAnnotation(peopleSet, term, collection);
valueAnnotationOnEntitySet.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline);
model.AddVocabularyAnnotation(valueAnnotationOnEntitySet);
ODataEntry entry = new ODataEntry
{
Properties = new[]
{
new ODataProperty {Name = "ID", Value = 123},
new ODataProperty {Name = "Name", Value = "lucy"},
}
};
Action action = () => GetWriterOutputForContentTypeAndKnobValue(entry, model, peopleSet, personType);
action.ShouldThrow<ODataException>().WithMessage(ErrorStrings.EdmValueUtils_PropertyDoesntExist("MyNs.Person", "NameName"));
}
private static void EdmWriteAnnotationDemo()
{
Console.WriteLine("EdmWriteAnnotationDemo");
var model = new EdmModel();
var mail = new EdmEntityType("ns", "Mail");
model.AddElement(mail);
mail.AddKeys(mail.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
var person = new EdmEntityType("ns", "Person");
model.AddElement(person);
person.AddKeys(person.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
var mails = person.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
ContainsTarget = true,
Name = "Mails",
TargetMultiplicity = EdmMultiplicity.Many,
Target = mail,
});
var ann1 = new EdmAnnotation(mails, CoreVocabularyModel.DescriptionTerm, new EdmStringConstant("test1"));
ann1.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline);
model.AddVocabularyAnnotation(ann1);
var container = new EdmEntityContainer("ns", "container");
model.AddElement(container);
var people = container.AddEntitySet("People", person);
var ann2 = new EdmAnnotation(people, CoreVocabularyModel.DescriptionTerm, new EdmStringConstant("test2"));
model.AddVocabularyAnnotation(ann2);
ShowModel(model);
}
private static void SetCapabilitiesAnnotation(this EdmModel model, IEdmVocabularyAnnotatable target, IEdmValueTerm term, bool value)
{
var expression = new EdmBooleanConstant(value);
var annotation = new EdmAnnotation(target, term, expression);
annotation.SetSerializationLocation(model, target.ToSerializationLocation());
model.AddVocabularyAnnotation(annotation);
}
private static void SetCapabilitiesAnnotation(this EdmModel model, IEdmVocabularyAnnotatable target, IEdmValueTerm term, bool value, IEnumerable<IEdmNavigationProperty> navigationProperties, string name1, string name2)
{
if (navigationProperties == null)
{
navigationProperties = new IEdmNavigationProperty[0];
}
var properties = new IEdmPropertyConstructor[]
{
new EdmPropertyConstructor(name1, new EdmBooleanConstant(value)),
new EdmPropertyConstructor(name2, new EdmCollectionExpression(navigationProperties.Select(p => new EdmNavigationPropertyPathExpression(p.Name)))),
};
var record = new EdmRecordExpression(properties);
var annotation = new EdmAnnotation(target, term, record);
annotation.SetSerializationLocation(model, target.ToSerializationLocation());
model.AddVocabularyAnnotation(annotation);
}
public static IEdmModel InterfaceCriticalPropertyValueMustNotBeNullUsingBinaryValueModel()
{
var model = new EdmModel();
var valueTerm = new EdmTerm("NS", "Note", EdmCoreModel.Instance.GetBinary(true));
model.AddElement(valueTerm);
var badValue = new CustomBinaryConstant(null);
var valueAnnotation = new EdmAnnotation(
valueTerm,
valueTerm,
badValue);
model.AddVocabularyAnnotation(valueAnnotation);
return model;
}
public static IEdmModel IsTypeResultFalseEvaluationModel()
{
var model = new EdmModel();
var booleanFlag = new EdmTerm("NS", "BooleanFlag", EdmCoreModel.Instance.GetBoolean(true));
model.AddElement(booleanFlag);
var valueAnnotation = new EdmAnnotation(
booleanFlag,
booleanFlag,
new EdmIsTypeExpression(new EdmIntegerConstant(32), EdmCoreModel.Instance.GetString(true)));
valueAnnotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.OutOfLine);
model.AddVocabularyAnnotation(valueAnnotation);
return model;
}
public static IEdmModel InvalidPropertyTypeUsingIsTypeOnInlineAnnotationModel()
{
var model = new EdmModel();
var bike = new EdmComplexType("NS", "Bike");
bike.AddStructuralProperty("Color", EdmCoreModel.Instance.GetString(true));
model.AddElement(bike);
var car = new EdmComplexType("NS", "Car");
var carExpensive = car.AddStructuralProperty("Expensive", new EdmComplexTypeReference(bike, true));
model.AddElement(car);
var carTerm = new EdmTerm("NS", "CarTerm", new EdmComplexTypeReference(car, true));
model.AddElement(carTerm);
var valueAnnotation = new EdmAnnotation(
car,
carTerm,
new EdmRecordExpression(
new EdmPropertyConstructor(carExpensive.Name, new EdmIsTypeExpression(new EdmStringConstant("foo"), EdmCoreModel.Instance.GetString(true)))));
valueAnnotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline);
model.AddVocabularyAnnotation(valueAnnotation);
return model;
}
public static IEdmModel InvalidPropertyTypeUsingIsTypeOnOutOfLineAnnotationModel()
{
var model = new EdmModel();
var friendName = new EdmTerm("NS", "FriendName", EdmCoreModel.Instance.GetString(true));
model.AddElement(friendName);
var valueAnnotation = new EdmAnnotation(
friendName,
friendName,
new EdmIsTypeExpression(new EdmStringConstant("foo"), EdmCoreModel.Instance.GetString(true)));
valueAnnotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.OutOfLine);
model.AddVocabularyAnnotation(valueAnnotation);
return model;
}
public static IEdmModel CastResultTrueEvaluationModel()
{
var model = new EdmModel();
var address = new EdmComplexType("NS", "Address");
address.AddStructuralProperty("StreetNumber", EdmCoreModel.Instance.GetInt32(true));
address.AddStructuralProperty("StreetName", EdmCoreModel.Instance.GetString(true));
model.AddElement(address);
var friend = new EdmEntityType("NS", "Friend");
var friendName = friend.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false));
friend.AddKeys(friendName);
var friendAddress = friend.AddStructuralProperty("Address", new EdmComplexTypeReference(address, true));
model.AddElement(friend);
var addressRecord = new EdmRecordExpression(new EdmPropertyConstructor[] {
new EdmPropertyConstructor("StreetNumber", new EdmIntegerConstant(3)),
new EdmPropertyConstructor("StreetName", new EdmStringConstant("에O詰 갂คำŚёæ"))
});
var friendAddressCast = new EdmCastExpression(addressRecord, new EdmComplexTypeReference(address, true));
var friendTerm = new EdmTerm("NS", "FriendTerm", new EdmEntityTypeReference(friend, true));
model.AddElement(friendTerm);
var valueAnnotation = new EdmAnnotation(
friend,
friendTerm,
new EdmRecordExpression(
new EdmPropertyConstructor(friendName.Name, new EdmStringConstant("foo")),
new EdmPropertyConstructor(friendAddress.Name, friendAddressCast)));
valueAnnotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.OutOfLine);
model.AddVocabularyAnnotation(valueAnnotation);
return model;
}
public static IEdmModel CastNullableToNonNullableOnInlineAnnotationModel()
{
var model = new EdmModel();
var address = new EdmComplexType("NS", "Address");
address.AddStructuralProperty("StreetNumber", EdmCoreModel.Instance.GetInt32(true));
address.AddStructuralProperty("StreetName", EdmCoreModel.Instance.GetString(true));
model.AddElement(address);
var friend = new EdmComplexType("NS", "Friend");
friend.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(true));
friend.AddStructuralProperty("NickNames", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetString(true)));
friend.AddStructuralProperty("Address", new EdmComplexTypeReference(address, true));
model.AddElement(friend);
var friendInfo = new EdmTerm("NS", "FriendInfo", EdmCoreModel.GetCollection(new EdmComplexTypeReference(friend, true)));
model.AddElement(friendInfo);
var valueAnnotationCast = new EdmCastExpression(new EdmCollectionExpression(new EdmStringConstant("foo"), new EdmStringConstant("bar")), new EdmComplexTypeReference(friend, true));
var valueAnnotation = new EdmAnnotation(
friendInfo,
friendInfo,
valueAnnotationCast);
valueAnnotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline);
model.AddVocabularyAnnotation(valueAnnotation);
return model;
}
public static IEdmModel IsTypeResultTrueEvaluationModel()
{
var model = new EdmModel();
var booleanFlag = new EdmComplexType("NS", "BooleanFlag");
var flag = booleanFlag.AddStructuralProperty("Flag", EdmCoreModel.Instance.GetBoolean(true));
model.AddElement(booleanFlag);
var booleanFlagTerm = new EdmTerm("NS", "BooleanFlagTerm", new EdmComplexTypeReference(booleanFlag, true));
model.AddElement(booleanFlagTerm);
var valueAnnotation = new EdmAnnotation(
booleanFlag,
booleanFlagTerm,
new EdmRecordExpression(
new EdmPropertyConstructor(flag.Name, new EdmIsTypeExpression(new EdmStringConstant("foo"), EdmCoreModel.Instance.GetString(true)))));
valueAnnotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.OutOfLine);
model.AddVocabularyAnnotation(valueAnnotation);
return model;
}
public static void SetNavigationRestrictionsCapabilitiesAnnotation(this EdmModel model, IEdmEntitySet entitySet, CapabilitiesNavigationType type, IEnumerable<Tuple<IEdmNavigationProperty, CapabilitiesNavigationType>> properties)
{
if (model == null) throw new ArgumentNullException("model");
if (entitySet == null) throw new ArgumentNullException("entitySet");
if (properties == null)
{
properties = new Tuple<IEdmNavigationProperty, CapabilitiesNavigationType>[0];
}
var target = entitySet;
var term = NavigationRestrictionsTerm;
// handle type
var typeLiteral = new EdmEnumTypeReference(NavigationTypeType, false).ToStringLiteral((long)type);
// handle properties
var propertiesExpression = properties.Select(p =>
{
var name = new EdmEnumTypeReference(NavigationTypeType, false).ToStringLiteral((long)p.Item2);
return new EdmRecordExpression(new IEdmPropertyConstructor[]
{
new EdmPropertyConstructor("NavigationProperty", new EdmNavigationPropertyPathExpression(p.Item1.Name)),
new EdmPropertyConstructor("Navigability", new EdmEnumMemberReferenceExpression(NavigationTypeType.Members.Single(m => m.Name == name))),
});
});
var record = new EdmRecordExpression(new IEdmPropertyConstructor[]
{
new EdmPropertyConstructor("Navigability", new EdmEnumMemberReferenceExpression(NavigationTypeType.Members.Single(m => m.Name == typeLiteral))),
new EdmPropertyConstructor("RestrictedProperties", new EdmCollectionExpression(propertiesExpression))
});
var annotation = new EdmAnnotation(target, term, record);
annotation.SetSerializationLocation(model, entitySet.ToSerializationLocation());
model.AddVocabularyAnnotation(annotation);
}
public static void SetSearchRestrictionsCapabilitiesAnnotation(this EdmModel model, IEdmEntitySet entitySet, bool searchable, CapabilitiesSearchExpressions unsupported)
{
if (model == null) throw new ArgumentNullException("model");
if (entitySet == null) throw new ArgumentNullException("entitySet");
var target = entitySet;
var term = SearchRestrictionsTerm;
var name = new EdmEnumTypeReference(SearchExpressionsType, false).ToStringLiteral((long)unsupported);
var properties = new IEdmPropertyConstructor[]
{
new EdmPropertyConstructor("Searchable", new EdmBooleanConstant(searchable)),
new EdmPropertyConstructor("UnsupportedExpressions", new EdmEnumMemberReferenceExpression(SearchExpressionsType.Members.Single(m => m.Name == name))),
};
var record = new EdmRecordExpression(properties);
var annotation = new EdmAnnotation(target, term, record);
annotation.SetSerializationLocation(model, entitySet.ToSerializationLocation());
model.AddVocabularyAnnotation(annotation);
}
public static IEdmModel AllInterfaceCriticalModel()
{
var model = new EdmModel();
var valueTerm = new EdmTerm("DefaultNamespace", "Note", EdmCoreModel.Instance.GetString(true));
model.AddElement(valueTerm);
var badString = new CustomStringConstant("foo", EdmExpressionKind.None, EdmValueKind.Integer);
var valueAnnotation = new EdmAnnotation(
valueTerm,
valueTerm,
badString);
model.AddVocabularyAnnotation(valueAnnotation);
var mutableValueAnnotationueAnnotation = new MutableValueAnnotation()
{
Target = valueTerm
};
model.AddVocabularyAnnotation(mutableValueAnnotationueAnnotation);
var customEntity = new CustomEntityType(new List<IEdmProperty>() { null });
model.AddElement(customEntity);
var entity = new EdmEntityType("DefaultNamespace", "bar");
var entity2 = new EdmEntityType("DefaultNamespace", "bar2");
var navProperty = new StubEdmNavigationProperty("Nav")
{
DeclaringType = entity,
Type = new EdmEntityTypeReference(entity2, false)
};
navProperty.Partner = navProperty;
entity.AddProperty(navProperty);
model.AddElement(entity);
model.AddElement(entity2);
return model;
}
private static void SetCapabilitiesAnnotation(this EdmModel model, IEdmVocabularyAnnotatable target, IEdmValueTerm term, IEnumerable<string> values)
{
if (values == null)
{
values = new string[0];
}
var expression = new EdmCollectionExpression(values.Select(function => new EdmStringConstant(function)));
var annotation = new EdmAnnotation(target, term, expression);
annotation.SetSerializationLocation(model, target.ToSerializationLocation());
model.AddVocabularyAnnotation(annotation);
}
public static IEdmModel InterfaceCriticalKindValueUnexpectedWithOtherErrorsModel()
{
var model = new EdmModel();
var valueTerm = new EdmTerm("DefaultNamespace", "Note", EdmCoreModel.Instance.GetString(true));
model.AddElement(valueTerm);
model.AddElement(valueTerm);
var entity = new EdmEntityType("DefaultNamespace", "foo");
model.AddElement(entity);
var entityContainer = new EdmEntityContainer("DefaultNamespace", "container");
model.AddElement(entityContainer);
var badString = new CustomStringConstant("foo", EdmExpressionKind.None, EdmValueKind.String);
var valueAnnotation = new EdmAnnotation(
valueTerm,
valueTerm,
badString);
model.AddVocabularyAnnotation(valueAnnotation);
var valueAnnotation2 = new EdmAnnotation(
valueTerm,
valueTerm,
new EdmStringConstant("foo"));
model.AddVocabularyAnnotation(valueAnnotation2);
return model;
}
public static void SetConformanceLevelCapabilitiesAnnotation(this EdmModel model, IEdmEntityContainer container, CapabilitiesConformanceLevelType level)
{
if (model == null) throw new ArgumentNullException("model");
if (container == null) throw new ArgumentNullException("container");
var target = container;
var term = ConformanceLevelTerm;
var name = new EdmEnumTypeReference(ConformanceLevelTypeType, false).ToStringLiteral((long)level);
var expression = new EdmEnumMemberReferenceExpression(ConformanceLevelTypeType.Members.Single(m => m.Name == name));
var annotation = new EdmAnnotation(target, term, expression);
annotation.SetSerializationLocation(model, container.ToSerializationLocation());
model.AddVocabularyAnnotation(annotation);
}
public void EdmSingletonAnnotationTests()
{
EdmModel model = new EdmModel();
EdmStructuralProperty customerProperty = new EdmStructuralProperty(customerType, "Name", EdmCoreModel.Instance.GetString(false));
customerType.AddProperty(customerProperty);
model.AddElement(this.customerType);
EdmSingleton vipCustomer = new EdmSingleton(this.entityContainer, "VIP", this.customerType);
EdmTerm term = new EdmTerm(myNamespace, "SingletonAnnotation", EdmPrimitiveTypeKind.String);
var annotation = new EdmAnnotation(vipCustomer, term, new EdmStringConstant("Singleton Annotation"));
model.AddVocabularyAnnotation(annotation);
var singletonAnnotation = vipCustomer.VocabularyAnnotations(model).Single();
Assert.Equal(vipCustomer, singletonAnnotation.Target);
Assert.Equal("SingletonAnnotation", singletonAnnotation.Term.Name);
singletonAnnotation = model.FindDeclaredVocabularyAnnotations(vipCustomer).Single();
Assert.Equal(vipCustomer, singletonAnnotation.Target);
Assert.Equal("SingletonAnnotation", singletonAnnotation.Term.Name);
EdmTerm propertyTerm = new EdmTerm(myNamespace, "SingletonPropertyAnnotation", EdmPrimitiveTypeKind.String);
var propertyAnnotation = new EdmAnnotation(customerProperty, propertyTerm, new EdmStringConstant("Singleton Property Annotation"));
model.AddVocabularyAnnotation(propertyAnnotation);
var singletonPropertyAnnotation = customerProperty.VocabularyAnnotations(model).Single();
Assert.Equal(customerProperty, singletonPropertyAnnotation.Target);
Assert.Equal("SingletonPropertyAnnotation", singletonPropertyAnnotation.Term.Name);
}
public void AnnotatedModelShouldSupportAddingStringAnnotations()
{
var primaryModel = new EdmModel();
var entityContainer = new EdmEntityContainer("Fake", "Container");
primaryModel.AddElement(entityContainer);
var testSubject = new VocabularyAnnotationCache(primaryModel);
var annotation = new EdmAnnotation(entityContainer, new EdmTerm("fake", "foo", EdmPrimitiveTypeKind.String), new EdmStringConstant("bar"));
testSubject.Add(annotation);
testSubject.FindDeclaredVocabularyAnnotations(entityContainer).Should().Contain(annotation).And.HaveCount(1);
}
private static void CustomTermDemo()
{
Console.WriteLine("CustomTermDemo");
var model = new EdmModel();
var term = new EdmTerm("ns", "ErrorCodes",
new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(false))));
model.AddElement(term);
var entity1 = new EdmEntityType("ns", "entity1");
entity1.AddKeys(entity1.AddStructuralProperty("id", EdmPrimitiveTypeKind.Guid));
model.AddElement(entity1);
var container = new EdmEntityContainer("ns", "default");
model.AddElement(container);
var e1 = container.AddSingleton("E1", entity1);
var annotation = new EdmAnnotation(e1, term,
new EdmCollectionExpression(
new EdmStringConstant("Entity Not Found"),
new EdmStringConstant("Deleting link failed")));
model.AddVocabularyAnnotation(annotation);
ShowModel(model);
}
private IEdmVocabularyAnnotation CreateAndAttachValueAnnotation(IEdmVocabularyAnnotatable target, IEdmValueTerm term, IEdmExpression value, string qualifier)
{
var annotation = new EdmAnnotation(
target,
term,
qualifier,
value);
// ?? Unnatural API
((EdmModel)this.baseModel).AddVocabularyAnnotation(annotation);
return annotation;
}
public static IEdmModel ValueAnnotationValidDefaultDurationConstantModel()
{
var model = new EdmModel();
var valueTerm = new EdmTerm("DefaultNamespace", "Note", EdmCoreModel.Instance.GetDuration(true));
model.AddElement(valueTerm);
var valueAnnotation = new EdmAnnotation(
valueTerm,
valueTerm,
new EdmDurationConstant(new TimeSpan()));
valueAnnotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.OutOfLine);
model.AddVocabularyAnnotation(valueAnnotation);
return model;
}
private static void SetComputedAnnotation(EdmModel model, IEdmProperty target)
{
// when 'target' is <Key> property, V4's 'Computed' also has the meaning of OData V3's 'Identity'.
var val = new EdmBooleanConstant(value: true);
var annotation = new EdmAnnotation(target, CoreVocabularyModel.ComputedTerm, val);
annotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline);
model.SetVocabularyAnnotation(annotation);
}
public static IEdmModel ValueAnnotationInvalidTypeReferenceDurationConstantModel()
{
var model = new EdmModel();
var valueTerm = new EdmTerm("DefaultNamespace", "Note", EdmCoreModel.Instance.GetDuration(true));
model.AddElement(valueTerm);
var valueAnnotation = new EdmAnnotation(
valueTerm,
valueTerm,
new EdmDurationConstant(EdmCoreModel.Instance.GetDateTimeOffset(false), new TimeSpan(1, 99, 99, 99, 999)));
valueAnnotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.OutOfLine);
model.AddVocabularyAnnotation(valueAnnotation);
return model;
}
