StandUpStreak - implement internal counter

src/HonzaBotner.Database/HonzaBotnerDbContext.cs

@@ -27,4 +27,5 @@ protected override void OnModelCreating(ModelBuilder builder)
     public DbSet<RoleBinding> RoleBindings { get; set; }
     public DbSet<Warning> Warnings { get; set; }
     public DbSet<Reminder> Reminders { get; set; }
+    public DbSet<StandUpStat> StandUpStats { get; set; }
 }

src/HonzaBotner.Database/StandUpStat.cs

@@ -0,0 +1,17 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+
+namespace HonzaBotner.Database;
+
+public class StandUpStat
+{
+    [Key] public ulong UserId { get; set; }
+    public int Streak { get; set; }
+    public int LongestStreak { get; set; }
+    public int Freezes { get; set; }
+    public DateTime LastDayOfStreak { get; set; }
+    public int LastDayCompleted { get; set; }
+    public int LastDayTasks { get; set; }
+    public int TotalCompleted { get; set; }
+    public int TotalTasks { get; set; }
+}

src/HonzaBotner.Discord.Services/EventHandlers/StandUpHandler.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Threading.Tasks;
+using DSharpPlus;
+using DSharpPlus.Entities;
+using DSharpPlus.EventArgs;
+using HonzaBotner.Discord.EventHandler;
+using HonzaBotner.Discord.Services.Options;
+using HonzaBotner.Services.Contract;
+using HonzaBotner.Services.Contract.Dto;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+namespace HonzaBotner.Discord.Services.EventHandlers;
+
+public class StandUpHandler : IEventHandler<ComponentInteractionCreateEventArgs>
+{
+
+    private readonly ButtonOptions _buttonOptions;
+    private readonly IStandUpStatsService _standUpStats;
+    private readonly ILogger<StandUpHandler> _logger;
+
+    public StandUpHandler(
+        IOptions<ButtonOptions> buttonOptions,
+        IStandUpStatsService standUpStats,
+        ILogger<StandUpHandler> logger)
+    {
+        _buttonOptions = buttonOptions.Value;
+        _standUpStats = standUpStats;
+        _logger = logger;
+    }
+
+    public async Task<EventHandlerResult> Handle(ComponentInteractionCreateEventArgs args)
+    {
+        if (args.Id != _buttonOptions.StandUpStatsId)
+        {
+            return EventHandlerResult.Continue;
+        }
+
+        _logger.LogDebug("{User} requested stats info", args.User.Username);
+
+        StandUpStat? stats = await _standUpStats.GetStreak(args.User.Id);
+
+        DiscordInteractionResponseBuilder response = new();
+        response.AsEphemeral(true);
+        DiscordEmbedBuilder embed = new DiscordEmbedBuilder().WithAuthor("Stats", iconUrl: args.User.AvatarUrl);
+
+        if (stats is null)
+        {
+            embed.Description = "Unfortunately you are not in the database yet.\nDatabase updates daily at 8 am";
+            embed.Color = new Optional<DiscordColor>(DiscordColor.Gold);
+            response.AddEmbed(embed.Build());
+
+            await args.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, response);
+            return EventHandlerResult.Stop;
+        }
+
+        embed.Description = $"Cool stats for {args.User.Mention}";
+        embed.AddField("Current streak", stats.Streak.ToString(), true);
+        embed.AddField("Available freezes", stats.Freezes.ToString(), true);
+        embed.AddField("Total tasks", stats.TotalTasks.ToString(), true);
+        embed.AddField("Total completed tasks", stats.TotalCompleted.ToString(), true);
+        embed.AddField("Last streak update",
+            "<t:" + ((DateTimeOffset)stats.LastDayOfStreak.AddDays(1)).ToUnixTimeSeconds() + ":D>");
+        embed.Color = new Optional<DiscordColor>(DiscordColor.Wheat);
+
+        response.AddEmbed(embed.Build());
+        await args.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, response);
+        return EventHandlerResult.Stop;
+    }
+
+}

src/HonzaBotner.Discord.Services/Jobs/StandUpJobProvider.cs

@@ -4,10 +4,12 @@
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
+using DSharpPlus;
 using DSharpPlus.Entities;
 using HonzaBotner.Discord.Services.Helpers;
 using HonzaBotner.Discord.Services.Options;
 using HonzaBotner.Scheduler.Contract;
+using HonzaBotner.Services.Contract;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 
@@ -20,17 +22,24 @@ public class StandUpJobProvider : IJob
 
     private readonly DiscordWrapper _discord;
 
-    private readonly CommonCommandOptions _commonOptions;
+    private readonly StandUpOptions _standUpOptions;
+    private readonly ButtonOptions _buttonOptions;
+
+    private readonly IStandUpStatsService _statsService;
 
     public StandUpJobProvider(
         ILogger<StandUpJobProvider> logger,
         DiscordWrapper discord,
-        IOptions<CommonCommandOptions> commonOptions
+        IOptions<StandUpOptions> standUpOptions,
+        IStandUpStatsService statsService,
+        IOptions<ButtonOptions> buttonOptions
     )
     {
         _logger = logger;
         _discord = discord;
-        _commonOptions = commonOptions.Value;
+        _standUpOptions = standUpOptions.Value;
+        _statsService = statsService;
+        _buttonOptions = buttonOptions.Value;
     }
 
     /// <summary>
@@ -44,32 +53,32 @@ IOptions<CommonCommandOptions> commonOptions
     /// [] - normal
     /// []! - critical
     /// </summary>
-    private static readonly Regex Regex = new(@"^ *\[ *(?<State>\S*) *\] *(?<Priority>[!])?", RegexOptions.Multiline);
+    private static readonly Regex TaskRegex = new(@"^ *\[ *(?<State>\S*) *\] *(?<Priority>[!])?",
+        RegexOptions.Multiline);
 
     private static readonly List<string> OkList = new() { "check", "done", "ok", "✅", "x" };
 
     public string Name => "standup";
 
     public async Task ExecuteAsync(CancellationToken cancellationToken)
     {
-        var today = DateTime.Today; // Fix one point in time.
-        DateTime yesterday = today.AddDays(-1);
+        DateTime yesterday = DateTime.Today.AddDays(-1);
 
         try
         {
-            DiscordChannel channel = await _discord.Client.GetChannelAsync(_commonOptions.StandUpChannelId);
+            DiscordChannel channel = await _discord.Client.GetChannelAsync(_standUpOptions.StandUpChannelId);
 
             var ok = new StandUpStats();
             var fail = new StandUpStats();
 
-            List<DiscordMessage> messageList = new();
-            messageList.AddRange(await channel.GetMessagesAsync());
+            List<DiscordMessage> messageList = (await channel.GetMessagesAsync())
+                .Where(msg => !msg.Author.IsBot).ToList();
 
             while (messageList.LastOrDefault()?.Timestamp.Date == yesterday)
             {
                 int messagesCount = messageList.Count;
                 messageList.AddRange(
-                    await channel.GetMessagesBeforeAsync(messageList.Last().Id)
+                    (await channel.GetMessagesBeforeAsync(messageList.Last().Id)).Where(msg => !msg.Author.IsBot)
                 );
 
                 // No new data.
@@ -79,34 +88,58 @@ await channel.GetMessagesBeforeAsync(messageList.Last().Id)
                 }
             }
 
-            foreach (DiscordMessage msg in messageList.Where(msg => msg.Timestamp.Date == yesterday))
+            foreach (var authorGrouped in messageList.Where(msg => msg.Timestamp.Date == yesterday)
+                         .GroupBy(msg => msg.Author.Id))
             {
-                foreach (Match match in Regex.Matches(msg.Content))
+                int total = 0;
+                int completed = 0;
+
+                foreach (var msg in authorGrouped)
                 {
-                    string state = match.Groups["State"].ToString();
-                    string priority = match.Groups["Priority"].ToString();
 
-                    if (OkList.Any(s => state.Contains(s)))
+                    foreach (Match match in TaskRegex.Matches(msg.Content))
                     {
-                        ok.Increment(priority);
-                    }
-                    else
-                    {
-                        fail.Increment(priority);
+                        total++;
+                        string state = match.Groups["State"].Value;
+                        string priority = match.Groups["Priority"].Value;
+
+                        if (OkList.Any(s => state.Contains(s)))
+                        {
+                            completed++;
+                            ok.Increment(priority);
+                        }
+                        else
+                        {
+                            fail.Increment(priority);
+                        }
                     }
                 }
+
+                // Update DB.
+                if (total != 0)
+                {
+                    await _statsService.UpdateStats(authorGrouped.Key, completed, total);
+                }
             }
 
-            await channel.SendMessageAsync($@"
-Stand-up time, <@&{_commonOptions.StandUpRoleId}>!
+            // Send stats message to channel.
+            DiscordMessageBuilder message = new DiscordMessageBuilder().WithContent($@"
+Stand-up time, <@&{_standUpOptions.StandUpRoleId}>!
 
-Results from <t:{((DateTimeOffset)today.AddDays(-1)).ToUnixTimeSeconds()}:D>:
+Results from <t:{((DateTimeOffset)yesterday).ToUnixTimeSeconds()}:D>:
 ```
 all:        {ok.Add(fail)}
 completed:  {ok}
 failed:     {fail}
 ```
 ");
+            if (_buttonOptions.StandUpStatsId is not null)
+            {
+                message.AddComponents(new DiscordButtonComponent(ButtonStyle.Primary, _buttonOptions.StandUpStatsId,
+                    "Get your stats", false, new DiscordComponentEmoji(DiscordEmoji.FromUnicode("🐸"))));
+            }
+
+            await message.SendAsync(channel);
         }
         catch (Exception e)
         {

src/HonzaBotner.Discord.Services/Options/ButtonOptions.cs

@@ -7,5 +7,6 @@ public class ButtonOptions
     public string? VerificationId { get; set; }
     public string? StaffVerificationId { get; set; }
     public string? StaffRemoveRoleId { get; set; }
+    public string? StandUpStatsId { get; set; }
     public ulong[]? CzechChannelsIds { get; set; }
 }

src/HonzaBotner.Discord.Services/Options/CommonCommandOptions.cs

@@ -21,8 +21,5 @@ public class CommonCommandOptions
 
     public ulong[]? ReactionIgnoreChannels { get; set; }
 
-    public ulong StandUpRoleId { get; set; }
-    public ulong StandUpChannelId { get; set; }
-
     public ulong[] MemberCountAllowlistIds { get; set; } = System.Array.Empty<ulong>();
 }

src/HonzaBotner.Discord.Services/Options/StandUpOptions.cs

@@ -0,0 +1,12 @@
+namespace HonzaBotner.Discord.Services.Options;
+
+public class StandUpOptions
+{
+    public static string ConfigName => "StandUpOptions";
+
+    public ulong StandUpRoleId { get; set; }
+    public ulong StandUpChannelId { get; set; }
+
+    public int DaysToAcquireFreeze { get; set; }
+    public int TasksCompletedThreshold { get; set; }
+}

src/HonzaBotner.Discord.Services/ServiceCollectionExtensions.cs

@@ -14,6 +14,7 @@ public static IServiceCollection AddCommandOptions(this IServiceCollection servi
         services.Configure<PinOptions>(configuration.GetSection(PinOptions.ConfigName));
         services.Configure<InfoOptions>(configuration.GetSection(InfoOptions.ConfigName));
         services.Configure<ReminderOptions>(configuration.GetSection(ReminderOptions.ConfigName));
+        services.Configure<StandUpOptions>(configuration.GetSection(StandUpOptions.ConfigName));
         services.Configure<ButtonOptions>(configuration.GetSection(ButtonOptions.ConfigName));
         services.Configure<BadgeRoleOptions>(configuration.GetSection(BadgeRoleOptions.ConfigName));
 

src/HonzaBotner.Services.Contract/Dto/StandUpStat.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace HonzaBotner.Services.Contract.Dto;
+
+public record StandUpStat(
+    ulong UserId, int Streak,
+    int LongestStreak, int Freezes,
+    DateTime LastDayOfStreak, int TotalCompleted,
+    int TotalTasks, int LastDayCompleted,
+    int LastDayTasks
+);

src/HonzaBotner.Services.Contract/IStandUpStatsService.cs

@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using HonzaBotner.Services.Contract.Dto;
+namespace HonzaBotner.Services.Contract;
+
+public interface IStandUpStatsService
+{
+    /// <summary>
+    /// Get StandUp stats for a user with a given userId
+    /// </summary>
+    /// <param name="userId">Id of the user</param>
+    /// <returns>Null if user not in database, else his stats</returns>
+    Task<StandUpStat?> GetStreak(ulong userId);
+
+    /// <summary>
+    /// Update database record of given user regarding StandUp stats. Should be called just once per day per user.
+    /// </summary>
+    /// <param name="userId">Id of the user</param>
+    /// <param name="completed">Amount of completed tasks yesterday</param>
+    /// <param name="total">Total amount of tasks yesterday</param>
+    Task UpdateStats(ulong userId, int completed, int total);
+}

src/HonzaBotner.Services.Test/HonzaBotner.Services.Test.csproj

@@ -18,7 +18,6 @@
     </ItemGroup>
 
     <ItemGroup>
-      <ProjectReference Include="..\HonzaBotner.Discord.Services\HonzaBotner.Discord.Services.csproj" />
       <ProjectReference Include="..\HonzaBotner.Scheduler\HonzaBotner.Scheduler.csproj" />
       <ProjectReference Include="..\HonzaBotner.Services.Contract\HonzaBotner.Services.Contract.csproj" />
       <ProjectReference Include="..\HonzaBotner.Services\HonzaBotner.Services.csproj" />

src/HonzaBotner.Services/HonzaBotner.Services.csproj

@@ -8,6 +8,7 @@
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\HonzaBotner.Database\HonzaBotner.Database.csproj" />
+    <ProjectReference Include="..\HonzaBotner.Discord.Services\HonzaBotner.Discord.Services.csproj" />
     <ProjectReference Include="..\HonzaBotner.Discord\HonzaBotner.Discord.csproj" />
     <ProjectReference Include="..\HonzaBotner.Services.Contract\HonzaBotner.Services.Contract.csproj" />
   </ItemGroup>

src/HonzaBotner.Services/ServiceCollectionExtensions.cs

@@ -31,6 +31,7 @@ public static IServiceCollection AddBotnerServices(this IServiceCollection servi
         serviceCollection.AddScoped<IRoleBindingsService, RoleBindingsService>();
         serviceCollection.AddScoped<IWarningService, WarningService>();
         serviceCollection.AddScoped<IRemindersService, RemindersService>();
+        serviceCollection.AddScoped<IStandUpStatsService, StandUpStatsService>();
 
         return serviceCollection;
     }