incr ver

Bug Fixes and UI Improvement

Documentation/Advanced.md

@@ -68,6 +68,10 @@ liberate all books and pdfs
 liberate pdfs only
   libationcli liberate --pdf
   libationcli liberate -p
+
+Copy the local sqlite database to postgres
+  libationcli copydb --connectionString "my postgres connection string"
+  libationcli copydb -c "my postgres connection string"
   
 export library to file
   libationcli export --path "C:\foo\bar\my.json" --json

Scripts/Bundle_Debian.sh

@@ -113,6 +113,7 @@ Essential: no
 Priority: optional
 Maintainer: github.com/rmcrackan
 Description: liberate your audiobooks
+Recommends: libgtk-3-0, libwebkit2gtk-4.1-0
 " >> $FOLDER_DEBIAN/control
 
 echo "Changing permissions for pre- and post-install files..."

Scripts/Bundle_Redhat.sh

@@ -62,7 +62,7 @@ License:        GPLv3+
 URL:            https://github.com/rmcrackan/Libation
 Source0:        https://github.com/rmcrackan/Libation   
 
-Requires:       bash
+Requires:       bash gtk3 webkit2gtk4.1
 
 
 %define __os_install_post %{nil}

Source/AaxDecrypter/AaxDecrypter.csproj

@@ -13,7 +13,7 @@
 	</PropertyGroup>
 
 	<ItemGroup>
-	  <PackageReference Include="AAXClean.Codecs" Version="2.0.2.2" />
+	  <PackageReference Include="AAXClean.Codecs" Version="2.0.3.1" />
 	</ItemGroup>
 
 	<ItemGroup>

Source/AppScaffolding/AppScaffolding.csproj

@@ -2,13 +2,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net9.0</TargetFramework>
-    <Version>12.5.7.1</Version>
+    <Version>12.7.1.1</Version>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Octokit" Version="14.0.0" />
     <!-- Do not remove unused Serilog.Sinks -->
     <!-- Only File sink is currently used. By user request (June 2024) others packages are included for experimental use. -->
-    <PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />
+    <PackageReference Include="Serilog.Sinks.Console" Version="6.1.1" />
     <PackageReference Include="Serilog.Sinks.File" Version="7.0.0" />
   </ItemGroup>
   <ItemGroup>

Source/ApplicationServices/ApplicationServices.csproj

@@ -6,12 +6,14 @@
 
   <ItemGroup>
     <PackageReference Include="CsvHelper" Version="33.1.0" />
-    <PackageReference Include="NPOI" Version="2.7.4" />
+	<PackageReference Include="ClosedXML" Version="0.105.0" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\DtoImporterService\DtoImporterService.csproj" />
     <ProjectReference Include="..\LibationSearchEngine\LibationSearchEngine.csproj" />
+    <ProjectReference Include="..\DataLayer.Postgres\DataLayer.Postgres.csproj" />
+    <ProjectReference Include="..\DataLayer.Sqlite\DataLayer.Sqlite.csproj" />
   </ItemGroup>
 
 	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">

Source/ApplicationServices/DbContexts.cs

@@ -1,21 +1,28 @@
-using System;
-using System.Collections.Generic;
-using DataLayer;
+using DataLayer;
 using LibationFileManager;
+using Microsoft.EntityFrameworkCore;
+using System.Collections.Generic;
 
 namespace ApplicationServices
 {
-	public static class DbContexts
-	{
-		/// <summary>Use for fully functional context, incl. SaveChanges(). For query-only, use the other method</summary>
-		public static LibationContext GetContext()
-			=> InstanceQueue<LibationContext>.WaitToCreateInstance(() => LibationContext.Create(SqliteStorage.ConnectionString));
+    public static class DbContexts
+    {
+        /// <summary>Use for fully functional context, incl. SaveChanges(). For query-only, use the other method</summary>
+        public static LibationContext GetContext()
+            => InstanceQueue<LibationContext>.WaitToCreateInstance(() =>
+            {
+                var context = !string.IsNullOrEmpty(Configuration.Instance.PostgresqlConnectionString)
+                    ? LibationContextFactory.CreatePostgres(Configuration.Instance.PostgresqlConnectionString)
+                    : LibationContextFactory.CreateSqlite(SqliteStorage.ConnectionString);
+                context.Database.Migrate();
+                return context;
+            });
 
-		/// <summary>Use for full library querying. No lazy loading</summary>
-		public static List<LibraryBook> GetLibrary_Flat_NoTracking(bool includeParents = false)
-		{
-			using var context = GetContext();
-			return context.GetLibrary_Flat_NoTracking(includeParents);
-		}
-	}
+        /// <summary>Use for full library querying. No lazy loading</summary>
+        public static List<LibraryBook> GetLibrary_Flat_NoTracking(bool includeParents = false)
+        {
+            using var context = GetContext();
+            return context.GetLibrary_Flat_NoTracking(includeParents);
+        }
+    }
 }

Source/ApplicationServices/LibraryExporter.cs

@@ -1,11 +1,12 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
+using ClosedXML.Excel;
 using CsvHelper;
 using CsvHelper.Configuration.Attributes;
 using DataLayer;
 using Newtonsoft.Json;
-using NPOI.XSSF.UserModel;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
 
 namespace ApplicationServices
 {
@@ -208,19 +209,11 @@ namespace ApplicationServices
 		{
 			var dtos = DbContexts.GetLibrary_Flat_NoTracking().ToDtos();
 
-			var workbook = new XSSFWorkbook();
-			var sheet = workbook.CreateSheet("Library");
+			using var workbook = new XLWorkbook();
+			var sheet = workbook.AddWorksheet("Library");
 
-			var detailSubtotalFont = workbook.CreateFont();
-			detailSubtotalFont.IsBold = true;
-
-			var detailSubtotalCellStyle = workbook.CreateCellStyle();
-			detailSubtotalCellStyle.SetFont(detailSubtotalFont);
 
 			// headers
-			var rowIndex = 0;
-			var row = sheet.CreateRow(rowIndex);
-
 			var columns = new[] {
 				nameof(ExportDto.Account),
 				nameof(ExportDto.DateAdded),
@@ -261,81 +254,71 @@ namespace ApplicationServices
                 nameof(ExportDto.ChannelCount),
                 nameof(ExportDto.BitRate)
             };
-			var col = 0;
+
+			int rowIndex = 1, col = 1;
+			var headerRow = sheet.Row(rowIndex++);
 			foreach (var c in columns)
 			{
-				var cell = row.CreateCell(col++);
-				var name = ExportDto.GetName(c);
-				cell.SetCellValue(name);
-				cell.CellStyle = detailSubtotalCellStyle;
+				var headerCell = headerRow.Cell(col++);
+				headerCell.Value = ExportDto.GetName(c);
+				headerCell.Style.Font.Bold = true;
 			}
 
-			var dateFormat = workbook.CreateDataFormat();
-			var dateStyle = workbook.CreateCellStyle();
-			dateStyle.DataFormat = dateFormat.GetFormat("MM/dd/yyyy HH:mm:ss");
-
-			rowIndex++;
+			var dateFormat = CultureInfo.CurrentCulture.DateTimeFormat.ShortDatePattern + " HH:mm:ss";
 
 			// Add data rows
 			foreach (var dto in dtos)
 			{
-				col = 0;
-				row = sheet.CreateRow(rowIndex++);
+				col = 1;
+				var row = sheet.Row(rowIndex++);
 
-				row.CreateCell(col++).SetCellValue(dto.Account);
-				row.CreateCell(col++).SetCellValue(dto.DateAdded).CellStyle = dateStyle;
-				row.CreateCell(col++).SetCellValue(dto.AudibleProductId);
-				row.CreateCell(col++).SetCellValue(dto.Locale);
-				row.CreateCell(col++).SetCellValue(dto.Title);
-				row.CreateCell(col++).SetCellValue(dto.Subtitle);
-				row.CreateCell(col++).SetCellValue(dto.AuthorNames);
-				row.CreateCell(col++).SetCellValue(dto.NarratorNames);
-				row.CreateCell(col++).SetCellValue(dto.LengthInMinutes);
-				row.CreateCell(col++).SetCellValue(dto.Description);
-				row.CreateCell(col++).SetCellValue(dto.Publisher);
-				row.CreateCell(col++).SetCellValue(dto.HasPdf);
-				row.CreateCell(col++).SetCellValue(dto.SeriesNames);
-				row.CreateCell(col++).SetCellValue(dto.SeriesOrder);
-				row.CreateCell(col++).SetCellValue(dto.CommunityRatingOverall);
-				row.CreateCell(col++).SetCellValue(dto.CommunityRatingPerformance);
-				row.CreateCell(col++).SetCellValue(dto.CommunityRatingStory);
-				row.CreateCell(col++).SetCellValue(dto.PictureId);
-				row.CreateCell(col++).SetCellValue(dto.IsAbridged);
-				row.CreateCell(col++).SetCellValue(dto.DatePublished).CellStyle = dateStyle;
-				row.CreateCell(col++).SetCellValue(dto.CategoriesNames);
-				row.CreateCell(col++).SetCellValue(dto.MyRatingOverall);
-				row.CreateCell(col++).SetCellValue(dto.MyRatingPerformance);
-				row.CreateCell(col++).SetCellValue(dto.MyRatingStory);
-				row.CreateCell(col++).SetCellValue(dto.MyLibationTags);
-				row.CreateCell(col++).SetCellValue(dto.BookStatus);
-				row.CreateCell(col++).SetCellValue(dto.PdfStatus);
-				row.CreateCell(col++).SetCellValue(dto.ContentType);
-				row.CreateCell(col++).SetCellValue(dto.Language);
-				row.CreateCell(col++).SetCellValue(dto.LastDownloaded).CellStyle = dateStyle;
-				row.CreateCell(col++).SetCellValue(dto.LastDownloadedVersion);
-				row.CreateCell(col++).SetCellValue(dto.IsFinished);
-				row.CreateCell(col++).SetCellValue(dto.IsSpatial);
-				row.CreateCell(col++).SetCellValue(dto.LastDownloadedFileVersion);
-				row.CreateCell(col++).SetCellValue(dto.CodecString);
-				row.CreateCell(col++).SetCellValue(dto.SampleRate);
-				row.CreateCell(col++).SetCellValue(dto.ChannelCount);
-				row.CreateCell(col++).SetCellValue(dto.BitRate);
+				row.Cell(col++).Value = dto.Account;
+				row.Cell(col++).SetDate(dto.DateAdded, dateFormat);
+				row.Cell(col++).Value = dto.AudibleProductId;
+				row.Cell(col++).Value = dto.Locale;
+				row.Cell(col++).Value = dto.Title;
+				row.Cell(col++).Value = dto.Subtitle;
+				row.Cell(col++).Value = dto.AuthorNames;
+				row.Cell(col++).Value = dto.NarratorNames;
+				row.Cell(col++).Value = dto.LengthInMinutes;
+				row.Cell(col++).Value = dto.Description;
+				row.Cell(col++).Value = dto.Publisher;
+				row.Cell(col++).Value = dto.HasPdf;
+				row.Cell(col++).Value = dto.SeriesNames;
+				row.Cell(col++).Value = dto.SeriesOrder;
+				row.Cell(col++).Value = dto.CommunityRatingOverall;
+				row.Cell(col++).Value = dto.CommunityRatingPerformance;
+				row.Cell(col++).Value = dto.CommunityRatingStory;
+				row.Cell(col++).Value = dto.PictureId;
+				row.Cell(col++).Value = dto.IsAbridged;
+				row.Cell(col++).SetDate(dto.DatePublished, dateFormat);
+				row.Cell(col++).Value = dto.CategoriesNames;
+				row.Cell(col++).Value = dto.MyRatingOverall;
+				row.Cell(col++).Value = dto.MyRatingPerformance;
+				row.Cell(col++).Value = dto.MyRatingStory;
+				row.Cell(col++).Value = dto.MyLibationTags;
+				row.Cell(col++).Value = dto.BookStatus;
+				row.Cell(col++).Value = dto.PdfStatus;
+				row.Cell(col++).Value = dto.ContentType;
+				row.Cell(col++).Value = dto.Language;
+				row.Cell(col++).SetDate(dto.LastDownloaded, dateFormat);
+				row.Cell(col++).Value = dto.LastDownloadedVersion;
+				row.Cell(col++).Value = dto.IsFinished;
+				row.Cell(col++).Value = dto.IsSpatial;
+				row.Cell(col++).Value = dto.LastDownloadedFileVersion;
+				row.Cell(col++).Value = dto.CodecString;
+				row.Cell(col++).Value = dto.SampleRate;
+				row.Cell(col++).Value = dto.ChannelCount;
+				row.Cell(col++).Value = dto.BitRate;
 			}
 
-			using var fileData = new System.IO.FileStream(saveFilePath, System.IO.FileMode.Create);
-			workbook.Write(fileData);
+			workbook.SaveAs(saveFilePath);
 		}
 
-		private static NPOI.SS.UserModel.ICell SetCellValue(this NPOI.SS.UserModel.ICell cell, DateTime? nullableDate)
-			=> nullableDate.HasValue ? cell.SetCellValue(nullableDate.Value)
-			: cell.SetCellType(NPOI.SS.UserModel.CellType.Numeric);
-
-		private static NPOI.SS.UserModel.ICell SetCellValue(this NPOI.SS.UserModel.ICell cell, int? nullableInt)
-			=> nullableInt.HasValue ? cell.SetCellValue(nullableInt.Value)
-			: cell.SetCellType(NPOI.SS.UserModel.CellType.Numeric);
-
-		private static NPOI.SS.UserModel.ICell SetCellValue(this NPOI.SS.UserModel.ICell cell, float? nullableFloat)
-			=> nullableFloat.HasValue ? cell.SetCellValue(nullableFloat.Value)
-			: cell.SetCellType(NPOI.SS.UserModel.CellType.Numeric);
+		private static void SetDate(this IXLCell cell, DateTime? value, string dateFormat)
+		{
+			cell.Value = value;
+			cell.Style.DateFormat.Format = dateFormat;
+		}
 	}
 }

Source/ApplicationServices/RecordExporter.cs

@@ -1,10 +1,11 @@
 using AudibleApi.Common;
+using ClosedXML.Excel;
 using CsvHelper;
 using DataLayer;
 using Newtonsoft.Json.Linq;
-using NPOI.XSSF.UserModel;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 
 namespace ApplicationServices
@@ -16,19 +17,10 @@ namespace ApplicationServices
 			if (!records.Any())
 				return;
 
-			using var workbook = new XSSFWorkbook();
-			var sheet = workbook.CreateSheet("Records");
-
-			var detailSubtotalFont = workbook.CreateFont();
-			detailSubtotalFont.IsBold = true;
-
-			var detailSubtotalCellStyle = workbook.CreateCellStyle();
-			detailSubtotalCellStyle.SetFont(detailSubtotalFont);
+			using var workbook = new XLWorkbook();
+			var worksheet = workbook.AddWorksheet("Records");
 
 			// headers
-			var rowIndex = 0;
-			var row = sheet.CreateRow(rowIndex);
-
 			var columns = new List<string>
 			{
 				nameof(Type.Name),
@@ -49,56 +41,52 @@ namespace ApplicationServices
 			if (records.OfType<Clip>().Any())
 				columns.Add(nameof(Clip.Title));
 
-			var col = 0;
+			int rowIndex = 1, col = 1;
+			var headerRow = worksheet.Row(rowIndex++);
 			foreach (var c in columns)
 			{
-				var cell = row.CreateCell(col++);
-				cell.SetCellValue(c);
-				cell.CellStyle = detailSubtotalCellStyle;
+				var headerCell = headerRow.Cell(col++);
+				headerCell.Value = c;
+				headerCell.Style.Font.Bold = true;
 			}
 
-			var dateFormat = workbook.CreateDataFormat();
-			var dateStyle = workbook.CreateCellStyle();
-			dateStyle.DataFormat = dateFormat.GetFormat("MM/dd/yyyy HH:mm:ss");
+			var dateFormat = CultureInfo.CurrentCulture.DateTimeFormat.ShortDatePattern + " HH:mm:ss";
 
 			// Add data rows
 			foreach (var record in records)
 			{
-				col = 0;
+				col = 1;
+				var row = worksheet.Row(rowIndex++);
 
-				row = sheet.CreateRow(++rowIndex);
-
-				row.CreateCell(col++).SetCellValue(record.GetType().Name);
-
-				var dateCreatedCell = row.CreateCell(col++);
-				dateCreatedCell.CellStyle = dateStyle;
-				dateCreatedCell.SetCellValue(record.Created.DateTime);
-
-				row.CreateCell(col++).SetCellValue(record.Start.TotalMilliseconds);
+				row.Cell(col++).Value = record.GetType().Name;
+				row.Cell(col++).SetDate(record.Created.DateTime, dateFormat);
+				row.Cell(col++).Value = record.Start.TotalMilliseconds;
 
 				if (record is IAnnotation annotation)
 				{
-					row.CreateCell(col++).SetCellValue(annotation.AnnotationId);
 
-					var lastModifiedCell = row.CreateCell(col++);
-					lastModifiedCell.CellStyle = dateStyle;
-					lastModifiedCell.SetCellValue(annotation.LastModified.DateTime);
+					row.Cell(col++).Value = annotation.AnnotationId;
+					row.Cell(col++).SetDate(annotation.LastModified.DateTime, dateFormat);
 
 					if (annotation is IRangeAnnotation rangeAnnotation)
 					{
-						row.CreateCell(col++).SetCellValue(rangeAnnotation.End.TotalMilliseconds);
-						row.CreateCell(col++).SetCellValue(rangeAnnotation.Text);
+						row.Cell(col++).Value = rangeAnnotation.End.TotalMilliseconds;
+						row.Cell(col++).Value = rangeAnnotation.Text;
 
 						if (rangeAnnotation is Clip clip)
-							row.CreateCell(col++).SetCellValue(clip.Title);
+							row.Cell(col++).Value = clip.Title;
 					}
 				}
 			}
 
-			using var fileData = new System.IO.FileStream(saveFilePath, System.IO.FileMode.Create);
-			workbook.Write(fileData);
+			workbook.SaveAs(saveFilePath);
 		}
 
+		private static void SetDate(this IXLCell cell, DateTime? value, string dateFormat)
+		{
+			cell.Value = value;
+			cell.Style.DateFormat.Format = dateFormat;
+		}
 		public static void ToJson(string saveFilePath, LibraryBook libraryBook, IEnumerable<IRecord> records)
 		{
 			if (!records.Any())

Source/AudibleUtilities/AccountsSettings.cs

@@ -6,6 +6,7 @@ using AudibleApi.Authorization;
 using Dinah.Core;
 using Newtonsoft.Json;
 
+#nullable enable
 namespace AudibleUtilities
 {
 	// 'AccountsSettings' is intentionally NOT IEnumerable<> so that properties can be added/extended
@@ -14,8 +15,8 @@ namespace AudibleUtilities
 	//   JSON :  Array (properties on the collection will not be serialized)
 	public class AccountsSettings : IUpdatable
 	{
-		public event EventHandler Updated;
-		private void update(object sender = null, EventArgs e = null)
+		public event EventHandler? Updated;
+		private void update(object? sender = null, EventArgs? e = null)
 		{
 			foreach (var account in Accounts)
 				validate(account);
@@ -48,9 +49,9 @@ namespace AudibleUtilities
 			}
 		}
 
-		private string _cdm;
+		private string? _cdm;
 		[JsonProperty]
-		public string Cdm
+		public string? Cdm
 		{
 			get => _cdm;
 			set
@@ -68,7 +69,7 @@ namespace AudibleUtilities
 		#endregion
 
 		#region de/serialize
-		public static AccountsSettings FromJson(string json)
+		public static AccountsSettings? FromJson(string json)
 			=> JsonConvert.DeserializeObject<AccountsSettings>(json, Identity.GetJsonSerializerSettings());
 
 		public string ToJson(Formatting formatting = Formatting.Indented)
@@ -107,7 +108,7 @@ namespace AudibleUtilities
 			account.Updated += update;
 		}
 
-		public Account GetAccount(string accountId, string locale)
+		public Account? GetAccount(string accountId, string? locale)
 		{
 			if (locale is null)
 				return null;

Source/AudibleUtilities/AudibleUtilities.csproj

@@ -5,8 +5,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="AudibleApi" Version="9.4.5.1" />
-    <PackageReference Include="Google.Protobuf" Version="3.32.0" />
+    <PackageReference Include="AudibleApi" Version="9.5.0.1" />
+    <PackageReference Include="Google.Protobuf" Version="3.33.0" />
   </ItemGroup>
 
   <ItemGroup>

Source/DataLayer.Postgres/DataLayer.Postgres.csproj

@@ -0,0 +1,42 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
+    <OutputType>Library</OutputType>
+  </PropertyGroup>
+  
+  <ItemGroup>
+    <PackageReference Include="Dinah.Core" Version="9.0.3.1" />
+    <PackageReference Include="Dinah.EntityFrameworkCore" Version="9.0.0.1" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.10">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.10">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+		<DebugType>embedded</DebugType>
+	</PropertyGroup>
+
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+		<DebugType>embedded</DebugType>
+	</PropertyGroup>
+
+	<ItemGroup>
+	  <ProjectReference Include="..\DataLayer\DataLayer.csproj" />
+	</ItemGroup>
+
+	<ItemGroup>
+	  <Folder Include="Migrations\" />
+	</ItemGroup>
+
+</Project>

Source/DataLayer.Postgres/Migrations/20251027224441_InitialPostgres.Designer.cs

@@ -0,0 +1,494 @@
+// <auto-generated />
+using System;
+using DataLayer;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace DataLayer.Postgres.Migrations
+{
+    [DbContext(typeof(LibationContext))]
+    [Migration("20251027224441_InitialPostgres")]
+    partial class InitialPostgres
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.8")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("CategoryCategoryLadder", b =>
+                {
+                    b.Property<int>("_categoriesCategoryId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("_categoryLaddersCategoryLadderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("_categoriesCategoryId", "_categoryLaddersCategoryLadderId");
+
+                    b.HasIndex("_categoryLaddersCategoryLadderId");
+
+                    b.ToTable("CategoryCategoryLadder");
+                });
+
+            modelBuilder.Entity("DataLayer.Book", b =>
+                {
+                    b.Property<int>("BookId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("BookId"));
+
+                    b.Property<string>("AudibleProductId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ContentType")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("DatePublished")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsAbridged")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsSpatial")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Language")
+                        .HasColumnType("text");
+
+                    b.Property<int>("LengthInMinutes")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Locale")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PictureId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PictureLarge")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Subtitle")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.HasKey("BookId");
+
+                    b.HasIndex("AudibleProductId");
+
+                    b.ToTable("Books");
+                });
+
+            modelBuilder.Entity("DataLayer.BookCategory", b =>
+                {
+                    b.Property<int>("BookId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("CategoryLadderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("BookId", "CategoryLadderId");
+
+                    b.HasIndex("BookId");
+
+                    b.HasIndex("CategoryLadderId");
+
+                    b.ToTable("BookCategory");
+                });
+
+            modelBuilder.Entity("DataLayer.BookContributor", b =>
+                {
+                    b.Property<int>("BookId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ContributorId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("integer");
+
+                    b.Property<byte>("Order")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("BookId", "ContributorId", "Role");
+
+                    b.HasIndex("BookId");
+
+                    b.HasIndex("ContributorId");
+
+                    b.ToTable("BookContributor");
+                });
+
+            modelBuilder.Entity("DataLayer.Category", b =>
+                {
+                    b.Property<int>("CategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("CategoryId"));
+
+                    b.Property<string>("AudibleCategoryId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.HasKey("CategoryId");
+
+                    b.HasIndex("AudibleCategoryId");
+
+                    b.ToTable("Categories");
+                });
+
+            modelBuilder.Entity("DataLayer.CategoryLadder", b =>
+                {
+                    b.Property<int>("CategoryLadderId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("CategoryLadderId"));
+
+                    b.HasKey("CategoryLadderId");
+
+                    b.ToTable("CategoryLadders");
+                });
+
+            modelBuilder.Entity("DataLayer.Contributor", b =>
+                {
+                    b.Property<int>("ContributorId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("ContributorId"));
+
+                    b.Property<string>("AudibleContributorId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.HasKey("ContributorId");
+
+                    b.HasIndex("Name");
+
+                    b.ToTable("Contributors");
+
+                    b.HasData(
+                        new
+                        {
+                            ContributorId = -1,
+                            Name = ""
+                        });
+                });
+
+            modelBuilder.Entity("DataLayer.LibraryBook", b =>
+                {
+                    b.Property<int>("BookId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("AbsentFromLastScan")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Account")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<DateTime?>("IncludedUntil")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("BookId");
+
+                    b.ToTable("LibraryBooks");
+                });
+
+            modelBuilder.Entity("DataLayer.Series", b =>
+                {
+                    b.Property<int>("SeriesId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("SeriesId"));
+
+                    b.Property<string>("AudibleSeriesId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.HasKey("SeriesId");
+
+                    b.HasIndex("AudibleSeriesId");
+
+                    b.ToTable("Series");
+                });
+
+            modelBuilder.Entity("DataLayer.SeriesBook", b =>
+                {
+                    b.Property<int>("SeriesId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("BookId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Order")
+                        .HasColumnType("text");
+
+                    b.HasKey("SeriesId", "BookId");
+
+                    b.HasIndex("BookId");
+
+                    b.HasIndex("SeriesId");
+
+                    b.ToTable("SeriesBook");
+                });
+
+            modelBuilder.Entity("CategoryCategoryLadder", b =>
+                {
+                    b.HasOne("DataLayer.Category", null)
+                        .WithMany()
+                        .HasForeignKey("_categoriesCategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DataLayer.CategoryLadder", null)
+                        .WithMany()
+                        .HasForeignKey("_categoryLaddersCategoryLadderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("DataLayer.Book", b =>
+                {
+                    b.OwnsOne("DataLayer.Rating", "Rating", b1 =>
+                        {
+                            b1.Property<int>("BookId")
+                                .HasColumnType("integer");
+
+                            b1.Property<float>("OverallRating")
+                                .HasColumnType("real");
+
+                            b1.Property<float>("PerformanceRating")
+                                .HasColumnType("real");
+
+                            b1.Property<float>("StoryRating")
+                                .HasColumnType("real");
+
+                            b1.HasKey("BookId");
+
+                            b1.ToTable("Books");
+
+                            b1.WithOwner()
+                                .HasForeignKey("BookId");
+                        });
+
+                    b.OwnsMany("DataLayer.Supplement", "Supplements", b1 =>
+                        {
+                            b1.Property<int>("SupplementId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("integer");
+
+                            NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b1.Property<int>("SupplementId"));
+
+                            b1.Property<int>("BookId")
+                                .HasColumnType("integer");
+
+                            b1.Property<string>("Url")
+                                .HasColumnType("text");
+
+                            b1.HasKey("SupplementId");
+
+                            b1.HasIndex("BookId");
+
+                            b1.ToTable("Supplement");
+
+                            b1.WithOwner("Book")
+                                .HasForeignKey("BookId");
+
+                            b1.Navigation("Book");
+                        });
+
+                    b.OwnsOne("DataLayer.UserDefinedItem", "UserDefinedItem", b1 =>
+                        {
+                            b1.Property<int>("BookId")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("BookStatus")
+                                .HasColumnType("integer");
+
+                            b1.Property<bool>("IsFinished")
+                                .HasColumnType("boolean");
+
+                            b1.Property<DateTime?>("LastDownloaded")
+                                .HasColumnType("timestamp without time zone");
+
+                            b1.Property<string>("LastDownloadedFileVersion")
+                                .HasColumnType("text");
+
+                            b1.Property<long?>("LastDownloadedFormat")
+                                .HasColumnType("bigint");
+
+                            b1.Property<string>("LastDownloadedVersion")
+                                .HasColumnType("text");
+
+                            b1.Property<int?>("PdfStatus")
+                                .HasColumnType("integer");
+
+                            b1.Property<string>("Tags")
+                                .HasColumnType("text");
+
+                            b1.HasKey("BookId");
+
+                            b1.ToTable("UserDefinedItem", (string)null);
+
+                            b1.WithOwner("Book")
+                                .HasForeignKey("BookId");
+
+                            b1.OwnsOne("DataLayer.Rating", "Rating", b2 =>
+                                {
+                                    b2.Property<int>("UserDefinedItemBookId")
+                                        .HasColumnType("integer");
+
+                                    b2.Property<float>("OverallRating")
+                                        .HasColumnType("real");
+
+                                    b2.Property<float>("PerformanceRating")
+                                        .HasColumnType("real");
+
+                                    b2.Property<float>("StoryRating")
+                                        .HasColumnType("real");
+
+                                    b2.HasKey("UserDefinedItemBookId");
+
+                                    b2.ToTable("UserDefinedItem");
+
+                                    b2.WithOwner()
+                                        .HasForeignKey("UserDefinedItemBookId");
+                                });
+
+                            b1.Navigation("Book");
+
+                            b1.Navigation("Rating");
+                        });
+
+                    b.Navigation("Rating");
+
+                    b.Navigation("Supplements");
+
+                    b.Navigation("UserDefinedItem");
+                });
+
+            modelBuilder.Entity("DataLayer.BookCategory", b =>
+                {
+                    b.HasOne("DataLayer.Book", "Book")
+                        .WithMany("CategoriesLink")
+                        .HasForeignKey("BookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DataLayer.CategoryLadder", "CategoryLadder")
+                        .WithMany("BooksLink")
+                        .HasForeignKey("CategoryLadderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Book");
+
+                    b.Navigation("CategoryLadder");
+                });
+
+            modelBuilder.Entity("DataLayer.BookContributor", b =>
+                {
+                    b.HasOne("DataLayer.Book", "Book")
+                        .WithMany("ContributorsLink")
+                        .HasForeignKey("BookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DataLayer.Contributor", "Contributor")
+                        .WithMany("BooksLink")
+                        .HasForeignKey("ContributorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Book");
+
+                    b.Navigation("Contributor");
+                });
+
+            modelBuilder.Entity("DataLayer.LibraryBook", b =>
+                {
+                    b.HasOne("DataLayer.Book", "Book")
+                        .WithOne()
+                        .HasForeignKey("DataLayer.LibraryBook", "BookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Book");
+                });
+
+            modelBuilder.Entity("DataLayer.SeriesBook", b =>
+                {
+                    b.HasOne("DataLayer.Book", "Book")
+                        .WithMany("SeriesLink")
+                        .HasForeignKey("BookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DataLayer.Series", "Series")
+                        .WithMany("BooksLink")
+                        .HasForeignKey("SeriesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Book");
+
+                    b.Navigation("Series");
+                });
+
+            modelBuilder.Entity("DataLayer.Book", b =>
+                {
+                    b.Navigation("CategoriesLink");
+
+                    b.Navigation("ContributorsLink");
+
+                    b.Navigation("SeriesLink");
+                });
+
+            modelBuilder.Entity("DataLayer.CategoryLadder", b =>
+                {
+                    b.Navigation("BooksLink");
+                });
+
+            modelBuilder.Entity("DataLayer.Contributor", b =>
+                {
+                    b.Navigation("BooksLink");
+                });
+
+            modelBuilder.Entity("DataLayer.Series", b =>
+                {
+                    b.Navigation("BooksLink");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Source/DataLayer.Postgres/Migrations/20251027224441_InitialPostgres.cs

@@ -0,0 +1,372 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace DataLayer.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class InitialPostgres : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Books",
+                columns: table => new
+                {
+                    BookId = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    AudibleProductId = table.Column<string>(type: "text", nullable: true),
+                    Title = table.Column<string>(type: "text", nullable: true),
+                    Subtitle = table.Column<string>(type: "text", nullable: true),
+                    Description = table.Column<string>(type: "text", nullable: true),
+                    LengthInMinutes = table.Column<int>(type: "integer", nullable: false),
+                    ContentType = table.Column<int>(type: "integer", nullable: false),
+                    Locale = table.Column<string>(type: "text", nullable: true),
+                    PictureId = table.Column<string>(type: "text", nullable: true),
+                    PictureLarge = table.Column<string>(type: "text", nullable: true),
+                    IsAbridged = table.Column<bool>(type: "boolean", nullable: false),
+                    IsSpatial = table.Column<bool>(type: "boolean", nullable: false),
+                    DatePublished = table.Column<DateTime>(type: "timestamp without time zone", nullable: true),
+                    Language = table.Column<string>(type: "text", nullable: true),
+                    Rating_OverallRating = table.Column<float>(type: "real", nullable: true),
+                    Rating_PerformanceRating = table.Column<float>(type: "real", nullable: true),
+                    Rating_StoryRating = table.Column<float>(type: "real", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Books", x => x.BookId);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Categories",
+                columns: table => new
+                {
+                    CategoryId = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    AudibleCategoryId = table.Column<string>(type: "text", nullable: true),
+                    Name = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Categories", x => x.CategoryId);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "CategoryLadders",
+                columns: table => new
+                {
+                    CategoryLadderId = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_CategoryLadders", x => x.CategoryLadderId);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Contributors",
+                columns: table => new
+                {
+                    ContributorId = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Name = table.Column<string>(type: "text", nullable: true),
+                    AudibleContributorId = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Contributors", x => x.ContributorId);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Series",
+                columns: table => new
+                {
+                    SeriesId = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    AudibleSeriesId = table.Column<string>(type: "text", nullable: true),
+                    Name = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Series", x => x.SeriesId);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "LibraryBooks",
+                columns: table => new
+                {
+                    BookId = table.Column<int>(type: "integer", nullable: false),
+                    DateAdded = table.Column<DateTime>(type: "timestamp without time zone", nullable: false),
+                    Account = table.Column<string>(type: "text", nullable: true),
+                    IsDeleted = table.Column<bool>(type: "boolean", nullable: false),
+                    AbsentFromLastScan = table.Column<bool>(type: "boolean", nullable: false),
+                    IncludedUntil = table.Column<DateTime>(type: "timestamp without time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_LibraryBooks", x => x.BookId);
+                    table.ForeignKey(
+                        name: "FK_LibraryBooks_Books_BookId",
+                        column: x => x.BookId,
+                        principalTable: "Books",
+                        principalColumn: "BookId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Supplement",
+                columns: table => new
+                {
+                    SupplementId = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    BookId = table.Column<int>(type: "integer", nullable: false),
+                    Url = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Supplement", x => x.SupplementId);
+                    table.ForeignKey(
+                        name: "FK_Supplement_Books_BookId",
+                        column: x => x.BookId,
+                        principalTable: "Books",
+                        principalColumn: "BookId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "UserDefinedItem",
+                columns: table => new
+                {
+                    BookId = table.Column<int>(type: "integer", nullable: false),
+                    LastDownloaded = table.Column<DateTime>(type: "timestamp without time zone", nullable: true),
+                    LastDownloadedVersion = table.Column<string>(type: "text", nullable: true),
+                    LastDownloadedFormat = table.Column<long>(type: "bigint", nullable: true),
+                    LastDownloadedFileVersion = table.Column<string>(type: "text", nullable: true),
+                    Tags = table.Column<string>(type: "text", nullable: true),
+                    Rating_OverallRating = table.Column<float>(type: "real", nullable: true),
+                    Rating_PerformanceRating = table.Column<float>(type: "real", nullable: true),
+                    Rating_StoryRating = table.Column<float>(type: "real", nullable: true),
+                    BookStatus = table.Column<int>(type: "integer", nullable: false),
+                    PdfStatus = table.Column<int>(type: "integer", nullable: true),
+                    IsFinished = table.Column<bool>(type: "boolean", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_UserDefinedItem", x => x.BookId);
+                    table.ForeignKey(
+                        name: "FK_UserDefinedItem_Books_BookId",
+                        column: x => x.BookId,
+                        principalTable: "Books",
+                        principalColumn: "BookId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "BookCategory",
+                columns: table => new
+                {
+                    BookId = table.Column<int>(type: "integer", nullable: false),
+                    CategoryLadderId = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_BookCategory", x => new { x.BookId, x.CategoryLadderId });
+                    table.ForeignKey(
+                        name: "FK_BookCategory_Books_BookId",
+                        column: x => x.BookId,
+                        principalTable: "Books",
+                        principalColumn: "BookId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_BookCategory_CategoryLadders_CategoryLadderId",
+                        column: x => x.CategoryLadderId,
+                        principalTable: "CategoryLadders",
+                        principalColumn: "CategoryLadderId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "CategoryCategoryLadder",
+                columns: table => new
+                {
+                    _categoriesCategoryId = table.Column<int>(type: "integer", nullable: false),
+                    _categoryLaddersCategoryLadderId = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_CategoryCategoryLadder", x => new { x._categoriesCategoryId, x._categoryLaddersCategoryLadderId });
+                    table.ForeignKey(
+                        name: "FK_CategoryCategoryLadder_Categories__categoriesCategoryId",
+                        column: x => x._categoriesCategoryId,
+                        principalTable: "Categories",
+                        principalColumn: "CategoryId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_CategoryCategoryLadder_CategoryLadders__categoryLaddersCate~",
+                        column: x => x._categoryLaddersCategoryLadderId,
+                        principalTable: "CategoryLadders",
+                        principalColumn: "CategoryLadderId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "BookContributor",
+                columns: table => new
+                {
+                    BookId = table.Column<int>(type: "integer", nullable: false),
+                    ContributorId = table.Column<int>(type: "integer", nullable: false),
+                    Role = table.Column<int>(type: "integer", nullable: false),
+                    Order = table.Column<byte>(type: "smallint", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_BookContributor", x => new { x.BookId, x.ContributorId, x.Role });
+                    table.ForeignKey(
+                        name: "FK_BookContributor_Books_BookId",
+                        column: x => x.BookId,
+                        principalTable: "Books",
+                        principalColumn: "BookId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_BookContributor_Contributors_ContributorId",
+                        column: x => x.ContributorId,
+                        principalTable: "Contributors",
+                        principalColumn: "ContributorId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "SeriesBook",
+                columns: table => new
+                {
+                    SeriesId = table.Column<int>(type: "integer", nullable: false),
+                    BookId = table.Column<int>(type: "integer", nullable: false),
+                    Order = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_SeriesBook", x => new { x.SeriesId, x.BookId });
+                    table.ForeignKey(
+                        name: "FK_SeriesBook_Books_BookId",
+                        column: x => x.BookId,
+                        principalTable: "Books",
+                        principalColumn: "BookId",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_SeriesBook_Series_SeriesId",
+                        column: x => x.SeriesId,
+                        principalTable: "Series",
+                        principalColumn: "SeriesId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.InsertData(
+                table: "Contributors",
+                columns: new[] { "ContributorId", "AudibleContributorId", "Name" },
+                values: new object[] { -1, null, "" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_BookCategory_BookId",
+                table: "BookCategory",
+                column: "BookId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_BookCategory_CategoryLadderId",
+                table: "BookCategory",
+                column: "CategoryLadderId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_BookContributor_BookId",
+                table: "BookContributor",
+                column: "BookId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_BookContributor_ContributorId",
+                table: "BookContributor",
+                column: "ContributorId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Books_AudibleProductId",
+                table: "Books",
+                column: "AudibleProductId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Categories_AudibleCategoryId",
+                table: "Categories",
+                column: "AudibleCategoryId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_CategoryCategoryLadder__categoryLaddersCategoryLadderId",
+                table: "CategoryCategoryLadder",
+                column: "_categoryLaddersCategoryLadderId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Contributors_Name",
+                table: "Contributors",
+                column: "Name");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Series_AudibleSeriesId",
+                table: "Series",
+                column: "AudibleSeriesId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_SeriesBook_BookId",
+                table: "SeriesBook",
+                column: "BookId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_SeriesBook_SeriesId",
+                table: "SeriesBook",
+                column: "SeriesId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Supplement_BookId",
+                table: "Supplement",
+                column: "BookId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "BookCategory");
+
+            migrationBuilder.DropTable(
+                name: "BookContributor");
+
+            migrationBuilder.DropTable(
+                name: "CategoryCategoryLadder");
+
+            migrationBuilder.DropTable(
+                name: "LibraryBooks");
+
+            migrationBuilder.DropTable(
+                name: "SeriesBook");
+
+            migrationBuilder.DropTable(
+                name: "Supplement");
+
+            migrationBuilder.DropTable(
+                name: "UserDefinedItem");
+
+            migrationBuilder.DropTable(
+                name: "Contributors");
+
+            migrationBuilder.DropTable(
+                name: "Categories");
+
+            migrationBuilder.DropTable(
+                name: "CategoryLadders");
+
+            migrationBuilder.DropTable(
+                name: "Series");
+
+            migrationBuilder.DropTable(
+                name: "Books");
+        }
+    }
+}

Source/DataLayer.Postgres/Migrations/LibationContextModelSnapshot.cs

@@ -0,0 +1,491 @@
+// <auto-generated />
+using System;
+using DataLayer;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace DataLayer.Postgres.Migrations
+{
+    [DbContext(typeof(LibationContext))]
+    partial class LibationContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.8")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("CategoryCategoryLadder", b =>
+                {
+                    b.Property<int>("_categoriesCategoryId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("_categoryLaddersCategoryLadderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("_categoriesCategoryId", "_categoryLaddersCategoryLadderId");
+
+                    b.HasIndex("_categoryLaddersCategoryLadderId");
+
+                    b.ToTable("CategoryCategoryLadder");
+                });
+
+            modelBuilder.Entity("DataLayer.Book", b =>
+                {
+                    b.Property<int>("BookId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("BookId"));
+
+                    b.Property<string>("AudibleProductId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ContentType")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("DatePublished")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsAbridged")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsSpatial")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Language")
+                        .HasColumnType("text");
+
+                    b.Property<int>("LengthInMinutes")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Locale")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PictureId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PictureLarge")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Subtitle")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.HasKey("BookId");
+
+                    b.HasIndex("AudibleProductId");
+
+                    b.ToTable("Books");
+                });
+
+            modelBuilder.Entity("DataLayer.BookCategory", b =>
+                {
+                    b.Property<int>("BookId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("CategoryLadderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("BookId", "CategoryLadderId");
+
+                    b.HasIndex("BookId");
+
+                    b.HasIndex("CategoryLadderId");
+
+                    b.ToTable("BookCategory");
+                });
+
+            modelBuilder.Entity("DataLayer.BookContributor", b =>
+                {
+                    b.Property<int>("BookId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ContributorId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("integer");
+
+                    b.Property<byte>("Order")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("BookId", "ContributorId", "Role");
+
+                    b.HasIndex("BookId");
+
+                    b.HasIndex("ContributorId");
+
+                    b.ToTable("BookContributor");
+                });
+
+            modelBuilder.Entity("DataLayer.Category", b =>
+                {
+                    b.Property<int>("CategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("CategoryId"));
+
+                    b.Property<string>("AudibleCategoryId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.HasKey("CategoryId");
+
+                    b.HasIndex("AudibleCategoryId");
+
+                    b.ToTable("Categories");
+                });
+
+            modelBuilder.Entity("DataLayer.CategoryLadder", b =>
+                {
+                    b.Property<int>("CategoryLadderId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("CategoryLadderId"));
+
+                    b.HasKey("CategoryLadderId");
+
+                    b.ToTable("CategoryLadders");
+                });
+
+            modelBuilder.Entity("DataLayer.Contributor", b =>
+                {
+                    b.Property<int>("ContributorId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("ContributorId"));
+
+                    b.Property<string>("AudibleContributorId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.HasKey("ContributorId");
+
+                    b.HasIndex("Name");
+
+                    b.ToTable("Contributors");
+
+                    b.HasData(
+                        new
+                        {
+                            ContributorId = -1,
+                            Name = ""
+                        });
+                });
+
+            modelBuilder.Entity("DataLayer.LibraryBook", b =>
+                {
+                    b.Property<int>("BookId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("AbsentFromLastScan")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Account")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<DateTime?>("IncludedUntil")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("BookId");
+
+                    b.ToTable("LibraryBooks");
+                });
+
+            modelBuilder.Entity("DataLayer.Series", b =>
+                {
+                    b.Property<int>("SeriesId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("SeriesId"));
+
+                    b.Property<string>("AudibleSeriesId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.HasKey("SeriesId");
+
+                    b.HasIndex("AudibleSeriesId");
+
+                    b.ToTable("Series");
+                });
+
+            modelBuilder.Entity("DataLayer.SeriesBook", b =>
+                {
+                    b.Property<int>("SeriesId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("BookId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Order")
+                        .HasColumnType("text");
+
+                    b.HasKey("SeriesId", "BookId");
+
+                    b.HasIndex("BookId");
+
+                    b.HasIndex("SeriesId");
+
+                    b.ToTable("SeriesBook");
+                });
+
+            modelBuilder.Entity("CategoryCategoryLadder", b =>
+                {
+                    b.HasOne("DataLayer.Category", null)
+                        .WithMany()
+                        .HasForeignKey("_categoriesCategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DataLayer.CategoryLadder", null)
+                        .WithMany()
+                        .HasForeignKey("_categoryLaddersCategoryLadderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("DataLayer.Book", b =>
+                {
+                    b.OwnsOne("DataLayer.Rating", "Rating", b1 =>
+                        {
+                            b1.Property<int>("BookId")
+                                .HasColumnType("integer");
+
+                            b1.Property<float>("OverallRating")
+                                .HasColumnType("real");
+
+                            b1.Property<float>("PerformanceRating")
+                                .HasColumnType("real");
+
+                            b1.Property<float>("StoryRating")
+                                .HasColumnType("real");
+
+                            b1.HasKey("BookId");
+
+                            b1.ToTable("Books");
+
+                            b1.WithOwner()
+                                .HasForeignKey("BookId");
+                        });
+
+                    b.OwnsMany("DataLayer.Supplement", "Supplements", b1 =>
+                        {
+                            b1.Property<int>("SupplementId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("integer");
+
+                            NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b1.Property<int>("SupplementId"));
+
+                            b1.Property<int>("BookId")
+                                .HasColumnType("integer");
+
+                            b1.Property<string>("Url")
+                                .HasColumnType("text");
+
+                            b1.HasKey("SupplementId");
+
+                            b1.HasIndex("BookId");
+
+                            b1.ToTable("Supplement");
+
+                            b1.WithOwner("Book")
+                                .HasForeignKey("BookId");
+
+                            b1.Navigation("Book");
+                        });
+
+                    b.OwnsOne("DataLayer.UserDefinedItem", "UserDefinedItem", b1 =>
+                        {
+                            b1.Property<int>("BookId")
+                                .HasColumnType("integer");
+
+                            b1.Property<int>("BookStatus")
+                                .HasColumnType("integer");
+
+                            b1.Property<bool>("IsFinished")
+                                .HasColumnType("boolean");
+
+                            b1.Property<DateTime?>("LastDownloaded")
+                                .HasColumnType("timestamp without time zone");
+
+                            b1.Property<string>("LastDownloadedFileVersion")
+                                .HasColumnType("text");
+
+                            b1.Property<long?>("LastDownloadedFormat")
+                                .HasColumnType("bigint");
+
+                            b1.Property<string>("LastDownloadedVersion")
+                                .HasColumnType("text");
+
+                            b1.Property<int?>("PdfStatus")
+                                .HasColumnType("integer");
+
+                            b1.Property<string>("Tags")
+                                .HasColumnType("text");
+
+                            b1.HasKey("BookId");
+
+                            b1.ToTable("UserDefinedItem", (string)null);
+
+                            b1.WithOwner("Book")
+                                .HasForeignKey("BookId");
+
+                            b1.OwnsOne("DataLayer.Rating", "Rating", b2 =>
+                                {
+                                    b2.Property<int>("UserDefinedItemBookId")
+                                        .HasColumnType("integer");
+
+                                    b2.Property<float>("OverallRating")
+                                        .HasColumnType("real");
+
+                                    b2.Property<float>("PerformanceRating")
+                                        .HasColumnType("real");
+
+                                    b2.Property<float>("StoryRating")
+                                        .HasColumnType("real");
+
+                                    b2.HasKey("UserDefinedItemBookId");
+
+                                    b2.ToTable("UserDefinedItem");
+
+                                    b2.WithOwner()
+                                        .HasForeignKey("UserDefinedItemBookId");
+                                });
+
+                            b1.Navigation("Book");
+
+                            b1.Navigation("Rating");
+                        });
+
+                    b.Navigation("Rating");
+
+                    b.Navigation("Supplements");
+
+                    b.Navigation("UserDefinedItem");
+                });
+
+            modelBuilder.Entity("DataLayer.BookCategory", b =>
+                {
+                    b.HasOne("DataLayer.Book", "Book")
+                        .WithMany("CategoriesLink")
+                        .HasForeignKey("BookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DataLayer.CategoryLadder", "CategoryLadder")
+                        .WithMany("BooksLink")
+                        .HasForeignKey("CategoryLadderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Book");
+
+                    b.Navigation("CategoryLadder");
+                });
+
+            modelBuilder.Entity("DataLayer.BookContributor", b =>
+                {
+                    b.HasOne("DataLayer.Book", "Book")
+                        .WithMany("ContributorsLink")
+                        .HasForeignKey("BookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DataLayer.Contributor", "Contributor")
+                        .WithMany("BooksLink")
+                        .HasForeignKey("ContributorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Book");
+
+                    b.Navigation("Contributor");
+                });
+
+            modelBuilder.Entity("DataLayer.LibraryBook", b =>
+                {
+                    b.HasOne("DataLayer.Book", "Book")
+                        .WithOne()
+                        .HasForeignKey("DataLayer.LibraryBook", "BookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Book");
+                });
+
+            modelBuilder.Entity("DataLayer.SeriesBook", b =>
+                {
+                    b.HasOne("DataLayer.Book", "Book")
+                        .WithMany("SeriesLink")
+                        .HasForeignKey("BookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DataLayer.Series", "Series")
+                        .WithMany("BooksLink")
+                        .HasForeignKey("SeriesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Book");
+
+                    b.Navigation("Series");
+                });
+
+            modelBuilder.Entity("DataLayer.Book", b =>
+                {
+                    b.Navigation("CategoriesLink");
+
+                    b.Navigation("ContributorsLink");
+
+                    b.Navigation("SeriesLink");
+                });
+
+            modelBuilder.Entity("DataLayer.CategoryLadder", b =>
+                {
+                    b.Navigation("BooksLink");
+                });
+
+            modelBuilder.Entity("DataLayer.Contributor", b =>
+                {
+                    b.Navigation("BooksLink");
+                });
+
+            modelBuilder.Entity("DataLayer.Series", b =>
+                {
+                    b.Navigation("BooksLink");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Source/DataLayer.Postgres/PostgresContextFactory.cs

@@ -0,0 +1,12 @@
+using Microsoft.EntityFrameworkCore.Design;
+
+namespace DataLayer.Postgres
+{
+    public class PostgresContextFactory : IDesignTimeDbContextFactory<LibationContext>
+    {
+        public LibationContext CreateDbContext(string[] args)
+        {
+            return LibationContextFactory.CreatePostgres(string.Empty);
+        }
+    }
+}

Source/DataLayer.Sqlite/DataLayer.Sqlite.csproj

@@ -0,0 +1,38 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
+    <OutputType>Library</OutputType>
+  </PropertyGroup>
+  
+  <ItemGroup>
+    <PackageReference Include="Dinah.Core" Version="9.0.3.1" />
+    <PackageReference Include="Dinah.EntityFrameworkCore" Version="9.0.0.1" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.10">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.0.10" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.10">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+		<DebugType>embedded</DebugType>
+	</PropertyGroup>
+
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+		<DebugType>embedded</DebugType>
+	</PropertyGroup>
+
+	<ItemGroup>
+	  <ProjectReference Include="..\DataLayer\DataLayer.csproj" />
+	</ItemGroup>
+
+</Project>

Source/DataLayer.Sqlite/SqliteContextFactory.cs

@@ -0,0 +1,12 @@
+using Microsoft.EntityFrameworkCore.Design;
+
+namespace DataLayer.Postgres
+{
+    public class SqliteContextFactory : IDesignTimeDbContextFactory<LibationContext>
+    {
+        public LibationContext CreateDbContext(string[] args)
+        {
+            return LibationContextFactory.CreateSqlite(string.Empty);
+        }
+    }
+}

Source/DataLayer/DataLayer.csproj

@@ -12,16 +12,23 @@
   <ItemGroup>
     <PackageReference Include="Dinah.Core" Version="9.0.3.1" />
     <PackageReference Include="Dinah.EntityFrameworkCore" Version="9.0.0.1" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.8">
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.0.10" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.10">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.0.8" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.8">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.10">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
   </ItemGroup>
+  
+  <ItemGroup>
+    <None Update="migrate.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
 
 	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
 		<DebugType>embedded</DebugType>
@@ -30,11 +37,5 @@
 	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
 		<DebugType>embedded</DebugType>
 	</PropertyGroup>
-  
-  <ItemGroup>
-    <None Update="migrate.json">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
 
 </Project>

Source/DataLayer/EfClasses/Contributor.cs

@@ -45,5 +45,7 @@ namespace DataLayer
 		public override string ToString() => Name;
 		public void SetAudibleContributorId(string audibleContributorId)
 			=> AudibleContributorId = audibleContributorId;
-	}
+
+        public bool IsEmpty => ContributorId == -1;
+    }
 }

Source/DataLayer/LibationContext.cs

@@ -39,15 +39,8 @@ namespace DataLayer
             ObjectDisposed?.Invoke(this, EventArgs.Empty);
         }
 
-        public static LibationContext Create(string connectionString)
-        {
-            var factory = new LibationContextFactory();
-            var context = factory.Create(connectionString);
-            return context;
-        }
-
         // see DesignTimeDbContextFactoryBase for info about ctors and connection strings/OnConfiguring()
-        internal LibationContext(DbContextOptions options) : base(options) { }
+        public LibationContext(DbContextOptions options) : base(options) { }
 
         // typically only called once per execution; NOT once per instantiation
         protected override void OnModelCreating(ModelBuilder modelBuilder)

Source/DataLayer/LibationContextFactory.cs

@@ -1,14 +1,41 @@
-using Dinah.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Diagnostics;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure;
+using System;
 
 namespace DataLayer
 {
-    public class LibationContextFactory : DesignTimeDbContextFactoryBase<LibationContext>
+    public class LibationContextFactory
     {
-        protected override LibationContext CreateNewInstance(DbContextOptions<LibationContext> options) => new LibationContext(options);
-        protected override void UseDatabaseEngine(DbContextOptionsBuilder optionsBuilder, string connectionString)
-            => optionsBuilder.ConfigureWarnings(w => w.Ignore(RelationalEventId.PendingModelChangesWarning))
-            .UseSqlite(connectionString, ob => ob.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery));
+        public static void ConfigureOptions(NpgsqlDbContextOptionsBuilder options)
+        {
+            AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
+            options.MigrationsAssembly("DataLayer.Postgres");
+            options.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery);
+        }
+
+        public static LibationContext CreatePostgres(string connectionString)
+        {
+            var options = new DbContextOptionsBuilder<LibationContext>();
+
+            options.UseNpgsql(connectionString, ConfigureOptions);
+
+            return new LibationContext(options.Options);
+        }
+
+        public static LibationContext CreateSqlite(string connectionString)
+        {
+            var options = new DbContextOptionsBuilder<LibationContext>();
+
+            options
+                .ConfigureWarnings(w => w.Ignore(RelationalEventId.PendingModelChangesWarning))
+                .UseSqlite(connectionString, options =>
+                {
+                    options.MigrationsAssembly("DataLayer.Sqlite");
+                    options.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery);
+                });
+
+            return new LibationContext(options.Options);
+        }
     }
 }

Source/DataLayer/MockLibraryBook.cs

@@ -0,0 +1,116 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+
+#nullable enable
+namespace DataLayer;
+public class MockLibraryBook : LibraryBook
+{
+	protected MockLibraryBook(Book book, DateTime dateAdded, string account, DateTime? includedUntil)
+		: base(book, dateAdded, account)
+	{
+		SetIncludedUntil(includedUntil);
+	}
+
+	public MockLibraryBook AddSeries(string seriesName, int order)
+	{
+		var series = new Series(new AudibleSeriesId(CalculateAsin(seriesName)), seriesName);
+		Book.UpsertSeries(series, order.ToString());
+		return this;
+	}
+
+	public MockLibraryBook AddCategoryLadder(params string[] ladder)
+	{
+		var newLadder = new CategoryLadder(ladder.Select(c => new Category(new AudibleCategoryId(CalculateAsin(c)), c)).ToList());
+		Book.SetCategoryLadders(Book.Categories.Select(c => c.CategoryLadder).Append(newLadder));
+		return this;
+	}
+
+	public MockLibraryBook AddNarrator(string name)
+	{
+		var newNarrator = new Contributor(name, CalculateAsin(name));
+		Book.ReplaceNarrators(Book.Narrators.Append(newNarrator));
+		return this;
+	}
+
+	public MockLibraryBook AddAuthor(string name)
+	{
+		var newAuthor = new Contributor(name, CalculateAsin(name));
+		Book.ReplaceAuthors(Book.Authors.Append(newAuthor));
+		return this;
+	}
+
+	public MockLibraryBook WithBookStatus(LiberatedStatus liberatedStatus)
+	{
+		//Set the backing field directly to preserve LiberatedStatus.PartialDownload
+		typeof(UserDefinedItem)
+			.GetField("_bookStatus", BindingFlags.NonPublic | BindingFlags.Instance)
+			?.SetValue(Book.UserDefinedItem, liberatedStatus);
+		return this;
+	}
+
+	public MockLibraryBook WithPdfStatus(LiberatedStatus liberatedStatus)
+	{
+		Book.UserDefinedItem.PdfStatus = liberatedStatus;
+		return this;
+	}
+
+	public MockLibraryBook WithLastDownloaded(Version? lastVersion = null, AudioFormat? format = null, string audioVersion = "1")
+	{
+		lastVersion ??= new Version(10, 0, 0, 0);
+		format ??= AudioFormat.Default;
+		Book.UserDefinedItem.SetLastDownloaded(lastVersion, format, audioVersion);
+		return this;
+	}
+
+	public MockLibraryBook WithMyRating(float overallRating = 4, float performanceRating = 4.5f, float storyRating = 5)
+	{
+		Book.UserDefinedItem.UpdateRating(overallRating, performanceRating, storyRating);
+		return this;
+	}
+
+	public static MockLibraryBook CreateBook(
+		string account = "someone@email.co",
+		bool absetFromLastScan = false,
+		DateTime? dateAdded = null,
+		DateTime? datePublished = null,
+		DateTime? includedUntil = null,
+		string title = "Mock Book Title",
+		string subtitle = "Mock Book Subtitle",
+		string description = "This is a mock book description.",
+		int lengthInMinutes = 1400,
+		ContentType contentType = ContentType.Product,
+		string firstAuthor = "Author One",
+		string firstNarrator = "Narrator One",
+		string localeName = "us",
+		bool isAbridged = false,
+		bool isSpatial = false,
+		string language = "English")
+	{
+		var book = new Book(
+			new AudibleProductId(CalculateAsin(title + subtitle)),
+			title,
+			subtitle,
+			description,
+			lengthInMinutes,
+			contentType,
+			[new Contributor(firstAuthor, CalculateAsin(firstAuthor))],
+			[new Contributor(firstNarrator, CalculateAsin(firstNarrator))],
+			localeName);
+
+		book.UpdateBookDetails(isAbridged, isSpatial, datePublished ?? DateTime.Now, language);
+
+		return new MockLibraryBook(
+			book,
+			dateAdded ?? DateTime.Now,
+			account,
+			includedUntil)
+		{
+			AbsentFromLastScan = absetFromLastScan
+		};
+	}
+
+	private static string CalculateAsin(string name) 
+		=> Convert.ToHexString(System.Security.Cryptography.MD5.HashData(Encoding.UTF8.GetBytes(name))).Substring(0, 10);
+}

Source/FileLiberator/DownloadOptions.Factory.cs

@@ -3,6 +3,8 @@ using AudibleApi;
 using AudibleApi.Common;
 using AudibleUtilities.Widevine;
 using DataLayer;
+using Dinah.Core;
+using DocumentFormat.OpenXml.Wordprocessing;
 using LibationFileManager;
 using NAudio.Lame;
 using System;
@@ -24,14 +26,42 @@ public partial class DownloadOptions
 	public static async Task<DownloadOptions> InitiateDownloadAsync(Api api, Configuration config, LibraryBook libraryBook, CancellationToken token)
 	{
 		var license = await ChooseContent(api, libraryBook, config, token);
+		Serilog.Log.Logger.Debug("Content License {@License}", new
+		{
+			license.DrmType,
+			license.ContentMetadata.ContentReference
+		});
+
 		token.ThrowIfCancellationRequested();
 
 		//Some audiobooks will have incorrect chapters in the metadata returned from the license request,
 		//but the metadata returned by the content metadata endpoint will be correct. Call the content
-		//metadata endpoint and use its chapters. Only replace the license request chapters if the total
-		//lengths match (defensive against different audio formats having slightly different lengths).
-		var metadata = await api.GetContentMetadataAsync(libraryBook.Book.AudibleProductId);
-		if (metadata.ChapterInfo.RuntimeLengthMs == license.ContentMetadata.ChapterInfo.RuntimeLengthMs)
+		//metadata endpoint and use its chapters. Only replace the license request chapters if the content
+		//references match (defensive against different audio formats having slightly different lengths).
+		var metadata = await api.GetContentMetadataAsync(
+		   libraryBook.Book.AudibleProductId,
+		   license.DrmType,
+		   license.ContentMetadata.ContentReference.Acr,
+		   license.ContentMetadata.ContentReference.FileVersion);
+
+		if (metadata is null)
+		{
+			Serilog.Log.Logger.Warning("Unable to retrieve metadata for {@FileReference}", new
+			{
+				libraryBook.Book.AudibleProductId,
+				license.DrmType,
+				license.ContentMetadata.ContentReference.Acr,
+				license.ContentMetadata.ContentReference.FileVersion
+			});
+		}
+		else if (metadata.ContentReference != license.ContentMetadata.ContentReference)
+		{
+			Serilog.Log.Logger.Warning("Metadata ContentReference does not match License ContentReference with drm_type = {@DrmType}. {@Metadata}. {@License} ",
+			license.DrmType,
+			metadata.ContentReference,
+			license.ContentMetadata.ContentReference);
+		}
+		else
 			license.ContentMetadata.ChapterInfo = metadata.ChapterInfo;
 
 		token.ThrowIfCancellationRequested();
@@ -41,7 +71,7 @@ public partial class DownloadOptions
 	private class LicenseInfo
 	{
 		public DrmType DrmType { get; }
-		public ContentMetadata ContentMetadata { get; set; }
+		public ContentMetadata ContentMetadata { get; }
 		public KeyData[]? DecryptionKeys { get; }
 		public LicenseInfo(ContentLicense license, IEnumerable<KeyData>? keys = null)
 		{
@@ -56,10 +86,28 @@ public partial class DownloadOptions
 
 	private static async Task<LicenseInfo> ChooseContent(Api api, LibraryBook libraryBook, Configuration config, CancellationToken token)
 	{
+		Serilog.Log.Logger.Information("Download Settings {@Settings}", new
+		{
+			config.FileDownloadQuality,
+			config.UseWidevine,
+			config.Request_xHE_AAC,
+			config.RequestSpatial,
+			config.SpatialAudioCodec
+		});
+
 		var dlQuality = config.FileDownloadQuality == Configuration.DownloadQuality.Normal ? DownloadQuality.Normal : DownloadQuality.High;
 
-		if (!config.UseWidevine || await Cdm.GetCdmAsync() is not Cdm cdm)
+		bool canUseWidevine = api.SupportsWidevine();
+		if (!config.UseWidevine || !canUseWidevine || await Cdm.GetCdmAsync() is not Cdm cdm)
 		{
+			if (config.UseWidevine)
+			{
+				if (canUseWidevine)
+					Serilog.Log.Logger.Warning("Unable to get a Widevine CDM. Falling back to ADRM.");
+				else
+					Serilog.Log.Logger.Warning("Account {@account} is not registered as an android device, so content will not be downloaded with Widevine DRM. Remove and re-add the account in Libation to fix.", libraryBook.Account.ToMask());
+			}
+
 			token.ThrowIfCancellationRequested();
 			var license = await api.GetDownloadLicenseAsync(libraryBook.Book.AudibleProductId, dlQuality);
 			return new LicenseInfo(license);
@@ -254,8 +302,11 @@ public partial class DownloadOptions
 
 	*/
 
-	public static List<Chapter> flattenChapters(IList<Chapter> chapters, string? titleConcat = ": ")
+	public static List<Chapter> flattenChapters(IList<Chapter>? chapters, string? titleConcat = ": ")
 	{
+		if (chapters is null)
+			return [];
+
 		List<Chapter> chaps = new();
 
 		foreach (var c in chapters)

Source/FileLiberator/UtilityExtensions.cs

@@ -7,6 +7,7 @@ using DataLayer;
 using Dinah.Core;
 using LibationFileManager;
 using LibationFileManager.Templates;
+using System.Security.Authentication;
 
 #nullable enable
 namespace FileLiberator
@@ -25,14 +26,22 @@ namespace FileLiberator
 
 		public static async Task<AudibleApi.Api> GetApiAsync(this LibraryBook libraryBook)
 		{
-			Account account;
-			using (var accounts = AudibleApiStorage.GetAccountsSettingsPersister())
-				account = accounts.AccountsSettings.GetAccount(libraryBook.Account, libraryBook.Book.Locale);
+			using var accounts = AudibleApiStorage.GetAccountsSettingsPersister();
+			var account = accounts.AccountsSettings.GetAccount(libraryBook.Account, libraryBook.Book.Locale)
+				?? throw new InvalidCredentialException($"No account found for '{libraryBook.Account}' and locale '{libraryBook.Book.Locale}'");
 
 			var apiExtended = await ApiExtended.CreateAsync(account);
 			return apiExtended.Api;
 		}
 
+		public static bool SupportsWidevine(this AudibleApi.Api api)
+		{
+			//TODO: Expose Api's identity maintainer directly instead of using reflection.
+			var identityProperty = api.GetType().GetProperty("_identityMaintainer", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+			return identityProperty?.GetValue(api) is AudibleApi.Authorization.IIdentityMaintainer identityMaintainer
+				&& identityMaintainer.DeviceType == AudibleApi.Resources.DeviceType;
+		}
+
 		public static LibraryBookDto ToDto(this LibraryBook libraryBook)
 		{
 			using var persister = AudibleApiStorage.GetAccountsSettingsPersister();

Source/FileManager/BackgroundFileSystem.cs

@@ -3,17 +3,18 @@ using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 
 #nullable enable
 namespace FileManager
 {
-    /// <summary>
-    /// Tracks actual locations of files.
-    /// </summary>
-    public class BackgroundFileSystem
+	/// <summary>
+	/// Tracks actual locations of files.
+	/// </summary>
+	public class BackgroundFileSystem : IDisposable
     {
-        public LongPath RootDirectory { get; private set; }
+        public LongPath? RootDirectory { get; private set; }
         public string SearchPattern { get; private set; }
         public SearchOption SearchOption { get; private set; }
 
@@ -21,7 +22,7 @@ namespace FileManager
         private BlockingCollection<FileSystemEventArgs>? directoryChangesEvents { get; set; }
         private Task? backgroundScanner { get; set; }
 
-        private object fsCacheLocker { get; } = new();
+        private Lock fsCacheLocker { get; } = new();
         private List<LongPath> fsCache { get; } = new();
 
         public BackgroundFileSystem(LongPath rootDirectory, string searchPattern, SearchOption searchOptions)
@@ -50,7 +51,8 @@ namespace FileManager
             lock (fsCacheLocker)
             {
                 fsCache.Clear();
-                fsCache.AddRange(SafestEnumerateFiles(RootDirectory));
+                if (Directory.Exists(RootDirectory))
+                    fsCache.AddRange(SafestEnumerateFiles(RootDirectory));
             }
         }
 
@@ -59,7 +61,14 @@ namespace FileManager
             Stop();
 
             lock (fsCacheLocker)
-                fsCache.AddRange(SafestEnumerateFiles(RootDirectory));
+            {
+                if (!Directory.Exists(RootDirectory))
+                {
+                    RootDirectory = null;
+					return;
+                }
+				fsCache.AddRange(SafestEnumerateFiles(RootDirectory));
+            }
 
             directoryChangesEvents = new BlockingCollection<FileSystemEventArgs>();
 			fileSystemWatcher = new FileSystemWatcher(RootDirectory)
@@ -100,7 +109,6 @@ namespace FileManager
 
         private void FileSystemWatcher_Error(object sender, ErrorEventArgs e)
         {
-            Stop();
             Init();
         }
 
@@ -181,8 +189,12 @@ namespace FileManager
                 fsCache.Add(newFile);
         }
 
-        #endregion
+		#endregion
 
-        ~BackgroundFileSystem() => Stop();
-    }
+		public void Dispose()
+		{
+			Stop();
+			GC.SuppressFinalize(this);
+		}
+	}
 }

Source/FileManager/FileManager.csproj

@@ -6,7 +6,7 @@
 
   <ItemGroup>
     <PackageReference Include="Dinah.Core" Version="9.0.3.1" />
-    <PackageReference Include="Polly" Version="8.6.2" />
+    <PackageReference Include="Polly" Version="8.6.4" />
   </ItemGroup>
 
 	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">

Source/FileManager/IPersistentDictionary.cs

@@ -0,0 +1,40 @@
+using Newtonsoft.Json.Linq;
+using System;
+using System.Linq;
+
+#nullable enable
+namespace FileManager;
+
+public interface IPersistentDictionary
+{
+	bool Exists(string propertyName);
+	string? GetString(string propertyName, string? defaultValue = null);
+	T? GetNonString<T>(string propertyName, T? defaultValue = default);
+	object? GetObject(string propertyName);
+	void SetString(string propertyName, string? newValue);
+	void SetNonString(string propertyName, object? newValue);
+	bool RemoveProperty(string propertyName);
+	bool SetWithJsonPath(string jsonPath, string propertyName, string? newValue, bool suppressLogging = false);
+	string? GetStringFromJsonPath(string jsonPath);
+
+	string? GetStringFromJsonPath(string jsonPath, string propertyName)
+		=> GetStringFromJsonPath($"{jsonPath}.{propertyName}");
+
+	static T? UpCast<T>(object obj)
+	{
+		if (obj.GetType().IsAssignableTo(typeof(T))) return (T)obj;
+		if (obj is JObject jObject) return jObject.ToObject<T>();
+		if (obj is JValue jValue)
+		{
+			if (typeof(T).IsAssignableTo(typeof(Enum)))
+			{
+				return
+					Enum.TryParse(typeof(T), jValue.Value<string>(), out var enumVal)
+					? (T)enumVal
+					: Enum.GetValues(typeof(T)).Cast<T>().First();
+			}
+			return jValue.Value<T>();
+		}
+		throw new InvalidCastException($"{obj.GetType()} is not convertible to {typeof(T)}");
+	}
+}

Source/FileManager/PersistentDictionary.cs

@@ -2,14 +2,13 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
-using System.Linq;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 #nullable enable
 namespace FileManager
 {
-    public class PersistentDictionary
+    public class PersistentDictionary : IPersistentDictionary
     {
         public string Filepath { get; }
         public bool IsReadOnly { get; }
@@ -60,21 +59,8 @@ namespace FileManager
                 objectCache[propertyName] = defaultValue;
                 return defaultValue;
             }
-            if (obj.GetType().IsAssignableTo(typeof(T))) return (T)obj;
-            if (obj is JObject jObject) return jObject.ToObject<T>();
-            if (obj is JValue jValue)
-            {
-                if (typeof(T).IsAssignableTo(typeof(Enum)))
-                {
-                    return
-                        Enum.TryParse(typeof(T), jValue.Value<string>(), out var enumVal)
-                        ? (T)enumVal
-                        : Enum.GetValues(typeof(T)).Cast<T>().First();
-                }
-                return jValue.Value<T>();
-            }
-            throw new InvalidCastException($"{obj.GetType()} is not convertible to {typeof(T)}");
-        }
+            return IPersistentDictionary.UpCast<T>(obj);
+		}
 
         public object? GetObject(string propertyName)
         {
@@ -89,7 +75,6 @@ namespace FileManager
             return objectCache[propertyName];
         }
 
-        public string? GetStringFromJsonPath(string jsonPath, string propertyName) => GetStringFromJsonPath($"{jsonPath}.{propertyName}");
         public string? GetStringFromJsonPath(string jsonPath)
         {
             if (!stringCache.ContainsKey(jsonPath))

Source/HangoverAvalonia/HangoverAvalonia.csproj

@@ -70,13 +70,11 @@
 		<TrimmableAssembly Include="Avalonia.Themes.Default" />
 	</ItemGroup>
 	<ItemGroup>
-
-		<PackageReference Include="Avalonia" Version="11.3.3" />
-		<PackageReference Include="Avalonia.Desktop" Version="11.3.3" />
+		<PackageReference Include="Avalonia.Desktop" Version="11.3.8" />
 		<!--Condition below is needed to remove Avalonia.Diagnostics package from build output in Release configuration.-->
-		<PackageReference Condition="'$(Configuration)' == 'Debug'" Include="Avalonia.Diagnostics" Version="11.3.3" />
-		<PackageReference Include="Avalonia.ReactiveUI" Version="11.3.3" />
-		<PackageReference Include="Avalonia.Themes.Fluent" Version="11.3.3" />
+		<PackageReference Condition="'$(Configuration)' == 'Debug'" Include="Avalonia.Diagnostics" Version="11.3.8" />
+		<PackageReference Include="ReactiveUI.Avalonia" Version="11.3.8" />
+		<PackageReference Include="Avalonia.Themes.Fluent" Version="11.3.8" />
 	</ItemGroup>
 	<ItemGroup>
 		<ProjectReference Include="..\HangoverBase\HangoverBase.csproj" />

Source/HangoverAvalonia/Program.cs

@@ -1,5 +1,5 @@
 using Avalonia;
-using Avalonia.ReactiveUI;
+using ReactiveUI.Avalonia;
 using System;
 
 namespace HangoverAvalonia

Source/Libation.sln

@@ -5,6 +5,7 @@ VisualStudioVersion = 17.0.31903.59
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "_Solution Items", "_Solution Items", "{03C8835F-936C-4AF7-87AE-FF92BDBE8B9B}"
 	ProjectSection(SolutionItems) = preProject
+		add-migrations.ps1 = add-migrations.ps1
 		REFERENCE.txt = REFERENCE.txt
 		Upgrading dotnet version.txt = Upgrading dotnet version.txt
 		_ARCHITECTURE NOTES.txt = _ARCHITECTURE NOTES.txt
@@ -104,6 +105,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Libation CLI", "Libation CL
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AssertionHelper", "_Tests\AssertionHelper\AssertionHelper.csproj", "{CFE7A0E5-37FE-40BE-A70B-41B5104181C4}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DataLayer.Postgres", "DataLayer.Postgres\DataLayer.Postgres.csproj", "{0E480D2D-C7C1-A6FE-8C90-8A6F0DBCEAC2}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DataLayer.Sqlite", "DataLayer.Sqlite\DataLayer.Sqlite.csproj", "{1E689E85-279E-39D4-7D97-3E993FB6D95B}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -226,6 +231,14 @@ Global
 		{CFE7A0E5-37FE-40BE-A70B-41B5104181C4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{CFE7A0E5-37FE-40BE-A70B-41B5104181C4}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{CFE7A0E5-37FE-40BE-A70B-41B5104181C4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0E480D2D-C7C1-A6FE-8C90-8A6F0DBCEAC2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0E480D2D-C7C1-A6FE-8C90-8A6F0DBCEAC2}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0E480D2D-C7C1-A6FE-8C90-8A6F0DBCEAC2}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0E480D2D-C7C1-A6FE-8C90-8A6F0DBCEAC2}.Release|Any CPU.Build.0 = Release|Any CPU
+		{1E689E85-279E-39D4-7D97-3E993FB6D95B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1E689E85-279E-39D4-7D97-3E993FB6D95B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1E689E85-279E-39D4-7D97-3E993FB6D95B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1E689E85-279E-39D4-7D97-3E993FB6D95B}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -265,6 +278,8 @@ Global
 		{53758A35-1C7E-4702-9B96-433ABA457B37} = {8679CAC8-9164-4007-BDD2-F004810EDA14}
 		{47E27674-595D-4F7A-8CFB-127E768E1D1E} = {8679CAC8-9164-4007-BDD2-F004810EDA14}
 		{CFE7A0E5-37FE-40BE-A70B-41B5104181C4} = {67E66E82-5532-4440-AFB3-9FB1DF9DEF53}
+		{0E480D2D-C7C1-A6FE-8C90-8A6F0DBCEAC2} = {751093DD-5DBA-463E-ADBE-E05FAFB6983E}
+		{1E689E85-279E-39D4-7D97-3E993FB6D95B} = {751093DD-5DBA-463E-ADBE-E05FAFB6983E}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {615E00ED-BAEF-4E8E-A92A-9B82D87942A9}

Source/LibationAvalonia/App.axaml.cs

@@ -1,261 +1,262 @@
 using ApplicationServices;
 using Avalonia;
+using Avalonia.Controls;
 using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Data.Core.Plugins;
 using Avalonia.Markup.Xaml;
 using Avalonia.Platform;
 using Avalonia.Styling;
+using Avalonia.Threading;
+using Dinah.Core;
 using LibationAvalonia.Dialogs;
+using LibationAvalonia.Themes;
 using LibationAvalonia.Views;
 using LibationFileManager;
+using LibationUiBase.Forms;
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Threading.Tasks;
-using Avalonia.Threading;
-using Dinah.Core;
-using LibationAvalonia.Themes;
-using Avalonia.Data.Core.Plugins;
 using System.Linq;
-using LibationUiBase.Forms;
-using Avalonia.Controls;
+using System.Threading.Tasks;
 
 #nullable enable
-namespace LibationAvalonia
+namespace LibationAvalonia;
+
+public class App : Application
 {
-	public class App : Application
+	public static Task<List<DataLayer.LibraryBook>>? LibraryTask { get; set; }
+	public static ChardonnayTheme? DefaultThemeColors { get; private set; }
+	public static MainWindow? MainWindow { get; private set; }
+	public static Uri AssetUriBase { get; } = new("avares://Libation/Assets/");
+	public static new Application Current => Application.Current ?? throw new InvalidOperationException("The Avalonia app hasn't started yet.");
+
+	public static Stream OpenAsset(string assetRelativePath)
+		=> AssetLoader.Open(new Uri(AssetUriBase, assetRelativePath));
+
+	public override void Initialize() => AvaloniaXamlLoader.Load(this);
+
+	public override void OnFrameworkInitializationCompleted()
 	{
-		public static Task<List<DataLayer.LibraryBook>>? LibraryTask { get; set; }
-		public static ChardonnayTheme? DefaultThemeColors { get; private set; }
-		public static MainWindow? MainWindow { get; private set; }
-		public static Uri AssetUriBase { get; } = new("avares://Libation/Assets/");
-		public static new Application Current => Application.Current ?? throw new InvalidOperationException("The Avalonia app hasn't started yet.");
+		DefaultThemeColors = ChardonnayTheme.GetLiveTheme();
 
-		public static Stream OpenAsset(string assetRelativePath)
-			=> AssetLoader.Open(new Uri(AssetUriBase, assetRelativePath));
-
-		public override void Initialize()
+		if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
 		{
-			AvaloniaXamlLoader.Load(this);
-		}
+			// Chardonnay uses the OnLastWindowClose shutdown mode. As long as the application lifetime
+			// has one active window, the application will stay alive. Setup windows must be daisy chained,
+			// each closing windows opens the next window before closing itself to prevent the app from exiting.
 
-		public override void OnFrameworkInitializationCompleted()
-		{
-			DefaultThemeColors = ChardonnayTheme.GetLiveTheme();
+			MessageBoxBase.ShowAsyncImpl = (owner, message, caption, buttons, icon, defaultButton, saveAndRestorePosition) =>
+				MessageBox.Show(owner as Window, message, caption, buttons, icon, defaultButton, saveAndRestorePosition);
 
-			if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
+			// Avoid duplicate validations from both Avalonia and the CommunityToolkit. 
+			// More info: https://docs.avaloniaui.net/docs/guides/development-guides/data-validation#manage-validationplugins
+			DisableAvaloniaDataAnnotationValidation();
+
+			Configuration config = Configuration.Instance;
+
+			if (!config.LibationSettingsAreValid)
 			{
-				MessageBoxBase.ShowAsyncImpl = (owner, message, caption, buttons, icon, defaultButton, saveAndRestorePosition) =>
-					MessageBox.Show(owner as Window, message, caption, buttons, icon, defaultButton, saveAndRestorePosition);
+				string defaultLibationFilesDir = Configuration.DefaultLibationFilesDirectory;
 
-				// Avoid duplicate validations from both Avalonia and the CommunityToolkit. 
-				// More info: https://docs.avaloniaui.net/docs/guides/development-guides/data-validation#manage-validationplugins
-				DisableAvaloniaDataAnnotationValidation();
+				// check for existing settings in default location
+				string defaultSettingsFile = Path.Combine(defaultLibationFilesDir, "Settings.json");
+				if (Configuration.SettingsFileIsValid(defaultSettingsFile))
+					Configuration.SetLibationFiles(defaultLibationFilesDir);
 
-				var config = Configuration.Instance;
-
-				if (!config.LibationSettingsAreValid)
+				if (config.LibationSettingsAreValid)
 				{
-					var defaultLibationFilesDir = Configuration.DefaultLibationFilesDirectory;
-
-					// check for existing settings in default location
-					var defaultSettingsFile = Path.Combine(defaultLibationFilesDir, "Settings.json");
-					if (Configuration.SettingsFileIsValid(defaultSettingsFile))
-						Configuration.SetLibationFiles(defaultLibationFilesDir);
-
-					if (config.LibationSettingsAreValid)
-					{
-						LibraryTask = Task.Run(() => DbContexts.GetLibrary_Flat_NoTracking(includeParents: true));
-						ShowMainWindow(desktop);
-					}
-					else
-					{
-						var setupDialog = new SetupDialog { Config = config };
-						setupDialog.Closing += Setup_Closing;
-						desktop.MainWindow = setupDialog;
-					}
+					LibraryTask = Task.Run(() => DbContexts.GetLibrary_Flat_NoTracking(includeParents: true));
+					ShowMainWindow(desktop);
 				}
 				else
-					ShowMainWindow(desktop);
-			}
-
-			base.OnFrameworkInitializationCompleted();
-		}
-		private void DisableAvaloniaDataAnnotationValidation()
-		{
-			// Get an array of plugins to remove
-			var dataValidationPluginsToRemove =
-				BindingPlugins.DataValidators.OfType<DataAnnotationsValidationPlugin>().ToArray();
-
-			// remove each entry found
-			foreach (var plugin in dataValidationPluginsToRemove)
-			{
-				BindingPlugins.DataValidators.Remove(plugin);
-			}
-		}
-
-		private async void Setup_Closing(object? sender, System.ComponentModel.CancelEventArgs e)
-		{
-			if (sender is not SetupDialog setupDialog || ApplicationLifetime is not IClassicDesktopStyleApplicationLifetime desktop)
-				return;
-
-			try
-			{
-				// all returns should be preceded by either:
-				// - if config.LibationSettingsAreValid
-				// - error message, Exit()				
-				if (setupDialog.IsNewUser)
 				{
-					Configuration.SetLibationFiles(Configuration.DefaultLibationFilesDirectory);
-					setupDialog.Config.Books = Configuration.DefaultBooksDirectory;
-
-					if (setupDialog.Config.LibationSettingsAreValid)
-					{
-						string? theme = setupDialog.SelectedTheme.Content as string;
-
-						setupDialog.Config.SetString(theme, nameof(ThemeVariant));
-
-						await RunMigrationsAsync(setupDialog.Config);
-						LibraryTask = Task.Run(() => DbContexts.GetLibrary_Flat_NoTracking(includeParents: true));
-						AudibleUtilities.AudibleApiStorage.EnsureAccountsSettingsFileExists();
-						ShowMainWindow(desktop);
-					}
-					else
-					{
-						e.Cancel = true;
-						await CancelInstallation(setupDialog);
-					}
+					SetupDialog setupDialog = new() { Config = config };
+					setupDialog.Closing += (_, e) => SetupClosing(setupDialog, desktop, e);
+					desktop.MainWindow = setupDialog;
 				}
-				else if (setupDialog.IsReturningUser)
+			}
+			else
+			{
+				ShowMainWindow(desktop);
+			}
+		}
+
+		base.OnFrameworkInitializationCompleted();
+	}
+
+	private void DisableAvaloniaDataAnnotationValidation()
+	{
+		// Get an array of plugins to remove
+		DataAnnotationsValidationPlugin[] dataValidationPluginsToRemove =
+			BindingPlugins.DataValidators.OfType<DataAnnotationsValidationPlugin>().ToArray();
+
+		// remove each entry found
+		foreach (DataAnnotationsValidationPlugin? plugin in dataValidationPluginsToRemove)
+		{
+			BindingPlugins.DataValidators.Remove(plugin);
+		}
+	}
+
+	private async void SetupClosing(SetupDialog setupDialog, IClassicDesktopStyleApplicationLifetime desktop, System.ComponentModel.CancelEventArgs e)
+	{
+		try
+		{
+			if (setupDialog.IsNewUser)
+			{
+				Configuration.SetLibationFiles(Configuration.DefaultLibationFilesDirectory);
+				setupDialog.Config.Books = Configuration.DefaultBooksDirectory;
+
+				if (setupDialog.Config.LibationSettingsAreValid)
 				{
-					ShowLibationFilesDialog(desktop, setupDialog.Config, OnLibationFilesCompleted);
+					string? theme = setupDialog.SelectedTheme.Content as string;
+					setupDialog.Config.SetString(theme, nameof(ThemeVariant));
+
+					await RunMigrationsAsync(setupDialog.Config);
+					LibraryTask = Task.Run(() => DbContexts.GetLibrary_Flat_NoTracking(includeParents: true));
+					AudibleUtilities.AudibleApiStorage.EnsureAccountsSettingsFileExists();
+					ShowMainWindow(desktop);
 				}
 				else
 				{
 					e.Cancel = true;
 					await CancelInstallation(setupDialog);
-					return;
 				}
-
 			}
-			catch (Exception ex)
+			else if (setupDialog.IsReturningUser)
 			{
-				var title = "Fatal error, pre-logging";
-				var body = "An unrecoverable error occurred. Since this error happened before logging could be initialized, this error can not be written to the log file.";
-				try
-				{
-					await MessageBox.ShowAdminAlert(setupDialog, body, title, ex);
-				}
-				catch
-				{
-					await MessageBox.Show(setupDialog, $"{body}\r\n\r\n{ex.Message}\r\n\r\n{ex.StackTrace}", title, MessageBoxButtons.OK, MessageBoxIcon.Error);
-				}
-				return;
-			}
-		}
-
-		private async Task RunMigrationsAsync(Configuration config)
-		{
-			// most migrations go in here
-			AppScaffolding.LibationScaffolding.RunPostConfigMigrations(config);
-
-			await MessageBox.VerboseLoggingWarning_ShowIfTrue();
-
-			// logging is init'd here
-			AppScaffolding.LibationScaffolding.RunPostMigrationScaffolding(AppScaffolding.Variety.Chardonnay, config);
-		}
-
-		private void ShowLibationFilesDialog(IClassicDesktopStyleApplicationLifetime desktop, Configuration config, Action<IClassicDesktopStyleApplicationLifetime, LibationFilesDialog, Configuration> OnClose)
-		{
-			var libationFilesDialog = new LibationFilesDialog();
-			desktop.MainWindow = libationFilesDialog;
-			libationFilesDialog.Show();
-
-			void WindowClosing(object? sender, System.ComponentModel.CancelEventArgs e)
-			{
-				libationFilesDialog.Closing -= WindowClosing;
-				e.Cancel = true;
-				OnClose?.Invoke(desktop, libationFilesDialog, config);
-			}
-			libationFilesDialog.Closing += WindowClosing;
-		}
-
-		private async void OnLibationFilesCompleted(IClassicDesktopStyleApplicationLifetime desktop, LibationFilesDialog libationFilesDialog, Configuration config)
-		{
-			Configuration.SetLibationFiles(libationFilesDialog.SelectedDirectory);
-			if (config.LibationSettingsAreValid)
-			{
-				await RunMigrationsAsync(config);
-
-				LibraryTask = Task.Run(() => DbContexts.GetLibrary_Flat_NoTracking(includeParents: true));
-				AudibleUtilities.AudibleApiStorage.EnsureAccountsSettingsFileExists();
-				ShowMainWindow(desktop);
+				ShowLibationFilesDialog(desktop, setupDialog.Config);
 			}
 			else
 			{
-				// path did not result in valid settings
-				var continueResult = await MessageBox.Show(
-					libationFilesDialog,
-					$"No valid settings were found at this location.\r\nWould you like to create a new install settings in this folder?\r\n\r\n{libationFilesDialog.SelectedDirectory}",
-					"New install?",
-					MessageBoxButtons.YesNo,
-					MessageBoxIcon.Question);
+				e.Cancel = true;
+				await CancelInstallation(setupDialog);
+			}
+		}
+		catch (Exception ex)
+		{
+			string title = "Fatal error, pre-logging";
+			string body = "An unrecoverable error occurred. Since this error happened before logging could be initialized, this error can not be written to the log file.";
 
-				if (continueResult == DialogResult.Yes)
+			MessageBoxAlertAdminDialog alert = new(body, title, ex);
+			desktop.MainWindow = alert;
+			alert.Show();
+		}
+	}
+
+	private void ShowLibationFilesDialog(IClassicDesktopStyleApplicationLifetime desktop, Configuration config)
+	{
+		LibationFilesDialog libationFilesDialog = new();
+		desktop.MainWindow = libationFilesDialog;
+		libationFilesDialog.Show();
+
+		async void WindowClosing(object? sender, System.ComponentModel.CancelEventArgs e)
+		{
+			libationFilesDialog.Closing -= WindowClosing;
+			e.Cancel = true;
+			if (libationFilesDialog.DialogResult == DialogResult.OK)
+				OnLibationFilesCompleted(desktop, libationFilesDialog, config);
+			else
+				await CancelInstallation(libationFilesDialog);
+		}
+		libationFilesDialog.Closing += WindowClosing;
+	}
+
+	private async void OnLibationFilesCompleted(IClassicDesktopStyleApplicationLifetime desktop, LibationFilesDialog libationFilesDialog, Configuration config)
+	{
+		Configuration.SetLibationFiles(libationFilesDialog.SelectedDirectory);
+		if (config.LibationSettingsAreValid)
+		{
+			await RunMigrationsAsync(config);
+
+			LibraryTask = Task.Run(() => DbContexts.GetLibrary_Flat_NoTracking(includeParents: true));
+			AudibleUtilities.AudibleApiStorage.EnsureAccountsSettingsFileExists();
+			ShowMainWindow(desktop);
+		}
+		else
+		{
+			// path did not result in valid settings
+			DialogResult continueResult = await MessageBox.Show(
+				libationFilesDialog,
+				$"No valid settings were found at this location.\r\nWould you like to create a new install settings in this folder?\r\n\r\n{libationFilesDialog.SelectedDirectory}",
+				"New install?",
+				MessageBoxButtons.YesNo,
+				MessageBoxIcon.Question);
+
+			if (continueResult == DialogResult.Yes)
+			{
+				config.Books = Path.Combine(libationFilesDialog.SelectedDirectory, nameof(Configuration.Books));
+
+				if (config.LibationSettingsAreValid)
 				{
-					config.Books = Configuration.DefaultBooksDirectory;
-
-					if (config.LibationSettingsAreValid)
-					{
-						await RunMigrationsAsync(config);
-						LibraryTask = Task.Run(() => DbContexts.GetLibrary_Flat_NoTracking(includeParents: true));
-						AudibleUtilities.AudibleApiStorage.EnsureAccountsSettingsFileExists();
-						ShowMainWindow(desktop);
-					}
-					else
-						await CancelInstallation(libationFilesDialog);
+					await RunMigrationsAsync(config);
+					LibraryTask = Task.Run(() => DbContexts.GetLibrary_Flat_NoTracking(includeParents: true));
+					AudibleUtilities.AudibleApiStorage.EnsureAccountsSettingsFileExists();
+					ShowMainWindow(desktop);
 				}
 				else
+				{
 					await CancelInstallation(libationFilesDialog);
+				}
 			}
-
-			libationFilesDialog.Close();
-		}
-
-		static async Task CancelInstallation(Window window)
-		{
-			await MessageBox.Show(window, "Initial set up cancelled.", "Cancelled", MessageBoxButtons.OK, MessageBoxIcon.Warning);
-			Environment.Exit(0);
-		}
-
-		private static void ShowMainWindow(IClassicDesktopStyleApplicationLifetime desktop)
-		{
-			Configuration.Instance.PropertyChanged += ThemeVariant_PropertyChanged;
-			OpenAndApplyTheme(Configuration.Instance.GetString(propertyName: nameof(ThemeVariant)));
-
-			var mainWindow = new MainWindow();
-			desktop.MainWindow = MainWindow = mainWindow;
-			mainWindow.Loaded += MainWindow_Loaded;
-			mainWindow.RestoreSizeAndLocation(Configuration.Instance);
-			mainWindow.Show();
-		}
-
-		[PropertyChangeFilter(nameof(ThemeVariant))]
-		private static void ThemeVariant_PropertyChanged(object sender, PropertyChangedEventArgsEx e)
-			=> OpenAndApplyTheme(e.NewValue as string);
-
-		private static void OpenAndApplyTheme(string? themeVariant)
-		{
-			using var themePersister = ChardonnayThemePersister.Create();
-			themePersister?.Target.ApplyTheme(themeVariant);
-		}
-
-		private static async void MainWindow_Loaded(object? sender, Avalonia.Interactivity.RoutedEventArgs e)
-		{
-			if (LibraryTask is not null && MainWindow is not null)
+			else
 			{
-				var library = await LibraryTask;
-				await Dispatcher.UIThread.InvokeAsync(() => MainWindow.OnLibraryLoadedAsync(library));
+				await CancelInstallation(libationFilesDialog);
 			}
 		}
+
+		libationFilesDialog.Close();
+	}
+
+	private static async Task CancelInstallation(Window window)
+	{
+		await MessageBox.Show(window, "Initial set up cancelled.", "Cancelled", MessageBoxButtons.OK, MessageBoxIcon.Warning);
+		Environment.Exit(-1);
+	}
+
+	private async Task RunMigrationsAsync(Configuration config)
+	{
+		// most migrations go in here
+		AppScaffolding.LibationScaffolding.RunPostConfigMigrations(config);
+
+		await MessageBox.VerboseLoggingWarning_ShowIfTrue();
+
+		// logging is init'd here
+		AppScaffolding.LibationScaffolding.RunPostMigrationScaffolding(AppScaffolding.Variety.Chardonnay, config);
+		Program.LoggingEnabled = true;
+	}
+
+	private static void ShowMainWindow(IClassicDesktopStyleApplicationLifetime desktop)
+	{
+		Configuration.Instance.PropertyChanged += ThemeVariant_PropertyChanged;
+		Current.ActualThemeVariantChanged += OnActualThemeVariantChanged;
+		OnActualThemeVariantChanged(Current, EventArgs.Empty);
+
+		MainWindow mainWindow = new();
+		desktop.MainWindow = MainWindow = mainWindow;
+		mainWindow.Loaded += MainWindow_Loaded;
+		mainWindow.RestoreSizeAndLocation(Configuration.Instance);
+		mainWindow.Show();
+	}
+
+	[PropertyChangeFilter(nameof(ThemeVariant))]
+	private static void ThemeVariant_PropertyChanged(object sender, PropertyChangedEventArgsEx e)
+		=> OpenAndApplyTheme(e.NewValue as string);
+
+	private static void OnActualThemeVariantChanged(object? sender, EventArgs e)
+		=> OpenAndApplyTheme(Configuration.Instance.GetString(propertyName: nameof(ThemeVariant)));
+
+	private static void OpenAndApplyTheme(string? themeVariant)
+	{
+		using ChardonnayThemePersister? themePersister = ChardonnayThemePersister.Create();
+		themePersister?.Target.ApplyTheme(themeVariant);
+	}
+
+	private static async void MainWindow_Loaded(object? sender, Avalonia.Interactivity.RoutedEventArgs e)
+	{
+		if (LibraryTask is not null && MainWindow is not null)
+		{
+			List<DataLayer.LibraryBook> library = await LibraryTask;
+			await Dispatcher.UIThread.InvokeAsync(() => MainWindow.OnLibraryLoadedAsync(library));
+		}
 	}
 }

Source/LibationAvalonia/Assets/LibationVectorIcons.xaml

@@ -117,6 +117,52 @@
 		   a 168,305 -35 0 0 104,-136
 	   </StreamGeometry>
 	   
+	   <StreamGeometry  x:Key="DolbyAtmosLogoVertical">
+		   M261.017,370.954h-13.752l38.363-88.449h11.241l37.967,88.449h-13.984l-8.988-21.733h-41.977
+	L261.017,370.954z M274.257,338.352h33.109l-16.497-41.484L274.257,338.352z M390.748,293.373h28.364v-10.868h-69.087v10.868h28.353
+	v77.581h12.37V293.373z M472.258,282.505h-19.229v88.449h11.985v-73.959h0.246l29.236,73.959h7.87l29.354-73.959h0.255v73.959
+	h12.368v-88.449h-19.229l-26.12,67.955h-0.257L472.258,282.505z M668.11,326.61c0,6.502-1.138,12.46-3.394,17.883
+	c-2.253,5.425-5.369,10.094-9.316,14.018c-3.966,3.92-8.678,6.966-14.135,9.146c-5.477,2.169-11.411,3.255-17.824,3.255
+	s-12.337-1.086-17.751-3.255c-5.434-2.181-10.114-5.227-14.08-9.146c-3.968-3.924-7.041-8.593-9.266-14.018
+	c-2.222-5.423-3.328-11.381-3.328-17.883c0-6.567,1.106-12.567,3.328-17.99c2.225-5.425,5.298-10.051,9.266-13.901
+	c3.966-3.838,8.646-6.826,14.08-8.971c5.414-2.132,11.338-3.2,17.751-3.2s12.348,1.068,17.824,3.2
+	c5.457,2.145,10.169,5.133,14.135,8.971c3.947,3.851,7.063,8.477,9.316,13.901C666.973,314.043,668.11,320.043,668.11,326.61
+	 M655.4,326.61c0-4.595-0.765-8.919-2.254-13.003c-1.522-4.073-3.647-7.667-6.424-10.752c-2.776-3.089-6.116-5.52-10.039-7.308
+	c-3.914-1.774-8.34-2.669-13.242-2.669c-4.828,0-9.21,0.895-13.124,2.669c-3.913,1.788-7.253,4.219-9.976,7.308
+	c-2.734,3.085-4.851,6.679-6.359,10.752c-1.5,4.084-2.256,8.408-2.256,13.003c0,4.674,0.756,9.071,2.256,13.188
+	c1.509,4.115,3.647,7.698,6.413,10.752c2.773,3.047,6.104,5.445,9.974,7.185c3.883,1.743,8.244,2.615,13.072,2.615
+	s9.221-0.872,13.178-2.615c3.967-1.739,7.327-4.138,10.104-7.185c2.776-3.054,4.901-6.637,6.424-10.752
+	C654.636,335.682,655.4,331.284,655.4,326.61 M751.896,292.173c-2.606-2.931-6.063-5.26-10.327-7.003
+	c-4.276-1.739-8.87-2.612-13.771-2.612c-3.479,0-6.945,0.457-10.403,1.361c-3.436,0.915-6.529,2.361-9.252,4.334
+	c-2.734,1.984-4.956,4.478-6.659,7.481c-1.701,3.016-2.542,6.611-2.542,10.817c0,3.877,0.629,7.12,1.894,9.726
+	c1.266,2.611,2.926,4.813,4.989,6.6c2.052,1.771,4.401,3.244,7.008,4.387c2.606,1.144,5.265,2.123,7.955,2.92
+	c2.691,0.861,5.244,1.706,7.658,2.547c2.415,0.829,4.541,1.84,6.349,3.025c1.831,1.191,3.266,2.638,4.339,4.335
+	c1.075,1.702,1.607,3.823,1.607,6.349c0,2.542-0.521,4.695-1.554,6.472c-1.021,1.787-2.35,3.266-3.966,4.457
+	c-1.627,1.185-3.436,2.057-5.402,2.611c-1.989,0.558-3.968,0.829-5.935,0.829c-3.895,0-7.488-0.904-10.817-2.723
+	c-3.328-1.819-5.977-4.196-7.955-7.126l-9.146,7.71c3.243,4.042,7.338,7.094,12.282,9.152c4.958,2.057,10.073,3.078,15.391,3.078
+	c3.722,0,7.327-0.51,10.859-1.531c3.531-1.037,6.637-2.595,9.328-4.696c2.688-2.099,4.849-4.747,6.476-7.96
+	c1.607-3.2,2.425-6.981,2.425-11.337c0-4.196-0.744-7.657-2.255-10.39c-1.498-2.734-3.434-5-5.816-6.829
+	c-2.372-1.818-5.032-3.275-7.955-4.393c-2.936-1.106-5.819-2.101-8.669-2.966c-2.383-0.799-4.604-1.575-6.711-2.325
+	c-2.105-0.74-3.925-1.654-5.456-2.723c-1.543-1.068-2.776-2.383-3.69-3.919c-0.903-1.548-1.361-3.462-1.361-5.765
+	c0-2.371,0.489-4.408,1.478-6.115c0.99-1.701,2.277-3.128,3.862-4.27c1.585-1.145,3.349-1.984,5.284-2.495
+	c1.937-0.521,3.86-0.775,5.766-0.775c3.563,0,6.764,0.733,9.613,2.201c2.851,1.457,5.105,3.345,6.775,5.631L751.896,292.173z
+	 M0,194.145h28.652c53.454,0,97.049-43.594,97.049-97.068c0-53.481-43.595-97.065-97.049-97.065H0V194.145z M276.172,0.011h-28.641
+	c-53.476,0-97.061,43.584-97.061,97.065c0,53.475,43.584,97.068,97.061,97.068h28.641V0.011z M405.074,0h-70.108v194.145h70.108
+	c53.517,0,97.069-43.552,97.069-97.068C502.144,43.552,458.591,0,405.074,0 M405.063,164.711h-19.952h-20.729V29.434h20.729h19.952
+	c37.268,0,67.641,30.375,67.641,67.643C472.704,134.336,442.331,164.711,405.063,164.711 M584.346,59.797
+	c-37.106,0-67.27,30.168-67.27,67.265c0,37.102,30.163,67.269,67.27,67.269c37.095,0,67.259-30.167,67.259-67.269
+	C651.604,89.965,621.44,59.797,584.346,59.797 M584.346,167.376c-22.506,0-40.554-18.305-40.554-40.56
+	c0-22.51,18.294-40.553,40.554-40.553c22.248,0,40.553,18.294,40.553,40.553C624.898,149.322,606.594,167.376,584.346,167.376
+	 M670.643,194.374h29.428V0.031h-29.428V194.374z M792.759,59.809c-14.295,0-27.546,4.488-38.459,12.124V0.031h-29.491l0.01,194.343
+	H754.3v-12.161c10.913,7.63,24.164,12.129,38.459,12.129c37.095,0,67.278-30.179,67.278-67.271
+	C860.037,89.977,829.854,59.809,792.759,59.809 M792.759,167.376c-17.985,0-33.119-11.704-38.459-27.78
+	c-1.339-4.021-2.095-8.312-2.095-12.768c0-4.483,0.756-8.785,2.095-12.806c5.383-16.171,20.634-27.759,38.459-27.759
+	c22.259,0,40.562,18.305,40.562,40.564C833.32,149.333,815.018,167.376,792.759,167.376 M967.85,59.84l-38.329,86.201L891.169,59.84
+	h-32.151l54.41,122.304l-1.084,2.376l-0.385,0.846l-11.782,26.61l-0.075,0.207c-3.53,7.907-12.836,11.486-20.729,7.961l-4.223-1.872
+	l-8.222,18.469l-3.657,8.188h0.01l0.044,0.021l10.188,4.541c19.133,8.541,41.7-0.143,50.262-19.318
+	c0.076-0.164,69.684-155.714,76.225-170.333H967.85z
+	   </StreamGeometry>
+	   
    </ResourceDictionary>
   </Styles.Resources>
 </Styles>

Source/LibationAvalonia/AvaloniaUtils.cs

@@ -23,11 +23,6 @@ namespace LibationAvalonia
 			? dialogWindow.ShowDialog<DialogResult>(window)
 			: Task.FromResult(DialogResult.None);
 
-		public static Task<DialogResult> ShowDialogAsync(this Dialogs.Login.WebLoginDialog dialogWindow, Window? owner = null)
-			=> ((owner ?? App.MainWindow) is Window window)
-			? dialogWindow.ShowDialog<DialogResult>(window)
-			: Task.FromResult(DialogResult.None);
-
 		public static Window? GetParentWindow(this Control control) => control.GetVisualRoot() as Window;
 
 

Source/LibationAvalonia/Controls/DataGridTextColumnExt.cs

@@ -0,0 +1,25 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+
+namespace LibationAvalonia.Controls;
+internal class DataGridTextColumnExt : DataGridTextColumn
+{
+	public static readonly StyledProperty<int> MaxLengthProperty =
+	AvaloniaProperty.Register<DataGridTextColumnExt, int>(nameof(MaxLength));
+
+	public int MaxLength
+	{
+		get => GetValue(MaxLengthProperty);
+		set => SetValue(MaxLengthProperty, value);
+	}
+
+	protected override object PrepareCellForEdit(Control editingElement, RoutedEventArgs editingEventArgs)
+	{
+		if (editingElement is TextBox textBox)
+		{
+			textBox.MaxLength = MaxLength;
+		}
+		return base.PrepareCellForEdit(editingElement, editingEventArgs);
+	}
+}

Source/LibationAvalonia/Controls/DirectoryOrCustomSelectControl.axaml

@@ -6,29 +6,63 @@
              mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
              x:Class="LibationAvalonia.Controls.DirectoryOrCustomSelectControl">
 	
-	<Grid ColumnDefinitions="Auto,*" RowDefinitions="Auto,Auto" Name="grid">
-		<controls:DirectorySelectControl
-			Grid.Column="1"
-			Grid.Row="0"
-			IsEnabled="{Binding KnownChecked}"
-			SelectedDirectory="{Binding SelectedDirectory, Mode=TwoWay}"
-			SubDirectory="{Binding $parent[1].SubDirectory}"
-			KnownDirectories="{Binding $parent[1].KnownDirectories}" />
+    <Grid
+        RowDefinitions="Auto,Auto,Auto"
+        ColumnDefinitions="Auto,*,Auto">
 
-		<RadioButton
-			Grid.Column="0"
-			Grid.Row="0"
-			IsChecked="{Binding KnownChecked, Mode=TwoWay}"/>
+        <RadioButton
+            Grid.RowSpan="2"
+            Name="rbKnown" />
 
-		<RadioButton
-			Grid.Column="0"
-			Grid.Row="1"
-			IsChecked="{Binding CustomChecked, Mode=TwoWay}"/>
+        <TextBlock
+            Grid.Column="1"
+            Grid.ColumnSpan="2"
+            VerticalAlignment="Center"
+            Margin="10,0"
+            IsEnabled="False"
+            IsVisible="{Binding #cmbKnownDirs.SelectedItem, Converter={x:Static ObjectConverters.IsNull}}"
+            Text="Select Known Directory:" />
 
-		<Grid Grid.Column="1" Grid.Row="1" ColumnDefinitions="*,Auto"
-			  IsEnabled="{Binding CustomChecked}">
-			<TextBox Grid.Column="0" IsReadOnly="True" Text="{Binding CustomDir, Mode=TwoWay}" />
-			<Button Grid.Column="1" Content="..." Margin="5,0,0,0" Padding="10,0,10,0" Click="CustomDirBrowseBtn_Click" VerticalAlignment="Stretch" />
-		</Grid>
-	</Grid>
+		<controls:WheelComboBox
+            Grid.Column="1"
+            Grid.ColumnSpan="2"
+            HorizontalAlignment="Stretch"
+            Margin="0,0,0,3"
+            IsEnabled="{Binding #rbKnown.IsChecked}"
+            Name="cmbKnownDirs" />
+
+        <TextBox
+            Grid.Row="1"
+            Grid.Column="1"
+            Grid.ColumnSpan="2"
+            IsReadOnly="True"
+            Margin="0,0,0,8"
+            Name="tboxKnownDirPath"
+            IsEnabled="{Binding #rbKnown.IsChecked}"
+            Text="{Binding #cmbKnownDirs.SelectedItem.Directory}" />
+
+        
+        <RadioButton
+            Grid.Row="2"
+            Name="rbCustom" />
+
+        <TextBox
+        Grid.Row="2"
+            Grid.Column="1"
+            HorizontalAlignment="Stretch"
+            Name="tboxCustomDirPath"
+            Margin="0,0,10,0"
+            VerticalAlignment="Center"
+            Text="{Binding $parent[1].Directory, Mode=OneWayToSource}"
+            IsEnabled="{Binding #rbCustom.IsChecked}"/>
+
+        <Button
+             Grid.Row="2"
+             Grid.Column="2"
+             Name="btnBrowse"
+             IsEnabled="{Binding #rbCustom.IsChecked}">
+                <TextBlock Text="..." />
+        </Button>
+
+    </Grid>
 </UserControl>

Source/LibationAvalonia/Controls/DirectoryOrCustomSelectControl.axaml.cs

@@ -1,142 +1,184 @@
 using Avalonia;
+using Avalonia.Collections;
 using Avalonia.Controls;
 using Avalonia.Platform.Storage;
 using Dinah.Core;
 using LibationFileManager;
 using ReactiveUI;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 
+#nullable enable
 namespace LibationAvalonia.Controls
 {
 	public partial class DirectoryOrCustomSelectControl : UserControl
 	{
-		public static readonly StyledProperty<List<Configuration.KnownDirectories>> KnownDirectoriesProperty =
-		AvaloniaProperty.Register<DirectorySelectControl, List<Configuration.KnownDirectories>>(nameof(KnownDirectories), DirectorySelectControl.DefaultKnownDirectories);
+		public static readonly StyledProperty<IList<Configuration.KnownDirectories>?> KnownDirectoriesProperty =
+		AvaloniaProperty.Register<DirectoryOrCustomSelectControl, IList<Configuration.KnownDirectories>?>(nameof(KnownDirectories), DefaultKnownDirectories);
 
-		public static readonly StyledProperty<string> SubDirectoryProperty =
-		AvaloniaProperty.Register<DirectorySelectControl, string>(nameof(SubDirectory));
+		public static readonly StyledProperty<string?> SubDirectoryProperty =
+		AvaloniaProperty.Register<DirectoryOrCustomSelectControl, string?>(nameof(SubDirectory));
 
-		public static readonly StyledProperty<string> DirectoryProperty =
-		AvaloniaProperty.Register<DirectorySelectControl, string>(nameof(Directory));
+		public static readonly StyledProperty<string?> DirectoryProperty =
+		AvaloniaProperty.Register<DirectoryOrCustomSelectControl, string?>(nameof(Directory));
 
-		public List<Configuration.KnownDirectories> KnownDirectories
+		public IList<Configuration.KnownDirectories>? KnownDirectories
 		{
 			get => GetValue(KnownDirectoriesProperty);
 			set => SetValue(KnownDirectoriesProperty, value);
 		}
 
-		public string Directory
+		public string? Directory
 		{
 			get => GetValue(DirectoryProperty);
 			set => SetValue(DirectoryProperty, value);
 		}
 
-		public string SubDirectory
+		public string? SubDirectory
 		{
 			get => GetValue(SubDirectoryProperty);
 			set => SetValue(SubDirectoryProperty, value);
 		}
 
-		private readonly DirectoryState directoryState = new();
+		public static IList<Configuration.KnownDirectories> DefaultKnownDirectories => [
+			Configuration.KnownDirectories.WinTemp,
+			Configuration.KnownDirectories.UserProfile,
+			Configuration.KnownDirectories.ApplicationData,
+			Configuration.KnownDirectories.AppDir,
+			Configuration.KnownDirectories.MyMusic,
+			Configuration.KnownDirectories.MyDocs,
+			Configuration.KnownDirectories.LibationFiles];
 
+		private readonly AvaloniaList<KnownDirectoryItem> _knownDirNames;
 		public DirectoryOrCustomSelectControl()
 		{
 			InitializeComponent();
-
-			grid.DataContext = directoryState;
-
-			directoryState.PropertyChanged += DirectoryState_PropertyChanged;
-			PropertyChanged += DirectoryOrCustomSelectControl_PropertyChanged;
+			_knownDirNames = new(GetKnownDirectories(DefaultKnownDirectories));
+			cmbKnownDirs.ItemsSource = _knownDirNames;
+			cmbKnownDirs.SelectionChanged += CmbKnownDirs_SelectionChanged;
+			btnBrowse.Click += Browse_Click;
 		}
 
-		private void DirectoryState_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
+		private void CmbKnownDirs_SelectionChanged(object? sender, SelectionChangedEventArgs e)
 		{
-			if (e.PropertyName is nameof(DirectoryState.SelectedDirectory) or nameof(DirectoryState.KnownChecked) &&
-				directoryState.KnownChecked &&
-				directoryState.SelectedDirectory is Configuration.KnownDirectories kdir &&
-				kdir is not Configuration.KnownDirectories.None)
+			if (cmbKnownDirs.SelectedItem is KnownDirectoryItem item && item.Directory is not null)
 			{
-				Directory = kdir is Configuration.KnownDirectories.AppDir ? Configuration.AppDir_Absolute : Configuration.GetKnownDirectoryPath(kdir);
-			}
-			else if (e.PropertyName is nameof(DirectoryState.CustomDir) or nameof(DirectoryState.CustomChecked) &&
-				directoryState.CustomChecked &&
-				directoryState.CustomDir is not null)
-			{
-				Directory = directoryState.CustomDir;
+				Directory = item.Directory;
 			}
 		}
 
-		private class DirectoryState : ViewModels.ViewModelBase
-		{
-			private string _customDir;
-			private string _subDirectory;
-			private bool _knownChecked;
-			private bool _customChecked;
-			private Configuration.KnownDirectories? _selectedDirectory;
-			public string CustomDir { get => _customDir; set => this.RaiseAndSetIfChanged(ref _customDir, value); }
-			public string SubDirectory { get => _subDirectory; set => this.RaiseAndSetIfChanged(ref _subDirectory, value); }
-			public bool KnownChecked { get => _knownChecked; set => this.RaiseAndSetIfChanged(ref _knownChecked, value); }
-			public bool CustomChecked { get => _customChecked; set => this.RaiseAndSetIfChanged(ref _customChecked, value); }
+		private IEnumerable<KnownDirectoryItem> GetKnownDirectories(IEnumerable<Configuration.KnownDirectories> knownDirs)
+			=> knownDirs.Select(k => new KnownDirectoryItem(k, SubDirectory)).Where(k => k.Directory is not null);
 
-			public Configuration.KnownDirectories? SelectedDirectory { get => _selectedDirectory; set => this.RaiseAndSetIfChanged(ref _selectedDirectory, value); }
+		protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+		{
+			if (change.Property == SubDirectoryProperty)
+			{
+				foreach (var item in _knownDirNames)
+				{
+					item.SubDirectory = SubDirectory;
+				}
+				VerifyAndApplyDirectory(Directory);
+			}
+			else if (change.Property == KnownDirectoriesProperty)
+			{
+				var knownDirs = KnownDirectories?.Count > 0 ? KnownDirectories : DefaultKnownDirectories;
+				if (!_knownDirNames.Select(k => k.KnownDirectory).SequenceEqual(knownDirs))
+				{
+					_knownDirNames.Clear();
+					_knownDirNames.AddRange(GetKnownDirectories(knownDirs));
+				}
+				VerifyAndApplyDirectory(Directory);
+			}
+			else if (change.Property == DirectoryProperty)
+			{
+				VerifyAndApplyDirectory(Directory);
+			}
+
+			base.OnPropertyChanged(change);
 		}
 
-		private async void CustomDirBrowseBtn_Click(object sender, Avalonia.Interactivity.RoutedEventArgs e)
+		private void VerifyAndApplyDirectory(string? directory)
 		{
-			var options = new Avalonia.Platform.Storage.FolderPickerOpenOptions
+			if (string.IsNullOrWhiteSpace(Directory))
+				return;
+
+			bool dirIsKnown = false;
+			foreach (var item in _knownDirNames)
+			{
+				if (item.IsSamePathAs(directory))
+				{
+					rbKnown.IsChecked = true;
+					Directory = item.Directory;
+					cmbKnownDirs.SelectedItem = item;
+					dirIsKnown = true;
+					break;
+				}
+			}
+			if (!dirIsKnown)
+			{
+				tboxCustomDirPath.Text = directory;
+				rbCustom.IsChecked = true;
+			}
+		}
+
+		public async void Browse_Click(object? sender, Avalonia.Interactivity.RoutedEventArgs e)
+		{
+			if (VisualRoot is not Window window)
+				return;
+
+			var options = new FolderPickerOpenOptions
 			{
 				AllowMultiple = false
 			};
 
-			var selectedFolders = await (VisualRoot as Window).StorageProvider.OpenFolderPickerAsync(options);
-
-			directoryState.CustomDir = selectedFolders.SingleOrDefault()?.TryGetLocalPath() ?? directoryState.CustomDir;
+			var selectedFolders = await window.StorageProvider.OpenFolderPickerAsync(options);
+			Directory = selectedFolders.SingleOrDefault()?.TryGetLocalPath() ?? Directory;
 		}
 
-		private void DirectoryOrCustomSelectControl_PropertyChanged(object sender, AvaloniaPropertyChangedEventArgs e)
+		private class KnownDirectoryItem : ReactiveObject
 		{
-			if (e.Property == DirectoryProperty)
+			public Configuration.KnownDirectories KnownDirectory { get; set; }
+			private string? _directory;
+			public string? Directory { get => _directory; private set => this.RaiseAndSetIfChanged(ref _directory, value); }
+			public string? Name { get; }
+			private string? _subDir;
+			public string? SubDirectory
 			{
-				var directory = Directory?.Trim() ?? "";
-
-				var noSubDir = RemoveSubDirectoryFromPath(directory);
-				var known = Configuration.GetKnownDirectory(noSubDir);
-
-				if (known == Configuration.KnownDirectories.None && noSubDir == Configuration.AppDir_Absolute)
-					known = Configuration.KnownDirectories.AppDir;
-
-				if (known is Configuration.KnownDirectories.None)
+				get => _subDir;
+				set
 				{
-					directoryState.CustomDir = directory;
-					directoryState.CustomChecked = true;
-				}
-				else
-				{
-					directoryState.SelectedDirectory = known;
-					directoryState.KnownChecked = true;
+					_subDir = value;
+					if (Configuration.GetKnownDirectoryPath(KnownDirectory) is string dir)
+					{
+						Directory = Path.Combine(dir, _subDir ?? "");
+					}
 				}
 			}
-			else if (e.Property == KnownDirectoriesProperty &&
-					KnownDirectories.Count > 0 &&
-					directoryState.SelectedDirectory is null or Configuration.KnownDirectories.None)
-				directoryState.SelectedDirectory = KnownDirectories[0];
-		}
 
-		private string RemoveSubDirectoryFromPath(string path)
-		{
-			if (string.IsNullOrWhiteSpace(SubDirectory))
-				return path;
+			public KnownDirectoryItem(Configuration.KnownDirectories known, string? subDir)
+			{
+				Name = known.GetDescription();
+				KnownDirectory = known;
+				SubDirectory = subDir;
+			}
 
-			path = path?.Trim() ?? "";
-			if (string.IsNullOrWhiteSpace(path))
-				return path;
+			public bool IsSamePathAs(string? otherPath)
+			{
+				if (string.IsNullOrWhiteSpace(otherPath) || string.IsNullOrWhiteSpace(Directory))
+					return false;
 
-			var bottomDir = System.IO.Path.GetFileName(path);
-			if (SubDirectory.EqualsInsensitive(bottomDir))
-				return System.IO.Path.GetDirectoryName(path);
+				try
+				{
+					var p1 = Path.GetFullPath(Directory);
+					var p2 = Path.GetFullPath(otherPath);
+					return p1.Equals(p2, System.StringComparison.OrdinalIgnoreCase);
+				}
+				catch { return false; }
+			}
 
-			return path;
+			public override string? ToString() => Name?.ToString();
 		}
 	}
 }

Source/LibationAvalonia/Controls/NativeWebView.cs

@@ -1,176 +0,0 @@
-using Avalonia.Controls;
-using Avalonia.Input;
-using Avalonia.Platform;
-using Avalonia;
-using LibationFileManager;
-using System;
-using System.Threading.Tasks;
-
-namespace LibationAvalonia.Controls;
-
-#nullable enable
-public class NativeWebView : NativeControlHost, IWebView
-{
-	private IWebViewAdapter? _webViewAdapter;
-	private Uri? _delayedSource;
-	private TaskCompletionSource _webViewReadyCompletion = new();
-
-	public event EventHandler<WebViewNavigationEventArgs>? NavigationCompleted;
-
-	public event EventHandler<WebViewNavigationEventArgs>? NavigationStarted;
-	public event EventHandler? DOMContentLoaded;
-
-	public bool CanGoBack => _webViewAdapter?.CanGoBack ?? false;
-
-	public bool CanGoForward => _webViewAdapter?.CanGoForward ?? false;
-
-	public Uri? Source
-	{
-		get => _webViewAdapter?.Source ?? throw new InvalidOperationException("Control was not initialized");
-		set
-		{
-			if (_webViewAdapter is null)
-			{
-				_delayedSource = value;
-				return;
-			}
-			_webViewAdapter.Source = value;
-		}
-	}
-
-
-	public bool GoBack()
-	{
-		return _webViewAdapter?.GoBack() ?? throw new InvalidOperationException("Control was not initialized");
-	}
-
-	public bool GoForward()
-	{
-		return _webViewAdapter?.GoForward() ?? throw new InvalidOperationException("Control was not initialized");
-	}
-
-	public Task<string?> InvokeScriptAsync(string scriptName)
-	{
-		return _webViewAdapter is null
-			? throw new InvalidOperationException("Control was not initialized")
-			: _webViewAdapter.InvokeScriptAsync(scriptName);
-	}
-
-	public void Navigate(Uri url)
-	{
-		(_webViewAdapter ?? throw new InvalidOperationException("Control was not initialized"))
-			.Navigate(url);
-	}
-
-	public Task NavigateToString(string text)
-	{
-		return (_webViewAdapter ?? throw new InvalidOperationException("Control was not initialized"))
-			.NavigateToString(text);
-	}
-
-	public void Refresh()
-	{
-		(_webViewAdapter ?? throw new InvalidOperationException("Control was not initialized"))
-			.Refresh();
-	}
-
-	public void Stop()
-	{
-		(_webViewAdapter ?? throw new InvalidOperationException("Control was not initialized"))
-			.Stop();
-	}
-
-	public Task WaitForNativeHost()
-	{
-		return _webViewReadyCompletion.Task;
-	}
-
-	private class PlatformHandle : IPlatformHandle
-	{
-		public nint Handle { get; init; }
-
-		public string? HandleDescriptor { get; init; }
-	}
-
-	protected override IPlatformHandle CreateNativeControlCore(IPlatformHandle parent)
-	{
-		_webViewAdapter = InteropFactory.Create().CreateWebViewAdapter();
-
-		if (_webViewAdapter is null)
-			return base.CreateNativeControlCore(parent);
-		else
-		{
-			SubscribeOnEvents();
-			var handle = new PlatformHandle
-			{
-				Handle = _webViewAdapter.PlatformHandle.Handle,
-				HandleDescriptor = _webViewAdapter.PlatformHandle.HandleDescriptor
-			};
-
-			if (_delayedSource is not null)
-			{
-				_webViewAdapter.Source = _delayedSource;
-			}
-
-			_webViewReadyCompletion.TrySetResult();
-
-			return handle;
-		}
-	}
-
-	private void SubscribeOnEvents()
-	{
-		if (_webViewAdapter is not null)
-		{
-			_webViewAdapter.NavigationStarted += WebViewAdapterOnNavigationStarted;
-			_webViewAdapter.NavigationCompleted += WebViewAdapterOnNavigationCompleted;
-			_webViewAdapter.DOMContentLoaded += _webViewAdapter_DOMContentLoaded;
-		}
-	}
-
-	private void _webViewAdapter_DOMContentLoaded(object? sender, EventArgs e)
-	{
-		DOMContentLoaded?.Invoke(this, e);
-	}
-
-	private void WebViewAdapterOnNavigationStarted(object? sender, WebViewNavigationEventArgs e)
-	{
-		NavigationStarted?.Invoke(this, e);
-	}
-
-	private void WebViewAdapterOnNavigationCompleted(object? sender, WebViewNavigationEventArgs e)
-	{
-		NavigationCompleted?.Invoke(this, e);
-	}
-
-	protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
-	{
-		base.OnPropertyChanged(change);
-		if (change.Property == BoundsProperty && change.NewValue is Rect rect)
-		{
-			var scaling = (float)(VisualRoot?.RenderScaling ?? 1.0f);
-			_webViewAdapter?.HandleResize((int)(rect.Width * scaling), (int)(rect.Height * scaling), scaling);
-		}
-	}
-
-	protected override void OnKeyDown(KeyEventArgs e)
-	{
-		if (_webViewAdapter != null)
-		{
-			e.Handled = _webViewAdapter.HandleKeyDown((uint)e.Key, (uint)e.KeyModifiers);
-		}
-
-		base.OnKeyDown(e);
-	}
-
-	protected override void DestroyNativeControlCore(IPlatformHandle control)
-	{
-		if (_webViewAdapter is not null)
-		{
-			_webViewReadyCompletion = new TaskCompletionSource();
-			_webViewAdapter.NavigationStarted -= WebViewAdapterOnNavigationStarted;
-			_webViewAdapter.NavigationCompleted -= WebViewAdapterOnNavigationCompleted;
-			(_webViewAdapter as IDisposable)?.Dispose();
-		}
-	}
-}

Source/LibationAvalonia/Controls/Settings/Audio.axaml.cs

@@ -19,8 +19,7 @@ namespace LibationAvalonia.Controls.Settings
 			InitializeComponent();
 			if (Design.IsDesignMode)
 			{
-				_ = Configuration.Instance.LibationFiles;
-				DataContext = new AudioSettingsVM(Configuration.Instance);
+				DataContext = new AudioSettingsVM(Configuration.CreateMockInstance());
 			}
 		}
 
@@ -39,7 +38,7 @@ namespace LibationAvalonia.Controls.Settings
 			{
 				using var accounts = AudibleApiStorage.GetAccountsSettingsPersister();
 
-				if (!accounts.AccountsSettings.Accounts.Any(a => a.IdentityTokens.DeviceType == AudibleApi.Resources.DeviceType))
+				if (!accounts.AccountsSettings.Accounts.All(a => a.IdentityTokens.DeviceType == AudibleApi.Resources.DeviceType))
 				{
 					if (VisualRoot is Window parent)
 					{

Source/LibationAvalonia/Controls/Settings/DownloadDecrypt.axaml.cs

@@ -16,8 +16,7 @@ namespace LibationAvalonia.Controls.Settings
 			InitializeComponent();
 			if (Design.IsDesignMode)
 			{
-				_ = Configuration.Instance.LibationFiles;
-				DataContext = new DownloadDecryptSettingsVM(Configuration.Instance);
+				DataContext = new DownloadDecryptSettingsVM(Configuration.CreateMockInstance());
 			}
 		}
 

Source/LibationAvalonia/Controls/Settings/Import.axaml.cs

@@ -12,8 +12,7 @@ namespace LibationAvalonia.Controls.Settings
 
 			if (Design.IsDesignMode)
 			{
-				_ = Configuration.Instance.LibationFiles;
-				DataContext = new ImportSettingsVM(Configuration.Instance);
+				DataContext = new ImportSettingsVM(Configuration.CreateMockInstance());
 			}
 		}
 	}

Source/LibationAvalonia/Controls/Settings/Important.axaml

@@ -8,7 +8,7 @@
 			 x:DataType="vm:ImportantSettingsVM"
              x:Class="LibationAvalonia.Controls.Settings.Important">
 
-	<Grid RowDefinitions="Auto,Auto,Auto,*">
+	<Grid RowDefinitions="Auto,Auto,Auto,Auto,*">
 		<controls:GroupBox
 			Grid.Row="0"
 			Margin="5"
@@ -69,9 +69,16 @@
 			</StackPanel>
 
 		</controls:GroupBox>
+		<CheckBox
+			Grid.Row="1"
+			Margin="10,5"
+			IsChecked="{CompiledBinding UseWebView, Mode=TwoWay}">
+			<TextBlock Text="{CompiledBinding UseWebViewText}" />
+
+			</CheckBox>
 
 		<StackPanel
-			Grid.Row="1" Margin="5"
+			Grid.Row="2" Margin="5"
 			Orientation="Horizontal">
 
 			<TextBlock
@@ -96,7 +103,7 @@
 		</StackPanel>
 
 		<controls:GroupBox
-			Grid.Row="2"
+			Grid.Row="3"
 			Margin="5"
 			Label="Display Settings">
 			<Grid
@@ -151,7 +158,7 @@
 		</controls:GroupBox>
 
 		<Grid
-			Grid.Row="3"
+			Grid.Row="4"
 			ColumnDefinitions="Auto,Auto,*"
 			Margin="10"
 			VerticalAlignment="Bottom">

Source/LibationAvalonia/Controls/Settings/Important.axaml.cs

@@ -18,8 +18,7 @@ namespace LibationAvalonia.Controls.Settings
 			InitializeComponent();
 			if (Design.IsDesignMode)
 			{
-				_ = Configuration.Instance.LibationFiles;
-				DataContext = new ImportantSettingsVM(Configuration.Instance);
+				DataContext = new ImportantSettingsVM(Configuration.CreateMockInstance());
 			}
 
 			ThemeComboBox.SelectionChanged += ThemeComboBox_SelectionChanged;

Source/LibationAvalonia/Controls/ThemePreviewControl.axaml.cs

@@ -2,11 +2,8 @@ using Avalonia.Controls;
 using DataLayer;
 using Dinah.Core.ErrorHandling;
 using LibationAvalonia.ViewModels;
-using LibationFileManager;
 using LibationUiBase.ProcessQueue;
-using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
@@ -32,9 +29,7 @@ public partial class ThemePreviewControl : UserControl
 
 		if (Design.IsDesignMode)
 		{
-			using var ms1 = new MemoryStream();
-			App.OpenAsset("img-coverart-prod-unavailable_80x80.jpg").CopyTo(ms1);
-			PictureStorage.SetDefaultImage(PictureSize._80x80, ms1.ToArray());
+			MainVM.Configure_NonUI();
 		}
 
 		QueuedBook = new ProcessBookViewModel(sampleEntries[0]) { Status = ProcessBookStatus.Queued };
@@ -56,32 +51,12 @@ public partial class ThemePreviewControl : UserControl
 
 	private IEnumerable<LibraryBook> CreateMockBooks()
 	{
-		var author = new Contributor("Some Author", "asin_contributor");
-		var narrator = new Contributor("Some Narrator", "asin_narrator");
-
-		var book1 = new Book(new AudibleProductId("asin_book1"), "Some Book 1", "The Theming", "Demo Book Entry", 525600, ContentType.Product, [author], [narrator], "us");
-		var book2 = new Book(new AudibleProductId("asin_book2"), "Some Book 2", "The Theming", "Demo Book Entry", 525600, ContentType.Product, [author], [narrator], "us");
-		var book3 = new Book(new AudibleProductId("asin_book3"), "Some Book 3", "The Theming", "Demo Book Entry", 525600, ContentType.Product, [author], [narrator], "us");
-		var book4 = new Book(new AudibleProductId("asin_book4"), "Some Book 4", "The Theming", "Demo Book Entry", 525600, ContentType.Product, [author], [narrator], "us");
-		var seriesParent = new Book(new AudibleProductId("asin_series"), "Some Series", "", "Demo Series Entry", 0, ContentType.Parent, [author], [narrator], "us");
-		var episode = new Book(new AudibleProductId("asin_episode"), "Some Episode", "Episode 1", "Demo Episode Entry", 56, ContentType.Episode, [author], [narrator], "us");
-
-		var series = new Series(new AudibleSeriesId(seriesParent.AudibleProductId), seriesParent.Title);
-
-		seriesParent.UpsertSeries(series, "");
-		episode.UpsertSeries(series, "1");
-
-		book1.UserDefinedItem.BookStatus = LiberatedStatus.Liberated;
-		book4.UserDefinedItem.BookStatus = LiberatedStatus.Error;
-		//Set the backing field directly to preserve LiberatedStatus.PartialDownload
-		typeof(UserDefinedItem).GetField("_bookStatus", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(book2.UserDefinedItem, LiberatedStatus.PartialDownload);
-
-		yield return new LibraryBook(book1, System.DateTime.Now.AddDays(4), "someone@email.co");
-		yield return new LibraryBook(book2, System.DateTime.Now.AddDays(3), "someone@email.co");
-		yield return new LibraryBook(book3, System.DateTime.Now.AddDays(2), "someone@email.co") { AbsentFromLastScan = true };
-		yield return new LibraryBook(book4, System.DateTime.Now.AddDays(1), "someone@email.co");
-		yield return new LibraryBook(seriesParent, System.DateTime.Now, "someone@email.co");
-		yield return new LibraryBook(episode, System.DateTime.Now, "someone@email.co");
+		yield return MockLibraryBook.CreateBook(title: "Some Book 1", subtitle: "The Theming", dateAdded: System.DateTime.Now.AddDays(4)).WithBookStatus(LiberatedStatus.Liberated);
+		yield return MockLibraryBook.CreateBook(title: "Some Book 2", dateAdded: System.DateTime.Now.AddDays(3)).WithBookStatus(LiberatedStatus.PartialDownload);
+		yield return MockLibraryBook.CreateBook(title: "Some Book 3", dateAdded: System.DateTime.Now.AddDays(2), absetFromLastScan: true).WithPdfStatus(LiberatedStatus.NotLiberated);
+		yield return MockLibraryBook.CreateBook(title: "Some Book 4", dateAdded: System.DateTime.Now.AddDays(1)).WithBookStatus(LiberatedStatus.Error);
+		yield return MockLibraryBook.CreateBook(title: "Some Series", subtitle: "", contentType: ContentType.Parent).AddSeries("Some Series", 0);
+		yield return MockLibraryBook.CreateBook(title: "Some Episode", subtitle: "Episode 1", contentType: ContentType.Episode).AddSeries("Some Series", 1);
 	}
 
 	private class MockProcessable : FileLiberator.Processable

Source/LibationAvalonia/Dialogs/AboutDialog.axaml

@@ -9,15 +9,15 @@
 		xmlns:controls="clr-namespace:LibationAvalonia.Controls"
         Title="About Libation">
 	
-	<Grid Margin="10" ColumnDefinitions="Auto,*" RowDefinitions="Auto,Auto,Auto,*">
+	<Grid Margin="10" RowDefinitions="Auto,Auto,Auto,Auto,*">
 		
-		<controls:LinkLabel Grid.ColumnSpan="2" FontSize="16" FontWeight="Bold" Text="{Binding Version}" ToolTip.Tip="View Release Notes" Tapped="ViewReleaseNotes_Tapped" />
+		<controls:LinkLabel FontSize="16" FontWeight="Bold" Text="{Binding Version}" ToolTip.Tip="View Release Notes" Tapped="ViewReleaseNotes_Tapped" />
 
-		<controls:LinkLabel Grid.Column="1" FontSize="14" VerticalAlignment="Center" HorizontalAlignment="Right" Text="https://getlibation.com" Tapped="Link_getlibation"/>
+		<controls:LinkLabel Grid.Row="1" FontSize="14" VerticalAlignment="Center" Text="https://getlibation.com" Tapped="Link_getlibation"/>
 		
-		<Button Grid.Row="1" Grid.ColumnSpan="2" HorizontalAlignment="Stretch" HorizontalContentAlignment="Center" Margin="0,20,0,0"  IsEnabled="{Binding CanCheckForUpgrade}" Content="{Binding UpgradeButtonText}" Click="CheckForUpgrade_Click" />
+		<Button Grid.Row="2" HorizontalAlignment="Stretch" HorizontalContentAlignment="Center" Margin="0,10,0,0"  IsEnabled="{Binding CanCheckForUpgrade}" Content="{Binding UpgradeButtonText}" Click="CheckForUpgrade_Click" />
 
-		<Canvas Grid.Row="2" Grid.ColumnSpan="2" Margin="0,30,0,20" Width="280" Height="220">
+		<Canvas Grid.Row="3" Margin="0,30,0,20" Width="280" Height="220">
 			<Path Stretch="None" Fill="{DynamicResource IconFill}" Data="{DynamicResource LibationCheersIcon}">
 				<Path.RenderTransform>
 					<TransformGroup>
@@ -39,7 +39,7 @@
 			</Path>
 		</Canvas>
 
-		<controls:GroupBox Grid.Row="3" Label="Acknowledgements" Grid.ColumnSpan="2">
+		<controls:GroupBox Grid.Row="4" Label="Acknowledgements">
 			<StackPanel>
 				<StackPanel.Styles>
 					<Style Selector="controls|LinkLabel">

Source/LibationAvalonia/Dialogs/AboutDialog.axaml.cs

@@ -16,9 +16,6 @@ namespace LibationAvalonia.Dialogs
 		private readonly AboutVM _viewModel;
 		public AboutDialog() : base(saveAndRestorePosition:false)
 		{
-			if (Design.IsDesignMode)
-				_ = Configuration.Instance.LibationFiles;
-
 			InitializeComponent();
 
 			DataContext = _viewModel = new AboutVM();

Source/LibationAvalonia/Dialogs/BookDetailsDialog.axaml

@@ -7,6 +7,9 @@
 		Width="650" Height="500"
         x:Class="LibationAvalonia.Dialogs.BookDetailsDialog"
 		xmlns:controls="clr-namespace:LibationAvalonia.Controls"
+		xmlns:dialogs="clr-namespace:LibationAvalonia.Dialogs"
+		x:DataType="dialogs:BookDetailsDialog+BookDetailsDialogViewModel"
+		x:CompileBindings="True"
         Title="Book Details" Name="BookDetails">
 
 	<Grid RowDefinitions="*,Auto,Auto,40">
@@ -16,27 +19,32 @@
 				<Setter Property="BorderThickness" Value="2" />
 			</Style>
 		</Grid.Styles>
-		<Grid ColumnDefinitions="Auto,*" RowDefinitions="*,Auto" Margin="10,10,10,0">
-			<Panel VerticalAlignment="Top" Margin="5" Background="LightGray" Width="80" Height="80" >
-				<Image Grid.Column="0" Width="80" Height="80" Source="{Binding Cover}" />
-			</Panel>
+		<Grid ColumnDefinitions="Auto,*" RowDefinitions="Auto,*,Auto" Margin="10">
+			<Image Source="{Binding Cover}" />
 
-			<Panel Grid.Column="0" Grid.Row="1">
+			<Path
+				Grid.Row="1"
+				VerticalAlignment="Center"
+				Stretch="Uniform"
+				Width="80"
+				Fill="{DynamicResource IconFill}"
+				IsVisible="{Binding IsSpatial}"
+				Data="{StaticResource DolbyAtmosLogoVertical}" />
 
-				<controls:LinkLabel
-					Margin="10"
-					TextWrapping="Wrap"
-					TextAlignment="Center"
-					Tapped="GoToAudible_Tapped"
-					Text="Open in&#xa;Audible&#xa;(Browser)" />
-			</Panel>
+			<controls:LinkLabel
+				Grid.Row="2"
+				HorizontalAlignment="Center"
+				TextAlignment="Center"
+				VerticalAlignment="Bottom"
+				TextWrapping="Wrap"
+				Command="{Binding OpenInAudibleCommand}"
+				Text="Open in &#xa;Audible&#xa;(Browser)" />
 			
 			<TextBox
 				Grid.Column="1"
-				Grid.Row="0"
-				Grid.RowSpan="2"
+				Grid.RowSpan="3"
+				Margin="10,0,0,0"
 				TextWrapping="Wrap"
-				Margin="5"
 				FontSize="12"
 				Text="{Binding DetailsText}" />
 		</Grid>
@@ -91,6 +99,7 @@
 						MinHeight="25"
 						Height="25"
 						VerticalAlignment="Center"
+						SelectionChanged="BookStatus_SelectionChanged"
 						SelectedItem="{Binding BookLiberatedSelectedItem, Mode=TwoWay}"
 						ItemsSource="{Binding BookLiberatedItems}">
 						

Source/LibationAvalonia/Dialogs/BookDetailsDialog.axaml.cs

@@ -1,13 +1,16 @@
 using ApplicationServices;
+using Avalonia.Collections;
 using Avalonia.Controls;
 using Avalonia.Media.Imaging;
 using DataLayer;
 using Dinah.Core;
+using LibationAvalonia.Controls;
 using LibationAvalonia.ViewModels;
 using LibationFileManager;
+using ReactiveUI;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Linq;
+using System.Windows.Input;
 
 namespace LibationAvalonia.Dialogs
 {
@@ -37,8 +40,17 @@ namespace LibationAvalonia.Dialogs
 
 			if (Design.IsDesignMode)
 			{
-				using var context = DbContexts.GetContext();
-				LibraryBook = context.GetLibraryBook_Flat_NoTracking("B017V4IM1G");
+				MainVM.Configure_NonUI();
+				LibraryBook
+					= MockLibraryBook
+					.CreateBook(isSpatial: true)
+					.AddAuthor("Author 2")
+					.AddNarrator("Narrator 2")
+					.AddSeries("Series Name", 1)
+					.AddCategoryLadder("Parent", "Child Category")
+					.AddCategoryLadder("Parent", "Child Category 2")
+					.WithBookStatus(LiberatedStatus.NotLiberated)
+					.WithPdfStatus(LiberatedStatus.Liberated);
 			}
 		}
 		public BookDetailsDialog(LibraryBook libraryBook) : this()
@@ -52,53 +64,47 @@ namespace LibationAvalonia.Dialogs
 			base.SaveAndClose();
 		}
 
-		public void GoToAudible_Tapped(object sender, Avalonia.Input.TappedEventArgs e)
+		public void BookStatus_SelectionChanged(object sender, SelectionChangedEventArgs e)
 		{
-			var locale = AudibleApi.Localization.Get(_libraryBook.Book.Locale);
-			var link = $"https://www.audible.{locale.TopDomain}/pd/{_libraryBook.Book.AudibleProductId}";
-			Go.To.Url(link);
+			if (sender is not WheelComboBox { SelectedItem: liberatedComboBoxItem { Status: LiberatedStatus.Error } } &&
+				_viewModel.BookLiberatedItems.SingleOrDefault(s => s.Status == LiberatedStatus.Error) is liberatedComboBoxItem errorItem)
+			{
+				_viewModel.BookLiberatedItems.Remove(errorItem);
+			}
 		}
 
 		public void SaveButton_Clicked(object sender, Avalonia.Interactivity.RoutedEventArgs e)
 			=> SaveAndClose();
-
-		private class BookDetailsDialogViewModel : ViewModelBase
+		public class liberatedComboBoxItem
 		{
-			public class liberatedComboBoxItem
-			{
-				public LiberatedStatus Status { get; set; }
-				public string Text { get; set; }
-				public override string ToString() => Text;
-			}
+			public LiberatedStatus Status { get; set; }
+			public string Text { get; set; }
+			public override string ToString() => Text;
+		}
 
+		public class BookDetailsDialogViewModel : ViewModelBase
+		{
 			public Bitmap Cover { get; set; }
 			public string DetailsText { get; set; }
 			public string Tags { get; set; }
+			public bool IsSpatial { get; }
 
 			public bool HasPDF => PdfLiberatedItems?.Count > 0;
-
-			private liberatedComboBoxItem _bookLiberatedSelectedItem;
-			public ObservableCollection<liberatedComboBoxItem> BookLiberatedItems { get; } = new();
+			public AvaloniaList<liberatedComboBoxItem> BookLiberatedItems { get; } = new();
 			public List<liberatedComboBoxItem> PdfLiberatedItems { get; } = new();
 			public liberatedComboBoxItem PdfLiberatedSelectedItem { get; set; }
-
-			public liberatedComboBoxItem BookLiberatedSelectedItem
-			{
-				get => _bookLiberatedSelectedItem;
-				set
-				{
-					_bookLiberatedSelectedItem = value;
-					if (value?.Status is not LiberatedStatus.Error)
-					{
-						BookLiberatedItems.Remove(BookLiberatedItems.SingleOrDefault(s => s.Status == LiberatedStatus.Error));
-					}
-				}
-			}
+			public liberatedComboBoxItem BookLiberatedSelectedItem { get; set; }
+			public ICommand OpenInAudibleCommand { get; }
 
 			public BookDetailsDialogViewModel(LibraryBook libraryBook)
 			{
 				var Book = libraryBook.Book;
 
+				var locale = AudibleApi.Localization.Get(libraryBook.Book.Locale);
+				var link = $"https://www.audible.{locale.TopDomain}/pd/{libraryBook.Book.AudibleProductId}";
+				OpenInAudibleCommand = ReactiveCommand.Create(() => Go.To.Url(link));
+				IsSpatial = libraryBook.Book.IsSpatial;
+
 				//init tags
 				Tags = libraryBook.Book.UserDefinedItem.Tags;
 

Source/LibationAvalonia/Dialogs/DialogWindow.cs

@@ -16,6 +16,7 @@ namespace LibationAvalonia.Dialogs
 		public bool SaveAndRestorePosition { get; set; }
 		public Control ControlToFocusOnShow { get; set; }
 		protected override Type StyleKeyOverride => typeof(DialogWindow);
+		public DialogResult DialogResult { get; private set; } = DialogResult.None;
 
 		public DialogWindow(bool saveAndRestorePosition = true)
 		{
@@ -27,7 +28,15 @@ namespace LibationAvalonia.Dialogs
 			Closing += DialogWindow_Closing;
 
 			if (Design.IsDesignMode)
-				RequestedThemeVariant = ThemeVariant.Dark;
+			{
+				var themeVariant = Configuration.CreateMockInstance().GetString(propertyName: nameof(ThemeVariant));
+				RequestedThemeVariant = themeVariant switch
+				{
+					nameof(ThemeVariant.Dark) => ThemeVariant.Dark,
+					nameof(ThemeVariant.Light) => ThemeVariant.Light,
+					_ => ThemeVariant.Default,
+				};
+			}
 		}
 
 		private void DialogWindow_Loaded(object sender, Avalonia.Interactivity.RoutedEventArgs e)
@@ -66,6 +75,12 @@ namespace LibationAvalonia.Dialogs
 			ControlToFocusOnShow?.Focus();
 		}
 
+		public void Close(DialogResult dialogResult)
+		{
+			DialogResult = dialogResult;
+			base.Close(dialogResult);
+		}
+
 		protected virtual void SaveAndClose() => Close(DialogResult.OK);
 		protected virtual async Task SaveAndCloseAsync() => await Avalonia.Threading.Dispatcher.UIThread.InvokeAsync(SaveAndClose);
 		protected virtual void CancelAndClose() => Close(DialogResult.Cancel);

Source/LibationAvalonia/Dialogs/EditReplacementChars.axaml

@@ -2,92 +2,80 @@
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-        mc:Ignorable="d" d:DesignWidth="500" d:DesignHeight="450"
-		MinWidth="500" MinHeight="450"
-		Width="500" Height="450"
+        mc:Ignorable="d" d:DesignWidth="450" d:DesignHeight="450"
+		MinWidth="450" MinHeight="450"
+		Width="450" Height="450"
         x:Class="LibationAvalonia.Dialogs.EditReplacementChars"
 		xmlns:dialogs="clr-namespace:LibationAvalonia.Dialogs"
+		xmlns:controls="clr-namespace:LibationAvalonia.Controls"
 		x:DataType="dialogs:EditReplacementChars"
-        Title="Illegal Character Replacement">
-
-	<Grid
-		RowDefinitions="*,Auto"
-		ColumnDefinitions="*,Auto">
+		x:CompileBindings="True"
+		Title="File Path Character Replacement">
 
+	<Grid RowDefinitions="*,Auto">
 		<DataGrid
 			Grid.Row="0"
 			Grid.ColumnSpan="2"
-			GridLinesVisibility="All"
 			Margin="5"
-			Name="replacementGrid"
-			AutoGenerateColumns="False"
 			IsReadOnly="False"
-			BeginningEdit="ReplacementGrid_BeginningEdit"
-			CellEditEnding="ReplacementGrid_CellEditEnding"
-			KeyDown="ReplacementGrid_KeyDown"
-			ItemsSource="{CompiledBinding replacements}">
-
+			GridLinesVisibility="All"
+			CanUserSortColumns="False"
+			AutoGenerateColumns="False"
+			ItemsSource="{Binding Replacements}"
+			KeyDown="replacementGrid_KeyDown"
+			BeginningEdit="replacementGrid_BeginningEdit"
+			CellEditEnded="replacementGrid_CellEditEnded"
+			CellEditEnding="replacementGrid_CellEditEnding">
 			<DataGrid.Columns>
 
-				<DataGridTemplateColumn Header="Char to&#xa;Replace">
-					<DataGridTemplateColumn.CellTemplate>
-						<DataTemplate x:DataType="dialogs:EditReplacementChars+ReplacementsExt">
-							<TextBox IsReadOnly="{CompiledBinding Mandatory}" Text="{CompiledBinding CharacterToReplace, Mode=TwoWay}" />
-						</DataTemplate>
-					</DataGridTemplateColumn.CellTemplate>
-				</DataGridTemplateColumn>
-				
-				<DataGridTemplateColumn Header="Replacement&#xa;Text">
-					<DataGridTemplateColumn.CellTemplate>
-						<DataTemplate x:DataType="dialogs:EditReplacementChars+ReplacementsExt">
-							<TextBox Text="{CompiledBinding ReplacementText, Mode=TwoWay}" />
-						</DataTemplate>
-					</DataGridTemplateColumn.CellTemplate>
-				</DataGridTemplateColumn>
+				<controls:DataGridTextColumnExt
+					x:DataType="dialogs:EditReplacementChars+ReplacementsExt"
+					MaxLength="1"
+					Header="Char to&#xa;Replace"
+					Binding="{Binding CharacterToReplace, Mode=TwoWay}"/>
 
-				<DataGridTemplateColumn Width="*" Header="Description">
-					<DataGridTemplateColumn.CellTemplate>
-						<DataTemplate x:DataType="dialogs:EditReplacementChars+ReplacementsExt">
-							<TextBox IsReadOnly="{CompiledBinding Mandatory}" Text="{CompiledBinding Description, Mode=TwoWay}" />
-						</DataTemplate>
-					</DataGridTemplateColumn.CellTemplate>
-				</DataGridTemplateColumn>
+				<DataGridTextColumn
+					x:DataType="dialogs:EditReplacementChars+ReplacementsExt"
+					Header="Replacement&#xa;Text"
+					Binding="{Binding ReplacementText, Mode=TwoWay}"/>
+            
+				<DataGridTextColumn
+					x:DataType="dialogs:EditReplacementChars+ReplacementsExt"
+					Header="Description"
+					Binding="{Binding Description, Mode=TwoWay}"/>
 
 			</DataGrid.Columns>
 		</DataGrid>
 
 		<Grid
 			Grid.Row="1"
-			Grid.Column="0"
 			RowDefinitions="Auto,Auto"
-			Margin="5"
-			ColumnDefinitions="Auto,Auto,Auto,Auto">
+			ColumnDefinitions="Auto,Auto,Auto,*,Auto,Auto"
+			Margin="5">
+			<Grid.Styles>
+				<Style Selector="Button">
+					<Setter Property="Margin" Value="2"/>
+					<Setter Property="Padding" Value="6"/>
+					<Setter Property="VerticalAlignment" Value="Bottom"/>
+				</Style>
+				<Style Selector="TextBlock">
+					<Setter Property="VerticalAlignment" Value="Center"/>
+				</Style>
+			</Grid.Styles>
 
-			<TextBlock IsVisible="{CompiledBinding !EnvironmentIsWindows}" Text="This System:" Margin="0,0,10,0" VerticalAlignment="Center" />
-			<TextBlock IsVisible="{CompiledBinding !EnvironmentIsWindows}" Grid.Row="1" Text="NTFS:" Margin="0,0,10,0" VerticalAlignment="Center" />
+			<TextBlock Grid.Row="0" Text="This&#xa;System:" IsVisible="{Binding !EnvironmentIsWindows}" />
+			<TextBlock Grid.Row="1" Text="NTFS:" IsVisible="{Binding !EnvironmentIsWindows}" />
 
-			<Button Grid.Column="1" Margin="0,0,10,0" Command="{CompiledBinding Defaults}" CommandParameter="{CompiledBinding EnvironmentIsWindows}" Content="Defaults" />
-			<Button Grid.Column="2" Margin="0,0,10,0" Command="{CompiledBinding LoFiDefaults}" CommandParameter="{CompiledBinding EnvironmentIsWindows}" Content="LoFi Defaults" />
-			<Button Grid.Column="3" Command="{CompiledBinding Barebones}" CommandParameter="{CompiledBinding EnvironmentIsWindows}" Content="Barebones" />
+			<Button Grid.Column="1" Command="{Binding Defaults}" CommandParameter="{Binding EnvironmentIsWindows}" Content="Defaults" />
+			<Button Grid.Column="2" Command="{Binding LoFiDefaults}" CommandParameter="{Binding EnvironmentIsWindows}" Content="LoFi Defaults" />
+			<Button Grid.Column="3" Command="{Binding Barebones}" CommandParameter="{Binding EnvironmentIsWindows}" Content="Barebones" />
 
-			<Button IsVisible="{CompiledBinding !EnvironmentIsWindows}" Grid.Row="1" Grid.Column="1" Margin="0,10,10,0" Command="{CompiledBinding Defaults}" CommandParameter="True" Content="Defaults" />
-			<Button IsVisible="{CompiledBinding !EnvironmentIsWindows}" Grid.Row="1" Grid.Column="2" Margin="0,10,10,0" Command="{CompiledBinding LoFiDefaults}" CommandParameter="True" Content="LoFi Defaults" />
-			<Button IsVisible="{CompiledBinding !EnvironmentIsWindows}" Grid.Row="1" Grid.Column="3" Margin="0,10,0,0" Command="{CompiledBinding Barebones}" CommandParameter="True" Content="Barebones" />
-
-		</Grid>
-
-		<StackPanel
-			Grid.Row="1"
-			Grid.Column="1"
-			Margin="5"
-			VerticalAlignment="Bottom"
-			Orientation="Horizontal">
-
-			<Button Margin="0,0,10,0" Command="{Binding Close}" Content="Cancel" />
-			<Button Padding="20,5,20,6" Command="{Binding SaveAndClose}" Content="Save" />
-		</StackPanel>
-		
-	</Grid>
-	
-	
+			<Button Grid.Row="1" Grid.Column="1" IsVisible="{Binding !EnvironmentIsWindows}" Command="{Binding Defaults}" CommandParameter="True" Content="Defaults" />
+			<Button Grid.Row="1" Grid.Column="2" IsVisible="{Binding !EnvironmentIsWindows}" Command="{Binding LoFiDefaults}" CommandParameter="True" Content="LoFi Defaults" />
+			<Button Grid.Row="1" Grid.Column="3" IsVisible="{Binding !EnvironmentIsWindows}" Command="{Binding Barebones}" CommandParameter="True" Content="Barebones" />
+						
+			<Button Grid.RowSpan="2" Grid.Column="4" Command="{Binding Close}" Content="Cancel" />
+			<Button Grid.RowSpan="2" Grid.Column="5" Padding="20,6" Command="{Binding SaveAndClose}" Content="Save" />
+		</Grid>	
+	</Grid>	
 </Window>

Source/LibationAvalonia/Dialogs/EditReplacementChars.axaml.cs

@@ -1,27 +1,27 @@
 using Avalonia.Collections;
 using Avalonia.Controls;
-using Avalonia.Data;
 using FileManager;
 using LibationFileManager;
 using ReactiveUI;
 using System.Collections.Generic;
 using System.Linq;
 
+#nullable enable
 namespace LibationAvalonia.Dialogs
 {
 	public partial class EditReplacementChars : DialogWindow
 	{
-		Configuration config;
+		private Configuration? Config { get; }
 
 		public bool EnvironmentIsWindows => Configuration.IsWindows;
 
-		private readonly List<ReplacementsExt> SOURCE = new();
-		public DataGridCollectionView replacements { get; }
+		private readonly AvaloniaList<ReplacementsExt> SOURCE = new();
+		public DataGridCollectionView Replacements { get; }
 		public EditReplacementChars()
 		{
 			InitializeComponent();
 
-			replacements = new(SOURCE);
+			Replacements = new(SOURCE);
 
 			if (Design.IsDesignMode)
 			{
@@ -33,7 +33,7 @@ namespace LibationAvalonia.Dialogs
 
 		public EditReplacementChars(Configuration config) : this()
 		{
-			this.config = config;
+			Config = config;
 			LoadTable(config.ReplacementCharacters.Replacements);
 		}
 
@@ -44,15 +44,14 @@ namespace LibationAvalonia.Dialogs
 		public void Barebones(bool isNtfs)
 			=> LoadTable(ReplacementCharacters.Barebones(isNtfs).Replacements);
 
-		protected override void SaveAndClose()
+		public new void Close() => base.Close();
+		public new void SaveAndClose()
 		{
-			var replacements = SOURCE
-				.Where(r => !r.IsDefault)
-				.Select(r => new Replacement(r.Character, r.ReplacementText, r.Description) { Mandatory = r.Mandatory })
-				.ToList();
-
-			if (config is not null)
-				config.ReplacementCharacters = new ReplacementCharacters { Replacements = replacements };
+			if (Config is not null)
+			{
+				var replacements = SOURCE.Where(r => !r.IsDefault).Select(r => r.ToReplacement()).ToArray();
+				Config.ReplacementCharacters = new ReplacementCharacters { Replacements = replacements };
+			}
 			base.SaveAndClose();
 		}
 
@@ -61,59 +60,64 @@ namespace LibationAvalonia.Dialogs
 			SOURCE.Clear();
 			SOURCE.AddRange(replacements.Select(r => new ReplacementsExt(r)));
 			SOURCE.Add(new ReplacementsExt());
-			this.replacements.Refresh();
 		}
 
-		public void ReplacementGrid_KeyDown(object sender, Avalonia.Input.KeyEventArgs e)
+		private bool ColumnIsCharacter(DataGridColumn column)
+			=> column.DisplayIndex is 0;
+
+		private bool ColumnIsReplacement(DataGridColumn column)
+			=> column.DisplayIndex is 1;
+
+		private bool RowIsReadOnly(DataGridRow row)
+			=> row.DataContext is ReplacementsExt rep && rep.Mandatory;
+
+		private bool CanDeleteSelectedItem(ReplacementsExt selectedItem)
+			=> !selectedItem.Mandatory && (!selectedItem.IsDefault || SOURCE[^1] != selectedItem);
+
+		private void replacementGrid_BeginningEdit(object sender, DataGridBeginningEditEventArgs e)
 		{
-			if (e.Key == Avalonia.Input.Key.Delete
-				&& ((DataGrid)sender).SelectedItem is ReplacementsExt repl
-				&& !repl.Mandatory
-				&& !repl.IsDefault)
-			{
-				replacements.Remove(repl);
-			}
+			e.Cancel = RowIsReadOnly(e.Row) && !ColumnIsReplacement(e.Column);
 		}
 
-		public void ReplacementGrid_CellEditEnding(object sender, DataGridCellEditEndingEventArgs e)
+		private void replacementGrid_CellEditEnding(object? sender, DataGridCellEditEndingEventArgs e)
 		{
-			var replacement = e.Row.DataContext as ReplacementsExt;
-			var colBinding = columnBindingPath(e.Column);
-
-			//Prevent duplicate CharacterToReplace
-			if (e.EditingElement is TextBox tbox
-				&& colBinding == nameof(replacement.CharacterToReplace)
-				&& SOURCE.Any(r => r != replacement && r.CharacterToReplace == tbox.Text))
+			//Disallow duplicates of CharacterToReplace
+			if (ColumnIsCharacter(e.Column) && e.Row.DataContext is ReplacementsExt r && r.CharacterToReplace.Length > 0 && SOURCE.Count(rep => rep.CharacterToReplace == r.CharacterToReplace) > 1)
 			{
-				tbox.Text = replacement.CharacterToReplace;
-			}
-
-			//Add new blank row
-			void Replacement_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
-			{
-				if (!SOURCE.Any(r => r.IsDefault))
-				{
-					var rewRepl = new ReplacementsExt();
-					SOURCE.Add(rewRepl);
-				}
-				replacement.PropertyChanged -= Replacement_PropertyChanged;
-			}
-
-			replacement.PropertyChanged += Replacement_PropertyChanged;
-		}
-
-		public void ReplacementGrid_BeginningEdit(object sender, DataGridBeginningEditEventArgs e)
-		{
-			var replacement = e.Row.DataContext as ReplacementsExt;
-
-			//Disallow editing of Mandatory CharacterToReplace and Descriptions
-			if (replacement.Mandatory
-				&& columnBindingPath(e.Column) != nameof(replacement.ReplacementText))
+				r.CharacterToReplace = "";
 				e.Cancel = true;
+			}
 		}
 
-		private static string columnBindingPath(DataGridColumn column)
-			=> ((Binding)((DataGridBoundColumn)column).Binding).Path;
+		private void replacementGrid_CellEditEnded(object? sender, DataGridCellEditEndedEventArgs e)
+		{
+			if (ColumnIsCharacter(e.Column) && e.Row.DataContext is ReplacementsExt r && r.CharacterToReplace.Length > 0 && !SOURCE[^1].IsDefault)
+			{
+				Replacements.AddNew();
+			}
+		}
+
+		private void replacementGrid_KeyDown(object? sender, Avalonia.Input.KeyEventArgs e)
+		{
+			if (e.Key == Avalonia.Input.Key.Delete && (sender as DataGrid)?.SelectedItem is ReplacementsExt r && CanDeleteSelectedItem(r))
+			{
+				if (Replacements.IsEditingItem)
+				{
+					if (Replacements.CanCancelEdit)
+						Replacements.CancelEdit();
+					else
+						Replacements.CommitEdit();
+				}
+				if (Replacements.IsAddingNew)
+				{
+					Replacements.CancelNew();
+				}
+				if (Replacements.CanRemove)
+				{
+					Replacements.Remove(r);
+				}
+			}
+		}
 
 		public class ReplacementsExt : ViewModels.ViewModelBase
 		{
@@ -122,7 +126,6 @@ namespace LibationAvalonia.Dialogs
 				_replacementText = string.Empty;
 				_description = string.Empty;
 				_characterToReplace = string.Empty;
-				IsDefault = true;
 			}
 			public ReplacementsExt(Replacement replacement)
 			{
@@ -131,41 +134,19 @@ namespace LibationAvalonia.Dialogs
 				_description = replacement.Description;
 				Mandatory = replacement.Mandatory;
 			}
+
 			private string _replacementText;
 			private string _description;
 			private string _characterToReplace;
-			public bool Mandatory { get; }
-			public string ReplacementText
-			{
-				get => _replacementText;
-				set
-				{
-					if (ReplacementCharacters.ContainsInvalidFilenameChar(value))
-						this.RaisePropertyChanged(nameof(ReplacementText));
-					else
-						this.RaiseAndSetIfChanged(ref _replacementText, value);
-				}
-			}
-
+			public string ReplacementText { get => _replacementText; set => this.RaiseAndSetIfChanged(ref _replacementText, value); }
 			public string Description { get => _description; set => this.RaiseAndSetIfChanged(ref _description, value); }
-
-			public string CharacterToReplace
-			{
-				get => _characterToReplace;
-
-				set
-				{
-					if (value?.Length != 1)
-						this.RaisePropertyChanged(nameof(CharacterToReplace));
-					else
-					{
-						IsDefault = false;
-						this.RaiseAndSetIfChanged(ref _characterToReplace, value);
-					}
-				}
-			}
+			public string CharacterToReplace { get => _characterToReplace; set => this.RaiseAndSetIfChanged(ref _characterToReplace, value); }
 			public char Character => string.IsNullOrEmpty(_characterToReplace) ? default : _characterToReplace[0];
-			public bool IsDefault { get; private set; }
+			public bool IsDefault => !Mandatory && string.IsNullOrEmpty(CharacterToReplace);
+			public bool Mandatory { get; }
+
+			public Replacement ToReplacement()
+				=> new(Character, ReplacementText, Description) { Mandatory = Mandatory };
 		}
 	}
 }

Source/LibationAvalonia/Dialogs/EditTemplateDialog.axaml.cs

@@ -25,10 +25,11 @@ public partial class EditTemplateDialog : DialogWindow
 
 		if (Design.IsDesignMode)
 		{
-			_ = Configuration.Instance.LibationFiles;
+			var mockInstance = Configuration.CreateMockInstance();
+			mockInstance.Books = Configuration.DefaultBooksDirectory;
 			RequestedThemeVariant  = ThemeVariant.Dark;
-			var editor = TemplateEditor<Templates.FileTemplate>.CreateFilenameEditor(Configuration.Instance.Books, Configuration.Instance.FileTemplate);
-			_viewModel = new(Configuration.Instance, editor);
+			var editor = TemplateEditor<Templates.FileTemplate>.CreateFilenameEditor(mockInstance.Books, mockInstance.FileTemplate);
+			_viewModel = new(mockInstance, editor);
 			_viewModel.ResetTextBox(editor.EditingTemplate.TemplateText);
 			Title = $"Edit {editor.TemplateName}";
 			DataContext = _viewModel;

Source/LibationAvalonia/Dialogs/Login/ApprovalNeededDialog.axaml

@@ -1,34 +0,0 @@
-<Window xmlns="https://github.com/avaloniaui"
-        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-        mc:Ignorable="d" d:DesignWidth="240" d:DesignHeight="140"
-		MinWidth="240" MinHeight="140"
-		MaxWidth="240" MaxHeight="140"
-		Width="240" Height="140"
-		WindowStartupLocation="CenterOwner"
-        x:Class="LibationAvalonia.Dialogs.Login.ApprovalNeededDialog"
-        Title="Approval Alert Detected">
-
-	<Grid RowDefinitions="Auto,Auto,*">
-
-		<TextBlock
-			Grid.Row="0"
-			Margin="10"
-			TextWrapping="Wrap"
-			Text="Amazon is sending you an email."/>
-		
-		<TextBlock
-			Grid.Row="1" Margin="10,0,10,0"
-			TextWrapping="Wrap"
-			Text="Please press this button after you've approved the notification."/>
-		
-		<Button
-			Grid.Row="2" 
-			Margin="10"
-			VerticalAlignment="Bottom"
-			Padding="30,3,30,3"
-			Content="Approve"
-			Click="Approve_Click" />
-	</Grid>
-</Window>

Source/LibationAvalonia/Dialogs/Login/ApprovalNeededDialog.axaml.cs

@@ -1,22 +0,0 @@
-using System.Threading.Tasks;
-
-namespace LibationAvalonia.Dialogs.Login
-{
-	public partial class ApprovalNeededDialog : DialogWindow
-	{
-		public ApprovalNeededDialog() : base(saveAndRestorePosition: false)
-		{
-			InitializeComponent();
-		}
-
-		protected override Task SaveAndCloseAsync()
-		{
-			Serilog.Log.Logger.Information("Approve button clicked");
-
-			return base.SaveAndCloseAsync();
-		}
-
-		public async void Approve_Click(object sender, Avalonia.Interactivity.RoutedEventArgs e)
-			=> await SaveAndCloseAsync();
-	}
-}

Source/LibationAvalonia/Dialogs/Login/AvaloniaLoginCallback.cs

@@ -1,63 +1,19 @@
 using AudibleApi;
-using AudibleUtilities;
-using Avalonia.Threading;
-using LibationUiBase.Forms;
 using System.Threading.Tasks;
 
 namespace LibationAvalonia.Dialogs.Login
 {
 	public class AvaloniaLoginCallback : ILoginCallback
 	{
-		private Account _account { get; }
-
 		public string DeviceName { get; } = "Libation";
 
-		public AvaloniaLoginCallback(Account account)
-		{
-			_account = Dinah.Core.ArgumentValidator.EnsureNotNull(account, nameof(account));
-		}
-
-		public async Task<string> Get2faCodeAsync(string prompt)
-			=> await Dispatcher.UIThread.InvokeAsync(async () =>
-			{
-				var dialog = new _2faCodeDialog(prompt);
-				if (await dialog.ShowDialogAsync() is DialogResult.OK)
-					return dialog.Code;
-				return null;
-			});
-
-		public async Task<(string password, string guess)> GetCaptchaAnswerAsync(string password, byte[] captchaImage)
-			=> await Dispatcher.UIThread.InvokeAsync(async () =>
-			{
-				var dialog = new CaptchaDialog(password, captchaImage);
-				if (await dialog.ShowDialogAsync() is DialogResult.OK)
-					return (dialog.Password, dialog.Answer);
-				return (null, null);
-			});
-
-		public async Task<(string name, string value)> GetMfaChoiceAsync(MfaConfig mfaConfig)
-			=> await Dispatcher.UIThread.InvokeAsync(async () =>
-			{
-				var dialog = new MfaDialog(mfaConfig);
-				if (await dialog.ShowDialogAsync() is DialogResult.OK)
-					return (dialog.SelectedName, dialog.SelectedValue);
-				return (null, null);
-			});
-
-		public async Task<(string email, string password)> GetLoginAsync()
-			=> await Dispatcher.UIThread.InvokeAsync(async () =>
-			{
-				var dialog = new LoginCallbackDialog(_account);
-				if (await dialog.ShowDialogAsync() is DialogResult.OK)
-					return (_account.AccountId, dialog.Password);
-				return (null, null);
-			});
-
-		public async Task ShowApprovalNeededAsync()
-			=> await Dispatcher.UIThread.InvokeAsync(async () =>
-			{
-				var dialog = new ApprovalNeededDialog();
-				await dialog.ShowDialogAsync();
-			});
+		public Task<string> Get2faCodeAsync(string prompt) => throw new System.NotSupportedException();
+		public Task<(string password, string guess)> GetCaptchaAnswerAsync(string password, byte[] captchaImage)
+			 => throw new System.NotSupportedException();
+		public Task<(string name, string value)> GetMfaChoiceAsync(MfaConfig mfaConfig)
+			 => throw new System.NotSupportedException();
+		public Task<(string email, string password)> GetLoginAsync()
+			 => throw new System.NotSupportedException();
+		public Task ShowApprovalNeededAsync() => throw new System.NotSupportedException();
 	}
 }

Source/LibationAvalonia/Dialogs/Login/AvaloniaLoginChoiceEager.cs

@@ -1,5 +1,6 @@
 using AudibleApi;
 using AudibleUtilities;
+using Avalonia.Controls;
 using Avalonia.Threading;
 using LibationFileManager;
 using LibationUiBase.Forms;
@@ -11,14 +12,13 @@ namespace LibationAvalonia.Dialogs.Login
 {
 	public class AvaloniaLoginChoiceEager : ILoginChoiceEager
 	{
-		public ILoginCallback LoginCallback { get; }
+		public ILoginCallback LoginCallback { get; } = new AvaloniaLoginCallback();
 
 		private readonly Account _account;
 
 		public AvaloniaLoginChoiceEager(Account account)
 		{
 			_account = Dinah.Core.ArgumentValidator.EnsureNotNull(account, nameof(account));
-			LoginCallback = new AvaloniaLoginCallback(_account);
 		}
 
 		public async Task<ChoiceOut?> StartAsync(ChoiceIn choiceIn)
@@ -26,41 +26,84 @@ namespace LibationAvalonia.Dialogs.Login
 
 		private async Task<ChoiceOut?> StartAsyncInternal(ChoiceIn choiceIn)
 		{
-			if (Configuration.IsWindows && Environment.OSVersion.Version.Major >= 10)
+			try
 			{
-				try
-				{
-					var weblogin = new WebLoginDialog(_account.AccountId, choiceIn.LoginUrl);
-					if (await weblogin.ShowDialogAsync(App.MainWindow) is DialogResult.OK)
-						return ChoiceOut.External(weblogin.ResponseUrl);
-				}
-				catch (Exception ex)
-				{
-					Serilog.Log.Logger.Error(ex, $"Failed to run {nameof(WebLoginDialog)}");
-				}
+				if (Configuration.Instance.UseWebView && await BrowserLoginAsync(choiceIn.LoginUrl) is ChoiceOut external)
+					return external;
+			}
+			catch (Exception ex)
+			{
+				Serilog.Log.Logger.Error(ex, $"Failed to use the {nameof(NativeWebDialog)}");
 			}
 
-			var dialog = new LoginChoiceEagerDialog(_account);
+			var externalDialog = new LoginExternalDialog(_account, choiceIn.LoginUrl);
+			return await externalDialog.ShowDialogAsync() is DialogResult.OK
+				? ChoiceOut.External(externalDialog.ResponseUrl)
+				: null;
+		}
 
-			if (await dialog.ShowDialogAsync() is not DialogResult.OK ||
-				(dialog.LoginMethod is LoginMethod.Api && string.IsNullOrWhiteSpace(dialog.Password)))
-				return null;
+		private async Task<ChoiceOut?> BrowserLoginAsync(string url)
+		{
+			TaskCompletionSource<ChoiceOut?> tcs = new();
 
-			switch (dialog.LoginMethod)
+			NativeWebDialog dialog = new()
 			{
-				case LoginMethod.Api:
-					return ChoiceOut.WithApi(dialog.Account.AccountId, dialog.Password);
-				case LoginMethod.External:
-					{
-						var externalDialog = new LoginExternalDialog(_account, choiceIn.LoginUrl);
-						return await externalDialog.ShowDialogAsync() is DialogResult.OK
-							? ChoiceOut.External(externalDialog.ResponseUrl)
-							: null;
-					}
-				default:
-					throw new Exception($"Unknown {nameof(LoginMethod)} value");
+				Title = "Audible Login",
+				CanUserResize = true,
+				Source = new Uri(url)
+			};
+
+			dialog.AdapterCreated += Dialog_AdapterCreated;
+			dialog.NavigationCompleted += Dialog_NavigationCompleted;
+			dialog.Closing += (_, _) => tcs.TrySetResult(null);
+			dialog.NavigationStarted += (_, e) =>
+			{
+				if (e.Request?.AbsolutePath.StartsWith("/ap/maplanding") is true)
+				{
+					tcs.TrySetResult(ChoiceOut.External(e.Request.ToString()));
+					dialog.Close();
+				}
+			};
+
+			if (!Configuration.IsLinux && App.MainWindow is TopLevel topLevel)
+				dialog.Show(topLevel);
+			else
+				dialog.Show();
+
+			return await tcs.Task;
+		}
+
+		private async void Dialog_NavigationCompleted(object? sender, WebViewNavigationCompletedEventArgs e)
+		{
+			if (e.IsSuccess && sender is NativeWebDialog dialog)
+			{
+				await dialog.InvokeScript(getScript(_account.AccountId));
 			}
 		}
 
+		private void Dialog_AdapterCreated(object? sender, WebViewAdapterEventArgs e)
+		{
+			if ((sender as NativeWebDialog)?.TryGetWindow() is Window window)
+			{
+				window.Width = 450;
+				window.Height = 700;
+			}
+		}
+
+		private static string getScript(string accountID) => $$"""
+			(function() {
+				function populateForm(){
+					var email = document.querySelector("input[id='ap_email_login']");
+					if (email !== null)
+						email.value = '{{accountID}}';
+					
+					var pass = document.querySelector("input[name='password']");
+					if (pass !== null)
+						pass.focus();
+				}
+				window.addEventListener("load", (event) => { populateForm(); });
+				populateForm();
+			})()
+			""";
 	}
 }

Source/LibationAvalonia/Dialogs/Login/CaptchaDialog.axaml

@@ -1,72 +0,0 @@
-<Window xmlns="https://github.com/avaloniaui"
-        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-        mc:Ignorable="d" d:DesignWidth="220" d:DesignHeight="250"
-		MinWidth="220" MinHeight="250"
-		MaxWidth="220" MaxHeight="250"
-		Width="220" Height="250"
-		WindowStartupLocation="CenterOwner"
-        x:Class="LibationAvalonia.Dialogs.Login.CaptchaDialog"
-        Title="CAPTCHA">
-
-	<Grid
-		RowDefinitions="Auto,Auto,Auto,Auto,*"
-		ColumnDefinitions="Auto,*" 
-			Margin="10">
-		
-		<Panel
-			Grid.Row="0"
-			Grid.Column="0"
-			Grid.ColumnSpan="2"
-			MinWidth="200"
-			MinHeight="70"
-			Background="LightGray">
-			
-			<Image
-				Stretch="None"
-				Source="{Binding CaptchaImage}" />
-			
-		</Panel>
-		
-		<TextBlock
-			Grid.Row="1"
-			Margin="0,10,0,0"
-			VerticalAlignment="Center"
-			Text="Password:" />
-
-		<TextBox
-			Name="passwordBox"
-			Grid.Row="2"
-			Grid.Column="0"
-			Grid.ColumnSpan="2"
-			Margin="0,10,0,0"
-			PasswordChar="*"
-			Text="{Binding Password, Mode=TwoWay}" />
-		
-		<TextBlock
-			Grid.Row="3"
-			Grid.Column="0"
-			Margin="0,10,10,0"
-			VerticalAlignment="Center"
-			Text="CAPTCHA&#xa;answer:" />
-		
-		<TextBox
-			Name="captchaBox"
-			Grid.Row="3"
-			Grid.Column="1"
-			Margin="0,10,0,0"
-			Text="{Binding Answer, Mode=TwoWay}" />
-		
-		<Button
-			Grid.Row="4"
-			Grid.Column="1"
-			Padding="0,5,0,5"
-			VerticalAlignment="Bottom"
-			HorizontalAlignment="Stretch"
-			HorizontalContentAlignment="Center"
-			Content="Submit"
-			Click="Submit_Click" />
-		
-	</Grid>
-</Window>

Source/LibationAvalonia/Dialogs/Login/CaptchaDialog.axaml.cs

@@ -1,120 +0,0 @@
-using Avalonia.Controls;
-using Avalonia.Media.Imaging;
-using LibationAvalonia.ViewModels;
-using ReactiveUI;
-using System.IO;
-using System.Threading.Tasks;
-
-namespace LibationAvalonia.Dialogs.Login
-{
-	public partial class CaptchaDialog : DialogWindow
-	{
-		public string Password => _viewModel.Password;
-		public string Answer => _viewModel.Answer;
-
-		private readonly CaptchaDialogViewModel _viewModel;
-		public CaptchaDialog() : base(saveAndRestorePosition: false)
-		{
-			InitializeComponent();
-			passwordBox = this.FindControl<TextBox>(nameof(passwordBox));
-			captchaBox = this.FindControl<TextBox>(nameof(captchaBox));
-		}
-
-		public CaptchaDialog(string password, byte[] captchaImage) : this()
-		{
-			//Avalonia doesn't support animated gifs.
-			//Deconstruct gifs into frames and manually switch them.
-			using var gif = SixLabors.ImageSharp.Image.Load(captchaImage);
-			var gifEncoder = new SixLabors.ImageSharp.Formats.Gif.GifEncoder();
-			var gifFrames = new Bitmap[gif.Frames.Count];
-			var frameDelayMs = new int[gif.Frames.Count];
-
-			for (int i = 0; i < gif.Frames.Count; i++)
-			{
-				var frameMetadata = gif.Frames[i].Metadata.GetFormatMetadata(SixLabors.ImageSharp.Formats.Gif.GifFormat.Instance);
-
-				using var clonedFrame = gif.Frames.CloneFrame(i);
-				using var framems = new MemoryStream();
-
-				clonedFrame.Save(framems, gifEncoder);
-				framems.Position = 0;
-
-				gifFrames[i] = new Bitmap(framems);
-				frameDelayMs[i] = frameMetadata.FrameDelay * 10;
-			}
-
-			DataContext = _viewModel = new(password, gifFrames, frameDelayMs);
-
-			Opened += (_, _) => (string.IsNullOrEmpty(password) ? passwordBox : captchaBox).Focus();
-		}
-
-		protected override async Task SaveAndCloseAsync()
-		{
-			if (string.IsNullOrWhiteSpace(_viewModel.Password))
-			{
-				await MessageBox.Show(this, "Please re-enter your password");
-				return;
-			}
-
-			Serilog.Log.Logger.Information("Submit button clicked: {@DebugInfo}", new { _viewModel.Answer });
-
-			await _viewModel.StopAsync();
-			await base.SaveAndCloseAsync();
-		}
-
-		protected override async Task CancelAndCloseAsync()
-		{
-			await _viewModel.StopAsync();
-			await base.CancelAndCloseAsync();
-		}
-
-		public async void Submit_Click(object sender, Avalonia.Interactivity.RoutedEventArgs e)
-			=> await SaveAndCloseAsync();
-	}
-
-	public class CaptchaDialogViewModel : ViewModelBase
-	{
-		public string Answer { get; set; }
-		public string Password { get; set; }
-		public Bitmap CaptchaImage { get => _captchaImage; private set => this.RaiseAndSetIfChanged(ref _captchaImage, value); }
-
-		private Bitmap _captchaImage;
-		private bool keepSwitching = true;
-		private readonly Task FrameSwitch;
-
-		public CaptchaDialogViewModel(string password, Bitmap[] gifFrames, int[] frameDelayMs)
-		{
-			Password = password;
-			if (gifFrames.Length == 1)
-			{
-				FrameSwitch = Task.CompletedTask;
-				CaptchaImage = gifFrames[0];
-			}
-			else
-			{
-				FrameSwitch = SwitchFramesAsync(gifFrames, frameDelayMs);
-			}
-		}
-
-		public async Task StopAsync()
-		{
-			keepSwitching = false;
-			await FrameSwitch;
-		}
-
-		private async Task SwitchFramesAsync(Bitmap[] gifFrames, int[] frameDelayMs)
-		{
-			int index = 0;
-			while (keepSwitching)
-			{
-				CaptchaImage = gifFrames[index];
-				await Task.Delay(frameDelayMs[index++]);
-
-				index %= gifFrames.Length;
-			}
-
-			foreach (var frame in gifFrames)
-				frame.Dispose();
-		}
-	}
-}