Improved static overrides so that artwork and join URL can have distinct sources

Author: sdasda7777

config/dummy

@@ -1,41 +1,42 @@
 
 // Include your static overrides here
-// Overrides may use album artist name or album name in keys, most specific combination being used first
-// Overrides must contain fetchedFrom, artworkUrl and joinUrl in aggregate value to be used
+// Override's key may use album artist name or album name, most specific combination being used first
+// Override's value must contain artworkFrom and artworkUrl or joinFrom and joinUrl or all four
 // For example:
 /*
 module.exports = [
   {key: {albumArtist: "Artist1", albumName: "Album1"},
-   value: {fetchedFrom: "Example1", artworkUrl: "example1.jpg", joinUrl: "example1"}},
+   value: {artworkFrom: "Example1", artworkUrl: "example1.jpg", joinFrom: "Example1", joinUrl: "example1"}},
 
   {key: {albumName: "Album2"},
    value: {joinUrl: "example2a"}},
   {key: {albumArtist: "Artist1", albumName: "Album2"},
-   value: {fetchedFrom: "Example2b", artworkUrl: "example2b.jpg", joinUrl: "example2b"}},
+   value: {artworkFrom: "Example2b", artworkUrl: "example2b.jpg", joinFrom: "Example2b", joinUrl: "example2b"}},
 
   {key: {albumArtist: "Artist1"},
-   value: {fetchedFrom: "Example3", artworkUrl: "example3.jpg"}},
-  {key: {albumName: "Album3"},
-   value: {joinUrl: "example3"}},
+   value: {artworkFrom: "Example3", artworkUrl: "example3.jpg"}},
+
+  {key: {albumName: "Album4"},
+   value: {joinFrom: "Example4", joinUrl: "example4.jpg"}},
 ]
 */
 // will return:
 
 //   for "Album1" by "Artist1":
-//     {fetchedFrom: "Example1", artworkUrl: "example1.jpg", joinUrl: "example1"}
-//       (no tricks here, key is exact match and values are complete)
+//     {artworkFrom: "Example1", artworkUrl: "example1.jpg", joinFrom: "Example1", joinUrl: "example1"}
+//       (no tricks here, the key is an exact match)
 
 //   for "Album2" by "Artist1":
-//     {fetchedFrom: "Example2b", artworkUrl: "example2b.jpg", joinUrl: "example2b"}
+//     {artworkFrom: "Example2b", artworkUrl: "example2b.jpg", joinFrom: "Example2b", joinUrl: "example2b"}
 //       (because the most specific key is used first)
 
 //   for "Album3" by "Artist1":
-//     {fetchedFrom: "Example3", artworkUrl: "example3.jpg", joinUrl: "example3"}
-//       (because partial information gets combined)
+//     {fetchedFrom: "Example3", artworkUrl: "example3.jpg"}
+//       (because it is the best match for given album)
 
-//   for "Album4" by "Artist1" or "Album1", "Album2", "Album3" by "Artist2":
-//     nothing
-//       (because some values wouldn't be set)
+//   for "Album4" by "Artist1":
+//     {artworkFrom: "Example3", artworkUrl: "example3.jpg", joinFrom: "Example4", joinUrl: "example4.jpg"}
+//       (partial matches for "Album4" and "Artist1" get combined)
 
 
 module.exports = [

src/helpers/configs/default_staticoverrides.js

@@ -81,14 +81,18 @@ const fetchers = {
  * Safe wrapper for calling a fetcher in try-catch block
  * @param {string} fetcherName name of the fetcher to use
  * @param {Object} metadata    VLC metadata
- * @returns {!{fetchedFrom: string, artworkUrl: string, joinUrl: string}}
+ * @returns {!{artworkFrom: string, artworkUrl: string, joinFrom: string, joinUrl: string}}
  */
 async function fetchSafely(fetcherName, metadata)
 {
   let returnValue;
   try
   {
     returnValue = await fetchers[fetcherName](metadata);
+    if (returnValue && fetcherName !== "staticoverrides")
+    {
+      returnValue.artworkFrom = returnValue.joinFrom = returnValue.fetchedFrom;
+    }
   }
   catch (err)
   {
@@ -105,19 +109,19 @@ async function fetchSafely(fetcherName, metadata)
  * @param {string} preferredArtworkProvider name of preferred artwork fetcher
  * @param {string} preferredJoinProvider    name of preferred join fetcher
  * @param {Object} metadata                 VLC metadata
- * @returns {!{artworkUrl: string, artworkFrom: string, joinUrl: string, joinFrom: string}}
+ * @returns {!{artworkFrom: string, artworkUrl: string, joinFrom: string, joinUrl: string}}
  */
 async function combinedFetch(preferredArtworkProvider, preferredJoinProvider, metadata)
 {
-  let artworkUrl, artworkFrom, joinUrl, joinFrom;
+  let artworkFrom, artworkUrl, joinFrom, joinUrl;
   let results = [];
 
   // First try fetching artwork URL using preferred provider
   results[preferredArtworkProvider] = await fetchSafely(preferredArtworkProvider, metadata);
   if(results[preferredArtworkProvider].artworkUrl)
   {
+    artworkFrom = results[preferredArtworkProvider].artworkFrom;
     artworkUrl = results[preferredArtworkProvider].artworkUrl;
-    artworkFrom = results[preferredArtworkProvider].fetchedFrom;
   }
 
   // Next try fetching join URL from preferred provider
@@ -128,20 +132,20 @@ async function combinedFetch(preferredArtworkProvider, preferredJoinProvider, me
   // Set it separately, in case both preferred providers are the same
   if (results[preferredJoinProvider].joinUrl)
   {
+    joinFrom = results[preferredJoinProvider].joinFrom;
     joinUrl = results[preferredJoinProvider].joinUrl;
-    joinFrom = results[preferredJoinProvider].fetchedFrom;
   }
 
   // Try using preferred join provider as a backup artwork provider and vice versa
   if (!artworkUrl && results[preferredJoinProvider].artworkUrl)
   {
+    artworkFrom = results[preferredJoinProvider].artworkFrom;
     artworkUrl = results[preferredJoinProvider].artworkUrl;
-    artworkFrom = results[preferredJoinProvider].fetchedFrom;
   }
   if (!joinUrl && results[preferredArtworkProvider].joinUrl)
   {
+    joinFrom = results[preferredArtworkProvider].joinFrom;
     joinUrl = results[preferredArtworkProvider].joinUrl;
-    joinFrom = results[preferredArtworkProvider].fetchedFrom;
   }
 
   // In case either still isn't set, iterate all other providers
@@ -153,13 +157,13 @@ async function combinedFetch(preferredArtworkProvider, preferredJoinProvider, me
       results[availableProviderNames[ii]] = await fetchSafely(availableProviderNames[ii], metadata);
       if(!artworkUrl && results[availableProviderNames[ii]].artworkUrl)
       {
+        artworkFrom = results[availableProviderNames[ii]].artworkFrom;
         artworkUrl = results[availableProviderNames[ii]].artworkUrl;
-        artworkFrom = results[availableProviderNames[ii]].fetchedFrom;
       }
       if (!joinUrl && results[availableProviderNames[ii]].joinUrl)
       {
+        joinFrom = results[availableProviderNames[ii]].joinFrom;
         joinUrl = results[availableProviderNames[ii]].joinUrl;
-        joinFrom = results[availableProviderNames[ii]].fetchedFrom;
       }
     }
   }

src/rpc/format.js

@@ -1,56 +1,65 @@
-
-class StaticOverridesFetcher
-{
-  /** Overrides data to use */
-  #data
-
-  constructor(rawData)
-  {
-    this.#data = {};
-    for (let v of rawData)
-    {
-      // Use key stringified with sorted keys
-      this.#data[JSON.stringify(v.key, Object.keys(v.key).sort())] = v.value;
-    }
-  }
-
-  fetch(metadata)
-  {
-    let result = {};
-
-    for (let v of StaticOverridesFetcher.createPowerset(metadata.ALBUMARTIST,
-                                                        metadata.album))
-    {
-      let lookup_result = this.#data[JSON.stringify(v)];
-
-      if (lookup_result)
-      {
-        if (!result.fetchedFrom && lookup_result.fetchedFrom)
-          result.fetchedFrom = lookup_result.fetchedFrom;
-        if (!result.artworkUrl && lookup_result.artworkUrl)
-          result.artworkUrl = lookup_result.artworkUrl;
-        if (!result.joinUrl && lookup_result.joinUrl)
-          result.joinUrl = lookup_result.joinUrl;
-
-        if (result.fetchedFrom && result.artworkUrl && result.joinUrl)
-          return result;
-      }
-    }
-  }
-
-  static createPowerset(albumArtist, albumName)
-  {
-    let result = [];
-
-    if (albumArtist && albumName)
-      result.push({albumArtist, albumName});
-    if (albumArtist)
-      result.push({albumArtist});
-    if (albumName)
-      result.push({albumName});
-
-    return result;
-  }
-}
-
-module.exports = StaticOverridesFetcher;
+
+/**
+ * Fetcher of static overrides
+ */
+class StaticOverridesFetcher
+{
+  /** @type {!Object} #data structure for storing the lookup data */
+  #data = {};
+
+  constructor(rawData)
+  {
+    for (let v of rawData)
+    {
+      // Use key stringified with sorted keys
+      this.#data[JSON.stringify(v.key, Object.keys(v.key).sort())] = v.value;
+    }
+  }
+
+  /**
+   * @param {!Object} VLC metadata
+   * @returns {!{artworkFrom: ?string, artworkUrl: ?string, joinFrom: ?string, joinUrl: ?string}}
+   */
+  fetch(metadata)
+  {
+    let result = {};
+
+    for (let v of StaticOverridesFetcher.createPowerset(metadata.ALBUMARTIST || metadata.artist,
+                                                        metadata.album))
+    {
+      let lookup_result = this.#data[JSON.stringify(v)];
+
+      if (lookup_result)
+      {
+        if (!result.artworkUrl && lookup_result.artworkUrl)
+        {
+          result.artworkFrom = lookup_result.artworkFrom;
+          result.artworkUrl = lookup_result.artworkUrl;
+        }
+        if (!result.joinUrl && lookup_result.joinUrl)
+        {
+          result.joinFrom = lookup_result.joinFrom;
+          result.joinUrl = lookup_result.joinUrl;
+        }
+      }
+    }
+
+    return result;
+  }
+
+  static createPowerset(albumArtist, albumName)
+  {
+    let result = [];
+
+    if (albumArtist && albumName)
+      result.push({albumArtist, albumName});
+    if (albumArtist)
+      result.push({albumArtist});
+    if (albumName)
+      result.push({albumName});
+
+    return result;
+  }
+}
+
+module.exports = StaticOverridesFetcher;