Added actor assignment to new actors module. Showing network icon on network-specific actors. Improved dark theme. Changed tag tile design. Added Digital Playground logos.

src/actors.js

@@ -1,57 +1,74 @@
 'use strict';
 
+const logger = require('./logger')(__filename);
 const knex = require('./knex');
 const slugify = require('./utils/slugify');
 const capitalize = require('./utils/capitalize');
 
 function toBaseActors(actorsOrNames, release) {
     return actorsOrNames.map((actorOrName) => {
+        const name = capitalize(actorOrName.name || actorOrName);
+        const slug = slugify(name);
+
+        const baseActor = {
+            name,
+            slug,
+            hasSingleName: name.split(/\s+/).length === 1,
+            network: release.site.network,
+            slugWithNetworkSlug: `${slug}-${release.site.network.slug}`,
+        };
+
         if (actorOrName.name) {
             return {
                 ...actorOrName,
-                name: capitalize(actorOrName.name),
-                slug: slugify(actorOrName.name),
-                networkId: release.site.network.id,
+                ...baseActor,
             };
         }
 
-        return {
-            name: capitalize(actorOrName),
-            slug: slugify(actorOrName),
-            networkId: release.site.network.id,
-        };
+        return baseActor;
     });
 }
 
 function curateActorEntry(baseActor) {
-    const actorEntry = {
+    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,
+        };
+    }
+
+    return {
         name: baseActor.name,
         slug: baseActor.slug,
     };
-
-    if (baseActor.name.split(/\s+/).length === 1) {
-        // attach network ID for single names, to reduce mismatches
-        actorEntry.network_id = baseActor.networkId;
-    }
-
-    return actorEntry;
 }
 
 function curateActorEntries(baseActors) {
     return baseActors.map(baseActor => curateActorEntry(baseActor));
 }
 
-async function getActors(baseActors) {
+async function getOrCreateActors(baseActors) {
     const existingActors = await knex('actors')
+        .select('id', 'name', 'slug', 'network_id')
         .whereIn('slug', baseActors.map(baseActor => baseActor.slug))
-        .orWhereIn('name', baseActors.map(baseActor => baseActor.slug));
+        .whereNull('network_id')
+        .orWhereIn(['slug', 'network_id'], baseActors.map(baseActor => [baseActor.slugWithNetworkSlug, baseActor.network.id]));
 
-    if (existingActors.length === 0) {
-        // TODO: TESTING ONLY
-        await knex('actors').insert(curateActorEntries(baseActors.slice(0, 3)));
+    const existingActorSlugs = new Set(existingActors.map(actor => actor.slug));
+    const uniqueBaseActors = baseActors.filter(baseActor => !existingActorSlugs.has(baseActor.slug) && !existingActorSlugs.has(baseActor.slugWithNetworkSlug));
+
+    const curatedActorEntries = curateActorEntries(uniqueBaseActors);
+    const newActors = await knex('actors').insert(curatedActorEntries, ['id', 'name', 'slug', 'network_id']);
+
+    if (Array.isArray(newActors)) {
+        return newActors.concat(existingActors);
     }
 
-    console.log(existingActors);
+    return existingActors;
 }
 
 async function associateActors(releases) {
@@ -67,9 +84,18 @@ async function associateActors(releases) {
     const baseActorsBySlug = baseActors.reduce((acc, baseActor) => ({ ...acc, [baseActor.slug]: baseActor }), {});
     const uniqueBaseActors = Object.values(baseActorsBySlug);
 
-    const actors = await getActors(uniqueBaseActors);
+    const actors = await getOrCreateActors(uniqueBaseActors);
+    const actorIdsBySlug = actors.reduce((acc, actor) => ({ ...acc, [actor.slug]: actor.id }), {});
 
-    console.log(actors);
+    const releaseActorAssociations = Object.entries(baseActorsByReleaseId)
+        .map(([releaseId, releaseActors]) => releaseActors
+            .map(releaseActor => ({
+                release_id: releaseId,
+                actor_id: actorIdsBySlug[releaseActor.slug] || actorIdsBySlug[releaseActor.slugWithNetworkSlug],
+            })))
+        .flat();
+
+    await knex.raw(`${knex('releases_actors').insert(releaseActorAssociations).toString()} ON CONFLICT DO NOTHING;`);
 }
 
 module.exports = {

src/web/plugins/actors.js

@@ -11,14 +11,14 @@ const schemaExtender = makeExtendSchemaPlugin(_build => ({
             IMPERIAL
         }
 
-      extend type ActorProfile {
+      extend type Actor {
         age: Int @requires(columns: ["birthdate"])
         height(units:Units): String @requires(columns: ["height"])
         weight(units:Units): String @requires(columns: ["weight"])
       }
     `,
     resolvers: {
-        ActorProfile: {
+        Actor: {
             age(parent, _args, _context, _info) {
                 if (!parent.birthdate) return null;