@agility/cli/dist/lib/mappers/asset-mapper.js

Agility CLI for working with your content. (Public Beta)

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AssetMapper = void 0;
var core_1 = require("../../core");
var AssetMapper = /** @class */ (function () {
    function AssetMapper(sourceGuid, targetGuid) {
        this.sourceGuid = sourceGuid;
        this.targetGuid = targetGuid;
        this.directory = 'assets';
        // this will provide access to the /agility-files/{GUID} folder
        this.fileOps = new core_1.fileOperations(targetGuid);
        this.mappings = this.loadMapping();
    }
    AssetMapper.prototype.getAssetMapping = function (asset, type) {
        var mapping = this.mappings.find(function (m) { return type === 'source' ? m.sourceMediaID === asset.mediaID : m.targetMediaID === asset.mediaID; });
        if (!mapping)
            return null;
        return mapping;
    };
    AssetMapper.prototype.getAssetMappingByMediaID = function (mediaID, type) {
        var mapping = this.mappings.find(function (m) { return type === 'source' ? m.sourceMediaID === mediaID : m.targetMediaID === mediaID; });
        if (!mapping)
            return null;
        return mapping;
    };
    AssetMapper.prototype.getAssetMappingByMediaUrl = function (url, type) {
        var mapping = this.mappings.find(function (m) { return type === 'source' ? m.sourceUrl === url : m.targetUrl === url; });
        if (!mapping)
            return null;
        return mapping;
    };
    AssetMapper.prototype.getMappedEntity = function (mapping, type) {
        var guid = type === 'source' ? mapping.sourceGuid : mapping.targetGuid;
        var mediaID = type === 'source' ? mapping.sourceMediaID : mapping.targetMediaID;
        var fileOps = new core_1.fileOperations(guid);
        var mediaFilePath = fileOps.getDataFilePath("assets/".concat(mediaID, ".json"));
        var mediaData = fileOps.readJsonFile(mediaFilePath);
        if (!mediaData)
            return null;
        return mediaData;
    };
    AssetMapper.prototype.addMapping = function (sourceAsset, targetAsset) {
        var mapping = this.getAssetMapping(targetAsset, 'target');
        if (mapping) {
            this.updateMapping(sourceAsset, targetAsset);
        }
        else {
            var newMapping = {
                sourceGuid: this.sourceGuid,
                targetGuid: this.targetGuid,
                sourceDateModified: sourceAsset.dateModified,
                targetDateModified: targetAsset.dateModified,
                sourceMediaID: sourceAsset.mediaID,
                targetMediaID: targetAsset.mediaID,
                sourceUrl: sourceAsset.edgeUrl,
                targetUrl: targetAsset.edgeUrl,
            };
            this.mappings.push(newMapping);
        }
        this.saveMapping();
    };
    AssetMapper.prototype.updateMapping = function (sourceAsset, targetAsset) {
        var mapping = this.getAssetMapping(targetAsset, 'target');
        if (mapping) {
            mapping.sourceGuid = this.sourceGuid;
            mapping.targetGuid = this.targetGuid;
            mapping.sourceDateModified = sourceAsset.dateModified;
            mapping.targetDateModified = targetAsset.dateModified;
            mapping.sourceMediaID = sourceAsset.mediaID;
            mapping.targetMediaID = targetAsset.mediaID;
            mapping.sourceUrl = sourceAsset.edgeUrl;
            mapping.targetUrl = targetAsset.edgeUrl;
        }
        this.saveMapping();
    };
    AssetMapper.prototype.loadMapping = function () {
        var mapping = this.fileOps.getMappingFile(this.directory, this.sourceGuid, this.targetGuid);
        return mapping;
    };
    AssetMapper.prototype.saveMapping = function () {
        this.fileOps.saveMappingFile(this.mappings, this.directory, this.sourceGuid, this.targetGuid);
    };
    AssetMapper.prototype.hasSourceChanged = function (sourceAsset) {
        if (!sourceAsset)
            return false;
        var mapping = this.getAssetMapping(sourceAsset, 'source');
        if (!mapping)
            return false;
        var sourceDate = new Date(sourceAsset.dateModified);
        var mappingDate = new Date(mapping.sourceDateModified);
        return sourceDate > mappingDate;
    };
    AssetMapper.prototype.hasTargetChanged = function (targetAsset) {
        if (!targetAsset)
            return false;
        var mapping = this.getAssetMapping(targetAsset, 'target');
        if (!mapping)
            return false;
        var targetDate = new Date(targetAsset.dateModified);
        var mappingDate = new Date(mapping.targetDateModified);
        return targetDate > mappingDate;
    };
    return AssetMapper;
}());
exports.AssetMapper = AssetMapper;
//# sourceMappingURL=asset-mapper.js.map