@celonis/content-cli 0.11.0 → 0.12.0

package/api/action-flow-api.js

@@ -0,0 +1,52 @@
+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", "../services/http-client-service.v2", "../util/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.actionFlowApi = void 0;
+    const http_client_service_v2_1 = require("../services/http-client-service.v2");
+    const logger_1 = require("../util/logger");
+    class ActionFlowApi {
+        exportRawAssets(packageId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return http_client_service_v2_1.httpClientV2.getFile(`/ems-automation/api/root/${packageId}/export/assets`).catch(e => {
+                    throw new logger_1.FatalError(`Problem getting Action Flow assets: ${e}`);
+                });
+            });
+        }
+        analyzeAssets(packageId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return http_client_service_v2_1.httpClientV2.get(`/ems-automation/api/root/${packageId}/export/assets/analyze`).catch(e => {
+                    throw new logger_1.FatalError(`Problem analyzing Action Flow assets: ${e}`);
+                });
+            });
+        }
+        importAssets(packageId, data, dryRun) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const params = {
+                    dryRun: dryRun,
+                };
+                return http_client_service_v2_1.httpClientV2.postFile(`/ems-automation/api/root/${packageId}/import/assets`, data, params).catch(e => {
+                    throw new logger_1.FatalError(`Problem importing Action Flow assets: ${e}`);
+                });
+            });
+        }
+    }
+    ActionFlowApi.INSTANCE = new ActionFlowApi();
+    exports.actionFlowApi = ActionFlowApi.INSTANCE;
+});

package/commands/{analysis.command.js → action-flow.command.js}

@@ -13,29 +13,29 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../services/content.service", "../content/factory/analysis-manager.factory"], factory);
+        define(["require", "exports", "../services/action-flow/action-flow-service"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.AnalysisCommand = void 0;
-    const content_service_1 = require("../services/content.service");
-    const analysis_manager_factory_1 = require("../content/factory/analysis-manager.factory");
-    class AnalysisCommand {
-        constructor() {
-            this.contentService = new content_service_1.ContentService();
-            this.analysisManagerFactory = new analysis_manager_factory_1.AnalysisManagerFactory();
+    exports.ActionFlowCommand = void 0;
+    const action_flow_service_1 = require("../services/action-flow/action-flow-service");
+    class ActionFlowCommand {
+        exportActionFlows(packageId, metadataFile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield action_flow_service_1.actionFlowService.exportActionFlows(packageId, metadataFile);
+            });
         }
-        pullAnalysis(profile, id, packageManager) {
+        analyzeActionFlows(packageId, outputToJsonFile) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield this.contentService.pull(profile, this.analysisManagerFactory.createManager(id, null, null, packageManager));
+                yield action_flow_service_1.actionFlowService.analyzeActionFlows(packageId, outputToJsonFile);
             });
         }
-        pushAnalysis(profile, workspaceId, filename) {
+        importActionFlows(packageId, filePath, dryRun, outputToJsonFile) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield this.contentService.push(profile, this.analysisManagerFactory.createManager(null, workspaceId, filename));
+                yield action_flow_service_1.actionFlowService.importActionFlows(packageId, filePath, dryRun, outputToJsonFile);
             });
         }
     }
-    exports.AnalysisCommand = AnalysisCommand;
+    exports.ActionFlowCommand = ActionFlowCommand;
 });

package/content-cli-analyze.js

@@ -0,0 +1,56 @@
+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", "./util/context-initializer", "./util/logger", "./commands/action-flow.command", "commander"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const context_initializer_1 = require("./util/context-initializer");
+    const logger_1 = require("./util/logger");
+    const action_flow_command_1 = require("./commands/action-flow.command");
+    const commander = require("commander");
+    class Analyze {
+        static actionFlows(program) {
+            program
+                .command("action-flows")
+                .description("Analyze Action Flows dependencies for a certain package")
+                .option("-p, --profile <profile>", "Profile which you want to use to analyze Action Flows")
+                .requiredOption("--packageId <packageId>", "ID of the package from which you want to export Action Flows")
+                .option("-o, --outputToJsonFile", "Output the analyze result in a JSON file")
+                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new action_flow_command_1.ActionFlowCommand().analyzeActionFlows(cmd.packageId, cmd.outputToJsonFile);
+                process.exit();
+            }));
+            return program;
+        }
+    }
+    const loadCommands = () => {
+        getAllCommands();
+    };
+    context_initializer_1.ContextInitializer.initContext()
+        .then(loadCommands, loadCommands)
+        .catch(e => {
+        logger_1.logger.error(e);
+    });
+    if (!process.argv.slice(2).length) {
+        commander.outputHelp();
+        process.exit(1);
+    }
+    function getAllCommands() {
+        Analyze.actionFlows(commander);
+        commander.parse(process.argv);
+    }
+});

package/content-cli-export.js

@@ -13,7 +13,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "commander", "./commands/package.command", "./util/logger", "./commands/data-pool.command", "./util/context-initializer"], factory);
+        define(["require", "exports", "commander", "./commands/package.command", "./util/logger", "./commands/data-pool.command", "./util/context-initializer", "./commands/action-flow.command"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -24,6 +24,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const logger_1 = require("./util/logger");
     const data_pool_command_1 = require("./commands/data-pool.command");
     const context_initializer_1 = require("./util/context-initializer");
+    const action_flow_command_1 = require("./commands/action-flow.command");
     class Export {
         static packages(program) {
             program
@@ -53,6 +54,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             }));
             return program;
         }
+        static actionFlows(program) {
+            program
+                .command("action-flows")
+                .description("Command to export all Action Flows in a package with their objects and dependencies")
+                .option("-p, --profile <profile>", "Profile which you want to use to export Action Flows")
+                .requiredOption("--packageId <packageId>", "ID of the package from which you want to export Action Flows")
+                .option("-f, --file <file>", "Action flows metadata file (relative path)")
+                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new action_flow_command_1.ActionFlowCommand().exportActionFlows(cmd.packageId, cmd.file);
+                process.exit();
+            }));
+            return program;
+        }
     }
     exports.Export = Export;
     const loadCommands = () => {
@@ -70,6 +84,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     function getAllCommands() {
         Export.packages(commander);
         Export.dataPool(commander);
+        Export.actionFlows(commander);
         commander.parse(process.argv);
     }
 });

package/content-cli-import.js

@@ -13,7 +13,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "commander", "./commands/package.command", "./commands/data-pool.command", "./util/context-initializer", "./util/logger"], factory);
+        define(["require", "exports", "commander", "./commands/package.command", "./commands/data-pool.command", "./util/context-initializer", "./util/logger", "./commands/action-flow.command"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -24,6 +24,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const data_pool_command_1 = require("./commands/data-pool.command");
     const context_initializer_1 = require("./util/context-initializer");
     const logger_1 = require("./util/logger");
+    const action_flow_command_1 = require("./commands/action-flow.command");
     class Import {
         static packages(program) {
             program
@@ -54,6 +55,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             }));
             return program;
         }
+        static actionFlows(program) {
+            program
+                .command("action-flows")
+                .description("Command to import all Action Flows in a package with their objects and dependencies")
+                .option("-p, --profile <profile>", "Profile which you want to use to import Action Flows")
+                .requiredOption("--packageId <packageId>", "ID of the package to which you want to export Action Flows")
+                .requiredOption("-f, --file <file>", "Exported Action Flows file (relative path)")
+                .requiredOption("-d, --dryRun <dryRun>", "Execute the import on dry run mode")
+                .option("-o, --outputToJsonFile", "Output the import result in a JSON file")
+                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new action_flow_command_1.ActionFlowCommand().importActionFlows(cmd.packageId, cmd.file, cmd.dryRun, cmd.outputToJsonFile);
+                process.exit();
+            }));
+            return program;
+        }
     }
     exports.Import = Import;
     const loadCommands = () => {
@@ -71,6 +87,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     function getAllCommands() {
         Import.packages(commander);
         Import.dataPools(commander);
+        Import.actionFlows(commander);
         commander.parse(process.argv);
     }
 });

package/content-cli-pull.js

@@ -13,12 +13,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./commands/analysis.command", "./commands/skill.command", "./commands/data-pool.command", "./commands/asset.command", "./commands/package.command", "./commands/analysis-bookmarks.command", "commander"], factory);
+        define(["require", "exports", "./commands/skill.command", "./commands/data-pool.command", "./commands/asset.command", "./commands/package.command", "./commands/analysis-bookmarks.command", "commander"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    const analysis_command_1 = require("./commands/analysis.command");
     const skill_command_1 = require("./commands/skill.command");
     const data_pool_command_1 = require("./commands/data-pool.command");
     const asset_command_1 = require("./commands/asset.command");
@@ -26,19 +25,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const analysis_bookmarks_command_1 = require("./commands/analysis-bookmarks.command");
     const commander = require("commander");
     class Pull {
-        static analysis(program) {
-            program
-                .command("analysis")
-                .description("Command to pull an analysis")
-                .option("-p, --profile <profile>", "Profile which you want to use to pull the analysis")
-                .requiredOption("--id <id>", "Id of the analysis you want to pull")
-                .option("--asset", "Pull workflow as an asset")
-                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
-                yield new analysis_command_1.AnalysisCommand().pullAnalysis(cmd.profile, cmd.id, !!cmd.asset);
-                process.exit();
-            }));
-            return program;
-        }
         static analysisBookmarks(program) {
             program
                 .command("bookmarks")
@@ -105,7 +91,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return program;
         }
     }
-    Pull.analysis(commander);
     Pull.analysisBookmarks(commander);
     Pull.skill(commander);
     Pull.dataPool(commander);

package/content-cli-push.js

@@ -13,7 +13,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "commander", "fs", "path", "./commands/analysis.command", "./commands/skill.command", "./commands/widget.command", "./commands/data-pool.command", "./commands/asset.command", "./commands/package.command", "./commands/ctp.command", "./commands/analysis-bookmarks.command", "child_process", "./util/logger"], factory);
+        define(["require", "exports", "commander", "fs", "path", "./commands/skill.command", "./commands/widget.command", "./commands/data-pool.command", "./commands/asset.command", "./commands/package.command", "./commands/ctp.command", "./commands/analysis-bookmarks.command", "child_process", "./util/logger"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -21,7 +21,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const commander = require("commander");
     const fs = require("fs");
     const path = require("path");
-    const analysis_command_1 = require("./commands/analysis.command");
     const skill_command_1 = require("./commands/skill.command");
     const widget_command_1 = require("./commands/widget.command");
     const data_pool_command_1 = require("./commands/data-pool.command");
@@ -32,19 +31,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const child_process_1 = require("child_process");
     const logger_1 = require("./util/logger");
     class Push {
-        static analysis(program) {
-            program
-                .command("analysis")
-                .description("Command to push an analysis to a workspace")
-                .option("-p, --profile <profile>", "Profile which you want to use to push the analysis")
-                .requiredOption("--workspaceId <workspaceId>", "Id of the workspace to which you want to push the analysis")
-                .requiredOption("-f, --file <file>", "The file you want to push")
-                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
-                yield new analysis_command_1.AnalysisCommand().pushAnalysis(cmd.profile, cmd.workspaceId, cmd.file);
-                process.exit();
-            }));
-            return program;
-        }
         static analysisBookmarks(program) {
             program
                 .command("bookmarks")
@@ -192,7 +178,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return program;
         }
     }
-    Push.analysis(commander);
     Push.analysisBookmarks(commander);
     Push.ctp(commander);
     Push.skill(commander);

package/content-cli.js

@@ -22,13 +22,14 @@
     program.command("profile", "Commands related to profiles.");
     program.command("pull", "Commands to pull content.");
     program.command("export", "Commands to export content.");
-    program.command("import", "Commands to export content.");
+    program.command("import", "Commands to import content.");
     program.command("push", "Commands to push content.");
     program.command("update", "Commands to update content.");
     program.command("list", "Commands to list content.").alias("ls");
     program.command("get", "Commands to get configuration properties.");
     program.command("set", "Commands to set configuration properties.");
     program.command("config", "Commands related to config management.");
+    program.command("analyze", "Commands to analyze assets dependencies.");
     program.version(version_1.VersionUtils.getCurrentCliVersion());
     program.parse(process.argv);
     if (!process.argv.slice(2).length) {

package/lib/api/action-flow-api.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import * as FormData from "form-data";
+declare class ActionFlowApi {
+    static readonly INSTANCE: ActionFlowApi;
+    exportRawAssets(packageId: string): Promise<Buffer>;
+    analyzeAssets(packageId: string): Promise<any>;
+    importAssets(packageId: string, data: FormData, dryRun: boolean): Promise<any>;
+}
+export declare const actionFlowApi: ActionFlowApi;
+export {};

package/lib/commands/action-flow.command.d.ts

@@ -0,0 +1,5 @@
+export declare class ActionFlowCommand {
+    exportActionFlows(packageId: string, metadataFile: string): Promise<void>;
+    analyzeActionFlows(packageId: string, outputToJsonFile: boolean): Promise<void>;
+    importActionFlows(packageId: string, filePath: string, dryRun: boolean, outputToJsonFile: boolean): Promise<void>;
+}

package/lib/content-cli-analyze.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/content-cli-export.d.ts

@@ -2,4 +2,5 @@ import { CommanderStatic } from "commander";
 export declare class Export {
     static packages(program: CommanderStatic): CommanderStatic;
     static dataPool(program: CommanderStatic): CommanderStatic;
+    static actionFlows(program: CommanderStatic): CommanderStatic;
 }

package/lib/content-cli-import.d.ts

@@ -2,4 +2,5 @@ import { CommanderStatic } from "commander";
 export declare class Import {
     static packages(program: CommanderStatic): CommanderStatic;
     static dataPools(program: CommanderStatic): CommanderStatic;
+    static actionFlows(program: CommanderStatic): CommanderStatic;
 }

package/lib/services/action-flow/action-flow-service.d.ts

@@ -0,0 +1,11 @@
+declare class ActionFlowService {
+    static readonly METADATA_FILE_NAME = "metadata.json";
+    exportActionFlows(packageId: string, metadataFilePath: string): Promise<void>;
+    analyzeActionFlows(packageId: string, outputToJsonFile: boolean): Promise<void>;
+    importActionFlows(packageId: string, filePath: string, dryRun: boolean, outputToJsonFile: boolean): Promise<void>;
+    private createBodyForImport;
+    private attachMetadataFile;
+}
+export declare const actionFlowService: ActionFlowService;
+export declare const metadataFileName = "metadata.json";
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celonis/content-cli",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "CLI Tool to help manage content in Celonis EMS",
   "main": "content-cli.js",
   "bin": {

package/services/action-flow/action-flow-service.js

@@ -0,0 +1,90 @@
+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", "../../util/logger", "uuid", "../file-service", "../../api/action-flow-api", "adm-zip", "form-data", "fs"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.metadataFileName = exports.actionFlowService = void 0;
+    const logger_1 = require("../../util/logger");
+    const uuid_1 = require("uuid");
+    const file_service_1 = require("../file-service");
+    const action_flow_api_1 = require("../../api/action-flow-api");
+    const AdmZip = require("adm-zip");
+    const FormData = require("form-data");
+    const fs = require("fs");
+    class ActionFlowService {
+        exportActionFlows(packageId, metadataFilePath) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const exportedActionFlowsData = yield action_flow_api_1.actionFlowApi.exportRawAssets(packageId);
+                const tmpZip = new AdmZip(exportedActionFlowsData);
+                const zip = new AdmZip();
+                tmpZip.getEntries().forEach(entry => {
+                    zip.addFile(entry.entryName, entry.getData());
+                });
+                if (metadataFilePath) {
+                    this.attachMetadataFile(metadataFilePath, zip);
+                }
+                const fileName = "action-flows_export_" + (0, uuid_1.v4)() + ".zip";
+                zip.writeZip(fileName);
+                logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + fileName);
+            });
+        }
+        analyzeActionFlows(packageId, outputToJsonFile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const actionFlowsMetadata = yield action_flow_api_1.actionFlowApi.analyzeAssets(packageId);
+                const actionFlowsMetadataString = JSON.stringify(actionFlowsMetadata, null, 4);
+                if (outputToJsonFile) {
+                    const metadataFileName = "action-flows_metadata_" + (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(actionFlowsMetadataString, metadataFileName);
+                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + metadataFileName);
+                }
+                else {
+                    logger_1.logger.info("Action flows analyze metadata: \n" + actionFlowsMetadataString);
+                }
+            });
+        }
+        importActionFlows(packageId, filePath, dryRun, outputToJsonFile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const actionFlowsZip = this.createBodyForImport(filePath);
+                const eventLog = yield action_flow_api_1.actionFlowApi.importAssets(packageId, actionFlowsZip, dryRun);
+                const eventLogString = JSON.stringify(eventLog, null, 4);
+                if (outputToJsonFile) {
+                    const eventLogFileName = "action-flows_import_event_log_" + (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(eventLogString, eventLogFileName);
+                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + eventLogFileName);
+                }
+                else {
+                    logger_1.logger.info("Action flows import event log: \n" + eventLogString);
+                }
+            });
+        }
+        createBodyForImport(fileName) {
+            fileName = fileName + (fileName.endsWith(".zip") ? "" : ".zip");
+            const formData = new FormData();
+            formData.append("file", fs.createReadStream(fileName, { encoding: null }), { filename: fileName });
+            return formData;
+        }
+        attachMetadataFile(fileName, zip) {
+            fileName = fileName + (fileName.endsWith(".json") ? "" : ".json");
+            const metadata = file_service_1.fileService.readFile(fileName);
+            zip.addFile(ActionFlowService.METADATA_FILE_NAME, Buffer.from(metadata));
+        }
+    }
+    ActionFlowService.METADATA_FILE_NAME = "metadata.json";
+    exports.actionFlowService = new ActionFlowService();
+    exports.metadataFileName = ActionFlowService.METADATA_FILE_NAME;
+});

package/content/factory/analysis-manager.factory.js

@@ -1,36 +0,0 @@
-(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", "fs", "path", "../../util/logger", "../manager/analysis.manager"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.AnalysisManagerFactory = void 0;
-    const fs = require("fs");
-    const path = require("path");
-    const logger_1 = require("../../util/logger");
-    const analysis_manager_1 = require("../manager/analysis.manager");
-    class AnalysisManagerFactory {
-        createManager(id, processId, filename, packageManager) {
-            const analysisManager = new analysis_manager_1.AnalysisManager();
-            analysisManager.id = id;
-            analysisManager.processId = processId;
-            if (filename !== null) {
-                analysisManager.fileName = this.resolvePackageFilePath(filename);
-            }
-            analysisManager.packageManager = packageManager;
-            return analysisManager;
-        }
-        resolvePackageFilePath(fileName) {
-            if (!fs.existsSync(path.resolve(process.cwd(), fileName))) {
-                logger_1.logger.error(new logger_1.FatalError("The provided file does not exist"));
-            }
-            return path.resolve(process.cwd(), fileName);
-        }
-    }
-    exports.AnalysisManagerFactory = AnalysisManagerFactory;
-});

package/content/manager/analysis.manager.js

@@ -1,72 +0,0 @@
-(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", "./base.manager", "./asset.manager", "fs", "../../util/yaml", "form-data"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.AnalysisManager = void 0;
-    const base_manager_1 = require("./base.manager");
-    const asset_manager_1 = require("./asset.manager");
-    const fs = require("fs");
-    const yaml_1 = require("../../util/yaml");
-    const FormData = require("form-data");
-    class AnalysisManager extends base_manager_1.BaseManager {
-        get fileName() {
-            return this._fileName;
-        }
-        set fileName(value) {
-            this._fileName = value;
-        }
-        get id() {
-            return this._id;
-        }
-        set id(value) {
-            this._id = value;
-        }
-        get processId() {
-            return this._processId;
-        }
-        set processId(value) {
-            this._processId = value;
-        }
-        get packageManager() {
-            return this._packageManager;
-        }
-        set packageManager(value) {
-            this._packageManager = value;
-        }
-        getConfig() {
-            const pullUrl = this.packageManager
-                ? `${AnalysisManager.BASE_URL}${this.id}/package/export`
-                : `${AnalysisManager.PULL_URL}${this.id}`;
-            return {
-                pushUrl: this.profile.team.replace(/\/?$/, `${AnalysisManager.BASE_URL}/import?processId=${this.processId}`),
-                pullUrl: this.profile.team.replace(/\/?$/, pullUrl),
-                exportFileName: `${this.packageManager ? asset_manager_1.AssetManager.ASSET_FILE_PREFIX : AnalysisManager.ANALYSIS_FILE_PREFIX}${this.id}${this.packageManager ? ".yaml" : ".json"}`,
-                onPushSuccessMessage: (data) => {
-                    return "Analysis was pushed successfully. New ID: " + data.id;
-                },
-            };
-        }
-        getBody() {
-            const formData = new FormData();
-            formData.append("file", fs.createReadStream(this.fileName));
-            return formData;
-        }
-        getSerializedFileContent(data) {
-            if (this.packageManager) {
-                return (0, yaml_1.stringify)(data);
-            }
-            return JSON.stringify(data);
-        }
-    }
-    exports.AnalysisManager = AnalysisManager;
-    AnalysisManager.BASE_URL = "/process-mining/api/analysis/";
-    AnalysisManager.PULL_URL = `${AnalysisManager.BASE_URL}/export?id=`;
-    AnalysisManager.ANALYSIS_FILE_PREFIX = "analysis_";
-});

package/lib/commands/analysis.command.d.ts

@@ -1,6 +0,0 @@
-export declare class AnalysisCommand {
-    private contentService;
-    private analysisManagerFactory;
-    pullAnalysis(profile: string, id: string, packageManager: boolean): Promise<void>;
-    pushAnalysis(profile: string, workspaceId: string, filename: string): Promise<void>;
-}

package/lib/content/factory/analysis-manager.factory.d.ts

@@ -1,5 +0,0 @@
-import { AnalysisManager } from "../manager/analysis.manager";
-export declare class AnalysisManagerFactory {
-    createManager(id: string, processId: string, filename: string, packageManager?: boolean): AnalysisManager;
-    private resolvePackageFilePath;
-}

package/lib/content/manager/analysis.manager.d.ts

@@ -1,22 +0,0 @@
-import { BaseManager } from "./base.manager";
-import { ManagerConfig } from "../../interfaces/manager-config.interface";
-export declare class AnalysisManager extends BaseManager {
-    private static BASE_URL;
-    private static PULL_URL;
-    private static ANALYSIS_FILE_PREFIX;
-    private _id;
-    private _processId;
-    private _fileName;
-    private _packageManager;
-    get fileName(): string;
-    set fileName(value: string);
-    get id(): string;
-    set id(value: string);
-    get processId(): string;
-    set processId(value: string);
-    get packageManager(): boolean;
-    set packageManager(value: boolean);
-    getConfig(): ManagerConfig;
-    getBody(): any;
-    protected getSerializedFileContent(data: any): string;
-}