@contrail/cli 1.0.71 → 2.0.1

package/dist/commands/types/loadAll.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAll = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const login_1 = require("../../auth/login");
+const uploadOptionSets_1 = require("./uploadOptionSets");
+const uploadOptionSetHierarchies_1 = require("./uploadOptionSetHierarchies");
+const uploadUsageInfo_1 = require("./uploadUsageInfo");
+const uploadRuleSets_1 = require("./uploadRuleSets");
+const uploadTypePropertyPolicies_1 = require("./uploadTypePropertyPolicies");
+const type_uploader_1 = require("../../helpers/types/type-uploader");
+class GetAllTypes extends core_1.Command {
+    async run() {
+        await loadAll();
+    }
+}
+exports.default = GetAllTypes;
+GetAllTypes.description = 'Get all Types and associated data for your Org';
+GetAllTypes.examples = [
+    `$ contrail types getAll
+`,
+];
+async function loadAll() {
+    try {
+        await (0, login_1.authUser)();
+        await (0, uploadOptionSets_1.uploadOptionSets)();
+        await (0, uploadOptionSetHierarchies_1.uploadOptionSetHierarchies)();
+        await (0, type_uploader_1.uploadTypes)();
+        await (0, uploadUsageInfo_1.uploadUsageInfo)();
+        await (0, uploadRuleSets_1.uploadRuleSets)();
+        await (0, uploadTypePropertyPolicies_1.uploadTypePropertyPolicies)();
+    }
+    catch (e) {
+        console.log(`%s Types Upload Failed. ${e}`, chalk_1.default.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s Types Upload Complete.', chalk_1.default.green.bold('COMPLETE'));
+}
+exports.loadAll = loadAll;

package/dist/commands/types/mergeOptionSets.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class MergeOptionSets extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        file: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/{lib/types/option-set-merger.js → dist/commands/types/mergeOptionSets.js}

@@ -1,105 +1,114 @@
-import { Entities } from '@contrail/sdk';
-import fs from 'fs';
-import { getSeparatorByPlatform } from '../common';
-import { authUser } from '../auth/login';
-import chalk from 'chalk';
-const yaml = require('js-yaml');
-export async function MergeOptionSets(args) {
-    try {
-        if ((args === null || args === void 0 ? void 0 : args.length) < 4) {
-            throw new Error('File name must be included.');
-        }
-        console.log('%s Importing local file', chalk.yellow.bold('OPTION SET MERGE'));
-        const fileLocation = args[3];
-        console.log('Using File: ', fileLocation);
-        await mergeOptionSets(fileLocation);
-        console.log('%s Merged', chalk.yellow.bold('OPTION SET MERGE'));
-    }
-    catch (e) {
-        console.log(`%s Merge Failed. ${e}`, chalk.red.bold('FAIL'));
-        return;
-    }
-    console.log('%s Merge Complete.', chalk.green.bold('COMPLETE'));
-}
-function loadOptionSets(fileLocation) {
-    const TARGET_DIR = process.cwd();
-    try {
-        const separator = getSeparatorByPlatform();
-        const fullPath = TARGET_DIR + separator + fileLocation;
-        console.log('Getting file from path: ', fullPath);
-        const doc = yaml.load(fs.readFileSync(TARGET_DIR + separator + fileLocation, 'utf8'));
-        return doc;
-    }
-    catch (e) {
-        throw new Error(`ERROR PARSING YAML: ${e}`);
-    }
-}
-async function mergeOptionSets(fileLocation) {
-    const uploadedOptionSets = loadOptionSets(fileLocation);
-    await authUser();
-    const currentOptionSetsFull = await new Entities().get({
-        entityName: 'type-property-option-set',
-    });
-    const currentOptionSets = currentOptionSetsFull.map(os => Object.assign({}, {
-        name: os.name,
-        isArchived: os.isArchived,
-        optionSet: os.optionSet,
-    }));
-    const currentOptionSetsByName = {};
-    for (const currentOptionSet of currentOptionSets) {
-        currentOptionSetsByName[currentOptionSet.name] = currentOptionSet;
-    }
-    const uploadedOptionSetsByName = {};
-    for (const optionSet of uploadedOptionSets) {
-        uploadedOptionSetsByName[optionSet.name] = optionSet;
-    }
-    const mergedOptionSets = [];
-    for (const uploadedOptionSet of uploadedOptionSets) {
-        const existing = currentOptionSetsByName[uploadedOptionSet.name];
-        if (!existing) {
-            if (!uploadedOptionSet.optionSet) {
-                console.log('No OptionSet for: ', uploadedOptionSet.name);
-                continue;
-            }
-            console.log('Adding New: ', uploadedOptionSet.name);
-            mergedOptionSets.push(uploadedOptionSet);
-        }
-        else {
-            console.log('Merging: ', uploadedOptionSet.name);
-            mergedOptionSets.push(mergeOptionSet(existing, uploadedOptionSet));
-        }
-    }
-    for (const currentOptionSet of currentOptionSets) {
-        const found = uploadedOptionSetsByName[currentOptionSet.name];
-        if (!found) {
-            console.log('Adding Existing: ', currentOptionSet.name);
-            mergedOptionSets.push(currentOptionSet);
-        }
-    }
-    saveData(mergedOptionSets);
-}
-function mergeOptionSet(existingOptionSet, uploadedOptionSet) {
-    var _a;
-    const merged = {
-        name: uploadedOptionSet.name,
-        optionSet: uploadedOptionSet.optionSet,
-        isArchived: uploadedOptionSet.isArchived,
-    };
-    if (((_a = existingOptionSet === null || existingOptionSet === void 0 ? void 0 : existingOptionSet.optionSet) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-        for (const keyVal of existingOptionSet.optionSet) {
-            const value = keyVal.value;
-            const display = keyVal.display;
-            const found = merged.optionSet.find(keyVal => keyVal.value === value);
-            if (!found) {
-                merged.optionSet.push({ value, display });
-            }
-        }
-    }
-    return merged;
-}
-function saveData(data) {
-    const yamlStr = yaml.dump(data);
-    const CURRENT_DIR = process.cwd();
-    const separator = getSeparatorByPlatform();
-    fs.writeFileSync(CURRENT_DIR + separator + 'merged_optionSets.yml', yamlStr, 'utf8');
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const sdk_1 = require("@contrail/sdk");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const login_1 = require("../../auth/login");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const core_1 = require("@oclif/core");
+const yaml = require('js-yaml');
+class MergeOptionSets extends core_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(MergeOptionSets);
+        try {
+            this.log('%s Importing local file', chalk_1.default.yellow.bold('OPTION SET MERGE'));
+            this.log('Using File: ', args.file);
+            await mergeOptionSets(args.file);
+            this.log('%s Merged', chalk_1.default.yellow.bold('OPTION SET MERGE'));
+        }
+        catch (e) {
+            this.log(`%s Merge Failed. ${e}`, chalk_1.default.red.bold('FAIL'));
+            return;
+        }
+        this.log('%s Merge Complete.', chalk_1.default.green.bold('COMPLETE'));
+    }
+}
+exports.default = MergeOptionSets;
+MergeOptionSets.description = 'Merge the OptionSets from an existing org and the OptionSets passed in. OptionSets File must be .yml.';
+MergeOptionSets.examples = [
+    `$ contrail types mergeOptionSets <File Path>
+`,
+];
+MergeOptionSets.args = {
+    file: core_1.Args.string({ description: 'File to merge with the cloud option sets', required: true }),
+};
+function loadOptionSets(fileLocation) {
+    const TARGET_DIR = process.cwd();
+    try {
+        const fullPath = path.resolve(path.join(TARGET_DIR, fileLocation));
+        const doc = yaml.load(fs_1.default.readFileSync(fullPath, 'utf8'));
+        return doc;
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING YAML: ${e}`);
+    }
+}
+async function mergeOptionSets(fileLocation) {
+    const uploadedOptionSets = loadOptionSets(fileLocation);
+    await (0, login_1.authUser)();
+    const currentOptionSetsFull = await new sdk_1.Entities().get({
+        entityName: 'type-property-option-set',
+    });
+    const currentOptionSets = currentOptionSetsFull.map(os => Object.assign({}, {
+        name: os.name,
+        isArchived: os.isArchived,
+        optionSet: os.optionSet,
+    }));
+    const currentOptionSetsByName = {};
+    for (const currentOptionSet of currentOptionSets) {
+        currentOptionSetsByName[currentOptionSet.name] = currentOptionSet;
+    }
+    const uploadedOptionSetsByName = {};
+    for (const optionSet of uploadedOptionSets) {
+        uploadedOptionSetsByName[optionSet.name] = optionSet;
+    }
+    const mergedOptionSets = [];
+    for (const uploadedOptionSet of uploadedOptionSets) {
+        const existing = currentOptionSetsByName[uploadedOptionSet.name];
+        if (!existing) {
+            if (!uploadedOptionSet.optionSet) {
+                console.log('No OptionSet for: ', uploadedOptionSet.name);
+                continue;
+            }
+            console.log('Adding New: ', uploadedOptionSet.name);
+            mergedOptionSets.push(uploadedOptionSet);
+        }
+        else {
+            console.log('Merging: ', uploadedOptionSet.name);
+            mergedOptionSets.push(mergeOptionSet(existing, uploadedOptionSet));
+        }
+    }
+    for (const currentOptionSet of currentOptionSets) {
+        const found = uploadedOptionSetsByName[currentOptionSet.name];
+        if (!found) {
+            console.log('Adding Existing: ', currentOptionSet.name);
+            mergedOptionSets.push(currentOptionSet);
+        }
+    }
+    saveData(mergedOptionSets);
+}
+function mergeOptionSet(existingOptionSet, uploadedOptionSet) {
+    var _a;
+    const merged = {
+        name: uploadedOptionSet.name,
+        optionSet: uploadedOptionSet.optionSet,
+        isArchived: uploadedOptionSet.isArchived,
+    };
+    if (((_a = existingOptionSet === null || existingOptionSet === void 0 ? void 0 : existingOptionSet.optionSet) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+        for (const keyVal of existingOptionSet.optionSet) {
+            const value = keyVal.value;
+            const display = keyVal.display;
+            const found = merged.optionSet.find(keyVal => keyVal.value === value);
+            if (!found) {
+                merged.optionSet.push({ value, display });
+            }
+        }
+    }
+    return merged;
+}
+function saveData(data) {
+    const yamlStr = yaml.dump(data);
+    const CURRENT_DIR = process.cwd();
+    fs_1.default.writeFileSync(path.resolve(path.join(CURRENT_DIR, 'merged_optionSets.yml')), yamlStr, 'utf8');
+}

package/dist/commands/types/mergeTypeProperties.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class MergeTypeProperties extends Command {
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    static args: {
+        file: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+        typePaths: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/types/mergeTypeProperties.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const login_1 = require("../../auth/login");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const core_1 = require("@oclif/core");
+const type_extractor_1 = require("../../helpers/types/type-extractor");
+const getAll_1 = require("./getAll");
+const types_1 = require("../../api/types");
+const yaml = require('js-yaml');
+class MergeTypeProperties extends core_1.Command {
+    async run() {
+        const { args, argv } = await this.parse(MergeTypeProperties);
+        try {
+            this.log('%s Importing local file', chalk_1.default.yellow.bold('TYPE PROPERTIES MERGE'));
+            this.log('Using File: ', args.file);
+            console.log('argv:', JSON.stringify(argv));
+            const typePaths = argv.slice(1);
+            this.log('Using TypePaths: ', typePaths);
+            await mergeTypeProperties(args.file, typePaths);
+            this.log('%s Merged', chalk_1.default.yellow.bold('TYPE PROPERTIES MERGE'));
+        }
+        catch (e) {
+            this.log(`%s Merge Failed. ${e}`, chalk_1.default.red.bold('FAIL'));
+            return;
+        }
+        this.log('%s Merge Complete.', chalk_1.default.green.bold('COMPLETE'));
+    }
+}
+exports.default = MergeTypeProperties;
+MergeTypeProperties.description = 'Merge the TypeProperties from an existing org and the TypeProperties passed in. Add to Types via TypePath File must be .yml';
+MergeTypeProperties.examples = [
+    `$ contrail types mergeTypeProperties <File Path> <TypePaths>
+    `,
+];
+// variable argument length
+MergeTypeProperties.strict = false;
+MergeTypeProperties.args = {
+    file: core_1.Args.string({ description: 'File to parse', required: true }),
+    typePaths: core_1.Args.string({ description: 'A list of the type paths to merge', required: true }),
+};
+function loadTypeProperties(fileLocation) {
+    const TARGET_DIR = process.cwd();
+    try {
+        const fullPath = path.join(TARGET_DIR, fileLocation);
+        return yaml.load(fs_1.default.readFileSync(fullPath, 'utf8'));
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING YAML: ${e}`);
+    }
+}
+async function mergeTypeProperties(fileLocation, typePaths) {
+    const uploadedTypeProperties = loadTypeProperties(fileLocation);
+    await (0, login_1.authUser)();
+    const data = {
+        types: await (0, type_extractor_1.getTypes)(),
+        optionSets: await (0, types_1.getOptionSets)(),
+        optionSetHierarchies: [],
+        ruleSets: [],
+        ruleSetLinks: [],
+        usageInfo: [],
+        typePropertyPolicies: [],
+        typePropertyPolicyLinks: [],
+    };
+    const reducedData = await (0, getAll_1.reduceData)(data);
+    for (const typePath of typePaths) {
+        const foundType = reducedData.reducedTypes.find(reducedTypes => reducedTypes.typePath === typePath);
+        if (!foundType) {
+            console.warn(`%s No Type found for: ${typePath}`, chalk_1.default.red.bold('WARNING'));
+        }
+        mergeType(foundType, uploadedTypeProperties);
+    }
+    saveData({ types: reducedData.reducedTypes });
+}
+function mergeType(reducedType, typePropertiesToAdd) {
+    for (const typeProperty of typePropertiesToAdd) {
+        const found = reducedType.typeProperties.find(tp => tp.slug === typeProperty.slug);
+        if (!found) {
+            reducedType.typeProperties.push(typeProperty);
+        }
+    }
+}
+function saveData(data) {
+    const yamlStr = yaml.dump(data);
+    const CURRENT_DIR = process.cwd();
+    fs_1.default.writeFileSync(path.resolve(path.join(CURRENT_DIR, 'merged_types.yml')), yamlStr, 'utf8');
+}

package/dist/commands/types/parseOptionSetsHierarchyLocalFile.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class ParseOptionSetsHierarchyLocalFile extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        file: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}
+export declare function parseOptionSetsHierarchyLocalFile(fileLocation: any): Promise<void>;

package/dist/commands/types/parseOptionSetsHierarchyLocalFile.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOptionSetsHierarchyLocalFile = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const csv = require('csvtojson');
+const sdk_1 = require("@contrail/sdk");
+const util_1 = require("@contrail/util");
+const login_1 = require("../../auth/login");
+const core_1 = require("@oclif/core");
+class ParseOptionSetsHierarchyLocalFile extends core_1.Command {
+    async run() {
+        const { args } = await this.parse(ParseOptionSetsHierarchyLocalFile);
+        await parseOptionSetsHierarchyLocalFile(args.file);
+    }
+}
+exports.default = ParseOptionSetsHierarchyLocalFile;
+ParseOptionSetsHierarchyLocalFile.description = 'Parse CSV file into OptionSetHierarchy';
+ParseOptionSetsHierarchyLocalFile.examples = [
+    `$ contrail types parseOptionSetsHierarchyLocalFile <File Paths>
+`,
+];
+ParseOptionSetsHierarchyLocalFile.args = {
+    file: core_1.Args.string({ description: 'File to parse', required: true }),
+};
+async function parseOptionSetsHierarchyLocalFile(fileLocation) {
+    try {
+        await (0, login_1.authUser)();
+        console.log('%s Importing local file', chalk_1.default.yellow.bold('OPTION SET HIERARCHY PARSE'));
+        console.log('Using File: ', fileLocation);
+        await parseAndSaveOptionSetHierarchiesLocalFile(fileLocation);
+        console.log('%s Parsed', chalk_1.default.yellow.bold('OPTION SET HIERARCHY PARSE'));
+    }
+    catch (e) {
+        console.log(`%s PARSE Failed. ${e}`, chalk_1.default.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s PARSE Complete.', chalk_1.default.green.bold('COMPLETE'));
+}
+exports.parseOptionSetsHierarchyLocalFile = parseOptionSetsHierarchyLocalFile;
+async function loadOptionSetHierarchyCSV(fileLocation) {
+    const TARGET_DIR = process.cwd();
+    try {
+        const fullPath = path.resolve(path.join(TARGET_DIR, fileLocation));
+        console.log('Getting file from path: ', fullPath);
+        return await csv().fromFile(fullPath);
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING CSV: ${e}`);
+    }
+}
+async function parseOptionSetHierarchiesLocalFile(fileLocation) {
+    const uploadedOptionHierarchyData = await loadOptionSetHierarchyCSV(fileLocation);
+    const optionSetHierarchy = {
+        hierarchy: [],
+        maxDepth: 0,
+        name: 'No Name',
+        options: []
+    };
+    if (!((uploadedOptionHierarchyData === null || uploadedOptionHierarchyData === void 0 ? void 0 : uploadedOptionHierarchyData.length) > 0)) {
+        return optionSetHierarchy;
+    }
+    const keysInOrder = Object.keys(uploadedOptionHierarchyData[0]);
+    const currentOptionSets = await new sdk_1.Entities().get({
+        entityName: 'type-property-option-set',
+    });
+    const currentOptionSetsByName = {};
+    for (const currentOptionSet of currentOptionSets) {
+        currentOptionSetsByName[util_1.StringUtil.convertToCamelCase(currentOptionSet.name)] = currentOptionSet;
+    }
+    const optionSetIds = [];
+    for (const key of keysInOrder) {
+        if (currentOptionSetsByName[key]) {
+            optionSetIds.push(currentOptionSetsByName[key].id);
+        }
+        else {
+            throw new Error(`No OptionSet found for ${key}`);
+        }
+    }
+    optionSetHierarchy.maxDepth = keysInOrder.length;
+    optionSetHierarchy.hierarchy = optionSetIds;
+    for (const row of uploadedOptionHierarchyData) {
+        addRowToOptions(optionSetHierarchy, keysInOrder, row);
+    }
+    return optionSetHierarchy;
+}
+async function parseAndSaveOptionSetHierarchiesLocalFile(fileLocation) {
+    const optionSetHierarchy = await parseOptionSetHierarchiesLocalFile(fileLocation);
+    saveData(optionSetHierarchy.options);
+}
+function addRowToOptions(optionSetHierarchy, keysInOrder, row) {
+    let options = optionSetHierarchy.options;
+    for (let i = 0; i < keysInOrder.length; i++) {
+        const optionValues = options.map(op => op.value);
+        const value = row[keysInOrder[i]];
+        if (!optionValues.includes(value)) {
+            const obj = i === (keysInOrder.length - 1) ? { value: value } : { value: value, options: [] };
+            options.push(obj);
+            options = obj.options;
+        }
+        else {
+            const optionObj = options.find(op => op.value === value);
+            options = optionObj.options;
+        }
+    }
+}
+function saveData(data) {
+    const CURRENT_DIR = process.cwd();
+    fs_1.default.writeFileSync(path.resolve(path.join(CURRENT_DIR, 'parsed_local_optionSetHierarchy.json')), JSON.stringify(data), 'utf8');
+}

package/dist/commands/types/parseOptionSetsLocalFiles.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class ParseOptionSetsLocalFiles extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        csvStyle: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        file: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}
+export declare function ParseOptionSetsToFolderStructure(args: any): Promise<void>;
+export declare function parseLabelsInColumn(uploadedOptionData: any): any[];