public static object ShouldBeConstantParameterWithValueType <TValue>(this OperationSegmentParameter parameter, string name, TValue value) { Assert.Equal(name, parameter.Name); ConstantNode constantNode = Assert.IsType <ConstantNode>(parameter.Value); if (value == null) { Assert.Null(constantNode.Value); } else { if (typeof(TValue).IsPrimitive() || typeof(TValue) == typeof(decimal)) { // for int value --> long TValue TValue tmp = (TValue)Convert.ChangeType(constantNode.Value, typeof(TValue)); Assert.NotNull(tmp); Assert.Equal(value, tmp); } else if (typeof(TValue) == typeof(UriTemplateExpression)) { UriTemplateExpression actual = Assert.IsType <UriTemplateExpression>(constantNode.Value); UriTemplateExpression expect = Assert.IsType <UriTemplateExpression>(value); Assert.Equal(expect.LiteralText, actual.LiteralText); Assert.Equal(expect.ExpectedType.FullName(), expect.ExpectedType.FullName()); } else { constantNode.Value.GetType().IsAssignableFrom(typeof(TValue)); Assert.Equal(value, constantNode.Value); } } return(constantNode.Value); }
public void BuildKeyMappingsKeySegmentTemplate_ReturnsKeyMapping_UriTemplateExpression() { // Arrange EdmEntityType customerType = new EdmEntityType("NS", "Customer"); EdmStructuralProperty idProperty = customerType.AddStructuralProperty("customerId", EdmPrimitiveTypeKind.Int32); customerType.AddKeys(idProperty); UriTemplateExpression tempateExpression = BuildExpression("{yourId}", idProperty.Type); IDictionary <string, object> keys = new Dictionary <string, object> { { "customerId", tempateExpression } }; // Act IDictionary <string, string> mapped = KeySegmentTemplate.BuildKeyMappings(keys, customerType); // Assert Assert.NotNull(mapped); KeyValuePair <string, string> actual = Assert.Single(mapped); Assert.Equal("customerId", actual.Key); Assert.Equal("yourId", actual.Value); }
// Translate the object of key in ODL path to string literal. private static string TranslateKeySegmentValue(object value, bool enableUriTemplateParsing) { if (value == null) { throw Error.ArgumentNull("value"); } if (enableUriTemplateParsing) { UriTemplateExpression uriTemplateExpression = value as UriTemplateExpression; if (uriTemplateExpression != null) { return(uriTemplateExpression.LiteralText); } } ConstantNode constantNode = value as ConstantNode; if (constantNode != null) { ODataEnumValue enumValue = constantNode.Value as ODataEnumValue; if (enumValue != null) { return(ODataUriUtils.ConvertToUriLiteral(enumValue, ODataVersion.V4)); } } return(ODataUriUtils.ConvertToUriLiteral(value, ODataVersion.V4)); }
// Translate the object of key in ODL path to string literal. private static string TranslateKeySegmentValue(object value) { if (value == null) { throw new ArgumentNullException(nameof(value)); } UriTemplateExpression uriTemplateExpression = value as UriTemplateExpression; if (uriTemplateExpression != null) { return(uriTemplateExpression.LiteralText); } ConstantNode constantNode = value as ConstantNode; if (constantNode != null) { ODataEnumValue enumValue = constantNode.Value as ODataEnumValue; if (enumValue != null) { return(ODataUriUtils.ConvertToUriLiteral(enumValue, ODataVersion.V4)); } } return(ODataUriUtils.ConvertToUriLiteral(value, ODataVersion.V4)); }
/// <summary> /// Build the key mappings /// </summary> /// <param name="keys">The Uri template parsing result. for example: SSN={ssnKey}</param> /// <param name="entityType">The Edm entity type.</param> /// <param name="keyProperties">The key properties.</param> /// <returns>The mapping</returns> internal static IDictionary <string, string> BuildKeyMappings(IEnumerable <KeyValuePair <string, object> > keys, IEdmEntityType entityType, IDictionary <string, IEdmProperty> keyProperties) { Contract.Assert(keys != null); Contract.Assert(entityType != null); Contract.Assert(keyProperties != null); Dictionary <string, string> parameterMappings = new Dictionary <string, string>(); int count = keys.Count(); if (count != keyProperties.Count) { throw new ODataException(Error.Format(SRResources.InputKeyNotMatchEntityTypeKey, count, keyProperties.Count, entityType.FullName())); } // keys have: SSN={ssn},Name={name} // the key "SSN" or "Name" is the alias in alternate keys foreach (KeyValuePair <string, object> key in keys) { string keyName = key.Key; // key name is case-sensitive if (!keyProperties.ContainsKey(key.Key)) { throw new ODataException(Error.Format(SRResources.CannotFindKeyInEntityType, keyName, entityType.FullName())); } string nameInRouteData; UriTemplateExpression uriTemplateExpression = key.Value as UriTemplateExpression; if (uriTemplateExpression != null) { nameInRouteData = uriTemplateExpression.LiteralText.Trim(); } else { // just for easy construct the key segment template // it must start with "{" and end with "}" nameInRouteData = key.Value as string; } if (nameInRouteData == null || !nameInRouteData.IsValidTemplateLiteral()) { throw new ODataException(Error.Format(SRResources.KeyTemplateMustBeInCurlyBraces, key.Value, key.Key)); } nameInRouteData = nameInRouteData.Substring(1, nameInRouteData.Length - 2); if (string.IsNullOrEmpty(nameInRouteData)) { throw new ODataException(Error.Format(SRResources.EmptyKeyTemplate, key.Value, key.Key)); } parameterMappings[key.Key] = nameInRouteData; } return(parameterMappings); }
public static UriTemplateExpression ShouldBeUriTemplateExpression(this object node, string literalText, IEdmTypeReference expectedType) { Assert.NotNull(node); UriTemplateExpression uriTemplate = Assert.IsType <UriTemplateExpression>(node); Assert.Equal(literalText, uriTemplate.LiteralText); Assert.True(uriTemplate.ExpectedType.IsEquivalentTo(expectedType)); return(uriTemplate); }
/// <summary> /// Parse a literal as Uri template. /// </summary> /// <param name="literalText">The input text.</param> /// <param name="expectedType">The expected type of the object which the Uri template stands for.</param> /// <param name="expression">The <see cref="UriTemplateExpression"/> representing the Uri template.</param> /// <returns>True if successfully expression parsed, false otherwise. </returns> internal static bool TryParseLiteral(string literalText, IEdmTypeReference expectedType, out UriTemplateExpression expression) { if (IsValidTemplateLiteral(literalText)) { expression = new UriTemplateExpression { LiteralText = literalText, ExpectedType = expectedType }; return(true); } expression = null; return(false); }
private static string TranslateNode(object node, string functionName, string parameterName) { // If the function parameter is null, for example myFunction(param=null), // the input node here is not null, it is a contant node with a value as "null". // However, if a function call (or key) using parameter alias but without providing the parameter alias value, // the input node here is a null. if (node == null) { // We can't throw ODataException here because ODataException will be caught and return 404 response with empty message. throw new InvalidOperationException(Error.Format(SRResources.MissingConvertNode, parameterName, functionName)); } ConstantNode constantNode = node as ConstantNode; if (constantNode != null) { UriTemplateExpression uriTemplateExpression = constantNode.Value as UriTemplateExpression; if (uriTemplateExpression != null) { return(uriTemplateExpression.LiteralText); } // Make the enum prefix free to work. ODataEnumValue enumValue = constantNode.Value as ODataEnumValue; if (enumValue != null) { return(ODataUriUtils.ConvertToUriLiteral(enumValue, ODataVersion.V4)); } return(constantNode.LiteralText); } ConvertNode convertNode = node as ConvertNode; if (convertNode != null) { return(TranslateNode(convertNode.Source, functionName, parameterName)); } ParameterAliasNode parameterAliasNode = node as ParameterAliasNode; if (parameterAliasNode != null) { return(parameterAliasNode.Alias); } //return node.ToString(); throw Error.NotSupported(SRResources.CannotRecognizeNodeType, typeof(ODataPathSegmentHandler), node.GetType().FullName); }
public static IDictionary <string, string> BuildParameterMappings( IEnumerable <OperationSegmentParameter> parameters, string segment) { Contract.Assert(parameters != null); Dictionary <string, string> parameterMappings = new Dictionary <string, string>(); foreach (OperationSegmentParameter parameter in parameters) { string parameterName = parameter.Name; string nameInRouteData = null; ConstantNode node = parameter.Value as ConstantNode; if (node != null) { UriTemplateExpression uriTemplateExpression = node.Value as UriTemplateExpression; if (uriTemplateExpression != null) { nameInRouteData = uriTemplateExpression.LiteralText.Trim(); } else { nameInRouteData = node.Value as string; } } else { // Just for easy constructor the function parameters nameInRouteData = parameter.Value as string; } if (nameInRouteData == null || !IsRouteParameter(nameInRouteData)) { throw new ODataException( Error.Format(SRResources.ParameterAliasMustBeInCurlyBraces, parameter.Value, segment)); } nameInRouteData = nameInRouteData.Substring(1, nameInRouteData.Length - 2); if (String.IsNullOrEmpty(nameInRouteData)) { throw new ODataException( Error.Format(SRResources.EmptyParameterAlias, parameter.Value, segment)); } parameterMappings[parameterName] = nameInRouteData; } return(parameterMappings); }
// Translate the node in ODL path to string literal. private string TranslateNode(object node) { if (node == null) { throw Error.ArgumentNull("node"); } ConstantNode constantNode = node as ConstantNode; if (constantNode != null) { if (_enableUriTemplateParsing) { UriTemplateExpression uriTemplateExpression = constantNode.Value as UriTemplateExpression; if (uriTemplateExpression != null) { return(uriTemplateExpression.LiteralText); } } // Make the enum prefix free to work. ODataEnumValue enumValue = constantNode.Value as ODataEnumValue; if (enumValue != null) { return(ODataUriUtils.ConvertToUriLiteral(enumValue, ODataVersion.V4)); } return(constantNode.LiteralText); } ConvertNode convertNode = node as ConvertNode; if (convertNode != null) { return(TranslateNode(convertNode.Source)); } ParameterAliasNode parameterAliasNode = node as ParameterAliasNode; if (parameterAliasNode != null) { return(TranslateParameterAlias(parameterAliasNode.Alias)); } throw Error.NotSupported( SRResources.CannotRecognizeNodeType, typeof(ODataPathSegmentTranslator), node.GetType().FullName); }
public void TranslateNode_TranslatesValue() { // Arrange & Act & Assert UriTemplateExpression expression = KeySegmentTemplateTests.BuildExpression("{key}"); ConstantNode node = new ConstantNode(expression); Assert.Equal("{key}", ODataPathSegmentHandler.TranslateNode(node)); // Arrange & Act & Assert EdmEnumType enumType = new EdmEnumType("NS", "Color"); enumType.AddMember(new EdmEnumMember(enumType, "Red", new EdmEnumMemberValue(1))); ODataEnumValue enumValue = new ODataEnumValue("Red", "NS.Color"); node = new ConstantNode(enumValue); Assert.Equal("NS.Color'Red'", ODataPathSegmentHandler.TranslateNode(node)); }
internal static IDictionary <string, string> BuildKeyMappings(KeyValuePathSegment keyValuePathSegment) { Contract.Assert(keyValuePathSegment != null); if (keyValuePathSegment.Segment != null) { Dictionary <string, string> parameterMappings = new Dictionary <string, string>(); foreach (var key in keyValuePathSegment.Segment.Keys) { string parameterNameInRouteData = null; UriTemplateExpression uriTemplateExpression = key.Value as UriTemplateExpression; if (uriTemplateExpression != null) { parameterNameInRouteData = uriTemplateExpression.LiteralText; } if (String.IsNullOrEmpty(parameterNameInRouteData)) { parameterNameInRouteData = key.Key; } else if (IsRouteParameter(parameterNameInRouteData)) { parameterNameInRouteData = parameterNameInRouteData.Substring(1, parameterNameInRouteData.Length - 2); if (String.IsNullOrEmpty(parameterNameInRouteData)) { throw new ODataException( Error.Format(SRResources.EmptyKeyTemplate, keyValuePathSegment.Value)); } } else { throw new ODataException( Error.Format(SRResources.KeyTemplateMustBeInCurlyBraces, keyValuePathSegment.Value)); } parameterMappings[key.Key] = parameterNameInRouteData; } return(parameterMappings); } return(BuildParameterMappings(keyValuePathSegment.Values, keyValuePathSegment.Value)); }
private static string TranslateNode(object node) { Contract.Assert(node != null); ConstantNode constantNode = node as ConstantNode; if (constantNode != null) { UriTemplateExpression uriTemplateExpression = constantNode.Value as UriTemplateExpression; if (uriTemplateExpression != null) { return(uriTemplateExpression.LiteralText); } // Make the enum prefix free to work. ODataEnumValue enumValue = constantNode.Value as ODataEnumValue; if (enumValue != null) { return(ODataUriUtils.ConvertToUriLiteral(enumValue, ODataVersion.V4)); } return(constantNode.LiteralText); } ConvertNode convertNode = node as ConvertNode; if (convertNode != null) { return(TranslateNode(convertNode.Source)); } ParameterAliasNode parameterAliasNode = node as ParameterAliasNode; if (parameterAliasNode != null) { return(parameterAliasNode.Alias); } //return node.ToString(); throw Error.NotSupported(SRResources.CannotRecognizeNodeType, typeof(ODataPathSegmentHandler), node.GetType().FullName); }
private static string TranslateNode(object node) { Contract.Assert(node != null); ConstantNode constantNode = node as ConstantNode; if (constantNode != null) { UriTemplateExpression uriTemplateExpression = constantNode.Value as UriTemplateExpression; if (uriTemplateExpression != null) { return(uriTemplateExpression.LiteralText); } // Make the enum prefix free to work. ODataEnumValue enumValue = constantNode.Value as ODataEnumValue; if (enumValue != null) { return(ODataUriUtils.ConvertToUriLiteral(enumValue, ODataVersion.V4)); } return(constantNode.LiteralText); } ConvertNode convertNode = node as ConvertNode; if (convertNode != null) { return(TranslateNode(convertNode.Source)); } ParameterAliasNode parameterAliasNode = node as ParameterAliasNode; if (parameterAliasNode != null) { return(parameterAliasNode.Alias); } //return node.ToString(); throw new NotSupportedException($"Cannot recongnize {node.GetType().FullName}"); }
internal static IDictionary <string, string> BuildKeyMappings(IEnumerable <KeyValuePair <string, object> > keys) { Contract.Assert(keys != null); Dictionary <string, string> parameterMappings = new Dictionary <string, string>(); foreach (KeyValuePair <string, object> key in keys) { string nameInRouteData; UriTemplateExpression uriTemplateExpression = key.Value as UriTemplateExpression; if (uriTemplateExpression != null) { nameInRouteData = uriTemplateExpression.LiteralText.Trim(); } else { // just for easy construct the key segment template // it must start with "{" and end with "}" nameInRouteData = key.Value as string; } if (nameInRouteData == null || !RoutingConventionHelpers.IsRouteParameter(nameInRouteData)) { throw new ODataException( Error.Format(SRResources.KeyTemplateMustBeInCurlyBraces, key.Value, key.Key)); } nameInRouteData = nameInRouteData.Substring(1, nameInRouteData.Length - 2); if (String.IsNullOrEmpty(nameInRouteData)) { throw new ODataException( Error.Format(SRResources.EmptyKeyTemplate, key.Value, key.Key)); } parameterMappings[key.Key] = nameInRouteData; } return(parameterMappings); }
internal static string TranslateNode(object node) { ConstantNode constantNode = node as ConstantNode; if (constantNode != null) { UriTemplateExpression uriTemplateExpression = constantNode.Value as UriTemplateExpression; if (uriTemplateExpression != null) { return(uriTemplateExpression.LiteralText); } // Make the enum prefix free to work. ODataEnumValue enumValue = constantNode.Value as ODataEnumValue; if (enumValue != null) { return(ODataUriUtils.ConvertToUriLiteral(enumValue, ODataVersion.V4)); } return(constantNode.LiteralText); } ConvertNode convertNode = node as ConvertNode; if (convertNode != null) { return(TranslateNode(convertNode.Source)); } ParameterAliasNode parameterAliasNode = node as ParameterAliasNode; if (parameterAliasNode != null) { return(parameterAliasNode.Alias); } return(ODataUriUtils.ConvertToUriLiteral(node, ODataVersion.V4)); }
public void BuildKeyMappings_ReturnsKeyMapping_UriTemplateExpression() { // Arrange EdmEntityType customerType = new EdmEntityType("NS", "Customer"); EdmStructuralProperty idProperty = customerType.AddStructuralProperty("customerId", EdmPrimitiveTypeKind.Int32); customerType.AddKeys(idProperty); // The properties of UriTemplateExpression are internal set. // We use the reflect to set the value. PropertyInfo literalText = typeof(UriTemplateExpression).GetProperty("LiteralText"); Assert.NotNull(literalText); PropertyInfo expectedType = typeof(UriTemplateExpression).GetProperty("ExpectedType"); Assert.NotNull(expectedType); UriTemplateExpression tempateExpression = new UriTemplateExpression(); literalText.SetValue(tempateExpression, "{yourId}"); expectedType.SetValue(tempateExpression, idProperty.Type); IDictionary <string, object> keys = new Dictionary <string, object> { { "customerId", tempateExpression } }; // Arrange IDictionary <string, string> mapped = KeySegmentTemplate.BuildKeyMappings(keys, customerType); // Assert Assert.NotNull(mapped); KeyValuePair <string, string> actual = Assert.Single(mapped); Assert.Equal("customerId", actual.Key); Assert.Equal("yourId", actual.Value); }
private static UriTemplateExpression BuildExpression(string value, object expectType = null) { // The properties of UriTemplateExpression are internal set. // We use the reflect to set the value. PropertyInfo literalText = typeof(UriTemplateExpression).GetProperty("LiteralText"); Assert.NotNull(literalText); PropertyInfo expectedType = typeof(UriTemplateExpression).GetProperty("ExpectedType"); Assert.NotNull(expectedType); UriTemplateExpression tempateExpression = new UriTemplateExpression(); literalText.SetValue(tempateExpression, value); if (expectType != null) { expectedType.SetValue(tempateExpression, expectType); } return(tempateExpression); }