curtain-web-api 1.0.62 → 1.0.64

package/src/classes/curtain-api.ts

@@ -30,6 +30,60 @@ export const reviver = (key: any, value: any) => {
     return value;
 }
 
+export interface SiteProperties {
+    non_user_post: boolean;
+    allow_user_set_permanent: boolean;
+    expiry_duration_options: number[];
+    default_expiry_duration_months: number;
+}
+
+export interface CurtainChunkedUploadStatus {
+    id: string;
+    filename?: string;
+    offset: number;
+    created_at: string;
+    status: number;
+    completed_at?: string;
+    original_filename?: string;
+    mime_type?: string;
+    file_size?: number;
+    upload_session_id?: string;
+}
+
+export interface CurtainChunkedUploadRequest {
+    file: File | Blob;
+    filename?: string;
+    upload_session_id?: string;
+    description?: string;
+    curtain_type?: string;
+    permanent?: boolean;
+    encrypted?: boolean;
+    expiry_duration?: number;
+    enable?: boolean;
+}
+
+export interface CurtainChunkedUploadResponse {
+    id: string;
+    filename: string;
+    offset: number;
+}
+
+export interface CurtainChunkedUploadCompletionRequest {
+    md5?: string;
+    description?: string;
+    curtain_type?: string;
+    permanent?: boolean;
+    encrypted?: boolean;
+    expiry_duration?: number;
+    enable?: boolean;
+}
+
+export interface CurtainChunkedUploadCompletionResponse {
+    curtain?: any;
+    message?: string;
+    error?: string;
+}
+
 export class CurtainWebAPI {
     loginURL: string = "";
     logoutURL: string = "";
@@ -211,7 +265,7 @@ export class CurtainWebAPI {
     async putSettings(settings: any, enable: boolean = true, description: string = "", sessionType: string = "TP", encryption: CurtainEncryption = {
         encrypted: false,
         e2e: false,
-    }, permanent: boolean = false, onUploadProgress: any = undefined) {
+    }, permanent: boolean = false, expiry_duration?: number, onUploadProgress: any = undefined) {
         let form: FormData = new FormData();
         let data = JSON.stringify(settings, replacer)
         if (enable) {
@@ -234,6 +288,9 @@ export class CurtainWebAPI {
         } else {
             form.append("permanent", "False")
         }
+        if (expiry_duration !== undefined) {
+            form.append("expiry_duration", expiry_duration.toString())
+        }
         if (encryption.encrypted && encryption.e2e && encryption.publicKey !== undefined) {
             const aesKey = await generateAESKey()
             console.log("Encrypting data")
@@ -350,6 +407,10 @@ export class CurtainWebAPI {
             }
         }
 
+        if ("expiry_duration" in sessionData) {
+            form.append("expiry_duration", sessionData["expiry_duration"].toString())
+        }
+
         if (encryption.encrypted) {
             form.append("encrypted", "True")
         } else {
@@ -422,9 +483,7 @@ export class CurtainWebAPI {
     getSiteProperties() {
         let headers = new AxiosHeaders();
         headers["Accept"] = "application/json";
-        return this.axiosInstance.get(this.baseURL + "site-properties/", {headers: headers, responseType:"json"}).then((response) => {
-            return response;
-        });
+        return this.axiosInstance.get<SiteProperties>(this.baseURL + "site-properties/", {headers: headers, responseType:"json"});
     }
 
     saveDataFilterList(name: string, data: string, category: string = "") {
@@ -694,5 +753,206 @@ export class CurtainWebAPI {
         headers["Accept"] = "application/json";
         return this.axiosInstance.get(this.baseURL + "datacite/file/" + datacite_id + "/", {headers: headers, responseType: "blob"});
     }
+
+    uploadCurtainChunk(
+        request: CurtainChunkedUploadRequest,
+        uploadId?: string,
+        offset?: number,
+        totalSize?: number
+    ) {
+        const formData = new FormData();
+        formData.append('file', request.file);
+
+        if (request.filename) {
+            formData.append('filename', request.filename);
+        }
+        if (request.upload_session_id) {
+            formData.append('upload_session_id', request.upload_session_id);
+        }
+        if (request.description) {
+            formData.append('description', request.description);
+        }
+        if (request.curtain_type) {
+            formData.append('curtain_type', request.curtain_type);
+        }
+        if (request.permanent !== undefined) {
+            formData.append('permanent', request.permanent.toString());
+        }
+        if (request.encrypted !== undefined) {
+            formData.append('encrypted', request.encrypted.toString());
+        }
+        if (request.expiry_duration !== undefined) {
+            formData.append('expiry_duration', request.expiry_duration.toString());
+        }
+        if (request.enable !== undefined) {
+            formData.append('enable', request.enable.toString());
+        }
+
+        const url = uploadId
+            ? `${this.baseURL}curtain-chunked-upload/${uploadId}/`
+            : `${this.baseURL}curtain-chunked-upload/`;
+
+        const headers = new AxiosHeaders();
+        headers["Accept"] = "application/json";
+
+        const isChunkedUpload = offset !== undefined && totalSize !== undefined;
+
+        if (isChunkedUpload && offset !== undefined && totalSize !== undefined) {
+            const chunkEnd = offset + (request.file as Blob).size - 1;
+            headers["Content-Range"] = `bytes ${offset}-${chunkEnd}/${totalSize}`;
+        }
+
+        if (isChunkedUpload || uploadId) {
+            return this.axiosInstance.put<CurtainChunkedUploadResponse>(url, formData, {headers: headers});
+        } else {
+            return this.axiosInstance.post<CurtainChunkedUploadResponse>(url, formData, {headers: headers});
+        }
+    }
+
+    getCurtainUploadStatus(uploadId: string) {
+        let headers = new AxiosHeaders();
+        headers["Accept"] = "application/json";
+        return this.axiosInstance.get<CurtainChunkedUploadStatus>(`${this.baseURL}curtain-chunked-upload/${uploadId}/`, {headers: headers});
+    }
+
+    completeCurtainUpload(uploadId: string, request?: CurtainChunkedUploadCompletionRequest) {
+        const formData = new FormData();
+
+        if (request?.md5) {
+            formData.append('md5', request.md5);
+        }
+        if (request?.description) {
+            formData.append('description', request.description);
+        }
+        if (request?.curtain_type) {
+            formData.append('curtain_type', request.curtain_type);
+        }
+        if (request?.permanent !== undefined) {
+            formData.append('permanent', request.permanent.toString());
+        }
+        if (request?.encrypted !== undefined) {
+            formData.append('encrypted', request.encrypted.toString());
+        }
+        if (request?.expiry_duration !== undefined) {
+            formData.append('expiry_duration', request.expiry_duration.toString());
+        }
+        if (request?.enable !== undefined) {
+            formData.append('enable', request.enable.toString());
+        }
+
+        let headers = new AxiosHeaders();
+        headers["Accept"] = "application/json";
+        return this.axiosInstance.put<CurtainChunkedUploadCompletionResponse>(`${this.baseURL}curtain-chunked-upload/${uploadId}/`, formData, {headers: headers});
+    }
+
+    cancelCurtainUpload(uploadId: string) {
+        let headers = new AxiosHeaders();
+        headers["Accept"] = "application/json";
+        return this.axiosInstance.delete<void>(`${this.baseURL}curtain-chunked-upload/${uploadId}/`, {headers: headers});
+    }
+
+    async uploadCurtainFileInChunks(
+        file: File,
+        chunkSize: number = 1024 * 1024,
+        options?: {
+            description?: string;
+            curtain_type?: string;
+            permanent?: boolean;
+            encrypted?: boolean;
+            expiry_duration?: number;
+            enable?: boolean;
+            upload_session_id?: string;
+            onProgress?: (progress: number) => void;
+        }
+    ): Promise<CurtainChunkedUploadCompletionResponse> {
+        return new Promise(async (resolve, reject) => {
+            let uploadId: string | undefined;
+            let offset = 0;
+            const totalSize = file.size;
+
+            if (totalSize <= chunkSize) {
+                try {
+                    const response = await this.uploadCurtainChunk({
+                        file: file,
+                        filename: file.name,
+                        upload_session_id: options?.upload_session_id,
+                        description: options?.description,
+                        curtain_type: options?.curtain_type,
+                        permanent: options?.permanent,
+                        encrypted: options?.encrypted,
+                        expiry_duration: options?.expiry_duration,
+                        enable: options?.enable
+                    });
+
+                    const completionResponse = await this.completeCurtainUpload(response.data.id, {
+                        description: options?.description,
+                        curtain_type: options?.curtain_type,
+                        permanent: options?.permanent,
+                        encrypted: options?.encrypted,
+                        expiry_duration: options?.expiry_duration,
+                        enable: options?.enable
+                    });
+                    resolve(completionResponse.data);
+                } catch (error) {
+                    reject(error);
+                }
+                return;
+            }
+
+            const uploadNextChunk = async () => {
+                if (offset >= totalSize) {
+                    if (uploadId) {
+                        try {
+                            const completionResponse = await this.completeCurtainUpload(uploadId, {
+                                description: options?.description,
+                                curtain_type: options?.curtain_type,
+                                permanent: options?.permanent,
+                                encrypted: options?.encrypted,
+                                expiry_duration: options?.expiry_duration,
+                                enable: options?.enable
+                            });
+                            resolve(completionResponse.data);
+                        } catch (error) {
+                            reject(error);
+                        }
+                    } else {
+                        reject(new Error('Upload failed: No upload ID'));
+                    }
+                    return;
+                }
+
+                const end = Math.min(offset + chunkSize, totalSize);
+                const chunk = file.slice(offset, end);
+
+                try {
+                    const response = await this.uploadCurtainChunk({
+                        file: chunk,
+                        filename: file.name,
+                        upload_session_id: options?.upload_session_id,
+                        description: options?.description,
+                        curtain_type: options?.curtain_type,
+                        permanent: options?.permanent,
+                        encrypted: options?.encrypted,
+                        expiry_duration: options?.expiry_duration,
+                        enable: options?.enable
+                    }, uploadId, offset, totalSize);
+
+                    uploadId = response.data.id;
+                    offset = response.data.offset;
+
+                    const progress = (offset / totalSize) * 100;
+                    if (options?.onProgress) {
+                        options.onProgress(progress);
+                    }
+
+                    uploadNextChunk();
+                } catch (error) {
+                    reject(error);
+                }
+            };
+
+            uploadNextChunk();
+        });
+    }
 }
 

package/src/index.ts

@@ -1,4 +1,14 @@
-import {CurtainWebAPI, replacer, reviver} from "./classes/curtain-api";
+import {
+  CurtainWebAPI,
+  replacer,
+  reviver,
+  SiteProperties,
+  CurtainChunkedUploadStatus,
+  CurtainChunkedUploadRequest,
+  CurtainChunkedUploadResponse,
+  CurtainChunkedUploadCompletionRequest,
+  CurtainChunkedUploadCompletionResponse
+} from "./classes/curtain-api";
 import {User} from "./classes/curtain-user";
 import {getProteomicsData, getPrideData, getEBIAlpha, getInteractomeAtlas, getStringDBInteractions} from "./utilities";
 import {importKey, importPrivateKey, exportPrivateKey, exportKeyString, exportPublicKey, importPublicKey, CurtainEncryption, generateKeyPair, encryptDataRSA, decryptDataRSA, loadFromLocalStorage, saveToLocalStorage, pemToArrayBuffer, base64ToArrayBuffer, arrayBufferToBase64String, removeLines} from "./classes/curtain-encryption";
@@ -13,6 +23,12 @@ export {
   getStringDBInteractions,
   replacer,
   reviver,
+  SiteProperties,
+  CurtainChunkedUploadStatus,
+  CurtainChunkedUploadRequest,
+  CurtainChunkedUploadResponse,
+  CurtainChunkedUploadCompletionRequest,
+  CurtainChunkedUploadCompletionResponse,
   importKey,
   importPrivateKey,
   exportPrivateKey,

package/tsconfig.json

@@ -1,8 +1,9 @@
 {
   "compilerOptions": {
-    "target": "es2015",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
-    "lib": ["es6"],                                      /* Specify a set of bundled library declaration files that describe the target runtime environment. */
-    "module": "commonjs",                                /* Specify what module code is generated. */
+    "target": "ES2020",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "lib": ["ES2020", "DOM"],                            /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    "module": "ES2020",                                  /* Specify what module code is generated. */
+    "moduleResolution": "bundler",                       /* Specify how TypeScript looks up a file from a given module specifier. */
     "rootDir": "src",                                    /* Specify the root folder within your source files. */
     "allowJs": true,                                     /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
     "outDir": "build",                                   /* Specify an output folder for all emitted files. */