v5.2.0

Added MP3 support to settings.

.gitignore

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

AaxDecrypter/AaxDecrypter.csproj

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

AaxDecrypter/AaxcDownloadConverter.cs

@@ -0,0 +1,228 @@
+using AAXClean;
+using Dinah.Core;
+using Dinah.Core.Diagnostics;
+using Dinah.Core.IO;
+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<int> DecryptProgressUpdate;
+        public event EventHandler<TimeSpan> DecryptTimeRemaining;
+        public string AppName { get; set; } = nameof(AaxcDownloadConverter);
+        public string OutputFileName { get; private set; }
+
+        private string cacheDir { get; }
+        private DownloadLicense downloadLicense { get; }
+        private AaxFile aaxFile;
+        private byte[] coverArt;
+        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,
+            };
+        }
+
+        public void SetCoverArt(byte[] coverArt)
+        {
+            if (coverArt is null) return;
+
+            this.coverArt = 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 thaan ~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();
+            }
+            nfsPersister.NetworkFileStream.BeginDownloading();
+
+            aaxFile = new AaxFile(nfsPersister.NetworkFileStream);
+            coverArt = aaxFile.AppleTags.Cover;
+
+            RetrievedTags?.Invoke(this, aaxFile.AppleTags);
+            RetrievedCoverArt?.Invoke(this, coverArt);
+
+            return !isCanceled;
+        }
+        private NetworkFileStreamPersister NewNetworkFilePersister()
+        {
+            var headers = new System.Net.WebHeaderCollection();
+            headers.Add("User-Agent", downloadLicense.UserAgent);
+
+            NetworkFileStream networkFileStream = new NetworkFileStream(tempFile, new Uri(downloadLicense.DownloadUrl), 0, headers);
+            return new NetworkFileStreamPersister(networkFileStream, jsonDownloadState);
+        }
+
+        public bool Step2_DownloadAndCombine()
+        {
+
+            DecryptProgressUpdate?.Invoke(this, 0);
+
+            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;
+
+            if (decryptionResult == ConversionResult.NoErrorsDetected
+                && coverArt is not null
+                && OutputFormat == OutputFormat.Mp4a)
+            {
+                //This handles a special case where the aaxc file doesn't contain cover art and
+                //Libation downloaded it instead (Animal Farm). Currently only works for Mp4a files.
+                using var decryptedBook = new Mp4File(OutputFileName, FileAccess.ReadWrite);
+                decryptedBook.AppleTags?.SetCoverArt(coverArt);
+                decryptedBook.Save();
+                decryptedBook.Close();
+            }
+
+            nfsPersister.Dispose();
+
+            DecryptProgressUpdate?.Invoke(this, 0);
+
+            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, (int)progressPercent);
+        }
+
+        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();
+        }
+    }
+}

AaxDecrypter/Cue.cs

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

AaxDecrypter/DownloadLicense.cs

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

AaxDecrypter/NFO.cs

@@ -0,0 +1,54 @@
+using AAXClean;
+using Dinah.Core;
+
+namespace AaxDecrypter
+{
+    public static class NFO
+    {
+        public static string CreateContents(string ripper, AAXClean.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 AAX\r\n"
+                + $" Source Sample Rate:     {aaxcTagLib.TimeScale} Hz\r\n"
+                + $" Source Channels:        {aaxcTagLib.AudioChannels}\r\n"
+                + $" Source Bitrate:         {aaxcTagLib.AverageBitrate} Kbps\r\n"
+                + "\r\n"
+                + " Lossless Encode:        Yes\r\n"
+                + " Encoded Codec:          AAC / M4B\r\n"
+                + $" Encoded Sample Rate:    {aaxcTagLib.TimeScale} Hz\r\n"
+                + $" Encoded Channels:       {aaxcTagLib.AudioChannels}\r\n"
+                + $" Encoded Bitrate:        {aaxcTagLib.AverageBitrate} Kbps\r\n"
+                + "\r\n"
+                + $" Ripper:                 {ripper}\r\n"
+                + "\r\n"
+                + "\r\n"
+                + "Book Description\r\n"
+                + "================\r\n"
+                + (!string.IsNullOrWhiteSpace(aaxcTagLib.AppleTags.LongDescription) ? aaxcTagLib.AppleTags.LongDescription.UnicodeToAscii() : aaxcTagLib.AppleTags.Comment?.UnicodeToAscii());
+
+            return nfoString;
+        }
+    }
+}

AaxDecrypter/NetworkFileStream.cs

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

AaxDecrypter/NetworkFileStreamPersister.cs

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

AaxDecrypter/UNTESTED/AaxToM4bConverter.cs

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

AaxDecrypter/UNTESTED/BytesCracker.cs

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

AaxDecrypter/UNTESTED/BytesCrackerSupportLibraries.cs

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

AaxDecrypter/UNTESTED/Chapters.cs

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

AaxDecrypter/UNTESTED/DecryptSupportLibraries.cs

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

AaxDecrypter/UNTESTED/EncodingInfo.cs

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

AaxDecrypter/UNTESTED/NFO.cs

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

AaxDecrypter/UNTESTED/Tags.cs

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

ApplicationServices/ApplicationServices.csproj

@@ -5,8 +5,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="CsvHelper" Version="16.0.0" />
-    <PackageReference Include="NPOI" Version="2.5.1" />
+    <PackageReference Include="CsvHelper" Version="27.1.1" />
+    <PackageReference Include="NPOI" Version="2.5.3" />
   </ItemGroup>
 
   <ItemGroup>

ApplicationServices/LibraryCommands.cs

@@ -35,7 +35,7 @@ namespace ApplicationServices
 			}
 			catch (AudibleApi.Authentication.LoginFailedException lfEx)
 			{
-				lfEx.MoveResponseBodyFile(FileManager.Configuration.Instance.LibationFiles);
+				lfEx.SaveFiles(FileManager.Configuration.Instance.LibationFiles);
 
 				// nuget Serilog.Exceptions would automatically log custom properties
 				//   However, it comes with a scary warning when used with EntityFrameworkCore which I'm not yet ready to implement:
@@ -46,7 +46,7 @@ namespace ApplicationServices
 					ResponseStatusCodeNumber = (int)lfEx.ResponseStatusCode,
 					ResponseStatusCodeDesc = lfEx.ResponseStatusCode,
 					lfEx.ResponseInputFields,
-					lfEx.ResponseBodyFilePath
+					lfEx.ResponseBodyFilePaths
 				});
 				throw;
 			}

DataLayer/DataLayer.csproj

@@ -12,13 +12,12 @@
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="5.0.0">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="5.0.5">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="5.0.0" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="5.0.0" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="5.0.0">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="5.0.5" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="5.0.5">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>

DataLayer/LibationContext.cs

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

DataLayer/LibationContextFactory.cs

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

DataLayer/Migrations/20210619030017_AddAaxcDecryptionKeys.Designer.cs

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

DataLayer/Migrations/20210619030017_AddAaxcDecryptionKeys.cs

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

DataLayer/Migrations/20210622205558_RemoveAaxcDecryptionKeys.Designer.cs

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

DataLayer/Migrations/20210622205558_RemoveAaxcDecryptionKeys.cs

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

DataLayer/Migrations/LibationContextModelSnapshot.cs

@@ -14,7 +14,7 @@ namespace DataLayer.Migrations
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "3.1.7");
+                .HasAnnotation("ProductVersion", "5.0.5");
 
             modelBuilder.Entity("DataLayer.Book", b =>
                 {
@@ -244,6 +244,8 @@ namespace DataLayer.Migrations
 
                             b1.WithOwner("Book")
                                 .HasForeignKey("BookId");
+
+                            b1.Navigation("Book");
                         });
 
                     b.OwnsOne("DataLayer.UserDefinedItem", "UserDefinedItem", b1 =>
@@ -282,7 +284,19 @@ namespace DataLayer.Migrations
                                     b2.WithOwner()
                                         .HasForeignKey("UserDefinedItemBookId");
                                 });
+
+                            b1.Navigation("Book");
+
+                            b1.Navigation("Rating");
                         });
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Rating");
+
+                    b.Navigation("Supplements");
+
+                    b.Navigation("UserDefinedItem");
                 });
 
             modelBuilder.Entity("DataLayer.BookContributor", b =>
@@ -298,6 +312,10 @@ namespace DataLayer.Migrations
                         .HasForeignKey("ContributorId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
+
+                    b.Navigation("Book");
+
+                    b.Navigation("Contributor");
                 });
 
             modelBuilder.Entity("DataLayer.Category", b =>
@@ -305,6 +323,8 @@ namespace DataLayer.Migrations
                     b.HasOne("DataLayer.Category", "ParentCategory")
                         .WithMany()
                         .HasForeignKey("ParentCategoryCategoryId");
+
+                    b.Navigation("ParentCategory");
                 });
 
             modelBuilder.Entity("DataLayer.LibraryBook", b =>
@@ -314,6 +334,8 @@ namespace DataLayer.Migrations
                         .HasForeignKey("DataLayer.LibraryBook", "BookId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
+
+                    b.Navigation("Book");
                 });
 
             modelBuilder.Entity("DataLayer.SeriesBook", b =>
@@ -329,6 +351,27 @@ namespace DataLayer.Migrations
                         .HasForeignKey("SeriesId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
+
+                    b.Navigation("Book");
+
+                    b.Navigation("Series");
+                });
+
+            modelBuilder.Entity("DataLayer.Book", b =>
+                {
+                    b.Navigation("ContributorsLink");
+
+                    b.Navigation("SeriesLink");
+                });
+
+            modelBuilder.Entity("DataLayer.Contributor", b =>
+                {
+                    b.Navigation("BooksLink");
+                });
+
+            modelBuilder.Entity("DataLayer.Series", b =>
+                {
+                    b.Navigation("BooksLink");
                 });
 #pragma warning restore 612, 618
         }

DataLayer/UNTESTED/_scratch pad/ScratchPad.cs

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

DataLayer/appsettings.json

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

DtoImporterService/BookImporter.cs

@@ -67,6 +67,9 @@ namespace DtoImporterService
 		{
 			var item = importItem.DtoItem;
 
+			//Add any subtitle after the title title.
+			var title = item.Title + (!string.IsNullOrWhiteSpace(item.Subtitle) ? $": {item.Subtitle}" : "");
+
 			// absence of authors is very rare, but possible
 			if (!item.Authors?.Any() ?? true)
 				item.Authors = new[] { new Person { Name = "", Asin = null } };
@@ -102,7 +105,7 @@ namespace DtoImporterService
 
 			var book = DbContext.Books.Add(new Book(
 				new AudibleProductId(item.ProductId),
-				item.Title,
+				title,
 				item.Description,
 				item.LengthInMinutes,
 				authors,

FileLiberator/BackupBook.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Linq;
 using System.Threading.Tasks;
 using DataLayer;
 using Dinah.Core.ErrorHandling;
@@ -21,8 +20,7 @@ namespace FileLiberator
         public event EventHandler<string> StatusUpdate;
         public event EventHandler<LibraryBook> Completed;
 
-        public DownloadBook DownloadBook { get; } = new DownloadBook();
-        public DecryptBook DecryptBook { get; } = new DecryptBook();
+        public DownloadDecryptBook DecryptBook { get; } = new DownloadDecryptBook();
 		public DownloadPdf DownloadPdf { get; } = new DownloadPdf();
 
 		public bool Validate(LibraryBook libraryBook)
@@ -36,12 +34,6 @@ namespace FileLiberator
 
             try
 			{
-				{
-					var statusHandler = await DownloadBook.TryProcessAsync(libraryBook);
-					if (statusHandler.HasErrors)
-						return statusHandler;
-				}
-
 				{
 					var statusHandler = await DecryptBook.TryProcessAsync(libraryBook);
 					if (statusHandler.HasErrors)

FileLiberator/DownloadDecryptBook.cs

@@ -0,0 +1,225 @@
+using DataLayer;
+using Dinah.Core;
+using Dinah.Core.ErrorHandling;
+using FileManager;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using AaxDecrypter;
+using AudibleApi;
+
+namespace FileLiberator
+{
+    public class DownloadDecryptBook : IDecryptable
+    {
+        public event EventHandler<Action<byte[]>> RequestCoverArt;
+        public event EventHandler<LibraryBook> Begin;
+        public event EventHandler<string> DecryptBegin;
+        public event EventHandler<string> TitleDiscovered;
+        public event EventHandler<string> AuthorsDiscovered;
+        public event EventHandler<string> NarratorsDiscovered;
+        public event EventHandler<byte[]> CoverImageFilepathDiscovered;
+        public event EventHandler<int> UpdateProgress;
+        public event EventHandler<TimeSpan> UpdateRemainingTime;
+        public event EventHandler<string> DecryptCompleted;
+        public event EventHandler<LibraryBook> Completed;
+        public event EventHandler<string> StatusUpdate;
+
+        private AaxcDownloadConverter aaxcDownloader;
+        public async Task<StatusHandler> ProcessAsync(LibraryBook libraryBook)
+        {
+            Begin?.Invoke(this, libraryBook);
+
+            try
+            {
+                if (AudibleFileStorage.Audio.Exists(libraryBook.Book.AudibleProductId))
+                    return new StatusHandler { "Cannot find decrypt. Final audio file already exists" };
+
+                var outputAudioFilename = await aaxToM4bConverterDecryptAsync(AudibleFileStorage.DownloadsInProgress, AudibleFileStorage.DecryptInProgress, libraryBook);
+
+                // decrypt failed
+                if (outputAudioFilename is null)
+                    return new StatusHandler { "Decrypt failed" };
+
+                // moves files and returns dest dir
+                _ = moveFilesToBooksDir(libraryBook.Book, outputAudioFilename);
+
+                var finalAudioExists = AudibleFileStorage.Audio.Exists(libraryBook.Book.AudibleProductId);
+                if (!finalAudioExists)
+                    return new StatusHandler { "Cannot find final audio file after decryption" };
+
+                return new StatusHandler();
+            }
+            finally
+            {
+                Completed?.Invoke(this, libraryBook);
+            }
+        }
+
+        private async Task<string> aaxToM4bConverterDecryptAsync(string cacheDir, string destinationDir, LibraryBook libraryBook)
+        {
+            DecryptBegin?.Invoke(this, $"Begin decrypting {libraryBook}");
+
+            try
+            {
+                validate(libraryBook);
+
+                var api = await InternalUtilities.AudibleApiActions.GetApiAsync(libraryBook.Account, libraryBook.Book.Locale);
+
+                var contentLic = await api.GetDownloadLicenseAsync(libraryBook.Book.AudibleProductId);
+
+                var aaxcDecryptDlLic = new DownloadLicense
+                    (
+                    contentLic.ContentMetadata?.ContentUrl?.OfflineUrl,
+                    contentLic.Voucher?.Key,
+                    contentLic.Voucher?.Iv,
+                    Resources.UserAgent
+                    );
+
+                if (Configuration.Instance.AllowLibationFixup)
+                {
+                    aaxcDecryptDlLic.ChapterInfo = new AAXClean.ChapterInfo();
+
+                    foreach (var chap in contentLic.ContentMetadata?.ChapterInfo?.Chapters)
+                        aaxcDecryptDlLic.ChapterInfo.AddChapter(chap.Title, TimeSpan.FromMilliseconds(chap.LengthMs));
+                }
+
+
+                var format = Configuration.Instance.DecryptToLossy ? OutputFormat.Mp3 : OutputFormat.Mp4a;
+
+                var extension = format switch
+                {
+                    OutputFormat.Mp4a => "m4b",
+                    OutputFormat.Mp3 => "mp3",
+                    _ => throw new NotImplementedException(),
+                };
+
+                 var proposedOutputFile = Path.Combine(destinationDir, $"{PathLib.ToPathSafeString(libraryBook.Book.Title)} [{libraryBook.Book.AudibleProductId}].{extension}");
+
+
+                aaxcDownloader = new AaxcDownloadConverter(proposedOutputFile, cacheDir, aaxcDecryptDlLic, format) { AppName = "Libation" };
+                aaxcDownloader.DecryptProgressUpdate += (s, progress) => UpdateProgress?.Invoke(this, progress);
+                aaxcDownloader.DecryptTimeRemaining += (s, remaining) => UpdateRemainingTime?.Invoke(this, remaining);
+                aaxcDownloader.RetrievedCoverArt += AaxcDownloader_RetrievedCoverArt;
+                aaxcDownloader.RetrievedTags += aaxcDownloader_RetrievedTags;
+
+                // REAL WORK DONE HERE
+                var success = await Task.Run(() => aaxcDownloader.Run());
+
+                // decrypt failed
+                if (!success)
+                    return null;
+
+                return aaxcDownloader.OutputFileName;
+            }
+            finally
+            {
+                DecryptCompleted?.Invoke(this, $"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)
+            {
+                CoverImageFilepathDiscovered?.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 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);
+
+            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);
+            }
+
+            return destinationDir;
+        }
+
+        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)
+		{
+			string errorString(string field)
+				=> $"{errorTitle()}\r\nCannot download book. {field} is not known. Try re-importing the account which owns this book.";
+
+			string errorTitle()
+			{
+				var title
+					= (libraryBook.Book.Title.Length > 53)
+					? $"{libraryBook.Book.Title.Truncate(50)}..."
+					: libraryBook.Book.Title;
+				var errorBookTitle = $"{title} [{libraryBook.Book.AudibleProductId}]";
+				return errorBookTitle;
+			};
+
+			if (string.IsNullOrWhiteSpace(libraryBook.Account))
+				throw new Exception(errorString("Account"));
+
+			if (string.IsNullOrWhiteSpace(libraryBook.Book.Locale))
+				throw new Exception(errorString("Locale"));
+		}
+
+        public bool Validate(LibraryBook libraryBook)
+            => !AudibleFileStorage.Audio.Exists(libraryBook.Book.AudibleProductId);
+
+        public void Cancel()
+        {
+            aaxcDownloader?.Cancel();
+        }
+    }
+}

FileLiberator/DownloadFile.cs

@@ -6,6 +6,7 @@ using Dinah.Core.Net.Http;
 namespace FileLiberator
 {
 	// frustratingly copy pasta from DownloadableBase and DownloadPdf
+	// currently only used to download the .zip flies for upgrade
 	public class DownloadFile : IDownloadable
 	{
 		public event EventHandler<string> DownloadBegin;

FileLiberator/DownloadPdf.cs

@@ -1,5 +1,4 @@
-using System;
-using System.IO;
+using System.IO;
 using System.Linq;
 using System.Net.Http;
 using System.Threading.Tasks;

FileLiberator/IDecryptable.cs

@@ -6,12 +6,15 @@ namespace FileLiberator
     {
         event EventHandler<string> DecryptBegin;
 
+        event EventHandler<Action<byte[]>> RequestCoverArt;
         event EventHandler<string> TitleDiscovered;
         event EventHandler<string> AuthorsDiscovered;
         event EventHandler<string> NarratorsDiscovered;
         event EventHandler<byte[]> CoverImageFilepathDiscovered;
         event EventHandler<int> UpdateProgress;
+        event EventHandler<TimeSpan> UpdateRemainingTime;
 
         event EventHandler<string> DecryptCompleted;
+        void Cancel();
     }
 }