private static IEdmModel GetEdmModelFromEdmxStream(Stream s) { // Update the EdmModel on the workspace IEdmModel model = null; IEnumerable <EdmError> errors = null; #if !WINDOWS_PHONE && !SILVERLIGHT using (var xmlTextReader = XmlTextReader.Create(s, new XmlReaderSettings())) { #else using (var xmlTextReader = XmlReader.Create(s)) { #endif ExceptionUtilities.Assert(CsdlReader.TryParse(xmlTextReader, out model, out errors), "Cannot read csdl model"); ExceptionUtilities.Assert(!errors.Any(), "Errors on parsing csdl"); } return(model); }
private QueryValue EvaluateJoinExpression(LinqJoinExpressionBase expression, bool isGroupJoin) { var outer = this.EvaluateCollection(expression.Outer); var inner = this.EvaluateCollection(expression.Inner); var outerKeys = this.EvaluateKeysForJoin(outer, expression.OuterKeySelector); var innerKeys = this.EvaluateKeysForJoin(inner, expression.InnerKeySelector); // Dictionary: inner key -> a list of inner values with this key Dictionary <QueryScalarValue, IList <QueryValue> > innerKeyLookup = this.BuildInnerKeyLookup(inner, innerKeys); List <QueryValue> joinResultElements = new List <QueryValue>(); for (int outerIndex = 0; outerIndex < outer.Elements.Count; outerIndex++) { ExceptionUtilities.Assert(outerKeys.Elements[outerIndex] is QueryScalarValue, "For now we only support join on primitive keys."); var outerKey = (QueryScalarValue)outerKeys.Elements[outerIndex]; IList <QueryValue> innerMatches; if (!innerKeyLookup.TryGetValue(outerKey, out innerMatches)) { innerMatches = new List <QueryValue>(); } if (isGroupJoin) { QueryValue result = this.EvaluateLambda <QueryValue>(expression.ResultSelector, outer.Elements[outerIndex], inner.Type.CreateCollectionWithValues(innerMatches)); joinResultElements.Add(result); } else { foreach (var innerValue in innerMatches) { QueryValue result = this.EvaluateLambda <QueryValue>(expression.ResultSelector, outer.Elements[outerIndex], innerValue); joinResultElements.Add(result); } } } var resultType = expression.ResultSelector.Body.ExpressionType; return(new QueryCollectionValue(resultType.CreateCollectionType(), resultType.EvaluationStrategy, QueryError.GetErrorFromValues(joinResultElements), joinResultElements)); }
private void WriteEntry(ODataWriter writer, Lazy <ODataReader> lazyReader, ODataResource entry) { this.WriteStart(writer, entry); var annotation = entry.GetAnnotation <ODataEntryNavigationLinksObjectModelAnnotation>(); ODataNestedResourceInfo navLink = null; if (annotation != null) { for (int i = 0; i < annotation.Count; ++i) { bool found = annotation.TryGetNavigationLinkAt(i, out navLink); ExceptionUtilities.Assert(found, "Navigation links should be ordered sequentially for writing"); this.WriteNavigationLink(writer, lazyReader, navLink); } } this.WriteEnd(writer, ODataReaderState.ResourceEnd); this.Read(lazyReader); }
/// <summary> /// Converts an entity data type to a entity type. /// </summary> /// <param name="entity">The entity data type to convert.</param> /// <returns>The corresponding entity type.</returns> private static IEdmEntityTypeReference GetEntityType(IEdmModel model, EntityDataType entityDataType) { Debug.Assert(entityDataType != null, "entityDataType != null"); IEdmSchemaType edmType = model.FindType(entityDataType.Definition.FullName); ExceptionUtilities.Assert( edmType != null, "The expected entity type '{0}' was not found in the entity model for this test.", entityDataType.Definition.FullName); IEdmEntityType entityType = edmType as IEdmEntityType; ExceptionUtilities.Assert( entityType != null, "The expected entity type '{0}' is not defined as entity type in the test's metadata.", entityDataType.Definition.FullName); return((IEdmEntityTypeReference)entityType.ToTypeReference(entityDataType.IsNullable)); }
/// <summary> /// Calculates an entity id based on the base uri, entity set resolver, set name, and entity key values /// </summary> /// <param name="contextData">The context data</param> /// <param name="entitySetName">the entity set name</param> /// <param name="entity">The entity to generate an id for</param> /// <returns>The id for the given entity</returns> public Uri CalculateEntityId(DataServiceContextData contextData, string entitySetName, object entity) { ExceptionUtilities.CheckArgumentNotNull(contextData, "contextData"); ExceptionUtilities.CheckStringArgumentIsNotNullOrEmpty(entitySetName, "entitySetName"); ExceptionUtilities.CheckArgumentNotNull(entity, "entity"); if (contextData.BaseUri != null) { ExceptionUtilities.Assert(contextData.BaseUri.IsAbsoluteUri, "Base uri must be absolute. Uri was: '{0}'", contextData.BaseUri.OriginalString); return(new Uri(UriHelpers.ConcatenateUriSegments(contextData.BaseUri.AbsoluteUri, Uri.EscapeDataString(entitySetName) + this.CalculateEntityKey(entity)))); } else { ExceptionUtilities.CheckObjectNotNull(contextData.ResolveEntitySet, "Entity set resolver cannot be null if base uri is null"); var resolvedUri = contextData.ResolveEntitySet(entitySetName); ExceptionUtilities.CheckObjectNotNull(resolvedUri, "Entity set resolver returned null for set name '{0}'", entitySetName); return(new Uri(resolvedUri.AbsoluteUri + this.CalculateEntityKey(entity))); } }
/// <summary> /// Visits a QueryExpression tree whose root node is a Function Call Expression /// </summary> /// <param name="expression">Query Custom Function Call Expression</param> /// <returns>A uri with a Action in it</returns> public override string Visit(QueryCustomFunctionCallExpression expression) { var serviceOperation = expression.Function.Annotations.OfType <ServiceOperationAnnotation>().SingleOrDefault(); // We are ignoring the other parameters associated with the function call expression because other than a binding parameter // these will be added into the payload that is sent if (serviceOperation != null && serviceOperation.BindingKind.IsBound()) { // Calculate the uri previous to the action query then append the function name after it ExceptionUtilities.Assert(expression.Arguments.Count > 0, "Action Function Expression where IsBinding = true must have at least one argment"); var argumentExpression = expression.Arguments[0]; return(string.Format(CultureInfo.InvariantCulture, "{0}/{1}", this.ComputeUriInternal(argumentExpression), expression.Function.Name)); } else { // return the function name because its at the root whether its a legacy serviceoperation or an action return(expression.Function.Name); } }
/// <summary> /// Disposes the inner message reader. /// </summary> public void Dispose() { this.messageReader.Dispose(); // Calling IDisposable.Dispose twice should not throw. this.messageReader.Dispose(); if (this.message != null && this.message.TestStream != null && this.message.StreamRetrieved) { bool enableMessageStreamDisposal = testConfiguration.MessageReaderSettings.EnableMessageStreamDisposal; TestStream messageStream = this.message.TestStream; if (enableMessageStreamDisposal == false && messageStream != null) { ExceptionUtilities.Assert(messageStream.DisposeCount == 0, "Dispose method on the stream must not be called when EnableMessageStreamDisposal is set to false."); } else { ExceptionUtilities.Assert(messageStream.DisposeCount == 1, "Dispose method on the stream must be called exactly once when EnableMessageStreamDisposal is set to true."); } } }
/// <summary> /// Uses the given target type to invoke the appropriate deserialize method /// Throws if the given type is not valid /// </summary> /// <param name="value">The wire representation of a primitive value</param> /// <param name="targetType">The type to deserialize into</param> /// <returns>A clr instance of the primitive value</returns> public virtual object DeserializePrimitive(TWire value, Type targetType) { ExceptionUtilities.CheckArgumentNotNull(targetType, "targetType"); bool nullableType = false; // if its nullable, just get the generic argument if (targetType.IsGenericType() && targetType.GetGenericTypeDefinition() == typeof(Nullable <>)) { nullableType = true; targetType = Nullable.GetUnderlyingType(targetType); } if ((nullableType || !targetType.IsValueType()) && this.ValueIsNull(value, targetType)) { return(null); } // find a method with the right return type and a single parameter of type TWire MethodInfo method = typeof(PrimitiveConverter <TWire>).GetMethods() .SingleOrDefault(m => m.ReturnType == targetType && m.Name.StartsWith("Deserialize", StringComparison.Ordinal) && m.GetParameters().Count(p => p.ParameterType == typeof(TWire)) == 1); ExceptionUtilities.CheckObjectNotNull(method, "Cannot deserialize into target type '{0}'", targetType.FullName); // invoke the method object result = method.Invoke(this, new object[] { value }); // ensure its of the right type before returning it ExceptionUtilities.Assert(targetType.IsInstanceOfType(result), "Result of deserialization was not of expected type"); if (nullableType) { Type nullable = typeof(Nullable <>).MakeGenericType(targetType); ConstructorInfo constructor = nullable.GetInstanceConstructor(true, new Type[] { targetType }); ExceptionUtilities.CheckObjectNotNull(constructor, "Cannot find constructor for Nullable<> with type argument: " + targetType.FullName); result = constructor.Invoke(new object[] { result }); } return(result); }
private void BuildStructuralTypes(QueryTypeLibrary library, EntityContainer container) { foreach (var entitySet in container.EntitySets) { var rootType = entitySet.EntityType; var allDerivedTypes = container.Model.EntityTypes.Where(et => et.IsKindOf(rootType)); foreach (var entityType in allDerivedTypes) { var queryEntityType = library.GetQueryEntityType(entitySet, entityType); var pathToProperty = new PathToProperty(container, entitySet, entityType); this.CreateMembers(library, queryEntityType, entityType.AllProperties, pathToProperty); ExceptionUtilities.Assert(pathToProperty.PathStackWithinEntityType.Count == 0, "Path to property stack is not empty."); this.CreateNavigationMembers(library, queryEntityType, entityType.AllNavigationProperties, container); } } }
private VariationTestItem InvokeMatrixCombinationCallback(MethodInfo method, VariationTestItem variation, VariationAttribute attribute) { var callbackAttr = (TestMatrixCombinationCallbackAttribute)method.GetCustomAttributes(typeof(TestMatrixCombinationCallbackAttribute), false).SingleOrDefault(); if (callbackAttr != null) { var callbackMethod = this.GetType().GetMethod(callbackAttr.CallbackMethodName, true, false); ExceptionUtilities.CheckObjectNotNull(callbackMethod, "Could not find instance method '{0}' on type '{1}'", callbackAttr.CallbackMethodName, this.GetType()); ExceptionUtilities.Assert(typeof(VariationTestItem).IsAssignableFrom(callbackMethod.ReturnType), "Matrix combination callback '{0}' returns unexpected type '{1}'", callbackMethod.Name, callbackMethod.ReturnType); var arguments = new object[attribute.Parameters.Length + 1]; arguments[0] = variation; Array.Copy(attribute.Parameters, 0, arguments, 1, attribute.Parameters.Length); variation = (VariationTestItem)callbackMethod.Invoke(this, arguments); } return(variation); }
/// <summary> /// Parses the token of type array /// </summary> /// <returns>Parsed array</returns> private JsonArray ParseArray() { // Array can start only with '[' ExceptionUtilities.Assert(this.tokenizer.TokenType == JsonTokenType.LeftSquareBracket, "Invalid Token"); // Should not end before we get ']' ExceptionUtilities.Assert(this.tokenizer.HasMoreTokens(), "Invalid End Of Stream"); this.tokenizer.GetNextToken(); // Array is an ordered collection of values ExceptionUtilities.Assert(this.IsValueType(this.tokenizer.TokenType) || this.tokenizer.TokenType == JsonTokenType.RightSquareBracket, "InvalidToken"); var result = new JsonArray(); while (this.tokenizer.HasMoreTokens()) { if (this.IsValueType(this.tokenizer.TokenType)) { JsonValue v = this.ParseValue(); result.Add(v); // Values are separated by , (comma). ExceptionUtilities.Assert(this.tokenizer.TokenType == JsonTokenType.Comma || this.tokenizer.TokenType == JsonTokenType.RightSquareBracket, "Invalid Token"); } else if (this.tokenizer.TokenType == JsonTokenType.RightSquareBracket) { if (this.tokenizer.HasMoreTokens()) { this.tokenizer.GetNextToken(); } return(result); } else if (this.tokenizer.TokenType == JsonTokenType.Comma) { this.tokenizer.GetNextToken(); // Last element of the array cannot be followed by a comma. ExceptionUtilities.Assert(this.IsValueType(this.tokenizer.TokenType) || this.tokenizer.TokenType == JsonTokenType.RightSquareBracket, "InvalidToken"); } } return(result); }
/// <summary> /// Serializes the given root element to a binary representation /// </summary> /// <param name="rootElement">The root element</param> /// <param name="encodingName">Optional name of an encoding to use if it is relevant to the current format</param> /// <returns>The serialized value</returns> public override byte[] SerializeToBinary(ODataPayloadElement rootElement, string encodingName) { ExceptionUtilities.CheckArgumentNotNull(rootElement, "rootElement"); ExceptionUtilities.Assert(rootElement.ElementType == ODataPayloadElementType.ComplexInstance, "Only complex instances form values can be serialized as html forms. Type was: {0}", rootElement.ElementType); var complexInstance = (ComplexInstance)rootElement; var queryOpions = new List <KeyValuePair <string, string> >(); foreach (var property in complexInstance.Properties) { string value; if (property.ElementType == ODataPayloadElementType.PrimitiveProperty) { value = this.LiteralConverter.SerializePrimitive(((PrimitiveProperty)property).Value.ClrValue); } else if (property.ElementType == ODataPayloadElementType.ComplexProperty) { value = this.JsonConverter.ConvertToJson(((ComplexProperty)property).Value); } else if (property.ElementType == ODataPayloadElementType.PrimitiveMultiValueProperty) { value = this.JsonConverter.ConvertToJson(((PrimitiveMultiValueProperty)property).Value); } else { ExceptionUtilities.Assert(property.ElementType == ODataPayloadElementType.ComplexMultiValueProperty, "Only primitive, complex, and multi-value properties are supported"); value = this.JsonConverter.ConvertToJson(((ComplexMultiValueProperty)property).Value); } var option = new KeyValuePair <string, string>(property.Name, value); queryOpions.Add(option); } StringBuilder builder = new StringBuilder(); UriHelpers.ConcatenateQueryOptions(builder, queryOpions); var encoding = HttpUtilities.GetEncodingOrDefault(encodingName); return(encoding.GetBytes(builder.ToString())); }
internal static IList <KeyValuePair <string, ITypedValue> > ConvertActionArgumentsToTypedValues(this Function function, ServiceOperationAnnotation actionAnnotation, IList <KeyValuePair <string, QueryExpression> > parameters) { var parameterValues = new List <KeyValuePair <string, ITypedValue> >(); FunctionParameter boundParameter = null; if (actionAnnotation.BindingKind.IsBound()) { boundParameter = function.Parameters[0]; } foreach (var parameterPair in parameters) { var edmFunctionParameterDefinition = function.Parameters.Where(p => p.Name == parameterPair.Key).SingleOrDefault(); ExceptionUtilities.CheckObjectNotNull(edmFunctionParameterDefinition, "Cannot find parameter '{0}' defined in function '{1}'", parameterPair.Key, function.Name); ExceptionUtilities.Assert(edmFunctionParameterDefinition != boundParameter, "Bound parameters MUST not be passed in as they will have already been built for the ODataUri was built"); var primitiveDataType = edmFunctionParameterDefinition.DataType as PrimitiveDataType; var collectionDataType = edmFunctionParameterDefinition.DataType as CollectionDataType; if (primitiveDataType != null) { ExceptionUtilities.CheckObjectNotNull(primitiveDataType, "Expected a primitive data type not '{0}'", primitiveDataType); var primitiveValue = ConvertToPrimitiveValue(parameterPair.Value, primitiveDataType); parameterValues.Add(new KeyValuePair <string, ITypedValue>(edmFunctionParameterDefinition.Name, primitiveValue)); } else if (collectionDataType != null) { ExceptionUtilities.CheckObjectNotNull(collectionDataType, "expected a collection data type, actual '{0}", collectionDataType); var collectionValue = parameterPair.Value.ConvertToMultiValue(collectionDataType.ElementDataType); parameterValues.Add(new KeyValuePair <string, ITypedValue>(edmFunctionParameterDefinition.Name, collectionValue)); } else { var complexArgumentValue = parameterPair.Value; var complexInstance = complexArgumentValue.ConvertToComplexInstance(); parameterValues.Add(new KeyValuePair <string, ITypedValue>(edmFunctionParameterDefinition.Name, complexInstance)); } } return(parameterValues); }
/// <summary> /// Entities returned from FunctionImport only have their scalar properties set. However, in order to properly evaluate results of queries /// which project navigation properties of these entities (such as FunctionImportReturningCustomers().Select(c => c.Orders)) /// we need to associate these entities with ones that are already stored in the data set (which basically is the full graph) /// In order to do that, we look through entity associated with the function import for entity with matching keys and return it instead /// </summary> /// <param name="result">Collection of fixed to fix-up.</param> /// <param name="entitySetName">Name of entity set associated with the given function import.</param> /// <returns>Collection of fixed-up entities.</returns> private QueryValue FixupFunctionImportResultEntities(QueryValue result, string entitySetName) { var resultCollection = result as QueryCollectionValue; ExceptionUtilities.CheckObjectNotNull(resultCollection, "Expecting collection."); ExceptionUtilities.Assert(resultCollection.Type.ElementType is QueryEntityType, "Expecting collection of entities."); var fixedElements = new List <QueryValue>(); foreach (var element in resultCollection.Elements.Cast <QueryStructuralValue>()) { var elementEntityType = (QueryEntityType)element.Type; var primaryKeyPropertyNames = elementEntityType.Properties.Where(p => p.IsPrimaryKey).Select(p => p.Name); var elementKeyPropertyValuesDictionary = primaryKeyPropertyNames.Select(n => new { Name = n, Value = element.GetScalarValue(n) }).ToDictionary(k => k.Name, e => e.Value); QueryValue matchingElementInEntitySet = null; foreach (var entitySetElement in this.DataSet[entitySetName].Elements.Cast <QueryStructuralValue>()) { if (!elementEntityType.EntityType.Equals(((QueryEntityType)entitySetElement.Type).EntityType)) { continue; } var elementsMatch = this.AllKeysMatch(entitySetElement, elementKeyPropertyValuesDictionary); if (elementsMatch) { matchingElementInEntitySet = entitySetElement; break; } } if (matchingElementInEntitySet != null) { fixedElements.Add(matchingElementInEntitySet); } else { fixedElements.Add(element); } } return(((QueryCollectionType)result.Type).CreateCollectionWithValues(fixedElements)); }
/// <summary> /// Normalizes an Atom link property value between an XmlTreeAnnotation and another property. /// </summary> /// <typeparam name="T">The type of payload element.</typeparam> /// <param name="payloadElement">The payload element to normalize.</param> /// <param name="relationValue">The relation value of the link to normalize.</param> /// <param name="attributeName">The name of the link attribute to normalize.</param> /// <param name="getOtherLinkValue">Function for retrieving the other value for the link property.</param> /// <param name="setOtherLinkValue">Delegate for setting the other value for the link property.</param> private void NormalizeLinkValue <T>(T payloadElement, string relationValue, string attributeName, Func <T, string> getOtherLinkValue, Action <T, string> setOtherLinkValue) where T : ODataPayloadElement { string otherLinkValue = getOtherLinkValue(payloadElement); XmlTreeAnnotation linkXmlTreeAnnotation = payloadElement.Annotations .OfType <XmlTreeAnnotation>() .SingleOrDefault(a => a.LocalName.Equals(TestAtomConstants.AtomLinkElementName) && HasAttribute(a, TestAtomConstants.AtomLinkRelationAttributeName, relationValue)); if (otherLinkValue != null) { if (linkXmlTreeAnnotation != null) { var linkAttribute = GetAttributeAnnotation(linkXmlTreeAnnotation, attributeName); if (linkAttribute == null) { linkXmlTreeAnnotation.Children.Add(XmlTreeAnnotation.AtomAttribute(attributeName, otherLinkValue)); } else if (linkAttribute.PropertyValue != otherLinkValue) { ExceptionUtilities.Assert(otherLinkValue.Equals(linkAttribute.PropertyValue), attributeName + " value for link '" + relationValue + "' does not match value on Xml Tree"); } } else { // Add an xml tree annotation to match the value from the other source. payloadElement.Add( XmlTreeAnnotation.Atom( TestAtomConstants.AtomLinkElementName, null, XmlTreeAnnotation.AtomAttribute(TestAtomConstants.AtomLinkRelationAttributeName, relationValue), XmlTreeAnnotation.AtomAttribute(attributeName, otherLinkValue))); } } else if (linkXmlTreeAnnotation != null) { // Set the other source to match the atom:link href value of the annotation var linkAttribute = GetAttributeAnnotation(linkXmlTreeAnnotation, attributeName); if (linkAttribute != null) { setOtherLinkValue(payloadElement, linkAttribute.PropertyValue); } } }
/// <summary> /// Splits the given json payload into multiple lines and adds the indentation marker to it. /// </summary> /// <param name="jsonString">Json Payload.</param> /// <param name="indentDepth">Indentation depth to start with.</param> /// <returns>all the lines after indenting the json payload.</returns> public static string[] GetJsonLines(string jsonString, int indentDepth = 0) { string indentVariable = "$(Indent)"; int originalIndentDepth = indentDepth; List <string> jsonLines = new List <string>(); StringBuilder stringBuilder = new StringBuilder(); for (int i = 0; i < jsonString.Length; i++) { if (jsonString[i] == '{' || jsonString[i] == '[') { stringBuilder.Append(jsonString[i]); jsonLines.Add(stringBuilder.ToString()); stringBuilder.Clear(); indentDepth++; for (int j = 0; j < indentDepth; j++) { stringBuilder.Append(indentVariable); } } else if (jsonString[i] == '}' || jsonString[i] == ']') { jsonLines.Add(stringBuilder.ToString()); stringBuilder.Clear(); indentDepth--; for (int j = 0; j < indentDepth; j++) { stringBuilder.Append(indentVariable); } stringBuilder.Append(jsonString[i]); } else { stringBuilder.Append(jsonString[i]); } } jsonLines.Add(stringBuilder.ToString()); ExceptionUtilities.Assert(originalIndentDepth == indentDepth, "indentDepth must be zero"); return(jsonLines.ToArray()); }
private bool ValuesAreEqual(QueryValue firstValue, QueryValue secondValue) { var firstValueScalar = firstValue as QueryScalarValue; if (firstValueScalar != null) { var secondValueScalar = secondValue as QueryScalarValue; return(secondValueScalar != null && this.ScalarValuesAreEqual(firstValueScalar, secondValueScalar)); } var firstValueStructural = firstValue as QueryStructuralValue; if (firstValueStructural != null) { var secondValueStructural = secondValue as QueryStructuralValue; return(secondValueStructural != null && this.StructuralValuesAreEqual(firstValueStructural, secondValueStructural)); } var firstValueReference = firstValue as QueryReferenceValue; if (firstValueReference != null) { var secondValueReference = secondValue as QueryReferenceValue; return(secondValueReference != null && this.ReferenceValuesAreEqual(firstValueReference, secondValueReference)); } var firstValueRecord = firstValue as QueryRecordValue; if (firstValueRecord != null) { var secondValueRecord = secondValue as QueryRecordValue; return(secondValueRecord != null && this.RecordValuesAreEqual(firstValueRecord, secondValueRecord)); } var firstValueCollection = firstValue as QueryCollectionValue; ExceptionUtilities.Assert(firstValueCollection != null, "Now only support query value equality comparison on primitive / structural / collection, not {0}.", firstValue); var secondValueCollection = secondValue as QueryCollectionValue; return(secondValueCollection != null && this.CollectionValuesAreEqual(firstValueCollection, secondValueCollection)); }
/// <summary> /// Removes all references to the given entity /// </summary> /// <param name="type">The type of the entity</param> /// <param name="entity">The entity to remove</param> private void RemoveAllReferences(QueryEntityType type, QueryStructuralValue entity) { ExceptionUtilities.Assert(type == entity.Type, "QueryStructuralValue must have the same type as what is provided"); // get all association sets that touch the entity's set var associationSets = this.Model.EntityContainers .SelectMany(c => c.AssociationSets) .Where(a => a.Ends.Any(e => e.EntitySet == type.EntitySet && type.EntityType.IsKindOf(e.AssociationEnd.EntityType))) .ToList(); // get all the navigation properties for each set. Note that there will only be more than one in the case of a self-reference var navigationPropertiesBySet = associationSets .SelectMany(a => a.Ends) .ToLookup( e => e.EntitySet.Name, e => e.AssociationEnd.EntityType.AllNavigationProperties.SingleOrDefault(n => n.FromAssociationEnd == e.AssociationEnd)); // compute the key of this entity var key = this.GetEntityKey(entity); // go through each potentially-affected set and remove the entity from the navigations of each element foreach (var setNavigations in navigationPropertiesBySet) { var setName = setNavigations.Key; var setContents = this.QueryDataSet[setName].Elements.Cast <QueryStructuralValue>(); // go through each element in the set foreach (var related in setContents) { // and remove the entity from each navigation foreach (var navigation in setNavigations.Where(n => n != null)) { // We have associations between sub types in the hierarchy so some instances will not have particular associations so we should filter them out var relatedQueryEntityType = related.Type as QueryEntityType; if (relatedQueryEntityType.EntityType.IsKindOf(navigation.FromAssociationEnd.EntityType)) { this.RemoveFromNavigationProperty(key, related, navigation); } } } } }
/// <summary> /// Returns whether or not to expect an error when reading the given payload with the given version. /// </summary> /// <param name="requestPayload">The payload which will be read.</param> /// <param name="version">The version the reader expects.</param> /// <param name="error">The error if one is expected.</param> /// <returns> /// Whether an error is expected /// </returns> public bool TryCalculateError(ODataPayloadElement requestPayload, DataServiceProtocolVersion version, out ExpectedErrorMessage error) { error = null; if (requestPayload == null) { return(false); } // Simplifying assumption. The rest of this class assumes that the version is < 3 and doesn't check further. if (version >= DataServiceProtocolVersion.V4) { return(false); } ExceptionUtilities.Assert(version != DataServiceProtocolVersion.Unspecified, "Version parameter cannot be unspecified"); this.payloadVersion = version; return(error != null); }
/// <summary> /// Initializes a new instance of the ResourceInstance class with the given type and set /// </summary> /// <param name="type">The type of the instance</param> /// <param name="set">The set the instance belongs to</param> public ResourceInstance(ResourceType type, ResourceSet set) : base() { ExceptionUtilities.CheckArgumentNotNull(type, "type"); if (type.ResourceTypeKind == ResourceTypeKind.EntityType) { ExceptionUtilities.CheckArgumentNotNull(set, "set"); this.IsEntityType = true; this.ResourceSetName = set.Name; } else { ExceptionUtilities.Assert(type.ResourceTypeKind == ResourceTypeKind.ComplexType, "Only entity and complex types can be represented. Type was: '{0}'", type); ExceptionUtilities.Assert(set == null, "Complex types cannot have sets"); this.IsEntityType = false; } this.ResourceTypeName = type.FullName; }
/// <summary> /// Replaces function parameter reference expression with an expression represeting argument for the parameter /// </summary> /// <param name="expression">The function parameter reference expression</param> /// <returns>An expression represeting corresponding argument for the parameter</returns> protected QueryExpression ReplaceFunctionParameterReference(QueryFunctionParameterReferenceExpression expression) { string parameterName = expression.ParameterName; var functionCall = this.customFunctionsCallStack.Peek(); var parameters = functionCall.Function.Parameters; var arguemnts = functionCall.Arguments; var matchingParameters = parameters.Where(p => p.Name == parameterName).ToList(); ExceptionUtilities.Assert( matchingParameters.Count == 1, "Found {0} parameters with name '{1}'. Expected: 1. Function: '{2}'.", matchingParameters.Count, parameterName, functionCall.Function.FullName); int index = parameters.IndexOf(matchingParameters[0]); return(arguemnts[index]); }
private IDataGenerator ResolveStringGenerator(IRandomNumberGenerator random, DataGenerationHint[] hints, bool isNullable) { int minLength; int maxLength = this.GetMaxLengthAndCheckLengthRange(hints, out minLength); bool ansiString = hints.OfType <AnsiStringHint>().Any(); IStringGenerator stringGenerator = ansiString ? this.AnsiStringGenerator : this.UnicodeStringGenerator; var stringPrefixHint = hints.OfType <StringPrefixHint>().SingleOrDefault(); if (stringPrefixHint != null) { string prefix = stringPrefixHint.Value; ExceptionUtilities.Assert(prefix.Length < maxLength, "the length of string prefix in data generation exceeds the max length limit"); return(CreateRandomGenerator <string>(random, (r) => prefix + stringGenerator.GenerateString(r, Math.Max(minLength - prefix.Length, 0), maxLength - prefix.Length), hints)); } return(CreateRandomGenerator <string>(random, (r) => stringGenerator.GenerateString(r, minLength, maxLength), hints)); }
private static IEnumerable <T> RecurseBaseTypes <T>(XElement typeElement, IDictionary <string, XElement> typeIndex, Func <XElement, IEnumerable <T> > selectFunction, ICollection <XElement> seenElements) { string baseTypeValue = string.Empty; if (typeElement.TryGetAttributeValue("BaseType", out baseTypeValue)) { ExceptionUtilities.Assert(typeIndex.ContainsKey(baseTypeValue), "Failed to find base type " + baseTypeValue); var baseTypeElement = typeIndex[baseTypeValue]; if (seenElements.Contains(baseTypeElement)) { // Detect cyclical hierachies return(selectFunction(baseTypeElement)); } seenElements.Add(baseTypeElement); return(RecurseBaseTypes(baseTypeElement, typeIndex, selectFunction, seenElements).Concat(selectFunction(typeElement))); } return(selectFunction(typeElement)); }
/// <summary> /// Visits a collection start. /// </summary> /// <param name="collection">The collection start to visit.</param> protected override ODataPayloadElement VisitCollectionStart(ODataCollectionStart collection) { ExceptionUtilities.CheckArgumentNotNull(collection, "collection"); // NOTE the Taupo OM does not currently support heterogenous collections; we determine the // type of the collection by looking at the first non-null item ODataCollectionItemsObjectModelAnnotation itemsAnnotation = collection.GetAnnotation <ODataCollectionItemsObjectModelAnnotation>(); ExceptionUtilities.Assert(itemsAnnotation != null, "itemsAnnotation != null"); PrimitiveCollection primitiveCollection = PayloadBuilder.PrimitiveCollection(collection.Name); foreach (object item in itemsAnnotation) { PrimitiveValue primitiveValue = (PrimitiveValue)this.Visit(item); primitiveCollection.Add(primitiveValue); } return(primitiveCollection); }
private static ODataPayloadElementCollection CreateCollectionForElementType(ODataPayloadElementType elementType) { if (elementType == ODataPayloadElementType.PrimitiveValue) { return(new PrimitiveCollection()); } else if (elementType == ODataPayloadElementType.DeferredLink) { return(new LinkCollection()); } else if (elementType == ODataPayloadElementType.ComplexInstance) { return(new ComplexInstanceCollection()); } else { ExceptionUtilities.Assert(elementType == ODataPayloadElementType.EntityInstance, "Element type was unexpected type '{0}'", elementType); return(new EntitySetInstance()); } }
private static ODataPayloadElement CreateNullElement(ODataPayloadElementType elementType) { if (elementType == ODataPayloadElementType.PrimitiveValue) { return(new PrimitiveValue(null, null)); } else if (elementType == ODataPayloadElementType.DeferredLink) { return(new DeferredLink()); } else if (elementType == ODataPayloadElementType.ComplexInstance) { return(new ComplexInstance(null, true)); } else { ExceptionUtilities.Assert(elementType == ODataPayloadElementType.EntityInstance, "Element type was unexpected type '{0}'", elementType); return(new EntityInstance(null, true)); } }
public virtual object GetResource(IQueryable query, string fullTypeName) { ExceptionUtilities.CheckArgumentNotNull(query, "query"); object resource = null; foreach (object r in query) { ExceptionUtilities.Assert(resource == null, "Invalid Uri specified. The query '{0}' must refer to a single resource", new object[] { query.ToString() }); resource = r; } if (resource == null) { return(null); } if (fullTypeName != null) { this.ValidateResourceType(resource, fullTypeName); } return(new UpdatableToken(resource)); }
/// <summary> /// Gets a data generator for the specified member. /// </summary> /// <param name="memberName">The member name.</param> /// <returns>A data generator for the specified member.</returns> public IDataGenerator GetMemberDataGenerator(string memberName) { string nextMemberName; string currenMemberName = MemberValueGenerators.GetCurrentMemberName(memberName, out nextMemberName); int index; ExceptionUtilities.Assert(int.TryParse(currenMemberName, out index), "Invalid member name for collection data generator. It should start with index. Member name: '{0}'.", memberName); IDataGenerator memberDataGenerator = this.itemDataGenerator; if (nextMemberName != null) { var memberDataGenerators = memberDataGenerator as IMemberDataGenerators; ExceptionUtilities.CheckObjectNotNull(memberDataGenerators, "Cannot find data generator for member '{0}'.", memberName); memberDataGenerator = memberDataGenerators.GetMemberDataGenerator(nextMemberName); } return(memberDataGenerator); }
/// <summary> /// Validator for spatial values. /// </summary> /// <param name="payloadElement">The payload element to validate.</param> /// <param name="testConfigLimits">The test configuration limits to modify.</param> public static void SpatialValueValidator(ODataPayloadElement payloadElement, TestConfigurationLimits testConfigLimits) { PrimitiveValue primitiveValue = payloadElement as PrimitiveValue; ExceptionUtilities.Assert(primitiveValue != null, "This validator only works on primitive values."); if (primitiveValue.ClrValue is ISpatial) { // Spatial values require V3. testConfigLimits.RaiseMinPayloadVersion(ODataVersion.V4); } else if (primitiveValue.ClrValue == null) { EntityModelTypeAnnotation typeAnnotation = primitiveValue.GetAnnotation <EntityModelTypeAnnotation>(); if (typeAnnotation != null && typeAnnotation.EdmModelType.Definition.IsSpatial()) { testConfigLimits.RaiseMinPayloadVersion(ODataVersion.V4); } } }
private QueryValue EvaluateQueryMethodWithLambdaExpression <TResult>( LinqQueryMethodWithLambdaExpression expression, Func <QueryCollectionValue, QueryValue> nolambdaEvaluator, Func <QueryCollectionValue, Func <QueryValue, TResult>, QueryValue> lambdaEvaluator) where TResult : QueryValue { var source = this.EvaluateCollection(expression.Source); LinqLambdaExpression lambda = expression.Lambda; if (lambda == null) { ExceptionUtilities.Assert(nolambdaEvaluator != null, "noLambdaEvaluator must not be null."); return(nolambdaEvaluator(source)); } else { return(lambdaEvaluator(source, v => this.EvaluateLambda <TResult>(lambda, v))); } }