Refactor BotApp and add SomeDataRow entity

Refactored BotApp.cs by extracting logic into new methods:
AuthorizeAsync, CheckMethodMatching, ExecuteResultAsync, and
DisposeAsync. Added DbSet<SomeDataRow> to AppDbContext.cs and
created SomeDataRow class for the some_data_rows table.
Refactored AuthorizeAttribute.cs to a single-line format.

Author: bvdcode

Sources/TelegramBot.ConsoleTest/Database/AppDbContext.cs

@@ -4,6 +4,6 @@ namespace TelegramBot.ConsoleTest.Database
 {
     public class AppDbContext(DbContextOptions<AppDbContext> options) : DbContext(options)
     {
-
+        public DbSet<SomeDataRow> SomeDataRows { get; set; }
     }
 }

Sources/TelegramBot.ConsoleTest/Database/SomeDataRow.cs

@@ -0,0 +1,11 @@
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace TelegramBot.ConsoleTest.Database
+{
+    [Table("some_data_rows")]
+    public class SomeDataRow
+    {
+        [Column("id")]
+        public int Id { get; set; }
+    }
+}

Sources/TelegramBot/Attributes/AuthorizeAttribute.cs

@@ -1,15 +1,10 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace TelegramBot.Attributes
 {
     /// <summary>
-    /// 
+    /// Attribute to mark a method as requiring authorization.
     /// </summary>
     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
-    public class AuthorizeAttribute : Attribute
-    {
-
-    }
+    public class AuthorizeAttribute : Attribute { }
 }

Sources/TelegramBot/BotApp.cs

@@ -245,28 +245,12 @@ 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
-                || method.DeclaringType?.GetCustomAttribute<AuthorizeAttribute>() != null)
-            {
-                if (_serviceProvider.GetService<IBotAuthorizationHandler>() is IBotAuthorizationHandler authorizationHandler)
-                {
-                    if (!authorizationHandler.Authorize(user))
-                    {
-                        await authorizationHandler
-                            .HandleUnauthorized(user)
-                            .ExecuteResultAsync(new ActionContext(_client, user.Id));
-                        return;
-                    }
-                }
-            }
-            if (method.ReturnType != typeof(Task<IActionResult>) && method.ReturnType != typeof(IActionResult))
+            bool isAuthorized = await AuthorizeAsync(method, user);
+            if (!isAuthorized)
             {
-                throw new InvalidOperationException("Invalid return type: " + method.ReturnType.Name);
-            }
-            if (args != null && method.GetParameters().Length != args?.Length)
-            {
-                throw new InvalidOperationException("Invalid arguments count: " + args?.Length);
+                return;
             }
+            CheckMethodMatching(method, args);
             BotControllerBase controller = (BotControllerBase)ActivatorUtilities.CreateInstance(_serviceProvider, method.DeclaringType!);
             controller.Update = update;
             controller.User = user;
@@ -276,37 +260,68 @@ await authorizationHandler
                 controller.KeyValueProvider = keyValueProvider;
             }
             var result = method.Invoke(controller, args);
-            if (result is Task<IActionResult> taskResult)
+            await ExecuteResultAsync(result, user.Id);
+            await DisposeAsync(controller);
+            await DisposeAsync(result);
+        }
+
+        private void CheckMethodMatching(MethodInfo method, object[]? args)
+        {
+            if (method.ReturnType != typeof(Task<IActionResult>) && method.ReturnType != typeof(IActionResult))
             {
-                await (await taskResult).ExecuteResultAsync(new ActionContext(_client, user.Id));
+                throw new InvalidOperationException("Invalid return type: " + method.ReturnType.Name);
             }
-            else if (result is IActionResult actionResult)
+            if (args != null && method.GetParameters().Length != args?.Length)
             {
-                await actionResult.ExecuteResultAsync(new ActionContext(_client, user.Id));
+                throw new InvalidOperationException("Invalid arguments count: " + args?.Length);
             }
-            else
+        }
+
+        private async Task<bool> AuthorizeAsync(MethodInfo method, User user)
+        {
+            if (method.GetCustomAttribute<AuthorizeAttribute>() != null
+                || method.DeclaringType?.GetCustomAttribute<AuthorizeAttribute>() != null)
             {
-                throw new InvalidOperationException("Invalid result type: " + result.GetType().Name);
+                if (_serviceProvider.GetService<IBotAuthorizationHandler>() is IBotAuthorizationHandler authorizationHandler)
+                {
+                    if (!authorizationHandler.Authorize(user))
+                    {
+                        await authorizationHandler
+                            .HandleUnauthorized(user)
+                            .ExecuteResultAsync(new ActionContext(_client, user.Id));
+                        return false;
+                    }
+                }
             }
+            return true;
+        }
 
-            if (controller is IAsyncDisposable asyncDisposable)
+        private async Task DisposeAsync(object obj)
+        {
+            if (obj is IAsyncDisposable asyncDisposable)
             {
                 await asyncDisposable.DisposeAsync();
             }
-            else if (controller is IDisposable disposable)
+            else if (obj is IDisposable disposable)
             {
                 disposable.Dispose();
             }
+        }
 
-            if (result is IAsyncDisposable asyncDisposableResult)
+        private async Task ExecuteResultAsync(object result, long userId)
+        {
+            if (result is Task<IActionResult> taskResult)
             {
-                await asyncDisposableResult.DisposeAsync();
+                await (await taskResult).ExecuteResultAsync(new ActionContext(_client, userId));
             }
-            else if (result is IDisposable disposableResult)
+            else if (result is IActionResult actionResult)
             {
-                disposableResult.Dispose();
+                await actionResult.ExecuteResultAsync(new ActionContext(_client, userId));
+            }
+            else
+            {
+                throw new InvalidOperationException("Invalid result type: " + result.GetType().Name);
             }
-
         }
 
         private void CheckDisposed()

Sources/TelegramBot/Handlers/InlineQueryHandler.cs

@@ -43,13 +43,15 @@ public InlineQueryHandler(IReadOnlyCollection<MethodInfo> controllerMethods, Upd
                         bool match = true;
                         for (int i = 0; i < controllerCommandParts.Length; i++)
                         {
-                            if (controllerCommandParts[i] != incomingCommandParts[i] && !controllerCommandParts[i].StartsWith('{') 
+                            if (controllerCommandParts[i] != incomingCommandParts[i] 
+                                && !controllerCommandParts[i].StartsWith('{') 
                                 && !controllerCommandParts[i].EndsWith('}'))
                             {
                                 match = false;
                                 break;
                             }
-                            if (controllerCommandParts[i].StartsWith('{') && controllerCommandParts[i].EndsWith('}'))
+                            if (controllerCommandParts[i].StartsWith('{') 
+                                && controllerCommandParts[i].EndsWith('}'))
                             {
                                 _args.Add(incomingCommandParts[i]);
                             }