Rough version of Saving Series, Volumes, and MangaFiles to the DB. Relies on Cascaded delete rather than manually handling updating of file changes.

API/Controllers/LibraryController.cs

@@ -86,8 +86,10 @@ namespace API.Controllers
         [HttpGet("scan")]
         public async Task<ActionResult> ScanLibrary(int libraryId)
         {
-            var library = await _libraryRepository.GetLibraryForIdAsync(libraryId);
+            var library = await _libraryRepository.GetLibraryDtoForIdAsync(libraryId);
             
+            // We have to send a json encoded Library (aka a DTO) to the Background Job thread. 
+            // Because we use EF, we have circular dependencies back to Library and it will crap out
             BackgroundJob.Enqueue(() => _directoryService.ScanLibrary(library));
 
             return Ok();

API/Data/DataContext.cs

@@ -14,6 +14,9 @@ namespace API.Data
             
         }
         public DbSet<Library> Library { get; set; }
+        public DbSet<Series> Series { get; set; }
+        public DbSet<Volume> Volume { get; set; }
+        
 
         protected override void OnModelCreating(ModelBuilder builder)
         {
@@ -30,6 +33,12 @@ namespace API.Data
                 .WithOne(u => u.Role)
                 .HasForeignKey(ur => ur.RoleId)
                 .IsRequired();
+            
+            // builder.Entity<Library>()
+            //     .HasMany(s => s.Series)
+            //     .WithOne(l => l.Library)
+            //     .HasForeignKey(x => x.Id)
+                
         }
     }
 }

API/Data/LibraryRepository.cs

@@ -30,6 +30,20 @@ namespace API.Data
         {
             return await _context.SaveChangesAsync() > 0;
         }
+        
+        public bool SaveAll()
+        {
+            return _context.SaveChanges() > 0;
+        }
+
+        public Library GetLibraryForName(string libraryName)
+        {
+            return _context.Library
+                .Where(x => x.Name == libraryName)
+                .Include(f => f.Folders)
+                .Include(s => s.Series)
+                .Single();
+        }
 
         public async Task<IEnumerable<LibraryDto>> GetLibrariesAsync()
         {
@@ -38,7 +52,7 @@ namespace API.Data
                 .ProjectTo<LibraryDto>(_mapper.ConfigurationProvider).ToListAsync();
         }
         
-        public async Task<LibraryDto> GetLibraryForIdAsync(int libraryId)
+        public async Task<LibraryDto> GetLibraryDtoForIdAsync(int libraryId)
         {
             return await _context.Library
                 .Where(x => x.Id == libraryId)
@@ -46,7 +60,14 @@ namespace API.Data
                 .ProjectTo<LibraryDto>(_mapper.ConfigurationProvider).SingleAsync();
         }
         
-
+        public async Task<Library> GetLibraryForIdAsync(int libraryId)
+        {
+            return await _context.Library
+                .Where(x => x.Id == libraryId)
+                .Include(f => f.Folders)
+                .SingleAsync();
+        }
+        
         public async Task<bool> LibraryExists(string libraryName)
         {
             return await _context.Library.AnyAsync(x => x.Name == libraryName);

API/Data/Migrations/20201229190216_SeriesAndVolumeEntities.Designer.cs

@@ -0,0 +1,488 @@
+// <auto-generated />
+using System;
+using API.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace API.Data.Migrations
+{
+    [DbContext(typeof(DataContext))]
+    [Migration("20201229190216_SeriesAndVolumeEntities")]
+    partial class SeriesAndVolumeEntities
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "5.0.1");
+
+            modelBuilder.Entity("API.Entities.AppRole", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles");
+                });
+
+            modelBuilder.Entity("API.Entities.AppUser", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsAdmin")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastActive")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers");
+                });
+
+            modelBuilder.Entity("API.Entities.AppUserRole", b =>
+                {
+                    b.Property<int>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles");
+                });
+
+            modelBuilder.Entity("API.Entities.FolderPath", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LibraryId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LibraryId");
+
+                    b.ToTable("FolderPath");
+                });
+
+            modelBuilder.Entity("API.Entities.Library", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("CoverImage")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Library");
+                });
+
+            modelBuilder.Entity("API.Entities.MangaFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("FilePath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("VolumeId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("VolumeId");
+
+                    b.ToTable("MangaFile");
+                });
+
+            modelBuilder.Entity("API.Entities.Series", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LibraryId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OriginalName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SortName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Summary")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LibraryId");
+
+                    b.ToTable("Series");
+                });
+
+            modelBuilder.Entity("API.Entities.Volume", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Number")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SeriesId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SeriesId");
+
+                    b.ToTable("Volume");
+                });
+
+            modelBuilder.Entity("AppUserLibrary", b =>
+                {
+                    b.Property<int>("AppUsersId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LibrariesId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("AppUsersId", "LibrariesId");
+
+                    b.HasIndex("LibrariesId");
+
+                    b.ToTable("AppUserLibrary");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<int>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<int>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<int>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<int>", b =>
+                {
+                    b.Property<int>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens");
+                });
+
+            modelBuilder.Entity("API.Entities.AppUserRole", b =>
+                {
+                    b.HasOne("API.Entities.AppRole", "Role")
+                        .WithMany("UserRoles")
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Entities.AppUser", "User")
+                        .WithMany("UserRoles")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("API.Entities.FolderPath", b =>
+                {
+                    b.HasOne("API.Entities.Library", "Library")
+                        .WithMany("Folders")
+                        .HasForeignKey("LibraryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Library");
+                });
+
+            modelBuilder.Entity("API.Entities.MangaFile", b =>
+                {
+                    b.HasOne("API.Entities.Volume", "Volume")
+                        .WithMany("Files")
+                        .HasForeignKey("VolumeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Volume");
+                });
+
+            modelBuilder.Entity("API.Entities.Series", b =>
+                {
+                    b.HasOne("API.Entities.Library", "Library")
+                        .WithMany("Series")
+                        .HasForeignKey("LibraryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Library");
+                });
+
+            modelBuilder.Entity("API.Entities.Volume", b =>
+                {
+                    b.HasOne("API.Entities.Series", "Series")
+                        .WithMany("Volumes")
+                        .HasForeignKey("SeriesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Series");
+                });
+
+            modelBuilder.Entity("AppUserLibrary", b =>
+                {
+                    b.HasOne("API.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("AppUsersId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("API.Entities.Library", null)
+                        .WithMany()
+                        .HasForeignKey("LibrariesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<int>", b =>
+                {
+                    b.HasOne("API.Entities.AppRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<int>", b =>
+                {
+                    b.HasOne("API.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<int>", b =>
+                {
+                    b.HasOne("API.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<int>", b =>
+                {
+                    b.HasOne("API.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("API.Entities.AppRole", b =>
+                {
+                    b.Navigation("UserRoles");
+                });
+
+            modelBuilder.Entity("API.Entities.AppUser", b =>
+                {
+                    b.Navigation("UserRoles");
+                });
+
+            modelBuilder.Entity("API.Entities.Library", b =>
+                {
+                    b.Navigation("Folders");
+
+                    b.Navigation("Series");
+                });
+
+            modelBuilder.Entity("API.Entities.Series", b =>
+                {
+                    b.Navigation("Volumes");
+                });
+
+            modelBuilder.Entity("API.Entities.Volume", b =>
+                {
+                    b.Navigation("Files");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

API/Data/Migrations/20201229190216_SeriesAndVolumeEntities.cs

@@ -0,0 +1,129 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace API.Data.Migrations
+{
+    public partial class SeriesAndVolumeEntities : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "PasswordSalt",
+                table: "AspNetUsers");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "PasswordHash",
+                table: "AspNetUsers",
+                type: "TEXT",
+                nullable: true,
+                oldClrType: typeof(byte[]),
+                oldType: "BLOB",
+                oldNullable: true);
+
+            migrationBuilder.CreateTable(
+                name: "Series",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    Name = table.Column<string>(type: "TEXT", nullable: true),
+                    OriginalName = table.Column<string>(type: "TEXT", nullable: true),
+                    SortName = table.Column<string>(type: "TEXT", nullable: true),
+                    Summary = table.Column<string>(type: "TEXT", nullable: true),
+                    LibraryId = table.Column<int>(type: "INTEGER", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Series", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Series_Library_LibraryId",
+                        column: x => x.LibraryId,
+                        principalTable: "Library",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Volume",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    Number = table.Column<string>(type: "TEXT", nullable: true),
+                    SeriesId = table.Column<int>(type: "INTEGER", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Volume", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Volume_Series_SeriesId",
+                        column: x => x.SeriesId,
+                        principalTable: "Series",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "MangaFile",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    FilePath = table.Column<string>(type: "TEXT", nullable: true),
+                    VolumeId = table.Column<int>(type: "INTEGER", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_MangaFile", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_MangaFile_Volume_VolumeId",
+                        column: x => x.VolumeId,
+                        principalTable: "Volume",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MangaFile_VolumeId",
+                table: "MangaFile",
+                column: "VolumeId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Series_LibraryId",
+                table: "Series",
+                column: "LibraryId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Volume_SeriesId",
+                table: "Volume",
+                column: "SeriesId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "MangaFile");
+
+            migrationBuilder.DropTable(
+                name: "Volume");
+
+            migrationBuilder.DropTable(
+                name: "Series");
+
+            migrationBuilder.AlterColumn<byte[]>(
+                name: "PasswordHash",
+                table: "AspNetUsers",
+                type: "BLOB",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldNullable: true);
+
+            migrationBuilder.AddColumn<byte[]>(
+                name: "PasswordSalt",
+                table: "AspNetUsers",
+                type: "BLOB",
+                nullable: true);
+        }
+    }
+}

API/Data/Migrations/DataContextModelSnapshot.cs

@@ -1,7 +1,9 @@
 // <auto-generated />
 using System;
+using API.Data;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 
 namespace API.Data.Migrations
 {
@@ -84,11 +86,8 @@ namespace API.Data.Migrations
                         .HasMaxLength(256)
                         .HasColumnType("TEXT");
 
-                    b.Property<byte[]>("PasswordHash")
-                        .HasColumnType("BLOB");
-
-                    b.Property<byte[]>("PasswordSalt")
-                        .HasColumnType("BLOB");
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("TEXT");
 
                     b.Property<string>("PhoneNumber")
                         .HasColumnType("TEXT");
@@ -176,6 +175,72 @@ namespace API.Data.Migrations
                     b.ToTable("Library");
                 });
 
+            modelBuilder.Entity("API.Entities.MangaFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("FilePath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("VolumeId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("VolumeId");
+
+                    b.ToTable("MangaFile");
+                });
+
+            modelBuilder.Entity("API.Entities.Series", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LibraryId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OriginalName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SortName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Summary")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LibraryId");
+
+                    b.ToTable("Series");
+                });
+
+            modelBuilder.Entity("API.Entities.Volume", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Number")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SeriesId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SeriesId");
+
+                    b.ToTable("Volume");
+                });
+
             modelBuilder.Entity("AppUserLibrary", b =>
                 {
                     b.Property<int>("AppUsersId")
@@ -305,6 +370,39 @@ namespace API.Data.Migrations
                     b.Navigation("Library");
                 });
 
+            modelBuilder.Entity("API.Entities.MangaFile", b =>
+                {
+                    b.HasOne("API.Entities.Volume", "Volume")
+                        .WithMany("Files")
+                        .HasForeignKey("VolumeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Volume");
+                });
+
+            modelBuilder.Entity("API.Entities.Series", b =>
+                {
+                    b.HasOne("API.Entities.Library", "Library")
+                        .WithMany("Series")
+                        .HasForeignKey("LibraryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Library");
+                });
+
+            modelBuilder.Entity("API.Entities.Volume", b =>
+                {
+                    b.HasOne("API.Entities.Series", "Series")
+                        .WithMany("Volumes")
+                        .HasForeignKey("SeriesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Series");
+                });
+
             modelBuilder.Entity("AppUserLibrary", b =>
                 {
                     b.HasOne("API.Entities.AppUser", null)
@@ -369,6 +467,18 @@ namespace API.Data.Migrations
             modelBuilder.Entity("API.Entities.Library", b =>
                 {
                     b.Navigation("Folders");
+
+                    b.Navigation("Series");
+                });
+
+            modelBuilder.Entity("API.Entities.Series", b =>
+                {
+                    b.Navigation("Volumes");
+                });
+
+            modelBuilder.Entity("API.Entities.Volume", b =>
+                {
+                    b.Navigation("Files");
                 });
 #pragma warning restore 612, 618
         }

API/Data/SeriesRepository.cs

@@ -0,0 +1,43 @@
+using System.Linq;
+using System.Threading.Tasks;
+using API.Entities;
+using API.Interfaces;
+using Microsoft.EntityFrameworkCore;
+
+namespace API.Data
+{
+    public class SeriesRepository : ISeriesRepository
+    {
+        private readonly DataContext _context;
+
+        public SeriesRepository(DataContext context)
+        {
+            _context = context;
+        }
+
+        public void Update(Series series)
+        {
+            _context.Entry(series).State = EntityState.Modified;
+        }
+
+        public async Task<bool> SaveAllAsync()
+        {
+            return await _context.SaveChangesAsync() > 0;
+        }
+        
+        public bool SaveAll()
+        {
+            return _context.SaveChanges() > 0;
+        }
+
+        public async Task<Series> GetSeriesByNameAsync(string name)
+        {
+            return await _context.Series.SingleOrDefaultAsync(x => x.Name == name);
+        }
+        
+        public Series GetSeriesByName(string name)
+        {
+            return _context.Series.SingleOrDefault(x => x.Name == name);
+        }
+    }
+}

API/Entities/Library.cs

@@ -10,5 +10,6 @@ namespace API.Entities
         public LibraryType Type { get; set; }
         public ICollection<FolderPath> Folders { get; set; }
         public ICollection<AppUser> AppUsers { get; set; }
+        public ICollection<Series> Series { get; set; }
     }
 }

API/Entities/MangaFile.cs

@@ -0,0 +1,14 @@
+namespace API.Entities
+{
+    public class MangaFile
+    {
+        public int Id { get; set; }
+        public string FilePath { get; set; }
+        //public string FileExtension { get; set; }
+        
+        // Relationship Mapping
+        public Volume Volume { get; set; }
+        public int VolumeId { get; set; }
+        
+    }
+}

API/Entities/Series.cs

@@ -4,6 +4,7 @@ namespace API.Entities
 {
     public class Series
     {
+        public int Id { get; set; }
         /// <summary>
         /// The UI visible Name of the Series. This may or may not be the same as the OriginalName
         /// </summary>
@@ -20,9 +21,11 @@ namespace API.Entities
         /// Summary information related to the Series
         /// </summary>
         public string Summary { get; set; }
-        
         public ICollection<Volume> Volumes { get; set; }
         
+        public Library Library { get; set; }
+        public int LibraryId { get; set; }
+        
         
     }
 }

API/Entities/Volume.cs

@@ -4,8 +4,9 @@ namespace API.Entities
 {
     public class Volume
     {
+        public int Id { get; set; }
         public string Number { get; set; }
-        public ICollection<string> Files { get; set; }
+        public ICollection<MangaFile> Files { get; set; }
         
         // Many-to-Many relationships
         public Series Series { get; set; }

API/Extensions/ApplicationServiceExtensions.cs

@@ -19,6 +19,7 @@ namespace API.Extensions
             services.AddScoped<ITaskScheduler, TaskScheduler>();
             services.AddScoped<IUserRepository, UserRepository>();
             services.AddScoped<ITokenService, TokenService>();
+            services.AddScoped<ISeriesRepository, SeriesRepository>();
             services.AddScoped<IDirectoryService, DirectoryService>();
             services.AddScoped<ILibraryRepository, LibraryRepository>();
             services.AddDbContext<DataContext>(options =>

API/Interfaces/IDirectoryService.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using API.DTOs;
+using API.Entities;
 
 namespace API.Interfaces
 {

API/Interfaces/ILibraryRepository.cs

@@ -16,7 +16,9 @@ namespace API.Interfaces
         /// <param name="libraryName"></param>
         /// <returns></returns>
         Task<bool> LibraryExists(string libraryName);
-
-        public Task<LibraryDto> GetLibraryForIdAsync(int libraryId);
+        Task<LibraryDto> GetLibraryDtoForIdAsync(int libraryId);
+        Task<Library> GetLibraryForIdAsync(int libraryId);
+        bool SaveAll();
+        Library GetLibraryForName(string libraryName);
     }
 }

API/Interfaces/ISeriesRepository.cs

@@ -0,0 +1,14 @@
+using System.Threading.Tasks;
+using API.Entities;
+
+namespace API.Interfaces
+{
+    public interface ISeriesRepository
+    {
+        void Update(Series series);
+        Task<bool> SaveAllAsync();
+        Task<Series> GetSeriesByNameAsync(string name);
+        Series GetSeriesByName(string name);
+        bool SaveAll();
+    }
+}

API/Services/DirectoryService.cs

@@ -5,13 +5,16 @@ using System.Collections.Immutable;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Security;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 using API.DTOs;
+using API.Entities;
 using API.Interfaces;
 using API.Parser;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 
 namespace API.Services
@@ -19,11 +22,15 @@ namespace API.Services
     public class DirectoryService : IDirectoryService
     {
        private readonly ILogger<DirectoryService> _logger;
+       private readonly ISeriesRepository _seriesRepository;
+       private readonly ILibraryRepository _libraryRepository;
        private ConcurrentDictionary<string, ConcurrentBag<ParserInfo>> _scannedSeries;
 
-       public DirectoryService(ILogger<DirectoryService> logger)
+       public DirectoryService(ILogger<DirectoryService> logger, ISeriesRepository seriesRepository, ILibraryRepository libraryRepository)
        {
           _logger = logger;
+          _seriesRepository = seriesRepository;
+          _libraryRepository = libraryRepository;
        }
        
        /// <summary>
@@ -125,6 +132,42 @@ namespace API.Services
           }
        }
 
+       private Series UpdateSeries(string seriesName, ParserInfo[] infos)
+       {
+          var series = _seriesRepository.GetSeriesByName(seriesName);
+
+          if (series == null)
+          {
+             series = new Series()
+             {
+                Name = seriesName,
+                OriginalName = seriesName,
+                SortName = seriesName,
+                Summary = "",
+             };
+          }
+          
+          ICollection<Volume> volumes = new List<Volume>();
+          foreach (var info in infos)
+          {
+             volumes.Add(new Volume()
+             {
+                Number = info.Volumes,
+                Files = new List<MangaFile>() {new MangaFile()
+                {
+                   FilePath = info.File
+                }}
+             });
+          }
+
+          series.Volumes = volumes;
+          
+
+          //_seriesRepository.Update(series);
+
+          return series;
+       }
+
         public void ScanLibrary(LibraryDto library)
         {
            _scannedSeries = new ConcurrentDictionary<string, ConcurrentBag<ParserInfo>>();
@@ -154,10 +197,62 @@ namespace API.Services
            var filtered = _scannedSeries.Where(kvp => !kvp.Value.IsEmpty);
            var series = filtered.ToImmutableDictionary(v => v.Key, v => v.Value);
 
-           // TODO: Perform DB activities on ImmutableDictionary
+           // Perform DB activities on ImmutableDictionary
+           var libraryEntity = _libraryRepository.GetLibraryForName(library.Name);
+           libraryEntity.Series = new List<Series>(); // Temp delete everything for testing
+           foreach (var seriesKey in series.Keys)
+           {
+              var s = UpdateSeries(seriesKey, series[seriesKey].ToArray());
+              Console.WriteLine($"Created/Updated series {s.Name}");
+              libraryEntity.Series.Add(s);
+           }
            
+           _libraryRepository.Update(libraryEntity);
+
+           // This is throwing a DbUpdateConcurrencyException due to multiple threads modifying Library at one time. 
+           try
+           {
+              if (_libraryRepository.SaveAll())
+              {
+                 _logger.LogInformation($"Scan completed on {library.Name}. Parsed {series.Keys.Count()} series.");
+              }
+              else
+              {
+                 _logger.LogError("There was a critical error that resulted in a failed scan. Please rescan.");
+              }
+           }
+           catch (DbUpdateConcurrencyException ex)
+           {
+              foreach (var entry in ex.Entries)
+              {
+                 if (entry.Entity is Series)
+                 {
+                    var proposedValues = entry.CurrentValues;
+                    var databaseValues = entry.GetDatabaseValues();
+
+                    foreach (var property in proposedValues.Properties)
+                    {
+                       var proposedValue = proposedValues[property];
+                       var databaseValue = databaseValues[property];
+
+                       // TODO: decide which value should be written to database
+                       // proposedValues[property] = <value to be saved>;
+                       Console.WriteLine($"Proposed ({proposedValue}) vs Database ({databaseValue})");
+                    }
+
+                    // Refresh original values to bypass next concurrency check
+                    entry.OriginalValues.SetValues(databaseValues);
+                 }
+                 else
+                 {
+                    throw new NotSupportedException(
+                       "Don't know how to handle concurrency conflicts for "
+                       + entry.Metadata.Name);
+                 }
+              }
+           }
            
-           _logger.LogInformation($"Scan completed on {library.Name}. Parsed {series.Keys.Count()} series.");
+
            _scannedSeries = null;
         }