Associating actors without network.

src/actors.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const logger = require('./logger')(__filename);
+// const logger = require('./logger')(__filename);
 const knex = require('./knex');
 const slugify = require('./utils/slugify');
 const capitalize = require('./utils/capitalize');
@@ -13,9 +13,7 @@ function toBaseActors(actorsOrNames, release) {
         const baseActor = {
             name,
             slug,
-            hasSingleName: name.split(/\s+/).length === 1,
             network: release.site.network,
-            slugWithNetworkSlug: `${slug}-${release.site.network.slug}`,
         };
 
         if (actorOrName.name) {
@@ -29,39 +27,38 @@ function toBaseActors(actorsOrNames, release) {
     });
 }
 
-function curateActorEntry(baseActor) {
-    if (baseActor.hasSingleName) {
-        logger.warn(`Assigning single name actor '${baseActor.name}' to network '${baseActor.network.name}'`);
-
-        // attach network ID to allow separating actors with the same name
-        return {
-            name: baseActor.name,
-            slug: baseActor.slugWithNetworkSlug,
-            network_id: baseActor.network.id,
-        };
-    }
-
+function curateActorEntry(baseActor, batchId) {
     return {
         name: baseActor.name,
         slug: baseActor.slug,
+        network_id: null,
+        batch_id: batchId,
     };
 }
 
-function curateActorEntries(baseActors) {
-    return baseActors.map(baseActor => curateActorEntry(baseActor));
+function curateActorEntries(baseActors, batchId) {
+    return baseActors.map(baseActor => curateActorEntry(baseActor, batchId));
 }
 
-async function getOrCreateActors(baseActors) {
+async function getOrCreateActors(baseActors, batchId) {
     const existingActors = await knex('actors')
         .select('id', 'name', 'slug', 'network_id')
         .whereIn('slug', baseActors.map(baseActor => baseActor.slug))
         .whereNull('network_id')
-        .orWhereIn(['slug', 'network_id'], baseActors.map(baseActor => [baseActor.slugWithNetworkSlug, baseActor.network.id]));
+        .orWhereIn(['slug', 'network_id'], baseActors.map(baseActor => [baseActor.slug, baseActor.network.id]));
 
-    const existingActorSlugs = new Set(existingActors.map(actor => actor.slug));
-    const uniqueBaseActors = baseActors.filter(baseActor => !existingActorSlugs.has(baseActor.slug) && !existingActorSlugs.has(baseActor.slugWithNetworkSlug));
+    // const existingActorSlugs = new Set(existingActors.map(actor => actor.slug));
+    const existingActorSlugs = existingActors.reduce((acc, actor) => ({
+        ...acc,
+        [actor.network_id]: {
+            ...acc[actor.network_id],
+            [actor.slug]: true,
+        },
+    }), {});
 
-    const curatedActorEntries = curateActorEntries(uniqueBaseActors);
+    const uniqueBaseActors = baseActors.filter(baseActor => !existingActorSlugs[baseActor.network.id]?.[baseActor.slug] && !existingActorSlugs.null?.[baseActor.slug]);
+
+    const curatedActorEntries = curateActorEntries(uniqueBaseActors, batchId);
     const newActors = await knex('actors').insert(curatedActorEntries, ['id', 'name', 'slug', 'network_id']);
 
     if (Array.isArray(newActors)) {
@@ -71,7 +68,7 @@ async function getOrCreateActors(baseActors) {
     return existingActors;
 }
 
-async function associateActors(releases) {
+async function associateActors(releases, batchId) {
     const baseActorsByReleaseId = releases.reduce((acc, release) => {
         if (release.actors) {
             acc[release.id] = toBaseActors(release.actors, release);
@@ -86,17 +83,32 @@ async function associateActors(releases) {
         return;
     }
 
-    const baseActorsBySlug = baseActors.reduce((acc, baseActor) => ({ ...acc, [baseActor.slug]: baseActor }), {});
-    const uniqueBaseActors = Object.values(baseActorsBySlug);
+    // const baseActorsBySlug = baseActors.reduce((acc, baseActor) => ({ ...acc, [baseActor.slug]: baseActor }), {});
+    const baseActorsBySlugAndNetworkId = baseActors.reduce((acc, baseActor) => ({
+        ...acc,
+        [baseActor.slug]: {
+            ...acc[baseActor.slug],
+            [baseActor.network.id]: baseActor,
+        },
+    }), {});
 
-    const actors = await getOrCreateActors(uniqueBaseActors);
-    const actorIdsBySlug = actors.reduce((acc, actor) => ({ ...acc, [actor.slug]: actor.id }), {});
+    const uniqueBaseActors = Object.values(baseActorsBySlugAndNetworkId).map(baseActorsByNetworkId => Object.values(baseActorsByNetworkId)).flat();
+
+    const actors = await getOrCreateActors(uniqueBaseActors, batchId);
+    // const actorIdsBySlug = actors.reduce((acc, actor) => ({ ...acc, [actor.slug]: actor.id }), {});
+    const actorIdsBySlugAndNetworkId = actors.reduce((acc, actor) => ({
+        ...acc,
+        [actor.network_id]: {
+            ...acc[actor.network_id],
+            [actor.slug]: actor.id,
+        },
+    }), {});
 
     const releaseActorAssociations = Object.entries(baseActorsByReleaseId)
         .map(([releaseId, releaseActors]) => releaseActors
             .map(releaseActor => ({
                 release_id: releaseId,
-                actor_id: actorIdsBySlug[releaseActor.slug] || actorIdsBySlug[releaseActor.slugWithNetworkSlug],
+                actor_id: actorIdsBySlugAndNetworkId[releaseActor.network.id]?.[releaseActor.slug] || actorIdsBySlugAndNetworkId.null[releaseActor.slug],
             })))
         .flat();