Refactored media module. Returning 320p and 720p videos from MindGeek as teasers instead of trailers.

src/releases.js

@@ -10,20 +10,11 @@ const argv = require('./argv');
 const whereOr = require('./utils/where-or');
 const { associateTags } = require('./tags');
 const { associateActors, scrapeBasicActors } = require('./actors');
-/*
 const {
-    createMediaDirectory,
-    storePhotos,
-    // storeReleasePhotos,
-    storeTrailer,
-    storeReleaseMedia,
+    pluckItems,
+    storeMedia,
+    associateMedia,
 } = require('./media');
-*/
-const {
-    createMediaDirectory,
-    storePhotos,
-    storeTrailer,
-} = require('./media_legacy');
 const { fetchSites, findSiteByUrl } = require('./sites');
 const slugify = require('./utils/slugify');
 
@@ -337,55 +328,39 @@ function accumulateMovies(releases) {
 }
 
 async function storeReleaseAssets(releases) {
-    // await storeReleasePhotos(releases);
+    const releasePostersById = releases.reduce((acc, release) => ({ ...acc, [release.id]: [release.poster] }), {});
+    const releaseCoversById = releases.reduce((acc, release) => ({ ...acc, [release.id]: release.covers }), {});
+    const releaseTrailersById = releases.reduce((acc, release) => ({ ...acc, [release.id]: [release.trailer] }), {});
+    const releaseTeasersById = releases.reduce((acc, release) => ({ ...acc, [release.id]: [release.teaser] }), {});
+    const releasePhotosById = releases.reduce((acc, release) => ({
+        ...acc,
+        [release.id]: pluckItems(release.photos),
+    }), {});
 
-    // return storeReleaseMedia(releases);
+    const [posters, covers] = await Promise.all([
+        storeMedia(Object.values(releasePostersById).flat(), 'release', 'poster'),
+        storeMedia(Object.values(releaseCoversById).flat(), 'release', 'cover'),
+    ]);
 
-    await Promise.map(releases, async (release) => {
-        const subpath = `${release.site.network.slug}/${release.site.slug}/${release.id}/`;
-        const identifier = `"${release.title}" (${release.id})`;
+    // ensure posters are available before fetching supplementary media
+    await Promise.all([
+        associateMedia(releasePostersById, posters, 'release', 'poster'),
+        associateMedia(releaseCoversById, covers, 'release', 'cover'),
+    ]);
 
-        try {
-            await createMediaDirectory('releases', subpath);
+    const photos = await storeMedia(Object.values(releasePhotosById).flat(), 'release', 'photo');
+    await associateMedia(releasePhotosById, photos, 'release', 'photo');
 
-            // don't use Promise.all to prevent concurrency issues with duplicate detection
-            if (release.poster) {
-                await storePhotos([release.poster], {
-                    role: 'poster',
-                    targetId: release.id,
-                    subpath,
-                }, identifier);
-            }
+    // videos take a long time, fetch last
+    const [trailers, teasers] = await Promise.all([
+        storeMedia(Object.values(releaseTrailersById).flat(), 'release', 'trailer'),
+        storeMedia(Object.values(releaseTeasersById).flat(), 'release', 'teaser'),
+    ]);
 
-            await storePhotos(release.photos, {
-                targetId: release.id,
-                subpath,
-                primaryRole: release.poster ? null : 'poster',
-            }, identifier);
-
-            await storePhotos(release.covers, {
-                role: 'cover',
-                targetId: release.id,
-                subpath,
-            }, identifier);
-
-            await storeTrailer(release.trailer, {
-                targetId: release.id,
-                subpath,
-                role: 'trailer',
-            }, identifier);
-
-            await storeTrailer(release.teaser, {
-                targetId: release.id,
-                subpath,
-                role: 'teaser',
-            }, identifier);
-        } catch (error) {
-            logger.error(error.message);
-        }
-    }, {
-        concurrency: 10,
-    });
+    await Promise.all([
+        associateMedia(releaseTrailersById, trailers, 'release', 'trailer'),
+        associateMedia(releaseTeasersById, teasers, 'release', 'teaser'),
+    ]);
 }
 
 async function storeRelease(release) {
@@ -453,6 +428,8 @@ async function storeReleases(releases) {
         concurrency: 10,
     }).filter(release => release);
 
+    logger.info(`Stored ${storedReleases.length} new releases`);
+
     const actors = accumulateActors(storedReleases);
     const movies = accumulateMovies(storedReleases);