Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision
  • jw_sonar
  • main
  • v5.0
  • open_tool_for_self_hosting
  • jw_sonar_backup
  • move-to-esm-only
  • v4.1
  • v4.2
8 results

Target

Select target project
No results found
Select Git revision
  • jw_sonar
  • main
  • v5.0
  • open_tool_for_self_hosting
  • jw_sonar_backup
  • move-to-esm-only
  • v4.1
  • v4.2
8 results
Show changes

Commits on Source 50

33 files
+ 285
− 505
Compare changes
  • Side-by-side
  • Inline

Files

config/SharedConfig.ts

+13 −31
Original line number Diff line number Diff line 
import * as process from 'process';





class SharedConfig {

    public readonly production: boolean;

    public debug: boolean = false;



    public readonly logsFolder: string;



    public gitlab: {

        URL: string, apiURL: string

    };



    public readonly login: {

        gitlab: {

            client: {

                id: string

            }, url: {

                redirect: string, token: string

            }

    public sonar: {

        enabled: boolean

        url: string

        token: string

    }

    };





    constructor() {

        this.production = process.env.NODE_ENV === 'production';



        this.logsFolder = process.env.LOGS_FOLDER || '';



        this.gitlab = {

            URL   : process.env.GITLAB_URL || '',

            apiURL: process.env.GITLAB_API_URL || ''

        this.sonar = {

            enabled: ['yes', 'true', '1', 'on'].includes(process.env.SONAR_ENABLED?.trim()?.toLowerCase() ?? ''),

            url: process.env.SONAR_URL || '',

            token: process.env.SONAR_TOKEN || ''

        };



        this.login = {

            gitlab: {

                client: {

                    id: process.env.LOGIN_GITLAB_CLIENT_ID || ''

                },

                url   : {

                    redirect: process.env.LOGIN_GITLAB_URL_REDIRECT || '',

                    token   : process.env.LOGIN_GITLAB_URL_TOKEN || ''

                }

            }

        };

        this.logsFolder = process.env.LOGS_FOLDER ?? '';

    }

}

helpers/ArchiveHelper.ts

+20 −20
Original line number Diff line number Diff line
@@ -8,26 +8,26 @@ import zlib from 'zlib'; 


class ArchiveHelper {

    private async explore(absoluteBasePath: string, rootPath: string, pack: tar.Pack) {

        for ( let file of await fs.promises.readdir(rootPath) ) {

            if ( file === 'output.tar' ) {

                continue;

            }

            file = path.join(rootPath, file);

            const stat = await fs.promises.stat(file);

        for ( const file of await fs.promises.readdir(rootPath) ) {

            let filename = file;

            if ( filename !== 'output.tar' ) {

                filename = path.join(rootPath, filename);

                const stat = await fs.promises.stat(filename);

                if ( stat.isDirectory() ) {

                await this.explore(absoluteBasePath, file, pack);

                continue;

            }

                    await this.explore(absoluteBasePath, filename, pack);

                } else {

                    const entry = pack.entry({

                                         name: file.replace(absoluteBasePath, ''),

                                                 name: filename.replace(absoluteBasePath, ''),

                                                 size: stat.size

                                     }, (err) => {

                                             }, err => {

                        if ( err ) {

                            throw err;

                        }

                    });

            const stream = fs.createReadStream(file);

            stream.pipe(entry);

                    const readStream = fs.createReadStream(filename);

                    readStream.pipe(entry);

                }

            }

        }

    }
@@ -55,7 +55,7 @@ class ArchiveHelper { 


        await this.compress(folderPath, tarDataStream);



        data = await (new Promise((resolve) => {

        data = await (new Promise(resolve => {

            tarDataStream.on('close', () => {

                resolve(data);

            });

helpers/Dojo/SharedAssignmentHelper.ts

+22 −17
Original line number Diff line number Diff line 
import AssignmentFile       from '../../types/Dojo/AssignmentFile';

import GitlabPipelineStatus from '../../types/Gitlab/GitlabPipelineStatus';

import DojoStatusCode       from '../../types/Dojo/DojoStatusCode';

import GitlabPipeline       from '../../types/Gitlab/GitlabPipeline';

import AssignmentFile       from '../../types/Dojo/AssignmentFile.js';

import DojoStatusCode       from '../../types/Dojo/DojoStatusCode.js';

import Json5FileValidator   from '../Json5FileValidator.js';

import * as Gitlab          from '@gitbeaker/rest';

import GitlabPipelineStatus from '../../types/Gitlab/GitlabPipelineStatus.js';

import SharedGitlabManager  from '../../managers/SharedGitlabManager';

import Json5FileValidator   from '../Json5FileValidator';





class SharedAssignmentHelper {

    private gitlabManager!: SharedGitlabManager;



    init(gitlabManager: SharedGitlabManager) {

        this.gitlabManager = gitlabManager;

    }



    validateDescriptionFile(filePathOrStr: string, isFile: boolean = true, version: number = 1): { content: AssignmentFile | undefined, isValid: boolean, error: string | null } {

        switch ( version ) {

            case 1:

        if ( version === 1 ) {

            return Json5FileValidator.validateFile(AssignmentFile, filePathOrStr, isFile);

            default:

        } else {

            return {

                content: undefined,

                isValid: false,
@@ -20,11 +25,11 @@ class SharedAssignmentHelper { 
        }

    }



    async isPublishable(repositoryId: number): Promise<{ isPublishable: boolean, lastPipeline: GitlabPipeline | null, status?: { code: DojoStatusCode, message: string } }> {

        const pipelines = await SharedGitlabManager.getRepositoryPipelines(repositoryId, 'main');

    async isPublishable(repositoryId: number): Promise<{ isPublishable: boolean, lastPipeline: Gitlab.PipelineSchema | null, status?: { code: DojoStatusCode, message: string } }> {

        const pipelines = await this.gitlabManager.getRepositoryPipelines(repositoryId, 'main');

        if ( pipelines.length > 0 ) {

            const lastPipeline = pipelines[0];

            if ( lastPipeline.status != GitlabPipelineStatus.SUCCESS ) {

            if ( lastPipeline.status !== GitlabPipelineStatus.SUCCESS.valueOf() ) {

                return {

                    isPublishable: false,

                    lastPipeline : lastPipeline,

helpers/Dojo/SharedExerciseHelper.ts

deleted100644 → 0
+0 −4
Original line number Diff line number Diff line 
class SharedExerciseHelper {}





export default new SharedExerciseHelper();
 
 No newline at end of file

helpers/LazyVal.ts

+5 −2
Original line number Diff line number Diff line 
class LazyVal<T> {

    private val: T | undefined = undefined;

    private readonly valLoader: () => Promise<T> | T;



    constructor(private valLoader: () => Promise<T> | T) {}

    constructor(valLoader: () => Promise<T> | T) {

        this.valLoader = valLoader;

    }



    get value(): Promise<T> {

        return new Promise<T>((resolve) => {

        return new Promise<T>(resolve => {

            if ( this.val === undefined ) {

                Promise.resolve(this.valLoader()).then((value: T) => {

                    this.val = value;

helpers/Toolbox.ts

+7 −2
Original line number Diff line number Diff line
@@ -14,8 +14,9 @@ class Toolbox { 
        const files = await fs.readdir(dirPath);



        await Promise.all(files.map(async file => {

            if ( (await fs.stat(dirPath + '/' + file)).isDirectory() ) {

                arrayOfFiles = await this.getAllFiles(dirPath + '/' + file, arrayOfFiles);

            const filePath = path.join(dirPath, file);

            if ( (await fs.stat(filePath)).isDirectory() ) {

                arrayOfFiles = await this.getAllFiles(filePath, arrayOfFiles);

            } else {

                arrayOfFiles.push(path.join(dirPath, file));

            }
@@ -50,6 +51,10 @@ class Toolbox { 
    public getKeysWithPrefix(obj: object, prefix: string): Array<string> {

        return Object.keys(obj).filter(key => key.startsWith(prefix));

    }



    public isString(value: unknown): value is string {

        return typeof value === 'string' || value instanceof String;

    }

}

helpers/TypeScriptExtensions.ts

+1 −3
Original line number Diff line number Diff line
@@ -64,9 +64,7 @@ function registerStringCapitalizeName() { 


function registerStringConvertWithEnvVars() {

    String.prototype.convertWithEnvVars = function (this: string): string {

        return this.replace(/\${?([a-zA-Z0-9_]+)}?/g, (_match: string, p1: string) => {

            return process.env[p1] || '';

        });

        return this.replace(/\${?([a-zA-Z0-9_]+)}?/g, (_match: string, p1: string) => process.env[p1] || '');

    };

}

helpers/recursiveFilesStats/RecursiveFilesStats.ts

+24 −23
Original line number Diff line number Diff line
@@ -51,33 +51,37 @@ class RecursiveFilesStats { 
        return this.getFiles(`${ path.resolve(rootPath) }/`, rootPath, options, [], callback);

    }



    private async getFiles(absoluteBasePath: string, rootPath: string, options: RecursiveReaddirFilesOptions = {}, files: IFileDirStat[] = [], callback?: Callback): Promise<IFileDirStat[]> {

        const {

                  ignored, include, exclude, filter

              } = options;

    private async getFilesDirsStat(rootPath: string, options: RecursiveReaddirFilesOptions): Promise<Array<IFileDirStat>> {

        const filesData = await fs.promises.readdir(rootPath);

        const fileDir: IFileDirStat[] = filesData.map((file) => ({

            name: file, path: path.join(rootPath, file)

        })).filter((item) => {

            if ( include && include.test(item.path) ) {

        return filesData.map(file => ({

            name: file,

            path: path.join(rootPath, file)

        })).filter(item => {

            if ( options.include && options.include.test(item.path) ) {

                return true;

            }

            if ( exclude && exclude.test(item.path) ) {

            if ( options.exclude && options.exclude.test(item.path) ) {

                return false;

            }

            if ( ignored ) {

                return !ignored.test(item.path);

            if ( options.ignored ) {

                return !options.ignored.test(item.path);

            }

            return true;

        });

    }



    private async getFiles(absoluteBasePath: string, rootPath: string, options: RecursiveReaddirFilesOptions = {}, files: IFileDirStat[] = [], callback?: Callback): Promise<IFileDirStat[]> {

        const fileDir: Array<IFileDirStat> = await this.getFilesDirsStat(rootPath, options);



        if ( callback ) {

            fileDir.map(async (item: IFileDirStat) => {

                const stat = await this.getStat(item.path, absoluteBasePath, options);

            fileDir.forEach(item => {

                this.getStat(item.path, absoluteBasePath, options).then(stat => {

                    if ( stat.isDirectory!() ) {

                    await this.getFiles(absoluteBasePath, item.path, options, [], callback);

                        this.getFiles(absoluteBasePath, item.path, options, [], callback).then();

                    }

                    callback(item.path, stat);

                });

            });

        } else {

            await Promise.all(fileDir.map(async (item: IFileDirStat) => {

                const stat = await this.getStat(item.path, absoluteBasePath, options);
@@ -89,9 +93,9 @@ class RecursiveFilesStats { 
                }

            }));

        }

        return files.filter((item) => {

            if ( filter && typeof filter === 'function' ) {

                return filter(item);

        return files.filter(item => {

            if ( options.filter && typeof options.filter === 'function' ) {

                return options.filter(item);

            }

            return true;

        });
@@ -124,10 +128,7 @@ class RecursiveFilesStats { 
            delete stat.ctimeMs;

            delete stat.birthtimeMs;

            delete stat.atime;

            //delete stat.mtime;

            delete stat.ctime;

            //delete stat.birthtime;

            //delete stat.mode;

        }



        return stat;

logging/WinstonLogger.ts

+13 −9
Original line number Diff line number Diff line 
import winston        from 'winston';

import SharedConfig   from '../config/SharedConfig';

import SharedConfig   from '../config/SharedConfig.js';

import * as Transport from 'winston-transport';
@@ -23,7 +23,11 @@ winston.addColors(colors); 
const format = winston.format.combine(winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston.format(info => ({

    ...info,

    level: info.level.toUpperCase()

}))(), SharedConfig.production ? winston.format.uncolorize() : winston.format.colorize({ all: true }), winston.format.prettyPrint(), winston.format.errors({ stack: true }), winston.format.align(), winston.format.printf((info) => `[${ info.timestamp }] (${ process.pid }) ${ info.level } ${ info.message } ${ info.metadata ? `\n${ JSON.stringify(info.metadata) }` : '' } ${ info.stack ? `\n${ info.stack }` : '' } `));

}))(), SharedConfig.production ? winston.format.uncolorize() : winston.format.colorize({ all: true }), winston.format.prettyPrint(), winston.format.errors({ stack: true }), winston.format.align(), winston.format.printf(info => {

    const metadata = info.metadata ? `\n${ JSON.stringify(info.metadata) }` : '';

    const stack = info.stack ? `\n${ JSON.stringify(info.stack, undefined, 4) }` : '';

    return `[${ info.timestamp }] (${ process.pid }) ${ info.level } ${ info.message } ${ metadata } ${ stack } `;

}));



const commonTransportOptions = {

    handleRejections: true,
@@ -54,11 +58,11 @@ if ( SharedConfig.production ) { 
                                                                                                 }) ]);

}



const logger = winston.createLogger({

const WinstonLogger = winston.createLogger({

                                               levels,

                                               format,

                                               transports,

                                               exitOnError: false

                                           });



export default logger;
 
export default WinstonLogger;

managers/SharedGitlabManager.ts

+74 −19
Original line number Diff line number Diff line 
import axios                                                                   from 'axios';

import GitlabPipeline from '../types/Gitlab/GitlabPipeline';

import GitlabRoute    from '../types/Gitlab/GitlabRoute';

import SharedConfig   from '../config/SharedConfig';

import GitlabToken    from '../types/Gitlab/GitlabToken';

import * as GitlabCore                                                         from '@gitbeaker/core';

import { GitbeakerRequestError }                                               from '@gitbeaker/requester-utils';

import { Gitlab, PipelineSchema, ProjectSchema, SimpleUserSchema, UserSchema } from '@gitbeaker/rest';

import GitlabToken                                                             from '../types/Gitlab/GitlabToken.js';





class GitlabManager {

    private getApiUrl(route: GitlabRoute): string {

        return `${ SharedConfig.gitlab.apiURL }${ route }`;

class SharedGitlabManager {

    protected api!: GitlabCore.Gitlab<false>;

    private readonly refreshTokenFunction?: () => Promise<string>;



    setToken(token: string) {

        this.api = new Gitlab(Object.assign({

                                                host: this.gitlabUrl ?? ''

                                            }, this.refreshTokenFunction ? { oauthToken: token } : { token: token }));

    }



    constructor(public gitlabUrl: string, token: string, public clientId?: string, public urlRedirect?: string, public urlToken?: string, refreshTokenFunction?: () => Promise<string>) {

        this.refreshTokenFunction = refreshTokenFunction;

        this.setToken(token);

    }



    protected async executeGitlabRequest<T>(request: () => Promise<T>, refreshTokenIfNeeded: boolean = true): Promise<T> {

        try {

            return await request();

        } catch ( error ) {

            if ( this.refreshTokenFunction && refreshTokenIfNeeded && error instanceof GitbeakerRequestError ) {

                this.setToken(await this.refreshTokenFunction());



                return this.executeGitlabRequest(request, false);

            } else {

                throw error;

            }

        }

    }



    async getTokens(codeOrRefresh: string, isRefresh: boolean = false, clientSecret: string = ''): Promise<GitlabToken> {

        const response = await axios.post<GitlabToken>(SharedConfig.login.gitlab.url.token, {

            client_id    : SharedConfig.login.gitlab.client.id,

        if ( !this.urlToken ) {

            throw new Error('Error when initializing GitlabManager');

        }



        const response = await axios.post<GitlabToken>(this.urlToken, {

            client_id    : this.clientId,

            client_secret: clientSecret,

            grant_type   : isRefresh ? 'refresh_token' : 'authorization_code',

            refresh_token: codeOrRefresh,

            code         : codeOrRefresh,

            redirect_uri : SharedConfig.login.gitlab.url.redirect

            redirect_uri : this.urlRedirect

        });



        return response.data;

    }



    async getRepositoryPipelines(repoId: number, branch: string = 'main'): Promise<Array<GitlabPipeline>> {

        const response = await axios.get<Array<GitlabPipeline>>(this.getApiUrl(GitlabRoute.REPOSITORY_PIPELINES).replace('{{id}}', String(repoId)), {

            params: {

                ref: branch

    public async getUserById(id: number): Promise<UserSchema | undefined> {

        try {

            return await this.executeGitlabRequest(async () => {

                const user = await this.api.Users.show(id);



                return user.id === id ? user : undefined;

            });

        } catch ( e ) {

            return undefined;

        }

    }



    public async getUserByUsername(username: string): Promise<SimpleUserSchema | undefined> {

        try {

            return await this.executeGitlabRequest(async () => {

                const user = await this.api.Users.all({

                                                          username: username,

                                                          maxPages: 1,

                                                          perPage : 1

                                                      });



        return response.data;



                return user.length > 0 && user[0].username === username ? user[0] : undefined;

            });

        } catch ( e ) {

            return undefined;

        }

    }



    async getRepository(projectIdOrNamespace: string): Promise<ProjectSchema> {

        return this.executeGitlabRequest(() => this.api.Projects.show(projectIdOrNamespace));

    }



    async getRepositoryPipelines(repoId: number, branch: string = 'main'): Promise<Array<PipelineSchema>> {

        return this.executeGitlabRequest(() => this.api.Pipelines.all(repoId, { ref: branch }));

    }

}





export default new GitlabManager();
 
export default SharedGitlabManager;

managers/SharedSonarManager.ts

0 → 100644
+43 −0
Original line number Diff line number Diff line 
import axios        from 'axios';

import https        from 'https';

import SharedConfig from '../config/SharedConfig';





class SharedSonarManager {



    // Use custom instance to allow self-signed certificates

    private instance = axios.create({

        httpsAgent: new https.Agent({

            rejectUnauthorized: false

        })

    });

    async isSonarSupported(): Promise<boolean> {

        if (!SharedConfig.sonar.enabled) {

            return false;

        }

        try {

            const sonar = await this.instance.get(SharedConfig.sonar.url);

            return sonar.status == 200;

        } catch ( error ) {

            return false;

        }

    }



    /**

     * Map a language name to the equivalent language ID in Sonar

     * Most language have the same name, so by default the same name is returned, even for languages that doesn't exist in sonar.

     * @param language

     */

    mapLanguage(language: string): string {

        switch (language) {

            case "csharp":

                return "cs";

            case "python":

                return "py";

            default:

                return language;

        }

    }

}



export default new SharedSonarManager();
 
 No newline at end of file

types/Dojo/AssignmentCheckerError.ts

+3 −0
Original line number Diff line number Diff line
@@ -11,6 +11,9 @@ enum ExerciseCheckerError { 
    COMPOSE_FILE_VOLUME_MISSING     = 209,

    DOCKERFILE_NOT_FOUND            = 210,

    COMPOSE_RUN_SUCCESSFULLY        = 211, // Yes, this is an error

    ASSIGNMENT_MISSING              = 212,

    BUILD_LINE_MISSING              = 213,

    SONAR_ANALYSIS_FAILED           = 214

}

types/Dojo/AssignmentFile.ts

+3 −2
Original line number Diff line number Diff line 
import ImmutableFileDescriptor from './ImmutableFileDescriptor';

import ImmutableFileDescriptor from './ImmutableFileDescriptor.js';

import { z }                   from 'zod';





const AssignmentFile = z.object({

                                    dojoAssignmentVersion: z.number(),

                                    version              : z.number(),

                                    immutable            : z.array(ImmutableFileDescriptor.transform(value => value as ImmutableFileDescriptor)),

                                    buildLine            : z.string().optional(),

                                    immutable            : z.array(ImmutableFileDescriptor),

                                    result               : z.object({

                                                                        container: z.string(),

                                                                        volume   : z.string().optional()

types/Dojo/DojoStatusCode.ts

+26 −15
Original line number Diff line number Diff line 
enum DojoStatusCode {

    LOGIN_FAILED                        = 1,

    REFRESH_TOKENS_FAILED               = 2,

    CLIENT_NOT_SUPPORTED                = 100,

    CLIENT_VERSION_NOT_SUPPORTED        = 110,

    ASSIGNMENT_PUBLISH_NO_PIPELINE      = 200,

    ASSIGNMENT_PUBLISH_PIPELINE_FAILED  = 201,

    ASSIGNMENT_CREATION_GITLAB_ERROR    = 202,

    ASSIGNMENT_CREATION_INTERNAL_ERROR  = 203,

    ASSIGNMENT_EXERCISE_NOT_RELATED     = 204,

    ASSIGNMENT_NOT_PUBLISHED            = 205,

    EXERCISE_CORRECTION_NOT_EXIST       = 206,

    EXERCISE_CORRECTION_ALREADY_EXIST   = 207,

    EXERCISE_CREATION_GITLAB_ERROR      = 302,

    EXERCISE_CREATION_INTERNAL_ERROR    = 303,

    MAX_EXERCISE_PER_ASSIGNMENT_REACHED = 304

    LOGIN_FAILED                        = 10001,

    REFRESH_TOKENS_FAILED               = 10002,

    CLIENT_NOT_SUPPORTED                = 10100,

    CLIENT_VERSION_NOT_SUPPORTED        = 10110,

    ASSIGNMENT_PUBLISH_NO_PIPELINE      = 10200,

    ASSIGNMENT_PUBLISH_PIPELINE_FAILED  = 10201,

    ASSIGNMENT_CREATION_GITLAB_ERROR    = 10202,

    ASSIGNMENT_CREATION_INTERNAL_ERROR  = 10203,

    ASSIGNMENT_EXERCISE_NOT_RELATED     = 10204,

    ASSIGNMENT_NOT_PUBLISHED            = 10205,

    EXERCISE_CORRECTION_NOT_EXIST       = 10206,

    EXERCISE_CORRECTION_ALREADY_EXIST   = 10207,

    ASSIGNMENT_NAME_CONFLICT            = 10208,

    EXERCISE_CREATION_GITLAB_ERROR      = 10302,

    EXERCISE_CREATION_INTERNAL_ERROR    = 10303,

    MAX_EXERCISE_PER_ASSIGNMENT_REACHED = 10304,

    GITLAB_TEMPLATE_NOT_FOUND           = 10401,

    GITLAB_TEMPLATE_ACCESS_UNAUTHORIZED = 10402,

    TAG_ONLY_ADMIN_CREATION             = 11101,

    TAG_WITH_ACTIVE_LINK_DELETION       = 11102,

    TAG_PROPOSAL_ANSWER_NOT_PENDING     = 11103,

    ASSIGNMENT_CREATION_SONAR_ERROR     = 208,

    ASSIGNMENT_CREATION_SONAR_MEMBER    = 209,

    EXERCISE_CREATION_SONAR_ERROR       = 305,

    ASSIGNMENT_SONAR_GATE_NOT_FOUND     = 401,

    ASSIGNMENT_SONAR_PROFILE_NOT_FOUND  = 402

}

types/Dojo/ExerciseCheckerError.ts

+4 −1
Original line number Diff line number Diff line
@@ -6,7 +6,10 @@ enum ExerciseCheckerError { 
    EXERCISE_RESULTS_FOLDER_TOO_BIG        = 204,

    EXERCISE_RESULTS_FILE_SCHEMA_NOT_VALID = 206,

    UPLOAD                                 = 207,

    DOCKER_COMPOSE_REMOVE_DANGLING_ERROR   = 208

    DOCKER_COMPOSE_REMOVE_DANGLING_ERROR   = 208,

    SONAR_DOCKER_ERROR                     = 209,

    SONAR_BUILD_ERROR                      = 210,

    SONAR_GATE_FAILED                      = 211

}

types/Dojo/ExerciseResultsFile.ts

+2 −2
Original line number Diff line number Diff line 
import Icon  from '../Icon';

import Icon  from '../Icon.js';

import { z } from 'zod';

types/Gitlab/GitlabAccessLevel.ts

deleted100644 → 0
+0 −11
Original line number Diff line number Diff line 
enum GitlabAccessLevel {

    GUEST      = 10,

    REPORTER   = 20,

    DEVELOPER  = 30,

    MAINTAINER = 40,

    OWNER      = 50,

    ADMIN      = 60

}





export default GitlabAccessLevel;

types/Gitlab/GitlabCommit.ts

deleted100644 → 0
+0 −17
Original line number Diff line number Diff line 
interface GitlabCommit {

    id: string;

    short_id: string;

    created_at: string;

    parent_ids: Array<string>;

    title: string;

    message: string;

    author_name: string;

    author_email: string;

    authored_date: string;

    committer_name: string;

    committer_email: string;

    committed_date: string;

}





export default GitlabCommit;
 
 No newline at end of file

types/Gitlab/GitlabFile.ts

deleted100644 → 0
+0 −16
Original line number Diff line number Diff line 
interface GitlabFile {

    file_name: string,

    file_path: string,

    size: number,

    encoding: string,

    content_sha256: string,

    ref: string,

    blob_id: string,

    commit_id: string,

    last_commit_id: string,

    execute_filemode: boolean,

    content: string,

}





export default GitlabFile;
 
 No newline at end of file

types/Gitlab/GitlabGroup.ts

deleted100644 → 0
+0 −10
Original line number Diff line number Diff line 
interface GitlabGroup {

    group_id: number,

    group_name: string,

    group_full_path: string,

    group_access_level: number,

    expires_at: string

}





export default GitlabGroup;
 
 No newline at end of file

types/Gitlab/GitlabMember.ts

deleted100644 → 0
+0 −12
Original line number Diff line number Diff line 
import GitlabUser from './GitlabUser';





interface GitlabMember extends GitlabUser {

    access_level: number,

    created_at: string,

    created_by: GitlabUser,

    expires_at: string | null

}





export default GitlabMember;
 
 No newline at end of file

types/Gitlab/GitlabMilestone.ts

deleted100644 → 0
+0 −19
Original line number Diff line number Diff line 
interface GitlabMilestone {

    id: number;

    iid: number;

    project_id: number;

    title: string;

    description: string;

    state: string;

    created_at: string;

    updated_at: string;

    due_date: string;

    start_date: string;

    web_url: string;

    issue_stats: {

        total: number; closed: number;

    };

}





export default GitlabMilestone;
 
 No newline at end of file

types/Gitlab/GitlabNamespace.ts

deleted100644 → 0
+0 −13
Original line number Diff line number Diff line 
interface GitlabNamespace {

    id: number,

    name: string,

    path: string,

    kind: string,

    full_path: string,

    parent_id: number,

    avatar_url: string,

    web_url: string

}





export default GitlabNamespace;
 
 No newline at end of file

types/Gitlab/GitlabPipeline.ts

deleted100644 → 0
+0 −31
Original line number Diff line number Diff line 
import GitlabPipelineStatus from './GitlabPipelineStatus';

import GitlabPipelineSource from './GitlabPipelineSource';

import GitlabUser           from './GitlabUser';





interface GitlabPipeline {

    id: number,

    iid: number,

    project_id: number,

    status: GitlabPipelineStatus,

    source: GitlabPipelineSource,

    ref: string,

    sha: string,

    before_sha: string,

    tag: boolean,

    name: string,

    yaml_errors: string | null,

    user: GitlabUser,

    web_url: string,

    created_at: string,

    updated_at: string,

    started_at: string | null,

    finished_at: string | null,

    committed_at: string | null,

    duration: number | null,

    queued_duration: number | null,

    coverage: string | null,

}





export default GitlabPipeline;
 
 No newline at end of file

types/Gitlab/GitlabProfile.ts

deleted100644 → 0
+0 −40
Original line number Diff line number Diff line 
import GitlabUser from './GitlabUser';





interface GitlabProfile extends GitlabUser {

    created_at: string,

    bio: string,

    location: string,

    public_email: string,

    skype: string,

    linkedin: string,

    twitter: string,

    discord: string,

    website_url: string,

    organization: string,

    job_title: string,

    pronouns: string,

    bot: boolean,

    work_information: string,

    local_time: string,

    last_sign_in_at: string,

    confirmed_at: string,

    last_activity_on: string,

    email: string,

    theme_id: number,

    color_scheme_id: number,

    projects_limit: number,

    current_sign_in_at: string,

    identities: Array<{

        provider: string, extern_uid: string

    }>,

    can_create_group: boolean,

    can_create_project: boolean,

    two_factor_enabled: boolean,

    external: boolean,

    private_profile: boolean,

    commit_email: string

}





export default GitlabProfile;
 
 No newline at end of file

types/Gitlab/GitlabRelease.ts

deleted100644 → 0
+0 −29
Original line number Diff line number Diff line 
import GitlabUser      from './GitlabUser';

import GitlabCommit    from './GitlabCommit';

import GitlabMilestone from './GitlabMilestone';





interface GitlabRelease {

    tag_name: string;

    description: string;

    created_at: string;

    released_at: string;

    author: GitlabUser;

    commit: GitlabCommit;

    milestones: Array<GitlabMilestone>;

    commit_path: string;

    tag_path: string;

    assets: {

        count: number; sources: Array<{

            format: string; url: string;

        }>; links: Array<{

            id: number; name: string; url: string; link_type: string;

        }>; evidence_file_path: string;

    };

    evidences: Array<{

        sha: string; filepath: string; collected_at: string;

    }>;

}





export default GitlabRelease; 
 No newline at end of file

types/Gitlab/GitlabRepository.ts

deleted100644 → 0
+0 −106
Original line number Diff line number Diff line 
import GitlabGroup     from './GitlabGroup';

import GitlabNamespace from './GitlabNamespace';





interface GitlabRepository {

    id: number,

    description: string,

    name: string,

    name_with_namespace: string,

    path: string,

    path_with_namespace: string,

    created_at: string,

    default_branch: string,

    tag_list: Array<string>,

    topics: Array<string>,

    ssh_url_to_repo: string,

    http_url_to_repo: string,

    web_url: string,

    readme_url: string,

    forks_count: number,

    avatar_url: string,

    star_count: number,

    last_activity_at: string,

    namespace: GitlabNamespace,

    _links: {

        self: string, issues: string, merge_requests: string, repo_branches: string, labels: string, events: string, members: string, cluster_agents: string

    },

    packages_enabled: boolean,

    empty_repo: boolean,

    archived: boolean,

    visibility: string,

    resolve_outdated_diff_discussions: boolean,

    container_expiration_policy: {

        cadence: string, enabled: boolean, keep_n: number, older_than: string, name_regex: string, name_regex_keep: string, next_run_at: string

    },

    issues_enabled: boolean,

    merge_requests_enabled: boolean,

    wiki_enabled: boolean,

    jobs_enabled: boolean,

    snippets_enabled: boolean,

    container_registry_enabled: boolean,

    service_desk_enabled: boolean,

    service_desk_address: string,

    can_create_merge_request_in: boolean,

    issues_access_level: string,

    repository_access_level: string,

    merge_requests_access_level: string,

    forking_access_level: string,

    wiki_access_level: string,

    builds_access_level: string,

    snippets_access_level: string,

    pages_access_level: string,

    operations_access_level: string,

    analytics_access_level: string,

    container_registry_access_level: string,

    security_and_compliance_access_level: string,

    releases_access_level: string,

    environments_access_level: string,

    feature_flags_access_level: string,

    infrastructure_access_level: string,

    monitor_access_level: string,

    emails_disabled: boolean,

    shared_runners_enabled: boolean,

    lfs_enabled: boolean,

    creator_id: number,

    import_url: string,

    import_type: string,

    import_status: string,

    import_error: string,

    open_issues_count: number,

    runners_token: string,

    ci_default_git_depth: number,

    ci_forward_deployment_enabled: boolean,

    ci_job_token_scope_enabled: boolean,

    ci_separated_caches: boolean,

    ci_opt_in_jwt: boolean,

    ci_allow_fork_pipelines_to_run_in_parent_project: boolean,

    public_jobs: boolean,

    build_git_strategy: string,

    build_timeout: number,

    auto_cancel_pending_pipelines: string,

    ci_config_path: string,

    shared_with_groups: Array<GitlabGroup>,

    only_allow_merge_if_pipeline_succeeds: boolean,

    allow_merge_on_skipped_pipeline: boolean,

    restrict_user_defined_variables: boolean,

    request_access_enabled: boolean,

    only_allow_merge_if_all_discussions_are_resolved: boolean,

    remove_source_branch_after_merge: boolean,

    printing_merge_request_link_enabled: boolean,

    merge_method: string,

    squash_option: string,

    enforce_auth_checks_on_uploads: boolean,

    suggestion_commit_message: string,

    merge_commit_template: string,

    squash_commit_template: string,

    issue_branch_template: string,

    auto_devops_enabled: boolean,

    auto_devops_deploy_strategy: string,

    autoclose_referenced_issues: boolean,

    keep_latest_artifact: boolean,

    runner_token_expiration_interval: number,

}





export default GitlabRepository;
 
 No newline at end of file

types/Gitlab/GitlabRoute.ts

deleted100644 → 0
+0 −22
Original line number Diff line number Diff line 
enum GitlabRoute {

    NOTIFICATION_SETTINGS       = '/notification_settings',

    PROFILE_GET                 = '/user',

    USERS_GET                   = '/users',

    REPOSITORY_GET              = '/projects/{{id}}',

    REPOSITORY_CREATE           = '/projects', // eslint-disable-next-line @typescript-eslint/no-duplicate-enum-values

    REPOSITORY_DELETE           = '/projects/{{id}}', // eslint-disable-next-line @typescript-eslint/no-duplicate-enum-values

    REPOSITORY_EDIT             = '/projects/{{id}}',

    REPOSITORY_FORK             = '/projects/{{id}}/fork',

    REPOSITORY_MEMBER_ADD       = '/projects/{{id}}/members',

    REPOSITORY_MEMBERS_GET      = '/projects/{{id}}/members/all',

    REPOSITORY_RELEASES_GET     = '/projects/{{id}}/releases',

    REPOSITORY_BADGES_ADD       = '/projects/{{id}}/badges',

    REPOSITORY_VARIABLES_ADD    = '/projects/{{id}}/variables',

    REPOSITORY_BRANCHES_PROTECT = '/projects/{{id}}/protected_branches',

    REPOSITORY_TREE             = '/projects/{{id}}/repository/tree',

    REPOSITORY_FILE             = '/projects/{{id}}/repository/files/{{filePath}}',

    REPOSITORY_PIPELINES        = '/projects/{{id}}/pipelines',

}





export default GitlabRoute;
 
 No newline at end of file

types/Gitlab/GitlabTreeFile.ts

deleted100644 → 0
+0 −13
Original line number Diff line number Diff line 
import GitlabTreeFileType from './GitlabTreeFileType';





interface GitlabTreeFile {

    id: number,

    name: string,

    type: GitlabTreeFileType,

    path: string,

    mode: string

}





export default GitlabTreeFile;
 
 No newline at end of file

types/Gitlab/GitlabUser.ts

deleted100644 → 0
+0 −11
Original line number Diff line number Diff line 
interface GitlabUser {

    id: number,

    username: string,

    name: string,

    state: string,

    avatar_url: string,

    web_url: string,

}





export default GitlabUser;
 
 No newline at end of file

types/Gitlab/GitlabVisibility.ts

+1 −5
Original line number Diff line number Diff line 
enum GitlabVisibility {

    PUBLIC   = 'public',

    INTERNAL = 'internal',

    PRIVATE  = 'private'

}

type GitlabVisibility = 'public' | 'internal' | 'private';





export default GitlabVisibility;

types/Sonar/SonarProjectCreation.ts

0 → 100644
+10 −0
Original line number Diff line number Diff line 
interface SonarProjectCreation {

    project: {

        key: string,

        name: string,

        qualifier: string,

        visibility: string

    }

}



export default SonarProjectCreation;
 
 No newline at end of file

types/Sonar/SonarRoute.ts

0 → 100644
+14 −0
Original line number Diff line number Diff line 
enum SonarRoute {

    SET_PAT               = '/api/alm_integrations/set_pat',

    PROJECT_CREATE_GITLAB = '/api/alm_integrations/import_gitlab_project',

    PROJECT_ADD_GATE      = '/api/qualitygates/select',

    PROJECT_ADD_PROFILE   = '/api/qualityprofiles/add_project',

    PROJECT_ADD_USER      = '/api/permissions/add_user',

    PROJECT_DELETE        = '/api/projects/delete',

    GET_LANGUAGES         = '/api/languages/list',

    TEST_GATE             = '/api/qualitygates/show',

    TEST_PROFILE          = '/api/qualityprofiles/search',

    SEARCH_USER           = '/api/users/search'

}



export default SonarRoute;
 
 No newline at end of file