Initial data flow reversal

Infrastructure/Repositories/PlantRepository.cs

@@ -11,9 +11,16 @@
     public async Task CreatePlant(Plant plant)
     {
         await using var context = await dbContextFactory.CreateDbContextAsync();
+
         await context.Plants.AddAsync(plant);
         await context.SaveChangesAsync();
     }
+
+    public async Task<bool> DoesDeviceIdExist(string deviceId)
+    {
+        await using var context = await dbContextFactory.CreateDbContextAsync();
+        return await context.Plants.AnyAsync(p => p.DeviceId == deviceId);
+    }
 
     public async Task<Plant?> GetPlantById(Guid id)
     {
@@ -108,8 +115,8 @@
                     .ThenByDescending(log => log.TimeStamp)
                     .FirstOrDefault()
             })
             .OrderBy(p => p.WorstMood.Mood)
             .ThenByDescending(p => p.WorstMood.TimeStamp)
             .Take(3)
             .Select(p => p.Plant)
             .ToListAsync();

api/Core/Services/ConditionsLogsService.cs

@@ -1,4 +1,5 @@
 using api.Events.Conditions.Server;
+using api.Events.PlantEvents.Server;
 using api.Extensions;
 using Infrastructure.Repositories;
 using Shared.Dtos;
@@ -45,6 +46,11 @@ public async Task CreateConditionsLogAsync(CreateConditionsLogDto createConditio
         {
             ConditionsLog = addedLog
         });
+        var allPlants = await plantService.GetPlantsForUser(email, 1, 100);
+        connection?.SendDto(new ServerSendsPlants
+        {
+            Plants = allPlants
+        });
 
         if (newMood != recentMood)
         {

api/Core/Services/PlantService.cs

@@ -1,5 +1,7 @@
 using api.Core.Options;
 using api.Core.Services.External.BlobStorage;
+using api.Events.Global;
+using api.Extensions;
 using Infrastructure.Repositories;
 using Microsoft.Extensions.Options;
 using Shared.Dtos.FromClient.Plant;
@@ -13,7 +15,7 @@ public class PlantService(
     PlantRepository plantRepository,
     RequirementService requirementService,
     IBlobStorageService blobStorageService,
-    IOptions<AzureBlobStorageOptions> azureBlobStorageOptions)
+    IOptions<AzureBlobStorageOptions> azureBlobStorageOptions, WebSocketConnectionService webSocketConnectionService)
 {
     public async Task<Plant> CreatePlant(CreatePlantDto createPlantDto, string loggedInUser)
     {
@@ -28,6 +30,16 @@ public async Task<Plant> CreatePlant(CreatePlantDto createPlantDto, string logge
             ímageUrl = await blobStorageService.SaveImageToBlobStorage(createPlantDto.Base64Image, loggedInUser, true);
         }
 
+
+        if (!String.IsNullOrEmpty(createPlantDto.DeviceId))
+        {
+            var deviceExists = await plantRepository.DoesDeviceIdExist(createPlantDto.DeviceId);
+            HandleExistingDeviceId(loggedInUser);
+            if (deviceExists)
+            {
+                createPlantDto.DeviceId = null;
+            }
+        }
         // Insert plant first to get the plantId
         var plant = new Plant
         {
@@ -40,6 +52,8 @@ public async Task<Plant> CreatePlant(CreatePlantDto createPlantDto, string logge
             LatestChange = DateTime.UtcNow
         };
 
+
+
         await plantRepository.CreatePlant(plant);
 
         // Create requirements for the plant to crete a link between the two
@@ -50,6 +64,12 @@ public async Task<Plant> CreatePlant(CreatePlantDto createPlantDto, string logge
         return plant;
     }
 
+    private void HandleExistingDeviceId(string loggedInUser)
+    {
+        var connection = webSocketConnectionService.GetConnectionByEmail(loggedInUser);
+        connection?.SendDto(new ServerSendsErrorMessage{Error = "Device ID already in use"});
+    }
+
     public async Task<Plant> GetPlantById(Guid id, string requesterEmail)
     {
         var plant = await VerifyPlantExistsAndUserHasAccess(id, requesterEmail);
@@ -89,6 +109,20 @@ public async Task<Plant> UpdatePlant(UpdatePlantDto updatePlantDto, string reque
           imageUrl = await blobStorageService.SaveImageToBlobStorage(updatePlantDto.Base64Image, requesterEmail, true, plant.ImageUrl);
         }
 
+        if (!String.IsNullOrEmpty(updatePlantDto.DeviceId))
+        {
+            var deviceExists = await plantRepository.DoesDeviceIdExist(updatePlantDto.DeviceId);
+            if (deviceExists)
+            {
+                var plantWithDeviceId = await plantRepository.GetPlantIdByDeviceIdAsync(updatePlantDto.DeviceId);
+                if (!plantWithDeviceId.ToString().Equals(updatePlantDto.DeviceId))
+                {
+                    HandleExistingDeviceId(requesterEmail);
+                    updatePlantDto.DeviceId = null;
+                }
+            }
+        }
+
         // Update the plant
         plant = new Plant
         {

api/Events/Auth/Client/ClientWantsToCheckJwtValidity.cs

@@ -1,6 +1,3 @@
-using api.Core.Services;
-using api.Events.Auth.Server;
-using api.Extensions;
 using Fleck;
 using lib;
 using Shared.Models;
@@ -14,16 +11,10 @@ public class ClientWantsToCheckJwtValidityDto : BaseDtoWithJwt;
 /// If the token is not valid, an exception will be thrown, and the GlobalExceptionHandler will catch it, and send a
 /// corresponding message to the client.
 /// </summary>
-public class ClientWantsToCheckJwtValidity(WebSocketConnectionService webSocketConnectionService, JwtService jwtService) : BaseEventHandler<ClientWantsToCheckJwtValidityDto>
+public class ClientWantsToCheckJwtValidity(InitialDataHelper initialDataHelper) : BaseEventHandler<ClientWantsToCheckJwtValidityDto>
 {
-    public override Task Handle(ClientWantsToCheckJwtValidityDto dto, IWebSocketConnection socket)
+    public override async Task Handle(ClientWantsToCheckJwtValidityDto dto, IWebSocketConnection socket)
     {
-        var email = jwtService.GetEmailFromJwt(dto.Jwt);
-        webSocketConnectionService.UpdateConnectionEmail(socket, email);
-        socket.SendDto(new ServerAuthenticatesUser
-        {
-            Jwt = dto.Jwt,
-        });
-        return Task.CompletedTask;
+        await initialDataHelper.SendInitialData(socket, dto.Jwt!);
     }
 }

api/Events/Auth/Client/ClientWantsToLogIn.cs

@@ -1,11 +1,6 @@
 using api.Core.Services;
-using api.Core.Services.External.BlobStorage;
-using api.Events.Auth.Server;
-using api.Events.Global;
-using api.Extensions;
 using Fleck;
 using lib;
-using Shared.Dtos;
 using Shared.Dtos.FromClient.Identity;
 using Shared.Exceptions;
 
@@ -16,39 +11,15 @@ public class ClientWantsToLogInDto : BaseDto
     public LoginDto LoginDto { get; set; } = null!;
 }
 
-public class ClientWantsToLogIn(WebSocketConnectionService webSocketConnectionService, UserService userService, IBlobStorageService blobStorageService)
+public class ClientWantsToLogIn(UserService userService, InitialDataHelper initialDataHelper)
     : BaseEventHandler<ClientWantsToLogInDto>
 {
     public override async Task Handle(ClientWantsToLogInDto dto, IWebSocketConnection socket)
     {
         var jwt = await userService.Login(dto.LoginDto);
         if (jwt == null) throw new InvalidCredentialsException();
 
-        var user = await userService.GetUserByEmail(dto.LoginDto.Email);
-
-        webSocketConnectionService.UpdateConnectionEmail(socket, dto.LoginDto.Email);
-
-        var getUserDto = new GetUserDto
-        {
-            UserEmail = user.UserEmail,
-            Username = user.UserName,
-        };
-
-        if (!string.IsNullOrEmpty(user.BlobUrl))
-        {
-            getUserDto.BlobUrl = blobStorageService.GenerateSasUri(user.BlobUrl, false);
-        }
-
-        socket.SendDto(new ServerAuthenticatesUser
-        {
-            Jwt = jwt,
-
-        });
-
-       socket.SendDto(new ServerSendsUserInfo
-        {
-            GetUserDto = getUserDto
-        });
+        await initialDataHelper.SendInitialData(socket, jwt);
     }
 }
 

api/Events/Auth/Client/InitialDataHelper.cs

@@ -0,0 +1,63 @@
+using api.Core.Services;
+using api.Core.Services.External.BlobStorage;
+using api.Events.Auth.Server;
+using api.Events.Collections.Server;
+using api.Events.Global;
+using api.Events.PlantEvents.Server;
+using api.Events.Statistics;
+using api.Extensions;
+using Fleck;
+using Shared.Dtos;
+
+namespace api.Events.Auth.Client;
+
+public class InitialDataHelper(PlantService plantService, IBlobStorageService blobStorageService, CollectionsService collectionsService, StatsService statsService, UserService userService, WebSocketConnectionService webSocketConnectionService, JwtService jwtService)
+{
+
+    public async Task SendInitialData(IWebSocketConnection socket, string jwt)
+    {
+        var email = jwtService.GetEmailFromJwt(jwt);
+        webSocketConnectionService.UpdateConnectionEmail(socket, email);
+
+        var user = await userService.GetUserByEmail(email);
+
+        socket.SendDto(new ServerAuthenticatesUser
+        {
+            Jwt = jwt,
+        });
+
+        var criticalPlants = await plantService.GetCriticalPlants(user.UserEmail);
+        socket.SendDto(new ServerSendsCriticalPlants
+        {
+            Plants = criticalPlants
+        });
+
+        var getUserDto = new GetUserDto
+        {
+            UserEmail = user.UserEmail,
+            Username = user.UserName,
+        };
+
+        if (!string.IsNullOrEmpty(user.BlobUrl))
+        {
+            getUserDto.BlobUrl = blobStorageService.GenerateSasUri(user.BlobUrl, false);
+        }
+
+        socket.SendDto(new ServerSendsUserInfo
+        {
+            GetUserDto = getUserDto
+        });
+
+        var allCollections = await collectionsService.GetCollectionsForUser(user.UserEmail);
+        socket.SendDto(new ServerSendsAllCollections
+        {
+            Collections = allCollections.ToList()
+        });
+
+        var stats = await statsService.GetStats(user.UserEmail);
+        socket.SendDto(new ServerSendsStats
+        {
+            Stats = stats
+        });
+    }
+}

api/Events/Collections/Client/ClientWantsToCreateCollection.cs

@@ -21,13 +21,13 @@ public override async Task Handle(ClientWantsToCreateCollectionDto dto, IWebSock
         var email = jwtService.GetEmailFromJwt(dto.Jwt!);
         await collectionsService.CreateCollection(dto.CreateCollectionDto, email);
         var allCollections = await collectionsService.GetCollectionsForUser(email);
-        var stats = await statsService.GetStats(email);
 
-        socket.SendDto(new ServerSendsAllCollections()
+        socket.SendDto(new ServerSendsAllCollections
         {
             Collections = allCollections.ToList()
         });
 
+        var stats = await statsService.GetStats(email);
         socket.SendDto(new ServerSendsStats{Stats = stats});
     }
 }

api/Events/Collections/Client/ClientWantsToUpdateCollection.cs

@@ -18,7 +18,7 @@ public class ClientWantsToUpdateCollection(CollectionsService collectionsService
     public override async Task Handle(ClientWantsToUpdateCollectionDto dto, IWebSocketConnection socket)
     {
         var email = jwtService.GetEmailFromJwt(dto.Jwt!);
-        var collection = await collectionsService.UpdateCollection(dto.UpdateCollectionDto, email);
+        await collectionsService.UpdateCollection(dto.UpdateCollectionDto, email);
         var allCollections = await collectionsService.GetCollectionsForUser(email);
         socket.SendDto(new ServerSendsAllCollections()
         {

api/Events/PlantEvents/Client/ClientWantsToCreatePlant.cs

@@ -29,6 +29,12 @@ public override async Task Handle(ClientWantsToCreatePlantDto dto, IWebSocketCon
         };
         socket.SendDto(serverCreatesNewPlant);
 
+        var allPlants = await plantService.GetPlantsForUser(email, 1, 100);
+        socket.SendDto(new ServerSendsPlants
+        {
+            Plants = allPlants
+        });
+
        var stats = await statsService.GetStats(email);
        socket.SendDto(new ServerSendsStats{Stats = stats});
     }

api/Events/PlantEvents/Client/ClientWantsToDeletePlant.cs

@@ -22,11 +22,17 @@ public class ClientWantsToDeletePlant(PlantService plantService, JwtService jwtS
     public override async Task Handle(ClientWantsToDeletePlantDto dto, IWebSocketConnection socket)
     {
         var email = jwtService.GetEmailFromJwt(dto.Jwt!);
-        var stats = await statsService.GetStats(email);
 
         await plantService.DeletePlant(dto.PlantId, email);
         socket.SendDto( new ServerConfirmsDelete());
 
+        var allPlants = await plantService.GetPlantsForUser(email, 1, 100);
+        socket.SendDto(new ServerSendsPlants
+        {
+            Plants = allPlants
+        });
+
+        var stats = await statsService.GetStats(email);
         socket.SendDto(new ServerSendsStats{Stats = stats});
     }
 }

api/Events/PlantEvents/Client/ClientWantsToUpdatePlant.cs

@@ -19,14 +19,20 @@ public class ClientWantsToUpdatePlant(PlantService plantService, JwtService jwtS
     public override async Task Handle(ClientWantsToUpdatePlantDto dto, IWebSocketConnection socket)
     {
         var email = jwtService.GetEmailFromJwt(dto.Jwt!);
-        var plant = await plantService.UpdatePlant(dto.UpdatePlantDto, email);
-        var stats = await statsService.GetStats(email);
 
+        var plant = await plantService.UpdatePlant(dto.UpdatePlantDto, email);
         socket.SendDto(new ServerSavesPlant
         {
             Plant = plant
         });
 
+        var allPlants = await plantService.GetPlantsForUser(email, 1, 100);
+        socket.SendDto(new ServerSendsPlants
+        {
+            Plants = allPlants
+        });
+
+        var stats = await statsService.GetStats(email);
         socket.SendDto(new ServerSendsStats{Stats = stats});
     }
 }

api/Extensions/AddServicesAndRepositoriesExtension.cs

@@ -1,6 +1,7 @@
 using api.Core.Services;
 using api.Core.Services.External.BackgroundRemoval;
 using api.Core.Services.External.BlobStorage;
+using api.Events.Auth.Client;
 using Infrastructure.Repositories;
 
 namespace api.Extensions;
@@ -28,6 +29,9 @@ public static void AddServicesAndRepositories(this IServiceCollection services)
         services.AddSingleton<MqttPublisherService>();
         services.AddSingleton<StatsService>();
 
+        // Helpers
+        services.AddSingleton<InitialDataHelper>();
+
         // External services
         if (EnvironmentHelper.IsTesting())
         {