public void OD_OdataArray_Creation_string()
{
var strings = new[] { "item1", "item2", "item3" };
var array = new ODataArray <string>((IEnumerable <string>)strings);
AssertSequenceEqual(strings, array);
}
public void OD_OdataArray_Creation_int()
{
var numbers = new[] { 1, 2, 42 };
var array = new ODataArray <int>(numbers);
AssertSequenceEqual(numbers, array);
}
public void OD_OdataArray_Creation_long()
{
var numbers = new[] { 1L, 2L, 42L };
var array = new ODataArray <long>(numbers);
AssertSequenceEqual(numbers, array);
}
public static bool HasPermission(Content content, ODataArray <string> permissions, string user = null)
{
IUser userObject = null;
if (!string.IsNullOrEmpty(user))
{
userObject = Node.Load <User>(user);
if (userObject == null)
{
throw new ContentNotFoundException("Identity not found: " + user);
}
}
if (permissions == null)
{
throw new ArgumentNullException(nameof(permissions));
}
var permissionNames = permissions;
var permissionArray = permissionNames.Select(GetPermissionTypeByName).ToArray();
return(user == null
? content.Security.HasPermission(permissionArray)
: content.Security.HasPermission(userObject, permissionArray));
}
public void OD_OdataArray_Creation_bool_CSrv()
{
var predicates = new [] { true, false, true };
var array = new ODataArray <bool>(predicates);
AssertSequenceEqual(predicates, array);
}
public void OD_OdataArray_Creation_float()
{
var numbers = new[] { 1.1f, 2.1f, 42.1f };
var array = new ODataArray <float>(numbers);
AssertSequenceEqual(numbers, array);
}
public void OD_OdataArray_Parse_long()
{
var numbers = new[] { 1L, 2L, 42L };
var array = new ODataArray <long>("1, 2, 42");
AssertSequenceEqual(numbers, array);
}
public void OD_OdataArray_Parse_byte()
{
var numbers = new byte[] { 1, 2, 42 };
var array = new ODataArray <byte>("1, 2, 42");
AssertSequenceEqual(numbers, array);
}
public void OD_OdataArray_Parse_bool()
{
var predicates = new[] { true, false, true };
var array = new ODataArray <bool>("true, false, true");
AssertSequenceEqual(predicates, array);
}
public void OD_OdataArray_Parse_int()
{
var numbers = new[] { 1, 2, 42 };
var array = new ODataArray <int>("1, 2, 42");
AssertSequenceEqual(numbers, array);
}
public void OD_OdataArray_Creation_double()
{
var numbers = new[] { 1.1d, 2.1d, 42.1d };
var array = new ODataArray <double>(numbers);
AssertSequenceEqual(numbers, array);
}
public void OD_OdataArray_Parse_string()
{
var strings = new[] { "item1", "item2", "item3" };
var array = new ODataArray <string>("item1, item2, item3");
AssertSequenceEqual(strings, array);
}
public void OD_OdataArray_Creation_decimal()
{
var numbers = new[] { 1.1m, 2.1m, 42.1m };
var array = new ODataArray <decimal>(numbers);
AssertSequenceEqual(numbers, array);
}
public void OD_OdataArray_Creation_byte()
{
var numbers = new byte[] { 1, 2, 42 };
var array = new ODataArray <byte>(numbers);
AssertSequenceEqual(numbers, array);
}
public void OD_OdataArray_Creation_TestItem()
{
var numbers = new[] { 1, 2, 42 };
var items = numbers.Select(x => new TestItem(x)).ToArray();
var array = new ODataArray <TestItem>(items);
AssertSequenceEqual(numbers, array.Select(x => x.Value));
}
public void OD_OdataArray_Parse_TestItem_Error()
{
var numbers = new[] { 1, 2, 42 };
// Incompetent type. Needs TestItemArray
var array = new ODataArray <TestItem>("#1.1, #2.1, #42.1");
AssertSequenceEqual(numbers, array.Select(x => x.Value));
}
public void OD_OdataArray_Parse_float_HU()
{
using (CultureHack("hu-HU"))
{
var numbers = new[] { 1.1f, 2.1f, 42.1f };
var array = new ODataArray <float>("1.1, 2.1, 42.1");
AssertSequenceEqual(numbers, array);
}
}
public void OD_OdataArray_Parse_decimal_US()
{
using (CultureHack("en-US"))
{
var numbers = new[] { 1.1m, 2.1m, 42.1m };
var array = new ODataArray <decimal>("1.1, 2.1, 42.1");
AssertSequenceEqual(numbers, array);
}
}
public void OD_OdataArray_Parse_double_HU_Comma()
{
using (CultureHack("hu"))
{
var numbers = new[] { 1.1d, 2.1d, 42.1d };
var array = new ODataArray <double>("; 1,1; 2,1; 42,1");
AssertSequenceEqual(numbers, array);
}
}
public void OD_OdataArray_Parse_double_HU()
{
using (CultureHack("hu-HU"))
{
var numbers = new[] { 1.1d, 2.1d, 42.1d };
var array = new ODataArray <double>("1.1, 2.1, 42.1");
AssertSequenceEqual(numbers, array);
}
}
/// <summary>
/// Read the <see cref="HttpContent"/> as OData resource set.
/// </summary>
/// <param name="content">The http content.</param>
/// <returns>The OData array.</returns>
public static async Task <ODataArray> ReadAsODataArrayAsync(this HttpContent content)
{
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
Stream stream = await content.ReadAsStreamAsync();
using (JsonDocument doc = await JsonDocument.ParseAsync(stream))
{
JsonElement root = doc.RootElement;
// OData array is an object as:
// {
// "@odata.context":...
// "value" [ ... ]
// }
if (root.ValueKind != JsonValueKind.Object)
{
return(null);
}
if (!root.TryGetProperty("value", out JsonElement value) &&
value.ValueKind != JsonValueKind.Array)
{
return(null);
}
ODataArray odataArray = new ODataArray();
// value array
foreach (var item in value.EnumerateArray())
{
IODataValue itemValue = item.ParseAsODataValue();
odataArray.Add(itemValue);
}
// context uri
odataArray.ContextUri = ReadStringPropertyValue(root, "@odata.context", "@context");
// next link
odataArray.NextLink = ReadStringPropertyValue(root, "@odata.nextlink", "@nextlink");
// odata.count
odataArray.TotalCount = ReadIntPropertyValue(root, "@odata.count", "@count");
return(odataArray);
}
}
/// <summary>
/// Read <see cref="JsonElement"/> as OData value.
/// </summary>
/// <param name="node">The JSON element.</param>
/// <returns>The OData value.</returns>
public static IODataValue ParseAsODataValue(this JsonElement node)
{
switch (node.ValueKind)
{
case JsonValueKind.Object: // A JSON object.
ODataObject odataObject = new ODataObject();
foreach (JsonProperty property in node.EnumerateObject())
{
odataObject[property.Name] = ParseAsODataValue(property.Value);
}
return(odataObject);
case JsonValueKind.Array: // A JSON array.
ODataArray odataArray = new ODataArray();
foreach (JsonElement element in node.EnumerateArray())
{
odataArray.Add(ParseAsODataValue(element));
}
return(odataArray);
case JsonValueKind.String: // A JSON string.
return(new ODataString(node.GetString()));
case JsonValueKind.Number: // A JSON number.
return(ReadNumber(node));
case JsonValueKind.True: // A JSON true.
return(ODataBoolean.True);
case JsonValueKind.False: // A JSON false.
return(ODataBoolean.False);
case JsonValueKind.Null: // A JSON null.
return(ODataNull.Null);
case JsonValueKind.Undefined:
default:
throw new ODataException($"Found an Undefined JSON element '{node.GetRawText()}'!");
}
}
[ODataFunction] public static IEnumerable <int> Optional_ODataArray_Int(Content content, ODataArray <int> a = null) => a;
[ODataFunction] public static IEnumerable <bool> Optional_ODataArray_Bool(Content content, ODataArray <bool> a = null) => a;
private static bool TryParseParameter(Type expectedType, ODataParameterValue parameter, bool strict, out object parsed)
{
if (expectedType == GetTypeAndValue(expectedType, parameter, out parsed))
{
return(true);
}
Type nullableBaseType;
if ((nullableBaseType = Nullable.GetUnderlyingType(expectedType)) != null)
{
expectedType = nullableBaseType;
}
if (!strict)
{
if (parameter.Type == JTokenType.String)
{
var stringValue = parameter.Value <string>();
#region int, long, byte, bool, decimal, float, double
if (expectedType == typeof(int))
{
if (int.TryParse(stringValue, out var v))
{
parsed = v;
return(true);
}
}
else if (expectedType == typeof(long))
{
if (long.TryParse(stringValue, out var v))
{
parsed = v;
return(true);
}
}
else if (expectedType == typeof(byte))
{
if (byte.TryParse(stringValue, out var v))
{
parsed = v;
return(true);
}
}
else if (expectedType == typeof(bool))
{
if (bool.TryParse(stringValue, out var v))
{
parsed = v;
return(true);
}
}
else if (expectedType == typeof(decimal))
{
if (decimal.TryParse(stringValue, out var v))
{
parsed = v;
return(true);
}
if (decimal.TryParse(stringValue, NumberStyles.Any, CultureInfo.InvariantCulture, out v))
{
parsed = v;
return(true);
}
}
else if (expectedType == typeof(float))
{
if (float.TryParse(stringValue, out var v))
{
parsed = v;
return(true);
}
if (float.TryParse(stringValue, NumberStyles.Any, CultureInfo.InvariantCulture, out v))
{
parsed = v;
return(true);
}
}
else if (expectedType == typeof(double))
{
if (double.TryParse(stringValue, out var v))
{
parsed = v;
return(true);
}
if (double.TryParse(stringValue, NumberStyles.Any, CultureInfo.InvariantCulture, out v))
{
parsed = v;
return(true);
}
}
else if (expectedType == typeof(DateTime))
{
if (DateTime.TryParse(stringValue, CultureInfo.CurrentCulture, DateTimeStyles.AssumeUniversal, out var v) ||
DateTime.TryParse(stringValue, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out v))
{
//var date = new DateTime(v.Year, v.Month, v.Day, v.Hour, v.Minute, v.Second, v.Millisecond,
// DateTimeKind.Utc);
parsed = v.ToUniversalTime();
return(true);
}
}
#endregion
#region enum
else if (expectedType.IsEnum)
{
if (int.TryParse(stringValue, out var intValue))
{
parsed = intValue;
return(true);
}
try
{
parsed = Enum.Parse(expectedType, stringValue, true);
return(true);
}
catch
{
// do nothing
}
return(false);
}
#endregion
#region string[]
else if (expectedType == typeof(ODataArray <string>))
{
try
{
parsed = new ODataArray <string>(stringValue);
return(true);
}
catch { /* ignored */ }
}
else if (expectedType == typeof(List <string>))
{
parsed = new List <string> {
stringValue
};
return(true);
}
else if (expectedType == typeof(string[]) || expectedType == typeof(IEnumerable <string>))
{
parsed = new[] { stringValue };
return(true);
}
#endregion
#region int[]
else if (expectedType == typeof(ODataArray <int>))
{
try
{
parsed = new ODataArray <int>(stringValue);
return(true);
}
catch { /* ignored */ }
}
else if (typeof(IEnumerable <int>).IsAssignableFrom(expectedType))
{
if (int.TryParse(stringValue, out var v))
{
if (expectedType == typeof(List <int>))
{
parsed = new List <int> {
v
}
}
;
else
{
parsed = new[] { v }
};
return(true);
}
}
#endregion
#region long[]
else if (expectedType == typeof(ODataArray <long>))
{
try
{
parsed = new ODataArray <long>(stringValue);
return(true);
}
catch { /* ignored */ }
}
else if (typeof(IEnumerable <long>).IsAssignableFrom(expectedType))
{
if (long.TryParse(stringValue, out var v))
{
if (expectedType == typeof(List <long>))
{
parsed = new List <long> {
v
}
}
;
else
{
parsed = new[] { v }
};
return(true);
}
}
#endregion
#region byte[]
else if (expectedType == typeof(ODataArray <byte>))
{
try
{
parsed = new ODataArray <byte>(stringValue);
return(true);
}
catch { /* ignored */ }
}
else if (typeof(IEnumerable <byte>).IsAssignableFrom(expectedType))
{
if (byte.TryParse(stringValue, out var v))
{
if (expectedType == typeof(List <byte>))
{
parsed = new List <byte> {
v
}
}
;
else
{
parsed = new[] { v }
};
return(true);
}
}
#endregion
#region bool[]
else if (expectedType == typeof(ODataArray <bool>))
{
try
{
parsed = new ODataArray <bool>(stringValue);
return(true);
}
catch { /* ignored */ }
}
else if (typeof(IEnumerable <bool>).IsAssignableFrom(expectedType))
{
if (bool.TryParse(stringValue, out var v))
{
if (expectedType == typeof(List <bool>))
{
parsed = new List <bool> {
v
}
}
;
else
{
parsed = new[] { v }
};
return(true);
}
}
#endregion
#region decimal[]
else if (expectedType == typeof(ODataArray <decimal>))
{
try
{
parsed = new ODataArray <decimal>(stringValue);
return(true);
}
catch { /* ignored */ }
}
else if (typeof(IEnumerable <decimal>).IsAssignableFrom(expectedType))
{
if (decimal.TryParse(stringValue, out var v) ||
decimal.TryParse(stringValue, NumberStyles.Any, CultureInfo.InvariantCulture, out v))
{
if (expectedType == typeof(List <decimal>))
{
parsed = new List <decimal> {
v
}
}
;
else
{
parsed = new[] { v }
};
return(true);
}
}
#endregion
#region float[]
else if (expectedType == typeof(ODataArray <float>))
{
try
{
parsed = new ODataArray <float>(stringValue);
return(true);
}
catch { /* ignored */ }
}
else if (typeof(IEnumerable <float>).IsAssignableFrom(expectedType))
{
if (float.TryParse(stringValue, out var v) ||
float.TryParse(stringValue, NumberStyles.Any, CultureInfo.InvariantCulture, out v))
{
if (expectedType == typeof(List <float>))
{
parsed = new List <float> {
v
}
}
;
else
{
parsed = new[] { v }
};
return(true);
}
}
#endregion
#region double[]
else if (expectedType == typeof(ODataArray <double>))
{
try
{
parsed = new ODataArray <double>(stringValue);
return(true);
}
catch { /* ignored */ }
}
else if (typeof(IEnumerable <double>).IsAssignableFrom(expectedType))
{
if (double.TryParse(stringValue, out var v) ||
double.TryParse(stringValue, NumberStyles.Any, CultureInfo.InvariantCulture, out v))
{
if (expectedType == typeof(List <double>))
{
parsed = new List <double> {
v
}
}
;
else
{
parsed = new[] { v }
};
return(true);
}
}
#endregion
else if (typeof(ODataArray).IsAssignableFrom(expectedType))
{
try
{
parsed = ODataTools.CreateODataArray(expectedType, stringValue);
return(true);
}
catch { /* ignored */ }
}
//TODO: try parse further opportunities from string to "expectedType"
}
else if (parameter.Type == JTokenType.Integer)
{
var intValue = parameter.Value <int>();
#region enum
if (expectedType.IsEnum)
{
parsed = intValue;
return(true);
}
#endregion
}
}
parsed = null;
return(false);
}
[ODataFunction] public static IEnumerable <float> Optional_ODataArray_Float(Content content, ODataArray <float> a = null) => a;
[ODataFunction] public static IEnumerable <double> Optional_ODataArray_Double(Content content, ODataArray <double> a = null) => a;
[ODataFunction] public static IEnumerable <decimal> Optional_ODataArray_Decimal(Content content, ODataArray <decimal> a = null) => a;
private static bool TryParseParameter(Type expectedType, ODataParameterValue parameter, bool strict, out object parsed)
{
if (expectedType == GetTypeAndValue(expectedType, parameter, out parsed))
{
return(true);
}
Type nullableBaseType;
if ((nullableBaseType = Nullable.GetUnderlyingType(expectedType)) != null)
{
expectedType = nullableBaseType;
}
if (!strict)
{
if (parameter.Type == JTokenType.String)
{
var stringValue = parameter.Value <string>();
#region int, long, byte, bool, decimal, float, double
if (expectedType == typeof(int))
{
if (int.TryParse(stringValue, out var v))
{
parsed = v;
return(true);
}
}
else if (expectedType == typeof(long))
{
if (long.TryParse(stringValue, out var v))
{
parsed = v;
return(true);
}
}
else if (expectedType == typeof(byte))
{
if (byte.TryParse(stringValue, out var v))
{
parsed = v;
return(true);
}
}
else if (expectedType == typeof(bool))
{
if (bool.TryParse(stringValue, out var v))
{
parsed = v;
return(true);
}
}
else if (expectedType == typeof(decimal))
{
if (decimal.TryParse(stringValue, out var v))
{
parsed = v;
return(true);
}
if (decimal.TryParse(stringValue, NumberStyles.Any, CultureInfo.InvariantCulture, out v))
{
parsed = v;
return(true);
}
}
else if (expectedType == typeof(float))
{
if (float.TryParse(stringValue, out var v))
{
parsed = v;
return(true);
}
if (float.TryParse(stringValue, NumberStyles.Any, CultureInfo.InvariantCulture, out v))
{
parsed = v;
return(true);
}
}
else if (expectedType == typeof(double))
{
if (double.TryParse(stringValue, out var v))
{
parsed = v;
return(true);
}
if (double.TryParse(stringValue, NumberStyles.Any, CultureInfo.InvariantCulture, out v))
{
parsed = v;
return(true);
}
}
#endregion
#region string[]
else if (expectedType == typeof(ODataArray <string>))
{
try
{
parsed = new ODataArray <string>(stringValue);
return(true);
}
catch { /* ignored */ }
}
else if (expectedType == typeof(List <string>))
{
parsed = new List <string> {
stringValue
};
return(true);
}
else if (expectedType == typeof(string[]) || expectedType == typeof(IEnumerable <string>))
{
parsed = new[] { stringValue };
return(true);
}
#endregion
#region int[]
else if (expectedType == typeof(ODataArray <int>))
{
try
{
parsed = new ODataArray <int>(stringValue);
return(true);
}
catch { /* ignored */ }
}
else if (typeof(IEnumerable <int>).IsAssignableFrom(expectedType))
{
if (int.TryParse(stringValue, out var v))
{
if (expectedType == typeof(List <int>))
{
parsed = new List <int> {
v
}
}
;
else
{
parsed = new[] { v }
};
return(true);
}
}
#endregion
#region long[]
else if (expectedType == typeof(ODataArray <long>))
{
try
{
parsed = new ODataArray <long>(stringValue);
return(true);
}
catch { /* ignored */ }
}
else if (typeof(IEnumerable <long>).IsAssignableFrom(expectedType))
{
if (long.TryParse(stringValue, out var v))
{
if (expectedType == typeof(List <long>))
{
parsed = new List <long> {
v
}
}
;
else
{
parsed = new[] { v }
};
return(true);
}
}
#endregion
#region byte[]
else if (expectedType == typeof(ODataArray <byte>))
{
try
{
parsed = new ODataArray <byte>(stringValue);
return(true);
}
catch { /* ignored */ }
}
else if (typeof(IEnumerable <byte>).IsAssignableFrom(expectedType))
{
if (byte.TryParse(stringValue, out var v))
{
if (expectedType == typeof(List <byte>))
{
parsed = new List <byte> {
v
}
}
;
else
{
parsed = new[] { v }
};
return(true);
}
}
#endregion
#region bool[]
else if (expectedType == typeof(ODataArray <bool>))
{
try
{
parsed = new ODataArray <bool>(stringValue);
return(true);
}
catch { /* ignored */ }
}
else if (typeof(IEnumerable <bool>).IsAssignableFrom(expectedType))
{
if (bool.TryParse(stringValue, out var v))
{
if (expectedType == typeof(List <bool>))
{
parsed = new List <bool> {
v
}
}
;
else
{
parsed = new[] { v }
};
return(true);
}
}
#endregion
#region decimal[]
else if (expectedType == typeof(ODataArray <decimal>))
{
try
{
parsed = new ODataArray <decimal>(stringValue);
return(true);
}
catch { /* ignored */ }
}
else if (typeof(IEnumerable <decimal>).IsAssignableFrom(expectedType))
{
if (decimal.TryParse(stringValue, out var v) ||
decimal.TryParse(stringValue, NumberStyles.Any, CultureInfo.InvariantCulture, out v))
{
if (expectedType == typeof(List <decimal>))
{
parsed = new List <decimal> {
v
}
}
;
else
{
parsed = new[] { v }
};
return(true);
}
}
#endregion
#region float[]
else if (expectedType == typeof(ODataArray <float>))
{
try
{
parsed = new ODataArray <float>(stringValue);
return(true);
}
catch { /* ignored */ }
}
else if (typeof(IEnumerable <float>).IsAssignableFrom(expectedType))
{
if (float.TryParse(stringValue, out var v) ||
float.TryParse(stringValue, NumberStyles.Any, CultureInfo.InvariantCulture, out v))
{
if (expectedType == typeof(List <float>))
{
parsed = new List <float> {
v
}
}
;
else
{
parsed = new[] { v }
};
return(true);
}
}
#endregion
#region double[]
else if (expectedType == typeof(ODataArray <double>))
{
try
{
parsed = new ODataArray <double>(stringValue);
return(true);
}
catch { /* ignored */ }
}
else if (typeof(IEnumerable <double>).IsAssignableFrom(expectedType))
{
if (double.TryParse(stringValue, out var v) ||
double.TryParse(stringValue, NumberStyles.Any, CultureInfo.InvariantCulture, out v))
{
if (expectedType == typeof(List <double>))
{
parsed = new List <double> {
v
}
}
;
else
{
parsed = new[] { v }
};
return(true);
}
}
#endregion
else if (typeof(ODataArray).IsAssignableFrom(expectedType))
{
try
{
parsed = ODataTools.CreateODataArray(expectedType, stringValue);
return(true);
}
catch { /* ignored */ }
}
//TODO: try parse further opportunities from string to "expectedType"
}
}
parsed = null;
return(false);
}
[ODataFunction] public static IEnumerable <long> Optional_ODataArray_Long(Content content, ODataArray <long> a = null) => a;
