Forgot to fix single scrapes

.drone.yml

@@ -0,0 +1,53 @@
+kind: pipeline
+type: docker
+name: default
+
+steps:
+- name: build
+  image: mcr.microsoft.com/dotnet/sdk:6.0
+
+  commands:
+  - dotnet restore *.sln
+  - mkdir build
+  - mkdir publish
+  - mkdir publish/api
+  - mkdir publish/frontend
+  - mkdir dist
+  - dotnet build *.sln -c Release -o build
+  - dotnet publish WebNovelPortalAPI/*.csproj -c Release -o publish/api
+  - dotnet publish WebNovelPortal/*.csproj -c Release -o publish/frontend
+  - tar -czvf dist/API.tar.gz publish/api/*
+  - tar -czvf dist/Frontend.tar.gz publish/frontend/*
+
+- name: docker_release_api
+  image: plugins/docker
+  settings:
+    repo: littlefoot123/webnovelportalapi
+    tags: latest
+    username:
+      from_secret: docker-username
+    password:
+      from_secret: docker-password
+    dockerfile: WebNovelPortalAPI/Dockerfile
+
+- name: docker_release_portal
+  image: plugins/docker
+  settings:
+    repo: littlefoot123/webnovelportal
+    tags: latest
+    username:
+      from_secret: docker-username
+    password:
+      from_secret: docker-password
+    dockerfile: WebNovelPortal/Dockerfile
+
+- name: gitea_release
+  image: plugins/gitea-release
+  settings:
+    api_key:
+      from_secret: gitea-api-key
+    base_url: https://git.orfl.xyz
+    files:
+      - dist/*
+  when:
+    event: tag

DBConnection/Contexts/AppDbContext.cs

@@ -1,12 +1,13 @@
 using System.Reflection;
 using DBConnection.ModelBuilders;
-using DBConnection.Models;
 using DBConnection.Seeders;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Treestar.Shared.Models.DBDomain;
 
-namespace DBConnection;
+namespace DBConnection.Contexts;
 
-public class AppDbContext : DbContext
+public abstract class AppDbContext : DbContext
 {
     public DbSet<Novel> Novels { get; set; }
     public DbSet<Chapter> Chapters { get; set; }
@@ -14,6 +15,8 @@ public class AppDbContext : DbContext
     public DbSet<User> Users { get; set; }
     public DbSet<Tag> Tags { get; set; }
     public DbSet<UserNovel> UserNovels { get; set; }
+    protected IConfiguration Configuration { get; set; }
+    protected abstract string ConnectionStringName { get; }
 
     private readonly IEnumerable<ISeeder> _seeders = 
         from t in Assembly.GetExecutingAssembly().GetTypes()
@@ -25,8 +28,9 @@ public class AppDbContext : DbContext
         where t.IsClass && (t.Namespace?.Contains(nameof(DBConnection.ModelBuilders)) ?? false) && typeof(IModelBuilder).IsAssignableFrom(t)
         select (IModelBuilder) Activator.CreateInstance(t);
 
-    public AppDbContext(DbContextOptions options) : base(options)
+    protected AppDbContext(DbContextOptions options, IConfiguration configuration) : base(options)
     {
+        Configuration = configuration;
     }
 
     public override Task<int> SaveChangesAsync(CancellationToken cancellationToken = new CancellationToken())
@@ -64,5 +68,8 @@ public class AppDbContext : DbContext
     protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
     {
         base.OnConfiguring(optionsBuilder);
+        UseSqlConnection(optionsBuilder, Configuration.GetConnectionString(ConnectionStringName));
     }
+
+    protected abstract void UseSqlConnection(DbContextOptionsBuilder builder, string connectionString);
 }

DBConnection/Contexts/PostgresSqlAppDbContext.cs

@@ -0,0 +1,21 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+
+namespace DBConnection.Contexts;
+
+/// <summary>
+/// Pulls connection string from 'PostgresSql' and selected with provider 'PostgresSql'
+/// </summary>
+public class PostgresSqlAppDbContext : AppDbContext
+{
+    public PostgresSqlAppDbContext(DbContextOptions options, IConfiguration configuration) : base(options, configuration)
+    {
+    }
+
+    protected override string ConnectionStringName => "PostgresSql";
+
+    protected override void UseSqlConnection(DbContextOptionsBuilder builder, string connectionString)
+    {
+        builder.UseNpgsql(connectionString);
+    }
+}

DBConnection/Contexts/SqliteAppDbContext.cs

@@ -0,0 +1,21 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+
+namespace DBConnection.Contexts;
+
+/// <summary>
+/// Pulls connection string from 'Sqlite' and selected with provider 'Sqlite'
+/// </summary>
+public class SqliteAppDbContext : AppDbContext
+{
+    public SqliteAppDbContext(DbContextOptions options, IConfiguration configuration) : base(options, configuration)
+    {
+    }
+
+
+    protected override string ConnectionStringName => "Sqlite";
+    protected override void UseSqlConnection(DbContextOptionsBuilder builder, string connectionString)
+    {
+        builder.UseSqlite(connectionString);
+    }
+}

DBConnection/DBConnection.csproj

@@ -19,6 +19,12 @@
 
     <ItemGroup>
       <Folder Include="Interfaces" />
+      <Folder Include="Migrations\PostgresSql" />
+      <Folder Include="Migrations\Sqlite" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\Treestar.Shared\Treestar.Shared.csproj" />
     </ItemGroup>
 
 </Project>

DBConnection/Enums/NovelStatus.cs

@@ -1,9 +0,0 @@
-namespace DBConnection.Enums;
-
-public enum NovelStatus
-{
-    InProgress,
-    Completed,
-    Hiatus,
-    Unknown
-}

DBConnection/Extensions/BuilderExtensions.cs

@@ -1,4 +1,5 @@
 using System.Reflection;
+using DBConnection.Contexts;
 using DBConnection.Repositories.Interfaces;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Configuration;
@@ -15,11 +16,22 @@ public static class BuilderExtensions
     /// <param name="config">configuration</param>
     public static void AddDbServices(this IServiceCollection collection, IConfiguration config)
     {
-        string dbConnectionString = config.GetConnectionString("DefaultConnection");
+        // Add appropriate DbContext
-        collection.AddDbContext<AppDbContext>(opt =>
+        // Contexts are linked to providers by trimming the 'AppDbContext' portion of their name.
-        {
+        // So 'PostgresSqlAppDbContext' is selected with provider 'PostgresSql'
-            opt.UseSqlite(dbConnectionString);
+        var providerTypes = Assembly.GetExecutingAssembly().GetTypes()
-        });
+            .Where(t => (t.Namespace?.Contains(nameof(Contexts)) ?? false) && typeof(AppDbContext).IsAssignableFrom(t) && !t.IsAbstract && t.Name.EndsWith(nameof(AppDbContext)));
+        var providers = providerTypes.ToDictionary(t => t.Name.Replace(nameof(AppDbContext), ""), t => t);
+        var selectedProvider = config["DatabaseProvider"];
+        
+        //add dboptions
+        collection.AddSingleton(new DbContextOptions<AppDbContext>());
+        collection.AddSingleton<DbContextOptions>(p => p.GetRequiredService<DbContextOptions<AppDbContext>>());
+        
+        // add our provider dbcontext
+        collection.AddScoped(typeof(AppDbContext), providers[selectedProvider]);
+        
+        // Add db repositories
         Type[] repositories = Assembly.GetExecutingAssembly().GetTypes()
             .Where(t => t.IsClass && !t.IsAbstract && (t.Namespace?.Contains(nameof(DBConnection.Repositories)) ?? false) && typeof(IRepository).IsAssignableFrom(t)).ToArray();
         foreach (var repo in repositories)

DBConnection/Migrations/PostgresSql/20220716211121_Initial.Designer.cs

@@ -0,0 +1,269 @@
+// <auto-generated />
+using System;
+using DBConnection.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace DBConnection.Migrations.PostgresSql
+{
+    [DbContext(typeof(PostgresSqlAppDbContext))]
+    [Migration("20220716211121_Initial")]
+    partial class Initial
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "6.0.7")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("NovelTag", b =>
+                {
+                    b.Property<string>("NovelsUrl")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TagsTagValue")
+                        .HasColumnType("text");
+
+                    b.HasKey("NovelsUrl", "TagsTagValue");
+
+                    b.HasIndex("TagsTagValue");
+
+                    b.ToTable("NovelTag");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Author", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Url");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Chapter", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ChapterNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Content")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("DatePosted")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("DateUpdated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("LastContentFetch")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NovelUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RawContent")
+                        .HasColumnType("text");
+
+                    b.HasKey("Url");
+
+                    b.HasIndex("NovelUrl");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AuthorUrl")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DatePosted")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("LastUpdated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Url");
+
+                    b.HasIndex("AuthorUrl");
+
+                    b.ToTable("Novels");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Tag", b =>
+                {
+                    b.Property<string>("TagValue")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("TagValue");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.UserNovel", b =>
+                {
+                    b.Property<string>("NovelUrl")
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LastChapterRead")
+                        .HasColumnType("integer");
+
+                    b.HasKey("NovelUrl", "UserId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserNovels");
+                });
+
+            modelBuilder.Entity("NovelTag", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", null)
+                        .WithMany()
+                        .HasForeignKey("NovelsUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Tag", null)
+                        .WithMany()
+                        .HasForeignKey("TagsTagValue")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Chapter", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", null)
+                        .WithMany("Chapters")
+                        .HasForeignKey("NovelUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Author", "Author")
+                        .WithMany("Novels")
+                        .HasForeignKey("AuthorUrl");
+
+                    b.Navigation("Author");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.UserNovel", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", "Novel")
+                        .WithMany()
+                        .HasForeignKey("NovelUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Treestar.Shared.Models.DBDomain.User", "User")
+                        .WithMany("WatchedNovels")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Novel");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Author", b =>
+                {
+                    b.Navigation("Novels");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.Navigation("Chapters");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.User", b =>
+                {
+                    b.Navigation("WatchedNovels");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

DBConnection/Migrations/PostgresSql/20220716211121_Initial.cs

@@ -0,0 +1,200 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace DBConnection.Migrations.PostgresSql
+{
+    public partial class Initial : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Authors",
+                columns: table => new
+                {
+                    Url = table.Column<string>(type: "text", nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: false),
+                    DateCreated = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    DateModified = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Authors", x => x.Url);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Tags",
+                columns: table => new
+                {
+                    TagValue = table.Column<string>(type: "text", nullable: false),
+                    DateCreated = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    DateModified = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Tags", x => x.TagValue);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Users",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Email = table.Column<string>(type: "text", nullable: false),
+                    DateCreated = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    DateModified = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Users", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Novels",
+                columns: table => new
+                {
+                    Url = table.Column<string>(type: "text", nullable: false),
+                    Guid = table.Column<Guid>(type: "uuid", nullable: false),
+                    Title = table.Column<string>(type: "text", nullable: false),
+                    AuthorUrl = table.Column<string>(type: "text", nullable: true),
+                    Status = table.Column<int>(type: "integer", nullable: false),
+                    LastUpdated = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    DatePosted = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    DateCreated = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    DateModified = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Novels", x => x.Url);
+                    table.ForeignKey(
+                        name: "FK_Novels_Authors_AuthorUrl",
+                        column: x => x.AuthorUrl,
+                        principalTable: "Authors",
+                        principalColumn: "Url");
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Chapters",
+                columns: table => new
+                {
+                    Url = table.Column<string>(type: "text", nullable: false),
+                    ChapterNumber = table.Column<int>(type: "integer", nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: false),
+                    Content = table.Column<string>(type: "text", nullable: true),
+                    RawContent = table.Column<string>(type: "text", nullable: true),
+                    DatePosted = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    DateUpdated = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    LastContentFetch = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    NovelUrl = table.Column<string>(type: "text", nullable: false),
+                    DateCreated = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    DateModified = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Chapters", x => x.Url);
+                    table.ForeignKey(
+                        name: "FK_Chapters_Novels_NovelUrl",
+                        column: x => x.NovelUrl,
+                        principalTable: "Novels",
+                        principalColumn: "Url",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "NovelTag",
+                columns: table => new
+                {
+                    NovelsUrl = table.Column<string>(type: "text", nullable: false),
+                    TagsTagValue = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_NovelTag", x => new { x.NovelsUrl, x.TagsTagValue });
+                    table.ForeignKey(
+                        name: "FK_NovelTag_Novels_NovelsUrl",
+                        column: x => x.NovelsUrl,
+                        principalTable: "Novels",
+                        principalColumn: "Url",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_NovelTag_Tags_TagsTagValue",
+                        column: x => x.TagsTagValue,
+                        principalTable: "Tags",
+                        principalColumn: "TagValue",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "UserNovels",
+                columns: table => new
+                {
+                    UserId = table.Column<int>(type: "integer", nullable: false),
+                    NovelUrl = table.Column<string>(type: "text", nullable: false),
+                    LastChapterRead = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_UserNovels", x => new { x.NovelUrl, x.UserId });
+                    table.ForeignKey(
+                        name: "FK_UserNovels_Novels_NovelUrl",
+                        column: x => x.NovelUrl,
+                        principalTable: "Novels",
+                        principalColumn: "Url",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_UserNovels_Users_UserId",
+                        column: x => x.UserId,
+                        principalTable: "Users",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Chapters_NovelUrl",
+                table: "Chapters",
+                column: "NovelUrl");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Novels_AuthorUrl",
+                table: "Novels",
+                column: "AuthorUrl");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_NovelTag_TagsTagValue",
+                table: "NovelTag",
+                column: "TagsTagValue");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_UserNovels_UserId",
+                table: "UserNovels",
+                column: "UserId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Chapters");
+
+            migrationBuilder.DropTable(
+                name: "NovelTag");
+
+            migrationBuilder.DropTable(
+                name: "UserNovels");
+
+            migrationBuilder.DropTable(
+                name: "Tags");
+
+            migrationBuilder.DropTable(
+                name: "Novels");
+
+            migrationBuilder.DropTable(
+                name: "Users");
+
+            migrationBuilder.DropTable(
+                name: "Authors");
+        }
+    }
+}

DBConnection/Migrations/PostgresSql/20220716211513_Add index on novel guid.Designer.cs

@@ -0,0 +1,271 @@
+// <auto-generated />
+using System;
+using DBConnection.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace DBConnection.Migrations.PostgresSql
+{
+    [DbContext(typeof(PostgresSqlAppDbContext))]
+    [Migration("20220716211513_Add index on novel guid")]
+    partial class Addindexonnovelguid
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "6.0.7")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("NovelTag", b =>
+                {
+                    b.Property<string>("NovelsUrl")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TagsTagValue")
+                        .HasColumnType("text");
+
+                    b.HasKey("NovelsUrl", "TagsTagValue");
+
+                    b.HasIndex("TagsTagValue");
+
+                    b.ToTable("NovelTag");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Author", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Url");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Chapter", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ChapterNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Content")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("DatePosted")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("DateUpdated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("LastContentFetch")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NovelUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RawContent")
+                        .HasColumnType("text");
+
+                    b.HasKey("Url");
+
+                    b.HasIndex("NovelUrl");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AuthorUrl")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DatePosted")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("LastUpdated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Url");
+
+                    b.HasIndex("AuthorUrl");
+
+                    b.HasIndex("Guid");
+
+                    b.ToTable("Novels");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Tag", b =>
+                {
+                    b.Property<string>("TagValue")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("TagValue");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.UserNovel", b =>
+                {
+                    b.Property<string>("NovelUrl")
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LastChapterRead")
+                        .HasColumnType("integer");
+
+                    b.HasKey("NovelUrl", "UserId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserNovels");
+                });
+
+            modelBuilder.Entity("NovelTag", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", null)
+                        .WithMany()
+                        .HasForeignKey("NovelsUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Tag", null)
+                        .WithMany()
+                        .HasForeignKey("TagsTagValue")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Chapter", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", null)
+                        .WithMany("Chapters")
+                        .HasForeignKey("NovelUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Author", "Author")
+                        .WithMany("Novels")
+                        .HasForeignKey("AuthorUrl");
+
+                    b.Navigation("Author");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.UserNovel", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", "Novel")
+                        .WithMany()
+                        .HasForeignKey("NovelUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Treestar.Shared.Models.DBDomain.User", "User")
+                        .WithMany("WatchedNovels")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Novel");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Author", b =>
+                {
+                    b.Navigation("Novels");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.Navigation("Chapters");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.User", b =>
+                {
+                    b.Navigation("WatchedNovels");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

DBConnection/Migrations/PostgresSql/20220716211513_Add index on novel guid.cs

@@ -0,0 +1,24 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace DBConnection.Migrations.PostgresSql
+{
+    public partial class Addindexonnovelguid : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateIndex(
+                name: "IX_Novels_Guid",
+                table: "Novels",
+                column: "Guid");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_Novels_Guid",
+                table: "Novels");
+        }
+    }
+}

DBConnection/Migrations/PostgresSql/20220717133208_Fix up UserNovel model and add index on User Email.Designer.cs

@@ -0,0 +1,275 @@
+// <auto-generated />
+using System;
+using DBConnection.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace DBConnection.Migrations.PostgresSql
+{
+    [DbContext(typeof(PostgresSqlAppDbContext))]
+    [Migration("20220717133208_Fix up UserNovel model and add index on User Email")]
+    partial class FixupUserNovelmodelandaddindexonUserEmail
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "6.0.7")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("NovelTag", b =>
+                {
+                    b.Property<string>("NovelsUrl")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TagsTagValue")
+                        .HasColumnType("text");
+
+                    b.HasKey("NovelsUrl", "TagsTagValue");
+
+                    b.HasIndex("TagsTagValue");
+
+                    b.ToTable("NovelTag");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Author", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Url");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Chapter", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ChapterNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Content")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("DatePosted")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("DateUpdated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("LastContentFetch")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NovelUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RawContent")
+                        .HasColumnType("text");
+
+                    b.HasKey("Url");
+
+                    b.HasIndex("NovelUrl");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AuthorUrl")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DatePosted")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("LastUpdated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Url");
+
+                    b.HasIndex("AuthorUrl");
+
+                    b.HasIndex("Guid");
+
+                    b.ToTable("Novels");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Tag", b =>
+                {
+                    b.Property<string>("TagValue")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("TagValue");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Email");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.UserNovel", b =>
+                {
+                    b.Property<string>("NovelUrl")
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LastChapterRead")
+                        .HasColumnType("integer");
+
+                    b.HasKey("NovelUrl", "UserId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserNovels");
+                });
+
+            modelBuilder.Entity("NovelTag", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", null)
+                        .WithMany()
+                        .HasForeignKey("NovelsUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Tag", null)
+                        .WithMany()
+                        .HasForeignKey("TagsTagValue")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Chapter", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", "Novel")
+                        .WithMany("Chapters")
+                        .HasForeignKey("NovelUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Novel");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Author", "Author")
+                        .WithMany("Novels")
+                        .HasForeignKey("AuthorUrl");
+
+                    b.Navigation("Author");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.UserNovel", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", "Novel")
+                        .WithMany()
+                        .HasForeignKey("NovelUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Treestar.Shared.Models.DBDomain.User", "User")
+                        .WithMany("WatchedNovels")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Novel");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Author", b =>
+                {
+                    b.Navigation("Novels");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.Navigation("Chapters");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.User", b =>
+                {
+                    b.Navigation("WatchedNovels");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

DBConnection/Migrations/PostgresSql/20220717133208_Fix up UserNovel model and add index on User Email.cs

@@ -0,0 +1,24 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace DBConnection.Migrations.PostgresSql
+{
+    public partial class FixupUserNovelmodelandaddindexonUserEmail : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateIndex(
+                name: "IX_Users_Email",
+                table: "Users",
+                column: "Email");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_Users_Email",
+                table: "Users");
+        }
+    }
+}

DBConnection/Migrations/PostgresSql/PostgresSqlAppDbContextModelSnapshot.cs

@@ -0,0 +1,273 @@
+// <auto-generated />
+using System;
+using DBConnection.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace DBConnection.Migrations.PostgresSql
+{
+    [DbContext(typeof(PostgresSqlAppDbContext))]
+    partial class PostgresSqlAppDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "6.0.7")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("NovelTag", b =>
+                {
+                    b.Property<string>("NovelsUrl")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TagsTagValue")
+                        .HasColumnType("text");
+
+                    b.HasKey("NovelsUrl", "TagsTagValue");
+
+                    b.HasIndex("TagsTagValue");
+
+                    b.ToTable("NovelTag");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Author", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Url");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Chapter", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ChapterNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Content")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("DatePosted")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("DateUpdated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("LastContentFetch")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NovelUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RawContent")
+                        .HasColumnType("text");
+
+                    b.HasKey("Url");
+
+                    b.HasIndex("NovelUrl");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AuthorUrl")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DatePosted")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("LastUpdated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Url");
+
+                    b.HasIndex("AuthorUrl");
+
+                    b.HasIndex("Guid");
+
+                    b.ToTable("Novels");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Tag", b =>
+                {
+                    b.Property<string>("TagValue")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("TagValue");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Email");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.UserNovel", b =>
+                {
+                    b.Property<string>("NovelUrl")
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LastChapterRead")
+                        .HasColumnType("integer");
+
+                    b.HasKey("NovelUrl", "UserId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserNovels");
+                });
+
+            modelBuilder.Entity("NovelTag", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", null)
+                        .WithMany()
+                        .HasForeignKey("NovelsUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Tag", null)
+                        .WithMany()
+                        .HasForeignKey("TagsTagValue")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Chapter", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", "Novel")
+                        .WithMany("Chapters")
+                        .HasForeignKey("NovelUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Novel");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Author", "Author")
+                        .WithMany("Novels")
+                        .HasForeignKey("AuthorUrl");
+
+                    b.Navigation("Author");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.UserNovel", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", "Novel")
+                        .WithMany()
+                        .HasForeignKey("NovelUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Treestar.Shared.Models.DBDomain.User", "User")
+                        .WithMany("WatchedNovels")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Novel");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Author", b =>
+                {
+                    b.Navigation("Novels");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.Navigation("Chapters");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.User", b =>
+                {
+                    b.Navigation("WatchedNovels");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

DBConnection/Migrations/Sqlite/20220716210907_Initial.Designer.cs

@@ -1,6 +1,6 @@
 // <auto-generated />
 using System;
-using DBConnection;
+using DBConnection.Contexts;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Migrations;
@@ -8,10 +8,10 @@ using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 
 #nullable disable
 
-namespace DBConnection.Migrations
+namespace DBConnection.Migrations.Sqlite
 {
-    [DbContext(typeof(AppDbContext))]
+    [DbContext(typeof(SqliteAppDbContext))]
-    [Migration("20220715030913_Initial")]
+    [Migration("20220716210907_Initial")]
     partial class Initial
     {
         protected override void BuildTargetModel(ModelBuilder modelBuilder)
@@ -19,7 +19,22 @@ namespace DBConnection.Migrations
 #pragma warning disable 612, 618
             modelBuilder.HasAnnotation("ProductVersion", "6.0.7");
 
-            modelBuilder.Entity("DBConnection.Models.Author", b =>
+            modelBuilder.Entity("NovelTag", b =>
+                {
+                    b.Property<string>("NovelsUrl")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TagsTagValue")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("NovelsUrl", "TagsTagValue");
+
+                    b.HasIndex("TagsTagValue");
+
+                    b.ToTable("NovelTag");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Author", b =>
                 {
                     b.Property<string>("Url")
                         .HasColumnType("TEXT");
@@ -39,7 +54,7 @@ namespace DBConnection.Migrations
                     b.ToTable("Authors");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.Chapter", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Chapter", b =>
                 {
                     b.Property<string>("Url")
                         .HasColumnType("TEXT");
@@ -56,10 +71,13 @@ namespace DBConnection.Migrations
                     b.Property<DateTime>("DateModified")
                         .HasColumnType("TEXT");
 
-                    b.Property<DateTime>("DatePosted")
+                    b.Property<DateTime?>("DatePosted")
                         .HasColumnType("TEXT");
 
-                    b.Property<DateTime>("DateUpdated")
+                    b.Property<DateTime?>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastContentFetch")
                         .HasColumnType("TEXT");
 
                     b.Property<string>("Name")
@@ -67,6 +85,7 @@ namespace DBConnection.Migrations
                         .HasColumnType("TEXT");
 
                     b.Property<string>("NovelUrl")
+                        .IsRequired()
                         .HasColumnType("TEXT");
 
                     b.Property<string>("RawContent")
@@ -79,7 +98,7 @@ namespace DBConnection.Migrations
                     b.ToTable("Chapters");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.Novel", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
                 {
                     b.Property<string>("Url")
                         .HasColumnType("TEXT");
@@ -96,9 +115,15 @@ namespace DBConnection.Migrations
                     b.Property<DateTime>("DatePosted")
                         .HasColumnType("TEXT");
 
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("TEXT");
+
                     b.Property<DateTime>("LastUpdated")
                         .HasColumnType("TEXT");
 
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
                     b.Property<string>("Title")
                         .IsRequired()
                         .HasColumnType("TEXT");
@@ -110,7 +135,7 @@ namespace DBConnection.Migrations
                     b.ToTable("Novels");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.Tag", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Tag", b =>
                 {
                     b.Property<string>("TagValue")
                         .HasColumnType("TEXT");
@@ -126,7 +151,7 @@ namespace DBConnection.Migrations
                     b.ToTable("Tags");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.User", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.User", b =>
                 {
                     b.Property<int>("Id")
                         .ValueGeneratedOnAdd()
@@ -147,7 +172,7 @@ namespace DBConnection.Migrations
                     b.ToTable("Users");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.UserNovel", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.UserNovel", b =>
                 {
                     b.Property<string>("NovelUrl")
                         .HasColumnType("TEXT");
@@ -167,44 +192,46 @@ namespace DBConnection.Migrations
 
             modelBuilder.Entity("NovelTag", b =>
                 {
-                    b.Property<string>("NovelsUrl")
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", null)
-                        .HasColumnType("TEXT");
+                        .WithMany()
+                        .HasForeignKey("NovelsUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
 
-                    b.Property<string>("TagsTagValue")
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Tag", null)
-                        .HasColumnType("TEXT");
+                        .WithMany()
-
+                        .HasForeignKey("TagsTagValue")
-                    b.HasKey("NovelsUrl", "TagsTagValue");
+                        .OnDelete(DeleteBehavior.Cascade)
-
+                        .IsRequired();
-                    b.HasIndex("TagsTagValue");
-
-                    b.ToTable("NovelTag");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.Chapter", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Chapter", b =>
                 {
-                    b.HasOne("DBConnection.Models.Novel", null)
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", null)
                         .WithMany("Chapters")
-                        .HasForeignKey("NovelUrl");
+                        .HasForeignKey("NovelUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
                 });
 
-            modelBuilder.Entity("DBConnection.Models.Novel", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
                 {
-                    b.HasOne("DBConnection.Models.Author", "Author")
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Author", "Author")
                         .WithMany("Novels")
                         .HasForeignKey("AuthorUrl");
 
                     b.Navigation("Author");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.UserNovel", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.UserNovel", b =>
                 {
-                    b.HasOne("DBConnection.Models.Novel", "Novel")
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", "Novel")
                         .WithMany()
                         .HasForeignKey("NovelUrl")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
-                    b.HasOne("DBConnection.Models.User", "User")
+                    b.HasOne("Treestar.Shared.Models.DBDomain.User", "User")
                         .WithMany("WatchedNovels")
                         .HasForeignKey("UserId")
                         .OnDelete(DeleteBehavior.Cascade)
@@ -215,32 +242,17 @@ namespace DBConnection.Migrations
                     b.Navigation("User");
                 });
 
-            modelBuilder.Entity("NovelTag", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Author", b =>
-                {
-                    b.HasOne("DBConnection.Models.Novel", null)
-                        .WithMany()
-                        .HasForeignKey("NovelsUrl")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("DBConnection.Models.Tag", null)
-                        .WithMany()
-                        .HasForeignKey("TagsTagValue")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("DBConnection.Models.Author", b =>
                 {
                     b.Navigation("Novels");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.Novel", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
                 {
                     b.Navigation("Chapters");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.User", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.User", b =>
                 {
                     b.Navigation("WatchedNovels");
                 });

DBConnection/Migrations/Sqlite/20220716210907_Initial.cs

@@ -3,7 +3,7 @@ using Microsoft.EntityFrameworkCore.Migrations;
 
 #nullable disable
 
-namespace DBConnection.Migrations
+namespace DBConnection.Migrations.Sqlite
 {
     public partial class Initial : Migration
     {
@@ -56,8 +56,10 @@ namespace DBConnection.Migrations
                 columns: table => new
                 {
                     Url = table.Column<string>(type: "TEXT", nullable: false),
+                    Guid = table.Column<Guid>(type: "TEXT", nullable: false),
                     Title = table.Column<string>(type: "TEXT", nullable: false),
                     AuthorUrl = table.Column<string>(type: "TEXT", nullable: true),
+                    Status = table.Column<int>(type: "INTEGER", nullable: false),
                     LastUpdated = table.Column<DateTime>(type: "TEXT", nullable: false),
                     DatePosted = table.Column<DateTime>(type: "TEXT", nullable: false),
                     DateCreated = table.Column<DateTime>(type: "TEXT", nullable: false),
@@ -82,9 +84,10 @@ namespace DBConnection.Migrations
                     Name = table.Column<string>(type: "TEXT", nullable: false),
                     Content = table.Column<string>(type: "TEXT", nullable: true),
                     RawContent = table.Column<string>(type: "TEXT", nullable: true),
-                    DatePosted = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    DatePosted = table.Column<DateTime>(type: "TEXT", nullable: true),
-                    DateUpdated = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    DateUpdated = table.Column<DateTime>(type: "TEXT", nullable: true),
-                    NovelUrl = table.Column<string>(type: "TEXT", nullable: true),
+                    LastContentFetch = table.Column<DateTime>(type: "TEXT", nullable: true),
+                    NovelUrl = table.Column<string>(type: "TEXT", nullable: false),
                     DateCreated = table.Column<DateTime>(type: "TEXT", nullable: false),
                     DateModified = table.Column<DateTime>(type: "TEXT", nullable: false)
                 },
@@ -95,7 +98,8 @@ namespace DBConnection.Migrations
                         name: "FK_Chapters_Novels_NovelUrl",
                         column: x => x.NovelUrl,
                         principalTable: "Novels",
-                        principalColumn: "Url");
+                        principalColumn: "Url",
+                        onDelete: ReferentialAction.Cascade);
                 });
 
             migrationBuilder.CreateTable(

DBConnection/Migrations/Sqlite/20220716211435_Add index on novel guid.Designer.cs

@@ -0,0 +1,264 @@
+// <auto-generated />
+using System;
+using DBConnection.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace DBConnection.Migrations.Sqlite
+{
+    [DbContext(typeof(SqliteAppDbContext))]
+    [Migration("20220716211435_Add index on novel guid")]
+    partial class Addindexonnovelguid
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "6.0.7");
+
+            modelBuilder.Entity("NovelTag", b =>
+                {
+                    b.Property<string>("NovelsUrl")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TagsTagValue")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("NovelsUrl", "TagsTagValue");
+
+                    b.HasIndex("TagsTagValue");
+
+                    b.ToTable("NovelTag");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Author", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Url");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Chapter", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ChapterNumber")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Content")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DatePosted")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastContentFetch")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NovelUrl")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RawContent")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Url");
+
+                    b.HasIndex("NovelUrl");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AuthorUrl")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DatePosted")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Url");
+
+                    b.HasIndex("AuthorUrl");
+
+                    b.HasIndex("Guid");
+
+                    b.ToTable("Novels");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Tag", b =>
+                {
+                    b.Property<string>("TagValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("TagValue");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.UserNovel", b =>
+                {
+                    b.Property<string>("NovelUrl")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LastChapterRead")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("NovelUrl", "UserId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserNovels");
+                });
+
+            modelBuilder.Entity("NovelTag", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", null)
+                        .WithMany()
+                        .HasForeignKey("NovelsUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Tag", null)
+                        .WithMany()
+                        .HasForeignKey("TagsTagValue")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Chapter", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", null)
+                        .WithMany("Chapters")
+                        .HasForeignKey("NovelUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Author", "Author")
+                        .WithMany("Novels")
+                        .HasForeignKey("AuthorUrl");
+
+                    b.Navigation("Author");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.UserNovel", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", "Novel")
+                        .WithMany()
+                        .HasForeignKey("NovelUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Treestar.Shared.Models.DBDomain.User", "User")
+                        .WithMany("WatchedNovels")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Novel");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Author", b =>
+                {
+                    b.Navigation("Novels");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.Navigation("Chapters");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.User", b =>
+                {
+                    b.Navigation("WatchedNovels");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

DBConnection/Migrations/Sqlite/20220716211435_Add index on novel guid.cs

@@ -0,0 +1,24 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace DBConnection.Migrations.Sqlite
+{
+    public partial class Addindexonnovelguid : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateIndex(
+                name: "IX_Novels_Guid",
+                table: "Novels",
+                column: "Guid");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_Novels_Guid",
+                table: "Novels");
+        }
+    }
+}

DBConnection/Migrations/Sqlite/20220717133151_Fix up UserNovel model and add index on User Email.Designer.cs

@@ -0,0 +1,268 @@
+// <auto-generated />
+using System;
+using DBConnection.Contexts;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace DBConnection.Migrations.Sqlite
+{
+    [DbContext(typeof(SqliteAppDbContext))]
+    [Migration("20220717133151_Fix up UserNovel model and add index on User Email")]
+    partial class FixupUserNovelmodelandaddindexonUserEmail
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "6.0.7");
+
+            modelBuilder.Entity("NovelTag", b =>
+                {
+                    b.Property<string>("NovelsUrl")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TagsTagValue")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("NovelsUrl", "TagsTagValue");
+
+                    b.HasIndex("TagsTagValue");
+
+                    b.ToTable("NovelTag");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Author", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Url");
+
+                    b.ToTable("Authors");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Chapter", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ChapterNumber")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Content")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DatePosted")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastContentFetch")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NovelUrl")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RawContent")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Url");
+
+                    b.HasIndex("NovelUrl");
+
+                    b.ToTable("Chapters");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.Property<string>("Url")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AuthorUrl")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DatePosted")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("LastUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Url");
+
+                    b.HasIndex("AuthorUrl");
+
+                    b.HasIndex("Guid");
+
+                    b.ToTable("Novels");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Tag", b =>
+                {
+                    b.Property<string>("TagValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("TagValue");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Email");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.UserNovel", b =>
+                {
+                    b.Property<string>("NovelUrl")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LastChapterRead")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("NovelUrl", "UserId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserNovels");
+                });
+
+            modelBuilder.Entity("NovelTag", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", null)
+                        .WithMany()
+                        .HasForeignKey("NovelsUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Tag", null)
+                        .WithMany()
+                        .HasForeignKey("TagsTagValue")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Chapter", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", "Novel")
+                        .WithMany("Chapters")
+                        .HasForeignKey("NovelUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Novel");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Author", "Author")
+                        .WithMany("Novels")
+                        .HasForeignKey("AuthorUrl");
+
+                    b.Navigation("Author");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.UserNovel", b =>
+                {
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", "Novel")
+                        .WithMany()
+                        .HasForeignKey("NovelUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Treestar.Shared.Models.DBDomain.User", "User")
+                        .WithMany("WatchedNovels")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Novel");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Author", b =>
+                {
+                    b.Navigation("Novels");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
+                {
+                    b.Navigation("Chapters");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.User", b =>
+                {
+                    b.Navigation("WatchedNovels");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

DBConnection/Migrations/Sqlite/20220717133151_Fix up UserNovel model and add index on User Email.cs

@@ -0,0 +1,24 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace DBConnection.Migrations.Sqlite
+{
+    public partial class FixupUserNovelmodelandaddindexonUserEmail : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateIndex(
+                name: "IX_Users_Email",
+                table: "Users",
+                column: "Email");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_Users_Email",
+                table: "Users");
+        }
+    }
+}

DBConnection/Migrations/Sqlite/SqliteAppDbContextModelSnapshot.cs

@@ -1,23 +1,38 @@
 // <auto-generated />
 using System;
-using DBConnection;
+using DBConnection.Contexts;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 
 #nullable disable
 
-namespace DBConnection.Migrations
+namespace DBConnection.Migrations.Sqlite
 {
-    [DbContext(typeof(AppDbContext))]
+    [DbContext(typeof(SqliteAppDbContext))]
-    partial class AppDbContextModelSnapshot : ModelSnapshot
+    partial class SqliteAppDbContextModelSnapshot : ModelSnapshot
     {
         protected override void BuildModel(ModelBuilder modelBuilder)
         {
 #pragma warning disable 612, 618
             modelBuilder.HasAnnotation("ProductVersion", "6.0.7");
 
-            modelBuilder.Entity("DBConnection.Models.Author", b =>
+            modelBuilder.Entity("NovelTag", b =>
+                {
+                    b.Property<string>("NovelsUrl")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TagsTagValue")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("NovelsUrl", "TagsTagValue");
+
+                    b.HasIndex("TagsTagValue");
+
+                    b.ToTable("NovelTag");
+                });
+
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Author", b =>
                 {
                     b.Property<string>("Url")
                         .HasColumnType("TEXT");
@@ -37,7 +52,7 @@ namespace DBConnection.Migrations
                     b.ToTable("Authors");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.Chapter", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Chapter", b =>
                 {
                     b.Property<string>("Url")
                         .HasColumnType("TEXT");
@@ -54,10 +69,13 @@ namespace DBConnection.Migrations
                     b.Property<DateTime>("DateModified")
                         .HasColumnType("TEXT");
 
-                    b.Property<DateTime>("DatePosted")
+                    b.Property<DateTime?>("DatePosted")
                         .HasColumnType("TEXT");
 
-                    b.Property<DateTime>("DateUpdated")
+                    b.Property<DateTime?>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastContentFetch")
                         .HasColumnType("TEXT");
 
                     b.Property<string>("Name")
@@ -65,6 +83,7 @@ namespace DBConnection.Migrations
                         .HasColumnType("TEXT");
 
                     b.Property<string>("NovelUrl")
+                        .IsRequired()
                         .HasColumnType("TEXT");
 
                     b.Property<string>("RawContent")
@@ -77,7 +96,7 @@ namespace DBConnection.Migrations
                     b.ToTable("Chapters");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.Novel", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
                 {
                     b.Property<string>("Url")
                         .HasColumnType("TEXT");
@@ -94,9 +113,15 @@ namespace DBConnection.Migrations
                     b.Property<DateTime>("DatePosted")
                         .HasColumnType("TEXT");
 
+                    b.Property<Guid>("Guid")
+                        .HasColumnType("TEXT");
+
                     b.Property<DateTime>("LastUpdated")
                         .HasColumnType("TEXT");
 
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
                     b.Property<string>("Title")
                         .IsRequired()
                         .HasColumnType("TEXT");
@@ -105,10 +130,12 @@ namespace DBConnection.Migrations
 
                     b.HasIndex("AuthorUrl");
 
+                    b.HasIndex("Guid");
+
                     b.ToTable("Novels");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.Tag", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Tag", b =>
                 {
                     b.Property<string>("TagValue")
                         .HasColumnType("TEXT");
@@ -124,7 +151,7 @@ namespace DBConnection.Migrations
                     b.ToTable("Tags");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.User", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.User", b =>
                 {
                     b.Property<int>("Id")
                         .ValueGeneratedOnAdd()
@@ -142,10 +169,12 @@ namespace DBConnection.Migrations
 
                     b.HasKey("Id");
 
+                    b.HasIndex("Email");
+
                     b.ToTable("Users");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.UserNovel", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.UserNovel", b =>
                 {
                     b.Property<string>("NovelUrl")
                         .HasColumnType("TEXT");
@@ -165,44 +194,48 @@ namespace DBConnection.Migrations
 
             modelBuilder.Entity("NovelTag", b =>
                 {
-                    b.Property<string>("NovelsUrl")
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", null)
-                        .HasColumnType("TEXT");
+                        .WithMany()
+                        .HasForeignKey("NovelsUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
 
-                    b.Property<string>("TagsTagValue")
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Tag", null)
-                        .HasColumnType("TEXT");
+                        .WithMany()
-
+                        .HasForeignKey("TagsTagValue")
-                    b.HasKey("NovelsUrl", "TagsTagValue");
+                        .OnDelete(DeleteBehavior.Cascade)
-
+                        .IsRequired();
-                    b.HasIndex("TagsTagValue");
-
-                    b.ToTable("NovelTag");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.Chapter", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Chapter", b =>
                 {
-                    b.HasOne("DBConnection.Models.Novel", null)
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", "Novel")
                         .WithMany("Chapters")
-                        .HasForeignKey("NovelUrl");
+                        .HasForeignKey("NovelUrl")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Novel");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.Novel", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
                 {
-                    b.HasOne("DBConnection.Models.Author", "Author")
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Author", "Author")
                         .WithMany("Novels")
                         .HasForeignKey("AuthorUrl");
 
                     b.Navigation("Author");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.UserNovel", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.UserNovel", b =>
                 {
-                    b.HasOne("DBConnection.Models.Novel", "Novel")
+                    b.HasOne("Treestar.Shared.Models.DBDomain.Novel", "Novel")
                         .WithMany()
                         .HasForeignKey("NovelUrl")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
-                    b.HasOne("DBConnection.Models.User", "User")
+                    b.HasOne("Treestar.Shared.Models.DBDomain.User", "User")
                         .WithMany("WatchedNovels")
                         .HasForeignKey("UserId")
                         .OnDelete(DeleteBehavior.Cascade)
@@ -213,32 +246,17 @@ namespace DBConnection.Migrations
                     b.Navigation("User");
                 });
 
-            modelBuilder.Entity("NovelTag", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Author", b =>
-                {
-                    b.HasOne("DBConnection.Models.Novel", null)
-                        .WithMany()
-                        .HasForeignKey("NovelsUrl")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("DBConnection.Models.Tag", null)
-                        .WithMany()
-                        .HasForeignKey("TagsTagValue")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("DBConnection.Models.Author", b =>
                 {
                     b.Navigation("Novels");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.Novel", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.Novel", b =>
                 {
                     b.Navigation("Chapters");
                 });
 
-            modelBuilder.Entity("DBConnection.Models.User", b =>
+            modelBuilder.Entity("Treestar.Shared.Models.DBDomain.User", b =>
                 {
                     b.Navigation("WatchedNovels");
                 });

DBConnection/ModelBuilders/UserNovelBuilder.cs

@@ -1,5 +1,5 @@
-using DBConnection.Models;
 using Microsoft.EntityFrameworkCore;
+using Treestar.Shared.Models.DBDomain;
 
 namespace DBConnection.ModelBuilders;
 

DBConnection/Models/Author.cs

@@ -1,13 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using Newtonsoft.Json;
-
-namespace DBConnection.Models;
-
-public class Author : BaseEntity
-{
-    [Key]
-    public string Url { get; set; }
-    public string Name { get; set; }
-    [JsonIgnore]
-    public List<Novel> Novels { get; set; }
-}

DBConnection/Models/BaseEntity.cs

@@ -1,7 +0,0 @@
-namespace DBConnection.Models;
-
-public abstract class BaseEntity
-{
-    public DateTime DateCreated { get; set; }
-    public DateTime DateModified { get; set; }
-}

DBConnection/Models/Chapter.cs

@@ -1,15 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace DBConnection.Models;
-
-public class Chapter : BaseEntity
-{
-    public int ChapterNumber { get; set; }
-    public string Name { get; set; }
-    public string? Content { get; set; }
-    public string? RawContent { get; set; }
-    [Key]
-    public string Url { get; set; }
-    public DateTime DatePosted { get; set; }
-    public DateTime DateUpdated { get; set; }
-}

DBConnection/Models/Novel.cs

@@ -1,15 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace DBConnection.Models;
-
-public class Novel : BaseEntity
-{
-    [Key]
-    public string Url { get; set; }
-    public string Title { get; set; }
-    public Author Author { get; set; }
-    public List<Tag> Tags { get; set; }
-    public List<Chapter> Chapters { get; set; }
-    public DateTime LastUpdated { get; set; }
-    public DateTime DatePosted { get; set; }
-}

DBConnection/Models/Tag.cs

@@ -1,12 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using Newtonsoft.Json;
-
-namespace DBConnection.Models;
-
-public class Tag : BaseEntity
-{
-    [Key]
-    public string TagValue { get; set; }
-    [JsonIgnore]
-    public List<Novel> Novels { get; set; }
-}

DBConnection/Models/User.cs

@@ -1,11 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace DBConnection.Models;
-
-public class User : BaseEntity
-{
-    [Key]
-    public int Id { get; set; }
-    public string Email { get; set; }
-    public List<UserNovel> WatchedNovels { get; set; }
-}

DBConnection/Models/UserNovel.cs

@@ -1,14 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using Newtonsoft.Json;
-
-namespace DBConnection.Models;
-
-public class UserNovel
-{
-    [JsonIgnore]
-    public int UserId { get; set; }
-    public string NovelUrl { get; set; }
-    public Novel Novel { get; set; }
-    public User User { get; set; }
-    public int LastChapterRead { get; set; }
-}

DBConnection/Readme.md

@@ -0,0 +1,13 @@
+# DBConnection
+## Providers
+Currently AppDbContext can support:
+* Sqlite (default)
+* PostgresSql
+
+The startup project should specify a 'DatabaseProvider' configuration key and provide an appropriate connection string
+## Repositories
+Repositories added into the DBConnection.Repositories namespace and assignable (implementing) IRepository will be dependency injected.
+
+Repositories extending a non-generic interface that also implements IRepository (or some descendant interface) will be DI'd as an implementation of that interface.
+
+As an example, AuthorRepository implements IAuthorRepository which implements IRepository<Author> which implements IRepository. Therefore, Author will get added as an implementation of IAuthorRepository.

DBConnection/Repositories/AuthorRepository.cs

@@ -1,6 +1,7 @@
-using DBConnection.Models;
+using DBConnection.Contexts;
 using DBConnection.Repositories.Interfaces;
 using Microsoft.EntityFrameworkCore;
+using Treestar.Shared.Models.DBDomain;
 
 namespace DBConnection.Repositories;
 

DBConnection/Repositories/BaseRepository.cs

@@ -1,8 +1,9 @@
 using System.Reflection;
-using DBConnection.Models;
+using DBConnection.Contexts;
 using DBConnection.Repositories.Interfaces;
 using Microsoft.EntityFrameworkCore;
 using NuGet.Configuration;
+using Treestar.Shared.Models.DBDomain;
 
 namespace DBConnection.Repositories;
 
@@ -30,7 +31,22 @@ public abstract class BaseRepository<TEntityType> : IRepository<TEntityType> whe
         return entity;
     }
 
-    public virtual async Task<TEntityType> Upsert(TEntityType entity)
+    public virtual async Task<IEnumerable<TEntityType>> UpsertMany(IEnumerable<TEntityType> entities, bool saveAfter=true)
+    {
+        var newEntities = new List<TEntityType>();
+        foreach (var entity in entities)
+        {
+            newEntities.Add(await Upsert(entity, false));
+        }
+
+        if (saveAfter)
+        {
+            await DbContext.SaveChangesAsync();
+        }
+        return newEntities;
+    }
+
+    public virtual async Task<TEntityType> Upsert(TEntityType entity, bool saveAfter=true)
     {
         bool exists = await DbContext.Set<TEntityType>().ContainsAsync(entity);
         if (!exists)
@@ -40,13 +56,24 @@ public abstract class BaseRepository<TEntityType> : IRepository<TEntityType> whe
         else
         {
             var dbEntry = await GetIncluded(entity);
-            DbContext.Entry(dbEntry).CurrentValues.SetValues(entity);
+            entity.DateCreated = dbEntry.DateCreated;
+            var entry = DbContext.Entry(dbEntry);
+            entry.CurrentValues.SetValues(entity);
+            entity = dbEntry;
         }
 
+        if (saveAfter)
+        {
             await DbContext.SaveChangesAsync();
+        }
         return entity;
     }
 
+    public virtual async Task<IEnumerable<TEntityType>> GetAllIncluded()
+    {
+        return await GetWhereIncluded(i => true);
+    }
+
     public virtual async Task<TEntityType?> GetIncluded(TEntityType entity)
     {
         return await GetIncluded(dbEntity => GetPrimaryKey(dbEntity).SequenceEqual(GetPrimaryKey(entity)));
@@ -57,8 +84,18 @@ public abstract class BaseRepository<TEntityType> : IRepository<TEntityType> whe
         return GetAllIncludedQueryable().FirstOrDefault(predicate);
     }
 
+    public virtual async Task<IEnumerable<TEntityType?>> GetWhereIncluded(IEnumerable<TEntityType> entities)
+    {
+        return await GetWhereIncluded(entities.Contains);
+    }
+    
     public virtual async Task<IEnumerable<TEntityType>> GetWhereIncluded(Func<TEntityType, bool> predicate)
     {
         return GetAllIncludedQueryable().AsEnumerable().Where(predicate);
     }
+
+    public virtual async Task PersistChanges()
+    {
+        await DbContext.SaveChangesAsync();
+    }
 }

DBConnection/Repositories/ChapterRepository.cs

@@ -0,0 +1,18 @@
+using DBConnection.Contexts;
+using DBConnection.Repositories.Interfaces;
+using Microsoft.EntityFrameworkCore;
+using Treestar.Shared.Models.DBDomain;
+
+namespace DBConnection.Repositories;
+
+public class ChapterRepository : BaseRepository<Chapter>, IChapterRepository
+{
+    public ChapterRepository(AppDbContext dbContext) : base(dbContext)
+    {
+    }
+
+    protected override IQueryable<Chapter> GetAllIncludedQueryable()
+    {
+        return DbContext.Chapters.AsQueryable();
+    }
+}

DBConnection/Repositories/Interfaces/IAuthorRepository.cs

@@ -1,4 +1,4 @@
-using DBConnection.Models;
+using Treestar.Shared.Models.DBDomain;
 
 namespace DBConnection.Repositories.Interfaces;
 

DBConnection/Repositories/Interfaces/IChapterRepository.cs

@@ -0,0 +1,8 @@
+using Treestar.Shared.Models.DBDomain;
+
+namespace DBConnection.Repositories.Interfaces;
+
+public interface IChapterRepository : IRepository<Chapter>
+{
+    
+}

DBConnection/Repositories/Interfaces/INovelRepository.cs

@@ -1,8 +1,8 @@
-using DBConnection.Models;
+using Treestar.Shared.Models.DBDomain;
 
 namespace DBConnection.Repositories.Interfaces;
 
 public interface INovelRepository : IRepository<Novel>
 {
-    
+    Task<Novel?> GetNovel(Guid guid);
 }

DBConnection/Repositories/Interfaces/IRepository.cs

@@ -1,4 +1,4 @@
-using DBConnection.Models;
+using Treestar.Shared.Models.DBDomain;
 
 namespace DBConnection.Repositories.Interfaces;
 
@@ -10,8 +10,12 @@ public interface IRepository
 public interface IRepository<TEntityType> : IRepository where TEntityType : BaseEntity
 {
     TEntityType Delete(TEntityType entity);
-    Task<TEntityType> Upsert(TEntityType entity);
+    Task<TEntityType> Upsert(TEntityType entity, bool saveAfter=true);
     Task<TEntityType?> GetIncluded(TEntityType entity);
     Task<TEntityType?> GetIncluded(Func<TEntityType, bool> predicate);
     Task<IEnumerable<TEntityType>> GetWhereIncluded(Func<TEntityType, bool> predicate);
+    Task<IEnumerable<TEntityType>> GetAllIncluded();
+    Task<IEnumerable<TEntityType>> UpsertMany(IEnumerable<TEntityType> entities, bool saveAfter=true);
+    Task PersistChanges();
+    Task<IEnumerable<TEntityType?>> GetWhereIncluded(IEnumerable<TEntityType> entities);
 }

DBConnection/Repositories/Interfaces/ITagRepository.cs

@@ -1,8 +1,7 @@
-using DBConnection.Models;
+using Treestar.Shared.Models.DBDomain;
 
 namespace DBConnection.Repositories.Interfaces;
 
 public interface ITagRepository : IRepository<Tag>
 {
-    
 }

DBConnection/Repositories/Interfaces/IUserRepository.cs

@@ -0,0 +1,9 @@
+using Treestar.Shared.Models.DBDomain;
+
+namespace DBConnection.Repositories.Interfaces;
+
+public interface IUserRepository : IRepository<User>
+{
+    Task<User> AssignNovelsToUser(User user, List<Novel> novels);
+    Task<User> UpdateLastChapterRead(User user, Novel novel, int chapterRead);
+}

DBConnection/Repositories/NovelRepository.cs

@@ -1,6 +1,7 @@
-using DBConnection.Models;
+using DBConnection.Contexts;
 using DBConnection.Repositories.Interfaces;
 using Microsoft.EntityFrameworkCore;
+using Treestar.Shared.Models.DBDomain;
 
 namespace DBConnection.Repositories;
 
@@ -8,29 +9,47 @@ public class NovelRepository : BaseRepository<Novel>, INovelRepository
 {
     private readonly IAuthorRepository _authorRepository;
     private readonly ITagRepository _tagRepository;
-    public NovelRepository(AppDbContext dbContext, IAuthorRepository authorRepository, ITagRepository tagRepository) : base(dbContext)
+    private readonly IChapterRepository _chapterRepository;
+    public NovelRepository(AppDbContext dbContext, IAuthorRepository authorRepository, ITagRepository tagRepository, IChapterRepository chapterRepository) : base(dbContext)
     {
         _authorRepository = authorRepository;
         _tagRepository = tagRepository;
+        _chapterRepository = chapterRepository;
     }
 
-    public override async Task<Novel> Upsert(Novel entity)
+    public override async Task<Novel> Upsert(Novel entity, bool saveAfter=true)
     {
         var dbEntity = await GetIncluded(entity) ?? entity;
-        dbEntity.Author = await _authorRepository.GetIncluded(entity.Author) ?? entity.Author;
+        // Author
-        List<Tag> newTags = new List<Tag>();
+        if (entity.Author != null)
-        foreach (var tag in dbEntity.Tags)
         {
-            newTags.Add(await _tagRepository.GetIncluded(tag) ?? tag);
+            entity.Author = await _authorRepository.Upsert(entity.Author, false);
         }
+
+        //Tags
+        var newTags = await _tagRepository.UpsertMany(entity.Tags, false);
+
+        //chapters are getting deleted now that their required...
+        var newChapters = await _chapterRepository.UpsertMany(entity.Chapters, false);
+
+        // update in db
+        entity.Guid = dbEntity.Guid;
+        DbContext.Entry(dbEntity).CurrentValues.SetValues(entity);
         dbEntity.Tags.Clear();
-        dbEntity.Tags = newTags;
+        dbEntity.Tags.AddRange(newTags);
+        dbEntity.Chapters.Clear();
+        dbEntity.Chapters.AddRange(newChapters);
+
         if (DbContext.Entry(dbEntity).State == EntityState.Detached)
         {
+            dbEntity.Guid = Guid.NewGuid();
             DbContext.Add(dbEntity);
         }
 
+        if (saveAfter)
+        {
             await DbContext.SaveChangesAsync();
+        }
         return dbEntity;
     }
 
@@ -42,6 +61,11 @@ public class NovelRepository : BaseRepository<Novel>, INovelRepository
             .Include(i => i.Tags);
     }
 
+    public async Task<Novel?> GetNovel(Guid guid)
+    {
+        return await GetIncluded(i => i.Guid == guid);
+    }
+
     public async Task<Novel?> GetNovel(string url)
     {
         return await GetIncluded(i => i.Url == url);

DBConnection/Repositories/TagRepository.cs

@@ -1,6 +1,7 @@
-using DBConnection.Models;
+using DBConnection.Contexts;
 using DBConnection.Repositories.Interfaces;
 using Microsoft.EntityFrameworkCore;
+using Treestar.Shared.Models.DBDomain;
 
 namespace DBConnection.Repositories;
 

DBConnection/Repositories/UserRepository.cs

@@ -0,0 +1,49 @@
+using DBConnection.Contexts;
+using DBConnection.Repositories.Interfaces;
+using Microsoft.EntityFrameworkCore;
+using Treestar.Shared.Models.DBDomain;
+
+namespace DBConnection.Repositories;
+
+public class UserRepository : BaseRepository<User>, IUserRepository
+{
+    private readonly INovelRepository _novelRepository;
+    public UserRepository(AppDbContext dbContext, INovelRepository novelRepository) : base(dbContext)
+    {
+        _novelRepository = novelRepository;
+    }
+
+    protected override IQueryable<User> GetAllIncludedQueryable()
+    {
+        return DbContext.Users.Include(u => u.WatchedNovels);
+    }
+
+    public async Task<User> AssignNovelsToUser(User user, List<Novel> novels)
+    {
+        var dbUser = await GetIncluded(user);
+        if (dbUser == null)
+        {
+            return user;
+        }
+
+        var dbNovels = await _novelRepository.GetWhereIncluded(novels);
+        var newNovels = dbNovels.Except(dbUser.WatchedNovels.Select(un => un.Novel));
+        var newUserNovels = newNovels.Select(n => new UserNovel
+        {
+            Novel = n,
+            User = dbUser
+        });
+        dbUser.WatchedNovels.AddRange(newUserNovels);
+        await DbContext.SaveChangesAsync();
+        return dbUser;
+    }
+
+    public async Task<User> UpdateLastChapterRead(User user, Novel novel, int chapterRead)
+    {
+        var dbUser = await GetIncluded(user);
+        var userNovel = dbUser.WatchedNovels.FirstOrDefault(i => i.NovelUrl == novel.Url);
+        userNovel.LastChapterRead = chapterRead;
+        await DbContext.SaveChangesAsync();
+        return dbUser;
+    }
+}

Shared/Shared.csproj

@@ -1,19 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-    <PropertyGroup>
-        <TargetFramework>net6.0</TargetFramework>
-        <ImplicitUsings>enable</ImplicitUsings>
-        <Nullable>enable</Nullable>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <Folder Include="Interfaces" />
-      <Folder Include="Utility" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <PackageReference Include="Microsoft.AspNetCore.WebUtilities" Version="2.2.0" />
-      <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
-    </ItemGroup>
-
-</Project>

Treestar.Shared/AccessLayers/ApiAccessLayer.cs

@@ -1,21 +1,30 @@
+using System.Net.Mime;
+using System.Text;
 using Microsoft.AspNetCore.WebUtilities;
 using Newtonsoft.Json;
-using Shared.Models;
+using Treestar.Shared.Models;
 
-namespace Shared.AccessLayers;
+namespace Treestar.Shared.AccessLayers;
 
 public abstract class ApiAccessLayer
 {
     private readonly HttpClient _httpClient;
+    private readonly IAccessLayerAuthenticationProvider _authenticationProvider;
 
-    protected ApiAccessLayer(string apiBaseUrl)
+    protected ApiAccessLayer(string apiBaseUrl, IAccessLayerAuthenticationProvider authenticationProvider)
     {
-        _httpClient = new HttpClient();
+        _authenticationProvider = authenticationProvider;
-        _httpClient.BaseAddress = new Uri(apiBaseUrl);
+        var handler = new HttpClientHandler() 
+        { 
+            ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator
+        };
+        _httpClient = new HttpClient(handler);
+        _httpClient.BaseAddress = new Uri(apiBaseUrl, UriKind.Absolute);
     }
 
     private async Task<HttpResponseWrapper> SendRequest(HttpRequestMessage message)
     {
+        await _authenticationProvider.AddAuthentication(message);
         var response = await _httpClient.SendAsync(message);
         return new HttpResponseWrapper()
         {
@@ -53,12 +62,11 @@ public abstract class ApiAccessLayer
         {
             uri = QueryHelpers.AddQueryString(endpoint, queryParams);
         }
-
+        message.RequestUri = new Uri(uri, UriKind.Relative);
-        message.RequestUri = new Uri(uri);
         message.Method = method;
         if (data != null)
         {
-            message.Content = new StringContent(JsonConvert.SerializeObject(data));
+            message.Content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, MediaTypeNames.Application.Json);
         }
 
         return message;

Treestar.Shared/AccessLayers/IAccessLayerAuthenticationProvider.cs

@@ -0,0 +1,6 @@
+namespace Treestar.Shared.AccessLayers;
+
+public interface IAccessLayerAuthenticationProvider
+{
+    Task AddAuthentication(HttpRequestMessage request);
+}

Treestar.Shared/Authentication/JwtBearer/JWTAuthenticationExtension.cs

@@ -0,0 +1,32 @@
+using System.Security.Claims;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.IdentityModel.Tokens;
+
+namespace Treestar.Shared.Authentication.JwtBearer;
+
+public static class JWTAuthenticationExtension
+{
+    public static void AddJwtBearerAuth(this IServiceCollection services, IConfiguration configuration)
+    {
+        var jwtAuthOptions = configuration.GetRequiredSection(JwtBearerAuthenticationOptions.ConfigrationSection)
+            .Get<JwtBearerAuthenticationOptions>();
+        services.AddAuthentication(opt =>
+        {
+            opt.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
+        }).AddJwtBearer(opt =>
+        {
+            opt.Authority = jwtAuthOptions.Authority;
+            opt.Audience = jwtAuthOptions.Audience;
+            opt.TokenValidationParameters = new TokenValidationParameters
+            {
+                NameClaimType = ClaimTypes.Name,
+                ValidateAudience = !string.IsNullOrEmpty(jwtAuthOptions.Audience),
+                ValidateIssuer = true,
+                ValidateIssuerSigningKey = true,
+                ValidateLifetime = true
+            };
+        });
+    }
+}

Treestar.Shared/Authentication/JwtBearer/JwtBearerAuthenticationOptions.cs

@@ -0,0 +1,8 @@
+namespace Treestar.Shared.Authentication.JwtBearer;
+
+public class JwtBearerAuthenticationOptions
+{
+    public const string ConfigrationSection = "JwtBearerAuthOptions";
+    public string Authority { get; set; } = null!;
+    public string? Audience { get; set; }
+}

Treestar.Shared/Authentication/OIDC/AuthenticationExtension.cs

@@ -0,0 +1,45 @@
+using System.Security.Claims;
+using Microsoft.AspNetCore.Authentication.Cookies;
+using Microsoft.AspNetCore.Authentication.OpenIdConnect;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.IdentityModel.Protocols.OpenIdConnect;
+using Microsoft.IdentityModel.Tokens;
+using WebNovelPortal.Authentication;
+
+namespace Treestar.Shared.Authentication.OIDC;
+
+public static class AuthenticationExtension
+{
+    public static void AddOIDCAuth(this IServiceCollection services, IConfiguration configuration)
+    {
+        var oidcConfig = configuration.GetRequiredSection(OpenIdConnectAuthenticationOptions.ConfigurationSection)
+            .Get<OpenIdConnectAuthenticationOptions>();
+        services.AddAuthentication(opt =>
+            {
+                opt.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
+                opt.DefaultChallengeScheme = OpenIdConnectDefaults.AuthenticationScheme;
+            })
+            .AddCookie()
+            .AddOpenIdConnect(opt =>
+            {
+                opt.Authority = oidcConfig.Authority;
+                opt.ClientId = oidcConfig.ClientId;
+                opt.ClientSecret = oidcConfig.ClientSecret;
+
+                opt.ResponseType = OpenIdConnectResponseType.Code;
+                opt.GetClaimsFromUserInfoEndpoint = false;
+                opt.SaveTokens = true;
+                opt.UseTokenLifetime = true;
+                foreach (var scope in oidcConfig.Scopes.Split(" "))
+                {
+                    opt.Scope.Add(scope);
+                }
+
+                opt.TokenValidationParameters = new TokenValidationParameters
+                {
+                    NameClaimType = ClaimTypes.Name
+                };
+            });
+    }
+}

Treestar.Shared/Authentication/OIDC/OpenIdConnectAuthenticationOptions.cs

@@ -0,0 +1,10 @@
+namespace WebNovelPortal.Authentication;
+
+public class OpenIdConnectAuthenticationOptions
+{
+    public const string ConfigurationSection = "OIDCAuthOptions";
+    public string Authority { get; set; }
+    public string ClientId { get; set; }
+    public string ClientSecret { get; set; }
+    public string Scopes { get; set; }
+}

Treestar.Shared/Models/DBDomain/Author.cs

@@ -0,0 +1,32 @@
+using System.ComponentModel.DataAnnotations;
+using Newtonsoft.Json;
+
+namespace Treestar.Shared.Models.DBDomain
+{
+    public class Author : BaseEntity
+    {
+        [Key]
+        public string Url { get; set; }
+        public string Name { get; set; }
+        [JsonIgnore]
+        public List<Novel> Novels { get; set; }
+
+        protected bool Equals(Author other)
+        {
+            return Url == other.Url;
+        }
+
+        public override bool Equals(object? obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((Author) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return Url.GetHashCode();
+        }
+    }
+}

Treestar.Shared/Models/DBDomain/BaseEntity.cs

@@ -0,0 +1,8 @@
+namespace Treestar.Shared.Models.DBDomain
+{
+    public abstract class BaseEntity
+    {
+        public DateTime DateCreated { get; set; }
+        public DateTime DateModified { get; set; }
+    }
+}

Treestar.Shared/Models/DBDomain/Chapter.cs

@@ -0,0 +1,37 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Treestar.Shared.Models.DBDomain
+{
+    public class Chapter : BaseEntity
+    {
+        public int ChapterNumber { get; set; }
+        public string Name { get; set; }
+        public string? Content { get; set; }
+        public string? RawContent { get; set; }
+        [Key]
+        public string Url { get; set; }
+        public DateTime? DatePosted { get; set; }
+        public DateTime? DateUpdated { get; set; }
+        public DateTime? LastContentFetch { get; set; }
+        [Required]
+        public Novel Novel { get; set; }
+
+        protected bool Equals(Chapter other)
+        {
+            return Url == other.Url;
+        }
+
+        public override bool Equals(object? obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((Chapter) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return Url.GetHashCode();
+        }
+    }
+}

Treestar.Shared/Models/DBDomain/Novel.cs

@@ -0,0 +1,39 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
+using Treestar.Shared.Models.Enums;
+
+namespace Treestar.Shared.Models.DBDomain
+{
+    [Index(nameof(Guid))]
+    public class Novel : BaseEntity
+    {
+        [Key]
+        public string Url { get; set; }
+        public Guid Guid { get; set; }
+        public string Title { get; set; }
+        public Author? Author { get; set; }
+        public List<Tag> Tags { get; set; }
+        public List<Chapter> Chapters { get; set; }
+        public NovelStatus Status { get; set; }
+        public DateTime LastUpdated { get; set; }
+        public DateTime DatePosted { get; set; }
+
+        protected bool Equals(Novel other)
+        {
+            return Url == other.Url;
+        }
+
+        public override bool Equals(object? obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((Novel) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return Url.GetHashCode();
+        }
+    }
+}

Treestar.Shared/Models/DBDomain/Tag.cs

@@ -0,0 +1,31 @@
+using System.ComponentModel.DataAnnotations;
+using Newtonsoft.Json;
+
+namespace Treestar.Shared.Models.DBDomain
+{
+    public class Tag : BaseEntity
+    {
+        [Key]
+        public string TagValue { get; set; }
+        [JsonIgnore]
+        public List<Novel> Novels { get; set; }
+
+        protected bool Equals(Tag other)
+        {
+            return TagValue == other.TagValue;
+        }
+
+        public override bool Equals(object? obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((Tag) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return TagValue.GetHashCode();
+        }
+    }
+}

Treestar.Shared/Models/DBDomain/User.cs

@@ -0,0 +1,32 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
+
+namespace Treestar.Shared.Models.DBDomain
+{
+    [Index(nameof(Email))]
+    public class User : BaseEntity
+    {
+        [Key]
+        public int Id { get; set; }
+        public string Email { get; set; }
+        public List<UserNovel> WatchedNovels { get; set; }
+
+        protected bool Equals(User other)
+        {
+            return Id == other.Id;
+        }
+
+        public override bool Equals(object? obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((User) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return Id;
+        }
+    }
+}

Treestar.Shared/Models/DBDomain/UserNovel.cs

@@ -0,0 +1,32 @@
+using Newtonsoft.Json;
+
+namespace Treestar.Shared.Models.DBDomain
+{
+    public class UserNovel
+    {
+        public int UserId { get; set; }
+        public string NovelUrl { get; set; }
+        public Novel Novel { get; set; }
+        [JsonIgnore]
+        public User User { get; set; }
+        public int LastChapterRead { get; set; }
+
+        protected bool Equals(UserNovel other)
+        {
+            return UserId == other.UserId && NovelUrl == other.NovelUrl;
+        }
+
+        public override bool Equals(object? obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((UserNovel) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(UserId, NovelUrl);
+        }
+    }
+}

Treestar.Shared/Models/DTO/Requests/ScrapeNovelRequest.cs

@@ -1,4 +1,4 @@
-namespace WebNovelPortalAPI.DTO;
+namespace Treestar.Shared.Models.DTO.Requests;
 
 public class ScrapeNovelRequest
 {

Treestar.Shared/Models/DTO/Requests/ScrapeNovelsRequest.cs

@@ -0,0 +1,9 @@
+using Newtonsoft.Json;
+
+namespace Treestar.Shared.Models.DTO.Requests;
+
+public class ScrapeNovelsRequest
+{
+    [JsonProperty("novelUrls")]
+    public List<string> NovelUrls { get; set; }
+}

Treestar.Shared/Models/DTO/Responses/ScrapeNovelsResponse.cs

@@ -0,0 +1,9 @@
+using Treestar.Shared.Models.DBDomain;
+
+namespace Treestar.Shared.Models.DTO.Responses;
+
+public class ScrapeNovelsResponse
+{
+    public List<Novel> SuccessfulNovels { get; set; }
+    public Dictionary<string, Exception> Failures { get; set; }
+}

Treestar.Shared/Models/Enums/NovelStatus.cs

@@ -0,0 +1,9 @@
+namespace Treestar.Shared.Models.Enums;
+
+public enum NovelStatus
+{
+    Unknown,
+    InProgress,
+    Completed,
+    Hiatus
+}

Treestar.Shared/Models/HttpResponseWrapper.cs

@@ -1,4 +1,4 @@
-namespace Shared.Models;
+namespace Treestar.Shared.Models;
 
 public class HttpResponseWrapper<T> : HttpResponseWrapper
 {

Treestar.Shared/Treestar.Shared.csproj

@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net6.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <Folder Include="BlazorComponents" />
+      <Folder Include="Interfaces" />
+      <Folder Include="Utility" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="6.0.7" />
+      <PackageReference Include="Microsoft.AspNetCore.Authentication.OpenIdConnect" Version="6.0.7" />
+      <PackageReference Include="Microsoft.AspNetCore.WebUtilities" Version="2.2.0" />
+      <PackageReference Include="Microsoft.EntityFrameworkCore.Abstractions" Version="6.0.7" />
+      <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <Reference Include="Microsoft.Extensions.Configuration.Abstractions">
+        <HintPath>..\..\..\..\..\usr\share\dotnet\shared\Microsoft.AspNetCore.App\6.0.0\Microsoft.Extensions.Configuration.Abstractions.dll</HintPath>
+      </Reference>
+      <Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions">
+        <HintPath>..\..\..\..\..\usr\share\dotnet\shared\Microsoft.AspNetCore.App\6.0.0\Microsoft.Extensions.DependencyInjection.Abstractions.dll</HintPath>
+      </Reference>
+    </ItemGroup>
+
+</Project>

WebNovelPortal.sln

@@ -4,7 +4,7 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebNovelPortal", "WebNovelP
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebNovelPortalAPI", "WebNovelPortalAPI\WebNovelPortalAPI.csproj", "{D24E3BBA-EAA1-4515-9060-56E673CC7FAA}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Shared", "Shared\Shared.csproj", "{639F52AF-9D62-4341-BEE6-0E9243020FC5}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Treestar.Shared", "Treestar.Shared\Treestar.Shared.csproj", "{639F52AF-9D62-4341-BEE6-0E9243020FC5}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DBConnection", "DBConnection\DBConnection.csproj", "{CD895518-DA05-4886-BE14-3E04D62FA2F7}"
 EndProject

WebNovelPortal/AccessLayers/WebApiAccessLayer.cs

@@ -0,0 +1,45 @@
+using Treestar.Shared.AccessLayers;
+using Treestar.Shared.Models.DBDomain;
+using Treestar.Shared.Models.DTO;
+using Treestar.Shared.Models.DTO.Requests;
+using Treestar.Shared.Models.DTO.Responses;
+
+namespace WebNovelPortal.AccessLayers;
+
+public class WebApiAccessLayer : ApiAccessLayer
+{
+    public WebApiAccessLayer(string apiBaseUrl, IAccessLayerAuthenticationProvider authenticationProvider) : base(apiBaseUrl, authenticationProvider)
+    {
+    }
+
+    public async Task<List<UserNovel>?> GetNovels()
+    {
+        return (await SendRequest<List<UserNovel>>("novel", HttpMethod.Get)).ResponseObject;
+    }
+
+    public async Task<Novel?> RequestNovelScrape(string url)
+    {
+        return (await SendRequest<Novel>("novel/scrapeNovel", HttpMethod.Post, null,
+            new ScrapeNovelRequest {NovelUrl = url})).ResponseObject;
+    }
+
+    public async Task<UserNovel?> GetNovel(string guid)
+    {
+        return (await SendRequest<UserNovel?>($"novel/{guid}", HttpMethod.Get)).ResponseObject;
+    }
+
+    public async Task<ScrapeNovelsResponse?> ScrapeNovels(List<string> novelUrls)
+    {
+        return (await SendRequest<ScrapeNovelsResponse>("novel/scrapeNovels", HttpMethod.Post, null,
+            new ScrapeNovelsRequest {NovelUrls = novelUrls})).ResponseObject;
+    }
+
+    public async Task UpdateLastChapterRead(Novel novel, int chapter)
+    {
+        await SendRequest("novel/updateLastChapterRead", HttpMethod.Patch, new Dictionary<string, string>
+        {
+            {"novelGuid", novel.Guid.ToString()},
+            {"chapter", chapter.ToString()}
+        }, null);
+    }
+}

WebNovelPortal/App.razor

@@ -1,6 +1,7 @@
-<Router AppAssembly="@typeof(App).Assembly">
+<CascadingAuthenticationState>
+    <Router AppAssembly="@typeof(App).Assembly">
         <Found Context="routeData">
-        <RouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)"/>
+            <AuthorizeRouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)"/>
             <FocusOnNavigate RouteData="@routeData" Selector="h1"/>
         </Found>
         <NotFound>
@@ -10,3 +11,4 @@
             </LayoutView>
         </NotFound>
     </Router>
+</CascadingAuthenticationState>

WebNovelPortal/Authentication/BlazorAccessLayerAuthProvider.cs

@@ -0,0 +1,29 @@
+using System.Net.Http.Headers;
+using System.Text.Json;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Authentication.OpenIdConnect;
+using Microsoft.AspNetCore.Components.Authorization;
+using Microsoft.IdentityModel.Protocols.OpenIdConnect;
+using Treestar.Shared.AccessLayers;
+
+namespace WebNovelPortal.Authentication;
+
+public class BlazorAccessLayerAuthProvider : IAccessLayerAuthenticationProvider
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+
+
+    public BlazorAccessLayerAuthProvider(IHttpContextAccessor httpContextAccessor)
+    {
+        _httpContextAccessor = httpContextAccessor;
+    }
+
+    public async Task AddAuthentication(HttpRequestMessage request)
+    {
+        var idToken = await _httpContextAccessor.HttpContext.GetTokenAsync(OpenIdConnectParameterNames.IdToken);
+        if (!string.IsNullOrEmpty(idToken))
+        {
+            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", idToken);
+        }
+    }
+}

WebNovelPortal/Controllers/AccountController.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace WebNovelPortal.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class AccountController : ControllerBase
+    {
+        [HttpGet]
+        [Route("login")]
+        public async Task Login(string redirect="/")
+        {
+            await HttpContext.ChallengeAsync(new AuthenticationProperties
+            {
+                RedirectUri = redirect
+            });
+        }
+
+        [HttpGet]
+        [Route("logout")]
+        public async Task Logout()
+        {
+            await HttpContext.SignOutAsync();
+            Response.Redirect("/");
+        }
+    }
+}

WebNovelPortal/Dockerfile

@@ -6,6 +6,7 @@ EXPOSE 443
 FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
 WORKDIR /src
 COPY ["WebNovelPortal/WebNovelPortal.csproj", "WebNovelPortal/"]
+COPY ["Treestar.Shared/Treestar.Shared.csproj", "Treestar.Shared/"]
 RUN dotnet restore "WebNovelPortal/WebNovelPortal.csproj"
 COPY . .
 WORKDIR "/src/WebNovelPortal"

WebNovelPortal/Pages/Auth0InfoDump.razor

@@ -0,0 +1,17 @@
+@page "/Auth0InfoDump"
+@using Microsoft.AspNetCore.Authentication
+@using Microsoft.IdentityModel.Protocols.OpenIdConnect
+<h3>Auth0InfoDump</h3>
+<b>IdToken: </b> @IdToken
+
+@code {
+    [Inject] private IHttpContextAccessor _contextAccessor { get; set; }
+    private string IdToken { get; set; }
+    protected override async Task OnInitializedAsync()
+    {
+        await base.OnInitializedAsync();
+        var context = _contextAccessor.HttpContext;
+        IdToken = await context.GetTokenAsync(OpenIdConnectParameterNames.IdToken);
+    }
+
+}

WebNovelPortal/Pages/Index.razor

@@ -1,7 +1,93 @@
 @page "/"
+@using WebNovelPortal.AccessLayers
 
 <PageTitle>Index</PageTitle>
+@if (loading)
+{
+    <LoadingDisplay/>
+    return;
+}
+@if (!authenticated)
+{
+    <div>you must login</div>
+    return;
+}
+<input @bind="NovelUrl" disabled="@awaitingRequest"/><button disabled="@IsDisabled()" onclick="@(() => RequestNovelScrape(NovelUrl))">Scrape</button><br/>
+<button onclick="@UpdateNovels" disabled="@IsDisabled()">Update Novels</button>
+<NovelList Novels="@novels" InputDisabled="awaitingRequest" HandleUpdateNovelRequest="UpdateNovel"/>
 
-<h1>Hello, world!</h1>
+@code {
+    [Inject]
+    WebApiAccessLayer api { get; set; }
+    [CascadingParameter]
+    Task<AuthenticationState> AuthenticationStateTask { get; set; }
+    string NovelUrl { get; set; }
+    List<UserNovel> novels = new List<UserNovel>();
+    protected bool loading = true;
+    protected bool awaitingRequest = false;
+    protected bool authenticated = false;
 
-Welcome to your new app.
+    protected override async Task OnInitializedAsync()
+    {
+        authenticated = (await AuthenticationStateTask).User.Identity.IsAuthenticated;
+        SetLoading(authenticated);
+    }
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (firstRender && authenticated)
+        {
+            await RefreshNovels();
+        }
+    }
+
+    async Task RequestNovelScrape(string url)
+    {
+        SetAwaitingRequest(true);
+        await api.RequestNovelScrape(url);
+        SetAwaitingRequest(false);
+        await RefreshNovels();
+    }
+
+    async Task RefreshNovels()
+    {
+        SetLoading(true);
+        novels = await api.GetNovels();
+        SetLoading(false);
+        StateHasChanged();
+    }
+
+    async Task UpdateNovels()
+    {
+        SetAwaitingRequest(true);
+        var res = await api.ScrapeNovels(novels.Select(i => i.Novel.Url).ToList());
+        await RefreshNovels();
+        SetAwaitingRequest(false);
+    }
+
+    async Task UpdateNovel(Novel novel)
+    {
+        SetAwaitingRequest(true);
+        var res = await api.RequestNovelScrape(novel.Url);
+        await RefreshNovels();
+        SetAwaitingRequest(false);
+    }
+
+    bool IsDisabled()
+    {
+        return awaitingRequest;
+    }
+
+    void SetLoading(bool enabled)
+    {
+        loading = enabled;
+        StateHasChanged();
+    }
+
+    void SetAwaitingRequest(bool enabled)
+    {
+        awaitingRequest = enabled;
+        StateHasChanged();
+    }
+
+}

WebNovelPortal/Pages/NovelDetails.razor

@@ -0,0 +1,75 @@
+@page "/novel/{NovelId}"
+@using WebNovelPortal.AccessLayers
+
+@if (Novel == null)
+{
+    <h3>Loading...</h3>
+}
+else
+{
+    <h3><a href="@Novel.Novel.Url">@(Novel.Novel.Title)</a></h3>
+    <h4>Author: <a href="@Novel.Novel.Author?.Url">@(Novel.Novel.Author?.Name ?? "Anonymous")</a></h4>
+    <h4>Date Posted: @Novel.Novel.DatePosted</h4>
+    <h4>Date Updated: @Novel.Novel.LastUpdated</h4>
+    <h4>Tags</h4>
+    <ul>
+        @foreach (var tag in Novel.Novel.Tags)
+        {
+            <li>@tag.TagValue</li>
+        }
+    </ul>
+    <h4>Chapters (Read <input @bind="currentLastChapter" /> / @Novel.Novel.Chapters.Count())</h4>
+    @if (currentLastChapter != originalLastChapter)
+    {
+        <button disabled="@awaitingRequest" @onclick="@UpdateLastReadChapter">Save</button>
+    }
+    <ol>
+        @foreach (var chapter in Novel.Novel.Chapters.OrderBy(i => i.ChapterNumber))
+        {
+            <li><a href="@chapter.Url">@chapter.Name</a></li>
+        }
+    </ol>
+}
+
+@code {
+    [Parameter]
+    public string? NovelId { get; set; }
+    [Inject]
+    public WebApiAccessLayer api { get; set; }
+    UserNovel? Novel { get; set; }
+    int originalLastChapter;
+    int currentLastChapter;
+    bool awaitingRequest;
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (firstRender)
+        {
+            await UpdateNovelDetails();
+        }
+        await base.OnAfterRenderAsync(firstRender);
+    }
+
+    private async Task UpdateNovelDetails()
+    {
+        Novel = await api.GetNovel(NovelId);
+        originalLastChapter = Novel.LastChapterRead;
+        currentLastChapter = originalLastChapter;
+        StateHasChanged();
+    }
+
+    private async Task UpdateLastReadChapter()
+    {
+        SetAwaitingRequest(true);
+        await api.UpdateLastChapterRead(Novel.Novel, currentLastChapter);
+        await UpdateNovelDetails();
+        SetAwaitingRequest(false);
+    }
+
+    private void SetAwaitingRequest(bool enabled)
+    {
+        awaitingRequest = enabled;
+        StateHasChanged();
+    }
+
+}

WebNovelPortal/Program.cs

@@ -1,11 +1,24 @@
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
+using Newtonsoft.Json;
+using Treestar.Shared.AccessLayers;
+using Treestar.Shared.Authentication.OIDC;
+using WebNovelPortal.AccessLayers;
+using WebNovelPortal.Authentication;
 
 var builder = WebApplication.CreateBuilder(args);
 
 // Add services to the container.
+builder.Services.AddScoped<IAccessLayerAuthenticationProvider, BlazorAccessLayerAuthProvider>();
+builder.Services.AddScoped(fac => new WebApiAccessLayer(builder.Configuration["WebAPIUrl"], fac.GetRequiredService<IAccessLayerAuthenticationProvider>()));
 builder.Services.AddRazorPages();
 builder.Services.AddServerSideBlazor();
+builder.Services.AddHttpContextAccessor();
+builder.Services.AddControllers().AddNewtonsoftJson(opt =>
+{
+    opt.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
+});
+builder.Services.AddOIDCAuth(builder.Configuration);
 
 var app = builder.Build();
 
@@ -23,7 +36,11 @@ app.UseStaticFiles();
 
 app.UseRouting();
 
+app.UseAuthentication();
+app.UseAuthorization();
+
 app.MapBlazorHub();
 app.MapFallbackToPage("/_Host");
+app.MapControllers();
 
 app.Run();

WebNovelPortal/Shared/Components/Display/LoadingDisplay.razor

@@ -0,0 +1,5 @@
+<div class="loading-display">Loading...</div>
+
+@code {
+    
+}

WebNovelPortal/Shared/Components/Display/LoadingDisplay.razor.css

@@ -0,0 +1,7 @@
+.loading-display {
+    display: flex;
+    justify-content: center;
+    align-content: center;
+    align-items: center;
+    height: 100%;
+}

WebNovelPortal/Shared/Components/Display/LoginDisplay.razor

@@ -0,0 +1,21 @@
+<AuthorizeView>
+    <Authorized>
+        Hello, @(LoggedInName)!
+        <a href="api/Account/logout">Log out</a>
+    </Authorized>
+    <NotAuthorized>
+        <a href="api/account/login?redirect=/">Log in</a>
+    </NotAuthorized>
+</AuthorizeView>
+
+@code {
+    [CascadingParameter]
+    Task<AuthenticationState> AuthenticationState { get; set; }
+    private string LoggedInName { get; set; }
+    protected override async Task OnInitializedAsync()
+    {
+        await base.OnInitializedAsync();
+        LoggedInName = (await AuthenticationState).User.Identity.Name;
+    }
+
+}

WebNovelPortal/Shared/Components/Display/NovelList.razor

@@ -0,0 +1,45 @@
+@using Microsoft.AspNetCore.Components
+@using WebNovelPortal.AccessLayers
+
+<h1>Novels</h1>
+<table>
+    <tr>
+        <th>Title</th>
+        <th>Author</th>
+        <th>Chapter Count</th>
+        <th>Last Updated</th>
+    </tr>
+    @foreach (var novel in Novels)
+    {
+        <tr>
+            <td>
+                <a href="@($"/novel/{novel.Novel.Guid}")">@novel.Novel.Title</a>
+            </td>
+            <td>
+                <a href="@novel.Novel.Author?.Url">@(novel.Novel.Author?.Name ?? "Anonymous")</a>
+            </td>
+            <td>
+                @novel.Novel.Chapters.Count
+            </td>
+            <td>
+                @novel.Novel.LastUpdated
+            </td>
+            <td>
+                <button disabled="@InputDisabled" @onclick="@(()=>HandleUpdateNovelRequest.InvokeAsync(novel.Novel))">Update</button>
+            </td>
+        </tr>
+    }
+</table>
+
+@code {
+    [Parameter]
+    public List<UserNovel> Novels { get; set; }
+    [Parameter]
+    public EventCallback<Novel> HandleUpdateNovelRequest { get; set; }
+    [Parameter]
+    public bool InputDisabled { get; set; }
+
+    [Inject]
+    private WebApiAccessLayer Api { get; set; }
+
+}

WebNovelPortal/Shared/Layouts/MainLayout.razor

@@ -9,7 +9,7 @@
 
     <main>
         <div class="top-row px-4">
-            <a href="https://docs.microsoft.com/aspnet/" target="_blank">About</a>
+            <LoginDisplay/>
         </div>
 
         <article class="content px-4">

WebNovelPortal/Shared/Layouts/MainLayout.razor.css

@@ -1,11 +1,19 @@
-.page {
+.page {
     position: relative;
     display: flex;
     flex-direction: column;
+    width: 100%;
+}
+
+article {
+    flex: 1 1 auto;
+    width: 100%;
 }
 
 main {
     flex: 1;
+    display: flex;
+    flex-flow: column;
 }
 
 .sidebar {
@@ -19,6 +27,7 @@ main {
     height: 3.5rem;
     display: flex;
     align-items: center;
+    width: 100%
 }
 
 .top-row ::deep a, .top-row .btn-link {
@@ -63,7 +72,7 @@ main {
         z-index: 1;
     }
 
-    .top-row, article {
+    .main > div {
         padding-left: 2rem !important;
         padding-right: 1.5rem !important;
     }

WebNovelPortal/WebNovelPortal.csproj

@@ -5,15 +5,22 @@
         <Nullable>enable</Nullable>
         <ImplicitUsings>enable</ImplicitUsings>
         <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+        <UserSecretsId>32b7cf85-871e-439d-88a2-f8ff5186dafd</UserSecretsId>
     </PropertyGroup>
 
     <ItemGroup>
-      <Content Include="Shared\Components\Layout\NavMenu.razor.css" />
+      <Folder Include="Controllers" />
-      <Content Include="Shared\Layouts\MainLayout.razor.css" />
-    </ItemGroup>
-
-    <ItemGroup>
       <Folder Include="Data" />
     </ItemGroup>
 
+    <ItemGroup>
+      <ProjectReference Include="..\Treestar.Shared\Treestar.Shared.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <PackageReference Include="Microsoft.AspNetCore.Authentication.OpenIdConnect" Version="6.0.7" />
+      <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="6.0.7" />
+      <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="6.0.7" />
+    </ItemGroup>
+
 </Project>

WebNovelPortal/_Imports.razor

@@ -10,3 +10,5 @@
 @using WebNovelPortal.Shared
 @using WebNovelPortal.Shared.Layouts
 @using WebNovelPortal.Shared.Components.Layout
+@using WebNovelPortal.Shared.Components.Display
+@using Treestar.Shared.Models.DBDomain

WebNovelPortal/appsettings.json

@@ -5,5 +5,12 @@
       "Microsoft.AspNetCore": "Warning"
     }
   },
-  "AllowedHosts": "*"
+  "OIDCAuthOptions": {
+    "Authority": "authority_here",
+    "ClientId": "clientid_here",
+    "ClientSecret": "clientsecret_here",
+    "Scopes": "openid profile email"
+  },
+  "AllowedHosts": "*",
+  "WebAPIUrl": "https://localhost:7137/api/"
 }

WebNovelPortal/wwwroot/css/site.css

@@ -2,6 +2,7 @@
 
 html, body {
     font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
+    height: 100%;
 }
 
 h1:focus {

WebNovelPortalAPI/.dockerignore

@@ -0,0 +1,25 @@
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/.idea
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/azds.yaml
+**/bin
+**/charts
+**/docker-compose*
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+LICENSE
+README.md

WebNovelPortalAPI/Controllers/AuthorizedController.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Treestar.Shared.Models.DBDomain;
+using WebNovelPortalAPI.Middleware;
+
+namespace WebNovelPortalAPI.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    [Authorize]
+    public class AuthorizedController : ControllerBase
+    {
+        protected int UserId
+        {
+            get
+            {
+                return (int) (HttpContext.Items[EnsureUserCreatedMiddleware.UserIdItemName] ?? 0);
+            }
+        }
+
+        public AuthorizedController()
+        {
+        }
+        
+    }
+}

WebNovelPortalAPI/Controllers/NovelController.cs

@@ -3,27 +3,45 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using DBConnection;
-using DBConnection.Models;
 using DBConnection.Repositories;
 using DBConnection.Repositories.Interfaces;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
-using WebNovelPortalAPI.DTO;
+using Treestar.Shared.Models.DBDomain;
+using Treestar.Shared.Models.DTO;
+using Treestar.Shared.Models.DTO.Requests;
+using Treestar.Shared.Models.DTO.Responses;
+using WebNovelPortalAPI.Exceptions;
 using WebNovelPortalAPI.Scrapers;
 
 namespace WebNovelPortalAPI.Controllers
 {
     [Route("api/[controller]")]
     [ApiController]
-    public class NovelController : ControllerBase
+    [Authorize]
+    public class NovelController : AuthorizedController
     {
         private readonly INovelRepository _novelRepository;
+        private readonly IUserRepository _userRepository;
         private readonly IEnumerable<IScraper> _scrapers;
 
-        public NovelController(IEnumerable<IScraper> scrapers, INovelRepository novelRepository)
+        public NovelController(IEnumerable<IScraper> scrapers, INovelRepository novelRepository, IUserRepository userRepository)
         {
             _scrapers = scrapers;
             _novelRepository = novelRepository;
+            _userRepository = userRepository;
+        }
+
+        private async Task<Novel?> ScrapeNovel(string url)
+        {
+            var scraper = MatchScraper(url);
+            if (scraper == null)
+            {
+                throw new NoMatchingScraperException(url);
+            }
+            var novel = scraper.ScrapeNovel(url);
+            return novel;
         }
 
         private IScraper? MatchScraper(string novelUrl)
@@ -31,28 +49,94 @@ namespace WebNovelPortalAPI.Controllers
             return _scrapers.FirstOrDefault(i => i.MatchesUrl(novelUrl));
         }
 
-        [HttpPost]
+        private async Task<User> GetUser()
-        [Route("scrapeNovel")]
-        public async Task<IActionResult> ScrapeNovel(ScrapeNovelRequest request)
         {
-            var scraper = MatchScraper(request.NovelUrl);
+            return await _userRepository.GetIncluded(u => u.Id == UserId);
-            if (scraper == null)
-            {
-                return BadRequest("Invalid url, no valid scraper configured");
         }
 
-            Novel novel;
+        [HttpGet]
+        [Route("{guid:guid}")]
+        public async Task<UserNovel?> GetNovel(Guid guid)
+        {
+            var user = await GetUser();
+            var novel = await _novelRepository.GetNovel(guid);
+            return user.WatchedNovels.FirstOrDefault(un => un.NovelUrl == novel.Url);
+        }
+
+        [HttpGet]
+        public async Task<List<UserNovel>> GetNovels()
+        {
+            var user = await GetUser();
+            var novels = user.WatchedNovels.Select(i => i.Novel);
+            (await _novelRepository.GetWhereIncluded(novels)).ToList();
+            return user.WatchedNovels.ToList();
+        }
+
+        [HttpPost]
+        [Route("scrapeNovels")]
+        public async Task<IActionResult> ScrapeNovels(ScrapeNovelsRequest request)
+        {
+            var successfulScrapes = new List<Novel>();
+            var failures = new Dictionary<string, Exception>();
+            foreach (var novelUrl in request.NovelUrls)
+            {
                 try
                 {
-                novel = scraper.ScrapeNovel(request.NovelUrl);
+                    successfulScrapes.Add(await ScrapeNovel(novelUrl));
+                }
+                catch (Exception e)
+                {
+                    failures[novelUrl] = e;
+                }
+            }
+            List<Novel> successfulUploads;
+            try
+            {
+                successfulUploads = (await _novelRepository.UpsertMany(successfulScrapes, true)).ToList();
+                var user = await GetUser();
+                await _userRepository.AssignNovelsToUser(user, successfulUploads);
             }
             catch (Exception e)
             {
                 return StatusCode(500, e);
             }
+            return Ok(new ScrapeNovelsResponse
+            {
+                Failures = failures,
+                SuccessfulNovels = successfulScrapes
+            });
+        }
 
-            var novelUpload = await _novelRepository.Upsert(novel);
+        [HttpPost]
-            return Ok(novelUpload);
+        [Route("scrapeNovel")]
+        public async Task<IActionResult> ScrapeNovel(ScrapeNovelRequest request)
+        {
+            try
+            {
+                var novel = await ScrapeNovel(request.NovelUrl);
+                var dbNovel = await _novelRepository.Upsert(novel, true);
+                var user = await GetUser();
+                await _userRepository.AssignNovelsToUser(user, new List<Novel> {novel});
+                return Ok(dbNovel);
+            }
+            catch (NoMatchingScraperException e)
+            {
+                return BadRequest("Invalid url, no valid scraper configured");
+            }
+            catch (Exception e)
+            {
+                return StatusCode(500, e);
+            }
+        }
+
+        [HttpPatch]
+        [Route("updateLastChapterRead")]
+        public async Task<IActionResult> UpdateLastChapterRead(Guid novelGuid, int chapter)
+        {
+            var user = await GetUser();
+            var novel = await _novelRepository.GetNovel(novelGuid);
+            await _userRepository.UpdateLastChapterRead(user, novel, chapter);
+            return Ok();
         }
     }
 }

WebNovelPortalAPI/Dockerfile

@@ -0,0 +1,22 @@
+FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
+WORKDIR /app
+EXPOSE 80
+EXPOSE 443
+
+FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
+WORKDIR /src
+COPY ["WebNovelPortalAPI/WebNovelPortalAPI.csproj", "WebNovelPortalAPI/"]
+COPY ["DBConnection/DBConnection.csproj", "DBConnection/"]
+COPY ["Treestar.Shared/Treestar.Shared.csproj", "Treestar.Shared/"]
+RUN dotnet restore "WebNovelPortalAPI/WebNovelPortalAPI.csproj"
+COPY . .
+WORKDIR "/src/WebNovelPortalAPI"
+RUN dotnet build "WebNovelPortalAPI.csproj" -c Release -o /app/build
+
+FROM build AS publish
+RUN dotnet publish "WebNovelPortalAPI.csproj" -c Release -o /app/publish
+
+FROM base AS final
+WORKDIR /app
+COPY --from=publish /app/publish .
+ENTRYPOINT ["dotnet", "WebNovelPortalAPI.dll"]

WebNovelPortalAPI/Exceptions/NoMatchingScraperException.cs

@@ -0,0 +1,10 @@
+namespace WebNovelPortalAPI.Exceptions;
+
+public class NoMatchingScraperException: Exception
+{
+    public NoMatchingScraperException(string novelUrl) : base($"Novel URL {novelUrl} did not match any registered web scraper.")
+    {
+    }
+    
+    
+}

WebNovelPortalAPI/Extensions/DBUpdateExtensions.cs

@@ -0,0 +1,17 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace WebNovelPortalAPI.Extensions;
+
+public static class DBUpdateExtensions
+{
+    public static void UpdateDatabase<T>(this IApplicationBuilder app) where T : DbContext
+    {
+        using var serviceScope = app.ApplicationServices.CreateScope();
+        using var context = serviceScope.ServiceProvider.GetService<T>();
+
+        if (context.Database.GetPendingMigrations().Any())
+        {
+            context.Database.Migrate();
+        }
+    }
+}

WebNovelPortalAPI/Extensions/ScraperExtensions.cs

@@ -8,7 +8,7 @@ public static class ScraperExtensions
     public static void AddScrapers(this IServiceCollection services)
     {
         Type[] types = Assembly.GetExecutingAssembly().GetTypes().Where(t =>
-                t.IsClass && typeof(IScraper).IsAssignableFrom(t) && (t.Namespace?.Contains(nameof(Scrapers)) ?? false))
+                t.IsClass && typeof(IScraper).IsAssignableFrom(t) && !t.IsAbstract && (t.Namespace?.Contains(nameof(Scrapers)) ?? false))
             .ToArray();
         foreach (var t in types)
         {

WebNovelPortalAPI/Middleware/EnsureUserCreatedMiddleware.cs

@@ -0,0 +1,32 @@
+using System.Security.Claims;
+using DBConnection.Repositories.Interfaces;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Treestar.Shared.Models.DBDomain;
+
+namespace WebNovelPortalAPI.Middleware;
+
+public class EnsureUserCreatedMiddleware : IMiddleware
+{
+    private readonly IUserRepository _userRepository;
+    public const string UserIdItemName = "userId";
+    public EnsureUserCreatedMiddleware(IUserRepository userRepository)
+    {
+        _userRepository = userRepository;
+    }
+
+    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
+    {
+        if (!context.User.Identity.IsAuthenticated)
+        {
+            await next(context);
+            return;
+        }
+        var userEmail = context.User.Claims.FirstOrDefault(i => i.Type == ClaimTypes.Email)?.Value;
+        var dbUser = await _userRepository.GetIncluded(u => u.Email == userEmail) ?? await _userRepository.Upsert(new User
+        {
+            Email = userEmail
+        });
+        context.Items[UserIdItemName] = dbUser.Id;
+        await next(context);
+    }
+}

WebNovelPortalAPI/Program.cs

@@ -1,8 +1,12 @@
 using DBConnection;
+using DBConnection.Contexts;
 using DBConnection.Extensions;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.OpenApi.Models;
 using Newtonsoft.Json;
+using Treestar.Shared.Authentication.JwtBearer;
 using WebNovelPortalAPI.Extensions;
+using WebNovelPortalAPI.Middleware;
 using WebNovelPortalAPI.Scrapers;
 
 var builder = WebApplication.CreateBuilder(args);
@@ -10,16 +14,43 @@ var builder = WebApplication.CreateBuilder(args);
 // Add services to the container.
 builder.Services.AddDbServices(builder.Configuration);
 builder.Services.AddScrapers();
+builder.Services.AddJwtBearerAuth(builder.Configuration);
+builder.Services.AddScoped<EnsureUserCreatedMiddleware>();
 builder.Services.AddControllers().AddNewtonsoftJson(opt =>
 {
     opt.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
 });
 // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
 builder.Services.AddEndpointsApiExplorer();
-builder.Services.AddSwaggerGen();
+builder.Services.AddSwaggerGen(opt =>
+{
+    opt.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
+    {
+        In = ParameterLocation.Header,
+        Description = "Bearer token",
+        Name = "Authorization",
+        Type = SecuritySchemeType.Http,
+        BearerFormat = "JWT",
+        Scheme = "bearer"
+    });
+    opt.AddSecurityRequirement(new OpenApiSecurityRequirement
+    {
+        {
+            new OpenApiSecurityScheme
+            {
+                Reference = new OpenApiReference
+                {
+                    Type=ReferenceType.SecurityScheme,
+                    Id="Bearer"
+                }
+            },
+            new string[]{}
+        }
+    });
+});
 
 var app = builder.Build();
-
+app.UpdateDatabase<AppDbContext>();
 // Configure the HTTP request pipeline.
 if (app.Environment.IsDevelopment())
 {
@@ -29,8 +60,9 @@ if (app.Environment.IsDevelopment())
 
 app.UseHttpsRedirection();
 
+app.UseAuthentication();
 app.UseAuthorization();
-
+app.UseMiddleware<EnsureUserCreatedMiddleware>();
 app.MapControllers();
 
 app.Run();

WebNovelPortalAPI/Scrapers/AbstractScraper.cs

@@ -0,0 +1,132 @@
+using System.Text.RegularExpressions;
+using HtmlAgilityPack;
+using Treestar.Shared.Models.DBDomain;
+
+namespace WebNovelPortalAPI.Scrapers;
+
+public abstract class AbstractScraper : IScraper
+{
+    protected abstract string UrlMatchPattern { get; }
+    protected abstract string BaseUrlPattern { get; }
+    protected virtual string? WorkTitlePattern { get; }
+    protected virtual string? AuthorNamePattern { get; }
+    protected virtual string? AuthorLinkPattern { get; }
+    protected virtual string? ChapterUrlPattern { get; }
+    protected virtual string? ChapterNamePattern { get; }
+    protected virtual string? ChapterPostedPattern { get; }
+    protected virtual string? ChapterUpdatedPattern { get; }
+    protected virtual string? TagPattern { get; }
+    protected virtual string? DatePostedPattern { get; }
+    protected virtual string? DateUpdatedPattern { get; }
+
+    protected virtual (DateTime? Posted, DateTime? Updated) GetDateTimeForChapter(HtmlNode linkNode, HtmlNode baseNode,
+        string baseUrl, string novelUrl)
+    {
+        return (null, null);
+    }
+    
+    public virtual bool MatchesUrl(string url)
+    {
+        var regex = new Regex(UrlMatchPattern, RegexOptions.IgnoreCase);
+        return regex.IsMatch(url);
+    }
+
+    protected virtual string GetNovelTitle(HtmlDocument document, string baseUrl, string novelUrl)
+    {
+        var xpath = WorkTitlePattern;
+        return document.DocumentNode.SelectSingleNode(xpath).InnerText;
+    }
+
+    protected virtual Author GetAuthor(HtmlDocument document, string baseUrl, string novelUrl)
+    {
+        var nameXPath = AuthorNamePattern;
+        var urlXPath = AuthorLinkPattern;
+        try
+        {
+            var authorName = document.DocumentNode.SelectSingleNode(nameXPath).InnerText;
+            var authorUrl = document.DocumentNode.SelectSingleNode(urlXPath).Attributes["href"].Value;
+            Author author = new Author
+            {
+                Name = authorName,
+                Url = $"{baseUrl + authorUrl}"
+            };
+            return author;
+        }
+        catch (Exception e)
+        {
+            return null;
+        }
+
+    }
+
+    protected virtual List<Chapter> GetChapters(HtmlDocument document, string baseUrl, string novelUrl)
+    {
+        var urlxpath = ChapterUrlPattern;
+        var namexpath = ChapterNamePattern;
+        var urlnodes = document.DocumentNode.SelectNodes(urlxpath);
+        var chapters = urlnodes.Select((node, i) =>
+        {
+            var dates = GetDateTimeForChapter(node, document.DocumentNode, baseUrl, novelUrl);
+            return new Chapter
+            {
+                ChapterNumber = i + 1,
+                Url = $"{baseUrl}{node.Attributes["href"].Value}",
+                Name = node.SelectSingleNode(namexpath).InnerText,
+                DatePosted = dates.Posted,
+                DateUpdated = dates.Updated
+            };
+        });
+
+        return chapters.ToList();
+    }
+
+    protected virtual List<Tag> GetTags(HtmlDocument document, string baseUrl, string novelUrl)
+    {
+        var xpath = TagPattern;
+        var nodes = document.DocumentNode.SelectNodes(xpath);
+        return nodes.Select(node => new Tag
+        {
+            TagValue = node.InnerText
+        }).ToList();
+    }
+
+    protected virtual DateTime GetPostedDate(HtmlDocument document, string baseUrl, string novelUrl)
+    {
+        var xpath = DatePostedPattern;
+        return DateTime.Parse(document.DocumentNode.SelectSingleNode(xpath).InnerText);
+    }
+
+    protected virtual DateTime GetLastUpdatedDate(HtmlDocument document, string baseUrl, string novelUrl)
+    {
+        var xpath = DateUpdatedPattern;
+        return DateTime.Parse(document.DocumentNode.SelectSingleNode(xpath).InnerText);
+    }
+    
+    public Novel ScrapeNovel(string url)
+    {
+        var web = new HtmlWeb();
+        var doc = web.Load(url);
+        if (doc == null)
+        {
+            throw new Exception("Error parsing document");
+        }
+
+        var baseUrl = new Regex(BaseUrlPattern).Match(url).Value;
+        var novelUrl = new Regex(UrlMatchPattern).Match(url).Value;
+        return new Novel
+        {
+            Author = GetAuthor(doc, baseUrl, novelUrl),
+            Chapters = GetChapters(doc, baseUrl, novelUrl),
+            DatePosted = GetPostedDate(doc, baseUrl, novelUrl),
+            LastUpdated = GetLastUpdatedDate(doc, baseUrl, novelUrl),
+            Tags = GetTags(doc, baseUrl, novelUrl),
+            Title = GetNovelTitle(doc, baseUrl, novelUrl),
+            Url = novelUrl
+        };
+    }
+
+    public string? ScrapeChapterContent(string chapterUrl)
+    {
+        throw new NotImplementedException();
+    }
+}

WebNovelPortalAPI/Scrapers/IScraper.cs

@@ -1,4 +1,4 @@
-using DBConnection.Models;
+using Treestar.Shared.Models.DBDomain;
 
 namespace WebNovelPortalAPI.Scrapers;
 

WebNovelPortalAPI/Scrapers/KakuyomuScraper.cs

@@ -1,102 +1,37 @@
 using System.Reflection.Metadata;
 using System.Text.RegularExpressions;
-using DBConnection.Models;
 using HtmlAgilityPack;
 
 namespace WebNovelPortalAPI.Scrapers;
 
-public class KakuyomuScraper : IScraper
+public class KakuyomuScraper : AbstractScraper
 {
-    private const string UrlPattern = @"https?:\/\/kakuyomu\.jp\/works\/\d+\/?";
+    protected override string UrlMatchPattern => @"https?:\/\/kakuyomu\.jp\/works\/\d+\/?";
-    private const string BaseUrl = "https://kakuyomu.jp";
-    public bool MatchesUrl(string url)
-    {
-        var regex = new Regex(UrlPattern, RegexOptions.IgnoreCase);
-        return regex.IsMatch(url);
-    }
 
-    private string GetNovelTitle(HtmlDocument document)
+    protected override string BaseUrlPattern => @"https?:\/\/kakuyomu\.jp";
-    {
-        var xpath = @"//*[@id='workTitle']/a";
-        return document.DocumentNode.SelectSingleNode(xpath).InnerText;
-    }
 
-    private Author GetAuthor(HtmlDocument document)
+    protected override string? WorkTitlePattern => @"//*[@id='workTitle']/a";
-    {
+    protected override string? AuthorNamePattern => @"//*[@id='workAuthor-activityName']/a";
-        var nameXPath = @"//*[@id='workAuthor-activityName']/a";
+    protected override string? AuthorLinkPattern => @"//*[@id='workAuthor-activityName']/a";
-        var urlXPath = @"//*[@id='workAuthor-activityName']/a";
-        var authorName = document.DocumentNode.SelectSingleNode(nameXPath).InnerText;
-        var authorUrl = document.DocumentNode.SelectSingleNode(urlXPath).Attributes["href"].Value;
-        Author author = new Author
-        {
-            Name = authorName,
-            Url = $"{BaseUrl + authorUrl}"
-        };
-        return author;
 
-    }
+    protected override string? ChapterUrlPattern => @"//a[@class='widget-toc-episode-episodeTitle']";
 
-    private List<Chapter> GetChapters(HtmlDocument document)
+    protected override string? ChapterNamePattern => @"span";
-    {
-        var urlxpath = @"//a[@class='widget-toc-episode-episodeTitle']";
-        var namexpath = @"span";
-        var urlnodes = document.DocumentNode.SelectNodes(urlxpath);
-        var chapters = urlnodes.Select((node, i) => new Chapter
-        {
-            ChapterNumber = i + 1,
-            Url = $"{BaseUrl}{node.Attributes["href"].Value}",
-            Name = node.SelectSingleNode(namexpath).InnerText
-        });
 
-        return chapters.ToList();
+    protected override string? ChapterPostedPattern => @"time";
-    }
 
-    private List<Tag> GetTags(HtmlDocument document)
+    protected override string? ChapterUpdatedPattern => base.ChapterUpdatedPattern;
-    {
-        var xpath = @"//span[@itemprop='keywords']/a";
-        var nodes = document.DocumentNode.SelectNodes(xpath);
-        return nodes.Select(node => new Tag
-        {
-            TagValue = node.InnerText
-        }).ToList();
-    }
 
-    private DateTime GetPostedDate(HtmlDocument document)
+    protected override string? TagPattern => @"//span[@itemprop='keywords']/a";
-    {
-        var xpath = @"//time[@itemprop='datePublished']";
-        return DateTime.Parse(document.DocumentNode.SelectSingleNode(xpath).InnerText);
-    }
 
-    private DateTime GetLastUpdatedDate(HtmlDocument document)
+    protected override string? DatePostedPattern => @"//time[@itemprop='datePublished']";
-    {
-        var xpath = @"//time[@itemprop='dateModified']";
-        return DateTime.Parse(document.DocumentNode.SelectSingleNode(xpath).InnerText);
-    }
 
-    public Novel ScrapeNovel(string url)
+    protected override string? DateUpdatedPattern => @"//time[@itemprop='dateModified']";
-    {
-        Novel novel = new Novel();
-        var web = new HtmlWeb();
-        var doc = web.Load(url);
-        if (doc == null)
-        {
-            throw new Exception("Error parsing document");
-        }
 
-        return new Novel
+    protected override (DateTime? Posted, DateTime? Updated) GetDateTimeForChapter(HtmlNode linkNode, HtmlNode baseNode, string baseUrl,
+        string novelUrl)
     {
-            Author = GetAuthor(doc),
+        var datePosted = linkNode.SelectSingleNode(ChapterPostedPattern).Attributes["datetime"].Value;
-            Chapters = GetChapters(doc),
+        return (DateTime.Parse(datePosted), null);
-            DatePosted = GetPostedDate(doc),
-            LastUpdated = GetLastUpdatedDate(doc),
-            Tags = GetTags(doc),
-            Title = GetNovelTitle(doc),
-            Url = url
-        };
-    }
-
-    public string? ScrapeChapterContent(string chapterUrl)
-    {
-        throw new NotImplementedException();
     }
 }

WebNovelPortalAPI/Scrapers/SyosetuScraper.cs

@@ -0,0 +1,119 @@
+using System.Text.RegularExpressions;
+using HtmlAgilityPack;
+using Treestar.Shared.Models.DBDomain;
+
+namespace WebNovelPortalAPI.Scrapers;
+
+public class SyosetuScraper : AbstractScraper
+{
+
+    protected override string UrlMatchPattern => @"https?:\/\/\w+\.syosetu\.com\/\w+\/?";
+
+    protected override string BaseUrlPattern => @"https?:\/\/\w+\.syosetu\.com";
+
+    protected override string? WorkTitlePattern => @"//p[@class='novel_title']";
+
+    protected override string? AuthorNamePattern => @"//div[@class='novel_writername']/a | //div[@class='novel_writername']";
+
+    protected override string? AuthorLinkPattern => @"//div[@class='novel_writername']/a";
+
+    protected override string? ChapterUrlPattern => @"//dl[@class='novel_sublist2']//a";
+
+    protected override string? ChapterPostedPattern => @"following-sibling::dt[@class='long_update']";
+
+    protected override string? ChapterUpdatedPattern => @"span";
+
+    protected override string? TagPattern => @"//th[text()='キーワード']/following-sibling::td";
+
+    protected override string? DatePostedPattern => @"//th[text()='掲載日']/following-sibling::td";
+
+    protected override string? DateUpdatedPattern => @"//th[contains(text(),'掲載日')]/following-sibling::td";
+
+    private HtmlDocument? GetInfoPage(string baseUrl, string novelUrl)
+    {
+        string novelInfoBase = $"/novelview/infotop/ncode/";
+        string novelRegex = @"https?:\/\/\w+\.syosetu\.com\/(\w+)\/?";
+        string novelCode = new Regex(novelRegex).Match(novelUrl).Groups[1].Value;
+        string novelInfoPage = $"{baseUrl}{novelInfoBase}{novelCode}";
+        var web = new HtmlWeb();
+        return web.Load(novelInfoPage);
+    }
+
+    protected override List<Chapter> GetChapters(HtmlDocument document, string baseUrl, string novelUrl)
+    {
+        string dateUpdatedRegex = @"\d\d\d\d\/\d\d\/\d\d \d\d:\d\d";
+        var nodes = document.DocumentNode.SelectNodes(ChapterUrlPattern);
+        return nodes.Select((node,i) =>
+        {
+            var datePostedNode = node.ParentNode.SelectSingleNode(ChapterPostedPattern);
+            var datePosted = DateTime.Parse(new Regex(dateUpdatedRegex).Match(datePostedNode.InnerText).Value);
+            var dateUpdatedNode = datePostedNode.SelectSingleNode(ChapterUpdatedPattern);
+            DateTime dateUpdated;
+            if (dateUpdatedNode == null)
+            {
+                dateUpdated = datePosted;
+            }
+            else
+            {
+                dateUpdated = DateTime.Parse(new Regex(dateUpdatedRegex).Match(dateUpdatedNode.Attributes["title"].Value).Value);
+            }
+            return new Chapter
+            {
+                Name = node.InnerText,
+                Url = baseUrl + node.Attributes["href"].Value,
+                ChapterNumber = i+1,
+                DatePosted = datePosted,
+                DateUpdated = dateUpdated
+            };
+        }).ToList();
+    }
+
+    protected override Author GetAuthor(HtmlDocument document, string baseUrl, string novelUrl)
+    {
+        var authorLink = document.DocumentNode.SelectSingleNode(AuthorLinkPattern)?.Attributes["href"].Value ?? null;
+        if (string.IsNullOrEmpty(authorLink))
+        {
+            return null;
+        }
+        var authorName = document.DocumentNode.SelectSingleNode(AuthorNamePattern).InnerText.Replace("\n", "");
+        return new Author
+        {
+            Name = authorName,
+            Url = authorLink
+        };
+    }
+
+    protected override DateTime GetPostedDate(HtmlDocument document, string baseUrl, string novelUrl)
+    {
+        var doc = GetInfoPage(baseUrl, novelUrl);
+        if (doc == null)
+        {
+            return DateTime.MinValue;
+        }
+
+        var node = doc.DocumentNode.SelectSingleNode(DatePostedPattern);
+        return DateTime.Parse(node.InnerText);
+    }
+
+    protected override DateTime GetLastUpdatedDate(HtmlDocument document, string baseUrl, string novelUrl)
+    {
+        var doc = GetInfoPage(baseUrl, novelUrl);
+        if (doc == null)
+        {
+            return DateTime.MinValue;
+        }
+        return DateTime.Parse(doc.DocumentNode.SelectNodes(DateUpdatedPattern)[1].InnerText);
+    }
+
+    protected override List<Tag> GetTags(HtmlDocument document, string baseUrl, string novelUrl)
+    {
+        var doc = GetInfoPage(baseUrl, novelUrl);
+        if (doc == null)
+        {
+            return new List<Tag>();
+        }
+
+        var tags = doc.DocumentNode.SelectSingleNode(TagPattern).InnerText.Replace("\n", "").Replace("&nbsp;", " ").Split(' ');
+        return tags.Select(i => new Tag {TagValue = i}).ToList();
+    }
+}

WebNovelPortalAPI/WebNovelPortalAPI.csproj

@@ -4,10 +4,13 @@
         <TargetFramework>net6.0</TargetFramework>
         <Nullable>enable</Nullable>
         <ImplicitUsings>enable</ImplicitUsings>
+        <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+        <UserSecretsId>dd5e7c53-e576-4442-ae30-c496ec2070a5</UserSecretsId>
     </PropertyGroup>
 
     <ItemGroup>
         <PackageReference Include="HtmlAgilityPack" Version="1.11.43" />
+        <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="6.0.7" />
         <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="6.0.7" />
         <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="6.0.7" />
         <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="6.0.7" />
@@ -21,6 +24,7 @@
 
     <ItemGroup>
       <ProjectReference Include="..\DBConnection\DBConnection.csproj" />
+      <ProjectReference Include="..\Treestar.Shared\Treestar.Shared.csproj" />
     </ItemGroup>
 
 </Project>

WebNovelPortalAPI/appsettings.json

@@ -6,7 +6,13 @@
     }
   },
   "ConnectionStrings": {
-    "DefaultConnection": "Data Source=/home/m/Documents/WebNovelPortal/WebNovelPortalAPI/test_db"
+    "Sqlite": "Data Source=test_db",
+    "PostgresSql": "placeholder"
   },
+  "JwtBearerAuthOptions": {
+    "Authority": "placeholder",
+    "Audience": ""
+  },
+  "DatabaseProvider": "Sqlite",
   "AllowedHosts": "*"
 }