@celonis/content-cli 0.13.5 → 1.0.0

package/README.md

@@ -82,7 +82,7 @@ content-cli -h
 content-cli pull package -h
 ```
 
-## Building the Project
+## Building and Using the Project locally 
 
 This tool is tightly connected with the Celonis EMS and all capabilities require to have access to a Celonis EMS Team. 
 After cloning the project, the next step is to install the project dependencies. We use `yarn` as our package manager, 
@@ -90,11 +90,16 @@ so running `yarn install` on the project root folder should install all the nece
 the project dependencies, you can run `yarn build` to build the project artifact. To use the built artifact, you can 
 run `node content-cli.js` in the generated `dist` folder.
 
+If we want to use a specific local build of the tool globally, we can do this by:
+- Move to the root directory of the project.
+- Execute the `npm link` command. 
+This will create a symbolic link in the global `node_modules` directory, allowing you to run the CLI from anywhere on your machine.
+
 ## Release Process
 
-We manage releases using Github Actions with the `Build and Publish Workflow`. This action runs after merging to 
-the master branch, which builds the project and publishes the package to the Github registry. You can install 
-a published version of the Content CLI using the following command:
+We manage releases using Github Actions with the `Build and Publish Workflow`. This action gets executed manually by the Codeowners when there are changes that need to be published.
+This builds the project and publishes the package to the Github registry. You can install 
+the latest published version of the Content CLI using the following command:
 
 ```
 npm i -g @celonis/content-cli
@@ -102,9 +107,11 @@ npm i -g @celonis/content-cli
 
 ## Contributing
 
-We encourage public contributions! Please review 
+We encourage public contributions! Please check 
 [CONTRIBUTING.md](https://github.com/celonis/content-cli/blob/master/CONTRIBUTING.md) for details on our 
-code of conduct and development process.
+code of conduct.
+
+For details on command development, refer to the [How to Add a Command](https://github.com/celonis/content-cli/blob/master/docs/how-to-add-command.md) guide.
 
 ## License
 

package/{api → commands/action-flows/action-flow}/action-flow-api.js

@@ -13,25 +13,27 @@ 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/http-client-service.v2", "../util/logger"], factory);
+        define(["require", "exports", "../../../core/utils/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");
+    exports.ActionFlowApi = void 0;
+    const logger_1 = require("../../../core/utils/logger");
     class ActionFlowApi {
+        constructor(context) {
+            this.httpClient = context.httpClient;
+        }
         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 => {
+                return this.httpClient.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 => {
+                return this.httpClient.get(`/ems-automation/api/root/${packageId}/export/assets/analyze`).catch(e => {
                     throw new logger_1.FatalError(`Problem analyzing Action Flow assets: ${e}`);
                 });
             });
@@ -41,12 +43,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 const params = {
                     dryRun: dryRun,
                 };
-                return http_client_service_v2_1.httpClientV2.postFile(`/ems-automation/api/root/${packageId}/import/assets`, data, params).catch(e => {
+                return this.httpClient.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;
+    exports.ActionFlowApi = ActionFlowApi;
 });

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

@@ -13,29 +13,32 @@ 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/action-flow/action-flow-service"], factory);
+        define(["require", "exports", "./action-flow.service"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.ActionFlowCommand = void 0;
-    const action_flow_service_1 = require("../services/action-flow/action-flow-service");
-    class ActionFlowCommand {
+    exports.ActionFlowCommandService = void 0;
+    const action_flow_service_1 = require("./action-flow.service");
+    class ActionFlowCommandService {
+        constructor(context) {
+            this.actionFlowService = new action_flow_service_1.ActionFlowService(context);
+        }
         exportActionFlows(packageId, metadataFile) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield action_flow_service_1.actionFlowService.exportActionFlows(packageId, metadataFile);
+                yield this.actionFlowService.exportActionFlows(packageId, metadataFile);
             });
         }
         analyzeActionFlows(packageId, outputToJsonFile) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield action_flow_service_1.actionFlowService.analyzeActionFlows(packageId, outputToJsonFile);
+                yield this.actionFlowService.analyzeActionFlows(packageId, outputToJsonFile);
             });
         }
         importActionFlows(packageId, filePath, dryRun, outputToJsonFile) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield action_flow_service_1.actionFlowService.importActionFlows(packageId, filePath, dryRun, outputToJsonFile);
+                yield this.actionFlowService.importActionFlows(packageId, filePath, dryRun, outputToJsonFile);
             });
         }
     }
-    exports.ActionFlowCommand = ActionFlowCommand;
+    exports.ActionFlowCommandService = ActionFlowCommandService;
 });

package/{services/action-flow/action-flow-service.js → commands/action-flows/action-flow/action-flow.service.js}

@@ -13,23 +13,26 @@ 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", "../../util/logger", "uuid", "../file-service", "../../api/action-flow-api", "adm-zip", "form-data", "fs"], factory);
+        define(["require", "exports", "uuid", "adm-zip", "form-data", "fs", "./action-flow-api", "../../../core/utils/file-service", "../../../core/utils/logger"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.metadataFileName = exports.actionFlowService = void 0;
-    const logger_1 = require("../../util/logger");
+    exports.ActionFlowService = void 0;
     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");
+    const action_flow_api_1 = require("./action-flow-api");
+    const file_service_1 = require("../../../core/utils/file-service");
+    const logger_1 = require("../../../core/utils/logger");
     class ActionFlowService {
+        constructor(context) {
+            this.actionFlowApi = new action_flow_api_1.ActionFlowApi(context);
+        }
         exportActionFlows(packageId, metadataFilePath) {
             return __awaiter(this, void 0, void 0, function* () {
-                const exportedActionFlowsData = yield action_flow_api_1.actionFlowApi.exportRawAssets(packageId);
+                const exportedActionFlowsData = yield this.actionFlowApi.exportRawAssets(packageId);
                 const tmpZip = new AdmZip(exportedActionFlowsData);
                 const zip = new AdmZip();
                 tmpZip.getEntries().forEach(entry => {
@@ -45,7 +48,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         analyzeActionFlows(packageId, outputToJsonFile) {
             return __awaiter(this, void 0, void 0, function* () {
-                const actionFlowsMetadata = yield action_flow_api_1.actionFlowApi.analyzeAssets(packageId);
+                const actionFlowsMetadata = yield this.actionFlowApi.analyzeAssets(packageId);
                 const actionFlowsMetadataString = JSON.stringify(actionFlowsMetadata, null, 4);
                 if (outputToJsonFile) {
                     const metadataFileName = "action-flows_metadata_" + (0, uuid_1.v4)() + ".json";
@@ -60,7 +63,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 eventLog = yield this.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";
@@ -84,7 +87,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             zip.addFile(ActionFlowService.METADATA_FILE_NAME, Buffer.from(metadata));
         }
     }
+    exports.ActionFlowService = ActionFlowService;
     ActionFlowService.METADATA_FILE_NAME = "metadata.json";
-    exports.actionFlowService = new ActionFlowService();
-    exports.metadataFileName = ActionFlowService.METADATA_FILE_NAME;
 });

package/commands/action-flows/module.js

@@ -0,0 +1,88 @@
+/**
+ * Commands related to the Action Flows area.
+ */
+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", "../../core/command/module-handler", "./action-flow/action-flow-command.service", "./skill/skill-command.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    const module_handler_1 = require("../../core/command/module-handler");
+    const action_flow_command_service_1 = require("./action-flow/action-flow-command.service");
+    const skill_command_service_1 = require("./skill/skill-command.service");
+    class Module extends module_handler_1.IModule {
+        register(context, configurator) {
+            const analyzeCommand = configurator.command("analyze");
+            analyzeCommand.command("action-flows")
+                .description("Analyze Action Flows dependencies for a certain package")
+                .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(this.analyzeActionFlows);
+            const exportCommand = configurator.command("export");
+            exportCommand.command("action-flows")
+                .description("Command to export all Action Flows in a package with their objects and dependencies")
+                .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(this.exportActionFlows);
+            const importCommand = configurator.command("import");
+            importCommand.command("action-flows")
+                .description("Command to import all Action Flows in a package with their objects and dependencies")
+                .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(this.importActionFlows);
+            const pullCommand = configurator.command("pull");
+            pullCommand.command("skill")
+                .description("Command to pull a skill")
+                .requiredOption("--projectId <projectId>", "Id of the project you want to pull")
+                .requiredOption("--skillId <skillId>", "Id of the skill you want to pull")
+                .action(this.pullSkill);
+            const pushCommand = configurator.command("push");
+            pushCommand.command("skill")
+                .description("Command to push a skill to a project")
+                .requiredOption("--projectId <projectId>", "Id of the project you want to push")
+                .requiredOption("-f, --file <file>", "The file you want to push")
+                .action(this.pushSkill);
+        }
+        analyzeActionFlows(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new action_flow_command_service_1.ActionFlowCommandService(context).analyzeActionFlows(options.packageId, options.outputToJsonFile);
+            });
+        }
+        exportActionFlows(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new action_flow_command_service_1.ActionFlowCommandService(context).exportActionFlows(options.packageId, options.file);
+            });
+        }
+        importActionFlows(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new action_flow_command_service_1.ActionFlowCommandService(context).importActionFlows(options.packageId, options.file, options.dryRun, options.outputToJsonFile);
+            });
+        }
+        pullSkill(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new skill_command_service_1.SkillCommandService(context).pullSkill(options.profile, options.projectId, options.skillId);
+            });
+        }
+        pushSkill(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new skill_command_service_1.SkillCommandService(context).pushSkill(options.profile, options.projectId, options.file);
+            });
+        }
+    }
+    return Module;
+});

package/commands/{skill.command.js → action-flows/skill/skill-command.service.js}

@@ -13,29 +13,27 @@ 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/skill-manager.factory"], factory);
+        define(["require", "exports", "./skill.manager-factory"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.SkillCommand = void 0;
-    const content_service_1 = require("../services/content.service");
-    const skill_manager_factory_1 = require("../content/factory/skill-manager.factory");
-    class SkillCommand {
-        constructor() {
-            this.contentService = new content_service_1.ContentService();
-            this.skillManagerFactory = new skill_manager_factory_1.SkillManagerFactory();
+    exports.SkillCommandService = void 0;
+    const skill_manager_factory_1 = require("./skill.manager-factory");
+    class SkillCommandService {
+        constructor(context) {
+            this.skillManagerFactory = new skill_manager_factory_1.SkillManagerFactory(context);
         }
         pullSkill(profile, projectId, skillId) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield this.contentService.pull(profile, this.skillManagerFactory.createManager(projectId, skillId, null));
+                yield this.skillManagerFactory.createManager(projectId, skillId, null).pull();
             });
         }
         pushSkill(profile, projectId, filename) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield this.contentService.push(profile, this.skillManagerFactory.createManager(projectId, null, filename));
+                yield this.skillManagerFactory.createManager(projectId, null, filename).push();
             });
         }
     }
-    exports.SkillCommand = SkillCommand;
+    exports.SkillCommandService = SkillCommandService;
 });

package/{content/factory/skill-manager.factory.js → commands/action-flows/skill/skill.manager-factory.js}

@@ -4,7 +4,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "fs", "path", "../../util/logger", "../manager/skill.manager"], factory);
+        define(["require", "exports", "fs", "path", "../../../core/utils/logger", "./skill.manager"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -12,11 +12,14 @@
     exports.SkillManagerFactory = void 0;
     const fs = require("fs");
     const path = require("path");
-    const logger_1 = require("../../util/logger");
-    const skill_manager_1 = require("../manager/skill.manager");
+    const logger_1 = require("../../../core/utils/logger");
+    const skill_manager_1 = require("./skill.manager");
     class SkillManagerFactory {
+        constructor(context) {
+            this.context = context;
+        }
         createManager(projectId, skillId, filename) {
-            const skillManager = new skill_manager_1.SkillManager();
+            const skillManager = new skill_manager_1.SkillManager(this.context);
             skillManager.skillId = skillId;
             skillManager.projectId = projectId;
             if (filename !== null) {

package/{content/manager → commands/action-flows/skill}/skill.manager.js

@@ -4,15 +4,18 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./base.manager", "form-data"], factory);
+        define(["require", "exports", "form-data", "../../../core/http/http-shared/base.manager"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.SkillManager = void 0;
-    const base_manager_1 = require("./base.manager");
     const FormData = require("form-data");
+    const base_manager_1 = require("../../../core/http/http-shared/base.manager");
     class SkillManager extends base_manager_1.BaseManager {
+        constructor(context) {
+            super(context);
+        }
         get content() {
             return this._content;
         }
@@ -33,8 +36,8 @@
         }
         getConfig() {
             return {
-                pushUrl: this.profile.team.replace(/\/?$/, `${SkillManager.BASE_URL}/${this.projectId}/skills/import-file`),
-                pullUrl: this.profile.team.replace(/\/?$/, `${SkillManager.BASE_URL}/${this.projectId}/skills/${this.skillId}/export`),
+                pushUrl: `${SkillManager.BASE_URL}/${this.projectId}/skills/import-file`,
+                pullUrl: `${SkillManager.BASE_URL}/${this.projectId}/skills/${this.skillId}/export`,
                 exportFileName: "skill_" + this.skillId + ".json",
                 onPushSuccessMessage: (skill) => {
                     return "Skill was pushed successfully. New ID: " + skill.id;

package/commands/analysis/analysis-bookmarks-command.service.js

@@ -0,0 +1,39 @@
+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", "./analysis-bookmarks.manager-factory"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AnalysisBookmarksCommandService = void 0;
+    const analysis_bookmarks_manager_factory_1 = require("./analysis-bookmarks.manager-factory");
+    class AnalysisBookmarksCommandService {
+        constructor(context) {
+            this.analysisBookmarksManagerFactory = new analysis_bookmarks_manager_factory_1.AnalysisBookmarksManagerFactory(context);
+        }
+        pullAnalysisBookmarks(analysisId, type) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.analysisBookmarksManagerFactory.createAnalysisBookmarksManager(null, analysisId, type).pull();
+            });
+        }
+        pushAnalysisBookmarks(analysisId, filename) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.analysisBookmarksManagerFactory.createAnalysisBookmarksManager(filename, analysisId).push();
+            });
+        }
+    }
+    exports.AnalysisBookmarksCommandService = AnalysisBookmarksCommandService;
+});

package/{content/factory/analysis-bookmarks-manager.factory.js → commands/analysis/analysis-bookmarks.manager-factory.js}

@@ -4,7 +4,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "fs", "path", "../../util/logger", "../manager/analysis-bookmarks.manager"], factory);
+        define(["require", "exports", "fs", "path", "./analysis-bookmarks.manager", "../../core/utils/logger"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -12,11 +12,14 @@
     exports.AnalysisBookmarksManagerFactory = void 0;
     const fs = require("fs");
     const path = require("path");
-    const logger_1 = require("../../util/logger");
-    const analysis_bookmarks_manager_1 = require("../manager/analysis-bookmarks.manager");
+    const analysis_bookmarks_manager_1 = require("./analysis-bookmarks.manager");
+    const logger_1 = require("../../core/utils/logger");
     class AnalysisBookmarksManagerFactory {
+        constructor(context) {
+            this.context = context;
+        }
         createAnalysisBookmarksManager(filename, analysisId, type) {
-            const analysisBookmarksManager = new analysis_bookmarks_manager_1.AnalysisBookmarksManager();
+            const analysisBookmarksManager = new analysis_bookmarks_manager_1.AnalysisBookmarksManager(this.context);
             analysisBookmarksManager.analysisId = analysisId;
             if (type === undefined || type === null) {
                 type = "user";

package/{content/manager → commands/analysis}/analysis-bookmarks.manager.js

@@ -4,16 +4,19 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./base.manager", "fs", "form-data"], factory);
+        define(["require", "exports", "fs", "form-data", "../../core/http/http-shared/base.manager"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.AnalysisBookmarksManager = void 0;
-    const base_manager_1 = require("./base.manager");
     const fs = require("fs");
     const FormData = require("form-data");
+    const base_manager_1 = require("../../core/http/http-shared/base.manager");
     class AnalysisBookmarksManager extends base_manager_1.BaseManager {
+        constructor(context) {
+            super(context);
+        }
         get fileName() {
             return this._fileName;
         }
@@ -35,9 +38,9 @@
         getConfig() {
             const pullUrl = `${AnalysisBookmarksManager.BASE_URL}/export?analysisId=${this.analysisId}&type=${this.type}`;
             return {
-                pushUrl: this.profile.team.replace(/\/?$/, `${AnalysisBookmarksManager.BASE_URL}/import?analysisId=${this.analysisId}`),
-                pullUrl: this.profile.team.replace(/\/?$/, pullUrl),
-                exportFileName: `${AnalysisBookmarksManager.ANALYSIS_BOOKMARKS_FILE_PREFIX}${this.analysisId}${".json"}`,
+                pushUrl: `${AnalysisBookmarksManager.BASE_URL}/import?analysisId=${this.analysisId}`,
+                pullUrl: pullUrl,
+                exportFileName: `${AnalysisBookmarksManager.ANALYSIS_BOOKMARKS_FILE_PREFIX}${this.analysisId}.json`,
                 onPushSuccessMessage: () => {
                     return "Analysis Bookmarks was pushed successfully.";
                 },

package/commands/analysis/module.js

@@ -0,0 +1,52 @@
+/**
+ * Commands related to the Analysis feature.
+ */
+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", "../../core/command/module-handler", "./analysis-bookmarks-command.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    const module_handler_1 = require("../../core/command/module-handler");
+    const analysis_bookmarks_command_service_1 = require("./analysis-bookmarks-command.service");
+    class Module extends module_handler_1.IModule {
+        register(context, configurator) {
+            const pullCommand = configurator.command("pull");
+            pullCommand.command("bookmarks")
+                .description("Command to pull an analysis bookmarks")
+                .option("--type <type>", "Pull shared/all Analysis Bookmarks, else by default get user bookmarks")
+                .requiredOption("--id <id>", "Id of the analysis you want to pull")
+                .action(this.pullAnalysisBookmarks);
+            const pushCommand = configurator.command("push");
+            pushCommand.command("bookmarks")
+                .description("Command to push an analysis to a workspace")
+                .requiredOption("--id <id>", "Id of the Analysis to which you want to push the analysis bookmarks")
+                .requiredOption("-f, --file <file>", "The file you want to push")
+                .action(this.pushAnalysisBookmarks);
+        }
+        pullAnalysisBookmarks(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new analysis_bookmarks_command_service_1.AnalysisBookmarksCommandService(context).pullAnalysisBookmarks(options.id, options.type);
+            });
+        }
+        pushAnalysisBookmarks(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new analysis_bookmarks_command_service_1.AnalysisBookmarksCommandService(context).pushAnalysisBookmarks(options.id, options.file);
+            });
+        }
+    }
+    return Module;
+});

package/commands/configuration-management/api/batch-import-export-api.js

@@ -0,0 +1,84 @@
+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", "../../../core/utils/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BatchImportExportApi = void 0;
+    const logger_1 = require("../../../core/utils/logger");
+    class BatchImportExportApi {
+        constructor(context) {
+            this.httpClient = context.httpClient;
+        }
+        findAllActivePackages(flavors, withDependencies = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                queryParams.set("withDependencies", withDependencies.toString());
+                flavors.forEach(flavor => queryParams.append("flavors", flavor));
+                return this.httpClient.get(`/package-manager/api/core/packages/export/list?${queryParams.toString()}`).catch(e => {
+                    throw new logger_1.FatalError(`Problem getting active packages: ${e}`);
+                });
+            });
+        }
+        findActivePackagesByVariableValue(flavors, variableValue, variableType) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                queryParams.set("variableValue", variableValue);
+                if (variableType) {
+                    queryParams.set("variableType", variableType);
+                }
+                flavors.forEach(flavor => queryParams.append("flavors", flavor));
+                return this.httpClient.get(`/package-manager/api/core/packages/export/list-by-variable-value?${queryParams.toString()}`).catch(e => {
+                    throw new logger_1.FatalError(`Problem getting active packages by variable value: ${e}`);
+                });
+            });
+        }
+        findActivePackagesByKeys(packageKeys, withDependencies = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                packageKeys.forEach(key => queryParams.append("packageKeys", key));
+                queryParams.set("withDependencies", withDependencies.toString());
+                return this.httpClient.get(`/package-manager/api/core/packages/export/list-by-keys?${queryParams.toString()}`).catch(e => {
+                    throw new logger_1.FatalError(`Problem getting active packages by keys: ${e}`);
+                });
+            });
+        }
+        exportPackages(packageKeys, withDependencies = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                packageKeys.forEach(packageKey => queryParams.append("packageKeys", packageKey));
+                queryParams.set("withDependencies", withDependencies.toString());
+                return this.httpClient.getFile(`/package-manager/api/core/packages/export/batch?${queryParams.toString()}`).catch(e => {
+                    throw new logger_1.FatalError(`Problem exporting packages: ${e}`);
+                });
+            });
+        }
+        importPackages(data, overwrite) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.httpClient.postFile("/package-manager/api/core/packages/import/batch", data, { overwrite });
+            });
+        }
+        findVariablesWithValuesByPackageKeysAndVersion(packagesByKeyAndVersion) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.httpClient.post("/package-manager/api/core/packages/export/batch/variables-with-assignments", packagesByKeyAndVersion).catch(e => {
+                    throw new logger_1.FatalError(`Problem exporting package variables: ${e}`);
+                });
+            });
+        }
+    }
+    exports.BatchImportExportApi = BatchImportExportApi;
+});