internal static IEnumerable <ODataActionItem> GetActionItems(Content content, ODataRequest request, HttpContext httpContext)
{
return(GetActionsWithScenario(content, request, httpContext).Select(a => new ODataActionItem
{
Name = a.Action.Name,
OpId = ODataTools.GetOperationId(a.Action.Name, a.Action.ActionParameters),
DisplayName = SNSR.GetString(a.Action.Text),
Icon = a.Action.Icon,
Index = a.Action.Index,
Url = a.Action.Uri,
Forbidden = a.Action.Forbidden,
IsODataAction = a.Action.IsODataOperation,
ActionParameters = a.Action.ActionParameters.Select(p => p.Name).ToArray(),
Scenario = a.Scenario
}));
}
private ODataOperation CreateOdataOperation(ActionBase a, string selfUrl)
{
return(new ODataOperation
{
Title = SNSR.GetString(a.Text),
Name = a.Name,
OpId = ODataTools.GetOperationId(a.Name, a.ActionParameters),
Target = string.Concat(selfUrl, "/", a.Name),
Forbidden = a.Forbidden,
Parameters = a.ActionParameters.Select(p => new ODataOperationParameter
{
Name = p.Name,
Type = ResolveODataParameterType(p.Type),
Required = p.Required
}).ToArray()
});
}
protected ODataSimpleMeta GetMetadata(Content content, string selfurl, MetadataFormat format, HttpContext httpContext)
{
if (format == MetadataFormat.Minimal)
{
return(new ODataSimpleMeta
{
Uri = selfurl,
Type = content.ContentType.Name,
});
}
var snActions = ODataTools.GetActions(content, this.Request, httpContext).ToArray();
return(new ODataFullMeta
{
Uri = selfurl,
Type = content.ContentType.Name,
Actions = snActions.Where(a => a.CausesStateChange && a.IsODataOperation).Select(a => CreateOdataOperation(a, selfurl)).OrderBy(x => x.Title).ToArray(),
Functions = snActions.Where(a => !a.CausesStateChange && a.IsODataOperation).Select(a => CreateOdataOperation(a, selfurl)).OrderBy(x => x.Title).ToArray(),
});
}
protected ODataActionItem[] GetActions(Content content, HttpContext httpContext)
{
return(ODataTools.GetActionItems(content, this.Request, httpContext).ToArray());
}
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);
}
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);
}
public object ToArray(Type expectedType, out Type realType)
{
var array = (JArray)GetUnifiedToken();
realType = expectedType;
try
{
if (expectedType == typeof(string[]))
{
return(array.Select(x => x.ToObject <string>()).ToArray());
}
if (expectedType == typeof(int[]))
{
return(array.Select(x => x.ToObject <int>()).ToArray());
}
if (expectedType == typeof(long[]))
{
return(array.Select(x => x.ToObject <long>()).ToArray());
}
if (expectedType == typeof(bool[]))
{
return(array.Select(x => x.ToObject <bool>()).ToArray());
}
if (expectedType == typeof(float[]))
{
return(array.Select(x => x.ToObject <float>()).ToArray());
}
if (expectedType == typeof(double[]))
{
return(array.Select(x => x.ToObject <double>()).ToArray());
}
if (expectedType == typeof(decimal[]))
{
return(array.Select(x => x.ToObject <decimal>()).ToArray());
}
if (expectedType == typeof(List <string>))
{
return(array.Select(x => x.ToObject <string>()).ToList());
}
if (expectedType == typeof(List <int>))
{
return(array.Select(x => x.ToObject <int>()).ToList());
}
if (expectedType == typeof(List <long>))
{
return(array.Select(x => x.ToObject <long>()).ToList());
}
if (expectedType == typeof(List <bool>))
{
return(array.Select(x => x.ToObject <bool>()).ToList());
}
if (expectedType == typeof(List <float>))
{
return(array.Select(x => x.ToObject <float>()).ToList());
}
if (expectedType == typeof(List <double>))
{
return(array.Select(x => x.ToObject <double>()).ToList());
}
if (expectedType == typeof(List <decimal>))
{
return(array.Select(x => x.ToObject <decimal>()).ToList());
}
if (expectedType == typeof(IEnumerable <string>))
{
return(array.Select(x => x.ToObject <string>()).ToArray());
}
if (expectedType == typeof(IEnumerable <int>))
{
return(array.Select(x => x.ToObject <int>()).ToArray());
}
if (expectedType == typeof(IEnumerable <long>))
{
return(array.Select(x => x.ToObject <long>()).ToArray());
}
if (expectedType == typeof(IEnumerable <bool>))
{
return(array.Select(x => x.ToObject <bool>()).ToArray());
}
if (expectedType == typeof(IEnumerable <float>))
{
return(array.Select(x => x.ToObject <float>()).ToArray());
}
if (expectedType == typeof(IEnumerable <double>))
{
return(array.Select(x => x.ToObject <double>()).ToArray());
}
if (expectedType == typeof(IEnumerable <decimal>))
{
return(array.Select(x => x.ToObject <decimal>()).ToArray());
}
if (expectedType == typeof(ODataArray <string>))
{
return(new ODataArray <string>((IEnumerable <string>)array.Select(x => x.ToObject <string>()).ToArray()));
}
if (expectedType == typeof(ODataArray <int>))
{
return(new ODataArray <int>(array.Select(x => x.ToObject <int>()).ToArray()));
}
if (expectedType == typeof(ODataArray <long>))
{
return(new ODataArray <long>(array.Select(x => x.ToObject <long>()).ToArray()));
}
if (expectedType == typeof(ODataArray <bool>))
{
return(new ODataArray <bool>(array.Select(x => x.ToObject <bool>()).ToArray()));
}
if (expectedType == typeof(ODataArray <float>))
{
return(new ODataArray <float>(array.Select(x => x.ToObject <float>()).ToArray()));
}
if (expectedType == typeof(ODataArray <double>))
{
return(new ODataArray <double>(array.Select(x => x.ToObject <double>()).ToArray()));
}
if (expectedType == typeof(ODataArray <decimal>))
{
return(new ODataArray <decimal>(array.Select(x => x.ToObject <decimal>()).ToArray()));
}
if (typeof(ODataArray).IsAssignableFrom(expectedType))
{
realType = expectedType;
var ctorParam = array.Select(x => x.ToObject <object>()).ToArray();
return(ODataTools.CreateODataArray(expectedType, ctorParam));
}
realType = typeof(object[]);
return(array.Select(x => x.ToObject <object>()).ToArray());
}
catch
{
// ignored
}
realType = typeof(object);
return(array);
}
