pedwfrontend/actions/services/documentDirectService.js

import { BASE_URL } from "../core/env";
import { consoleLogger } from "../core/logger";
import { hashAPIPath } from "../core/hash";
import {
    buildFileQuery,
    withBaseUrl,
    appendQuerySuffix,
    appendHashSuffix
} from "../clients/fileRouteBuilder";
import {
    getFileJson,
    getSignedFileJson,
    downloadFileBlob,
    postSignedFileJson
} from "../clients/fileClient";

const MAX_FILES_PER_UPLOAD_BATCH = 10;

export const getAwaitingSubmissionFromBlob = (containerName) => {
    const route = buildFileQuery("/api/file/getawaitingsubmissionfromblob", {
        container: containerName
    });

    return getFileJson(
        withBaseUrl(BASE_URL, appendHashSuffix(route, hashAPIPath))
    ).catch((error) => {
        consoleLogger(error);
    });
};

export const getRepsFromBlob = (containerName) => {
    const route = buildFileQuery("/api/file/getrepsblob", {
        container: containerName
    });

    return getFileJson(
        withBaseUrl(BASE_URL, appendHashSuffix(route, hashAPIPath))
    ).catch((error) => {
        consoleLogger(error);
    });
};

export const getRepsFromBlobProxy = async (containerName) => {
    const route = buildFileQuery("/api/file/getrepsblobproxy", {
        container: containerName
    });

    return getFileJson(route).catch((error) => {
        consoleLogger(error);
    });
};

export const getAwaitingSubmissionFromBlobProxy = async (containerName) => {
    const route = buildFileQuery(
        "/api/file/getawaitingsubmissionfromblobproxy",
        {
            container: containerName
        }
    );

    return getFileJson(withBaseUrl(BASE_URL, route)).catch((error) => {
        consoleLogger(error);
    });
};

export const getFilesFromBlobproxy = (containerName, casefolderID) => {
    const route = buildFileQuery("/api/file/getbloblistproxy", {
        container: containerName,
        casefolderID
    });

    return getFileJson(route).catch((error) => {
        consoleLogger(error);
    });
};

export const deleteAwaitingSubmissionsFromBlob = (
    containerID,
    casefolderID
) => {
    var queryUrl = buildFileQuery("/api/file/deleteblobcase", {
        container: containerID,
        casefolderID
    });

    return getSignedFileJson(queryUrl).catch((error) => {
        consoleLogger(error);
    });
};

export const deleteMyRepresentationsFromBlob = (
    containerID,
    casefolderID,
    repfile
) => {
    var queryUrl = buildFileQuery("/api/file/deleteblobrep", {
        container: containerID,
        casefolderID,
        repfile
    });

    return getSignedFileJson(queryUrl).catch((error) => {
        consoleLogger(error);
    });
};

export const uploadFiles = async (
    formValues,
    filesObj,
    containerID,
    casefolderID
) => {
    let files = filesObj;

    var formData = new FormData();
    formData.append("appealData", JSON.stringify(formValues));
    formData.append("containerID", containerID);
    formData.append("casefolderID", casefolderID);

    for (let i = 0; i < files.length; i++) {
        for (let j = 0; j < files[i].length; j++) {
            formData.append(files[i][j].name, files[i][j]);
        }
    }

    var queryUrl = "/api/file/upload";

    try {
        return await postSignedFileJson(queryUrl, formData);
    } catch (error) {
        consoleLogger(error);
    }
};

export const uploadSingleFile = async (
    filesObj,
    containerID,
    casefolderID,
    options = {}
) => {
    let files = filesObj;
    try {
        const queryUrl = "/api/file/uploadsinglefile";
        const uploadResponse = {
            data: [],
            invalidFiles: []
        };
        let cumulativeUploaded = 0;
        let cumulativeInvalid = 0;
        const totalFiles = files.length;
        const totalChunks = Math.ceil(totalFiles / MAX_FILES_PER_UPLOAD_BATCH);

        for (
            let index = 0;
            index < files.length;
            index += MAX_FILES_PER_UPLOAD_BATCH
        ) {
            const chunkIndex =
                Math.floor(index / MAX_FILES_PER_UPLOAD_BATCH) + 1;
            const fileChunk = files.slice(
                index,
                index + MAX_FILES_PER_UPLOAD_BATCH
            );
            const formData = new FormData();

            formData.append("containerID", containerID);
            formData.append("casefolderID", casefolderID);

            for (let i = 0; i < fileChunk.length; i++) {
                formData.append(fileChunk[i].name, fileChunk[i]);
            }

            const chunkResult = await postSignedFileJson(queryUrl, formData);

            if (Array.isArray(chunkResult?.data)) {
                uploadResponse.data.push(...chunkResult.data);
                cumulativeUploaded += chunkResult.data.length;
            }

            if (Array.isArray(chunkResult?.invalidFiles)) {
                uploadResponse.invalidFiles.push(...chunkResult.invalidFiles);
                cumulativeInvalid += chunkResult.invalidFiles.length;
            }

            if (typeof options.onChunkComplete === "function") {
                options.onChunkComplete({
                    chunkIndex,
                    totalChunks,
                    totalFiles,
                    cumulativeUploaded,
                    cumulativeInvalid,
                    processedFiles: cumulativeUploaded + cumulativeInvalid
                });
            }
        }

        return uploadResponse;
    } catch (error) {
        consoleLogger(error);
    }
};

export const uploadRepFiles = async (
    formValues,
    filesObj,
    containerID,
    casefolderID
) => {
    var formData = new FormData();
    formData.append("appealData", JSON.stringify(formValues));
    formData.append("containerID", containerID);
    formData.append("casefolderID", casefolderID);
    formData.append("repOrAppeal", true);

    var queryUrl = "/api/file/upload";

    try {
        return await postSignedFileJson(queryUrl, formData);
    } catch (error) {
        consoleLogger(error);
    }
};

export const generateRepPDF = async (
    formValues,
    containerID,
    casefolderID,
    options = {}
) => {
    var queryUrl =
        "/api/file/generatepdf" + (options.download ? "?download=true" : "");

    try {
        return await postSignedFileJson(queryUrl, formValues, {
            ...(options.download ? { responseType: "blob" } : {})
        });
    } catch (error) {
        consoleLogger(error);
    }
};

export const generateAppealPDF = async (
    formValues,
    containerID,
    casefolderID,
    appealType,
    fileList,
    options = {}
) => {
    Object.assign(formValues, {
        "filesList": fileList
    });

    var queryUrl =
        "/api/file/generateappealpdf?appealType=" +
        appealType +
        (options.download ? "&download=true" : "");

    try {
        return await postSignedFileJson(queryUrl, formValues, {
            ...(options.download ? { responseType: "blob" } : {})
        });
    } catch (error) {
        consoleLogger(error);
    }
};

export const getFilesFromBlob = (containerName, casefolderID) => {
    const route = buildFileQuery("/api/file/getbloblist", {
        container: containerName,
        casefolderID
    });

    return getFileJson(
        withBaseUrl(BASE_URL, appendHashSuffix(route, hashAPIPath))
    ).catch((error) => {
        consoleLogger(error);
    });
};

export const getFilesFromBlobHashed = (
    containerName,
    getblobshash,
    casefolderID
) => {
    const route = buildFileQuery("/api/file/getbloblist", {
        container: containerName,
        casefolderID
    });

    return getFileJson(appendQuerySuffix(route, getblobshash)).catch(
        (error) => {
            consoleLogger(error);
        }
    );
};

export const deleteBlob = async (
    containerName,
    blobName,
    deleteblobhash,
    casefolderID
) => {
    const route = buildFileQuery(
        "/api/file/deleteblob",
        {
            container: containerName,
            casefolderID,
            blobname: blobName
        },
        {
            encode: true
        }
    );

    return getFileJson(appendQuerySuffix(route, deleteblobhash)).catch(
        (error) => {
            consoleLogger(error);
        }
    );
};

export const deleteRepBlob = async (
    containerName,
    blobName,
    deleteblobhash,
    casefolderID,
    filenamePrefix
) => {
    const route = buildFileQuery(
        "/api/file/deleteblob",
        {
            container: containerName,
            casefolderID: casefolderID + "/" + filenamePrefix,
            blobname: blobName
        },
        {
            encode: true
        }
    );

    return getFileJson(appendQuerySuffix(route, deleteblobhash)).catch(
        (error) => {
            consoleLogger(error);
        }
    );
};

export const downloadBlob = (containerName, blobName) => {
    const queryUrl = withBaseUrl(
        BASE_URL,
        buildFileQuery("/api/file/downloadblob", {
            container: containerName.toLowerCase(),
            blobname: blobName
        })
    );

    return downloadFileBlob(queryUrl).catch((error) => {
        consoleLogger(error);
    });
};

export const getProgressFromBlob = async (containerName, casereference) => {
    const route = buildFileQuery(
        "/api/file/getprogressobjblob",
        {
            container: containerName,
            casefolderID: casereference
        },
        {
            encode: true
        }
    );

    return getFileJson(
        withBaseUrl(BASE_URL, appendHashSuffix(route, hashAPIPath))
    ).catch((error) => {
        consoleLogger(error);
    });
};

export const createContainerProxy = (containerName) => {
    var route = buildFileQuery("/api/file/setupcontainer", {
        ident: containerName
    });
    var queryUrl = appendHashSuffix(route, hashAPIPath);

    return getFileJson(withBaseUrl(BASE_URL, queryUrl)).catch((error) => {
        consoleLogger(error);

        return JSON.stringify(error);
    });
};