source: main/trunk/model-interfaces-dev/atea/macron-restoration/src/js/MacronRestorationModule.js@ 35716

/**
 * @file Defines components that are used to interact with the transcription proxy servlet.
 * @author Carl Stephens
 * @module
 */

import { log } from "./Util"

export class MacronRestorationError extends Error {
    /**
     * Initialises a new instance of the {@link MacronRestorationError} object.
     *
     * @param {Number | undefined} statusCode The HTTP status code of the error.
     * @param {String | undefined} message The status message.
     * @param {String | null} fileName The file on which the transcription failed.
     */
    constructor(message = undefined, fileName = null, statusCode = -1) {
        super(message);

        /** @type {String | null} The name of the file that the transcription error occured on. */
        this.fileName = fileName;

        /** @type {Number | undefined} The status code returned by the API when the erro was generated. */
        this.statusCode = statusCode;
    }
}

/**
 * A service that performs requests to the macron restoration API.
 */
export default class MacronRestorationService {
    constructor() {
        /** @type {String} The URL to which query POST requests should be made. */
        if (process.env.NODE_ENV !== "production") {
            this.queryUrl = "//localhost:8383/macron-restoration/jsp/servlet/DirectInput";
        }
        else {
            this.queryUrl = "/macron-restoration/jsp/servlet/DirectInput";
        }
    }

    /**
     * Performs a request to the macron restoration API to restore the given input text.
     * @param {String} input The input text to macronise
     * @returns The JSON response from the macron restoration API.
     */
    async directMacronisation(input) {
        const that = this;

        try {
            const response = await fetch(
                that.queryUrl,
                {
                    method: "POST",
                    headers: {
                        "Content-Type": "application/x-www-form-urlencoded"
                    },
                    body: `o=json&fragment=${input}`
                }
            );

            if (!response.ok) {
                log(`Macron Restoration API failed with status ${response.status} and message ${response.statusText}`, "error")
                throw new MacronRestorationError(response.statusText, undefined, response.status);
            }

            return await response.json();
        }
        catch (e) {
            log(`Macron restoration failed with reason ${e}`, "error");
            throw new MacronRestorationError(undefined, "Unknown");
        }
    }

    /**
     * Performs chunked queries to transcribe the given audio files, returning the data in iterations.
     * Data is chunked according to which ever occurs first:
     * A maximum of three files per request, or;
     * A maximum of 5 MiB before chunking.
     *
     * @param {FileList | File[]} files The files to upload
     * @returns {AsyncGenerator<TranscriptionModel[]>} The transcribed audio files.
     * @throws {TranscriptionError} When the transcription request fails to complete.
     */
    async* batchFileMacronisation(files) {
        let filesToSubmit = [];
        let fileCounter = 0;
        let byteCounter = 0;

        for (const file of files) {
            if (fileCounter === this.MAX_BATCH_COUNT || byteCounter > this.BATCH_BYTE_LIMIT) { // 5 MiB
                yield await this.fileMacronisation(filesToSubmit);
                filesToSubmit = [];
                byteCounter = 0;
                fileCounter = 0;
            }

            filesToSubmit[fileCounter++] = file;
            byteCounter += file.size;
        }

        if (filesToSubmit.length > 0) {
            yield await this.fileMacronisation(filesToSubmit);
        }
    }

    /**
     * Performs a query to transcribe the given audio files.
     *
     * @param {File[]} files The files to upload.
     * @returns {Promise<TranscriptionModel[]>} The transcribed audio file.
     * @throws {TranscriptionError} When the transcription request fails to complete.
     */
    async fileMacronisation(files) {
        if (process.env.NODE_ENV !== "production" || files.some(file => file.name === "akl_mi_pk_0002_offline.wav")) {
            return await this.fileMacronisationTest(files);
        }
        else {
            return await this.fileMacronisationActual(files);
        }
    }

    async fileMacronisationTest(files) {
        const objects = [];

        for (const file of files) {
            const object = JSON.parse(this.TEST_JSON);
            object.file_name = file.name;
            objects.push(object);
        }

        return objects;
    }

    /**
     * Performs a query to transcribe the given audio files.
     *
     * @param {FileList | File[]} files The files to upload.
     * @returns {Promise<TranscriptionModel[]>} The transcribed audio file.
     * @throws {TranscriptionError} When the transcription request fails to complete.
     */
    async fileMacronisationActual(files) {
        const that = this;
        const formData = new FormData();

        let audioFileKeys = "";
        for (let i = 0; i < files.length; i++) {
            const f = files[i];
            const key = "audioFile" + i;

            formData.append(key, f, f.name);
            audioFileKeys += key + "|";
        }
        formData.append("audioFileKeys", audioFileKeys);

        try {
            const response = await fetch(
                that.queryUrl,
                {
                    method: "POST",
                    body: formData
                }
            );

            if (!response.ok) {
                log(`Transcription API failed with status ${response.status} and message ${response.statusText}`, "error")
                throw new MacronRestorationError(response.statusText, undefined, response.status);
            }

            return await response.json();
        }
        catch (e) {
            log(`Transcription failed with reason ${e}`, "error");
            throw new MacronRestorationError(undefined, "Unknown");
        }
    }
}