unofficial linux/mac support

"F*ck it, we'll do it live!"

.gitignore

@@ -4,6 +4,7 @@
 ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
 
 # User-specific files
+*.rsuser
 *.suo
 *.user
 *.userosscache
@@ -12,6 +13,9 @@
 # User-specific files (MonoDevelop/Xamarin Studio)
 *.userprefs
 
+# Mono auto generated files
+mono_crash.*
+
 # Build results
 [Dd]ebug/
 [Dd]ebugPublic/
@@ -19,10 +23,15 @@
 [Rr]eleases/
 x64/
 x86/
+[Ww][Ii][Nn]32/
+[Aa][Rr][Mm]/
+[Aa][Rr][Mm]64/
 bld/
 [Bb]in/
 [Oo]bj/
+[Oo]ut/
 [Ll]og/
+[Ll]ogs/
 
 # Visual Studio 2015/2017 cache/options directory
 .vs/
@@ -36,9 +45,10 @@ Generated\ Files/
 [Tt]est[Rr]esult*/
 [Bb]uild[Ll]og.*
 
-# NUNIT
+# NUnit
 *.VisualState.xml
 TestResult.xml
+nunit-*.xml
 
 # Build Results of an ATL Project
 [Dd]ebugPS/
@@ -52,7 +62,9 @@ BenchmarkDotNet.Artifacts/
 project.lock.json
 project.fragment.lock.json
 artifacts/
-**/Properties/launchSettings.json
+
+# ASP.NET Scaffolding
+ScaffoldingReadMe.txt
 
 # StyleCop
 StyleCopReport.xml
@@ -60,7 +72,7 @@ StyleCopReport.xml
 # Files built by Visual Studio
 *_i.c
 *_p.c
-*_i.h
+*_h.h
 *.ilk
 *.meta
 *.obj
@@ -77,6 +89,7 @@ StyleCopReport.xml
 *.tlh
 *.tmp
 *.tmp_proj
+*_wpftmp.csproj
 *.log
 *.vspscc
 *.vssscc
@@ -119,9 +132,6 @@ _ReSharper*/
 *.[Rr]e[Ss]harper
 *.DotSettings.user
 
-# JustCode is a .NET coding add-in
-.JustCode
-
 # TeamCity is a build add-in
 _TeamCity*
 
@@ -132,6 +142,11 @@ _TeamCity*
 .axoCover/*
 !.axoCover/settings.json
 
+# Coverlet is a free, cross platform Code Coverage Tool
+coverage*.json
+coverage*.xml
+coverage*.info
+
 # Visual Studio code coverage results
 *.coverage
 *.coveragexml
@@ -179,6 +194,8 @@ PublishScripts/
 
 # NuGet Packages
 *.nupkg
+# NuGet Symbol Packages
+*.snupkg
 # The packages folder can be ignored because of Package Restore
 **/[Pp]ackages/*
 # except build/, which is used as an MSBuild target.
@@ -203,12 +220,14 @@ BundleArtifacts/
 Package.StoreAssociation.xml
 _pkginfo.txt
 *.appx
+*.appxbundle
+*.appxupload
 
 # Visual Studio cache files
 # files ending in .cache can be ignored
 *.[Cc]ache
 # but keep track of directories ending in .cache
-!*.[Cc]ache/
+!?*.[Cc]ache/
 
 # Others
 ClientBin/
@@ -221,7 +240,7 @@ ClientBin/
 *.publishsettings
 orleans.codegen.cs
 
-# Including strong name files can present a security risk 
+# Including strong name files can present a security risk
 # (https://github.com/github/gitignore/pull/2483#issue-259490424)
 #*.snk
 
@@ -252,6 +271,9 @@ ServiceFabricBackup/
 *.bim.layout
 *.bim_*.settings
 *.rptproj.rsuser
+*- [Bb]ackup.rdl
+*- [Bb]ackup ([0-9]).rdl
+*- [Bb]ackup ([0-9][0-9]).rdl
 
 # Microsoft Fakes
 FakesAssemblies/
@@ -287,12 +309,8 @@ paket-files/
 # FAKE - F# Make
 .fake/
 
-# JetBrains Rider
-.idea/
-*.sln.iml
-
-# CodeRush
-.cr/
+# CodeRush personal settings
+.cr/personal
 
 # Python Tools for Visual Studio (PTVS)
 __pycache__/
@@ -317,7 +335,7 @@ __pycache__/
 # OpenCover UI analysis results
 OpenCover/
 
-# Azure Stream Analytics local run output 
+# Azure Stream Analytics local run output
 ASALocalRun/
 
 # MSBuild Binary and Structured Log
@@ -326,10 +344,29 @@ ASALocalRun/
 # NVidia Nsight GPU debugger configuration file
 *.nvuser
 
-# MFractors (Xamarin productivity tool) working folder 
+# MFractors (Xamarin productivity tool) working folder
 .mfractor/
 
+# Local History for Visual Studio
+.localhistory/
+
+# BeatPulse healthcheck temp database
+healthchecksdb
+
+# Backup folder for Package Reference Convert tool in Visual Studio 2017
+MigrationBackup/
+
+# Ionide (cross platform F# VS Code tools) working folder
+.ionide/
+
+# Fody - auto-generated XML schema
+FodyWeavers.xsd
+
+
+### manually ignored files
+
+# Windows shortcuts
+*.lnk
 
-# manually ignored files
 /__TODO.txt
 /DataLayer/LibationContext.db

AaxDecrypter/AaxDecrypter.csproj

@@ -1,123 +1,12 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <Reference Include="taglib-sharp">
-      <HintPath>lib\taglib-sharp.dll</HintPath>
-    </Reference>
-  </ItemGroup>
-
-  <ItemGroup>
-    <Folder Include="..\..\..\..\..\..\Dinah%2527s folder\coding\_NET\Visual Studio 2019\Libation\AaxDecrypter\UNTESTED\BytesCrackerLib\" />
-  </ItemGroup>
-
-  <ItemGroup>
+    <ProjectReference Include="..\..\AAXClean\AAXClean.csproj" />
     <ProjectReference Include="..\..\Dinah.Core\Dinah.Core\Dinah.Core.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <None Update="BytesCrackerLib\alglib1.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="BytesCrackerLib\audible_byte#4-4_0_10000x789935_0.rtc">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="BytesCrackerLib\audible_byte#4-4_1_10000x791425_0.rtc">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="BytesCrackerLib\audible_byte#4-4_2_10000x790991_0.rtc">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="BytesCrackerLib\audible_byte#4-4_3_10000x792120_0.rtc">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="BytesCrackerLib\audible_byte#4-4_4_10000x790743_0.rtc">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="BytesCrackerLib\audible_byte#4-4_5_10000x790568_0.rtc">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="BytesCrackerLib\audible_byte#4-4_6_10000x791458_0.rtc">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="BytesCrackerLib\audible_byte#4-4_7_10000x791707_0.rtc">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="BytesCrackerLib\audible_byte#4-4_8_10000x790202_0.rtc">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="BytesCrackerLib\audible_byte#4-4_9_10000x791022_0.rtc">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="BytesCrackerLib\ffmpeg.exe">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="BytesCrackerLib\ffprobe.exe">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="BytesCrackerLib\rcrack.exe">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\AtomicParsley.exe">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\avcodec-57.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\avdevice-57.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\avfilter-6.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\avformat-57.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\avutil-55.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\cygcrypto-1.0.0.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\cyggcc_s-1.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\cygmp4v2-2.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\cygstdc++-6.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\cygwin1.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\cygz.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\ffmpeg.exe">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\ffprobe.exe">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\mp4trackdump.exe">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\postproc-54.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\swresample-2.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\swscale-4.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-    <None Update="DecryptLib\taglib-sharp.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-
 </Project>

AaxDecrypter/AaxcDownloadConverter.cs

@@ -0,0 +1,229 @@
+using AAXClean;
+using Dinah.Core;
+using Dinah.Core.IO;
+using Dinah.Core.Net.Http;
+using Dinah.Core.StepRunner;
+using System;
+using System.IO;
+
+namespace AaxDecrypter
+{
+    public enum OutputFormat { Mp4a,  Mp3 }
+    public class AaxcDownloadConverter
+    {
+        public event EventHandler<AppleTags> RetrievedTags;
+        public event EventHandler<byte[]> RetrievedCoverArt;
+        public event EventHandler<DownloadProgress> DecryptProgressUpdate;
+        public event EventHandler<TimeSpan> DecryptTimeRemaining;
+
+        public string AppName { get; set; } = nameof(AaxcDownloadConverter);
+
+        private string outputFileName { get; }
+        private string cacheDir { get; }
+        private DownloadLicense downloadLicense { get; }
+        private AaxFile aaxFile;
+        private OutputFormat OutputFormat;
+
+        private StepSequence steps { get; }
+        private NetworkFileStreamPersister nfsPersister;
+        private bool isCanceled { get; set; }
+        private string jsonDownloadState => Path.Combine(cacheDir, Path.GetFileNameWithoutExtension(outputFileName) + ".json");
+        private string tempFile => PathLib.ReplaceExtension(jsonDownloadState, ".aaxc");
+
+        public AaxcDownloadConverter(string outFileName, string cacheDirectory, DownloadLicense dlLic, OutputFormat outputFormat)
+        {
+            ArgumentValidator.EnsureNotNullOrWhiteSpace(outFileName, nameof(outFileName));
+            outputFileName = outFileName;
+
+            var outDir = Path.GetDirectoryName(outputFileName);
+            if (!Directory.Exists(outDir))
+                throw new ArgumentNullException(nameof(outDir), "Directory does not exist");
+            if (File.Exists(outputFileName))
+                File.Delete(outputFileName);
+
+            if (!Directory.Exists(cacheDirectory))
+                throw new ArgumentNullException(nameof(cacheDirectory), "Directory does not exist");
+            cacheDir = cacheDirectory;
+
+            downloadLicense = ArgumentValidator.EnsureNotNull(dlLic, nameof(dlLic));
+            OutputFormat = outputFormat;
+
+            steps = new StepSequence
+            {
+                Name = "Download and Convert Aaxc To " + (outputFormat == OutputFormat.Mp4a ? "M4b" : "Mp3"),
+
+                ["Step 1: Get Aaxc Metadata"] = Step1_GetMetadata,
+                ["Step 2: Download Decrypted Audiobook"] = Step2_DownloadAndCombine,
+                ["Step 3: Create Cue"] = Step3_CreateCue,
+                ["Step 4: Create Nfo"] = Step4_CreateNfo,
+                ["Step 5: Cleanup"] = Step5_Cleanup,
+            };
+        }
+
+        /// <summary>
+        /// Setting cover art by this method will insert the art into the audiobook metadata
+        /// </summary>
+        public void SetCoverArt(byte[] coverArt)
+        {
+            if (coverArt is null) return;
+
+            aaxFile?.AppleTags.SetCoverArt(coverArt);
+
+            RetrievedCoverArt?.Invoke(this, coverArt);
+        }
+
+        public bool Run()
+        {
+            var (IsSuccess, Elapsed) = steps.Run();
+
+            if (!IsSuccess)
+            {
+                Console.WriteLine("WARNING-Conversion failed");
+                return false;
+            }
+
+            var speedup = (int)(aaxFile.Duration.TotalSeconds / (long)Elapsed.TotalSeconds);
+            Console.WriteLine("Speedup is " + speedup + "x realtime.");
+            Console.WriteLine("Done");
+            return true;
+        }
+
+        public bool Step1_GetMetadata()
+        {
+            //Get metadata from the file over http
+                       
+            if (File.Exists(jsonDownloadState))
+            {
+                try
+                {
+                    nfsPersister = new NetworkFileStreamPersister(jsonDownloadState);
+                    //If More than ~1 hour has elapsed since getting the download url, it will expire.
+                    //The new url will be to the same file.
+                    nfsPersister.NetworkFileStream.SetUriForSameFile(new Uri(downloadLicense.DownloadUrl));
+                }
+                catch
+                {
+                    FileExt.SafeDelete(jsonDownloadState);
+                    FileExt.SafeDelete(tempFile);
+                    nfsPersister = NewNetworkFilePersister();
+                }
+            }
+            else
+            {
+                nfsPersister = NewNetworkFilePersister();
+            }
+
+            aaxFile = new AaxFile(nfsPersister.NetworkFileStream);
+
+            RetrievedTags?.Invoke(this, aaxFile.AppleTags);
+            RetrievedCoverArt?.Invoke(this, aaxFile.AppleTags.Cover);
+
+            return !isCanceled;
+        }
+        private NetworkFileStreamPersister NewNetworkFilePersister()
+        {
+			var headers = new System.Net.WebHeaderCollection
+			{
+				{ "User-Agent", downloadLicense.UserAgent }
+			};
+
+			var networkFileStream = new NetworkFileStream(tempFile, new Uri(downloadLicense.DownloadUrl), 0, headers);
+            return new NetworkFileStreamPersister(networkFileStream, jsonDownloadState);
+        }
+
+        public bool Step2_DownloadAndCombine()
+        {
+            var zeroProgress = new DownloadProgress 
+            { 
+                BytesReceived = 0,
+                ProgressPercentage = 0, 
+                TotalBytesToReceive = nfsPersister.NetworkFileStream.Length 
+            };
+
+            DecryptProgressUpdate?.Invoke(this, zeroProgress);
+
+            if (File.Exists(outputFileName))
+                FileExt.SafeDelete(outputFileName);
+
+            FileStream outFile = File.OpenWrite(outputFileName);
+
+            aaxFile.SetDecryptionKey(downloadLicense.AudibleKey, downloadLicense.AudibleIV);
+
+            aaxFile.ConversionProgressUpdate += AaxFile_ConversionProgressUpdate;
+            var decryptionResult = OutputFormat == OutputFormat.Mp4a ? aaxFile.ConvertToMp4a(outFile, downloadLicense.ChapterInfo) : aaxFile.ConvertToMp3(outFile);
+            aaxFile.ConversionProgressUpdate -= AaxFile_ConversionProgressUpdate;
+
+            aaxFile.Close();
+
+            downloadLicense.ChapterInfo = aaxFile.Chapters;
+
+            nfsPersister.Dispose();
+
+            DecryptProgressUpdate?.Invoke(this, zeroProgress);
+
+            return decryptionResult == ConversionResult.NoErrorsDetected && !isCanceled;
+        }
+
+        private void AaxFile_ConversionProgressUpdate(object sender, ConversionProgressEventArgs e)
+        {
+            var duration = aaxFile.Duration;
+            double remainingSecsToProcess = (duration - e.ProcessPosition).TotalSeconds;
+            double estTimeRemaining = remainingSecsToProcess / e.ProcessSpeed;
+
+            if (double.IsNormal(estTimeRemaining))
+                DecryptTimeRemaining?.Invoke(this, TimeSpan.FromSeconds(estTimeRemaining));
+
+            double progressPercent = 100 * e.ProcessPosition.TotalSeconds / duration.TotalSeconds;
+
+            DecryptProgressUpdate?.Invoke(this,
+                new DownloadProgress 
+                {
+                    ProgressPercentage = progressPercent,
+                    BytesReceived = (long)(nfsPersister.NetworkFileStream.Length * progressPercent),
+                    TotalBytesToReceive = nfsPersister.NetworkFileStream.Length
+                });
+        }
+
+        public bool Step3_CreateCue()
+        {
+            // not a critical step. its failure should not prevent future steps from running
+            try
+            {
+                File.WriteAllText(PathLib.ReplaceExtension(outputFileName, ".cue"), Cue.CreateContents(Path.GetFileName(outputFileName), downloadLicense.ChapterInfo));
+            }
+            catch (Exception ex)
+            {
+                Serilog.Log.Logger.Error(ex, $"{nameof(Step3_CreateCue)}. FAILED");
+            }
+            return !isCanceled;
+        }
+
+        public bool Step4_CreateNfo()
+        {
+            // not a critical step. its failure should not prevent future steps from running
+            try
+            {
+                File.WriteAllText(PathLib.ReplaceExtension(outputFileName, ".nfo"), NFO.CreateContents(AppName, aaxFile, downloadLicense.ChapterInfo));
+            }
+            catch (Exception ex)
+            {
+                Serilog.Log.Logger.Error(ex, $"{nameof(Step4_CreateNfo)}. FAILED");
+            }
+            return !isCanceled;
+        }
+
+        public bool Step5_Cleanup()
+        {
+            FileExt.SafeDelete(jsonDownloadState);
+            FileExt.SafeDelete(tempFile);
+            return !isCanceled;
+        }
+
+        public void Cancel()
+        {
+            isCanceled = true;
+            aaxFile?.Cancel();
+            aaxFile?.Dispose();
+        }
+    }
+}

AaxDecrypter/Cue.cs

@@ -0,0 +1,59 @@
+using System;
+using System.IO;
+using System.Text;
+using AAXClean;
+using Dinah.Core;
+
+namespace AaxDecrypter
+{
+    public static class Cue
+    {
+        public static string CreateContents(string filePath, ChapterInfo chapters)
+        {
+            var stringBuilder = new StringBuilder();
+
+            stringBuilder.AppendLine(GetFileLine(filePath, "MP3"));
+
+            var trackCount = 0;
+            foreach (var c in chapters.Chapters)
+            {
+                trackCount++;
+
+                stringBuilder.AppendLine($"TRACK {trackCount} AUDIO");
+                stringBuilder.AppendLine($"  TITLE \"{c.Title}\"");
+                stringBuilder.AppendLine($"  INDEX 01 {(int)c.StartOffset.TotalMinutes}:{c.StartOffset:ss\\:ff}");
+            }
+
+            return stringBuilder.ToString();
+        }
+
+        public static void UpdateFileName(FileInfo cueFileInfo, string audioFilePath)
+            => UpdateFileName(cueFileInfo.FullName, audioFilePath);
+
+        public static void UpdateFileName(string cueFilePath, FileInfo audioFileInfo)
+            => UpdateFileName(cueFilePath, audioFileInfo.FullName);
+
+        public static void UpdateFileName(FileInfo cueFileInfo, FileInfo audioFileInfo)
+            => UpdateFileName(cueFileInfo.FullName, audioFileInfo.FullName);
+
+        public static void UpdateFileName(string cueFilePath, string audioFilePath)
+        {
+            var cueContents = File.ReadAllLines(cueFilePath);
+
+            for (var i = 0; i < cueContents.Length; i++)
+            {
+                var line = cueContents[i];
+                if (!line.Trim().StartsWith("FILE") || !line.Contains(" "))
+                    continue;
+
+                var fileTypeBegins = line.LastIndexOf(" ") + 1;
+                cueContents[i] = GetFileLine(audioFilePath, line[fileTypeBegins..]);
+                break;
+            }
+
+            File.WriteAllLines(cueFilePath, cueContents);
+        }
+
+        private static string GetFileLine(string filePath, string audioType) => $"FILE {Path.GetFileName(filePath).SurroundWithQuotes()} {audioType}";
+    }
+}

AaxDecrypter/DownloadLicense.cs

@@ -0,0 +1,27 @@
+using AAXClean;
+using Dinah.Core;
+
+namespace AaxDecrypter
+{
+    public class DownloadLicense
+    {
+        public string DownloadUrl { get; }
+        public string AudibleKey { get; }
+        public string AudibleIV { get; }
+        public string UserAgent { get; }
+        public ChapterInfo ChapterInfo { get; set; }
+
+        public DownloadLicense(string downloadUrl, string audibleKey, string audibleIV, string userAgent)
+        {
+            ArgumentValidator.EnsureNotNullOrEmpty(downloadUrl, nameof(downloadUrl));
+            ArgumentValidator.EnsureNotNullOrEmpty(audibleKey, nameof(audibleKey));
+            ArgumentValidator.EnsureNotNullOrEmpty(audibleIV, nameof(audibleIV));
+            ArgumentValidator.EnsureNotNullOrEmpty(userAgent, nameof(userAgent));
+
+            DownloadUrl = downloadUrl;
+            AudibleKey = audibleKey;
+            AudibleIV = audibleIV;
+            UserAgent = userAgent;
+        }
+    }
+}

AaxDecrypter/NFO.cs

@@ -0,0 +1,54 @@
+using AAXClean;
+using Dinah.Core;
+
+namespace AaxDecrypter
+{
+    public static class NFO
+    {
+        public static string CreateContents(string ripper, Mp4File aaxcTagLib, ChapterInfo chapters)
+        {
+            var _hours = (int)aaxcTagLib.Duration.TotalHours;
+            var myDuration
+                = (_hours > 0 ? _hours + " hours, " : string.Empty)
+                + aaxcTagLib.Duration.Minutes + " minutes, "
+                + aaxcTagLib.Duration.Seconds + " seconds";
+
+            var nfoString
+                = "General Information\r\n"
+                + "======================\r\n"
+                + $" Title:                  {aaxcTagLib.AppleTags.TitleSansUnabridged?.UnicodeToAscii() ?? "[unknown]"}\r\n"
+                + $" Author:                 {aaxcTagLib.AppleTags.FirstAuthor?.UnicodeToAscii() ?? "[unknown]"}\r\n"
+                + $" Read By:                {aaxcTagLib.AppleTags.Narrator?.UnicodeToAscii() ?? "[unknown]"}\r\n"
+                + $" Release Date:           {aaxcTagLib.AppleTags.ReleaseDate ?? "[unknown]"}\r\n"
+                + $" Book Copyright:         {aaxcTagLib.AppleTags.BookCopyright ?? "[unknown]"}\r\n"
+                + $" Recording Copyright:    {aaxcTagLib.AppleTags.RecordingCopyright ?? "[unknown]"}\r\n"
+                + $" Genre:                  {aaxcTagLib.AppleTags.Generes ?? "[unknown]"}\r\n"
+                + $" Publisher:              {aaxcTagLib.AppleTags.Publisher ?? "[unknown]"}\r\n"
+                + $" Duration:               {myDuration}\r\n"
+                + $" Chapters:               {chapters.Count}\r\n"
+                + "\r\n"
+                + "\r\n"
+                + "Media Information\r\n"
+                + "======================\r\n"
+                + " Source Format:          Audible AAXC\r\n"
+                + $" Source Sample Rate:     {aaxcTagLib.TimeScale} Hz\r\n"
+                + $" Source Channels:        {aaxcTagLib.AudioChannels}\r\n"
+                + $" Source Bitrate:         {aaxcTagLib.AverageBitrate} Kbps\r\n"
+                + "\r\n"
+                + " Lossless Encode:        Yes\r\n"
+                + " Encoded Codec:          AAC / M4B\r\n"
+                + $" Encoded Sample Rate:    {aaxcTagLib.TimeScale} Hz\r\n"
+                + $" Encoded Channels:       {aaxcTagLib.AudioChannels}\r\n"
+                + $" Encoded Bitrate:        {aaxcTagLib.AverageBitrate} Kbps\r\n"
+                + "\r\n"
+                + $" Ripper:                 {ripper}\r\n"
+                + "\r\n"
+                + "\r\n"
+                + "Book Description\r\n"
+                + "================\r\n"
+                + (!string.IsNullOrWhiteSpace(aaxcTagLib.AppleTags.LongDescription) ? aaxcTagLib.AppleTags.LongDescription.UnicodeToAscii() : aaxcTagLib.AppleTags.Comment?.UnicodeToAscii());
+
+            return nfoString;
+        }
+    }
+}

AaxDecrypter/NetworkFileStream.cs

@@ -0,0 +1,444 @@
+using Dinah.Core;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Threading;
+
+namespace AaxDecrypter
+{
+    /// <summary>
+    /// A <see cref="CookieContainer"/> for a single Uri.
+    /// </summary>
+    public class SingleUriCookieContainer : CookieContainer
+    {
+        private Uri baseAddress;
+        public Uri Uri
+        { 
+            get => baseAddress; 
+            set 
+            { 
+                baseAddress = new UriBuilder(value.Scheme, value.Host).Uri; 
+            } 
+        }
+
+        public CookieCollection GetCookies()
+        {
+            return GetCookies(Uri);
+        }
+    }
+
+    /// <summary>
+    /// A resumable, simultaneous file downloader and reader.
+    /// </summary>
+    public class NetworkFileStream : Stream, IUpdatable
+    {
+        public event EventHandler Updated;
+
+        #region Public Properties
+
+        /// <summary>
+        /// Location to save the downloaded data.
+        /// </summary>
+        [JsonProperty(Required = Required.Always)]
+        public string SaveFilePath { get; }
+
+        /// <summary>
+        /// Http(s) address of the file to download.
+        /// </summary>
+        [JsonProperty(Required = Required.Always)]
+        public Uri Uri { get; private set; }
+
+        /// <summary>
+        /// All cookies set by caller or by the remote server.
+        /// </summary>
+        [JsonProperty(Required = Required.Always)]
+        public SingleUriCookieContainer CookieContainer { get; }
+
+        /// <summary>
+        /// Http headers to be sent to the server with the request.
+        /// </summary>
+        [JsonProperty(Required = Required.Always)]
+        public WebHeaderCollection RequestHeaders { get; private set; }
+
+        /// <summary>
+        /// The position in <see cref="SaveFilePath"/> that has been written and flushed to disk.
+        /// </summary>
+        [JsonProperty(Required = Required.Always)]
+        public long WritePosition { get; private set; }
+
+        /// <summary>
+        /// The total length of the <see cref="Uri"/> file to download.
+        /// </summary>
+        [JsonProperty(Required = Required.Always)]
+        public long ContentLength { get; private set; }
+
+        #endregion
+
+        #region Private Properties
+        private HttpWebRequest HttpRequest { get; set; }
+        private FileStream _writeFile { get; }
+        private FileStream _readFile { get; }
+        private Stream _networkStream { get; set; }
+        private bool hasBegunDownloading { get; set; }
+        private bool isCancelled { get; set; }
+        private EventWaitHandle downloadEnded { get; set; } 
+        private EventWaitHandle downloadedPiece { get; set; } 
+
+        #endregion
+
+        #region Constants
+
+        //Download buffer size
+        private const int DOWNLOAD_BUFF_SZ = 4 * 1024;
+
+        //NetworkFileStream will flush all data in _writeFile to disk after every
+        //DATA_FLUSH_SZ bytes are written to the file stream.
+        private const int DATA_FLUSH_SZ = 1024 * 1024;
+
+        #endregion
+
+        #region Constructor
+
+        /// <summary>
+        /// A resumable, simultaneous file downloader and reader.
+        /// </summary>
+        /// <param name="saveFilePath">Path to a location on disk to save the downloaded data from <paramref name="uri"/></param>
+        /// <param name="uri">Http(s) address of the file to download.</param>
+        /// <param name="writePosition">The position in <paramref name="uri"/> to begin downloading.</param>
+        /// <param name="requestHeaders">Http headers to be sent to the server with the <see cref="HttpWebRequest"/>.</param>
+        /// <param name="cookies">A <see cref="SingleUriCookieContainer"/> with cookies to send with the <see cref="HttpWebRequest"/>. It will also be populated with any cookies set by the server. </param>
+        public NetworkFileStream(string saveFilePath, Uri uri, long writePosition = 0, WebHeaderCollection requestHeaders = null, SingleUriCookieContainer cookies = null)
+        {
+            ArgumentValidator.EnsureNotNullOrWhiteSpace(saveFilePath, nameof(saveFilePath));
+            ArgumentValidator.EnsureNotNullOrWhiteSpace(uri?.AbsoluteUri, nameof(uri));
+            ArgumentValidator.EnsureGreaterThan(writePosition, nameof(writePosition), -1);
+
+            if (!Directory.Exists(Path.GetDirectoryName(saveFilePath)))
+                throw new ArgumentException($"Specified {nameof(saveFilePath)} directory \"{Path.GetDirectoryName(saveFilePath)}\" does not exist.");
+
+            SaveFilePath = saveFilePath;
+            Uri = uri;
+            WritePosition = writePosition;
+            RequestHeaders = requestHeaders ?? new WebHeaderCollection();
+            CookieContainer = cookies ?? new SingleUriCookieContainer { Uri = uri };
+            
+            _writeFile = new FileStream(SaveFilePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite)
+            {
+                Position = WritePosition
+            };
+
+            _readFile = new FileStream(SaveFilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+
+            SetUriForSameFile(uri);
+        }
+
+        #endregion
+               
+        #region Downloader
+
+        /// <summary>
+        /// Update the <see cref="JsonFilePersister"/>.
+        /// </summary>
+        private void Update()
+        {
+            RequestHeaders = HttpRequest.Headers;
+            Updated?.Invoke(this, EventArgs.Empty);
+        }
+
+        /// <summary>
+        /// Set a different <see cref="System.Uri"/> to the same file targeted by this instance of <see cref="NetworkFileStream"/>
+        /// </summary>
+        /// <param name="uriToSameFile">New <see cref="System.Uri"/> host must match existing host.</param>
+        public void SetUriForSameFile(Uri uriToSameFile)
+        {
+            ArgumentValidator.EnsureNotNullOrWhiteSpace(uriToSameFile?.AbsoluteUri, nameof(uriToSameFile));
+
+            if (uriToSameFile.Host != Uri.Host)
+                throw new ArgumentException($"New uri to the same file must have the same host.\r\n Old Host :{Uri.Host}\r\nNew Host: {uriToSameFile.Host}");
+            if (hasBegunDownloading)
+                throw new InvalidOperationException("Cannot change Uri after download has started.");
+
+            Uri = uriToSameFile;
+            HttpRequest = WebRequest.CreateHttp(Uri);
+
+            HttpRequest.CookieContainer = CookieContainer;
+            HttpRequest.Headers = RequestHeaders;
+            //If NetworkFileStream is resuming, Header will already contain a range.
+            HttpRequest.Headers.Remove("Range");
+            HttpRequest.AddRange(WritePosition);
+        }
+
+        /// <summary>
+        /// Begins downloading <see cref="Uri"/> to <see cref="SaveFilePath"/> in a background thread.
+        /// </summary>
+        private void BeginDownloading()
+        {
+            downloadEnded = new EventWaitHandle(false, EventResetMode.ManualReset);
+
+            if (ContentLength != 0 && WritePosition == ContentLength)
+            {
+                hasBegunDownloading = true;
+                downloadEnded.Set();
+                return;
+            }
+
+            if (ContentLength != 0 && WritePosition > ContentLength)
+                throw new WebException($"Specified write position (0x{WritePosition:X10}) is larger than  {nameof(ContentLength)} (0x{ContentLength:X10}).");
+
+            var response = HttpRequest.GetResponse() as HttpWebResponse;
+
+            if (response.StatusCode != HttpStatusCode.PartialContent)
+                throw new WebException($"Server at {Uri.Host} responded with unexpected status code: {response.StatusCode}.");
+
+            if (response.Headers.GetValues("Accept-Ranges").FirstOrDefault(r => r.EqualsInsensitive("bytes")) is null)
+                throw new WebException($"Server at {Uri.Host} does not support Http ranges");
+
+            //Content length is the length of the range request, and it is only equal
+            //to the complete file length if requesting Range: bytes=0-
+            if (WritePosition == 0)
+                ContentLength = response.ContentLength;
+
+            _networkStream = response.GetResponseStream();
+            downloadedPiece = new EventWaitHandle(false, EventResetMode.AutoReset);
+
+            //Download the file in the background.
+            new Thread(() => DownloadFile())
+            { IsBackground = true }
+            .Start();
+
+            hasBegunDownloading = true;
+            return;
+        }
+
+        /// <summary>
+        /// Downlod <see cref="Uri"/> to <see cref="SaveFilePath"/>.
+        /// </summary>
+        private void DownloadFile()
+        {
+            var downloadPosition = WritePosition;
+            var nextFlush = downloadPosition + DATA_FLUSH_SZ;
+
+            var buff = new byte[DOWNLOAD_BUFF_SZ];
+            do
+            {
+                var bytesRead = _networkStream.Read(buff, 0, DOWNLOAD_BUFF_SZ);
+                _writeFile.Write(buff, 0, bytesRead);
+
+                downloadPosition += bytesRead;
+
+                if (downloadPosition > nextFlush)
+                {
+                    _writeFile.Flush();
+                    WritePosition = downloadPosition;
+                    Update();
+                    nextFlush = downloadPosition + DATA_FLUSH_SZ;
+                    downloadedPiece.Set();
+                }
+
+            } while (downloadPosition < ContentLength && !isCancelled);
+
+            _writeFile.Close();
+            WritePosition = downloadPosition;
+            Update();
+            _networkStream.Close();
+
+            if (!isCancelled && WritePosition < ContentLength)
+                throw new WebException($"Downloaded size (0x{WritePosition:X10}) is less than {nameof(ContentLength)} (0x{ContentLength:X10}).");
+
+            if (WritePosition > ContentLength)
+                throw new WebException($"Downloaded size (0x{WritePosition:X10}) is greater than {nameof(ContentLength)} (0x{ContentLength:X10}).");
+
+            downloadEnded.Set();
+        }
+
+        #endregion
+
+        #region Json Connverters
+
+        public static JsonSerializerSettings GetJsonSerializerSettings()
+        {
+            var settings = new JsonSerializerSettings();
+            settings.Converters.Add(new CookieContainerConverter());
+            settings.Converters.Add(new WebHeaderCollectionConverter());
+            return settings;
+        }
+
+        internal class CookieContainerConverter : JsonConverter
+        {
+            public override bool CanConvert(Type objectType)
+                => objectType == typeof(SingleUriCookieContainer);
+
+            public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+            {
+                var jObj = JObject.Load(reader);
+
+                var result = new SingleUriCookieContainer()
+                {
+                    Uri = new Uri(jObj["Uri"].Value<string>()),
+                    Capacity = jObj["Capacity"].Value<int>(),
+                    MaxCookieSize = jObj["MaxCookieSize"].Value<int>(),
+                    PerDomainCapacity = jObj["PerDomainCapacity"].Value<int>()
+                };
+
+                var cookieList = jObj["Cookies"].ToList();
+
+                foreach (var cookie in cookieList)
+                {
+                    result.Add(
+                        new Cookie
+                        {
+                            Comment = cookie["Comment"].Value<string>(),
+                            HttpOnly = cookie["HttpOnly"].Value<bool>(),
+                            Discard = cookie["Discard"].Value<bool>(),
+                            Domain = cookie["Domain"].Value<string>(),
+                            Expired = cookie["Expired"].Value<bool>(),
+                            Expires = cookie["Expires"].Value<DateTime>(),
+                            Name = cookie["Name"].Value<string>(),
+                            Path = cookie["Path"].Value<string>(),
+                            Port = cookie["Port"].Value<string>(),
+                            Secure = cookie["Secure"].Value<bool>(),
+                            Value = cookie["Value"].Value<string>(),
+                            Version = cookie["Version"].Value<int>(),
+                        });
+                }
+
+                return result;
+            }
+
+            public override bool CanWrite => true;
+
+            public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+            {
+                var cookies = value as SingleUriCookieContainer;
+                var obj = (JObject)JToken.FromObject(value);
+                var container = cookies.GetCookies();
+                var propertyNames = container.Select(c => JToken.FromObject(c));
+                obj.AddFirst(new JProperty("Cookies", new JArray(propertyNames)));
+                obj.WriteTo(writer);
+            }
+        }
+
+        internal class WebHeaderCollectionConverter : JsonConverter
+        {
+            public override bool CanConvert(Type objectType)
+                => objectType == typeof(WebHeaderCollection);
+
+            public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+            {
+                var jObj = JObject.Load(reader);
+                var result = new WebHeaderCollection();
+
+                foreach (var kvp in jObj)
+                    result.Add(kvp.Key, kvp.Value.Value<string>());
+
+                return result;
+            }
+
+            public override bool CanWrite => true;
+
+            public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+            {
+                var jObj = new JObject();
+                var type = value.GetType();
+                var headers = value as WebHeaderCollection;
+                var jHeaders = headers.AllKeys.Select(k => new JProperty(k, headers[k]));
+                jObj.Add(jHeaders);
+                jObj.WriteTo(writer);
+            }
+        }
+
+        #endregion
+
+        #region Download Stream Reader
+
+        [JsonIgnore]
+        public override bool CanRead => true;
+
+        [JsonIgnore]
+        public override bool CanSeek => true;
+
+        [JsonIgnore]
+        public override bool CanWrite => false;
+
+        [JsonIgnore]
+        public override long Length
+        {
+            get
+            {
+                if (!hasBegunDownloading)
+                    BeginDownloading();
+                return ContentLength;
+            }
+        }
+
+        [JsonIgnore]
+        public override long Position { get => _readFile.Position; set => Seek(value, SeekOrigin.Begin); }
+
+        [JsonIgnore]
+        public override bool CanTimeout => false;
+
+        [JsonIgnore]
+        public override int ReadTimeout { get => base.ReadTimeout; set => base.ReadTimeout = value; }
+
+        [JsonIgnore]
+        public override int WriteTimeout { get => base.WriteTimeout; set => base.WriteTimeout = value; }
+
+        public override void Flush() => throw new NotImplementedException();
+        public override void SetLength(long value) => throw new NotImplementedException();
+        public override void Write(byte[] buffer, int offset, int count) => throw new NotImplementedException();
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (!hasBegunDownloading)
+                BeginDownloading();
+
+            var toRead = Math.Min(count, Length - Position);
+            WaitToPosition(Position + toRead);
+            return _readFile.Read(buffer, offset, count);
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            var newPosition = origin switch
+			{
+				SeekOrigin.Current => Position + offset,
+				SeekOrigin.End => ContentLength + offset,
+				_ => offset,
+			};
+
+            WaitToPosition(newPosition);
+            return _readFile.Position = newPosition;
+        }
+
+        /// <summary>
+        /// Blocks until the file has downloaded to at least <paramref name="requiredPosition"/>, then returns.
+        /// </summary>
+        /// <param name="requiredPosition">The minimum required flished data length in <see cref="SaveFilePath"/>.</param>
+        private void WaitToPosition(long requiredPosition)
+		{
+            while (requiredPosition > WritePosition && !isCancelled && hasBegunDownloading && !downloadedPiece.WaitOne(1000)) ;
+        }
+
+        public override void Close()
+        {
+            isCancelled = true;
+
+            while (downloadEnded is not null && !downloadEnded.WaitOne(1000)) ;
+
+            _readFile.Close();
+            _writeFile.Close();
+            _networkStream?.Close();
+            Update();
+        }
+
+        #endregion
+        ~NetworkFileStream()
+        {
+            downloadEnded?.Close();
+            downloadedPiece?.Close();
+        }
+    }
+}

AaxDecrypter/NetworkFileStreamPersister.cs

@@ -0,0 +1,23 @@
+using Dinah.Core.IO;
+using Newtonsoft.Json;
+
+namespace AaxDecrypter
+{
+    internal class NetworkFileStreamPersister : JsonFilePersister<NetworkFileStream>
+    {
+
+		/// <summary>Alias for Target </summary>
+		public NetworkFileStream NetworkFileStream => Target;
+
+		/// <summary>uses path. create file if doesn't yet exist</summary>
+		public NetworkFileStreamPersister(NetworkFileStream networkFileStream, string path, string jsonPath = null)
+			: base(networkFileStream, path, jsonPath) { }
+
+		/// <summary>load from existing file</summary>
+		public NetworkFileStreamPersister(string path, string jsonPath = null)
+			: base(path, jsonPath) { }
+
+		protected override JsonSerializerSettings GetSerializerSettings() => NetworkFileStream.GetJsonSerializerSettings();
+
+    }
+}

AaxDecrypter/UNTESTED/AaxToM4bConverter.cs

@@ -1,362 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using Dinah.Core;
-using Dinah.Core.Diagnostics;
-using Dinah.Core.IO;
-using Dinah.Core.StepRunner;
-
-namespace AaxDecrypter
-{
-    public interface ISimpleAaxToM4bConverter
-    {
-        event EventHandler<int> DecryptProgressUpdate;
-
-        bool Run();
-
-        string AppName { get; set; }
-        string inputFileName { get; }
-        byte[] coverBytes { get;  }
-        string outDir { get; }
-        string outputFileName { get; }
-
-        Chapters chapters { get; }
-        Tags tags { get; }
-        EncodingInfo encodingInfo { get; }
-
-        void SetOutputFilename(string outFileName);
-    }
-    public interface IAdvancedAaxToM4bConverter : ISimpleAaxToM4bConverter
-    {
-        bool Step1_CreateDir();
-        bool Step2_DecryptAax();
-        bool Step3_Chapterize();
-        bool Step4_InsertCoverArt();
-        bool Step5_Cleanup();
-        bool Step6_AddTags();
-        bool End_CreateCue();
-        bool End_CreateNfo();
-    }
-    /// <summary>full c# app. integrated logging. no UI</summary>
-    public class AaxToM4bConverter : IAdvancedAaxToM4bConverter
-    {
-        public event EventHandler<int> DecryptProgressUpdate;
-
-        public string inputFileName { get; }
-        public string decryptKey { get; private set; }
-
-        private StepSequence steps { get; }
-        public byte[] coverBytes { get; private set; }
-
-        public string AppName { get; set; } = nameof(AaxToM4bConverter);
-
-        public string outDir { get; private set; }
-        public string outputFileName { get; private set; }
-
-        public Chapters chapters { get; private set; }
-        public Tags tags { get; private set; }
-        public EncodingInfo encodingInfo { get; private set; }
-
-        public static async Task<AaxToM4bConverter> CreateAsync(string inputFile, string decryptKey)
-        {
-            var converter = new AaxToM4bConverter(inputFile, decryptKey);
-            await converter.prelimProcessing();
-            converter.printPrelim();
-
-            return converter;
-        }
-        private AaxToM4bConverter(string inputFile, string decryptKey)
-        {
-			ArgumentValidator.EnsureNotNullOrWhiteSpace(inputFile, nameof(inputFile));
-            if (!File.Exists(inputFile))
-                throw new ArgumentNullException(nameof(inputFile), "File does not exist");
-
-            steps = new StepSequence
-            {
-                Name = "Convert Aax To M4b",
-
-                ["Step 1: Create Dir"] = Step1_CreateDir,
-                ["Step 2: Decrypt Aax"] = Step2_DecryptAax,
-                ["Step 3: Chapterize and tag"] = Step3_Chapterize,
-                ["Step 4: Insert Cover Art"] = Step4_InsertCoverArt,
-                ["Step 5: Cleanup"] = Step5_Cleanup,
-                ["Step 6: Add Tags"] = Step6_AddTags,
-                ["End: Create Cue"] = End_CreateCue,
-                ["End: Create Nfo"] = End_CreateNfo
-            };
-
-            inputFileName = inputFile;
-            this.decryptKey = decryptKey;
-        }
-
-        private async Task prelimProcessing()
-        {
-            tags = new Tags(inputFileName);
-            encodingInfo = new EncodingInfo(inputFileName);
-            chapters = new Chapters(inputFileName, tags.duration.TotalSeconds);
-
-            var defaultFilename = Path.Combine(
-                Path.GetDirectoryName(inputFileName),
-                getASCIITag(tags.author),
-                getASCIITag(tags.title) + ".m4b"
-                );
-
-			// set default name
-			SetOutputFilename(defaultFilename);
-
-            await Task.Run(() => saveCover(inputFileName));
-        }
-        private string getASCIITag(string property)
-        {
-            foreach (char ch in new string(Path.GetInvalidFileNameChars()) + new string(Path.GetInvalidPathChars()))
-                property = property.Replace(ch.ToString(), "");
-            return property;
-        }
-
-        private void saveCover(string aaxFile)
-        {
-			using var file = TagLib.File.Create(aaxFile, "audio/mp4", TagLib.ReadStyle.Average);
-			coverBytes = file.Tag.Pictures[0].Data.Data;
-		}
-
-        private void printPrelim()
-        {
-            Console.WriteLine("Audible Book ID = " + tags.id);
-
-            Console.WriteLine("Book: " + tags.title);
-            Console.WriteLine("Author: " + tags.author);
-            Console.WriteLine("Narrator: " + tags.narrator);
-            Console.WriteLine("Year: " + tags.year);
-            Console.WriteLine("Total Time: "
-                + tags.duration.GetTotalTimeFormatted()
-                + " in " + chapters.Count() + " chapters");
-            Console.WriteLine("WARNING-Source is "
-                + encodingInfo.originalBitrate + " kbits @ "
-                + encodingInfo.sampleRate + "Hz, "
-                + encodingInfo.channels + " channels");
-        }
-
-        public bool Run()
-        {
-            var (IsSuccess, Elapsed) = steps.Run();
-
-            if (!IsSuccess)
-            {
-                Console.WriteLine("WARNING-Conversion failed");
-                return false;
-            }
-
-            var speedup = (int)(tags.duration.TotalSeconds / (long)Elapsed.TotalSeconds);
-            Console.WriteLine("Speedup is " + speedup + "x realtime.");
-            Console.WriteLine("Done");
-            return true;
-        }
-
-        public void SetOutputFilename(string outFileName)
-        {
-            outputFileName = outFileName;
-
-            if (Path.GetExtension(outputFileName) != ".m4b")
-                outputFileName = outputFileWithNewExt(".m4b");
-
-			if (File.Exists(outputFileName))
-				File.Delete(outputFileName);
-
-            outDir = Path.GetDirectoryName(outputFileName);
-        }
-
-        private string outputFileWithNewExt(string extension)
-            => Path.Combine(outDir, Path.GetFileNameWithoutExtension(outputFileName) + '.' + extension.Trim('.'));
-
-        public bool Step1_CreateDir()
-        {
-            ProcessRunner.WorkingDir = outDir;
-            Directory.CreateDirectory(outDir);
-            return true;
-        }
-
-        public bool Step2_DecryptAax()
-        {
-            DecryptProgressUpdate?.Invoke(this, 0);
-
-            var tempRipFile = Path.Combine(outDir, "funny.aac");
-
-            var fail = "WARNING-Decrypt failure. ";
-
-            int returnCode;
-            if (string.IsNullOrWhiteSpace(decryptKey))
-            {
-                returnCode = getKey_decrypt(tempRipFile);
-            }
-            else
-            {
-                returnCode = decrypt(tempRipFile);
-                if (returnCode == -99)
-                {
-                    Console.WriteLine($"{fail}Incorrect decrypt key: {decryptKey}");
-                    decryptKey = null;
-                    returnCode = getKey_decrypt(tempRipFile);
-                }
-            }
-
-            if (returnCode == 100)
-                Console.WriteLine($"{fail}Thread completed without changing return code. This shouldn't be possible");
-            else if (returnCode == 0)
-            {
-                // success!
-                FileExt.SafeMove(tempRipFile, outputFileWithNewExt(".mp4"));
-                DecryptProgressUpdate?.Invoke(this, 100);
-                return true;
-            }
-            else if (returnCode == -99)
-                Console.WriteLine($"{fail}Incorrect decrypt key: {decryptKey}");
-            else // any other returnCode
-                Console.WriteLine($"{fail}Unknown failure code: {returnCode}");
-
-            FileExt.SafeDelete(tempRipFile);
-            DecryptProgressUpdate?.Invoke(this, 0);
-            return false;
-        }
-
-        private int getKey_decrypt(string tempRipFile)
-        {
-            getKey();
-            return decrypt(tempRipFile);
-        }
-        private void getKey()
-        {
-            Console.WriteLine("Discovering decrypt key");
-
-            Console.WriteLine("Getting file hash");
-            var checksum = BytesCracker.GetChecksum(inputFileName);
-            Console.WriteLine("File hash calculated: " + checksum);
-
-            Console.WriteLine("Cracking activation bytes");
-            var activation_bytes = BytesCracker.GetActivationBytes(checksum);
-            decryptKey = activation_bytes;
-            Console.WriteLine("Activation bytes cracked. Decrypt key: " + activation_bytes);
-        }
-
-        private int decrypt(string tempRipFile)
-        {
-            FileExt.SafeDelete(tempRipFile);
-
-            Console.WriteLine("Decrypting with key " + decryptKey);
-
-            var returnCode = 100;
-            var thread = new Thread(() => returnCode = ngDecrypt());
-            thread.Start();
-
-            double fileLen = new FileInfo(inputFileName).Length;
-            while (thread.IsAlive && returnCode == 100)
-            {
-                Thread.Sleep(500);
-                if (File.Exists(tempRipFile))
-                {
-                    double tempLen = new FileInfo(tempRipFile).Length;
-                    var percentProgress = tempLen / fileLen * 100.0;
-                    DecryptProgressUpdate?.Invoke(this, (int)percentProgress);
-                }
-            }
-
-            return returnCode;
-        }
-
-        private int ngDecrypt()
-        {
-            var info = new ProcessStartInfo
-            {
-                FileName = DecryptSupportLibraries.mp4trackdumpPath,
-                Arguments = "-c " + encodingInfo.channels + " -r " + encodingInfo.sampleRate + " \"" + inputFileName + "\""
-            };
-            info.EnvironmentVariables["VARIABLE"] = decryptKey;
-
-            var result = info.RunHidden();
-
-            // bad checksum -- bad decrypt key
-            if (result.Output.Contains("checksums mismatch, aborting!"))
-                return -99;
-
-            return result.ExitCode;
-        }
-
-		// temp file names for steps 3, 4, 5
-        string tempChapsGuid { get; } = Guid.NewGuid().ToString().ToUpper().Replace("-", "");
-        string tempChapsPath => Path.Combine(outDir, $"tempChaps_{tempChapsGuid}.mp4");
-        string mp4_file => outputFileWithNewExt(".mp4");
-        string ff_txt_file => mp4_file + ".ff.txt";
-
-        public bool Step3_Chapterize()
-        {
-            var str1 = "";
-            if (chapters.FirstChapterStart != 0.0)
-            {
-                str1 = " -ss " + chapters.FirstChapterStart.ToString("0.000", CultureInfo.InvariantCulture) + " -t " + (chapters.LastChapterStart - 1.0).ToString("0.000", CultureInfo.InvariantCulture) + " ";
-            }
-
-            var ffmpegTags = tags.GenerateFfmpegTags();
-            var ffmpegChapters = chapters.GenerateFfmpegChapters();
-            File.WriteAllText(ff_txt_file, ffmpegTags + ffmpegChapters);
-
-            var tagAndChapterInfo = new ProcessStartInfo
-            {
-                FileName = DecryptSupportLibraries.ffmpegPath,
-                Arguments = "-y -i \"" + mp4_file + "\" -f ffmetadata -i \"" + ff_txt_file + "\" -map_metadata 1  -bsf:a aac_adtstoasc -c:a copy" + str1 + " -map 0 \"" + tempChapsPath + "\""
-            };
-            tagAndChapterInfo.RunHidden();
-
-            return true;
-        }
-
-        public bool Step4_InsertCoverArt()
-        {
-            // save cover image as temp file
-            var coverPath = Path.Combine(outDir, "cover-" + Guid.NewGuid() + ".jpg");
-            FileExt.CreateFile(coverPath, coverBytes);
-
-            var insertCoverArtInfo = new ProcessStartInfo
-            {
-                FileName = DecryptSupportLibraries.atomicParsleyPath,
-                Arguments = "\"" + tempChapsPath + "\" --encodingTool \"" + AppName + "\" --artwork \"" + coverPath + "\" --overWrite"
-            };
-            insertCoverArtInfo.RunHidden();
-
-            // delete temp file
-            FileExt.SafeDelete(coverPath);
-
-            return true;
-        }
-
-        public bool Step5_Cleanup()
-        {
-            FileExt.SafeDelete(mp4_file);
-            FileExt.SafeDelete(ff_txt_file);
-            FileExt.SafeMove(tempChapsPath, outputFileName);
-
-            return true;
-        }
-
-        public bool Step6_AddTags()
-        {
-            tags.AddAppleTags(outputFileName);
-            return true;
-        }
-
-        public bool End_CreateCue()
-        {
-            File.WriteAllText(outputFileWithNewExt(".cue"), chapters.GetCuefromChapters(Path.GetFileName(outputFileName)));
-            return true;
-        }
-
-        public bool End_CreateNfo()
-        {
-            File.WriteAllText(outputFileWithNewExt(".nfo"), NFO.CreateNfoContents(AppName, tags, encodingInfo, chapters));
-            return true;
-        }
-    }
-}

AaxDecrypter/UNTESTED/BytesCracker.cs

@@ -1,52 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Text;
-using System.Threading.Tasks;
-using Dinah.Core;
-using Dinah.Core.Diagnostics;
-
-namespace AaxDecrypter
-{
-    public static class BytesCracker
-    {
-        public static string GetChecksum(string aaxPath)
-        {
-            var info = new ProcessStartInfo
-            {
-                FileName = BytesCrackerSupportLibraries.ffprobePath,
-                Arguments = aaxPath.SurroundWithQuotes(),
-                WorkingDirectory = Directory.GetCurrentDirectory()
-            };
-
-            // checksum is in the debug info. ffprobe's debug info is written to stderr, not stdout
-            var ffprobeStderr = info.RunHidden().Error;
-
-            // example checksum line:
-            // ... [aax] file checksum == 0c527840c4f18517157eb0b4f9d6f9317ce60cd1
-            var checksum = ffprobeStderr.ExtractString("file checksum == ", 40);
-
-            return checksum;
-        }
-
-        /// <summary>use checksum to get activation bytes. activation bytes are unique per audible customer. only have to do this 1x/customer</summary>
-        public static string GetActivationBytes(string checksum)
-        {
-            var info = new ProcessStartInfo
-            {
-                FileName = BytesCrackerSupportLibraries.rcrackPath,
-                Arguments = @". -h " + checksum,
-                WorkingDirectory = Directory.GetCurrentDirectory()
-            };
-
-            var rcrackStdout = info.RunHidden().Output;
-
-            // example result
-            // 0c527840c4f18517157eb0b4f9d6f9317ce60cd1  \xbd\x89X\x09  hex:bd895809
-            var activation_bytes = rcrackStdout.ExtractString("hex:", 8);
-
-            return activation_bytes;
-        }
-    }
-}

AaxDecrypter/UNTESTED/BytesCrackerSupportLibraries.cs

@@ -1,28 +0,0 @@
-using System.IO;
-
-namespace AaxDecrypter
-{
-    public static class BytesCrackerSupportLibraries
-    {
-        // GetActivationBytes dependencies
-        //   rcrack.exe
-        //   alglib1.dll
-        //   RainbowCrack files to recover your own Audible activation data (activation_bytes) in an offline manner
-        //   audible_byte#4-4_0_10000x789935_0.rtc
-        //   audible_byte#4-4_1_10000x791425_0.rtc
-        //   audible_byte#4-4_2_10000x790991_0.rtc
-        //   audible_byte#4-4_3_10000x792120_0.rtc
-        //   audible_byte#4-4_4_10000x790743_0.rtc
-        //   audible_byte#4-4_5_10000x790568_0.rtc
-        //   audible_byte#4-4_6_10000x791458_0.rtc
-        //   audible_byte#4-4_7_10000x791707_0.rtc
-        //   audible_byte#4-4_8_10000x790202_0.rtc
-        //   audible_byte#4-4_9_10000x791022_0.rtc
-
-        private static string appPath_ { get; } = Path.GetDirectoryName(Dinah.Core.Exe.FileLocationOnDisk);
-        private static string bytesCrackerLib_ { get; } = Path.Combine(appPath_, "BytesCrackerLib");
-
-        public static string ffprobePath { get; } = Path.Combine(bytesCrackerLib_, "ffprobe.exe");
-        public static string rcrackPath { get; } = Path.Combine(bytesCrackerLib_, "rcrack.exe");
-    }
-}

AaxDecrypter/UNTESTED/Chapters.cs

@@ -1,95 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Globalization;
-using System.Linq;
-using System.Text;
-using Dinah.Core.Diagnostics;
-
-namespace AaxDecrypter
-{
-    public class Chapters
-    {
-        private List<double> markers { get; }
-
-        public double FirstChapterStart => markers[0];
-        public double LastChapterStart => markers[markers.Count - 1];
-
-        public Chapters(string file, double totalTime)
-        {
-            markers = getAAXChapters(file);
-
-            // add end time
-            markers.Add(totalTime);
-        }
-
-        private static List<double> getAAXChapters(string file)
-        {
-            var info = new ProcessStartInfo
-            {
-                FileName = DecryptSupportLibraries.ffprobePath,
-                Arguments = "-loglevel panic -show_chapters -print_format xml \"" + file + "\""
-            };
-            var xml = info.RunHidden().Output;
-
-            var xmlDocument = new System.Xml.XmlDocument();
-            xmlDocument.LoadXml(xml);
-            var chapters = xmlDocument.SelectNodes("/ffprobe/chapters/chapter")
-                .Cast<System.Xml.XmlNode>()
-                .Select(xmlNode => double.Parse(xmlNode.Attributes["start_time"].Value.Replace(",", "."), CultureInfo.InvariantCulture))
-                .ToList();
-            return chapters;
-        }
-
-        // subtract 1 b/c end time marker is a real entry but isn't a real chapter
-        public int Count() => markers.Count - 1;
-
-        public string GetCuefromChapters(string fileName)
-        {
-            var stringBuilder = new StringBuilder();
-            if (fileName != "")
-            {
-                stringBuilder.Append("FILE \"" + fileName + "\" MP4\n");
-            }
-
-            for (var i = 0; i < Count(); i++)
-            {
-                var chapter = i + 1;
-
-                var timeSpan = TimeSpan.FromSeconds(markers[i]);
-                var minutes = Math.Floor(timeSpan.TotalMinutes).ToString();
-                var seconds = timeSpan.Seconds.ToString("D2");
-                var milliseconds = (timeSpan.Milliseconds / 10).ToString("D2");
-                string str = minutes + ":" + seconds + ":" + milliseconds;
-
-                stringBuilder.Append("TRACK " + chapter + " AUDIO\n");
-                stringBuilder.Append("  TITLE \"Chapter " + chapter.ToString("D2") + "\"\n");
-                stringBuilder.Append("  INDEX 01 " + str + "\n");
-            }
-
-            return stringBuilder.ToString();
-        }
-
-        public string GenerateFfmpegChapters()
-        {
-            var stringBuilder = new StringBuilder();
-
-            for (var i = 0; i < Count(); i++)
-            {
-                var chapter = i + 1;
-
-                var start = markers[i] * 1000.0;
-                var end = markers[i + 1] * 1000.0;
-                var chapterName = chapter.ToString("D3");
-
-                stringBuilder.Append("[CHAPTER]\n");
-                stringBuilder.Append("TIMEBASE=1/1000\n");
-                stringBuilder.Append("START=" + start + "\n");
-                stringBuilder.Append("END=" + end + "\n");
-                stringBuilder.Append("title=" + chapterName + "\n");
-            }
-
-            return stringBuilder.ToString();
-        }
-    }
-}

AaxDecrypter/UNTESTED/DecryptSupportLibraries.cs

@@ -1,21 +0,0 @@
-using System.IO;
-
-namespace AaxDecrypter
-{
-    public static class DecryptSupportLibraries
-    {
-        // OTHER EXTERNAL DEPENDENCIES
-        // ffprobe has these pre-req.s as I'm using it:
-        // avcodec-57.dll, avdevice-57.dll, avfilter-6.dll, avformat-57.dll, avutil-55.dll, postproc-54.dll, swresample-2.dll, swscale-4.dll, taglib-sharp.dll
-        //
-        // something else needs the cygwin files (cyg*.dll)
-
-        private static string appPath_ { get; } = Path.GetDirectoryName(Dinah.Core.Exe.FileLocationOnDisk);
-        private static string decryptLib_ { get; } = Path.Combine(appPath_, "DecryptLib");
-
-        public static string ffmpegPath { get; } = Path.Combine(decryptLib_, "ffmpeg.exe");
-        public static string ffprobePath { get; } = Path.Combine(decryptLib_, "ffprobe.exe");
-        public static string atomicParsleyPath { get; } = Path.Combine(decryptLib_, "AtomicParsley.exe");
-        public static string mp4trackdumpPath { get; } = Path.Combine(decryptLib_, "mp4trackdump.exe");
-    }
-}

AaxDecrypter/UNTESTED/EncodingInfo.cs

@@ -1,41 +0,0 @@
-using System;
-using System.Diagnostics;
-using Dinah.Core.Diagnostics;
-
-namespace AaxDecrypter
-{
-    public class EncodingInfo
-    {
-        public int sampleRate { get; } = 44100;
-        public int channels { get; } = 2;
-        public int originalBitrate { get; }
-
-        public EncodingInfo(string file)
-        {
-            var info = new ProcessStartInfo
-            {
-                FileName = DecryptSupportLibraries.ffprobePath,
-                Arguments = "-loglevel panic -show_streams -print_format flat \"" + file + "\""
-            };
-            var end = info.RunHidden().Output;
-
-            foreach (string str2 in end.Split('\n'))
-            {
-                string[] strArray = str2.Split('=');
-                switch (strArray[0])
-                {
-                    case "streams.stream.0.channels":
-                        this.channels = int.Parse(strArray[1].Replace("\"", "").TrimEnd('\r', '\n'));
-                        break;
-                    case "streams.stream.0.sample_rate":
-                        this.sampleRate = int.Parse(strArray[1].Replace("\"", "").TrimEnd('\r', '\n'));
-                        break;
-                    case "streams.stream.0.bit_rate":
-                        string s = strArray[1].Replace("\"", "").TrimEnd('\r', '\n');
-                        this.originalBitrate = (int)Math.Round(double.Parse(s) / 1000.0, MidpointRounding.AwayFromZero);
-                        break;
-                }
-            }
-        }
-    }
-}

AaxDecrypter/UNTESTED/NFO.cs

@@ -1,56 +0,0 @@
-namespace AaxDecrypter
-{
-    public static class NFO
-    {
-        public static string CreateNfoContents(string ripper, Tags tags, EncodingInfo encodingInfo, Chapters chapters)
-        {
-            int _hours = (int)tags.duration.TotalHours;
-            string myDuration
-                = (_hours > 0 ? _hours + " hours, " : "")
-                + tags.duration.Minutes + " minutes, "
-                + tags.duration.Seconds + " seconds";
-
-            string str4
-                = "General Information\r\n"
-                + "===================\r\n"
-                + " Title:                  " + tags.title + "\r\n"
-                + " Author:                 " + tags.author + "\r\n"
-                + " Read By:                " + tags.narrator + "\r\n"
-                + " Copyright:              " + tags.year + "\r\n"
-                + " Audiobook Copyright:    " + tags.year + "\r\n";
-            if (tags.genre != "")
-            {
-                str4 = str4 + " Genre:                  " + tags.genre + "\r\n";
-            }
-
-            string s
-                = str4
-                + " Publisher:              " + tags.publisher + "\r\n"
-                + " Duration:               " + myDuration + "\r\n"
-                + " Chapters:               " + chapters.Count() + "\r\n"
-                + "\r\n"
-                + "\r\n"
-                + "Media Information\r\n"
-                + "=================\r\n"
-                + " Source Format:          Audible AAX\r\n"
-                + " Source Sample Rate:     " + encodingInfo.sampleRate + " Hz\r\n"
-                + " Source Channels:        " + encodingInfo.channels + "\r\n"
-                + " Source Bitrate:         " + encodingInfo.originalBitrate + " kbits\r\n"
-                + "\r\n"
-                + " Lossless Encode:        Yes\r\n"
-                + " Encoded Codec:          AAC / M4B\r\n"
-                + " Encoded Sample Rate:    " + encodingInfo.sampleRate + " Hz\r\n"
-                + " Encoded Channels:       " + encodingInfo.channels + "\r\n"
-                + " Encoded Bitrate:        " + encodingInfo.originalBitrate + " kbits\r\n"
-                + "\r\n"
-                + " Ripper:                 " + ripper + "\r\n"
-                + "\r\n"
-                + "\r\n"
-                + "Book Description\r\n"
-                + "================\r\n"
-                + tags.comments;
-
-            return s;
-        }
-    }
-}

AaxDecrypter/UNTESTED/Tags.cs

@@ -1,67 +0,0 @@
-using System;
-using TagLib;
-using TagLib.Mpeg4;
-using Dinah.Core;
-
-namespace AaxDecrypter
-{
-    public class Tags
-    {
-        public string title { get; }
-        public string album { get; }
-        public string author { get; }
-        public string comments { get; }
-        public string narrator { get; }
-        public string year { get; }
-        public string publisher { get; }
-        public string id { get; }
-        public string genre { get; }
-        public TimeSpan duration { get; }
-
-        // input file
-        public Tags(string file)
-        {
-            using var tagLibFile = TagLib.File.Create(file, "audio/mp4", ReadStyle.Average);
-			title = tagLibFile.Tag.Title.Replace(" (Unabridged)", "");
-			album = tagLibFile.Tag.Album.Replace(" (Unabridged)", "");
-			author = tagLibFile.Tag.FirstPerformer ?? "[unknown]";
-			year = tagLibFile.Tag.Year.ToString();
-			comments = tagLibFile.Tag.Comment ?? "";
-			duration = tagLibFile.Properties.Duration;
-			genre = tagLibFile.Tag.FirstGenre ?? "";
-
-            var tag = tagLibFile.GetTag(TagTypes.Apple, true);
-			publisher = tag.Publisher ?? "";
-			narrator = string.IsNullOrWhiteSpace(tagLibFile.Tag.FirstComposer) ? tag.Narrator : tagLibFile.Tag.FirstComposer;
-			comments = !string.IsNullOrWhiteSpace(tag.LongDescription) ? tag.LongDescription : tag.Description;
-			id = tag.AudibleCDEK;
-		}
-
-        // my best guess of what this step is doing:
-        // re-publish the data we read from the input file => output file
-        public void AddAppleTags(string file)
-        {
-            using var tagLibFile = TagLib.File.Create(file, "audio/mp4", ReadStyle.Average);
-            var tag = (AppleTag)tagLibFile.GetTag(TagTypes.Apple, true);
-			tag.Publisher = publisher;
-			tag.LongDescription = comments;
-			tag.Description = comments;
-            tagLibFile.Save();
-		}
-
-        public string GenerateFfmpegTags()
-            => $";FFMETADATA1"
-            + $"\nmajor_brand=aax"
-            + $"\nminor_version=1"
-            + $"\ncompatible_brands=aax M4B mp42isom"
-            + $"\ndate={year}"
-            + $"\ngenre={genre}"
-            + $"\ntitle={title}"
-            + $"\nartist={author}"
-            + $"\nalbum={album}"
-            + $"\ncomposer={narrator}"
-            + $"\ncomment={comments.Truncate(254)}"
-            + $"\ndescription={comments}"
-            + $"\n";
-    }
-}

ApplicationServices/ApplicationServices.csproj

@@ -1,9 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="CsvHelper" Version="27.1.1" />
+    <PackageReference Include="NPOI" Version="2.5.3" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\..\audible api\AudibleApi\AudibleApiDTOs\AudibleApiDTOs.csproj" />
     <ProjectReference Include="..\..\audible api\AudibleApi\AudibleApi\AudibleApi.csproj" />

ApplicationServices/LibraryCommands.cs

@@ -0,0 +1,287 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using AudibleApi;
+using DataLayer;
+using Dinah.Core;
+using DtoImporterService;
+using InternalUtilities;
+using Serilog;
+
+namespace ApplicationServices
+{
+	// subtly different from DataLayer.LiberatedStatus
+	// - DataLayer.LiberatedStatus: has no concept of partially downloaded
+	// - ApplicationServices.LiberatedState: has no concept of Error/skipped
+	public enum LiberatedState { NotDownloaded, PartialDownload, Liberated }
+
+	public enum PdfState { NoPdf, Downloaded, NotDownloaded }
+
+	public static class LibraryCommands
+	{
+		private static LibraryOptions.ResponseGroupOptions LibraryResponseGroups = LibraryOptions.ResponseGroupOptions.ALL_OPTIONS;
+
+		public static async Task<List<LibraryBook>> FindInactiveBooks(Func<Account, ILoginCallback> loginCallbackFactoryFunc, List<LibraryBook> existingLibrary, params Account[] accounts)
+        {
+			//These are the minimum response groups required for the
+			//library scanner to pass all validation and filtering.
+			LibraryResponseGroups = 
+				LibraryOptions.ResponseGroupOptions.ProductAttrs |
+				LibraryOptions.ResponseGroupOptions.ProductDesc | 
+				LibraryOptions.ResponseGroupOptions.Relationships;
+
+			if (accounts is null || accounts.Length == 0)
+				return new List<LibraryBook>();
+
+			try
+			{
+				var libraryItems = await scanAccountsAsync(loginCallbackFactoryFunc, accounts);
+				Log.Logger.Information($"GetAllLibraryItems: Total count {libraryItems.Count}");
+
+				var missingBookList = existingLibrary.Where(b => !libraryItems.Any(i => i.DtoItem.Asin == b.Book.AudibleProductId)).ToList();
+
+				return missingBookList;
+			}
+			catch (AudibleApi.Authentication.LoginFailedException lfEx)
+			{
+				lfEx.SaveFiles(FileManager.Configuration.Instance.LibationFiles);
+
+				// nuget Serilog.Exceptions would automatically log custom properties
+				//   However, it comes with a scary warning when used with EntityFrameworkCore which I'm not yet ready to implement:
+				//   https://github.com/RehanSaeed/Serilog.Exceptions
+				// work-around: use 3rd param. don't just put exception object in 3rd param -- info overload: stack trace, etc
+				Log.Logger.Error(lfEx, "Error scanning library. Login failed. {@DebugInfo}", new
+				{
+					lfEx.RequestUrl,
+					ResponseStatusCodeNumber = (int)lfEx.ResponseStatusCode,
+					ResponseStatusCodeDesc = lfEx.ResponseStatusCode,
+					lfEx.ResponseInputFields,
+					lfEx.ResponseBodyFilePaths
+				});
+				throw;
+			}
+			catch (Exception ex)
+			{
+				Log.Logger.Error(ex, "Error importing library");
+				throw;
+			}
+            finally
+            {
+				LibraryResponseGroups = LibraryOptions.ResponseGroupOptions.ALL_OPTIONS;
+            }
+		}
+		#region FULL LIBRARY scan and import
+		public static async Task<(int totalCount, int newCount)> ImportAccountAsync(Func<Account, ILoginCallback> loginCallbackFactoryFunc, params Account[] accounts)
+		{
+			if (accounts is null || accounts.Length == 0)
+				return (0, 0);
+
+			try
+			{
+				var importItems = await scanAccountsAsync(loginCallbackFactoryFunc, accounts);
+
+				var totalCount = importItems.Count;
+				Log.Logger.Information($"GetAllLibraryItems: Total count {totalCount}");
+
+				var newCount = await importIntoDbAsync(importItems);
+				Log.Logger.Information($"Import: New count {newCount}");
+
+				await Task.Run(() => SearchEngineCommands.FullReIndex());
+				Log.Logger.Information("FullReIndex: success");
+
+				return (totalCount, newCount);
+			}
+			catch (AudibleApi.Authentication.LoginFailedException lfEx)
+			{
+				lfEx.SaveFiles(FileManager.Configuration.Instance.LibationFiles);
+
+				// nuget Serilog.Exceptions would automatically log custom properties
+				//   However, it comes with a scary warning when used with EntityFrameworkCore which I'm not yet ready to implement:
+				//   https://github.com/RehanSaeed/Serilog.Exceptions
+				// work-around: use 3rd param. don't just put exception object in 3rd param -- info overload: stack trace, etc
+				Log.Logger.Error(lfEx, "Error importing library. Login failed. {@DebugInfo}", new
+				{
+					lfEx.RequestUrl,
+					ResponseStatusCodeNumber = (int)lfEx.ResponseStatusCode,
+					ResponseStatusCodeDesc = lfEx.ResponseStatusCode,
+					lfEx.ResponseInputFields,
+					lfEx.ResponseBodyFilePaths
+				});
+				throw;
+			}
+			catch (Exception ex)
+			{
+				Log.Logger.Error(ex, "Error importing library");
+				throw;
+			}
+		}
+
+		private static async Task<List<ImportItem>> scanAccountsAsync(Func<Account, ILoginCallback> loginCallbackFactoryFunc, Account[] accounts)
+		{
+			var tasks = new List<Task<List<ImportItem>>>();
+			foreach (var account in accounts)
+			{
+				var callback = loginCallbackFactoryFunc(account);
+
+				// get APIs in serial, esp b/c of logins
+				var api = await AudibleApiActions.GetApiAsync(callback, account);
+
+				// add scanAccountAsync as a TASK: do not await
+				tasks.Add(scanAccountAsync(api, account));
+			}
+
+			// import library in parallel
+			var arrayOfLists = await Task.WhenAll(tasks);
+			var importItems = arrayOfLists.SelectMany(a => a).ToList();
+			return importItems;
+		}
+
+		private static async Task<List<ImportItem>> scanAccountAsync(Api api, Account account)
+		{
+			ArgumentValidator.EnsureNotNull(account, nameof(account));
+
+			Log.Logger.Information("ImportLibraryAsync. {@DebugInfo}", new
+			{
+				Account = account?.MaskedLogEntry ?? "[null]"
+			});
+
+			var dtoItems = await AudibleApiActions.GetLibraryValidatedAsync(api, LibraryResponseGroups);
+			return dtoItems.Select(d => new ImportItem { DtoItem = d, AccountId = account.AccountId, LocaleName = account.Locale?.Name }).ToList();
+		}
+
+		private static async Task<int> importIntoDbAsync(List<ImportItem> importItems)
+		{
+			using var context = DbContexts.GetContext();
+			var libraryImporter = new LibraryImporter(context);
+			var newCount = await Task.Run(() => libraryImporter.Import(importItems));
+			context.SaveChanges();
+
+			return newCount;
+		}
+		#endregion
+
+		#region Update book details
+		public static int UpdateTags(Book book, string newTags)
+		{
+			try
+			{
+				using var context = DbContexts.GetContext();
+
+				var udi = book.UserDefinedItem;
+
+				if (udi.Tags == newTags)
+					return 0;
+
+				// Attach() NoTracking entities before SaveChanges()
+				udi.Tags = newTags;
+				context.Attach(udi).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
+				var qtyChanges = context.SaveChanges();
+
+				if (qtyChanges > 0)
+					SearchEngineCommands.UpdateBookTags(book);
+
+				return qtyChanges;
+			}
+			catch (Exception ex)
+			{
+				Log.Logger.Error(ex, "Error updating tags");
+				throw;
+			}
+		}
+
+		public static int UpdateBook(LibraryBook libraryBook, LiberatedStatus liberatedStatus, string finalAudioPath)
+		{
+			try
+			{
+				using var context = DbContexts.GetContext();
+
+				var udi = libraryBook.Book.UserDefinedItem;
+
+				if (udi.BookStatus == liberatedStatus && udi.BookLocation == finalAudioPath)
+					return 0;
+
+				// Attach() NoTracking entities before SaveChanges()
+				udi.BookStatus = liberatedStatus;
+				udi.BookLocation = finalAudioPath;
+				context.Attach(udi).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
+				var qtyChanges = context.SaveChanges();
+				if (qtyChanges > 0)
+					SearchEngineCommands.UpdateLiberatedStatus(libraryBook.Book);
+
+				return qtyChanges;
+			}
+			catch (Exception ex)
+			{
+				Log.Logger.Error(ex, "Error updating tags");
+				throw;
+			}
+		}
+
+		public static int UpdatePdf(LibraryBook libraryBook, LiberatedStatus liberatedStatus)
+		{
+			try
+			{
+				using var context = DbContexts.GetContext();
+
+				var udi = libraryBook.Book.UserDefinedItem;
+
+				if (udi.PdfStatus == liberatedStatus)
+					return 0;
+
+				// Attach() NoTracking entities before SaveChanges()
+				udi.PdfStatus = liberatedStatus;
+				context.Attach(udi).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
+				var qtyChanges = context.SaveChanges();
+
+				return qtyChanges;
+			}
+			catch (Exception ex)
+			{
+				Log.Logger.Error(ex, "Error updating tags");
+				throw;
+			}
+		}
+		#endregion
+
+		// below are queries, not commands. maybe I should make a LibraryQueries. except there's already one of those...
+
+		public static LiberatedState Liberated_Status(Book book)
+			=> TransitionalFileLocator.Audio_Exists(book) ? LiberatedState.Liberated
+			: TransitionalFileLocator.AAXC_Exists(book) ? LiberatedState.PartialDownload
+			: LiberatedState.NotDownloaded;
+
+		public static PdfState Pdf_Status(Book book)
+			=> !book.Supplements.Any() ? PdfState.NoPdf
+			: TransitionalFileLocator.PDF_Exists(book) ? PdfState.Downloaded
+			: PdfState.NotDownloaded;
+
+		public record LibraryStats(int booksFullyBackedUp, int booksDownloadedOnly, int booksNoProgress, int pdfsDownloaded, int pdfsNotDownloaded) { }
+		public static LibraryStats GetCounts()
+		{
+			var libraryBooks = DbContexts.GetContext().GetLibrary_Flat_NoTracking();
+
+			var results = libraryBooks
+				.AsParallel()
+				.Select(lb => Liberated_Status(lb.Book))
+				.ToList();
+			var booksFullyBackedUp = results.Count(r => r == LiberatedState.Liberated);
+			var booksDownloadedOnly = results.Count(r => r == LiberatedState.PartialDownload);
+			var booksNoProgress = results.Count(r => r == LiberatedState.NotDownloaded);
+
+			Log.Logger.Information("Book counts. {@DebugInfo}", new { total = results.Count, booksFullyBackedUp, booksDownloadedOnly, booksNoProgress });
+
+			var boolResults = libraryBooks
+				.AsParallel()
+				.Where(lb => lb.Book.Supplements.Any())
+				.Select(lb => Pdf_Status(lb.Book))
+				.ToList();
+			var pdfsDownloaded = boolResults.Count(r => r == PdfState.Downloaded);
+			var pdfsNotDownloaded = boolResults.Count(r => r == PdfState.NotDownloaded);
+
+			Log.Logger.Information("PDF counts. {@DebugInfo}", new { total = boolResults.Count, pdfsDownloaded, pdfsNotDownloaded });
+
+			return new(booksFullyBackedUp, booksDownloadedOnly, booksNoProgress, pdfsDownloaded, pdfsNotDownloaded);
+		}
+	}
+}

ApplicationServices/LibraryExporter.cs

@@ -0,0 +1,286 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using CsvHelper;
+using CsvHelper.Configuration.Attributes;
+using DataLayer;
+using NPOI.XSSF.UserModel;
+using Serilog;
+
+namespace ApplicationServices
+{
+	public class ExportDto
+	{
+		public static string GetName(string fieldName)
+		{
+			var property = typeof(ExportDto).GetProperty(fieldName);
+			var attribute = property.GetCustomAttributes(typeof(NameAttribute), true)[0];
+			var description = (NameAttribute)attribute;
+			var text = description.Names;
+			return text[0];
+		}
+
+		[Name("Account")]
+		public string Account { get; set; }
+
+		[Name("Date Added to library")]
+		public DateTime DateAdded { get; set; }
+
+		[Name("Audible Product Id")]
+		public string AudibleProductId { get; set; }
+
+		[Name("Locale")]
+		public string Locale { get; set; }
+
+		[Name("Title")]
+		public string Title { get; set; }
+
+		[Name("Authors")]
+		public string AuthorNames { get; set; }
+
+		[Name("Narrators")]
+		public string NarratorNames { get; set; }
+
+		[Name("Length In Minutes")]
+		public int LengthInMinutes { get; set; }
+
+		[Name("Publisher")]
+		public string Publisher { get; set; }
+
+		[Name("Pdf url")]
+		public string PdfUrl { get; set; }
+
+		[Name("Series Names")]
+		public string SeriesNames { get; set; }
+
+		[Name("Series Order")]
+		public string SeriesOrder { get; set; }
+
+		[Name("Community Rating: Overall")]
+		public float? CommunityRatingOverall { get; set; }
+
+		[Name("Community Rating: Performance")]
+		public float? CommunityRatingPerformance { get; set; }
+
+		[Name("Community Rating: Story")]
+		public float? CommunityRatingStory { get; set; }
+
+		[Name("Cover Id")]
+		public string PictureId { get; set; }
+
+		[Name("Is Abridged?")]
+		public bool IsAbridged { get; set; }
+
+		[Name("Date Published")]
+		public DateTime? DatePublished { get; set; }
+
+		[Name("Categories")]
+		public string CategoriesNames { get; set; }
+
+		[Name("My Rating: Overall")]
+		public float? MyRatingOverall { get; set; }
+
+		[Name("My Rating: Performance")]
+		public float? MyRatingPerformance { get; set; }
+
+		[Name("My Rating: Story")]
+		public float? MyRatingStory { get; set; }
+
+		[Name("My Libation Tags")]
+		public string MyLibationTags { get; set; }
+
+		[Name("Book Liberation Status")]
+		public string BookStatus { get; set; }
+
+		[Name("Book File Location")]
+		public string BookLocation { get; set; }
+
+		[Name("PDF Liberation Status")]
+		public string PdfStatus { get; set; }
+	}
+	public static class LibToDtos
+	{
+		public static List<ExportDto> ToDtos(this IEnumerable<LibraryBook> library)
+			=> library.Select(a => new ExportDto
+			{
+				Account = a.Account,
+				DateAdded = a.DateAdded,
+				AudibleProductId = a.Book.AudibleProductId,
+				Locale = a.Book.Locale,
+				Title = a.Book.Title,
+				AuthorNames = a.Book.AuthorNames,
+				NarratorNames = a.Book.NarratorNames,
+				LengthInMinutes = a.Book.LengthInMinutes,
+				Publisher = a.Book.Publisher,
+				PdfUrl = a.Book.Supplements?.FirstOrDefault()?.Url,
+				SeriesNames = a.Book.SeriesNames,
+				SeriesOrder = a.Book.SeriesLink.Any() ? a.Book.SeriesLink?.Select(sl => $"{sl.Index} : {sl.Series.Name}").Aggregate((a, b) => $"{a}, {b}") : "",
+				CommunityRatingOverall = a.Book.Rating?.OverallRating,
+				CommunityRatingPerformance = a.Book.Rating?.PerformanceRating,
+				CommunityRatingStory = a.Book.Rating?.StoryRating,
+				PictureId = a.Book.PictureId,
+				IsAbridged = a.Book.IsAbridged,
+				DatePublished = a.Book.DatePublished,
+				CategoriesNames = a.Book.CategoriesNames.Any() ? a.Book.CategoriesNames.Aggregate((a, b) => $"{a}, {b}") : "",
+				MyRatingOverall = a.Book.UserDefinedItem.Rating.OverallRating,
+				MyRatingPerformance = a.Book.UserDefinedItem.Rating.PerformanceRating,
+				MyRatingStory = a.Book.UserDefinedItem.Rating.StoryRating,
+				MyLibationTags = a.Book.UserDefinedItem.Tags,
+				BookStatus = a.Book.UserDefinedItem.BookStatus.ToString(),
+				BookLocation = a.Book.UserDefinedItem.BookLocation,
+				PdfStatus = a.Book.UserDefinedItem.PdfStatus.ToString()
+			}).ToList();
+	}
+	public static class LibraryExporter
+	{
+		public static void ToCsv(string saveFilePath)
+		{
+			using var context = DbContexts.GetContext();
+			var dtos = context.GetLibrary_Flat_NoTracking().ToDtos();
+
+			if (!dtos.Any())
+				return;
+
+			using var writer = new System.IO.StreamWriter(saveFilePath);
+			using var csv = new CsvWriter(writer, System.Globalization.CultureInfo.CurrentCulture);
+
+			csv.WriteHeader(typeof(ExportDto));
+			csv.NextRecord();
+			csv.WriteRecords(dtos);
+		}
+
+		public static void ToJson(string saveFilePath)
+		{
+			using var context = DbContexts.GetContext();
+			var dtos = context.GetLibrary_Flat_NoTracking().ToDtos();
+
+			var json = Newtonsoft.Json.JsonConvert.SerializeObject(dtos, Newtonsoft.Json.Formatting.Indented);
+			System.IO.File.WriteAllText(saveFilePath, json);
+		}
+
+		public static void ToXlsx(string saveFilePath)
+		{
+			using var context = DbContexts.GetContext();
+			var dtos = context.GetLibrary_Flat_NoTracking().ToDtos();
+
+			var workbook = new XSSFWorkbook();
+			var sheet = workbook.CreateSheet("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),
+				nameof (ExportDto.AudibleProductId),
+				nameof (ExportDto.Locale),
+				nameof (ExportDto.Title),
+				nameof (ExportDto.AuthorNames),
+				nameof (ExportDto.NarratorNames),
+				nameof (ExportDto.LengthInMinutes),
+				nameof (ExportDto.Publisher),
+				nameof (ExportDto.PdfUrl),
+				nameof (ExportDto.SeriesNames),
+				nameof (ExportDto.SeriesOrder),
+				nameof (ExportDto.CommunityRatingOverall),
+				nameof (ExportDto.CommunityRatingPerformance),
+				nameof (ExportDto.CommunityRatingStory),
+				nameof (ExportDto.PictureId),
+				nameof (ExportDto.IsAbridged),
+				nameof (ExportDto.DatePublished),
+				nameof (ExportDto.CategoriesNames),
+				nameof (ExportDto.MyRatingOverall),
+				nameof (ExportDto.MyRatingPerformance),
+				nameof (ExportDto.MyRatingStory),
+				nameof (ExportDto.MyLibationTags),
+				nameof (ExportDto.BookStatus),
+				nameof (ExportDto.BookLocation),
+				nameof (ExportDto.PdfStatus)
+			};
+			var col = 0;
+			foreach (var c in columns)
+			{
+				var cell = row.CreateCell(col++);
+				var name = ExportDto.GetName(c);
+				cell.SetCellValue(name);
+				cell.CellStyle = detailSubtotalCellStyle;
+			}
+
+			var dateFormat = workbook.CreateDataFormat();
+			var dateStyle = workbook.CreateCellStyle();
+			dateStyle.DataFormat = dateFormat.GetFormat("MM/dd/yyyy HH:mm:ss");
+
+			rowIndex++;
+
+			// Add data rows
+			foreach (var dto in dtos)
+			{
+				col = 0;
+
+				row = sheet.CreateRow(rowIndex);
+
+				row.CreateCell(col++).SetCellValue(dto.Account);
+
+				var dateAddedCell = row.CreateCell(col++);
+				dateAddedCell.CellStyle = dateStyle;
+				dateAddedCell.SetCellValue(dto.DateAdded);
+
+				row.CreateCell(col++).SetCellValue(dto.AudibleProductId);
+				row.CreateCell(col++).SetCellValue(dto.Locale);
+				row.CreateCell(col++).SetCellValue(dto.Title);
+				row.CreateCell(col++).SetCellValue(dto.AuthorNames);
+				row.CreateCell(col++).SetCellValue(dto.NarratorNames);
+				row.CreateCell(col++).SetCellValue(dto.LengthInMinutes);
+				row.CreateCell(col++).SetCellValue(dto.Publisher);
+				row.CreateCell(col++).SetCellValue(dto.PdfUrl);
+				row.CreateCell(col++).SetCellValue(dto.SeriesNames);
+				row.CreateCell(col++).SetCellValue(dto.SeriesOrder);
+
+				col = createCell(row, col, dto.CommunityRatingOverall);
+				col = createCell(row, col, dto.CommunityRatingPerformance);
+				col = createCell(row, col, dto.CommunityRatingStory);
+
+				row.CreateCell(col++).SetCellValue(dto.PictureId);
+				row.CreateCell(col++).SetCellValue(dto.IsAbridged);
+
+				var datePubCell = row.CreateCell(col++);
+				datePubCell.CellStyle = dateStyle;
+				if (dto.DatePublished.HasValue)
+					datePubCell.SetCellValue(dto.DatePublished.Value);
+				else
+					datePubCell.SetCellValue("");
+
+				row.CreateCell(col++).SetCellValue(dto.CategoriesNames);
+
+				col = createCell(row, col, dto.MyRatingOverall);
+				col = createCell(row, col, dto.MyRatingPerformance);
+				col = createCell(row, col, dto.MyRatingStory);
+
+				row.CreateCell(col++).SetCellValue(dto.MyLibationTags);
+				row.CreateCell(col++).SetCellValue(dto.BookStatus);
+				row.CreateCell(col++).SetCellValue(dto.BookLocation);
+				row.CreateCell(col++).SetCellValue(dto.PdfStatus);
+
+				rowIndex++;
+			}
+
+			using var fileData = new System.IO.FileStream(saveFilePath, System.IO.FileMode.Create);
+			workbook.Write(fileData);
+		}
+		private static int createCell(NPOI.SS.UserModel.IRow row, int col, float? nullableFloat)
+		{
+			if (nullableFloat.HasValue)
+				row.CreateCell(col++).SetCellValue(nullableFloat.Value);
+			else
+				row.CreateCell(col++).SetCellValue("");
+			return col;
+		}
+	}
+}

ApplicationServices/SearchEngineCommands.cs

@@ -0,0 +1,56 @@
+using System;
+using System.IO;
+using DataLayer;
+using LibationSearchEngine;
+
+namespace ApplicationServices
+{
+	public static class SearchEngineCommands
+	{
+		public static void FullReIndex(SearchEngine engine = null)
+		{
+			engine ??= new SearchEngine();
+			engine.CreateNewIndex(DbContexts.GetContext());
+		}
+
+		public static SearchResultSet Search(string searchString) => performSearchEngineFunc_safe(e =>
+			e.Search(searchString)
+		);
+
+		public static void UpdateBookTags(Book book) => performSearchEngineAction_safe(e =>
+			e.UpdateTags(book.AudibleProductId, book.UserDefinedItem.Tags)
+		);
+
+		public static void UpdateLiberatedStatus(Book book) => performSearchEngineAction_safe(e =>
+			e.UpdateLiberatedStatus(book)
+		);
+
+		private static void performSearchEngineAction_safe(Action<SearchEngine> action)
+		{
+			var engine = new SearchEngine();
+			try
+			{
+				action(engine);
+			}
+			catch (FileNotFoundException)
+			{
+				FullReIndex(engine);
+				action(engine);
+			}
+		}
+
+		private static T performSearchEngineFunc_safe<T>(Func<SearchEngine, T> action)
+		{
+			var engine = new SearchEngine();
+			try
+			{
+				return action(engine);
+			}
+			catch (FileNotFoundException)
+			{
+				FullReIndex(engine);
+				return action(engine);
+			}
+		}
+	}
+}

ApplicationServices/TransitionalFileLocator.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using DataLayer;
+using FileManager;
+
+namespace ApplicationServices
+{
+	public static class TransitionalFileLocator
+	{
+		public static string Audio_GetPath(Book book)
+		{
+			var loc = book?.UserDefinedItem?.BookLocation ?? "";
+			if (File.Exists(loc))
+				return loc;
+
+			return AudibleFileStorage.Audio.GetPath(book.AudibleProductId);
+		}
+
+		public static bool PDF_Exists(Book book)
+		{
+			var status = book?.UserDefinedItem?.PdfStatus;
+			if (status.HasValue && status.Value == LiberatedStatus.Liberated)
+				return true;
+
+			return AudibleFileStorage.PDF.Exists(book.AudibleProductId);
+		}
+
+		public static bool Audio_Exists(Book book)
+		{
+			var status = book?.UserDefinedItem?.BookStatus;
+			// true since Error == libhack
+			if (status.HasValue && status.Value != LiberatedStatus.NotLiberated)
+				return true;
+
+			return AudibleFileStorage.Audio.Exists(book.AudibleProductId);
+		}
+
+		public static bool AAXC_Exists(Book book)
+		{
+			// this one will actually stay the same. centralizing helps with organization in the interim though
+			return AudibleFileStorage.AAXC.Exists(book.AudibleProductId);
+		}
+	}
+}

ApplicationServices/UNTESTED/LibraryCommands.cs

@@ -1,108 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using AudibleApi;
-using DataLayer;
-using DtoImporterService;
-using InternalUtilities;
-using Serilog;
-
-namespace ApplicationServices
-{
-	public static class LibraryCommands
-	{
-		public static async Task<(int totalCount, int newCount)> ImportAccountAsync(Func<Account, ILoginCallback> loginCallbackFactoryFunc, params Account[] accounts)
-		{
-			if (accounts is null || accounts.Length == 0)
-				return (0, 0);
-
-			try
-			{
-				var importItems = await scanAccountsAsync(loginCallbackFactoryFunc, accounts);
-
-				var totalCount = importItems.Count;
-				Log.Logger.Information($"GetAllLibraryItems: Total count {totalCount}");
-
-				var newCount = await getNewCountAsync(importItems);
-				Log.Logger.Information($"Import: New count {newCount}");
-
-				await Task.Run(() => SearchEngineCommands.FullReIndex());
-				Log.Logger.Information("FullReIndex: success");
-
-				return (totalCount, newCount);
-			}
-			catch (Exception ex)
-			{
-				Log.Logger.Error(ex, "Error importing library");
-				throw;
-			}
-		}
-
-		private static async Task<List<ImportItem>> scanAccountsAsync(Func<Account, ILoginCallback> loginCallbackFactoryFunc, Account[] accounts)
-		{
-			var tasks = new List<Task<List<ImportItem>>>();
-			foreach (var account in accounts)
-			{
-				var callback = loginCallbackFactoryFunc(account);
-
-				// get APIs in serial, esp b/c of logins
-				var api = await AudibleApiActions.GetApiAsync(callback, account);
-
-				// add scanAccountAsync as a TASK: do not await
-				tasks.Add(scanAccountAsync(api, account));
-			}
-
-			// import library in parallel
-			var arrayOfLists = await Task.WhenAll(tasks);
-			var importItems = arrayOfLists.SelectMany(a => a).ToList();
-			return importItems;
-		}
-
-		private static async Task<List<ImportItem>> scanAccountAsync(Api api, Account account)
-		{
-			Dinah.Core.ArgumentValidator.EnsureNotNull(account, nameof(account));
-
-			var localeName = account.Locale?.Name;
-			Log.Logger.Information("ImportLibraryAsync. {@DebugInfo}", new
-			{
-				account.AccountName,
-				account.AccountId,
-				LocaleName = localeName,
-			});
-
-			var dtoItems = await AudibleApiActions.GetLibraryValidatedAsync(api);
-			return dtoItems.Select(d => new ImportItem { DtoItem = d, AccountId = account.AccountId, LocaleName = localeName }).ToList();
-		}
-
-		private static async Task<int> getNewCountAsync(List<ImportItem> importItems)
-		{
-			using var context = DbContexts.GetContext();
-			var libraryImporter = new LibraryImporter(context);
-			var newCount = await Task.Run(() => libraryImporter.Import(importItems));
-			context.SaveChanges();
-
-			return newCount;
-		}
-
-		public static int UpdateTags(this LibationContext context, Book book, string newTags)
-		{
-			try
-			{
-				book.UserDefinedItem.Tags = newTags;
-
-				var qtyChanges = context.SaveChanges();
-
-				if (qtyChanges > 0)
-					SearchEngineCommands.UpdateBookTags(book);
-
-				return qtyChanges;
-			}
-			catch (Exception ex)
-			{
-				Log.Logger.Error(ex, "Error updating tags");
-				throw;
-			}
-		}
-	}
-}

ApplicationServices/UNTESTED/SearchEngineCommands.cs

@@ -1,43 +0,0 @@
-using System.IO;
-using DataLayer;
-using LibationSearchEngine;
-
-namespace ApplicationServices
-{
-	public static class SearchEngineCommands
-	{
-		public static void FullReIndex()
-		{
-			var engine = new SearchEngine(DbContexts.GetContext());
-			engine.CreateNewIndex();
-		}
-
-		public static SearchResultSet Search(string searchString)
-		{
-			var engine = new SearchEngine(DbContexts.GetContext());
-			try
-			{
-				return engine.Search(searchString);
-			}
-			catch (FileNotFoundException)
-			{
-				FullReIndex();
-				return engine.Search(searchString);
-			}
-		}
-
-		public static void UpdateBookTags(Book book)
-		{
-			var engine = new SearchEngine(DbContexts.GetContext());
-			try
-			{
-				engine.UpdateTags(book.AudibleProductId, book.UserDefinedItem.Tags);
-			}
-			catch (FileNotFoundException)
-			{
-				FullReIndex();
-				engine.UpdateTags(book.AudibleProductId, book.UserDefinedItem.Tags);
-			}
-		}
-	}
-}

DataLayer/DataLayer.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netcoreapp3.1;netstandard2.1</TargetFrameworks>
+    <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
 
   <PropertyGroup>
@@ -12,13 +12,12 @@
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="3.1.7">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="5.0.5">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="3.1.7" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="3.1.7" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="3.1.7">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="5.0.5" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="5.0.5">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>

DataLayer/EfClasses/Book.cs

@@ -88,8 +88,8 @@ namespace DataLayer
 			Category = category;
 
             // simple assigns
-            Title = title;
-            Description = description;
+            Title = title.Trim();
+            Description = description.Trim();
             LengthInMinutes = lengthInMinutes;
 
             // assigns with biz logic
@@ -220,8 +220,11 @@ namespace DataLayer
 
             ArgumentValidator.EnsureNotNullOrWhiteSpace(url, nameof(url));
 
-            if (!_supplements.Any(s => url.EqualsInsensitive(url)))
-                _supplements.Add(new Supplement(this, url));
+            if (_supplements.Any(s => url.EqualsInsensitive(url)))
+                return;
+
+            _supplements.Add(new Supplement(this, url));
+            UserDefinedItem.PdfStatus ??= LiberatedStatus.NotLiberated;
         }
         #endregion
 

DataLayer/EfClasses/BookContributor.cs

@@ -2,6 +2,8 @@
 
 namespace DataLayer
 {
+    public enum Role { Author = 1, Narrator = 2, Publisher = 3 }
+
     public class BookContributor
     {
         internal int BookId { get; private set; }

DataLayer/EfClasses/UserDefinedItem.cs

@@ -6,6 +6,17 @@ using Dinah.Core;
 
 namespace DataLayer
 {
+    /// <summary>
+    /// Do not track in-process state. In-process state is determined by the presence of temp file.
+    /// </summary>
+    public enum LiberatedStatus
+    {
+        NotLiberated = 0,
+        Liberated = 1,
+        /// <summary>Error occurred during liberation. Don't retry</summary>
+        Error = 2
+    }
+
     public class UserDefinedItem
     {
         internal int BookId { get; private set; }
@@ -22,6 +33,7 @@ namespace DataLayer
 			Tags = FileManager.TagsPersistence.GetTags(book.AudibleProductId);
 		}
 
+        #region Tags
         private string _tags = "";
         public string Tags
         {
@@ -71,14 +83,23 @@ namespace DataLayer
             return string.Join(" ", unique);
         }
         #endregion
+        #endregion
 
+        #region Rating
         // owned: not an optional one-to-one
         /// <summary>The user's individual book rating</summary>
         public Rating Rating { get; private set; } = new Rating(0, 0, 0);
 
         public void UpdateRating(float overallRating, float performanceRating, float storyRating)
             => Rating.Update(overallRating, performanceRating, storyRating);
+        #endregion
 
-		public override string ToString() => $"{Book} {Rating} {Tags}";
+        #region LiberatedStatuses and book file location
+        public LiberatedStatus BookStatus { get; set; }
+        public string BookLocation { get; set; }
+        public LiberatedStatus? PdfStatus { get; set; }
+        #endregion
+
+        public override string ToString() => $"{Book} {Rating} {Tags}";
 	}
 }

DataLayer/LibationContext.cs

@@ -56,9 +56,10 @@ namespace DataLayer
             modelBuilder.ApplyConfiguration(new SeriesBookConfig());
             modelBuilder.ApplyConfiguration(new CategoryConfig());
 
-			// seeds go here. examples in scratch pad
-			modelBuilder
-				.Entity<Category>()
+            // seeds go here. examples in Dinah.EntityFrameworkCore.Tests\DbContextFactoryExample.cs
+
+            modelBuilder
+                .Entity<Category>()
 				.HasData(Category.GetEmpty());
 			modelBuilder
 				.Entity<Contributor>()

DataLayer/LibationContextFactory.cs

@@ -6,9 +6,6 @@ namespace DataLayer
     public class LibationContextFactory : DesignTimeDbContextFactoryBase<LibationContext>
     {
         protected override LibationContext CreateNewInstance(DbContextOptions<LibationContext> options) => new LibationContext(options);
-        protected override void UseDatabaseEngine(DbContextOptionsBuilder optionsBuilder, string connectionString) => optionsBuilder
-			//.UseSqlServer
-			.UseSqlite
-			(connectionString);
+        protected override void UseDatabaseEngine(DbContextOptionsBuilder optionsBuilder, string connectionString) => optionsBuilder.UseSqlite(connectionString);
     }
 }

DataLayer/Migrations/20210619030017_AddAaxcDecryptionKeys.Designer.cs

@@ -0,0 +1,387 @@
+// <auto-generated />
+using System;
+using DataLayer;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace DataLayer.Migrations
+{
+    [DbContext(typeof(LibationContext))]
+    [Migration("20210619030017_AddAaxcDecryptionKeys")]
+    partial class AddAaxcDecryptionKeys
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "5.0.5");
+
+            modelBuilder.Entity("DataLayer.Book", b =>
+                {
+                    b.Property<int>("BookId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AudibleIV")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AudibleKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AudibleProductId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("DatePublished")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsAbridged")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LengthInMinutes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Locale")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PictureId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("BookId");
+
+                    b.HasIndex("AudibleProductId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.ToTable("Books");
+                });
+
+            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("INTEGER");
+
+                    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");
+
+                    b.Property<string>("AudibleCategoryId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ParentCategoryCategoryId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("CategoryId");
+
+                    b.HasIndex("AudibleCategoryId");
+
+                    b.HasIndex("ParentCategoryCategoryId");
+
+                    b.ToTable("Categories");
+
+                    b.HasData(
+                        new
+                        {
+                            CategoryId = -1,
+                            AudibleCategoryId = "",
+                            Name = ""
+                        });
+                });
+
+            modelBuilder.Entity("DataLayer.Contributor", b =>
+                {
+                    b.Property<int>("ContributorId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    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<string>("Account")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("BookId");
+
+                    b.ToTable("Library");
+                });
+
+            modelBuilder.Entity("DataLayer.Series", b =>
+                {
+                    b.Property<int>("SeriesId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    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<float?>("Index")
+                        .HasColumnType("REAL");
+
+                    b.HasKey("SeriesId", "BookId");
+
+                    b.HasIndex("BookId");
+
+                    b.HasIndex("SeriesId");
+
+                    b.ToTable("SeriesBook");
+                });
+
+            modelBuilder.Entity("DataLayer.Book", b =>
+                {
+                    b.HasOne("DataLayer.Category", "Category")
+                        .WithMany()
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    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");
+
+                            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<string>("Tags")
+                                .HasColumnType("TEXT");
+
+                            b1.HasKey("BookId");
+
+                            b1.ToTable("UserDefinedItem");
+
+                            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("Category");
+
+                    b.Navigation("Rating");
+
+                    b.Navigation("Supplements");
+
+                    b.Navigation("UserDefinedItem");
+                });
+
+            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.Category", b =>
+                {
+                    b.HasOne("DataLayer.Category", "ParentCategory")
+                        .WithMany()
+                        .HasForeignKey("ParentCategoryCategoryId");
+
+                    b.Navigation("ParentCategory");
+                });
+
+            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("ContributorsLink");
+
+                    b.Navigation("SeriesLink");
+                });
+
+            modelBuilder.Entity("DataLayer.Contributor", b =>
+                {
+                    b.Navigation("BooksLink");
+                });
+
+            modelBuilder.Entity("DataLayer.Series", b =>
+                {
+                    b.Navigation("BooksLink");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

DataLayer/Migrations/20210619030017_AddAaxcDecryptionKeys.cs

@@ -0,0 +1,33 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace DataLayer.Migrations
+{
+    public partial class AddAaxcDecryptionKeys : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "AudibleIV",
+                table: "Books",
+                type: "TEXT",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "AudibleKey",
+                table: "Books",
+                type: "TEXT",
+                nullable: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "AudibleIV",
+                table: "Books");
+
+            migrationBuilder.DropColumn(
+                name: "AudibleKey",
+                table: "Books");
+        }
+    }
+}

DataLayer/Migrations/20210622205558_RemoveAaxcDecryptionKeys.Designer.cs

@@ -0,0 +1,381 @@
+// <auto-generated />
+using System;
+using DataLayer;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace DataLayer.Migrations
+{
+    [DbContext(typeof(LibationContext))]
+    [Migration("20210622205558_RemoveAaxcDecryptionKeys")]
+    partial class RemoveAaxcDecryptionKeys
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "5.0.5");
+
+            modelBuilder.Entity("DataLayer.Book", b =>
+                {
+                    b.Property<int>("BookId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AudibleProductId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("DatePublished")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsAbridged")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LengthInMinutes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Locale")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PictureId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("BookId");
+
+                    b.HasIndex("AudibleProductId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.ToTable("Books");
+                });
+
+            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("INTEGER");
+
+                    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");
+
+                    b.Property<string>("AudibleCategoryId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ParentCategoryCategoryId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("CategoryId");
+
+                    b.HasIndex("AudibleCategoryId");
+
+                    b.HasIndex("ParentCategoryCategoryId");
+
+                    b.ToTable("Categories");
+
+                    b.HasData(
+                        new
+                        {
+                            CategoryId = -1,
+                            AudibleCategoryId = "",
+                            Name = ""
+                        });
+                });
+
+            modelBuilder.Entity("DataLayer.Contributor", b =>
+                {
+                    b.Property<int>("ContributorId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    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<string>("Account")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("BookId");
+
+                    b.ToTable("Library");
+                });
+
+            modelBuilder.Entity("DataLayer.Series", b =>
+                {
+                    b.Property<int>("SeriesId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    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<float?>("Index")
+                        .HasColumnType("REAL");
+
+                    b.HasKey("SeriesId", "BookId");
+
+                    b.HasIndex("BookId");
+
+                    b.HasIndex("SeriesId");
+
+                    b.ToTable("SeriesBook");
+                });
+
+            modelBuilder.Entity("DataLayer.Book", b =>
+                {
+                    b.HasOne("DataLayer.Category", "Category")
+                        .WithMany()
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    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");
+
+                            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<string>("Tags")
+                                .HasColumnType("TEXT");
+
+                            b1.HasKey("BookId");
+
+                            b1.ToTable("UserDefinedItem");
+
+                            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("Category");
+
+                    b.Navigation("Rating");
+
+                    b.Navigation("Supplements");
+
+                    b.Navigation("UserDefinedItem");
+                });
+
+            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.Category", b =>
+                {
+                    b.HasOne("DataLayer.Category", "ParentCategory")
+                        .WithMany()
+                        .HasForeignKey("ParentCategoryCategoryId");
+
+                    b.Navigation("ParentCategory");
+                });
+
+            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("ContributorsLink");
+
+                    b.Navigation("SeriesLink");
+                });
+
+            modelBuilder.Entity("DataLayer.Contributor", b =>
+                {
+                    b.Navigation("BooksLink");
+                });
+
+            modelBuilder.Entity("DataLayer.Series", b =>
+                {
+                    b.Navigation("BooksLink");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

DataLayer/Migrations/20210622205558_RemoveAaxcDecryptionKeys.cs

@@ -0,0 +1,33 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace DataLayer.Migrations
+{
+    public partial class RemoveAaxcDecryptionKeys : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "AudibleIV",
+                table: "Books");
+
+            migrationBuilder.DropColumn(
+                name: "AudibleKey",
+                table: "Books");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "AudibleIV",
+                table: "Books",
+                type: "TEXT",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "AudibleKey",
+                table: "Books",
+                type: "TEXT",
+                nullable: true);
+        }
+    }
+}

DataLayer/Migrations/20210727180408_AddLiberatedStatus.Designer.cs

@@ -0,0 +1,390 @@
+// <auto-generated />
+using System;
+using DataLayer;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace DataLayer.Migrations
+{
+    [DbContext(typeof(LibationContext))]
+    [Migration("20210727180408_AddLiberatedStatus")]
+    partial class AddLiberatedStatus
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "5.0.5");
+
+            modelBuilder.Entity("DataLayer.Book", b =>
+                {
+                    b.Property<int>("BookId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AudibleProductId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("DatePublished")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsAbridged")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LengthInMinutes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Locale")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PictureId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("BookId");
+
+                    b.HasIndex("AudibleProductId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.ToTable("Books");
+                });
+
+            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("INTEGER");
+
+                    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");
+
+                    b.Property<string>("AudibleCategoryId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ParentCategoryCategoryId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("CategoryId");
+
+                    b.HasIndex("AudibleCategoryId");
+
+                    b.HasIndex("ParentCategoryCategoryId");
+
+                    b.ToTable("Categories");
+
+                    b.HasData(
+                        new
+                        {
+                            CategoryId = -1,
+                            AudibleCategoryId = "",
+                            Name = ""
+                        });
+                });
+
+            modelBuilder.Entity("DataLayer.Contributor", b =>
+                {
+                    b.Property<int>("ContributorId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    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<string>("Account")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("BookId");
+
+                    b.ToTable("Library");
+                });
+
+            modelBuilder.Entity("DataLayer.Series", b =>
+                {
+                    b.Property<int>("SeriesId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    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<float?>("Index")
+                        .HasColumnType("REAL");
+
+                    b.HasKey("SeriesId", "BookId");
+
+                    b.HasIndex("BookId");
+
+                    b.HasIndex("SeriesId");
+
+                    b.ToTable("SeriesBook");
+                });
+
+            modelBuilder.Entity("DataLayer.Book", b =>
+                {
+                    b.HasOne("DataLayer.Category", "Category")
+                        .WithMany()
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    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");
+
+                            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<string>("BookLocation")
+                                .HasColumnType("TEXT");
+
+                            b1.Property<int>("BookStatus")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int?>("PdfStatus")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<string>("Tags")
+                                .HasColumnType("TEXT");
+
+                            b1.HasKey("BookId");
+
+                            b1.ToTable("UserDefinedItem");
+
+                            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("Category");
+
+                    b.Navigation("Rating");
+
+                    b.Navigation("Supplements");
+
+                    b.Navigation("UserDefinedItem");
+                });
+
+            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.Category", b =>
+                {
+                    b.HasOne("DataLayer.Category", "ParentCategory")
+                        .WithMany()
+                        .HasForeignKey("ParentCategoryCategoryId");
+
+                    b.Navigation("ParentCategory");
+                });
+
+            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("ContributorsLink");
+
+                    b.Navigation("SeriesLink");
+                });
+
+            modelBuilder.Entity("DataLayer.Contributor", b =>
+                {
+                    b.Navigation("BooksLink");
+                });
+
+            modelBuilder.Entity("DataLayer.Series", b =>
+                {
+                    b.Navigation("BooksLink");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

DataLayer/Migrations/20210727180408_AddLiberatedStatus.cs

@@ -0,0 +1,44 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace DataLayer.Migrations
+{
+    public partial class AddLiberatedStatus : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "BookLocation",
+                table: "UserDefinedItem",
+                type: "TEXT",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "BookStatus",
+                table: "UserDefinedItem",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<int>(
+                name: "PdfStatus",
+                table: "UserDefinedItem",
+                type: "INTEGER",
+                nullable: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "BookLocation",
+                table: "UserDefinedItem");
+
+            migrationBuilder.DropColumn(
+                name: "BookStatus",
+                table: "UserDefinedItem");
+
+            migrationBuilder.DropColumn(
+                name: "PdfStatus",
+                table: "UserDefinedItem");
+        }
+    }
+}

DataLayer/Migrations/LibationContextModelSnapshot.cs

@@ -14,7 +14,7 @@ namespace DataLayer.Migrations
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "3.1.7");
+                .HasAnnotation("ProductVersion", "5.0.5");
 
             modelBuilder.Entity("DataLayer.Book", b =>
                 {
@@ -244,6 +244,8 @@ namespace DataLayer.Migrations
 
                             b1.WithOwner("Book")
                                 .HasForeignKey("BookId");
+
+                            b1.Navigation("Book");
                         });
 
                     b.OwnsOne("DataLayer.UserDefinedItem", "UserDefinedItem", b1 =>
@@ -251,6 +253,15 @@ namespace DataLayer.Migrations
                             b1.Property<int>("BookId")
                                 .HasColumnType("INTEGER");
 
+                            b1.Property<string>("BookLocation")
+                                .HasColumnType("TEXT");
+
+                            b1.Property<int>("BookStatus")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int?>("PdfStatus")
+                                .HasColumnType("INTEGER");
+
                             b1.Property<string>("Tags")
                                 .HasColumnType("TEXT");
 
@@ -282,7 +293,19 @@ namespace DataLayer.Migrations
                                     b2.WithOwner()
                                         .HasForeignKey("UserDefinedItemBookId");
                                 });
+
+                            b1.Navigation("Book");
+
+                            b1.Navigation("Rating");
                         });
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Rating");
+
+                    b.Navigation("Supplements");
+
+                    b.Navigation("UserDefinedItem");
                 });
 
             modelBuilder.Entity("DataLayer.BookContributor", b =>
@@ -298,6 +321,10 @@ namespace DataLayer.Migrations
                         .HasForeignKey("ContributorId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
+
+                    b.Navigation("Book");
+
+                    b.Navigation("Contributor");
                 });
 
             modelBuilder.Entity("DataLayer.Category", b =>
@@ -305,6 +332,8 @@ namespace DataLayer.Migrations
                     b.HasOne("DataLayer.Category", "ParentCategory")
                         .WithMany()
                         .HasForeignKey("ParentCategoryCategoryId");
+
+                    b.Navigation("ParentCategory");
                 });
 
             modelBuilder.Entity("DataLayer.LibraryBook", b =>
@@ -314,6 +343,8 @@ namespace DataLayer.Migrations
                         .HasForeignKey("DataLayer.LibraryBook", "BookId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
+
+                    b.Navigation("Book");
                 });
 
             modelBuilder.Entity("DataLayer.SeriesBook", b =>
@@ -329,6 +360,27 @@ namespace DataLayer.Migrations
                         .HasForeignKey("SeriesId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
+
+                    b.Navigation("Book");
+
+                    b.Navigation("Series");
+                });
+
+            modelBuilder.Entity("DataLayer.Book", b =>
+                {
+                    b.Navigation("ContributorsLink");
+
+                    b.Navigation("SeriesLink");
+                });
+
+            modelBuilder.Entity("DataLayer.Contributor", b =>
+                {
+                    b.Navigation("BooksLink");
+                });
+
+            modelBuilder.Entity("DataLayer.Series", b =>
+                {
+                    b.Navigation("BooksLink");
                 });
 #pragma warning restore 612, 618
         }

DataLayer/QueryObjects/BookQueries.cs

@@ -6,12 +6,14 @@ using Microsoft.EntityFrameworkCore;
 
 namespace DataLayer
 {
+    // only library importing should use tracking. All else should be NoTracking.
+    // only library importing should directly query Book. All else should use LibraryBook
     public static class BookQueries
     {
         public static Book GetBook_Flat_NoTracking(this LibationContext context, string productId)
             => context
                 .Books
-                .AsNoTracking()
+                .AsNoTrackingWithIdentityResolution()
                 .GetBook(productId);
 
         public static Book GetBook(this IQueryable<Book> books, string productId)
@@ -25,6 +27,7 @@ namespace DataLayer
                 .GetBooks()
                 .Where(predicate);
 
+        /// <summary>This is still IQueryable. YOU MUST CALL ToList() YOURSELF</summary>
         public static IQueryable<Book> GetBooks(this IQueryable<Book> books)
             => books
                 // owned items are always loaded. eg: book.UserDefinedItem, book.Supplements

DataLayer/QueryObjects/LibraryQueries.cs

@@ -4,27 +4,35 @@ using Microsoft.EntityFrameworkCore;
 
 namespace DataLayer
 {
+    // only library importing should use tracking. All else should be NoTracking.
+    // only library importing should directly query Book. All else should use LibraryBook
     public static class LibraryQueries
 	{
-		public static List<LibraryBook> GetLibrary_Flat_WithTracking(this LibationContext context)
-			=> context
-				.Library
-				.GetLibrary()
-				.ToList();
+        //// tracking is a bad idea for main grid. it prevents anything else from updating entities unless getting them from the grid
+		//public static List<LibraryBook> GetLibrary_Flat_WithTracking(this LibationContext context)
+		//	=> context
+		//		.Library
+		//		.GetLibrary()
+		//		.ToList();
 
 		public static List<LibraryBook> GetLibrary_Flat_NoTracking(this LibationContext context)
             => context
                 .Library
-                .AsNoTracking()
+                .AsNoTrackingWithIdentityResolution()
                 .GetLibrary()
                 .ToList();
 
         public static LibraryBook GetLibraryBook_Flat_NoTracking(this LibationContext context, string productId)
             => context
                 .Library
-                .AsNoTracking()
+                .AsNoTrackingWithIdentityResolution()
                 .GetLibraryBook(productId);
 
+        public static LibraryBook GetLibraryBook(this IQueryable<LibraryBook> library, string productId)
+            => library
+                .GetLibrary()
+                .SingleOrDefault(lb => lb.Book.AudibleProductId == productId);
+
         /// <summary>This is still IQueryable. YOU MUST CALL ToList() YOURSELF</summary>
         public static IQueryable<LibraryBook> GetLibrary(this IQueryable<LibraryBook> library)
             => library
@@ -32,10 +40,5 @@ namespace DataLayer
                 .Include(le => le.Book).ThenInclude(b => b.SeriesLink).ThenInclude(sb => sb.Series)
                 .Include(le => le.Book).ThenInclude(b => b.ContributorsLink).ThenInclude(c => c.Contributor)
                 .Include(le => le.Book).ThenInclude(b => b.Category).ThenInclude(c => c.ParentCategory);
-
-        public static LibraryBook GetLibraryBook(this IQueryable<LibraryBook> library, string productId)
-            => library
-                .GetLibrary()
-                .SingleOrDefault(le => le.Book.AudibleProductId == productId);
     }
 }

DataLayer/UNTESTED/EfClasses/Role.cs

@@ -1,4 +0,0 @@
-namespace DataLayer
-{
-    public enum Role { Author = 1, Narrator = 2, Publisher = 3 }
-}

DataLayer/UNTESTED/_scratch pad/ScratchPad.cs

@@ -1,122 +0,0 @@
-using System;
-using Dinah.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore;
-
-namespace _scratch_pad
-{
-    ////// to use this as a console, open properties and change from class library => console
-    //// DON'T FORGET TO REVERT IT
-    //public class Program
-    //{
-    //    public static void Main(string[] args)
-    //    {
-    //        var user = new Student() { Name = "Dinah Cheshire" };
-    //        var udi = new UserDef { UserDefId = 1, TagsRaw = "my,tags" };
-
-    //        using var context = new MyTestContextDesignTimeDbContextFactory().Create();
-    //        context.Add(user);
-    //        //context.Add(udi);
-    //        context.Update(udi);
-    //        context.SaveChanges();
-
-    //        Console.WriteLine($"Student was saved in the database with id: {user.Id}");
-    //    }
-    //}
-
-    public class MyTestContextDesignTimeDbContextFactory : DesignTimeDbContextFactoryBase<MyTestContext>
-    {
-        protected override MyTestContext CreateNewInstance(DbContextOptions<MyTestContext> options) => new MyTestContext(options);
-        protected override void UseDatabaseEngine(DbContextOptionsBuilder optionsBuilder, string connectionString) => optionsBuilder.UseSqlite(connectionString);
-    }
-
-    public class MyTestContext : DbContext
-    {
-        // see DesignTimeDbContextFactoryBase for info about ctors and connection strings/OnConfiguring()
-        public MyTestContext(DbContextOptions<MyTestContext> options) : base(options) { }
-
-        #region classes for OnModelCreating() seed example
-        class Blog
-        {
-            public int BlogId { get; set; }
-            public string Url { get; set; }
-            public System.Collections.Generic.ICollection<Post> Posts { get; set; }
-        }
-        class Post
-        {
-            public int PostId { get; set; }
-            public string Content { get; set; }
-            public string Title { get; set; }
-            public int BlogId { get; set; }
-            public Blog Blog { get; set; }
-            public Name AuthorName { get; set; }
-        }
-        class Name
-        {
-            public string First { get; set; }
-            public string Last { get; set; }
-        }
-        #endregion
-        protected override void OnModelCreating(ModelBuilder modelBuilder)
-        {
-            base.OnModelCreating(modelBuilder);
-
-            // config
-            modelBuilder.Entity<Blog>(entity => entity.Property(e => e.Url).IsRequired());
-            modelBuilder.Entity<Order>().OwnsOne(p => p.OrderDetails, cb =>
-            {
-                cb.OwnsOne(c => c.BillingAddress);
-                cb.OwnsOne(c => c.ShippingAddress);
-            });
-            modelBuilder.Entity<Post>(entity =>
-                entity
-                    .HasOne(d => d.Blog)
-                    .WithMany(p => p.Posts)
-                    .HasForeignKey("BlogId"));
-
-            // BlogSeed
-            modelBuilder.Entity<Blog>().HasData(new Blog { BlogId = 1, Url = "http://sample.com" });
-
-            // PostSeed
-            modelBuilder.Entity<Post>().HasData(new Post() { BlogId = 1, PostId = 1, Title = "First post", Content = "Test 1" });
-
-            // AnonymousPostSeed
-            modelBuilder.Entity<Post>().HasData(new { BlogId = 1, PostId = 2, Title = "Second post", Content = "Test 2" });
-
-            // OwnedTypeSeed
-            modelBuilder.Entity<Post>().OwnsOne(p => p.AuthorName).HasData(
-                new { PostId = 1, First = "Andriy", Last = "Svyryd" },
-                new { PostId = 2, First = "Diego", Last = "Vega" });
-        }
-
-        public DbSet<Student> Students { get; set; }
-        public DbSet<UserDef> UserDefs { get; set; }
-        public DbSet<Order> Orders { get; set; }
-    }
-
-    public class Student
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-    }
-    public class UserDef
-    {
-        public int UserDefId { get; set; }
-        public string TagsRaw { get; set; }
-    }
-
-    public class Order
-    {
-        public int Id { get; set; }
-        public OrderDetails OrderDetails { get; set; }
-    }
-    public class OrderDetails
-    {
-        public StreetAddress BillingAddress { get; set; }
-        public StreetAddress ShippingAddress { get; set; }
-    }
-    public class StreetAddress
-    {
-        public string Street { get; set; }
-        public string City { get; set; }
-    }
-}

DataLayer/appsettings.json

@@ -1,14 +1,6 @@
 {
   "ConnectionStrings": {
-    "LibationContext_sqlserver": "Server=(LocalDb)\\MSSQLLocalDB;Database=DataLayer.LibationContext;Integrated Security=true;",
-
     "// this connection string is ONLY used for DataLayer's Migrations. this appsettings.json file is NOT used at all by application; it is overwritten":  "",
-    "LibationContext": "Data Source=LibationContext.db;Foreign Keys=False;",
-
-    "// sqlite notes": "",
-    "// absolute path example": "Data Source=C:/foo/bar/sample.db",
-    "// relative path example": "Data Source=sample.db",
-    "// on windows: sqlite paths accept windows and/or unix slashes": "",
-    "MyTestContext": "Data Source=%DESKTOP%/sample.db"
+    "LibationContext": "Data Source=LibationContext.db;Foreign Keys=False;"
   }
 }

DtoImporterService/BookImporter.cs

@@ -102,7 +102,7 @@ namespace DtoImporterService
 
 			var book = DbContext.Books.Add(new Book(
 				new AudibleProductId(item.ProductId),
-				item.Title,
+				item.TitleWithSubtitle,
 				item.Description,
 				item.LengthInMinutes,
 				authors,

DtoImporterService/ContributorImporter.cs

@@ -71,7 +71,8 @@ namespace DtoImporterService
 
 			foreach (var p in people)
 			{
-				var person = DbContext.Contributors.Local.SingleOrDefault(c => c.Name == p.Name);
+				// Should be 'Single' not 'First'. A user had a duplicate get in somehow though so I'm now using 'First' defensively
+				var person = DbContext.Contributors.Local.FirstOrDefault(c => c.Name == p.Name);
 				if (person == null)
 				{
 					person = DbContext.Contributors.Add(new Contributor(p.Name, p.Asin)).Entity;

DtoImporterService/DtoImporterService.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

FileLiberator/ConvertToMp3.cs

@@ -0,0 +1,107 @@
+using AAXClean;
+using DataLayer;
+using Dinah.Core;
+using Dinah.Core.ErrorHandling;
+using Dinah.Core.IO;
+using Dinah.Core.Net.Http;
+using FileManager;
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace FileLiberator
+{
+    public class ConvertToMp3 : IAudioDecodable
+    {
+
+        private Mp4File m4bBook;
+
+		public event EventHandler<TimeSpan> StreamingTimeRemaining;
+		public event EventHandler<Action<byte[]>> RequestCoverArt;
+		public event EventHandler<string> TitleDiscovered;
+		public event EventHandler<string> AuthorsDiscovered;
+		public event EventHandler<string> NarratorsDiscovered;
+		public event EventHandler<byte[]> CoverImageDiscovered;
+		public event EventHandler<string> StreamingBegin;
+		public event EventHandler<DownloadProgress> StreamingProgressChanged;
+		public event EventHandler<string> StreamingCompleted;
+		public event EventHandler<LibraryBook> Begin;
+		public event EventHandler<string> StatusUpdate;
+		public event EventHandler<LibraryBook> Completed;
+
+        private long fileSize;
+		private string Mp3FileName(string m4bPath) => m4bPath is null ? string.Empty : PathLib.ReplaceExtension(m4bPath, ".mp3");
+
+        public void Cancel() => m4bBook?.Cancel();
+
+        public bool Validate(LibraryBook libraryBook)
+        {
+            var path = ApplicationServices.TransitionalFileLocator.Audio_GetPath(libraryBook.Book);
+            return path?.ToLower()?.EndsWith(".m4b") == true && !File.Exists(Mp3FileName(path));
+        }
+
+        public async Task<StatusHandler> ProcessAsync(LibraryBook libraryBook)
+        {
+            Begin?.Invoke(this, libraryBook);
+
+            StreamingBegin?.Invoke(this, $"Begin converting {libraryBook} to mp3");
+
+            try
+            {
+                var m4bPath = ApplicationServices.TransitionalFileLocator.Audio_GetPath(libraryBook.Book);
+                m4bBook = new Mp4File(m4bPath, FileAccess.Read);
+                m4bBook.ConversionProgressUpdate += M4bBook_ConversionProgressUpdate;
+
+                fileSize = m4bBook.InputStream.Length;
+
+                TitleDiscovered?.Invoke(this, m4bBook.AppleTags.Title);
+                AuthorsDiscovered?.Invoke(this, m4bBook.AppleTags.FirstAuthor);
+                NarratorsDiscovered?.Invoke(this, m4bBook.AppleTags.Narrator);
+                CoverImageDiscovered?.Invoke(this, m4bBook.AppleTags.Cover);
+
+                using var mp3File = File.OpenWrite(Path.GetTempFileName());
+
+                var result = await Task.Run(() => m4bBook.ConvertToMp3(mp3File));
+                m4bBook.InputStream.Close();
+                mp3File.Close();
+
+                var mp3Path = Mp3FileName(m4bPath);
+
+                FileExt.SafeMove(mp3File.Name, mp3Path);
+
+                var statusHandler = new StatusHandler();
+
+                if (result == ConversionResult.Failed)
+                    statusHandler.AddError("Conversion failed");
+
+                return statusHandler;
+            }
+            finally
+            {
+                StreamingCompleted?.Invoke(this, $"Completed converting to mp3: {libraryBook.Book.Title}");
+                Completed?.Invoke(this, libraryBook);
+            }
+        }
+
+        private void M4bBook_ConversionProgressUpdate(object sender, ConversionProgressEventArgs e)
+        {
+            var duration = m4bBook.Duration;
+            double remainingSecsToProcess = (duration - e.ProcessPosition).TotalSeconds;
+            double estTimeRemaining = remainingSecsToProcess / e.ProcessSpeed;
+
+            if (double.IsNormal(estTimeRemaining))
+                StreamingTimeRemaining?.Invoke(this, TimeSpan.FromSeconds(estTimeRemaining));
+
+            double progressPercent = 100 * e.ProcessPosition.TotalSeconds / duration.TotalSeconds;
+
+            StreamingProgressChanged?.Invoke(this,
+                new DownloadProgress
+                {
+                    ProgressPercentage = progressPercent,
+                    BytesReceived = (long)(fileSize * progressPercent),
+                    TotalBytesToReceive = fileSize
+                });
+        }
+    }
+}