wip-backup-manager
Version:
This utility enables backup & restore of Kentico Kontent projects
893 lines • 50.8 kB
JavaScript
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
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) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var kontent_core_1 = require("@kentico/kontent-core");
var kontent_management_1 = require("@kentico/kontent-management");
var core_1 = require("../core");
var ImportService = /** @class */ (function () {
function ImportService(config) {
this.config = config;
this.defaultLanguageId = '00000000-0000-0000-0000-000000000000';
/**
* Maximum allowed size of asset in Bytes.
* Currently 1e8 = 100 MB
*/
this.maxAllowedAssetSizeInBytes = 1e8;
this.client = new kontent_management_1.ManagementClient({
apiKey: config.apiKey,
projectId: config.projectId,
retryStrategy: {
addJitter: true,
canRetryError: function (err) { return true; },
maxAttempts: 3,
deltaBackoffMs: 1000,
maxCumulativeWaitTimeMs: 60000
},
httpService: new kontent_core_1.HttpService({
axiosRequestConfig: {
// required for uploading large files
// https://github.com/axios/axios/issues/1362
maxContentLength: 'Infinity'
}
})
});
}
ImportService.prototype.importFromSourceAsync = function (sourceData) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.importAsync(sourceData)];
case 1: return [2 /*return*/, _a.sent()];
}
});
});
};
ImportService.prototype.importAsync = function (sourceData) {
return __awaiter(this, void 0, void 0, function () {
var importedItems, importedAssetFolders, importedLanguages, importedTaxonomies, importedAssets, importedContentItems, importedLanguageVariants;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
importedItems = [];
if (this.config.enableLog) {
console.log("Translating object ids to codenames");
}
// translate ids to codenames for certain objects types
this.translateIds(sourceData);
if (this.config.enableLog) {
console.log("Removing skipped items");
}
// this is an optional step where users can exclude certain objects from being
// imported via import configuration.
this.removeSkippedItemsFromImport(sourceData);
if (this.config.enableLog) {
console.log("Importing data");
}
return [4 /*yield*/, this.importAssetFoldersAsync(sourceData.assetFolders, importedItems)];
case 1:
importedAssetFolders = _a.sent();
importedItems.push.apply(importedItems, importedAssetFolders);
return [4 /*yield*/, this.importLanguagesAsync(sourceData.importData.languages)];
case 2:
importedLanguages = _a.sent();
importedItems.push.apply(importedItems, importedLanguages);
return [4 /*yield*/, this.importTaxonomiesAsync(sourceData.importData.taxonomies)];
case 3:
importedTaxonomies = _a.sent();
importedItems.push.apply(importedItems, importedTaxonomies);
// ### Content types & snippets
return [4 /*yield*/, this.importContentTypeSnippetsAsync(sourceData.importData.contentTypeSnippets)];
case 4:
// ### Content types & snippets
_a.sent();
return [4 /*yield*/, this.importContentTypesAsync(sourceData.importData.contentTypes)];
case 5:
_a.sent();
return [4 /*yield*/, this.importAssetsAsync(sourceData.importData.assets, sourceData.binaryFiles, importedItems)];
case 6:
importedAssets = _a.sent();
importedItems.push.apply(importedItems, importedAssets);
return [4 /*yield*/, this.importContentItemAsync(sourceData.importData.contentItems)];
case 7:
importedContentItems = _a.sent();
importedItems.push.apply(importedItems, importedContentItems);
return [4 /*yield*/, this.importLanguageVariantsAsync(sourceData.importData.languageVariants, importedItems)];
case 8:
importedLanguageVariants = _a.sent();
importedItems.push.apply(importedItems, importedLanguageVariants);
if (this.config.enableLog) {
console.log("Finished importing data");
}
return [2 /*return*/, importedItems];
}
});
});
};
ImportService.prototype.translateIds = function (source) {
// in following objects replace id references with external ids
core_1.translationHelper.replaceIdReferencesWithExternalId(source.importData.taxonomies);
core_1.translationHelper.replaceIdReferencesWithExternalId(source.importData.contentTypeSnippets);
core_1.translationHelper.replaceIdReferencesWithExternalId(source.importData.contentTypes);
// in following objects replace id references with codename
core_1.translationHelper.replaceIdReferencesWithCodenames(source.importData.languages, source.importData, {});
core_1.translationHelper.replaceIdReferencesWithCodenames(source.importData.assets, source.importData, {});
core_1.translationHelper.replaceIdReferencesWithCodenames(source.importData.contentItems, source.importData, {});
core_1.translationHelper.replaceIdReferencesWithCodenames(source.importData.languageVariants, source.importData, {});
};
ImportService.prototype.removeSkippedItemsFromImport = function (source) {
if (this.config.process && this.config.process.asset) {
var _loop_1 = function (item) {
var shouldImport = this_1.config.process.asset(item);
if (!shouldImport) {
source.importData.assets = source.importData.assets.filter(function (m) { return m.id !== item.id; });
}
};
var this_1 = this;
for (var _i = 0, _a = source.importData.assets; _i < _a.length; _i++) {
var item = _a[_i];
_loop_1(item);
}
}
if (this.config.process && this.config.process.language) {
var _loop_2 = function (item) {
var shouldImport = this_2.config.process.language(item);
if (!shouldImport) {
source.importData.languages = source.importData.languages.filter(function (m) { return m.id !== item.id; });
}
};
var this_2 = this;
for (var _b = 0, _c = source.importData.languages; _b < _c.length; _b++) {
var item = _c[_b];
_loop_2(item);
}
}
if (this.config.process && this.config.process.assetFolder) {
var _loop_3 = function (item) {
var shouldImport = this_3.config.process.assetFolder(item);
if (!shouldImport) {
source.assetFolders = source.assetFolders.filter(function (m) { return m.id !== item.id; });
}
};
var this_3 = this;
for (var _d = 0, _e = source.assetFolders; _d < _e.length; _d++) {
var item = _e[_d];
_loop_3(item);
}
}
if (this.config.process && this.config.process.contentType) {
var _loop_4 = function (item) {
var shouldImport = this_4.config.process.contentType(item);
if (!shouldImport) {
source.importData.contentTypes = source.importData.contentTypes.filter(function (m) { return m.id !== item.id; });
}
};
var this_4 = this;
for (var _f = 0, _g = source.importData.contentTypes; _f < _g.length; _f++) {
var item = _g[_f];
_loop_4(item);
}
}
if (this.config.process && this.config.process.contentItem) {
var _loop_5 = function (item) {
var shouldImport = this_5.config.process.contentItem(item);
if (!shouldImport) {
source.importData.contentItems = source.importData.contentItems.filter(function (m) { return m.id !== item.id; });
}
};
var this_5 = this;
for (var _h = 0, _j = source.importData.contentItems; _h < _j.length; _h++) {
var item = _j[_h];
_loop_5(item);
}
}
if (this.config.process && this.config.process.contentTypeSnippet) {
var _loop_6 = function (item) {
var shouldImport = this_6.config.process.contentTypeSnippet(item);
if (!shouldImport) {
source.importData.contentTypeSnippets = source.importData.contentTypeSnippets.filter(function (m) { return m.id !== item.id; });
}
};
var this_6 = this;
for (var _k = 0, _l = source.importData.contentTypeSnippets; _k < _l.length; _k++) {
var item = _l[_k];
_loop_6(item);
}
}
if (this.config.process && this.config.process.languageVariant) {
var _loop_7 = function (item) {
var shouldImport = this_7.config.process.languageVariant(item);
if (!shouldImport) {
source.importData.languageVariants = source.importData.languageVariants.filter(function (m) { return m.item.id !== item.item.id && m.language.id !== item.language.id; });
}
};
var this_7 = this;
for (var _m = 0, _o = source.importData.languageVariants; _m < _o.length; _m++) {
var item = _o[_m];
_loop_7(item);
}
}
if (this.config.process && this.config.process.taxonomy) {
var _loop_8 = function (item) {
var shouldImport = this_8.config.process.taxonomy(item);
if (!shouldImport) {
source.importData.taxonomies = source.importData.taxonomies.filter(function (m) { return m.id !== item.id; });
}
};
var this_8 = this;
for (var _p = 0, _q = source.importData.taxonomies; _p < _q.length; _p++) {
var item = _q[_p];
_loop_8(item);
}
}
};
ImportService.prototype.fixLanguageAsync = function (currentLanguages, importLanguage) {
return __awaiter(this, void 0, void 0, function () {
var existingLanguage, defaultExistingLanguage;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
existingLanguage = currentLanguages.find(function (m) { return m.codename === importLanguage.codename; });
if (!existingLanguage) return [3 /*break*/, 2];
if (!!existingLanguage.isActive) return [3 /*break*/, 2];
console.log("Language '" + existingLanguage.name + "' with codename '" + existingLanguage.codename + "' is not active in target project. Activating language.");
return [4 /*yield*/, this.client
.modifyLanguage()
.byLanguageCodename(existingLanguage.codename)
.withData([
{
op: 'replace',
property_name: 'is_active',
value: true
}
])
.toPromise()];
case 1:
_a.sent();
_a.label = 2;
case 2:
if (!importLanguage.is_default) return [3 /*break*/, 4];
defaultExistingLanguage = currentLanguages.find(function (m) { return m.id === importLanguage.id; });
if (!defaultExistingLanguage) {
throw Error("Invalid default existing language. Language with id '" + importLanguage.id + "' was not found.");
}
if (!(importLanguage.codename !== defaultExistingLanguage.codename)) return [3 /*break*/, 4];
// languages do not match, change it
console.log("Default language '" + importLanguage.name + "' with codename '" + importLanguage.codename + "' does not match default language in target project. Changing language codename in target project from '" + defaultExistingLanguage.codename + "' codename to '" + importLanguage.codename + "'");
return [4 /*yield*/, this.client
.modifyLanguage()
.byLanguageCodename(defaultExistingLanguage.codename)
.withData([
{
op: 'replace',
property_name: 'codename',
value: importLanguage.codename
}
])
.toPromise()];
case 3:
_a.sent();
_a.label = 4;
case 4: return [2 /*return*/];
}
});
});
};
ImportService.prototype.tryGetLanguage = function (currentLanguages, importLanguage) {
var _this = this;
// check if language with given codename already exists
var existingLanguage = currentLanguages.find(function (m) { return m.codename === importLanguage.codename; });
if (existingLanguage) {
// no need to import it
console.log("Skipping language '" + existingLanguage.name + "' with codename '" + existingLanguage.codename + "'");
return 'noImport';
}
// check if language codename of default language matches
if (importLanguage.id === this.defaultLanguageId) {
var defaultCurrentLanguage = currentLanguages.find(function (m) { return m.id === _this.defaultLanguageId; });
if (defaultCurrentLanguage && defaultCurrentLanguage.codename !== importLanguage.codename) {
// default language codename is source project is different than target project
throw Error("Codename of default language from imported data does not match target project. The source language codename is '" + importLanguage.codename + "' while target is '" + defaultCurrentLanguage.codename + "'. Please update codename of default language in target project to be '" + importLanguage.codename);
}
}
// 'codename' property is set in codename translator
var fallbackLanguageCodename = importLanguage.fallback_language.codename;
if (!fallbackLanguageCodename) {
throw Error("Language '" + importLanguage.name + "' has unset codename");
}
return {
codename: importLanguage.codename,
name: importLanguage.name,
external_id: importLanguage.external_id,
fallback_language: importLanguage.codename === fallbackLanguageCodename
? { id: this.defaultLanguageId }
: { codename: fallbackLanguageCodename },
is_active: importLanguage.is_active
};
};
ImportService.prototype.importLanguagesAsync = function (languages) {
return __awaiter(this, void 0, void 0, function () {
var importedItems, currentLanguagesResponse, _loop_9, this_9, _i, languages_1, language;
var _this = this;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
importedItems = [];
return [4 /*yield*/, this.client.listLanguages().toAllPromise()];
case 1:
currentLanguagesResponse = _a.sent();
_loop_9 = function (language) {
var processedLanguageData;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!this_9.config.fixLanguages) return [3 /*break*/, 3];
return [4 /*yield*/, this_9.fixLanguageAsync(currentLanguagesResponse.data.items, language)];
case 1:
_a.sent();
return [4 /*yield*/, this_9.client.listLanguages().toAllPromise()];
case 2:
// reload existing languages = they were fixed
currentLanguagesResponse = _a.sent();
_a.label = 3;
case 3:
processedLanguageData = this_9.tryGetLanguage(currentLanguagesResponse.data.items, language);
if (processedLanguageData === 'noImport') {
return [2 /*return*/, "continue"];
}
return [4 /*yield*/, this_9.client
.addLanguage()
.withData(processedLanguageData)
.toPromise()
.then(function (response) {
importedItems.push({
imported: response.data,
original: language,
importId: response.data.id,
originalId: language.id
});
_this.processItem(response.data.name, 'language', response.data);
})
.catch(function (error) { return _this.handleImportError(error); })];
case 4:
_a.sent();
return [2 /*return*/];
}
});
};
this_9 = this;
_i = 0, languages_1 = languages;
_a.label = 2;
case 2:
if (!(_i < languages_1.length)) return [3 /*break*/, 5];
language = languages_1[_i];
return [5 /*yield**/, _loop_9(language)];
case 3:
_a.sent();
_a.label = 4;
case 4:
_i++;
return [3 /*break*/, 2];
case 5: return [2 /*return*/, importedItems];
}
});
});
};
ImportService.prototype.importAssetsAsync = function (assets, binaryFiles, currentItems) {
return __awaiter(this, void 0, void 0, function () {
var importedItems, unsupportedBinaryFiles, _loop_10, this_10, _i, assets_1, asset;
var _this = this;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
importedItems = [];
unsupportedBinaryFiles = [];
_loop_10 = function (asset) {
var binaryFile, binaryDataToUpload, uploadedBinaryFile, assetData;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
binaryFile = binaryFiles.find(function (m) { return m.asset.id === asset.id; });
if (!binaryFile) {
throw Error("Could not find binary file for asset with id '" + asset.id + "'");
}
binaryDataToUpload = binaryFile.binaryData;
if (binaryFile.asset.size >= this_10.maxAllowedAssetSizeInBytes) {
if (this_10.config.onUnsupportedBinaryFile) {
this_10.config.onUnsupportedBinaryFile(binaryFile);
}
console.log("Removing binary data from file due to size. Max. file size is '" + this_10.maxAllowedAssetSizeInBytes + "'Bytes, but file has '" + asset.size + "' Bytes", asset.file_name);
// remove binary data so that import proceeds & asset is created (so that it can be referenced by
// content items )
binaryDataToUpload = [];
unsupportedBinaryFiles.push(binaryFile);
}
return [4 /*yield*/, this_10.client
.uploadBinaryFile()
.withData({
binaryData: binaryDataToUpload,
contentType: asset.type,
filename: asset.file_name
})
.toPromise()
.then(function (m) { return m; })
.catch(function (error) { return _this.handleImportError(error); })];
case 1:
uploadedBinaryFile = _a.sent();
if (!uploadedBinaryFile) {
throw Error("File not uploaded");
}
assetData = this_10.getAddAssetModel(asset, uploadedBinaryFile.data.id, currentItems);
return [4 /*yield*/, this_10.client
.addAsset()
.withData(assetData)
.toPromise()
.then(function (response) {
importedItems.push({
imported: response.data,
original: asset,
importId: response.data.id,
originalId: asset.id
});
_this.processItem(response.data.fileName, 'asset', response.data);
})
.catch(function (error) { return _this.handleImportError(error); })];
case 2:
_a.sent();
return [2 /*return*/];
}
});
};
this_10 = this;
_i = 0, assets_1 = assets;
_a.label = 1;
case 1:
if (!(_i < assets_1.length)) return [3 /*break*/, 4];
asset = assets_1[_i];
return [5 /*yield**/, _loop_10(asset)];
case 2:
_a.sent();
_a.label = 3;
case 3:
_i++;
return [3 /*break*/, 1];
case 4: return [2 /*return*/, importedItems];
}
});
});
};
ImportService.prototype.importAssetFoldersAsync = function (assetFolders, currentItems) {
return __awaiter(this, void 0, void 0, function () {
var importedItems, assetFoldersToAdd;
var _this = this;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
importedItems = [];
// set external id for all folders to equal old id (needed to match referenced folders)
this.setExternalIdForFolders(assetFolders);
assetFoldersToAdd = assetFolders.map(function (m) { return _this.mapAssetFolder(m); });
return [4 /*yield*/, this.client
.addAssetFolders()
.withData({
folders: assetFoldersToAdd
})
.toPromise()
.then(function (response) {
var importedFlattenedFolders = [];
var flattenedAssetFolderContracts = [];
_this.flattenAssetFolderContracts(assetFolders, flattenedAssetFolderContracts);
_this.flattenAssetFolders(response.data.items, flattenedAssetFolderContracts, importedFlattenedFolders);
for (var _i = 0, importedFlattenedFolders_1 = importedFlattenedFolders; _i < importedFlattenedFolders_1.length; _i++) {
var flattenedFolder = importedFlattenedFolders_1[_i];
importedItems.push(flattenedFolder);
_this.processItem(flattenedFolder.imported.name, 'assetFolder', flattenedFolder.imported);
}
})
.catch(function (error) { return _this.handleImportError(error); })];
case 1:
_a.sent();
return [2 /*return*/, importedItems];
}
});
});
};
ImportService.prototype.importContentTypesAsync = function (contentTypes) {
return __awaiter(this, void 0, void 0, function () {
var importedItems, _loop_11, this_11, _i, contentTypes_1, contentType;
var _this = this;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
importedItems = [];
_loop_11 = function (contentType) {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this_11.client
.addContentType()
.withData(function (builder) {
return contentType;
})
.toPromise()
.then(function (response) {
importedItems.push({
imported: response.data,
original: contentType,
importId: response.data.id,
originalId: contentType.id
});
_this.processItem(response.data.name, 'contentType', response.data);
})
.catch(function (error) { return _this.handleImportError(error); })];
case 1:
_a.sent();
return [2 /*return*/];
}
});
};
this_11 = this;
_i = 0, contentTypes_1 = contentTypes;
_a.label = 1;
case 1:
if (!(_i < contentTypes_1.length)) return [3 /*break*/, 4];
contentType = contentTypes_1[_i];
return [5 /*yield**/, _loop_11(contentType)];
case 2:
_a.sent();
_a.label = 3;
case 3:
_i++;
return [3 /*break*/, 1];
case 4: return [2 /*return*/, importedItems];
}
});
});
};
ImportService.prototype.importContentItemAsync = function (contentItems) {
return __awaiter(this, void 0, void 0, function () {
var importedItems, _loop_12, this_12, _i, contentItems_1, contentItem;
var _this = this;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
importedItems = [];
_loop_12 = function (contentItem) {
var typeCodename;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
typeCodename = contentItem.type.codename;
if (!typeCodename) {
throw Error("Content item '" + contentItem.codename + "' has unset type codename");
}
return [4 /*yield*/, this_12.client
.addContentItem()
.withData({
name: contentItem.name,
type: {
codename: typeCodename
},
codename: contentItem.codename,
external_id: contentItem.external_id
})
.toPromise()
.then(function (response) {
importedItems.push({
imported: response.data,
original: contentItem,
importId: response.data.id,
originalId: contentItem.id
});
_this.processItem(response.data.name, 'contentItem', response.data);
})
.catch(function (error) { return _this.handleImportError(error); })];
case 1:
_a.sent();
return [2 /*return*/];
}
});
};
this_12 = this;
_i = 0, contentItems_1 = contentItems;
_a.label = 1;
case 1:
if (!(_i < contentItems_1.length)) return [3 /*break*/, 4];
contentItem = contentItems_1[_i];
return [5 /*yield**/, _loop_12(contentItem)];
case 2:
_a.sent();
_a.label = 3;
case 3:
_i++;
return [3 /*break*/, 1];
case 4: return [2 /*return*/, importedItems];
}
});
});
};
ImportService.prototype.importLanguageVariantsAsync = function (languageVariants, currentItems) {
return __awaiter(this, void 0, void 0, function () {
var importedItems, _loop_13, this_13, _i, languageVariants_1, languageVariant;
var _this = this;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
importedItems = [];
_loop_13 = function (languageVariant) {
var itemCodename, languageCodename;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
itemCodename = languageVariant.item.codename;
languageCodename = languageVariant.language.codename;
if (!itemCodename) {
throw Error("Missing item codename for item");
}
if (!languageCodename) {
throw Error("Missing language codename for item");
}
// replace ids in assets with new ones
core_1.idTranslateHelper.replaceIdReferencesWithNewId(languageVariant, currentItems);
// set workflow id (there is no API to create workflows programatically)
languageVariant.workflow_step.id = this_13.config.workflowIdForImportedItems;
return [4 /*yield*/, this_13.client
.upsertLanguageVariant()
.byItemCodename(itemCodename)
.byLanguageCodename(languageCodename)
.withElements(languageVariant.elements)
.toPromise()
.then(function (response) {
importedItems.push({
imported: response.data,
original: languageVariant,
importId: response.data.item.id,
originalId: languageVariant.item.id
});
_this.processItem(itemCodename + " (" + languageCodename + ")", 'languageVariant', response.data);
})
.catch(function (error) { return _this.handleImportError(error); })];
case 1:
_a.sent();
return [2 /*return*/];
}
});
};
this_13 = this;
_i = 0, languageVariants_1 = languageVariants;
_a.label = 1;
case 1:
if (!(_i < languageVariants_1.length)) return [3 /*break*/, 4];
languageVariant = languageVariants_1[_i];
return [5 /*yield**/, _loop_13(languageVariant)];
case 2:
_a.sent();
_a.label = 3;
case 3:
_i++;
return [3 /*break*/, 1];
case 4: return [2 /*return*/, importedItems];
}
});
});
};
ImportService.prototype.importContentTypeSnippetsAsync = function (contentTypeSnippets) {
return __awaiter(this, void 0, void 0, function () {
var importedItems, _loop_14, this_14, _i, contentTypeSnippets_1, contentTypeSnippet;
var _this = this;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
importedItems = [];
_loop_14 = function (contentTypeSnippet) {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this_14.client
.addContentTypeSnippet()
.withData(function (builder) {
return {
elements: contentTypeSnippet.elements,
name: contentTypeSnippet.name,
codename: contentTypeSnippet.codename,
external_id: contentTypeSnippet.external_id
};
})
.toPromise()
.then(function (response) {
importedItems.push({
imported: response.data,
original: contentTypeSnippet,
importId: response.data.id,
originalId: contentTypeSnippet.id
});
_this.processItem(response.data.name, 'contentTypeSnippet', response.data);
})
.catch(function (error) { return _this.handleImportError(error); })];
case 1:
_a.sent();
return [2 /*return*/];
}
});
};
this_14 = this;
_i = 0, contentTypeSnippets_1 = contentTypeSnippets;
_a.label = 1;
case 1:
if (!(_i < contentTypeSnippets_1.length)) return [3 /*break*/, 4];
contentTypeSnippet = contentTypeSnippets_1[_i];
return [5 /*yield**/, _loop_14(contentTypeSnippet)];
case 2:
_a.sent();
_a.label = 3;
case 3:
_i++;
return [3 /*break*/, 1];
case 4: return [2 /*return*/, importedItems];
}
});
});
};
ImportService.prototype.importTaxonomiesAsync = function (taxonomies) {
return __awaiter(this, void 0, void 0, function () {
var importedItems, _loop_15, this_15, _i, taxonomies_1, taxonomy;
var _this = this;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
importedItems = [];
_loop_15 = function (taxonomy) {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this_15.client
.addTaxonomy()
.withData(taxonomy)
.toPromise()
.then(function (response) {
importedItems.push({
imported: response.data,
original: taxonomy,
importId: response.data.id,
originalId: taxonomy.id
});
_this.processItem(response.data.name, 'taxonomy', response.data);
})
.catch(function (error) { return _this.handleImportError(error); })];
case 1:
_a.sent();
return [2 /*return*/];
}
});
};
this_15 = this;
_i = 0, taxonomies_1 = taxonomies;
_a.label = 1;
case 1:
if (!(_i < taxonomies_1.length)) return [3 /*break*/, 4];
taxonomy = taxonomies_1[_i];
return [5 /*yield**/, _loop_15(taxonomy)];
case 2:
_a.sent();
_a.label = 3;
case 3:
_i++;
return [3 /*break*/, 1];
case 4: return [2 /*return*/, importedItems];
}
});
});
};
ImportService.prototype.handleImportError = function (error) {
console.log(error);
throw error;
};
ImportService.prototype.processItem = function (title, type, data) {
if (!this.config.onImport) {
return;
}
this.config.onImport({
data: data,
title: title,
type: type
});
};
ImportService.prototype.getAddAssetModel = function (assetContract, binaryFileId, currentItems) {
var model = {
descriptions: assetContract.descriptions,
file_reference: {
id: binaryFileId,
type: assetContract.file_reference.type
},
external_id: assetContract.external_id,
folder: assetContract.folder,
title: assetContract.title
};
// replace ids
core_1.idTranslateHelper.replaceIdReferencesWithNewId(model, currentItems);
return model;
};
ImportService.prototype.setExternalIdForFolders = function (folders) {
for (var _i = 0, folders_1 = folders; _i < folders_1.length; _i++) {
var folder = folders_1[_i];
folder.external_id = folder.id;
if (folder.folders.length) {
this.setExternalIdForFolders(folder.folders);
}
}
};
ImportService.prototype.flattenAssetFolders = function (importedAssetFolders, originalItems, items) {
var _loop_16 = function (assetFolder) {
var originalFolder = originalItems.find(function (m) { return m.external_id === assetFolder.externalId; });
if (!originalFolder) {
throw Error("Could not find original folder with id '" + assetFolder.externalId + "' with name '" + assetFolder.name + "'");
}
items.push({
imported: assetFolder,
original: originalFolder,
importId: assetFolder.id,
originalId: originalFolder.id
});
if (assetFolder.folders.length) {
this_16.flattenAssetFolders(assetFolder.folders, originalItems, items);
}
};
var this_16 = this;
for (var _i = 0, importedAssetFolders_1 = importedAssetFolders; _i < importedAssetFolders_1.length; _i++) {
var assetFolder = importedAssetFolders_1[_i];
_loop_16(assetFolder);
}
};
ImportService.prototype.flattenAssetFolderContracts = function (assetFolders, flattened) {
for (var _i = 0, assetFolders_1 = assetFolders; _i < assetFolders_1.length; _i++) {
var assetFolder = assetFolders_1[_i];
flattened.push(assetFolder);
if (assetFolder.folders.length) {
this.flattenAssetFolderContracts(assetFolder.folders, flattened);
}
}
};
ImportService.prototype.mapAssetFolder = function (folder) {
var _this = this;
var _a, _b;
return {
name: folder.name,
external_id: folder.external_id,
folders: (_b = (_a = folder.folders) === null || _a === void 0 ? void 0 : _a.map(function (m) { return _this.mapAssetFolder(m); })) !== null && _b !== void 0 ? _b : []
};
};
return ImportService;
}());
exports.ImportService = ImportService;
//# sourceMappingURL=import.service.js.map