track-cli 3.0.0-rc

package/esm/src/shared/mod.js

@@ -0,0 +1,383 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { load as loadConfig, save as saveConfig, webUrl, } from "./config.js";
+import { BadTarballURL, ChallengeAlreadyFinished, ExamCanceled, ExamExpired, ExamSubmitted, ExamUnread, OtherError, } from "./errors.js";
+import { getUniqueDirName, toNativeStyle, untgz } from "./file.js";
+import { TrackClient } from "../track/client.js";
+import { ApplicantExamStatus, ChallengeResultStatus, ChallengeStyle, FileListType, } from "../track/types.js";
+import * as datetime from "../../deps/deno.land/std@0.195.0/datetime/mod.js";
+import * as colors from "../../deps/deno.land/std@0.195.0/fmt/colors.js";
+import { format as duration } from "../../deps/deno.land/std@0.195.0/fmt/duration.js";
+import * as fs from "../../deps/deno.land/std@0.195.0/fs/mod.js";
+export const _internals = {
+    prompt: dntShim.prompt,
+};
+export const HttpStatus = {
+    OK: 200,
+    Unauthorized: 401,
+    isSuccess(r) {
+        const status = typeof r === "number" ? r : r.status;
+        return 300 > status && status >= 200;
+    },
+    isClientError(r) {
+        const status = typeof r === "number" ? r : r.status;
+        return 500 > status && status >= 400;
+    },
+    isServerError(r) {
+        const status = typeof r === "number" ? r : r.status;
+        return 600 > status && status >= 500;
+    },
+};
+export const Prompt = {
+    select(message, items) {
+        const maxDigits = items.length.toString().length;
+        // Writes lines like this, with padding:
+        // [ 1] C++
+        // [..] ...
+        // [45] Golang
+        const list = items
+            .map((item, i) => `[${((i + 1) + "").padStart(maxDigits, " ")}] ${item}`)
+            .join("\n");
+        const answerStr = _internals.prompt(`${message}\n${list}\n> `);
+        if (!answerStr) {
+            return;
+        }
+        const answer = parseInt(answerStr);
+        if (answer > 0 && answer <= items.length) {
+            return answer - 1;
+        }
+        else {
+            return;
+        }
+    },
+};
+export function printTimeLeft(timeLeftSeconds) {
+    const durationMessage = duration(timeLeftSeconds * 1000, { ignoreZero: true }) || "0s";
+    if (timeLeftSeconds > 300) {
+        console.log(`Time left: ${colors.yellow(durationMessage)}`);
+    }
+    else if (timeLeftSeconds >= 0) {
+        const isWindows = dntShim.Deno.build.os === "windows";
+        const warningSymbol = isWindows ? "!" : "⚠️";
+        console.log(`Time left: ${warningSymbol}    ${colors.red(durationMessage)}    ${warningSymbol}`);
+    }
+    else if (timeLeftSeconds === -1) {
+        console.log("The exam deadline has not yet been started");
+    }
+    else {
+        console.log("The exam deadline has passed");
+    }
+}
+export function ensureExamInProgress(applicantExam, webUrlRedirect) {
+    switch (applicantExam.status) {
+        case ApplicantExamStatus.Submitted:
+        case ApplicantExamStatus.Reviewed:
+            throw new ExamSubmitted();
+        case ApplicantExamStatus.Expired:
+            throw new ExamExpired();
+        case ApplicantExamStatus.Canceled:
+            throw new ExamCanceled();
+        case ApplicantExamStatus.Unread:
+            throw new ExamUnread(webUrlRedirect);
+        case ApplicantExamStatus.InProgress:
+            return;
+    }
+}
+export function getChallengeFromExamSession(examSession, challengeId) {
+    return examSession.challengesSets
+        .flatMap((s) => s.challenges)
+        .find((c) => c.id === challengeId &&
+        (c.style === ChallengeStyle.Development ||
+            c.style === ChallengeStyle.Algorithm));
+}
+export async function tryStartingChallenge(challenge, api, applicantExam, resultOpt) {
+    let result = resultOpt;
+    while (true) {
+        if (result) {
+            switch (result.status) {
+                case ChallengeResultStatus.Prepared:
+                case ChallengeResultStatus.CanRestart: {
+                    const timeMsg = typeof challenge.timeLimitMinutes === "number"
+                        ? `You have ${challenge.timeLimitMinutes} minutes to complete this challenge.`
+                        : `This challenge has no time limit.`;
+                    const wariningMsg = challenge.programmingLanguages.length === 0
+                        ? `The challenge will start after this point.\n${timeMsg}`
+                        : `The challenge will start after you select a programming language in the next step.\n${timeMsg}`;
+                    console.log(wariningMsg);
+                    const shouldContinue = dntShim.confirm("Do you want to continue? (y/n): ");
+                    if (!shouldContinue) {
+                        throw new OtherError("Aborted. Challenge was not started.");
+                    }
+                    if (challenge.programmingLanguages.length > 0) {
+                        const programmingLanguages = (await api.getProgrammingLanguages())
+                            .filter((pl) => challenge.programmingLanguages.includes(pl.value));
+                        const desiredLanguage = chooseProgrammingLanguage(programmingLanguages);
+                        if (desiredLanguage.value !== result.programmingLanguage) {
+                            await api.switchChallengeLanguage(applicantExam.id, result.id, desiredLanguage.value);
+                        }
+                    }
+                    result = await api.startChallenge(applicantExam.id, result.id);
+                    break;
+                }
+                case ChallengeResultStatus.Started:
+                    console.log("Challenge is started.");
+                    return result;
+                case ChallengeResultStatus.InProgress:
+                    console.log("Challenge is in progress!");
+                    return result;
+                case ChallengeResultStatus.Finished:
+                case ChallengeResultStatus.NotModified:
+                case ChallengeResultStatus.ScoringWaiting:
+                    throw new ChallengeAlreadyFinished();
+            }
+        }
+        else {
+            // Challenge hasn't been prepared yet
+            result = await api.prepareChallenge(applicantExam.id, challenge.id);
+        }
+    }
+}
+export function chooseProgrammingLanguage(languages) {
+    while (true) {
+        const desiredLanguageIndex = Prompt.select("Please select a programming language:", languages.map((l) => l.displayString));
+        if (desiredLanguageIndex !== undefined) {
+            return languages[desiredLanguageIndex];
+        }
+        else {
+            console.log("An invalid programming language was specified");
+        }
+    }
+}
+function filePaths(settings, fileListType) {
+    const files = [];
+    function addFiles(path, fileTree) {
+        for (const [name, entry] of Object.entries(fileTree)) {
+            const relativePath = path.length === 0 ? name : `${path}/${name}`;
+            if (typeof entry === "boolean") { // file
+                const editable = entry;
+                switch (fileListType) {
+                    case FileListType.All:
+                        files.push(relativePath);
+                        break;
+                    case FileListType.ReadOnlyChallengeFiles:
+                        if (!editable) {
+                            files.push(relativePath);
+                        }
+                        break;
+                    case FileListType.EditableChallengeFiles:
+                    case FileListType.Editable:
+                        if (editable) {
+                            files.push(relativePath);
+                        }
+                        break;
+                    case FileListType.UserAddedFiles:
+                        break;
+                }
+            }
+            else { // directory
+                addFiles(relativePath, entry);
+            }
+        }
+    }
+    addFiles("", settings.files);
+    return files;
+}
+export function listFileNames(context, fileListType) {
+    const allFiles = new Set(filePaths(context.settings, fileListType));
+    const addedFiles = context.answers.addedFiles;
+    switch (fileListType) {
+        case FileListType.All:
+        case FileListType.Editable:
+        case FileListType.UserAddedFiles:
+            addedFiles?.forEach((f) => allFiles.add(f));
+            break;
+    }
+    return Array.from(allFiles);
+}
+export const SnakeCase = {
+    to(obj) {
+        const type = typeof obj;
+        switch (type) {
+            case "string":
+                return obj.replace(/([A-Z])/g, "_$1").toLowerCase();
+            case "object": {
+                if (obj instanceof Array) {
+                    return obj;
+                }
+                else if (obj === null) {
+                    return obj;
+                }
+                const newObj = {};
+                for (const [key, value] of Object.entries(obj)) {
+                    newObj[this.to(key)] = typeof value === "string"
+                        ? value
+                        : this.to(value);
+                }
+                return newObj;
+            }
+            default:
+                return obj;
+        }
+    },
+    from(obj) {
+        const type = typeof obj;
+        switch (type) {
+            case "string":
+                return obj.replace(/(_\w)/g, (m) => m[1].toUpperCase());
+            case "object": {
+                if (obj instanceof Array) {
+                    return obj;
+                }
+                else if (obj === null) {
+                    return obj;
+                }
+                const newObj = {};
+                for (const [key, value] of Object.entries(obj)) {
+                    newObj[this.from(key)] = typeof value === "string"
+                        ? value
+                        : this.from(value);
+                }
+                return newObj;
+            }
+            default:
+                return obj;
+        }
+    },
+};
+export async function getCommonChallengeContext() {
+    const config = await loadConfig();
+    const api = TrackClient.fromTrackConfig(config);
+    const applicantExam = await api.getApplicantExamNoAuth(config.examToken);
+    ensureExamInProgress(applicantExam, webUrl(config));
+    const codingContext = await api.getChallengeCodingContext(config.applicantExamId, config.challengeResultId);
+    const examSession = await api.getExamSession(config.applicantExamId);
+    let result = getResultFromExamSession(examSession, config.challengeId);
+    if (!result) {
+        throw new OtherError(`Cchallenge result for challenge id ${config.challengeId} is missing - has the challenge been started yet?`);
+    }
+    const challenge = getChallengeFromExamSession(examSession, config.challengeId);
+    if (!challenge) {
+        throw new OtherError(`Challenge for challenge id ${config.challengeId} is missing - has the challenge been started yet?`);
+    }
+    switch (result.status) {
+        case ChallengeResultStatus.Finished:
+        case ChallengeResultStatus.NotModified:
+            throw new ChallengeAlreadyFinished();
+        case ChallengeResultStatus.CanRestart:
+            console.log("This challenge can be restarted");
+            console.log();
+            result = await tryStartingChallenge(challenge, api, applicantExam, result);
+            if (!result) {
+                throw new OtherError("Expected to have a challenge result after preparing and starting");
+            }
+            break;
+    }
+    const challengePosition = examSession
+        .challengesSets
+        .flatMap((s) => s.challenges)
+        .findIndex((c) => c.id === config.challengeId) +
+        1;
+    if (api.authCookieExpired()) {
+        config.cookies = api.getCookies();
+        await saveConfig(config);
+    }
+    return {
+        config,
+        api,
+        codingContext,
+        applicantExam,
+        challengeResult: result,
+        challenge,
+        challengePosition,
+    };
+}
+function getResultFromExamSession(examSession, challengeId) {
+    return examSession
+        .results
+        .find((cr) => cr.challengeId === challengeId);
+}
+export async function printChallengeInfo(trackContext) {
+    const { config, api, challengeResult: result } = trackContext;
+    const timeLeft = await api.timeLeft(config.applicantExamId, config.challengeResultId);
+    printWorkingFileSet(trackContext.codingContext);
+    console.log();
+    const lastScoredAt = result.lastScoredAt
+        ? ` (Ran at ${datetime.format(new Date(result.lastScoredAt), "yyyy-MM-dd HH:mm:ss")})`
+        : "";
+    const scoreRatio = (result.editorScore && trackContext.challenge.openTestcases)
+        ? `\t${result.editorScore}/${trackContext.challenge.openTestcases}`
+        : "\tN/A - Use 'track run' to save and run your submission";
+    console.log(`Latest score${lastScoredAt}`);
+    console.log(colors.green(scoreRatio));
+    console.log();
+    printTimeLeft(timeLeft);
+}
+export function printWorkingFileSet(codingContext) {
+    console.log("Extra files included in your submission:");
+    const userAddedFiles = listFileNames(codingContext, FileListType.UserAddedFiles);
+    if (userAddedFiles.length > 0) {
+        console.log("  (use 'track rm <file>' to remove files from your submission)");
+        console.log();
+        userAddedFiles.sort();
+        userAddedFiles.forEach((f) => console.log(`\t${colors.green(toNativeStyle(f))}`));
+    }
+    else if (codingContext.settings.allowNewFile) {
+        console.log();
+        console.log("\tNo files currently added, use 'track add <file>' to add your own files to your submission");
+        console.log();
+    }
+    else {
+        console.log();
+        console.log("\tThis challenge does not support adding new files");
+        console.log();
+    }
+}
+export async function downloadChallengeFilesTo(codingContext, dest, api, applicantExamId, challengeResultId, showFileDiff, includeTarball) {
+    if (includeTarball) {
+        console.log("Fetching challenge tarball...");
+        const tarballResp = await dntShim.fetch(codingContext.tarballUrl);
+        if (!HttpStatus.isSuccess(tarballResp.status)) {
+            const statusReason = `${tarballResp.status} - ${tarballResp.statusText}`;
+            throw new BadTarballURL(codingContext.tarballUrl, statusReason);
+        }
+        untgz(new Uint8Array(await (await tarballResp.blob()).arrayBuffer()), dest);
+    }
+    console.log("Downloading editable files");
+    const filesToDownload = listFileNames(codingContext, FileListType.Editable);
+    const presignedUrls = Object.entries(await api.getPresignedUrls(applicantExamId, challengeResultId, filesToDownload))
+        .map(([file, url]) => ({ file, url }));
+    presignedUrls.sort((a, b) => a.file.localeCompare(b.file));
+    const promises = presignedUrls.map(async ({ file, url }) => {
+        const fileResp = await dntShim.fetch(url);
+        const fileBody = new Uint8Array(await fileResp.arrayBuffer());
+        const filePath = `${dest}/${file}`;
+        if (!showFileDiff || !await fs.exists(file)) {
+            await fs.ensureFile(filePath);
+            await dntShim.Deno.writeFile(filePath, fileBody);
+        }
+        else {
+            // TODO
+        }
+    });
+    await Promise.all(promises);
+}
+export /**
+ * Archives all files in a challenge directory into a subdirectory of
+ * the challenge directory. Ignores .track/ and other existing archival directories
+ */ async function archiveExistingChallengeFiles(orgName, challengePosition, options) {
+    const challengeDir = options?.challengeDir ?? dntShim.Deno.cwd();
+    const langString = options?.selectedLanguage?.displayString ?? "";
+    const archivePath = await getUniqueDirName(`${orgName}_challenge_${challengePosition}_old_${langString}`, { root: challengeDir });
+    console.log(`Your old challenge contents will be archived in ${archivePath}`);
+    await fs.ensureDir(archivePath);
+    // Match directories with names like 'ORGNAME_challenge_12_Go_1'
+    const oldArchivePattern = /.*_challenge_\d+_.+_\d+/;
+    // Move all files and directories in the challenge dir into the archive path
+    // Do not copy the track config folder, the archive path, or old archive paths
+    for await (const dirEntry of dntShim.Deno.readDir(challengeDir)) {
+        if (dirEntry.name === archivePath || dirEntry.name === ".track" ||
+            (dirEntry.isDirectory && oldArchivePattern.test(dirEntry.name))) {
+            continue;
+        }
+        await fs.move(`${challengeDir}/${dirEntry.name}`, `${archivePath}/${dirEntry.name}`);
+    }
+}

package/esm/src/shared/types.d.ts

@@ -0,0 +1,12 @@
+import { TrackConfig } from "./config.js";
+import { TrackClient } from "../track/client.js";
+import { ApplicantExamForNoAuth, ChallengeResult, CodingContext, ExamSessionChallenge } from "../track/types.js";
+export interface TrackCLIContext {
+    config: TrackConfig;
+    api: TrackClient;
+    codingContext: CodingContext;
+    applicantExam: ApplicantExamForNoAuth;
+    challengeResult: ChallengeResult;
+    challenge: ExamSessionChallenge;
+    challengePosition: number;
+}

package/esm/src/shared/types.js

@@ -0,0 +1 @@
+export {};

package/esm/src/track/client.d.ts

@@ -0,0 +1,60 @@
+import { TrackConfig } from "../shared/config.js";
+import { ApplicantExamForNoAuth, ChallengeResult, CodingContext, ExamSession, ProgrammingLanguage, ProgrammingLanguageInfo, SaveFilesRequest } from "./types.js";
+export interface BasicAuth {
+    username: string;
+    password?: string;
+}
+export interface AuthData {
+    examToken: string;
+    orgName: string;
+}
+export interface ApiResponse<T> {
+    code: number;
+    message?: string[];
+    result?: T;
+}
+export declare const FormType: {
+    URLEncoded: string;
+    JSON: string;
+};
+export type FormType = typeof FormType[keyof typeof FormType];
+export declare class TrackClient {
+    private baseUrl;
+    private headers;
+    private cookies;
+    private authData?;
+    private cookieExpired;
+    private agent;
+    constructor(scheme: string, hostname: string, basic?: BasicAuth, authData?: AuthData);
+    getCookies(): {
+        [name: string]: string;
+    };
+    authCookieExpired(): boolean;
+    static fromTrackConfig(config: TrackConfig): TrackClient;
+    authenticate(): Promise<void>;
+    private _get;
+    private _post;
+    private _put;
+    private _result;
+    getApplicantExamNoAuth(token: string): Promise<ApplicantExamForNoAuth>;
+    getExamSession(applicantExamId: number): Promise<ExamSession>;
+    getProgrammingLanguages(): Promise<ProgrammingLanguageInfo[]>;
+    findProgrammingLanguage(programmingLanguage: ProgrammingLanguage): Promise<ProgrammingLanguageInfo | undefined>;
+    switchChallengeLanguage(applicantExamId: number, resultId: number, language: ProgrammingLanguage): Promise<ChallengeResult>;
+    startChallenge(applicantExamId: number, resultId: number): Promise<ChallengeResult>;
+    prepareChallenge(applicantExamId: number, challengeId: number): Promise<ChallengeResult>;
+    timeLeft(applicantExamId: number, resultId: number): Promise<number>;
+    getChallengeCodingContext(applicantExamId: number, resultId: number): Promise<CodingContext>;
+    getPresignedUrls(applicantExamId: number, resultId: number, files: string[]): Promise<{
+        [name: string]: string;
+    }>;
+    orcaToken(url: string): Promise<string>;
+    /**
+     * Temporary code to retrieve the Orca host.
+     * Will be able to get from CodingContext in the future.
+     */
+    orcaHost(): Promise<string>;
+    saveFiles(applicantExamId: number, resultId: number, saveFilesRequest: SaveFilesRequest): Promise<ChallengeResult>;
+    updateEditorScore(applicantExamId: number, resultId: number, editorScore: number): Promise<ChallengeResult>;
+    reset(applicantExamId: number, resultId: number): Promise<ChallengeResult>;
+}