@celonis/content-cli 0.5.2 → 0.5.4

package/api/variable-assignment-apis.js

@@ -0,0 +1,20 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.variableAssignmentApis = {
+        DATA_MODEL: {
+            url: "/package-manager/api/compute-pools/pools-with-data-models"
+        },
+        CONNECTION: {
+            url: "/process-automation-v2/api/connections"
+        }
+    };
+});

package/api/variables-api.js

@@ -13,13 +13,14 @@ 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", "../services/http-client-service.v2", "../util/logger", "./variable-assignment-apis"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     const http_client_service_v2_1 = require("../services/http-client-service.v2");
     const logger_1 = require("../util/logger");
+    const variable_assignment_apis_1 = require("./variable-assignment-apis");
     class VariablesApi {
         assignVariableValues(packageKey, variablesAssignments) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -28,7 +29,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
+        getCandidateAssignments(type, params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!VariablesApi.ASSIGNMENT_APIS[type]) {
+                    throw new logger_1.FatalError(`Variable type ${type} not supported.`);
+                }
+                const apiUrl = VariablesApi.ASSIGNMENT_APIS[type].url + (params.toString().length ? `?${params.toString()}` : "");
+                return http_client_service_v2_1.httpClientV2.get(apiUrl).catch(e => {
+                    throw new logger_1.FatalError(`Problem getting variables assignment values for type ${type}: ${e}`);
+                });
+            });
+        }
     }
     VariablesApi.INSTANCE = new VariablesApi();
+    VariablesApi.ASSIGNMENT_APIS = variable_assignment_apis_1.variableAssignmentApis;
     exports.variablesApi = VariablesApi.INSTANCE;
 });

package/commands/variable.command.js

@@ -0,0 +1,35 @@
+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/package-manager/variable-service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const variable_service_1 = require("../services/package-manager/variable-service");
+    class VariableCommand {
+        listAssignments(variableType, jsonResponse, params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (jsonResponse) {
+                    yield variable_service_1.variableService.findAndExportCandidateAssignments(variableType, params);
+                }
+                else {
+                    yield variable_service_1.variableService.listCandidateAssignments(variableType, params);
+                }
+            });
+        }
+    }
+    exports.VariableCommand = VariableCommand;
+});

package/content-cli-import.js

@@ -31,7 +31,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 .option("-p, --profile <profile>", "Profile which you want to use to list packages")
                 .option("--spaceMappings <spaceMappings...>", "List of mappings for importing packages to different target spaces. Mappings should follow format 'packageKey:targetSpaceKey'")
                 .option("--overwrite", "Flag to allow overwriting of packages")
-                .option("--dataModelMappingsFile <dataModelMappingsFile>", "DataModel variable mappings file path")
+                .option("--dataModelMappingsFile <dataModelMappingsFile>", "DataModel variable mappings file path. If missing, variables will be mapped from manifest file.")
                 .requiredOption("-f, --file <file>", "Exported packages file (relative path)")
                 .action((cmd) => __awaiter(this, void 0, void 0, function* () {
                 yield new package_command_1.PackageCommand().batchImportPackages(cmd.spaceMappings, cmd.dataModelMappingsFile, cmd.file, cmd.overwrite);

package/content-cli-list.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", "./commands/package.command", "./commands/space.command", "./commands/data-pool.command", "./commands/asset.command", "./util/logger", "commander", "./util/context-initializer"], factory);
+        define(["require", "exports", "./commands/package.command", "./commands/space.command", "./commands/data-pool.command", "./commands/asset.command", "./util/logger", "commander", "./util/context-initializer", "./commands/variable.command"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -25,6 +25,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const logger_1 = require("./util/logger");
     const commander = require("commander");
     const context_initializer_1 = require("./util/context-initializer");
+    const variable_command_1 = require("./commands/variable.command");
     class List {
         static packages(program) {
             program
@@ -77,6 +78,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             }));
             return program;
         }
+        static assignments(program) {
+            program
+                .command("assignments")
+                .description("Command to list possible variable assignments for a type")
+                .option("-p, --profile <profile>", "Profile which you want to use to list possible variable assignments")
+                .option("--json", "Return response as json type", "")
+                .requiredOption("--type <type>", "Type of variable")
+                .option("--params <params>", "Variable query params")
+                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new variable_command_1.VariableCommand().listAssignments(cmd.type, cmd.json, cmd.params);
+                process.exit();
+            }));
+            return program;
+        }
     }
     exports.List = List;
     process.on("unhandledRejection", (e, promise) => {
@@ -87,6 +102,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         List.spaces(commander);
         List.dataPools(commander);
         List.assets(commander);
+        List.assignments(commander);
         commander.parse(process.argv);
     };
     context_initializer_1.ContextInitializer.initContext()

package/interfaces/variable-assignment-api.interface.js

@@ -0,0 +1,12 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/lib/api/variable-assignment-apis.d.ts

@@ -0,0 +1,4 @@
+import { VariableAssignmentApi } from "../interfaces/variable-assignment-api.interface";
+export declare const variableAssignmentApis: {
+    [key: string]: VariableAssignmentApi;
+};

package/lib/api/variables-api.d.ts

@@ -1,7 +1,13 @@
+/// <reference types="node" />
 import { ContentNodeTransport, VariablesAssignments } from "../interfaces/package-manager.interfaces";
+import { URLSearchParams } from "url";
 declare class VariablesApi {
     static readonly INSTANCE: VariablesApi;
+    static readonly ASSIGNMENT_APIS: {
+        [key: string]: import("../interfaces/variable-assignment-api.interface").VariableAssignmentApi;
+    };
     assignVariableValues(packageKey: string, variablesAssignments: VariablesAssignments[]): Promise<ContentNodeTransport[]>;
+    getCandidateAssignments(type: string, params: URLSearchParams): Promise<object[]>;
 }
 export declare const variablesApi: VariablesApi;
 export {};

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

@@ -0,0 +1,3 @@
+export declare class VariableCommand {
+    listAssignments(variableType: string, jsonResponse: boolean, params: string): Promise<void>;
+}

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

@@ -5,5 +5,6 @@ export declare class List {
     static spaces(program: CommanderStatic): CommanderStatic;
     static dataPools(program: CommanderStatic): CommanderStatic;
     static assets(program: CommanderStatic): CommanderStatic;
+    static assignments(program: CommanderStatic): CommanderStatic;
 }
 export {};

package/lib/interfaces/variable-assignment-api.interface.d.ts

@@ -0,0 +1,3 @@
+export interface VariableAssignmentApi {
+    url: string;
+}

package/lib/services/package-manager/variable-service.d.ts

@@ -2,6 +2,9 @@ import { PackageManagerVariableType, PackageWithVariableAssignments, VariablesAs
 declare class VariableService {
     getVariableAssignmentsForNodes(type?: PackageManagerVariableType): Promise<PackageWithVariableAssignments[]>;
     assignVariableValues(packageKey: string, variablesAssignments: VariablesAssignments[]): Promise<void>;
+    listCandidateAssignments(type: string, params: string): Promise<void>;
+    findAndExportCandidateAssignments(type: string, params: string): Promise<void>;
+    private parseParams;
 }
 export declare const variableService: VariableService;
 export {};

package/package.json

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

package/services/package-manager/package-service.js

@@ -173,13 +173,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
                 nodeInTargetTeam = yield node_api_1.nodeApi.findOneByKeyAndRootNodeKey(packageToImport.packageKey, packageToImport.packageKey);
                 if (this.isLatestVersion(versionOfPackageBeingImported, [...packageToImport.dependenciesByVersion.keys()])) {
-                    const variableAssignments = packageToImport.variables
-                        .filter(variable => variable.type === package_manager_interfaces_1.PackageManagerVariableType.DATA_MODEL).map(variable => {
-                        var _a;
-                        variable.value = dmTargetIdsBySourceIds.get((_a = variable.value) === null || _a === void 0 ? void 0 : _a.toString());
-                        return variable;
-                    });
-                    yield variable_service_1.variableService.assignVariableValues(nodeInTargetTeam.key, variableAssignments);
+                    if (dmTargetIdsBySourceIds.size > 0) {
+                        const variableAssignments = packageToImport.variables
+                            .filter(variable => variable.type === package_manager_interfaces_1.PackageManagerVariableType.DATA_MODEL).map(variable => {
+                            var _a;
+                            variable.value = dmTargetIdsBySourceIds.get((_a = variable.value) === null || _a === void 0 ? void 0 : _a.toString());
+                            return variable;
+                        });
+                        yield variable_service_1.variableService.assignVariableValues(nodeInTargetTeam.key, variableAssignments);
+                    }
+                    else {
+                        yield variable_service_1.variableService.assignVariableValues(nodeInTargetTeam.key, packageToImport.variables);
+                    }
                 }
                 draftIdsByPackageKeyAndVersion.set(`${nodeInTargetTeam.key}_${versionOfPackageBeingImported}`, nodeInTargetTeam.workingDraftId);
                 yield this.updateDependencyVersions(packageToImport, versionOfPackageBeingImported, sourceToTargetVersionsByNodeKey, draftIdsByPackageKeyAndVersion);

package/services/package-manager/variable-service.js

@@ -13,13 +13,17 @@ 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", "../../api/package-api", "../../api/variables-api"], factory);
+        define(["require", "exports", "../../api/package-api", "../../api/variables-api", "uuid", "../../util/logger", "../file-service", "url"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     const package_api_1 = require("../../api/package-api");
     const variables_api_1 = require("../../api/variables-api");
+    const uuid_1 = require("uuid");
+    const logger_1 = require("../../util/logger");
+    const file_service_1 = require("../file-service");
+    const url_1 = require("url");
     class VariableService {
         getVariableAssignmentsForNodes(type) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -31,6 +35,39 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 yield variables_api_1.variablesApi.assignVariableValues(packageKey, variablesAssignments);
             });
         }
+        listCandidateAssignments(type, params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const parsedParams = this.parseParams(params);
+                const assignments = yield variables_api_1.variablesApi.getCandidateAssignments(type, parsedParams);
+                assignments.forEach(assignment => {
+                    logger_1.logger.info(JSON.stringify(assignment));
+                });
+            });
+        }
+        findAndExportCandidateAssignments(type, params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const parsedParams = this.parseParams(params);
+                const assignments = yield variables_api_1.variablesApi.getCandidateAssignments(type, parsedParams);
+                const filename = uuid_1.v4() + ".json";
+                file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(assignments), filename);
+                logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+            });
+        }
+        parseParams(params) {
+            const queryParams = new url_1.URLSearchParams();
+            if (params) {
+                try {
+                    params.split(",").forEach((param) => {
+                        const paramKeyValuePair = param.split("=");
+                        queryParams.set(paramKeyValuePair[0], paramKeyValuePair[1]);
+                    });
+                }
+                catch (e) {
+                    throw new logger_1.FatalError(`Problem parsing query params: ${e}`);
+                }
+            }
+            return queryParams;
+        }
     }
     exports.variableService = new VariableService();
 });