public async Task ExecuteHandler(HandlerParams param)
{
bool executed;
var parametrized = handlers.Where(x => x.Parametrized)
.Where(x => x.Attribute.CanHandleInternal(param))
.ToList();
foreach (var eventHandler in parametrized)
{
executed = await Exec(eventHandler, param);
if (executed)
{
return;
}
}
foreach (var eventHandler in handlers.Where(x => !x.Parametrized)
.Where(x => x.Attribute.CanHandleInternal(param)))
{
executed = await Exec(eventHandler, param);
if (executed)
{
return;
}
}
}
private async Task <HandlerExec> Exec(EventHandler handler, HandlerParams param)
{
var provider = param.ServiceProvider;
var method = handler.Method;
try
{
var instance = (BotEventHandler)ActivatorUtilities.CreateInstance(provider, method.DeclaringType);
instance.__Instantiate(param);
object[] paramObjects;
if (handler.Parameters.Length > 0 && handler.Parametrized)
{
var parseOk = param.TryParseParams(handler.Parameters);
var paramses = handler.Parameters;
if (parseOk)
{
paramObjects =
paramses.Select(x =>
{
return(param.CommandParameters
.First(p => p.Position == x.Position)
.TypedValue);
})
.ToArray();
}
else
{
return(HandlerExec.Error);
}
}
else
{
paramObjects = null;
}
if (method.ReturnParameter.ParameterType == typeof(Task))
{
var task = method.Invoke(instance, paramObjects);
await(Task) task;
return(HandlerExec.Continue);
}
else if (method.ReturnParameter.ParameterType == typeof(Task <bool>))
{
var task = method.Invoke(instance, paramObjects);
return(await(Task <bool>) task ? HandlerExec.Continue : HandlerExec.Break);
}
method.Invoke(instance, paramObjects);
return(HandlerExec.Continue);
} catch (ArgumentException e)
{
Console.WriteLine(e);
}
return(HandlerExec.Error);
}
private async void Client_OnUpdate(object sender, UpdateEventArgs e)
{
try
{
await Task.Run(async() =>
{
using (var scope = _scopeFactory.CreateScope())
{
var wares = new Stack <IMiddleware>();
var wareInstances = scope.ServiceProvider.GetServices <IMiddleware>().ToDictionary(x => x.GetType());
var param = new HandlerParams(BotClient, e.Update, scope.ServiceProvider, _userName);
var router = new Router(factory);
router.__Setup(null, param);
wares.Push(router);
if (wareInstances.Count > 0 && _wares.Count > 0)
{
var firstWareType = _wares.First;
if (firstWareType?.Value != null && wareInstances.ContainsKey(firstWareType.Value))
{
var currentWare = wareInstances[firstWareType.Value];
((BaseMiddleware)currentWare).__Setup(router, param);
wares.Push(currentWare);
var nextWareType = firstWareType.Next;
while (nextWareType?.Next != null)
{
var prevWare = wares.Pop();
currentWare = wareInstances[nextWareType.Value];
((BaseMiddleware)currentWare).__Setup(prevWare, param);
wares.Push(currentWare);
}
}
}
var runWare = wares.Pop();
await((BaseMiddleware)runWare).__ProcessInternal();
}
});
} catch (Exception exception)
{
Console.WriteLine(exception);
// throw;
}
}
public async Task ExecuteHandler(HandlerParams param)
{
HandlerExec executed;
var availableHandlers = handlers
.Where(x => x.Attribute.CanHandleInternal(param))
.OrderByDescending(x => x.Priority)
.ToList();
foreach (var eventHandler in availableHandlers)
{
executed = await Exec(eventHandler, param);
if (executed == HandlerExec.Break)
{
return;
}
else if (executed == HandlerExec.Error)
{
//TODO: ?
}
}
}
internal void __Instantiate(HandlerParams param)
{
_params = param;
}
