@adinsure-ops/ops-cli 4.0.0-rc6

package/lib/command.base.jira.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const JiraApi = require("jira-client");
+const command_base_1 = require("./command.base");
+class CommandBaseJira extends command_base_1.default {
+    async jiraInit(url, username, password) {
+        const jiraUrl = new URL(url);
+        const jira = new JiraApi({
+            protocol: jiraUrl.protocol,
+            host: jiraUrl.hostname,
+            username,
+            password,
+            apiVersion: '2',
+            strictSSL: true
+        });
+        return jira;
+    }
+}
+exports.default = CommandBaseJira;
+CommandBaseJira.flags = {
+    username: command_1.flags.string({
+        description: 'jira username',
+        env: 'JIRA_USERNAME',
+        required: true
+    }),
+    password: command_1.flags.string({
+        description: 'jira password',
+        env: 'JIRA_PASSWORD',
+        required: true
+    }),
+    hostname: command_1.flags.string({
+        description: 'jira hostname',
+        default: 'https://jira.adacta-fintech.com',
+        env: 'JIRA_HOSTNAME'
+    })
+};

package/lib/command.base.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const fs = require("fs-extra");
+const path = require("path");
+const context_1 = require("./security/context");
+class CommandBase extends command_1.Command {
+    constructor(argv, config) {
+        super(argv, config);
+        this.security = new context_1.default(this.config.configDir);
+    }
+    async getGitRoot(startDir) {
+        let currentPath = path.resolve(startDir || process.cwd());
+        // tslint:disable-next-line: no-constant-condition
+        while (true) {
+            // We've reached the root and didn't find .git
+            if (currentPath === path.parse(currentPath).root) {
+                throw new Error('Not a git repository (or any of the parent directories)');
+            }
+            if (await fs.pathExists(path.resolve(currentPath, '.git'))) {
+                // toLowerCase because of different behaviour when executing tests with yarn or with Test Explorer in VS Code
+                return currentPath.toLowerCase();
+            }
+            currentPath = path.dirname(currentPath);
+        }
+    }
+    async getVersion(versionFile = 'VERSION', ...filesToCheck) {
+        filesToCheck.unshift(versionFile);
+        const gitRoot = await this.getGitRoot();
+        for (const file of filesToCheck) {
+            const versionPath = path.resolve(gitRoot, file);
+            if (await fs.pathExists(versionPath)) {
+                return fs.readFileSync(versionPath, 'utf-8');
+            }
+        }
+        return this.error(`${filesToCheck} file was not found`, { exit: 2 });
+    }
+    /**
+     * Resolve path to Changelog folder from current execution directory
+     */
+    async getChangelogsRoot() {
+        let currentPath = path.resolve(process.cwd());
+        if (!await fs.pathExists(currentPath)) {
+            this.log(`Directory '${currentPath}' doesn't exist ... nothing to do here.`);
+            this.exit(0);
+        }
+        return path.resolve(currentPath, 'changelogs', 'unreleased');
+    }
+    /**
+     * Get all files inside directory and normalize it against {baseRelativePath}.
+     */
+    async getFilesRecursive(dir, baseRelativePath, filter) {
+        if (!await fs.pathExists(dir)) {
+            this.warn(`Directory '${dir}' doesn't exist ... nothing to do here.`);
+            return [];
+        }
+        let relativePath = path.relative(baseRelativePath, dir);
+        relativePath = relativePath === '' ? '.' : relativePath;
+        const entries = await fs.readdir(dir);
+        // Get files within the current directory and add a relative path to the file objects
+        const files = entries
+            .filter(file => !fs.statSync(path.resolve(dir, file)).isDirectory())
+            .filter(file => filter.test(path.resolve(dir, file)))
+            .map(file => `${relativePath}/${file}`);
+        // Get folders within the current directory
+        const folders = entries.filter(filetype => fs.statSync(path.resolve(dir, filetype)).isDirectory());
+        for (const folder of folders)
+            // Recursivly call this function and get relative paths of files inside directory
+            files.push(...await this.getFilesRecursive(path.join(dir, folder), baseRelativePath, filter));
+        return files;
+    }
+}
+exports.default = CommandBase;

package/lib/commands/doctor.d.ts

@@ -0,0 +1,54 @@
+import CommandBase from '../command.base';
+export default class Doctor extends CommandBase {
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static flags: {
+        fix: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+    };
+    private readonly cp;
+    private nvm;
+    private yarn;
+    private node;
+    private missing_packages;
+    /**
+     * Check if nvm is installed
+     */
+    gitCheck(fix: boolean): Promise<void>;
+    gitInstall(): Promise<void>;
+    gitLinuxInstall(): Promise<void>;
+    gitWindowsInstall(): Promise<void>;
+    /**
+     * Check if nvm is installed
+     */
+    nvmCheck(): Promise<void>;
+    /**
+     * Check which node is installed
+     */
+    nodeCheck(fix: boolean): Promise<void>;
+    /**
+     * Check which node is installed
+     */
+    nodeInstall(): Promise<void>;
+    /**
+     * Check which yarn is installed
+     */
+    yarnCheck(fix: boolean): Promise<void>;
+    /**
+     * Check which yarn is installed
+     */
+    yarnInstall(): Promise<void>;
+    /**
+     * Check which vsts-npm-auth is installed
+     */
+    vstsCheck(fix: boolean): Promise<void>;
+    /**
+     * Check which yarn is installed
+     */
+    vstsInstall(): Promise<void>;
+    /**
+     * Check which VSCode is installed
+     */
+    vscodeCheck(): Promise<void>;
+    run(): Promise<void>;
+}

package/lib/commands/doctor.js

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const chalk_1 = require("chalk");
+const cli_ux_1 = require("cli-ux");
+const fs = require("fs-extra");
+const command_base_1 = require("../command.base");
+const command_2 = require("../lib/command");
+class Doctor extends command_base_1.default {
+    constructor() {
+        super(...arguments);
+        this.cp = new command_2.default();
+        this.nvm = false;
+        this.yarn = false;
+        this.node = false;
+        this.missing_packages = 0;
+    }
+    /**
+     * Check if nvm is installed
+     */
+    async gitCheck(fix) {
+        cli_ux_1.default.action.start('Checking git', undefined, { stdout: true });
+        try {
+            let output = await this.cp.runCommand(['git', '--version']);
+            if (output.error) {
+                cli_ux_1.default.action.stop(`${chalk_1.default.red(output.error)}`);
+            }
+            else {
+                let version = output.data.split(' ')[2].split('\n')[0];
+                cli_ux_1.default.action.stop(`${chalk_1.default.green(version)}`);
+            }
+        }
+        catch (_a) {
+            cli_ux_1.default.action.stop(`${chalk_1.default.red('git is missing')}`);
+            if (fix) {
+                await this.gitInstall();
+            }
+            else {
+                this.missing_packages++;
+                this.warn(`Looks like git is missing.
+    Official documentation on how to install git can be found here: (https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)`);
+            }
+        }
+    }
+    async gitInstall() {
+        switch (process.platform) {
+            case 'linux':
+                await this.gitLinuxInstall();
+                break;
+            case 'win32':
+                break;
+            default:
+                this.warn('unsupported platform. skipping git install.');
+        }
+    }
+    async gitLinuxInstall() {
+        this.log(`Try to install git on ubuntu. Sudo is required`);
+        try {
+            await this.cp.runCommand(['sudo', 'apt', 'update']);
+            await this.cp.runCommand(['sudo', 'apt', 'install', 'git']);
+            await this.gitCheck(false);
+        }
+        catch (_a) {
+            cli_ux_1.default.action.stop(`${chalk_1.default.red('error installing git.')}`);
+        }
+    }
+    async gitWindowsInstall() {
+        // https://github.com/git-for-windows/git/releases/download/v2.33.1.windows.1/Git-2.33.1-64-bit.exe
+        // %USERPROFILE%\Downloads
+    }
+    /**
+     * Check if nvm is installed
+     */
+    async nvmCheck() {
+        cli_ux_1.default.action.start('Checking nvm', undefined, { stdout: true });
+        if (process.platform !== 'win32') {
+            if (process.env.NVM_DIR) {
+                try {
+                    let data = await fs.readJSON(`${process.env.NVM_DIR}/package.json`);
+                    cli_ux_1.default.action.stop(`${chalk_1.default.green(data.version)}`);
+                    this.nvm = true;
+                }
+                catch (_a) {
+                    cli_ux_1.default.action.stop(`${chalk_1.default.red('not installed')}`);
+                }
+            }
+            else {
+                cli_ux_1.default.action.stop(`${chalk_1.default.red('nvm is missing (install manually from https://github.com/nvm-sh/nvm#installing-and-updating')}`);
+            }
+            return;
+        }
+        try {
+            let output = await this.cp.runCommand(['nvm', 'version']);
+            if (output.error) {
+                cli_ux_1.default.action.stop(`${chalk_1.default.red(output.error)}`);
+            }
+            else {
+                let version = output.data.split('\n')[0];
+                this.nvm = true;
+                cli_ux_1.default.action.stop(`${chalk_1.default.green(version)}`);
+            }
+        }
+        catch (_b) {
+            cli_ux_1.default.action.stop(`${chalk_1.default.red('nvm is missing (install manually from https://github.com/coreybutler/nvm-windows/releases)')}`);
+        }
+    }
+    /**
+     * Check which node is installed
+     */
+    async nodeCheck(fix) {
+        cli_ux_1.default.action.start('Checking node', undefined, { stdout: true });
+        try {
+            let output = await this.cp.runCommand(['node', '--version']);
+            if (output.error) {
+                cli_ux_1.default.action.stop(`${chalk_1.default.red(output.error)}`);
+            }
+            else {
+                let version = output.data.split('\n')[0];
+                if (version) {
+                    cli_ux_1.default.action.stop(`${chalk_1.default.green(version)}`);
+                    this.node = true;
+                    // only check yarn and vsts if node is installed
+                    await this.yarnCheck(fix);
+                    await this.vstsCheck(fix);
+                }
+                else {
+                    cli_ux_1.default.action.stop(`${chalk_1.default.red('failed getting version')}`);
+                }
+            }
+        }
+        catch (_a) {
+            cli_ux_1.default.action.stop(`${chalk_1.default.red('node is missing')}`);
+            if (fix && this.nvm) {
+                await this.nodeInstall();
+            }
+            else {
+                this.missing_packages++;
+            }
+        }
+    }
+    /**
+     * Check which node is installed
+     */
+    async nodeInstall() {
+        cli_ux_1.default.action.start('installing node 15.6.0', undefined, { stdout: true });
+        if (!this.nvm) {
+            return cli_ux_1.default.action.stop(`${chalk_1.default.red('only works with nvm isntalled')}`);
+        }
+        try {
+            let output = await this.cp.runCommand(['nvm', 'install', '15.6.0']);
+            if (output.error) {
+                cli_ux_1.default.action.stop(`${chalk_1.default.red(output.error)}`);
+            }
+            else {
+                let nvmUserOutput = await this.cp.runCommand(['nvm', 'use', '15.6.0']);
+                if (nvmUserOutput.error) {
+                    cli_ux_1.default.action.stop(`${chalk_1.default.red(output.error)}`);
+                }
+                cli_ux_1.default.action.stop(`${chalk_1.default.green('Done')}`);
+            }
+        }
+        catch (_a) {
+            cli_ux_1.default.action.stop(`${chalk_1.default.red('failed')}`);
+        }
+    }
+    /**
+     * Check which yarn is installed
+     */
+    async yarnCheck(fix) {
+        cli_ux_1.default.action.start('Checking yarn', undefined, { stdout: true });
+        try {
+            let output = await this.cp.runCommand(['yarn', '--version']);
+            if (output.error) {
+                cli_ux_1.default.action.stop(`${chalk_1.default.red(output.error)}`);
+            }
+            else {
+                let version = output.data.split('\n')[0];
+                if (version) {
+                    this.yarn = true;
+                    cli_ux_1.default.action.stop(`${chalk_1.default.green(version)}`);
+                }
+                else {
+                    cli_ux_1.default.action.stop(`${chalk_1.default.red('yarn is missing')}`);
+                }
+            }
+        }
+        catch (_a) {
+            this.missing_packages++;
+            cli_ux_1.default.action.stop(`${chalk_1.default.red('yarn is missing')}`);
+            if (fix) {
+                await this.yarnInstall();
+            }
+        }
+    }
+    /**
+     * Check which yarn is installed
+     */
+    async yarnInstall() {
+        cli_ux_1.default.action.start('Install yarn', undefined, { stdout: true });
+        try {
+            let output = await this.cp.runCommand(['npm', '-g', 'install', 'yarn']);
+            if (output.error) {
+                cli_ux_1.default.action.stop(`${chalk_1.default.red(output.error)}`);
+            }
+            else {
+                this.yarn = true;
+                cli_ux_1.default.action.stop(`${chalk_1.default.green('yarn installed')}`);
+            }
+        }
+        catch (_a) {
+            this.missing_packages++;
+            cli_ux_1.default.action.stop(`${chalk_1.default.red('yarn failed to install')}`);
+        }
+    }
+    /**
+     * Check which vsts-npm-auth is installed
+     */
+    async vstsCheck(fix) {
+        cli_ux_1.default.action.start('Checking vsts-npm-auth', undefined, { stdout: true });
+        if (process.platform !== 'win32') {
+            cli_ux_1.default.action.stop(`${chalk_1.default.blue('not Windows, skipping')}`);
+            return;
+        }
+        try {
+            let output = await this.cp.runCommand(['yarn', 'global', 'list']);
+            if (output.error) {
+                cli_ux_1.default.action.stop(`${chalk_1.default.red(output.error)}`);
+            }
+            else {
+                let version = output.data.match(/\"vsts-npm-auth\@(.*)\"/);
+                if (version && version.length > 1) {
+                    cli_ux_1.default.action.stop(`${chalk_1.default.green(version[1])}`);
+                }
+                else {
+                    cli_ux_1.default.action.stop(`${chalk_1.default.red('vsts-npm-auth is missing')}`);
+                    if (fix && this.yarn) {
+                        await this.vstsInstall();
+                    }
+                    else {
+                        this.missing_packages++;
+                    }
+                }
+            }
+        }
+        catch (err) {
+            cli_ux_1.default.action.stop(`${chalk_1.default.red(err.message)}`);
+        }
+    }
+    /**
+     * Check which yarn is installed
+     */
+    async vstsInstall() {
+        cli_ux_1.default.action.start('Install vsts-npm-auth', undefined, { stdout: true });
+        try {
+            let output = await this.cp.runCommand(['yarn', 'global', 'add', 'vsts-npm-auth']);
+            if (output.error) {
+                cli_ux_1.default.action.stop(`${chalk_1.default.red(output.error)}`);
+            }
+            else {
+                cli_ux_1.default.action.stop(`${chalk_1.default.green('vsts-npm-auth installed')}`);
+            }
+        }
+        catch (_a) {
+            this.missing_packages++;
+            cli_ux_1.default.action.stop(`${chalk_1.default.red('vsts-npm-auth failed to install')}`);
+        }
+    }
+    /**
+     * Check which VSCode is installed
+     */
+    async vscodeCheck() {
+        cli_ux_1.default.action.start('Checking vscode', undefined, { stdout: true });
+        try {
+            let output = await this.cp.runCommand(['code', '--version']);
+            if (output.error) {
+                cli_ux_1.default.action.stop(`${chalk_1.default.red(output.error)}`);
+            }
+            else {
+                let version = output.data.split('\n')[0];
+                cli_ux_1.default.action.stop(`${chalk_1.default.green(version)}`);
+            }
+        }
+        catch (_a) {
+            this.missing_packages++;
+            cli_ux_1.default.action.stop(`${chalk_1.default.red('VSCode not installed')}`);
+        }
+    }
+    async run() {
+        const { flags } = this.parse(Doctor);
+        await this.gitCheck(flags.fix);
+        await this.nvmCheck();
+        await this.nodeCheck(flags.fix);
+        await this.vscodeCheck();
+        if (this.missing_packages > 0) {
+            this.warn(`${chalk_1.default.yellow('Some packages are missing. try --fix to automaticaly install.')}`);
+        }
+    }
+}
+exports.default = Doctor;
+Doctor.description = 'check if everyting is installed';
+Doctor.usage = 'doctor';
+Doctor.examples = [
+    `$ ops doctor`
+];
+Doctor.flags = {
+    fix: command_1.flags.boolean({
+        char: 'p',
+        description: 'try to install missing packages',
+        default: false
+    })
+};

package/lib/commands/download/client.d.ts

@@ -0,0 +1,18 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../../command.base';
+export default class DownloadClient extends CommandBase {
+    static aliases: string[];
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static flags: {
+        version: flags.IOptionFlag<string>;
+        output: flags.IOptionFlag<string>;
+    };
+    private readonly url;
+    /**
+     * Get unique scriptID by specified version
+     */
+    downloadFile(version: string): Promise<string>;
+    run(): Promise<void>;
+}

package/lib/commands/download/client.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const chalk_1 = require("chalk");
+const cli_ux_1 = require("cli-ux");
+const fs = require("fs-extra");
+const path = require("path");
+const request = require("request-promise");
+const command_base_1 = require("../../command.base");
+class DownloadClient extends command_base_1.default {
+    constructor() {
+        super(...arguments);
+        this.url = 'https://ops.adinsure.com/api/storage/binaries/';
+    }
+    /**
+     * Get unique scriptID by specified version
+     */
+    async downloadFile(version) {
+        let options = {
+            uri: `${this.url}/AdInsure-client-${version}.zip`,
+            encoding: 'binary',
+            headers: {
+                Authorization: 'Bearer ' + await this.security.getToken()
+            }
+        };
+        return request.get(options);
+    }
+    async run() {
+        const { flags } = this.parse(DownloadClient);
+        let basePath = flags.output;
+        const filename = `AdInsure-client-${flags.version}.zip`;
+        let filePath = path.resolve(basePath, filename);
+        cli_ux_1.default.action.start(`Downloading AdInsure Client version ${flags.version} to ${filePath}`, undefined, { stdout: true });
+        try {
+            let file = await this.downloadFile(flags.version);
+            let writeStream = fs.createWriteStream(filePath);
+            writeStream.write(file, 'binary');
+            writeStream.on('finish', () => {
+                cli_ux_1.default.action.stop(`${chalk_1.default.green('OK')}`);
+            });
+            writeStream.end();
+        }
+        catch (err) {
+            if (err.statusCode === 404) {
+                // cli.action.stop(`${chalk.red('Does not exists.')}`);
+                this.error('Does not exists.', { exit: 1 });
+            }
+            else {
+                this.error(err.message);
+            }
+        }
+    }
+}
+exports.default = DownloadClient;
+DownloadClient.aliases = ['download:client'];
+DownloadClient.description = 'download AdInsure Client from Azure storage';
+DownloadClient.usage = 'download:client <flags>';
+DownloadClient.examples = [
+    `$ ops download:client -v 3.2.0 -o ~/Downloads`
+];
+DownloadClient.flags = {
+    version: command_1.flags.string({
+        char: 'v',
+        description: 'version we want to download',
+        required: true
+    }),
+    output: command_1.flags.string({
+        char: 'o',
+        description: 'output directory',
+        default: './'
+    }),
+};

package/lib/commands/download/identity-server.d.ts

@@ -0,0 +1,18 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../../command.base';
+export default class DownloadIdentityServer extends CommandBase {
+    static aliases: string[];
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static flags: {
+        version: flags.IOptionFlag<string>;
+        output: flags.IOptionFlag<string>;
+    };
+    private readonly url;
+    /**
+     * Get unique scriptID by specified version
+     */
+    downloadFile(version: string): Promise<string>;
+    run(): Promise<void>;
+}

package/lib/commands/download/identity-server.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const chalk_1 = require("chalk");
+const cli_ux_1 = require("cli-ux");
+const fs = require("fs-extra");
+const path = require("path");
+const request = require("request-promise");
+const command_base_1 = require("../../command.base");
+class DownloadIdentityServer extends command_base_1.default {
+    constructor() {
+        super(...arguments);
+        this.url = 'https://ops.adinsure.com/api/storage/binaries/';
+    }
+    /**
+     * Get unique scriptID by specified version
+     */
+    async downloadFile(version) {
+        let options = {
+            uri: `${this.url}/AdInsure-identityServer-${version}.zip`,
+            encoding: 'binary',
+            headers: {
+                Authorization: 'Bearer ' + await this.security.getToken()
+            }
+        };
+        return request.get(options);
+    }
+    async run() {
+        const { flags } = this.parse(DownloadIdentityServer);
+        let basePath = flags.output;
+        const filename = `AdInsure-identityServer-${flags.version}.zip`;
+        let filePath = path.resolve(basePath, filename);
+        cli_ux_1.default.action.start(`Downloading AdInsure Identity Server version ${flags.version} to ${filePath}`, undefined, { stdout: true });
+        try {
+            let file = await this.downloadFile(flags.version);
+            let writeStream = fs.createWriteStream(filePath);
+            writeStream.write(file, 'binary');
+            writeStream.on('finish', () => {
+                cli_ux_1.default.action.stop(`${chalk_1.default.green('OK')}`);
+            });
+            writeStream.end();
+        }
+        catch (err) {
+            if (err.statusCode === 404) {
+                // cli.action.stop(`${chalk.red('Does not exists.')}`);
+                this.error('Does not exists.', { exit: 1 });
+            }
+            else {
+                this.error(err.message);
+            }
+        }
+    }
+}
+exports.default = DownloadIdentityServer;
+DownloadIdentityServer.aliases = ['download:identity-server'];
+DownloadIdentityServer.description = 'download AdInsure Identity Server from Azure storage';
+DownloadIdentityServer.usage = 'download:identity-server <flags>';
+DownloadIdentityServer.examples = [
+    `$ ops download:identity-server -v 3.0.3 -o ~/Downloads`
+];
+DownloadIdentityServer.flags = {
+    version: command_1.flags.string({
+        char: 'v',
+        description: 'version we want to download',
+        required: true
+    }),
+    output: command_1.flags.string({
+        char: 'o',
+        description: 'output directory',
+        default: './'
+    }),
+};

package/lib/commands/download/platform.d.ts

@@ -0,0 +1,18 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../../command.base';
+export default class DownloadPlatform extends CommandBase {
+    static aliases: string[];
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static flags: {
+        version: flags.IOptionFlag<string>;
+        output: flags.IOptionFlag<string>;
+    };
+    private readonly url;
+    /**
+     * Get unique scriptID by specified version
+     */
+    downloadFile(version: string): Promise<string>;
+    run(): Promise<void>;
+}