EnonceCreateCommand.ts

import CommanderCommand   from '../CommanderCommand';
import chalk              from 'chalk';
import ora                from 'ora';
import GitlabManager      from '../../managers/GitlabManager';
import SessionManager     from '../../managers/SessionManager';
import GitlabUser         from '../../shared/types/Gitlab/GitlabUser';
import DojoBackendManager from '../../managers/DojoBackendManager';
import Toolbox            from '../../shared/Toolbox';
import Enonce             from '../../types/Enonce';


class EnonceCreateCommand extends CommanderCommand {
    protected commandName: string = 'create';

    private static _instance: EnonceCreateCommand;

    private constructor() { super(); }

    public static get instance(): EnonceCreateCommand {
        if ( !EnonceCreateCommand._instance ) {
            EnonceCreateCommand._instance = new EnonceCreateCommand();
        }

        return EnonceCreateCommand._instance;
    }

    protected defineCommand() {
        this.command
        .description('Create a new repository for an enonce.')
        .requiredOption('-n, --name <name>', 'name of the enonce.')
        .option('-i, --members_id <ids...>', 'list of members ids (teaching staff) to add to the repository.')
        .option('-m, --members_username <usernames...>', 'list of members username (teaching staff) to add to the repository.')
        .option('-t, --template <string>', 'id or url of the template (http(s) and ssh urls are possible).')
        .action(this.commandAction.bind(this));
    }

    private async checkAccesses(): Promise<boolean> {
        let sessionResult = await SessionManager.testSession(true, [ 'teachingStaff' ]);

        if ( !sessionResult || !sessionResult.teachingStaff ) {
            return false;
        }

        return (await GitlabManager.testToken(true)).every(result => result);
    }

    private async fetchMembers(options: any): Promise<Array<GitlabUser> | false> {
        ora('Checking Gitlab members:').start().info();

        let members: Array<GitlabUser> = [];

        async function getMembers<T>(context: any, functionName: string, paramsToSearch: Array<T>): Promise<boolean> {
            const result = await (context[functionName] as (arg: Array<T>, verbose: boolean, verboseIndent: number) => Promise<Array<GitlabUser | undefined>>)(paramsToSearch, true, 8);

            if ( result.every(user => user) ) {
                members = members.concat(result as Array<GitlabUser>);
                return true;
            } else {
                return false;
            }
        }

        let result = true;

        if ( options.members_id ) {
            ora({
                    text  : 'Fetching members by id:',
                    indent: 4
                }).start().info();

            result = await getMembers(GitlabManager, 'getUsersById', options.members_id);
        }

        if ( options.members_username ) {
            ora({
                    text  : 'Fetching members by username:',
                    indent: 4
                }).start().info();

            result = result && await getMembers(GitlabManager, 'getUsersByUsername', options.members_username);
        }

        if ( !result ) {
            return false;
        }

        members = members.reduce((unique, user) => (unique.findIndex(uniqueUser => uniqueUser.id === user.id) !== -1 ? unique : [ ...unique, user ]), Array<GitlabUser>());

        return members;
    }

    protected async commandAction(options: any): Promise<void> {
        let members!: Array<GitlabUser> | false;
        let templateIdOrNamespace: string | null = null;

        // Check access and retrieve data
        {
            console.log(chalk.cyan('Please wait while we verify and retrieve data...'));

            if ( !await this.checkAccesses() ) {
                return;
            }

            members = await this.fetchMembers(options);
            if ( !members ) {
                return;
            }

            if ( options.template ) {
                templateIdOrNamespace = options.template;

                if ( Number.isNaN(Number(templateIdOrNamespace)) ) {
                    templateIdOrNamespace = Toolbox.urlToPath(templateIdOrNamespace as string);
                }

                if ( !await DojoBackendManager.checkTemplateAccess(encodeURIComponent(templateIdOrNamespace as string)) ) {
                    return;
                }
            }
        }

        // Create the enonce
        {
            console.log(chalk.cyan('Please wait while we are creating the enonce...'));

            try {
                const enonce: Enonce = await DojoBackendManager.createProject(options.name, members, templateIdOrNamespace);

                const oraInfo = (message: string) => {
                    ora({
                            text  : message,
                            indent: 4
                        }).start().info();
                };

                oraInfo(`Dojo ID: ${ enonce.id }`);
                oraInfo(`Name: ${ enonce.name }`);
                oraInfo(`Web URL: ${ enonce.gitlabCreationInfo.web_url }`);
                oraInfo(`HTTP Repo: ${ enonce.gitlabCreationInfo.http_url_to_repo }`);
                oraInfo(`SSH Repo: ${ enonce.gitlabCreationInfo.ssh_url_to_repo }`);
            } catch ( error ) {
                return;
            }
        }
    }
}


export default EnonceCreateCommand.instance;