@testgorilla/tgo-coding-test 0.0.1 → 1.0.0

package/esm2022/lib/services/candidate-coding-test-services/coding-test.service.mjs

@@ -0,0 +1,490 @@
+import { Injectable, signal } from '@angular/core';
+import { translate } from '@ngneat/transloco';
+import { ConfirmDialogComponent, DialogService, SnackbarService, } from '@testgorilla/tgo-ui';
+import { MixpanelService, } from '../../../shared/index.mjs';
+import { LibCodingTestService } from '../lib-coding-test.service';
+import { BehaviorSubject, Subject, filter, of, takeUntil, throwError, } from 'rxjs';
+import { catchError, map, switchMap, take, tap } from 'rxjs/operators';
+import { TIMEOUT_SIGNAL, } from '../../models/coderunner-execution-results';
+import { ROOT_TRANSLATIONS_SCOPE } from '../../models/translations';
+import { CoderunnerApiService } from './coderunner-api.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./coderunner-api.service";
+import * as i2 from "../lib-coding-test.service";
+import * as i3 from "../../../shared/index.mjs";
+import * as i4 from "@testgorilla/tgo-ui";
+export class CodingTestService {
+    coderunnerApiService;
+    libCodingTestService;
+    mixpanel;
+    snackBar;
+    dialog;
+    translationContext = `${ROOT_TRANSLATIONS_SCOPE}.CODING_LIB.`;
+    codingTestResults = {
+        listResponse: [],
+        resume: {
+            ok: 0,
+            error: 0,
+            total: 0,
+        },
+    };
+    currentLanguage;
+    codingTestResutsSubj$ = new BehaviorSubject(this.codingTestResults);
+    codingTestResults$ = this.codingTestResutsSubj$.asObservable();
+    isTestResultsLoading = signal(false);
+    unsubscribe$ = new Subject();
+    sqlTestCases;
+    isSQLTest = false;
+    constructor(coderunnerApiService, libCodingTestService, mixpanel, snackBar, dialog) {
+        this.coderunnerApiService = coderunnerApiService;
+        this.libCodingTestService = libCodingTestService;
+        this.mixpanel = mixpanel;
+        this.snackBar = snackBar;
+        this.dialog = dialog;
+    }
+    getBaseExampleTestCase = (id, index) => ({
+        id: id ?? 0,
+        name: `Example ${index + 1}`,
+        preloaded: true,
+    });
+    transformToExampleLATtestCase = (testcase, index) => ({
+        ...this.getBaseExampleTestCase(testcase.id, index),
+        expectedOutput: testcase.solution ?? '',
+        input: testcase.input,
+    });
+    transformToExampleSQLTestCase = (testcase, index) => ({
+        ...this.getBaseExampleTestCase(testcase.id, index),
+        expectedOutput: testcase.result ?? '',
+    });
+    setSqlTestCases(sqlTestCases) {
+        this.sqlTestCases = sqlTestCases;
+    }
+    getSqlTestCases() {
+        return this.sqlTestCases;
+    }
+    handleResetCodeModal(applicationTheme, companyColor) {
+        const modalTranslationContext = `${ROOT_TRANSLATIONS_SCOPE}.MODALS.RESET_CODE.`;
+        const modalData = {
+            confirmButtonText: translate(`${modalTranslationContext}SUBMIT`),
+            title: translate(`${modalTranslationContext}TITLE`),
+            message: translate(`${modalTranslationContext}MESSAGE`),
+            color: companyColor,
+        };
+        const dialogRef = this.dialog.open(ConfirmDialogComponent, {
+            applicationTheme,
+            size: 'small',
+            extraData: modalData,
+        });
+        dialogRef
+            .afterClosed()
+            .pipe(filter(Boolean), take(1))
+            .subscribe(() => {
+            this.libCodingTestService.confirmReset();
+        });
+    }
+    listenDeleteCustomTestCases() {
+        return this.libCodingTestService.testCaseDeletion$.pipe(filter(({ action }) => action === "try" /* TestCaseDeletionAction.Try */));
+    }
+    handleDeleteTestCaseModal(index, applicationTheme, companyColor) {
+        const deleteTestCaseTranslationContext = `${ROOT_TRANSLATIONS_SCOPE}.MODALS.DELETE_TEST_CASE.`;
+        const modalData = {
+            title: translate(`${deleteTestCaseTranslationContext}TITLE`),
+            message: translate(`${deleteTestCaseTranslationContext}MESSAGE`),
+            confirmButtonText: translate(`${deleteTestCaseTranslationContext}SUBMIT`),
+            color: companyColor,
+        };
+        const dialogRef = this.dialog.open(ConfirmDialogComponent, {
+            applicationTheme,
+            size: 'small',
+            extraData: modalData,
+        });
+        dialogRef
+            .afterClosed()
+            .pipe(filter(Boolean), take(1))
+            .subscribe(() => {
+            this.libCodingTestService.confirmTestCaseDeletion(index);
+        });
+    }
+    handleLanguageChangeModal(questionResultId, selectedLanguage, applicationTheme = 'light', companyColor) {
+        const modalLangChangeTranslationContext = `${ROOT_TRANSLATIONS_SCOPE}.MODALS.LANGUAGE_CHANGE.`;
+        const modalData = {
+            confirmButtonText: translate(`${modalLangChangeTranslationContext}SUBMIT`),
+            title: translate(`${modalLangChangeTranslationContext}TITLE`),
+            message: translate(`${modalLangChangeTranslationContext}MESSAGE`),
+            ...(companyColor && { color: companyColor }),
+        };
+        const dialogRef = this.dialog.open(ConfirmDialogComponent, {
+            applicationTheme,
+            size: 'small',
+            extraData: modalData,
+        });
+        dialogRef
+            .afterClosed()
+            .pipe(take(1))
+            .subscribe((result) => {
+            if (result) {
+                this.libCodingTestService.confirmLanguageChange();
+                if (selectedLanguage) {
+                    this.setCurrentLanguageLAT(selectedLanguage);
+                    this.sendLanguageChangeEvent$(questionResultId);
+                }
+            }
+            else {
+                this.libCodingTestService.cancelLanguageChange();
+            }
+        });
+    }
+    setCurrentLanguageLAT(language) {
+        this.currentLanguage = language;
+    }
+    listenCodingTestChanges() {
+        return this.libCodingTestService.codeReset$.pipe(filter((val) => val === "try" /* ResetCodeAction.Try */));
+    }
+    runTest(resultId, code, isLAT = true, isSQL = false, 
+    // todo: remove from everywhere or comment temporarily?
+    publicPreview = false, preview = false, id = 0, testResultId = 0, testData) {
+        this.preRunTests();
+        if (isSQL) {
+            this.getSQLrequest(resultId, testResultId, code, id, publicPreview, preview);
+        }
+        else if (isLAT) {
+            const testCases = this.libCodingTestService.getValidTestCases();
+            const testCasesFormatted = testCases.map((testCase) => ({
+                input: testCase.input,
+                solution: testCase.expectedOutput,
+            }));
+            this.libCodingTestService.currentLanguage$
+                .pipe(take(1))
+                .subscribe((language) => {
+                const runReq$ = this.getLATrequest(id, resultId, testResultId, code, testCasesFormatted, language, publicPreview, preview);
+                this.runLAT(runReq$, publicPreview, preview, testData || {}, testCases, code, resultId);
+            });
+        }
+    }
+    sendCopypasteEvent$(code, copiedText, questionResultId) {
+        const event = this.getBaseEvent({
+            code,
+            event_type: 'COPYPASTE',
+            extra_payload: copiedText,
+            question_result_id: questionResultId,
+        });
+        return this.coderunnerApiService.sendCodeEvent$(event);
+    }
+    sendAutosaveEvent$(code, questionResultId) {
+        const event = this.getBaseEvent({
+            code,
+            event_type: 'AUTOSAVE',
+            question_result_id: questionResultId,
+        });
+        return this.coderunnerApiService
+            .sendCodeEvent$(event)
+            .pipe(catchError((err) => of(err)));
+    }
+    sendLanguageChangeEvent$(questionResultId) {
+        const event = this.getBaseEvent({
+            event_type: 'SWITCH',
+            question_result_id: questionResultId,
+        });
+        this.coderunnerApiService.sendCodeEvent$(event).pipe(take(1)).subscribe();
+    }
+    getBaseEvent(event) {
+        let language = '';
+        if (this.isSQLTest) {
+            language = "sqlite3-3.36.0" /* ProgrammingLanguageVersioned.SQLite */;
+        }
+        else {
+            const { name, version } = this.currentLanguage;
+            language = `${name}-${version}`;
+        }
+        const baseEvent = {
+            code: '',
+            extra_payload: '',
+            attempt_id: null,
+            language,
+        };
+        return { ...baseEvent, ...event };
+    }
+    sendCodeEvent$(attemptId, questionResultId, code) {
+        const event = this.getBaseEvent({
+            code,
+            attempt_id: attemptId,
+            event_type: 'ATTEMPT',
+            question_result_id: questionResultId,
+        });
+        return this.coderunnerApiService.sendCodeEvent$(event);
+    }
+    countTestResults(executions) {
+        if (executions) {
+            return executions.reduce((acc, response) => {
+                if (response.evaluation.testcase) {
+                    acc.passed++;
+                }
+                else {
+                    acc.error++;
+                }
+                acc.total++;
+                return acc;
+            }, { passed: 0, error: 0, total: 0 });
+        }
+        return { passed: 0, error: 0, total: 0 };
+    }
+    handleTestCasesResult(testCasesResultObject) {
+        this.codingTestResults = testCasesResultObject;
+        this.publishTestResults();
+        this.isTestResultsLoading.set(false);
+    }
+    getSQLrequest(resultId, testResultId, code, id, publicPreview, preview) {
+        const testCases = this.getSqlTestCases();
+        let runReq$;
+        if (publicPreview) {
+            runReq$ = this.coderunnerApiService.runPublicTest$(code, testCases, "sqlite3-3.36.0" /* ProgrammingLanguageVersioned.SQLite */);
+        }
+        else if (preview) {
+            runReq$ = this.coderunnerApiService.runPreviewTest$(testResultId, code, testCases, "sqlite3-3.36.0" /* ProgrammingLanguageVersioned.SQLite */);
+        }
+        else {
+            runReq$ = this.coderunnerApiService.runNonPreviewTest$(id, resultId, code, testCases, "sqlite3-3.36.0" /* ProgrammingLanguageVersioned.SQLite */);
+        }
+        this.runSql(runReq$, testCases, resultId, !publicPreview && !preview, code);
+    }
+    runSql(runReq$, testCases, questionResultId, isActualQuestion, code) {
+        let attemptId = '';
+        runReq$
+            .pipe(catchError((err) => {
+            this.finalizeReq(err);
+            return throwError(() => err);
+        }), tap((res) => this.finalizeReq(res)), tap(({ id }) => (attemptId = id ?? '')), switchMap((responseArray) => of(responseArray.executions).pipe(map((executions) => this.countTestResults(executions)), map((countResult) => {
+            const sqlExecutedSuccessfullyCopy = translate(`${this.translationContext}TEST_RESULTS.TEST_CASES.SQL_EXECUTED_SUCCESSFULLY`);
+            const noOutputCopies = this.getNoOutputCopies();
+            return {
+                resume: {
+                    ok: countResult.passed,
+                    error: countResult.error,
+                    total: countResult.total,
+                },
+                listResponse: responseArray.executions?.map(({ run, evaluation }) => ({
+                    actualOutput: run.stdout
+                        ? run.stdout
+                        : run.stderr || run.signal === TIMEOUT_SIGNAL
+                            ? noOutputCopies['noResponse']
+                            : noOutputCopies['noOutput'],
+                    logs: this.getCoderunnerLogs(run, TIMEOUT_SIGNAL, noOutputCopies['timeoutError'], sqlExecutedSuccessfullyCopy),
+                    status: evaluation.testcase ? 'passed' : 'error',
+                })),
+            };
+        }), tap((testCasesResultObject) => this.handleTestCasesResult(testCasesResultObject)))), switchMap(() => this.getSendCodeEventStream$(isActualQuestion, attemptId, questionResultId, code)))
+            .subscribe();
+    }
+    getLATrequest(id, resultId, testResultId, code, testCasesFormatted, language, publicPreview, preview) {
+        if (publicPreview) {
+            return this.coderunnerApiService.runPublicTest$(code, testCasesFormatted, `${language}-${this.libCodingTestService.getVersion()}`);
+        }
+        else if (preview) {
+            return this.coderunnerApiService.runPreviewTest$(testResultId, code, testCasesFormatted, `${language}-${this.libCodingTestService.getVersion()}`);
+        }
+        else {
+            return this.coderunnerApiService.runNonPreviewTest$(id, resultId, code, testCasesFormatted, `${language}-${this.libCodingTestService.getVersion()}`);
+        }
+    }
+    setIsSQLTest(isSQL) {
+        this.isSQLTest = isSQL;
+    }
+    runLAT(runCodeRequest$, isPublicPreviewLAT, isPractice = false, testData, testCases, code, questionResultId) {
+        const pistonRegex = /\/piston\/[^/ ]+(\/[^/ ]+)*/g;
+        const reqStartTime = performance.now();
+        let reqEndTime;
+        let attemptId = '';
+        runCodeRequest$
+            .pipe(catchError((err) => {
+            this.finalizeReq(err);
+            return throwError(() => err);
+        }), tap((res) => this.finalizeReq(res)), tap(() => (reqEndTime = performance.now())), tap(({ id }) => (attemptId = id ?? '')), switchMap((responseArray) => of(responseArray.executions).pipe(map((executions) => (executions ? executions : [])), map((executions) => executions.map((x) => {
+            if (x.run.stderr) {
+                x.run.stderr = x.run.stderr.replace(pistonRegex, '');
+            }
+            if (x.run.stdout) {
+                x.run.stdout = x.run.stdout.replace(pistonRegex, '');
+            }
+            return x;
+        })), map((executions) => this.countTestResults(executions)), map((countResult) => {
+            if (!isPublicPreviewLAT) {
+                const responseTime = Math.round(reqEndTime - reqStartTime);
+                this.trackTestcasesRun(testData, countResult, responseArray.executions || [], responseTime, testCases);
+            }
+            const noOutputCopies = this.getNoOutputCopies();
+            const executedSuccessfullyCopy = translate(`${this.translationContext}TEST_RESULTS.TEST_CASES.EXECUTED_SUCCESSFULLY`);
+            return {
+                resume: {
+                    ok: countResult.passed,
+                    error: countResult.error,
+                    total: countResult.total,
+                },
+                listResponse: responseArray.executions?.map(({ run, evaluation, compile, }) => ({
+                    actualOutput: run.stdout
+                        ? run.stdout
+                        : run.stderr || run.signal === TIMEOUT_SIGNAL
+                            ? noOutputCopies['noResponse']
+                            : noOutputCopies['noOutput'],
+                    logs: this.getCoderunnerLogs(run, TIMEOUT_SIGNAL, noOutputCopies['timeoutError'], executedSuccessfullyCopy, compile),
+                    status: evaluation.testcase ? 'passed' : 'error',
+                })),
+            };
+        }), tap((testCasesResultObject) => this.handleTestCasesResult(testCasesResultObject)))), switchMap(() => this.getSendCodeEventStream$(!isPractice && !isPublicPreviewLAT, attemptId, questionResultId, code)))
+            .subscribe();
+    }
+    finalizeReq(err) {
+        this.isTestResultsLoading.set(false);
+        if (err.detail) {
+            this.snackBar.error(err.detail);
+        }
+    }
+    getNoOutputCopies() {
+        return {
+            noResponse: translate(`${this.translationContext}TEST_RESULTS.TEST_CASES.NO_RESPONSE`),
+            noOutput: translate(`${this.translationContext}TEST_RESULTS.TEST_CASES.NONE`),
+            timeoutError: translate(`${this.translationContext}TEST_RESULTS.TEST_CASES.TIMEOUT_ERROR`),
+        };
+    }
+    getSendCodeEventStream$(isActualQuestion, attemptId, questionResultId, code) {
+        if (isActualQuestion) {
+            return this.sendCodeEvent$(attemptId, questionResultId, code);
+        }
+        else {
+            return of({});
+        }
+    }
+    // todo: check if we need this anymore due to MFE providers specificity
+    unsubscribeAll() {
+        this.unsubscribe$.next();
+        this.unsubscribe$.complete();
+    }
+    resetRunTestSummary() {
+        this.codingTestResults = {
+            listResponse: [],
+            resume: {
+                ok: 0,
+                error: 0,
+                total: 0,
+            },
+        };
+        this.publishTestResults();
+    }
+    trackConfigChanged(isPracticeQuestion = false) {
+        this.libCodingTestService.configFieldChanged$
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((config) => {
+            const { settingInstance, changedKey, newValueString } = this.getMixpanelSettingsData(isPracticeQuestion, config);
+            this.mixpanel.track("Changed Coderunner setting" /* MixpanelEvents.ChangedSettings */, {
+                coderunner_setting: changedKey,
+                coderunner_setting_new_value: newValueString,
+                coderunner_setting_instance: settingInstance,
+            });
+        });
+    }
+    getCoderunnerLogs(run, TIMEOUT_SIGNAL, timeoutErrorCopy, executedSuccessfullyCopy, compile, isSQL) {
+        if (isSQL) {
+            return run?.stderr === TIMEOUT_SIGNAL
+                ? run.stderr
+                : executedSuccessfullyCopy;
+        }
+        else if (run?.stderr) {
+            return run.stderr === compile?.stderr
+                ? run.stderr
+                : `${run.stderr}\n${compile?.stderr || ''}`;
+        }
+        else if (run.signal === TIMEOUT_SIGNAL) {
+            return timeoutErrorCopy;
+        }
+        return executedSuccessfullyCopy;
+    }
+    trackTestcasesRun(testData, countResult, testCasesExecutions, responseTime, testCases) {
+        const { instance, customPassed, customFailed, examplePassed, exampleFailed, customEmpty, testUuid, testName, } = this.getMixpanelTestCasesData(testData, countResult, testCasesExecutions, testCases);
+        this.mixpanel.track('Candidate ran tests in Coderunner', {
+            coding_test_uuid: testUuid,
+            coding_test_name: testName,
+            coderunner_test_instance: instance,
+            custom_testcases_passed: customPassed,
+            custom_testcases_failed: customFailed,
+            custom_testcases_empty: customEmpty,
+            example_testcases_passed: examplePassed,
+            example_testcases_failed: exampleFailed,
+            coderunner_response_time: responseTime,
+        });
+    }
+    preRunTests() {
+        this.isTestResultsLoading.set(true);
+        this.resetRunTestSummary();
+    }
+    getMixpanelTestCasesData(testData, { total }, testCasesExecutions, validTestCases) {
+        const allTestCasesCount = this.libCodingTestService.getTestCasesCount();
+        const customEmpty = allTestCasesCount - total || 0;
+        const instance = this.getMixpanelInstanceValue(!!testData.is_preview_mode);
+        const { uuid: testUuid } = testData;
+        const { name: testName } = testData.test ?? { name: '' };
+        const mixpanelResults = this.getGroupedTestCaseResult(testCasesExecutions, validTestCases);
+        return {
+            testUuid: testUuid?.replace(/-/g, ''),
+            testName,
+            instance,
+            customEmpty,
+            customPassed: mixpanelResults.custom.passed,
+            customFailed: mixpanelResults.custom.failed,
+            examplePassed: mixpanelResults.example.passed,
+            exampleFailed: mixpanelResults.example.failed,
+        };
+    }
+    getGroupedTestCaseResult(testCasesExecutions, validTestCases) {
+        const groupedResult = {
+            custom: {
+                failed: 0,
+                passed: 0,
+            },
+            example: {
+                failed: 0,
+                passed: 0,
+            },
+        };
+        testCasesExecutions.forEach(({ input: resultInput, evaluation }) => {
+            const localTestCase = validTestCases.find(({ input }) => resultInput === input);
+            const mixpanelResultBody = localTestCase?.preloaded
+                ? groupedResult.example
+                : groupedResult.custom;
+            if (evaluation?.testcase) {
+                mixpanelResultBody.passed++;
+            }
+            else {
+                mixpanelResultBody.failed++;
+            }
+        });
+        return groupedResult;
+    }
+    getMixpanelSettingsData(isPracticeQuestion, config) {
+        const settingInstance = this.getMixpanelInstanceValue(isPracticeQuestion);
+        const changedKey = Object.keys(config)[0];
+        const THEME_IDENTIFIER = 'theme-';
+        let changedValue = config[changedKey];
+        let newValueString;
+        if (typeof changedValue === 'boolean') {
+            newValueString = changedValue ? 'ON' : 'OFF';
+        }
+        else {
+            changedValue = String(changedValue);
+            newValueString = changedValue.includes(THEME_IDENTIFIER)
+                ? changedValue.replace(THEME_IDENTIFIER, '')
+                : changedValue;
+        }
+        return { settingInstance, changedKey, newValueString };
+    }
+    getMixpanelInstanceValue(isPracticeQuestion) {
+        return isPracticeQuestion ? 'practice question' : 'real test';
+    }
+    publishTestResults() {
+        this.codingTestResutsSubj$.next({ ...this.codingTestResults });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CodingTestService, deps: [{ token: i1.CoderunnerApiService }, { token: i2.LibCodingTestService }, { token: i3.MixpanelService }, { token: i4.SnackbarService }, { token: i4.DialogService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CodingTestService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CodingTestService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.CoderunnerApiService }, { type: i2.LibCodingTestService }, { type: i3.MixpanelService }, { type: i4.SnackbarService }, { type: i4.DialogService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"coding-test.service.js","sourceRoot":"","sources":["../../../../../../../packages/tgo-coding-test/src/lib/services/candidate-coding-test-services/coding-test.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, signal } from '@angular/core';\nimport { translate } from '@ngneat/transloco';\nimport {\n  ApplicationTheme,\n  ConfirmDialogComponent,\n  DialogService,\n  SnackbarService,\n} from '@testgorilla/tgo-ui';\nimport {\n  MixpanelService,\n  TestResultRead,\n} from '@testgorilla/tgo-test-shared';\nimport {\n  CustomTestCase,\n  ExampleTestCase,\n  TestCaseDeletionAction,\n  TestCaseDeletionData,\n} from '../../models/test-cases';\nimport { LibCodingTestService, ResetCodeAction } from '../lib-coding-test.service';\nimport { CodeEditorLanguages } from '../../components/code-editor/helpers/code-editor-helper.model';\nimport {\n  BehaviorSubject,\n  Observable,\n  Subject,\n  filter,\n  of,\n  takeUntil,\n  throwError,\n} from 'rxjs';\nimport { catchError, map, switchMap, take, tap } from 'rxjs/operators';\nimport { CodeEvent, CodeEventResponse } from '../../models/code-event';\nimport {\n  CodeRunnerTestCaseExecutionOutputModel,\n  CoderunnerAttemptModel,\n  CoderunnerTestCaseExecutionModel,\n  CodingTestsResultsModel,\n  TIMEOUT_SIGNAL,\n} from '../../models/coderunner-execution-results';\nimport { MixpanelEvents } from '../../models/mixpanel-events';\nimport {\n  ProgrammingLanguage,\n  ProgrammingLanguageVersioned,\n} from '../../models/programming-language';\nimport {\n  GroupedTestCasesResult,\n  LATFormattedTestCases,\n  SqlTestCase,\n  Testcase,\n} from '../../models/test-cases';\nimport { ROOT_TRANSLATIONS_SCOPE } from '../../models/translations';\nimport { CoderunnerApiService } from './coderunner-api.service';\n\ninterface CustomError {\n  detail?: string;\n}\n\n@Injectable()\nexport class CodingTestService {\n  readonly translationContext = `${ROOT_TRANSLATIONS_SCOPE}.CODING_LIB.`;\n\n  private codingTestResults: CodingTestsResultsModel = {\n    listResponse: [],\n    resume: {\n      ok: 0,\n      error: 0,\n      total: 0,\n    },\n  };\n  private currentLanguage!: ProgrammingLanguage;\n  private codingTestResutsSubj$ = new BehaviorSubject(this.codingTestResults);\n  codingTestResults$ = this.codingTestResutsSubj$.asObservable();\n\n  isTestResultsLoading = signal<boolean>(false);\n\n  private unsubscribe$ = new Subject<void>();\n\n  private sqlTestCases!: SqlTestCase[];\n  private isSQLTest = false;\n\n  constructor(\n    private coderunnerApiService: CoderunnerApiService,\n    private libCodingTestService: LibCodingTestService,\n    private mixpanel: MixpanelService,\n    private snackBar: SnackbarService,\n    private dialog: DialogService\n  ) {}\n\n  private getBaseExampleTestCase = (id: number, index: number) => ({\n    id: id ?? 0,\n    name: `Example ${index + 1}`,\n    preloaded: true,\n  });\n\n  transformToExampleLATtestCase = (\n    testcase: Testcase,\n    index: number\n  ): ExampleTestCase => ({\n    ...this.getBaseExampleTestCase(testcase.id!, index),\n    expectedOutput: testcase.solution ?? '',\n    input: testcase.input,\n  });\n\n  transformToExampleSQLTestCase = (\n    testcase: SqlTestCase,\n    index: number\n  ): ExampleTestCase => ({\n    ...this.getBaseExampleTestCase(testcase.id!, index),\n    expectedOutput: testcase.result ?? '',\n  });\n\n  setSqlTestCases(sqlTestCases: SqlTestCase[]) {\n    this.sqlTestCases = sqlTestCases;\n  }\n\n  getSqlTestCases(): SqlTestCase[] {\n    return this.sqlTestCases;\n  }\n\n  handleResetCodeModal(applicationTheme: ApplicationTheme, companyColor: string): void {\n    const modalTranslationContext = `${ROOT_TRANSLATIONS_SCOPE}.MODALS.RESET_CODE.`;\n    const modalData = {\n      confirmButtonText: translate(`${modalTranslationContext}SUBMIT`),\n      title: translate(`${modalTranslationContext}TITLE`),\n      message: translate(`${modalTranslationContext}MESSAGE`),\n      color: companyColor,\n    };\n    const dialogRef = this.dialog.open(ConfirmDialogComponent, {\n      applicationTheme,\n      size: 'small',\n      extraData: modalData,\n    });\n\n    dialogRef\n      .afterClosed()\n      .pipe(filter(Boolean), take(1))\n      .subscribe(() => {\n        this.libCodingTestService.confirmReset();\n      });\n  }\n\n  listenDeleteCustomTestCases(): Observable<TestCaseDeletionData> {\n    return this.libCodingTestService.testCaseDeletion$.pipe(\n      filter(({ action }) => action === TestCaseDeletionAction.Try)\n    );\n  }\n\n  handleDeleteTestCaseModal(\n    index: number,\n    applicationTheme: ApplicationTheme,\n    companyColor: string\n  ): void {\n    const deleteTestCaseTranslationContext = `${ROOT_TRANSLATIONS_SCOPE}.MODALS.DELETE_TEST_CASE.`;\n    const modalData = {\n      title: translate(`${deleteTestCaseTranslationContext}TITLE`),\n      message: translate(`${deleteTestCaseTranslationContext}MESSAGE`),\n      confirmButtonText: translate(`${deleteTestCaseTranslationContext}SUBMIT`),\n      color: companyColor,\n    };\n    const dialogRef = this.dialog.open(ConfirmDialogComponent, {\n      applicationTheme,\n      size: 'small',\n      extraData: modalData,\n    });\n\n    dialogRef\n      .afterClosed()\n      .pipe(filter(Boolean), take(1))\n      .subscribe(() => {\n        this.libCodingTestService.confirmTestCaseDeletion(index);\n      });\n  }\n\n  handleLanguageChangeModal(\n    questionResultId: number,\n    selectedLanguage?: ProgrammingLanguage,\n    applicationTheme: ApplicationTheme = 'light',\n    companyColor?: string,\n  ): void {\n    const modalLangChangeTranslationContext = `${ROOT_TRANSLATIONS_SCOPE}.MODALS.LANGUAGE_CHANGE.`;\n    const modalData = {\n      confirmButtonText: translate(\n        `${modalLangChangeTranslationContext}SUBMIT`\n      ),\n      title: translate(`${modalLangChangeTranslationContext}TITLE`),\n      message: translate(`${modalLangChangeTranslationContext}MESSAGE`),\n      ...(companyColor && { color: companyColor }),\n    };\n\n    const dialogRef = this.dialog.open(ConfirmDialogComponent, {\n      applicationTheme,\n      size: 'small',\n      extraData: modalData,\n    });\n\n    dialogRef\n      .afterClosed()\n      .pipe(take(1))\n      .subscribe((result) => {\n        if (result) {\n          this.libCodingTestService.confirmLanguageChange();\n          if (selectedLanguage) {\n            this.setCurrentLanguageLAT(selectedLanguage);\n            this.sendLanguageChangeEvent$(questionResultId);\n          }\n        } else {\n          this.libCodingTestService.cancelLanguageChange();\n        }\n      });\n  }\n\n  setCurrentLanguageLAT(language: ProgrammingLanguage): void {\n    this.currentLanguage = language;\n  }\n\n  listenCodingTestChanges(): Observable<ResetCodeAction> {\n    return this.libCodingTestService.codeReset$.pipe(\n      filter((val) => val === ResetCodeAction.Try)\n    );\n  }\n\n  runTest(\n    resultId: number,\n    code: string,\n    isLAT = true,\n    isSQL = false,\n    // todo: remove from everywhere or comment temporarily?\n    publicPreview = false,\n    preview = false,\n    id = 0,\n    testResultId = 0,\n    testData?: TestResultRead\n  ): void {\n    this.preRunTests();\n    if (isSQL) {\n      this.getSQLrequest(\n        resultId,\n        testResultId,\n        code,\n        id,\n        publicPreview,\n        preview\n      );\n    } else if (isLAT) {\n      const testCases: (ExampleTestCase | CustomTestCase)[] =\n        this.libCodingTestService.getValidTestCases();\n      const testCasesFormatted = testCases.map((testCase) => ({\n        input: testCase.input,\n        solution: testCase.expectedOutput,\n      })) as LATFormattedTestCases[];\n      this.libCodingTestService.currentLanguage$\n        .pipe(take(1))\n        .subscribe((language) => {\n          const runReq$ = this.getLATrequest(\n            id,\n            resultId,\n            testResultId,\n            code,\n            testCasesFormatted as LATFormattedTestCases[],\n            language,\n            publicPreview,\n            preview\n          );\n          this.runLAT(\n            runReq$,\n            publicPreview,\n            preview,\n            testData || ({} as TestResultRead),\n            testCases,\n            code,\n            resultId\n          );\n        });\n    }\n  }\n\n  sendCopypasteEvent$(\n    code: string,\n    copiedText: string,\n    questionResultId: number\n  ): Observable<CodeEventResponse> {\n    const event: CodeEvent = this.getBaseEvent({\n      code,\n      event_type: 'COPYPASTE',\n      extra_payload: copiedText,\n      question_result_id: questionResultId,\n    });\n\n    return this.coderunnerApiService.sendCodeEvent$(event);\n  }\n\n  sendAutosaveEvent$(\n    code: string,\n    questionResultId: number\n  ): Observable<CodeEventResponse> {\n    const event: CodeEvent = this.getBaseEvent({\n      code,\n      event_type: 'AUTOSAVE',\n      question_result_id: questionResultId,\n    });\n\n    return this.coderunnerApiService\n      .sendCodeEvent$(event)\n      .pipe(catchError((err) => of(err)));\n  }\n\n  private sendLanguageChangeEvent$(questionResultId: number): void {\n    const event: CodeEvent = this.getBaseEvent({\n      event_type: 'SWITCH',\n      question_result_id: questionResultId,\n    });\n\n    this.coderunnerApiService.sendCodeEvent$(event).pipe(take(1)).subscribe();\n  }\n\n  private getBaseEvent(event: Partial<CodeEvent>): CodeEvent {\n    let language = '';\n\n    if (this.isSQLTest) {\n      language = ProgrammingLanguageVersioned.SQLite;\n    } else {\n      const { name, version } = this.currentLanguage;\n      language = `${name}-${version}`;\n    }\n\n    const baseEvent: Partial<CodeEvent> = {\n      code: '',\n      extra_payload: '',\n      attempt_id: null,\n      language,\n    };\n\n    return { ...baseEvent, ...event } as CodeEvent;\n  }\n\n  private sendCodeEvent$(\n    attemptId: string,\n    questionResultId: number,\n    code: string\n  ): Observable<CodeEventResponse> {\n    const event: CodeEvent = this.getBaseEvent({\n      code,\n      attempt_id: attemptId,\n      event_type: 'ATTEMPT',\n      question_result_id: questionResultId,\n    });\n\n    return this.coderunnerApiService.sendCodeEvent$(event);\n  }\n\n  private countTestResults(\n    executions: CoderunnerTestCaseExecutionModel[] | undefined\n  ): {\n    passed: number;\n    error: number;\n    total: number;\n  } {\n    if (executions) {\n      return executions.reduce(\n        (acc, response) => {\n          if (response.evaluation.testcase) {\n            acc.passed++;\n          } else {\n            acc.error++;\n          }\n          acc.total++;\n          return acc;\n        },\n        { passed: 0, error: 0, total: 0 }\n      );\n    }\n    return { passed: 0, error: 0, total: 0 };\n  }\n\n  private handleTestCasesResult(\n    testCasesResultObject: CodingTestsResultsModel\n  ): void {\n    this.codingTestResults = testCasesResultObject;\n    this.publishTestResults();\n    this.isTestResultsLoading.set(false);\n  }\n\n  private getSQLrequest(\n    resultId: number,\n    testResultId: number,\n    code: string,\n    id: number,\n    publicPreview: boolean,\n    preview: boolean\n  ): void {\n    const testCases: SqlTestCase[] = this.getSqlTestCases();\n    let runReq$: Observable<CoderunnerAttemptModel>;\n    if (publicPreview) {\n      runReq$ = this.coderunnerApiService.runPublicTest$(\n        code,\n        testCases,\n        ProgrammingLanguageVersioned.SQLite\n      );\n    } else if (preview) {\n      runReq$ = this.coderunnerApiService.runPreviewTest$(\n        testResultId,\n        code,\n        testCases,\n        ProgrammingLanguageVersioned.SQLite\n      );\n    } else {\n      runReq$ = this.coderunnerApiService.runNonPreviewTest$(\n        id,\n        resultId,\n        code,\n        testCases,\n        ProgrammingLanguageVersioned.SQLite\n      );\n    }\n    this.runSql(runReq$, testCases, resultId, !publicPreview && !preview, code);\n  }\n\n  private runSql(\n    runReq$: Observable<CoderunnerAttemptModel>,\n    testCases: SqlTestCase[],\n    questionResultId: number,\n    isActualQuestion: boolean,\n    code: string\n  ) {\n    let attemptId = '';\n\n    runReq$\n      .pipe(\n        catchError((err) => {\n          this.finalizeReq(err);\n          return throwError(() => err);\n        }),\n        tap((res) => this.finalizeReq(res as CustomError)),\n        tap(({ id }) => (attemptId = id ?? '')),\n        switchMap((responseArray: CoderunnerAttemptModel) =>\n          of(responseArray.executions).pipe(\n            map((executions) => this.countTestResults(executions)),\n            map((countResult) => {\n              const sqlExecutedSuccessfullyCopy = translate(\n                `${this.translationContext}TEST_RESULTS.TEST_CASES.SQL_EXECUTED_SUCCESSFULLY`\n              );\n              const noOutputCopies = this.getNoOutputCopies();\n\n              return {\n                resume: {\n                  ok: countResult.passed,\n                  error: countResult.error,\n                  total: countResult.total,\n                },\n                listResponse: responseArray.executions?.map(\n                  ({ run, evaluation }: CoderunnerTestCaseExecutionModel) => ({\n                    actualOutput: run.stdout\n                      ? run.stdout\n                      : run.stderr || run.signal === TIMEOUT_SIGNAL\n                      ? noOutputCopies['noResponse']\n                      : noOutputCopies['noOutput'],\n                    logs: this.getCoderunnerLogs(\n                      run,\n                      TIMEOUT_SIGNAL,\n                      noOutputCopies['timeoutError'],\n                      sqlExecutedSuccessfullyCopy\n                    ),\n                    status: evaluation.testcase ? 'passed' : 'error',\n                  })\n                ),\n              } as CodingTestsResultsModel;\n            }),\n            tap((testCasesResultObject) =>\n              this.handleTestCasesResult(testCasesResultObject)\n            )\n          )\n        ),\n        switchMap(() =>\n          this.getSendCodeEventStream$(\n            isActualQuestion,\n            attemptId,\n            questionResultId,\n            code\n          )\n        )\n      )\n      .subscribe();\n  }\n\n  private getLATrequest(\n    id: number,\n    resultId: number,\n    testResultId: number,\n    code: string,\n    testCasesFormatted: LATFormattedTestCases[],\n    language: CodeEditorLanguages,\n    publicPreview: boolean,\n    preview: boolean\n  ): Observable<CoderunnerAttemptModel> {\n    if (publicPreview) {\n      return this.coderunnerApiService.runPublicTest$(\n        code,\n        testCasesFormatted,\n        `${language}-${this.libCodingTestService.getVersion()}`\n      );\n    } else if (preview) {\n      return this.coderunnerApiService.runPreviewTest$(\n        testResultId,\n        code,\n        testCasesFormatted,\n        `${language}-${this.libCodingTestService.getVersion()}`\n      );\n    } else {\n      return this.coderunnerApiService.runNonPreviewTest$(\n        id,\n        resultId,\n        code,\n        testCasesFormatted,\n        `${language}-${this.libCodingTestService.getVersion()}`\n      );\n    }\n  }\n\n  setIsSQLTest(isSQL: boolean): void {\n    this.isSQLTest = isSQL;\n  }\n\n  private runLAT(\n    runCodeRequest$: Observable<CoderunnerAttemptModel>,\n    isPublicPreviewLAT: boolean,\n    isPractice = false,\n    testData: TestResultRead,\n    testCases: ExampleTestCase[] | CustomTestCase[],\n    code: string,\n    questionResultId: number\n  ): void {\n    const pistonRegex = /\\/piston\\/[^/ ]+(\\/[^/ ]+)*/g;\n    const reqStartTime = performance.now();\n    let reqEndTime: number;\n    let attemptId = '';\n\n    runCodeRequest$\n      .pipe(\n        catchError((err) => {\n          this.finalizeReq(err);\n          return throwError(() => err);\n        }),\n        tap((res) => this.finalizeReq(res as CustomError)),\n        tap(() => (reqEndTime = performance.now())),\n        tap(({ id }) => (attemptId = id ?? '')),\n        switchMap((responseArray: CoderunnerAttemptModel) =>\n          of(responseArray.executions).pipe(\n            map((executions) => (executions ? executions : [])),\n            map((executions: CoderunnerTestCaseExecutionModel[]) =>\n              executions.map((x) => {\n                if (x.run.stderr) {\n                  x.run.stderr = x.run.stderr.replace(pistonRegex, '');\n                }\n                if (x.run.stdout) {\n                  x.run.stdout = x.run.stdout.replace(pistonRegex, '');\n                }\n                return x;\n              })\n            ),\n            map((executions) => this.countTestResults(executions)),\n            map((countResult) => {\n              if (!isPublicPreviewLAT) {\n                const responseTime = Math.round(reqEndTime - reqStartTime);\n                this.trackTestcasesRun(\n                  testData,\n                  countResult,\n                  responseArray.executions || [],\n                  responseTime,\n                  testCases\n                );\n              }\n              const noOutputCopies = this.getNoOutputCopies();\n              const executedSuccessfullyCopy = translate(\n                `${this.translationContext}TEST_RESULTS.TEST_CASES.EXECUTED_SUCCESSFULLY`\n              );\n\n              return {\n                resume: {\n                  ok: countResult.passed,\n                  error: countResult.error,\n                  total: countResult.total,\n                },\n                listResponse: responseArray.executions?.map(\n                  ({\n                    run,\n                    evaluation,\n                    compile,\n                  }: CoderunnerTestCaseExecutionModel) => ({\n                    actualOutput: run.stdout\n                      ? run.stdout\n                      : run.stderr || run.signal === TIMEOUT_SIGNAL\n                      ? noOutputCopies['noResponse']\n                      : noOutputCopies['noOutput'],\n                    logs: this.getCoderunnerLogs(\n                      run,\n                      TIMEOUT_SIGNAL,\n                      noOutputCopies['timeoutError'],\n                      executedSuccessfullyCopy,\n                      compile\n                    ),\n                    status: evaluation.testcase ? 'passed' : 'error',\n                  })\n                ),\n              } as CodingTestsResultsModel;\n            }),\n            tap((testCasesResultObject) =>\n              this.handleTestCasesResult(testCasesResultObject)\n            )\n          )\n        ),\n        switchMap(() =>\n          this.getSendCodeEventStream$(\n            !isPractice && !isPublicPreviewLAT,\n            attemptId,\n            questionResultId,\n            code\n          )\n        )\n      )\n      .subscribe();\n  }\n\n  private finalizeReq(err: CustomError): void {\n    this.isTestResultsLoading.set(false);\n    if (err.detail) {\n      this.snackBar.error(err.detail);\n    }\n  }\n\n  private getNoOutputCopies(): { [key: string]: string } {\n    return {\n      noResponse: translate(\n        `${this.translationContext}TEST_RESULTS.TEST_CASES.NO_RESPONSE`\n      ),\n      noOutput: translate(\n        `${this.translationContext}TEST_RESULTS.TEST_CASES.NONE`\n      ),\n      timeoutError: translate(\n        `${this.translationContext}TEST_RESULTS.TEST_CASES.TIMEOUT_ERROR`\n      ),\n    };\n  }\n\n  private getSendCodeEventStream$(\n    isActualQuestion: boolean,\n    attemptId: string,\n    questionResultId: number,\n    code: string\n  ): Observable<CodeEventResponse> {\n    if (isActualQuestion) {\n      return this.sendCodeEvent$(attemptId, questionResultId, code);\n    } else {\n      return of({} as CodeEventResponse);\n    }\n  }\n\n  // todo: check if we need this anymore due to MFE providers specificity\n  unsubscribeAll(): void {\n    this.unsubscribe$.next();\n    this.unsubscribe$.complete();\n  }\n\n  resetRunTestSummary(): void {\n    this.codingTestResults = {\n      listResponse: [],\n      resume: {\n        ok: 0,\n        error: 0,\n        total: 0,\n      },\n    };\n\n    this.publishTestResults();\n  }\n\n  trackConfigChanged(isPracticeQuestion = false): void {\n    this.libCodingTestService.configFieldChanged$\n      .pipe(takeUntil(this.unsubscribe$))\n      .subscribe((config) => {\n        const { settingInstance, changedKey, newValueString } =\n          this.getMixpanelSettingsData(isPracticeQuestion, config);\n\n        this.mixpanel.track(MixpanelEvents.ChangedSettings, {\n          coderunner_setting: changedKey,\n          coderunner_setting_new_value: newValueString,\n          coderunner_setting_instance: settingInstance,\n        });\n      });\n  }\n\n  private getCoderunnerLogs(\n    run: CodeRunnerTestCaseExecutionOutputModel,\n    TIMEOUT_SIGNAL: string,\n    timeoutErrorCopy: string,\n    executedSuccessfullyCopy: string,\n    compile?: CodeRunnerTestCaseExecutionOutputModel,\n    isSQL?: boolean\n  ): string {\n    if (isSQL) {\n      return run?.stderr === TIMEOUT_SIGNAL\n        ? run.stderr\n        : executedSuccessfullyCopy;\n    } else if (run?.stderr) {\n      return run.stderr === compile?.stderr\n        ? run.stderr\n        : `${run.stderr}\\n${compile?.stderr || ''}`;\n    } else if (run.signal === TIMEOUT_SIGNAL) {\n      return timeoutErrorCopy;\n    }\n    return executedSuccessfullyCopy;\n  }\n\n  private trackTestcasesRun(\n    testData: TestResultRead,\n    countResult: { [key: string]: number },\n    testCasesExecutions: CoderunnerTestCaseExecutionModel[],\n    responseTime: number,\n    testCases: ExampleTestCase[] | CustomTestCase[]\n  ): void {\n    const {\n      instance,\n      customPassed,\n      customFailed,\n      examplePassed,\n      exampleFailed,\n      customEmpty,\n      testUuid,\n      testName,\n    } = this.getMixpanelTestCasesData(\n      testData,\n      countResult,\n      testCasesExecutions,\n      testCases\n    );\n\n    this.mixpanel.track('Candidate ran tests in Coderunner', {\n      coding_test_uuid: testUuid,\n      coding_test_name: testName,\n      coderunner_test_instance: instance,\n      custom_testcases_passed: customPassed,\n      custom_testcases_failed: customFailed,\n      custom_testcases_empty: customEmpty,\n      example_testcases_passed: examplePassed,\n      example_testcases_failed: exampleFailed,\n      coderunner_response_time: responseTime,\n    });\n  }\n\n  private preRunTests() {\n    this.isTestResultsLoading.set(true);\n    this.resetRunTestSummary();\n  }\n\n  private getMixpanelTestCasesData(\n    testData: TestResultRead,\n    { total }: { [key: string]: number },\n    testCasesExecutions: CoderunnerTestCaseExecutionModel[],\n    validTestCases: ExampleTestCase[] | CustomTestCase[]\n  ) {\n    const allTestCasesCount = this.libCodingTestService.getTestCasesCount();\n    const customEmpty = allTestCasesCount - total || 0;\n    const instance = this.getMixpanelInstanceValue(!!testData.is_preview_mode);\n    const { uuid: testUuid } = testData;\n    const { name: testName } = testData.test ?? { name: '' };\n    const mixpanelResults = this.getGroupedTestCaseResult(\n      testCasesExecutions,\n      validTestCases\n    );\n\n    return {\n      testUuid: testUuid?.replace(/-/g, ''),\n      testName,\n      instance,\n      customEmpty,\n      customPassed: mixpanelResults.custom.passed,\n      customFailed: mixpanelResults.custom.failed,\n      examplePassed: mixpanelResults.example.passed,\n      exampleFailed: mixpanelResults.example.failed,\n    };\n  }\n\n  private getGroupedTestCaseResult(\n    testCasesExecutions: CoderunnerTestCaseExecutionModel[],\n    validTestCases: ExampleTestCase[] | CustomTestCase[]\n  ): GroupedTestCasesResult {\n    const groupedResult = {\n      custom: {\n        failed: 0,\n        passed: 0,\n      },\n      example: {\n        failed: 0,\n        passed: 0,\n      },\n    };\n\n    testCasesExecutions.forEach(({ input: resultInput, evaluation }) => {\n      const localTestCase = validTestCases.find(\n        ({ input }) => resultInput === input\n      );\n      const mixpanelResultBody = localTestCase?.preloaded\n        ? groupedResult.example\n        : groupedResult.custom;\n\n      if (evaluation?.testcase) {\n        mixpanelResultBody.passed++;\n      } else {\n        mixpanelResultBody.failed++;\n      }\n    });\n\n    return groupedResult;\n  }\n\n  private getMixpanelSettingsData(\n    isPracticeQuestion: boolean,\n    config: { [key: string]: boolean | string | number }\n  ) {\n    const settingInstance = this.getMixpanelInstanceValue(isPracticeQuestion);\n    const changedKey = Object.keys(config)[0];\n    const THEME_IDENTIFIER = 'theme-';\n    let changedValue: boolean | string | number = config[changedKey];\n    let newValueString;\n\n    if (typeof changedValue === 'boolean') {\n      newValueString = changedValue ? 'ON' : 'OFF';\n    } else {\n      changedValue = String(changedValue);\n      newValueString = changedValue.includes(THEME_IDENTIFIER)\n        ? changedValue.replace(THEME_IDENTIFIER, '')\n        : changedValue;\n    }\n\n    return { settingInstance, changedKey, newValueString };\n  }\n\n  private getMixpanelInstanceValue(isPracticeQuestion: boolean) {\n    return isPracticeQuestion ? 'practice question' : 'real test';\n  }\n\n  private publishTestResults() {\n    this.codingTestResutsSubj$.next({ ...this.codingTestResults });\n  }\n}\n"]}

package/esm2022/lib/services/candidate-coding-test-services/index.mjs

@@ -0,0 +1,5 @@
+export * from './coding-test.service';
+export * from './coding-test-tour.service';
+export * from './candidature-api.service';
+export * from './coderunner-api.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy90Z28tY29kaW5nLXRlc3Qvc3JjL2xpYi9zZXJ2aWNlcy9jYW5kaWRhdGUtY29kaW5nLXRlc3Qtc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYywwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29kaW5nLXRlc3Quc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2NvZGluZy10ZXN0LXRvdXIuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2NhbmRpZGF0dXJlLWFwaS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vY29kZXJ1bm5lci1hcGkuc2VydmljZSc7Il19