Al/new redis graph modeling

src/CentralApi/Mappings/ApiContractToDomainMapper.cs

@@ -2,6 +2,7 @@
 using Middleware.CentralApi.Domain;
 using Middleware.Common.Enums;
 using Middleware.Models.Domain;
+using Middleware.Models.Enums;
 
 namespace Middleware.CentralApi.Mappings;
 

src/CentralApi/Services/LocationService.cs

@@ -8,6 +8,7 @@
 using OneOf.Types;
 using Middleware.CentralApi.Mappings;
 using Middleware.Common.Enums;
+using Middleware.Models.Enums;
 
 namespace Middleware.CentralApi.Services;
 

src/CentralApi/Validation/RegisterRequestValidator.cs

@@ -1,6 +1,7 @@
 using FluentValidation;
 using Middleware.CentralApi.Contracts.Requests;
 using Middleware.Common.Enums;
+using Middleware.Models.Enums;
 
 namespace Middleware.CentralApi.Validation;
 

src/Common/Enums/ActionStatusEnum.cs

@@ -0,0 +1,10 @@
+namespace Middleware.Common.Enums;
+
+public enum ActionStatusEnum
+{
+    Unknown,
+    Running,
+    Finished,
+    Idle,
+    Off
+}

src/DataAccess/ExtensionMethods/DataAccessExtensionMethods.cs

@@ -46,6 +46,9 @@ public static IServiceCollection RegisterRepositories(this IServiceCollection se
         services.AddScoped<IRobotRepository, RedisRobotRepository>();
         services.AddScoped<ITaskRepository, RedisTaskRepository>();
         services.AddScoped<IUserRepository, RedisUserRepository>();
+        services.AddScoped<IActionRunningRepository, RedisActionRunningRepository>();
+        services.AddScoped<IInstanceRunningRepository, RedisInstanceRunningRepository>();
+        services.AddScoped<IHistoricalActionPlanRepository, RedisHistoricalActionPlanRepository>();
 
         return services;
     }

src/DataAccess/Repositories/Abstract/IActionPlanRepository.cs

@@ -4,5 +4,5 @@ namespace Middleware.DataAccess.Repositories.Abstract;
 
 public interface IActionPlanRepository : IBaseRepository<ActionPlanModel>, IRelationRepository
 {
-    Task<List<ActionPlanModel>> GetRobotActionPlans(Guid robotId);
+    Task<List<ActionPlanModel>?> GetRobotActionPlans(Guid robotId);
 }

src/DataAccess/Repositories/Abstract/IActionRunningRepository.cs

@@ -0,0 +1,9 @@
+using Middleware.Models.Domain;
+
+namespace Middleware.DataAccess.Repositories.Abstract
+{
+    public interface IActionRunningRepository: IBaseRepository<ActionRunningModel>, IRelationRepository
+    {
+        Task<ActionRunningModel?> PatchActionAsync(Guid id, ActionRunningModel patch);
+    }
+}

src/DataAccess/Repositories/Abstract/IBaseRepository.cs

@@ -28,7 +28,7 @@ public interface IBaseRepository<T> where T : class
     /// Get all objects of the specified type from the data store
     /// </summary>
     /// <returns></returns>
-    Task<List<T>> GetAllAsync();
+    Task<List<T>?> GetAllAsync();
 
     /// <summary>
     /// Delete object from the data store by its id

src/DataAccess/Repositories/Abstract/IHistoricalActionPlanRepository.cs

@@ -0,0 +1,10 @@
+using Middleware.Models.Domain;
+
+namespace Middleware.DataAccess.Repositories.Abstract;
+
+public interface IHistoricalActionPlanRepository : IBaseRepository<HistoricalActionPlanModel>, IRelationRepository
+{
+    Task<List<HistoricalActionPlanModel>> GetRobotActionPlans(Guid robotId);
+
+    Task<List<HistoricalActionPlanModel>> GetRobotReplanActionPlans(Guid robotId);
+}

src/DataAccess/Repositories/Abstract/IInstanceRunningRepository.cs

@@ -0,0 +1,10 @@
+using Middleware.Models.Domain;
+
+namespace Middleware.DataAccess.Repositories.Abstract
+{
+    public interface IInstanceRunningRepository : IBaseRepository<InstanceRunningModel>, IRelationRepository
+    {
+        Task<InstanceRunningModel> PatchInstanceAsync(Guid id, InstanceRunningModel patch);
+
+    }
+}

src/DataAccess/Repositories/Redis/RedisActionRepository.cs

@@ -37,7 +37,7 @@ public async Task<ActionModel> PatchActionAsync(Guid id, ActionModel patch)
         {
             currentModel.Placement = patch.Placement;
         }
-        if (!string.IsNullOrEmpty(patch.PlacementType))
+        if (patch.PlacementType is not null)
         {
             currentModel.PlacementType = patch.PlacementType;
         }

src/DataAccess/Repositories/Redis/RedisActionRunningRepository.cs

@@ -0,0 +1,68 @@
+using Middleware.DataAccess.Repositories.Abstract;
+using Middleware.Models.Domain;
+using Middleware.Models.Dto;
+using Middleware.Models.Enums;
+using Redis.OM.Contracts;
+using RedisGraphDotNet.Client;
+using Serilog;
+
+namespace Middleware.DataAccess.Repositories;
+
+public class RedisActionRunningRepository : RedisRepository<ActionRunningModel, ActionRunningDto>, IActionRunningRepository
+{
+    public RedisActionRunningRepository(IRedisConnectionProvider provider, IRedisGraphClient redisGraph, ILogger logger) : base(provider, redisGraph, true, logger)
+    {
+
+    }
+
+    public async Task<ActionRunningModel?> PatchActionAsync(Guid id, ActionRunningModel patch)
+    {
+        ActionRunningModel? currentModel = await GetByIdAsync(id);
+        if (currentModel == null)
+        {
+            return null;
+        }
+        if (!string.IsNullOrEmpty(patch.Name))
+        {
+            currentModel.Name = patch.Name;
+        }
+        if (patch.Tags != null)
+        {
+            currentModel.Tags = patch.Tags;
+        }
+        if (!string.IsNullOrEmpty(patch.Order.ToString()))
+        {
+            currentModel.Order = patch.Order;
+        }
+        if (!string.IsNullOrEmpty(patch.Placement))
+        {
+            currentModel.Placement = patch.Placement;
+        }
+        if (patch.PlacementType != LocationType.Unspecified)
+        {
+            currentModel.PlacementType = patch.PlacementType;
+        }
+        if (!string.IsNullOrEmpty(patch.ActionPriority))
+        {
+            currentModel.ActionPriority = patch.ActionPriority;
+        }
+        if (!string.IsNullOrEmpty(patch.ActionStatus))
+        {
+            currentModel.ActionStatus = patch.ActionStatus;
+        }
+        if (patch.Services != null)
+        {
+            currentModel.Services = patch.Services;
+        }
+        if (!string.IsNullOrEmpty(patch.MinimumRam.ToString()))
+        {
+            currentModel.MinimumRam = patch.MinimumRam;
+        }
+        if (!string.IsNullOrEmpty(patch.MinimumNumCores.ToString()))
+        {
+            currentModel.MinimumNumCores = patch.MinimumNumCores;
+        }
+        await UpdateAsync(currentModel);
+        return currentModel;
+    }
+}

src/DataAccess/Repositories/Redis/RedisHistoricalActionPlanRepository.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.Text.Json;
+using Microsoft.Extensions.Logging;
+using Middleware.Common.Enums;
+using Middleware.DataAccess.Repositories.Abstract;
+using Middleware.Models.Domain;
+using Middleware.Models.Dto;
+using Middleware.Models.Enums;
+using NReJSON;
+using Redis.OM.Contracts;
+using RedisGraphDotNet.Client;
+using StackExchange.Redis;
+using ILogger = Serilog.ILogger;
+
+
+namespace Middleware.DataAccess.Repositories
+{
+    public class RedisHistoricalActionPlanRepository : RedisRepository<HistoricalActionPlanModel, HistoricalActionPlanDto>, IHistoricalActionPlanRepository
+    {
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        /// <param name="redisClient"></param>
+        /// <param name="redisGraph"></param>
+        /// <param name="logger"></param>
+        public RedisHistoricalActionPlanRepository(IRedisConnectionProvider provider, IRedisGraphClient redisGraph,
+            ILogger logger) : base(provider, redisGraph, true, logger)
+        {
+        }
+
+        /// <summary>
+        /// Retrieves all actionPlanModels associated with an specific robot Id.
+        /// </summary>
+        /// <returns> List of ActionPlanModel </returns>
+        public async Task<List<HistoricalActionPlanModel>> GetRobotActionPlans(Guid robotId)
+        {
+            var guidStr = robotId.ToString();
+            var actionPlans = await FindQuery(dto => dto.RobotId == guidStr).ToListAsync();
+            var planModels = actionPlans.Select(ToTModel).ToList();
+            return planModels;
+        }
+
+        /// <summary>
+        /// Retrieves all actionPlanModels associated with an specific robot Id that have a replan set to true.
+        /// </summary>
+        /// <returns> List of HistoricalActionPlanModel </returns>
+        public async Task<List<HistoricalActionPlanModel>> GetRobotReplanActionPlans(Guid robotId)
+        {
+            var guidStr = robotId.ToString();
+            var actionPlans = await FindQuery(dto => dto.RobotId == guidStr && dto.IsReplan == true).ToListAsync();
+            var planModels = actionPlans.Select(ToTModel).ToList();
+            return planModels;
+        }
+    }
+}

src/DataAccess/Repositories/Redis/RedisInstanceRunningRepository.cs

@@ -0,0 +1,66 @@
+using Microsoft.IdentityModel.Tokens;
+using Middleware.DataAccess.Repositories.Abstract;
+using Middleware.Models.Domain;
+using Middleware.Models.Dto;
+using Redis.OM.Contracts;
+using RedisGraphDotNet.Client;
+using Serilog;
+
+namespace Middleware.DataAccess.Repositories
+{
+    public class RedisInstanceRunningRepository : RedisRepository<InstanceRunningModel, InstanceRunningDto>, IInstanceRunningRepository
+    {
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        /// <param name="redisClient"></param>
+        /// <param name="redisGraph"></param>
+        /// <param name="logger"></param>
+        public RedisInstanceRunningRepository(IRedisConnectionProvider provider, IRedisGraphClient redisGraph, ILogger logger) : base(provider, redisGraph, true, logger)
+        {
+        }
+
+        /// <summary>
+        /// Patching properties for InstaceModel
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="patch"></param>
+        /// <returns> Patched model </returns>
+        public async Task<InstanceRunningModel> PatchInstanceAsync(Guid id, InstanceRunningModel patch)
+        {
+            InstanceRunningModel? currentModel = await GetByIdAsync(id);
+            if (currentModel == null)
+            {
+                return null;
+            }
+            if (!string.IsNullOrEmpty(patch.Name))
+            {
+                currentModel.Name = patch.Name;
+            }
+            if (!string.IsNullOrEmpty(patch.ServiceType))
+            {
+                currentModel.ServiceType = patch.ServiceType;
+            }
+            if (!string.IsNullOrEmpty(patch.ServiceInstanceId.ToString()))
+            {
+                currentModel.ServiceInstanceId = patch.ServiceInstanceId;
+            }
+            if (!string.IsNullOrEmpty(patch.ServiceUrl))
+            {
+                currentModel.ServiceUrl = patch.ServiceUrl;
+            }
+            if (!string.IsNullOrEmpty(patch.ServiceStatus))
+            {
+                currentModel.ServiceStatus = patch.ServiceStatus;
+            }
+            if (!string.IsNullOrEmpty(patch.DeployedTime.ToString()))
+            {
+                currentModel.DeployedTime = patch.DeployedTime;
+            }
+
+            await UpdateAsync(currentModel);
+            return currentModel;
+        }
+
+    }
+}

src/DataConverter/Program.cs

@@ -3,6 +3,7 @@
 using Microsoft.Extensions.Logging.Abstractions;
 using Middleware.Common.Config;
 using Middleware.DataAccess.Repositories;
+using Middleware.DataAccess.Repositories.Abstract;
 using Middleware.DataAccess.Repositories.Redis;
 using Middleware.Models.Domain;
 using Middleware.RedisInterface.Contracts.Responses;
@@ -182,17 +183,18 @@
 {
     actionPlan.LastStatusChange = DateTime.Now;
     actionPlan.TaskStartedAt = DateTime.Now.AddDays(-1);
-    actionPlan.ActionSequence.ForEach(a=>a.Services.ForEach(i=>i.OnboardedTime = DateTime.Today.AddDays(-10)));
+    //actionPlan.ActionSequence.ForEach(a=>a.Services.ForEach(i=>i.OnboardedTime = DateTime.Today.AddDays(-10)));
     await redisActionPlanRepository.AddAsync(actionPlan);
 }
 
 #endregion
 
+
 #region relations
 Console.WriteLine("Writing Relations...");
-
+var historicalActionPlanRepository = new RedisHistoricalActionPlanRepository(clusterConnectionProvider, redisGraphClient, Serilog.Log.Logger);
 var dashboardService = new DashboardService(robotRepository, taskRepository, actionPlanRepository, edgeRepository,
-    cloudRepository, instanceRepository, actionRepository);
+    cloudRepository, instanceRepository, actionRepository, historicalActionPlanRepository);
 
 var relations = await dashboardService.GetAllRelationModelsAsync();
 

src/Models/Domain/ActionModel.cs

@@ -1,6 +1,7 @@
 using System.Text.Json.Serialization;
 using Middleware.Models.Dto;
 using Middleware.Models.Dto.Hardware;
+using Middleware.Models.Enums;
 
 namespace Middleware.Models.Domain;
 
@@ -10,8 +11,7 @@ public class ActionModel : BaseModel
     public override Guid Id { get; set; } = Guid.NewGuid();
 
     [JsonPropertyName("Name")]
-    public override string Name { get; set; }
-
+    public override string Name { get; set; } = default!;
 
     [JsonPropertyName("Tags")]
     public List<string>? Tags { get; set; }
@@ -23,7 +23,7 @@ public class ActionModel : BaseModel
     public string? Placement { get; set; }
 
     [JsonPropertyName("PlacementType")]
-    public string? PlacementType { get; set; } // Either edge or cloud. 
+    public LocationType? PlacementType { get; set; } 
 
     [JsonPropertyName("ActionPriority")]
     public string? ActionPriority { get; set; }
@@ -54,7 +54,26 @@ public override Dto.Dto ToDto()
                 MinimumRam = domain.MinimumRam,
                 MinimumNumCores = domain.MinimumNumCores
             },
-            Tags = domain.Tags
+            Tags = domain.Tags ?? new List<string>()
+        };
+    }
+
+    public ActionRunningModel ToActionRunningModel(Guid actionPlanId)
+    {
+        var that = this;
+        return new ActionRunningModel()
+        {
+            ActionPriority = that.ActionPriority,
+            ActionId = that.Id,
+            ActionPlanId = actionPlanId,
+            Name = that.Name,
+            ActionStatus = that.ActionStatus,
+            Placement = that.Placement!,
+            PlacementType = that.PlacementType!.Value,
+            Order = that.Order,
+            MinimumRam = that.MinimumRam,
+            MinimumNumCores = that.MinimumNumCores,
+            Tags = that.Tags
         };
     }
 }