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)); }