traxxx/src/media.js

'use strict';

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,
};