broadcasting:

- Received messages marking API

Author: devgopher

Botticelli.Framework.Telegram/Builders/TelegramBotBuilder.cs

@@ -86,7 +86,8 @@ public TelegramBotBuilder<TBot> AddClient(TelegramClientDecoratorBuilder builder
         Services!.AddHttpClient<GetBroadCastMessagesService<TelegramBot>>()
             .AddServerCertificates(BotSettings);
         Services!.AddHostedService<GetBroadCastMessagesService<IBot<TelegramBot>>>();
-
+        Services!.AddHostedService<MarkAsReceivedService<IBot<TelegramBot>>>();
+        
         Services!.AddHostedService<TelegramBotHostedService>();
         var botId = BotDataUtils.GetBotId();
 

Botticelli.Framework/Services/BotActualizationService.cs

@@ -56,7 +56,7 @@ public virtual Task StopAsync(CancellationToken cancellationToken)
     /// <param name="funcName">Response</param>
     /// <param name="cancellationToken">Cancellation token</param>
     /// <returns></returns>
-    protected virtual async Task<TResp?> InnerSend<TReq, TResp>(TReq request,
+    protected virtual async Task<TResp?> InnerSendPost<TReq, TResp>(TReq request,
         string funcName,
         CancellationToken cancellationToken)
     {

Botticelli.Framework/Services/BotStatusService.cs

@@ -56,7 +56,7 @@ private void GetRequiredStatus(CancellationToken cancellationToken)
     private Task<GetRequiredStatusFromServerResponse?> Process(GetRequiredStatusFromServerRequest request,
         CancellationToken cancellationToken)
     {
-        var task = InnerSend<GetRequiredStatusFromServerRequest, GetRequiredStatusFromServerResponse>(request,
+        var task = InnerSendPost<GetRequiredStatusFromServerRequest, GetRequiredStatusFromServerResponse>(request,
             "/bot/client/GetRequiredBotStatus",
             cancellationToken);
 

Botticelli.Framework/Services/GetBroadCastMessagesService.cs

@@ -26,7 +26,7 @@ public class GetBroadCastMessagesService<TBot>(
         bot,
         logger)
 {
-    private IBot _bot = bot;
+    private readonly IBot _bot = bot;
 
     protected override async Task InnerProcess(GetBroadCastMessagesResponse response, CancellationToken ct)
     {

Botticelli.Framework/Services/MarkAsReceivedService.cs

@@ -0,0 +1,33 @@
+using Botticelli.Framework.Options;
+using Botticelli.Interfaces;
+using Botticelli.Shared.API.Client.Requests;
+using Botticelli.Shared.API.Client.Responses;
+using Microsoft.Extensions.Logging;
+
+namespace Botticelli.Framework.Services;
+
+/// <summary>
+///     Marks a broadcast message as received
+/// </summary>
+/// <param name="httpClientFactory"></param>
+/// <param name="serverSettings"></param>
+/// <param name="bot"></param>
+/// <param name="logger"></param>
+/// <typeparam name="TBot"></typeparam>
+public class MarkAsReceivedService<TBot>(
+        IHttpClientFactory httpClientFactory,
+        ServerSettings serverSettings,
+        IBot bot,
+        ILogger<BotActualizationService> logger)
+        : PollActualizationService<MarkAsReceivedRequest, MarksAsReceivedResponse>(httpClientFactory,
+                                                                                   "broadcast",
+                                                                                   serverSettings,
+                                                                                   bot,
+                                                                                   logger)
+{
+    private readonly IBot _bot = bot;
+
+    protected override async Task InnerProcess(MarksAsReceivedResponse response, CancellationToken ct)
+    {
+    }
+}

Botticelli.Framework/Services/PollActualizationService.cs

@@ -37,7 +37,7 @@ public override Task StartAsync(CancellationToken cancellationToken)
     /// <param name="funcName">Method on a server</param>
     /// <param name="cancellationToken">Cancellation token</param>
     /// <returns></returns>
-    protected override async Task<TResp?> InnerSend<TReq, TResp>(TReq request,
+    protected override async Task<TResp?> InnerSendPost<TReq, TResp>(TReq request,
         string funcName,
         CancellationToken cancellationToken) where TResp : default
     {
@@ -93,7 +93,7 @@ private void ProcessRequest(CancellationToken cancellationToken)
 
     private async Task<TResponse> Process(TRequest request, CancellationToken ct)
     {
-        var response = await InnerSend<TRequest, TResponse>(request,
+        var response = await InnerSendPost<TRequest, TResponse>(request,
             $"/bot/client/{subPath}",
             ct);
 

Botticelli.Server.Back/Controllers/AdminController.cs

@@ -1,5 +1,8 @@
-using Botticelli.Server.Back.Services;
+using System.Collections;
+using Botticelli.Server.Back.Services;
+using Botticelli.Server.Back.Services.Broadcasting;
 using Botticelli.Server.Data.Entities.Bot;
+using Botticelli.Server.Data.Entities.Bot.Broadcasting;
 using Botticelli.Shared.API.Admin.Responses;
 using Botticelli.Shared.API.Client.Requests;
 using Botticelli.Shared.API.Client.Responses;
@@ -17,16 +20,19 @@ namespace Botticelli.Server.Back.Controllers;
 public class AdminController
 {
     private readonly IBotManagementService _botManagementService;
+    private readonly IBroadcastService _broadcastService;
     private readonly IBotStatusDataService _botStatusDataService;
     private readonly ILogger<AdminController> _logger;
 
     public AdminController(IBotManagementService botManagementService,
         IBotStatusDataService botStatusDataService,
-        ILogger<AdminController> logger)
+        ILogger<AdminController> logger,
+        IBroadcastService broadcastService)
     {
         _botManagementService = botManagementService;
         _botStatusDataService = botStatusDataService;
         _logger = logger;
+        _broadcastService = broadcastService;
     }
 
     [HttpPost("[action]")]
@@ -64,6 +70,23 @@ public async Task<UpdateBotResponse> UpdateBot([FromBody] UpdateBotRequest reque
         };
     }
 
+    /// <summary>
+    ///     Sends a broadcast message
+    /// </summary>
+    /// <param name="botId"></param>
+    /// <param name="message"></param>
+    /// <returns></returns>
+    [HttpGet("[action]")]
+    public async Task SendBroadcast([FromQuery] string botId, [FromQuery] string message)
+    {
+        await _broadcastService.BroadcastMessage(new Broadcast
+        {
+            Id = Guid.NewGuid().ToString(),
+            BotId = botId,
+            Body = message
+        });
+    }
+    
     [HttpGet("[action]")]
     public async Task<ICollection<BotInfo>> GetBots()
         => _botStatusDataService.GetBots();
@@ -76,7 +99,6 @@ public async Task ActivateBot([FromQuery] string botId)
     public async Task DeactivateBot([FromQuery] string botId)
         => await _botManagementService.SetRequiredBotStatus(botId, BotStatus.Locked);
 
-
     [HttpGet("[action]")]
     public async Task RemoveBot([FromQuery] string botId)
         => await _botManagementService.RemoveBot(botId);

Botticelli.Server.Back/Controllers/BotController.cs

@@ -139,7 +139,6 @@ public async Task<GetBroadCastMessagesResponse> Broadcast([FromBody] GetBroadCas
         }
     }
 
-
     /// <summary>
     ///     Gets broadcast messages received notifications
     /// </summary>
@@ -156,7 +155,7 @@ public async Task<BroadCastMessagesReceivedResponse> BroadcastReceived(
             request.BotId?.NotNullOrEmpty();
 
             foreach (var messageId in request.MessageIds)
-                await broadcastService.DeleteReceived(request.BotId!, messageId);
+                await broadcastService.MarkReceived(request.BotId!, messageId);
 
             return new BroadCastMessagesReceivedResponse
             {

Botticelli.Server.Back/Services/BotManagementService.cs

@@ -1,5 +1,6 @@
 using Botticelli.Server.Data;
 using Botticelli.Server.Data.Entities.Bot;
+using Botticelli.Server.Data.Entities.Bot.Broadcasting;
 using Botticelli.Shared.API.Admin.Responses;
 using Botticelli.Shared.Constants;
 

Botticelli.Server.Back/Services/Broadcasting/BroadcastService.cs

@@ -18,10 +18,38 @@ public async Task BroadcastMessage(Broadcast message)
     public async Task<IEnumerable<Broadcast>> GetMessages(string botId)
         => await context.BroadcastMessages.Where(m => m.BotId.Equals(botId)).ToArrayAsync();
 
-    public async Task DeleteReceived(string botId, string messageId)
+    public async Task MarkReceived(string botId, string messageId)
     {
-        context.BroadcastMessages.RemoveRange(
-            context.BroadcastMessages.Where(bm => bm.BotId == botId && bm.Id == messageId));
+        var messages = context.BroadcastMessages.Where(bm => bm.BotId == botId && bm.Id == messageId)
+                              .ToList();
+
+        foreach (var message in messages)
+        {
+            message.Received = true;
+        }
+        
+        context.UpdateRange(messages);
+        
+        await context.SaveChangesAsync();
+    }
+    
+    
+    public async Task<List<Broadcast>> GetBroadcasts(string botId)
+    {
+        var broadcasts = context.BroadcastMessages.Where(x => x.BotId == botId && !x.Sent && !x.Received).ToList();
+
+        return broadcasts;
+    }
+
+    public async Task MarkAsReceived(string messageId)
+    {
+        var broadcast = context.BroadcastMessages.FirstOrDefault(x => x.Id == messageId);
+        if (broadcast == null) return;
+
+        broadcast.Received = true;
+
+        context.Update(broadcast);
+
         await context.SaveChangesAsync();
     }
 }