public async Task <MiddlewareData> InvokeAsync(MiddlewareData data, IMiddlewaresChain chain)
{
var chatId = _contextManager.GetChatId(data);
var messageId = _contextManager.GetMessageId(data);
var chatContext = await _storage.LoadChatContext(chatId);
var messageContext = Enumerable.Empty <KeyValuePair <string, object> >();
if (_contextManager.HasMessageContext(data))
{
messageContext = await _storage.LoadMessageContext(chatId, messageId);
}
var newData = data.UpdateFeatures(f => f.AddExclusive <ChatContextFeature>(new ChatContextFeature(chatContext))
.AddExclusive <MessageContextFeature>(new MessageContextFeature(messageId, messageContext)));
var resultData = await chain.NextAsync(newData);
var newChatContext = resultData.Features.RequireOne <ChatContextFeature>();
await _storage.SaveChatContext(chatId, newChatContext.Items);
var newMessageContext = resultData.Features.RequireOne <MessageContextFeature>();
foreach (var id in newMessageContext.MessageIds)
{
await _storage.SaveMessageContext(chatId, id, newMessageContext.Items);
}
return(resultData);
}
public async Task <MiddlewareData> InvokeAsync(MiddlewareData data, IMiddlewaresChain chain)
{
var commandInfo = await _commandParser.ParseAsync(data);
var newData = data.UpdateFeatures(f => f.Add <CommandFeature>(new CommandFeature(commandInfo)));
return(await chain.NextAsync(newData));
}
public async Task <MiddlewareData> InvokeAsync(MiddlewareData data, IMiddlewaresChain chain)
{
var controller = _controllerFactory.GetController(data);
var newData = await controller.InvokeAsync(data);
return(await chain.NextAsync(newData));
}
public ChainElement(ILogger logger, IServiceProvider serviceProvider, Type type, IMiddlewaresChain next)
{
_logger = logger;
_serviceProvider = serviceProvider;
_instance = null;
_type = type;
_next = next;
}
public async Task <MiddlewareData> InvokeAsync(MiddlewareData data, IMiddlewaresChain chain)
{
try {
return(await chain.NextAsync(data));
}
catch (Exception e) {
return(GetHandler(e.GetType()).HandleException(data, e));
}
}
public void Start()
{
try {
_services.AddSingleton <IPollerHistoryStorage>(new TempPollerHistoryStorage(0));
_services.AddSingleton <ITelegramClient, TelegramClient>();
_services.AddSingleton <IClientConfiguration, ClientAutoConfiguration>();
_services.AddSingleton <IAutoPollerConfiguration, AutoPollerAutoConfiguration>();
_services.AddSingleton <IMiddlewaresChainFactory, MiddlewaresChainFactory>();
_services.AddSingleton <LocalizationManager>();
_services.AddSingleton <ILocalizationProvider, EnglishLocalizationProvider>();
var middlewaresChainBuilder = new MiddlewaresChainBuilder();
middlewaresChainBuilder.InsertFirst <HandleErrorMiddleware>();
_services.AddSingleton(middlewaresChainBuilder);
_services.AddControllers(b =>
b.SetAssembly(GetType().GetTypeInfo().Assembly)
.GenerateRoutes()
);
ConfigureServices(_services);
_serviceProvider = CreateServiceProvider(_services);
// check all required services
_serviceProvider.GetRequiredService <IRouter>();
_serviceProvider.GetRequiredService <IControllerFactory>();
_client = _serviceProvider.GetRequiredService <ITelegramClient>();
var loggerFactory = _serviceProvider.GetRequiredService <ILoggerFactory>();
_logger = loggerFactory.CreateLogger(GetType());
var autoPollerConfig = _serviceProvider.GetService <IAutoPollerConfiguration>();
if ((autoPollerConfig as AutoPollerAutoConfiguration)?.Enabled ?? true)
{
_autoPoller = _serviceProvider.GetInstance <AutoPoller>();
_autoPoller.UpdateReceived += (sender, args) => EnqueueUpdate(args.Update);
_autoPoller.Start();
_logger.LogInformation("Auto polling has been enabled...");
}
CallConfigure();
var middlewaresChainFactory = _serviceProvider.GetRequiredService <IMiddlewaresChainFactory>();
_middlewaresChain = middlewaresChainBuilder.Build(middlewaresChainFactory);
_cancellationTokenSource = new CancellationTokenSource();
_updatesProcessingTask = ProcessUpdates(_cancellationTokenSource.Token);
_logger.LogInformation("Application started...");
}
catch (Exception e) {
Console.WriteLine("Cannot start application: " + e.ToString());
throw;
}
}
public async Task <MiddlewareData> InvokeAsync(MiddlewareData data, IMiddlewaresChain chain)
{
try {
return(await chain.NextAsync(data));
}
catch (Exception e) {
_logger.LogError(0, e, "Unexpected error occurred");
return(data.AddResponseRenderer($"Error occured: [{e.GetType().Name}] {e.Message}"));
}
}
public async Task <MiddlewareData> InvokeAsync(MiddlewareData data, IMiddlewaresChain chain)
{
var userPreferences = data.Features.GetOne <UserPreferencesFeature>()
.Map(f => f.UserPreferences)
.OrElse(DefaultUserPreferences.Instance);
var routingData = ParseRoutingData(data);
var prevRoutingData = await LoadSavedRoutingData(data);
if (prevRoutingData != null)
{
routingData = JoinRoutingData(prevRoutingData, routingData);
}
var dataWithContext = data.UpdateFeatures(f => f.ReplaceExclusive <SessionFeature>(
e => e.SetRoutingData(prevRoutingData)
)
);
_logger.LogDebug($"Try find route for {routingData.Path} ({routingData.UserCommand})");
var match = _router.FindRoute(routingData);
var chatId = dataWithContext.Features.RequireOne <UpdateInfoFeature>().GetAnyMessage().Chat.Id;
if (!match.IsMatched)
{
await _sessionStorage.ClearRoutingDataAsync(chatId);
var message = _localizationManager.Localize(
userPreferences: userPreferences,
key: LocalizationKeys.UnknownCommand,
parameters: new { text = routingData.UserCommand }
);
return(dataWithContext.AddResponseRenderer(message));
}
if (!match.IsCompleted)
{
await _sessionStorage.SaveRoutingDataAsync(chatId, routingData);
var responseMessage = MessageData.Builder()
.SetText(_localizationManager.Localize(userPreferences, LocalizationKeys.SelectOneForCompletion))
.SetInlineKeyboardMarkup(bldr => BuildResponseMarkup(bldr, match.UncompletedRoutes))
.Build();
return(dataWithContext.AddResponseRenderer(responseMessage));
}
await _sessionStorage.ClearRoutingDataAsync(chatId);
var route = match.CompletedRoute;
var feature = new RouterFeature(route.Route, routingData, route.Fields);
var dataWithRoute = dataWithContext.UpdateFeatures(f => f.AddExclusive <RouterFeature>(feature));
return(await chain.NextAsync(dataWithRoute));
}
public AutoPollingBotApplication(
IMiddlewaresChain middlewares,
IAutoPollerConfiguration autoPollerConfiguration,
AutoPoller autoPoller,
ILogger <AutoPollingBotApplication> logger
) : base(middlewares, logger)
{
_autoPollerConfiguration = autoPollerConfiguration;
_autoPoller = autoPoller;
_autoPoller.UpdateReceived += (sender, eventArgs) => EnqueueUpdate(eventArgs.Update);
}
public async Task <MiddlewareData> InvokeAsync(MiddlewareData data, IMiddlewaresChain chain)
{
var resultData = await chain.NextAsync(data);
foreach (var message in resultData.Features.GetAll <RenderMessageFeature>().Select(f => f.Message))
{
var renderrer = GetRenderer(message.GetType());
resultData = await renderrer.RenderAsync(resultData, message);
}
return(resultData);
}
public async Task <MiddlewareData> InvokeAsync(MiddlewareData data, IMiddlewaresChain chain)
{
var principal = new CombinablePrincipal();
foreach (var authenticationHandler in _authenticationHandlers)
{
var identity = await authenticationHandler.HandleAuthenticationAsync(data, principal);
principal = identity.Map(principal.AddIdentity).OrElse(principal);
}
var newData = data.UpdateFeatures(f => f.AddExclusive <AuthenticationFeature>(new AuthenticationFeature(principal)));
return(await chain.NextAsync(newData));
}
public async Task <MiddlewareData> InvokeAsync(MiddlewareData data, IMiddlewaresChain chain)
{
foreach (var handler in _handlerFactory.CreateHandlers(data))
{
var result = await handler.ExecuteAsync(data);
if (result == null) // TODO fix this check
{
continue;
}
var resultData = await result.RenderAsync(data);
return(await chain.NextAsync(resultData));
}
throw new NoSuchHandlerException();
}
public async Task <MiddlewareData> InvokeAsync(MiddlewareData data, IMiddlewaresChain chain)
{
var outputData = await chain.NextAsync(data);
var tasks = outputData.Renderers
.Select(r => r.Render(outputData, _telegramClient, CancellationToken.None))
.ToArray();
await Task.WhenAll(tasks);
var joinedContext = tasks.Select(t => t.Result);
var newData = outputData.UpdateFeatures(f =>
f.ReplaceExclusive <SessionFeature>(e =>
e.Join(joinedContext)
)
);
return(newData);
}
public async Task <MiddlewareData> InvokeAsync(MiddlewareData data, IMiddlewaresChain chain)
{
var message = data.Features.RequireOne <UpdateInfoFeature>().GetAnyMessage();
var context = await _sessionStorage.LoadMessageContextAsync(message.Chat.Id, message.Id) ??
MessageContext.Builder().Build();
var feature = new SessionFeature(context);
var output = await chain.NextAsync(data.UpdateFeatures(f => f.AddExclusive <SessionFeature>(feature)));
var outputContext = output.Features.RequireOne <SessionFeature>().Context;
await _sessionStorage.SaveMessageContextAsync(message.Chat.Id, message.Id, outputContext);
foreach (var sentMessageId in outputContext.SentMessageIds)
{
await _sessionStorage.SaveMessageContextAsync(message.Chat.Id, sentMessageId, outputContext);
}
return(output);
}
public BotApplication(IMiddlewaresChain middlewares, ILogger <BotApplication> logger)
{
_updatesQueue = new ConcurrentQueue <UpdateInfo>();
_middlewares = middlewares;
_logger = logger;
}
public TimerChainElement(Stopwatch stopwatch, IMiddlewaresChain next)
{
_stopwatch = stopwatch;
_next = next;
}
public IMiddlewaresChain CreateElement(IMiddleware instance, IMiddlewaresChain next)
{
return(new ChainElement(_logger, _serviceProvider, instance, next));
}
public IMiddlewaresChain CreateElement(Type type, IMiddlewaresChain next)
{
return(new ChainElement(_logger, _serviceProvider, type, next));
}
