public ODataResource CreateEntry(Object entity) { var odataProperties = new ODataProperty[Accessors.Length]; for (int i = 0; i < Accessors.Length; i++) { OePropertyAccessor accessor = Accessors[i]; Object value = accessor.Accessor(entity); ODataValue odataValue = null; if (value == null) { odataValue = new ODataNullValue(); } else if (value.GetType().IsEnum) { odataValue = new ODataEnumValue(value.ToString()); } else if (value is DateTime dateTime) { switch (dateTime.Kind) { case DateTimeKind.Unspecified: value = new DateTimeOffset(DateTime.SpecifyKind(dateTime, DateTimeKind.Utc)); break; case DateTimeKind.Utc: value = new DateTimeOffset(dateTime); break; case DateTimeKind.Local: value = new DateTimeOffset(dateTime.ToUniversalTime()); break; default: throw new ArgumentOutOfRangeException("unknown DateTimeKind " + dateTime.Kind.ToString()); } odataValue = new ODataPrimitiveValue(value); } else { odataValue = new ODataPrimitiveValue(value); } odataValue.TypeAnnotation = accessor.TypeAnnotation; odataProperties[i] = new ODataProperty() { Name = accessor.Name, Value = odataValue }; } return(new ODataResource { TypeName = _typeName, Properties = odataProperties }); }
internal static object ConvertValue( object odataValue, Type expectedReturnType, IEdmTypeReference propertyType, IEdmModel model, ApiContext apiContext) { ODataDeserializerContext readContext = new ODataDeserializerContext { Model = model }; ODataDeserializerProvider deserializerProvider = apiContext.GetApiService <ODataDeserializerProvider>(); if (odataValue == null) { return(null); } ODataNullValue nullValue = odataValue as ODataNullValue; if (nullValue != null) { return(null); } ODataComplexValue complexValue = odataValue as ODataComplexValue; if (complexValue != null) { ODataEdmTypeDeserializer deserializer = deserializerProvider.GetEdmTypeDeserializer(propertyType.AsComplex()); return(deserializer.ReadInline(complexValue, propertyType, readContext)); } ODataEnumValue enumValue = odataValue as ODataEnumValue; if (enumValue != null) { ODataEdmTypeDeserializer deserializer = deserializerProvider.GetEdmTypeDeserializer(propertyType.AsEnum()); return(deserializer.ReadInline(enumValue, propertyType, readContext)); } ODataCollectionValue collection = odataValue as ODataCollectionValue; if (collection != null) { ODataEdmTypeDeserializer deserializer = deserializerProvider.GetEdmTypeDeserializer(propertyType as IEdmCollectionTypeReference); var collectionResult = deserializer.ReadInline(collection, propertyType, readContext); return(ConvertCollectionType(collectionResult, expectedReturnType)); } return(odataValue); }
public void ConvertEnumValue_ThrowsValidationException_NonEnumType() { // Arrange & Act & Assert ODataEnumValue enumValue = new ODataEnumValue("Red"); ExceptionAssert.Throws <InvalidOperationException>( () => EnumDeserializationHelpers.ConvertEnumValue(enumValue, typeof(int)), "The type 'Int32' must be an enum or Nullable<T> where T is an enum type."); }
/// <summary> /// Converts an enum value to a string for use in a Url. /// </summary> /// <param name="value">Value to convert.</param> /// <param name="version">OData version to be compliant with.</param> /// <returns>A string representation of <paramref name="value"/> to be added to a Url.</returns> internal static string ConvertToUriEnumLiteral(ODataEnumValue value, ODataVersion version) { ExceptionUtils.CheckArgumentNotNull(value, "value"); ExceptionUtils.CheckArgumentNotNull(value.TypeName, "value.TypeName"); ExceptionUtils.CheckArgumentNotNull(value.Value, "value.Value"); // not URL-encode the resulting string: return string.Format(CultureInfo.InvariantCulture, "{0}'{1}'", value.TypeName, value.Value); }
/// <summary> /// Converts an enum value to a string for use in a Url. /// </summary> /// <param name="value">Value to convert.</param> /// <param name="version">OData version to be compliant with.</param> /// <returns>A string representation of <paramref name="value"/> to be added to a Url.</returns> internal static string ConvertToUriEnumLiteral(ODataEnumValue value, ODataVersion version) { ExceptionUtils.CheckArgumentNotNull(value, "value"); ExceptionUtils.CheckArgumentNotNull(value.TypeName, "value.TypeName"); ExceptionUtils.CheckArgumentNotNull(value.Value, "value.Value"); // not URL-encode the resulting string: return(string.Format(CultureInfo.InvariantCulture, "{0}'{1}'", value.TypeName, value.Value)); }
public void SetCoverColors(ODataCollectionValue values) { this.CoverColors = new Collection <Color>(); foreach (var item in values.Items) { ODataEnumValue enumItem = item as ODataEnumValue; this.CoverColors.Add((Color)Enum.Parse(typeof(Color), enumItem.Value)); } }
public void ConvertEnumValue_ReturnEnumValue_ForEnumType() { // Arrange object value = new ODataEnumValue("Red"); Type type = typeof(Color); // Act & Assert Assert.Equal(Enum.ToObject(typeof(Color), Color.Red), EnumDeserializationHelpers.ConvertEnumValue(value, type)); }
public void EnumTypeCollectionRoundtripJsonLightTest() { ODataEnumValue subject0 = new ODataEnumValue("Red", "NS.ColorFlags"); ODataEnumValue subject1 = new ODataEnumValue("123", "NS.ColorFlags"); ODataCollectionValue complexCollectionValue = new ODataCollectionValue { TypeName = "Collection(NS.ColorFlags)", Items = new[] { subject0, subject1 } }; this.VerifyNonPrimitiveTypeRoundtrip(complexCollectionValue, "ClothesColors"); }
/// <summary> /// Writes a enum property. /// </summary> /// <param name="enumValue">The enum value to be written.</param> /// <param name="isOpenPropertyType">If the property is open.</param> private void WriteEnumProperty( ODataEnumValue enumValue, bool isOpenPropertyType) { ResolveEnumValueTypeName(enumValue, isOpenPropertyType); this.WritePropertyTypeName(); this.JsonWriter.WriteName(this.currentPropertyInfo.WireName); this.JsonLightValueSerializer.WriteEnumValue(enumValue, this.currentPropertyInfo.MetadataType.TypeReference); }
private static ODataResource CreateEntry(Object entity, PropertyInfo[] structuralProperties) { Type clrEntityType = entity.GetType(); var odataProperties = new ODataProperty[structuralProperties.Length]; for (int i = 0; i < odataProperties.Length; i++) { Object value = structuralProperties[i].GetValue(entity); ODataValue odataValue = null; if (value == null) { odataValue = new ODataNullValue(); } else if (value.GetType().IsEnum) { odataValue = new ODataEnumValue(value.ToString()); } else if (value is DateTime dateTime) { switch (dateTime.Kind) { case DateTimeKind.Unspecified: value = new DateTimeOffset(DateTime.SpecifyKind(dateTime, DateTimeKind.Utc)); break; case DateTimeKind.Utc: value = new DateTimeOffset(dateTime); break; case DateTimeKind.Local: value = new DateTimeOffset(dateTime.ToUniversalTime()); break; default: throw new ArgumentOutOfRangeException("unknown DateTimeKind " + dateTime.Kind.ToString()); } odataValue = new ODataPrimitiveValue(value); } else { odataValue = new ODataPrimitiveValue(value); } odataProperties[i] = new ODataProperty() { Name = structuralProperties[i].Name, Value = odataValue }; } return(new ODataResource { TypeName = clrEntityType.FullName, Properties = odataProperties }); }
public void ConvertEnumValue_Throws_ForNonEnumType() { // Arrange object value = new ODataEnumValue("Red"); Type type = typeof(int); // Act & Assert Assert.Throws <InvalidOperationException>( () => EnumDeserializationHelpers.ConvertEnumValue(value, type), "The type 'Int32' must be an enum or Nullable<T> where T is an enum type."); }
public void ConvertEnumValue_Throws_ForNullTypeParameter() { // Arrange object value = new ODataEnumValue("Red"); Type type = null; // Act & Assert ExceptionAssert.ThrowsArgumentNull( () => EnumDeserializationHelpers.ConvertEnumValue(value, type), "type"); }
public void ConvertEnumValue_Returns_ForODataEnumValue() { // Arrange & Act & Assert ODataEnumValue enumValue = new ODataEnumValue("Red"); Assert.Equal(EnumColor.Red, EnumDeserializationHelpers.ConvertEnumValue(enumValue, typeof(EnumColor))); // Arrange & Act & Assert enumValue = new ODataEnumValue("Green"); Assert.Equal(EnumColor.Green, EnumDeserializationHelpers.ConvertEnumValue(enumValue, typeof(EnumColor))); }
/// <summary> /// Generates a string to be used as the skip token value within the next link. /// </summary> /// <param name="lastMember"> Object based on which SkipToken value will be generated.</param> /// <param name="model">The edm model.</param> /// <param name="orderByNodes">List of orderByNodes used to generate the skiptoken value.</param> /// <returns>Value for the skiptoken to be used in the next link.</returns> private static string GenerateSkipTokenValue(Object lastMember, IEdmModel model, IList <OrderByNode> orderByNodes) { if (lastMember == null) { return(String.Empty); } IEnumerable <IEdmProperty> propertiesForSkipToken = GetPropertiesForSkipToken(lastMember, model, orderByNodes); StringBuilder skipTokenBuilder = new StringBuilder(String.Empty); if (propertiesForSkipToken == null) { return(skipTokenBuilder.ToString()); } int count = 0; string uriLiteral; object value; int lastIndex = propertiesForSkipToken.Count() - 1; IEdmStructuredObject obj = lastMember as IEdmStructuredObject; foreach (IEdmProperty edmProperty in propertiesForSkipToken) { bool islast = count == lastIndex; string clrPropertyName = EdmLibHelpers.GetClrPropertyName(edmProperty, model); if (obj != null) { obj.TryGetPropertyValue(clrPropertyName, out value); } else { value = lastMember.GetType().GetProperty(clrPropertyName).GetValue(lastMember); } if (value == null) { uriLiteral = ODataUriUtils.ConvertToUriLiteral(value, ODataVersion.V401); } else if (edmProperty.Type.IsEnum()) { ODataEnumValue enumValue = new ODataEnumValue(value.ToString(), value.GetType().FullName); uriLiteral = ODataUriUtils.ConvertToUriLiteral(enumValue, ODataVersion.V401, model); } else { uriLiteral = ODataUriUtils.ConvertToUriLiteral(value, ODataVersion.V401, model); } skipTokenBuilder.Append(edmProperty.Name).Append(propertyDelimiter).Append(uriLiteral).Append(islast ? String.Empty : CommaDelimiter.ToString()); count++; } return(skipTokenBuilder.ToString()); }
public void QuerySingletonEnumProperty() { foreach (var mimeType in mimeTypes) { ODataProperty property = this.QueryProperty("Company/CompanyCategory", mimeType); if (!mimeType.Contains(MimeTypes.ODataParameterNoMetadata)) { ODataEnumValue enumValue = (ODataEnumValue)property.Value; Assert.AreEqual("IT", enumValue.Value); } } }
public void UpdateEnumProperty() { // query an entry ODataEntry productEntry = this.QueryEntityItem("Products(5)") as ODataEntry; // send a request to update an entry property productEntry = new ODataEntry() { TypeName = NameSpacePrefix + "Product", Properties = new[] { new ODataProperty { Name = "SkinColor", Value = new ODataEnumValue("Green") }, new ODataProperty { Name = "UserAccess", Value = new ODataEnumValue("Read") } } }; var settings = new ODataMessageWriterSettings(); settings.PayloadBaseUri = ServiceBaseUri; settings.AutoComputePayloadMetadataInJson = true; var productType = Model.FindDeclaredType(NameSpacePrefix + "Product") as IEdmEntityType; var productSet = Model.EntityContainer.FindEntitySet("Products"); foreach (var mimeType in mimeTypes) { var requestMessage = new HttpWebRequestMessage(new Uri(ServiceBaseUri + "Products(5)")); requestMessage.SetHeader("Content-Type", mimeType); requestMessage.SetHeader("Accept", mimeType); requestMessage.Method = "PATCH"; using (var messageWriter = new ODataMessageWriter(requestMessage, settings, Model)) { var odataWriter = messageWriter.CreateODataEntryWriter(productSet, productType); odataWriter.WriteStart(productEntry); odataWriter.WriteEnd(); } var responseMessage = requestMessage.GetResponse(); // verify the update Assert.AreEqual(204, responseMessage.StatusCode); ODataEntry updatedProduct = this.QueryEntityItem("Products(5)") as ODataEntry; ODataEnumValue skinColor = updatedProduct.Properties.Single(p => p.Name == "SkinColor").Value as ODataEnumValue; ODataEnumValue userAccess = updatedProduct.Properties.Single(p => p.Name == "UserAccess").Value as ODataEnumValue; Assert.AreEqual("Green", skinColor.Value); Assert.AreEqual("Read", userAccess.Value); } }
/// <summary> /// Read an enumeration value from the reader. /// </summary> /// <param name="actualValueTypeReference">The thpe of the value to read.</param> /// <returns>An ODataEnumValue with the value read from the payload.</returns> private ODataEnumValue ReadEnumValue(IEdmEnumTypeReference actualValueTypeReference) { Debug.Assert(actualValueTypeReference != null, "actualValueTypeReference != null"); Debug.Assert(actualValueTypeReference.TypeKind() == EdmTypeKind.Enum, "Only Enum values can be read by this method."); this.AssertXmlCondition(XmlNodeType.Element, XmlNodeType.Attribute); ODataEnumValue result = AtomValueUtils.ReadEnumValue(this.XmlReader, actualValueTypeReference); this.AssertXmlCondition(true, XmlNodeType.EndElement); Debug.Assert(result != null, "The method should never return null since it doesn't handle null values."); return(result); }
public void FlagsEnumAsTopLevelValue_StrAsValue_StrAsTypeName_anyContentType() { WriteToMessageWriterAndVerifyPayload( contentType: "*/*", writerAction: (writer) => { ODataEnumValue enumValue = new ODataEnumValue(Color.Red.ToString(), "NS.EnumUndefinedTypename"); writer.WriteValue(enumValue); }, expectedPayload: Color.Red.ToString() ); }
/// <inheritdoc /> public override object ReadInline(object item, IEdmTypeReference edmType, ODataDeserializerContext readContext) { if (item == null) { return(null); } if (readContext == null) { throw Error.ArgumentNull(nameof(readContext)); } ODataProperty property = item as ODataProperty; if (property != null) { item = property.Value; } IEdmEnumTypeReference enumTypeReference = edmType.AsEnum(); ODataEnumValue enumValue = item as ODataEnumValue; if (readContext.IsNoClrType) { Contract.Assert(edmType.TypeKind() == EdmTypeKind.Enum); return(new EdmEnumObject(enumTypeReference, enumValue.Value)); } IEdmEnumType enumType = enumTypeReference.EnumDefinition(); // Enum member supports model alias case. So, try to use the Edm member name to retrieve the Enum value. var memberMapAnnotation = readContext.Model.GetClrEnumMemberAnnotation(enumType); if (memberMapAnnotation != null) { if (enumValue != null) { IEdmEnumMember enumMember = enumType.Members.FirstOrDefault(m => m.Name == enumValue.Value); if (enumMember != null) { var clrMember = memberMapAnnotation.GetClrEnumMember(enumMember); if (clrMember != null) { return(clrMember); } } } } Type clrType = readContext.Model.GetClrType(edmType); return(EnumDeserializationHelpers.ConvertEnumValue(item, clrType)); }
public void FlagsEnumAsTopLevelValue_StrAsValue_StrAsTypeName_textplainContentType() { WriteToMessageWriterAndVerifyPayload( contentType: "text/plain", // can't be full/minimal/none metadata writerAction: (writer) => { ODataEnumValue enumValue = new ODataEnumValue(Color.Red.ToString(), "NS.EnumUndefinedTypename"); writer.WriteValue(enumValue); }, expectedPayload: Color.Red.ToString() ); }
public override ODataEnumValue CreateODataEnumValue(object graph, IEdmEnumTypeReference enumType, ODataSerializerContext writeContext) { ODataEnumValue result = base.CreateODataEnumValue(graph, enumType, writeContext); if (!string.IsNullOrEmpty(result?.Value) && !string.IsNullOrEmpty(result.TypeName)) { // EnumKey >> "Namespace.EnumType'EnumKey'" result = new ODataEnumValue($"{result.TypeName}'{result.Value}'"); } return(result); }
public void MaterializeEnumTypeShouldWork() { ODataEnumValue enumValue = new ODataEnumValue("blue"); ODataProperty property = new ODataProperty { Name = "enumProperty", Value = enumValue }; var enumPolicy = new EnumValueMaterializationPolicy(new TestMaterializerContext()); var result = enumPolicy.MaterializeEnumTypeProperty(typeof(Color), property); property.GetMaterializedValue().Should().Be(Color.Blue); result.Should().Be(Color.Blue); }
/// <summary> /// ConstantExpression visit method /// </summary> /// <param name="c">The ConstantExpression expression to visit</param> /// <returns>The visited ConstantExpression expression </returns> internal override Expression VisitConstant(ConstantExpression c) { if (c.Value == null) { this.builder.Append(UriHelper.NULL); return(c); } // DEVNOTE: // Rather than forcing every other codepath to have the 'Try...' pattern for formatting, // we catch the InvalidOperationException here to change the exception type. // This is exceedingly rare, and not a scenario where performance is meaningful, so the // reduced complexity in all other call sites is worth the extra logic here. string result; BinaryExpression b = this.parent as BinaryExpression; MethodCallExpression m = this.parent as MethodCallExpression; if ((b != null && HasEnumInBinaryExpression(b)) || (m != null && m.Method.Name == "HasFlag")) { c = this.ConvertConstantExpressionForEnum(c); ClientEdmModel model = this.context.Model; IEdmType edmType = model.GetOrCreateEdmType(c.Type.IsEnum() ? c.Type : c.Type.GetGenericArguments()[0]); ClientTypeAnnotation typeAnnotation = model.GetClientTypeAnnotation(edmType); string typeNameInEdm = this.context.ResolveNameFromTypeInternal(typeAnnotation.ElementType); MemberInfo member = typeAnnotation.ElementType.GetField(c.Value.ToString()); string memberValue = ClientTypeUtil.GetServerDefinedName(member); ODataEnumValue enumValue = new ODataEnumValue(memberValue, typeNameInEdm ?? typeAnnotation.ElementTypeName); result = ODataUriUtils.ConvertToUriLiteral(enumValue, CommonUtil.ConvertToODataVersion(this.uriVersion), null); } else { try { result = LiteralFormatter.ForConstants.Format(c.Value); } catch (InvalidOperationException) { if (this.cantTranslateExpression) { // there's already a problem in the parents. // we should just return here, because caller somewhere up the stack will throw a better exception return(c); } throw new NotSupportedException(Strings.ALinq_CouldNotConvert(c.Value)); } } Debug.Assert(result != null, "result != null"); this.builder.Append(result); return(c); }
private static bool ApplyDynamicProperty(ODataProperty property, IEdmStructuredType structuredType, object resource, ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext) { PropertyInfo propertyInfo = EdmLibHelpers.GetDynamicPropertyDictionary(structuredType, readContext.Model); if (propertyInfo == null) { return(false); } IDictionary <string, object> dynamicPropertyDictionary = propertyInfo.GetValue(resource) as IDictionary <string, object>; if (dynamicPropertyDictionary == null) { dynamicPropertyDictionary = new Dictionary <string, object>(); propertyInfo.SetValue(resource, dynamicPropertyDictionary); } if (dynamicPropertyDictionary.ContainsKey(property.Name)) { throw Error.InvalidOperation(SRResources.DuplicateDynamicPropertyNameFound, property.Name, structuredType.FullTypeName()); } EdmTypeKind propertyKind; IEdmTypeReference propertyType = null; object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext, out propertyKind); if (propertyKind == EdmTypeKind.Collection) { throw Error.InvalidOperation(SRResources.CollectionNotAllowedAsDynamicProperty, property.Name); } if (propertyKind == EdmTypeKind.Enum) { ODataEnumValue enumValue = (ODataEnumValue)value; IEdmModel model = readContext.Model; IEdmType edmType = model.FindType(enumValue.TypeName); if (edmType == null) { return(false); } Type enumType = EdmLibHelpers.GetClrType(edmType, model); value = Enum.Parse(enumType, enumValue.Value); } dynamicPropertyDictionary.Add(property.Name, value); return(true); }
/// <summary> /// Materializes the enum data value. /// </summary> /// <param name="valueType">Type of the collection item.</param> /// <param name="property">The ODataProperty.</param> /// <returns>Materialized enum data CLR value.</returns> public object MaterializeEnumTypeProperty(Type valueType, ODataProperty property) { object materializedValue = null; ODataEnumValue value = property.Value as ODataEnumValue; this.MaterializeODataEnumValue(valueType, value.TypeName, value.Value, () => "TODO: Is this reachable?", out materializedValue); if (!property.HasMaterializedValue()) { property.SetMaterializedValue(materializedValue); } return(materializedValue); }
/// <summary> /// Parse string or integer to enum value /// </summary> /// <param name="enumType">edm enum type</param> /// <param name="value">input string value</param> /// <param name="enumValue">output edm enum value</param> /// <returns>true if parse succeeds, false if fails</returns> private static bool TryParseEnum(IEdmEnumType enumType, string value, out ODataEnumValue enumValue) { long parsedValue; bool success = enumType.TryParseEnum(value, true, out parsedValue); enumValue = null; if (success) { enumValue = new ODataEnumValue(parsedValue.ToString(CultureInfo.InvariantCulture), enumType.FullTypeName()); } return(success); }
public override object ReadInline(object item, IEdmTypeReference edmType, ODataDeserializerContext readContext) { ODataEnumValue valueItem = item as ODataEnumValue; if (valueItem != null && !string.IsNullOrEmpty(valueItem.Value) && !string.IsNullOrEmpty(valueItem.TypeName)) { // "Namespace.EnumType'EnumKey'" >> EnumKey valueItem = new ODataEnumValue(valueItem.Value.Replace(valueItem.TypeName, string.Empty).Replace("'", string.Empty)); } object result = base.ReadInline(valueItem, edmType, readContext); return(result); }
/// <summary> /// Write enum value /// </summary> /// <param name="value">enum value</param> /// <param name="expectedTypeReference">expected type reference</param> public virtual void WriteEnumValue( ODataEnumValue value, IEdmTypeReference expectedTypeReference) { if (value.Value == null) { this.WriteNullValue(); } else { this.JsonWriter.WritePrimitiveValue(value.Value); } }
public async Task WriteEnumValueAsync_WritesNullForEnumValueAsNull() { var colorEnumValue = new ODataEnumValue(null); var colorEdmEnumTypeReference = new EdmEnumTypeReference(this.colorEnumType, false); var result = await SetupJsonLightValueSerializerAndRunTestAsync( (jsonLightValueSerializer) => { return(jsonLightValueSerializer.WriteEnumValueAsync(colorEnumValue, colorEdmEnumTypeReference)); }); Assert.Equal("null", result); }
/// <summary> /// Asynchronously writes enum value /// </summary> /// <param name="value">enum value</param> /// <param name="expectedTypeReference">expected type reference</param> /// <returns>A task that represents the asynchronous write operation.</returns> public virtual Task WriteEnumValueAsync( ODataEnumValue value, IEdmTypeReference expectedTypeReference) { if (value.Value == null) { return(this.WriteNullValueAsync()); } else { return(this.AsynchronousJsonWriter.WritePrimitiveValueAsync(value.Value)); } }
private static string TranslateNode(object node, string functionName, string parameterName) { // If the function parameter is null, for example myFunction(param=null), // the input node here is not null, it is a contant node with a value as "null". // However, if a function call (or key) using parameter alias but without providing the parameter alias value, // the input node here is a null. if (node == null) { // We can't throw ODataException here because ODataException will be caught and return 404 response with empty message. throw new InvalidOperationException(Error.Format(SRResources.MissingConvertNode, parameterName, functionName)); } ConstantNode constantNode = node as ConstantNode; if (constantNode != null) { UriTemplateExpression uriTemplateExpression = constantNode.Value as UriTemplateExpression; if (uriTemplateExpression != null) { return(uriTemplateExpression.LiteralText); } // Make the enum prefix free to work. ODataEnumValue enumValue = constantNode.Value as ODataEnumValue; if (enumValue != null) { return(ODataUriUtils.ConvertToUriLiteral(enumValue, ODataVersion.V4)); } return(constantNode.LiteralText); } ConvertNode convertNode = node as ConvertNode; if (convertNode != null) { return(TranslateNode(convertNode.Source, functionName, parameterName)); } ParameterAliasNode parameterAliasNode = node as ParameterAliasNode; if (parameterAliasNode != null) { return(parameterAliasNode.Alias); } //return node.ToString(); throw Error.NotSupported(SRResources.CannotRecognizeNodeType, typeof(ODataPathSegmentHandler), node.GetType().FullName); }
/// <summary> /// Write enum value /// </summary> /// <param name="value">enum value</param> /// <param name="expectedTypeReference">expected type reference</param> public void WriteEnumValue(ODataEnumValue value, IEdmTypeReference expectedTypeReference) { throw new NotImplementedException(); }
public void FlagsEnumAsCollectionItemAsTopLevelValue_StrAsValue_StrAsTypeName_MinimalMetadata_CollecionWriter() { ODataCollectionStart collectionStart = new ODataCollectionStart(); collectionStart.SetSerializationInfo(new ODataCollectionStartSerializationInfo { CollectionTypeName = "Collection(NS.ColorFlags)" }); ODataEnumValue[] items = new ODataEnumValue[] { new ODataEnumValue(ColorFlags.Red.ToString(), "NS.ColorFlags"), new ODataEnumValue(null, "NS.ColorFlags_Undefined"), new ODataEnumValue("Red,Green", "NS.ColorFlags"), new ODataEnumValue("Red|Green", "NS.ColorFlags"), new ODataEnumValue(ColorFlags.Green.ToString(), "NS.ColorFlags") }; EdmEnumTypeReference enumRef = new EdmEnumTypeReference((IEdmEnumType)this.userModel.FindType("NS.ColorFlags"), true); WriteToMessageWriterAndVerifyPayload( contentType: "application/json;odata.metadata=minimal;", writerAction: (writer) => { ODataCollectionWriter collectionWriter = writer.CreateODataCollectionWriter(enumRef); collectionWriter.WriteStart(collectionStart); foreach (object item in items) { collectionWriter.WriteItem(item); } collectionWriter.WriteEnd(); }, expectedPayload: "{\"@odata.context\":\"http://odata.org/test/$metadata#Collection(NS.ColorFlags)\",\"value\":[\"Red\",null,\"Red,Green\",\"Red|Green\",\"Green\"]}" ); }
/// <summary> /// Writes a enum property. /// </summary> /// <param name="property">The property to write out.</param> /// <param name="enumValue">The enum value to be written.</param> /// <param name="propertyTypeReference">The metadata type reference of the property.</param> /// <param name="isTopLevel">true when writing a top-level property; false for nested properties.</param> /// <param name="isOpenPropertyType">If the property is open.</param> private void WriteEnumProperty( ODataProperty property, ODataEnumValue enumValue, IEdmTypeReference propertyTypeReference, bool isTopLevel, bool isOpenPropertyType) { string wirePropertyName = GetWirePropertyName(isTopLevel, property.Name); IEdmTypeReference typeFromValue = TypeNameOracle.ResolveAndValidateTypeForEnumValue(this.Model, enumValue, isOpenPropertyType); // This is a work around, needTypeOnWire always = true for client side: // ClientEdmModel's reflection can't know a property is open type even if it is, so here // make client side always write 'odata.type' for enum. bool needTypeOnWire = string.Equals(this.JsonLightOutputContext.Model.GetType().Name, "ClientEdmModel", StringComparison.OrdinalIgnoreCase); string typeNameToWrite = this.JsonLightOutputContext.TypeNameOracle.GetValueTypeNameForWriting( enumValue, propertyTypeReference, typeFromValue, needTypeOnWire || isOpenPropertyType); this.WritePropertyTypeName(wirePropertyName, typeNameToWrite, isTopLevel); this.JsonWriter.WriteName(wirePropertyName); this.JsonLightValueSerializer.WriteEnumValue(enumValue, propertyTypeReference); }
public void IfValueIsEnumThenODataValueShouldBeReferenceEqual() { var enumValue = new ODataEnumValue(Color.Green.ToString()); this.property.Value = enumValue; this.property.ODataValue.Should().BeSameAs(enumValue); }
/// <summary> /// Write enum value /// </summary> /// <param name="value">enum value</param> /// <param name="expectedTypeReference">expected type reference</param> public void WriteEnumValue( ODataEnumValue value, IEdmTypeReference expectedTypeReference) { if (value.Value == null) { this.WriteNullValue(); } else { this.JsonWriter.WritePrimitiveValue(value.Value); } }
public void TestEnumConvertToUriLiteral_EnumValue() { var val = new ODataEnumValue(11L + "", "Fully.Qualified.Namespace.ColorPattern"); string enumValStr = ODataUriUtils.ConvertToUriLiteral(val, ODataVersion.V4); enumValStr.Should().Be("Fully.Qualified.Namespace.ColorPattern'11'"); }
/// <summary> /// Parse string or integer to enum value /// </summary> /// <param name="enumType">edm enum type</param> /// <param name="value">input string value</param> /// <param name="enumValue">output edm enum value</param> /// <returns>true if parse succeeds, false if fails</returns> private static bool TryParseEnum(IEdmEnumType enumType, string value, out ODataEnumValue enumValue) { long parsedValue; bool success = enumType.TryParseEnum(value, true, out parsedValue); enumValue = null; if (success) { enumValue = new ODataEnumValue(parsedValue.ToString(CultureInfo.InvariantCulture), enumType.FullTypeName()); } return success; }
/// <summary> /// Writes an enumeration value. /// </summary> /// <param name="value">The value to write.</param> /// <param name="collectionValidator">The collection validator instance.</param> /// <param name="expectedTypeReference">The expected type of the enumeration value.</param> /// <param name="typeNameAnnotation">The optional type name annotation provided by the user on the OM for this enumeration value. The annotation value will override whatever type name is being written.</param> internal void WriteEnumValue( ODataEnumValue value, CollectionWithoutExpectedTypeValidator collectionValidator, IEdmTypeReference expectedTypeReference, SerializationTypeNameAnnotation typeNameAnnotation) { Debug.Assert(value != null, "value != null"); // write type name without validation: // TODO: consider adding a overloaded GetValueTypeNameForWriting() without out parameter. string collectionItemTypeName; string typeName = this.AtomOutputContext.TypeNameOracle.GetValueTypeNameForWriting(value, expectedTypeReference, typeNameAnnotation, collectionValidator, out collectionItemTypeName); Debug.Assert(collectionItemTypeName == null, "collectionItemTypeName == null"); if (typeName != null) { Debug.Assert(typeName != EdmConstants.EdmStringTypeName, "Enum typeName != EdmConstants.StringTypeName"); this.WritePropertyTypeAttribute(typeName); } // write string value without validation: AtomValueUtils.WritePrimitiveValue(this.XmlWriter, value.Value); }
/// <summary> /// Parse string or integer to enum value /// </summary> /// <param name="enumType">edm enum type</param> /// <param name="value">input string value</param> /// <param name="enumValue">output edm enum value</param> /// <returns>true if parse succeeds, false if fails</returns> internal static bool TryParseEnum(IEdmEnumType enumType, string value, out ODataEnumValue enumValue) { long parsedValue; bool success = enumType.TryParseEnum(value, true, out parsedValue); enumValue = null; if (success) { // ODataEnumValue.Value will always be numeric string like '3', '10' instead of 'Cyan', 'Solid,Yellow', etc. // so user code can easily Enum.Parse() them into CLR value. enumValue = new ODataEnumValue(parsedValue.ToString(CultureInfo.InvariantCulture), enumType.ODataFullName()); } return success; }