@neoskop/paperboy-source-magnolia/dist/dam.util.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const fs = require("fs-extra");
const request = require("request");
const retry = require("retry");
function fetchDamAssets(uuids, options) {
    return new Promise(resolve => {
        const operation = retry.operation();
        const damUrl = options.magnolia.url + options.magnolia.damJsonEndpoint;
        request.get(damUrl, {
            json: true,
            headers: {
                Authorization: options.magnolia.auth.header,
                'User-Agent': 'Paperboy'
            }
        }, (err, res, body) => __awaiter(this, void 0, void 0, function* () {
            if (operation.retry(err)) {
                console.error('Attempt to get asset information failed, will retry in some time...');
                return;
            }
            if (body && body.results && body.results.length > 0) {
                const sanitizedAssetJson = uuids
                    .map(uuid => body.results.find((asset) => asset['jcr:uuid'] === uuid || asset['@id'] === uuid))
                    .map(json => json ? sanitizeDamJson(json) : null);
                const assetsNeedingUpdate = sanitizedAssetJson.filter(asset => {
                    if (asset) {
                        const filePath = options.output.assets + asset.path;
                        const fileExists = fs.existsSync(filePath);
                        if (fileExists) {
                            return (new Date(fs.statSync(filePath).mtime).getTime() <
                                new Date(asset.lastModified).getTime());
                        }
                    }
                    return true;
                });
                yield Promise.all(assetsNeedingUpdate.map(asset => downloadAsset(options, asset)));
                resolve(sanitizedAssetJson);
            }
        }));
    });
}
exports.fetchDamAssets = fetchDamAssets;
function sanitizeDamJson(damJson) {
    const sanitized = {};
    Object.keys(damJson).forEach((key) => __awaiter(this, void 0, void 0, function* () {
        const sanitizedKey = key
            .replace(/^@path/, 'path')
            .replace(/^@/, '')
            .replace(/^mgnl:/, '')
            .replace(/^jcr:uuid/, 'id')
            .replace(/^jcr:mimeType/, 'mimeType');
        if (!sanitizedKey.match(/^jcr:/)) {
            sanitized[sanitizedKey] = damJson[key];
        }
    }));
    return sanitized;
}
function downloadAsset(options, asset) {
    return new Promise(resolve => {
        if (asset) {
            const filePath = options.output.assets + asset.path;
            const directory = filePath
                .split('/')
                .slice(0, -1)
                .join('/');
            fs.mkdirpSync(directory);
            request
                .get(options.magnolia.url + '/dam/jcr:' + asset.id, {
                headers: {
                    Authorization: options.magnolia.auth.header,
                    'User-Agent': 'Paperboy'
                }
            })
                .on('response', res => {
                res.pipe(fs.createWriteStream(filePath));
                res.on('end', () => {
                    resolve();
                });
            });
        }
        else {
            resolve();
        }
    });
}
//# sourceMappingURL=dam.util.js.map