EnonceRoutes.ts

import { Express }               from 'express-serve-static-core';
import express                   from 'express';
import * as ExpressValidator     from 'express-validator';
import { StatusCodes }           from 'http-status-codes';
import RoutesManager             from '../express/RoutesManager';
import ParamsValidatorMiddleware from '../middlewares/ParamsValidatorMiddleware';
import ApiRequest                from '../models/ApiRequest';
import SecurityMiddleware        from '../middlewares/SecurityMiddleware';
import SecurityCheckType         from '../types/SecurityCheckType';
import GitlabUser                from '../shared/types/Gitlab/GitlabUser';
import GitlabHelper              from '../helpers/GitlabHelper';
import Config                    from '../config/Config';
import GitlabMember              from '../shared/types/Gitlab/GitlabMember';
import GitlabAccessLevel         from '../shared/types/Gitlab/GitlabAccessLevel';
import GitlabRepository          from '../shared/types/Gitlab/GitlabRepository';
import UserManager               from '../managers/UserManager';
import User                      from '../models/User';
import Enonce                    from '../models/Enonce';
import EnonceStaff               from '../models/EnonceStaff';
import { AxiosError }            from 'axios';


class EnonceRoutes implements RoutesManager {
    private static _instance: EnonceRoutes;

    private constructor() { }

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

        return EnonceRoutes._instance;
    }

    private readonly enonceValidator: ExpressValidator.Schema = {
        name    : {
            trim    : true,
            notEmpty: true
        },
        members : {
            trim    : true,
            notEmpty: true
        },
        template: {
            optional: true,
            trim    : true,
            notEmpty: true
        }
    };

    registerOnBackend(backend: Express) {
        backend.post('/enonces', SecurityMiddleware.check(true, SecurityCheckType.TEACHING_STAFF), ParamsValidatorMiddleware.validate(this.enonceValidator), this.createEnonce);
    }

    private async createEnonce(req: ApiRequest, res: express.Response) {
        const params: { name: string, members: string, template: string | null } = req.body;
        const gitlabMembers: Array<GitlabUser> = JSON.parse(params.members) as Array<GitlabUser>;

        let template: string = Config.enonce.default.template;
        if ( params.template ) {
            template = params.template;
            const templateAccess = await GitlabHelper.checkTemplateAccess(template, req);

            if ( templateAccess !== StatusCodes.OK ) {
                return res.status(templateAccess).send();
            } else {
                template = `${ Config.gitlab.urls[0].replace(/^([a-z]{3,5}:\/{2})?(.*)/, `$1${ Config.gitlab.account.username }:${ Config.gitlab.account.token }@$2`) }${ template }.git`;
            }
        }

        let repository: GitlabRepository;
        try {
            repository = await GitlabHelper.createRepository(params.name, Config.enonce.default.description.replace('{{ENONCE_NAME}}', params.name), Config.enonce.default.visibility, Config.enonce.default.initReadme, Config.gitlab.group.enonces, Config.enonce.default.sharedRunnersEnabled, Config.enonce.default.wikiEnabled, template);
        } catch ( error ) {
            if ( error instanceof AxiosError ) {
                if ( error.response.data.message.name && error.response.data.message.name == 'has already been taken' ) {
                    return res.status(StatusCodes.CONFLICT).send();
                }

                return res.status(error.response.status).send();
            }

            return res.status(StatusCodes.INTERNAL_SERVER_ERROR).send();
        }

        try {
            const members: Array<GitlabMember | false> = await Promise.all([ req.session.profile.userGitlabId, ...gitlabMembers.map(member => member.id) ].map(async (memberId: number): Promise<GitlabMember | false> => {
                try {
                    return await GitlabHelper.addRepositoryMember(repository.id, memberId, GitlabAccessLevel.Maintainer);
                } catch ( e ) {
                    return false;
                }
            }));

            const enonce: Enonce = Enonce.createFromSql({
                                                            enonceName              : repository.name,
                                                            enonceGitlabId          : repository.id,
                                                            enonceGitlabLink        : repository.web_url,
                                                            enonceGitlabCreationInfo: JSON.stringify(repository),
                                                            enonceGitlabLastInfo    : JSON.stringify(repository),
                                                            enonceGitlabLastInfoTs  : new Date().getTime()
                                                        });
            await enonce.create();

            let dojoUsers: Array<User> = [ req.session.profile, ...(await UserManager.getByGitlabIds(gitlabMembers.map(member => member.id))).filter(user => user) ]; // TODO: Remplacer le filter par une map qui créer l'utilisateur inconnu.
            dojoUsers = dojoUsers.reduce((unique, user) => (unique.findIndex(uniqueUser => uniqueUser.userID === user.userID) !== -1 ? unique : [ ...unique, user ]), Array<User>());
            await Promise.all(dojoUsers.map(async (dojoUser: User) => {
                return EnonceStaff.createFromSql({
                                                     enonceID: enonce.enonceID,
                                                     userID  : dojoUser.userID
                                                 });
            }));

            return req.session.sendResponse(res, StatusCodes.OK, enonce.toJsonObject());
        } catch ( error ) {
            if ( error instanceof AxiosError ) {
                return res.status(error.response.status).send();
            }

            return res.status(StatusCodes.INTERNAL_SERVER_ERROR).send();
        }
    }
}


export default EnonceRoutes.instance;