Add new bot commands and enhance file handling

- Added `/receipt` command in `CafeController.cs` with an empty handler.
- Enhanced `Program.cs` to register bot commands using `RegisterCommands`.
- Updated `EmptyResult.cs` for a detailed `ExecuteResultAsync` summary.
- Changed `InlineResult` and `MarkdownResult` classes to public and added XML docs.
- Introduced `FileResult` class for handling file responses.
- Added `CommandRegistrationBuilder` for bot command registration.
- Modified `BotApp.cs` to register commands and dispose of resources properly.
- Added `File` and `Delete` methods in `BotControllerBase.cs`.
- Removed redundant `Delete` method from `BotControllerBase.cs`.
- Updated `BotBuilder.cs` to include `RegisterCommands`.
- Adjusted DI in `BotApp.cs` to use `GetService` for `IHostApplicationLifetime`.
- Added necessary `using` directives for new functionality.

Author: bvdcode

Sources/TelegramBot.ConsoleTest/Controllers/CafeController.cs

@@ -69,5 +69,11 @@ public async Task<IActionResult> HandleBurgersDoneAsync()
             await telegramBotClient.SendTextMessageAsync(customerId, text);
             return Text(text);
         }
+
+        [TextCommand("/receipt")]
+        public IActionResult HandleReceipt()
+        {
+
+        }
     }
 }

Sources/TelegramBot.ConsoleTest/Program.cs

@@ -11,7 +11,14 @@ public class Program
         public static void Main(string[] args)
         {
             BotBuilder builder = new BotBuilder(args)
-                .UseApiKey(x => x.FromConfiguration());
+                .UseApiKey(x => x.FromConfiguration())
+                .RegisterCommands(x =>
+                {
+                    x.RegisterCommand("/start", "initiates the bot")
+                        .RegisterCommand("/help", "shows help message")
+                        .RegisterCommand("/burgers", "shows burgers menu")
+                        .RegisterCommand("/burgersdone", "notifies that the order is ready");
+                }, "en");
 
             builder.Services
                 .AddDbContext<AppDbContext>(x => x.UseSqlite("Data Source=app.db"))

Sources/TelegramBot/ActionResults/EmptyResult.cs

@@ -9,10 +9,10 @@ namespace TelegramBot.ActionResults
     public class EmptyResult : IActionResult
     {
         /// <summary>
-        /// Does nothing.
+        /// Executes the result asynchronously.
         /// </summary>
-        /// <param name="context">The context.</param>
-        /// <returns>Task representing the result of the action.</returns>
+        /// <param name="context">Action context.</param>
+        /// <returns>The task representing the result of the action.</returns>
         public Task ExecuteResultAsync(ActionContext context)
         {
             return Task.CompletedTask;

Sources/TelegramBot/ActionResults/FileResult.cs

@@ -0,0 +1,53 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Telegram.Bot;
+using Telegram.Bot.Types;
+using TelegramBot.Abstractions;
+
+namespace TelegramBot.ActionResults
+{
+    /// <summary>
+    /// File result with disposing.
+    /// </summary>
+    public class FileResult : IActionResult, IDisposable
+    {
+        private bool _disposed;
+        private readonly string _fileName;
+        private readonly Stream _fileStream;
+        private readonly bool _disposeStream = true;
+
+        /// <summary>
+        /// Creates a new instance of <see cref="FileResult"/>.
+        /// </summary>
+        /// <param name="filePath">Full path to the file.</param>
+        public FileResult(string filePath)
+        {
+            _fileName = Path.GetFileName(filePath);
+            _fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
+        }
+
+        /// <summary>
+        /// Disposes the file stream if it is applicable.
+        /// </summary>
+        public void Dispose()
+        {
+            if (!_disposed)
+            {
+                _fileStream.Dispose();
+                _disposed = true;
+            }
+        }
+
+        /// <summary>
+        /// Executes the result asynchronously.
+        /// </summary>
+        /// <param name="context">Action context.</param>
+        /// <returns>The task representing the result of the action.</returns>
+        public Task ExecuteResultAsync(ActionContext context)
+        {
+            InputFile file = InputFile.FromStream(_fileStream, _fileName);
+            return context.Bot.SendDocumentAsync(context.ChatId, document: file);
+        }
+    }
+}

Sources/TelegramBot/ActionResults/InlineResult.cs

@@ -6,19 +6,44 @@
 
 namespace TelegramBot.ActionResults
 {
-    internal class InlineResult : IActionResult
+    /// <summary>
+    /// Inline query result.
+    /// </summary>
+    public class InlineResult : IActionResult
     {
+        /// <summary>
+        /// Inline message (caption).
+        /// </summary>
         public string Text { get; }
+
+        /// <summary>
+        /// Use markdown or just plain text.
+        /// </summary>
         public bool UseMarkdown { get; }
+
+        /// <summary>
+        /// Inline keyboard.
+        /// </summary>
         public InlineKeyboardMarkup Keyboard { get; }
 
+        /// <summary>
+        /// Creates a new instance of <see cref="InlineResult"/>.
+        /// </summary>
+        /// <param name="text">Inline message (caption).</param>
+        /// <param name="keyboard">Inline keyboard.</param>
+        /// <param name="useMarkdown">Use markdown or just plain text.</param>
         public InlineResult(string text, InlineKeyboardMarkup keyboard, bool useMarkdown)
         {
             Text = text;
             Keyboard = keyboard;
             UseMarkdown = useMarkdown;
         }
 
+        /// <summary>
+        /// Executes the result asynchronously.
+        /// </summary>
+        /// <param name="context">Action context.</param>
+        /// <returns>The task representing the result of the action.</returns>
         public async Task ExecuteResultAsync(ActionContext context)
         {
             ParseMode? parseMode = null;

Sources/TelegramBot/ActionResults/MarkdownResult.cs

@@ -5,15 +5,30 @@
 
 namespace TelegramBot.ActionResults
 {
-    internal class MarkdownResult : IActionResult
+    /// <summary>
+    /// Markdown result.
+    /// </summary>
+    public class MarkdownResult : IActionResult
     {
+        /// <summary>
+        /// Markdown message.
+        /// </summary>
         public string Text { get; }
 
+        /// <summary>
+        /// Creates a new instance of <see cref="MarkdownResult"/>.
+        /// </summary>
+        /// <param name="text">Markdown message.</param>
         public MarkdownResult(string text)
         {
             Text = text;
         }
 
+        /// <summary>
+        /// Executes the result asynchronously.
+        /// </summary>
+        /// <param name="context">Action context.</param>
+        /// <returns>The task representing the result of the action.</returns>
         public async Task ExecuteResultAsync(ActionContext context)
         {
             await context.Bot.SendTextMessageAsync(context.ChatId, Text, parseMode: ParseMode.MarkdownV2);

Sources/TelegramBot/BotApp.cs

@@ -16,6 +16,7 @@
 using Newtonsoft.Json.Linq;
 using TelegramBot.Attributes;
 using TelegramBot.Services;
+using TelegramBot.Builders;
 
 namespace TelegramBot
 {
@@ -122,8 +123,21 @@ public async Task StartAsync(CancellationToken cancellationToken = default)
                 await hostedService.StartAsync(mergedToken);
                 _logger.LogInformation("Started '{hostedService}'.", hostedService.GetType().Name);
             }
-            var hostApplicationLifetime = _serviceProvider.GetRequiredService<IHostApplicationLifetime>()
+            var hostApplicationLifetime = _serviceProvider.GetService<IHostApplicationLifetime>()
                 as HostApplicationLifetime ?? throw new InvalidOperationException("Host application lifetime is not registered.");
+            var commandRegistrationBuilders = _serviceProvider.GetServices<CommandRegistrationBuilder>();
+            if (commandRegistrationBuilders != null && commandRegistrationBuilders.Any())
+            {
+                foreach (var builder in commandRegistrationBuilders)
+                {
+                    var commands = builder.Build();
+                    await _client.SetMyCommandsAsync(commands,
+                            languageCode: builder.Language,
+                            cancellationToken: mergedToken);
+                    _logger.LogInformation("Registered {count} commands for language '{language}'.",
+                        commands.Count(), builder.Language);
+                }
+            }
             hostApplicationLifetime.NotifyStarted();
         }
 
@@ -225,7 +239,7 @@ private async Task HandleRequestAsync(ITelegramUpdateHandler handler, Update upd
                 _logger.LogWarning("Method not found for message: {Text}.", update.Message?.Text);
                 return;
             }
-            if (method.GetCustomAttribute<AuthorizeAttribute>() != null 
+            if (method.GetCustomAttribute<AuthorizeAttribute>() != null
                 || method.DeclaringType?.GetCustomAttribute<AuthorizeAttribute>() != null)
             {
                 if (_serviceProvider.GetService<IBotAuthorizationHandler>() is IBotAuthorizationHandler authorizationHandler)
@@ -268,6 +282,25 @@ await authorizationHandler
             {
                 throw new InvalidOperationException("Invalid result type: " + result.GetType().Name);
             }
+
+            if (controller is IAsyncDisposable asyncDisposable)
+            {
+                await asyncDisposable.DisposeAsync();
+            }
+            else if (controller is IDisposable disposable)
+            {
+                disposable.Dispose();
+            }
+
+            if (result is IAsyncDisposable asyncDisposableResult)
+            {
+                await asyncDisposableResult.DisposeAsync();
+            }
+            else if (result is IDisposable disposableResult)
+            {
+                disposableResult.Dispose();
+            }
+
         }
 
         private void CheckDisposed()

Sources/TelegramBot/Builders/BotBuilder.cs

@@ -12,6 +12,7 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using TelegramBot.Controllers;
+using System.Collections.Generic;
 
 namespace TelegramBot.Builders
 {
@@ -122,6 +123,20 @@ public BotBuilder UseServices(IServiceCollection services)
             return this;
         }
 
+        /// <summary>
+        /// Register commands for the bot.
+        /// </summary>
+        /// <param name="setup">The setup for the command registration.</param>
+        /// <param name="language">The language for the commands, default is English.</param>
+        /// <returns>This instance of <see cref="BotBuilder"/>.</returns>
+        public BotBuilder RegisterCommands(Action<CommandRegistrationBuilder> setup, string language = "en")
+        {
+            CommandRegistrationBuilder builder = new CommandRegistrationBuilder(language);
+            setup(builder);
+            Services.AddSingleton(builder);
+            return this;
+        }
+
         /// <summary>
         /// Build the bot.
         /// </summary>

Sources/TelegramBot/Builders/CommandRegistrationBuilder.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Linq;
+using Telegram.Bot.Types;
+using System.Collections.Generic;
+
+namespace TelegramBot.Builders
+{
+    /// <summary>
+    /// Command registration builder.
+    /// </summary>
+    public class CommandRegistrationBuilder
+    {
+        internal string Language { get; set; } = string.Empty;
+        private readonly List<BotCommand> botCommands = new List<BotCommand>();
+
+        /// <summary>
+        /// Creates a new instance of the <see cref="CommandRegistrationBuilder"/> class.
+        /// </summary>
+        /// <param name="language">Language code of the commands.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="language"/> is null or empty.</exception>
+        public CommandRegistrationBuilder(string language)
+        {
+            if (string.IsNullOrWhiteSpace(language))
+            {
+                throw new ArgumentNullException(nameof(language));
+            }
+            Language = language;
+        }
+
+        /// <summary>
+        /// Registers a command with a description.
+        /// </summary>
+        /// <param name="command">Text of the command, 1-32 characters. Can contain only lowercase English letters, digits and underscores.</param>
+        /// <param name="description">Description of the command, 3-256 characters.</param>
+        /// <returns>The <see cref="CommandRegistrationBuilder"/>.</returns>
+        public CommandRegistrationBuilder RegisterCommand(string command, string description)
+        {
+            if (string.IsNullOrWhiteSpace(command))
+            {
+                throw new ArgumentNullException(nameof(command));
+            }
+            if (string.IsNullOrWhiteSpace(description))
+            {
+                throw new ArgumentNullException(nameof(description));
+            }
+            while (command.StartsWith('/'))
+            {
+                command = command[1..];
+            }
+            if (command.Length < 1 || command.Length > 32)
+            {
+                throw new ArgumentOutOfRangeException(nameof(command), "Command must be 1-32 characters long.");
+            }
+            if (!command.All(char.IsLower) && !command.All(char.IsDigit) && !command.All(char.IsLetter))
+            {
+                throw new ArgumentException("Command can contain only lowercase English letters, digits and underscores.", nameof(command));
+            }
+            var botCommand = new BotCommand()
+            {
+                Command = command,
+                Description = description
+            };
+            botCommands.Add(botCommand);
+            return this;
+        }
+
+        /// <summary>
+        /// Builds the collection of bot commands.
+        /// </summary>
+        /// <returns>The collection of bot commands.</returns>
+        public IEnumerable<BotCommand> Build()
+        {
+            return botCommands;
+        }
+    }
+}