public static bool Succeeded(this IAuthorizationResult result, bool failedIfNotHandled = true)
{
switch (result.Result)
{
case PolicyResult.Success:
return(true);
case PolicyResult.Failed:
return(false);
case PolicyResult.NotHandled:
default:
return(!failedIfNotHandled);
}
}
private static object[] PrepareHandlerMethodParameters(MethodInfo method, IServiceProvider services, HttpContext httpContext, IAuthorizationResult authorizationResult)
{
ParameterInfo[] parameters = method.GetParameters();
if (parameters.Length <= 0)
{
return(null);
}
object[] result = new object[parameters.Length];
object value;
int i = 0;
foreach (ParameterInfo parameter in parameters)
{
if (parameter.ParameterType.Equals(typeof(HttpContext)))
{
result[i] = httpContext;
}
else if (parameter.ParameterType.Equals(typeof(IAuthorizationResult)))
{
result[i] = authorizationResult;
}
else
{
value = services.GetService(parameter.ParameterType);
if (value == null)
{
if (parameter.HasDefaultValue)
{
value = parameter.DefaultValue;
}
else
{
value = parameter.ParameterType.IsValueType ? Activator.CreateInstance(parameter.ParameterType) : null;
}
}
result[i] = value;
}
i++;
}
return(result);
}
public string Index([FromServices] IAuthorizationResult result)
{
return($"hello, index, {result}");
}
internal void CombineAsAnd(IAuthorizationResult result)
{
if (!result.IsAuthorizationRequired)
{
return;
}
if (!IsAuthorizationRequired)
{
expression = (IPolicyExpressionRootCombine)result.Expression;
this.result = expression.Result;
foreach (string key in result.SucceededPolicies)
{
policyResults.Add(key, PolicyResult.Success);
succeededPolicies.Add(key);
}
foreach (string key in result.FailedPolicies)
{
policyResults.Add(key, PolicyResult.Failed);
failedPolicies.Add(key);
}
foreach (string key in result.NotHandledPolicies)
{
policyResults.Add(key, PolicyResult.NotHandled);
notHandledPolicies.Add(key);
}
return;
}
foreach (string key in result.SucceededPolicies)
{
if (policyResults.TryGetValue(key, out PolicyResult policyResult))
{
switch (policyResult)
{
case PolicyResult.Success:
case PolicyResult.Failed:
// keep
break;
case PolicyResult.NotHandled:
default:
// overwrite
policyResults[key] = PolicyResult.Success;
succeededPolicies.Add(key);
notHandledPolicies.Remove(key);
break;
}
}
else
{
policyResults.Add(key, PolicyResult.Success);
succeededPolicies.Add(key);
}
}
foreach (string key in result.FailedPolicies)
{
if (policyResults.TryGetValue(key, out PolicyResult policyResult))
{
switch (policyResult)
{
case PolicyResult.Success:
case PolicyResult.Failed:
// keep
break;
case PolicyResult.NotHandled:
default:
// overwrite
policyResults[key] = PolicyResult.Failed;
failedPolicies.Add(key);
notHandledPolicies.Remove(key);
break;
}
}
else
{
policyResults.Add(key, PolicyResult.Failed);
failedPolicies.Add(key);
}
}
foreach (string key in result.NotHandledPolicies)
{
if (!policyResults.ContainsKey(key))
{
policyResults.Add(key, PolicyResult.NotHandled);
notHandledPolicies.Add(key);
}
}
expression.Combine(result.Expression, PolicyOperator.And);
this.result = expression.Result;
}
internal IActionResult Execute(HttpContext httpContext, IAuthorizationResult result)
{
return(FailedHelper.ExecuteHandler(Handler, ConstructParameters, httpContext, result));
}
internal static IActionResult ExecuteHandler(Type handler, object[] constructParameters, HttpContext httpContext, IAuthorizationResult authorizationResult)
{
IServiceProvider services = httpContext.RequestServices;
IHandlerInvokeMethodCache cache = services.GetRequiredService <IHandlerInvokeMethodCache>();
InvokeMethodInfo methodInfo = cache.Get(handler);
if (methodInfo != null)
{
return(ExecuteMethod(methodInfo));
}
return(null);
IActionResult ExecuteMethod(InvokeMethodInfo info)
{
try
{
MethodInfo method = info.Method;
object handler_instance = ActivatorUtilities.CreateInstance(services, handler, constructParameters);
object invoke_result = method.Invoke(handler_instance, PrepareHandlerMethodParameters(method, services, httpContext, authorizationResult));
switch (info.ReturnType)
{
case InvokeMethodReturnType.Void:
return(null);
case InvokeMethodReturnType.Task:
{
Task result = (Task)invoke_result;
if (result == null)
{
return(null);
}
if (result.Status == TaskStatus.WaitingToRun || result.Status == TaskStatus.Created)
{
result.Start();
}
result.Wait();
return(null);
}
case InvokeMethodReturnType.TaskWithIActionResult:
{
object awaiter = info.GetAwaiter.Invoke(invoke_result, null);
IActionResult result = (IActionResult)info.GetResult.Invoke(awaiter, null);
if (result == null)
{
return(null);
}
return(result);
}
case InvokeMethodReturnType.IActionResult:
default:
{
IActionResult result = (IActionResult)invoke_result;
if (result == null)
{
return(null);
}
return(result);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
return(null);
}
}
}
