Added WIP media module. Returning releases from release search database function. Fixed page loop in update module.

src/media.js

@@ -1,9 +1,170 @@
 'use strict';
 
-function toBaseAvatars() {
+const Promise = require('bluebird');
+const nanoid = require('nanoid/non-secure');
 
+const logger = require('./logger')(__filename);
+const argv = require('./argv');
+const knex = require('./knex');
+const { get } = require('./utils/qu');
+
+function itemsByKey(items, key) {
+    return items.reduce((acc, item) => ({ ...acc, [item[key]]: item }), {});
+}
+
+function toBaseSource(rawSource) {
+    if (rawSource.src || (rawSource.extract && rawSource.url)) {
+        const baseSource = {};
+
+        if (rawSource.src) baseSource.src = rawSource.src;
+        if (rawSource.quality) baseSource.quality = rawSource.quality;
+        if (rawSource.type) baseSource.type = rawSource.type;
+
+        if (rawSource.url) baseSource.url = rawSource.url;
+        if (rawSource.extract) baseSource.extract = rawSource.extract;
+
+        return baseSource;
+    }
+
+    if (typeof rawSource === 'string') {
+        return {
+            src: rawSource,
+        };
+    }
+
+    return null;
+}
+
+function baseSourceToBaseMedia(baseSource) {
+    if (Array.isArray(baseSource)) {
+        if (baseSource.length > 0) {
+            return {
+                id: nanoid(),
+                sources: baseSource,
+            };
+        }
+
+        return null;
+    }
+
+    if (baseSource) {
+        return {
+            id: nanoid(),
+            sources: [baseSource],
+        };
+    }
+
+    return null;
+}
+
+function fallbackMediaToBaseMedia(rawMedia) {
+    const baseSources = rawMedia
+        .map(source => toBaseSource(source))
+        .filter(Boolean);
+
+    return baseSourceToBaseMedia(baseSources);
+}
+
+function toBaseMedias(rawMedias) {
+    if (!rawMedias || rawMedias.length === 0) {
+        return [];
+    }
+
+    return rawMedias.map((rawMedia) => {
+        if (!rawMedia) {
+            return null;
+        }
+
+        if (Array.isArray(rawMedia)) {
+            // fallback sources provided
+            return fallbackMediaToBaseMedia(rawMedia);
+        }
+
+        const baseSource = toBaseSource(rawMedia);
+
+        return baseSourceToBaseMedia(baseSource);
+    }).filter(Boolean);
+}
+
+async function findSourceDuplicates(baseMedias) {
+    const sourceUrls = baseMedias
+        .map(baseMedia => baseMedia.sources.map(source => source.src))
+        .flat()
+        .filter(Boolean);
+
+    const extractUrls = baseMedias
+        .map(baseMedia => baseMedia.sources.map(source => source.url))
+        .flat()
+        .filter(Boolean);
+
+
+    const [existingSourceMedia, existingExtractMedia] = await Promise.all([
+        knex('media').whereIn('source', sourceUrls),
+        knex('media').whereIn('source_page', extractUrls),
+    ]);
+
+    const existingSourceMediaByUrl = itemsByKey(existingSourceMedia, 'source');
+    const existingExtractMediaByUrl = itemsByKey(existingExtractMedia, 'source_page');
+
+    return {
+        existingSourceMediaByUrl,
+        existingExtractMediaByUrl,
+    };
+}
+
+async function extractSource(baseSource) {
+    if (!baseSource.extract || !baseSource.url) {
+        return baseSource;
+    }
+
+    const res = await get(baseSource.url);
+
+    console.log(res);
+    return baseSource;
+}
+
+async function fetchSource(baseSource, { existingSourceMediaByUrl, existingExtractMediaByUrl }) {
+    // attempts
+    // extract
+    const extractedSource = await extractSource(baseSource, existingExtractMediaByUrl);
+
+    console.log(extractedSource);
+}
+
+async function fetchMedia(baseMedia, existingMedias) {
+    await baseMedia.sources.reduce((result, baseSource, _baseSourceIndex) => result.catch(async () => {
+        await fetchSource(baseSource, existingMedias);
+    }), Promise.reject(new Error()));
+}
+
+async function storeMedias(baseMedias) {
+    const { existingSourceMediaByUrl, existingExtractMediaByUrl } = await findSourceDuplicates(baseMedias);
+
+    await Promise.map(baseMedias, async baseMedia => fetchMedia(baseMedia, { existingSourceMediaByUrl, existingExtractMediaByUrl }));
+
+    console.log(existingSourceMediaByUrl, existingExtractMediaByUrl);
+}
+
+async function associateReleaseMedia(releases) {
+    if (!argv.media) {
+        return;
+    }
+
+    const baseMediasByReleaseId = releases.reduce((acc, release) => ({
+        ...acc,
+        [release.id]: {
+            poster: argv.images && argv.poster && toBaseMedias([release.poster]),
+            photos: argv.images && argv.photos && toBaseMedias(release.photos),
+            trailer: argv.videos && argv.trailer && toBaseMedias([release.trailer]),
+            teaser: argv.videos && argv.teaser && toBaseMedias([release.teaser]),
+        },
+    }), {});
+
+    const baseMedias = Object.values(baseMediasByReleaseId).map(releaseMedia => Object.values(releaseMedia)).flat(2);
+
+    await storeMedias(baseMedias);
 }
 
 module.exports = {
-
+    associateReleaseMedia,
 };