ExerciseCreateCommand.ts

import CommanderCommand   from '../../CommanderCommand';
import chalk              from 'chalk';
import GitlabManager      from '../../../managers/GitlabManager';
import GitlabUser         from '../../../shared/types/Gitlab/GitlabUser';
import ora                from 'ora';
import DojoBackendManager from '../../../managers/DojoBackendManager';
import AccessesHelper     from '../../../helpers/AccessesHelper';
import Assignment         from '../../../sharedByClients/models/Assignment';
import Exercise           from '../../../sharedByClients/models/Exercise';


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

    protected defineCommand() {
        this.command
        .description('create a new exercise from an assignment')
        .requiredOption('-a, --assignment <value>', 'assignment source (Dojo assignment ID, Dojo assignment name or Gitlab assignment URL)')
        .option('-i, --members_id <ids...>', 'list of gitlab members ids (group\'s student) to add to the repository')
        .option('-u, --members_username <usernames...>', 'list of gitlab members username (group\'s student) to add to the repository')
        .option('-c, --clone [string]', 'automatically clone the repository (SSH required) in the specified directory (this will create a subdirectory with the assignment name)')
        .action(this.commandAction.bind(this));
    }

    protected async commandAction(options: { assignment: string, members_id?: Array<number>, members_username?: Array<string>, clone?: string | boolean }): Promise<void> {
        let members!: Array<GitlabUser> | false;
        let assignment!: Assignment | undefined;
        let exercise!: Exercise;

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

            if ( !await AccessesHelper.checkStudent() ) {
                return;
            }

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

            ora('Checking assignment:').start().info();
            const assignmentGetSpinner: ora.Ora = ora({
                                                          text  : 'Checking if assignment exists',
                                                          indent: 4
                                                      }).start();
            assignment = await DojoBackendManager.getAssignment(options.assignment);
            if ( !assignment ) {
                assignmentGetSpinner.fail(`Assignment "${ options.assignment }" doesn't exists`);
                return;
            }
            assignmentGetSpinner.succeed(`Assignment "${ options.assignment }" exists`);

            const assignmentPublishedSpinner: ora.Ora = ora({
                                                                text  : 'Checking if assignment is published',
                                                                indent: 4
                                                            }).start();
            if ( !assignment.published ) {
                assignmentPublishedSpinner.fail(`Assignment "${ assignment.name }" isn't published`);
                return;
            }
            assignmentPublishedSpinner.succeed(`Assignment "${ assignment.name }" is published`);
        }

        //Create the exercise
        {
            console.log(chalk.cyan('Please wait while we are creating the exercise (approximately 10 seconds)...'));

            try {
                exercise = await DojoBackendManager.createExercise((assignment as Assignment).name, members);

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

                oraInfo(`${ chalk.magenta('Id:') } ${ exercise.id }`);
                oraInfo(`${ chalk.magenta('Name:') } ${ exercise.name }`);
                oraInfo(`${ chalk.magenta('Web URL:') } ${ exercise.gitlabCreationInfo.web_url }`);
                oraInfo(`${ chalk.magenta('HTTP Repo:') } ${ exercise.gitlabCreationInfo.http_url_to_repo }`);
                oraInfo(`${ chalk.magenta('SSH Repo:') } ${ exercise.gitlabCreationInfo.ssh_url_to_repo }`);
            } catch ( error ) {
                return;
            }
        }

        // Clone the repository
        {
            if ( options.clone ) {
                console.log(chalk.cyan('Please wait while we are cloning the repository...'));

                await GitlabManager.cloneRepository(options.clone, assignment.gitlabCreationInfo.ssh_url_to_repo, `DojoExercise - ${ exercise.assignmentName }`, true, 0);
            }
        }
    }
}


export default new ExerciseCreateCommand();