/// <summary>
/// Creates an <see cref="EntitySetNode"/>
/// </summary>
/// <param name="entitySet">The entity set this node represents</param>
/// <exception cref="System.ArgumentNullException">Throws if the input entitySet is null.</exception>
public EntitySetNode(IEdmEntitySet entitySet)
{
ExceptionUtils.CheckArgumentNotNull(entitySet, "entitySet");
this.entitySet = entitySet;
this.entityType = new EdmEntityTypeReference(this.NavigationSource.EntityType(), false);
this.collectionTypeReference = EdmCoreModel.GetCollection(this.entityType);
}
public ODataDeltaFeedSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_customerSet = _model.EntityContainer.FindEntitySet("Customers");
_model.SetAnnotationValue(_customerSet.EntityType(), new ClrTypeAnnotation(typeof(Customer)));
_path = new ODataPath(new EntitySetPathSegment(_customerSet));
_customers = new[] {
new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 10,
},
new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 42,
}
};
_deltaFeedCustomers = new EdmChangedObjectCollection(_customerSet.EntityType());
EdmDeltaEntityObject newCustomer = new EdmDeltaEntityObject(_customerSet.EntityType());
newCustomer.TrySetPropertyValue("ID", 10);
newCustomer.TrySetPropertyValue("FirstName", "Foo");
_deltaFeedCustomers.Add(newCustomer);
_customersType = _model.GetEdmTypeReference(typeof(Customer[])).AsCollection();
_writeContext = new ODataSerializerContext() { NavigationSource = _customerSet, Model = _model, Path = _path };
}
public ODataFeedSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_customerSet = _model.FindDeclaredEntityContainer("Default.Container").FindEntitySet("Customers");
_customers = new[] {
new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 10,
},
new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 42,
}
};
_customersType = new EdmCollectionTypeReference(
new EdmCollectionType(
new EdmEntityTypeReference(
_customerSet.ElementType,
isNullable: false)),
isNullable: false);
_writeContext = new ODataSerializerContext() { EntitySet = _customerSet, Model = _model };
}
public ODataFeedSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_customerSet = _model.FindDeclaredEntityContainer("Default.Container").FindEntitySet("Customers");
_customers = new[] {
new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 10,
},
new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 42,
}
};
_customersType = new EdmCollectionTypeReference(
new EdmCollectionType(
new EdmEntityTypeReference(
_customerSet.ElementType,
isNullable: false)),
isNullable: false);
_urlHelper = new Mock<UrlHelper>(new HttpRequestMessage()).Object;
_writeContext = new ODataSerializerWriteContext(new ODataResponseContext()) { EntitySet = _customerSet, UrlHelper = _urlHelper };
}
public ODataFeedSerializer(IEdmCollectionTypeReference edmCollectionType, ODataSerializerProvider serializerProvider)
: base(edmCollectionType, ODataPayloadKind.Feed, serializerProvider)
{
_edmCollectionType = edmCollectionType;
if (!edmCollectionType.ElementType().IsEntity())
{
throw Error.NotSupported(SRResources.TypeMustBeEntityCollection, edmCollectionType.ElementType().FullName(), typeof(IEdmEntityType).Name);
}
}
public ODataCollectionSerializer(IEdmCollectionTypeReference edmCollectionType, ODataSerializerProvider serializerProvider)
: base(edmCollectionType, ODataPayloadKind.Collection, serializerProvider)
{
Contract.Assert(edmCollectionType != null);
_edmCollectionType = edmCollectionType;
IEdmTypeReference itemType = edmCollectionType.ElementType();
Contract.Assert(itemType != null);
_edmItemType = itemType;
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataFeedDeserializer"/> class.
/// </summary>
/// <param name="edmType">The entity collection type that this deserializer can read.</param>
/// <param name="deserializerProvider">The deserializer provider to use to read inner objects.</param>
public ODataFeedDeserializer(IEdmCollectionTypeReference edmType, ODataDeserializerProvider deserializerProvider)
: base(edmType, ODataPayloadKind.Feed, deserializerProvider)
{
CollectionType = edmType;
if (!edmType.ElementType().IsEntity())
{
throw Error.Argument("edmType", SRResources.TypeMustBeEntityCollection, edmType.ElementType().FullName(), typeof(IEdmEntityType).Name);
}
EntityType = CollectionType.ElementType().AsEntity();
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataCollectionSerializer"/> class.
/// </summary>
/// <param name="edmType">The edm collection type this serializer instance can serialize.</param>
/// <param name="serializerProvider">The serializer provider to use to serialize nested objects.</param>
public ODataCollectionSerializer(IEdmCollectionTypeReference edmType, ODataSerializerProvider serializerProvider)
: base(edmType, ODataPayloadKind.Collection, serializerProvider)
{
IEdmTypeReference itemType = edmType.ElementType();
if (itemType == null)
{
throw Error.Argument("edmType", SRResources.ItemTypeOfCollectionNull, edmType.FullName());
}
CollectionType = edmType;
ElementType = itemType;
}
internal static void SetCollectionProperty(object resource, string propertyName,
IEdmCollectionTypeReference edmPropertyType, object value, bool clearCollection)
{
if (value != null)
{
IEnumerable collection = value as IEnumerable;
Contract.Assert(collection != null,
"SetCollectionProperty is always passed the result of ODataFeedDeserializer or ODataCollectionDeserializer");
Type resourceType = resource.GetType();
Type propertyType = GetPropertyType(resource, propertyName);
Type elementType;
if (!propertyType.IsCollection(out elementType))
{
string message = Error.Format(SRResources.PropertyIsNotCollection, propertyType.FullName, propertyName, resourceType.FullName);
throw new SerializationException(message);
}
IEnumerable newCollection;
if (CanSetProperty(resource, propertyName) &&
CollectionDeserializationHelpers.TryCreateInstance(propertyType, edmPropertyType, elementType, out newCollection))
{
// settable collections
collection.AddToCollection(newCollection, elementType, resourceType, propertyName, propertyType);
if (propertyType.IsArray)
{
newCollection = CollectionDeserializationHelpers.ToArray(newCollection, elementType);
}
SetProperty(resource, propertyName, newCollection);
}
else
{
// get-only collections.
newCollection = GetProperty(resource, propertyName) as IEnumerable;
if (newCollection == null)
{
string message = Error.Format(SRResources.CannotAddToNullCollection, propertyName, resourceType.FullName);
throw new SerializationException(message);
}
if (clearCollection)
{
newCollection.Clear(propertyName, resourceType);
}
collection.AddToCollection(newCollection, elementType, resourceType, propertyName, propertyType);
}
}
}
public ODataFeedSerializer(IEdmCollectionTypeReference edmCollectionType, ODataSerializerProvider serializerProvider)
: base(edmCollectionType, ODataPayloadKind.Feed, serializerProvider)
{
Contract.Assert(edmCollectionType != null);
_edmCollectionType = edmCollectionType;
if (!edmCollectionType.ElementType().IsEntity())
{
throw Error.NotSupported(SRResources.TypeMustBeEntityCollection, edmCollectionType.ElementType().FullName(), typeof(IEdmEntityType).Name);
}
Contract.Assert(edmCollectionType.ElementType() != null);
Contract.Assert(edmCollectionType.ElementType().AsEntity() != null);
Contract.Assert(edmCollectionType.ElementType().AsEntity().Definition != null);
Contract.Assert(edmCollectionType.ElementType().AsEntity().Definition as IEdmEntityType != null);
_edmElementType = _edmCollectionType.ElementType().AsEntity().Definition as IEdmEntityType;
}
public ODataCollectionSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_customerSet = _model.FindDeclaredEntityContainer("Default.Container").FindEntitySet("Customers");
_edmIntType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false);
_customer = new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 10,
};
ODataSerializerProvider serializerProvider = new DefaultODataSerializerProvider();
_collectionType = new EdmCollectionTypeReference(new EdmCollectionType(_edmIntType), isNullable: false);
_serializer = new ODataCollectionSerializer(serializerProvider);
}
public static bool TryCreateInstance(Type collectionType, IEdmCollectionTypeReference edmCollectionType, Type elementType, out IEnumerable instance)
{
Contract.Assert(collectionType != null);
if (collectionType == typeof(EdmComplexObjectCollection))
{
instance = new EdmComplexObjectCollection(edmCollectionType);
return true;
}
else if (collectionType == typeof(EdmEntityObjectCollection))
{
instance = new EdmEntityObjectCollection(edmCollectionType);
return true;
}
else if (collectionType.IsGenericType)
{
Type genericDefinition = collectionType.GetGenericTypeDefinition();
if (genericDefinition == typeof(IEnumerable<>) ||
genericDefinition == typeof(ICollection<>) ||
genericDefinition == typeof(IList<>))
{
instance = Activator.CreateInstance(typeof(List<>).MakeGenericType(elementType)) as IEnumerable;
return true;
}
}
if (collectionType.IsArray)
{
// We dont know the size of the collection in advance. So, create a list and later call ToArray.
instance = Activator.CreateInstance(typeof(List<>).MakeGenericType(elementType)) as IEnumerable;
return true;
}
if (collectionType.GetConstructor(Type.EmptyTypes) != null && !collectionType.IsAbstract)
{
instance = Activator.CreateInstance(collectionType) as IEnumerable;
return true;
}
instance = null;
return false;
}
public ODataFeedSerializerTests()
{
_model = SerializationTestsHelpers.SimpleCustomerOrderModel();
_customerSet = _model.EntityContainer.FindEntitySet("Customers");
_model.SetAnnotationValue(_customerSet.EntityType(), new ClrTypeAnnotation(typeof(Customer)));
_customers = new[] {
new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 10,
},
new Customer()
{
FirstName = "Foo",
LastName = "Bar",
ID = 42,
}
};
_customersType = _model.GetEdmTypeReference(typeof(Customer[])).AsCollection();
_writeContext = new ODataSerializerContext() { NavigationSource = _customerSet, Model = _model };
}
/// <summary>
/// Reads a collection value.
/// </summary>
/// <param name="collectionValueTypeReference">The collection 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>
/// <returns>The value of the collection.</returns>
/// <remarks>
/// Pre-Condition: Fails if the current node is not a JsonNodeType.StartArray
/// Post-Condition: almost anything - the node after the collection value (after the EndArray)
/// </remarks>
private ODataCollectionValue ReadCollectionValue(
IEdmCollectionTypeReference collectionValueTypeReference,
string payloadTypeName,
SerializationTypeNameAnnotation serializationTypeNameAnnotation)
{
Debug.Assert(
collectionValueTypeReference == null || collectionValueTypeReference.IsNonEntityCollectionType(),
"If the metadata is specified it must denote a Collection for this method to work.");
this.IncreaseRecursionDepth();
// Read over the start array
this.JsonReader.ReadStartArray();
ODataCollectionValue collectionValue = new ODataCollectionValue();
collectionValue.TypeName = collectionValueTypeReference != null ? collectionValueTypeReference.FullName() : payloadTypeName;
if (serializationTypeNameAnnotation != null)
{
collectionValue.SetAnnotation(serializationTypeNameAnnotation);
}
if (collectionValueTypeReference != null)
{
collectionValue.SetAnnotation(new ODataTypeAnnotation(collectionValueTypeReference));
}
List<object> items = new List<object>();
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker = this.CreateDuplicatePropertyNamesChecker();
IEdmTypeReference itemType = null;
if (collectionValueTypeReference != null)
{
itemType = collectionValueTypeReference.CollectionDefinition().ElementType;
}
// NOTE: we do not support reading JSON Light without metadata right now so we always have an expected item type;
// The collection validator is always null.
CollectionWithoutExpectedTypeValidator collectionValidator = null;
while (this.JsonReader.NodeType != JsonNodeType.EndArray)
{
object itemValue = this.ReadNonEntityValueImplementation(
/*payloadTypeName*/ null,
itemType,
duplicatePropertyNamesChecker,
collectionValidator,
/*validateNullValue*/ true,
/*isTopLevelPropertyValue*/ false,
/*insideComplexValue*/ false,
/*propertyName*/ null);
// Validate the item (for example that it's not null)
ValidationUtils.ValidateCollectionItem(itemValue, itemType.IsNullable());
// Note that the ReadNonEntityValue already validated that the actual type of the value matches
// the expected type (the itemType).
items.Add(itemValue);
}
Debug.Assert(this.JsonReader.NodeType == JsonNodeType.EndArray, "The results value must end with an end array.");
this.JsonReader.ReadEndArray();
collectionValue.Items = new ReadOnlyEnumerable(items);
this.DecreaseRecursionDepth();
return collectionValue;
}
public CustomFeedSerializer(IEdmCollectionTypeReference edmType, ODataSerializerProvider serializerProvider)
: base(edmType, serializerProvider)
{
}
public CollectionFunctionCallNodeTests()
{
itemTypeReference = EdmCoreModel.Instance.GetString(true);
collectionTypeReference = new EdmCollectionType(itemTypeReference).ToTypeReference().AsCollection();
}
public CustomFeedSerializer(IEdmCollectionTypeReference edmType, ODataSerializerProvider serializerProvider)
: base(edmType, serializerProvider)
{
}
public ODataCollectionSerializerTests()
{
_edmIntType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false);
_collectionType = new EdmCollectionTypeReference(new EdmCollectionType(_edmIntType));
}
private bool TryBindIdentifier(string identifier, IEnumerable <FunctionParameterToken> arguments, QueryNode parent, BindingState state, out QueryNode boundFunction)
{
boundFunction = null;
IEdmType bindingType = null;
var singleValueParent = parent as SingleValueNode;
if (singleValueParent != null)
{
if (singleValueParent.TypeReference != null)
{
bindingType = singleValueParent.TypeReference.Definition;
}
}
else
{
var collectionValueParent = parent as CollectionNode;
if (collectionValueParent != null)
{
bindingType = collectionValueParent.CollectionType.Definition;
}
}
if (!UriEdmHelpers.IsBindingTypeValid(bindingType))
{
return(false);
}
// All functions should be fully qualified, if they aren't they they aren't functions.
// When using extension, there may be function call with unqualified name. So loose the restriction here.
if (identifier.IndexOf(".", StringComparison.Ordinal) == -1 && this.Resolver.GetType() == typeof(ODataUriResolver))
{
return(false);
}
IEdmOperation operation;
List <FunctionParameterToken> syntacticArguments = arguments == null ? new List <FunctionParameterToken>() : arguments.ToList();
if (!FunctionOverloadResolver.ResolveOperationFromList(identifier, syntacticArguments.Select(ar => ar.ParameterName).ToList(), bindingType, state.Model, out operation, this.Resolver))
{
// TODO: FunctionOverloadResolver.ResolveOperationFromList() looks up the function by parameter names, but it shouldn't ignore parameter types. (test case ParseFilter_AliasInFunction_PropertyAsValue_TypeMismatch should fail)
return(false);
}
if (singleValueParent != null && singleValueParent.TypeReference == null)
{
// if the parent exists, but has no type information, then we're in open type land, and we
// shouldn't go any farther.
throw new ODataException(ODataErrorStrings.FunctionCallBinder_CallingFunctionOnOpenProperty(identifier));
}
if (operation.IsAction())
{
return(false);
}
IEdmFunction function = (IEdmFunction)operation;
// TODO: $filter $orderby parameter expression which contains complex or collection should NOT be supported in this way
// but should be parsed into token tree, and binded to node tree: parsedParameters.Select(p => this.bindMethod(p));
ICollection <FunctionParameterToken> parsedParameters = HandleComplexOrCollectionParameterValueIfExists(state.Configuration.Model, function, syntacticArguments, state.Configuration.Resolver.EnableCaseInsensitive);
IEnumerable <QueryNode> boundArguments = parsedParameters.Select(p => this.bindMethod(p));
boundArguments = boundArguments.ToList(); // force enumerable to run : will immediately evaluate all this.bindMethod(p).
IEdmTypeReference returnType = function.ReturnType;
IEdmEntitySetBase returnSet = null;
var singleEntityNode = parent as SingleEntityNode;
if (singleEntityNode != null)
{
returnSet = function.GetTargetEntitySet(singleEntityNode.NavigationSource, state.Model);
}
string functionName = function.FullName();
if (returnType.IsEntity())
{
boundFunction = new SingleEntityFunctionCallNode(functionName, new[] { function }, boundArguments, (IEdmEntityTypeReference)returnType.Definition.ToTypeReference(), returnSet, parent);
}
else if (returnType.IsEntityCollection())
{
IEdmCollectionTypeReference collectionTypeReference = (IEdmCollectionTypeReference)returnType;
boundFunction = new EntityCollectionFunctionCallNode(functionName, new[] { function }, boundArguments, collectionTypeReference, returnSet, parent);
}
else if (returnType.IsCollection())
{
IEdmCollectionTypeReference collectionTypeReference = (IEdmCollectionTypeReference)returnType;
boundFunction = new CollectionFunctionCallNode(functionName, new[] { function }, boundArguments, collectionTypeReference, parent);
}
else
{
boundFunction = new SingleValueFunctionCallNode(functionName, new[] { function }, boundArguments, returnType, parent);
}
return(true);
}
/// <summary>
/// Creates a CollectionFunctionCallNode to represent a operation call that returns a collection
/// </summary>
/// <param name="name">The name of this operation.</param>
/// <param name="functions">the list of functions that this node should represent.</param>
/// <param name="parameters">the list of already bound parameters to this operation</param>
/// <param name="returnedCollectionType">the type of the collection returned by this operation.</param>
/// <param name="source">The parent of this CollectionFunctionCallNode.</param>
/// <exception cref="System.ArgumentNullException">Throws if the provided name is null.</exception>
/// <exception cref="System.ArgumentNullException">Throws if the provided collection type reference is null.</exception>
/// <exception cref="System.ArgumentException">Throws if the element type of the provided collection type reference is not a primitive or complex type.</exception>
public CollectionFunctionCallNode(string name, IEnumerable <IEdmFunction> functions, IEnumerable <QueryNode> parameters, IEdmCollectionTypeReference returnedCollectionType, QueryNode source)
{
ExceptionUtils.CheckArgumentNotNull(name, "name");
ExceptionUtils.CheckArgumentNotNull(returnedCollectionType, "returnedCollectionType");
this.name = name;
this.functions = new ReadOnlyCollection <IEdmFunction>(functions == null ? new List <IEdmFunction>() : functions.ToList());
this.parameters = new ReadOnlyCollection <QueryNode>(parameters == null ? new List <QueryNode>() : parameters.ToList());
this.returnedCollectionType = returnedCollectionType;
this.itemType = returnedCollectionType.ElementType();
if (!this.itemType.IsPrimitive() && !this.itemType.IsComplex() && !this.itemType.IsEnum())
{
throw new ArgumentException(ODataErrorStrings.Nodes_CollectionFunctionCallNode_ItemTypeMustBePrimitiveOrComplexOrEnum);
}
this.source = source;
}
/// <summary>
/// Create the <see cref="ODataFeed"/> to be written for the given feed instance.
/// </summary>
/// <param name="feedInstance">The instance representing the feed being written.</param>
/// <param name="feedType">The EDM type of the feed being written.</param>
/// <param name="writeContext">The serializer context.</param>
/// <returns>The created <see cref="ODataFeed"/> object.</returns>
public virtual ODataFeed CreateODataFeed(IEnumerable feedInstance, IEdmCollectionTypeReference feedType,
ODataSerializerContext writeContext)
{
ODataFeed feed = new ODataFeed();
if (writeContext.EntitySet != null)
{
IEdmModel model = writeContext.Model;
EntitySetLinkBuilderAnnotation linkBuilder = model.GetEntitySetLinkBuilder(writeContext.EntitySet);
FeedContext feedContext = new FeedContext
{
Request = writeContext.Request,
RequestContext = writeContext.RequestContext,
EntitySet = writeContext.EntitySet,
Url = writeContext.Url,
FeedInstance = feedInstance
};
Uri feedSelfLink = linkBuilder.BuildFeedSelfLink(feedContext);
if (feedSelfLink != null)
{
feed.SetAnnotation(new AtomFeedMetadata()
{
SelfLink = new AtomLinkMetadata()
{
Relation = "self", Href = feedSelfLink
}
});
}
}
feed.Id = new Uri("http://schemas.datacontract.org/2004/07/" + feedType.FullName());
if (writeContext.ExpandedEntity == null)
{
// If we have more OData format specific information apply it now, only if we are the root feed.
PageResult odataFeedAnnotations = feedInstance as PageResult;
if (odataFeedAnnotations != null)
{
feed.Count = odataFeedAnnotations.Count;
feed.NextPageLink = odataFeedAnnotations.NextPageLink;
}
else if (writeContext.Request != null)
{
feed.NextPageLink = writeContext.Request.ODataProperties().NextLink;
long?countValue = writeContext.Request.ODataProperties().TotalCount;
if (countValue.HasValue)
{
feed.Count = countValue.Value;
}
}
}
else
{
// nested feed
ITruncatedCollection truncatedCollection = feedInstance as ITruncatedCollection;
if (truncatedCollection != null && truncatedCollection.IsTruncated)
{
feed.NextPageLink = GetNestedNextPageLink(writeContext, truncatedCollection.PageSize);
}
}
return(feed);
}
/// <summary>
/// Create the <see cref="ODataFeed"/> to be written for the given feed instance.
/// </summary>
/// <param name="feedInstance">The instance representing the feed being written.</param>
/// <param name="feedType">The EDM type of the feed being written.</param>
/// <param name="writeContext">The serializer context.</param>
/// <returns>The created <see cref="ODataFeed"/> object.</returns>
public virtual ODataFeed CreateODataFeed(IEnumerable feedInstance, IEdmCollectionTypeReference feedType,
ODataSerializerContext writeContext)
{
ODataFeed feed = new ODataFeed();
if (writeContext.NavigationSource != null)
{
FeedContext feedContext = new FeedContext
{
Request = writeContext.Request,
RequestContext = writeContext.RequestContext,
EntitySetBase = writeContext.NavigationSource as IEdmEntitySetBase,
Url = writeContext.Url,
FeedInstance = feedInstance
};
IEdmEntityType entityType = GetEntityType(feedType).Definition as IEdmEntityType;
var operations = writeContext.Model.GetAvailableOperationsBoundToCollection(entityType);
var odataOperations = CreateODataOperations(operations, feedContext, writeContext);
foreach (var odataOperation in odataOperations)
{
ODataAction action = odataOperation as ODataAction;
if (action != null)
{
feed.AddAction(action);
}
else
{
feed.AddFunction((ODataFunction)odataOperation);
}
}
}
if (writeContext.ExpandedEntity == null)
{
// If we have more OData format specific information apply it now, only if we are the root feed.
PageResult odataFeedAnnotations = feedInstance as PageResult;
if (odataFeedAnnotations != null)
{
feed.Count = odataFeedAnnotations.Count;
feed.NextPageLink = odataFeedAnnotations.NextPageLink;
}
else if (writeContext.Request != null)
{
feed.NextPageLink = writeContext.Request.ODataProperties().NextLink;
feed.DeltaLink = writeContext.Request.ODataProperties().DeltaLink;
long?countValue = writeContext.Request.ODataProperties().TotalCount;
if (countValue.HasValue)
{
feed.Count = countValue.Value;
}
}
}
else
{
// nested feed
ITruncatedCollection truncatedCollection = feedInstance as ITruncatedCollection;
if (truncatedCollection != null && truncatedCollection.IsTruncated)
{
feed.NextPageLink = GetNestedNextPageLink(writeContext, truncatedCollection.PageSize);
}
ICountOptionCollection countOptionCollection = feedInstance as ICountOptionCollection;
if (countOptionCollection != null && countOptionCollection.TotalCount != null)
{
feed.Count = countOptionCollection.TotalCount;
}
}
return(feed);
}
/// <summary>
/// Create the <see cref="ODataDeltaResourceSet"/> to be written for the given feed instance.
/// </summary>
/// <param name="feedInstance">The instance representing the feed being written.</param>
/// <param name="feedType">The EDM type of the feed being written.</param>
/// <param name="writeContext">The serializer context.</param>
/// <returns>The created <see cref="ODataDeltaResourceSet"/> object.</returns>
public virtual ODataDeltaResourceSet CreateODataDeltaResourceSet(IEnumerable feedInstance, IEdmCollectionTypeReference feedType,
ODataSerializerContext writeContext)
{
if (writeContext == null)
{
throw Error.ArgumentNull(nameof(writeContext));
}
ODataDeltaResourceSet feed = new ODataDeltaResourceSet();
if (writeContext.ExpandedResource == null)
{
// If we have more OData format specific information apply it now, only if we are the root feed.
PageResult odataFeedAnnotations = feedInstance as PageResult;
if (odataFeedAnnotations != null)
{
feed.Count = odataFeedAnnotations.Count;
feed.NextPageLink = odataFeedAnnotations.NextPageLink;
}
else if (writeContext.Request != null)
{
IODataFeature odataFeature = writeContext.Request.ODataFeature();
feed.NextPageLink = odataFeature.NextLink;
feed.DeltaLink = odataFeature.DeltaLink;
long?countValue = odataFeature.TotalCount;
if (countValue.HasValue)
{
feed.Count = countValue.Value;
}
}
}
return(feed);
}
protected virtual void ProcessCollectionTypeReference(IEdmCollectionTypeReference reference)
{
this.ProcessTypeReference(reference);
this.ProcessCollectionType(reference.CollectionDefinition());
}
private bool TryBindIdentifier(string identifier, IEnumerable <FunctionParameterToken> arguments, QueryNode parent, BindingState state, out QueryNode boundFunction)
{
boundFunction = null;
IEdmType bindingType = null;
var singleValueParent = parent as SingleValueNode;
if (singleValueParent != null)
{
if (singleValueParent.TypeReference != null)
{
bindingType = singleValueParent.TypeReference.Definition;
}
}
else
{
var collectionValueParent = parent as CollectionNode;
if (collectionValueParent != null)
{
bindingType = collectionValueParent.CollectionType.Definition;
}
}
if (!UriEdmHelpers.IsBindingTypeValid(bindingType))
{
return(false);
}
IEdmFunctionImport functionImport;
List <FunctionParameterToken> syntacticArguments = arguments == null ? new List <FunctionParameterToken>() : arguments.ToList();
if (!FunctionOverloadResolver.ResolveFunctionsFromList(identifier, syntacticArguments.Select(ar => ar.ParameterName).ToList(), bindingType, state.Model, out functionImport))
{
return(false);
}
if (singleValueParent != null && singleValueParent.TypeReference == null)
{
// if the parent exists, but has no type information, then we're in open type land, and we
// shouldn't go any farther.
throw new ODataException(ODataErrorStrings.FunctionCallBinder_CallingFunctionOnOpenProperty(identifier));
}
if (functionImport.IsSideEffecting)
{
return(false);
}
ICollection <FunctionParameterToken> parsedParameters;
if (!FunctionParameterParser.TryParseFunctionParameters(syntacticArguments, state.Configuration, functionImport, out parsedParameters))
{
return(false);
}
IEnumerable <QueryNode> boundArguments = parsedParameters.Select(p => this.bindMethod(p));
IEdmTypeReference returnType = functionImport.ReturnType;
IEdmEntitySet returnSet = null;
var singleEntityNode = parent as SingleEntityNode;
if (singleEntityNode != null)
{
returnSet = functionImport.GetTargetEntitySet(singleEntityNode.EntitySet, state.Model);
}
if (returnType.IsEntity())
{
boundFunction = new SingleEntityFunctionCallNode(identifier, new[] { functionImport }, boundArguments, (IEdmEntityTypeReference)returnType.Definition.ToTypeReference(), returnSet, parent);
}
else if (returnType.IsEntityCollection())
{
IEdmCollectionTypeReference collectionTypeReference = (IEdmCollectionTypeReference)returnType;
boundFunction = new EntityCollectionFunctionCallNode(identifier, new[] { functionImport }, boundArguments, collectionTypeReference, returnSet, parent);
}
else if (returnType.IsCollection())
{
IEdmCollectionTypeReference collectionTypeReference = (IEdmCollectionTypeReference)returnType;
boundFunction = new CollectionFunctionCallNode(identifier, new[] { functionImport }, boundArguments, collectionTypeReference, parent);
}
else
{
boundFunction = new SingleValueFunctionCallNode(identifier, new[] { functionImport }, boundArguments, returnType, parent);
}
return(true);
}
/// <summary>
/// Walk the JSON body and format top level instance annotations (more complex annotations are unsupported)
/// and change types that would be deserialized incorrectly by OData V4 formatters to types that will be deserialized correctly.
/// </summary>
/// <param name="node">JToken root or child of JSON request body</param>
/// <param name="edmType">Corresponding edm type</param>
public static void WalkTranslate(this JToken node, IEdmTypeReference edmType)
{
if (node == null)
{
return;
}
if (node.Type == JTokenType.Object)
{
JObject obj = (JObject)node;
IEdmStructuredTypeReference structuredType = edmType.AsStructured();
foreach (JProperty child in node.Children <JProperty>().ToList())
{
IEdmProperty property = structuredType.FindProperty(child.Name);
// Convert instance annotations to V3 format
if (child.Name == "odata.type")
{
obj["@odata.type"] = "#" + obj["odata.type"];
obj.Remove("odata.type");
}
else if (child.Name.Contains("@odata"))
{
obj[child.Name] = "#" + obj[child.Name];
}
else if (property != null &&
property.Type.TypeKind() == EdmTypeKind.Primitive &&
((IEdmPrimitiveType)property.Type.Definition).PrimitiveKind == EdmPrimitiveTypeKind.Int64)
{
// Convert long type to unquoted when deserializing
obj[child.Name] = Convert.ToInt64(obj[child.Name]);
}
else if (property != null)
{
// If type is not IEdmStructuredTypeReference or IEdmCollectionTypeReference, then won't need to convert.
if (property.Type.TypeKind() == EdmTypeKind.Collection)
{
// Translate collection types
WalkTranslate(child.Value, property.Type as IEdmCollectionTypeReference);
}
else
{
// Continue to translate deeper nested entities
WalkTranslate(child.Value, property.Type as IEdmStructuredTypeReference);
}
}
}
}
else if (node.Type == JTokenType.Array)
{
JArray items = (JArray)node;
IEdmCollectionTypeReference collectionType = (IEdmCollectionTypeReference)edmType;
IEdmTypeReference elementType = collectionType.Definition.AsElementType().ToEdmTypeReference();
if (elementType != null)
{
for (int i = 0; i < items.Count; i++)
{
if (elementType.IsComplex() || elementType.IsEntity() || elementType.IsCollection())
{
// Continue to translate deeper nested entities
items[i].WalkTranslate(elementType);
}
else
{
// Do translation of V3 formatted types to V4 formatted types at the collection level
if (items[i].Type == JTokenType.String && elementType.IsInt64())
{
items[i] = new JValue(Convert.ToInt64(items[i].ToString()));
}
}
}
}
}
}
/// <summary>
/// Read a collection from the reader.
/// </summary>
/// <param name="collectionTypeReference">The type of the collection to read (or null if no type is available).</param>
/// <param name="payloadTypeName">The name of the collection type specified in the payload.</param>
/// <param name="serializationTypeNameAnnotation">The serialization type name for the collection value (possibly null).</param>
/// <returns>The value read from the payload.</returns>
/// <remarks>
/// Pre-Condition: XmlNodeType.Element - the element to read the value for.
/// XmlNodeType.Attribute - an attribute on the element to read the value for.
/// Post-Condition: XmlNodeType.Element - the element was empty.
/// XmlNodeType.EndElement - the element had some value.
///
/// Note that this method will not read null values, those should be handled by the caller already.
/// </remarks>
private ODataCollectionValue ReadCollectionValue(
IEdmCollectionTypeReference collectionTypeReference,
string payloadTypeName,
SerializationTypeNameAnnotation serializationTypeNameAnnotation)
{
this.AssertXmlCondition(XmlNodeType.Element, XmlNodeType.Attribute);
Debug.Assert(
collectionTypeReference == null || collectionTypeReference.IsNonEntityCollectionType(),
"If the metadata is specified it must denote a collection for this method to work.");
this.IncreaseRecursionDepth();
ODataCollectionValue collectionValue = new ODataCollectionValue();
// If we have a metadata type for the collection, use that type name
// otherwise use the type name from the payload (if there was any).
collectionValue.TypeName = collectionTypeReference == null ? payloadTypeName : collectionTypeReference.ODataFullName();
if (serializationTypeNameAnnotation != null)
{
collectionValue.SetAnnotation(serializationTypeNameAnnotation);
}
// Move to the element (so that if we were on an attribute we can test the element for being empty)
this.XmlReader.MoveToElement();
List<object> items = new List<object>();
// Empty collections are valid - they have no items
if (!this.XmlReader.IsEmptyElement)
{
// Read over the collection element to its first child node (or end-element)
this.XmlReader.ReadStartElement();
// If we don't have metadata (that is collectionType is null) we parse the type name
// and extract the item type name from it. Then we create a CollectionWithoutExpectedTypeValidator
// instance and use it to ensure that all item types read for the collection value are consistent with
// the item type derived from the collection value's type name.
// Note that if an item does not specify a type name but the collection value does, the item will be
// assigned the item type name computed from the collection value's type.
// Note that JSON doesn't have this problem since in JSON we always have metadata and thus the collectionType
// is never null by the time we get to a similar place in the code.
IEdmTypeReference itemTypeReference = collectionTypeReference == null ? null : collectionTypeReference.ElementType();
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker = this.CreateDuplicatePropertyNamesChecker();
CollectionWithoutExpectedTypeValidator collectionValidator = null;
if (collectionTypeReference == null)
{
// Parse the type name from the payload (if any), extract the item type name and construct a collection validator
string itemTypeName = payloadTypeName == null ? null : EdmLibraryExtensions.GetCollectionItemTypeName(payloadTypeName);
collectionValidator = new CollectionWithoutExpectedTypeValidator(itemTypeName);
}
do
{
switch (this.XmlReader.NodeType)
{
case XmlNodeType.Element:
if (this.XmlReader.NamespaceEquals(this.XmlReader.ODataMetadataNamespace))
{
if (!this.XmlReader.LocalNameEquals(this.ODataCollectionItemElementName))
{
this.XmlReader.Skip();
}
else
{
object itemValue = this.ReadNonEntityValueImplementation(
itemTypeReference,
duplicatePropertyNamesChecker,
collectionValidator,
/*validateNullValue*/ true,
/*propertyName*/ null);
// read over the end tag of the element or the start tag if the element was empty.
this.XmlReader.Read();
// Validate the item (for example that it's not null)
ValidationUtils.ValidateCollectionItem(itemValue, itemTypeReference.IsNullable());
// Note that the ReadNonEntityValue already validated that the actual type of the value matches
// the expected type (the itemType).
items.Add(itemValue);
}
}
else if (this.XmlReader.NamespaceEquals(this.XmlReader.ODataNamespace))
{
throw new ODataException(ODataErrorStrings.ODataAtomPropertyAndValueDeserializer_InvalidCollectionElement(this.XmlReader.LocalName, this.XmlReader.ODataMetadataNamespace));
}
else
{
this.XmlReader.Skip();
}
break;
case XmlNodeType.EndElement:
// End of the collection.
break;
default:
// Non-element so for example a text node, just ignore
this.XmlReader.Skip();
break;
}
}
while (this.XmlReader.NodeType != XmlNodeType.EndElement);
}
collectionValue.Items = new ReadOnlyEnumerable(items);
this.AssertXmlCondition(true, XmlNodeType.EndElement);
Debug.Assert(collectionValue != null, "The method should never return null since it doesn't handle null values.");
this.DecreaseRecursionDepth();
return collectionValue;
}
/// <summary>
/// Create a CollectionConstantNode
/// </summary>
/// <param name="objectCollection">A collection of objects.</param>
/// <param name="literalText">The literal text for this node's value, formatted according to the OData URI literal formatting rules.</param>
/// <param name="collectionType">The reference to the collection type.</param>
/// <exception cref="System.ArgumentNullException">Throws if the input literalText is null.</exception>
public CollectionConstantNode(IEnumerable <object> objectCollection, string literalText, IEdmCollectionTypeReference collectionType)
{
ExceptionUtils.CheckArgumentNotNull(objectCollection, "objectCollection");
ExceptionUtils.CheckArgumentStringNotNullOrEmpty(literalText, "literalText");
ExceptionUtils.CheckArgumentNotNull(collectionType, "collectionType");
this.LiteralText = literalText;
EdmCollectionType edmCollectionType = collectionType.Definition as EdmCollectionType;
this.itemType = edmCollectionType.ElementType;
this.collectionTypeReference = collectionType;
foreach (object item in objectCollection)
{
this.collection.Add(new ConstantNode(item, item != null ? item.ToString() : "null", this.itemType));
}
}
public override object Read(ODataMessageReader messageReader, Type type, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
IEdmAction action = GetAction(readContext);
Contract.Assert(action != null);
// Create the correct resource type;
Dictionary <string, object> payload;
if (type == typeof(ODataActionParameters))
{
payload = new ODataActionParameters();
}
else
{
payload = new ODataUntypedActionParameters(action);
}
ODataParameterReader reader = messageReader.CreateODataParameterReader(action);
while (reader.Read())
{
string parameterName = null;
IEdmOperationParameter parameter = null;
switch (reader.State)
{
case ODataParameterReaderState.Value:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
if (parameter.Type.IsPrimitive())
{
payload[parameterName] = reader.Value;
}
else
{
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(parameter.Type);
payload[parameterName] = deserializer.ReadInline(reader.Value, parameter.Type, readContext);
}
break;
case ODataParameterReaderState.Collection:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmCollectionTypeReference collectionType = parameter.Type as IEdmCollectionTypeReference;
Contract.Assert(collectionType != null);
ODataCollectionValue value = ODataCollectionDeserializer.ReadCollection(reader.CreateCollectionReader());
ODataCollectionDeserializer collectionDeserializer = (ODataCollectionDeserializer)DeserializerProvider.GetEdmTypeDeserializer(collectionType);
payload[parameterName] = collectionDeserializer.ReadInline(value, collectionType, readContext);
break;
case ODataParameterReaderState.Entry:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmEntityTypeReference entityTypeReference = parameter.Type as IEdmEntityTypeReference;
Contract.Assert(entityTypeReference != null);
ODataReader entryReader = reader.CreateEntryReader();
object item = ODataEntityDeserializer.ReadEntryOrFeed(entryReader);
ODataEntityDeserializer entityDeserializer = (ODataEntityDeserializer)DeserializerProvider.GetEdmTypeDeserializer(entityTypeReference);
payload[parameterName] = entityDeserializer.ReadInline(item, entityTypeReference, readContext);
break;
case ODataParameterReaderState.Feed:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmCollectionTypeReference feedType = parameter.Type as IEdmCollectionTypeReference;
Contract.Assert(feedType != null);
ODataReader feedReader = reader.CreateFeedReader();
object feed = ODataEntityDeserializer.ReadEntryOrFeed(feedReader);
ODataFeedDeserializer feedDeserializer = (ODataFeedDeserializer)DeserializerProvider.GetEdmTypeDeserializer(feedType);
object result = feedDeserializer.ReadInline(feed, feedType, readContext);
IEdmTypeReference elementTypeReference = feedType.ElementType();
Contract.Assert(elementTypeReference.IsEntity());
IEnumerable enumerable = result as IEnumerable;
if (enumerable != null)
{
if (readContext.IsUntyped)
{
EdmEntityObjectCollection entityCollection = new EdmEntityObjectCollection(feedType);
foreach (EdmEntityObject entityObject in enumerable)
{
entityCollection.Add(entityObject);
}
payload[parameterName] = entityCollection;
}
else
{
Type elementClrType = EdmLibHelpers.GetClrType(elementTypeReference, readContext.Model);
IEnumerable castedResult =
_castMethodInfo.MakeGenericMethod(elementClrType)
.Invoke(null, new[] { result }) as IEnumerable;
payload[parameterName] = castedResult;
}
}
break;
}
}
return(payload);
}
public ODataCollectionDeserializer(IEdmCollectionTypeReference edmCollectionType, ODataDeserializerProvider deserializerProvider)
: base(edmCollectionType, ODataPayloadKind.Collection, deserializerProvider)
{
_edmCollectionType = edmCollectionType;
}
/// <summary>
/// Reads the primitive, complex or collection value.
/// </summary>
/// <param name="expectedTypeReference">The expected type reference of the value.</param>
/// <param name="duplicatePropertyNamesChecker">The duplicate property names checker to use (cached), or null if new one should be created.</param>
/// <param name="collectionValidator">The collection validator instance if no expected item type has been specified; otherwise null.</param>
/// <param name="validateNullValue">true to validate a null value (i.e., throw if a null value is being written for a non-nullable property); otherwise false.</param>
/// <param name="propertyName">The name of the property whose value is being read, if applicable (used for error reporting).</param>
/// <returns>The value read (null, primitive CLR value, ODataComplexValue or ODataCollectionValue).</returns>
/// <remarks>
/// Pre-Condition: XmlNodeType.Element - The XML element containing the value to read (also the attributes will be read from it)
/// Post-Condition: XmlNodeType.EndElement - The end tag of the element.
/// XmlNodeType.Element - The empty element node.
/// </remarks>
private object ReadNonEntityValueImplementation(IEdmTypeReference expectedTypeReference, DuplicatePropertyNamesChecker duplicatePropertyNamesChecker, CollectionWithoutExpectedTypeValidator collectionValidator, bool validateNullValue, string propertyName)
{
this.AssertXmlCondition(XmlNodeType.Element);
Debug.Assert(
expectedTypeReference == null || !expectedTypeReference.IsODataEntityTypeKind(),
"Only primitive, complex or collection types can be read by this method.");
Debug.Assert(
expectedTypeReference == null || collectionValidator == null,
"If an expected value type reference is specified, no collection validator must be provided.");
this.XmlReader.AssertNotBuffering();
// Read the attributes looking for m:type and m:null
string payloadTypeName;
bool isNull;
this.ReadNonEntityValueAttributes(out payloadTypeName, out isNull);
object result;
if (isNull)
{
result = this.ReadNullValue(expectedTypeReference, validateNullValue, propertyName);
}
else
{
// If we could derive the item type name from the collection's type name and no type name was specified in the payload
// fill it in now.
EdmTypeKind payloadTypeKind;
bool derivedItemTypeNameFromCollectionTypeName = false;
if (collectionValidator != null && payloadTypeName == null)
{
payloadTypeName = collectionValidator.ItemTypeNameFromCollection;
payloadTypeKind = collectionValidator.ItemTypeKindFromCollection;
derivedItemTypeNameFromCollectionTypeName = payloadTypeKind != EdmTypeKind.None;
}
// Resolve the payload type name and compute the target type kind and target type reference.
SerializationTypeNameAnnotation serializationTypeNameAnnotation;
EdmTypeKind targetTypeKind;
IEdmTypeReference targetTypeReference = ReaderValidationUtils.ResolvePayloadTypeNameAndComputeTargetType(
EdmTypeKind.None,
/*defaultPrimitivePayloadType*/ edmStringType,
expectedTypeReference,
payloadTypeName,
this.Model,
this.MessageReaderSettings,
this.Version,
this.GetNonEntityValueKind,
out targetTypeKind,
out serializationTypeNameAnnotation);
if (derivedItemTypeNameFromCollectionTypeName)
{
Debug.Assert(
serializationTypeNameAnnotation == null,
"If we derived the item type name from the collection type name we must not have created a serialization type name annotation.");
serializationTypeNameAnnotation = new SerializationTypeNameAnnotation {
TypeName = null
};
}
// If we have no expected type make sure the collection items are of the same kind and specify the same name.
if (collectionValidator != null)
{
Debug.Assert(expectedTypeReference == null, "If a collection validator is specified there must not be an expected value type reference.");
collectionValidator.ValidateCollectionItem(payloadTypeName, targetTypeKind);
}
switch (targetTypeKind)
{
case EdmTypeKind.Enum:
Debug.Assert(targetTypeReference != null && targetTypeReference.IsODataEnumTypeKind(), "Expected an OData Enum type.");
result = this.ReadEnumValue(targetTypeReference.AsEnum());
break;
case EdmTypeKind.Primitive:
Debug.Assert(targetTypeReference != null && targetTypeReference.IsODataPrimitiveTypeKind(), "Expected an OData primitive type.");
result = this.ReadPrimitiveValue(targetTypeReference.AsPrimitive());
break;
case EdmTypeKind.Complex:
Debug.Assert(targetTypeReference == null || targetTypeReference.IsComplex(), "Expected a complex type.");
result = this.ReadComplexValue(
targetTypeReference == null ? null : targetTypeReference.AsComplex(),
payloadTypeName,
serializationTypeNameAnnotation,
duplicatePropertyNamesChecker);
break;
case EdmTypeKind.Collection:
IEdmCollectionTypeReference collectionTypeReference = ValidationUtils.ValidateCollectionType(targetTypeReference);
result = this.ReadCollectionValue(
collectionTypeReference,
payloadTypeName,
serializationTypeNameAnnotation);
break;
default:
throw new ODataException(ODataErrorStrings.General_InternalError(InternalErrorCodes.ODataAtomPropertyAndValueDeserializer_ReadNonEntityValue));
}
}
this.AssertXmlCondition(true, XmlNodeType.EndElement);
this.XmlReader.AssertNotBuffering();
return(result);
}
/// <summary>
/// Creates an CollectionResourceFunctionCallNode to represent a operation call that returns a collection of entities.
/// </summary>
/// <param name="name">The name of this operation.</param>
/// <param name="functions">the list of functions that this node should represent.</param>
/// <param name="parameters">the list of parameters to this operation</param>
/// <param name="returnedCollectionTypeReference">the type the entity collection returned by this operation. The element type must be an entity type.</param>
/// <param name="navigationSource">the set containing entities returned by this operation</param>
/// <param name="source">the semantically bound parent of this CollectionResourceFunctionCallNode.</param>
/// <exception cref="System.ArgumentNullException">Throws if the provided name is null.</exception>
/// <exception cref="System.ArgumentNullException">Throws if the provided collection type reference is null.</exception>
/// <exception cref="System.ArgumentException">Throws if the element type of the provided collection type reference is not an entity type.</exception>
/// <exception cref="System.ArgumentNullException">Throws if the input operation imports is null</exception>
public CollectionResourceFunctionCallNode(string name, IEnumerable <IEdmFunction> functions, IEnumerable <QueryNode> parameters, IEdmCollectionTypeReference returnedCollectionTypeReference, IEdmEntitySetBase navigationSource, QueryNode source)
{
ExceptionUtils.CheckArgumentNotNull(name, "name");
ExceptionUtils.CheckArgumentNotNull(returnedCollectionTypeReference, "returnedCollectionTypeReference");
this.name = name;
this.functions = new ReadOnlyCollection <IEdmFunction>(functions == null ? new List <IEdmFunction>() : functions.ToList());
this.parameters = new ReadOnlyCollection <QueryNode>(parameters == null ? new List <QueryNode>() : parameters.ToList());
this.returnedCollectionTypeReference = returnedCollectionTypeReference;
this.navigationSource = navigationSource;
this.structuredTypeReference = returnedCollectionTypeReference.ElementType().AsStructuredOrNull();
if (this.structuredTypeReference == null)
{
// TODO: Update error message #644
throw new ArgumentException(ODataErrorStrings.Nodes_EntityCollectionFunctionCallNode_ItemTypeMustBeAnEntity);
}
this.source = source;
}
/// <summary>
/// Create the <see cref="ODataDeltaResourceSet"/> to be written for the given feed instance.
/// </summary>
/// <param name="feedInstance">The instance representing the feed being written.</param>
/// <param name="feedType">The EDM type of the feed being written.</param>
/// <param name="writeContext">The serializer context.</param>
/// <returns>The created <see cref="ODataDeltaResourceSet"/> object.</returns>
public virtual ODataDeltaResourceSet CreateODataDeltaFeed(IEnumerable feedInstance, IEdmCollectionTypeReference feedType,
ODataSerializerContext writeContext)
{
ODataDeltaResourceSet feed = new ODataDeltaResourceSet();
if (writeContext.ExpandedResource == null)
{
// If we have more OData format specific information apply it now, only if we are the root feed.
PageResult odataFeedAnnotations = feedInstance as PageResult;
if (odataFeedAnnotations != null)
{
feed.Count = odataFeedAnnotations.Count;
feed.NextPageLink = odataFeedAnnotations.NextPageLink;
}
else if (writeContext.Request != null)
{
feed.NextPageLink = writeContext.Context.ODataFeature().NextLink;
long?countValue = writeContext.Context.ODataFeature().TotalCount;
if (countValue.HasValue)
{
feed.Count = countValue.Value;
}
}
}
else
{
// nested feed
ITruncatedCollection truncatedCollection = feedInstance as ITruncatedCollection;
if (truncatedCollection != null && truncatedCollection.IsTruncated)
{
feed.NextPageLink = GetNestedNextPageLink(writeContext, truncatedCollection.PageSize);
}
}
return(feed);
}
internal static IEnumerable CovertFeedIds(IEnumerable sources, ODataFeedWithEntries feed,
IEdmCollectionTypeReference collectionType, ODataDeserializerContext readContext)
{
IEdmEntityTypeReference entityTypeReference = collectionType.ElementType().AsEntity();
int i = 0;
foreach (object item in sources)
{
object newItem = CovertEntityId(item, feed.Entries[i].Entry, entityTypeReference, readContext);
i++;
yield return newItem;
}
}
/// <summary>
/// Creates a new instance of the type annotation for a collection value.
/// </summary>
/// <param name="collectionType">The type of the collection value (required).</param>
public ODataTypeAnnotation(IEdmCollectionTypeReference collectionType)
{
ExceptionUtils.CheckArgumentNotNull(collectionType, "collectionType");
this.type = collectionType;
}
/// <summary>
/// Create the <see cref="ODataFeed"/> to be written for the given feed instance.
/// </summary>
/// <param name="feedInstance">The instance representing the feed being written.</param>
/// <param name="feedType">The EDM type of the feed being written.</param>
/// <param name="writeContext">The serializer context.</param>
/// <returns>The created <see cref="ODataFeed"/> object.</returns>
public virtual ODataFeed CreateODataFeed(IEnumerable feedInstance, IEdmCollectionTypeReference feedType,
ODataSerializerContext writeContext)
{
ODataFeed feed = new ODataFeed();
if (writeContext.EntitySet != null)
{
IEdmModel model = writeContext.Model;
EntitySetLinkBuilderAnnotation linkBuilder = model.GetEntitySetLinkBuilder(writeContext.EntitySet);
FeedContext feedContext = new FeedContext
{
Request = writeContext.Request,
RequestContext = writeContext.RequestContext,
EntitySet = writeContext.EntitySet,
Url = writeContext.Url,
FeedInstance = feedInstance
};
Uri feedSelfLink = linkBuilder.BuildFeedSelfLink(feedContext);
if (feedSelfLink != null)
{
feed.SetAnnotation(new AtomFeedMetadata() { SelfLink = new AtomLinkMetadata() { Relation = "self", Href = feedSelfLink } });
}
}
// TODO: Bug 467590: remove the hardcoded feed id. Get support for it from the model builder ?
feed.Id = "http://schemas.datacontract.org/2004/07/" + feedType.FullName();
if (writeContext.ExpandedEntity == null)
{
// If we have more OData format specific information apply it now, only if we are the root feed.
PageResult odataFeedAnnotations = feedInstance as PageResult;
if (odataFeedAnnotations != null)
{
feed.Count = odataFeedAnnotations.Count;
feed.NextPageLink = odataFeedAnnotations.NextPageLink;
}
else if (writeContext.Request != null)
{
feed.NextPageLink = writeContext.Request.ODataProperties().NextLink;
long? inlineCount = writeContext.Request.ODataProperties().TotalCount;
if (inlineCount.HasValue)
{
feed.Count = inlineCount.Value;
}
}
}
else
{
// nested feed
ITruncatedCollection truncatedCollection = feedInstance as ITruncatedCollection;
if (truncatedCollection != null && truncatedCollection.IsTruncated)
{
feed.NextPageLink = GetNestedNextPageLink(writeContext, truncatedCollection.PageSize);
}
}
return feed;
}
/// <summary>
/// Initialzes a new instance of the <see cref="EdmEntityObjectCollection"/> class.
/// </summary>
/// <param name="edmType">The edm type of the collection.</param>
public EdmEntityObjectCollection(IEdmCollectionTypeReference edmType)
{
Initialize(edmType);
}
/// <summary>
/// Read a collection from the reader.
/// </summary>
/// <param name="collectionTypeReference">The type of the collection to read (or null if no type is available).</param>
/// <param name="payloadTypeName">The name of the collection type specified in the payload.</param>
/// <param name="serializationTypeNameAnnotation">The serialization type name for the collection value (possibly null).</param>
/// <returns>The value read from the payload.</returns>
/// <remarks>
/// Pre-Condition: XmlNodeType.Element - the element to read the value for.
/// XmlNodeType.Attribute - an attribute on the element to read the value for.
/// Post-Condition: XmlNodeType.Element - the element was empty.
/// XmlNodeType.EndElement - the element had some value.
///
/// Note that this method will not read null values, those should be handled by the caller already.
/// </remarks>
private ODataCollectionValue ReadCollectionValue(
IEdmCollectionTypeReference collectionTypeReference,
string payloadTypeName,
SerializationTypeNameAnnotation serializationTypeNameAnnotation)
{
this.AssertXmlCondition(XmlNodeType.Element, XmlNodeType.Attribute);
Debug.Assert(
collectionTypeReference == null || collectionTypeReference.IsNonEntityCollectionType(),
"If the metadata is specified it must denote a collection for this method to work.");
this.IncreaseRecursionDepth();
ODataCollectionValue collectionValue = new ODataCollectionValue();
// If we have a metadata type for the collection, use that type name
// otherwise use the type name from the payload (if there was any).
collectionValue.TypeName = collectionTypeReference == null ? payloadTypeName : collectionTypeReference.ODataFullName();
if (serializationTypeNameAnnotation != null)
{
collectionValue.SetAnnotation(serializationTypeNameAnnotation);
}
// Move to the element (so that if we were on an attribute we can test the element for being empty)
this.XmlReader.MoveToElement();
List <object> items = new List <object>();
// Empty collections are valid - they have no items
if (!this.XmlReader.IsEmptyElement)
{
// Read over the collection element to its first child node (or end-element)
this.XmlReader.ReadStartElement();
IEdmTypeReference itemTypeReference = collectionTypeReference == null ? null : collectionTypeReference.ElementType();
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker = this.CreateDuplicatePropertyNamesChecker();
CollectionWithoutExpectedTypeValidator collectionValidator = null;
if (collectionTypeReference == null)
{
// Parse the type name from the payload (if any), extract the item type name and construct a collection validator
string itemTypeName = payloadTypeName == null ? null : EdmLibraryExtensions.GetCollectionItemTypeName(payloadTypeName);
collectionValidator = new CollectionWithoutExpectedTypeValidator(itemTypeName);
}
do
{
switch (this.XmlReader.NodeType)
{
case XmlNodeType.Element:
if (this.XmlReader.NamespaceEquals(this.XmlReader.ODataMetadataNamespace))
{
if (!this.XmlReader.LocalNameEquals(this.ODataCollectionItemElementName))
{
this.XmlReader.Skip();
}
else
{
object itemValue = this.ReadNonEntityValueImplementation(
itemTypeReference,
duplicatePropertyNamesChecker,
collectionValidator,
/*validateNullValue*/ true,
/*propertyName*/ null);
// read over the end tag of the element or the start tag if the element was empty.
this.XmlReader.Read();
// Validate the item (for example that it's not null)
ValidationUtils.ValidateCollectionItem(itemValue, itemTypeReference.IsNullable());
// Note that the ReadNonEntityValue already validated that the actual type of the value matches
// the expected type (the itemType).
items.Add(itemValue);
}
}
else if (this.XmlReader.NamespaceEquals(this.XmlReader.ODataNamespace))
{
throw new ODataException(ODataErrorStrings.ODataAtomPropertyAndValueDeserializer_InvalidCollectionElement(this.XmlReader.LocalName, this.XmlReader.ODataMetadataNamespace));
}
else
{
this.XmlReader.Skip();
}
break;
case XmlNodeType.EndElement:
// End of the collection.
break;
default:
// Non-element so for example a text node, just ignore
this.XmlReader.Skip();
break;
}
}while (this.XmlReader.NodeType != XmlNodeType.EndElement);
}
collectionValue.Items = new ReadOnlyEnumerable(items);
this.AssertXmlCondition(true, XmlNodeType.EndElement);
Debug.Assert(collectionValue != null, "The method should never return null since it doesn't handle null values.");
this.DecreaseRecursionDepth();
return(collectionValue);
}
public ODataFeedDeserializerTest()
{
_model = GetEdmModel();
_customerType = _model.GetEdmTypeReference(typeof(Customer)).AsEntity();
_customersType = new EdmCollectionTypeReference(new EdmCollectionType(_customerType));
}
public void WriteCollectionValue(ODataCollectionValue collectionValue, IEdmTypeReference metadataTypeReference, bool isTopLevelProperty, bool isInUri, bool isOpenPropertyType)
{
Debug.Assert(collectionValue != null, "collectionValue != null");
Debug.Assert(!isTopLevelProperty || !isInUri, "Cannot be a top level property and in a uri");
this.IncreaseRecursionDepth();
// If the CollectionValue has type information write out the metadata and the type in it.
string typeName = collectionValue.TypeName;
if (isTopLevelProperty)
{
Debug.Assert(metadataTypeReference == null, "Never expect a metadata type for top-level properties.");
if (typeName == null)
{
throw new ODataException(ODataErrorStrings.ODataJsonLightValueSerializer_MissingTypeNameOnCollection);
}
}
else
{
// In requests, we allow the metadata type reference to be null if the type name is specified in the OM
if (metadataTypeReference == null && !this.WritingResponse && typeName == null && this.Model.IsUserModel())
{
throw new ODataException(ODataErrorStrings.ODataJsonLightPropertyAndValueSerializer_NoExpectedTypeOrTypeNameSpecifiedForCollectionValueInRequest);
}
}
// resolve the type name to the type; if no type name is specified we will use the
// type inferred from metadata
IEdmCollectionTypeReference collectionTypeReference = (IEdmCollectionTypeReference)TypeNameOracle.ResolveAndValidateTypeNameForValue(this.Model, metadataTypeReference, collectionValue, isOpenPropertyType);
typeName = this.JsonLightOutputContext.TypeNameOracle.GetValueTypeNameForWriting(collectionValue, metadataTypeReference, collectionTypeReference, isOpenPropertyType);
bool useValueProperty = isInUri && !string.IsNullOrEmpty(typeName);
if (useValueProperty)
{
// "{"
this.JsonWriter.StartObjectScope();
ODataJsonLightWriterUtils.WriteODataTypeInstanceAnnotation(this.JsonWriter, typeName);
this.JsonWriter.WriteValuePropertyName();
}
// [
// This represents the array of items in the CollectionValue
this.JsonWriter.StartArrayScope();
// Iterate through the CollectionValue items and write them out (treat null Items as an empty enumeration)
IEnumerable items = collectionValue.Items;
if (items != null)
{
IEdmTypeReference expectedItemTypeReference = collectionTypeReference == null ? null : collectionTypeReference.ElementType();
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker = null;
foreach (object item in items)
{
ValidationUtils.ValidateCollectionItem(item, expectedItemTypeReference.IsNullable());
ODataComplexValue itemAsComplexValue = item as ODataComplexValue;
if (itemAsComplexValue != null)
{
if (duplicatePropertyNamesChecker == null)
{
duplicatePropertyNamesChecker = this.CreateDuplicatePropertyNamesChecker();
}
this.WriteComplexValue(
itemAsComplexValue,
expectedItemTypeReference,
false /*isTopLevel*/,
false /*isOpenPropertyType*/,
duplicatePropertyNamesChecker);
duplicatePropertyNamesChecker.Clear();
}
else
{
Debug.Assert(!(item is ODataCollectionValue), "!(item is ODataCollectionValue)");
Debug.Assert(!(item is ODataStreamReferenceValue), "!(item is ODataStreamReferenceValue)");
// by design: collection element's type name is not written for enum or non-spatial primitive value even in case of full metadata.
// because enum and non-spatial primitive types don't have inheritance, the type of each element is the same as the item type of the collection, whose type name for spatial types in full metadata mode.
ODataEnumValue enumValue = item as ODataEnumValue;
if (enumValue != null)
{
this.WriteEnumValue(enumValue, expectedItemTypeReference);
}
else
{
if (item != null)
{
this.WritePrimitiveValue(item, expectedItemTypeReference);
}
else
{
this.WriteNullValue();
}
}
}
}
}
// End the array scope which holds the items
this.JsonWriter.EndArrayScope();
if (useValueProperty)
{
this.JsonWriter.EndObjectScope();
}
this.DecreaseRecursionDepth();
}
public CollectionFunctionCallNodeTests()
{
itemTypeReference = EdmCoreModel.Instance.GetString(true);
collectionTypeReference = new EdmCollectionType(itemTypeReference).ToTypeReference().AsCollection();
}
public ODataCollectionSerializer(IEdmCollectionTypeReference edmCollectionType, ODataSerializerProvider serializerProvider)
: base(edmCollectionType, ODataPayloadKind.Collection, serializerProvider)
{
_edmCollectionType = edmCollectionType;
}
public EntityCollectionFunctionCallNodeUnitTests()
{
entityTypeReference = ModelBuildingHelpers.BuildValidEntityType().ToTypeReference().AsEntity();
entityCollectionTypeReference = new EdmCollectionType(entityTypeReference).ToTypeReference().AsCollection();
}
internal static void SetDynamicCollectionProperty(object resource, string propertyName, object value,
IEdmCollectionTypeReference edmPropertyType, IEdmStructuredType structuredType,
ODataDeserializerContext readContext, AssembliesResolver assembliesResolver)
{
Contract.Assert(value != null);
Contract.Assert(readContext != null);
Contract.Assert(readContext.Model != null);
IEnumerable collection = value as IEnumerable;
Contract.Assert(collection != null);
Type resourceType = resource.GetType();
Type elementType = EdmLibHelpers.GetClrType(edmPropertyType.ElementType(), readContext.Model, assembliesResolver);
Type propertyType = typeof(ICollection<>).MakeGenericType(elementType);
IEnumerable newCollection;
if (CollectionDeserializationHelpers.TryCreateInstance(propertyType, edmPropertyType, elementType,
out newCollection))
{
collection.AddToCollection(newCollection, elementType, resourceType, propertyName, propertyType, assembliesResolver);
SetDynamicProperty(resource, propertyName, newCollection, structuredType, readContext);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmCollectionValue"/> class.
/// </summary>
/// <param name="type">A reference to a collection type that describes this collection value</param>
/// <param name="elements">The collection of values stored in this collection value</param>
public EdmCollectionValue(IEdmCollectionTypeReference type, IEnumerable <IEdmDelayedValue> elements)
: base(type)
{
this.elements = elements;
}
private ODataCollectionValue ReadCollectionValueImplementation(IEdmCollectionTypeReference collectionValueTypeReference, string payloadTypeName, SerializationTypeNameAnnotation serializationTypeNameAnnotation)
{
ODataVersionChecker.CheckCollectionValue(base.Version);
this.IncreaseRecursionDepth();
base.JsonReader.ReadStartObject();
ODataCollectionValue value2 = new ODataCollectionValue {
TypeName = (collectionValueTypeReference != null) ? collectionValueTypeReference.ODataFullName() : payloadTypeName
};
if (serializationTypeNameAnnotation != null)
{
value2.SetAnnotation<SerializationTypeNameAnnotation>(serializationTypeNameAnnotation);
}
List<object> sourceEnumerable = null;
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_MultiplePropertiesInCollectionWrapper("__metadata"));
}
flag = true;
base.JsonReader.SkipValue();
}
else
{
if (string.CompareOrdinal("results", strB) == 0)
{
if (sourceEnumerable != null)
{
throw new ODataException(Microsoft.Data.OData.Strings.ODataJsonPropertyAndValueDeserializer_MultiplePropertiesInCollectionWrapper("results"));
}
sourceEnumerable = new List<object>();
base.JsonReader.ReadStartArray();
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker = base.CreateDuplicatePropertyNamesChecker();
IEdmTypeReference expectedTypeReference = null;
if (collectionValueTypeReference != null)
{
expectedTypeReference = collectionValueTypeReference.CollectionDefinition().ElementType;
}
CollectionWithoutExpectedTypeValidator collectionValidator = null;
while (base.JsonReader.NodeType != JsonNodeType.EndArray)
{
object item = this.ReadNonEntityValueImplementation(expectedTypeReference, duplicatePropertyNamesChecker, collectionValidator, true);
ValidationUtils.ValidateCollectionItem(item, false);
sourceEnumerable.Add(item);
}
base.JsonReader.ReadEndArray();
continue;
}
base.JsonReader.SkipValue();
}
}
base.JsonReader.ReadEndObject();
if (sourceEnumerable == null)
{
throw new ODataException(Microsoft.Data.OData.Strings.ODataJsonPropertyAndValueDeserializer_CollectionWithoutResults);
}
value2.Items = new ReadOnlyEnumerable(sourceEnumerable);
this.DecreaseRecursionDepth();
return value2;
}
/// <summary>
/// Create the <see cref="ODataFeed"/> to be written for the given feed instance.
/// </summary>
/// <param name="feedInstance">The instance representing the feed being written.</param>
/// <param name="feedType">The EDM type of the feed being written.</param>
/// <param name="writeContext">The serializer context.</param>
/// <returns>The created <see cref="ODataFeed"/> object.</returns>
public virtual ODataFeed CreateODataFeed(IEnumerable feedInstance, IEdmCollectionTypeReference feedType,
ODataSerializerContext writeContext)
{
ODataFeed feed = new ODataFeed();
if (writeContext.ExpandedEntity == null)
{
// If we have more OData format specific information apply it now, only if we are the root feed.
PageResult odataFeedAnnotations = feedInstance as PageResult;
if (odataFeedAnnotations != null)
{
feed.Count = odataFeedAnnotations.Count;
feed.NextPageLink = odataFeedAnnotations.NextPageLink;
}
else if (writeContext.Request != null)
{
feed.NextPageLink = writeContext.Request.ODataProperties().NextLink;
long? countValue = writeContext.Request.ODataProperties().TotalCount;
if (countValue.HasValue)
{
feed.Count = countValue.Value;
}
}
}
else
{
// nested feed
ITruncatedCollection truncatedCollection = feedInstance as ITruncatedCollection;
if (truncatedCollection != null && truncatedCollection.IsTruncated)
{
feed.NextPageLink = GetNestedNextPageLink(writeContext, truncatedCollection.PageSize);
}
}
return feed;
}
/// <summary>
/// Creates the collection instance.
/// </summary>
/// <param name="edmCollectionTypeReference">The edm collection type reference.</param>
/// <param name="clientCollectionType">Type of the client collection.</param>
/// <returns>New Collection Instance.</returns>
internal object CreateCollectionInstance(IEdmCollectionTypeReference edmCollectionTypeReference, Type clientCollectionType)
{
Debug.Assert(edmCollectionTypeReference != null, "edmCollectionTypeReference!=null");
Debug.Assert(clientCollectionType != null, "clientCollectionType!=null");
return CreateCollectionInstance(edmCollectionTypeReference, clientCollectionType, () => DSClient.Strings.AtomMaterializer_MaterializationTypeError(clientCollectionType.FullName));
}
/// <summary>
/// Create the <see cref="ODataResourceSet"/> to be written for the given resourceSet instance.
/// </summary>
/// <param name="resourceSetInstance">The instance representing the resourceSet being written.</param>
/// <param name="resourceSetType">The EDM type of the resourceSet being written.</param>
/// <param name="writeContext">The serializer context.</param>
/// <returns>The created <see cref="ODataResourceSet"/> object.</returns>
public virtual ODataResourceSet CreateResourceSet(IEnumerable resourceSetInstance, IEdmCollectionTypeReference resourceSetType,
ODataSerializerContext writeContext)
{
ODataResourceSet resourceSet = new ODataResourceSet
{
TypeName = resourceSetType.FullName()
};
IEdmStructuredTypeReference structuredType = GetResourceType(resourceSetType).AsStructured();
if (writeContext.NavigationSource != null && structuredType.IsEntity())
{
ResourceSetContext resourceSetContext = ResourceSetContext.Create(writeContext, resourceSetInstance);
IEdmEntityType entityType = structuredType.AsEntity().EntityDefinition();
var operations = writeContext.Model.GetAvailableOperationsBoundToCollection(entityType);
var odataOperations = CreateODataOperations(operations, resourceSetContext, writeContext);
foreach (var odataOperation in odataOperations)
{
ODataAction action = odataOperation as ODataAction;
if (action != null)
{
resourceSet.AddAction(action);
}
else
{
resourceSet.AddFunction((ODataFunction)odataOperation);
}
}
}
if (writeContext.ExpandedResource == null)
{
// If we have more OData format specific information apply it now, only if we are the root feed.
PageResult odataResourceSetAnnotations = resourceSetInstance as PageResult;
if (odataResourceSetAnnotations != null)
{
resourceSet.Count = odataResourceSetAnnotations.Count;
resourceSet.NextPageLink = odataResourceSetAnnotations.NextPageLink;
}
else if (writeContext.Request != null)
{
resourceSet.NextPageLink = writeContext.InternalRequest.Context.NextLink;
resourceSet.DeltaLink = writeContext.InternalRequest.Context.DeltaLink;
long?countValue = writeContext.InternalRequest.Context.TotalCount;
if (countValue.HasValue)
{
resourceSet.Count = countValue.Value;
}
}
}
else
{
ICountOptionCollection countOptionCollection = resourceSetInstance as ICountOptionCollection;
if (countOptionCollection != null && countOptionCollection.TotalCount != null)
{
resourceSet.Count = countOptionCollection.TotalCount;
}
}
return(resourceSet);
}
/// <summary>
/// Writes out the value of a collection property.
/// </summary>
/// <param name="collectionValue">The collection value to write.</param>
/// <param name="metadataTypeReference">The metadata type reference for the collection.</param>
/// <param name="isOpenPropertyType">true if the type name belongs to an open property.</param>
/// <remarks>The current recursion depth is measured by the number of complex and collection values between
/// this one and the top-level payload, not including this one.</remarks>
internal void WriteCollectionValue(
ODataCollectionValue collectionValue,
IEdmTypeReference metadataTypeReference,
bool isOpenPropertyType)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(collectionValue != null, "collectionValue != null");
this.IncreaseRecursionDepth();
// Start the object scope which will represent the entire CollectionValue instance
this.JsonWriter.StartObjectScope();
// resolve the type name to the type; if no type name is specified we will use the
// type inferred from metadata
IEdmCollectionTypeReference collectionTypeReference = (IEdmCollectionTypeReference)TypeNameOracle.ResolveAndValidateTypeNameForValue(this.Model, metadataTypeReference, collectionValue, isOpenPropertyType);
// "__metadata": { "type": "typename" }
// If the CollectionValue has type information write out the metadata and the type in it.
string collectionItemTypeName;
string typeName = this.VerboseJsonOutputContext.TypeNameOracle.GetValueTypeNameForWriting(collectionValue, collectionTypeReference, collectionValue.GetAnnotation <SerializationTypeNameAnnotation>(), /*collectionValidator*/ null, out collectionItemTypeName);
if (typeName != null)
{
ODataJsonWriterUtils.WriteMetadataWithTypeName(this.JsonWriter, typeName);
}
// "results": [
// This represents the array of items in the CollectionValue
this.JsonWriter.WriteDataArrayName();
this.JsonWriter.StartArrayScope();
// Iterate through the CollectionValue items and write them out (treat null Items as an empty enumeration)
IEnumerable items = collectionValue.Items;
if (items != null)
{
IEdmTypeReference expectedItemTypeReference = collectionTypeReference == null ? null : collectionTypeReference.ElementType();
CollectionWithoutExpectedTypeValidator collectionValidator = new CollectionWithoutExpectedTypeValidator(collectionItemTypeName);
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker = null;
foreach (object item in items)
{
ValidationUtils.ValidateCollectionItem(item, false /* isStreamable */);
ODataComplexValue itemAsComplexValue = item as ODataComplexValue;
if (itemAsComplexValue != null)
{
if (duplicatePropertyNamesChecker == null)
{
duplicatePropertyNamesChecker = this.CreateDuplicatePropertyNamesChecker();
}
this.WriteComplexValue(
itemAsComplexValue,
expectedItemTypeReference,
false,
duplicatePropertyNamesChecker,
collectionValidator);
duplicatePropertyNamesChecker.Clear();
}
else
{
Debug.Assert(!(item is ODataCollectionValue), "!(item is ODataCollectionValue)");
Debug.Assert(!(item is ODataStreamReferenceValue), "!(item is ODataStreamReferenceValue)");
this.WritePrimitiveValue(item, collectionValidator, expectedItemTypeReference);
}
}
}
// End the array scope which holds the items
this.JsonWriter.EndArrayScope();
// End the object scope which holds the entire collection
this.JsonWriter.EndObjectScope();
this.DecreaseRecursionDepth();
}
private object Convert(ODataCollectionReader reader, IEdmCollectionTypeReference collectionType, ODataDeserializerContext readContext)
{
IEdmTypeReference elementType = collectionType.ElementType();
Type clrElementType = EdmLibHelpers.GetClrType(elementType, readContext.Model);
IList list = Activator.CreateInstance(typeof(List<>).MakeGenericType(clrElementType)) as IList;
while (reader.Read())
{
switch (reader.State)
{
case ODataCollectionReaderState.Value:
object element = Convert(reader.Item, elementType, readContext);
list.Add(element);
break;
default:
break;
}
}
return list;
}
public override async Task <object> ReadAsync(ODataMessageReader messageReader, Type type, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
IEdmAction action = GetAction(readContext);
Contract.Assert(action != null);
// Create the correct resource type;
Dictionary <string, object> payload;
if (type == typeof(ODataActionParameters))
{
payload = new ODataActionParameters();
}
else
{
payload = new ODataUntypedActionParameters(action);
}
ODataParameterReader reader = await messageReader.CreateODataParameterReaderAsync(action).ConfigureAwait(false);
while (await reader.ReadAsync().ConfigureAwait(false))
{
string parameterName = null;
IEdmOperationParameter parameter = null;
switch (reader.State)
{
case ODataParameterReaderState.Value:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
if (parameter.Type.IsPrimitive())
{
payload[parameterName] = reader.Value;
}
else
{
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(parameter.Type);
payload[parameterName] = deserializer.ReadInline(reader.Value, parameter.Type, readContext);
}
break;
case ODataParameterReaderState.Collection:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmCollectionTypeReference collectionType = parameter.Type as IEdmCollectionTypeReference;
Contract.Assert(collectionType != null);
ODataCollectionValue value = await ODataCollectionDeserializer
.ReadCollectionAsync(reader.CreateCollectionReader()).ConfigureAwait(false);
ODataCollectionDeserializer collectionDeserializer = (ODataCollectionDeserializer)DeserializerProvider.GetEdmTypeDeserializer(collectionType);
payload[parameterName] = collectionDeserializer.ReadInline(value, collectionType, readContext);
break;
case ODataParameterReaderState.Resource:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
Contract.Assert(parameter.Type.IsStructured());
ODataReader resourceReader = reader.CreateResourceReader();
object item = await resourceReader.ReadResourceOrResourceSetAsync().ConfigureAwait(false);
ODataResourceDeserializer resourceDeserializer = (ODataResourceDeserializer)DeserializerProvider.GetEdmTypeDeserializer(parameter.Type);
payload[parameterName] = resourceDeserializer.ReadInline(item, parameter.Type, readContext);
break;
case ODataParameterReaderState.ResourceSet:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmCollectionTypeReference resourceSetType = parameter.Type as IEdmCollectionTypeReference;
Contract.Assert(resourceSetType != null);
ODataReader resourceSetReader = reader.CreateResourceSetReader();
object feed = await resourceSetReader.ReadResourceOrResourceSetAsync().ConfigureAwait(false);
ODataResourceSetDeserializer resourceSetDeserializer = (ODataResourceSetDeserializer)DeserializerProvider.GetEdmTypeDeserializer(resourceSetType);
object result = resourceSetDeserializer.ReadInline(feed, resourceSetType, readContext);
IEdmTypeReference elementTypeReference = resourceSetType.ElementType();
Contract.Assert(elementTypeReference.IsStructured());
IEnumerable enumerable = result as IEnumerable;
if (enumerable != null)
{
if (readContext.IsUntyped)
{
payload[parameterName] = enumerable.ConvertToEdmObject(resourceSetType);
}
else
{
Type elementClrType = readContext.Model.GetClrType(elementTypeReference);
IEnumerable castedResult =
_castMethodInfo.MakeGenericMethod(elementClrType)
.Invoke(null, new[] { result }) as IEnumerable;
payload[parameterName] = castedResult;
}
}
break;
}
}
return(payload);
}
/// <summary>
/// Initialzes a new instance of the <see cref="EdmEnumObjectCollection"/> class.
/// </summary>
/// <param name="edmType">The edm type of the collection.</param>
public EdmEnumObjectCollection(IEdmCollectionTypeReference edmType)
: this(edmType, Enumerable.Empty <IEdmEnumObject>().ToList())
{
}
/// <summary>
/// Initialzes a new instance of the <see cref="EdmEnumObjectCollection"/> class.
/// </summary>
/// <param name="edmType">The edm type of the collection.</param>
/// <param name="list">The list that is wrapped by the new collection.</param>
public EdmEnumObjectCollection(IEdmCollectionTypeReference edmType, IList <IEdmEnumObject> list)
: base(list)
{
Initialize(edmType);
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmCollectionValue"/> class.
/// </summary>
/// <param name="type">A reference to a collection type that describes this collection value</param>
/// <param name="elements">The collection of values stored in this collection value</param>
public EdmCollectionValue(IEdmCollectionTypeReference type, IEnumerable<IEdmDelayedValue> elements)
: base(type)
{
this.elements = elements;
}
/// <summary>
/// Creates the collection instance.
/// </summary>
/// <param name="edmCollectionTypeReference">The edm collection type reference.</param>
/// <param name="clientCollectionType">Type of the client collection.</param>
/// <returns>New Collection Instance.</returns>
internal object CreateCollectionInstance(IEdmCollectionTypeReference edmCollectionTypeReference, Type clientCollectionType)
{
Debug.Assert(edmCollectionTypeReference != null, "edmCollectionTypeReference!=null");
Debug.Assert(clientCollectionType != null, "clientCollectionType!=null");
return(CreateCollectionInstance(edmCollectionTypeReference, clientCollectionType, () => DSClient.Strings.AtomMaterializer_MaterializationTypeError(clientCollectionType.FullName)));
}
/// <summary>
/// Creates Collection instance of store Collection items.
/// </summary>
/// <param name="edmCollectionTypeReference">The edm collection type reference.</param>
/// <param name="clientCollectionType">Type of the client collection.</param>
/// <param name="error">Error to throw.</param>
/// <returns>
/// Newly created Collection instance. Never null.
/// </returns>
private object CreateCollectionInstance(IEdmCollectionTypeReference edmCollectionTypeReference, Type clientCollectionType, Func<string> error)
{
Debug.Assert(clientCollectionType != null, "clientCollectionType != null");
Debug.Assert(edmCollectionTypeReference != null, "edmCollectionTypeReference != null");
Debug.Assert(error != null, "error != null");
// DataServiceCollection cannot track non-entity types so it should not be used for storing primitive or complex types
if (ClientTypeUtil.IsDataServiceCollection(clientCollectionType))
{
throw DSClient.Error.InvalidOperation(DSClient.Strings.AtomMaterializer_DataServiceCollectionNotSupportedForNonEntities);
}
try
{
return this.CreateNewInstance(edmCollectionTypeReference, clientCollectionType);
}
#if PORTABLELIB
catch (MissingMemberException ex)
#else
catch (MissingMethodException ex)
#endif
{
throw DSClient.Error.InvalidOperation(error(), ex);
}
}
/// <summary>
/// Write the items of a collection in ATOM format.
/// </summary>
/// <param name="collectionValue">The collection value to write.</param>
/// <param name="propertyTypeReference">The type reference of the collection value (or null if not metadata is available).</param>
/// <param name="isOpenPropertyType">true if the type name belongs to an open property.</param>
/// <param name="isWritingCollection">true if we are writing a top-level collection instead of an entry.</param>
private void WriteCollectionValue(
ODataCollectionValue collectionValue,
IEdmTypeReference propertyTypeReference,
bool isOpenPropertyType,
bool isWritingCollection)
{
Debug.Assert(collectionValue != null, "collectionValue != null");
this.IncreaseRecursionDepth();
// resolve the type name to the type; if no type name is specified we will use the
// type inferred from metadata
IEdmCollectionTypeReference collectionTypeReference = (IEdmCollectionTypeReference)TypeNameOracle.ResolveAndValidateTypeNameForValue(this.Model, propertyTypeReference, collectionValue, isOpenPropertyType);
string collectionItemTypeName;
string typeName = this.AtomOutputContext.TypeNameOracle.GetValueTypeNameForWriting(collectionValue, collectionTypeReference, collectionValue.GetAnnotation <SerializationTypeNameAnnotation>(), /*collectionValidator*/ null, out collectionItemTypeName);
if (typeName != null)
{
this.WritePropertyTypeAttribute(typeName);
}
// COMPAT 4: ATOM and JSON format for collections - The collection format is not formally specified yet, since it's a new feature
// If the official format deviates from the current WCFDS behavior we would have to introduce a back compat mode here as well.
IEdmTypeReference expectedItemTypeReference = collectionTypeReference == null ? null : collectionTypeReference.ElementType();
CollectionWithoutExpectedTypeValidator collectionValidator = new CollectionWithoutExpectedTypeValidator(collectionItemTypeName);
IEnumerable items = collectionValue.Items;
if (items != null)
{
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker = null;
foreach (object item in items)
{
ValidationUtils.ValidateCollectionItem(item, expectedItemTypeReference.IsNullable());
this.XmlWriter.WriteStartElement(AtomConstants.ODataMetadataNamespacePrefix, AtomConstants.ODataCollectionItemElementName, AtomConstants.ODataMetadataNamespace);
ODataComplexValue complexValue = item as ODataComplexValue;
if (complexValue != null)
{
if (duplicatePropertyNamesChecker == null)
{
duplicatePropertyNamesChecker = this.CreateDuplicatePropertyNamesChecker();
}
this.WriteComplexValue(
complexValue,
expectedItemTypeReference,
false,
isWritingCollection,
null /* beforeValueAction */,
null /* afterValueAction */,
duplicatePropertyNamesChecker,
collectionValidator,
null /* projectedProperties */);
duplicatePropertyNamesChecker.Clear();
}
else
{
Debug.Assert(!(item is ODataCollectionValue), "!(item is ODataCollectionValue)");
Debug.Assert(!(item is ODataStreamReferenceValue), "!(item is ODataStreamReferenceValue)");
ODataEnumValue enumValue = item as ODataEnumValue;
if (enumValue != null)
{
// Note: Currently there is no way for a user to control enum type's serializationTypeNameAnnotation information when the enum values are part of a collection.
this.WriteEnumValue(enumValue, collectionValidator, expectedItemTypeReference, /*serializationTypeNameAnnotation*/ null);
}
else
{
// Note: Currently there is no way for a user to control primitive type information when the primitive values are part of a collection.
if (item != null)
{
this.WritePrimitiveValue(item, collectionValidator, expectedItemTypeReference, /*serializationTypeNameAnnotation*/ null);
}
else
{
this.WriteNullCollectionElementValue(expectedItemTypeReference);
}
}
}
this.XmlWriter.WriteEndElement();
}
}
this.DecreaseRecursionDepth();
}
public override ODataFeed CreateODataFeed(IEnumerable feedInstance, IEdmCollectionTypeReference feedType,
ODataSerializerContext writeContext)
{
ODataFeed feed = base.CreateODataFeed(feedInstance, feedType, writeContext);
feed.Atom().Title = new AtomTextConstruct { Kind = AtomTextConstructKind.Text, Text = "My amazing feed" };
return feed;
}
public IODataComplexObjectCollection CreateODataComplexObjectCollection(IEdmCollectionTypeReference edmType)
{
return(new EdmComplexObjectCollection(edmType).ToODataComplexObjectCollection());
}