/// <summary>
/// Try to convert a value into an EDM primitive type, if template parsing enabled, the <paramref name="valueText"/> matching
/// template would be converted into corresponding UriTemplateExpression.
/// </summary>
/// <param name="typeReference">the type to convert to (primitive or enum type)</param>
/// <param name="valueText">the value to convert</param>
/// <param name="convertedValue">The converted value, if conversion succeeded.</param>
/// <returns>true if the conversion was successful.</returns>
private bool TryConvertValue(IEdmTypeReference typeReference, string valueText, out object convertedValue)
{
if (typeReference.IsEnum())
{
QueryNode enumNode = null;
if (EnumBinder.TryBindIdentifier(valueText, typeReference.AsEnum(), null, out enumNode))
{
convertedValue = enumNode;
return(true);
}
convertedValue = null;
return(false);
}
IEdmPrimitiveTypeReference primitiveType = typeReference.AsPrimitive();
UriTemplateExpression expression;
if (this.enableUriTemplateParsing && UriTemplateParser.TryParseLiteral(valueText, primitiveType, out expression))
{
convertedValue = expression;
return(true);
}
Type primitiveClrType = EdmLibraryExtensions.GetPrimitiveClrType((IEdmPrimitiveType)primitiveType.Definition, primitiveType.IsNullable);
LiteralParser literalParser = LiteralParser.ForKeys(this.keysAsSegment);
return(literalParser.TryParseLiteral(primitiveClrType, valueText, out convertedValue));
}
private static ICollection <FunctionParameterToken> HandleComplexOrCollectionParameterValueIfExists(IEdmModel model, IEdmOperation operation, ICollection <FunctionParameterToken> parameterTokens, bool enableCaseInsensitive, bool enableUriTemplateParsing = false)
{
ICollection <FunctionParameterToken> partiallyParsedParametersWithComplexOrCollection = new Collection <FunctionParameterToken>();
foreach (FunctionParameterToken paraToken in parameterTokens)
{
FunctionParameterToken funcParaToken;
IEdmOperationParameter functionParameter = operation.FindParameter(paraToken.ParameterName);
if (enableCaseInsensitive && functionParameter == null)
{
functionParameter = ODataUriResolver.ResolveOpearationParameterNameCaseInsensitive(operation, paraToken.ParameterName);
// The functionParameter can not be null here, else this method won't be called.
funcParaToken = new FunctionParameterToken(functionParameter.Name, paraToken.ValueToken);
}
else
{
funcParaToken = paraToken;
}
FunctionParameterAliasToken aliasToken = funcParaToken.ValueToken as FunctionParameterAliasToken;
if (aliasToken != null)
{
aliasToken.ExpectedParameterType = functionParameter.Type;
}
LiteralToken valueToken = funcParaToken.ValueToken as LiteralToken;
string valueStr = null;
if (valueToken != null && (valueStr = valueToken.Value as string) != null && !string.IsNullOrEmpty(valueToken.OriginalText))
{
var lexer = new ExpressionLexer(valueToken.OriginalText, true /*moveToFirstToken*/, false /*useSemicolonDelimiter*/, true /*parsingFunctionParameters*/);
if (lexer.CurrentToken.Kind == ExpressionTokenKind.BracketedExpression)
{
object result;
UriTemplateExpression expression;
if (enableUriTemplateParsing && UriTemplateParser.TryParseLiteral(lexer.CurrentToken.Text, functionParameter.Type, out expression))
{
result = expression;
}
else
{
// ExpressionTokenKind.BracketedExpression means text like [{\"Street\":\"NE 24th St.\",\"City\":\"Redmond\"},{\"Street\":\"Pine St.\",\"City\":\"Seattle\"}]
// so now try convert it into complex or collection type value:
result = ODataUriUtils.ConvertFromUriLiteral(valueStr, ODataVersion.V4, model, functionParameter.Type);
}
LiteralToken newValueToken = new LiteralToken(result, valueToken.OriginalText);
FunctionParameterToken newFuncParaToken = new FunctionParameterToken(funcParaToken.ParameterName, newValueToken);
partiallyParsedParametersWithComplexOrCollection.Add(newFuncParaToken);
continue;
}
}
partiallyParsedParametersWithComplexOrCollection.Add(funcParaToken);
}
return(partiallyParsedParametersWithComplexOrCollection);
}
/// <summary>
/// Try to convert a value into an EDM primitive type, if template parsing enabled, the <paramref name="valueText"/> matching
/// template would be converted into corresponding UriTemplateExpression.
/// </summary>
/// <param name="primitiveType">the type to convert to</param>
/// <param name="valueText">the value to convert</param>
/// <param name="convertedValue">The converted value, if conversion succeeded.</param>
/// <returns>true if the conversion was successful.</returns>
private bool TryConvertValue(IEdmPrimitiveTypeReference primitiveType, string valueText, out object convertedValue)
{
UriTemplateExpression expression;
if (this.enableUriTemplateParsing && UriTemplateParser.TryParseLiteral(valueText, primitiveType, out expression))
{
convertedValue = expression;
return(true);
}
Type primitiveClrType = EdmLibraryExtensions.GetPrimitiveClrType((IEdmPrimitiveType)primitiveType.Definition, primitiveType.IsNullable);
LiteralParser literalParser = LiteralParser.ForKeys(this.keysAsSegments);
return(literalParser.TryParseLiteral(primitiveClrType, valueText, out convertedValue));
}
private static ICollection <FunctionParameterToken> HandleComplexOrCollectionParameterValueIfExists(IEdmModel model, IEdmOperation functionOrOpertion, ICollection <FunctionParameterToken> parameterTokens, bool enableUriTemplateParsing = false)
{
ICollection <FunctionParameterToken> partiallyParsedParametersWithComplexOrCollection = new Collection <FunctionParameterToken>();
foreach (FunctionParameterToken funcParaToken in parameterTokens)
{
LiteralToken valueToken = funcParaToken.ValueToken as LiteralToken;
string valueStr = null;
if (valueToken != null && (valueStr = valueToken.Value as string) != null)
{
var lexer = new ExpressionLexer(valueStr, true /*moveToFirstToken*/, false /*useSemicolonDelimiter*/, true /*parsingFunctionParameters*/);
if (lexer.CurrentToken.Kind == ExpressionTokenKind.BracketedExpression)
{
var functionParameter = functionOrOpertion.FindParameter(funcParaToken.ParameterName);
if (functionParameter == null)
{
throw new ODataException(Strings.ODataParameterWriterCore_ParameterNameNotFoundInOperation(funcParaToken.ParameterName, functionOrOpertion.Name));
}
object result;
UriTemplateExpression expression;
if (enableUriTemplateParsing && UriTemplateParser.TryParseLiteral(lexer.CurrentToken.Text, functionParameter.Type, out expression))
{
result = expression;
}
else
{
// ExpressionTokenKind.BracketedExpression means text like [{\"Street\":\"NE 24th St.\",\"City\":\"Redmond\"},{\"Street\":\"Pine St.\",\"City\":\"Seattle\"}]
// so now try convert it into complex or collection type value:
result = ODataUriUtils.ConvertFromUriLiteral(valueStr, ODataVersion.V4, model, functionParameter.Type);
}
LiteralToken newValueToken = new LiteralToken(result, valueToken.OriginalText);
FunctionParameterToken newFuncParaToken = new FunctionParameterToken(funcParaToken.ParameterName, newValueToken);
partiallyParsedParametersWithComplexOrCollection.Add(newFuncParaToken);
continue;
}
}
partiallyParsedParametersWithComplexOrCollection.Add(funcParaToken);
}
return(partiallyParsedParametersWithComplexOrCollection);
}
/// <summary>Attempts to parse key values from the specified text.</summary>
/// <param name='text'>Text to parse (not null).</param>
/// <param name="allowNamedValues">Set to true if the parser should accept named values
/// so syntax like Name='value'. If this is false, the parsing will fail on such constructs.</param>
/// <param name="allowNull">Set to true if the parser should accept null values.
/// If set to false, the parser will fail on null values.</param>
/// <param name='instance'>After invocation, the parsed key instance.</param>
/// <param name="enableUriTemplateParsing">Whether Uri template parsing is enabled.</param>
/// <returns>
/// true if the key instance was parsed; false if there was a
/// syntactic error.
/// </returns>
/// <remarks>
/// The returned instance contains only string values. To get typed values, a call to
/// TryConvertValues is necessary.
/// </remarks>
private static bool TryParseFromUri(string text, bool allowNamedValues, bool allowNull, out SegmentArgumentParser instance, bool enableUriTemplateParsing)
{
Debug.Assert(text != null, "text != null");
Dictionary <string, string> namedValues = null;
List <string> positionalValues = null;
// parse keys just like function parameters
ExpressionLexer lexer = new ExpressionLexer("(" + text + ")", true, false);
UriQueryExpressionParser exprParser = new UriQueryExpressionParser(ODataUriParserSettings.DefaultFilterLimit /* default limit for parsing key value */, lexer);
var tmp = (new FunctionCallParser(lexer, exprParser)).ParseArgumentListOrEntityKeyList();
if (lexer.CurrentToken.Kind != ExpressionTokenKind.End)
{
instance = null;
return(false);
}
if (tmp.Length == 0)
{
instance = Empty;
return(true);
}
string valueText = null;
foreach (FunctionParameterToken t in tmp)
{
valueText = null;
LiteralToken literalToken = t.ValueToken as LiteralToken;
if (literalToken != null)
{
valueText = literalToken.OriginalText;
// disallow "{...}" if enableUriTemplateParsing is false (which could have been seen as valid function parameter, e.g. array notation)
if (!enableUriTemplateParsing && UriTemplateParser.IsValidTemplateLiteral(valueText))
{
instance = null;
return(false);
}
}
else
{
DottedIdentifierToken dottedIdentifierToken = t.ValueToken as DottedIdentifierToken; // for enum
if (dottedIdentifierToken != null)
{
valueText = dottedIdentifierToken.Identifier;
}
}
if (valueText != null)
{
if (t.ParameterName == null)
{
if (namedValues != null)
{
instance = null; // We cannot mix named and non-named values.
return(false);
}
CreateIfNull(ref positionalValues);
positionalValues.Add(valueText);
}
else
{
if (positionalValues != null)
{
instance = null; // We cannot mix named and non-named values.
return(false);
}
CreateIfNull(ref namedValues);
namedValues.Add(t.ParameterName, valueText);
}
}
else
{
instance = null;
return(false);
}
}
instance = new SegmentArgumentParser(namedValues, positionalValues, false, enableUriTemplateParsing);
return(true);
}
/// <summary>
/// Whether given token is valid for keyPropertyValue, allow Uri template {key} if template parsing is enabled
/// </summary>
/// <param name="token">The literal token to be evaluated.</param>
/// <param name="enableUriTemplateParsing">Whether Uri template parsing is enabled.</param>
/// <returns>Whether token is valid for keyPropertyValue.</returns>
private static bool IsKeyValueToken(ExpressionToken token, bool enableUriTemplateParsing)
{
return(token.IsKeyValueToken || (enableUriTemplateParsing && UriTemplateParser.IsValidTemplateLiteral(token.Text)));
}
