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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const fs = require("fs");
const request = require("request");
const retry = require("retry");
function fetchSitemap(options) {
    return loadDataFromMagnolia({
        authHeader: options.magnolia.auth.header,
        url: options.magnolia.url + options.magnolia.sitemapEndpoint,
        errorMessage: "Attempt to get the sitemap failed, will retry in some time...",
        resolverHandler: body => body,
        retryOptions: { forever: true }
    });
}
exports.fetchSitemap = fetchSitemap;
function fetchWorkspace(workspace, options) {
    return loadDataFromMagnolia({
        authHeader: options.magnolia.auth.header,
        url: options.magnolia.url + "/.rest/delivery/" + workspace + "/v1",
        errorMessage: `Attempt to get workspace ${workspace} failed, will retry in some time...`,
        resolverHandler: body => body.results
    });
}
exports.fetchWorkspace = fetchWorkspace;
function fetchPages(options) {
    return loadDataFromMagnolia({
        authHeader: options.magnolia.auth.header,
        url: options.magnolia.url + options.magnolia.pagesEndpoint,
        errorMessage: `Attempt to get pages failed, will retry in some time...`,
        resolverHandler: body => body.results
    });
}
exports.fetchPages = fetchPages;
function loadDataFromMagnolia(params) {
    const operation = retry.operation(params.retryOptions);
    return new Promise(resolve => {
        operation.attempt(() => {
            request.get(params.url, {
                json: true,
                headers: {
                    Authorization: params.authHeader,
                    "User-Agent": "Paperboy"
                },
                timeout: 60 * 1000
            }, (error, response, body) => {
                const operationError = error ||
                    (response && response.statusCode !== 200
                        ? new Error(`Return code was: ${response.statusCode}`)
                        : undefined);
                if (operation.retry(operationError)) {
                    console.error(params.errorMessage);
                    if (error) {
                        console.error(error);
                    }
                    return;
                }
                resolve(params.resolverHandler(body));
            });
        });
    });
}
function writePagesFile(pages, options) {
    return new Promise((resolve, reject) => {
        if (!fs.existsSync(options.output.json)) {
            fs.mkdirSync(options.output.json);
        }
        fs.writeFile(options.output.json + "/pages.json", JSON.stringify(pages), err => {
            if (err) {
                reject(err);
            }
            resolve();
        });
    });
}
exports.writePagesFile = writePagesFile;
function writeWorkspaceFile(workspace, workspaceData, options) {
    return new Promise((resolve, reject) => {
        if (!fs.existsSync(options.output.json)) {
            fs.mkdirSync(options.output.json);
        }
        fs.writeFile(options.output.json + "/" + workspace + ".json", JSON.stringify(workspaceData), err => {
            if (err) {
                reject(err);
            }
            resolve();
        });
    });
}
exports.writeWorkspaceFile = writeWorkspaceFile;
function sanitizeJson(json, damAssets, pages, sourceOptions, workspaces = {}) {
    const sanitized = {};
    if (json) {
        Object.keys(json).forEach(key => {
            const isKeyExcluded = sourceOptions &&
                sourceOptions.output.excludedProperties &&
                sourceOptions.output.excludedProperties.findIndex(prop => prop === key) > -1;
            if (!isKeyExcluded && key === "@nodes") {
                const contentOrder = json[key];
                if (contentOrder.length > 0) {
                    sanitized[key.substr(1)] = contentOrder.map(contentKeyIndex => sanitizeJson(json[contentKeyIndex], damAssets, pages, sourceOptions, workspaces));
                }
            }
            else if (!isKeyExcluded && key !== "content" && !key.match(/^\d+$/)) {
                const originalKey = key;
                const sanitizedKey = key
                    .replace(/^@/, "")
                    .replace(/^mgnl:/, "")
                    .replace(/^jcr:uuid/, "id");
                if (!sanitizedKey.match(/^jcr:/)) {
                    if (typeof json[key] === "object" && !Array.isArray(json[key])) {
                        sanitized[sanitizedKey] = sanitizeJson(json[key], damAssets, pages, sourceOptions, workspaces);
                    }
                    else {
                        let items = Array.isArray(json[key]) ? json[key] : [json[key]];
                        items = items.map((item) => {
                            if (item.match(/^jcr:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/)) {
                                const uuid = item.replace("jcr:", "");
                                return damAssets.find(damAsset => damAsset && damAsset.id === uuid);
                            }
                            else if (!originalKey.match(/^@/) &&
                                !originalKey.match(/^jcr:uuid/) &&
                                item.match(/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/)) {
                                const node = getPopulatedNode(item, pages);
                                let value;
                                if (node) {
                                    value = Object.assign(node || {}, {
                                        workspace: "website"
                                    });
                                }
                                else {
                                    const asset = getPopulatedNode(item, damAssets);
                                    if (asset) {
                                        value = Object.assign(asset || {}, {
                                            workspace: "dam"
                                        });
                                    }
                                    else {
                                        value = {};
                                        Object.keys(workspaces)
                                            .forEach(key => {
                                            const foundItem = getPopulatedNode(item, workspaces[key]);
                                            if (foundItem) {
                                                value = Object.assign({}, foundItem, { workspace: key });
                                            }
                                        });
                                    }
                                }
                                return value;
                            }
                            else {
                                return item;
                            }
                        });
                        sanitized[sanitizedKey] = Array.isArray(json[key])
                            ? items
                            : items[0];
                    }
                }
            }
        });
    }
    return sanitized;
}
exports.sanitizeJson = sanitizeJson;
function getPopulatedNode(id, source, populatedNode) {
    if (populatedNode || !source) {
        return populatedNode;
    }
    else {
        if (source["jcr:uuid"] === id || source.id === id) {
            populatedNode = {
                id,
                path: source["@path"] || source.path
            };
        }
        else {
            Object.keys(source).forEach(key => {
                if (source[key] && typeof source[key] === "object") {
                    populatedNode = getPopulatedNode(id, source[key], populatedNode);
                }
            });
        }
        return populatedNode;
    }
}
exports.getPopulatedNode = getPopulatedNode;
//# sourceMappingURL=pages.util.js.map