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; }