OSIT-AE-App-Svelte/src/lib/api_post_object.ts

import axios from 'axios';

export let temp_post_blob_percent_completed = 0;
export let post_blob_percent_completed = temp_post_blob_percent_completed;
export let temp_post_object_percent_completed = 0;
export let post_object_percent_completed = temp_post_object_percent_completed;

// Updated 2024-05-23
export let post_object = async function post_object(
        {
            api_cfg=null,
            endpoint='',
            params={},
            data={},
            form_data=null,
            return_meta=false,
            return_blob=false,
            filename='',
            auto_download=false,
            // The task_id value should be a random string that is unique to the task. This is used to identify the task in the message event.
            task_id=crypto.randomUUID(),
            log_lvl=0
        }: {
            api_cfg: any,
            endpoint: string,
            params?: any,
            data?: any,
            form_data?: any,
            return_meta?: boolean,
            return_blob?: boolean,
            filename?: string,
            auto_download?: boolean,
            task_id?: string,
            log_lvl?: number
        }
        ) {

    if (log_lvl) {
        console.log(`*** post_object() *** Endpoint: ${endpoint} Task ID: ${task_id}`);
        console.log('Params:', params);
        if (log_lvl > 1) {
            console.log('Data:', data);
            console.log(typeof data);
            console.log(`Base URL: ${api_cfg['base_url']}`);
            console.log('API Config:', api_cfg);
        }
        if (log_lvl > 2) {
            console.log(`Return Meta: ${return_meta}`);
            console.log(`Return Blob: ${return_blob}`);
            console.log(`Filename: ${filename}`);
            console.log(`Auto Download: ${auto_download}`);
        }
        // console.log(return_meta);
    }

    let axios_api = axios.create({
        baseURL: api_cfg['base_url'],
        /* other custom settings */
    });
    axios_api.defaults.headers = api_cfg['headers'];
    console.log('Axios API', axios_api);
    // console.log('Axios API POST', axios_api.post);

    // if (typeof data == 'FormData') {
    if (form_data) {
        axios_api.defaults.headers['content-type'] = 'multipart/form-data';
        data = form_data;
    } else {
        axios_api.defaults.headers['content-type'] = 'application/json';
    }


    if (!return_blob) {
        let response_data = await axios_api.post(
            endpoint,
            data,
            {
                params: params,
                onUploadProgress: (progressEvent) => {
                    let percent_completed = Math.round(
                        (progressEvent.loaded * 100) / progressEvent.total
                    );
                    console.log('POST Progress:', progressEvent.progress, 'Total:', progressEvent.total, 'Loaded:', progressEvent.loaded, 'Percent Completed', percent_completed);

                    temp_post_object_percent_completed = percent_completed;

                    try {
                        window.postMessage({
                            type: 'api_post_json_form',
                            status: 'uploading',
                            task_id: task_id,
                            endpoint: endpoint,
                            size_total: progressEvent.total,
                            size_loaded: progressEvent.loaded,
                            percent_completed: percent_completed,
                            progress: progressEvent.progress,
                            rate: progressEvent.rate,
                            },
                            '*'
                        );
                    } catch (error) {
                        console.log('Error posting message to window:', error);
                    }
                }
            }
        )
        .then(function (response) {
            console.log('POST Response Data:', response.data);
            try {
                window.postMessage({
                    type: 'api_post_json_form',
                    status: 'complete',
                    task_id: task_id,
                    endpoint: endpoint,
                    size_total: 0,
                    size_loaded: 0,
                    percent_completed: 100,
                    progress: 100,
                    rate: 0,
                    },
                    '*'
                );
            } catch (error) {
                console.log('Error posting message to window:', error);
            }

            if (response.data['data'].result === null) {
                // This should mean that the request was successful, but a result of None/null was returned from Aether API.
                // console.log('Returning null after POST');
                return null;
            } else {
                // This should mean that the request was successful, and a result with data was returned from Aether API.
                // console.log('Returning data after POST');
                return response.data['data'];
            }
            //return response.data;
        })
        .catch(function (error) {
            if (error.response && error.response.status === 404) {
                return null; // Returning null since there were no results
            }
            console.log(error);
            return false; // Returning false since something may have gone wrong. Also more in line with what the API returns.
            // return error;
        });

        if (log_lvl > 1) {
            console.log('Response Data:', response_data);
        }
        axios_api.defaults.headers['content-type'] = 'application/json';
        return response_data;

    } else {
        // console.log('Expecting a Blob to be returned...');

        let response_data_promise = await axios_api.post(
                endpoint,
                data,
                {
                    params: params,
                    responseType: 'blob',
                    onDownloadProgress: (progressEvent) => {
                        let percent_completed = Math.round(
                            (progressEvent.loaded * 100) / progressEvent.total
                        );
                        console.log('POST Blob Progress:', progressEvent.progress, 'Total:', progressEvent.total, 'Loaded:', progressEvent.loaded, 'Percent Completed', percent_completed);

                        temp_post_blob_percent_completed = percent_completed;
                    }
                }
            )
        .then(function (response) {
            if (log_lvl) {
                console.log(response);
            }

            const { data, headers } = response
            console.log(headers);

            if (filename) {
            } else if (headers['content-disposition']) {
                filename = headers['content-disposition'].replace(/\w+;filename=(.*)/, '$1');
            } else {
                filename = 'unknown_file.ext';
            }

            if (auto_download) {
                const url = window.URL.createObjectURL(new Blob([response.data]));
                const link = document.createElement('a');
                link.href = url;
                // link.setAttribute('download', 'event_exhibit_tracking_export.xlsx'); //or any other extension
                link.setAttribute('download', filename); //or any other extension
                document.body.appendChild(link);
                link.click();
                return true;
            } else {
                return response;
            }
        });

        if (response_data_promise) {
            // The most common and expected response.
            // console.log('Returning result. This is generally expected.');
            // let test_blob = new Blob([response_data_promise.data]);
            // console.log(test_blob);
            // return test_blob;
            // console.log(response_data_promise.blob());
            return response_data_promise;
        } else {
            // This generally should not happen. It likely means the query was bad or an API issue.
            console.log('Returning unknown. This should not happen in most cases.');
            Promise.reject(new Error('fail')).then(resolved, rejected);
        }
    }
}


function resolved(result: any) {
    console.log('Resolved');
}

function rejected(result: any) {
    console.error(result);
}