@celonis/content-cli 0.6.1 → 0.8.0

package/services/studio/studio.service.js

@@ -0,0 +1,220 @@
+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());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../api/package-api", "../../interfaces/package-manager.interfaces", "../package-manager/datamodel-service", "../../util/yaml", "../../api/node-api", "../../api/variables-api", "../../api/space-api", "../package-manager/space-service", "../package-manager/variable-service", "../../interfaces/batch-export-import-constants", "adm-zip"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.studioService = void 0;
+    const package_api_1 = require("../../api/package-api");
+    const package_manager_interfaces_1 = require("../../interfaces/package-manager.interfaces");
+    const datamodel_service_1 = require("../package-manager/datamodel-service");
+    const yaml_1 = require("../../util/yaml");
+    const node_api_1 = require("../../api/node-api");
+    const variables_api_1 = require("../../api/variables-api");
+    const space_api_1 = require("../../api/space-api");
+    const space_service_1 = require("../package-manager/space-service");
+    const variable_service_1 = require("../package-manager/variable-service");
+    const batch_export_import_constants_1 = require("../../interfaces/batch-export-import-constants");
+    const AdmZip = require("adm-zip");
+    class StudioService {
+        getExportPackagesWithStudioData(packagesToExport, withDependencies) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const studioPackagesWithDataModels = yield package_api_1.packageApi.findAllPackagesWithVariableAssignments(package_manager_interfaces_1.PackageManagerVariableType.DATA_MODEL);
+                packagesToExport = exports.studioService.setSpaceIdForStudioPackages(packagesToExport, studioPackagesWithDataModels);
+                if (withDependencies) {
+                    const dataModelDetailsByNode = yield datamodel_service_1.dataModelService.getDataModelDetailsForPackages(studioPackagesWithDataModels);
+                    packagesToExport = exports.studioService.setDataModelsForStudioPackages(packagesToExport, studioPackagesWithDataModels, dataModelDetailsByNode);
+                }
+                return packagesToExport;
+            });
+        }
+        fixConnectionVariables(variables) {
+            return variables.map(variableManifest => (Object.assign(Object.assign({}, variableManifest), { variables: variableManifest.variables.map(variable => {
+                    if (variable.type !== package_manager_interfaces_1.PackageManagerVariableType.CONNECTION) {
+                        return variable;
+                    }
+                    return this.fixConnectionVariable(variable);
+                }) })));
+        }
+        getStudioPackageManifests(studioPackageKeys) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return Promise.all(studioPackageKeys.map((packageKey) => __awaiter(this, void 0, void 0, function* () {
+                    const node = yield node_api_1.nodeApi.findOneByKeyAndRootNodeKey(packageKey, packageKey);
+                    const nodeSpace = yield space_api_1.spaceApi.findOne(node.spaceId);
+                    const variableAssignments = yield variables_api_1.variablesApi.getRuntimeVariableValues(packageKey, batch_export_import_constants_1.BatchExportImportConstants.APP_MODE_VIEWER);
+                    return {
+                        packageKey: packageKey,
+                        space: {
+                            name: nodeSpace.name,
+                            iconReference: nodeSpace.iconReference
+                        },
+                        runtimeVariableAssignments: variableAssignments
+                    };
+                })));
+            });
+        }
+        processPackageForExport(exportedPackage, exportedVariables) {
+            const packageZip = new AdmZip(exportedPackage.getData());
+            this.deleteScenarioAssets(packageZip);
+            this.fixConnectionVariablesForRootNodeFiles(packageZip, exportedPackage.name, exportedVariables);
+            return packageZip;
+        }
+        processImportedPackages(configs, existingStudioPackages, studioManifests) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (studioManifests == null) {
+                    return;
+                }
+                for (const manifest of studioManifests) {
+                    const existingPackage = existingStudioPackages.find(existingPackage => existingPackage.key === manifest.packageKey);
+                    if (existingPackage) {
+                        yield package_api_1.packageApi.movePackageToSpace(existingPackage.id, manifest.space.id);
+                    }
+                    yield this.assignRuntimeVariables(manifest);
+                }
+            });
+        }
+        setSpaceIdForStudioPackages(packages, studioPackages) {
+            const studioPackageByKey = new Map();
+            studioPackages.forEach(pkg => studioPackageByKey.set(pkg.key, pkg));
+            return packages.map(pkg => {
+                return studioPackageByKey.has(pkg.key) ? Object.assign(Object.assign({}, pkg), { spaceId: studioPackageByKey.get(pkg.key).spaceId }) : pkg;
+            });
+        }
+        setDataModelsForStudioPackages(packages, studioPackageWithDataModels, dataModelDetailsByNode) {
+            const studioPackageByKey = new Map();
+            studioPackageWithDataModels.forEach(pkg => studioPackageByKey.set(pkg.key, pkg));
+            return packages.map(pkg => {
+                return studioPackageByKey.has(pkg.key) ? Object.assign(Object.assign({}, pkg), { datamodels: dataModelDetailsByNode.get(pkg.key)
+                        .map(dataModel => ({
+                        name: dataModel.name,
+                        poolId: dataModel.poolId,
+                        dataModelId: dataModel.dataModelId
+                    })) }) : pkg;
+            });
+        }
+        fixConnectionVariable(variable) {
+            if (!variable.value.appName) {
+                return variable;
+            }
+            return Object.assign(Object.assign({}, variable), { metadata: Object.assign(Object.assign({}, variable.metadata), { appName: variable.value.appName }) });
+        }
+        deleteScenarioAssets(packageZip) {
+            packageZip.getEntries().filter(entry => entry.entryName.startsWith(batch_export_import_constants_1.BatchExportImportConstants.NODES_FOLDER_NAME) && entry.entryName.endsWith(batch_export_import_constants_1.BatchExportImportConstants.YAML_EXTENSION))
+                .forEach(entry => {
+                const node = (0, yaml_1.parse)(entry.getData().toString());
+                if (node.type === batch_export_import_constants_1.BatchExportImportConstants.SCENARIO_NODE) {
+                    packageZip.deleteFile(entry);
+                }
+            });
+        }
+        fixConnectionVariablesForRootNodeFiles(packageZip, zipName, exportedVariables) {
+            const packageKeyAndVersion = this.getPackageKeyAndVersion(zipName);
+            const connectionVariablesByKey = this.getConnectionVariablesByKeyForPackage(packageKeyAndVersion.packageKey, packageKeyAndVersion.version, exportedVariables);
+            if (connectionVariablesByKey.size === 0) {
+                return;
+            }
+            const packageEntry = packageZip.getEntry("package.yml");
+            const exportedNode = (0, yaml_1.parse)(packageEntry.getData().toString());
+            const nodeContent = (0, yaml_1.parse)(exportedNode.serializedContent);
+            nodeContent.variables = nodeContent.variables.map(variable => (Object.assign(Object.assign({}, variable), { metadata: variable.type === package_manager_interfaces_1.PackageManagerVariableType.CONNECTION ?
+                    connectionVariablesByKey.get(variable.key).metadata : variable.metadata })));
+            exportedNode.serializedContent = (0, yaml_1.stringify)(nodeContent);
+            packageZip.updateFile(packageEntry, Buffer.from((0, yaml_1.stringify)(exportedNode)));
+        }
+        getPackageKeyAndVersion(zipName) {
+            const lastUnderscoreIndex = zipName.lastIndexOf("_");
+            const packageKey = zipName.replace(batch_export_import_constants_1.BatchExportImportConstants.ZIP_EXTENSION, "").substring(0, lastUnderscoreIndex);
+            const packageVersion = zipName.replace(batch_export_import_constants_1.BatchExportImportConstants.ZIP_EXTENSION, "").substring(lastUnderscoreIndex + 1);
+            return {
+                packageKey: packageKey,
+                version: packageVersion
+            };
+        }
+        getConnectionVariablesByKeyForPackage(packageKey, packageVersion, variables) {
+            const variablesByKey = new Map();
+            const packageVariables = variables.find(exportedVariable => exportedVariable.packageKey === packageKey && exportedVariable.version === packageVersion);
+            if (packageVariables && packageVariables.variables.length) {
+                packageVariables.variables.filter(variable => variable.type === package_manager_interfaces_1.PackageManagerVariableType.CONNECTION)
+                    .forEach(variable => variablesByKey.set(variable.key, variable));
+            }
+            return variablesByKey;
+        }
+        mapSpaces(exportedFiles, studioManifests) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (studioManifests == null) {
+                    return exportedFiles;
+                }
+                for (const file of exportedFiles.getEntries()) {
+                    if (file.name.endsWith(batch_export_import_constants_1.BatchExportImportConstants.ZIP_EXTENSION)) {
+                        const packageKey = this.getPackageKeyAndVersion(file.name).packageKey;
+                        if (this.isStudioPackage(studioManifests, packageKey)) {
+                            const studioManifest = studioManifests.find(manifest => manifest.packageKey === packageKey);
+                            if (studioManifest) {
+                                const spaceId = yield this.findDesiredSpaceIdForPackage(studioManifest);
+                                studioManifest.space.id = spaceId;
+                                const packageZip = new AdmZip(file.getData());
+                                packageZip.getEntries().forEach(nodeFile => {
+                                    if (nodeFile.entryName.endsWith(batch_export_import_constants_1.BatchExportImportConstants.YAML_EXTENSION)) {
+                                        const updatedNodeFile = this.updateSpaceIdForNode(nodeFile.getData().toString(), spaceId);
+                                        packageZip.updateFile(nodeFile, Buffer.from(updatedNodeFile));
+                                    }
+                                });
+                                exportedFiles.updateFile(file, packageZip.toBuffer());
+                            }
+                        }
+                    }
+                }
+                return exportedFiles;
+            });
+        }
+        isStudioPackage(studioManifests, packageKey) {
+            return studioManifests.some(manifest => manifest.packageKey === packageKey);
+        }
+        findDesiredSpaceIdForPackage(studioPackageManifest) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const allSpaces = yield space_service_1.spaceService.refreshAndGetAllSpaces();
+                if (studioPackageManifest.space.id) {
+                    const targetSpace = allSpaces.find(space => space.id === studioPackageManifest.space.id);
+                    if (!targetSpace) {
+                        throw Error("Provided space ID does not exist.");
+                    }
+                    return targetSpace.id;
+                }
+                const targetSpaceByName = allSpaces.find(space => space.name === studioPackageManifest.space.name);
+                if (targetSpaceByName) {
+                    return targetSpaceByName.id;
+                }
+                const spaceTransport = yield space_service_1.spaceService.createSpace(studioPackageManifest.space.name, studioPackageManifest.space.iconReference);
+                return spaceTransport.id;
+            });
+        }
+        assignRuntimeVariables(manifest) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (manifest.runtimeVariableAssignments.length) {
+                    yield variable_service_1.variableService.assignVariableValues(manifest.packageKey, manifest.runtimeVariableAssignments);
+                }
+            });
+        }
+        updateSpaceIdForNode(nodeContent, spaceId) {
+            const exportedNode = (0, yaml_1.parse)(nodeContent);
+            const oldSpaceId = exportedNode.unversionedMetadata.spaceId;
+            nodeContent = nodeContent.replace(new RegExp(oldSpaceId, "g"), spaceId);
+            return nodeContent;
+        }
+    }
+    exports.studioService = new StudioService();
+});