Move source code into "Source" folder

Source/AudibleUtilities/Account.cs

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

Source/AudibleUtilities/AccountsSettings.cs

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

Source/AudibleUtilities/AccountsSettingsPersister.cs

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

Source/AudibleUtilities/ApiExtended.cs

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

Source/AudibleUtilities/AudibleApiStorage.cs

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

Source/AudibleUtilities/AudibleApiValidators.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using AudibleApi.Common;
+
+namespace AudibleUtilities
+{
+	public interface IValidator
+	{
+		IEnumerable<Exception> Validate(IEnumerable<Item> items);
+	}
+	public class LibraryValidator : IValidator
+	{
+		public IEnumerable<Exception> Validate(IEnumerable<Item> items)
+		{
+			var exceptions = new List<Exception>();
+
+			if (items.Any(i => string.IsNullOrWhiteSpace(i.ProductId)))
+				exceptions.Add(new ArgumentException($"Collection contains item(s) with null or blank {nameof(Item.ProductId)}", nameof(items)));
+			if (items.Any(i => i.DateAdded < new DateTime(1980, 1, 1)))
+				exceptions.Add(new ArgumentException($"Collection contains item(s) with invalid {nameof(Item.DateAdded)}", nameof(items)));
+
+			return exceptions;
+		}
+	}
+	public class BookValidator : IValidator
+	{
+		public IEnumerable<Exception> Validate(IEnumerable<Item> items)
+		{
+			var exceptions = new List<Exception>();
+
+			// a book having no authors is rare but allowed
+
+			if (items.Any(i => string.IsNullOrWhiteSpace(i.ProductId)))
+				exceptions.Add(new ArgumentException($"Collection contains item(s) with blank {nameof(Item.ProductId)}", nameof(items)));
+
+			// this can happen with podcast episodes
+			foreach (var i in items.Where(i => string.IsNullOrWhiteSpace(i.Title)))
+				i.Title = "[blank title]";
+
+			return exceptions;
+		}
+	}
+	public class CategoryValidator : IValidator
+	{
+		public IEnumerable<Exception> Validate(IEnumerable<Item> items)
+		{
+			var exceptions = new List<Exception>();
+
+			var distinct = items.GetCategoriesDistinct();
+			if (distinct.Any(s => s.CategoryId is null))
+				exceptions.Add(new ArgumentException($"Collection contains {nameof(Item.Categories)} with null {nameof(Ladder.CategoryId)}", nameof(items)));
+			if (distinct.Any(s => s.CategoryName is null))
+				exceptions.Add(new ArgumentException($"Collection contains {nameof(Item.Categories)} with null {nameof(Ladder.CategoryName)}", nameof(items)));
+
+			return exceptions;
+		}
+	}
+	public class ContributorValidator : IValidator
+	{
+		public IEnumerable<Exception> Validate(IEnumerable<Item> items)
+		{
+			var exceptions = new List<Exception>();
+
+			if (items.GetAuthorsDistinct().Any(a => string.IsNullOrWhiteSpace(a.Name)))
+				exceptions.Add(new ArgumentException($"Collection contains {nameof(Item.Authors)} with null {nameof(Person.Name)}", nameof(items)));
+			if (items.GetNarratorsDistinct().Any(a => string.IsNullOrWhiteSpace(a.Name)))
+				exceptions.Add(new ArgumentException($"Collection contains {nameof(Item.Narrators)} with null {nameof(Person.Name)}", nameof(items)));
+
+			return exceptions;
+		}
+	}
+	public class SeriesValidator : IValidator
+	{
+		public IEnumerable<Exception> Validate(IEnumerable<Item> items)
+		{
+			var exceptions = new List<Exception>();
+
+			var distinct = items.GetSeriesDistinct();
+			if (distinct.Any(s => s.SeriesId is null))
+				exceptions.Add(new ArgumentException($"Collection contains {nameof(Item.Series)} with null {nameof(Series.SeriesId)}", nameof(items)));
+			if (distinct.Any(s => s.SeriesName is null))
+				exceptions.Add(new ArgumentException($"Collection contains {nameof(Item.Series)} with null {nameof(Series.SeriesName)}", nameof(items)));
+
+			return exceptions;
+		}
+	}
+}

Source/AudibleUtilities/AudibleUtilities.csproj

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

Source/AudibleUtilities/_InternalsVisible.cs

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