changes

Repositories/TreeRepository.cs

@@ -0,0 +1,168 @@
+using Microsoft.EntityFrameworkCore;
+using public_valetax.Data;
+using public_valetax.Models;
+using public_valetax.DTOs;
+using public_valetax.Exceptions;
+
+namespace public_valetax.Repositories
+{
+    public class TreeRepository(ApplicationDbContext _context) : ITreeRepository
+    {
+        public async Task<Tree?> GetTreeByNameAsync(string name)
+        {
+            return await _context.Trees
+                .Include(t => t.Nodes)
+                .FirstOrDefaultAsync(t => t.Name == name);
+        }
+
+        public async Task<Tree> CreateTreeAsync(string name)
+        {
+            var tree = new Tree
+            {
+                Name = name,
+                CreatedAt = DateTime.UtcNow
+            };
+
+            if (await _context.Trees.AnyAsync(t => t.Name == name))
+            {
+                throw new SecureException("Tree with such name already exist");
+            }
+
+            _context.Trees.Add(tree);
+            await _context.SaveChangesAsync();
+            return tree;
+        }
+
+        public async Task<Node?> GetNodeByIdAsync(long nodeId)
+        {
+            return await _context.Nodes.FindAsync(nodeId);
+        }
+
+        public async Task<Node> CreateNodeAsync(long treeId, long? parentId, string name)
+        {
+            // Verify that parent node belongs to the same tree if provided
+            if (parentId.HasValue)
+            {
+                var parentNode = await _context.Nodes.FindAsync(parentId.Value);
+                if (parentNode == null || parentNode.TreeId != treeId)
+                {
+                    throw new SecureException("Parent node does not belong to the specified tree");
+                }
+            }
+
+            // Check if a node with the same name already exists in the same tree
+            var existingNode = await _context.Nodes
+                .FirstOrDefaultAsync(n => n.TreeId == treeId && n.Name == name && n.ParentId == parentId);
+            
+            if (existingNode != null)
+            {
+                throw new SecureException("A node with the same name already exists in this location");
+            }
+
+            var node = new Node
+            {
+                TreeId = treeId,
+                ParentId = parentId,
+                Name = name,
+                CreatedAt = DateTime.UtcNow
+            };
+
+            _context.Nodes.Add(node);
+            await _context.SaveChangesAsync();
+            return node;
+        }
+
+        public async Task DeleteNodeAsync(long nodeId)
+        {
+            var node = await _context.Nodes
+                .Include(n => n.Children)
+                .FirstOrDefaultAsync(n => n.Id == nodeId);
+
+            if (node == null)
+            {
+                throw new SecureException("Node not found");
+            }
+
+            // Check if node has children
+            if (node.Children.Any())
+            {
+                throw new SecureException("You have to delete all children nodes first");
+            }
+
+            _context.Nodes.Remove(node);
+            await _context.SaveChangesAsync();
+        }
+
+        public async Task RenameNodeAsync(long nodeId, string newName)
+        {
+            var node = await _context.Nodes.FindAsync(nodeId);
+            
+            if (node == null)
+            {
+                throw new SecureException("Node not found");
+            }
+
+            // Check if another node with the same name already exists in the same parent
+            var existingNode = await _context.Nodes
+                .FirstOrDefaultAsync(n => n.TreeId == node.TreeId && n.Name == newName && n.ParentId == node.ParentId && n.Id != nodeId);
+            
+            if (existingNode != null)
+            {
+                throw new SecureException("A node with the same name already exists in this location");
+            }
+
+            node.Name = newName;
+            await _context.SaveChangesAsync();
+        }
+
+        public async Task<MNode?> GetTreeStructureAsync(string treeName)
+        {
+            var tree = await _context.Trees
+                .Include(t => t.Nodes)
+                .FirstOrDefaultAsync(t => t.Name == treeName);
+
+            if (tree == null)
+            {
+                return null;
+            }
+
+            // Build the tree structure recursively
+            var rootNodes = tree.Nodes
+                .Where(n => n.ParentId == null)
+                .Select(n => BuildMNode(n, tree.Nodes))
+                .ToList();
+
+            // If no root node exists, create one
+            if (!rootNodes.Any())
+            {
+                return new MNode
+                {
+                    Id = 0,
+                    Name = tree.Name,
+                    Children = []
+                };
+            }
+
+            return rootNodes.First();
+        }
+
+        private MNode BuildMNode(Node node, ICollection<Node> allNodes)
+        {
+            var mNode = new MNode
+            {
+                Id = node.Id,
+                Name = node.Name,
+                Children = []
+            };
+
+            // Add children recursively
+            var children = allNodes.Where(n => n.ParentId == node.Id).ToList();
+            foreach (var child in children)
+            {
+                mNode.Children.Add(BuildMNode(child, allNodes));
+            }
+
+            return mNode;
+        }
+    }
+}