Enhance Telegram bot with new features and improvements

- Updated `HandleStartAsync` in `README.md` to include new command handlers and response types.
- Renamed `adminId` to `chiefUserId` in `CafeController.cs` and modified message handling.
- Added `HandleReceipt` method to generate and return a receipt as text and image.
- Updated `HandleByeAsync` to remove reply keyboard in `QueryController.cs`.
- Registered new `/counter` command in `Program.cs` for both English and Russian.
- Upgraded target framework to `net9.0` and updated package references in `TelegramBot.ConsoleTest.csproj`.
- Refactored `ExecuteResultAsync` methods in `InlineResult.cs` and `MarkdownResult.cs` for performance.
- Added `RemoveReplyKeyboard` property in `TextResult.cs` for better message handling.
- Set console output encoding to UTF-8 in `BotBuilder.cs`.
- Enhanced `BotControllerBase.cs` with new methods for editing messages and combining action results.
- Introduced `CounterController.cs` for managing a simple counter with logging.
- Added new result classes: `DeleteMessageResult`, `ImageResult`, `InlineEditResult`, `MultiActionResult`, and `TextEditResult`.
- Improved `ImageResult` to support stream disposal after sending.

Author: bvdcode

README.md

@@ -123,14 +123,15 @@ public async Task<IActionResult> HandleStartAsync()
   - [x] Text
   - [x] Inline
   - [x] Markdown
-  - [ ] Image
+  - [x] Image
   - [ ] Video
-  - [ ] Delete
+  - [x] Delete
   - [ ] Redirect
 - [ ] Implement language dictionary service
 - [x] Implement router for inline query
 - [ ] Inject user model in base controller
-- [ ] Add user state service
+- [x] Add user state service
+- [ ] Add builder for message arguments
 
 See the [open issues](https://github.com/BigMakCode/TelegramBot.NET/issues) for a full list of proposed features (and known issues).
 

Sources/TelegramBot.ConsoleTest/Controllers/CafeController.cs

@@ -1,15 +1,17 @@
-using Telegram.Bot;
+using System.Text;
+using Telegram.Bot;
+using SixLabors.ImageSharp;
 using TelegramBot.Builders;
 using TelegramBot.Attributes;
 using TelegramBot.Controllers;
 using TelegramBot.Abstractions;
-using System.Text;
+using SixLabors.ImageSharp.PixelFormats;
 
 namespace TelegramBot.ConsoleTest.Controllers
 {
     public class CafeController(ITelegramBotClient telegramBotClient) : BotControllerBase
     {
-        const long adminId = 123;
+        const long chiefUserId = 123; // Replace with the actual user ID of the chief in restaurant
 
         [TextCommand("/burgers")]
         public IActionResult HandleBurgers()
@@ -21,6 +23,7 @@ public IActionResult HandleBurgers()
                 .AddButton("🍔🍔", "/burgers/2/drink/false")
                 .AddButton("🍔🥤", "/burgers/1/drink/true")
                 .AddButton("🍔🍔🥤", "/burgers/2/drink/true");
+
             return Inline("Choose your order:", builder.Build());
         }
 
@@ -48,10 +51,12 @@ public async Task<IActionResult> HandleBurgersAsync(int burgers, bool drink)
             $"Total: ${totalPrice}.00\n" +
                 "Send /burgersdone when you are ready to pick up";
 
-            await telegramBotClient.SendMessage(adminId, orderText);
+            await telegramBotClient.SendMessage(chiefUserId, orderText);
             SetValue("customerId", User.Id);
-            Delete();
-            return Text(text);
+            return MultiAction(
+                Text(text),
+                DeleteMessage()
+            );
         }
 
         [TextCommand("/burgersdone")]
@@ -73,6 +78,16 @@ public async Task<IActionResult> HandleBurgersDoneAsync()
 
         [TextCommand("/receipt")]
         public IActionResult HandleReceipt()
+        {
+            var textFileStream = WriteFile();
+            var imageStream = DrawImage();
+
+            return MultiAction(
+                File(textFileStream, "receipt.txt"),
+                Image(imageStream, "Receipt Image"));
+        }
+
+        private static MemoryStream WriteFile()
         {
             StringBuilder stringBuilder = new();
             stringBuilder.AppendLine("Date: 2021-09-01");
@@ -82,7 +97,27 @@ public IActionResult HandleReceipt()
             stringBuilder.AppendLine("Payment method: Cash");
             stringBuilder.AppendLine("Thank you for your order!");
             MemoryStream fileStream = new(Encoding.UTF8.GetBytes(stringBuilder.ToString()));
-            return File(fileStream, "receipt.txt");
+            return fileStream;
+        }
+
+        private static MemoryStream DrawImage()
+        {
+            const byte size = byte.MaxValue;
+            using Image<Rgba32> image = new(size, size, Color.Gray);
+            for (int x = 0; x < image.Width; x++)
+            {
+                for (int y = 0; y < image.Height; y++)
+                {
+                    byte r = (byte)(x % size);
+                    byte g = (byte)(y % size);
+                    byte b = (byte)((x + y) / 2 % size);
+                    image[x, y] = new Rgba32(r, g, b);
+                }
+            }
+            MemoryStream imageStream = new();
+            image.SaveAsJpegAsync(imageStream);
+            imageStream.Position = 0;
+            return imageStream;
         }
     }
 }

Sources/TelegramBot.ConsoleTest/Controllers/CounterController.cs

@@ -0,0 +1,66 @@
+using Telegram.Bot.Types;
+using TelegramBot.Builders;
+using TelegramBot.Attributes;
+using TelegramBot.Controllers;
+using TelegramBot.Abstractions;
+using Microsoft.Extensions.Logging;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace TelegramBot.ConsoleTest.Controllers
+{
+    public class CounterController(ILogger<CounterController> _logger) : BotControllerBase
+    {
+        private const string CounterKeyPrefix = "Counter:";
+        private const string IncrementCommand = "/counter/increment";
+        private const string DecrementCommand = "/counter/decrement";
+
+        [TextCommand("/counter")]
+        public IActionResult GetCounter()
+        {
+            int value = GetCounterValue();
+            _logger.LogInformation("Counter value requested: {Value}", value);
+            return CreateCounterResponse(value, edit: false);
+        }
+
+        [InlineCommand("/counter/increment")]
+        public IActionResult IncrementCounter()
+        {
+            int value = GetCounterValue();
+            value++;
+            SetCounterValue(value);
+            _logger.LogInformation("Counter incremented: {Value}", value);
+            return CreateCounterResponse(value);
+        }
+
+        [InlineCommand("/counter/decrement")]
+        public IActionResult DecrementCounter()
+        {
+            int value = GetCounterValue();
+            value--;
+            SetCounterValue(value);
+            _logger.LogInformation("Counter decremented: {Value}", value);
+            return CreateCounterResponse(value);
+        }
+
+        private string GetCounterKey() => $"{CounterKeyPrefix}{User.Id}";
+
+        private int GetCounterValue() => GetValue<int>(GetCounterKey());
+
+        private void SetCounterValue(int value) => SetValue(GetCounterKey(), value);
+
+        private static InlineKeyboardMarkup CreateCounterKeyboard()
+        {
+            return new KeyboardBuilder()
+                .WithColumns(2)
+                .AddButton("➖", DecrementCommand)
+                .AddButton("➕", IncrementCommand)
+                .Build();
+        }
+
+        private IActionResult CreateCounterResponse(int value, bool edit = true)
+        {
+            string message = $"{CounterKeyPrefix} {value}";
+            return edit ? TextEdit(message, CreateCounterKeyboard()) : Inline(message, CreateCounterKeyboard());
+        }
+    }
+}

Sources/TelegramBot.ConsoleTest/Controllers/QueryController.cs

@@ -15,7 +15,7 @@ public IActionResult HandleHelloAsync()
         [TextQuery(pattern: "bye")]
         public IActionResult HandleByeAsync()
         {
-            return Text("Goodbye!");
+            return Text("Goodbye!", removeReplyKeyboard: true);
         }
     }
 }

Sources/TelegramBot.ConsoleTest/Program.cs

@@ -18,6 +18,7 @@ public static void Main(string[] args)
                 .RegisterCommands(x =>
                 {
                     x.RegisterCommand("/start", "initiates the bot")
+                        .RegisterCommand("/counter", "simple counter command")
                         .RegisterCommand("/help", "shows help message")
                         .RegisterCommand("/burgers", "shows burgers menu")
                         .RegisterCommand("/burgersdone", "notifies that the order is ready")
@@ -26,6 +27,7 @@ public static void Main(string[] args)
                 .RegisterCommands(x =>
                 {
                     x.RegisterCommand("/start", "инициирует бота")
+                        .RegisterCommand("/counter", "простой счетчик")
                         .RegisterCommand("/help", "показывает сообщение справки")
                         .RegisterCommand("/burgers", "показывает меню бургеров")
                         .RegisterCommand("/burgersdone", "уведомляет о готовности заказа")

Sources/TelegramBot.ConsoleTest/TelegramBot.ConsoleTest.csproj

@@ -2,7 +2,7 @@
 
 	<PropertyGroup>
 		<OutputType>Exe</OutputType>
-		<TargetFramework>net8.0</TargetFramework>
+		<TargetFramework>net9.0</TargetFramework>
 		<ImplicitUsings>enable</ImplicitUsings>
 		<Nullable>enable</Nullable>
 	</PropertyGroup>
@@ -11,11 +11,12 @@
 		<Content Include="appsettings.json">
 			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
 		</Content>
-		<PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.0.0" />
-		<PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.0">
+		<PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.0.6" />
+		<PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.6">
 			<PrivateAssets>all</PrivateAssets>
 			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
 		</PackageReference>
+		<PackageReference Include="SixLabors.ImageSharp" Version="3.1.10" />
 		<ProjectReference Include="..\TelegramBot\TelegramBot.csproj" />
 	</ItemGroup>
 

Sources/TelegramBot/ActionResults/DeleteMessageResult.cs

@@ -0,0 +1,33 @@
+using Telegram.Bot;
+using System.Threading.Tasks;
+using TelegramBot.Abstractions;
+
+namespace TelegramBot.ActionResults
+{
+    /// <summary>
+    /// Represents a result for deleting a message in a Telegram bot.
+    /// </summary>
+    public class DeleteMessageResult : IActionResult
+    {
+        private readonly int _messageId;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DeleteMessageResult"/> class.
+        /// </summary>
+        /// <param name="messageId">The identifier of the message to delete.</param>
+        public DeleteMessageResult(int messageId)
+        {
+            _messageId = messageId;
+        }
+
+        /// <summary>
+        /// Executes the result asynchronously, deleting the specified message.
+        /// </summary>
+        /// <param name="context">The action context containing the bot and chat information.</param>
+        /// <returns>A task representing the asynchronous operation.</returns>
+        public Task ExecuteResultAsync(ActionContext context)
+        {
+            return context.Bot.DeleteMessage(context.ChatId, _messageId);
+        }
+    }
+}

Sources/TelegramBot/ActionResults/ImageResult.cs

@@ -0,0 +1,71 @@
+using System;
+using System.IO;
+using Telegram.Bot;
+using Telegram.Bot.Types;
+using System.Threading.Tasks;
+using TelegramBot.Abstractions;
+
+namespace TelegramBot.ActionResults
+{
+    /// <summary>
+    /// Image result with disposing.
+    /// </summary>
+    public class ImageResult : IActionResult, IDisposable
+    {
+        private bool _disposed;
+        private readonly string _fileName;
+        private readonly Stream _imageStream;
+        private readonly bool _disposeStream = true;
+        private readonly string _caption = string.Empty;
+
+        /// <summary>
+        /// Creates a new instance of <see cref="ImageResult"/>.
+        /// </summary>
+        /// <param name="filePath">Full path to the image.</param>
+        /// <param name="caption">Caption for the image.</param>
+        public ImageResult(string filePath, string caption = "")
+        {
+            _caption = caption;
+            _fileName = Path.GetFileName(filePath);
+            _imageStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="ImageResult"/>.
+        /// </summary>
+        /// <param name="stream">Stream with image content.</param>
+        /// <param name="fileName">File name.</param>
+        /// <param name="caption">Caption for the image.</param>
+        /// <param name="disposeStream">Dispose the stream after sending the file.</param>
+        public ImageResult(Stream stream, string fileName, string caption = "", bool disposeStream = true)
+        {
+            _caption = caption;
+            _fileName = fileName;
+            _imageStream = stream;
+            _disposeStream = disposeStream;
+        }
+
+        /// <summary>
+        /// Disposes the file stream if it is applicable.
+        /// </summary>
+        public void Dispose()
+        {
+            if (!_disposed && _disposeStream)
+            {
+                _imageStream.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(_imageStream, _fileName);
+            return context.Bot.SendPhoto(context.ChatId, photo: file, caption: _caption);
+        }
+    }
+}

Sources/TelegramBot/ActionResults/InlineEditResult.cs

@@ -0,0 +1,51 @@
+using Telegram.Bot;
+using System.Threading.Tasks;
+using TelegramBot.Abstractions;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace TelegramBot.ActionResults
+{
+    /// <summary>
+    /// Inline query result.
+    /// </summary>
+    public class InlineEditResult : IActionResult
+    {
+        /// <summary>
+        /// Inline message (caption).
+        /// </summary>
+        public string Text { get; }
+
+        /// <summary>
+        /// Message identifier to edit.
+        /// </summary>
+        public int MessageId { 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="messageId">Message identifier to edit.</param>
+        public InlineEditResult(string text, InlineKeyboardMarkup keyboard, int messageId)
+        {
+            Text = text;
+            Keyboard = keyboard;
+            MessageId = messageId;
+        }
+
+        /// <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)
+        {
+            return context.Bot.EditMessageReplyMarkup(context.ChatId, messageId: MessageId, replyMarkup: Keyboard);
+        }
+    }
+}