Bugfix: template validation was opposite #142

File extensions: Dinah.Core => Libation FileUtility

AaxDecrypter/AaxDecrypter.csproj

@@ -5,8 +5,12 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="AAXClean" Version="0.1.8" />
-    <PackageReference Include="Dinah.Core" Version="1.1.0.1" />
+    <PackageReference Include="AAXClean" Version="0.1.10" />
+    <PackageReference Include="Dinah.Core" Version="2.0.2.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <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/AaxcDownloadConverter.cs

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

AaxDecrypter/AaxcDownloadMultiConverter.cs

@@ -0,0 +1,146 @@
+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<string, int, int, NewSplitCallback, string> multipartFileNameCallback { get; }
+        private static string DefaultMultipartFilename(string outputFileName, int partsPosition, int partsTotal, NewSplitCallback newSplitCallback)
+        {
+            var template = Path.ChangeExtension(outputFileName, null) + " - <ch# 0> - <title>" + Path.GetExtension(outputFileName);
+
+            var fileTemplate = new FileTemplate(template) { IllegalCharacterReplacements = " " };
+            fileTemplate.AddParameterReplacement("ch# 0", FileUtility.GetSequenceFormatted(partsPosition, partsTotal));
+            fileTemplate.AddParameterReplacement("title", newSplitCallback?.Chapter?.Title ?? "");
+
+            return fileTemplate.GetFilePath();
+        }
+
+        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<string, int, int, NewSplitCallback, 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 ?? 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(OutputFileName, currentChapter, splitChapters.Count, newSplitCallback);
+            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/DownloadLicense.cs

@@ -13,15 +13,12 @@ namespace AaxDecrypter
 
         public DownloadLicense(string downloadUrl, string audibleKey, string audibleIV, string userAgent)
         {
-            ArgumentValidator.EnsureNotNullOrEmpty(downloadUrl, nameof(downloadUrl));
-            ArgumentValidator.EnsureNotNullOrEmpty(audibleKey, nameof(audibleKey));
-            ArgumentValidator.EnsureNotNullOrEmpty(audibleIV, nameof(audibleIV));
-            ArgumentValidator.EnsureNotNullOrEmpty(userAgent, nameof(userAgent));
+            DownloadUrl = ArgumentValidator.EnsureNotNullOrEmpty(downloadUrl, nameof(downloadUrl));
+            UserAgent = ArgumentValidator.EnsureNotNullOrEmpty(userAgent, nameof(userAgent));
 
-            DownloadUrl = downloadUrl;
+            // no null/empty check. unencrypted files do not have these
             AudibleKey = audibleKey;
             AudibleIV = audibleIV;
-            UserAgent = userAgent;
         }
     }
 }

AaxDecrypter/NFO.cs

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

AaxDecrypter/NetworkFileStream.cs

@@ -83,7 +83,7 @@ namespace AaxDecrypter
         private FileStream _readFile { get; }
         private Stream _networkStream { get; set; }
         private bool hasBegunDownloading { get; set; }
-        private bool isCancelled { get; set; }
+        public bool IsCancelled { get; private set; }
         private EventWaitHandle downloadEnded { get; set; } 
         private EventWaitHandle downloadedPiece { get; set; } 
 
@@ -238,7 +238,7 @@ namespace AaxDecrypter
                     downloadedPiece.Set();
                 }
 
-            } while (downloadPosition < ContentLength && !isCancelled);
+            } while (downloadPosition < ContentLength && !IsCancelled);
 
             _writeFile.Close();
             _networkStream.Close();
@@ -248,7 +248,7 @@ namespace AaxDecrypter
             downloadedPiece.Set();
             downloadEnded.Set();
 
-            if (!isCancelled && WritePosition < ContentLength)
+            if (!IsCancelled && WritePosition < ContentLength)
                 throw new WebException($"Downloaded size (0x{WritePosition:X10}) is less than {nameof(ContentLength)} (0x{ContentLength:X10}).");
 
             if (WritePosition > ContentLength)
@@ -421,12 +421,12 @@ namespace AaxDecrypter
         /// <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)) ;
+            while (requiredPosition > WritePosition && !IsCancelled && hasBegunDownloading && !downloadedPiece.WaitOne(1000)) ;
         }
 
         public override void Close()
         {
-            isCancelled = true;
+            IsCancelled = true;
 
             while (downloadEnded is not null && !downloadEnded.WaitOne(1000)) ;
 

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/AppScaffolding.csproj

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net5.0</TargetFramework>
+    <Version>6.3.2.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,363 @@
+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();
+
+			//
+			// migrations go below here
+			//
+
+			Migrations.migrate_to_v5_2_0__post_config(config);
+			Migrations.migrate_to_v5_7_1(config);
+			Migrations.migrate_to_v6_1_2(config);
+			Migrations.migrate_to_v6_2_0(config);
+			Migrations.migrate_to_v6_2_9(config);
+		}
+
+		/// <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;
+
+			// "Serilog": {
+			//   "MinimumLevel": "Information"
+			//   "WriteTo": [
+			//     {
+			//       "Name": "Console"
+			//     },
+			//     {
+			//       "Name": "File",
+			//       "Args": {
+			//         "rollingInterval": "Day",
+			//         "outputTemplate": ...
+			//       }
+			//     }
+			//   ],
+			//   "Using": [ "Dinah.Core" ],
+			//   "Enrich": [ "WithCaller" ]
+			// }
+			var serilogObj = new JObject
+			{
+				{ "MinimumLevel", "Information" },
+				{ "WriteTo", new JArray
+					{
+						new JObject { {"Name", "Console" } },
+						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
+									{ "outputTemplate", "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] (at {Caller}) {Message:lj}{NewLine}{Exception}" }
+								}
+							}
+						}
+					}
+				},
+				{ "Using", new JArray{ "Dinah.Core" } }, // dll's name, NOT namespace
+				{ "Enrich", new JArray{ "WithCaller" } },
+			};
+			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.
+			//
+			// Serilog also writes to Console so this might be asking for trouble. ie: infinite loops.
+			// SerilogTextWriter needs to be more robust and tested. Esp the Write() methods.
+			// 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 = Directory.EnumerateFiles(AudibleFileStorage.DownloadsInProgressDirectory).Count(),
+
+				AudibleFileStorage.DecryptInProgressDirectory,
+				DecryptInProgressFiles = Directory.EnumerateFiles(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
+			};
+
+		public static void migrate_to_v5_2_0__post_config(Configuration config)
+		{
+			if (!config.Exists(nameof(config.AllowLibationFixup)))
+				config.AllowLibationFixup = true;
+
+			if (!config.Exists(nameof(config.DecryptToLossy)))
+				config.DecryptToLossy = false;
+		}
+		#endregion
+
+		// add config.BadBook
+		public static void migrate_to_v5_7_1(Configuration config)
+		{
+			if (!config.Exists(nameof(config.BadBook)))
+				config.BadBook = Configuration.BadBookAction.Ask;
+		}
+
+		// add config.DownloadEpisodes , config.ImportEpisodes
+		public static void migrate_to_v6_1_2(Configuration config)
+		{
+			if (!config.Exists(nameof(config.DownloadEpisodes)))
+				config.DownloadEpisodes = true;
+
+			if (!config.Exists(nameof(config.ImportEpisodes)))
+				config.ImportEpisodes = true;
+		}
+
+		// add config.SplitFilesByChapter
+		public static void migrate_to_v6_2_0(Configuration config)
+		{
+			if (!config.Exists(nameof(config.SplitFilesByChapter)))
+				config.SplitFilesByChapter = false;
+		}
+
+		// add file naming templates
+		public static void migrate_to_v6_2_9(Configuration config)
+		{
+			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;
+		}
+	}
+}

AppScaffolding/UNSAFE_MigrationHelper.cs

@@ -6,7 +6,7 @@ using Dinah.Core;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
-namespace LibationLauncher
+namespace AppScaffolding
 {
 	/// <summary>
 	/// 
@@ -20,7 +20,7 @@ namespace LibationLauncher
 	internal static class UNSAFE_MigrationHelper
 	{
 		#region appsettings.json
-		private const string APPSETTINGS_JSON = "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);
 
@@ -61,7 +61,16 @@ namespace LibationLauncher
 				return;
 
 			var startingContents = File.ReadAllText(APPSETTINGS_JSON);
-			var jObj = JObject.Parse(startingContents);
+
+			JObject jObj;
+			try
+			{
+				jObj = JObject.Parse(startingContents);
+			}
+			catch
+			{
+				return;
+			}
 
 			action(jObj);
 
@@ -130,7 +139,16 @@ namespace LibationLauncher
 				return;
 
 			var startingContents = File.ReadAllText(SettingsJsonPath);
-			var jObj = JObject.Parse(startingContents);
+
+			JObject jObj;
+			try
+			{
+				jObj = JObject.Parse(startingContents);
+			}
+			catch
+			{
+				return;
+			}
 
 			action(jObj);
 

ApplicationServices/ApplicationServices.csproj

@@ -6,7 +6,7 @@
 
   <ItemGroup>
     <PackageReference Include="CsvHelper" Version="27.1.1" />
-    <PackageReference Include="NPOI" Version="2.5.4" />
+    <PackageReference Include="NPOI" Version="2.5.5" />
   </ItemGroup>
 
   <ItemGroup>

ApplicationServices/DbContexts.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 using DataLayer;
-using FileManager;
+using LibationFileManager;
 
 namespace ApplicationServices
 {

ApplicationServices/LibraryCommands.cs

@@ -3,10 +3,11 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using AudibleApi;
+using AudibleUtilities;
 using DataLayer;
 using Dinah.Core;
 using DtoImporterService;
-using InternalUtilities;
+using LibationFileManager;
 using Serilog;
 using static DtoImporterService.PerfLogger;
 
@@ -14,15 +15,13 @@ namespace ApplicationServices
 {
 	public static class LibraryCommands
 	{
-		private static LibraryOptions.ResponseGroupOptions LibraryResponseGroups = LibraryOptions.ResponseGroupOptions.ALL_OPTIONS;
-
-		public static async Task<List<LibraryBook>> FindInactiveBooks(Func<Account, ILoginCallback> loginCallbackFactoryFunc, List<LibraryBook> existingLibrary, params Account[] accounts)
+		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.
-			LibraryResponseGroups =
+			var libraryResponseGroups =
 				LibraryOptions.ResponseGroupOptions.ProductAttrs |
 				LibraryOptions.ResponseGroupOptions.ProductDesc |
 				LibraryOptions.ResponseGroupOptions.Relationships;
@@ -33,7 +32,7 @@ namespace ApplicationServices
 			try
 			{
 				logTime($"pre {nameof(scanAccountsAsync)} all");
-				var libraryItems = await scanAccountsAsync(loginCallbackFactoryFunc, accounts);
+				var libraryItems = await scanAccountsAsync(apiExtendedfunc, accounts, libraryResponseGroups);
 				logTime($"post {nameof(scanAccountsAsync)} all");
 
 				var totalCount = libraryItems.Count;
@@ -45,7 +44,7 @@ namespace ApplicationServices
 			}
 			catch (AudibleApi.Authentication.LoginFailedException lfEx)
 			{
-				lfEx.SaveFiles(FileManager.Configuration.Instance.LibationFiles);
+				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:
@@ -68,14 +67,13 @@ namespace ApplicationServices
 			}
 			finally
 			{
-				LibraryResponseGroups = LibraryOptions.ResponseGroupOptions.ALL_OPTIONS;
 				stop();
 				var putBreakPointHere = logOutput;
 			}
 		}
 
 		#region FULL LIBRARY scan and import
-		public static async Task<(int totalCount, int newCount)> ImportAccountAsync(Func<Account, ILoginCallback> loginCallbackFactoryFunc, params Account[] accounts)
+		public static async Task<(int totalCount, int newCount)> ImportAccountAsync(Func<Account, Task<ApiExtended>> apiExtendedfunc, params Account[] accounts)
 		{
 			logRestart();
 
@@ -85,22 +83,23 @@ namespace ApplicationServices
 			try
 			{
 				logTime($"pre {nameof(scanAccountsAsync)} all");
-				var importItems = await scanAccountsAsync(loginCallbackFactoryFunc, accounts);
+				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: New count {newCount}");
+				Log.Logger.Information($"Import complete. New count {newCount}");
 
 				return (totalCount, newCount);
 			}
 			catch (AudibleApi.Authentication.LoginFailedException lfEx)
 			{
-				lfEx.SaveFiles(FileManager.Configuration.Instance.LibationFiles);
+				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:
@@ -128,18 +127,16 @@ namespace ApplicationServices
 			}
 		}
 
-		private static async Task<List<ImportItem>> scanAccountsAsync(Func<Account, ILoginCallback> loginCallbackFactoryFunc, Account[] accounts)
+		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)
 			{
-				var callback = loginCallbackFactoryFunc(account);
-
-				// get APIs in serial, esp b/c of logins
-				var api = await AudibleApiActions.GetApiAsync(callback, account);
+				// 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(api, account));
+				tasks.Add(scanAccountAsync(apiExtended, account, libraryResponseGroups));
 			}
 
 			// import library in parallel
@@ -148,7 +145,7 @@ namespace ApplicationServices
 			return importItems;
 		}
 
-		private static async Task<List<ImportItem>> scanAccountAsync(Api api, Account account)
+		private static async Task<List<ImportItem>> scanAccountAsync(ApiExtended apiExtended, Account account, LibraryOptions.ResponseGroupOptions libraryResponseGroups)
 		{
 			ArgumentValidator.EnsureNotNull(account, nameof(account));
 
@@ -159,7 +156,7 @@ namespace ApplicationServices
 
 			logTime($"pre scanAccountAsync {account.AccountName}");
 
-			var dtoItems = await AudibleApiActions.GetLibraryValidatedAsync(api, LibraryResponseGroups);
+			var dtoItems = await apiExtended.GetLibraryValidatedAsync(libraryResponseGroups, Configuration.Instance.ImportEpisodes);
 
 			logTime($"post scanAccountAsync {account.AccountName} qty: {dtoItems.Count}");
 
@@ -193,6 +190,7 @@ namespace ApplicationServices
 
 			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)
@@ -231,6 +229,7 @@ namespace ApplicationServices
 				if (qtyChanges > 0)
 				{
 					SearchEngineCommands.UpdateLiberatedStatus(book);
+					SearchEngineCommands.UpdateBookTags(book);
 					BookUserDefinedItemCommitted?.Invoke(null, book.AudibleProductId);
 				}
 
@@ -247,7 +246,7 @@ namespace ApplicationServices
 		// must be here instead of in db layer due to AaxcExists
 		public static LiberatedStatus Liberated_Status(Book book)
 			=> book.Audio_Exists ? book.UserDefinedItem.BookStatus
-			: FileManager.AudibleFileStorage.AaxcExists(book.AudibleProductId) ? LiberatedStatus.PartialDownload
+			: AudibleFileStorage.AaxcExists(book.AudibleProductId) ? LiberatedStatus.PartialDownload
 			: LiberatedStatus.NotLiberated;
 
 		// exists here for feature predictability. It makes sense for this to be where Liberated_Status is

ApplicationServices/LibraryExporter.cs

@@ -114,7 +114,7 @@ namespace ApplicationServices
 				Publisher = a.Book.Publisher,
 				HasPdf = a.Book.HasPdf,
 				SeriesNames = a.Book.SeriesNames,
-				SeriesOrder = a.Book.SeriesLink.Any() ? a.Book.SeriesLink?.Select(sl => $"{sl.Index} : {sl.Series.Name}").Aggregate((a, b) => $"{a}, {b}") : "",
+				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,

AudibleUtilities/Account.cs

@@ -6,7 +6,7 @@ using AudibleApi.Authorization;
 using Dinah.Core;
 using Newtonsoft.Json;
 
-namespace InternalUtilities
+namespace AudibleUtilities
 {
 	public class Account : IUpdatable
 	{

AudibleUtilities/AccountsSettings.cs

@@ -6,7 +6,7 @@ using AudibleApi.Authorization;
 using Dinah.Core;
 using Newtonsoft.Json;
 
-namespace InternalUtilities
+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):

AudibleUtilities/AccountsSettingsPersister.cs

@@ -3,7 +3,7 @@ using AudibleApi.Authorization;
 using Dinah.Core.IO;
 using Newtonsoft.Json;
 
-namespace InternalUtilities
+namespace AudibleUtilities
 {
 	public class AccountsSettingsPersister : JsonFilePersister<AccountsSettings>
 	{

AudibleUtilities/ApiExtended.cs

@@ -8,38 +8,97 @@ using Dinah.Core;
 using Polly;
 using Polly.Retry;
 
-namespace InternalUtilities
+namespace AudibleUtilities
 {
-	public static class AudibleApiActions
+	/// <summary>USE THIS from within Libation. It wraps the call with correct JSONPath</summary>
+	public class ApiExtended
 	{
-		/// <summary>USE THIS from within Libation. It wraps the call with correct JSONPath</summary>
-		public static Task<Api> GetApiAsync(string username, string localeName, ILoginCallback loginCallback = null)
+		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("GetApiAsync. {@DebugInfo}", new
+			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,
 			});
-			return EzApiCreator.GetApiAsync(
-				Localization.Get(localeName),
-				AudibleApiStorage.AccountsSettingsFile,
-				AudibleApiStorage.GetIdentityTokensJsonPath(username, localeName),
-				loginCallback);
-		}
 
-		/// <summary>USE THIS from within Libation. It wraps the call with correct JSONPath</summary>
-		public static Task<Api> GetApiAsync(ILoginCallback loginCallback, Account account)
-		{
-			Serilog.Log.Logger.Information("GetApiAsync. {@DebugInfo}", new
-			{
-				Account = account?.MaskedLogEntry ?? "[null]",
-				LocaleName = account?.Locale?.Name
-			});
-			return EzApiCreator.GetApiAsync(
-				account.Locale,
-				AudibleApiStorage.AccountsSettingsFile,
-				account.GetIdentityTokensJsonPath(),
-				loginCallback);
+			var api = await EzApiCreator.GetApiAsync(
+					Localization.Get(localeName),
+					AudibleApiStorage.AccountsSettingsFile,
+					AudibleApiStorage.GetIdentityTokensJsonPath(username, localeName));
+			return new ApiExtended(api);
 		}
 
 		private static AsyncRetryPolicy policy { get; }
@@ -47,33 +106,35 @@ namespace InternalUtilities
 			// 2 retries == 3 total
 			.RetryAsync(2);
 
-		public static Task<List<Item>> GetLibraryValidatedAsync(Api api, LibraryOptions.ResponseGroupOptions responseGroups = LibraryOptions.ResponseGroupOptions.ALL_OPTIONS)
+		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 tokens are refreshed
+			// 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(api, responseGroups));
+			return policy.ExecuteAsync(() => getItemsAsync(responseGroups, importEpisodes));
 		}
 
-		private static async Task<List<Item>> getItemsAsync(Api api, LibraryOptions.ResponseGroupOptions responseGroups)
+		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
 			if (!items.Any())
-				items = await api.GetAllLibraryItemsAsync(responseGroups);
-#if DEBUG
-//System.IO.File.WriteAllText("library.json", AudibleApi.Common.Converter.ToJson(items));
-#endif
+				items = await Api.GetAllLibraryItemsAsync(responseGroups);
 
-			await manageEpisodesAsync(api, items);
+			await manageEpisodesAsync(items, importEpisodes);
+
+#if DEBUG
+//System.IO.File.WriteAllText(library_json, AudibleApi.Common.Converter.ToJson(items));
+#endif
 
 			var validators = new List<IValidator>();
 			validators.AddRange(getValidators());
@@ -88,7 +149,7 @@ namespace InternalUtilities
 		}
 
 		#region episodes and podcasts
-		private static async Task manageEpisodesAsync(Api api, List<Item> items)
+		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
@@ -109,10 +170,13 @@ namespace InternalUtilities
 				// also must happen before processing children because children abuses this flag
 				items.RemoveAll(i => i.IsEpisodes);
 
-				// add children
-				var children = await getEpisodesAsync(api, parents);
-				Serilog.Log.Logger.Information($"{children.Count} episodes of shows/podcasts found");
-				items.AddRange(children);
+				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)
 			{
@@ -120,13 +184,13 @@ namespace InternalUtilities
 			}
 		}
 
-		private static async Task<List<Item>> getEpisodesAsync(Api api, List<Item> parents)
+		private async Task<List<Item>> getEpisodesAsync(List<Item> parents)
 		{
 			var results = new List<Item>();
 
 			foreach (var parent in parents)
 			{
-				var children = await getEpisodeChildrenAsync(api, parent);
+				var children = await getEpisodeChildrenAsync(parent);
 
 				foreach (var child in children)
 				{
@@ -159,7 +223,7 @@ namespace InternalUtilities
 			return results;
 		}
 
-		private static async Task<List<Item>> getEpisodeChildrenAsync(Api api, Item parent)
+		private async Task<List<Item>> getEpisodeChildrenAsync(Item parent)
 		{
 			var childrenIds = parent.Relationships
 				.Where(r => r.RelationshipToProduct == RelationshipToProduct.Child && r.RelationshipType == RelationshipType.Episode)
@@ -180,7 +244,7 @@ namespace InternalUtilities
 				List<Item> childrenBatch;
 				try
 				{
-					childrenBatch = await api.GetCatalogProductsAsync(idBatch, CatalogOptions.ResponseGroupOptions.ALL_OPTIONS);
+					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);
@@ -222,7 +286,7 @@ namespace InternalUtilities
 
 			return results;
 		}
-#endregion
+		#endregion
 
 		private static List<IValidator> getValidators()
 		{

AudibleUtilities/AudibleApiStorage.cs

@@ -1,9 +1,9 @@
 using System;
 using System.IO;
-using FileManager;
+using LibationFileManager;
 using Newtonsoft.Json;
 
-namespace InternalUtilities
+namespace AudibleUtilities
 {
 	public static class AudibleApiStorage
 	{

AudibleUtilities/AudibleApiValidators.cs

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using AudibleApi.Common;
 
-namespace InternalUtilities
+namespace AudibleUtilities
 {
 	public interface IValidator
 	{
@@ -33,8 +33,10 @@ namespace InternalUtilities
 
 			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)));
+
+			// this can happen with podcast episodes
+			foreach (var i in items.Where(i => string.IsNullOrWhiteSpace(i.Title)))
+				i.Title = "[blank title]";
 
 			return exceptions;
 		}
@@ -76,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(AudibleApi.Common.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(AudibleApi.Common.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>net5.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="AudibleApi" Version="2.3.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")]

DataLayer/DataLayer.csproj

@@ -12,20 +12,20 @@
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="Dinah.EntityFrameworkCore" Version="1.0.5.1" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="5.0.9">
+    <PackageReference Include="Dinah.EntityFrameworkCore" Version="1.0.7.1" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="5.0.11">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="5.0.9" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="5.0.9">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="5.0.11" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="5.0.11">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
   </ItemGroup>
   
   <ItemGroup>
-    <ProjectReference Include="..\FileManager\FileManager.csproj" />
+    <ProjectReference Include="..\LibationFileManager\LibationFileManager.csproj" />
   </ItemGroup>
   
   <ItemGroup>

DataLayer/EfClasses/Book.cs

@@ -99,8 +99,8 @@ namespace DataLayer
 			Category = category;
 
             // simple assigns
-            Title = title.Trim();
-            Description = description.Trim();
+            Title = title.Trim() ?? "";
+            Description = description?.Trim() ?? "";
             LengthInMinutes = lengthInMinutes;
             ContentType = contentType;
 
@@ -203,7 +203,7 @@ namespace DataLayer
             }
         }
 
-        public void UpsertSeries(Series series, float? index = null, DbContext context = null)
+        public void UpsertSeries(Series series, string order, DbContext context = null)
         {
             ArgumentValidator.EnsureNotNull(series, nameof(series));
 
@@ -214,9 +214,9 @@ namespace DataLayer
 
 			var singleSeriesBook = _seriesLink.SingleOrDefault(sb => sb.Series == series);
             if (singleSeriesBook == null)
-                _seriesLink.Add(new SeriesBook(series, this, index));
+                _seriesLink.Add(new SeriesBook(series, this, order));
             else
-                singleSeriesBook.UpdateIndex(index);
+                singleSeriesBook.UpdateOrder(order);
         }
         #endregion
 

DataLayer/EfClasses/Series.cs

@@ -48,25 +48,6 @@ namespace DataLayer
                 Name = name;
         }
 
-        public void AddBook(Book book, float? index = null, DbContext context = null)
-        {
-            ArgumentValidator.EnsureNotNull(book, nameof(book));
-
-            // our add() is conditional upon what's already included in the collection.
-            // therefore if not loaded, a trip is required. might as well just load it
-            if (_booksLink == null)
-            {
-                ArgumentValidator.EnsureNotNull(context, nameof(context));
-                if (!context.Entry(this).IsKeySet)
-                    throw new InvalidOperationException("Could not add series");
-
-                context.Entry(this).Collection(s => s.BooksLink).Load();
-            }
-
-            if (_booksLink.SingleOrDefault(sb => sb.Book == book) == null)
-                _booksLink.Add(new SeriesBook(this, book, index));
-        }
-
 		public override string ToString() => Name;
 	}
 }

DataLayer/EfClasses/SeriesBook.cs

@@ -7,32 +7,27 @@ namespace DataLayer
         internal int SeriesId { get; private set; }
         internal int BookId { get; private set; }
 
-        /// <summary>
-        /// <para>"index" not "order". This is both for sequence and display</para>
-        /// <para>Float allows for in-between books. eg: 2.5</para>
-        /// <para>To show 2 editions as the same book in a series, give them the same index</para>
-        /// <para>null IS NOT the same as 0. Some series call a book "book 0"</para>
-        /// </summary>
-        public float? Index { get; private set; }
+        public string Order { get; private set; }
+        public float Index => StringLib.ExtractFirstNumber(Order);
 
         public Series Series { get; private set; }
         public Book Book { get; private set; }
 
         private SeriesBook() { }
-        internal SeriesBook(Series series, Book book, float? index = null)
+        internal SeriesBook(Series series, Book book, string order)
         {
             ArgumentValidator.EnsureNotNull(series, nameof(series));
             ArgumentValidator.EnsureNotNull(book, nameof(book));
 
             Series = series;
             Book = book;
-            Index = index;
+            Order = order;
         }
 
-        public void UpdateIndex(float? index)
+        public void UpdateOrder(string order)
         {
-            if (index.HasValue)
-                Index = index.Value;
+            if (!string.IsNullOrWhiteSpace(order))
+                Order = order;
         }
 
 		public override string ToString() => $"Series={Series} Book={Book}";

DataLayer/EfClasses/UserDefinedItem.cs

@@ -33,7 +33,7 @@ namespace DataLayer
 
 			// import previously saved tags
 			ArgumentValidator.EnsureNotNullOrWhiteSpace(book.AudibleProductId, nameof(book.AudibleProductId));
-			Tags = FileManager.TagsPersistence.GetTags(book.AudibleProductId);
+			Tags = LibationFileManager.TagsPersistence.GetTags(book.AudibleProductId);
 		}
 
         #region Tags
@@ -47,7 +47,7 @@ namespace DataLayer
                 if (_tags != newTags)
                 {
                     _tags = newTags;
-                    ItemChanged?.Invoke(this, nameof(Tags));
+                    OnItemChanged(nameof(Tags));
                 }
             }
 		}
@@ -106,6 +106,33 @@ namespace DataLayer
         #endregion
 
         #region LiberatedStatuses
+        /// <summary>
+        /// Occurs when <see cref="Tags"/>, <see cref="BookStatus"/>, or <see cref="PdfStatus"/> values change.
+        /// This signals the change of the in-memory value; it does not ensure that the new value has been persisted.
+        /// </summary>
+        public static event EventHandler<string> ItemChanged;
+
+        private void OnItemChanged(string e)
+        {
+            // HACK
+            // must not fire during initial import.
+            //
+            // these checks are necessary because current architecture attaches to this instead of attaching to an event *after* fully committed to db. the attached delegate/action sometimes calls commit:
+            //
+            // desired:
+            // - importing new book
+            // - update pdf status
+            // - initial book commit
+            //
+            // actual without these checks [BAD]:
+            // - importing new book
+            // - update pdf status
+            //   - invoke event
+            //   - commit UserDefinedItem
+            // - initial book commit
+            if (BookId > 0 && Book is not null && Book.BookId > 0)
+                ItemChanged?.Invoke(this, e);
+        }
 
         private LiberatedStatus _bookStatus;
         private LiberatedStatus? _pdfStatus;
@@ -117,7 +144,7 @@ namespace DataLayer
                 if (_bookStatus != value)
 				{
                     _bookStatus = value;
-                    ItemChanged?.Invoke(this, nameof(BookStatus));
+                    OnItemChanged(nameof(BookStatus));
                 }
             }
         }
@@ -129,16 +156,44 @@ namespace DataLayer
                 if (_pdfStatus != value)
                 {
                     _pdfStatus = value;
-                    ItemChanged?.Invoke(this, nameof(PdfStatus));
+                    OnItemChanged(nameof(PdfStatus));
                 }
             }
+        }
+		#endregion
+
+		#region batch changes
+		public static event EventHandler<string> Batch_ItemChanged;
+        public void BatchMode_UpdateBookStatus(LiberatedStatus value)
+        {
+            if (_bookStatus != value)
+            {
+                _bookStatus = value;
+                batchFlag = true;
+            }
+        }
+
+        // don't overwrite current with null. Therefore input is "LiberatedStatus" not "LiberatedStatus?"
+        public void BatchMode_UpdatePdfStatus(LiberatedStatus value)
+        {
+            if (_pdfStatus != value)
+            {
+                _pdfStatus = value;
+                batchFlag = true;
+            }
+        }
+
+        private static bool batchFlag = false;
+
+        public static void BatchMode_Finalize()
+        {
+            if (batchFlag)
+                Batch_ItemChanged?.Invoke(null, null);
+
+            batchFlag = false;
         }
         #endregion
-        /// <summary>
-        /// Occurs when <see cref="Tags"/>, <see cref="BookStatus"/>, or <see cref="PdfStatus"/> values change.
-        /// This signals the change of the in-memory value; it does not ensure that the new value has been persisted.
-        /// </summary>
-        public static event EventHandler<string> ItemChanged;
+
         public override string ToString() => $"{Book} {Rating} {Tags}";
 	}
 }

DataLayer/Migrations/20210922154900_AddSeriesOrderString.Designer.cs

@@ -0,0 +1,390 @@
+// <auto-generated />
+using System;
+using DataLayer;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace DataLayer.Migrations
+{
+    [DbContext(typeof(LibationContext))]
+    [Migration("20210922154900_AddSeriesOrderString")]
+    partial class AddSeriesOrderString
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "5.0.10");
+
+            modelBuilder.Entity("DataLayer.Book", b =>
+                {
+                    b.Property<int>("BookId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AudibleProductId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("CategoryId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ContentType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("DatePublished")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsAbridged")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LengthInMinutes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Locale")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PictureId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("BookId");
+
+                    b.HasIndex("AudibleProductId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.ToTable("Books");
+                });
+
+            modelBuilder.Entity("DataLayer.BookContributor", b =>
+                {
+                    b.Property<int>("BookId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ContributorId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<byte>("Order")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("BookId", "ContributorId", "Role");
+
+                    b.HasIndex("BookId");
+
+                    b.HasIndex("ContributorId");
+
+                    b.ToTable("BookContributor");
+                });
+
+            modelBuilder.Entity("DataLayer.Category", b =>
+                {
+                    b.Property<int>("CategoryId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AudibleCategoryId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ParentCategoryCategoryId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("CategoryId");
+
+                    b.HasIndex("AudibleCategoryId");
+
+                    b.HasIndex("ParentCategoryCategoryId");
+
+                    b.ToTable("Categories");
+
+                    b.HasData(
+                        new
+                        {
+                            CategoryId = -1,
+                            AudibleCategoryId = "",
+                            Name = ""
+                        });
+                });
+
+            modelBuilder.Entity("DataLayer.Contributor", b =>
+                {
+                    b.Property<int>("ContributorId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AudibleContributorId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ContributorId");
+
+                    b.HasIndex("Name");
+
+                    b.ToTable("Contributors");
+
+                    b.HasData(
+                        new
+                        {
+                            ContributorId = -1,
+                            Name = ""
+                        });
+                });
+
+            modelBuilder.Entity("DataLayer.LibraryBook", b =>
+                {
+                    b.Property<int>("BookId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Account")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("BookId");
+
+                    b.ToTable("LibraryBooks");
+                });
+
+            modelBuilder.Entity("DataLayer.Series", b =>
+                {
+                    b.Property<int>("SeriesId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AudibleSeriesId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("SeriesId");
+
+                    b.HasIndex("AudibleSeriesId");
+
+                    b.ToTable("Series");
+                });
+
+            modelBuilder.Entity("DataLayer.SeriesBook", b =>
+                {
+                    b.Property<int>("SeriesId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("BookId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Order")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("SeriesId", "BookId");
+
+                    b.HasIndex("BookId");
+
+                    b.HasIndex("SeriesId");
+
+                    b.ToTable("SeriesBook");
+                });
+
+            modelBuilder.Entity("DataLayer.Book", b =>
+                {
+                    b.HasOne("DataLayer.Category", "Category")
+                        .WithMany()
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("DataLayer.Rating", "Rating", b1 =>
+                        {
+                            b1.Property<int>("BookId")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<float>("OverallRating")
+                                .HasColumnType("REAL");
+
+                            b1.Property<float>("PerformanceRating")
+                                .HasColumnType("REAL");
+
+                            b1.Property<float>("StoryRating")
+                                .HasColumnType("REAL");
+
+                            b1.HasKey("BookId");
+
+                            b1.ToTable("Books");
+
+                            b1.WithOwner()
+                                .HasForeignKey("BookId");
+                        });
+
+                    b.OwnsMany("DataLayer.Supplement", "Supplements", b1 =>
+                        {
+                            b1.Property<int>("SupplementId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int>("BookId")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<string>("Url")
+                                .HasColumnType("TEXT");
+
+                            b1.HasKey("SupplementId");
+
+                            b1.HasIndex("BookId");
+
+                            b1.ToTable("Supplement");
+
+                            b1.WithOwner("Book")
+                                .HasForeignKey("BookId");
+
+                            b1.Navigation("Book");
+                        });
+
+                    b.OwnsOne("DataLayer.UserDefinedItem", "UserDefinedItem", b1 =>
+                        {
+                            b1.Property<int>("BookId")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int>("BookStatus")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int?>("PdfStatus")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<string>("Tags")
+                                .HasColumnType("TEXT");
+
+                            b1.HasKey("BookId");
+
+                            b1.ToTable("UserDefinedItem");
+
+                            b1.WithOwner("Book")
+                                .HasForeignKey("BookId");
+
+                            b1.OwnsOne("DataLayer.Rating", "Rating", b2 =>
+                                {
+                                    b2.Property<int>("UserDefinedItemBookId")
+                                        .HasColumnType("INTEGER");
+
+                                    b2.Property<float>("OverallRating")
+                                        .HasColumnType("REAL");
+
+                                    b2.Property<float>("PerformanceRating")
+                                        .HasColumnType("REAL");
+
+                                    b2.Property<float>("StoryRating")
+                                        .HasColumnType("REAL");
+
+                                    b2.HasKey("UserDefinedItemBookId");
+
+                                    b2.ToTable("UserDefinedItem");
+
+                                    b2.WithOwner()
+                                        .HasForeignKey("UserDefinedItemBookId");
+                                });
+
+                            b1.Navigation("Book");
+
+                            b1.Navigation("Rating");
+                        });
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Rating");
+
+                    b.Navigation("Supplements");
+
+                    b.Navigation("UserDefinedItem");
+                });
+
+            modelBuilder.Entity("DataLayer.BookContributor", b =>
+                {
+                    b.HasOne("DataLayer.Book", "Book")
+                        .WithMany("ContributorsLink")
+                        .HasForeignKey("BookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DataLayer.Contributor", "Contributor")
+                        .WithMany("BooksLink")
+                        .HasForeignKey("ContributorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Book");
+
+                    b.Navigation("Contributor");
+                });
+
+            modelBuilder.Entity("DataLayer.Category", b =>
+                {
+                    b.HasOne("DataLayer.Category", "ParentCategory")
+                        .WithMany()
+                        .HasForeignKey("ParentCategoryCategoryId");
+
+                    b.Navigation("ParentCategory");
+                });
+
+            modelBuilder.Entity("DataLayer.LibraryBook", b =>
+                {
+                    b.HasOne("DataLayer.Book", "Book")
+                        .WithOne()
+                        .HasForeignKey("DataLayer.LibraryBook", "BookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Book");
+                });
+
+            modelBuilder.Entity("DataLayer.SeriesBook", b =>
+                {
+                    b.HasOne("DataLayer.Book", "Book")
+                        .WithMany("SeriesLink")
+                        .HasForeignKey("BookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("DataLayer.Series", "Series")
+                        .WithMany("BooksLink")
+                        .HasForeignKey("SeriesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Book");
+
+                    b.Navigation("Series");
+                });
+
+            modelBuilder.Entity("DataLayer.Book", b =>
+                {
+                    b.Navigation("ContributorsLink");
+
+                    b.Navigation("SeriesLink");
+                });
+
+            modelBuilder.Entity("DataLayer.Contributor", b =>
+                {
+                    b.Navigation("BooksLink");
+                });
+
+            modelBuilder.Entity("DataLayer.Series", b =>
+                {
+                    b.Navigation("BooksLink");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

DataLayer/Migrations/20210922154900_AddSeriesOrderString.cs

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

DataLayer/Migrations/LibationContextModelSnapshot.cs

@@ -14,7 +14,7 @@ namespace DataLayer.Migrations
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "5.0.9");
+                .HasAnnotation("ProductVersion", "5.0.10");
 
             modelBuilder.Entity("DataLayer.Book", b =>
                 {
@@ -185,8 +185,8 @@ namespace DataLayer.Migrations
                     b.Property<int>("BookId")
                         .HasColumnType("INTEGER");
 
-                    b.Property<float?>("Index")
-                        .HasColumnType("REAL");
+                    b.Property<string>("Order")
+                        .HasColumnType("TEXT");
 
                     b.HasKey("SeriesId", "BookId");
 

DataLayer/TagPersistenceInterceptor.cs

@@ -24,7 +24,7 @@ namespace DataLayer
 				.Select(t => (t.Book.AudibleProductId, t.Tags))
 				.ToList();
 
-			FileManager.TagsPersistence.Save(tagsCollection);
+			LibationFileManager.TagsPersistence.Save(tagsCollection);
 		}
 	}
 }

DataLayer/Utilities/LocalDatabaseInfo.cs

@@ -1,38 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace DataLayer.Utilities
-{
-	public static class LocalDatabaseInfo
-	{
-		public static List<string> GetLocalDBInstances()
-		{
-			// Start the child process.
-			using var p = new System.Diagnostics.Process
-			{
-				StartInfo = new System.Diagnostics.ProcessStartInfo
-				{
-					UseShellExecute = false,
-					RedirectStandardOutput = true,
-					FileName = "cmd.exe",
-					Arguments = "/C sqllocaldb info",
-					CreateNoWindow = true,
-					WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden
-				}
-			};
-			p.Start();
-			var output = p.StandardOutput.ReadToEnd();
-			p.WaitForExit();
-
-			// if LocalDb is not installed then it will return that 'sqllocaldb' is not recognized as an internal or external command operable program or batch file
-			return string.IsNullOrWhiteSpace(output) || output.Contains("not recognized")
-				? new List<string>()
-				: output
-					.Split(new string[] { Environment.NewLine }, StringSplitOptions.None)
-					.Select(i => i.Trim())
-					.Where(i => !string.IsNullOrEmpty(i))
-					.ToList();
-		}
-	}
-}

DtoImporterService/BookImporter.cs

@@ -2,8 +2,8 @@
 using System.Collections.Generic;
 using System.Linq;
 using AudibleApi.Common;
+using AudibleUtilities;
 using DataLayer;
-using InternalUtilities;
 
 namespace DtoImporterService
 {
@@ -68,7 +68,7 @@ namespace DtoImporterService
 
 			foreach (var item in importItems)
 			{
-				var book = DbContext.Books.Local.SingleOrDefault(p => p.AudibleProductId == item.DtoItem.ProductId);
+				var book = DbContext.Books.Local.FirstOrDefault(p => p.AudibleProductId == item.DtoItem.ProductId);
 				if (book is null)
 				{
 					book = createNewBook(item);
@@ -164,19 +164,8 @@ namespace DtoImporterService
 			{
 				foreach (var seriesEntry in item.Series)
 				{
-					var series = DbContext.Series.Local.Single(s => seriesEntry.SeriesId == s.AudibleSeriesId);
-
-					var index = 0f;
-					try
-					{
-						index = seriesEntry.Index;
-					}
-					catch (Exception ex)
-					{
-						Serilog.Log.Logger.Error(ex, $"Error parsing series index. Title: {item.Title}. ASIN: {item.Asin}. Series index: {seriesEntry.Sequence}");
-					}
-
-					book.UpsertSeries(series, index);
+					var series = DbContext.Series.Local.FirstOrDefault(s => seriesEntry.SeriesId == s.AudibleSeriesId);
+					book.UpsertSeries(series, seriesEntry.Sequence);
 				}
 			}
 		}

DtoImporterService/CategoryImporter.cs

@@ -2,8 +2,8 @@
 using System.Collections.Generic;
 using System.Linq;
 using AudibleApi.Common;
+using AudibleUtilities;
 using DataLayer;
-using InternalUtilities;
 
 namespace DtoImporterService
 {
@@ -66,9 +66,11 @@ namespace DtoImporterService
 
 					Category parentCategory = null;
 					if (i == 1)
-						parentCategory = DbContext.Categories.Local.Single(c => c.AudibleCategoryId == pair[0].CategoryId);
+						// should be "Single()" but user is getting a strange error
+						parentCategory = DbContext.Categories.Local.FirstOrDefault(c => c.AudibleCategoryId == pair[0].CategoryId);
 
-					var category = DbContext.Categories.Local.SingleOrDefault(c => c.AudibleCategoryId == id);
+					// should be "SingleOrDefault()" but user is getting a strange error
+					var category = DbContext.Categories.Local.FirstOrDefault(c => c.AudibleCategoryId == id);
 					if (category is null)
 					{
 						category = DbContext.Categories.Add(new Category(new AudibleCategoryId(id), name)).Entity;

DtoImporterService/ContributorImporter.cs

@@ -2,8 +2,8 @@
 using System.Collections.Generic;
 using System.Linq;
 using AudibleApi.Common;
+using AudibleUtilities;
 using DataLayer;
-using InternalUtilities;
 
 namespace DtoImporterService
 {

DtoImporterService/DtoImporterService.csproj

@@ -5,8 +5,8 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\AudibleUtilities\AudibleUtilities.csproj" />
     <ProjectReference Include="..\DataLayer\DataLayer.csproj" />
-    <ProjectReference Include="..\InternalUtilities\InternalUtilities.csproj" />
   </ItemGroup>
 
 </Project>

DtoImporterService/ImportItem.cs

@@ -1,7 +1,7 @@
 using System;
 using AudibleApi.Common;
 
-namespace InternalUtilities
+namespace DtoImporterService
 {
 	public class ImportItem
 	{

DtoImporterService/ImporterBase.cs

@@ -1,9 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using AudibleUtilities;
 using DataLayer;
 using Dinah.Core;
-using InternalUtilities;
 
 namespace DtoImporterService
 {

DtoImporterService/LibraryBookImporter.cs

@@ -1,8 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using AudibleUtilities;
 using DataLayer;
-using InternalUtilities;
 
 namespace DtoImporterService
 {

DtoImporterService/SeriesImporter.cs

@@ -2,8 +2,8 @@
 using System.Collections.Generic;
 using System.Linq;
 using AudibleApi.Common;
+using AudibleUtilities;
 using DataLayer;
-using InternalUtilities;
 
 namespace DtoImporterService
 {
@@ -48,7 +48,7 @@ namespace DtoImporterService
 
 			foreach (var s in requestedSeries)
 			{
-				var series = DbContext.Series.Local.SingleOrDefault(c => c.AudibleSeriesId == s.SeriesId);
+				var series = DbContext.Series.Local.FirstOrDefault(c => c.AudibleSeriesId == s.SeriesId);
 				if (series is null)
 				{
 					series = DbContext.Series.Add(new DataLayer.Series(new AudibleSeriesId(s.SeriesId))).Entity;

FileLiberator/AudioDecodable.cs

@@ -0,0 +1,44 @@
+using System;
+
+namespace FileLiberator
+{
+    public abstract class AudioDecodable : Processable
+    {
+        public event EventHandler<Action<byte[]>> RequestCoverArt;
+        public event EventHandler<string> TitleDiscovered;
+        public event EventHandler<string> AuthorsDiscovered;
+        public event EventHandler<string> NarratorsDiscovered;
+        public event EventHandler<byte[]> CoverImageDiscovered;
+        public abstract void Cancel();
+
+        protected void OnRequestCoverArt(Action<byte[]> setCoverArtDel)
+		{
+            Serilog.Log.Logger.Debug("Event fired {@DebugInfo}", new { Name = nameof(RequestCoverArt) });
+            RequestCoverArt?.Invoke(this, setCoverArtDel);
+        }
+
+        protected void OnTitleDiscovered(string title)
+		{
+            Serilog.Log.Logger.Debug("Event fired {@DebugInfo}", new { Name = nameof(TitleDiscovered), Title = title });
+            TitleDiscovered?.Invoke(this, title);
+		}
+
+        protected void OnAuthorsDiscovered(string authors)
+		{
+            Serilog.Log.Logger.Debug("Event fired {@DebugInfo}", new { Name = nameof(AuthorsDiscovered), Authors = authors });
+            AuthorsDiscovered?.Invoke(this, authors);
+		}
+
+        protected void OnNarratorsDiscovered(string narrators)
+		{
+            Serilog.Log.Logger.Debug("Event fired {@DebugInfo}", new { Name = nameof(NarratorsDiscovered), Narrators = narrators });
+            NarratorsDiscovered?.Invoke(this, narrators);
+		}
+
+        protected void OnCoverImageDiscovered(byte[] coverImage)
+		{
+            Serilog.Log.Logger.Debug("Event fired {@DebugInfo}", new { Name = nameof(CoverImageDiscovered), CoverImageBytes = coverImage?.Length });
+            CoverImageDiscovered?.Invoke(this, coverImage);
+        }
+    }
+}

FileLiberator/AudioFileStorageExt.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using DataLayer;
+using Dinah.Core;
+using FileManager;
+using LibationFileManager;
+
+namespace FileLiberator
+{
+    public static class AudioFileStorageExt
+    {
+        private static void AddParameterReplacement(this FileTemplate fileTemplate, TemplateTags templateTags, object value)
+            => fileTemplate.AddParameterReplacement(templateTags.TagName, value);
+
+        internal class MultipartRenamer
+        {
+            public LibraryBook libraryBook { get; }
+
+            public MultipartRenamer(LibraryBook libraryBook) => this.libraryBook = libraryBook;
+
+            internal string MultipartFilename(string outputFileName, int partsPosition, int partsTotal, AAXClean.NewSplitCallback newSplitCallback)
+                => MultipartFilename(Configuration.Instance.ChapterFileTemplate, AudibleFileStorage.DecryptInProgressDirectory, Path.GetExtension(outputFileName), partsPosition, partsTotal, newSplitCallback?.Chapter?.Title ?? "");
+
+            internal string MultipartFilename(string template, string fullDirPath, string extension, int partsPosition, int partsTotal, string chapterTitle)
+            {
+                var fileTemplate = GetFileTemplateSingle(template, libraryBook, fullDirPath, extension);
+
+                fileTemplate.AddParameterReplacement(TemplateTags.ChCount, partsTotal);
+                fileTemplate.AddParameterReplacement(TemplateTags.ChNumber, partsPosition);
+                fileTemplate.AddParameterReplacement(TemplateTags.ChNumber0, FileUtility.GetSequenceFormatted(partsPosition, partsTotal));
+                fileTemplate.AddParameterReplacement(TemplateTags.ChTitle, chapterTitle);
+
+                return fileTemplate.GetFilePath();
+            }
+        }
+
+        public static Func<string, int, int, AAXClean.NewSplitCallback, string> CreateMultipartRenamerFunc(this AudioFileStorage _, LibraryBook libraryBook)
+            => new MultipartRenamer(libraryBook).MultipartFilename;
+
+        public static string GetInProgressFilename(this AudioFileStorage _, LibraryBook libraryBook, string extension)
+            => GetCustomDirFilename(_, libraryBook, AudibleFileStorage.DecryptInProgressDirectory, extension);
+
+        public static string GetBooksDirectoryFilename(this AudioFileStorage _, LibraryBook libraryBook, string extension)
+            => GetCustomDirFilename(_, libraryBook, AudibleFileStorage.BooksDirectory, extension);
+
+        public static string GetDestinationDirectory(this AudioFileStorage _, LibraryBook libraryBook)
+            => GetFileTemplateSingle(Configuration.Instance.FolderTemplate, libraryBook, AudibleFileStorage.BooksDirectory, null)
+            .GetFilePath();
+
+        public static string GetCustomDirFilename(this AudioFileStorage _, LibraryBook libraryBook, string dirFullPath, string extension)
+            => GetFileTemplateSingle(Configuration.Instance.FileTemplate, libraryBook, dirFullPath, extension)
+            .GetFilePath();
+
+        internal static FileTemplate GetFileTemplateSingle(string template, LibraryBook libraryBook, string dirFullPath, string extension)
+        {
+            ArgumentValidator.EnsureNotNullOrWhiteSpace(template, nameof(template));
+            ArgumentValidator.EnsureNotNull(libraryBook, nameof(libraryBook));
+            ArgumentValidator.EnsureNotNullOrWhiteSpace(dirFullPath, nameof(dirFullPath));
+
+            var fullfilename = Path.Combine(dirFullPath, template + FileUtility.GetStandardizedExtension(extension));
+            var fileTemplate = new FileTemplate(fullfilename) { IllegalCharacterReplacements = "_" };
+
+            var title = libraryBook.Book.Title ?? "";
+
+            fileTemplate.AddParameterReplacement(TemplateTags.Id, libraryBook.Book.AudibleProductId);
+            fileTemplate.AddParameterReplacement(TemplateTags.Title, title);
+            fileTemplate.AddParameterReplacement(TemplateTags.TitleShort, title.IndexOf(':') < 1 ? title : title.Substring(0, title.IndexOf(':')));
+            fileTemplate.AddParameterReplacement(TemplateTags.Author, libraryBook.Book.AuthorNames);
+            fileTemplate.AddParameterReplacement(TemplateTags.FirstAuthor, libraryBook.Book.Authors.FirstOrDefault()?.Name);
+            fileTemplate.AddParameterReplacement(TemplateTags.Narrator, libraryBook.Book.NarratorNames);
+            fileTemplate.AddParameterReplacement(TemplateTags.FirstNarrator, libraryBook.Book.Narrators.FirstOrDefault()?.Name);
+
+            var seriesLink = libraryBook.Book.SeriesLink.FirstOrDefault();
+            fileTemplate.AddParameterReplacement(TemplateTags.Series, seriesLink?.Series.Name);
+            fileTemplate.AddParameterReplacement(TemplateTags.SeriesNumber, seriesLink?.Order);
+
+            return fileTemplate;
+        }
+    }
+}

FileLiberator/ConvertToMp3.cs

@@ -1,51 +1,36 @@
-using AAXClean;
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using AAXClean;
 using DataLayer;
 using Dinah.Core;
 using Dinah.Core.ErrorHandling;
-using Dinah.Core.IO;
 using Dinah.Core.Net.Http;
 using FileManager;
-using System;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
+using LibationFileManager;
 
 namespace FileLiberator
 {
-    public class ConvertToMp3 : IAudioDecodable
+    public class ConvertToMp3 : AudioDecodable
     {
-
         private Mp4File m4bBook;
 
-		public event EventHandler<TimeSpan> StreamingTimeRemaining;
-		public event EventHandler<Action<byte[]>> RequestCoverArt;
-		public event EventHandler<string> TitleDiscovered;
-		public event EventHandler<string> AuthorsDiscovered;
-		public event EventHandler<string> NarratorsDiscovered;
-		public event EventHandler<byte[]> CoverImageDiscovered;
-		public event EventHandler<string> StreamingBegin;
-		public event EventHandler<DownloadProgress> StreamingProgressChanged;
-		public event EventHandler<string> StreamingCompleted;
-		public event EventHandler<LibraryBook> Begin;
-		public event EventHandler<string> StatusUpdate;
-		public event EventHandler<LibraryBook> Completed;
+		private long fileSize;
+        private static string Mp3FileName(string m4bPath) => Path.ChangeExtension(m4bPath ?? "", ".mp3");
 
-        private long fileSize;
-		private string Mp3FileName(string m4bPath) => m4bPath is null ? string.Empty : PathLib.ReplaceExtension(m4bPath, ".mp3");
+        public override void Cancel() => m4bBook?.Cancel();
 
-        public void Cancel() => m4bBook?.Cancel();
-
-        public bool Validate(LibraryBook libraryBook)
+        public override bool Validate(LibraryBook libraryBook)
         {
             var path = AudibleFileStorage.Audio.GetPath(libraryBook.Book.AudibleProductId);
             return path?.ToLower()?.EndsWith(".m4b") == true && !File.Exists(Mp3FileName(path));
         }
 
-        public async Task<StatusHandler> ProcessAsync(LibraryBook libraryBook)
+        public override async Task<StatusHandler> ProcessAsync(LibraryBook libraryBook)
         {
-            Begin?.Invoke(this, libraryBook);
+            OnBegin(libraryBook);
 
-            StreamingBegin?.Invoke(this, $"Begin converting {libraryBook} to mp3");
+            OnStreamingBegin($"Begin converting {libraryBook} to mp3");
 
             try
             {
@@ -55,10 +40,10 @@ namespace FileLiberator
 
                 fileSize = m4bBook.InputStream.Length;
 
-                TitleDiscovered?.Invoke(this, m4bBook.AppleTags.Title);
-                AuthorsDiscovered?.Invoke(this, m4bBook.AppleTags.FirstAuthor);
-                NarratorsDiscovered?.Invoke(this, m4bBook.AppleTags.Narrator);
-                CoverImageDiscovered?.Invoke(this, m4bBook.AppleTags.Cover);
+                OnTitleDiscovered(m4bBook.AppleTags.Title);
+                OnAuthorsDiscovered(m4bBook.AppleTags.FirstAuthor);
+                OnNarratorsDiscovered(m4bBook.AppleTags.Narrator);
+                OnCoverImageDiscovered(m4bBook.AppleTags.Cover);
 
                 using var mp3File = File.OpenWrite(Path.GetTempFileName());
 
@@ -66,9 +51,9 @@ namespace FileLiberator
                 m4bBook.InputStream.Close();
                 mp3File.Close();
 
-                var mp3Path = Mp3FileName(m4bPath);
-
-                FileExt.SafeMove(mp3File.Name, mp3Path);
+                var proposedMp3Path = Mp3FileName(m4bPath);
+                var realMp3Path = FileUtility.SaferMoveToValidPath(mp3File.Name, proposedMp3Path);
+                OnFileCreated(libraryBook, realMp3Path);
 
                 var statusHandler = new StatusHandler();
 
@@ -79,8 +64,8 @@ namespace FileLiberator
             }
             finally
             {
-                StreamingCompleted?.Invoke(this, $"Completed converting to mp3: {libraryBook.Book.Title}");
-                Completed?.Invoke(this, libraryBook);
+                OnStreamingCompleted($"Completed converting to mp3: {libraryBook.Book.Title}");
+                OnCompleted(libraryBook);
             }
         }
 
@@ -91,11 +76,11 @@ namespace FileLiberator
             double estTimeRemaining = remainingSecsToProcess / e.ProcessSpeed;
 
             if (double.IsNormal(estTimeRemaining))
-                StreamingTimeRemaining?.Invoke(this, TimeSpan.FromSeconds(estTimeRemaining));
+                OnStreamingTimeRemaining(TimeSpan.FromSeconds(estTimeRemaining));
 
             double progressPercent = 100 * e.ProcessPosition.TotalSeconds / duration.TotalSeconds;
 
-            StreamingProgressChanged?.Invoke(this,
+            OnStreamingProgressChanged(
                 new DownloadProgress
                 {
                     ProgressPercentage = progressPercent,

FileLiberator/DownloadDecryptBook.cs

@@ -8,48 +8,66 @@ using AudibleApi;
 using DataLayer;
 using Dinah.Core;
 using Dinah.Core.ErrorHandling;
-using Dinah.Core.Net.Http;
 using FileManager;
+using LibationFileManager;
 
 namespace FileLiberator
 {
-    public class DownloadDecryptBook : IAudioDecodable
+    public class DownloadDecryptBook : AudioDecodable
     {
+        private AudiobookDownloadBase abDownloader;
 
-        private AaxcDownloadConverter aaxcDownloader;
+        public override bool Validate(LibraryBook libraryBook) => !libraryBook.Book.Audio_Exists;
 
-        public event EventHandler<TimeSpan> StreamingTimeRemaining;
-        public event EventHandler<Action<byte[]>> RequestCoverArt;
-        public event EventHandler<string> TitleDiscovered;
-        public event EventHandler<string> AuthorsDiscovered;
-        public event EventHandler<string> NarratorsDiscovered;
-        public event EventHandler<byte[]> CoverImageDiscovered;
-        public event EventHandler<string> StreamingBegin;
-        public event EventHandler<DownloadProgress> StreamingProgressChanged;
-        public event EventHandler<string> StreamingCompleted;
-        public event EventHandler<LibraryBook> Begin;
-        public event EventHandler<string> StatusUpdate;
-        public event EventHandler<LibraryBook> Completed;
+        public override void Cancel() => abDownloader?.Cancel();
 
-        public async Task<StatusHandler> ProcessAsync(LibraryBook libraryBook)
+        public override async Task<StatusHandler> ProcessAsync(LibraryBook libraryBook)
         {
-            Begin?.Invoke(this, libraryBook);
+            var entries = new List<FilePathCache.CacheEntry>();
+            // these only work so minimally b/c CacheEntry is a record.
+            // in case of parallel decrypts, only capture the ones for this book id.
+            // if user somehow starts multiple decrypts of the same book in parallel: on their own head be it
+            void FilePathCache_Inserted(object sender, FilePathCache.CacheEntry e)
+            {
+                if (e.Id.EqualsInsensitive(libraryBook.Book.AudibleProductId))
+                    entries.Add(e);
+            }
+            void FilePathCache_Removed(object sender, FilePathCache.CacheEntry e)
+            {
+                if (e.Id.EqualsInsensitive(libraryBook.Book.AudibleProductId))
+                    entries.Remove(e);
+            }
+
+            OnBegin(libraryBook);
 
             try
             {
                 if (libraryBook.Book.Audio_Exists)
                     return new StatusHandler { "Cannot find decrypt. Final audio file already exists" };
 
-                var outputAudioFilename = await aaxToM4bConverterDecryptAsync(AudibleFileStorage.DownloadsInProgress, AudibleFileStorage.DecryptInProgress, libraryBook);
+                bool success = false;
+                try
+                {
+                    FilePathCache.Inserted += FilePathCache_Inserted;
+                    FilePathCache.Removed += FilePathCache_Removed;
+
+                    success = await downloadAudiobookAsync(libraryBook);
+                }
+                finally
+                {
+                    FilePathCache.Inserted -= FilePathCache_Inserted;
+                    FilePathCache.Removed -= FilePathCache_Removed;
+                }
 
                 // decrypt failed
-                if (outputAudioFilename is null)
+                if (!success)
                     return new StatusHandler { "Decrypt failed" };
 
-                // moves files and returns dest dir
-                var moveResults = MoveFilesToBooksDir(libraryBook.Book, outputAudioFilename);
+                // moves new files from temp dir to final dest
+                var movedAudioFile = moveFilesToBooksDir(libraryBook, entries);
 
-                if (!moveResults.movedAudioFile)
+                // decrypt failed
+                if (!movedAudioFile)
                     return new StatusHandler { "Cannot find final audio file after decryption" };
 
                 libraryBook.Book.UserDefinedItem.BookStatus = LiberatedStatus.Liberated;
@@ -58,150 +76,75 @@ namespace FileLiberator
             }
             finally
             {
-                Completed?.Invoke(this, libraryBook);
+                OnCompleted(libraryBook);
             }
         }
 
-        private async Task<string> aaxToM4bConverterDecryptAsync(string cacheDir, string destinationDir, LibraryBook libraryBook)
+        private async Task<bool> downloadAudiobookAsync(LibraryBook libraryBook)
         {
-            StreamingBegin?.Invoke(this, $"Begin decrypting {libraryBook}");
+            OnStreamingBegin($"Begin decrypting {libraryBook}");
 
             try
             {
-                validate(libraryBook);
-
-                var api = await InternalUtilities.AudibleApiActions.GetApiAsync(libraryBook.Account, libraryBook.Book.Locale);
+                downloadValidation(libraryBook);
 
+                var api = await libraryBook.GetApiAsync();
                 var contentLic = await api.GetDownloadLicenseAsync(libraryBook.Book.AudibleProductId);
 
-                var aaxcDecryptDlLic = new DownloadLicense
+                var audiobookDlLic = new DownloadLicense
                     (
                     contentLic?.ContentMetadata?.ContentUrl?.OfflineUrl,
                     contentLic?.Voucher?.Key,
                     contentLic?.Voucher?.Iv,
-                    Resources.UserAgent
+                    Resources.USER_AGENT
                     );
 
-                if (Configuration.Instance.AllowLibationFixup)
+                //I assume if ContentFormat == "MPEG" that the delivered file is an unencrypted mp3.
+                //I also assume that if DrmType != Adrm, the file will be an mp3.
+                //These assumptions may be wrong, and only time and bug reports will tell.
+                var outputFormat = 
+                    contentLic.ContentMetadata.ContentReference.ContentFormat == "MPEG" ||
+                    (Configuration.Instance.AllowLibationFixup && Configuration.Instance.DecryptToLossy) ? 
+                    OutputFormat.Mp3 : OutputFormat.M4b;
+
+                if (Configuration.Instance.AllowLibationFixup || outputFormat == OutputFormat.Mp3)
                 {
-                    aaxcDecryptDlLic.ChapterInfo = new AAXClean.ChapterInfo();
+                    audiobookDlLic.ChapterInfo = new AAXClean.ChapterInfo();
 
                     foreach (var chap in contentLic.ContentMetadata?.ChapterInfo?.Chapters)
-                        aaxcDecryptDlLic.ChapterInfo.AddChapter(chap.Title, TimeSpan.FromMilliseconds(chap.LengthMs));
+                        audiobookDlLic.ChapterInfo.AddChapter(chap.Title, TimeSpan.FromMilliseconds(chap.LengthMs));
                 }
 
+                var outFileName = AudibleFileStorage.Audio.GetInProgressFilename(libraryBook, outputFormat.ToString().ToLower());
 
-                var format = Configuration.Instance.DecryptToLossy ? OutputFormat.Mp3 : OutputFormat.Mp4a;
+                var cacheDir = AudibleFileStorage.DownloadsInProgressDirectory;
 
-                var extension = format switch
-                {
-                    OutputFormat.Mp4a => "m4b",
-                    OutputFormat.Mp3 => "mp3",
-                    _ => throw new NotImplementedException(),
-                };
-
-                var outFileName = Path.Combine(destinationDir, $"{PathLib.ToPathSafeString(libraryBook.Book.Title)} [{libraryBook.Book.AudibleProductId}].{extension}");
-
-
-                aaxcDownloader = new AaxcDownloadConverter(outFileName, cacheDir, aaxcDecryptDlLic, format) { AppName = "Libation" };
-                aaxcDownloader.DecryptProgressUpdate += (s, progress) => StreamingProgressChanged?.Invoke(this, progress);
-                aaxcDownloader.DecryptTimeRemaining += (s, remaining) => StreamingTimeRemaining?.Invoke(this, remaining);
-                aaxcDownloader.RetrievedCoverArt += AaxcDownloader_RetrievedCoverArt;
-                aaxcDownloader.RetrievedTags += aaxcDownloader_RetrievedTags;
+                abDownloader
+                    = contentLic.DrmType != AudibleApi.Common.DrmType.Adrm ? new UnencryptedAudiobookDownloader(outFileName, cacheDir, audiobookDlLic)
+                    : Configuration.Instance.SplitFilesByChapter ? new AaxcDownloadMultiConverter(
+                        outFileName, cacheDir, audiobookDlLic, outputFormat,
+                        AudibleFileStorage.Audio.CreateMultipartRenamerFunc(libraryBook)
+                        )
+                    : new AaxcDownloadSingleConverter(outFileName, cacheDir, audiobookDlLic, outputFormat);
+                abDownloader.DecryptProgressUpdate += (_, progress) => OnStreamingProgressChanged(progress);
+                abDownloader.DecryptTimeRemaining += (_, remaining) => OnStreamingTimeRemaining(remaining);
+                abDownloader.RetrievedTitle += (_, title) => OnTitleDiscovered(title);
+                abDownloader.RetrievedAuthors += (_, authors) => OnAuthorsDiscovered(authors);
+                abDownloader.RetrievedNarrators += (_, narrators) => OnNarratorsDiscovered(narrators);
+                abDownloader.RetrievedCoverArt += AaxcDownloader_RetrievedCoverArt;
+                abDownloader.FileCreated += (_, path) => OnFileCreated(libraryBook, path);
 
                 // REAL WORK DONE HERE
-                var success = await Task.Run(() => aaxcDownloader.Run());
-
-                // decrypt failed
-                if (!success)
-                    return null;
-
-                return outFileName;
+                var success = await Task.Run(abDownloader.Run);
+                return success;
             }
             finally
             {
-                StreamingCompleted?.Invoke(this, $"Completed downloading and decrypting {libraryBook.Book.Title}");
+                OnStreamingCompleted($"Completed downloading and decrypting {libraryBook.Book.Title}");
             }
         }
 
-
-        private void AaxcDownloader_RetrievedCoverArt(object sender, byte[] e)
-        {
-            if (e is null && Configuration.Instance.AllowLibationFixup)
-            {
-                RequestCoverArt?.Invoke(this, aaxcDownloader.SetCoverArt);
-            }
-
-            if (e is not null)
-            {
-                CoverImageDiscovered?.Invoke(this, e);
-            }
-        }
-
-        private void aaxcDownloader_RetrievedTags(object sender, AAXClean.AppleTags e)
-        {
-            TitleDiscovered?.Invoke(this, e.TitleSansUnabridged);
-            AuthorsDiscovered?.Invoke(this, e.FirstAuthor ?? "[unknown]");
-            NarratorsDiscovered?.Invoke(this, e.Narrator ?? "[unknown]");
-        }
-
-        private static (string destinationDir, bool movedAudioFile) MoveFilesToBooksDir(Book product, string outputAudioFilename)
-        {
-            // create final directory. move each file into it. MOVE AUDIO FILE LAST
-            // new dir: safetitle_limit50char + " [" + productId + "]"
-
-            var destinationDir = AudibleFileStorage.Audio.GetDestDir(product.Title, product.AudibleProductId);
-            Directory.CreateDirectory(destinationDir);
-
-            var sortedFiles = getProductFilesSorted(product, outputAudioFilename);
-
-            var musicFileExt = Path.GetExtension(outputAudioFilename).Trim('.');
-
-            // audio filename: safetitle_limit50char + " [" + productId + "]." + audio_ext
-            var audioFileName = FileUtility.GetValidFilename(destinationDir, product.Title, musicFileExt, product.AudibleProductId);
-
-            bool movedAudioFile = false;
-            foreach (var f in sortedFiles)
-            {
-                var dest
-                    = AudibleFileStorage.Audio.IsFileTypeMatch(f)
-                    ? audioFileName
-                    // non-audio filename: safetitle_limit50char + " [" + productId + "][" + audio_ext +"]." + non_audio_ext
-                    : FileUtility.GetValidFilename(destinationDir, product.Title, f.Extension, product.AudibleProductId, musicFileExt);
-
-                if (Path.GetExtension(dest).Trim('.').ToLower() == "cue")
-                    Cue.UpdateFileName(f, audioFileName);
-
-                File.Move(f.FullName, dest);
-
-                movedAudioFile |= AudibleFileStorage.Audio.IsFileTypeMatch(f);
-            }
-
-            AudibleFileStorage.Audio.Refresh();
-
-            return (destinationDir, movedAudioFile);
-        }
-
-        private static List<FileInfo> getProductFilesSorted(Book product, string outputAudioFilename)
-        {
-            // files are: temp path\author\[asin].ext
-            var m4bDir = new FileInfo(outputAudioFilename).Directory;
-            var files = m4bDir
-                .EnumerateFiles()
-                .Where(f => f.Name.ContainsInsensitive(product.AudibleProductId))
-                .ToList();
-
-            // move audio files to the end of the collection so these files are moved last
-            var musicFiles = files.Where(f => AudibleFileStorage.Audio.IsFileTypeMatch(f));
-            var sortedFiles = files
-                .Except(musicFiles)
-                .Concat(musicFiles)
-                .ToList();
-
-            return sortedFiles;
-        }
-
-        private static void validate(LibraryBook libraryBook)
+        private static void downloadValidation(LibraryBook libraryBook)
         {
             string errorString(string field)
                 => $"{errorTitle()}\r\nCannot download book. {field} is not known. Try re-importing the account which owns this book.";
@@ -223,11 +166,45 @@ namespace FileLiberator
                 throw new Exception(errorString("Locale"));
         }
 
-        public bool Validate(LibraryBook libraryBook) => !libraryBook.Book.Audio_Exists;
-
-        public void Cancel()
+        private void AaxcDownloader_RetrievedCoverArt(object sender, byte[] e)
         {
-            aaxcDownloader?.Cancel();
+            if (e is not null)
+                OnCoverImageDiscovered(e);
+            else if (Configuration.Instance.AllowLibationFixup)
+                OnRequestCoverArt(abDownloader.SetCoverArt);
         }
-    }
+
+        /// <summary>Move new files to 'Books' directory</summary>
+        /// <returns>True if audiobook file(s) were successfully created and can be located on disk. Else false.</returns>
+        private static bool moveFilesToBooksDir(LibraryBook libraryBook, List<FilePathCache.CacheEntry> entries)
+        {
+            // create final directory. move each file into it
+            var destinationDir = AudibleFileStorage.Audio.GetDestinationDirectory(libraryBook);
+            Directory.CreateDirectory(destinationDir);
+
+            FilePathCache.CacheEntry getFirstAudio() => entries.FirstOrDefault(f => f.FileType == FileType.Audio);
+
+			if (getFirstAudio() == default)
+				return false;
+
+			for (var i = 0; i < entries.Count; i++)
+			{
+				var entry = entries[i];
+
+				var realDest = FileUtility.SaferMoveToValidPath(entry.Path, Path.Combine(destinationDir, Path.GetFileName(entry.Path)));
+				FilePathCache.Insert(libraryBook.Book.AudibleProductId, realDest);
+
+				// propogate corrected path. Must update cache with corrected path. Also want updated path for cue file (after this for-loop)
+				entries[i] = entry with { Path = realDest };
+			}
+
+			var cue = entries.FirstOrDefault(f => f.FileType == FileType.Cue);
+			if (cue != default)
+				Cue.UpdateFileName(cue.Path, getFirstAudio().Path);
+
+			AudibleFileStorage.Audio.Refresh();
+
+			return true;
+		}
+	}
 }

FileLiberator/DownloadFile.cs

@@ -6,30 +6,26 @@ using Dinah.Core.Net.Http;
 namespace FileLiberator
 {
 	// currently only used to download the .zip flies for upgrade
-	public class DownloadFile : IStreamable
+	public class DownloadFile : Streamable
 	{
-		public event EventHandler<string> StreamingBegin;
-		public event EventHandler<DownloadProgress> StreamingProgressChanged;
-		public event EventHandler<string> StreamingCompleted;
-		public event EventHandler<TimeSpan> StreamingTimeRemaining;
-
 		public async Task<string> PerformDownloadFileAsync(string downloadUrl, string proposedDownloadFilePath)
 		{
 			var client = new HttpClient();
 
 			var progress = new Progress<DownloadProgress>();
-			progress.ProgressChanged += (_, e) => StreamingProgressChanged?.Invoke(this, e);
+			progress.ProgressChanged += (_, e) => OnStreamingProgressChanged(e);
 
-			StreamingBegin?.Invoke(this, proposedDownloadFilePath);
+			OnStreamingBegin(proposedDownloadFilePath);
 
 			try
 			{
 				var actualDownloadedFilePath = await client.DownloadFileAsync(downloadUrl, proposedDownloadFilePath, progress);
+				OnFileCreated("Upgrade", actualDownloadedFilePath);
 				return actualDownloadedFilePath;
 			}
 			finally
 			{
-				StreamingCompleted?.Invoke(this, proposedDownloadFilePath);
+				OnStreamingCompleted(proposedDownloadFilePath);
 			}
 		}
 	}

FileLiberator/DownloadPdf.cs

@@ -8,41 +8,46 @@ using DataLayer;
 using Dinah.Core.ErrorHandling;
 using Dinah.Core.Net.Http;
 using FileManager;
+using LibationFileManager;
 
 namespace FileLiberator
 {
-	public class DownloadPdf : DownloadableBase
+	public class DownloadPdf : Processable
 	{
 		public override bool Validate(LibraryBook libraryBook)
 			=> !string.IsNullOrWhiteSpace(getdownloadUrl(libraryBook))
 			&& !libraryBook.Book.PDF_Exists;
 
-		public override async Task<StatusHandler> ProcessItemAsync(LibraryBook libraryBook)
+		public override async Task<StatusHandler> ProcessAsync(LibraryBook libraryBook)
 		{
-			var proposedDownloadFilePath = getProposedDownloadFilePath(libraryBook);
-			var actualDownloadedFilePath = await downloadPdfAsync(libraryBook, proposedDownloadFilePath);
-			var result = verifyDownload(actualDownloadedFilePath);
+			OnBegin(libraryBook);
 
-			libraryBook.Book.UserDefinedItem.PdfStatus = result.IsSuccess ? LiberatedStatus.Liberated : LiberatedStatus.NotLiberated;
+			try
+			{
+				var proposedDownloadFilePath = getProposedDownloadFilePath(libraryBook);
+				var actualDownloadedFilePath = await downloadPdfAsync(libraryBook, proposedDownloadFilePath);
+				var result = verifyDownload(actualDownloadedFilePath);
 
-			return result;
+				libraryBook.Book.UserDefinedItem.PdfStatus = result.IsSuccess ? LiberatedStatus.Liberated : LiberatedStatus.NotLiberated;
+
+				return result;
+			}
+			finally
+			{
+				OnCompleted(libraryBook);
+			}
 		}
 
 		private static string getProposedDownloadFilePath(LibraryBook libraryBook)
 		{
+			var extension = Path.GetExtension(getdownloadUrl(libraryBook));
+
 			// if audio file exists, get it's dir. else return base Book dir
 			var existingPath = Path.GetDirectoryName(AudibleFileStorage.Audio.GetPath(libraryBook.Book.AudibleProductId));
-			var file = getdownloadUrl(libraryBook);
+			if (existingPath is not null)
+				return AudibleFileStorage.Audio.GetCustomDirFilename(libraryBook, existingPath, extension);
 
-			if (existingPath != null)
-				return Path.Combine(existingPath, Path.GetFileName(file));
-
-			var full = FileUtility.GetValidFilename(
-				AudibleFileStorage.PdfStorageDirectory,
-				libraryBook.Book.Title,
-				Path.GetExtension(file),
-				libraryBook.Book.AudibleProductId);
-			return full;
+			return AudibleFileStorage.Audio.GetBooksDirectoryFilename(libraryBook, extension);
 		}
 
 		private static string getdownloadUrl(LibraryBook libraryBook)
@@ -50,15 +55,28 @@ namespace FileLiberator
 
 		private async Task<string> downloadPdfAsync(LibraryBook libraryBook, string proposedDownloadFilePath)
 		{
-			var api = await GetApiAsync(libraryBook);
-			var downloadUrl = await api.GetPdfDownloadLinkAsync(libraryBook.Book.AudibleProductId);
+			OnStreamingBegin(proposedDownloadFilePath);
 
-			var client = new HttpClient();
-			var actualDownloadedFilePath = await PerformDownloadAsync(
-				proposedDownloadFilePath,
-				(p) => client.DownloadFileAsync(downloadUrl, proposedDownloadFilePath, p));
+			try
+			{
+				var api = await libraryBook.GetApiAsync();
+				var downloadUrl = await api.GetPdfDownloadLinkAsync(libraryBook.Book.AudibleProductId);
 
-			return actualDownloadedFilePath;
+				var progress = new Progress<DownloadProgress>();
+				progress.ProgressChanged += (_, e) => OnStreamingProgressChanged(e);
+
+				var client = new HttpClient();
+
+				var actualDownloadedFilePath = await client.DownloadFileAsync(downloadUrl, proposedDownloadFilePath, progress);
+				OnFileCreated(libraryBook, actualDownloadedFilePath);
+
+				OnStatusUpdate(actualDownloadedFilePath);
+				return actualDownloadedFilePath;
+			}
+			finally
+			{
+				OnStreamingCompleted(proposedDownloadFilePath);
+			}
 		}
 
 		private static StatusHandler verifyDownload(string actualDownloadedFilePath)

FileLiberator/DownloadableBase.cs

@@ -1,66 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using DataLayer;
-using Dinah.Core.ErrorHandling;
-using Dinah.Core.Net.Http;
-
-namespace FileLiberator
-{
-	public abstract class DownloadableBase : IProcessable
-	{
-		public event EventHandler<LibraryBook> Begin;
-		public event EventHandler<LibraryBook> Completed;
-
-		public event EventHandler<string> StreamingBegin;
-		public event EventHandler<DownloadProgress> StreamingProgressChanged;
-		public event EventHandler<string> StreamingCompleted;
-
-		public event EventHandler<string> StatusUpdate;
-		public event EventHandler<TimeSpan> StreamingTimeRemaining;
-
-		protected void Invoke_StatusUpdate(string message) => StatusUpdate?.Invoke(this, message);
-
-        public abstract bool Validate(LibraryBook libraryBook);
-
-        public abstract Task<StatusHandler> ProcessItemAsync(LibraryBook libraryBook);
-
-		// do NOT use ConfigureAwait(false) on ProcessAsync()
-		// often calls events which prints to forms in the UI context
-		public async Task<StatusHandler> ProcessAsync(LibraryBook libraryBook)
-        {
-            Begin?.Invoke(this, libraryBook);
-
-            try
-            {
-                return await ProcessItemAsync(libraryBook);
-            }
-            finally
-            {
-                Completed?.Invoke(this, libraryBook);
-            }
-        }
-
-		protected static Task<AudibleApi.Api> GetApiAsync(LibraryBook libraryBook)
-			=> InternalUtilities.AudibleApiActions.GetApiAsync(libraryBook.Account, libraryBook.Book.Locale);
-
-		protected async Task<string> PerformDownloadAsync(string proposedDownloadFilePath, Func<Progress<DownloadProgress>, Task<string>> func)
-		{
-			var progress = new Progress<DownloadProgress>();
-			progress.ProgressChanged += (_, e) => StreamingProgressChanged?.Invoke(this, e);
-
-			StreamingBegin?.Invoke(this, proposedDownloadFilePath);
-
-			try
-			{
-				var result = await func(progress);
-				StatusUpdate?.Invoke(this, result);
-
-				return result;
-			}
-			finally
-			{
-				StreamingCompleted?.Invoke(this, proposedDownloadFilePath);
-			}
-		}
-	}
-}

FileLiberator/FileLiberator.csproj

@@ -7,8 +7,7 @@
   <ItemGroup>
     <ProjectReference Include="..\AaxDecrypter\AaxDecrypter.csproj" />
     <ProjectReference Include="..\DataLayer\DataLayer.csproj" />
-    <ProjectReference Include="..\FileManager\FileManager.csproj" />
-    <ProjectReference Include="..\InternalUtilities\InternalUtilities.csproj" />
+    <ProjectReference Include="..\AudibleUtilities\AudibleUtilities.csproj" />
   </ItemGroup>
 
 </Project>

FileLiberator/IAudioDecodable.cs

@@ -1,14 +0,0 @@
-using System;
-
-namespace FileLiberator
-{
-    public interface IAudioDecodable : IProcessable
-    {
-        event EventHandler<Action<byte[]>> RequestCoverArt;
-        event EventHandler<string> TitleDiscovered;
-        event EventHandler<string> AuthorsDiscovered;
-        event EventHandler<string> NarratorsDiscovered;
-        event EventHandler<byte[]> CoverImageDiscovered;
-        void Cancel();
-    }
-}

FileLiberator/IProcessable.cs

@@ -1,23 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using DataLayer;
-using Dinah.Core.ErrorHandling;
-
-namespace FileLiberator
-{
-    public interface IProcessable : IStreamable
-    {
-        event EventHandler<LibraryBook> Begin;
-
-        /// <summary>General string message to display. DON'T rely on this for success, failure, or control logic</summary>
-        event EventHandler<string> StatusUpdate;
-
-        event EventHandler<LibraryBook> Completed;
-
-		/// <returns>True == Valid</returns>
-		bool Validate(LibraryBook libraryBook);
-
-        /// <returns>True == success</returns>
-        Task<StatusHandler> ProcessAsync(LibraryBook libraryBook);
-    }
-}

FileLiberator/IProcessableExt.cs

@@ -1,48 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using DataLayer;
-using Dinah.Core;
-using Dinah.Core.ErrorHandling;
-
-namespace FileLiberator
-{
-    public static class IProcessableExt
-    {
-        //
-        // DO NOT USE ConfigureAwait(false) WITH ProcessAsync() unless ensuring ProcessAsync() implementation is cross-thread compatible
-        // ProcessAsync() often does a lot with forms in the UI context
-        //
-
-
-        // when used in foreach: stateful. deferred execution
-        public static IEnumerable<LibraryBook> GetValidLibraryBooks(this IProcessable processable, IEnumerable<LibraryBook> library)
-            => library.Where(libraryBook => processable.Validate(libraryBook));
-
-        public static async Task<StatusHandler> ProcessSingleAsync(this IProcessable processable, LibraryBook libraryBook, bool validate)
-        {
-            if (validate && !processable.Validate(libraryBook))
-                return new StatusHandler { "Validation failed" };
-
-            Serilog.Log.Logger.Information("Begin " + nameof(ProcessSingleAsync) + " {@DebugInfo}", new
-            {
-                libraryBook.Book.Title,
-                libraryBook.Book.AudibleProductId,
-                libraryBook.Book.Locale,
-                Account = libraryBook.Account?.ToMask() ?? "[empty]"
-            });
-
-            var status
-                = (await processable.ProcessAsync(libraryBook))
-                ?? new StatusHandler { "Processable should never return a null status" };
-
-            return status;
-        }
-
-		public static async Task<StatusHandler> TryProcessAsync(this IProcessable processable, LibraryBook libraryBook)
-			=> processable.Validate(libraryBook)
-			? await processable.ProcessAsync(libraryBook)
-			: new StatusHandler();
-	}
-}

FileLiberator/IStreamable.cs

@@ -1,13 +0,0 @@
-using System;
-using Dinah.Core.Net.Http;
-
-namespace FileLiberator
-{
-    public interface IStreamable
-    {
-        event EventHandler<string> StreamingBegin;
-		event EventHandler<DownloadProgress> StreamingProgressChanged;
-        event EventHandler<TimeSpan> StreamingTimeRemaining;
-        event EventHandler<string> StreamingCompleted;
-    }
-}

FileLiberator/Processable.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using DataLayer;
+using Dinah.Core;
+using Dinah.Core.ErrorHandling;
+
+namespace FileLiberator
+{
+    public abstract class Processable : Streamable
+    {
+        public event EventHandler<LibraryBook> Begin;
+
+        /// <summary>General string message to display. DON'T rely on this for success, failure, or control logic</summary>
+        public event EventHandler<string> StatusUpdate;
+
+        public event EventHandler<LibraryBook> Completed;
+
+        /// <returns>True == Valid</returns>
+        public abstract bool Validate(LibraryBook libraryBook);
+
+        /// <returns>True == success</returns>
+        public abstract Task<StatusHandler> ProcessAsync(LibraryBook libraryBook);
+
+        // when used in foreach: stateful. deferred execution
+        public IEnumerable<LibraryBook> GetValidLibraryBooks(IEnumerable<LibraryBook> library)
+            => library.Where(libraryBook =>
+                Validate(libraryBook)
+                && (libraryBook.Book.ContentType != ContentType.Episode || LibationFileManager.Configuration.Instance.DownloadEpisodes)
+                );
+
+        public async Task<StatusHandler> ProcessSingleAsync(LibraryBook libraryBook, bool validate)
+        {
+            if (validate && !Validate(libraryBook))
+                return new StatusHandler { "Validation failed" };
+
+            Serilog.Log.Logger.Information("Begin " + nameof(ProcessSingleAsync) + " {@DebugInfo}", new
+            {
+                libraryBook.Book.Title,
+                libraryBook.Book.AudibleProductId,
+                libraryBook.Book.Locale,
+                Account = libraryBook.Account?.ToMask() ?? "[empty]"
+            });
+
+            var status
+                = (await ProcessAsync(libraryBook))
+                ?? new StatusHandler { "Processable should never return a null status" };
+
+            return status;
+        }
+
+        public async Task<StatusHandler> TryProcessAsync(LibraryBook libraryBook)
+            => Validate(libraryBook)
+            ? await ProcessAsync(libraryBook)
+            : new StatusHandler();
+
+        protected void OnBegin(LibraryBook libraryBook)
+        {
+            Serilog.Log.Logger.Debug("Event fired {@DebugInfo}", new { Name = nameof(Begin), Book = libraryBook.LogFriendly() });
+            Begin?.Invoke(this, libraryBook);
+        }
+
+        protected void OnStatusUpdate(string statusUpdate)
+        {
+            Serilog.Log.Logger.Debug("Event fired {@DebugInfo}", new { Name = nameof(StatusUpdate), Status = statusUpdate });
+            StatusUpdate?.Invoke(this, statusUpdate);
+        }
+
+        protected void OnCompleted(LibraryBook libraryBook)
+        {
+            Serilog.Log.Logger.Debug("Event fired {@DebugInfo}", new { Name = nameof(Completed), Book = libraryBook.LogFriendly() });
+            Completed?.Invoke(this, libraryBook);
+        }
+    }
+}

FileLiberator/Streamable.cs

@@ -0,0 +1,45 @@
+using System;
+using Dinah.Core.Net.Http;
+
+namespace FileLiberator
+{
+    public abstract class Streamable
+    {
+        public event EventHandler<string> StreamingBegin;
+        public event EventHandler<DownloadProgress> StreamingProgressChanged;
+        public event EventHandler<TimeSpan> StreamingTimeRemaining;
+        public event EventHandler<string> StreamingCompleted;
+        /// <summary>Fired when a file is successfully saved to disk</summary>
+        public event EventHandler<(string id, string path)> FileCreated;
+
+        protected void OnStreamingBegin(string filePath)
+        {
+            Serilog.Log.Logger.Debug("Event fired {@DebugInfo}", new { Name = nameof(StreamingBegin), Message = filePath });
+            StreamingBegin?.Invoke(this, filePath);
+        }
+
+        protected void OnStreamingProgressChanged(DownloadProgress progress)
+        {
+            StreamingProgressChanged?.Invoke(this, progress);
+        }
+
+        protected void OnStreamingTimeRemaining(TimeSpan timeRemaining)
+        {
+            StreamingTimeRemaining?.Invoke(this, timeRemaining);
+        }
+
+        protected void OnStreamingCompleted(string filePath)
+        {
+            Serilog.Log.Logger.Debug("Event fired {@DebugInfo}", new { Name = nameof(StreamingCompleted), Message = filePath });
+            StreamingCompleted?.Invoke(this, filePath);
+        }
+
+        protected void OnFileCreated(DataLayer.LibraryBook libraryBook, string path) => OnFileCreated(libraryBook.Book.AudibleProductId, path);
+        protected void OnFileCreated(string id, string path)
+        {
+            Serilog.Log.Logger.Information("File created {@DebugInfo}", new { Name = nameof(FileCreated), id, path });
+            LibationFileManager.FilePathCache.Insert(id, path);
+            FileCreated?.Invoke(this, (id, path));
+        }
+    }
+}

FileLiberator/UtilityExtensions.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using DataLayer;
+using Dinah.Core;
+
+namespace FileLiberator
+{
+	public static class UtilityExtensions
+	{
+		public static (string id, string title, string locale, string account) LogFriendly(this LibraryBook libraryBook)
+			=> (
+			id: libraryBook.Book.AudibleProductId,
+			title: libraryBook.Book.Title,
+			locale: libraryBook.Book.Locale,
+			account: libraryBook.Account.ToMask()
+			);
+
+		public static async Task<AudibleApi.Api> GetApiAsync(this LibraryBook libraryBook)
+		{
+			var apiExtended = await AudibleUtilities.ApiExtended.CreateAsync(libraryBook.Account, libraryBook.Book.Locale);
+			return apiExtended.Api;
+		}
+	}
+}

FileLiberator/_InternalsVisible.cs

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

FileManager/AudibleFileStorage.cs

@@ -1,147 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text.RegularExpressions;
-using Dinah.Core;
-using Dinah.Core.Collections.Generic;
-
-namespace FileManager
-{
-    public enum FileType { Unknown, Audio, AAXC, PDF }
-
-	public abstract class AudibleFileStorage : Enumeration<AudibleFileStorage>
-	{
-		protected abstract string[] Extensions { get; }
-		public abstract string StorageDirectory { get; }
-
-		public static string DownloadsInProgress => Directory.CreateDirectory(Path.Combine(Configuration.Instance.InProgress, "DownloadsInProgress")).FullName;
-        public static string DecryptInProgress => Directory.CreateDirectory(Path.Combine(Configuration.Instance.InProgress, "DecryptInProgress")).FullName;
-
-        public static string PdfStorageDirectory => BooksDirectory;
-
-		private static AaxcFileStorage AAXC { get; } = new AaxcFileStorage();
-        public static bool AaxcExists(string productId) => AAXC.Exists(productId);
-
-		#region static
-		public static AudioFileStorage Audio { get; } = new AudioFileStorage();
-
-        public static string BooksDirectory
-        {
-            get
-            {
-                if (string.IsNullOrWhiteSpace(Configuration.Instance.Books))
-                    Configuration.Instance.Books = Path.Combine(Configuration.UserProfile, "Books");
-                return Directory.CreateDirectory(Configuration.Instance.Books).FullName;
-            }
-        }
-
-        internal static BackgroundFileSystem BookDirectoryFiles { get; set; }
-        #endregion
-
-        #region instance
-        public FileType FileType => (FileType)Value;
-
-		protected IEnumerable<string> extensions_noDots { get; }
-        private string extAggr { get; }
-
-        protected AudibleFileStorage(FileType fileType) : base((int)fileType, fileType.ToString())
-		{
-			extensions_noDots = Extensions.Select(ext => ext.Trim('.')).ToList();
-			extAggr = extensions_noDots.Aggregate((a, b) => $"{a}|{b}");
-            BookDirectoryFiles ??= new BackgroundFileSystem(BooksDirectory, "*.*", SearchOption.AllDirectories);
-        }
-
-        protected string GetFilePath(string productId)
-        {
-            var cachedFile = FilePathCache.GetPath(productId, FileType);
-            if (cachedFile != null)
-                return cachedFile;
-
-            string regexPattern = $@"{productId}.*?\.({extAggr})$";
-            string firstOrNull;
-
-            if (StorageDirectory == BooksDirectory)
-            {
-                //If user changed the BooksDirectory, reinitialize.
-                if (StorageDirectory != BookDirectoryFiles.RootDirectory)
-				{
-                    lock (BookDirectoryFiles)
-                    {
-                        if (StorageDirectory != BookDirectoryFiles.RootDirectory)
-                        {
-                            BookDirectoryFiles = new BackgroundFileSystem(StorageDirectory, "*.*", SearchOption.AllDirectories);
-                        }
-                    }
-				}
-
-                firstOrNull = BookDirectoryFiles.FindFile(regexPattern, RegexOptions.IgnoreCase);
-            }
-            else
-            {
-                firstOrNull =
-                    Directory
-                    .EnumerateFiles(StorageDirectory, "*.*", SearchOption.AllDirectories)
-                    .FirstOrDefault(s => Regex.IsMatch(s, regexPattern, RegexOptions.IgnoreCase));
-            }
-
-			if (firstOrNull is null)
-				return null;
-
-			FilePathCache.Upsert(productId, FileType, firstOrNull);
-			return firstOrNull;
-        }
-        #endregion
-    }
-
-    public class AudioFileStorage : AudibleFileStorage
-    {
-        protected override string[] Extensions { get; } = new[] { "m4b", "mp3", "aac", "mp4", "m4a", "ogg", "flac" };
-
-        // we always want to use the latest config value, therefore
-        // - DO use 'get' arrow "=>"
-        // - do NOT use assign "="
-        public override string StorageDirectory => BooksDirectory;
-
-        public AudioFileStorage() : base(FileType.Audio) { }
-
-        public void Refresh() => BookDirectoryFiles.RefreshFiles();
-
-        public string GetDestDir(string title, string asin)
-        {
-            // to prevent the paths from getting too long, we don't need after the 1st ":" for the folder
-            var underscoreIndex = title.IndexOf(':');
-            var titleDir
-                = underscoreIndex < 4
-                ? title
-                : title.Substring(0, underscoreIndex);
-            var finalDir = FileUtility.GetValidFilename(StorageDirectory, titleDir, null, asin);
-            return finalDir;
-        }
-
-        public bool IsFileTypeMatch(FileInfo fileInfo)
-            => extensions_noDots.ContainsInsensative(fileInfo.Extension.Trim('.'));
-
-        public string GetPath(string productId) => GetFilePath(productId);
-    }
-
-    public class AaxcFileStorage : AudibleFileStorage
-    {
-        protected override string[] Extensions { get; } = new[] { "aaxc" };
-
-        // we always want to use the latest config value, therefore
-        // - DO use 'get' arrow "=>"
-        // - do NOT use assign "="
-        public override string StorageDirectory => DownloadsInProgress;
-
-        public AaxcFileStorage() : base(FileType.AAXC) { }
-
-        /// <summary>
-        /// Example for full books:
-        /// Search recursively in _books directory. Full book exists if either are true
-        /// - a directory name has the product id and an audio file is immediately inside
-        /// - any audio filename contains the product id
-        /// </summary>
-        public bool Exists(string productId) => GetFilePath(productId) != null;
-    }
-}

FileManager/BackgroundFileSystem.cs

@@ -3,20 +3,14 @@ using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 
 namespace FileManager
 {
     /// <summary>
-    /// Tracks actual locations of files. This is especially useful for clicking button to navigate to the book's files.
-    /// 
-    /// Note: this is no longer how Libation manages "Liberated" state. That is not statefully managed in the database.
-    /// This paradigm is what allows users to manually choose to not download books. Also allows them to manually toggle
-    /// this state and download again.
+    /// Tracks actual locations of files.
     /// </summary>
-    internal class BackgroundFileSystem
+    public class BackgroundFileSystem
     {
         public string RootDirectory { get; private set; }
         public string SearchPattern { get; private set; }
@@ -25,6 +19,8 @@ namespace FileManager
         private FileSystemWatcher fileSystemWatcher { get; set; }
         private BlockingCollection<FileSystemEventArgs> directoryChangesEvents { get; set; }
         private Task backgroundScanner { get; set; }
+
+        private object fsCacheLocker { get; } = new();
         private List<string> fsCache { get; } = new();
 
         public BackgroundFileSystem(string rootDirectory, string searchPattern, SearchOption searchOptions)
@@ -36,17 +32,15 @@ namespace FileManager
             Init();
         }
 
-        public string FindFile(string regexPattern, RegexOptions options)
+        public string FindFile(System.Text.RegularExpressions.Regex regex)
         {
-            lock (fsCache)
-            {
-                return fsCache.FirstOrDefault(s => Regex.IsMatch(s, regexPattern, options));
-            }
+            lock (fsCacheLocker)
+                return fsCache.FirstOrDefault(s => regex.IsMatch(s));
         }
 
         public void RefreshFiles()
         {
-            lock (fsCache)
+            lock (fsCacheLocker)
             {
                 fsCache.Clear();
                 fsCache.AddRange(Directory.EnumerateFiles(RootDirectory, SearchPattern, SearchOption));
@@ -57,17 +51,19 @@ namespace FileManager
         {
             Stop();
 
-            lock (fsCache)
+            lock (fsCacheLocker)
                 fsCache.AddRange(Directory.EnumerateFiles(RootDirectory, SearchPattern, SearchOption));
 
             directoryChangesEvents = new BlockingCollection<FileSystemEventArgs>();
-            fileSystemWatcher = new FileSystemWatcher(RootDirectory);
-            fileSystemWatcher.Created += FileSystemWatcher_Changed;
+			fileSystemWatcher = new FileSystemWatcher(RootDirectory)
+			{
+				IncludeSubdirectories = true,
+				EnableRaisingEvents = true
+			};
+			fileSystemWatcher.Created += FileSystemWatcher_Changed;
             fileSystemWatcher.Deleted += FileSystemWatcher_Changed;
             fileSystemWatcher.Renamed += FileSystemWatcher_Changed;
             fileSystemWatcher.Error += FileSystemWatcher_Error;
-            fileSystemWatcher.IncludeSubdirectories = true;
-            fileSystemWatcher.EnableRaisingEvents = true;
 
             backgroundScanner = new Task(BackgroundScanner);
             backgroundScanner.Start();
@@ -86,7 +82,7 @@ namespace FileManager
             //Dispose of directoryChangesEvents after backgroundScanner exists.
             directoryChangesEvents?.Dispose();
 
-            lock (fsCache)
+            lock (fsCacheLocker)
                 fsCache.Clear();
         }
 
@@ -106,7 +102,7 @@ namespace FileManager
         {
             while (directoryChangesEvents.TryTake(out FileSystemEventArgs change, -1))
             {
-                lock (fsCache)
+                lock (fsCacheLocker)
                     UpdateLocalCache(change);
             }
         }
@@ -146,9 +142,7 @@ namespace FileManager
         private void AddUniqueFiles(IEnumerable<string> newFiles)
         {
             foreach (var file in newFiles)
-            {
                 AddUniqueFile(file);
-            }
         }
         private void AddUniqueFile(string newFile)
         {

FileManager/FileManager.csproj

@@ -1,13 +1,11 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Dinah.Core" Version="1.1.0.1" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="5.0.0" />
-    <PackageReference Include="Octokit" Version="0.50.0" />
+    <PackageReference Include="Dinah.Core" Version="2.0.2.1" />
     <PackageReference Include="Polly" Version="7.2.2" />
   </ItemGroup>
 

FileManager/FileTemplate.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Dinah.Core;
+
+namespace FileManager
+{
+    /// <summary>Get valid filename. Advanced features incl. parameterized template</summary>
+    public class FileTemplate
+    {
+        /// <summary>Proposed full file path. May contain optional html-styled template tags. Eg: &lt;name&gt;</summary>
+        public string Template { get; }
+
+        /// <param name="template">Proposed file name with optional html-styled template tags.</param>
+        public FileTemplate(string template) => Template = ArgumentValidator.EnsureNotNullOrWhiteSpace(template, nameof(template));
+
+        /// <summary>Optional step 1: Replace html-styled template tags with parameters. Eg {"name", "Bill Gates"} => /&lt;name&gt;/ => /Bill Gates/</summary>
+        public Dictionary<string, object> ParameterReplacements { get; } = new Dictionary<string, object>();
+
+        /// <summary>Convenience method</summary>
+        public void AddParameterReplacement(string key, object value)
+            // using .Add() instead of "[key] = value" will make unintended overwriting throw exception
+            => ParameterReplacements.Add(key, value);
+
+        /// <summary>If set, truncate each parameter replacement to this many characters. Default 50</summary>
+        public int? ParameterMaxSize { get; set; } = 50;
+
+        /// <summary>Optional step 2: Replace all illegal characters with this. Default=<see cref="string.Empty"/></summary>
+        public string IllegalCharacterReplacements { get; set; }
+
+        /// <summary>Generate a valid path for this file or directory</summary>
+        public string GetFilePath()
+        {
+            var filename = Template;
+
+            foreach (var r in ParameterReplacements)
+                filename = filename.Replace($"<{formatKey(r.Key)}>", formatValue(r.Value));
+
+            return FileUtility.GetValidFilename(filename, IllegalCharacterReplacements);
+        }
+
+        private static string formatKey(string key)
+            => key
+            .Replace("<", "")
+            .Replace(">", "");
+
+        private string formatValue(object value)
+            => ParameterMaxSize.HasValue && ParameterMaxSize.Value > 0
+            ? value?.ToString().Truncate(ParameterMaxSize.Value)
+            : value?.ToString();
+    }
+}

FileManager/FileUtility.cs

@@ -1,52 +1,179 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
+using Dinah.Core;
+using Polly;
+using Polly.Retry;
 
 namespace FileManager
 {
     public static class FileUtility
     {
-        public static string GetValidFilename(string dirFullPath, string filename, string extension, params string[] metadataSuffixes)
+        /// <summary>
+        /// "txt" => ".txt"
+        /// <br />".txt" => ".txt"
+        /// <br />null or whitespace => ""
+        /// </summary>
+        public static string GetStandardizedExtension(string extension)
+            => string.IsNullOrWhiteSpace(extension)
+            ? (extension ?? "")?.Trim()
+            : '.' + extension.Trim().Trim('.');
+
+        /// <summary>
+        /// Return position with correct number of leading zeros.
+        /// <br />- 2 of 9 => "2"
+        /// <br />- 2 of 90 => "02"
+        /// <br />- 2 of 900 => "002"
+        /// </summary>
+        /// <param name="position">position in sequence. The 'x' in 'x of y'</param>
+        /// <param name="total">total qty in sequence. The 'y' in 'x of y'</param>
+        public static string GetSequenceFormatted(int position, int total)
         {
-            if (string.IsNullOrWhiteSpace(dirFullPath))
-                throw new ArgumentException($"{nameof(dirFullPath)} may not be null or whitespace", nameof(dirFullPath));
+            ArgumentValidator.EnsureGreaterThan(position, nameof(position), 0);
+            ArgumentValidator.EnsureGreaterThan(total, nameof(total), 0);
+            if (position > total)
+                throw new ArgumentException($"{position} may not be greater than {total}");
 
-            // file max length = 255. dir max len = 247
+            return position.ToString().PadLeft(total.ToString().Length, '0');
+        }
 
-            // sanitize
-            filename = GetAsciiTag(filename);
-            // manage length
-            if (filename.Length > 50)
-                filename = filename.Substring(0, 50) + "[...]";
+        private const int MAX_FILENAME_LENGTH = 255;
+        private const int MAX_DIRECTORY_LENGTH = 247;
 
-            // append id. it is 10 or 14 char in the common cases
-            if (metadataSuffixes != null && metadataSuffixes.Length > 0)
-                filename += " [" + string.Join("][", metadataSuffixes) + "]";
+        /// <summary>
+        /// Ensure valid file name path: 
+        /// <br/>- remove invalid chars
+        /// <br/>- ensure uniqueness
+        /// <br/>- enforce max file length
+        /// </summary>
+        public static string GetValidFilename(string path, string illegalCharacterReplacements = "")
+        {
+            ArgumentValidator.EnsureNotNull(path, nameof(path));
 
-            // this method may also be used for directory names, so no guarantee of extension
-            if (!string.IsNullOrWhiteSpace(extension))
-                extension = '.' + extension.Trim('.');
+            // remove invalid chars
+            path = GetSafePath(path, illegalCharacterReplacements);
+
+            // ensure uniqueness and check lengths
+            var dir = Path.GetDirectoryName(path);
+            dir = dir.Truncate(MAX_DIRECTORY_LENGTH);
+
+            var filename = Path.GetFileNameWithoutExtension(path);
+            var fileStem = Path.Combine(dir, filename);
+
+            var extension = Path.GetExtension(path);
+
+            var fullfilename = fileStem.Truncate(MAX_FILENAME_LENGTH - extension.Length) + extension;
 
-            // ensure uniqueness
-            var fullfilename = Path.Combine(dirFullPath, filename + extension);
             var i = 0;
             while (File.Exists(fullfilename))
-                fullfilename = Path.Combine(dirFullPath, filename + $" ({++i})" + extension);
+            {
+                var increm = $" ({++i})";
+                fullfilename = fileStem.Truncate(MAX_FILENAME_LENGTH - increm.Length - extension.Length) + increm + extension;
+            }
 
             return fullfilename;
         }
 
-        public static string GetAsciiTag(string property)
+        // GetInvalidFileNameChars contains everything in GetInvalidPathChars plus ':', '*', '?', '\\', '/'
+
+        /// <summary>Use with file name, not full path. Valid path charaters which are invalid file name characters will be replaced: ':', '\\', '/'</summary>
+        public static string GetSafeFileName(string str, string illegalCharacterReplacements = "")
+            => string.Join(illegalCharacterReplacements ?? "", str.Split(Path.GetInvalidFileNameChars()));
+
+        /// <summary>Use with full path, not file name. Valid path charaters which are invalid file name characters will be retained: '\\', '/'</summary>
+        public static string GetSafePath(string path, string illegalCharacterReplacements = "")
         {
-            if (property == null)
-                return "";
+            ArgumentValidator.EnsureNotNull(path, nameof(path));
 
-            // omit characters which are invalid. EXCEPTION: change colon to underscore
-            property = property.Replace(':', '_');
+            var invalidChars = Path.GetInvalidPathChars().Union(new[] {
+                '*', '?',
+                // these are weird. If you run Path.GetInvalidPathChars() in C# interactive, these characters are included.
+                // In live code, Path.GetInvalidPathChars() does not include them
+                '"', '<', '>'
+            }).ToArray();
 
-            // GetInvalidFileNameChars contains everything in GetInvalidPathChars plus ':', '*', '?', '\\', '/'
-            foreach (var ch in Path.GetInvalidFileNameChars())
-                property = property.Replace(ch.ToString(), "");
-            return property;
+            var fixedPath = string
+                .Join(illegalCharacterReplacements ?? "", path.Split(invalidChars))
+                .Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
+
+            // replace all colons except within the first 2 chars
+            var builder = new System.Text.StringBuilder();
+            for (var i = 0; i < fixedPath.Length; i++)
+            {
+                var c = fixedPath[i];
+                if (i >= 2 && c == ':')
+                    builder.Append(illegalCharacterReplacements);
+                else
+                    builder.Append(c);
+            }
+            fixedPath = builder.ToString();
+
+            var dblSeparator = $"{Path.DirectorySeparatorChar}{Path.DirectorySeparatorChar}";
+            while (fixedPath.Contains(dblSeparator))
+                fixedPath = fixedPath.Replace(dblSeparator, $"{Path.DirectorySeparatorChar}");
+
+            return fixedPath;
         }
+
+        /// <summary>
+        /// Move file.
+        /// <br/>- Ensure valid file name path: remove invalid chars, ensure uniqueness, enforce max file length
+        /// <br/>- Perform <see cref="SaferMove"/>
+        /// <br/>- Return valid path
+        /// </summary>
+        public static string SaferMoveToValidPath(string source, string destination)
+        {
+            destination = GetValidFilename(destination);
+            SaferMove(source, destination);
+            return destination;
+        }
+
+        private static int maxRetryAttempts { get; } = 3;
+        private static TimeSpan pauseBetweenFailures { get; } = TimeSpan.FromMilliseconds(100);
+        private static RetryPolicy retryPolicy { get; } =
+            Policy
+            .Handle<Exception>()
+            .WaitAndRetry(maxRetryAttempts, i => pauseBetweenFailures);
+
+        /// <summary>Delete file. No error when source does not exist. Retry up to 3 times before throwing exception.</summary>
+        public static void SaferDelete(string source)
+            => retryPolicy.Execute(() =>
+            {
+                try
+                {
+                    if (File.Exists(source))
+                    {
+                        File.Delete(source);
+                        Serilog.Log.Logger.Information("File successfully deleted", new { source });
+                    }
+                }
+                catch (Exception e)
+                {
+                    Serilog.Log.Logger.Error(e, "Failed to delete file", new { source });
+                    throw;
+                }
+            });
+
+        /// <summary>Move file. No error when source does not exist. Retry up to 3 times before throwing exception.</summary>
+		public static void SaferMove(string source, string destination)
+            => retryPolicy.Execute(() =>
+            {
+                try
+                {
+                    if (File.Exists(source))
+                    {
+                        SaferDelete(destination);
+                        Directory.CreateDirectory(Path.GetDirectoryName(destination));
+                        File.Move(source, destination);
+                        Serilog.Log.Logger.Information("File successfully moved", new { source, destination });
+                    }
+                }
+                catch (Exception e)
+                {
+                    Serilog.Log.Logger.Error(e, "Failed to move file", new { source, destination });
+                    throw;
+                }
+            });
     }
 }

FileManager/_InternalsVisible.cs

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

Libation.sln

@@ -23,34 +23,47 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "2 Utilities (domain ignoran
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AaxDecrypter", "AaxDecrypter\AaxDecrypter.csproj", "{8BD8E012-F44F-4EE2-A234-D66C14D5FE4B}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "FileManager", "FileManager\FileManager.csproj", "{1AE65B61-9C05-4C80-ABFF-48F16E22FDF1}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibationFileManager", "LibationFileManager\LibationFileManager.csproj", "{1AE65B61-9C05-4C80-ABFF-48F16E22FDF1}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DataLayer", "DataLayer\DataLayer.csproj", "{59A10DF3-63EC-43F1-A3BF-4000CFA118D2}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "FileLiberator", "FileLiberator\FileLiberator.csproj", "{393B5B27-D15C-4F77-9457-FA14BA8F3C73}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "InternalUtilities", "InternalUtilities\InternalUtilities.csproj", "{06882742-27A6-4347-97D9-56162CEC9C11}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AudibleUtilities", "AudibleUtilities\AudibleUtilities.csproj", "{06882742-27A6-4347-97D9-56162CEC9C11}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "3 Domain Internal Utilities (db ignorant)", "3 Domain Internal Utilities (db ignorant)", "{F0CBB7A7-D3FB-41FF-8F47-CF3F6A592249}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibationSearchEngine", "LibationSearchEngine\LibationSearchEngine.csproj", "{2E1F5DB4-40CC-4804-A893-5DCE0193E598}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibationWinForms", "LibationWinForms\LibationWinForms.csproj", "{635F00E1-AAD1-45F7-BEB7-D909AD33B9F6}"
+	ProjectSection(ProjectDependencies) = postProject
+		{428163C3-D558-4914-B570-A92069521877} = {428163C3-D558-4914-B570-A92069521877}
+	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DtoImporterService", "DtoImporterService\DtoImporterService.csproj", "{401865F5-1942-4713-B230-04544C0A97B0}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ApplicationServices", "ApplicationServices\ApplicationServices.csproj", "{B95650EA-25F0-449E-BA5D-99126BC5D730}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibationLauncher", "LibationLauncher\LibationLauncher.csproj", "{F3B04A3A-20C8-4582-A54A-715AF6A5D859}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "_Tests", "_Tests", "{67E66E82-5532-4440-AFB3-9FB1DF9DEF53}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "InternalUtilities.Tests", "_Tests\InternalUtilities.Tests\InternalUtilities.Tests.csproj", "{8447C956-B03E-4F59-9DD4-877793B849D9}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibationSearchEngine.Tests", "_Tests\LibationSearchEngine.Tests\LibationSearchEngine.Tests.csproj", "{C5B21768-C7C9-4FCB-AC1E-187B223D5A98}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Hoopla", "Hoopla\Hoopla.csproj", "{D8F56E5A-3E65-41A6-B7E7-C4515A264B1F}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibationCli", "LibationCli\LibationCli.csproj", "{428163C3-D558-4914-B570-A92069521877}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AppScaffolding", "AppScaffolding\AppScaffolding.csproj", "{595E7C4D-506D-486D-98B7-5FDDF398D033}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "FileManager", "FileManager\FileManager.csproj", "{E86014F9-E4B3-4CD4-A210-2B3DB571DD86}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AudibleUtilities.Tests", "_Tests\AudibleUtilities.Tests\AudibleUtilities.Tests.csproj", "{788294BE-0D8E-40D4-9CEE-67896FBB52CE}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "FileLiberator.Tests", "_Tests\FileLiberator.Tests\FileLiberator.Tests.csproj", "{5B8FC827-BF58-4CB1-A59E-BDEB9C62A05E}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "FileManager.Tests", "_Tests\FileManager.Tests\FileManager.Tests.csproj", "{F2E04270-4551-41C4-99FF-E7125BED708C}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LibationFileManager.Tests", "_Tests\LibationFileManager.Tests\LibationFileManager.Tests.csproj", "{EB781571-8548-477E-82AD-FB9FAB548D2F}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -93,14 +106,6 @@ Global
 		{B95650EA-25F0-449E-BA5D-99126BC5D730}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{B95650EA-25F0-449E-BA5D-99126BC5D730}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{B95650EA-25F0-449E-BA5D-99126BC5D730}.Release|Any CPU.Build.0 = Release|Any CPU
-		{F3B04A3A-20C8-4582-A54A-715AF6A5D859}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{F3B04A3A-20C8-4582-A54A-715AF6A5D859}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{F3B04A3A-20C8-4582-A54A-715AF6A5D859}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{F3B04A3A-20C8-4582-A54A-715AF6A5D859}.Release|Any CPU.Build.0 = Release|Any CPU
-		{8447C956-B03E-4F59-9DD4-877793B849D9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{8447C956-B03E-4F59-9DD4-877793B849D9}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{8447C956-B03E-4F59-9DD4-877793B849D9}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{8447C956-B03E-4F59-9DD4-877793B849D9}.Release|Any CPU.Build.0 = Release|Any CPU
 		{C5B21768-C7C9-4FCB-AC1E-187B223D5A98}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{C5B21768-C7C9-4FCB-AC1E-187B223D5A98}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{C5B21768-C7C9-4FCB-AC1E-187B223D5A98}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -109,6 +114,34 @@ Global
 		{D8F56E5A-3E65-41A6-B7E7-C4515A264B1F}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D8F56E5A-3E65-41A6-B7E7-C4515A264B1F}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{D8F56E5A-3E65-41A6-B7E7-C4515A264B1F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{428163C3-D558-4914-B570-A92069521877}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{428163C3-D558-4914-B570-A92069521877}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{428163C3-D558-4914-B570-A92069521877}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{428163C3-D558-4914-B570-A92069521877}.Release|Any CPU.Build.0 = Release|Any CPU
+		{595E7C4D-506D-486D-98B7-5FDDF398D033}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{595E7C4D-506D-486D-98B7-5FDDF398D033}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{595E7C4D-506D-486D-98B7-5FDDF398D033}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{595E7C4D-506D-486D-98B7-5FDDF398D033}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E86014F9-E4B3-4CD4-A210-2B3DB571DD86}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E86014F9-E4B3-4CD4-A210-2B3DB571DD86}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E86014F9-E4B3-4CD4-A210-2B3DB571DD86}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E86014F9-E4B3-4CD4-A210-2B3DB571DD86}.Release|Any CPU.Build.0 = Release|Any CPU
+		{788294BE-0D8E-40D4-9CEE-67896FBB52CE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{788294BE-0D8E-40D4-9CEE-67896FBB52CE}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{788294BE-0D8E-40D4-9CEE-67896FBB52CE}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{788294BE-0D8E-40D4-9CEE-67896FBB52CE}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5B8FC827-BF58-4CB1-A59E-BDEB9C62A05E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5B8FC827-BF58-4CB1-A59E-BDEB9C62A05E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5B8FC827-BF58-4CB1-A59E-BDEB9C62A05E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5B8FC827-BF58-4CB1-A59E-BDEB9C62A05E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F2E04270-4551-41C4-99FF-E7125BED708C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F2E04270-4551-41C4-99FF-E7125BED708C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F2E04270-4551-41C4-99FF-E7125BED708C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F2E04270-4551-41C4-99FF-E7125BED708C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EB781571-8548-477E-82AD-FB9FAB548D2F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EB781571-8548-477E-82AD-FB9FAB548D2F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EB781571-8548-477E-82AD-FB9FAB548D2F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EB781571-8548-477E-82AD-FB9FAB548D2F}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -123,10 +156,15 @@ Global
 		{635F00E1-AAD1-45F7-BEB7-D909AD33B9F6} = {8679CAC8-9164-4007-BDD2-F004810EDA14}
 		{401865F5-1942-4713-B230-04544C0A97B0} = {41CDCC73-9B81-49DD-9570-C54406E852AF}
 		{B95650EA-25F0-449E-BA5D-99126BC5D730} = {41CDCC73-9B81-49DD-9570-C54406E852AF}
-		{F3B04A3A-20C8-4582-A54A-715AF6A5D859} = {8679CAC8-9164-4007-BDD2-F004810EDA14}
-		{8447C956-B03E-4F59-9DD4-877793B849D9} = {67E66E82-5532-4440-AFB3-9FB1DF9DEF53}
 		{C5B21768-C7C9-4FCB-AC1E-187B223D5A98} = {67E66E82-5532-4440-AFB3-9FB1DF9DEF53}
 		{D8F56E5A-3E65-41A6-B7E7-C4515A264B1F} = {7FBBB086-0807-4998-85BF-6D1A49C8AD05}
+		{428163C3-D558-4914-B570-A92069521877} = {8679CAC8-9164-4007-BDD2-F004810EDA14}
+		{595E7C4D-506D-486D-98B7-5FDDF398D033} = {8679CAC8-9164-4007-BDD2-F004810EDA14}
+		{E86014F9-E4B3-4CD4-A210-2B3DB571DD86} = {43E3ACB3-E0BC-4370-8DBB-E3720C8C8FD1}
+		{788294BE-0D8E-40D4-9CEE-67896FBB52CE} = {67E66E82-5532-4440-AFB3-9FB1DF9DEF53}
+		{5B8FC827-BF58-4CB1-A59E-BDEB9C62A05E} = {67E66E82-5532-4440-AFB3-9FB1DF9DEF53}
+		{F2E04270-4551-41C4-99FF-E7125BED708C} = {67E66E82-5532-4440-AFB3-9FB1DF9DEF53}
+		{EB781571-8548-477E-82AD-FB9FAB548D2F} = {67E66E82-5532-4440-AFB3-9FB1DF9DEF53}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {615E00ED-BAEF-4E8E-A92A-9B82D87942A9}

LibationCli/LibationCli.csproj

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net5.0</TargetFramework>
+
+    <PublishTrimmed>true</PublishTrimmed>
+    <PublishReadyToRun>true</PublishReadyToRun>
+    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+  </PropertyGroup>
+
+  <!--
+  When LibationWinForms and LibationCli output to the same dir, LibationCli must build before LibationWinForms
+  
+  VS > rt-clik solution > Project Build Order...
+  Dependencies [tab]
+  Projects: LibationWinForms
+  manually check LibationCli
+  -->
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <OutputPath>..\LibationWinForms\bin\Debug</OutputPath>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <OutputPath>..\LibationWinForms\bin\Release</OutputPath>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="CommandLineParser" Version="2.8.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ApplicationServices\ApplicationServices.csproj" />
+    <ProjectReference Include="..\AppScaffolding\AppScaffolding.csproj" />
+    <ProjectReference Include="..\FileLiberator\FileLiberator.csproj" />
+  </ItemGroup>
+
+</Project>

LibationCli/Options/ConvertOptions.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using CommandLine;
+
+namespace LibationCli
+{
+	[Verb("convert", HelpText = "Convert mp4 to mp3.")]
+	public class ConvertOptions : ProcessableOptionsBase
+	{
+		protected override Task ProcessAsync() => RunAsync(CreateProcessable<FileLiberator.ConvertToMp3>());
+	}
+}

LibationCli/Options/ExportOptions.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using ApplicationServices;
+using AudibleUtilities;
+using CommandLine;
+
+namespace LibationCli
+{
+	[Verb("export", HelpText = "Must include path and flag for export file type: --xlsx , --csv , --json]")]
+	public class ExportOptions : OptionsBase
+	{
+		[Option(shortName: 'p', longName: "path", Required = true, HelpText = "Path to save file to.")]
+		public string FilePath { get; set; }
+
+		#region explanation of mutually exclusive options
+		/*
+		giving these SetName values makes them mutually exclusive. they are in different sets. eg:
+		class Options
+		{
+		    [Option("username", SetName = "auth")]
+		    public string Username { get; set; }
+		    [Option("password", SetName = "auth")]
+		    public string Password { get; set; }
+
+		    [Option("guestaccess", SetName = "guest")]
+		    public bool GuestAccess { get; set; }
+		}
+		*/
+		#endregion
+		[Option(shortName: 'x', longName: "xlsx", SetName = "xlsx", Required = true)]
+		public bool xlsx { get; set; }
+
+		[Option(shortName: 'c', longName: "csv", SetName = "csv", Required = true)]
+		public bool csv { get; set; }
+
+		[Option(shortName: 'j', longName: "json", SetName = "json", Required = true)]
+		public bool json { get; set; }
+
+		protected override Task ProcessAsync()
+		{
+			if (xlsx)
+				LibraryExporter.ToXlsx(FilePath);
+			if (csv)
+				LibraryExporter.ToCsv(FilePath);
+			if (json)
+				LibraryExporter.ToJson(FilePath);
+
+			Console.WriteLine($"Library exported to: {FilePath}");
+
+			return Task.CompletedTask;
+		}
+	}
+}

LibationCli/Options/LiberateOptions.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using CommandLine;
+using DataLayer;
+using FileLiberator;
+
+namespace LibationCli
+{
+	[Verb("liberate", HelpText = "Liberate: book and pdf backups. Default: download and decrypt all un-liberated titles and download pdfs. "
+		+ "Optional: use 'pdf' flag to only download pdfs.")]
+	public class LiberateOptions : ProcessableOptionsBase
+	{
+		[Option(shortName: 'p', longName: "pdf", Required = false, Default = false, HelpText = "Flag to only download pdfs")]
+		public bool PdfOnly { get; set; }
+
+		protected override Task ProcessAsync()
+			=> PdfOnly
+			? RunAsync(CreateProcessable<DownloadPdf>())
+			: RunAsync(CreateBackupBook());
+
+		private static Processable CreateBackupBook()
+		{
+			var downloadPdf = CreateProcessable<DownloadPdf>();
+
+			//Chain pdf download on DownloadDecryptBook.Completed
+			async void onDownloadDecryptBookCompleted(object sender, LibraryBook e)
+			{
+				await downloadPdf.TryProcessAsync(e);
+			}
+
+			var downloadDecryptBook = CreateProcessable<DownloadDecryptBook>(onDownloadDecryptBookCompleted);
+			return downloadDecryptBook;
+		}
+	}
+}

LibationCli/Options/ScanOptions.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using ApplicationServices;
+using AudibleUtilities;
+using CommandLine;
+
+namespace LibationCli
+{
+	[Verb("scan", HelpText = "Scan library. Default: scan all accounts. Optional: use 'account' flag to specify a single account.")]
+	public class ScanOptions : OptionsBase
+	{
+		[Value(0, MetaName = "Accounts", HelpText = "Optional: nicknames of accounts to scan.", Required = false)]
+		public IEnumerable<string> AccountNicknames { get; set; }
+
+		protected override async Task ProcessAsync()
+		{
+			var accounts = getAccounts();
+			if (!accounts.Any())
+			{
+				Console.WriteLine("No accounts. Exiting.");
+				Environment.ExitCode = (int)ExitCode.RunTimeError;
+				return;
+			}
+
+			var _accounts = accounts.ToArray();
+
+			var intro
+				= (_accounts.Length == 1)
+				? "Scanning Audible library. This may take a few minutes."
+				: $"Scanning Audible library: {_accounts.Length} accounts. This may take a few minutes per account.";
+			Console.WriteLine(intro);
+
+			var (TotalBooksProcessed, NewBooksAdded) = await LibraryCommands.ImportAccountAsync((a) => ApiExtended.CreateAsync(a), _accounts);
+
+			Console.WriteLine("Scan complete.");
+			Console.WriteLine($"Total processed: {TotalBooksProcessed}\r\nNew: {NewBooksAdded}");
+		}
+
+		private Account[] getAccounts()
+		{
+			using var persister = AudibleApiStorage.GetAccountsSettingsPersister();
+			var accounts = persister.AccountsSettings.GetAll().ToArray();
+
+			if (!AccountNicknames.Any())
+				return accounts;
+
+			var found = accounts.Where(acct => AccountNicknames.Contains(acct.AccountName)).ToArray();
+			var notFound = AccountNicknames.Except(found.Select(f => f.AccountName)).ToArray();
+
+			// no accounts found. do not continue
+			if (!found.Any())
+			{
+				Console.WriteLine("Accounts not found:");
+				foreach (var nf in notFound)
+					Console.WriteLine($"- {nf}");
+				return found;
+			}
+
+			// some accounts not found. continue after message
+			if (notFound.Any())
+			{
+				Console.WriteLine("Accounts found:");
+				foreach (var f in found)
+					Console.WriteLine($"- {f}");
+				Console.WriteLine("Accounts not found:");
+				foreach (var nf in notFound)
+					Console.WriteLine($"- {nf}");
+			}
+
+			// else: all accounts area found. silently continue
+
+			return found;
+		}
+	}
+}

LibationCli/Options/_OptionsBase.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using CommandLine;
+
+namespace LibationCli
+{
+	public abstract class OptionsBase
+	{
+		public async Task Run()
+		{
+			try
+			{
+				await ProcessAsync();
+			}
+			catch (Exception ex)
+			{
+				Environment.ExitCode = (int)ExitCode.RunTimeError;
+
+				Console.WriteLine("ERROR");
+				Console.WriteLine("=====");
+				Console.WriteLine(ex.Message);
+				Console.WriteLine();
+				Console.WriteLine(ex.StackTrace);
+			}
+		}
+
+		protected abstract Task ProcessAsync();
+	}
+}

LibationCli/Options/_ProcessableOptionsBase.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using ApplicationServices;
+using CommandLine;
+using DataLayer;
+using FileLiberator;
+
+namespace LibationCli
+{
+	// streamlined, non-Forms copy of ProcessorAutomationController
+	public abstract class ProcessableOptionsBase : OptionsBase
+	{
+		protected static TProcessable CreateProcessable<TProcessable>(EventHandler<LibraryBook> completedAction = null)
+			where TProcessable : Processable, new()
+		{
+			var strProc = new TProcessable();
+
+			strProc.Begin += (o, e) => Console.WriteLine($"{typeof(TProcessable).Name} Begin: {e}");
+			strProc.Completed += (o, e) => Console.WriteLine($"{typeof(TProcessable).Name} Completed: {e}");
+
+			strProc.Completed += completedAction;
+
+			return strProc;
+		}
+
+		protected static async Task RunAsync(Processable Processable)
+		{
+			foreach (var libraryBook in Processable.GetValidLibraryBooks(DbContexts.GetLibrary_Flat_NoTracking()))
+				await ProcessOneAsync(Processable, libraryBook, false);
+
+			var done = "Done. All books have been processed";
+			Console.WriteLine(done);
+			Serilog.Log.Logger.Information(done);
+		}
+
+		private static async Task ProcessOneAsync(Processable Processable, LibraryBook libraryBook, bool validate)
+		{
+			try
+			{
+				var statusHandler = await Processable.ProcessSingleAsync(libraryBook, validate);
+
+				if (statusHandler.IsSuccess)
+					return;
+
+				foreach (var errorMessage in statusHandler.Errors)
+					Serilog.Log.Logger.Error(errorMessage);
+			}
+			catch (Exception ex)
+			{
+				var msg = "Error processing book. Skipping. This book will be tried again on next attempt. For options of skipping or marking as error, retry with main Libation app.";
+				Console.WriteLine(msg + ". See log for more details.");
+				Serilog.Log.Logger.Error(ex, $"{msg} {{@DebugInfo}}", new { Book = libraryBook.LogFriendly() });
+			}
+		}
+	}
+}

LibationCli/Program.cs

@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using CommandLine;
+using CommandLine.Text;
+using Dinah.Core;
+using Dinah.Core.Collections;
+using Dinah.Core.Collections.Generic;
+
+namespace LibationCli
+{
+	public enum ExitCode
+	{
+		ProcessCompletedSuccessfully = 0,
+		NonRunNonError = 1,
+		ParseError = 2,
+		RunTimeError = 3
+	}
+	class Program
+	{
+        static async Task<int> Main(string[] args)
+		{
+			//***********************************************//
+			//                                               //
+			//   do not use Configuration before this line   //
+			//                                               //
+			//***********************************************//
+			Setup.Initialize();
+			Setup.SubscribeToDatabaseEvents();
+
+			var types = Setup.LoadVerbs();
+
+#if DEBUG
+			string input = null;
+
+			//input = "  export --help";
+			//input = "  scan  rmcrackan";
+			//input = "  liberate ";
+
+
+			// note: this hack will fail for quoted file paths with spaces because it will break on those spaces
+			if (!string.IsNullOrWhiteSpace(input))
+				args = input.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+			var setBreakPointHere = args;
+#endif
+
+			var result = Parser.Default.ParseArguments(args, types);
+
+			// if successfully parsed
+			// async: run parsed options
+			await result.WithParsedAsync<OptionsBase>(opt => opt.Run());
+
+			// if not successfully parsed
+			// sync: handle parse errors
+			result.WithNotParsed(errors => HandleErrors(result, errors));
+
+			return Environment.ExitCode;
+		}
+
+		private static void HandleErrors(ParserResult<object> result, IEnumerable<Error> errors)
+		{
+			var errorsList = errors.ToList();
+			if (errorsList.Any(e => e.Tag.In(ErrorType.HelpRequestedError, ErrorType.VersionRequestedError, ErrorType.HelpVerbRequestedError)))
+			{
+				Environment.ExitCode = (int)ExitCode.NonRunNonError;
+				return;
+			}
+
+			Environment.ExitCode = (int)ExitCode.ParseError;
+
+			if (errorsList.Any(e => e.Tag.In(ErrorType.NoVerbSelectedError)))
+			{
+				Console.WriteLine("No verb selected");
+				return;
+			}
+
+			var helpText = HelpText.AutoBuild(result,
+				h => HelpText.DefaultParsingErrorsHandler(result, h),
+				e => e);
+			Console.WriteLine(helpText);
+		}
+	}
+}

LibationCli/Setup.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using AppScaffolding;
+using CommandLine;
+using CommandLine.Text;
+using Dinah.Core;
+using Dinah.Core.Collections;
+using Dinah.Core.Collections.Generic;
+
+namespace LibationCli
+{
+	public static class Setup
+	{
+		public static void Initialize()
+		{
+			//***********************************************//
+			//                                               //
+			//   do not use Configuration before this line   //
+			//                                               //
+			//***********************************************//
+			var config = LibationScaffolding.RunPreConfigMigrations();
+
+
+			LibationScaffolding.RunPostConfigMigrations(config);
+			LibationScaffolding.RunPostMigrationScaffolding(config);
+
+#if !DEBUG
+			checkForUpdate();
+#endif
+		}
+
+		private static void checkForUpdate()
+		{
+			var (hasUpgrade, zipUrl, htmlUrl, zipName) = LibationScaffolding.GetLatestRelease();
+			if (!hasUpgrade)
+				return;
+
+			var origColor = Console.ForegroundColor;
+			try
+			{
+				Console.ForegroundColor = ConsoleColor.Red;
+				Console.WriteLine($"UPDATE AVAILABLE @ {zipUrl}");
+			}
+			finally
+			{
+				Console.ForegroundColor = origColor;
+			}
+		}
+
+		public static void SubscribeToDatabaseEvents()
+		{
+			DataLayer.UserDefinedItem.ItemChanged += (sender, e) => ApplicationServices.LibraryCommands.UpdateUserDefinedItem(((DataLayer.UserDefinedItem)sender).Book);
+		}
+
+		public static Type[] LoadVerbs() => Assembly.GetExecutingAssembly()
+			.GetTypes()
+			.Where(t => t.GetCustomAttribute<VerbAttribute>() is not null)
+			.ToArray();
+	}
+}

LibationFileManager/AudibleFileStorage.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using FileManager;
+
+namespace LibationFileManager
+{
+    public abstract class AudibleFileStorage
+    {
+        protected abstract string GetFilePathCustom(string productId);
+
+        #region static
+        public static string DownloadsInProgressDirectory => Directory.CreateDirectory(Path.Combine(Configuration.Instance.InProgress, "DownloadsInProgress")).FullName;
+        public static string DecryptInProgressDirectory => Directory.CreateDirectory(Path.Combine(Configuration.Instance.InProgress, "DecryptInProgress")).FullName;
+
+        private static AaxcFileStorage AAXC { get; } = new AaxcFileStorage();
+        public static bool AaxcExists(string productId) => AAXC.Exists(productId);
+
+        public static AudioFileStorage Audio { get; } = new AudioFileStorage();
+
+        public static string BooksDirectory
+        {
+            get
+            {
+                if (string.IsNullOrWhiteSpace(Configuration.Instance.Books))
+                    Configuration.Instance.Books = Path.Combine(Configuration.UserProfile, "Books");
+                return Directory.CreateDirectory(Configuration.Instance.Books).FullName;
+            }
+        }
+        #endregion
+
+        #region instance
+        private FileType FileType { get; }
+        private string regexTemplate { get; }
+
+        protected AudibleFileStorage(FileType fileType)
+        {
+            FileType = fileType;
+
+            var extAggr = FileTypes.GetExtensions(FileType).Aggregate((a, b) => $"{a}|{b}");
+            regexTemplate = $@"{{0}}.*?\.({extAggr})$";
+        }
+
+        protected string GetFilePath(string productId)
+        {
+            // primary lookup
+            var cachedFile = FilePathCache.GetFirstPath(productId, FileType);
+            if (cachedFile != null)
+                return cachedFile;
+
+            // secondary lookup attempt
+            var firstOrNull = GetFilePathCustom(productId);
+            if (firstOrNull is not null)
+                FilePathCache.Insert(productId, firstOrNull);
+
+            return firstOrNull;
+        }
+
+        protected Regex GetBookSearchRegex(string productId)
+        {
+            var pattern = string.Format(regexTemplate, productId);
+            return new Regex(pattern, RegexOptions.IgnoreCase);
+        }
+        #endregion
+    }
+
+    internal class AaxcFileStorage : AudibleFileStorage
+    {
+        internal AaxcFileStorage() : base(FileType.AAXC) { }
+
+        protected override string GetFilePathCustom(string productId)
+        {
+            var regex = GetBookSearchRegex(productId);
+            return Directory
+                .EnumerateFiles(DownloadsInProgressDirectory, "*.*", SearchOption.AllDirectories)
+                .FirstOrDefault(s => regex.IsMatch(s));
+        }
+
+        public bool Exists(string productId) => GetFilePath(productId) != null;
+    }
+
+    public class AudioFileStorage : AudibleFileStorage
+    {
+        internal AudioFileStorage() : base(FileType.Audio)
+            => BookDirectoryFiles ??= new BackgroundFileSystem(BooksDirectory, "*.*", SearchOption.AllDirectories);
+
+        private static BackgroundFileSystem BookDirectoryFiles { get; set; }
+        private static object bookDirectoryFilesLocker { get; } = new();
+        protected override string GetFilePathCustom(string productId)
+        {
+            // If user changed the BooksDirectory: reinitialize
+            lock (bookDirectoryFilesLocker)
+                if (BooksDirectory != BookDirectoryFiles.RootDirectory)
+                    BookDirectoryFiles = new BackgroundFileSystem(BooksDirectory, "*.*", SearchOption.AllDirectories);
+
+            var regex = GetBookSearchRegex(productId);
+            return BookDirectoryFiles.FindFile(regex);
+        }
+
+        public void Refresh() => BookDirectoryFiles.RefreshFiles();
+
+        public string GetPath(string productId) => GetFilePath(productId);
+    }
+}

LibationFileManager/Configuration.cs

@@ -5,13 +5,14 @@ using System.IO;
 using System.Linq;
 using Dinah.Core;
 using Dinah.Core.Logging;
+using FileManager;
 using Microsoft.Extensions.Configuration;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using Serilog;
 using Serilog.Events;
 
-namespace FileManager
+namespace LibationFileManager
 {
     public class Configuration
     {
@@ -51,9 +52,12 @@ namespace FileManager
         public void SetObject(string propertyName, object newValue) => persistentDictionary.SetNonString(propertyName, newValue);
 
         /// <summary>WILL ONLY set if already present. WILL NOT create new</summary>
-        /// <returns>Value was changed</returns>
-        public bool SetWithJsonPath(string jsonPath, string propertyName, string newValue, bool suppressLogging = false)
-            => persistentDictionary.SetWithJsonPath(jsonPath, propertyName, newValue, suppressLogging);
+        public void SetWithJsonPath(string jsonPath, string propertyName, string newValue, bool suppressLogging = false)
+        {
+            var settingWasChanged = persistentDictionary.SetWithJsonPath(jsonPath, propertyName, newValue, suppressLogging);
+            if (settingWasChanged)
+                configuration?.Reload();
+        }
 
         public string SettingsFilePath => Path.Combine(LibationFiles, "Settings.json");
 
@@ -85,7 +89,7 @@ namespace FileManager
             set => persistentDictionary.SetString(nameof(InProgress), value);
         }
 
-        [Description("Allow Libation for fix up audiobook metadata?")]
+        [Description("Allow Libation to fix up audiobook metadata")]
         public bool AllowLibationFixup
         {
             get => persistentDictionary.GetNonString<bool>(nameof(AllowLibationFixup));
@@ -98,6 +102,86 @@ namespace FileManager
             get => persistentDictionary.GetNonString<bool>(nameof(DecryptToLossy));
             set => persistentDictionary.SetNonString(nameof(DecryptToLossy), value);
         }
+        
+        [Description("Split my books into multiple files by chapter")]
+        public bool SplitFilesByChapter
+        {
+            get => persistentDictionary.GetNonString<bool>(nameof(SplitFilesByChapter));
+            set => persistentDictionary.SetNonString(nameof(SplitFilesByChapter), value);
+        }
+
+        public enum BadBookAction
+        {
+            [Description("Ask each time what action to take.")]
+            Ask = 0,
+            [Description("Stop processing books.")]
+            Abort = 1,
+            [Description("Retry book later. Skip for now. Continue processing books.")]
+            Retry = 2,
+            [Description("Permanently ignore book. Continue processing books. Do not try book again.")]
+            Ignore = 3
+        }
+
+        [Description("When liberating books and there is an error, Libation should:")]
+        public BadBookAction BadBook
+        {
+            get
+            {
+                var badBookStr = persistentDictionary.GetString(nameof(BadBook));
+				return Enum.TryParse<BadBookAction>(badBookStr, out var badBookEnum) ? badBookEnum : BadBookAction.Ask;
+            }
+            set => persistentDictionary.SetString(nameof(BadBook), value.ToString());
+        }
+
+        [Description("Import episodes? (eg: podcasts) When unchecked, episodes will not be imported into Libation.")]
+        public bool ImportEpisodes
+        {
+            get => persistentDictionary.GetNonString<bool>(nameof(ImportEpisodes));
+            set => persistentDictionary.SetNonString(nameof(ImportEpisodes), value);
+        }
+
+        [Description("Download episodes? (eg: podcasts). When unchecked, episodes already in Libation will not be downloaded.")]
+        public bool DownloadEpisodes
+        {
+            get => persistentDictionary.GetNonString<bool>(nameof(DownloadEpisodes));
+            set => persistentDictionary.SetNonString(nameof(DownloadEpisodes), value);
+		}
+
+        #region templates: custom file naming
+
+        [Description("How to format the folders in which files will be saved")]
+		public string FolderTemplate
+        {
+            get => getTemplate(nameof(FolderTemplate), Templates.Folder);
+            set => setTemplate(nameof(FolderTemplate), Templates.Folder, value);
+        }
+
+        [Description("How to format the saved pdf and audio files")]
+		public string FileTemplate
+        {
+            get => getTemplate(nameof(FileTemplate), Templates.File);
+            set => setTemplate(nameof(FileTemplate), Templates.File, value);
+        }
+
+        [Description("How to format the saved audio files when split by chapters")]
+        public string ChapterFileTemplate
+        {
+            get => getTemplate(nameof(ChapterFileTemplate), Templates.ChapterFile);
+            set => setTemplate(nameof(ChapterFileTemplate), Templates.ChapterFile, value);
+        }
+
+        private string getTemplate(string settingName, Templates templ)
+        {
+            var value = persistentDictionary.GetString(settingName).Trim();
+            return templ.IsValid(value) ? value : templ.DefaultTemplate;
+        }
+        private void setTemplate(string settingName, Templates templ, string newValue)
+        {
+            var template = newValue.Trim();
+            if (templ.IsValid(template))
+                persistentDictionary.SetString(settingName, template);
+        }
+        #endregion
 
         #endregion
 
@@ -159,13 +243,9 @@ namespace FileManager
 
         #region logging
         private IConfigurationRoot configuration;
+
         public void ConfigureLogging()
         {
-            //// with code. also persists to Settings.json
-            //SetWithJsonPath("Serilog.WriteTo[1].Args", "path", logPath, true);
-            //// hack which achieves the same, in memory only
-            //configuration["Serilog:WriteTo:1:Args:path"] = logPath;
-
             configuration = new ConfigurationBuilder()
                 .AddJsonFile(SettingsFilePath, optional: false, reloadOnChange: true)
                 .Build();
@@ -179,16 +259,8 @@ namespace FileManager
         {
             get
             {
-                try
-                {
-                    var logLevelStr = persistentDictionary.GetStringFromJsonPath("Serilog", "MinimumLevel");
-                    var logLevelEnum = Enum<LogEventLevel>.Parse(logLevelStr);
-                    return logLevelEnum;
-                }
-                catch
-                {
-                    return LogEventLevel.Information;
-                }
+                var logLevelStr = persistentDictionary.GetStringFromJsonPath("Serilog", "MinimumLevel");
+                return Enum.TryParse<LogEventLevel>(logLevelStr, out var logLevelEnum) ? logLevelEnum : LogEventLevel.Information;
             }
             set
             {
@@ -217,11 +289,10 @@ namespace FileManager
 		#region singleton stuff
 		public static Configuration Instance { get; } = new Configuration();
         private Configuration() { }
-		#endregion
+        #endregion
 
-		#region LibationFiles
-
-		private const string APPSETTINGS_JSON = "appsettings.json";
+        #region LibationFiles
+        private static string APPSETTINGS_JSON { get; } = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location), "appsettings.json");
         private const string LIBATION_FILES_KEY = "LibationFiles";
 
         [Description("Location for storage of program-created files")]
@@ -238,12 +309,16 @@ namespace FileManager
                 // SECOND. before setting to json file with SetWithJsonPath, PersistentDictionary must exist
                 persistentDictionary = new PersistentDictionary(SettingsFilePath);
 
-                // Config init in Program.ensureSerilogConfig() only happens when serilog setting is first created (prob on 1st run).
+                // Config init in ensureSerilogConfig() only happens when serilog setting is first created (prob on 1st run).
                 // This Set() enforces current LibationFiles every time we restart Libation or redirect LibationFiles
                 var logPath = Path.Combine(LibationFiles, "Log.log");
-                bool settingWasChanged = SetWithJsonPath("Serilog.WriteTo[1].Args", "path", logPath, true);
-                if (settingWasChanged)
-                    configuration?.Reload();
+
+                // BAD: Serilog.WriteTo[1].Args
+                //      "[1]" assumes ordinal position
+                // GOOD: Serilog.WriteTo[?(@.Name=='File')].Args
+                var jsonpath = "Serilog.WriteTo[?(@.Name=='File')].Args";
+
+                SetWithJsonPath(jsonpath, "path", logPath, true);
 
                 return libationFilesPathCache;
             }

LibationFileManager/FilePathCache.cs

@@ -5,17 +5,16 @@ using System.Linq;
 using Dinah.Core.Collections.Immutable;
 using Newtonsoft.Json;
 
-namespace FileManager
+namespace LibationFileManager
 {
 	public static class FilePathCache
-    {
+	{
+		public record CacheEntry(string Id, FileType FileType, string Path);
+
 		private const string FILENAME = "FileLocations.json";
-        internal class CacheEntry
-        {
-            public string Id { get; set; }
-            public FileType FileType { get; set; }
-            public string Path { get; set; }
-        }
+
+		public static event EventHandler<CacheEntry> Inserted;
+		public static event EventHandler<CacheEntry> Removed;
 
 		private static Cache<CacheEntry> cache { get; } = new Cache<CacheEntry>();
 
@@ -31,42 +30,51 @@ namespace FileManager
 			}
         }
 
-        public static bool Exists(string id, FileType type) => GetPath(id, type) != null;
+        public static bool Exists(string id, FileType type) => GetFirstPath(id, type) != null;
 
-        public static string GetPath(string id, FileType type)
-        {
-            var entry = cache.SingleOrDefault(i => i.Id == id && i.FileType == type);
+		public static List<(FileType fileType, string path)> GetFiles(string id)
+			=> getEntries(entry => entry.Id == id)
+			.Select(entry => (entry.FileType, entry.Path))
+			.ToList();
 
-            if (entry == null)
-                return null;
+		public static string GetFirstPath(string id, FileType type)
+			=> getEntries(entry => entry.Id == id && entry.FileType == type)
+			?.FirstOrDefault()
+			?.Path;
 
-            if (!File.Exists(entry.Path))
-            {
-                remove(entry);
-                return null;
-            }
-
-            return entry.Path;
-        }
-
-        private static void remove(CacheEntry entry)
+		private static List<CacheEntry> getEntries(Func<CacheEntry, bool> predicate)
 		{
-			cache.Remove(entry);
-			save();
+			var entries = cache.Where(predicate).ToList();
+			if (entries is null || !entries.Any())
+				return null;
+
+			remove(entries.Where(e => !File.Exists(e.Path)).ToList());
+
+			return entries;
 		}
 
-        public static void Upsert(string id, FileType type, string path)
-        {
-            if (!File.Exists(path))
-                throw new FileNotFoundException("Cannot add path to cache. File not found");
+		private static void remove(List<CacheEntry> entries)
+		{
+			if (entries is null)
+				return;
 
-			var entry = cache.SingleOrDefault(i => i.Id == id && i.FileType == type);
-
-			if (entry is null)
-				cache.Add(new CacheEntry { Id = id, FileType = type, Path = path });
-			else
-				entry.Path = path;
+			lock (locker)
+			{
+				foreach (var entry in entries)
+				{
+					cache.Remove(entry);
+					Removed?.Invoke(null, entry);
+				}
+				save();
+			}
+		}
 
+        public static void Insert(string id, string path)
+		{
+			var type = FileTypes.GetFileTypeFromPath(path);
+			var entry = new CacheEntry(id, type, path);
+			cache.Add(entry);
+			Inserted?.Invoke(null, entry);
 			save();
 		}
 

LibationFileManager/FileTypes.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace LibationFileManager
+{
+	public enum FileType { Unknown, Audio, AAXC, PDF, Zip, Cue }
+
+	public static class FileTypes
+	{
+		private static Dictionary<string, FileType> dic => new()
+		{
+			["aaxc"] = FileType.AAXC,
+			["cue"] = FileType.Cue,
+			["pdf"] = FileType.PDF,
+			["zip"] = FileType.Zip,
+
+			["aac"] = FileType.Audio,
+			["flac"] = FileType.Audio,
+			["m4a"] = FileType.Audio,
+			["m4b"] = FileType.Audio,
+			["mp3"] = FileType.Audio,
+			["mp4"] = FileType.Audio,
+			["ogg"] = FileType.Audio,
+		};
+
+		public static FileType GetFileTypeFromPath(string path)
+			=> dic.TryGetValue(Path.GetExtension(path).ToLower().Trim('.'), out var fileType)
+			? fileType
+			: FileType.Unknown;
+
+		public static List<string> GetExtensions(FileType fileType)
+			=> dic
+			.Where(kvp => kvp.Value == fileType)
+			.Select(kvp => kvp.Key)
+			.ToList();
+	}
+}

LibationFileManager/LibationFileManager.csproj

@@ -5,7 +5,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="AudibleApi" Version="1.2.1.2" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="5.0.0" />
   </ItemGroup>
 
   <ItemGroup>

LibationFileManager/PictureStorage.cs

@@ -6,7 +6,7 @@ using System.Linq;
 using System.Net.Http;
 using System.Threading.Tasks;
 
-namespace FileManager
+namespace LibationFileManager
 {
 	public enum PictureSize { _80x80 = 80, _300x300 = 300, _500x500 = 500 }
 	public class PictureCachedEventArgs : EventArgs
@@ -43,11 +43,12 @@ namespace FileManager
 		public static event EventHandler<PictureCachedEventArgs> PictureCached;
 
 		private static BlockingCollection<PictureDefinition> DownloadQueue { get; } = new BlockingCollection<PictureDefinition>();
+		private static object cacheLocker { get; } = new object();
 		private static Dictionary<PictureDefinition, byte[]> cache { get; } = new Dictionary<PictureDefinition, byte[]>();
 		private static Dictionary<PictureSize, byte[]> defaultImages { get; } = new Dictionary<PictureSize, byte[]>();
 		public static (bool isDefault, byte[] bytes) GetPicture(PictureDefinition def)
 		{
-			lock (cache)
+			lock (cacheLocker)
 			{
 				if (cache.ContainsKey(def))
 					return (false, cache[def]);
@@ -67,7 +68,7 @@ namespace FileManager
 
 		public static byte[] GetPictureSynchronously(PictureDefinition def)
 		{
-			lock (cache)
+			lock (cacheLocker)
 			{
 				if (!cache.ContainsKey(def) || cache[def] == null)
 				{
@@ -104,7 +105,7 @@ namespace FileManager
 
 				var bytes = downloadBytes(def);
 				saveFile(def, bytes);
-				lock (cache)
+				lock (cacheLocker)
 					cache[def] = bytes;
 
 				PictureCached?.Invoke(nameof(PictureStorage), new PictureCachedEventArgs { Definition = def, Picture = bytes });

LibationFileManager/QuickFilters.cs

@@ -5,7 +5,7 @@ using System.Linq;
 using Dinah.Core.Collections.Generic;
 using Newtonsoft.Json;
 
-namespace FileManager
+namespace LibationFileManager
 {
     public static class QuickFilters
     {

LibationFileManager/SqliteStorage.cs

@@ -1,6 +1,6 @@
 using System.IO;
 
-namespace FileManager
+namespace LibationFileManager
 {
 	public static class SqliteStorage
 	{

LibationFileManager/TagsPersistence.cs

@@ -6,7 +6,7 @@ using Newtonsoft.Json;
 using Polly;
 using Polly.Retry;
 
-namespace FileManager
+namespace LibationFileManager
 {
     /// <summary>
     /// Tags must also be stored in db for search performance. Stored in json file to survive a db reset.

LibationFileManager/TemplateTags.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Dinah.Core;
+
+namespace LibationFileManager
+{
+    public sealed class TemplateTags : Enumeration<TemplateTags>
+    {
+        public string TagName => DisplayName;
+        public string Description { get; }
+        public bool IsChapterOnly { get; }
+
+        private static int value = 0;
+        private TemplateTags(string tagName, string description, bool isChapterOnly = false) : base(value++, tagName)
+        {
+            Description = description;
+            IsChapterOnly = isChapterOnly;
+        }
+
+        public static TemplateTags Id { get; } = new TemplateTags("id", "Audible ID");
+        public static TemplateTags Title { get; } = new TemplateTags("title", "Full title");
+        public static TemplateTags TitleShort { get; } = new TemplateTags("title short", "Title. Stop at first colon");
+        public static TemplateTags Author { get; } = new TemplateTags("author", "Author(s)");
+        public static TemplateTags FirstAuthor { get; } = new TemplateTags("first author", "First author");
+        public static TemplateTags Narrator { get; } = new TemplateTags("narrator", "Narrator(s)");
+        public static TemplateTags FirstNarrator { get; } = new TemplateTags("first narrator", "First narrator");
+        public static TemplateTags Series { get; } = new TemplateTags("series", "Name of series");
+        // can't also have a leading zeros version. Too many weird edge cases. Eg: "1-4"
+        public static TemplateTags SeriesNumber { get; } = new TemplateTags("series#", "Number order in series");
+
+        public static TemplateTags ChCount { get; } = new TemplateTags("ch count", "Number of chapters", true);
+        public static TemplateTags ChTitle { get; } = new TemplateTags("ch title", "Chapter title", true);
+        public static TemplateTags ChNumber { get; } = new TemplateTags("ch#", "Chapter number", true);
+        public static TemplateTags ChNumber0 { get; } = new TemplateTags("ch# 0", "Chapter number with leading zeros", true);
+    }
+}

LibationFileManager/Templates.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace LibationFileManager
+{
+    public abstract class Templates
+    {
+        public static Templates Folder { get; } = new FolderTemplate();
+        public static Templates File { get; } = new FileTemplate();
+        public static Templates ChapterFile { get; } = new ChapterFileTemplate();
+
+        public abstract string DefaultTemplate { get; }
+
+        public abstract bool IsValid(string template);
+        public abstract bool IsRecommended(string template);
+        public abstract int TagCount(string template);
+
+        public static bool ContainsChapterOnlyTags(string template)
+            => TemplateTags.GetAll()
+            .Where(t => t.IsChapterOnly)
+            .Any(t => ContainsTag(template, t.TagName));
+
+        public static bool ContainsTag(string template, string tag) => template.Contains($"<{tag}>");
+
+        protected static bool fileIsValid(string template)
+            // File name only; not path. all other path chars are valid enough to pass this check and will be handled on final save.
+            // null is invalid. whitespace is valid but not recommended
+            => template is not null
+            && !template.Contains(':')
+            && !template.Contains(System.IO.Path.DirectorySeparatorChar)
+            && !template.Contains(System.IO.Path.AltDirectorySeparatorChar);
+
+        protected bool isRecommended(string template, bool isChapter)
+            => IsValid(template)
+            && !string.IsNullOrWhiteSpace(template)
+            && TagCount(template) > 0
+            && ContainsChapterOnlyTags(template) == isChapter;
+
+        protected static int tagCount(string template, Func<TemplateTags, bool> func)
+            => TemplateTags.GetAll()
+            .Where(func)
+            // for <id><id> == 1, use:
+            //   .Count(t => template.Contains($"<{t.TagName}>"))
+            // .Sum() impl: <id><id> == 2
+            .Sum(t => template.Split($"<{t.TagName}>").Length - 1);
+
+        private class FolderTemplate : Templates
+        {
+			public override string DefaultTemplate { get; } = "<title short> [<id>]";
+
+			public override bool IsValid(string template)
+                // must be relative. no colons. all other path chars are valid enough to pass this check and will be handled on final save.
+                // null is invalid. whitespace is valid but not recommended
+                => template is not null
+                && !template.Contains(':');
+
+            public override bool IsRecommended(string template) => isRecommended(template, false);
+
+            public override int TagCount(string template) => tagCount(template, t => !t.IsChapterOnly);
+        }
+
+        private class FileTemplate : Templates
+        {
+			public override string DefaultTemplate { get; } = "<title> [<id>]";
+
+            public override bool IsValid(string template) => fileIsValid(template);
+
+            public override bool IsRecommended(string template) => isRecommended(template, false);
+
+            public override int TagCount(string template) => tagCount(template, t => !t.IsChapterOnly);
+        }
+
+        private class ChapterFileTemplate : Templates
+        {
+            public override string DefaultTemplate { get; } = "<title> [<id>] - <ch# 0> - <ch title>";
+
+            public override bool IsValid(string template) => fileIsValid(template);
+
+            public override bool IsRecommended(string template)
+                => isRecommended(template, true)
+                // recommended to incl. <ch#> or <ch# 0>
+                && (ContainsTag(template, TemplateTags.ChNumber.TagName) || ContainsTag(template, TemplateTags.ChNumber0.TagName));
+
+            public override int TagCount(string template) => tagCount(template, t => true);
+        }
+    }
+}

LibationFileManager/_InternalsVisible.cs

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

LibationLauncher/LibationLauncher.csproj

@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <TargetFramework>net5.0-windows</TargetFramework>
-    <UseWindowsForms>true</UseWindowsForms>
-    <ApplicationIcon>libation.ico</ApplicationIcon>
-    <AssemblyName>Libation</AssemblyName>
-
-    <PublishTrimmed>true</PublishTrimmed>
-    <PublishReadyToRun>true</PublishReadyToRun>
-    <!-- <PublishSingleFile>true</PublishSingleFile> -->
-    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
-
-    <Version>5.6.7.1</Version>
-  </PropertyGroup>
-
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-    <DefineConstants>TRACE;DEBUG</DefineConstants>
-  </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="..\LibationWinForms\LibationWinForms.csproj" />
-  </ItemGroup>
-
-</Project>

LibationLauncher/Program.cs

@@ -1,508 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Windows.Forms;
-using AudibleApi.Authorization;
-using DataLayer;
-using Dinah.Core;
-using Dinah.Core.IO;
-using Dinah.Core.Logging;
-using FileManager;
-using InternalUtilities;
-using LibationWinForms;
-using LibationWinForms.Dialogs;
-using Microsoft.EntityFrameworkCore;
-using Newtonsoft.Json.Linq;
-using Serilog;
-
-namespace LibationLauncher
-{
-	static class Program
-	{
-		[System.Runtime.InteropServices.DllImport("kernel32.dll", SetLastError = true)]
-		[return: System.Runtime.InteropServices.MarshalAs(System.Runtime.InteropServices.UnmanagedType.Bool)]
-		static extern bool AllocConsole();
-
-		[STAThread]
-		static void Main()
-		{
-			//// uncomment to see Console. MUST be called before anything writes to Console. Might only work from VS
-			//AllocConsole();
-
-			Application.SetHighDpiMode(HighDpiMode.SystemAware);
-			Application.EnableVisualStyles();
-			Application.SetCompatibleTextRenderingDefault(false);
-
-			// must occur before access to Configuration instance
-			migrate_to_v5_2_0__pre_config();
-
-
-			//***********************************************//
-			//                                               //
-			//   do not use Configuration before this line   //
-			//                                               //
-			//***********************************************//
-
-
-			var config = Configuration.Instance;
-
-			createSettings(config);
-
-			AudibleApiStorage.EnsureAccountsSettingsFileExists();
-
-			migrate_to_v5_0_0(config);
-			migrate_to_v5_2_0__post_config(config);
-			migrate_to_v5_5_0(config);
-
-			ensureSerilogConfig(config);
-			configureLogging(config);
-			logStartupState(config);
-
-#if !DEBUG
-			checkForUpdate(config);
-#endif
-			Application.Run(new Form1());
-		}
-
-		private static void createSettings(Configuration config)
-		{
-			// all returns should be preceded by either:
-			// - if config.LibationSettingsAreValid
-			// - error message, Exit()
-
-			static void CancelInstallation()
-			{
-				MessageBox.Show("Initial set up cancelled.", "Cancelled", MessageBoxButtons.OK, MessageBoxIcon.Warning);
-				Application.Exit();
-				Environment.Exit(0);
-			}
-
-			if (config.LibationSettingsAreValid)
-				return;
-
-			var defaultLibationFilesDir = Configuration.UserProfile;
-
-			// check for existing settigns in default location
-			var defaultSettingsFile = Path.Combine(defaultLibationFilesDir, "Settings.json");
-			if (Configuration.SettingsFileIsValid(defaultSettingsFile))
-				config.SetLibationFiles(defaultLibationFilesDir);
-
-			if (config.LibationSettingsAreValid)
-				return;
-
-			var setupDialog = new SetupDialog();
-			if (setupDialog.ShowDialog() != DialogResult.OK)
-			{
-				CancelInstallation();
-				return;
-			}
-
-			if (setupDialog.IsNewUser)
-				config.SetLibationFiles(defaultLibationFilesDir);
-			else if (setupDialog.IsReturningUser)
-			{
-				var libationFilesDialog = new LibationFilesDialog();
-
-				if (libationFilesDialog.ShowDialog() != DialogResult.OK)
-				{
-					CancelInstallation();
-					return;
-				}
-
-				config.SetLibationFiles(libationFilesDialog.SelectedDirectory);
-				if (config.LibationSettingsAreValid)
-					return;
-
-				// path did not result in valid settings
-				var continueResult = MessageBox.Show(
-					$"No valid settings were found at this location.\r\nWould you like to create a new install settings in this folder?\r\n\r\n{libationFilesDialog.SelectedDirectory}",
-					"New install?",
-					MessageBoxButtons.YesNo,
-					MessageBoxIcon.Question);
-
-				if (continueResult != DialogResult.Yes)
-				{
-					CancelInstallation();
-					return;
-				}
-			}
-
-			// if 'new user' was clicked, or if 'returning user' chose new install: show basic settings dialog
-			config.Books ??= Path.Combine(defaultLibationFilesDir, "Books");
-			config.InProgress ??= Configuration.WinTemp;
-			config.AllowLibationFixup = true;
-			config.DecryptToLossy = false;
-
-			if (new SettingsDialog().ShowDialog() != DialogResult.OK)
-			{
-				CancelInstallation();
-				return;
-			}
-
-			if (config.LibationSettingsAreValid)
-				return;
-
-			CancelInstallation();
-		}
-
-		#region migrate to v5.0.0 re-register device if device info not in settings
-		private static void migrate_to_v5_0_0(Configuration config)
-		{
-			if (!config.Exists(nameof(config.AllowLibationFixup)))
-				config.AllowLibationFixup = true;
-
-			if (!File.Exists(AudibleApiStorage.AccountsSettingsFile))
-				return;
-
-			var accountsPersister = AudibleApiStorage.GetAccountsSettingsPersister();
-
-			var accounts = accountsPersister?.AccountsSettings?.Accounts;
-			if (accounts is null)
-				return;
-
-			foreach (var account in accounts)
-			{
-				var identity = account?.IdentityTokens;
-
-				if (identity is null)
-					continue;
-
-				if (!string.IsNullOrWhiteSpace(identity.DeviceType) &&
-					!string.IsNullOrWhiteSpace(identity.DeviceSerialNumber) &&
-					!string.IsNullOrWhiteSpace(identity.AmazonAccountId))
-					continue;
-
-				var authorize = new Authorize(identity.Locale);
-
-				try
-				{
-					authorize.DeregisterAsync(identity.ExistingAccessToken, identity.Cookies.ToKeyValuePair()).GetAwaiter().GetResult();
-					identity.Invalidate();
-
-					var api = AudibleApiActions.GetApiAsync(new LibationWinForms.Login.WinformResponder(account), account).GetAwaiter().GetResult();
-				}
-                catch
-                {
-					// Don't care if it fails
-                }
-			}
-		}
-		#endregion
-
-		#region migrate to v5.2.0
-		// get rid of meta-directories, combine DownloadsInProgressEnum and DecryptInProgressEnum => InProgress
-		private 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
-			};
-
-		private static void migrate_to_v5_2_0__post_config(Configuration config)
-		{
-			if (!config.Exists(nameof(config.AllowLibationFixup)))
-				config.AllowLibationFixup = true;
-
-			if (!config.Exists(nameof(config.DecryptToLossy)))
-				config.DecryptToLossy = false;
-		}
-		#endregion
-
-		#region migrate to v5.5.0. FilePaths.json => db. long running. fire and forget
-		private static void migrate_to_v5_5_0(Configuration config)
-			=> new System.Threading.Thread(() => migrate_to_v5_5_0_thread(config)) { IsBackground = true }.Start();
-		private static void migrate_to_v5_5_0_thread(Configuration config)
-		{
-			try
-			{
-				var filePaths = Path.Combine(config.LibationFiles, "FilePaths.json");
-				if (!File.Exists(filePaths))
-					return;
-
-				var fileLocations = Path.Combine(config.LibationFiles, "FileLocations.json");
-				if (!File.Exists(fileLocations))
-					File.Copy(filePaths, fileLocations);
-
-				// files to be deleted at the end
-				var libhackFilesToDelete = new List<string>();
-				// .libhack files => errors
-				var libhackFiles = Directory.EnumerateDirectories(config.Books, "*.libhack", SearchOption.AllDirectories);
-
-				using var context = ApplicationServices.DbContexts.GetContext();
-				context.Books.Load();
-
-				var jArr = JArray.Parse(File.ReadAllText(filePaths));
-
-				foreach (var jToken in jArr)
-				{
-					var asinToken = jToken["Id"];
-					var fileTypeToken = jToken["FileType"];
-					var pathToken = jToken["Path"];
-					if (asinToken is null || fileTypeToken is null || pathToken is null ||
-						asinToken.Type != JTokenType.String || fileTypeToken.Type != JTokenType.Integer || pathToken.Type != JTokenType.String)
-						continue;
-
-					var asin = asinToken.Value<string>();
-					var fileType = (FileType)fileTypeToken.Value<int>();
-					var path = pathToken.Value<string>();
-
-					if (fileType == FileType.Unknown || fileType == FileType.AAXC)
-						continue;
-
-					var book = context.Books.Local.FirstOrDefault(b => b.AudibleProductId == asin);
-					if (book is null)
-						continue;
-
-					// assign these strings and enums/ints unconditionally. EFCore will only update if changed
-					if (fileType == FileType.PDF)
-						book.UserDefinedItem.PdfStatus = LiberatedStatus.Liberated;
-
-					if (fileType == FileType.Audio)
-					{
-						var lhack = libhackFiles.FirstOrDefault(f => f.ContainsInsensitive(asin));
-						if (lhack is null)
-							book.UserDefinedItem.BookStatus = LiberatedStatus.Liberated;
-						else
-						{
-							book.UserDefinedItem.BookStatus = LiberatedStatus.Error;
-							libhackFilesToDelete.Add(lhack);
-						}
-					}
-				}
-
-				context.SaveChanges();
-
-				// only do this after save changes
-				foreach (var libhackFile in libhackFilesToDelete)
-					File.Delete(libhackFile);
-
-				File.Delete(filePaths);
-			}
-			catch (Exception ex)
-			{
-				Log.Logger.Error(ex, "Error attempting to insert FilePaths into db");
-			}
-		}
-		#endregion
-
-		private static void ensureSerilogConfig(Configuration config)
-		{
-			if (config.GetObject("Serilog") != null)
-				return;
-
-			// "Serilog": {
-			//   "MinimumLevel": "Information"
-			//   "WriteTo": [
-			//     {
-			//       "Name": "Console"
-			//     },
-			//     {
-			//       "Name": "File",
-			//       "Args": {
-			//         "rollingInterval": "Day",
-			//         "outputTemplate": ...
-			//       }
-			//     }
-			//   ],
-			//   "Using": [ "Dinah.Core" ],
-			//   "Enrich": [ "WithCaller" ]
-			// }
-			var serilogObj = new JObject
-			{
-				{ "MinimumLevel", "Information" },
-				{ "WriteTo", new JArray
-					{
-						new JObject { {"Name", "Console" } },
-						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
-									{ "outputTemplate", "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] (at {Caller}) {Message:lj}{NewLine}{Exception}" }
-								}
-							}
-						}
-					}
-				},
-				{ "Using", new JArray{ "Dinah.Core" } }, // dll's name, NOT namespace
-				{ "Enrich", new JArray{ "WithCaller" } },
-			};
-			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();
-
-			// Fwd Console to serilog.
-			// Serilog also writes to Console (should probably change this) so it might be asking for trouble.
-			// SerilogTextWriter needs to be more robust and tested. Esp the Write() methods.
-			// Empirical testing so far has shown no issues.
-			Console.SetOut(new MultiTextWriter(origOut, new SerilogTextWriter()));
-
-			// .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 Libation. {@DebugInfo}", new
-			{
-				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,
-
-				DownloadsInProgressDir = AudibleFileStorage.DownloadsInProgress,
-				DownloadsInProgressFiles = Directory.EnumerateFiles(AudibleFileStorage.DownloadsInProgress).Count(),
-
-				DecryptInProgressDir = AudibleFileStorage.DecryptInProgress,
-				DecryptInProgressFiles = Directory.EnumerateFiles(AudibleFileStorage.DecryptInProgress).Count(),
-			});
-
-			MessageBoxVerboseLoggingWarning.ShowIfTrue();
-		}
-
-		private static void checkForUpdate(Configuration config)
-		{
-			string zipUrl;
-			string selectedPath;
-
-			try
-			{
-				// timed out
-				var latest = getLatestRelease(TimeSpan.FromSeconds(10));
-				if (latest is null)
-					return;
-
-				var latestVersionString = latest.TagName.Trim('v');
-				if (!Version.TryParse(latestVersionString, out var latestRelease))
-					return;
-
-				// we're up to date
-				if (latestRelease <= BuildVersion)
-					return;
-
-				// we have an update
-				var zip = latest.Assets.FirstOrDefault(a => a.BrowserDownloadUrl.EndsWith(".zip"));
-				zipUrl = zip?.BrowserDownloadUrl;
-
-				Log.Logger.Information("Update available: {@DebugInfo}", new {
-					latestRelease = latestRelease.ToString(),
-					latest.HtmlUrl,
-					zipUrl
-				});
-
-				if (zipUrl is null)
-				{
-					MessageBox.Show(latest.HtmlUrl, "New version available");
-					return;
-				}
-
-				var result = MessageBox.Show($"New version available @ {latest.HtmlUrl}\r\nDownload the zip file?", "New version available", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
-				if (result != DialogResult.Yes)
-					return;
-
-				using var fileSelector = new SaveFileDialog { FileName = zip.Name, Filter = "Zip Files (*.zip)|*.zip|All files (*.*)|*.*" };
-				if (fileSelector.ShowDialog() != DialogResult.OK)
-					return;
-				selectedPath = fileSelector.FileName;
-			}
-			catch (AggregateException aggEx)
-			{
-				Log.Logger.Error(aggEx, "Checking for new version too often");
-				return;
-			}
-			catch (Exception ex)
-			{
-				MessageBoxAlertAdmin.Show("Error checking for update", "Error checking for update", ex);
-				return;
-			}
-
-			try
-			{
-				LibationWinForms.BookLiberation.ProcessorAutomationController.DownloadFile(zipUrl, selectedPath, true);
-			}
-			catch (Exception ex)
-			{
-				MessageBoxAlertAdmin.Show("Error downloading update", "Error downloading update", ex);
-			}
-		}
-
-		private static Octokit.Release getLatestRelease(TimeSpan timeout)
-		{
-			var task = System.Threading.Tasks.Task.Run(() => getLatestRelease());
-			if (task.Wait(timeout))
-				return task.Result;
-
-			Log.Logger.Information("Timed out");
-			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;
-		}
-
-		private static Version BuildVersion => System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
-	}
-}

LibationSearchEngine/LibationSearchEngine.csproj

@@ -14,7 +14,6 @@
 
   <ItemGroup>
     <ProjectReference Include="..\DataLayer\DataLayer.csproj" />
-    <ProjectReference Include="..\FileManager\FileManager.csproj" />
   </ItemGroup>
 
 </Project>

LibationSearchEngine/SearchEngine.cs

@@ -5,7 +5,7 @@ using System.Linq;
 using System.Text.RegularExpressions;
 using DataLayer;
 using Dinah.Core;
-using FileManager;
+using LibationFileManager;
 using Lucene.Net.Analysis.Standard;
 using Lucene.Net.Documents;
 using Lucene.Net.Index;
@@ -315,7 +315,7 @@ namespace LibationSearchEngine
             var docs = searcher.Search(query, 1);
             var scoreDoc = docs.ScoreDocs.SingleOrDefault();
             if (scoreDoc == null)
-                throw new Exception("document not found");
+                return;
             var document = searcher.Doc(scoreDoc.Doc);
 
 

LibationSearchEngine/_InternalsVisible.cs

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

LibationWinForms/BookLiberation/AudioConvertForm.cs

@@ -1,6 +1,6 @@
-using DataLayer;
-using FileManager;
-using System;
+using System;
+using DataLayer;
+using LibationFileManager;
 
 namespace LibationWinForms.BookLiberation
 {
@@ -16,15 +16,18 @@ namespace LibationWinForms.BookLiberation
 		public override string DecodeActionName => "Converting";
 		#endregion
 
-		#region IProcessable event handler overrides
-		public override void OnBegin(object sender, LibraryBook libraryBook)
+		#region Processable event handler overrides
+		public override void Processable_Begin(object sender, LibraryBook libraryBook)
 		{
 			LogMe.Info($"Convert Step, Begin: {libraryBook.Book}");
 
-			base.OnBegin(sender, libraryBook);
+			base.Processable_Begin(sender, libraryBook);
+		}
+		public override void Processable_Completed(object sender, LibraryBook libraryBook)
+		{
+			base.Processable_Completed(sender, libraryBook);
+			LogMe.Info($"Convert Step, Completed: {libraryBook.Book}{Environment.NewLine}");
 		}
-		public override void OnCompleted(object sender, LibraryBook libraryBook)
-			=> LogMe.Info($"Convert Step, Completed: {libraryBook.Book}{Environment.NewLine}");
 
 		#endregion
 	}

LibationWinForms/BookLiberation/AudioDecodeForm.cs

@@ -2,6 +2,7 @@
 using DataLayer;
 using Dinah.Core.Net.Http;
 using Dinah.Core.Threading;
+using LibationFileManager;
 using LibationWinForms.BookLiberation.BaseForms;
 
 namespace LibationWinForms.BookLiberation
@@ -18,29 +19,32 @@ namespace LibationWinForms.BookLiberation
 		private string authorNames;
 		private string narratorNames;
 
-		#region IProcessable event handler overrides
-		public override void OnBegin(object sender, LibraryBook libraryBook)
+		#region Processable event handler overrides
+		public override void Processable_Begin(object sender, LibraryBook libraryBook)
 		{
-			GetCoverArtDelegate = () => FileManager.PictureStorage.GetPictureSynchronously(
-						new FileManager.PictureDefinition(
+			base.Processable_Begin(sender, libraryBook);
+
+			GetCoverArtDelegate = () => PictureStorage.GetPictureSynchronously(
+						new PictureDefinition(
 							libraryBook.Book.PictureId,
-							FileManager.PictureSize._500x500));
+							PictureSize._500x500));
 
 			//Set default values from library
-			OnTitleDiscovered(sender, libraryBook.Book.Title);
-			OnAuthorsDiscovered(sender, string.Join(", ", libraryBook.Book.Authors));
-			OnNarratorsDiscovered(sender, string.Join(", ", libraryBook.Book.NarratorNames));
-			OnCoverImageDiscovered(sender,
-					FileManager.PictureStorage.GetPicture(
-						new FileManager.PictureDefinition(
+			AudioDecodable_TitleDiscovered(sender, libraryBook.Book.Title);
+			AudioDecodable_AuthorsDiscovered(sender, string.Join(", ", libraryBook.Book.Authors));
+			AudioDecodable_NarratorsDiscovered(sender, string.Join(", ", libraryBook.Book.NarratorNames));
+			AudioDecodable_CoverImageDiscovered(sender,
+					PictureStorage.GetPicture(
+						new PictureDefinition(
 							libraryBook.Book.PictureId,
-							FileManager.PictureSize._80x80)).bytes);
+							PictureSize._80x80)).bytes);
 		}
 		#endregion
 
-		#region IStreamable event handler overrides
-		public override void OnStreamingProgressChanged(object sender, DownloadProgress downloadProgress)
+		#region Streamable event handler overrides
+		public override void Streamable_StreamingProgressChanged(object sender, DownloadProgress downloadProgress)
 		{
+			base.Streamable_StreamingProgressChanged(sender, downloadProgress);
 			if (!downloadProgress.ProgressPercentage.HasValue)
 				return;
 
@@ -50,36 +54,48 @@ namespace LibationWinForms.BookLiberation
 				progressBar1.UIThreadAsync(() => progressBar1.Value = (int)downloadProgress.ProgressPercentage);
 		}
 
-		public override void OnStreamingTimeRemaining(object sender, TimeSpan timeRemaining)
-			=> updateRemainingTime((int)timeRemaining.TotalSeconds);
+		public override void Streamable_StreamingTimeRemaining(object sender, TimeSpan timeRemaining)
+		{
+			base.Streamable_StreamingTimeRemaining(sender, timeRemaining);
+			updateRemainingTime((int)timeRemaining.TotalSeconds);
+		}
 
 		#endregion
 
-		#region IAudioDecodable event handlers
-		public override void OnRequestCoverArt(object sender, Action<byte[]> setCoverArtDelegate)
-			=> setCoverArtDelegate(GetCoverArtDelegate?.Invoke());
-
-		public override void OnTitleDiscovered(object sender, string title)
+		#region AudioDecodable event handlers
+		public override void AudioDecodable_RequestCoverArt(object sender, Action<byte[]> setCoverArtDelegate)
 		{
+			base.AudioDecodable_RequestCoverArt(sender, setCoverArtDelegate);
+			setCoverArtDelegate(GetCoverArtDelegate?.Invoke());
+		}
+
+		public override void AudioDecodable_TitleDiscovered(object sender, string title)
+		{
+			base.AudioDecodable_TitleDiscovered(sender, title);
 			this.UIThreadAsync(() => this.Text = DecodeActionName + " " + title);
 			this.title = title;
 			updateBookInfo();
 		}
 
-		public override void OnAuthorsDiscovered(object sender, string authors)
+		public override void AudioDecodable_AuthorsDiscovered(object sender, string authors)
 		{
+			base.AudioDecodable_AuthorsDiscovered(sender, authors);
 			authorNames = authors;
 			updateBookInfo();
 		}
 
-		public override void OnNarratorsDiscovered(object sender, string narrators)
+		public override void AudioDecodable_NarratorsDiscovered(object sender, string narrators)
 		{
+			base.AudioDecodable_NarratorsDiscovered(sender, narrators);
 			narratorNames = narrators;
 			updateBookInfo();
 		}
 
-		public override void OnCoverImageDiscovered(object sender, byte[] coverArt) 
-			=> pictureBox1.UIThreadAsync(() => pictureBox1.Image = Dinah.Core.Drawing.ImageReader.ToImage(coverArt));
+		public override void AudioDecodable_CoverImageDiscovered(object sender, byte[] coverArt)
+		{
+			base.AudioDecodable_CoverImageDiscovered(sender, coverArt);
+			pictureBox1.UIThreadAsync(() => pictureBox1.Image = Dinah.Core.Drawing.ImageReader.ToImage(coverArt));
+		}
 		#endregion
 
 		// thread-safe UI updates
@@ -87,6 +103,15 @@ namespace LibationWinForms.BookLiberation
 			=> bookInfoLbl.UIThreadAsync(() => bookInfoLbl.Text = $"{title}\r\nBy {authorNames}\r\nNarrated by {narratorNames}");
 
 		private void updateRemainingTime(int remaining)
-			=> remainingTimeLbl.UIThreadAsync(() => remainingTimeLbl.Text = $"ETA:\r\n{remaining} sec");
+			=> remainingTimeLbl.UIThreadAsync(() => remainingTimeLbl.Text = $"ETA:\r\n{formatTime(remaining)}");
+
+		private string formatTime(int seconds)
+		{
+			var timeSpan = new TimeSpan(0, 0, seconds);
+			return
+				timeSpan.TotalHours >= 1 ? $"{timeSpan:%h}h {timeSpan:mm}m {timeSpan:ss}s"
+				: timeSpan.TotalMinutes >= 1 ? $"{timeSpan:%m}m {timeSpan:ss}s"
+				: $"{seconds} sec";
+		}
 	}
 }

LibationWinForms/BookLiberation/AudioDecryptForm.cs

@@ -1,6 +1,6 @@
-using DataLayer;
-using FileManager;
-using System;
+using System;
+using DataLayer;
+using LibationFileManager;
 
 namespace LibationWinForms.BookLiberation
 {
@@ -16,15 +16,18 @@ namespace LibationWinForms.BookLiberation
 		public override string DecodeActionName => "Decrypting";
 		#endregion
 
-		#region IProcessable event handler overrides
-		public override void OnBegin(object sender, LibraryBook libraryBook)
+		#region Processable event handler overrides
+		public override void Processable_Begin(object sender, LibraryBook libraryBook)
 		{
 			LogMe.Info($"Download & Decrypt Step, Begin: {libraryBook.Book}");
 
-			base.OnBegin(sender, libraryBook);
+			base.Processable_Begin(sender, libraryBook);
+		}
+		public override void Processable_Completed(object sender, LibraryBook libraryBook)
+		{
+			base.Processable_Completed(sender, libraryBook);
+			LogMe.Info($"Download & Decrypt Step, Completed: {libraryBook.Book}{Environment.NewLine}");
 		}
-		public override void OnCompleted(object sender, LibraryBook libraryBook)
-			=> LogMe.Info($"Download & Decrypt Step, Completed: {libraryBook.Book}{Environment.NewLine}");
 
 		#endregion
 	}

LibationWinForms/BookLiberation/BaseForms/LiberationBaseForm.cs

@@ -9,7 +9,7 @@ namespace LibationWinForms.BookLiberation.BaseForms
 {
 	public class LiberationBaseForm : Form
 	{
-		protected IStreamable Streamable { get; private set; }
+		protected Streamable Streamable { get; private set; }
 		protected LogMe LogMe { get; private set; }
 		private SynchronizeInvoker Invoker { get; init; } 
 
@@ -21,7 +21,7 @@ namespace LibationWinForms.BookLiberation.BaseForms
 			Invoker = new SynchronizeInvoker();
 		}
 
-		public void RegisterFileLiberator(IStreamable streamable, LogMe logMe = null)
+		public void RegisterFileLiberator(Streamable streamable, LogMe logMe = null)
 		{
 			if (streamable is null) return;
 
@@ -30,52 +30,52 @@ namespace LibationWinForms.BookLiberation.BaseForms
 
 			Subscribe(streamable);
 
-			if (Streamable is IProcessable processable)
+			if (Streamable is Processable processable)
 				Subscribe(processable);
-			if (Streamable is IAudioDecodable audioDecodable)
+			if (Streamable is AudioDecodable audioDecodable)
 				Subscribe(audioDecodable);
 		}
 
 		#region Event Subscribers and Unsubscribers
-		private void Subscribe(IStreamable streamable)
+		private void Subscribe(Streamable streamable)
 		{
 			UnsubscribeStreamable(this, EventArgs.Empty);
 
 			streamable.StreamingBegin += OnStreamingBeginShow;
-			streamable.StreamingBegin += OnStreamingBegin;
-			streamable.StreamingProgressChanged += OnStreamingProgressChanged;
-			streamable.StreamingTimeRemaining += OnStreamingTimeRemaining;
-			streamable.StreamingCompleted += OnStreamingCompleted;
+			streamable.StreamingBegin += Streamable_StreamingBegin;
+			streamable.StreamingProgressChanged += Streamable_StreamingProgressChanged;
+			streamable.StreamingTimeRemaining += Streamable_StreamingTimeRemaining;
+			streamable.StreamingCompleted += Streamable_StreamingCompleted;
 			streamable.StreamingCompleted += OnStreamingCompletedClose;
 
 			Disposed += UnsubscribeStreamable;
 		}
-		private void Subscribe(IProcessable processable)
+		private void Subscribe(Processable processable)
 		{
 			UnsubscribeProcessable(this, null);
 
-			processable.Begin += OnBegin;
-			processable.StatusUpdate += OnStatusUpdate;
-			processable.Completed += OnCompleted;
+			processable.Begin += Processable_Begin;
+			processable.StatusUpdate += Processable_StatusUpdate;
+			processable.Completed += Processable_Completed;
 
-			//The form is created on IProcessable.Begin and we
-			//dispose of it on IProcessable.Completed
+			//The form is created on Processable.Begin and we
+			//dispose of it on Processable.Completed
 			processable.Completed += OnCompletedDispose;
 
 			//Don't unsubscribe from Dispose because it fires when
-			//IStreamable.StreamingCompleted closes the form, and
-			//the IProcessable events need to live past that event.
+			//Streamable.StreamingCompleted closes the form, and
+			//the Processable events need to live past that event.
 			processable.Completed += UnsubscribeProcessable;
 		}
-		private void Subscribe(IAudioDecodable audioDecodable)
+		private void Subscribe(AudioDecodable audioDecodable)
 		{
 			UnsubscribeAudioDecodable(this, EventArgs.Empty);
 
-			audioDecodable.RequestCoverArt += OnRequestCoverArt;
-			audioDecodable.TitleDiscovered += OnTitleDiscovered;
-			audioDecodable.AuthorsDiscovered += OnAuthorsDiscovered;
-			audioDecodable.NarratorsDiscovered += OnNarratorsDiscovered;
-			audioDecodable.CoverImageDiscovered += OnCoverImageDiscovered;
+			audioDecodable.RequestCoverArt += AudioDecodable_RequestCoverArt;
+			audioDecodable.TitleDiscovered += AudioDecodable_TitleDiscovered;
+			audioDecodable.AuthorsDiscovered += AudioDecodable_AuthorsDiscovered;
+			audioDecodable.NarratorsDiscovered += AudioDecodable_NarratorsDiscovered;
+			audioDecodable.CoverImageDiscovered += AudioDecodable_CoverImageDiscovered;
 
 			Disposed += UnsubscribeAudioDecodable;
 		}
@@ -84,34 +84,34 @@ namespace LibationWinForms.BookLiberation.BaseForms
 			Disposed -= UnsubscribeStreamable;
 
 			Streamable.StreamingBegin -= OnStreamingBeginShow;
-			Streamable.StreamingBegin -= OnStreamingBegin;
-			Streamable.StreamingProgressChanged -= OnStreamingProgressChanged;
-			Streamable.StreamingTimeRemaining -= OnStreamingTimeRemaining;
-			Streamable.StreamingCompleted -= OnStreamingCompleted;
+			Streamable.StreamingBegin -= Streamable_StreamingBegin;
+			Streamable.StreamingProgressChanged -= Streamable_StreamingProgressChanged;
+			Streamable.StreamingTimeRemaining -= Streamable_StreamingTimeRemaining;
+			Streamable.StreamingCompleted -= Streamable_StreamingCompleted;
 			Streamable.StreamingCompleted -= OnStreamingCompletedClose;
 		}
 		private void UnsubscribeProcessable(object sender, LibraryBook e)
 		{
-			if (Streamable is not IProcessable processable)
+			if (Streamable is not Processable processable)
 				return;
 
 			processable.Completed -= UnsubscribeProcessable;
 			processable.Completed -= OnCompletedDispose;
-			processable.Completed -= OnCompleted;
-			processable.StatusUpdate -= OnStatusUpdate;
-			processable.Begin -= OnBegin;
+			processable.Completed -= Processable_Completed;
+			processable.StatusUpdate -= Processable_StatusUpdate;
+			processable.Begin -= Processable_Begin;
 		}
 		private void UnsubscribeAudioDecodable(object sender, EventArgs e)
 		{
-			if (Streamable is not IAudioDecodable audioDecodable)
+			if (Streamable is not AudioDecodable audioDecodable)
 				return;
 
 			Disposed -= UnsubscribeAudioDecodable;
-			audioDecodable.RequestCoverArt -= OnRequestCoverArt;
-			audioDecodable.TitleDiscovered -= OnTitleDiscovered;
-			audioDecodable.AuthorsDiscovered -= OnAuthorsDiscovered;
-			audioDecodable.NarratorsDiscovered -= OnNarratorsDiscovered;
-			audioDecodable.CoverImageDiscovered -= OnCoverImageDiscovered;
+			audioDecodable.RequestCoverArt -= AudioDecodable_RequestCoverArt;
+			audioDecodable.TitleDiscovered -= AudioDecodable_TitleDiscovered;
+			audioDecodable.AuthorsDiscovered -= AudioDecodable_AuthorsDiscovered;
+			audioDecodable.NarratorsDiscovered -= AudioDecodable_NarratorsDiscovered;
+			audioDecodable.CoverImageDiscovered -= AudioDecodable_CoverImageDiscovered;
 
 			audioDecodable.Cancel();
 		}
@@ -133,28 +133,30 @@ namespace LibationWinForms.BookLiberation.BaseForms
 		/// (ie. shown) because Control doesn't get a window handle until it is Shown.
 		/// </summary>
 		private void OnStreamingBeginShow(object sender, string beginString) => Invoker.UIThreadAsync(Show);
-		
+
 		#endregion
 
-		#region IStreamable event handlers
-		public virtual void OnStreamingBegin(object sender, string beginString) { }
-		public virtual void OnStreamingProgressChanged(object sender, DownloadProgress downloadProgress) { }
-		public virtual void OnStreamingTimeRemaining(object sender, TimeSpan timeRemaining) { }
-		public virtual void OnStreamingCompleted(object sender, string completedString) { }
+		#region Streamable event handlers
+		public virtual void Streamable_StreamingBegin(object sender, string beginString) { }
+		public virtual void Streamable_StreamingProgressChanged(object sender, DownloadProgress downloadProgress) { }
+		public virtual void Streamable_StreamingTimeRemaining(object sender, TimeSpan timeRemaining) { }
+		public virtual void Streamable_StreamingCompleted(object sender, string completedString) { }
+
 		#endregion
 
-		#region IProcessable event handlers
-		public virtual void OnBegin(object sender, LibraryBook libraryBook) { }
-		public virtual void OnStatusUpdate(object sender, string statusUpdate) { }
-		public virtual void OnCompleted(object sender, LibraryBook libraryBook) { }
+		#region Processable event handlers
+		public virtual void Processable_Begin(object sender, LibraryBook libraryBook) { }
+		public virtual void Processable_StatusUpdate(object sender, string statusUpdate) { }
+		public virtual void Processable_Completed(object sender, LibraryBook libraryBook) { }
+
 		#endregion
 
-		#region IAudioDecodable event handlers
-		public virtual void OnRequestCoverArt(object sender, Action<byte[]> setCoverArtDelegate) { }
-		public virtual void OnTitleDiscovered(object sender, string title) { }
-		public virtual void OnAuthorsDiscovered(object sender, string authors) { }
-		public virtual void OnNarratorsDiscovered(object sender, string narrators) { }
-		public virtual void OnCoverImageDiscovered(object sender, byte[] coverArt) { }
+		#region AudioDecodable event handlers
+		public virtual void AudioDecodable_RequestCoverArt(object sender, Action<byte[]> setCoverArtDelegate) { }
+		public virtual void AudioDecodable_TitleDiscovered(object sender, string title) { }
+		public virtual void AudioDecodable_AuthorsDiscovered(object sender, string authors) { }
+		public virtual void AudioDecodable_NarratorsDiscovered(object sender, string narrators) { }
+		public virtual void AudioDecodable_CoverImageDiscovered(object sender, byte[] coverArt) { }
 		#endregion
 	}
 }

LibationWinForms/BookLiberation/DownloadForm.cs

@@ -17,13 +17,15 @@ namespace LibationWinForms.BookLiberation
 		}
 
 
-		#region IStreamable event handler overrides
-		public override void OnStreamingBegin(object sender, string beginString)
+		#region Streamable event handler overrides
+		public override void Streamable_StreamingBegin(object sender, string beginString)
 		{
+			base.Streamable_StreamingBegin(sender, beginString);
 			filenameLbl.UIThreadAsync(() => filenameLbl.Text = beginString);
 		}
-		public override void OnStreamingProgressChanged(object sender, DownloadProgress downloadProgress)
+		public override void Streamable_StreamingProgressChanged(object sender, DownloadProgress downloadProgress)
 		{
+			base.Streamable_StreamingProgressChanged(sender, downloadProgress);
 			// this won't happen with download file. it will happen with download string
 			if (!downloadProgress.TotalBytesToReceive.HasValue || downloadProgress.TotalBytesToReceive.Value <= 0)
 				return;

LibationWinForms/BookLiberation/PdfDownloadForm.cs

@@ -4,7 +4,15 @@ namespace LibationWinForms.BookLiberation
 {
 	internal class PdfDownloadForm : DownloadForm
 	{
-		public override void OnBegin(object sender, LibraryBook libraryBook) => LogMe.Info($"PDF Step, Begin: {libraryBook.Book}");
-		public override void OnCompleted(object sender, LibraryBook libraryBook) => LogMe.Info($"PDF Step, Completed: {libraryBook.Book}");
+		public override void Processable_Begin(object sender, LibraryBook libraryBook)
+		{
+			base.Processable_Begin(sender, libraryBook);
+			LogMe.Info($"PDF Step, Begin: {libraryBook.Book}");
+		}
+		public override void Processable_Completed(object sender, LibraryBook libraryBook)
+		{
+			base.Processable_Completed(sender, libraryBook);
+			LogMe.Info($"PDF Step, Completed: {libraryBook.Book}");
+		}
 	}
 }