Skip to content
Snippets Groups Projects
Select Git revision
  • 97546213079adbb6355896de51f10ef9366784df
  • live_exam_os_ubuntu default protected
2 results

userCreate.go

Blame
  • EnonceRoutes.ts 6.46 KiB
    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 GitlabManager             from '../managers/GitlabManager';
    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';
    import logger                    from '../shared/logging/WinstonLogger';
    import DojoValidators            from '../helpers/DojoValidators';
    import EnonceManager             from '../managers/EnonceManager';
    
    
    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,
                customSanitizer: DojoValidators.jsonSanitizer
            },
            template: {
                trim           : true,
                custom         : DojoValidators.templateUrlValidator,
                customSanitizer: DojoValidators.templateUrlSanitizer
            }
        };
    
        registerOnBackend(backend: Express) {
            backend.get('/enonces/:enonceNameOrUrl', SecurityMiddleware.check(true), this.getEnonce);
            backend.post('/enonces', SecurityMiddleware.check(true, SecurityCheckType.TEACHING_STAFF), ParamsValidatorMiddleware.validate(this.enonceValidator), this.createEnonce);
        }
    
        // Get an enonce by its name or gitlab url
        private async getEnonce(req: ApiRequest, res: express.Response) {
            return req.boundParams.enonce ? req.session.sendResponse(res, StatusCodes.OK, req.boundParams.enonce.toJsonObject()) : res.status(StatusCodes.NOT_FOUND).send();
        }
    
        private async createEnonce(req: ApiRequest, res: express.Response) {
            const params: { name: string, members: Array<GitlabUser>, template: string } = req.body;
    
            let repository: GitlabRepository;
            try {
                repository = await GitlabManager.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, params.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();
                }
    
                logger.error(error);
                return res.status(StatusCodes.INTERNAL_SERVER_ERROR).send();
            }
    
            try {
                const members: Array<GitlabMember | false> = await Promise.all([ req.session.profile.userGitlabId, ...params.members.map(member => member.id) ].map(async (memberId: number): Promise<GitlabMember | false> => {
                    try {
                        return await GitlabManager.addRepositoryMember(repository.id, memberId, GitlabAccessLevel.Maintainer);
                    } catch ( e ) {
                        return false;
                    }
                }));
    
                const enonce: Enonce = await EnonceManager.createObjectFromRawSql({
                                                                                      enonceName              : repository.name,
                                                                                      enonceGitlabId          : repository.id,
                                                                                      enonceGitlabLink        : repository.web_url,
                                                                                      enonceGitlabCreationInfo: JSON.stringify(repository),
                                                                                      enonceGitlabLastInfo    : JSON.stringify(repository),
                                                                                      enonceGitlabLastInfoTs  : new Date().getTime()
                                                                                  }).create();
    
                let dojoUsers: Array<User> = [ req.session.profile, ...(await UserManager.getFromGitlabUsers(params.members, true) as Array<User>) ];
                dojoUsers = dojoUsers.reduce((unique, user) => (unique.findIndex(uniqueUser => uniqueUser.userId === user.userId) !== -1 ? unique : [ ...unique, user ]), Array<User>());
                await Promise.all(dojoUsers.map(dojoUser => EnonceStaff.createFromSql({
                                                                                          enonceName: enonce.enonceName,
                                                                                          userId    : dojoUser.userId
                                                                                      }).create()));
    
                return req.session.sendResponse(res, StatusCodes.OK, enonce.toJsonObject());
            } catch ( error ) {
                if ( error instanceof AxiosError ) {
                    return res.status(error.response.status).send();
                }
    
                logger.error(error);
                return res.status(StatusCodes.INTERNAL_SERVER_ERROR).send();
            }
        }
    }
    
    
    export default EnonceRoutes.instance;