@adinsure-ops/ops-cli 4.0.0-rc6

package/lib/commands/download/platform.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 DownloadPlatform 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-${version}.zip`,
+            encoding: 'binary',
+            headers: {
+                Authorization: 'Bearer ' + await this.security.getToken()
+            }
+        };
+        return request.get(options);
+    }
+    async run() {
+        const { flags } = this.parse(DownloadPlatform);
+        let basePath = flags.output;
+        const filename = `AdInsure-${flags.version}.zip`;
+        let filePath = path.resolve(basePath, filename);
+        cli_ux_1.default.action.start(`Downloading AdInsure Platform 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 = DownloadPlatform;
+DownloadPlatform.aliases = ['download', 'download:platform'];
+DownloadPlatform.description = 'download platform from azure storage';
+DownloadPlatform.usage = 'download <flags>';
+DownloadPlatform.examples = [
+    `$ ops download -v 6.0.0 -o ~/Downloads`
+];
+DownloadPlatform.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/scheduler.d.ts

@@ -0,0 +1,18 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../../command.base';
+export default class DownloadScheduler 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/scheduler.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 DownloadScheduler 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}/AdInsureScheduler-${version}.zip`,
+            encoding: 'binary',
+            headers: {
+                Authorization: 'Bearer ' + await this.security.getToken()
+            }
+        };
+        return request.get(options);
+    }
+    async run() {
+        const { flags } = this.parse(DownloadScheduler);
+        let basePath = flags.output;
+        const filename = `AdInsureScheduler-${flags.version}.zip`;
+        let filePath = path.resolve(basePath, filename);
+        cli_ux_1.default.action.start(`Downloading AdInsure Scheduler 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 = DownloadScheduler;
+DownloadScheduler.aliases = ['download:scheduler'];
+DownloadScheduler.description = 'download scheduler from azure storage';
+DownloadScheduler.usage = 'download:scheduler <flags>';
+DownloadScheduler.examples = [
+    `$ ops download:scheduler -v 3.2.0 -o ~/Downloads`
+];
+DownloadScheduler.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/server.d.ts

@@ -0,0 +1,18 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../../command.base';
+export default class DownloadServer 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/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 DownloadServer 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-server-${version}.zip`,
+            encoding: 'binary',
+            headers: {
+                Authorization: 'Bearer ' + await this.security.getToken()
+            }
+        };
+        return request.get(options);
+    }
+    async run() {
+        const { flags } = this.parse(DownloadServer);
+        let basePath = flags.output;
+        const filename = `AdInsure-server-${flags.version}.zip`;
+        let filePath = path.resolve(basePath, filename);
+        cli_ux_1.default.action.start(`Downloading AdInsure 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 = DownloadServer;
+DownloadServer.aliases = ['download:server'];
+DownloadServer.description = 'download AdInsure Server from Azure storage';
+DownloadServer.usage = 'download:server <flags>';
+DownloadServer.examples = [
+    `$ ops download:server -v 3.2.0 -o ~/Downloads`
+];
+DownloadServer.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/studio.d.ts

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

package/lib/commands/download/studio.js

@@ -0,0 +1,89 @@
+"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");
+const command_2 = require("../../lib/command");
+class DownloadStudio extends command_base_1.default {
+    constructor() {
+        super(...arguments);
+        this.url = 'https://ops.adinsure.com/api/storage/extensions/';
+    }
+    /**
+     * Get unique scriptID by specified version
+     */
+    async downloadFile(version) {
+        let options = {
+            uri: `${this.url}/adinsure-studio-${version}.vsix`,
+            encoding: 'binary',
+            headers: {
+                Authorization: 'Bearer ' + await this.security.getToken()
+            }
+        };
+        return request.get(options);
+    }
+    async installExtension(extensionPath) {
+        let cp = new command_2.default();
+        await cp.runCommand(['code', '--install-extension', extensionPath, '--force']);
+    }
+    async run() {
+        const { flags } = this.parse(DownloadStudio);
+        let basePath = flags.output;
+        const filename = `adinsure-studio-${flags.version}.vsix`;
+        let filePath = path.resolve(basePath, filename);
+        cli_ux_1.default.action.start(`Downloading AdInsure Studio 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', async () => {
+                cli_ux_1.default.action.stop(`${chalk_1.default.green('OK')}`);
+                if (flags.install) {
+                    cli_ux_1.default.action.start(`Installing into VSCode`, undefined, { stdout: true });
+                    await this.installExtension(filePath);
+                    cli_ux_1.default.action.stop(`${chalk_1.default.green('Done')}`);
+                    this.log(`${chalk_1.default.yellow('Use \'CRTL + SHIFT + P\' and select reload windows to apply this studio version.')}`);
+                }
+            });
+            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 = DownloadStudio;
+DownloadStudio.aliases = ['download:studio'];
+DownloadStudio.description = 'download studio vsix from azure storage';
+DownloadStudio.usage = 'download:studio <flags>';
+DownloadStudio.examples = [
+    `$ ops download:studio -v 15.0.0 -o ~/Downloads`,
+    `$ ops download:studio -v 15.0.0 -i`
+];
+DownloadStudio.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: './'
+    }),
+    install: command_1.flags.boolean({
+        char: 'i',
+        description: 'install plugin to vscode. save to temp folder and remove vsix after.',
+        default: false
+    }),
+};

package/lib/commands/gitlab/next-nightly-tag.d.ts

@@ -0,0 +1,30 @@
+import { flags } from '@oclif/command';
+import * as semver from 'semver';
+import CommandBase from '../../command.base';
+export default class GitlabNextNightlyTag extends CommandBase {
+    static aliases: string[];
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static args: {
+        name: string;
+        description: string;
+    }[];
+    static flags: {
+        pat: flags.IOptionFlag<string>;
+        host: flags.IOptionFlag<string>;
+        project: flags.IOptionFlag<string>;
+        reference: flags.IOptionFlag<string>;
+        dryRun: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+    };
+    private readonly apiBase;
+    /**
+     * Try to figure out latest available version already created
+     */
+    createNewTag(url: string, pat: string, tag_name: string, ref: string): Promise<void>;
+    /**
+     * Try to figure out latest available version already created
+     */
+    getLatestVersion(url: string, pat: string, searchVersion: string, prefix?: string): Promise<semver.SemVer>;
+    run(): Promise<undefined>;
+}

package/lib/commands/gitlab/next-nightly-tag.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const axios_1 = require("axios");
+const chalk_1 = require("chalk");
+const cli_ux_1 = require("cli-ux");
+const semver = require("semver");
+const command_base_1 = require("../../command.base");
+class GitlabNextNightlyTag extends command_base_1.default {
+    constructor() {
+        super(...arguments);
+        this.apiBase = '/api/v4/projects';
+    }
+    /**
+     * Try to figure out latest available version already created
+     */
+    async createNewTag(url, pat, tag_name, ref) {
+        try {
+            await axios_1.default.post(`${url}`, {
+                tag_name,
+                ref
+            }, {
+                headers: {
+                    Authorization: `Bearer ${pat}`,
+                }
+            });
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+        return;
+    }
+    /**
+     * Try to figure out latest available version already created
+     */
+    async getLatestVersion(url, pat, searchVersion, prefix = '') {
+        let versions = [];
+        try {
+            let page = 1;
+            let totalPages = 1;
+            do {
+                let response = await axios_1.default.get(`${url}`, {
+                    headers: {
+                        Authorization: `Bearer ${pat}`,
+                    },
+                    params: {
+                        search: `^${prefix}v${searchVersion}`,
+                        per_page: 100,
+                        page
+                    }
+                });
+                response.data.forEach((tag) => {
+                    const regex = new RegExp(`${prefix}(.*)`);
+                    let searchTag = tag;
+                    let match = tag.name.match(regex);
+                    if (match[1]) {
+                        searchTag = match[1];
+                    }
+                    let semanticVersion = semver.parse(searchTag, { includePrerelease: true });
+                    if (semanticVersion && semanticVersion.prerelease.length === 0) {
+                        versions.push(semanticVersion);
+                        // ignore versions that that doesn't have number for prerelease identifier (skip qa and test prereleases)
+                    }
+                    else if (semanticVersion && semanticVersion.prerelease.length === 2 && /^[0-9]+$/.test(semanticVersion.prerelease[1].toString())) {
+                        versions.push(semanticVersion);
+                    }
+                });
+                totalPages = parseInt(response.headers['x-total-pages'], 10);
+                page++;
+            } while (page <= totalPages);
+        }
+        catch (err) {
+            this.error(err.message);
+        }
+        return semver.rsort(versions)[0];
+    }
+    async run() {
+        const { args, flags } = this.parse(GitlabNextNightlyTag);
+        const re = /^release\/(\w+\-)?((\d+)(\.\d+)?)$/;
+        let prefix = '';
+        let inputVersion = args.version;
+        const match = args.version.match(re);
+        if (match) {
+            if (match[1] !== 'adinsure-') {
+                prefix = match[1];
+            }
+            inputVersion = match[2];
+        }
+        const urlPath = `${this.apiBase}/${flags.project}/repository/tags`;
+        let version = semver.parse(inputVersion);
+        let nextVersion = null;
+        // if version is not parsable try to find something that starts with this version
+        if (!version) {
+            version = await this.getLatestVersion(`${flags.host}${urlPath}`, flags.pat, inputVersion, prefix);
+        }
+        // still version does not exists we will try to parse it with additional 0 as patch version
+        if (!version) {
+            version = semver.parse(`${inputVersion}.0`);
+        }
+        // last option trying to add 0 for minor and patch version
+        if (!version) {
+            version = semver.parse(`${inputVersion}.0.0`);
+        }
+        // fail because we were not able to parse this version
+        if (!version) {
+            return this.error(`${chalk_1.default.red('Version in incorrect format')}`);
+        }
+        cli_ux_1.default.action.start('Calculating next prerelease test version', undefined, { stdout: true });
+        const date = new Date();
+        const prereleaseDate = `${date.getFullYear()}${('0' + (date.getMonth() + 1)).slice(-2)}`;
+        let lastVersion = await this.getLatestVersion(`${flags.host}${urlPath}`, flags.pat, version.version, prefix);
+        if (lastVersion) {
+            nextVersion = `v${semver.inc(lastVersion, 'prerelease', prereleaseDate)}`;
+        }
+        else {
+            nextVersion = `v${semver.inc(`${version.version}-${prereleaseDate}.0`, 'prerelease', prereleaseDate)}`;
+        }
+        if (prefix) {
+            nextVersion = `${prefix}${nextVersion}`;
+        }
+        cli_ux_1.default.action.stop(`${chalk_1.default.green(nextVersion)}`);
+        if (!flags.dryRun) {
+            await this.createNewTag(`${flags.host}${urlPath}`, flags.pat, nextVersion, flags.reference);
+        }
+        else {
+            this.warn(`This is only dry run. no new tag will was created!`);
+        }
+    }
+}
+exports.default = GitlabNextNightlyTag;
+GitlabNextNightlyTag.aliases = ['gitlab:next-nightly-tag'];
+GitlabNextNightlyTag.description = 'creates new gitlab tag';
+GitlabNextNightlyTag.usage = 'gitlab:next-nightly-tag <version> -n';
+GitlabNextNightlyTag.examples = [
+    `$ ops gitlab:tag 17.0.0`,
+    `$ ops gitlab:tag 17.0.0 -n`
+];
+GitlabNextNightlyTag.args = [
+    {
+        name: 'version',
+        description: 'Tag version'
+    }
+];
+GitlabNextNightlyTag.flags = {
+    pat: command_1.flags.string({
+        required: true,
+        env: 'PRIVATE_TOKEN',
+        description: 'Token from user that has permissions to list and create tags'
+    }),
+    host: command_1.flags.string({
+        required: true,
+        default: 'https://git.adacta-fintech.com',
+        env: 'CI_SERVER_URL',
+        description: 'Server hostname'
+    }),
+    project: command_1.flags.string({
+        required: true,
+        default: '413',
+        env: 'CI_PROJECT_ID',
+        description: 'Project ID'
+    }),
+    reference: command_1.flags.string({
+        required: true,
+        env: 'CI_COMMIT_REF_NAME',
+        description: 'Reference to create tag on (branch, commit, tag)'
+    }),
+    dryRun: command_1.flags.boolean({
+        description: `Only printout version and don't create it`,
+        default: false
+    })
+};

package/lib/commands/jira/issue.d.ts

@@ -0,0 +1,17 @@
+import CommandBaseJira from '../../command.base.jira';
+export default class JiraLabels extends CommandBaseJira {
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    static flags: {
+        username: import("@oclif/command/lib/flags").IOptionFlag<string>;
+        password: import("@oclif/command/lib/flags").IOptionFlag<string>;
+        hostname: import("@oclif/command/lib/flags").IOptionFlag<string>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/jira/issue.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_base_jira_1 = require("../../command.base.jira");
+class JiraLabels extends command_base_jira_1.default {
+    async run() {
+        const { args, flags } = this.parse(JiraLabels);
+        const jira = await this.jiraInit(flags.hostname, flags.username, flags.password);
+        try {
+            let issue = await jira.findIssue(args.issue);
+            this.log(JSON.stringify(issue));
+        }
+        catch (err) {
+            this.error(err);
+            this.exit(1);
+        }
+    }
+}
+exports.default = JiraLabels;
+JiraLabels.description = 'get Jira issue';
+JiraLabels.usage = 'jira:issue <issue>';
+JiraLabels.examples = [
+    `$ ops jira:issue LJADIRD-1337`,
+];
+JiraLabels.args = [
+    {
+        name: 'issue',
+        description: 'Jira issue number',
+        required: true
+    }
+];
+JiraLabels.flags = Object.assign({}, command_base_jira_1.default.flags);

package/lib/commands/jira/labels.d.ts

@@ -0,0 +1,22 @@
+import { flags } from '@oclif/command';
+import JiraApi = require('jira-client');
+import CommandBaseJira from '../../command.base.jira';
+export default class JiraLabels extends CommandBaseJira {
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    static flags: {
+        add: flags.IOptionFlag<string[]>;
+        remove: flags.IOptionFlag<string[]>;
+        username: flags.IOptionFlag<string>;
+        password: flags.IOptionFlag<string>;
+        hostname: flags.IOptionFlag<string>;
+    };
+    setLabels(jira: JiraApi, issue: string, add?: string[], remove?: string[]): Promise<JiraApi.JsonResponse>;
+    run(): Promise<void>;
+}