internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource, ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext) { IEdmProperty edmProperty = resourceType.FindProperty(property.Name); string propertyName = property.Name; IEdmTypeReference propertyType = edmProperty != null ? edmProperty.Type : null; // open properties have null values // If we are in patch mode and we are deserializing an entity object then we are updating Delta<T> and not T. bool isDelta = readContext.IsPatchMode && resourceType.IsEntity(); EdmTypeKind propertyKind; object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext, out propertyKind); if (propertyKind == EdmTypeKind.Collection) { SetCollectionProperty(resource, propertyName, isDelta, value); } else { if (propertyKind == EdmTypeKind.Primitive) { value = EdmPrimitiveHelpers.ConvertPrimitiveValue(value, GetPropertyType(resource, propertyName, isDelta)); } SetProperty(resource, propertyName, isDelta, value); } }
internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource, ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext) { IEdmProperty edmProperty = resourceType.FindProperty(property.Name); string propertyName = property.Name; IEdmTypeReference propertyType = edmProperty != null ? edmProperty.Type : null; // open properties have null values EdmTypeKind propertyKind; object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext, out propertyKind); if (propertyKind == EdmTypeKind.Collection) { SetCollectionProperty(resource, edmProperty, value); } else { if (propertyKind == EdmTypeKind.Primitive && !readContext.IsUntyped) { value = EdmPrimitiveHelpers.ConvertPrimitiveValue(value, GetPropertyType(resource, propertyName)); } SetProperty(resource, propertyName, value); } }
protected void ApplyProperty(ODataProperty property, ResourceType resourceType, object resource) { ResourceType type; string name = property.Name; ResourceProperty resourceProperty = resourceType.TryResolvePropertyName(name); if (resourceProperty == null) { type = null; } else { if (resourceProperty.Kind == ResourcePropertyKind.Stream) { return; } if (base.Update && resourceProperty.IsOfKind(ResourcePropertyKind.Key)) { return; } type = resourceProperty.ResourceType; } object propertyValue = this.ConvertValue(property.Value, ref type); if (resourceProperty == null) { Deserializer.SetOpenPropertyValue(resource, name, propertyValue, base.Service); } else { Deserializer.SetPropertyValue(resourceProperty, resource, propertyValue, base.Service); } }
private static void AddEntryProperty(IODataJsonReaderEntryState entryState, string propertyName, object propertyValue) { ODataProperty property = new ODataProperty { Name = propertyName, Value = propertyValue }; entryState.DuplicatePropertyNamesChecker.CheckForDuplicatePropertyNames(property); ReaderUtils.AddPropertyToPropertiesList(entryState.Entry.Properties, property); }
/// <summary> /// Validates an <see cref="ODataProperty"/> for not being null. /// </summary> /// <param name="property">The property to validate for not being null.</param> internal static void ValidatePropertyNotNull(ODataProperty property) { DebugUtils.CheckNoExternalCallers(); if (property == null) { throw new ODataException(Strings.WriterValidationUtils_PropertyMustNotBeNull); } }
/// <summary> /// Deserializes the primitive from the given <paramref name="primitiveProperty"/> under the given <paramref name="readContext"/>. /// </summary> /// <param name="primitiveProperty">The primitive property to deserialize.</param> /// <param name="readContext">The deserializer context.</param> /// <returns>The deserialized OData primitive value.</returns> public virtual object ReadPrimitive(ODataProperty primitiveProperty, ODataDeserializerContext readContext) { if (primitiveProperty == null) { throw Error.ArgumentNull("primitiveProperty"); } return primitiveProperty.Value; }
private void AddEpmPropertyValue(List<ODataProperty> properties, string propertyName, object propertyValue, bool checkDuplicateEntryPropertyNames) { ODataProperty property = new ODataProperty { Name = propertyName, Value = propertyValue }; if (checkDuplicateEntryPropertyNames) { this.entryState.DuplicatePropertyNamesChecker.CheckForDuplicatePropertyNames(property); } properties.Add(property); }
/// <summary> /// Validates an <see cref="ODataProperty"/> to ensure all required information is specified. /// </summary> /// <param name="property">The property to validate (must not be null, call ValidatePropertyNotNull before).</param> internal static void ValidateProperty(ODataProperty property) { DebugUtils.CheckNoExternalCallers(); Debug.Assert(property != null, "property != null"); // Properties must have a non-empty name string propertyName = property.Name; if (string.IsNullOrEmpty(propertyName)) { throw new ODataException(Strings.WriterValidationUtils_PropertiesMustHaveNonEmptyName); } ValidationUtils.ValidatePropertyName(propertyName); }
internal void CheckForDuplicatePropertyNames(ODataProperty property) { DuplicationRecord record; string name = property.Name; DuplicationKind duplicationKind = GetDuplicationKind(property); if (!this.TryGetDuplicationRecord(name, out record)) { this.propertyNameCache.Add(name, new DuplicationRecord(duplicationKind)); } else if ((((record.DuplicationKind == DuplicationKind.Prohibited) || (duplicationKind == DuplicationKind.Prohibited)) || ((record.DuplicationKind == DuplicationKind.NavigationProperty) && record.AssociationLinkFound)) || !this.allowDuplicateProperties) { throw new ODataException(Strings.DuplicatePropertyNamesChecker_DuplicatePropertyNamesNotAllowed(name)); } }
public void ReadInline_Calls_ReadPrimitive() { // Arrange IEdmPrimitiveTypeReference primitiveType = EdmCoreModel.Instance.GetInt32(isNullable: true); Mock<ODataPrimitiveDeserializer> deserializer = new Mock<ODataPrimitiveDeserializer>(); ODataProperty property = new ODataProperty(); ODataDeserializerContext readContext = new ODataDeserializerContext(); deserializer.Setup(d => d.ReadPrimitive(property, readContext)).Returns(42).Verifiable(); // Act var result = deserializer.Object.ReadInline(property, primitiveType, readContext); // Assert deserializer.Verify(); Assert.Equal(42, result); }
/// <summary> /// Validates a stream reference property. /// </summary> /// <param name="streamProperty">The stream property to check.</param> /// <param name="structuredType">The owning type of the stream property or null if no metadata is available.</param> /// <param name="streamEdmProperty">The stream property defined by the model.</param> internal static void ValidateStreamReferenceProperty(ODataProperty streamProperty, IEdmStructuredType structuredType, IEdmProperty streamEdmProperty) { DebugUtils.CheckNoExternalCallers(); Debug.Assert(streamProperty != null, "streamProperty != null"); ValidationUtils.ValidateStreamReferenceProperty(streamProperty, streamEdmProperty); if (structuredType != null && structuredType.IsOpen) { // If no property match was found in the metadata and an error wasn't raised, // it is an open property (which is not supported for streams). if (streamEdmProperty == null) { // Fails with the correct error message. ValidationUtils.ValidateOpenPropertyValue(streamProperty.Name, streamProperty.Value); } } }
internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource, ODataDeserializerProvider deserializerProvider, ODataDeserializerReadContext readContext) { IEdmProperty edmProperty = resourceType.FindProperty(property.Name); string propertyName = property.Name; IEdmTypeReference propertyType = edmProperty != null ? edmProperty.Type : null; // open properties have null values object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext); // If we are in patch mode and we are deserializing an entity object then we are updating Delta<T> and not T. if (!readContext.IsPatchMode || !resourceType.IsEntity()) { resource.GetType().GetProperty(propertyName).SetValue(resource, value, index: null); } else { (resource as IDelta).TrySetPropertyValue(propertyName, value); } }
/// <summary> /// Writes a single property in ATOM format. /// </summary> /// <param name="property">The property to write out.</param> internal void WriteTopLevelProperty(ODataProperty property) { DebugUtils.CheckNoExternalCallers(); this.WritePayloadStart(); this.AssertRecursionDepthIsZero(); this.WriteProperty( property, null /* owningType */, true /* isTopLevel */, false /* isWritingCollection */, null /* beforePropertyAction */, null /* epmValueCache */, null /* epmParentSourcePathSegment */, this.CreateDuplicatePropertyNamesChecker(), null /* projectedProperties */); this.AssertRecursionDepthIsZero(); this.WritePayloadEnd(); }
/// <summary> /// Check the <paramref name="property"/> for duplicate property names in an entry or complex value. /// If not explicitly allowed throw when duplicate properties are detected. /// If duplicate properties are allowed see the comment on ODataWriterBehavior.AllowDuplicatePropertyNames /// or ODataReaderBehavior.AllowDuplicatePropertyNames for further details. /// </summary> /// <param name="property">The property to be checked.</param> internal void CheckForDuplicatePropertyNames(ODataProperty property) { DebugUtils.CheckNoExternalCallers(); Debug.Assert(property != null, "property != null"); #if DEBUG Debug.Assert(this.startNavigationLinkName == null, "CheckForDuplicatePropertyNamesOnNavigationLinkStart was followed by a CheckForDuplicatePropertyNames(ODataProperty)."); #endif string propertyName = property.Name; DuplicationKind duplicationKind = GetDuplicationKind(property); DuplicationRecord existingDuplicationRecord; if (!this.TryGetDuplicationRecord(propertyName, out existingDuplicationRecord)) { this.propertyNameCache.Add(propertyName, new DuplicationRecord(duplicationKind)); } else if (existingDuplicationRecord.DuplicationKind == DuplicationKind.PropertyAnnotationSeen) { existingDuplicationRecord.DuplicationKind = duplicationKind; } else { // If either of them prohibits duplication, fail // If the existing one is an association link, fail (association links don't allow duplicates with simple properties) // If we don't allow duplication in the first place, fail, since there is no valid case where a simple property coexists with anything else with the same name. if (existingDuplicationRecord.DuplicationKind == DuplicationKind.Prohibited || duplicationKind == DuplicationKind.Prohibited || (existingDuplicationRecord.DuplicationKind == DuplicationKind.NavigationProperty && existingDuplicationRecord.AssociationLink != null) || !this.allowDuplicateProperties) { throw new ODataException(Strings.DuplicatePropertyNamesChecker_DuplicatePropertyNamesNotAllowed(propertyName)); } else { // Otherwise allow the duplicate. // Note that we don't modify the existing duplication record in any way if the new property is a simple property. // This is because if the existing one is a simple property which allows duplication as well, there's nothing to change. // and if the existing one is a navigation property the navigation property information is more important than the simple property one. } } }
protected static void ApplyCollectionDataValues(ODataProperty collectionProperty, bool ignoreMissingProperties, System.Data.Services.Client.ResponseInfo responseInfo, object collectionInstance, Type collectionItemType, Action<object, object> AddValueToBackingICollectionInstance) { ODataCollectionValue value2 = collectionProperty.Value as ODataCollectionValue; if (value2.Items != null) { bool flag = PrimitiveType.IsKnownNullableType(collectionItemType); ClientEdmModel model = ClientEdmModel.GetModel(responseInfo.MaxProtocolVersion); foreach (object obj2 in value2.Items) { if (obj2 == null) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Collection_NullCollectionItemsNotSupported); } if (flag) { object obj3; if ((obj2 is ODataComplexValue) || (obj2 is ODataCollectionValue)) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Collection_ComplexTypesInCollectionOfPrimitiveTypesNotAllowed); } MaterializePrimitiveDataValue(collectionItemType, value2.TypeName, obj2, responseInfo, () => System.Data.Services.Client.Strings.Collection_NullCollectionItemsNotSupported, out obj3); AddValueToBackingICollectionInstance(collectionInstance, ConvertPrimitiveValue(obj2, collectionItemType)); } else { ODataComplexValue value3 = obj2 as ODataComplexValue; if (value3 == null) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Collection_PrimitiveTypesInCollectionOfComplexTypesNotAllowed); } ClientTypeAnnotation clientTypeAnnotation = model.GetClientTypeAnnotation(model.GetOrCreateEdmType(collectionItemType)); object instance = clientTypeAnnotation.CreateInstance(); ApplyDataValues(clientTypeAnnotation, value3.Properties, ignoreMissingProperties, responseInfo, instance); AddValueToBackingICollectionInstance(collectionInstance, instance); } } } collectionProperty.SetMaterializedValue(collectionInstance); }
public override ODataProperty CreateProperty(object graph, string elementName, ODataSerializerWriteContext writeContext) { if (String.IsNullOrWhiteSpace(elementName)) { throw Error.ArgumentNullOrEmpty("elementName"); } string value = null; if (graph != null) { // TODO: Bug 453831: [OData] Figure out how OData serializes enum flags value = graph.ToString(); } ODataProperty property = new ODataProperty() { Name = elementName, Value = value }; return property; }
/// <summary> /// Write an <see cref="ODataProperty" /> to the given stream. This method creates an /// async buffered stream and writes the property to it. /// </summary> /// <param name="property">The property to write.</param> internal void WriteTopLevelProperty(ODataProperty property) { DebugUtils.CheckNoExternalCallers(); Debug.Assert(property != null, "property != null"); Debug.Assert(!(property.Value is ODataStreamReferenceValue), "!(property.Value is ODataStreamReferenceValue)"); this.WriteTopLevelPayload( () => { this.JsonWriter.StartObjectScope(); // Note we do not allow named stream properties to be written as top level property. this.AssertRecursionDepthIsZero(); this.WriteProperty( property, null /* owningType */, false /* allowStreamProperty */, this.CreateDuplicatePropertyNamesChecker(), null /* projectedProperties */); this.AssertRecursionDepthIsZero(); this.JsonWriter.EndObjectScope(); }); }
public void CreateEntry_Calls_CreateStructuralPropertyBag() { // Arrange ODataProperty[] properties = new ODataProperty[] { new ODataProperty(), new ODataProperty() }; EntityInstanceContext entityInstanceContext = new EntityInstanceContext(); Mock<ODataEntityTypeSerializer> serializer = new Mock<ODataEntityTypeSerializer>(_serializer.EdmType, new DefaultODataSerializerProvider()); serializer.CallBase = true; serializer.Setup(s => s.CreateODataActions(entityInstanceContext, _writeContext)).Returns(Enumerable.Empty<ODataAction>()); serializer.Setup(s => s.CreateStructuralPropertyBag(entityInstanceContext, _writeContext)).Returns(properties).Verifiable(); // Act ODataEntry entry = serializer.Object.CreateEntry(entityInstanceContext, _writeContext); // Assert serializer.Verify(); Assert.Same(properties, entry.Properties); }
internal virtual Task WritePropertyAsync(ODataProperty property) { throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Property); }
/// <summary> /// Reads a complex value. /// </summary> /// <param name="complexValueTypeReference">The expected type reference of the value.</param> /// <param name="payloadTypeName">The type name read from the payload.</param> /// <param name="serializationTypeNameAnnotation">The serialization type name for the collection value (possibly null).</param> /// <param name="duplicatePropertyNamesChecker">The duplicate property names checker to use - if null the method should create a new one if necessary.</param> /// <returns>The value of the complex value.</returns> /// <remarks> /// Pre-Condition: Fails if the current node is not a JsonNodeType.StartObject or JsonNodeType.PrimitiveValue (with null value) /// Post-Condition: almost anything - the node after the complex value (after the EndObject) /// </remarks> private ODataComplexValue ReadComplexValueImplementation( IEdmComplexTypeReference complexValueTypeReference, string payloadTypeName, SerializationTypeNameAnnotation serializationTypeNameAnnotation, DuplicatePropertyNamesChecker duplicatePropertyNamesChecker) { this.JsonReader.AssertNotBuffering(); this.IncreaseRecursionDepth(); // Read over the start object this.JsonReader.ReadStartObject(); ODataComplexValue complexValue = new ODataComplexValue(); complexValue.TypeName = complexValueTypeReference != null ? complexValueTypeReference.ODataFullName() : payloadTypeName; if (serializationTypeNameAnnotation != null) { complexValue.SetAnnotation(serializationTypeNameAnnotation); } if (duplicatePropertyNamesChecker == null) { duplicatePropertyNamesChecker = this.CreateDuplicatePropertyNamesChecker(); } else { duplicatePropertyNamesChecker.Clear(); } List<ODataProperty> properties = new List<ODataProperty>(); bool metadataPropertyFound = false; while (this.JsonReader.NodeType == JsonNodeType.Property) { string propertyName = this.JsonReader.ReadPropertyName(); if (string.CompareOrdinal(JsonConstants.ODataMetadataName, propertyName) == 0) { // __metadata property. if (metadataPropertyFound) { throw new ODataException(o.Strings.ODataJsonPropertyAndValueDeserializer_MultipleMetadataPropertiesInComplexValue); } metadataPropertyFound = true; this.JsonReader.SkipValue(); } else { if (!ValidationUtils.IsValidPropertyName(propertyName)) { // We ignore properties with an invalid name since these are extension points for the future. this.JsonReader.SkipValue(); } else { // Any other property is data ODataProperty property = new ODataProperty(); property.Name = propertyName; // Lookup the property in metadata IEdmProperty edmProperty = null; bool ignoreProperty = false; if (complexValueTypeReference != null) { edmProperty = ReaderValidationUtils.ValidateValuePropertyDefined(propertyName, complexValueTypeReference.ComplexDefinition(), this.MessageReaderSettings, out ignoreProperty); } if (ignoreProperty) { this.JsonReader.SkipValue(); } else { ODataNullValueBehaviorKind nullValueReadBehaviorKind = this.ReadingResponse || edmProperty == null ? ODataNullValueBehaviorKind.Default : this.Model.NullValueReadBehaviorKind(edmProperty); // Read the property value object propertyValue = this.ReadNonEntityValueImplementation( edmProperty == null ? null : edmProperty.Type, /*duplicatePropertyNamesChecker*/ null, /*collectionValidator*/ null, nullValueReadBehaviorKind == ODataNullValueBehaviorKind.Default); if (nullValueReadBehaviorKind != ODataNullValueBehaviorKind.IgnoreValue || propertyValue != null) { duplicatePropertyNamesChecker.CheckForDuplicatePropertyNames(property); property.Value = propertyValue; properties.Add(property); } } } } } Debug.Assert(this.JsonReader.NodeType == JsonNodeType.EndObject, "After all the properties of a complex value are read the EndObject node is expected."); this.JsonReader.ReadEndObject(); complexValue.Properties = new ReadOnlyEnumerable<ODataProperty>(properties); this.JsonReader.AssertNotBuffering(); this.DecreaseRecursionDepth(); return complexValue; }
internal void WriteStreamProperty(ODataProperty streamProperty, IEdmEntityType owningType, DuplicatePropertyNamesChecker duplicatePropertyNamesChecker, ProjectedPropertiesAnnotation projectedProperties) { WriterValidationUtils.ValidatePropertyNotNull(streamProperty); string name = streamProperty.Name; if (!projectedProperties.ShouldSkipProperty(name)) { WriterValidationUtils.ValidateProperty(streamProperty); duplicatePropertyNamesChecker.CheckForDuplicatePropertyNames(streamProperty); IEdmProperty edmProperty = WriterValidationUtils.ValidatePropertyDefined(streamProperty.Name, owningType); WriterValidationUtils.ValidateStreamReferenceProperty(streamProperty, edmProperty, base.Version, base.WritingResponse); ODataStreamReferenceValue value2 = (ODataStreamReferenceValue) streamProperty.Value; if (((owningType != null) && owningType.IsOpen) && (edmProperty == null)) { ValidationUtils.ValidateOpenPropertyValue(streamProperty.Name, value2); } AtomStreamReferenceMetadata annotation = value2.GetAnnotation<AtomStreamReferenceMetadata>(); string contentType = value2.ContentType; string title = streamProperty.Name; Uri readLink = value2.ReadLink; if (readLink != null) { string relation = AtomUtils.ComputeStreamPropertyRelation(streamProperty, false); AtomLinkMetadata metadata = (annotation == null) ? null : annotation.SelfLink; AtomLinkMetadata linkMetadata = ODataAtomWriterMetadataUtils.MergeLinkMetadata(metadata, relation, readLink, title, contentType); this.atomEntryMetadataSerializer.WriteAtomLink(linkMetadata, null); } Uri editLink = value2.EditLink; if (editLink != null) { string str5 = AtomUtils.ComputeStreamPropertyRelation(streamProperty, true); AtomLinkMetadata metadata4 = (annotation == null) ? null : annotation.EditLink; AtomLinkMetadata metadata5 = ODataAtomWriterMetadataUtils.MergeLinkMetadata(metadata4, str5, editLink, title, contentType); this.atomEntryMetadataSerializer.WriteAtomLink(metadata5, value2.ETag); } } }
/// <summary> /// Returns an existing stream property value if it already exists in the list of OData properties otherwise creates a new /// ODataProperty for the stream property and returns the value of that property. /// </summary> /// <param name="entryState">The reader entry state for the entry being read.</param> /// <param name="streamPropertyName">The name of the stream property to return.</param> /// <returns>A new or an existing stream property value.</returns> private ODataStreamReferenceValue GetNewOrExistingStreamPropertyValue(IODataAtomReaderEntryState entryState, string streamPropertyName) { Debug.Assert(entryState != null, "entryState != null"); Debug.Assert(streamPropertyName != null, "streamPropertyName != null"); List<ODataProperty> properties = ReaderUtils.GetPropertiesList(entryState.Entry.Properties); // Property names are case sensitive, so compare in a case sensitive way. ODataProperty streamProperty = properties.FirstOrDefault(p => String.CompareOrdinal(p.Name, streamPropertyName) == 0); ODataStreamReferenceValue streamReferenceValue; if (streamProperty == null) { // The ValidateLinkPropertyDefined will fail if a stream property is not defined and the reader settings don't allow // reporting undeclared link properties. So if the method returns null, it means report the undeclared property anyway. IEdmProperty streamEdmProperty = ReaderValidationUtils.ValidateLinkPropertyDefined(streamPropertyName, entryState.EntityType, this.MessageReaderSettings); streamReferenceValue = new ODataStreamReferenceValue(); streamProperty = new ODataProperty { Name = streamPropertyName, Value = streamReferenceValue }; ReaderValidationUtils.ValidateStreamReferenceProperty(streamProperty, entryState.EntityType, streamEdmProperty); entryState.DuplicatePropertyNamesChecker.CheckForDuplicatePropertyNames(streamProperty); properties.Add(streamProperty); } else { streamReferenceValue = streamProperty.Value as ODataStreamReferenceValue; if (streamReferenceValue == null) { throw new ODataException(o.Strings.ODataAtomEntryAndFeedDeserializer_StreamPropertyDuplicatePropertyName(streamPropertyName)); } } return streamReferenceValue; }
/// <summary> /// Adds a property to the Properties collection which must have been previously populated by CreateNewEntry. /// </summary> /// <param name="properties">The value of the Properties property to add the property to.</param> /// <param name="propertyToAdd">The property to add.</param> internal static void AddPropertyToPropertiesList(IEnumerable <ODataProperty> properties, ODataProperty propertyToAdd) { DebugUtils.CheckNoExternalCallers(); Debug.Assert(propertyToAdd != null, "propertyToAdd != null"); ReaderUtils.GetPropertiesList(properties).Add(propertyToAdd); }
public void ApplyStructuralProperty_SetsProperty() { // Arrange var deserializer = new ODataEntityDeserializer(_productEdmType, _deserializerProvider); Product product = new Product(); ODataProperty property = new ODataProperty { Name = "ID", Value = 42 }; // Act deserializer.ApplyStructuralProperty(product, property, _readContext); // Assert Assert.Equal(42, product.ID); }
/// <summary> /// Asynchronously writes an <see cref="ODataProperty"/> as message payload. /// </summary> /// <param name="property">The property to write</param> /// <returns>A task representing the asynchronous operation of writing the property.</returns> /// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks> internal virtual Task WritePropertyAsync(ODataProperty property) { DebugUtils.CheckNoExternalCallers(); throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Property); }
internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource, ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext) { IEdmProperty edmProperty = resourceType.FindProperty(property.Name); string propertyName = property.Name; IEdmTypeReference propertyType = edmProperty != null ? edmProperty.Type : null; // open properties have null values bool isDelta = readContext.IsPatchMode && resourceType.IsEntity(); if (isDelta && resourceType.AsEntity().Key().Select(key => key.Name).Contains(propertyName)) { // we are patching a key property. if (readContext.PatchKeyMode == PatchKeyMode.Ignore) { return; } else if (readContext.PatchKeyMode == PatchKeyMode.Throw) { throw Error.InvalidOperation(SRResources.CannotPatchKeyProperty, propertyName, resourceType.FullName(), typeof(PatchKeyMode).Name, PatchKeyMode.Throw); } } EdmTypeKind propertyKind; object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext, out propertyKind); if (propertyKind == EdmTypeKind.Primitive) { value = ConvertPrimitiveValue(value, GetPropertyType(resource, propertyName, isDelta), propertyName, resource.GetType().FullName); } SetProperty(resource, propertyName, isDelta, value); }
public void WriteProperty(ODataProperty property) { this.VerifyCanWriteProperty(property); this.WriteToOutput(ODataPayloadKind.Property, null, context => context.WriteProperty(property)); }
/// <summary> /// Deserializes the given <paramref name="structuralProperty"/> into <paramref name="entityResource"/>. /// </summary> /// <param name="entityResource">The object into which the structural property should be read.</param> /// <param name="structuralProperty">The entry object containing the structural properties.</param> /// <param name="entityType">The entity type of the entity resource.</param> /// <param name="readContext">The deserializer context.</param> public virtual void ApplyStructuralProperty(object entityResource, ODataProperty structuralProperty, IEdmEntityTypeReference entityType, ODataDeserializerContext readContext) { if (entityResource == null) { throw Error.ArgumentNull("entityResource"); } if (structuralProperty == null) { throw Error.ArgumentNull("structuralProperty"); } DeserializationHelpers.ApplyProperty(structuralProperty, entityType, entityResource, DeserializerProvider, readContext); }
private ODataEntry CreateODataEntry(IGraph resultsGraph, string entryResource, string entryType) { var idPrefix = _map.GetResourceUriPrefix(entryType); if (!entryResource.StartsWith(idPrefix)) { // Now we have a problem throw new Exception("Cannot create entry feed for resource " + entryResource + ". Resource URI does not start with the expected prefix " + idPrefix); } var resourceId = entryResource.Substring(idPrefix.Length); var odataLink = _baseUri + _map.GetTypeSet(entryType) + "('" + resourceId + "')"; var entry = new ODataEntry { TypeName = entryType, ReadLink = new Uri(odataLink), Id = odataLink }; var subject = resultsGraph.CreateUriNode(UriFactory.Create(entryResource)); var properties = new List<ODataProperty>(); var identifierPropertyMapping = _map.GetIdentifierPropertyMapping(entryType); if (identifierPropertyMapping != null) { properties.Add(new ODataProperty{Name=identifierPropertyMapping.Name, Value=resourceId}); } foreach (var propertyMapping in _map.GetStructuralPropertyMappings(entryType)) { var predicate = resultsGraph.CreateUriNode(UriFactory.Create(propertyMapping.Uri)); var match = resultsGraph.GetTriplesWithSubjectPredicate(subject, predicate).FirstOrDefault(); if (match != null) { if (match.Object is LiteralNode) { var newProperty = new ODataProperty { Name = propertyMapping.Name, Value = GetValue(match.Object, propertyMapping.PropertyType) }; properties.Add(newProperty); } else if (match.Object is UriNode && propertyMapping.PropertyType.IsPrimitive()) { var newProperty = new ODataProperty() { Name = propertyMapping.Name, Value = GetValue(match.Object, propertyMapping.PropertyType) }; properties.Add(newProperty); } } } if (_writerSettings.Version == null || _writerSettings.Version >= ODataVersion.V3) { var associationLinks = new List<ODataAssociationLink>(); foreach (var assocMap in _map.GetAssociationPropertyMappings(entryType)) { var predicate = resultsGraph.CreateUriNode(UriFactory.Create(assocMap.Uri)); bool hasMatch = false; if (assocMap.IsInverse) { hasMatch = resultsGraph.GetTriplesWithPredicateObject(predicate, subject).Any(); } else { hasMatch = resultsGraph.GetTriplesWithSubjectPredicate(subject, predicate).Any(); } // TODO: May need to be more specific here to catch inverse/forward versions of the same // RDF property being mapped to two different OData properties (e.g. broader and narrower on a category) // This quick hack will work for now though: //bool hasMatch = resultsGraph.GetTriplesWithPredicate(resultsGraph.CreateUriNode(UriFactory.Create(assocMap.Uri))).Any(); if (hasMatch) { associationLinks.Add(new ODataAssociationLink { Name = assocMap.Name, Url = new Uri(odataLink + "/$links/" + assocMap.Name) }); } } entry.AssociationLinks = associationLinks; } entry.Properties = properties; return entry; }
public void CreateEntry_Calls_CreateStructuralProperty_ForEachSelectedStructuralProperty() { // Arrange SelectExpandNode selectExpandNode = new SelectExpandNode { SelectedStructuralProperties = { new Mock<IEdmStructuralProperty>().Object, new Mock<IEdmStructuralProperty>().Object } }; ODataProperty[] properties = new ODataProperty[] { new ODataProperty(), new ODataProperty() }; Mock<ODataEntityTypeSerializer> serializer = new Mock<ODataEntityTypeSerializer>(_serializer.EdmType, _serializerProvider); serializer.CallBase = true; serializer .Setup(s => s.CreateStructuralProperty(selectExpandNode.SelectedStructuralProperties.ElementAt(0), _entityInstanceContext)) .Returns(properties[0]) .Verifiable(); serializer .Setup(s => s.CreateStructuralProperty(selectExpandNode.SelectedStructuralProperties.ElementAt(1), _entityInstanceContext)) .Returns(properties[1]) .Verifiable(); // Act ODataEntry entry = serializer.Object.CreateEntry(selectExpandNode, _entityInstanceContext); // Assert serializer.Verify(); Assert.Equal(properties, entry.Properties); }
internal override void WriteProperty(ODataProperty property) { this.WritePropertyImplementation(property); this.Flush(); }
internal static void AddPropertyToPropertiesList(IEnumerable <ODataProperty> properties, ODataProperty propertyToAdd) { GetPropertiesList(properties).Add(propertyToAdd); }
internal override Task WritePropertyAsync(ODataProperty property) { return TaskUtils.GetTaskForSynchronousOperationReturningTask(delegate { this.WritePropertyImplementation(property); return this.FlushAsync(); }); }
private ODataComplexValue ReadComplexValueImplementation(IEdmComplexTypeReference complexValueTypeReference, string payloadTypeName, SerializationTypeNameAnnotation serializationTypeNameAnnotation, DuplicatePropertyNamesChecker duplicatePropertyNamesChecker) { this.IncreaseRecursionDepth(); base.JsonReader.ReadStartObject(); ODataComplexValue value2 = new ODataComplexValue { TypeName = (complexValueTypeReference != null) ? complexValueTypeReference.ODataFullName() : payloadTypeName }; if (serializationTypeNameAnnotation != null) { value2.SetAnnotation<SerializationTypeNameAnnotation>(serializationTypeNameAnnotation); } if (duplicatePropertyNamesChecker == null) { duplicatePropertyNamesChecker = base.CreateDuplicatePropertyNamesChecker(); } else { duplicatePropertyNamesChecker.Clear(); } List<ODataProperty> sourceList = new List<ODataProperty>(); bool flag = false; while (base.JsonReader.NodeType == JsonNodeType.Property) { string strB = base.JsonReader.ReadPropertyName(); if (string.CompareOrdinal("__metadata", strB) == 0) { if (flag) { throw new ODataException(Microsoft.Data.OData.Strings.ODataJsonPropertyAndValueDeserializer_MultipleMetadataPropertiesInComplexValue); } flag = true; base.JsonReader.SkipValue(); } else if (!ValidationUtils.IsValidPropertyName(strB)) { base.JsonReader.SkipValue(); } else { ODataProperty property = new ODataProperty { Name = strB }; IEdmProperty property2 = null; bool ignoreProperty = false; if (complexValueTypeReference != null) { property2 = ReaderValidationUtils.ValidateValuePropertyDefined(strB, complexValueTypeReference.ComplexDefinition(), base.MessageReaderSettings, out ignoreProperty); } if (ignoreProperty) { base.JsonReader.SkipValue(); continue; } ODataNullValueBehaviorKind kind = (base.ReadingResponse || (property2 == null)) ? ODataNullValueBehaviorKind.Default : base.Model.NullValueReadBehaviorKind(property2); object obj2 = this.ReadNonEntityValueImplementation((property2 == null) ? null : property2.Type, null, null, kind == ODataNullValueBehaviorKind.Default); if ((kind != ODataNullValueBehaviorKind.IgnoreValue) || (obj2 != null)) { duplicatePropertyNamesChecker.CheckForDuplicatePropertyNames(property); property.Value = obj2; sourceList.Add(property); } } } base.JsonReader.ReadEndObject(); value2.Properties = new ReadOnlyEnumerable<ODataProperty>(sourceList); this.DecreaseRecursionDepth(); return value2; }
private void WritePropertyImplementation(ODataProperty property) { new ODataJsonPropertyAndValueSerializer(this).WriteTopLevelProperty(property); }
public Task WritePropertyAsync(ODataProperty property) { this.VerifyCanWriteProperty(property); return(this.WriteToOutputAsync(ODataPayloadKind.Property, null, context => context.WritePropertyAsync(property))); }
internal IEnumerable<ODataProperty> PopulateProperties(ClientTypeAnnotation type, object resource, List<object> visitedComplexTypeObjects) { List<ODataProperty> list = new List<ODataProperty>(); foreach (ClientPropertyAnnotation annotation in from p in type.Properties() orderby p.PropertyName select p) { if (((!annotation.IsDictionary && (annotation != type.MediaDataMember)) && !annotation.IsStreamLinkProperty) && ((type.MediaDataMember == null) || (type.MediaDataMember.MimeTypeProperty != annotation))) { object propertyValue = annotation.GetValue(resource); if (annotation.IsKnownType) { ODataProperty item = new ODataProperty { Name = annotation.EdmProperty.Name, Value = GetPrimitiveValue(propertyValue, annotation.PropertyType) }; list.Add(item); } else if (annotation.IsPrimitiveOrComplexCollection) { ODataProperty property2 = new ODataProperty { Name = annotation.EdmProperty.Name, Value = this.CreateODataCollectionPropertyValue(annotation, propertyValue, visitedComplexTypeObjects) }; list.Add(property2); } else if (!annotation.IsEntityCollection && !ClientTypeUtil.TypeIsEntity(annotation.PropertyType, this.requestInfo.MaxProtocolVersion)) { ODataProperty property3 = new ODataProperty { Name = annotation.EdmProperty.Name, Value = this.CreateODataComplexPropertyValue(annotation, propertyValue, visitedComplexTypeObjects) }; list.Add(property3); } } } return list; }