Expansion+Get info

RelationshipAnalysis/Controllers/EdgeController.cs

@@ -14,7 +14,8 @@ namespace RelationshipAnalysis.Controllers;
 public class EdgeController(
     ICreateEdgeCategoryService createEdgeCategoryService,
     IEdgeCategoryReceiver edgeCategoryReceiver,
-    IEdgesAdditionService edgesAdditionService)
+    IEdgesAdditionService edgesAdditionService,
+    [FromKeyedServices("edge")] IInfoReceiver infoReceiver)
     : ControllerBase
 {
 
@@ -25,6 +26,14 @@ public async Task<IActionResult> GetAllEdgeCategories()
         return Ok(result);
     }
 
+
+    [HttpGet]
+    public async Task<IActionResult> GetInfo(int edgeId)
+    {
+        var result = await infoReceiver.GetInfo(edgeId);
+        return StatusCode((int)result.StatusCode, result.Data);
+    }
+
     [HttpPost("categories")]
     public async Task<IActionResult> CreateEdgeCategory([FromBody] CreateEdgeCategoryDto createEdgeCategoryDto)
     {

RelationshipAnalysis/Controllers/GraphController.cs

@@ -8,11 +8,18 @@ namespace RelationshipAnalysis.Controllers;
 [ApiController]
 [Authorize]
 [Route("api/[controller]")]
-public class GraphController(IGraphReceiver graphReceiver) : ControllerBase
+public class GraphController(IGraphReceiver graphReceiver,
+    IExpansionGraphReceiver expansionGraphReceiver) : ControllerBase
 {
     [HttpGet]
     public async Task<IActionResult> GetGraph()
     {
         return Ok(await graphReceiver.GetGraph());
     }
+    [HttpGet("expansion")]
+    public async Task<IActionResult> GetExpansionGraph(int nodeId, string sourceCategoryName, string targetCategoryName, string edgeCategoryName)
+    {
+        var result = await expansionGraphReceiver.GetExpansionGraph(nodeId, sourceCategoryName, targetCategoryName, edgeCategoryName);
+        return Ok(result);
+    }
 }

RelationshipAnalysis/Controllers/NodeController.cs

@@ -14,7 +14,8 @@ namespace RelationshipAnalysis.Controllers;
 public class NodeController(
     ICreateNodeCategoryService createNodeCategoryService,
     INodeCategoryReceiver nodeCategoryReceiver,
-    INodesAdditionService nodesAdditionService)
+    INodesAdditionService nodesAdditionService,
+    [FromKeyedServices("node")] IInfoReceiver infoReceiver)
     : ControllerBase
 {
     [HttpGet("categories")]
@@ -24,6 +25,12 @@ public async Task<IActionResult> GetAllNodeCategories()
         return Ok(result);
     }
 
+    [HttpGet]
+    public async Task<IActionResult> GetInfo(int nodeId)
+    {
+        var result = await infoReceiver.GetInfo(nodeId);
+        return StatusCode((int)result.StatusCode, result.Data);
+    }
 
     [HttpPost("categories")]
     public async Task<IActionResult> CreateNodeCategory([FromBody] CreateNodeCategoryDto createNodeCategoryDto)

RelationshipAnalysis/Dto/Graph/ExpansionDto.cs

@@ -0,0 +1,15 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace RelationshipAnalysis.Dto.Graph;
+
+public class ExpansionDto
+{
+    [Required]
+    public int NodeId { get; set; }
+    [Required]
+    public int SourceCategoryId { get; set; }
+    [Required]
+    public int TargetCategoryId { get; set; }
+    [Required]
+    public int EdgeCategoryId { get; set; }
+}

RelationshipAnalysis/Program.cs

@@ -56,7 +56,11 @@
     .AddSingleton<ICsvProcessorService, CsvProcessorService>()
     .AddSingleton<ISingleEdgeAdditionService, SingleEdgeAdditionService>()
     .AddSingleton<IEdgesAdditionService, EdgesAdditionService>()
-    .AddSingleton<ICsvValidatorService, CsvValidatorService>();
+    .AddSingleton<ICsvValidatorService, CsvValidatorService>()
+    .AddSingleton<IExpansionGraphReceiver, ExpansionGraphReceiver>()
+    .AddSingleton<IGraphDtoCreator, GraphDtoCreator>()
+    .AddKeyedSingleton<IInfoReceiver, NodeInfoReceiver>("node")
+    .AddKeyedSingleton<IInfoReceiver, EdgeInfoReceiver>("edge");
 
 
 

RelationshipAnalysis/Services/GraphServices/Abstraction/IExpansionGraphReceiver.cs

@@ -0,0 +1,10 @@
+using RelationshipAnalysis.Dto;
+using RelationshipAnalysis.Dto.Graph;
+
+namespace RelationshipAnalysis.Services.GraphServices.Abstraction;
+
+public interface IExpansionGraphReceiver
+{
+    Task<GraphDto> GetExpansionGraph(int nodeId, string sourceCategoryName, string targetCategoryName,
+        string edgeCategoryName);
+}

RelationshipAnalysis/Services/GraphServices/Abstraction/IGraphDtoCreator.cs

@@ -0,0 +1,10 @@
+using RelationshipAnalysis.Dto.Graph;
+using RelationshipAnalysis.Models.Graph;
+using Node = AngleSharp.Dom.Node;
+
+namespace RelationshipAnalysis.Services.GraphServices.Abstraction;
+
+public interface IGraphDtoCreator
+{
+    GraphDto CreateResultGraphDto(List<Models.Graph.Node> contextNodes, List<Models.Graph.Edge> contextEdges);
+}

RelationshipAnalysis/Services/GraphServices/Abstraction/IInfoReceiver.cs

@@ -0,0 +1,8 @@
+using RelationshipAnalysis.Dto;
+
+namespace RelationshipAnalysis.Services.GraphServices.Abstraction;
+
+public interface IInfoReceiver
+{
+    Task<ActionResponse<IDictionary<string, string>>> GetInfo(int id);
+}

RelationshipAnalysis/Services/GraphServices/EdgeInfoReceiver.cs

@@ -0,0 +1,41 @@
+using RelationshipAnalysis.Context;
+using RelationshipAnalysis.Dto;
+using RelationshipAnalysis.Enums;
+using RelationshipAnalysis.Services.GraphServices.Abstraction;
+
+namespace RelationshipAnalysis.Services.GraphServices;
+
+public class EdgeInfoReceiver(IServiceProvider serviceProvider) : IInfoReceiver
+{
+    public Task<ActionResponse<IDictionary<string, string>>> GetInfo(int edgeId)
+    {
+        using var scope = serviceProvider.CreateScope();
+        var context = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
+
+        var result = new Dictionary<string, string>();
+        var selectedEdge = context.Edges.SingleOrDefault(e => e.EdgeId == edgeId);
+        if (selectedEdge == null)
+        {
+            return NotFoundResult();
+        }
+        selectedEdge.EdgeValues.ToList().ForEach(v => result.Add(v.EdgeAttribute.EdgeAttributeName, v.ValueData));
+        return SuccessResult(result);
+    }
+
+    private async Task<ActionResponse<IDictionary<string, string>>> NotFoundResult()
+    {
+        return new ActionResponse<IDictionary<string, string>>()
+        {
+            StatusCode = StatusCodeType.NotFound
+        };
+    }
+
+    private async Task<ActionResponse<IDictionary<string, string>>> SuccessResult(Dictionary<string, string> result)
+    {
+        return new ActionResponse<IDictionary<string, string>>()
+        {
+            StatusCode = StatusCodeType.Success,
+            Data =  result
+        };
+    }
+}

RelationshipAnalysis/Services/GraphServices/ExpansionGraphReceiver.cs

@@ -0,0 +1,46 @@
+using Microsoft.EntityFrameworkCore;
+using RelationshipAnalysis.Context;
+using RelationshipAnalysis.Dto.Graph;
+using RelationshipAnalysis.Models.Graph;
+using RelationshipAnalysis.Services.GraphServices.Abstraction;
+
+namespace RelationshipAnalysis.Services.GraphServices;
+
+public class ExpansionGraphReceiver(IServiceProvider serviceProvider, IGraphDtoCreator graphDtoCreator) : IExpansionGraphReceiver
+{
+    public async Task<GraphDto> GetExpansionGraph(int nodeId, string sourceCategoryName, string targetCategoryName, string edgeCategoryName)
+    {
+        using var scope = serviceProvider.CreateScope();
+        var context = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
+
+        var inputNodes = await GetInputNodes(sourceCategoryName, context);
+        var outputNodes = await GetOutputNodes(targetCategoryName, context);
+        var validEdges = await GetValidEdges(edgeCategoryName, context, inputNodes, outputNodes);
+
+        return graphDtoCreator.CreateResultGraphDto(inputNodes.Union(outputNodes).ToList(), validEdges);
+    }
+
+    private async Task<List<Edge>> GetValidEdges(string edgeCategoryName, ApplicationDbContext context, List<Node> inputNodes,
+        List<Node> outputNodes)
+    {
+        var validEdges = await context.Edges.Where(e =>
+            e.EdgeCategory.EdgeCategoryName == edgeCategoryName &&
+            inputNodes.Contains(e.NodeSource) &&
+            outputNodes.Contains(e.NodeDestination)).ToListAsync();
+        return validEdges;
+    }
+
+    private async Task<List<Node>> GetOutputNodes(string targetCategoryName, ApplicationDbContext context)
+    {
+        var outputNodes =
+            await context.Nodes.Where(n => n.NodeCategory.NodeCategoryName == targetCategoryName).ToListAsync();
+        return outputNodes;
+    }
+
+    private async Task<List<Node>> GetInputNodes(string sourceCategoryName, ApplicationDbContext context)
+    {
+        var inputNodes =
+            await context.Nodes.Where(n => n.NodeCategory.NodeCategoryName == sourceCategoryName).ToListAsync();
+        return inputNodes;
+    }
+}

RelationshipAnalysis/Services/GraphServices/GraphDtoCreator.cs

@@ -0,0 +1,28 @@
+using RelationshipAnalysis.Dto.Graph;
+using RelationshipAnalysis.Models.Graph;
+using RelationshipAnalysis.Services.GraphServices.Abstraction;
+using Node = AngleSharp.Dom.Node;
+
+namespace RelationshipAnalysis.Services.GraphServices;
+
+public class GraphDtoCreator : IGraphDtoCreator
+{
+
+    public GraphDto CreateResultGraphDto(List<Models.Graph.Node> contextNodes, List<Models.Graph.Edge> contextEdges)
+    {
+        if (contextEdges == null || contextNodes == null) throw new ArgumentNullException();
+        var resultGraphDto = new GraphDto();
+        contextNodes.ForEach(n => resultGraphDto.nodes.Add(new NodeDto
+        {
+            id = n.NodeId.ToString(),
+            label = $"{n.NodeCategory.NodeCategoryName}/{n.NodeUniqueString}"
+        }));
+        contextEdges.ForEach(e => resultGraphDto.edges.Add(new EdgeDto
+        {
+            id = e.EdgeId.ToString(),
+            source = e.EdgeSourceNodeId.ToString(),
+            target = e.EdgeDestinationNodeId.ToString()
+        }));
+        return resultGraphDto;
+    }
+}

RelationshipAnalysis/Services/GraphServices/NodeInfoReceiver.cs

@@ -0,0 +1,42 @@
+using Microsoft.AspNetCore.Mvc;
+using RelationshipAnalysis.Context;
+using RelationshipAnalysis.Dto;
+using RelationshipAnalysis.Enums;
+using RelationshipAnalysis.Services.GraphServices.Abstraction;
+
+namespace RelationshipAnalysis.Services.GraphServices;
+
+public class NodeInfoReceiver(IServiceProvider serviceProvider) : IInfoReceiver
+{
+    public Task<ActionResponse<IDictionary<string, string>>> GetInfo(int nodeId)
+    {
+        using var scope = serviceProvider.CreateScope();
+        var context = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
+
+        var result = new Dictionary<string, string>();
+        var selectedNode = context.Nodes.SingleOrDefault(n => n.NodeId == nodeId);
+        if (selectedNode == null)
+        {
+            return NotFoundResult();
+        }
+        selectedNode.Values.ToList().ForEach(v => result.Add(v.NodeAttribute.NodeAttributeName, v.ValueData));
+        return SuccessResult(result);
+    }
+
+    private async Task<ActionResponse<IDictionary<string, string>>> NotFoundResult()
+    {
+        return new ActionResponse<IDictionary<string, string>>()
+        {
+            StatusCode = StatusCodeType.NotFound
+        };
+    }
+
+    private async Task<ActionResponse<IDictionary<string, string>>> SuccessResult(Dictionary<string, string> result)
+    {
+        return new ActionResponse<IDictionary<string, string>>()
+        {
+            StatusCode = StatusCodeType.Success,
+            Data =  result
+        };
+    }
+}