Bug fix #225 : SaferEnumerateFiles will skip files with UnauthorizedAccessException

CLI manual change to settings file no longer needed

.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,5 +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
+
+/__TODO.txt
+/DataLayer/LibationContext.db

AaxDecrypter/AaxDecrypter.csproj

@@ -1,123 +1,15 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.1</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <Reference Include="taglib-sharp">
-      <HintPath>lib\taglib-sharp.dll</HintPath>
-    </Reference>
+    <PackageReference Include="AAXClean" Version="0.1.10" />
   </ItemGroup>
 
   <ItemGroup>
-    <Folder Include="..\..\..\..\..\..\Dinah%2527s folder\coding\_NET\Visual Studio 2019\Libation\AaxDecrypter\UNTESTED\BytesCrackerLib\" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <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>
+    <ProjectReference Include="..\FileManager\FileManager.csproj" />
   </ItemGroup>
 
 </Project>

AaxDecrypter/AaxcDownloadConvertBase.cs

@@ -0,0 +1,91 @@
+using System;
+using AAXClean;
+using Dinah.Core.Net.Http;
+
+namespace AaxDecrypter
+{
+	public abstract class AaxcDownloadConvertBase : AudiobookDownloadBase
+	{
+		protected OutputFormat OutputFormat { get; }
+
+		protected AaxFile AaxFile;
+
+		protected AaxcDownloadConvertBase(string outFileName, string cacheDirectory, DownloadLicense dlLic, OutputFormat outputFormat)
+			: base(outFileName, cacheDirectory, dlLic)
+		{
+			OutputFormat = outputFormat;
+		}
+
+		/// <summary>Setting cover art by this method will insert the art into the audiobook metadata</summary>
+		public override void SetCoverArt(byte[] coverArt)
+		{
+			base.SetCoverArt(coverArt);
+			if (coverArt is not null)
+				AaxFile?.AppleTags.SetCoverArt(coverArt);
+		}
+
+		protected bool Step_GetMetadata()
+		{
+			AaxFile = new AaxFile(InputFileStream);
+
+			OnRetrievedTitle(AaxFile.AppleTags.TitleSansUnabridged);
+			OnRetrievedAuthors(AaxFile.AppleTags.FirstAuthor ?? "[unknown]");
+			OnRetrievedNarrators(AaxFile.AppleTags.Narrator ?? "[unknown]");
+			OnRetrievedCoverArt(AaxFile.AppleTags.Cover);
+
+			return !IsCanceled;
+		}
+
+		protected DownloadProgress Step_DownloadAudiobook_Start()
+		{
+			var zeroProgress = new DownloadProgress
+			{
+				BytesReceived = 0,
+				ProgressPercentage = 0,
+				TotalBytesToReceive = InputFileStream.Length
+			};
+
+			OnDecryptProgressUpdate(zeroProgress);
+
+			AaxFile.SetDecryptionKey(DownloadLicense.AudibleKey, DownloadLicense.AudibleIV);
+			return zeroProgress;
+		}
+
+		protected void Step_DownloadAudiobook_End(DownloadProgress zeroProgress)
+		{
+			AaxFile.Close();
+
+			CloseInputFileStream();
+
+			OnDecryptProgressUpdate(zeroProgress);
+		}
+
+		protected void AaxFile_ConversionProgressUpdate(object sender, ConversionProgressEventArgs e)
+		{
+			var duration = AaxFile.Duration;
+			var remainingSecsToProcess = (duration - e.ProcessPosition).TotalSeconds;
+			var estTimeRemaining = remainingSecsToProcess / e.ProcessSpeed;
+
+			if (double.IsNormal(estTimeRemaining))
+				OnDecryptTimeRemaining(TimeSpan.FromSeconds(estTimeRemaining));
+
+			var progressPercent = e.ProcessPosition.TotalSeconds / duration.TotalSeconds;
+
+			OnDecryptProgressUpdate(
+				new DownloadProgress
+				{
+					ProgressPercentage = 100 * progressPercent,
+					BytesReceived = (long)(InputFileStream.Length * progressPercent),
+					TotalBytesToReceive = InputFileStream.Length
+				});
+		}
+
+		public override void Cancel()
+		{
+			IsCanceled = true;
+			AaxFile?.Cancel();
+			AaxFile?.Dispose();
+			CloseInputFileStream();
+		}
+	}
+}

AaxDecrypter/AaxcDownloadMultiConverter.cs

@@ -0,0 +1,142 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using AAXClean;
+using Dinah.Core.StepRunner;
+using FileManager;
+
+namespace AaxDecrypter
+{
+	public class AaxcDownloadMultiConverter : AaxcDownloadConvertBase
+	{
+		protected override StepSequence Steps { get; }
+
+        private Func<MultiConvertFileProperties, string> multipartFileNameCallback { get; }
+
+        private static TimeSpan minChapterLength { get; } = TimeSpan.FromSeconds(3);
+		private List<string> multiPartFilePaths { get; } = new List<string>();
+
+        public AaxcDownloadMultiConverter(string outFileName, string cacheDirectory, DownloadLicense dlLic, OutputFormat outputFormat,
+            Func<MultiConvertFileProperties, string> multipartFileNameCallback = null)
+			: base(outFileName, cacheDirectory, dlLic, outputFormat)
+        {
+            Steps = new StepSequence
+            {
+                Name = "Download and Convert Aaxc To " + OutputFormat,
+
+                ["Step 1: Get Aaxc Metadata"] = Step_GetMetadata,
+                ["Step 2: Download Decrypted Audiobook"] = Step_DownloadAudiobookAsMultipleFilesPerChapter,
+                ["Step 3: Cleanup"] = Step_Cleanup,
+            };
+            this.multipartFileNameCallback = multipartFileNameCallback ?? MultiConvertFileProperties.DefaultMultipartFilename;
+        }
+
+        /*
+https://github.com/rmcrackan/Libation/pull/127#issuecomment-939088489
+
+If the chapter truly is empty, that is, 0 audio frames in length, then yes it is ignored.
+If the chapter is shorter than 3 seconds long but still has some audio frames, those frames are combined with the following chapter and not split into a new file.
+
+I also implemented file naming by chapter title. When 2 or more consecutive chapters are combined, the first of the combined chapter's title is used in the file name. For example, given an audiobook with the following chapters:
+
+00:00:00 - 00:00:02 | Part 1
+00:00:02 - 00:35:00 | Chapter 1
+00:35:02 - 01:02:00 | Chapter 2
+01:02:00 - 01:02:02 | Part 2
+01:02:02 - 01:41:00 | Chapter 3
+01:41:00 - 02:05:00 | Chapter 4
+
+The book will be split into the following files:
+
+00:00:00 - 00:35:00 | Book - 01 - Part 1.m4b
+00:35:00 - 01:02:00 | Book - 02 - Chapter 2.m4b
+01:02:00 - 01:41:00 | Book - 03 - Part 2.m4b
+01:41:00 - 02:05:00 | Book - 04 - Chapter 4.m4b
+
+That naming may not be desirable for everyone, but it's an easy change to instead use the last of the combined chapter's title in the file name.
+         */
+        private bool Step_DownloadAudiobookAsMultipleFilesPerChapter()
+        {
+            var zeroProgress = Step_DownloadAudiobook_Start();
+
+            var chapters = DownloadLicense.ChapterInfo.Chapters.ToList();
+
+            // Ensure split files are at least minChapterLength in duration.
+            var splitChapters = new ChapterInfo();
+
+            var runningTotal = TimeSpan.Zero;
+            string title = "";
+
+            for (int i = 0; i < chapters.Count; i++)
+            {
+                if (runningTotal == TimeSpan.Zero)
+                    title = chapters[i].Title;
+
+                runningTotal += chapters[i].Duration;
+
+                if (runningTotal >= minChapterLength)
+                {
+                    splitChapters.AddChapter(title, runningTotal);
+                    runningTotal = TimeSpan.Zero;
+                }
+            }
+
+            // reset, just in case
+            multiPartFilePaths.Clear();
+
+            AaxFile.ConversionProgressUpdate += AaxFile_ConversionProgressUpdate;
+            if (OutputFormat == OutputFormat.M4b)
+                ConvertToMultiMp4a(splitChapters);
+            else
+                ConvertToMultiMp3(splitChapters);
+            AaxFile.ConversionProgressUpdate -= AaxFile_ConversionProgressUpdate;
+
+            Step_DownloadAudiobook_End(zeroProgress);
+
+            var success = !IsCanceled;
+
+            if (success)
+                foreach (var path in multiPartFilePaths)
+                    OnFileCreated(path);
+
+            return success;
+        }
+
+        private void ConvertToMultiMp4a(ChapterInfo splitChapters)
+        {
+            var chapterCount = 0;
+            AaxFile.ConvertToMultiMp4a(splitChapters, newSplitCallback =>
+                createOutputFileStream(++chapterCount, splitChapters, newSplitCallback)
+            );
+        }
+
+        private void ConvertToMultiMp3(ChapterInfo splitChapters)
+        {
+            var chapterCount = 0;
+            AaxFile.ConvertToMultiMp3(splitChapters, newSplitCallback =>
+            {
+                createOutputFileStream(++chapterCount, splitChapters, newSplitCallback);
+                newSplitCallback.LameConfig.ID3.Track = chapterCount.ToString();
+            });
+        }
+
+        private void createOutputFileStream(int currentChapter, ChapterInfo splitChapters, NewSplitCallback newSplitCallback)
+        {
+            var fileName = multipartFileNameCallback(new()
+            {
+                OutputFileName = OutputFileName,
+                PartsPosition = currentChapter,
+                PartsTotal = splitChapters.Count,
+                Title = newSplitCallback?.Chapter?.Title
+            });
+            fileName = FileUtility.GetValidFilename(fileName);
+
+            multiPartFilePaths.Add(fileName);
+
+            FileUtility.SaferDelete(fileName);
+
+            newSplitCallback.OutputFile = File.Open(fileName, FileMode.OpenOrCreate);
+        }
+    }
+}

AaxDecrypter/AaxcDownloadSingleConverter.cs

@@ -0,0 +1,53 @@
+using System;
+using System.IO;
+using AAXClean;
+using Dinah.Core.StepRunner;
+using FileManager;
+
+namespace AaxDecrypter
+{
+	public class AaxcDownloadSingleConverter : AaxcDownloadConvertBase
+	{
+		protected override StepSequence Steps { get; }
+
+        public AaxcDownloadSingleConverter(string outFileName, string cacheDirectory, DownloadLicense dlLic, OutputFormat outputFormat)
+			: base(outFileName, cacheDirectory, dlLic, outputFormat)
+        {
+            Steps = new StepSequence
+            {
+                Name = "Download and Convert Aaxc To " + OutputFormat,
+
+                ["Step 1: Get Aaxc Metadata"] = Step_GetMetadata,
+                ["Step 2: Download Decrypted Audiobook"] = Step_DownloadAudiobookAsSingleFile,
+                ["Step 3: Create Cue"] = Step_CreateCue,
+                ["Step 4: Cleanup"] = Step_Cleanup,
+            };
+        }
+
+        private bool Step_DownloadAudiobookAsSingleFile()
+        {
+            var zeroProgress = Step_DownloadAudiobook_Start();
+
+            FileUtility.SaferDelete(OutputFileName);
+
+            var outputFile = File.Open(OutputFileName, FileMode.OpenOrCreate, FileAccess.ReadWrite);
+
+            AaxFile.ConversionProgressUpdate += AaxFile_ConversionProgressUpdate;
+            var decryptionResult
+                = OutputFormat == OutputFormat.M4b
+                ? AaxFile.ConvertToMp4a(outputFile, DownloadLicense.ChapterInfo)
+                : AaxFile.ConvertToMp3(outputFile);
+            AaxFile.ConversionProgressUpdate -= AaxFile_ConversionProgressUpdate;
+
+            DownloadLicense.ChapterInfo = AaxFile.Chapters;
+
+            Step_DownloadAudiobook_End(zeroProgress);
+
+            var success = decryptionResult == ConversionResult.NoErrorsDetected && !IsCanceled;
+            if (success)
+                base.OnFileCreated(OutputFileName);
+
+            return success;
+        }
+    }
+}

AaxDecrypter/AudiobookDownloadBase.cs

@@ -0,0 +1,149 @@
+using System;
+using System.IO;
+using Dinah.Core;
+using Dinah.Core.Net.Http;
+using Dinah.Core.StepRunner;
+using FileManager;
+
+namespace AaxDecrypter
+{
+	public enum OutputFormat { M4b, Mp3 }
+
+	public abstract class AudiobookDownloadBase
+	{
+		public event EventHandler<string> RetrievedTitle;
+		public event EventHandler<string> RetrievedAuthors;
+		public event EventHandler<string> RetrievedNarrators;
+		public event EventHandler<byte[]> RetrievedCoverArt;
+		public event EventHandler<DownloadProgress> DecryptProgressUpdate;
+		public event EventHandler<TimeSpan> DecryptTimeRemaining;
+		public event EventHandler<string> FileCreated;
+
+		protected bool IsCanceled { get; set; }
+		protected string OutputFileName { get; private set; }
+		protected DownloadLicense DownloadLicense { get; }
+		protected NetworkFileStream InputFileStream => (nfsPersister ??= OpenNetworkFileStream()).NetworkFileStream;
+
+		// Don't give the property a 'set'. This should have to be an obvious choice; not accidental
+		protected void SetOutputFileName(string newOutputFileName) => OutputFileName = newOutputFileName;
+
+		protected abstract StepSequence Steps { get; }
+		private NetworkFileStreamPersister nfsPersister;
+
+		private string jsonDownloadState { get; }
+		private string tempFile => Path.ChangeExtension(jsonDownloadState, ".tmp");
+
+		protected AudiobookDownloadBase(string outFileName, string cacheDirectory, DownloadLicense dlLic)
+		{
+			OutputFileName = ArgumentValidator.EnsureNotNullOrWhiteSpace(outFileName, nameof(outFileName));
+
+			var outDir = Path.GetDirectoryName(OutputFileName);
+			if (!Directory.Exists(outDir))
+				throw new DirectoryNotFoundException($"Directory does not exist: {nameof(outDir)}");
+
+			if (!Directory.Exists(cacheDirectory))
+				throw new DirectoryNotFoundException($"Directory does not exist: {nameof(cacheDirectory)}");
+			jsonDownloadState = Path.Combine(cacheDirectory, Path.ChangeExtension(OutputFileName, ".json"));
+
+			DownloadLicense = ArgumentValidator.EnsureNotNull(dlLic, nameof(dlLic));
+
+			// delete file after validation is complete
+			FileUtility.SaferDelete(OutputFileName);
+		}
+
+		public abstract void Cancel();
+
+		public virtual void SetCoverArt(byte[] coverArt)
+		{
+			if (coverArt is not null)
+				OnRetrievedCoverArt(coverArt);
+		}
+
+		public bool Run()
+		{
+			var (IsSuccess, Elapsed) = Steps.Run();
+
+			if (!IsSuccess)
+				Serilog.Log.Logger.Error("Conversion failed");
+
+			return IsSuccess;
+		}		
+
+		protected void OnRetrievedTitle(string title) 
+			=> RetrievedTitle?.Invoke(this, title);
+		protected void OnRetrievedAuthors(string authors) 
+			=> RetrievedAuthors?.Invoke(this, authors);
+		protected void OnRetrievedNarrators(string narrators) 
+			=> RetrievedNarrators?.Invoke(this, narrators);
+		protected void OnRetrievedCoverArt(byte[] coverArt) 
+			=> RetrievedCoverArt?.Invoke(this, coverArt);
+		protected void OnDecryptProgressUpdate(DownloadProgress downloadProgress) 
+			=> DecryptProgressUpdate?.Invoke(this, downloadProgress);
+		protected void OnDecryptTimeRemaining(TimeSpan timeRemaining)
+			=> DecryptTimeRemaining?.Invoke(this, timeRemaining);
+		protected void OnFileCreated(string path)
+			=> FileCreated?.Invoke(this, path);
+
+		protected void CloseInputFileStream()
+		{
+			nfsPersister?.NetworkFileStream?.Close();
+			nfsPersister?.Dispose();
+		}
+
+		protected bool Step_CreateCue()
+		{
+			// not a critical step. its failure should not prevent future steps from running
+			try
+			{
+				var path = Path.ChangeExtension(OutputFileName, ".cue");
+				path = FileUtility.GetValidFilename(path);
+				File.WriteAllText(path, Cue.CreateContents(Path.GetFileName(OutputFileName), DownloadLicense.ChapterInfo));
+				OnFileCreated(path);
+			}
+			catch (Exception ex)
+			{
+				Serilog.Log.Logger.Error(ex, $"{nameof(Step_CreateCue)}. FAILED");
+			}
+			return !IsCanceled;
+		}
+
+		protected bool Step_Cleanup()
+		{
+			FileUtility.SaferDelete(jsonDownloadState);
+			FileUtility.SaferDelete(tempFile);
+			return !IsCanceled;
+		}
+
+		private NetworkFileStreamPersister OpenNetworkFileStream()
+		{
+			if (!File.Exists(jsonDownloadState))
+				return NewNetworkFilePersister();
+
+			try
+			{
+				var nfsp = 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.
+				nfsp.NetworkFileStream.SetUriForSameFile(new Uri(DownloadLicense.DownloadUrl));
+				return nfsp;
+			}
+			catch
+			{
+				FileUtility.SaferDelete(jsonDownloadState);
+				FileUtility.SaferDelete(tempFile);
+				return NewNetworkFilePersister();
+			}
+		}
+
+		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);
+		}
+	}
+}

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,24 @@
+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)
+        {
+            DownloadUrl = ArgumentValidator.EnsureNotNullOrEmpty(downloadUrl, nameof(downloadUrl));
+            UserAgent = ArgumentValidator.EnsureNotNullOrEmpty(userAgent, nameof(userAgent));
+
+            // no null/empty check. unencrypted files do not have these
+            AudibleKey = audibleKey;
+            AudibleIV = audibleIV;
+        }
+    }
+}

AaxDecrypter/MultiConvertFileProperties.cs

@@ -0,0 +1,25 @@
+using System;
+using System.IO;
+using FileManager;
+
+namespace AaxDecrypter
+{
+    public class MultiConvertFileProperties
+    {
+        public string OutputFileName { get; set; }
+        public int PartsPosition { get; set; }
+        public int PartsTotal { get; set; }
+        public string Title { get; set; }
+
+        public static string DefaultMultipartFilename(MultiConvertFileProperties multiConvertFileProperties)
+        {
+            var template = Path.ChangeExtension(multiConvertFileProperties.OutputFileName, null) + " - <ch# 0> - <title>" + Path.GetExtension(multiConvertFileProperties.OutputFileName);
+
+            var fileNamingTemplate = new FileNamingTemplate(template) { IllegalCharacterReplacements = " " };
+            fileNamingTemplate.AddParameterReplacement("ch# 0", FileUtility.GetSequenceFormatted(multiConvertFileProperties.PartsPosition, multiConvertFileProperties.PartsTotal));
+            fileNamingTemplate.AddParameterReplacement("title", multiConvertFileProperties.Title ?? "");
+
+            return fileNamingTemplate.GetFilePath();
+        }
+    }
+}

AaxDecrypter/NetworkFileStream.cs

@@ -0,0 +1,443 @@
+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; }
+        public bool IsCancelled { get; private 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}.");
+
+            //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();
+            _networkStream.Close();
+            WritePosition = downloadPosition;
+            Update();
+
+            downloadedPiece.Set();
+            downloadEnded.Set();
+
+            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}).");
+
+        }
+
+        #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,355 +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)
-        {
-            if (string.IsNullOrWhiteSpace(inputFile)) throw new ArgumentNullException(nameof(inputFile), "Input file may not be null or whitespace");
-            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
-            };
-
-            this.inputFileName = inputFile;
-            this.decryptKey = decryptKey;
-        }
-
-        private async Task prelimProcessing()
-        {
-            this.tags = new Tags(this.inputFileName);
-            this.encodingInfo = new EncodingInfo(this.inputFileName);
-            this.chapters = new Chapters(this.inputFileName, this.tags.duration.TotalSeconds);
-
-            var defaultFilename = Path.Combine(
-                Path.GetDirectoryName(this.inputFileName),
-                getASCIITag(this.tags.author),
-                getASCIITag(this.tags.title) + ".m4b"
-                );
-            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);
-			this.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)
-        {
-            this.outputFileName = outFileName;
-
-            if (Path.GetExtension(this.outputFileName) != ".m4b")
-                this.outputFileName = outputFileWithNewExt(".m4b");
-
-            this.outDir = Path.GetDirectoryName(this.outputFileName);
-        }
-
-        private string outputFileWithNewExt(string extension)
-            => Path.Combine(this.outDir, Path.GetFileNameWithoutExtension(this.outputFileName) + '.' + extension.Trim('.'));
-
-        public bool Step1_CreateDir()
-        {
-            ProcessRunner.WorkingDir = this.outDir;
-            Directory.CreateDirectory(this.outDir);
-            return true;
-        }
-
-        public bool Step2_DecryptAax()
-        {
-            DecryptProgressUpdate?.Invoke(this, 0);
-
-            var tempRipFile = Path.Combine(this.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}");
-                    this.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);
-            this.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 = this.ngDecrypt());
-            thread.Start();
-
-            double fileLen = new FileInfo(this.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 " + this.encodingInfo.channels + " -r " + this.encodingInfo.sampleRate + " \"" + this.inputFileName + "\""
-            };
-            info.EnvironmentVariables["VARIABLE"] = decryptKey;
-
-            var (output, exitCode) = info.RunHidden();
-
-            // bad checksum -- bad decrypt key
-            if (output.Contains("checksums mismatch, aborting!"))
-                return -99;
-
-            return exitCode;
-        }
-
-        // temp file names for steps 3, 4, 5
-        string tempChapsPath => Path.Combine(this.outDir, "tempChaps.mp4");
-        string mp4_file => outputFileWithNewExt(".mp4");
-        string ff_txt_file => mp4_file + ".ff.txt";
-
-        public bool Step3_Chapterize()
-        {
-            string str1 = "";
-            if (this.chapters.FirstChapterStart != 0.0)
-            {
-                str1 = " -ss " + this.chapters.FirstChapterStart.ToString("0.000", CultureInfo.InvariantCulture) + " -t " + (this.chapters.LastChapterStart - 1.0).ToString("0.000", CultureInfo.InvariantCulture) + " ";
-            }
-
-            string ffmpegTags = this.tags.GenerateFfmpegTags();
-            string ffmpegChapters = this.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(this.outDir, "cover-" + Guid.NewGuid() + ".jpg");
-            FileExt.CreateFile(coverPath, this.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, this.outputFileName);
-
-            return true;
-        }
-
-        public bool Step6_AddTags()
-        {
-            this.tags.AddAppleTags(this.outputFileName);
-            return true;
-        }
-
-        public bool End_CreateCue()
-        {
-            File.WriteAllText(outputFileWithNewExt(".cue"), this.chapters.GetCuefromChapters(Path.GetFileName(this.outputFileName)));
-            return true;
-        }
-
-        public bool End_CreateNfo()
-        {
-            File.WriteAllText(outputFileWithNewExt(".nfo"), NFO.CreateNfoContents(AppName, this.tags, this.encodingInfo, this.chapters));
-            return true;
-        }
-    }
-}

AaxDecrypter/UNTESTED/BytesCracker.cs

@@ -1,53 +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 readErrorOutput = true;
-            var ffprobeStderr = info.RunHidden(readErrorOutput).Output;
-
-            // 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)
-        {
-            this.markers = getAAXChapters(file);
-
-            // add end time
-            this.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() => this.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(this.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 = this.markers[i] * 1000.0;
-                var end = this.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,74 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Globalization;
-using System.IO;
-using System.Text;
-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; }
-
-        public Tags(string file)
-        {
-			using TagLib.File tagLibFile = TagLib.File.Create(file, "audio/mp4", ReadStyle.Average);
-			this.title = tagLibFile.Tag.Title.Replace(" (Unabridged)", "");
-			this.album = tagLibFile.Tag.Album.Replace(" (Unabridged)", "");
-			this.author = tagLibFile.Tag.FirstPerformer;
-			this.year = tagLibFile.Tag.Year.ToString();
-			this.comments = tagLibFile.Tag.Comment;
-			this.duration = tagLibFile.Properties.Duration;
-			this.genre = tagLibFile.Tag.FirstGenre;
-
-			var tag = tagLibFile.GetTag(TagTypes.Apple, true);
-			this.publisher = tag.Publisher;
-			this.narrator = string.IsNullOrWhiteSpace(tagLibFile.Tag.FirstComposer) ? tag.Narrator : tagLibFile.Tag.FirstComposer;
-			this.comments = !string.IsNullOrWhiteSpace(tag.LongDescription) ? tag.LongDescription : tag.Description;
-			this.id = tag.AudibleCDEK;
-		}
-
-        public void AddAppleTags(string file)
-        {
-			using var file1 = TagLib.File.Create(file, "audio/mp4", ReadStyle.Average);
-			var tag = (AppleTag)file1.GetTag(TagTypes.Apple, true);
-			tag.Publisher = this.publisher;
-			tag.LongDescription = this.comments;
-			tag.Description = this.comments;
-			file1.Save();
-		}
-
-        public string GenerateFfmpegTags()
-        {
-            StringBuilder stringBuilder = new StringBuilder();
-
-            stringBuilder.Append(";FFMETADATA1\n");
-            stringBuilder.Append("major_brand=aax\n");
-            stringBuilder.Append("minor_version=1\n");
-            stringBuilder.Append("compatible_brands=aax M4B mp42isom\n");
-            stringBuilder.Append("date=" + this.year + "\n");
-            stringBuilder.Append("genre=" + this.genre + "\n");
-            stringBuilder.Append("title=" + this.title + "\n");
-            stringBuilder.Append("artist=" + this.author + "\n");
-            stringBuilder.Append("album=" + this.album + "\n");
-            stringBuilder.Append("composer=" + this.narrator + "\n");
-            stringBuilder.Append("comment=" + this.comments.Truncate(254) + "\n");
-            stringBuilder.Append("description=" + this.comments + "\n");
-
-            return stringBuilder.ToString();
-        }
-    }
-}

AaxDecrypter/UnencryptedAudiobookDownloader.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Threading;
+using Dinah.Core.Net.Http;
+using Dinah.Core.StepRunner;
+using FileManager;
+
+namespace AaxDecrypter
+{
+	public class UnencryptedAudiobookDownloader : AudiobookDownloadBase
+	{
+		protected override StepSequence Steps { get; }
+
+		public UnencryptedAudiobookDownloader(string outFileName, string cacheDirectory, DownloadLicense dlLic)
+			: base(outFileName, cacheDirectory, dlLic)
+		{
+			Steps = new StepSequence
+			{
+				Name = "Download Mp3 Audiobook",
+
+				["Step 1: Get Mp3 Metadata"] = Step_GetMetadata,
+				["Step 2: Download Audiobook"] = Step_DownloadAudiobookAsSingleFile,
+				["Step 3: Create Cue"] = Step_CreateCue,
+				["Step 4: Cleanup"] = Step_Cleanup,
+			};
+		}
+
+		public override void Cancel()
+		{
+			IsCanceled = true;
+			CloseInputFileStream();
+		}
+
+		protected bool Step_GetMetadata()
+		{
+			OnRetrievedCoverArt(null);
+
+			return !IsCanceled;
+		}
+
+		private bool Step_DownloadAudiobookAsSingleFile()
+		{
+			DateTime startTime = DateTime.Now;
+
+			// MUST put InputFileStream.Length first, because it starts background downloader.
+
+			while (InputFileStream.Length > InputFileStream.WritePosition && !InputFileStream.IsCancelled) 
+			{
+				var rate = InputFileStream.WritePosition / (DateTime.Now - startTime).TotalSeconds;
+
+				var estTimeRemaining = (InputFileStream.Length - InputFileStream.WritePosition) / rate;
+
+				if (double.IsNormal(estTimeRemaining))
+					OnDecryptTimeRemaining(TimeSpan.FromSeconds(estTimeRemaining));
+
+				var progressPercent = (double)InputFileStream.WritePosition / InputFileStream.Length;
+
+				OnDecryptProgressUpdate(
+					new DownloadProgress
+					{
+						ProgressPercentage = 100 * progressPercent,
+						BytesReceived = (long)(InputFileStream.Length * progressPercent),
+						TotalBytesToReceive = InputFileStream.Length
+					});
+				Thread.Sleep(200);
+			}
+
+			CloseInputFileStream();
+
+			var realOutputFileName = FileUtility.SaferMoveToValidPath(InputFileStream.SaveFilePath, OutputFileName);
+			SetOutputFileName(realOutputFileName);
+			OnFileCreated(realOutputFileName);
+
+			return !IsCanceled;
+		}
+	}
+}

AppScaffolding/.msbump

@@ -0,0 +1,4 @@
+{
+  "//": "https://github.com/BalassaMarton/MSBump",
+  BumpRevision: true
+}

AppScaffolding/AppScaffolding.csproj

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <Version>6.7.5.1</Version>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="MSBump" Version="2.3.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Octokit" Version="0.50.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\AudibleUtilities\AudibleUtilities.csproj" />
+  </ItemGroup>
+
+</Project>

AppScaffolding/LibationScaffolding.cs

@@ -0,0 +1,381 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using AudibleUtilities;
+using Dinah.Core;
+using Dinah.Core.IO;
+using Dinah.Core.Logging;
+using LibationFileManager;
+using Newtonsoft.Json.Linq;
+using Serilog;
+
+namespace AppScaffolding
+{
+	public static class LibationScaffolding
+	{
+		// AppScaffolding
+		private static Assembly _executingAssembly;
+		private static Assembly ExecutingAssembly
+			=> _executingAssembly ??= Assembly.GetExecutingAssembly();
+
+		// LibationWinForms or LibationCli
+		private static Assembly _entryAssembly;
+		private static Assembly EntryAssembly
+			=> _entryAssembly ??= Assembly.GetEntryAssembly();
+
+		// previously: System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
+		private static Version _buildVersion;
+		public static Version BuildVersion
+			=> _buildVersion
+			??= new[] { ExecutingAssembly.GetName(), EntryAssembly.GetName() }
+			.Max(a => a.Version);
+
+		/// <summary>Run migrations before loading Configuration for the first time. Then load and return Configuration</summary>
+		public static Configuration RunPreConfigMigrations()
+		{
+			// must occur before access to Configuration instance
+			Migrations.migrate_to_v5_2_0__pre_config();
+
+			//***********************************************//
+			//                                               //
+			//   do not use Configuration before this line   //
+			//                                               //
+			//***********************************************//
+			return Configuration.Instance;
+		}
+
+		/// <summary>most migrations go in here</summary>
+		public static void RunPostConfigMigrations(Configuration config)
+		{
+			AudibleApiStorage.EnsureAccountsSettingsFileExists();
+			PopulateMissingConfigValues(config);
+
+			//
+			// migrations go below here
+			//
+
+			Migrations.migrate_to_v6_6_9(config);
+		}
+
+		public static void PopulateMissingConfigValues(Configuration config)
+		{
+			config.InProgress ??= Configuration.WinTemp;
+
+			if (!config.Exists(nameof(config.AllowLibationFixup)))
+				config.AllowLibationFixup = true;
+
+			if (!config.Exists(nameof(config.DecryptToLossy)))
+				config.DecryptToLossy = false;
+
+			if (!config.Exists(nameof(config.BadBook)))
+				config.BadBook = Configuration.BadBookAction.Ask;
+
+			if (!config.Exists(nameof(config.DownloadEpisodes)))
+				config.DownloadEpisodes = true;
+
+			if (!config.Exists(nameof(config.ImportEpisodes)))
+				config.ImportEpisodes = true;
+
+			if (!config.Exists(nameof(config.SplitFilesByChapter)))
+				config.SplitFilesByChapter = false;
+
+			if (!config.Exists(nameof(config.FolderTemplate)))
+				config.FolderTemplate = Templates.Folder.DefaultTemplate;
+
+			if (!config.Exists(nameof(config.FileTemplate)))
+				config.FileTemplate = Templates.File.DefaultTemplate;
+
+			if (!config.Exists(nameof(config.ChapterFileTemplate)))
+				config.ChapterFileTemplate = Templates.ChapterFile.DefaultTemplate;
+
+			if (!config.Exists(nameof(config.ShowImportedStats)))
+				config.ShowImportedStats = true;
+		}
+
+		/// <summary>Initialize logging. Run after migration</summary>
+		public static void RunPostMigrationScaffolding(Configuration config)
+		{
+			ensureSerilogConfig(config);
+			configureLogging(config);
+			logStartupState(config);
+		}
+
+		private static void ensureSerilogConfig(Configuration config)
+		{
+			if (config.GetObject("Serilog") != null)
+				return;
+
+			var serilogObj = new JObject
+			{
+				{ "MinimumLevel", "Information" },
+				{ "WriteTo", new JArray
+					{
+						// new JObject { {"Name", "Console" } }, // this has caused more problems than it's solved
+						new JObject
+						{
+							{ "Name", "File" },
+							{ "Args",
+								new JObject
+								{
+									// for this sink to work, a path must be provided. we override this below
+									{ "path", Path.Combine(config.LibationFiles, "_Log.log") },
+									{ "rollingInterval", "Month" },
+									// Serilog template formatting examples
+									// - default:                    "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}"
+									//   output example:             2019-11-26 08:48:40.224 -05:00 [DBG] Begin Libation
+									// - with class and method info: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] (at {Caller}) {Message:lj}{NewLine}{Exception}";
+									//   output example:             2019-11-26 08:48:40.224 -05:00 [DBG] (at LibationWinForms.Program.init()) Begin Libation
+									// {Properties:j} needed for expanded exception logging
+									{ "outputTemplate", "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] (at {Caller}) {Message:lj}{NewLine}{Exception} {Properties:j}" }
+								}
+							}
+						}
+					}
+				},
+				// better exception logging with: Serilog.Exceptions library -- WithExceptionDetails
+				{ "Using", new JArray{ "Dinah.Core", "Serilog.Exceptions" } }, // dll's name, NOT namespace
+				{ "Enrich", new JArray{ "WithCaller", "WithExceptionDetails" } },
+			};
+			config.SetObject("Serilog", serilogObj);
+		}
+
+		// to restore original: Console.SetOut(origOut);
+		private static TextWriter origOut { get; } = Console.Out;
+
+		private static void configureLogging(Configuration config)
+		{
+			config.ConfigureLogging();
+
+			// capture most Console.WriteLine() and write to serilog. See below tests for details.
+			// Some dependencies print helpful info via Console.WriteLine. We'd like to log it.
+			//
+			// If Serilog also writes to Console, this might be asking for trouble. ie: infinite loops.
+			// To use that way, SerilogTextWriter needs to be more robust and tested. Esp the Write() methods.
+			// However, empirical testing so far has shown no issues.
+			Console.SetOut(new MultiTextWriter(origOut, new SerilogTextWriter()));
+
+			#region Console => Serilog tests
+			/*
+			// all below apply to "Console." and "Console.Out."
+
+			// captured
+			Console.WriteLine("str");
+			Console.WriteLine(new { a = "anon" });
+			Console.WriteLine("{0}", "format");
+			Console.WriteLine("{0}{1}", "zero|", "one");
+			Console.WriteLine("{0}{1}{2}", "zero|", "one|", "two");
+			Console.WriteLine("{0}", new object[] { "arr" });
+
+			// not captured
+			Console.WriteLine();
+			Console.WriteLine(true);
+			Console.WriteLine('0');
+			Console.WriteLine(1);
+			Console.WriteLine(2m);
+			Console.WriteLine(3f);
+			Console.WriteLine(4d);
+			Console.WriteLine(5L);
+			Console.WriteLine((uint)6);
+			Console.WriteLine((ulong)7);
+
+			Console.Write("str");
+			Console.Write(true);
+			Console.Write('0');
+			Console.Write(1);
+			Console.Write(2m);
+			Console.Write(3f);
+			Console.Write(4d);
+			Console.Write(5L);
+			Console.Write((uint)6);
+			Console.Write((ulong)7);
+			Console.Write(new { a = "anon" });
+			Console.Write("{0}", "format");
+			Console.Write("{0}{1}", "zero|", "one");
+			Console.Write("{0}{1}{2}", "zero|", "one|", "two");
+			Console.Write("{0}", new object[] { "arr" });
+			*/
+			#endregion
+
+			// .Here() captures debug info via System.Runtime.CompilerServices attributes. Warning: expensive
+			//var withLineNumbers_outputTemplate = "[{Timestamp:HH:mm:ss} {Level}] {SourceContext}{NewLine}{Message}{NewLine}in method {MemberName} at {FilePath}:{LineNumber}{NewLine}{Exception}{NewLine}";
+			//Log.Logger.Here().Debug("Begin Libation. Debug with line numbers");
+		}
+
+		private static void logStartupState(Configuration config)
+		{
+			// begin logging session with a form feed
+			Log.Logger.Information("\r\n\f");
+			Log.Logger.Information("Begin. {@DebugInfo}", new
+			{
+				AppName = EntryAssembly.GetName().Name,
+				Version = BuildVersion.ToString(),
+#if DEBUG
+				Mode = "Debug",
+#else
+				Mode = "Release",
+#endif
+
+				LogLevel_Verbose_Enabled = Log.Logger.IsVerboseEnabled(),
+				LogLevel_Debug_Enabled = Log.Logger.IsDebugEnabled(),
+				LogLevel_Information_Enabled = Log.Logger.IsInformationEnabled(),
+				LogLevel_Warning_Enabled = Log.Logger.IsWarningEnabled(),
+				LogLevel_Error_Enabled = Log.Logger.IsErrorEnabled(),
+				LogLevel_Fatal_Enabled = Log.Logger.IsFatalEnabled(),
+
+				config.LibationFiles,
+				AudibleFileStorage.BooksDirectory,
+
+				config.InProgress,
+
+				AudibleFileStorage.DownloadsInProgressDirectory,
+				DownloadsInProgressFiles = FileManager.FileUtility.SaferEnumerateFiles(AudibleFileStorage.DownloadsInProgressDirectory).Count(),
+
+				AudibleFileStorage.DecryptInProgressDirectory,
+				DecryptInProgressFiles = FileManager.FileUtility.SaferEnumerateFiles(AudibleFileStorage.DecryptInProgressDirectory).Count(),
+			});
+		}
+
+		public static (bool hasUpgrade, string zipUrl, string htmlUrl, string zipName) GetLatestRelease()
+		{
+			(bool, string, string, string) isFalse = (false, null, null, null);
+
+			// timed out
+			var latest = getLatestRelease(TimeSpan.FromSeconds(10));
+			if (latest is null)
+				return isFalse;
+
+			var latestVersionString = latest.TagName.Trim('v');
+			if (!Version.TryParse(latestVersionString, out var latestRelease))
+				return isFalse;
+
+			// we're up to date
+			if (latestRelease <= BuildVersion)
+				return isFalse;
+
+			// we have an update
+			var zip = latest.Assets.FirstOrDefault(a => a.BrowserDownloadUrl.EndsWith(".zip"));
+			var zipUrl = zip?.BrowserDownloadUrl;
+
+			Log.Logger.Information("Update available: {@DebugInfo}", new
+			{
+				latestRelease = latestRelease.ToString(),
+				latest.HtmlUrl,
+				zipUrl
+			});
+
+			return (true, zipUrl, latest.HtmlUrl, zip.Name);
+		}
+		private static Octokit.Release getLatestRelease(TimeSpan timeout)
+		{
+			try
+			{
+				var task = System.Threading.Tasks.Task.Run(() => getLatestRelease());
+				if (task.Wait(timeout))
+					return task.Result;
+
+				Log.Logger.Information("Timed out");
+			}
+			catch (AggregateException aggEx)
+			{
+				Log.Logger.Error(aggEx, "Checking for new version too often");
+			}
+			return null;
+		}
+		private static Octokit.Release getLatestRelease()
+		{
+			var gitHubClient = new Octokit.GitHubClient(new Octokit.ProductHeaderValue("Libation"));
+
+			// https://octokitnet.readthedocs.io/en/latest/releases/
+			var releases = gitHubClient.Repository.Release.GetAll("rmcrackan", "Libation").GetAwaiter().GetResult();
+			var latest = releases.First(r => !r.Draft && !r.Prerelease);
+			return latest;
+		}
+	}
+
+	internal static class Migrations
+	{
+		#region migrate to v5.2.0
+		// get rid of meta-directories, combine DownloadsInProgressEnum and DecryptInProgressEnum => InProgress
+		public static void migrate_to_v5_2_0__pre_config()
+		{
+			{
+				var settingsKey = "DownloadsInProgressEnum";
+				if (UNSAFE_MigrationHelper.Settings_TryGet(settingsKey, out var value))
+				{
+					UNSAFE_MigrationHelper.Settings_Delete(settingsKey);
+					UNSAFE_MigrationHelper.Settings_Insert("InProgress", translatePath(value));
+				}
+			}
+
+			{
+				UNSAFE_MigrationHelper.Settings_Delete("DecryptInProgressEnum");
+			}
+
+			{ // appsettings.json
+				var appSettingsKey = UNSAFE_MigrationHelper.LIBATION_FILES_KEY;
+				if (UNSAFE_MigrationHelper.APPSETTINGS_TryGet(appSettingsKey, out var value))
+					UNSAFE_MigrationHelper.APPSETTINGS_Update(appSettingsKey, translatePath(value));
+			}
+		}
+
+		private static string translatePath(string path)
+			=> path switch
+			{
+				"AppDir" => @".\LibationFiles",
+				"MyDocs" => Path.GetFullPath(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "LibationFiles")),
+				"UserProfile" => Path.GetFullPath(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Libation")),
+				"WinTemp" => Path.GetFullPath(Path.Combine(Path.GetTempPath(), "Libation")),
+				_ => path
+			};
+		#endregion
+
+		public static void migrate_to_v6_6_9(Configuration config)
+		{
+			var writeToPath = $"Serilog.WriteTo";
+
+			// remove WriteTo[].Name == Console
+			{
+				if (UNSAFE_MigrationHelper.Settings_TryGetArrayLength(writeToPath, out var length1))
+				{
+					for (var i = length1 - 1; i >= 0; i--)
+					{
+						var exists = UNSAFE_MigrationHelper.Settings_TryGetFromJsonPath($"{writeToPath}[{i}].Name", out var value);
+
+						if (exists && value == "Console")
+							UNSAFE_MigrationHelper.Settings_RemoveFromArray(writeToPath, i);
+					}
+				}
+			}
+
+			// add Serilog.Exceptions -- WithExceptionDetails
+			{
+				// outputTemplate should contain "{Properties:j}"
+				{
+					// re-calculate. previous loop may have changed the length
+					if (UNSAFE_MigrationHelper.Settings_TryGetArrayLength(writeToPath, out var length2))
+					{
+						var propertyName = "outputTemplate";
+						for (var i = 0; i < length2; i++)
+						{
+							var jsonPath = $"{writeToPath}[{i}].Args";
+							var exists = UNSAFE_MigrationHelper.Settings_TryGetFromJsonPath($"{jsonPath}.{propertyName}", out var value);
+
+							var newValue = "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] (at {Caller}) {Message:lj}{NewLine}{Exception} {Properties:j}";
+
+							if (exists && value != newValue)
+								UNSAFE_MigrationHelper.Settings_SetWithJsonPath(jsonPath, propertyName, newValue);
+						}
+					}
+				}
+
+				// Serilog.Using must include "Serilog.Exceptions"
+				UNSAFE_MigrationHelper.Settings_AddUniqueToArray("Serilog.Using", "Serilog.Exceptions");
+
+				// Serilog.Enrich must include "WithExceptionDetails"
+				UNSAFE_MigrationHelper.Settings_AddUniqueToArray("Serilog.Enrich", "WithExceptionDetails");
+			}
+		}
+	}
+}

AppScaffolding/UNSAFE_MigrationHelper.cs

@@ -0,0 +1,271 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Dinah.Core;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace AppScaffolding
+{
+	/// <summary>
+	/// 
+	/// 
+	///      directly manipulates settings files without going through domain logic.
+	///      
+	///      for migrations only. use with caution.
+	/// 
+	/// 
+	/// </summary>
+	internal static class UNSAFE_MigrationHelper
+	{
+		#region appsettings.json
+		private static string APPSETTINGS_JSON { get; } = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location), "appsettings.json");
+
+		public static bool APPSETTINGS_Json_Exists => File.Exists(APPSETTINGS_JSON);
+
+		public static bool APPSETTINGS_TryGet(string key, out string value)
+		{
+			bool success = false;
+			JToken val = null;
+
+			process_APPSETTINGS_Json(jObj => success = jObj.TryGetValue(key, out val), false);
+
+			value = success ? val.Value<string>() : null;
+			return success;
+		}
+
+		/// <summary>only insert if not exists</summary>
+		public static void APPSETTINGS_Insert(string key, string value)
+			=> process_APPSETTINGS_Json(jObj => jObj.TryAdd(key, value));
+
+		/// <summary>only update if exists</summary>
+		public static void APPSETTINGS_Update(string key, string value)
+			=> process_APPSETTINGS_Json(jObj => {
+				if (jObj.ContainsKey(key))
+					jObj[key] = value;
+			});
+
+		/// <summary>only delete if exists</summary>
+		public static void APPSETTINGS_Delete(string key)
+			=> process_APPSETTINGS_Json(jObj => {
+				if (jObj.ContainsKey(key))
+					jObj.Remove(key);
+			});
+
+		/// <param name="save">True: save if contents changed. False: no not attempt save</param>
+		private static void process_APPSETTINGS_Json(Action<JObject> action, bool save = true)
+		{
+			// only insert if not exists
+			if (!APPSETTINGS_Json_Exists)
+				return;
+
+			var startingContents = File.ReadAllText(APPSETTINGS_JSON);
+
+			JObject jObj;
+			try
+			{
+				jObj = JObject.Parse(startingContents);
+			}
+			catch
+			{
+				return;
+			}
+
+			action(jObj);
+
+			if (!save)
+				return;
+
+			// only save if different
+			var endingContents_indented = jObj.ToString(Formatting.Indented);
+			var endingContents_compact = jObj.ToString(Formatting.None);
+			if (startingContents.EqualsInsensitive(endingContents_indented) || startingContents.EqualsInsensitive(endingContents_compact))
+				return;
+
+			File.WriteAllText(APPSETTINGS_JSON, endingContents_indented);
+			System.Threading.Thread.Sleep(100);
+		}
+		#endregion
+
+		#region Settings.json
+		public const string LIBATION_FILES_KEY = "LibationFiles";
+		private const string SETTINGS_JSON = "Settings.json";
+
+		public static string SettingsJsonPath
+		{
+			get
+			{
+				var success = APPSETTINGS_TryGet(LIBATION_FILES_KEY, out var value);
+				return !success || value is null ? null : Path.Combine(value, SETTINGS_JSON);
+			}
+		}
+		public static bool SettingsJson_Exists => SettingsJsonPath is not null && File.Exists(SettingsJsonPath);
+
+		public static bool Settings_TryGet(string key, out string value)
+		{
+			bool success = false;
+			JToken val = null;
+
+			process_SettingsJson(jObj => success = jObj.TryGetValue(key, out val), false);
+
+			value = success ? val.Value<string>() : null;
+			return success;
+		}
+
+		public static bool Settings_JsonPathIsType(string jsonPath, JTokenType jTokenType)
+		{
+			JToken val = null;
+
+			process_SettingsJson(jObj => val = jObj.SelectToken(jsonPath), false);
+
+			return val?.Type == jTokenType;
+		}
+
+		public static bool Settings_TryGetFromJsonPath(string jsonPath, out string value)
+		{
+			JToken val = null;
+
+			process_SettingsJson(jObj => val = jObj.SelectToken(jsonPath), false);
+
+			if (val?.Type == JTokenType.String)
+			{
+				value = val.Value<string>();
+				return true;
+			}
+			else
+			{
+				value = null;
+				return false;
+			}
+		}
+
+		public static void Settings_SetWithJsonPath(string jsonPath, string propertyName, string newValue)
+		{
+			if (!Settings_TryGetFromJsonPath($"{jsonPath}.{propertyName}", out _))
+				return;
+
+			process_SettingsJson(jObj =>
+			{
+				var token = jObj.SelectToken(jsonPath);
+				if (token is null
+				|| token is not JObject o
+				|| o[propertyName] is null)
+					return;
+
+				var oldValue = token.Value<string>(propertyName);
+				if (oldValue != newValue)
+					token[propertyName] = newValue;
+			});
+		}
+
+		public static bool Settings_TryGetArrayLength(string jsonPath, out int length)
+		{
+			length = 0;
+
+			if (!Settings_JsonPathIsType(jsonPath, JTokenType.Array))
+				return false;
+
+			JArray array = null;
+			process_SettingsJson(jObj => array = (JArray)jObj.SelectToken(jsonPath));
+
+			length = array.Count;
+			return true;
+		}
+
+		public static void Settings_AddToArray(string jsonPath, string newValue)
+		{
+			if (!Settings_JsonPathIsType(jsonPath, JTokenType.Array))
+				return;
+
+			process_SettingsJson(jObj =>
+			{
+				var array = (JArray)jObj.SelectToken(jsonPath);
+				array.Add(newValue);
+			});
+		}
+
+		/// <summary>Do not add if already exists</summary>
+		public static void Settings_AddUniqueToArray(string arrayPath, string newValue)
+		{
+			if (!Settings_TryGetArrayLength(arrayPath, out var qty))
+				return;
+
+			for (var i = 0; i < qty; i++)
+			{
+				var exists = Settings_TryGetFromJsonPath($"{arrayPath}[{i}]", out var value);
+				if (exists && value == newValue)
+					return;
+			}
+
+			Settings_AddToArray(arrayPath, newValue);
+		}
+
+		/// <summary>only remove if not exists</summary>
+		public static void Settings_RemoveFromArray(string jsonPath, int position)
+		{
+			if (!Settings_JsonPathIsType(jsonPath, JTokenType.Array))
+				return;
+
+			process_SettingsJson(jObj =>
+			{
+				var array = (JArray)jObj.SelectToken(jsonPath);
+				if (position < array.Count)
+					array.RemoveAt(position);
+			});
+		}
+
+		/// <summary>only insert if not exists</summary>
+		public static void Settings_Insert(string key, string value)
+			=> process_SettingsJson(jObj => jObj.TryAdd(key, value));
+
+		/// <summary>only update if exists</summary>
+		public static void Settings_Update(string key, string value)
+			=> process_SettingsJson(jObj => {
+				if (jObj.ContainsKey(key))
+					jObj[key] = value;
+			});
+
+		/// <summary>only delete if exists</summary>
+		public static void Settings_Delete(string key)
+			=> process_SettingsJson(jObj => {
+				if (jObj.ContainsKey(key))
+					jObj.Remove(key);
+			});
+
+		/// <param name="save">True: save if contents changed. False: no not attempt save</param>
+		private static void process_SettingsJson(Action<JObject> action, bool save = true)
+		{
+			// only insert if not exists
+			if (!SettingsJson_Exists)
+				return;
+
+			var startingContents = File.ReadAllText(SettingsJsonPath);
+
+			JObject jObj;
+			try
+			{
+				jObj = JObject.Parse(startingContents);
+			}
+			catch
+			{
+				return;
+			}
+
+			action(jObj);
+
+			if (!save)
+				return;
+
+			// only save if different
+			var endingContents_indented = jObj.ToString(Formatting.Indented);
+			var endingContents_compact = jObj.ToString(Formatting.None);
+			if (startingContents.EqualsInsensitive(endingContents_indented) || startingContents.EqualsInsensitive(endingContents_compact))
+				return;
+
+			File.WriteAllText(SettingsJsonPath, endingContents_indented);
+			System.Threading.Thread.Sleep(100);
+		}
+		#endregion
+	}
+}

ApplicationServices/ApplicationServices.csproj

@@ -1,14 +1,16 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.1</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\..\audible api\AudibleApi\AudibleApiDTOs\AudibleApiDTOs.csproj" />
-    <ProjectReference Include="..\..\audible api\AudibleApi\AudibleApi\AudibleApi.csproj" />
+    <PackageReference Include="CsvHelper" Version="27.2.1" />
+    <PackageReference Include="NPOI" Version="2.5.5" />
+  </ItemGroup>
+
+  <ItemGroup>
     <ProjectReference Include="..\DtoImporterService\DtoImporterService.csproj" />
-    <ProjectReference Include="..\InternalUtilities\InternalUtilities.csproj" />
     <ProjectReference Include="..\LibationSearchEngine\LibationSearchEngine.csproj" />
   </ItemGroup>
 

ApplicationServices/DbContexts.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using DataLayer;
+using LibationFileManager;
+
+namespace ApplicationServices
+{
+	public static class DbContexts
+	{
+		/// <summary>Use for fully functional context, incl. SaveChanges(). For query-only, use the other method</summary>
+		public static LibationContext GetContext()
+			=> LibationContext.Create(SqliteStorage.ConnectionString);
+
+		/// <summary>Use for full library querying. No lazy loading</summary>
+		public static List<LibraryBook> GetLibrary_Flat_NoTracking()
+		{
+			using var context = GetContext();
+			return context.GetLibrary_Flat_NoTracking();
+		}
+	}
+}

ApplicationServices/LibraryCommands.cs

@@ -0,0 +1,286 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using AudibleApi;
+using AudibleUtilities;
+using DataLayer;
+using Dinah.Core;
+using DtoImporterService;
+using LibationFileManager;
+using Serilog;
+using static DtoImporterService.PerfLogger;
+
+namespace ApplicationServices
+{
+	public static class LibraryCommands
+	{
+		public static async Task<List<LibraryBook>> FindInactiveBooks(Func<Account, Task<ApiExtended>> apiExtendedfunc, List<LibraryBook> existingLibrary, params Account[] accounts)
+		{
+			logRestart();
+
+			//These are the minimum response groups required for the
+			//library scanner to pass all validation and filtering.
+			var libraryResponseGroups =
+				LibraryOptions.ResponseGroupOptions.ProductAttrs |
+				LibraryOptions.ResponseGroupOptions.ProductDesc |
+				LibraryOptions.ResponseGroupOptions.Relationships;
+
+			if (accounts is null || accounts.Length == 0)
+				return new List<LibraryBook>();
+
+			try
+			{
+				logTime($"pre {nameof(scanAccountsAsync)} all");
+				var libraryItems = await scanAccountsAsync(apiExtendedfunc, accounts, libraryResponseGroups);
+				logTime($"post {nameof(scanAccountsAsync)} all");
+
+				var totalCount = libraryItems.Count;
+				Log.Logger.Information($"GetAllLibraryItems: Total count {totalCount}");
+
+				var missingBookList = existingLibrary.Where(b => !libraryItems.Any(i => i.DtoItem.Asin == b.Book.AudibleProductId)).ToList();
+
+				return missingBookList;
+			}
+			catch (AudibleApi.Authentication.LoginFailedException lfEx)
+			{
+				lfEx.SaveFiles(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 scanning library");
+				throw;
+			}
+			finally
+			{
+				stop();
+				var putBreakPointHere = logOutput;
+			}
+		}
+
+		#region FULL LIBRARY scan and import
+		public static async Task<(int totalCount, int newCount)> ImportAccountAsync(Func<Account, Task<ApiExtended>> apiExtendedfunc, params Account[] accounts)
+		{
+			logRestart();
+
+			if (accounts is null || accounts.Length == 0)
+				return (0, 0);
+
+			try
+			{
+				logTime($"pre {nameof(scanAccountsAsync)} all");
+				var importItems = await scanAccountsAsync(apiExtendedfunc, accounts, LibraryOptions.ResponseGroupOptions.ALL_OPTIONS);
+				logTime($"post {nameof(scanAccountsAsync)} all");
+
+				var totalCount = importItems.Count;
+				Log.Logger.Information($"GetAllLibraryItems: Total count {totalCount}");
+
+				Log.Logger.Information("Begin long-running import");
+				logTime($"pre {nameof(importIntoDbAsync)}");
+				var newCount = await importIntoDbAsync(importItems);
+				logTime($"post {nameof(importIntoDbAsync)}");
+				Log.Logger.Information($"Import complete. New count {newCount}");
+
+				return (totalCount, newCount);
+			}
+			catch (AudibleApi.Authentication.LoginFailedException lfEx)
+			{
+				lfEx.SaveFiles(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;
+			}
+			finally
+			{
+				stop();
+				var putBreakPointHere = logOutput;
+			}
+		}
+
+		private static async Task<List<ImportItem>> scanAccountsAsync(Func<Account, Task<ApiExtended>> apiExtendedfunc, Account[] accounts, LibraryOptions.ResponseGroupOptions libraryResponseGroups)
+		{
+			var tasks = new List<Task<List<ImportItem>>>();
+			foreach (var account in accounts)
+			{
+				// get APIs in serial b/c of logins. do NOT move inside of parallel (Task.WhenAll)
+				var apiExtended = await apiExtendedfunc(account);
+
+				// add scanAccountAsync as a TASK: do not await
+				tasks.Add(scanAccountAsync(apiExtended, account, libraryResponseGroups));
+			}
+
+			// 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(ApiExtended apiExtended, Account account, LibraryOptions.ResponseGroupOptions libraryResponseGroups)
+		{
+			ArgumentValidator.EnsureNotNull(account, nameof(account));
+
+			Log.Logger.Information("ImportLibraryAsync. {@DebugInfo}", new
+			{
+				Account = account?.MaskedLogEntry ?? "[null]"
+			});
+
+			logTime($"pre scanAccountAsync {account.AccountName}");
+
+			var dtoItems = await apiExtended.GetLibraryValidatedAsync(libraryResponseGroups, Configuration.Instance.ImportEpisodes);
+
+			logTime($"post scanAccountAsync {account.AccountName} qty: {dtoItems.Count}");
+
+			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)
+		{
+			logTime("importIntoDbAsync -- pre db");
+			using var context = DbContexts.GetContext();
+			var libraryBookImporter = new LibraryBookImporter(context);
+			var newCount = await Task.Run(() => libraryBookImporter.Import(importItems));
+			logTime("importIntoDbAsync -- post Import()");
+			var qtyChanges = context.SaveChanges();
+			logTime("importIntoDbAsync -- post SaveChanges");
+
+			if (qtyChanges > 0)
+				await Task.Run(() => finalizeLibrarySizeChange());
+			logTime("importIntoDbAsync -- post finalizeLibrarySizeChange");
+
+			return newCount;
+		}
+		#endregion
+
+		#region remove books
+		public static Task<List<LibraryBook>> RemoveBooksAsync(List<string> idsToRemove) => Task.Run(() => removeBooks(idsToRemove));
+		private static List<LibraryBook> removeBooks(List<string> idsToRemove)
+		{
+			using var context = DbContexts.GetContext();
+			var libBooks = context.GetLibrary_Flat_NoTracking();
+
+			var removeLibraryBooks = libBooks.Where(lb => idsToRemove.Contains(lb.Book.AudibleProductId)).ToList();
+			context.LibraryBooks.RemoveRange(removeLibraryBooks);
+			context.Books.RemoveRange(removeLibraryBooks.Select(lb => lb.Book));
+
+			var qtyChanges = context.SaveChanges();
+			if (qtyChanges > 0)
+				finalizeLibrarySizeChange();
+
+			return removeLibraryBooks;
+		}
+		#endregion
+
+		// call this whenever books are added or removed from library
+		private static void finalizeLibrarySizeChange()
+		{
+			SearchEngineCommands.FullReIndex();
+			LibrarySizeChanged?.Invoke(null, null);
+		}
+
+		/// <summary>Occurs when books are added or removed from library</summary>
+		public static event EventHandler LibrarySizeChanged;
+
+		/// <summary>
+		/// Occurs when <see cref="UserDefinedItem.Tags"/>, <see cref="UserDefinedItem.BookStatus"/>, or <see cref="UserDefinedItem.PdfStatus"/>
+		/// changed values are successfully persisted.
+		/// </summary>
+		public static event EventHandler<string> BookUserDefinedItemCommitted;
+
+		#region Update book details
+		public static int UpdateUserDefinedItem(Book book)
+		{
+			try
+			{
+				using var context = DbContexts.GetContext();
+
+				// Attach() NoTracking entities before SaveChanges()
+				context.Attach(book.UserDefinedItem).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
+				var qtyChanges = context.SaveChanges();
+				if (qtyChanges > 0)
+				{
+					SearchEngineCommands.UpdateLiberatedStatus(book);
+					SearchEngineCommands.UpdateBookTags(book);
+					BookUserDefinedItemCommitted?.Invoke(null, book.AudibleProductId);
+				}
+
+				return qtyChanges;
+			}
+			catch (Exception ex)
+			{
+				Log.Logger.Error(ex, $"Error updating {nameof(book.UserDefinedItem)}");
+				throw;
+			}
+		}
+		#endregion
+
+		// must be here instead of in db layer due to AaxcExists
+		public static LiberatedStatus Liberated_Status(Book book)
+			=> book.Audio_Exists ? book.UserDefinedItem.BookStatus
+			: AudibleFileStorage.AaxcExists(book.AudibleProductId) ? LiberatedStatus.PartialDownload
+			: LiberatedStatus.NotLiberated;
+
+		// exists here for feature predictability. It makes sense for this to be where Liberated_Status is
+		public static LiberatedStatus? Pdf_Status(Book book) => book.UserDefinedItem.PdfStatus;
+
+		// below are queries, not commands. maybe I should make a LibraryQueries. except there's already one of those...
+
+		public record LibraryStats(int booksFullyBackedUp, int booksDownloadedOnly, int booksNoProgress, int booksError, int pdfsDownloaded, int pdfsNotDownloaded) { }
+		public static LibraryStats GetCounts()
+		{
+			var libraryBooks = DbContexts.GetLibrary_Flat_NoTracking();
+
+			var results = libraryBooks
+				.AsParallel()
+				.Select(lb => Liberated_Status(lb.Book))
+				.ToList();
+			var booksFullyBackedUp = results.Count(r => r == LiberatedStatus.Liberated);
+			var booksDownloadedOnly = results.Count(r => r == LiberatedStatus.PartialDownload);
+			var booksNoProgress = results.Count(r => r == LiberatedStatus.NotLiberated);
+			var booksError = results.Count(r => r == LiberatedStatus.Error);
+
+			Log.Logger.Information("Book counts. {@DebugInfo}", new { total = results.Count, booksFullyBackedUp, booksDownloadedOnly, booksNoProgress, booksError });
+
+			var boolResults = libraryBooks
+				.AsParallel()
+				.Where(lb => lb.Book.HasPdf)
+				.Select(lb => Pdf_Status(lb.Book))
+				.ToList();
+			var pdfsDownloaded = boolResults.Count(r => r == LiberatedStatus.Liberated);
+			var pdfsNotDownloaded = boolResults.Count(r => r == LiberatedStatus.NotLiberated);
+
+			Log.Logger.Information("PDF counts. {@DebugInfo}", new { total = boolResults.Count, pdfsDownloaded, pdfsNotDownloaded });
+
+			return new(booksFullyBackedUp, booksDownloadedOnly, booksNoProgress, booksError, pdfsDownloaded, pdfsNotDownloaded);
+		}
+	}
+}

ApplicationServices/LibraryExporter.cs

@@ -0,0 +1,287 @@
+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("Description")]
+		public string Description { get; set; }
+
+		[Name("Publisher")]
+		public string Publisher { get; set; }
+
+		[Name("Has PDF")]
+		public bool HasPdf { 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 Liberated Status")]
+		public string BookStatus { get; set; }
+
+		[Name("PDF Liberated Status")]
+		public string PdfStatus { get; set; }
+
+		[Name("Content Type")]
+		public string ContentType { 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,
+				Description = a.Book.Description,
+				Publisher = a.Book.Publisher,
+				HasPdf = a.Book.HasPdf,
+				SeriesNames = a.Book.SeriesNames,
+				SeriesOrder = a.Book.SeriesLink.Any() ? a.Book.SeriesLink?.Select(sl => $"{sl.Order} : {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(),
+				PdfStatus = a.Book.UserDefinedItem.PdfStatus.ToString(),
+				ContentType = a.Book.ContentType.ToString()
+			}).ToList();
+	}
+	public static class LibraryExporter
+	{
+		public static void ToCsv(string saveFilePath)
+		{
+			var dtos = DbContexts.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)
+		{
+			var dtos = DbContexts.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)
+		{
+			var dtos = DbContexts.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.Description),
+				nameof (ExportDto.Publisher),
+				nameof (ExportDto.HasPdf),
+				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.PdfStatus),
+				nameof (ExportDto.ContentType)
+			};
+			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.Description);
+				row.CreateCell(col++).SetCellValue(dto.Publisher);
+				row.CreateCell(col++).SetCellValue(dto.HasPdf);
+				row.CreateCell(col++).SetCellValue(dto.SeriesNames);
+				row.CreateCell(col++).SetCellValue(dto.SeriesOrder);
+
+				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.PdfStatus);
+				row.CreateCell(col++).SetCellValue(dto.ContentType);
+
+				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,57 @@
+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();
+			var library = DbContexts.GetLibrary_Flat_NoTracking();
+			engine.CreateNewIndex(library);
+		}
+
+		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> func)
+		{
+			var engine = new SearchEngine();
+			try
+			{
+				return func(engine);
+			}
+			catch (FileNotFoundException)
+			{
+				FullReIndex(engine);
+				return func(engine);
+			}
+		}
+	}
+}

ApplicationServices/UNTESTED/LibraryIndexer.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using AudibleApi;
-using DtoImporterService;
-using InternalUtilities;
-
-namespace ApplicationService
-{
-	public class LibraryIndexer
-	{
-		public async Task<(int totalCount, int newCount)> IndexAsync(ILoginCallback callback)
-		{
-			var audibleApiActions = new AudibleApiActions();
-			var items = await audibleApiActions.GetAllLibraryItemsAsync(callback);
-			var totalCount = items.Count;
-
-			var libImporter = new LibraryImporter();
-			var newCount = await Task.Run(() => libImporter.Import(items));
-
-			await SearchEngineActions.FullReIndexAsync();
-
-			return (totalCount, newCount);
-		}
-	}
-}

ApplicationServices/UNTESTED/SearchEngineActions.cs

@@ -1,26 +0,0 @@
-using System.Threading.Tasks;
-using DataLayer;
-
-namespace ApplicationService
-{
-	public static class SearchEngineActions
-	{
-		public static async Task FullReIndexAsync()
-		{
-			var engine = new LibationSearchEngine.SearchEngine();
-			await engine.CreateNewIndexAsync().ConfigureAwait(false);
-		}
-
-		public static void UpdateBookTags(Book book)
-		{
-			var engine = new LibationSearchEngine.SearchEngine();
-			engine.UpdateTags(book.AudibleProductId, book.UserDefinedItem.Tags);
-		}
-
-		public static async Task ProductReIndexAsync(string productId)
-		{
-			var engine = new LibationSearchEngine.SearchEngine();
-			await engine.UpdateBookAsync(productId).ConfigureAwait(false);
-		}
-	}
-}

AudibleDotCom/AudibleDotCom.csproj

@@ -1,11 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>netstandard2.1</TargetFramework>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\FileManager\FileManager.csproj" />
-  </ItemGroup>
-
-</Project>

AudibleDotCom/UNTESTED/AudiblePage.cs

@@ -1,66 +0,0 @@
-using System;
-using System.Linq;
-using Dinah.Core;
-
-namespace AudibleDotCom
-{
-    public enum AudiblePageType
-    {
-        ProductDetails = 1,
-
-        Library = 2
-    }
-    public static class AudiblePageExt
-    {
-        public static AudiblePage GetAudiblePageRobust(this AudiblePageType audiblePage) => AudiblePage.FromPageType(audiblePage);
-    }
-
-    public abstract partial class AudiblePage : Enumeration<AudiblePage>
-    {
-        // useful for generic classes:
-        //     public abstract class PageScraper<T> where T : AudiblePageRobust {
-        //         public AudiblePage AudiblePage => AudiblePageRobust.GetAudiblePageFromType(typeof(T));
-        public static AudiblePageType GetAudiblePageFromType(Type audiblePageRobustType)
-            => (AudiblePageType)GetAll().Single(t => t.GetType() == audiblePageRobustType).Id;
-
-        public AudiblePageType AudiblePageType { get; }
-
-        protected AudiblePage(AudiblePageType audiblePage, string abbreviation) : base((int)audiblePage, abbreviation) => AudiblePageType = audiblePage;
-
-        public static AudiblePage FromPageType(AudiblePageType audiblePage) => FromValue((int)audiblePage);
-
-        /// <summary>For pages which need a param, the param is marked with {0}</summary>
-        protected abstract string Url { get; }
-        public string GetUrl(string id) => string.Format(Url, id);
-
-        public string Abbreviation => DisplayName;
-    }
-    public abstract partial class AudiblePage : Enumeration<AudiblePage>
-    {
-        public static AudiblePage Library { get; } = LibraryPage.Instance;
-        public class LibraryPage : AudiblePage
-        {
-            #region singleton stuff
-            public static LibraryPage Instance { get; } = new LibraryPage();
-            static LibraryPage() { }
-            private LibraryPage() : base(AudiblePageType.Library, "LIB") { }
-            #endregion
-
-            protected override string Url => "http://www.audible.com/lib";
-        }
-    }
-    public abstract partial class AudiblePage : Enumeration<AudiblePage>
-    {
-        public static AudiblePage Product { get; } = ProductDetailPage.Instance;
-        public class ProductDetailPage : AudiblePage
-        {
-            #region singleton stuff
-            public static ProductDetailPage Instance { get; } = new ProductDetailPage();
-            static ProductDetailPage() { }
-            private ProductDetailPage() : base(AudiblePageType.ProductDetails, "PD") { }
-            #endregion
-
-            protected override string Url => "http://www.audible.com/pd/{0}";
-        }
-    }
-}

AudibleDotCom/UNTESTED/AudiblePageSource.cs

@@ -1,43 +0,0 @@
-using FileManager;
-
-namespace AudibleDotCom
-{
-    public class AudiblePageSource
-    {
-        public AudiblePageType AudiblePage { get; }
-        public string Source { get; }
-        public string PageId { get; }
-
-        public AudiblePageSource(AudiblePageType audiblePage, string source, string pageId)
-        {
-            AudiblePage = audiblePage;
-            Source = source;
-            PageId = pageId;
-        }
-
-        /// <summary>declawed allows local file to safely be reloaded in chrome
-        /// NOTE ABOUT DECLAWED FILES
-        /// making them safer also breaks functionality
-        /// eg: previously hidden parts become visible. this changes how selenium can parse pages.
-        ///     hidden elements don't expose .Text property</summary>
-        public AudiblePageSource Declawed() => new AudiblePageSource(AudiblePage, FileUtility.Declaw(Source), PageId);
-
-        public string Serialized() => $"<!-- |{AudiblePage.GetAudiblePageRobust().Abbreviation}|{(PageId ?? "").Trim()}| -->\r\n" + Source;
-
-        public static AudiblePageSource Deserialize(string serializedSource)
-        {
-            var endOfLine1 = serializedSource.IndexOf('\n');
-
-            var parameters = serializedSource
-                .Substring(0, endOfLine1)
-                .Split('|');
-            var abbrev = parameters[1];
-            var pageId = parameters[2];
-
-            var source = serializedSource.Substring(endOfLine1 + 1);
-            var audiblePage = AudibleDotCom.AudiblePage.FromDisplayName(abbrev).AudiblePageType;
-
-            return new AudiblePageSource(audiblePage, source, pageId);
-        }
-    }
-}

AudibleDotComAutomation/AudibleDotComAutomation.csproj

@@ -1,23 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>netstandard2.1</TargetFramework>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Selenium.Support" Version="3.141.0" />
-    <PackageReference Include="Selenium.WebDriver" Version="3.141.0" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\AudibleDotCom\AudibleDotCom.csproj" />
-    <ProjectReference Include="..\CookieMonster\CookieMonster.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Update="chromedriver.exe">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-
-</Project>

AudibleDotComAutomation/UNTESTED/Page Retrievers/Abstract_SeleniumRetriever.cs

@@ -1,184 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using AudibleDotCom;
-using Dinah.Core.Humanizer;
-using OpenQA.Selenium;
-using OpenQA.Selenium.Chrome;
-using OpenQA.Selenium.Support.UI;
-
-namespace AudibleDotComAutomation
-{
-    /// <summary>browser manipulation. web driver access
-    /// browser operators. create and store web driver, browser navigation which can vary depending on whether anon or auth'd
-    /// 
-    /// this base class: is online. no auth. used for most pages. retain no chrome cookies</summary>
-    public abstract class SeleniumRetriever : IPageRetriever
-    {
-        #region // chrome driver details
-        /*
-           HIDING CHROME CONSOLE WINDOW
-           hiding chrome console window has proven to cause more headaches than it solves. here's how to do it though:
-               // can also use CreateDefaultService() overloads to specify driver path and/or file name
-               var chromeDriverService = ChromeDriverService.CreateDefaultService();
-               chromeDriverService.HideCommandPromptWindow = true;
-               return new ChromeDriver(chromeDriverService, options);
-
-           HEADLESS CHROME
-           this WOULD be how to do headless. but amazon/audible are far too tricksy about their changes and anti-scraping measures
-           which renders 'headless' mode useless
-               var options = new ChromeOptions();
-               options.AddArgument("--headless");
-
-           SPECIFYING DRIVER LOCATION
-           if continues to have trouble finding driver:
-               var driver = new ChromeDriver(@"C:\my\path\to\chromedriver\directory");
-               var chromeDriverService = ChromeDriverService.CreateDefaultService(@"C:\my\path\to\chromedriver\directory");
-         */
-        #endregion
-
-        protected IWebDriver Driver { get; }
-        Humanizer humanizer { get; } = new Humanizer();
-
-        protected SeleniumRetriever()
-        {
-            Driver = new ChromeDriver(ctorCreateChromeOptions());
-        }
-
-        /// <summary>no auth. retain no chrome cookies</summary>
-        protected virtual ChromeOptions ctorCreateChromeOptions() => new ChromeOptions();
-
-        protected async Task AudibleLinkClickAsync(IWebElement element)
-        {
-            // EACH CALL to audible should have a small random wait to reduce chances of scrape detection
-            await humanizer.Wait();
-
-            await Task.Run(() => Driver.Click(element));
-
-            await waitForSpinnerAsync();
-
-            // sometimes these clicks just take a while. add a few more seconds
-            await Task.Delay(5000);
-        }
-
-        By spinnerLocator { get; } = By.Id("library-main-overlay");
-        private async Task waitForSpinnerAsync()
-        {
-            // if loading overlay w/spinner exists: pause, wait for it to end
-
-            await Task.Delay(100);
-
-            if (Driver.FindElements(spinnerLocator).Count > 0)
-                new WebDriverWait(Driver, TimeSpan.FromSeconds(60))
-                    .Until(ExpectedConditions.InvisibilityOfElementLocated(spinnerLocator));
-        }
-
-        private bool isFirstRun = true;
-        protected virtual async Task FirstRunAsync()
-        {
-            // load with no beginning wait. then wait 7 seconds to allow for page flicker. it usually happens after ~5 seconds. can happen irrespective of login state
-            await Task.Run(() => Driver.Navigate().GoToUrl("http://www.audible.com/"));
-            await Task.Delay(7000);
-        }
-
-        public async Task<IEnumerable<AudiblePageSource>> GetPageSourcesAsync(AudiblePageType audiblePage, string pageId = null)
-        {
-            if (isFirstRun)
-            {
-                await FirstRunAsync();
-                isFirstRun = false;
-            }
-
-            await initFirstPageAsync(audiblePage, pageId);
-
-            return await processUrl(audiblePage, pageId);
-        }
-
-        private async Task initFirstPageAsync(AudiblePageType audiblePage, string pageId)
-        {
-            // EACH CALL to audible should have a small random wait to reduce chances of scrape detection
-            await humanizer.Wait();
-
-            var url = audiblePage.GetAudiblePageRobust().GetUrl(pageId);
-            await Task.Run(() => Driver.Navigate().GoToUrl(url));
-
-            await waitForSpinnerAsync();
-        }
-
-        private async Task<IEnumerable<AudiblePageSource>> processUrl(AudiblePageType audiblePage, string pageId)
-        {
-            var pageSources = new List<AudiblePageSource>();
-            do
-            {
-                pageSources.Add(new AudiblePageSource(audiblePage, Driver.PageSource, pageId));
-            }
-            while (await hasMorePagesAsync());
-
-            return pageSources;
-        }
-
-        #region has more pages
-        /// <summary>if no more pages, return false. else, navigate to next page and return true</summary>
-        private async Task<bool> hasMorePagesAsync()
-        {
-            var next = //old_hasMorePages() ??
-                new_hasMorePages();
-            if (next == null)
-                return false;
-
-            await AudibleLinkClickAsync(next);
-            return true;
-        }
-
-        private IWebElement old_hasMorePages()
-        {
-            var parentElements = Driver.FindElements(By.ClassName("adbl-page-next"));
-            if (parentElements.Count == 0)
-                return null;
-
-            var childElements = parentElements[0].FindElements(By.LinkText("NEXT"));
-            if (childElements.Count != 1)
-                return null;
-
-            return childElements[0];
-        }
-
-        // ~ oct 2017
-        private IWebElement new_hasMorePages()
-        {
-            // get all active/enabled navigation links
-            var pageNavLinks = Driver.FindElements(By.ClassName("library-load-page"));
-            if (pageNavLinks.Count == 0)
-                return null;
-
-            // get only the right chevron if active.
-            // note: there are also right chevrons which are not for wish list navigation which is why we first filter by library-load-page
-            var nextLink = pageNavLinks
-                .Where(p => p.FindElements(By.ClassName("bc-icon-chevron-right")).Count > 0)
-                .ToList(); // cut-off delayed execution
-            if (nextLink.Count == 0)
-                return null;
-
-            return nextLink.Single().FindElement(By.TagName("button"));
-        }
-        #endregion
-
-        #region IDisposable pattern
-        public void Dispose()
-        {
-            Dispose(true);
-            GC.SuppressFinalize(this);
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (disposing && Driver != null)
-            {
-                // Quit() does cleanup AND disposes
-                Driver.Quit();
-            }
-        }
-        #endregion
-    }
-}

AudibleDotComAutomation/UNTESTED/Page Retrievers/AuthSeleniumRetriever.cs

@@ -1,26 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using OpenQA.Selenium;
-
-namespace AudibleDotComAutomation
-{
-    /// <summary>for user collections: lib, WL</summary>
-    public abstract class AuthSeleniumRetriever : SeleniumRetriever
-    {
-        protected bool IsLoggedIn => GetListenerPageLink() != null;
-
-        // needed?
-        protected AuthSeleniumRetriever() : base() { }
-
-        protected IWebElement GetListenerPageLink()
-        {
-            var listenerPageElement = Driver.FindElements(By.XPath("//a[contains(@href, '/review-by-author')]"));
-            if (listenerPageElement.Count > 0)
-                return listenerPageElement[0];
-            return null;
-        }
-    }
-}

AudibleDotComAutomation/UNTESTED/Page Retrievers/BrowserlessRetriever.cs

@@ -1,130 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Net;
-using System.Threading.Tasks;
-using AudibleDotCom;
-using CookieMonster;
-using Dinah.Core;
-using Dinah.Core.Humanizer;
-
-namespace AudibleDotComAutomation
-{
-    public class BrowserlessRetriever : IPageRetriever
-    {
-        Humanizer humanizer { get; } = new Humanizer();
-
-        public async Task<IEnumerable<AudiblePageSource>> GetPageSourcesAsync(AudiblePageType audiblePage, string pageId = null)
-        {
-            switch (audiblePage)
-            {
-case AudiblePageType.Library: return await getLibraryPageSourcesAsync();
-                default: throw new NotImplementedException();
-            }
-        }
-
-        private async Task<IEnumerable<AudiblePageSource>> getLibraryPageSourcesAsync()
-        {
-            var collection = new List<AudiblePageSource>();
-
-            var cookies = await getAudibleCookiesAsync();
-
-            var currPageNum = 1;
-            bool hasMorePages;
-            do
-            {
-                // EACH CALL to audible should have a small random wait to reduce chances of scrape detection
-                await humanizer.Wait();
-
-var html = await getLibraryPageAsync(cookies, currPageNum);
-var pageSource = new AudiblePageSource(AudiblePageType.Library, html, null);
-                collection.Add(pageSource);
-
-                hasMorePages = getHasMorePages(pageSource.Source);
-
-                currPageNum++;
-            } while (hasMorePages);
-
-            return collection;
-        }
-
-        private static async Task<CookieContainer> getAudibleCookiesAsync()
-        {
-            var liveCookies = await CookiesHelper.GetLiveCookieValuesAsync();
-
-            var audibleCookies = liveCookies.Where(c
-                => c.Domain.ContainsInsensitive("audible.com")
-                || c.Domain.ContainsInsensitive("adbl")
-                || c.Domain.ContainsInsensitive("amazon.com"))
-            .ToList();
-
-            var cookies = new CookieContainer();
-            foreach (var c in audibleCookies)
-                cookies.Add(new Cookie(c.Name, c.Value, "/", c.Domain));
-
-            return cookies;
-        }
-
-        private static bool getHasMorePages(string html)
-        {
-            var doc = new HtmlAgilityPack.HtmlDocument();
-            doc.LoadHtml(html);
-
-            // final page, invalid page:
-            //   <span class="bc-button
-            //     bc-button-secondary
-            //     nextButton
-            //     bc-button-disabled">
-            // only page: ???
-            // has more pages:
-            //   <span class="bc-button
-            //     bc-button-secondary
-            //     refinementFormButton
-            //     nextButton">
-            var next_active_link = doc
-                .DocumentNode
-                .Descendants()
-                .FirstOrDefault(n =>
-                    n.HasClass("nextButton") &&
-                    !n.HasClass("bc-button-disabled"));
-
-            return next_active_link != null;
-        }
-
-        private static async Task<string> getLibraryPageAsync(CookieContainer cookies, int pageNum)
-        {
-			#region // POST example (from 2017 ajax)
-			// var destination = "https://www.audible.com/lib-ajax";
-			// var webRequest = (HttpWebRequest)WebRequest.Create(destination);
-			// webRequest.Method = "POST";
-			// webRequest.Accept = "*/*";
-			// webRequest.AllowAutoRedirect = false;
-			// webRequest.UserAgent = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0; .NET CLR 1.0.3705)";
-			// webRequest.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";
-			// webRequest.Credentials = null;
-			//
-			// webRequest.CookieContainer = new CookieContainer();
-			// webRequest.CookieContainer.Add(cookies.GetCookies(new Uri(destination)));
-			//
-			// var postData = $"progType=all&timeFilter=all&itemsPerPage={itemsPerPage}&searchTerm=&searchType=&sortColumn=&sortType=down&page={pageNum}&mode=normal&subId=&subTitle=";
-			// var data = Encoding.UTF8.GetBytes(postData);
-			// webRequest.ContentLength = data.Length;
-			// using var dataStream = webRequest.GetRequestStream();
-			// dataStream.Write(data, 0, data.Length);
-			#endregion
-
-            var destination = "https://" + $"www.audible.com/lib?purchaseDateFilter=all&programFilter=all&sortBy=PURCHASE_DATE.dsc&page={pageNum}";
-            var webRequest = (HttpWebRequest)WebRequest.Create(destination);
-            webRequest.UserAgent = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0; .NET CLR 1.0.3705)";
-
-            webRequest.CookieContainer = new CookieContainer();
-            webRequest.CookieContainer.Add(cookies.GetCookies(new Uri(destination)));
-
-            var webResponse = await webRequest.GetResponseAsync();
-            return new StreamReader(webResponse.GetResponseStream()).ReadToEnd();
-        }
-
-        public void Dispose() { }
-    }
-}

AudibleDotComAutomation/UNTESTED/Page Retrievers/ManualLoginSeleniumRetriever.cs

@@ -1,75 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using OpenQA.Selenium;
-using OpenQA.Selenium.Support.UI;
-
-namespace AudibleDotComAutomation
-{
-    /// <summary>online. get auth by logging in with provided username and password
-    /// retain no chrome cookies. enter user + pw login</summary>
-    public class ManualLoginSeleniumRetriever : AuthSeleniumRetriever
-    {
-        string _username;
-        string _password;
-        public ManualLoginSeleniumRetriever(string username, string password) : base()
-        {
-            _username = username;
-            _password = password;
-        }
-        protected override async Task FirstRunAsync()
-        {
-            await base.FirstRunAsync();
-
-            // can't extract this into AuthSeleniumRetriever ctor. can't use username/pw until prev ctors are complete
-
-            // click login link
-            await AudibleLinkClickAsync(getLoginLink());
-
-            // wait until login page loads
-            new WebDriverWait(Driver, TimeSpan.FromSeconds(60)).Until(ExpectedConditions.ElementIsVisible(By.Id("ap_email")));
-
-            // insert credentials
-            Driver
-                .FindElement(By.Id("ap_email"))
-                .SendKeys(_username);
-            Driver
-                .FindElement(By.Id("ap_password"))
-                .SendKeys(_password);
-
-            // submit
-            var submitElement
-                = Driver.FindElements(By.Id("signInSubmit")).FirstOrDefault()
-                ?? Driver.FindElement(By.Id("signInSubmit-input"));
-            await AudibleLinkClickAsync(submitElement);
-
-            // wait until audible page loads
-            new WebDriverWait(Driver, TimeSpan.FromSeconds(60))
-                .Until(d => GetListenerPageLink());
-
-            if (!IsLoggedIn)
-                throw new Exception("not logged in");
-        }
-        private IWebElement getLoginLink()
-        {
-            {
-                var loginLinkElements1 = Driver.FindElements(By.XPath("//a[contains(@href, '/signin')]"));
-                if (loginLinkElements1.Any())
-                    return loginLinkElements1[0];
-            }
-
-            //
-            // ADD ADDITIONAL ACCEPTABLE PATTERNS HERE
-            //
-            //{
-            //    var loginLinkElements2 = Driver.FindElements(By.XPath("//a[contains(@href, '/signin')]"));
-            //    if (loginLinkElements2.Any())
-            //        return loginLinkElements2[0];
-            //}
-
-            throw new NotFoundException("Cannot locate login link");
-        }
-    }
-}

AudibleDotComAutomation/UNTESTED/Page Retrievers/UserDataSeleniumRetriever.cs

@@ -1,38 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using OpenQA.Selenium.Chrome;
-
-namespace AudibleDotComAutomation
-{
-    /// <summary>online. load auth, cookies etc from user data</summary>
-    public class UserDataSeleniumRetriever : AuthSeleniumRetriever
-    {
-        public UserDataSeleniumRetriever() : base()
-        {
-            // can't extract this into AuthSeleniumRetriever ctor. can't use username/pw until prev ctors are complete
-            if (!IsLoggedIn)
-                throw new Exception("not logged in");
-        }
-
-        /// <summary>Use current user data/chrome cookies. DO NOT use if chrome is already open</summary>
-        protected override ChromeOptions ctorCreateChromeOptions()
-        {
-            var options = base.ctorCreateChromeOptions();
-
-            // load user data incl cookies. default on windows:
-            //   %LOCALAPPDATA%\Google\Chrome\User Data
-            //   C:\Users\username\AppData\Local\Google\Chrome\User Data
-            var chromeDefaultWindowsUserDataDir = System.IO.Path.Combine(
-                Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
-                "Google",
-                "Chrome",
-                "User Data");
-            options.AddArguments($"user-data-dir={chromeDefaultWindowsUserDataDir}");
-
-            return options;
-        }
-    }
-}

AudibleDotComAutomation/UNTESTED/Page Retrievers/_IPageRetriever.cs

@@ -1,12 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using AudibleDotCom;
-
-namespace AudibleDotComAutomation
-{
-    public interface IPageRetriever : IDisposable
-    {
-        Task<IEnumerable<AudiblePageSource>> GetPageSourcesAsync(AudiblePageType audiblePage, string pageId = null);
-    }
-}

AudibleDotComAutomation/UNTESTED/Selenium.Examples.cs

@@ -1,115 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Linq;
-using OpenQA.Selenium;
-using OpenQA.Selenium.Support.UI;
-
-namespace AudibleDotComAutomation.Examples
-{
-    public class SeleniumExamples
-    {
-        public IWebDriver Driver { get; set; }
-
-        IWebElement GetListenerPageLink()
-        {
-            var listenerPageElement = Driver.FindElements(By.XPath("//a[contains(@href, '/review-by-author')]"));
-            if (listenerPageElement.Count > 0)
-                return listenerPageElement[0];
-            return null;
-        }
-        void wait_examples()
-        {
-            new WebDriverWait(Driver, TimeSpan.FromSeconds(60))
-                .Until(ExpectedConditions.ElementIsVisible(By.Id("mast-member-acct-name")));
-
-            new WebDriverWait(Driver, TimeSpan.FromSeconds(60))
-                .Until(d => GetListenerPageLink());
-
-            // https://stackoverflow.com/questions/21339339/how-to-add-custom-expectedconditions-for-selenium
-            new WebDriverWait(Driver, TimeSpan.FromSeconds(60))
-                .Until((d) =>
-                {
-                    // could be refactored into OR, AND per the java selenium library
-
-                    // check 1
-                    var e1 = Driver.FindElements(By.Id("mast-member-acct-name"));
-                    if (e1.Count > 0)
-                        return e1[0];
-                    // check 2
-                    var e2 = Driver.FindElements(By.Id("header-account-info-0"));
-                    if (e2.Count > 0)
-                        return e2[0];
-                    return null;
-                });
-        }
-        void XPath_examples()
-        {
-            // <tr>
-            //   <td>1</td>
-            //   <td>2</td>
-            // </tr>
-            // <tr>
-            //   <td>3</td>
-            //   <td>4</td>
-            // </tr>
-
-            ReadOnlyCollection<IWebElement> all_tr = Driver.FindElements(By.XPath("/tr"));
-            IWebElement first_tr = Driver.FindElement(By.XPath("/tr"));
-            IWebElement second_tr = Driver.FindElement(By.XPath("/tr[2]"));
-            // beginning with a single / starts from root
-            IWebElement ERROR_not_at_root = Driver.FindElement(By.XPath("/td"));
-            // 2 slashes searches all, NOT just descendants
-            IWebElement td1 = Driver.FindElement(By.XPath("//td"));
-
-            // 2 slashes still searches all, NOT just descendants
-            IWebElement still_td1 = first_tr.FindElement(By.XPath("//td"));
-            
-            // dot operator starts from current node specified by first_tr
-            // single slash: immediate descendant
-            IWebElement td3 = first_tr.FindElement(By.XPath(
-                ".//td"));
-            // double slash: descendant at any depth
-            IWebElement td3_also = first_tr.FindElement(By.XPath(
-                "./td"));
-
-            // <input type="hidden" name="asin" value="ABCD1234">
-            IWebElement find_anywhere_in_doc = first_tr.FindElement(By.XPath(
-                "//input[@name='asin']"));
-            IWebElement find_in_subsection = first_tr.FindElement(By.XPath(
-                ".//input[@name='asin']"));
-
-            // search entire page. useful for:
-            // - RulesLocator to find something that only appears once on the page
-            // - non-list pages. eg: product details
-            var onePerPageRules = new RuleFamily
-            {
-                RowsLocator = By.XPath("/*"), // search entire page
-                Rules = new RuleSet {
-                    (row, productItem) => productItem.CustomerId = row.FindElement(By.XPath("//input[@name='cust_id']")).GetValue(),
-                    (row, productItem) => productItem.UserName = row.FindElement(By.XPath("//input[@name='user_name']")).GetValue()
-                }
-            };
-            // - applying conditionals to entire page
-            var ruleFamily = new RuleFamily
-            {
-                RowsLocator = By.XPath("//*[starts-with(@id,'adbl-library-content-row-')]"),
-                // Rules = getRuleSet()
-            };
-        }
-        #region Rules classes stubs
-        public class RuleFamily { public By RowsLocator; public IRuleClass Rules; }
-        public interface IRuleClass { }
-        public class RuleSet : IRuleClass, IEnumerable<IRuleClass>
-        {
-            public void Add(IRuleClass ruleClass) { }
-            public void Add(RuleAction action) { }
-
-            public IEnumerator<IRuleClass> GetEnumerator() => throw new NotImplementedException();
-            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => throw new NotImplementedException();
-        }
-        public delegate void RuleAction(IWebElement row, ProductItem productItem);
-        public class ProductItem { public string CustomerId; public string UserName; }
-        #endregion
-    }
-}

AudibleDotComAutomation/UNTESTED/SeleniumExt.cs

@@ -1,47 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using OpenQA.Selenium;
-using OpenQA.Selenium.Interactions;
-
-namespace AudibleDotComAutomation
-{
-    public static class IWebElementExt
-    {
-        // allows getting Text from elements even if hidden
-        // this only works on visible elements: webElement.Text
-        // http://yizeng.me/2014/04/08/get-text-from-hidden-elements-using-selenium-webdriver/#c-sharp
-        //
-        public static string GetText(this IWebElement webElement) => webElement.GetAttribute("textContent");
-
-        public static string GetValue(this IWebElement webElement) => webElement.GetAttribute("value");
-    }
-
-    public static class IWebDriverExt
-    {
-        /// <summary>Use this instead of element.Click() to ensure that the element is clicked even if it's not currently scrolled into view</summary>
-        public static void Click(this IWebDriver driver, IWebElement element)
-        {
-            // from: https://stackoverflow.com/questions/12035023/selenium-webdriver-cant-click-on-a-link-outside-the-page
-
-
-            //// this works but isn't really the same
-            //element.SendKeys(Keys.Enter);
-
-
-            //// didn't work for me
-            //new Actions(driver)
-            //    .MoveToElement(element)
-            //    .Click()
-            //    .Build()
-            //    .Perform();
-
-            driver.ScrollIntoView(element);
-            element.Click();
-        }
-        public static void ScrollIntoView(this IWebDriver driver, IWebElement element)
-            => ((IJavaScriptExecutor)driver).ExecuteScript($"window.scroll({element.Location.X}, {element.Location.Y})");
-    }
-}

AudibleUtilities/Account.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using AudibleApi;
+using AudibleApi.Authorization;
+using Dinah.Core;
+using Newtonsoft.Json;
+
+namespace AudibleUtilities
+{
+	public class Account : IUpdatable
+	{
+		public event EventHandler Updated;
+		private void update(object sender = null, EventArgs e = null)
+			=> Updated?.Invoke(this, new EventArgs());
+
+		// canonical. immutable. email or phone number
+		public string AccountId { get; }
+
+		// user-friendly, non-canonical name. mutable
+		private string _accountName;
+		public string AccountName
+		{
+			get => _accountName;
+			set
+			{
+				if (string.IsNullOrWhiteSpace(value))
+					return;
+				var v = value.Trim();
+				if (v == _accountName)
+					return;
+				_accountName = v;
+				update();
+			}
+		}
+
+		// whether to include this account when scanning libraries.
+		// technically this is an app setting; not an attribute of account. but since it's managed with accounts, it makes sense to put this exception-to-the-rule here
+		private bool _libraryScan = true;
+		public bool LibraryScan
+		{
+			get => _libraryScan;
+			set
+			{
+				if (value == _libraryScan)
+					return;
+				_libraryScan = value;
+				update();
+			}
+		}
+
+		private string _decryptKey = "";
+		/// <summary>aka: activation bytes</summary>
+		public string DecryptKey
+		{
+			get => _decryptKey;
+			set
+			{
+				var v = (value ?? "").Trim();
+				if (v == _decryptKey)
+					return;
+				_decryptKey = v;
+				update();
+			}
+		}
+
+		private Identity _identity;
+		public Identity IdentityTokens
+		{
+			get => _identity;
+			set
+			{
+				if (_identity is null && value is null)
+					return;
+
+				if (_identity != null)
+					_identity.Updated -= update;
+
+				if (value != null)
+					value.Updated += update;
+
+				_identity = value;
+				update();
+			}
+		}
+
+		[JsonIgnore]
+		public Locale Locale => IdentityTokens?.Locale;
+
+		public Account(string accountId)
+		{
+			AccountId = ArgumentValidator.EnsureNotNullOrWhiteSpace(accountId, nameof(accountId)).Trim();
+		}
+
+		public override string ToString() => $"{AccountId} - {Locale?.Name ?? "[empty]"}";
+
+		public string MaskedLogEntry => @$"AccountId={mask(AccountId)}|AccountName={mask(AccountName)}|Locale={Locale?.Name ?? "[empty]"}";
+		private static string mask(string str)
+			=> str is null ? "[null]"
+			: str == string.Empty ? "[empty]"
+			: str.ToMask();
+	}
+}

AudibleUtilities/AccountsSettings.cs

@@ -0,0 +1,142 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using AudibleApi;
+using AudibleApi.Authorization;
+using Dinah.Core;
+using Newtonsoft.Json;
+
+namespace AudibleUtilities
+{
+	// 'AccountsSettings' is intentionally NOT IEnumerable<> so that properties can be added/extended
+	// from newtonsoft (https://www.newtonsoft.com/json/help/html/SerializationGuide.htm):
+	//   .NET :  IList, IEnumerable, IList<T>, Array
+	//   JSON :  Array (properties on the collection will not be serialized)
+	public class AccountsSettings : IUpdatable
+	{
+		public event EventHandler Updated;
+		private void update(object sender = null, EventArgs e = null)
+		{
+			foreach (var account in Accounts)
+				validate(account);
+			update_no_validate();
+		}
+		private void update_no_validate() => Updated?.Invoke(this, new EventArgs());
+
+		public AccountsSettings() { }
+
+		// for some reason this will make the json instantiator use _accounts_json.set()
+		[JsonConstructor]
+		protected AccountsSettings(List<Account> accountsSettings) { }
+
+		#region Accounts
+		private List<Account> _accounts_backing = new List<Account>();
+		[JsonProperty(PropertyName = nameof(Accounts))]
+		private List<Account> _accounts_json
+		{
+			get => _accounts_backing;
+			// 'set' is only used by json deser
+			set
+			{
+				if (value is null)
+					return;
+
+				foreach (var account in value)
+					_add(account);
+
+				update_no_validate();
+			}
+		}
+		[JsonIgnore]
+		public IReadOnlyList<Account> Accounts => _accounts_json.AsReadOnly();
+		#endregion
+
+		#region de/serialize
+		public static AccountsSettings FromJson(string json)
+			=> JsonConvert.DeserializeObject<AccountsSettings>(json, Identity.GetJsonSerializerSettings());
+
+		public string ToJson(Formatting formatting = Formatting.Indented)
+			=> JsonConvert.SerializeObject(this, formatting, Identity.GetJsonSerializerSettings());
+		#endregion
+
+		// more common naming convention alias for internal collection
+		public IReadOnlyList<Account> GetAll() => Accounts;
+
+		public Account Upsert(string accountId, string locale)
+		{
+			var acct = GetAccount(accountId, locale);
+
+			if (acct != null)
+				return acct;
+
+			var l = Localization.Get(locale);
+			var id = new Identity(l);
+
+			var account = new Account(accountId) { IdentityTokens = id };
+			Add(account);
+			return account;
+		}
+
+		public void Add(Account account)
+		{
+			_add(account);
+			update_no_validate();
+		}
+
+		public void _add(Account account)
+		{
+			validate(account);
+
+			_accounts_backing.Add(account);
+			account.Updated += update;
+		}
+
+		public Account GetAccount(string accountId, string locale)
+		{
+			if (locale is null)
+				return null;
+
+			return Accounts.SingleOrDefault(a => a.AccountId == accountId && a.IdentityTokens.Locale.Name == locale);
+		}
+
+		public bool Delete(string accountId, string locale)
+		{
+			var acct = GetAccount(accountId, locale);
+			if (acct is null)
+				return false;
+			return Delete(acct);
+		}
+
+		public bool Delete(Account account)
+		{
+			if (!_accounts_backing.Contains(account))
+				return false;
+
+			account.Updated -= update;
+			var result = _accounts_backing.Remove(account);
+			update_no_validate();
+			return result;
+		}
+
+		private void validate(Account account)
+		{
+			ArgumentValidator.EnsureNotNull(account, nameof(account));
+
+			var accountId = account.AccountId;
+			var locale = account?.IdentityTokens?.Locale?.Name;
+
+			var acct = GetAccount(accountId, locale);
+
+			// new: ok
+			if (acct is null)
+				return;
+
+			// same account instance: ok
+			if (acct == account)
+				return;
+			
+			// same account id + locale, different instance: bad
+			throw new InvalidOperationException("Cannot add an account with the same account Id and Locale");
+		}
+	}
+}

AudibleUtilities/AccountsSettingsPersister.cs

@@ -0,0 +1,24 @@
+using System;
+using AudibleApi.Authorization;
+using Dinah.Core.IO;
+using Newtonsoft.Json;
+
+namespace AudibleUtilities
+{
+	public class AccountsSettingsPersister : JsonFilePersister<AccountsSettings>
+	{
+		/// <summary>Alias for Target </summary>
+		public AccountsSettings AccountsSettings => Target;
+
+		/// <summary>uses path. create file if doesn't yet exist</summary>
+		public AccountsSettingsPersister(AccountsSettings target, string path, string jsonPath = null)
+			: base(target, path, jsonPath) { }
+
+		/// <summary>load from existing file</summary>
+		public AccountsSettingsPersister(string path, string jsonPath = null)
+			: base(path, jsonPath) { }
+
+		protected override JsonSerializerSettings GetSerializerSettings()
+			=> Identity.GetJsonSerializerSettings();
+	}
+}

AudibleUtilities/ApiExtended.cs

@@ -0,0 +1,316 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using AudibleApi;
+using AudibleApi.Common;
+using Dinah.Core;
+using Polly;
+using Polly.Retry;
+
+namespace AudibleUtilities
+{
+	/// <summary>USE THIS from within Libation. It wraps the call with correct JSONPath</summary>
+	public class ApiExtended
+	{
+		public Api Api { get; private set; }
+
+		private ApiExtended(Api api) => Api = api;
+
+		/// <summary>Get api from existing tokens else login with 'eager' choice. External browser url is provided. Response can be external browser login or continuing with native api callbacks.</summary>
+		public static async Task<ApiExtended> CreateAsync(Account account, ILoginChoiceEager loginChoiceEager)
+		{
+			Serilog.Log.Logger.Information("{@DebugInfo}", new
+			{
+				LoginType = nameof(ILoginChoiceEager),
+				Account = account?.MaskedLogEntry ?? "[null]",
+				LocaleName = account?.Locale?.Name
+			});
+
+			var api = await EzApiCreator.GetApiAsync(
+				loginChoiceEager,
+				account.Locale,
+				AudibleApiStorage.AccountsSettingsFile,
+				account.GetIdentityTokensJsonPath());
+			return new ApiExtended(api);
+		}
+
+		/// <summary>Get api from existing tokens else login with native api callbacks.</summary>
+		public static async Task<ApiExtended> CreateAsync(Account account, ILoginCallback loginCallback)
+		{
+			Serilog.Log.Logger.Information("{@DebugInfo}", new
+			{
+				LoginType = nameof(ILoginCallback),
+				Account = account?.MaskedLogEntry ?? "[null]",
+				LocaleName = account?.Locale?.Name
+			});
+
+			var api = await EzApiCreator.GetApiAsync(
+				loginCallback,
+				account.Locale,
+				AudibleApiStorage.AccountsSettingsFile,
+				account.GetIdentityTokensJsonPath());
+			return new ApiExtended(api);
+		}
+
+		/// <summary>Get api from existing tokens else login with external browser</summary>
+		public static async Task<ApiExtended> CreateAsync(Account account, ILoginExternal loginExternal)
+		{
+			Serilog.Log.Logger.Information("{@DebugInfo}", new
+			{
+				LoginType = nameof(ILoginExternal),
+				Account = account?.MaskedLogEntry ?? "[null]",
+				LocaleName = account?.Locale?.Name
+			});
+
+			var api = await EzApiCreator.GetApiAsync(
+				loginExternal,
+				account.Locale,
+				AudibleApiStorage.AccountsSettingsFile,
+				account.GetIdentityTokensJsonPath());
+			return new ApiExtended(api);
+		}
+
+		/// <summary>Get api from existing tokens. Assumes you have valid login tokens. Else exception</summary>
+		public static async Task<ApiExtended> CreateAsync(Account account)
+		{
+			ArgumentValidator.EnsureNotNull(account, nameof(account));
+			ArgumentValidator.EnsureNotNull(account.Locale, nameof(account.Locale));
+
+			Serilog.Log.Logger.Information("{@DebugInfo}", new
+			{
+				AccountMaskedLogEntry = account.MaskedLogEntry
+			});
+
+			return await CreateAsync(account.AccountId, account.Locale.Name);
+		}
+
+		/// <summary>Get api from existing tokens. Assumes you have valid login tokens. Else exception</summary>
+		public static async Task<ApiExtended> CreateAsync(string username, string localeName)
+		{
+			Serilog.Log.Logger.Information("{@DebugInfo}", new
+			{
+				Username = username.ToMask(),
+				LocaleName = localeName,
+			});
+
+			var api = await EzApiCreator.GetApiAsync(
+					Localization.Get(localeName),
+					AudibleApiStorage.AccountsSettingsFile,
+					AudibleApiStorage.GetIdentityTokensJsonPath(username, localeName));
+			return new ApiExtended(api);
+		}
+
+		private static AsyncRetryPolicy policy { get; }
+			= Policy.Handle<Exception>()
+			// 2 retries == 3 total
+			.RetryAsync(2);
+
+		public Task<List<Item>> GetLibraryValidatedAsync(LibraryOptions.ResponseGroupOptions responseGroups = LibraryOptions.ResponseGroupOptions.ALL_OPTIONS, bool importEpisodes = true)
+		{
+			// bug on audible's side. the 1st time after a long absence, a query to get library will return without titles or authors. a subsequent identical query will be successful. this is true whether or not tokens are refreshed
+			// worse, this 1st dummy call doesn't seem to help:
+			//    var page = await api.GetLibraryAsync(new AudibleApi.LibraryOptions { NumberOfResultPerPage = 1, PageNumber = 1, PurchasedAfter = DateTime.Now.AddYears(-20), ResponseGroups = AudibleApi.LibraryOptions.ResponseGroupOptions.ALL_OPTIONS });
+			// i don't want to incur the cost of making a full dummy call every time because it fails sometimes
+			return policy.ExecuteAsync(() => getItemsAsync(responseGroups, importEpisodes));
+		}
+
+		private async Task<List<Item>> getItemsAsync(LibraryOptions.ResponseGroupOptions responseGroups, bool importEpisodes)
+		{
+			var items = new List<Item>();
+#if DEBUG
+//// this will not work for multi accounts
+//var library_json = "library.json";
+//library_json = System.IO.Path.GetFullPath(library_json);
+//if (System.IO.File.Exists(library_json))
+//{
+//    items = AudibleApi.Common.Converter.FromJson<List<Item>>(System.IO.File.ReadAllText(library_json));
+//}
+#endif
+
+			Serilog.Log.Logger.Debug("Begin initial library scan");
+
+			if (!items.Any())
+				items = await Api.GetAllLibraryItemsAsync(responseGroups);
+
+			Serilog.Log.Logger.Debug("Initial library scan complete. Begin episode scan");
+
+			await manageEpisodesAsync(items, importEpisodes);
+
+			Serilog.Log.Logger.Debug("Episode scan complete");
+
+#if DEBUG
+//System.IO.File.WriteAllText(library_json, AudibleApi.Common.Converter.ToJson(items));
+#endif
+
+			var validators = new List<IValidator>();
+			validators.AddRange(getValidators());
+			foreach (var v in validators)
+			{
+				var exceptions = v.Validate(items);
+				if (exceptions != null && exceptions.Any())
+					throw new AggregateException(exceptions);
+			}
+
+			return items;
+		}
+
+		#region episodes and podcasts
+		private async Task manageEpisodesAsync(List<Item> items, bool importEpisodes)
+		{
+			// add podcasts and episodes to list. If fail, don't let it de-rail the rest of the import
+			try
+			{
+				// get parents
+				var parents = items.Where(i => i.IsEpisodes).ToList();
+#if DEBUG
+//var parentsDebug = parents.Select(i => i.ToJson()).Aggregate((a, b) => $"{a}\r\n\r\n{b}");
+//System.IO.File.WriteAllText("parents.json", parentsDebug);
+#endif
+
+				if (!parents.Any())
+					return;
+
+				Serilog.Log.Logger.Information($"{parents.Count} series of shows/podcasts found");
+
+				// remove episode parents. even if the following stuff fails, these will still be removed from the collection
+				items.RemoveAll(i => i.IsEpisodes);
+
+				if (importEpisodes)
+				{
+					// add children
+					var children = await getEpisodesAsync(parents);
+					Serilog.Log.Logger.Information($"{children.Count} episodes of shows/podcasts found");
+					items.AddRange(children);
+				}
+			}
+			catch (Exception ex)
+			{
+				Serilog.Log.Logger.Error(ex, "Error adding podcasts and episodes");
+			}
+		}
+
+		private async Task<List<Item>> getEpisodesAsync(List<Item> parents)
+		{
+			var results = new List<Item>();
+
+			foreach (var parent in parents)
+			{
+				var children = await getEpisodeChildrenAsync(parent);
+
+				// actual individual episode, not the parent of a series.
+				// for now I'm keeping it inside this method since it fits the work flow, incl. importEpisodes logic
+				if (!children.Any())
+				{
+					results.Add(parent);
+					continue;
+				}
+
+				foreach (var child in children)
+				{
+					// use parent's 'DateAdded'. DateAdded is just a convenience prop for: PurchaseDate.UtcDateTime
+					child.PurchaseDate = parent.PurchaseDate;
+					// parent is essentially a series
+					child.Series = new Series[]
+					{
+						new Series
+						{
+							Asin = parent.Asin,
+							// This should properly be Single() not FirstOrDefault(), but FirstOrDefault is defensive for malformed data from audible
+							Sequence = parent.Relationships.FirstOrDefault(r => r.Asin == child.Asin).Sort.ToString(),
+							Title = parent.TitleWithSubtitle
+						}
+					};
+					// overload (read: abuse) IsEpisodes flag
+					child.Relationships = new Relationship[]
+					{
+						new Relationship
+						{
+							RelationshipToProduct = RelationshipToProduct.Child,
+							RelationshipType = RelationshipType.Episode
+						}
+					};
+				}
+
+				results.AddRange(children);
+			}
+
+			return results;
+		}
+
+		private async Task<List<Item>> getEpisodeChildrenAsync(Item parent)
+		{
+			var childrenIds = parent.Relationships
+				.Where(r => r.RelationshipToProduct == RelationshipToProduct.Child && r.RelationshipType == RelationshipType.Episode)
+				.Select(r => r.Asin)
+				.ToList();
+
+			// fetch children in batches
+			const int batchSize = 20;
+
+			var results = new List<Item>();
+
+			for (var i = 1; ; i++)
+			{
+				var idBatch = childrenIds.Skip((i - 1) * batchSize).Take(batchSize).ToList();
+				if (!idBatch.Any())
+					break;
+
+				List<Item> childrenBatch;
+				try
+				{
+					childrenBatch = await Api.GetCatalogProductsAsync(idBatch, CatalogOptions.ResponseGroupOptions.ALL_OPTIONS);
+#if DEBUG
+//var childrenBatchDebug = childrenBatch.Select(i => i.ToJson()).Aggregate((a, b) => $"{a}\r\n\r\n{b}");
+//System.IO.File.WriteAllText($"children of {parent.Asin}.json", childrenBatchDebug);
+#endif
+				}
+				catch (Exception ex)
+				{
+					Serilog.Log.Logger.Error(ex, "Error fetching batch of episodes. {@DebugInfo}", new
+					{
+						ParentId = parent.Asin,
+						ParentTitle = parent.Title,
+						BatchNumber = i,
+						ChildIdBatch = idBatch
+					});
+					throw;
+				}
+
+				Serilog.Log.Logger.Debug($"Batch {i}: {childrenBatch.Count} results");
+				// the service returned no results. probably indicates an error. stop running batches
+				if (!childrenBatch.Any())
+					break;
+
+				results.AddRange(childrenBatch);
+			}
+
+			Serilog.Log.Logger.Debug("Parent episodes/podcasts series. Children found. {@DebugInfo}", new
+			{
+				ParentId = parent.Asin,
+				ParentTitle = parent.Title,
+				ChildCount = childrenIds.Count
+			});
+
+			if (childrenIds.Count != results.Count)
+			{
+				var ex = new ApplicationException($"Mis-match: Children defined by parent={childrenIds.Count}. Children returned by batches={results.Count}");
+				Serilog.Log.Logger.Error(ex, "Quantity of series episodes defined by parent does not match quantity returned by batch fetching.");
+				throw ex;
+			}
+
+			return results;
+		}
+		#endregion
+
+		private static List<IValidator> getValidators()
+		{
+			var type = typeof(IValidator);
+			var types = AppDomain.CurrentDomain.GetAssemblies()
+				.SelectMany(s => s.GetTypes())
+				.Where(p => type.IsAssignableFrom(p) && !p.IsInterface);
+
+			return types.Select(t => Activator.CreateInstance(t) as IValidator).ToList();
+		}
+	}
+}

AudibleUtilities/AudibleApiStorage.cs

@@ -0,0 +1,47 @@
+using System;
+using System.IO;
+using LibationFileManager;
+using Newtonsoft.Json;
+
+namespace AudibleUtilities
+{
+	public static class AudibleApiStorage
+	{
+		public static string AccountsSettingsFile => Path.Combine(Configuration.Instance.LibationFiles, "AccountsSettings.json");
+
+		public static void EnsureAccountsSettingsFileExists()
+		{
+			// saves. BEWARE: this will overwrite an existing file
+			if (!File.Exists(AccountsSettingsFile))
+				_ = new AccountsSettingsPersister(new AccountsSettings(), AccountsSettingsFile);
+		}
+
+		/// <summary>If you use this, be a good citizen and DISPOSE of it</summary>
+		public static AccountsSettingsPersister GetAccountsSettingsPersister() => new AccountsSettingsPersister(AccountsSettingsFile);
+
+		public static string GetIdentityTokensJsonPath(this Account account)
+			=> GetIdentityTokensJsonPath(account.AccountId, account.Locale?.Name);
+		public static string GetIdentityTokensJsonPath(string username, string localeName)
+		{
+			var usernameSanitized = trimSurroundingQuotes(JsonConvert.ToString(username));
+			var localeNameSanitized = trimSurroundingQuotes(JsonConvert.ToString(localeName));
+
+			return $"$.Accounts[?(@.AccountId == '{usernameSanitized}' && @.IdentityTokens.LocaleName == '{localeNameSanitized}')].IdentityTokens";
+		}
+		private static string trimSurroundingQuotes(string str)
+		{
+			// SubString algo is better than .Trim("\"")
+			//   orig string  "
+			//   json string  "\""
+			// Eg:
+			//   =>           str.Trim("\"")
+			//   output       \
+			// vs
+			//   =>           str.Substring(1, str.Length - 2)
+			//   output       \"
+			// also works with surrounding single quotes
+
+			return str.Substring(1, str.Length - 2);
+		}
+	}
+}

AudibleUtilities/AudibleApiValidators.cs

@@ -1,9 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using AudibleApiDTOs;
+using AudibleApi.Common;
 
-namespace InternalUtilities
+namespace AudibleUtilities
 {
 	public interface IValidator
 	{
@@ -29,12 +29,14 @@ namespace InternalUtilities
 		{
 			var exceptions = new List<Exception>();
 
+			// a book having no authors is rare but allowed
+
 			if (items.Any(i => string.IsNullOrWhiteSpace(i.ProductId)))
 				exceptions.Add(new ArgumentException($"Collection contains item(s) with blank {nameof(Item.ProductId)}", nameof(items)));
-			if (items.Any(i => string.IsNullOrWhiteSpace(i.Title)))
-				exceptions.Add(new ArgumentException($"Collection contains item(s) with blank {nameof(Item.Title)}", nameof(items)));
-			if (items.Any(i => i.Authors is null))
-				exceptions.Add(new ArgumentException($"Collection contains item(s) with null {nameof(Item.Authors)}", nameof(items)));
+
+			// this can happen with podcast episodes
+			foreach (var i in items.Where(i => string.IsNullOrWhiteSpace(i.Title)))
+				i.Title = "[blank title]";
 
 			return exceptions;
 		}
@@ -51,9 +53,6 @@ namespace InternalUtilities
 			if (distinct.Any(s => s.CategoryName is null))
 				exceptions.Add(new ArgumentException($"Collection contains {nameof(Item.Categories)} with null {nameof(Ladder.CategoryName)}", nameof(items)));
 
-			if (items.GetCategoryPairsDistinct().Any(p => p.Length > 2))
-				exceptions.Add(new ArgumentException($"Collection contains {nameof(Item.Categories)} with wrong number of categories. Expecting 0, 1, or 2 categories per title", nameof(items)));
-
 			return exceptions;
 		}
 	}
@@ -79,9 +78,9 @@ namespace InternalUtilities
 
 			var distinct = items.GetSeriesDistinct();
 			if (distinct.Any(s => s.SeriesId is null))
-				exceptions.Add(new ArgumentException($"Collection contains {nameof(Item.Series)} with null {nameof(AudibleApiDTOs.Series.SeriesId)}", nameof(items)));
+				exceptions.Add(new ArgumentException($"Collection contains {nameof(Item.Series)} with null {nameof(Series.SeriesId)}", nameof(items)));
 			if (distinct.Any(s => s.SeriesName is null))
-				exceptions.Add(new ArgumentException($"Collection contains {nameof(Item.Series)} with null {nameof(AudibleApiDTOs.Series.SeriesName)}", nameof(items)));
+				exceptions.Add(new ArgumentException($"Collection contains {nameof(Item.Series)} with null {nameof(Series.SeriesName)}", nameof(items)));
 
 			return exceptions;
 		}

AudibleUtilities/AudibleUtilities.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="AudibleApi" Version="2.7.2.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\LibationFileManager\LibationFileManager.csproj" />
+  </ItemGroup>
+
+</Project>

AudibleUtilities/_InternalsVisible.cs

@@ -0,0 +1 @@
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(nameof(AudibleUtilities) + ".Tests")]

CookieMonster/CookieMonster.csproj

@@ -1,16 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>netstandard2.1</TargetFramework>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="System.Data.SQLite.Core" Version="1.0.112" />
-    <PackageReference Include="System.Security.Cryptography.ProtectedData" Version="4.6.0" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\FileManager\FileManager.csproj" />
-  </ItemGroup>
-
-</Project>

CookieMonster/UNTESTED/Browsers/Chrome.cs

@@ -1,66 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Data.SQLite;
-using System.IO;
-using System.Text;
-using System.Threading.Tasks;
-using FileManager;
-
-namespace CookieMonster
-{
-    internal class Chrome : IBrowser
-    {
-		public async Task<IEnumerable<CookieValue>> GetAllCookiesAsync()
-		{
-			var col = new List<CookieValue>();
-
-			var strPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), @"Google\Chrome\User Data\Default\Cookies");
-			if (!FileUtility.FileExists(strPath))
-				return col;
-
-			//
-			// IF WE GET AN ERROR HERE
-			//   then add a reference to sqlite core in the project which is ultimately calling this.
-			// a project which directly references CookieMonster doesn't need to also ref sqlite.
-			// however, for any further number of abstractions, the project needs to directly ref sqlite.
-			// eg: this will not work unless the winforms proj adds sqlite to ref.s:
-			//     LibationWinForm > AudibleDotComAutomation > CookieMonster
-			//
-			using var conn = new SQLiteConnection("Data Source=" + strPath + ";pooling=false");
-			using var cmd = conn.CreateCommand();
-			cmd.CommandText = "SELECT host_key, name, value, encrypted_value, last_access_utc, expires_utc FROM cookies;";
-
-			conn.Open();
-			using var reader = await cmd.ExecuteReaderAsync().ConfigureAwait(false);
-			while (reader.Read())
-			{
-				var host_key = reader.GetString(0);
-				var name = reader.GetString(1);
-				var value = reader.GetString(2);
-				var last_access_utc = reader.GetInt64(4);
-				var expires_utc = reader.GetInt64(5);
-
-				// https://stackoverflow.com/a/25874366
-				if (string.IsNullOrWhiteSpace(value))
-				{
-					var encrypted_value = (byte[])reader[3];
-					var decodedData = System.Security.Cryptography.ProtectedData.Unprotect(encrypted_value, null, System.Security.Cryptography.DataProtectionScope.CurrentUser);
-					value = Encoding.ASCII.GetString(decodedData);
-				}
-
-				try
-				{
-					// if something goes wrong in this step (eg: a cookie has an invalid filetime), then just skip this cookie
-					col.Add(new CookieValue { Browser = "chrome", Domain = host_key, Name = name, Value = value, LastAccess = chromeTimeToDateTimeUtc(last_access_utc), Expires = chromeTimeToDateTimeUtc(expires_utc) });
-				}
-				catch { }
-			}
-
-			return col;
-		}
-
-		// Chrome uses 1601-01-01 00:00:00 UTC as the epoch (ie the starting point for the millisecond time counter).
-		// this is the same as "FILETIME" in Win32 except FILETIME uses 100ns ticks instead of ms.
-		private static DateTime chromeTimeToDateTimeUtc(long time) => DateTime.SpecifyKind(DateTime.FromFileTime(time * 10), DateTimeKind.Utc);
-	}
-}

CookieMonster/UNTESTED/Browsers/FireFox.cs

@@ -1,61 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Data.SQLite;
-using System.IO;
-using System.Threading.Tasks;
-using FileManager;
-
-namespace CookieMonster
-{
-    internal class FireFox : IBrowser
-    {
-        public async Task<IEnumerable<CookieValue>> GetAllCookiesAsync()
-        {
-            var col = new List<CookieValue>();
-
-            string strPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), @"Mozilla\Firefox\Profiles");
-            if (!FileUtility.FileExists(strPath))
-                return col;
-            var dirs = new DirectoryInfo(strPath).GetDirectories("*.default");
-            if (dirs.Length != 1)
-                return col;
-            strPath = Path.Combine(strPath, dirs[0].Name, "cookies.sqlite");
-            if (!FileUtility.FileExists(strPath))
-                return col;
-
-            // First copy the cookie jar so that we can read the cookies from unlocked copy while FireFox is running
-            var strTemp = strPath + ".temp";
-
-            File.Copy(strPath, strTemp, true);
-
-			// Now open the temporary cookie jar and extract Value from the cookie if we find it.
-			using var conn = new SQLiteConnection("Data Source=" + strTemp + ";pooling=false");
-			using var cmd = conn.CreateCommand();
-            cmd.CommandText = "SELECT host, name, value, lastAccessed, expiry FROM moz_cookies; ";
-
-            conn.Open();
-			using var reader = await cmd.ExecuteReaderAsync().ConfigureAwait(false);
-			while (reader.Read())
-			{
-			    var host_key = reader.GetString(0);
-			    var name = reader.GetString(1);
-			    var value = reader.GetString(2);
-			    var lastAccessed = reader.GetInt32(3);
-			    var expiry = reader.GetInt32(4);
-
-			    col.Add(new CookieValue { Browser = "firefox", Domain = host_key, Name = name, Value = value, LastAccess = lastAccessedToDateTime(lastAccessed), Expires = expiryToDateTime(expiry) });
-			}
-
-            if (FileUtility.FileExists(strTemp))
-                File.Delete(strTemp);
-
-            return col;
-        }
-
-        // time is in microseconds since unix epoch
-        private static DateTime lastAccessedToDateTime(int time) => new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(time);
-
-        // time is in normal seconds since unix epoch
-        private static DateTime expiryToDateTime(int time) => new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc).AddSeconds(time);
-    }
-}

CookieMonster/UNTESTED/Browsers/IBrowser.cs

@@ -1,12 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-
-namespace CookieMonster
-{
-    internal interface IBrowser
-    {
-        Task<IEnumerable<CookieValue>> GetAllCookiesAsync();
-    }
-}

CookieMonster/UNTESTED/Browsers/InternetExplorer.cs

@@ -1,87 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace CookieMonster
-{
-    internal class InternetExplorer : IBrowser
-    {
-        public async Task<IEnumerable<CookieValue>> GetAllCookiesAsync()
-        {
-            // real locations of Windows Cookies folders
-            //
-            // Windows 7:
-            // C:\Users\username\AppData\Roaming\Microsoft\Windows\Cookies
-            // C:\Users\username\AppData\Roaming\Microsoft\Windows\Cookies\Low
-            //
-            // Windows 8, Windows 8.1, Windows 10:
-            // C:\Users\username\AppData\Local\Microsoft\Windows\INetCookies
-            // C:\Users\username\AppData\Local\Microsoft\Windows\INetCookies\Low
-
-            var strPath = Environment.GetFolderPath(Environment.SpecialFolder.Cookies);
-
-            var col = (await getIECookiesAsync(strPath).ConfigureAwait(false)).ToList();
-            col = col.Concat(await getIECookiesAsync(Path.Combine(strPath, "Low"))).ToList();
-
-            return col;
-        }
-
-        private static async Task<IEnumerable<CookieValue>> getIECookiesAsync(string strPath)
-        {
-            var cookies = new List<CookieValue>();
-
-            var files = await Task.Run(() => Directory.EnumerateFiles(strPath, "*.txt"));
-            foreach (string path in files)
-            {
-                var cookiesInFile = new List<CookieValue>();
-
-                var cookieLines = File.ReadAllLines(path);
-                CookieValue currCookieVal = null;
-                for (var i = 0; i < cookieLines.Length; i++)
-                {
-                    var line = cookieLines[i];
-
-                    // IE cookie format
-                    // 0  Cookie name
-                    // 1  Cookie value
-                    // 2  Host / path for the web server setting the cookie
-                    // 3  Flags
-                    // 4  Expiration time (low int)
-                    // 5  Expiration time (high int)
-                    // 6  Creation time (low int)
-                    // 7  Creation time (high int)
-                    // 8  Record delimiter == "*"
-                    var pos = i % 9;
-                    long expLoTemp = 0;
-                    long creatLoTemp = 0;
-                    if (pos == 0)
-                    {
-                        currCookieVal = new CookieValue { Browser = "ie", Name = line };
-                        cookiesInFile.Add(currCookieVal);
-                    }
-                    else if (pos == 1)
-                        currCookieVal.Value = line;
-                    else if (pos == 2)
-                        currCookieVal.Domain = line;
-                    else if (pos == 4)
-                        expLoTemp = Int64.Parse(line);
-                    else if (pos == 5)
-                        currCookieVal.Expires = LoHiToDateTime(expLoTemp, Int64.Parse(line));
-                    else if (pos == 6)
-                        creatLoTemp = Int64.Parse(line);
-                    else if (pos == 7)
-                        currCookieVal.LastAccess = LoHiToDateTime(creatLoTemp, Int64.Parse(line));
-                }
-
-                cookies.AddRange(cookiesInFile);
-            }
-
-            return cookies;
-        }
-
-        private static DateTime LoHiToDateTime(long lo, long hi) => DateTime.FromFileTimeUtc(((hi << 32) + lo));
-    }
-}

CookieMonster/UNTESTED/CookieValue.cs

@@ -1,32 +0,0 @@
-using System;
-
-namespace CookieMonster
-{
-    public class CookieValue
-    {
-        public string Browser { get; set; }
-
-        public string Name { get; set; }
-        public string Value { get; set; }
-        public string Domain { get; set; }
-
-        public DateTime LastAccess { get; set; }
-        public DateTime Expires { get; set; }
-
-        public bool IsValid
-        {
-            get
-            {
-                // sanity check. datetimes are stored weird in each cookie type. make sure i haven't converted these incredibly wrong.
-                // some early conversion attempts produced years like 42, 1955, 4033
-                var _5yearsPast = DateTime.UtcNow.AddYears(-5);
-                if (LastAccess < _5yearsPast || LastAccess > DateTime.UtcNow)
-                    return false;
-                // don't check expiry. some sites are setting stupid values for year. eg: 9999
-                return true;
-            }
-        }
-
-        public bool HasExpired => Expires < DateTime.UtcNow;
-    }
-}

CookieMonster/UNTESTED/CookiesHelper.cs

@@ -1,57 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using Dinah.Core.Collections.Generic;
-
-namespace CookieMonster
-{
-    public static class CookiesHelper
-    {
-        internal static IEnumerable<IBrowser> GetBrowsers()
-            => AppDomain.CurrentDomain
-                .GetAssemblies()
-                .SelectMany(s => s.GetTypes())
-                .Where(p => typeof(IBrowser).IsAssignableFrom(p) && !p.IsAbstract && !p.IsInterface)
-                .Select(t => Activator.CreateInstance(t) as IBrowser)
-                .ToList();
-
-        /// <summary>all. including expired</summary>
-        public static async Task<IEnumerable<CookieValue>> GetAllCookieValuesAsync()
-        {
-            //// foreach{await} runs in serial
-            //var allCookies = new List<CookieValue>();
-            //foreach (var b in GetBrowsers())
-            //{
-            //    var browserCookies = await b.GetAllCookiesAsync().ConfigureAwait(false);
-            //    allCookies.AddRange(browserCookies);
-            //}
-
-            //// WhenAll runs in parallel
-            // this 1st step LOOKS like a bug which runs each method until completion. However, since we don't use await, it's actually returning a Task. That resulting task is awaited asynchronously
-            var browserTasks = GetBrowsers().Select(b => b.GetAllCookiesAsync());
-            var results = await Task.WhenAll(browserTasks).ConfigureAwait(false);
-            var allCookies = results.SelectMany(a => a).ToList();
-
-            if (allCookies.Any(c => !c.IsValid))
-                throw new Exception("some date time was converted way too far");
-
-            foreach (var c in allCookies)
-                c.Domain = c.Domain.TrimEnd('/');
-
-            // for each domain+name, only keep the 1 with the most recent access
-            var sortedCookies = allCookies
-                .OrderByDescending(c => c.LastAccess)
-                .DistinctBy(c => new { c.Domain, c.Name })
-                .ToList();
-
-            return sortedCookies;
-        }
-
-        /// <summary>not expired</summary>
-        public static async Task<IEnumerable<CookieValue>> GetLiveCookieValuesAsync()
-            => (await GetAllCookieValuesAsync().ConfigureAwait(false))
-            .Where(c => !c.HasExpired)
-            .ToList();
-    }
-}

DataLayer/Configurations/LibraryBookConfig.cs

@@ -0,0 +1,32 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace DataLayer.Configurations
+{
+    internal class LibraryBookConfig : IEntityTypeConfiguration<LibraryBook>
+    {
+        public void Configure(EntityTypeBuilder<LibraryBook> entity)
+        {
+            // to allow same book (incl region) with diff acct.s:
+            //
+            // this file:
+            // - composite key:
+            //     entity.HasKey(b => new { b.BookId, b.Account });
+            //     entity.HasIndex(b => b.BookId);
+            //     entity.HasIndex(b => b.Account);
+            // - change the below relationship since Book+LibraryBook would no longer be 1:1
+            //
+            // other files:
+            // - change Book class since Book+LibraryBook would no longer be 1:1
+            // - update LibraryBook import code
+            // - would likely challenge assumptions throughout Libation which have been true up until now
+
+            entity.HasKey(b => b.BookId);
+
+            entity
+                .HasOne(le => le.Book)
+                .WithOne()
+                .HasForeignKey<LibraryBook>(le => le.BookId);
+        }
+    }
+}

DataLayer/DataLayer.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netcoreapp3.0;netstandard2.1</TargetFrameworks>
+    <TargetFramework>net6.0</TargetFramework>
   </PropertyGroup>
 
   <PropertyGroup>
@@ -12,21 +12,20 @@
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="3.0.0">
+    <PackageReference Include="Dinah.EntityFrameworkCore" Version="4.0.0.3" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="6.0.3">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="3.0.0" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="3.0.0" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="3.0.0">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="6.0.3" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="6.0.3">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
   </ItemGroup>
   
   <ItemGroup>
-    <ProjectReference Include="..\..\Dinah.Core\Dinah.EntityFrameworkCore\Dinah.EntityFrameworkCore.csproj" />
-    <ProjectReference Include="..\FileManager\FileManager.csproj" />
+    <ProjectReference Include="..\LibationFileManager\LibationFileManager.csproj" />
   </ItemGroup>
   
   <ItemGroup>