public void TestCollectionConvertFromBracketCollection()
{
object collection = ODataUriUtils.ConvertFromUriLiteral("[1,2,3]", ODataVersion.V4, HardCodedTestModel.TestModel, new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt32(false))));
IEnumerable items = collection.As <Microsoft.OData.ODataCollectionValue>().Items;
items.Should().Equal(new int[] { 1, 2, 3 });
}
//public async Task<IHttpActionResult> DeleteLink([FromODataUri] int key, string navigationProperty)
//{
// Product product = await db.Products.FindAsync(key);
// if (product == null)
// {
// return NotFound();
// }
// switch (navigationProperty)
// {
// case "Supplier":
// product.Supplier = null;
// await db.SaveChangesAsync();
// return StatusCode(HttpStatusCode.NoContent);
// default:
// return NotFound();
// }
//}
// Helper method to extract the key from an OData link URI.
private TKey GetKeyFromLinkUri <TKey>(Uri link)
{
TKey key = default(TKey);
// Get the route that was used for this request.
IHttpRoute route = Request.GetRouteData().Route;
// Create an equivalent self-hosted route.
IHttpRoute newRoute = new HttpRoute(route.RouteTemplate,
new HttpRouteValueDictionary(route.Defaults),
new HttpRouteValueDictionary(route.Constraints),
new HttpRouteValueDictionary(route.DataTokens), route.Handler);
// Create a fake GET request for the link URI.
var tmpRequest = new HttpRequestMessage(HttpMethod.Get, link);
// Send this request through the routing process.
var routeData = newRoute.GetRouteData(
Request.GetConfiguration().VirtualPathRoot, tmpRequest);
// If the GET request matches the route, use the path segments to find the key.
if (routeData != null)
{
ODataPath path = tmpRequest.GetODataPath();
var segment = path.Segments.OfType <KeyValuePathSegment>().FirstOrDefault();
if (segment != null)
{
// Convert the segment into the key type.
key = (TKey)ODataUriUtils.ConvertFromUriLiteral(
segment.Value, ODataVersion.V3);
}
}
return(key);
}
public IDictionary <string, object> ParseETag(EntityTagHeaderValue etagHeaderValue)
{
if (etagHeaderValue == null)
{
throw Error.ArgumentNull("etagHeaderValue");
}
string tag = etagHeaderValue.Tag.Trim('\"');
// split etag
string[] rawValues = tag.Split(Separator);
IDictionary <string, object> properties = new Dictionary <string, object>();
for (int index = 0; index < rawValues.Length; index++)
{
string rawValue = rawValues[index];
// base64 decode
byte[] bytes = Convert.FromBase64String(rawValue);
string valueString = Encoding.UTF8.GetString(bytes);
object obj = ODataUriUtils.ConvertFromUriLiteral(valueString, ODataVersion.V4);
if (obj is ODataNullValue)
{
obj = null;
}
properties.Add(index.ToString(CultureInfo.InvariantCulture), obj);
}
return(properties);
}
public void TestEnumConvertFromUriLiteral_EnumName()
{
ODataEnumValue enumVal = (ODataEnumValue)ODataUriUtils.ConvertFromUriLiteral("Fully.Qualified.Namespace.ColorPattern'Red'", ODataVersion.V4, HardCodedTestModel.TestModel, null);
enumVal.Value.Should().Be(1L + "");
enumVal.TypeName.Should().Be("Fully.Qualified.Namespace.ColorPattern");
}
public override string SelectAction(ODataPath odataPath, HttpControllerContext controllerContext, ILookup <string, HttpActionDescriptor> actionMap)
{
HttpMethod httpMethod = controllerContext.Request.Method;
if (httpMethod != HttpMethod.Get)
{
return(null);
}
if (odataPath.PathTemplate == "~/entityset/key/navigation/key")
{
KeyValuePathSegment segment = (KeyValuePathSegment)odataPath.Segments[1];
object value = ODataUriUtils.ConvertFromUriLiteral(segment.Value, ODataVersion.V4);
controllerContext.RouteData.Values.Add("key", value);
segment = (KeyValuePathSegment)odataPath.Segments[3];
value = ODataUriUtils.ConvertFromUriLiteral(segment.Value, ODataVersion.V4);
controllerContext.RouteData.Values.Add("relatedKey", value);
NavigationPathSegment property = odataPath.Segments[2] as NavigationPathSegment;
// controllerContext.RouteData.Values.Add("propertyName", property.NavigationProperty.Name);
return("Get" + property.NavigationProperty.Name);
}
return(null);
}
public static Tkey GetKeyFromUri <Tkey>(HttpRequestMessage request, Uri uri)
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
var urlHelper = request.GetUrlHelper() ?? new UrlHelper(request);
string serviceRoot = urlHelper.CreateODataLink(
request.ODataProperties().RouteName,
request.ODataProperties().PathHandler,
new List <ODataPathSegment>());
var odataPath = request.ODataProperties().PathHandler.Parse(
request.ODataProperties().Model,
serviceRoot, uri.LocalPath);
var keySegment = odataPath.Segments.OfType <KeyValuePathSegment>().FirstOrDefault();
if (keySegment == null)
{
throw new InvalidOperationException("The link does not contain a key.");
}
var value = ODataUriUtils.ConvertFromUriLiteral(keySegment.Value, ODataVersion.V4);
return((Tkey)value);
}
public void TestEnumConvertFromUriLiteral_EnumLong()
{
ODataEnumValue enumVal = (ODataEnumValue)ODataUriUtils.ConvertFromUriLiteral("Fully.Qualified.Namespace.ColorPattern'11'", ODataVersion.V4, HardCodedTestModel.TestModel, null);
Assert.Equal(11L + "", enumVal.Value);
Assert.Equal("Fully.Qualified.Namespace.ColorPattern", enumVal.TypeName);
}
public void TestEnumConvertFromUriLiteral_EnumName_Combined()
{
ODataEnumValue enumVal = (ODataEnumValue)ODataUriUtils.ConvertFromUriLiteral("Fully.Qualified.Namespace.ColorPattern'Red,Solid,BlueYellowStriped'", ODataVersion.V4, HardCodedTestModel.TestModel, null);
Assert.Equal(31L + "", enumVal.Value);
Assert.Equal("Fully.Qualified.Namespace.ColorPattern", enumVal.TypeName);
}
/// <summary>
/// Gets the parameter value.
/// </summary>
/// <param name="parameterName">The name of the parameter.</param>
/// <returns> The value of the parameter. </returns>
public object GetParameterValue(string parameterName)
{
if (String.IsNullOrEmpty(parameterName))
{
throw Error.ArgumentNullOrEmpty("parameterName");
}
string paramValue;
if (Values.TryGetValue(parameterName, out paramValue))
{
IEdmOperationParameter edmParam = Function.FindParameter(parameterName);
if (edmParam != null)
{
IEdmTypeReference edmType = edmParam.Type;
if (edmParam.Type.IsCollection())
{
IEdmCollectionTypeReference collectionTypeReference = edmParam.Type.AsCollection();
edmType = collectionTypeReference.ElementType();
}
// for entity or collection of entity, return the string literal from Uri.
if (edmType.Definition.TypeKind == EdmTypeKind.Entity)
{
return(paramValue);
}
return(ODataUriUtils.ConvertFromUriLiteral(paramValue, ODataVersion.V4, _edmModel, edmParam.Type));
}
}
throw Error.Argument("parameterName", SRResources.FunctionParameterNotFound, parameterName);
}
// DFTODO - this cannot be the final solution - way to much overhead
public static T GetKeyFromLinkUri <T>(this ODataController controller, Uri link)
{
Contract.Requires(null != link);
T key = default(T);
IHttpRoute route = controller.Request.GetRouteData().Route;
IHttpRoute newRoute = new HttpRoute(
route.RouteTemplate
,
new HttpRouteValueDictionary(route.Defaults)
,
new HttpRouteValueDictionary(route.Constraints)
,
new HttpRouteValueDictionary(route.DataTokens), route.Handler
);
var newRequest = new HttpRequestMessage(HttpMethod.Get, link);
var routeData = newRoute.GetRouteData(controller.Request.GetConfiguration().VirtualPathRoot, newRequest);
if (null != routeData)
{
ODataPath path = newRequest.ODataProperties().Path;
System.Diagnostics.Trace.Assert(null != path);
var segment = path.Segments.OfType <KeyValuePathSegment>().FirstOrDefault();
if (null != segment)
{
key = (T)ODataUriUtils.ConvertFromUriLiteral(segment.Value, ODataVersion.V3);
}
}
return(key);
}
public static TKey GetKeyFromUri <TKey>(HttpRequestMessage request, Uri uri)
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
var urlHelper = request.GetUrlHelper() ?? new UrlHelper(request);
var routeName = request.ODataProperties().RouteName;
ODataRoute oDataRoute = request.GetConfiguration().Routes[routeName] as ODataRoute;
var prefixName = oDataRoute.RoutePrefix;
var requestUri = request.RequestUri.ToString();
string serviceRoot = requestUri.Substring(0, requestUri.IndexOf(prefixName) + prefixName.Length);
var odataPath = request.ODataProperties().Path;
var keySegment = odataPath.Segments.OfType <KeySegmentTemplate>().LastOrDefault().Segment.Keys.LastOrDefault();
if (keySegment.Key == null)
{
throw new InvalidOperationException("The link does not contain a key.");
}
var value = ODataUriUtils.ConvertFromUriLiteral(keySegment.Value.ToString(), ODataVersion.V4);
return((TKey)value);
}
private object ConvertNode(object node, IEdmTypeReference typeReference)
{
// TODO: maybe find a better solution to do the convert.
if (node == null)
{
return(null);
}
ConstantNode constantNode = node as ConstantNode;
if (constantNode == null)
{
return(node);
}
if (constantNode.Value is UriTemplateExpression)
{
return(node);
}
if (constantNode.Value is ODataEnumValue)
{
return(node);
}
string literal = constantNode.LiteralText;
object convertValue = ODataUriUtils.ConvertFromUriLiteral(literal, ODataVersion.V4, _model, typeReference);
return(new ConstantNode(convertValue, literal, typeReference));
}
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);
}
public void TestCollectionConvertFromBracketCollection()
{
object collection = ODataUriUtils.ConvertFromUriLiteral("[1,2,3]", ODataVersion.V4, HardCodedTestModel.TestModel, new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt32(false))));
var collectionValue = Assert.IsType <ODataCollectionValue>(collection);
Assert.Equal(3, collectionValue.Items.Count());
Assert.Equal(new int[] { 1, 2, 3 }, collectionValue.Items.Cast <int>());
}
public void TestIntegerConvertFromUriLiteralThrowOverflow(string value)
{
var numberType = EdmCoreModel.Instance.GetInt16(true);
Action test = () => ODataUriUtils.ConvertFromUriLiteral(value, ODataVersion.V4, EdmCoreModel.Instance, numberType);
test.Throws <ODataException>(Strings.ODataUriUtils_ConvertFromUriLiteralOverflowNumber("Edm.Int16", "Value was either too large or too small for an Int16."));
}
public static IList <OperationSegmentParameter> Match(ODataTemplateTranslateContext context, IEdmFunction function,
IDictionary <string, string> parameterMappings)
{
Contract.Assert(context != null);
Contract.Assert(function != null);
Contract.Assert(parameterMappings != null);
RouteValueDictionary routeValues = context.RouteValues;
IList <OperationSegmentParameter> parameters = new List <OperationSegmentParameter>();
foreach (var parameter in parameterMappings)
{
string parameterName = parameter.Key;
string parameterTemp = parameter.Value;
IEdmOperationParameter edmParameter = function.Parameters.FirstOrDefault(p => p.Name == parameterName);
Contract.Assert(edmParameter != null);
// For a parameter mapping like: minSalary={min}
// and a request like: ~/MyFunction(minSalary=2)
// the routeValue includes the [min=2], so we should use the mapping name to retrieve the value.
if (routeValues.TryGetValue(parameterTemp, out object rawValue))
{
string strValue = rawValue as string;
strValue = context.GetParameterAliasOrSelf(strValue);
// for resource or collection resource, this method will return "ODataResourceValue, ..." we should support it.
if (edmParameter.Type.IsResourceOrCollectionResource())
{
// For FromODataUri
string prefixName = ODataParameterValue.ParameterValuePrefix + parameterTemp;
routeValues[prefixName] = new ODataParameterValue(strValue, edmParameter.Type);
parameters.Add(new OperationSegmentParameter(parameterName, strValue));
}
else
{
object newValue = ODataUriUtils.ConvertFromUriLiteral(strValue, ODataVersion.V4, context.Model, edmParameter.Type);
// for without FromODataUri, so update it, for example, remove the single quote for string value.
routeValues[parameterTemp] = newValue;
// For FromODataUri
string prefixName = ODataParameterValue.ParameterValuePrefix + parameterTemp;
routeValues[prefixName] = new ODataParameterValue(newValue, edmParameter.Type);
parameters.Add(new OperationSegmentParameter(parameterName, newValue));
}
}
else
{
return(null);
}
}
return(parameters);
}
public void TestDateTimeOffsetConvertFromUriLiteral()
{
DateTimeOffset dtoValue1 = (DateTimeOffset)ODataUriUtils.ConvertFromUriLiteral("1997-07-01", ODataVersion.V4, HardCodedTestModel.TestModel, EdmCoreModel.Instance.GetDateTimeOffset(false));
dtoValue1.Should().Be(new DateTimeOffset(new DateTime(1997, 7, 1)));
DateTimeOffset dtoValue2 = (DateTimeOffset)ODataUriUtils.ConvertFromUriLiteral("1997-07-01", ODataVersion.V4);
dtoValue2.Should().Be(new DateTimeOffset(new DateTime(1997, 7, 1)));
}
public void TestDecimalConvertFromUriLiteral(string value)
{
object dec = ODataUriUtils.ConvertFromUriLiteral(value, ODataVersion.V4);
#if NETCOREAPP3_1
Assert.True(dec is double || dec is decimal);
#else
Assert.True(dec is decimal);
#endif
}
public void TestTimeOfDayConvertFromUriLiteral()
{
TimeOfDay timeValue1 = (TimeOfDay)ODataUriUtils.ConvertFromUriLiteral("12:13:14.015", ODataVersion.V4, HardCodedTestModel.TestModel, EdmCoreModel.Instance.GetTimeOfDay(false));
Assert.Equal(new TimeOfDay(12, 13, 14, 15), timeValue1);
TimeOfDay timeValue2 = (TimeOfDay)ODataUriUtils.ConvertFromUriLiteral("12:13:14.015", ODataVersion.V4);
Assert.Equal(new TimeOfDay(12, 13, 14, 15), timeValue2);
}
public void TestIntegerConvertFromUriLiteral(EdmPrimitiveTypeKind kind, object expected)
{
Type expectedType = expected.GetType();
var numberType = EdmCoreModel.Instance.GetPrimitive(kind, true);
object primitiveValue = ODataUriUtils.ConvertFromUriLiteral("2", ODataVersion.V4, EdmCoreModel.Instance, numberType);
Assert.IsType(expectedType, primitiveValue);
Assert.Equal(expected, primitiveValue);
}
public void TestSingleConvertFromUriLiteral(string value)
{
object singleNumber = ODataUriUtils.ConvertFromUriLiteral(value, ODataVersion.V4);
#if NETCOREAPP3_1
Assert.True(singleNumber is float || singleNumber is double);
#else
Assert.True(singleNumber is float);
#endif
}
public override bool TryTranslate(ODataTemplateTranslateContext context)
{
if (context == null)
{
throw Error.ArgumentNull(nameof(context));
}
RouteValueDictionary routeValues = context.RouteValues;
RouteValueDictionary updateValues = context.UpdatedValues;
IDictionary <string, object> keysValues = new Dictionary <string, object>();
foreach (var key in KeyMappings)
{
string keyName = key.Key;
string templateName = key.Value;
if (routeValues.TryGetValue(templateName, out object rawValue))
{
IEdmProperty keyProperty = KeyProperties.FirstOrDefault(k => k.Key == keyName).Value;
Contract.Assert(keyProperty != null);
IEdmTypeReference edmType = keyProperty.Type;
string strValue = rawValue as string;
string newStrValue = context.GetParameterAliasOrSelf(strValue);
if (newStrValue != strValue)
{
updateValues[templateName] = newStrValue;
strValue = newStrValue;
}
object newValue;
try
{
newValue = ODataUriUtils.ConvertFromUriLiteral(strValue, ODataVersion.V4, context.Model, edmType);
}
catch
{
return(false);
}
// for non FromODataUri, so update it, for example, remove the single quote for string value.
updateValues[templateName] = newValue;
// For FromODataUri, let's refactor it later.
string prefixName = ODataParameterValue.ParameterValuePrefix + templateName;
updateValues[prefixName] = new ODataParameterValue(newValue, edmType);
keysValues[keyName] = newValue;
}
}
context.Segments.Add(new KeySegment(keysValues, EntityType, NavigationSource));
return(true);
}
public void TestLongConvertFromUriLiteral()
{
object longNumber = ODataUriUtils.ConvertFromUriLiteral("9223372036854775807", ODataVersion.V4);
(longNumber is long).Should().Be(true);
longNumber = ODataUriUtils.ConvertFromUriLiteral("-9223372036854775808", ODataVersion.V4);
(longNumber is long).Should().Be(true);
longNumber = ODataUriUtils.ConvertFromUriLiteral("123L", ODataVersion.V4);
(longNumber is long).Should().Be(true);
}
public void TestDoubleConvertFromUriLiteral()
{
object doubleNumber = ODataUriUtils.ConvertFromUriLiteral("1.7976931348623157E+308", ODataVersion.V4);
(doubleNumber is double).Should().Be(true);
doubleNumber = ODataUriUtils.ConvertFromUriLiteral("-1.7976931348623157E+308", ODataVersion.V4);
(doubleNumber is double).Should().Be(true);
doubleNumber = ODataUriUtils.ConvertFromUriLiteral("1000000000000D", ODataVersion.V4);
(doubleNumber is double).Should().Be(true);
}
public void TestDecimalConvertFromUriLiteral()
{
object dec = ODataUriUtils.ConvertFromUriLiteral("79228162514264337593543950335", ODataVersion.V4);
(dec is decimal).Should().Be(true);
dec = ODataUriUtils.ConvertFromUriLiteral("-79228162514264337593543950335", ODataVersion.V4);
(dec is decimal).Should().Be(true);
dec = ODataUriUtils.ConvertFromUriLiteral("112M", ODataVersion.V4);
(dec is decimal).Should().Be(true);
}
public void TestSingleConvertFromUriLiteral()
{
object singleNumber = ODataUriUtils.ConvertFromUriLiteral("3.40282347E+38", ODataVersion.V4);
(singleNumber is float).Should().Be(true);
singleNumber = ODataUriUtils.ConvertFromUriLiteral("-3.40282347E+38", ODataVersion.V4);
(singleNumber is float).Should().Be(true);
singleNumber = ODataUriUtils.ConvertFromUriLiteral("1000000000000f", ODataVersion.V4);
(singleNumber is float).Should().Be(true);
}
private static IReadOnlyDictionary <string, object> GetPathKeyValues(
KeyValuePathSegment keySegment,
IEdmEntityType entityType)
{
var result = new Dictionary <string, object>();
var keys = entityType.Key();
// TODO GitHubIssue#42 : Improve key parsing logic
// this parsing implementation does not allow key values to contain commas
// Depending on the WebAPI to make KeyValuePathSegment.Values collection public
// (or have the parsing logic public).
string[] values = keySegment.Value.Split(EntityKeySeparator);
if (values.Length > 1)
{
foreach (string value in values)
{
// Split key name and key value
var keyValues = value.Split(EntityKeyNameValueSeparator);
if (keyValues.Length != 2)
{
throw new InvalidOperationException(Resources.IncorrectKeyFormat);
}
// Validate the key name
if (!keys.Select(k => k.Name).Contains(keyValues[0]))
{
throw new InvalidOperationException(
string.Format(
CultureInfo.InvariantCulture,
Resources.KeyNotValidForEntityType,
keyValues[0],
entityType.Name));
}
result.Add(keyValues[0], ODataUriUtils.ConvertFromUriLiteral(keyValues[1], ODataVersion.V4));
}
}
else
{
// We just have the single key value
// Validate it has exactly one key
if (keys.Count() > 1)
{
throw new InvalidOperationException(Resources.MultiKeyValuesExpected);
}
var keyName = keys.First().Name;
result.Add(keyName, ODataUriUtils.ConvertFromUriLiteral(keySegment.Value, ODataVersion.V4));
}
return(result);
}
internal static object ConvertTo(string valueString, Type type)
{
if (valueString == null)
{
return(null);
}
// TODO 1668: ODL beta1's ODataUriUtils.ConvertFromUriLiteral does not support converting uri literal
// to ODataEnumValue, but beta1's ODataUriUtils.ConvertToUriLiteral supports converting ODataEnumValue
// to uri literal.
if (TypeHelper.IsEnum(type))
{
string[] values = valueString.Split(new[] { '\'' }, StringSplitOptions.None);
if (values.Length == 3 && String.IsNullOrEmpty(values[2]))
{
// Remove the type name if the enum value is a fully qualified literal.
valueString = values[1];
}
if (type.IsNullable() && String.Equals(valueString, "null", StringComparison.Ordinal))
{
return(null);
}
Type enumType = TypeHelper.GetUnderlyingTypeOrSelf(type);
object[] parameters = new[] { valueString, Enum.ToObject(enumType, 0) };
bool isSuccessful = (bool)enumTryParseMethod.MakeGenericMethod(enumType).Invoke(null, parameters);
if (!isSuccessful)
{
throw Error.InvalidOperation(SRResources.ModelBinderUtil_ValueCannotBeEnum, valueString, type.Name);
}
return(parameters[1]);
}
object value = ODataUriUtils.ConvertFromUriLiteral(valueString, ODataVersion.V4);
bool isNonStandardEdmPrimitive;
EdmLibHelpers.IsNonstandardEdmPrimitive(type, out isNonStandardEdmPrimitive);
if (isNonStandardEdmPrimitive)
{
return(EdmPrimitiveHelpers.ConvertPrimitiveValue(value, type));
}
else
{
type = Nullable.GetUnderlyingType(type) ?? type;
return(Convert.ChangeType(value, type, CultureInfo.InvariantCulture));
}
}
private Object GetArgumentValue(IEdmTypeReference typeReference, GraphQLValue graphValue)
{
if (graphValue is GraphQLScalarValue scalarValue)
{
if (typeReference.IsString())
{
return(scalarValue.Value);
}
return(ODataUriUtils.ConvertFromUriLiteral(scalarValue.Value, ODataVersion.V4, _edmModel, typeReference));
}
throw new NotSupportedException("argument " + graphValue.GetType().Name + " not supported");
}
public void TestDateConvertFromUriLiteral()
{
Date dateValue = (Date)ODataUriUtils.ConvertFromUriLiteral("1997-07-01", ODataVersion.V4, HardCodedTestModel.TestModel, EdmCoreModel.Instance.GetDate(false));
Assert.Equal(new Date(1997, 7, 1), dateValue);
DateTimeOffset dtoValue1 = (DateTimeOffset)ODataUriUtils.ConvertFromUriLiteral("1997-07-01", ODataVersion.V4, HardCodedTestModel.TestModel, EdmCoreModel.Instance.GetDateTimeOffset(false));
Assert.Equal(new DateTimeOffset(1997, 7, 1, 0, 0, 0, new TimeSpan(0)), dtoValue1);
var dtoValue2 = ODataUriUtils.ConvertFromUriLiteral("1997-07-01", ODataVersion.V4);
Assert.Equal(new Date(1997, 7, 1), dtoValue2);
}