Added folder system

src/Application/Common/DTOs/Folders/FolderInDto.cs

@@ -0,0 +1,18 @@
+namespace Application.Common.DTOs.Folders;
+
+public class FolderInDto
+{
+ public string Guid { get; set; }
+
+ public string Name { get; set; }
+
+ public string Color { get; set; }
+
+ public string Icon { get; set; }
+
+ public string Description { get; set; }
+
+ public string LastModified { get; set; }
+
+ public ICollection<FolderInDto> Children { get; set; } = new List<FolderInDto>();
+}

src/Application/Common/DTOs/Folders/FolderOutDto.cs

@@ -0,0 +1,20 @@
+using System.Collections.ObjectModel;
+
+namespace Application.Common.DTOs.Folders;
+
+public class FolderOutDto
+{
+ public string Guid { get; set; }
+
+ public string Name { get; set; }
+
+ public string Color { get; set; }
+
+ public string Icon { get; set; }
+
+ public string Description { get; set; }
+
+ public string LastModified { get; set; }
+
+ public ICollection<FolderOutDto> Children { get; set; } = new Collection<FolderOutDto>();
+}

src/Application/Interfaces/Repositories/IFolderRepository.cs

@@ -0,0 +1,11 @@
+using Domain.Entities;
+
+namespace Application.Interfaces.Repositories;
+
+public interface IFolderRepository
+{
+ public Task SaveChangesAsync();
+ public Task<Folder> GetFolderAsync(Guid folderId);
+ public Task CreateFolderAsync(Folder folder);
+ public void RemoveFolder(Folder folder);
+}

src/Application/Interfaces/Services/IFolderService.cs

@@ -0,0 +1,9 @@
+using Application.Common.DTOs.Folders;
+
+namespace Application.Interfaces.Services;
+
+public interface IFolderService
+{
+ public Task UpdateFoldersAsync(string email, FolderInDto folderInDto);
+ public Task<FolderOutDto> GetFoldersAsync(string email);
+}

src/Application/Services/FolderService.cs

@@ -0,0 +1,102 @@
+using Application.Common.DTOs.Folders;
+using Application.Common.Exceptions;
+using Application.Interfaces.Repositories;
+using Application.Interfaces.Services;
+using Domain.Entities;
+
+namespace Application.Services;
+
+public class FolderService(IUserRepository userRepository, IFolderRepository folderRepository) : IFolderService
+{
+ public IUserRepository UserRepository { get; } = userRepository;
+ public IFolderRepository FolderRepository { get; } = folderRepository;
+
+ public async Task UpdateFoldersAsync(string email, FolderInDto folderInDto)
+ {
+ var user = await UserRepository.GetAsync(email, true);
+ if (user == null)
+ throw new CommonErrorException(400, "No user with this email exists", 17);
+
+ var folder = FolderInDtoToFolder(folderInDto);
+ // If the user has no root folder, create it and set it as the user's root folder
+ if(user.RootFolderId == Guid.Empty)
+ {
+ await FolderRepository.CreateFolderAsync(folder);
+ user.RootFolderId = folder.FolderId;
+
+ await UserRepository.SaveChangesAsync();
+ return;
+ }
+
+ if(folder.FolderId != user.RootFolderId)
+ throw new CommonErrorException(400, "Folder id does not match user root folder id", 0);
+
+ var existingFolder = await FolderRepository.GetFolderAsync(user.RootFolderId);
+ if(existingFolder == null)
+ throw new CommonErrorException(400, "User has no root folder", 0);
+
+ FolderRepository.RemoveFolder(existingFolder);
+ await FolderRepository.CreateFolderAsync(folder);
+ await FolderRepository.SaveChangesAsync();
+ }
+
+ private Folder FolderInDtoToFolder(FolderInDto folderInDto)
+ {
+ var folder = new Folder
+ {
+ FolderId = new Guid(folderInDto.Guid),
+ Name = folderInDto.Name,
+ Color = folderInDto.Color,
+ Icon = folderInDto.Icon,
+ Description = folderInDto.Description,
+ LastModified = folderInDto.LastModified,
+ Children = new List<Folder>()
+ };
+
+ foreach (var child in folderInDto.Children)
+ {
+ var childFolder = FolderInDtoToFolder(child);
+ folder.Children.Add(childFolder);
+ }
+
+ return folder;
+ }
+
+ public async Task<FolderOutDto> GetFoldersAsync(string email)
+ {
+ var user = await UserRepository.GetAsync(email, false);
+ if (user == null)
+ {
+ throw new CommonErrorException(400, "No user with this email exists", 17);
+ }
+
+ if(user.RootFolderId == Guid.Empty)
+ {
+ throw new CommonErrorException(400, "User has no root folder", 22);
+ }
+
+ var folder = await FolderRepository.GetFolderAsync(user.RootFolderId);
+ return await FolderToFolderOutDto(folder);
+ }
+
+ private async Task<FolderOutDto> FolderToFolderOutDto(Folder folder)
+ {
+ var folderOutDto = new FolderOutDto
+ {
+ Guid = folder.FolderId.ToString(),
+ Name = folder.Name,
+ Color = folder.Color,
+ Icon = folder.Icon,
+ LastModified = folder.LastModified,
+ Description = folder.Description
+ };
+
+ foreach (var child in folder.Children)
+ {
+ var childFolderOutDto = await FolderToFolderOutDto(child);
+ folderOutDto.Children.Add(childFolderOutDto);
+ }
+
+ return folderOutDto;
+ }
+}

src/Domain/Entities/Folder.cs

@@ -0,0 +1,30 @@
+#nullable enable
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Domain.Entities;
+
+public class Folder
+{
+ [DatabaseGenerated(DatabaseGeneratedOption.None)]
+ [Key]
+ public Guid FolderId { get; set; }
+
+ [Required]
+ public string Name { get; set; }
+
+ [Required]
+ public string Color { get; set; }
+
+ [Required]
+ public string Icon { get; set; }
+
+ public string Description { get; set; }
+
+ [Required]
+ public string LastModified { get; set; }
+
+ public Guid? ParentFolderId { get; set; }
+ public Folder? ParentFolder { get; set; }
+ public List<Folder>? Children { get; set; } = new List<Folder>();
+}

src/Domain/Entities/User.cs

@@ -39,6 +39,8 @@ public class User : IdentityUser
  [Required]
  public int AiExplanationRequestsMadeToday { get; set; } = 0;
 
+ public Guid RootFolderId { get; set; }
+
  public ICollection<Book> Books { get; set; }
  public ICollection<Tag> Tags { get; set; }
 }

src/Infrastructure/Persistence/DataContext.cs

@@ -12,6 +12,7 @@ public class DataContext : IdentityDbContext<User>
  public DbSet<Bookmark> Bookmarks { get; set; }
  public DbSet<Tag> Tags { get; set; }
  public DbSet<Product> Products { get; set; }
+ public DbSet<Folder> Folders { get; set; }
 
  public DataContext(DbContextOptions<DataContext> options) :
  base(options)

src/Infrastructure/Persistence/EntityConfigurations/FolderConfiguration.cs

@@ -0,0 +1,17 @@
+using Domain.Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Infrastructure.Persistence.EntityConfigurations;
+
+public class FolderConfiguration : IEntityTypeConfiguration<Folder>
+{
+ public void Configure(EntityTypeBuilder<Folder> builder)
+ {
+ builder
+ .HasOne(f => f.ParentFolder)
+ .WithMany(f => f.Children)
+ .HasForeignKey(f => f.ParentFolderId)
+ .OnDelete(DeleteBehavior.NoAction);
+ }
+}

src/Infrastructure/Persistence/Migrations/DataContextModelSnapshot.cs

@@ -144,6 +144,41 @@ protected override void BuildModel(ModelBuilder modelBuilder)
  b.ToTable("Bookmarks");
  });
 
+ modelBuilder.Entity("Domain.Entities.Folder", b =>
+ {
+ b.Property<Guid>("FolderId")
+ .HasColumnType("uniqueidentifier");
+
+ b.Property<string>("Color")
+ .IsRequired()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property<string>("Description")
+ .IsRequired()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property<string>("Icon")
+ .IsRequired()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property<string>("LastModified")
+ .IsRequired()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property<string>("Name")
+ .IsRequired()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property<Guid?>("ParentFolderId")
+ .HasColumnType("uniqueidentifier");
+
+ b.HasKey("FolderId");
+
+ b.HasIndex("ParentFolderId");
+
+ b.ToTable("Folders");
+ });
+
  modelBuilder.Entity("Domain.Entities.Highlight", b =>
  {
  b.Property<Guid>("HighlightId")
@@ -349,6 +384,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
  b.Property<DateTime>("ProfilePictureLastUpdated")
  .HasColumnType("datetime2");
 
+ b.Property<Guid>("RootFolderId")
+ .HasColumnType("uniqueidentifier");
+
  b.Property<string>("SecurityStamp")
  .HasColumnType("nvarchar(max)");
 
@@ -530,6 +568,16 @@ protected override void BuildModel(ModelBuilder modelBuilder)
  b.Navigation("Book");
  });
 
+ modelBuilder.Entity("Domain.Entities.Folder", b =>
+ {
+ b.HasOne("Domain.Entities.Folder", "ParentFolder")
+ .WithMany("Children")
+ .HasForeignKey("ParentFolderId")
+ .OnDelete(DeleteBehavior.NoAction);
+
+ b.Navigation("ParentFolder");
+ });
+
  modelBuilder.Entity("Domain.Entities.Highlight", b =>
  {
  b.HasOne("Domain.Entities.Book", "Book")
@@ -638,6 +686,11 @@ protected override void BuildModel(ModelBuilder modelBuilder)
  b.Navigation("Tags");
  });
 
+ modelBuilder.Entity("Domain.Entities.Folder", b =>
+ {
+ b.Navigation("Children");
+ });
+
  modelBuilder.Entity("Domain.Entities.Highlight", b =>
  {
  b.Navigation("Rects");

src/Infrastructure/Persistence/Repository/FolderRepository.cs

@@ -0,0 +1,50 @@
+using Application.Interfaces.Repositories;
+using Domain.Entities;
+using Microsoft.EntityFrameworkCore;
+
+namespace Infrastructure.Persistence.Repository;
+
+public class FolderRepository(DataContext context) : IFolderRepository
+{
+ public DataContext Context { get; } = context;
+
+ public async Task SaveChangesAsync()
+ {
+ await Context.SaveChangesAsync();
+ }
+
+ public async Task<Folder> GetFolderAsync(Guid folderId)
+ {
+ return await Context.Folders
+ .Where(f => f.FolderId == folderId)
+ .Include(f => f.Children)
+ .ThenInclude(f => f.Children)
+ .ThenInclude(f => f.Children)
+ .ThenInclude(f => f.Children)
+ .ThenInclude(f => f.Children)
+ .FirstOrDefaultAsync();
+ }
+
+ public async Task CreateFolderAsync(Folder folder)
+ {
+ await Context.Folders.AddAsync(folder);
+ }
+
+ public void RemoveFolder(Folder folder)
+ {
+ var allFolders = new List<Folder>();
+ GetAllChildren(folder, allFolders);
+ allFolders.Add(folder);
+
+ Context.Folders.RemoveRange(allFolders);
+ }
+
+ private void GetAllChildren(Folder folder, List<Folder> allChildren)
+ {
+ allChildren.Add(folder);
+ foreach (var child in folder.Children)
+ {
+ GetAllChildren(child, allChildren);
+ }
+ }
+}