dpu-cloud-sdk 1.0.0

package/src/ServiceIntegration.ts

@@ -0,0 +1,710 @@
+import { FileDownloadInfo } from "./models/RequestModel";
+import {
+  BaseReponseModel,
+  InitUploadResponse,
+  PresignURLResponse,
+  ObjectDetail,
+  CompleteMultipartUploadResponse,
+  MultiPresignURLResponse,
+} from "./models/ResponseModel";
+import { ApiStatus, ConfigFileRules, Path } from "./utils/Constants";
+import { validString } from "./utils/Helper";
+
+export class ServiceIntegration {
+  constructor() {}
+
+  public async getUrlToDownload(
+    bucketName: string,
+    fileName: string,
+    accessToken?: string
+  ) {
+    try {
+      const url = `${Path.BaseURL}${Path.GetUrlDownload}`;
+      const headers: any = {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        "ngrok-skip-browser-warning": true,
+      };
+
+      let queryParams: any;
+      if (validString(bucketName)) {
+        queryParams = { ...queryParams, bucketName: bucketName };
+      }
+      if (validString(fileName)) {
+        queryParams = { ...queryParams, fileName: fileName };
+      }
+
+      const response = await fetch(
+        `${url}?${new URLSearchParams(queryParams)}`,
+        {
+          method: "GET",
+          headers: headers,
+        }
+      );
+      if (response.ok) {
+        const json: BaseReponseModel<string> =
+          (await response.json()) as BaseReponseModel<string>;
+        if (json.statusCode === ApiStatus.Success) {
+          return json.data;
+        } else {
+          console.error(
+            `Fail to generate url download with message error: ${json.message}`
+          );
+        }
+      } else {
+        console.error(
+          `Fail to generate url download with status ${response.statusText} and error: ${response.statusText}`
+        );
+      }
+
+      return null;
+    } catch (error) {
+      console.error(`Error when generate url download: ${error}`);
+    }
+  }
+
+  public async fetchChunkFile(url: string, start: number, end: number) {
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          Range: `bytes=${start}-${end}`,
+        },
+      });
+      if (!response.ok) {
+        const error = `Fail to fetch chunk file with status ${
+          response.statusText
+        } and error: ${await response.text()}`;
+        throw new Error(error);
+      }
+
+      return await response.arrayBuffer();
+    } catch (error) {
+      console.error(`Error when download file: ${error}`);
+      throw error;
+    }
+  }
+
+  //#region Upload small file
+  public async uploadSmallFile(
+    bucketName: string,
+    fileName: string,
+    buffer: Buffer,
+    // file: File,
+    accessToken: string,
+    cancellationToken: AbortController,
+    onProgress?: (percentCompleted: number) => void,
+    reGetAccessToken?: () => string,
+    isGetInfo?: boolean,
+    preSignUrl?: PresignURLResponse
+  ) {
+    if(!preSignUrl) {
+      const presignUrlResponse = await this.generatePresignedUrl(
+        bucketName,
+        fileName,
+        accessToken,
+        cancellationToken
+      );
+      if (!presignUrlResponse) {
+        return new Promise((resolve, reject) => {
+          reject(`Fail to generate presigned url for file ${fileName}`);
+        });
+      }
+      preSignUrl = presignUrlResponse;
+    }
+
+    var responseUploadChild = await this.uploadChildFile(
+      preSignUrl,
+      buffer,
+      cancellationToken
+    );
+
+    if (!responseUploadChild) {
+      return new Promise((resolve, reject) => {
+        reject(`Fail to upload file ${fileName}`);
+      });
+    }
+
+    if (isGetInfo === true) {
+      const objectDetail: ObjectDetail | null = await this.getObjectDetail(
+        bucketName,
+        fileName,
+        accessToken
+      );
+      if (!objectDetail) {
+        return new Promise((resolve, reject) => {
+          reject(`Fail to get object detail for file ${fileName}`);
+        });
+      }
+      const fileModel = {
+        bucketName: bucketName,
+        fileName: fileName,
+        contentLength: buffer.length,
+        versionFile: objectDetail.versionId,
+        dateVersionFile: objectDetail.lastModified,
+      };
+
+      return new Promise((resolve, reject) => {
+        resolve(fileModel);
+      });
+    }
+
+    return new Promise((resolve, reject) => {
+      resolve({
+        bucketName: bucketName,
+        fileName: fileName,
+        contentLength: buffer.length,
+        versionFile: null,
+        dateVersionFile: null,
+      });
+    });
+  }
+
+  private async generatePresignedUrl(
+    bucketName: string,
+    fileName: string,
+    accessToken?: string,
+    cancellationToken?: AbortController
+  ) {
+    try {
+      const url = `${Path.BaseURL}${Path.GeneratePresignedUrl}`;
+      const headers: any = {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        "ngrok-skip-browser-warning": true,
+      };
+
+      let queryParams: any = {
+        setPermission: false,
+      };
+      if (validString(bucketName)) {
+        queryParams = { ...queryParams, bucketName: bucketName };
+      }
+      if (validString(fileName)) {
+        queryParams = { ...queryParams, objectName: fileName };
+      }
+
+      const response = await fetch(
+        `${url}?${new URLSearchParams(queryParams)}`,
+        {
+          method: "GET",
+          headers: headers,
+          signal: cancellationToken?.signal
+        }
+      );
+      if (response.ok) {
+        const json: BaseReponseModel<PresignURLResponse> =
+          (await response.json()) as BaseReponseModel<PresignURLResponse>;
+        if (json.statusCode === ApiStatus.Success) {
+          return json.data;
+        } else {
+          console.error(
+            `Fail to generate presigned urls with message error: ${json.message}`
+          );
+        }
+      } else {
+        console.error(
+          `Fail to generate presigned urls with status ${response.statusText} and error: ${response.statusText}`
+        );
+      }
+
+      return null;
+    } catch (error) {
+      console.error(`Error when generate presigned urls: ${error}`);
+    }
+  }
+
+  private async uploadChildFile(
+    presignUrlResponse: PresignURLResponse,
+    buffer: ArrayBuffer,
+    cancellationToken?: AbortController
+  ) {
+    try {
+      const response = await fetch(presignUrlResponse.url, {
+        method: "PUT",
+        headers: presignUrlResponse.headers,
+        body: buffer,
+        signal: cancellationToken?.signal
+      });
+
+      if (response.status === ApiStatus.Success) {
+        var eTag: string | null = response.headers.get("ETag");
+        if (eTag) return eTag.replace(/^"|"$/g, "");
+      } else {
+        console.error(
+          `Fail to upload child file with status ${response.statusText} and error: ${response.statusText}`
+        );
+      }
+
+      return null;
+    } catch (error) {
+      console.error(`Error when upload child file: ${error}`);
+    }
+  }
+  //#endregion
+
+  //#region Upload large file
+  public async uploadLargeFile(
+    bucketName: string,
+    fileName: string,
+    buffer: Buffer,
+    accessToken: string,
+    cancellationToken: AbortController,
+    onProgress?: (percentCompleted: number) => void,
+    reGetAccessToken?: () => string,
+    initUpload?: InitUploadResponse,
+    isGetInfo?: boolean
+  ) {
+    await this.validateFileSize(fileName, buffer.length);
+    // init multi upload
+    if (!initUpload) {
+      initUpload = await this.initMultiPartUpload(
+        bucketName,
+        fileName,
+        accessToken,
+        false,
+        cancellationToken
+      );
+    }
+    if (!initUpload) {
+      return new Promise((resolve, reject) => {
+        reject(`Fail to initiate multipart upload for file ${fileName}`);
+      });
+    }
+    var numberOfChunks: number = this.calculateNumberOfChunks(
+      buffer.length
+    );
+    const urls = await this.generatePresignedUrls(
+      bucketName,
+      fileName,
+      initUpload,
+      numberOfChunks,
+      accessToken,
+      cancellationToken
+    );
+    if (!urls) {
+      return new Promise((resolve, reject) => {
+        reject(`Fail to generate presigned urls for file ${fileName}`);
+      });
+    }
+
+    var chunksUploaded: number = 0;
+    var start: number = 0;
+    const eTags: any = {};
+    while (chunksUploaded < numberOfChunks) {
+      this.throwIfCancellationRequested(cancellationToken, fileName);
+      var end: number = Math.min(
+        start + ConfigFileRules.ChunkSize,
+        buffer.length
+      );
+      // var fileChunk: ArrayBuffer = await this.readFileBytes(file, start, end);
+      const sliced = buffer.subarray(start, end); // lấy phần con của buffer
+      const fileChunk = sliced.buffer.slice(sliced.byteOffset, sliced.byteOffset + sliced.byteLength);
+      this.throwIfCancellationRequested(cancellationToken, fileName);
+      var url: string = urls[chunksUploaded];
+      var responseUploadChild = await this.uploadChildFile(
+        { url: url, headers: initUpload.headers },
+        fileChunk
+      );
+      if (!responseUploadChild) {
+        return new Promise((resolve, reject) => {
+          reject(`Fail to upload chunk ${chunksUploaded} of file ${fileName}`);
+        });
+      }
+      Object.defineProperty(eTags, chunksUploaded + 1, {
+        value: responseUploadChild,
+        enumerable: true,
+      });
+      chunksUploaded++;
+      start = end;
+      var percentCompleted: number = (chunksUploaded / numberOfChunks) * 100;
+      onProgress?.(percentCompleted);
+      // console.log(`${requestId} Number of chunks uploaded : ${chunksUploaded}`);
+    }
+    var completeResponse = await this.completeMultipartUpload(
+      bucketName,
+      fileName,
+      initUpload.uploadId,
+      eTags,
+      accessToken,
+      cancellationToken
+    );
+    onProgress?.(100);
+    if (!completeResponse) {
+      return new Promise((resolve, reject) => {
+        reject(`Fail to complete multipart upload for file ${fileName}`);
+      });
+    }
+    if (isGetInfo === false) {
+      return new Promise((resolve, reject) => {
+        resolve(fileName);
+      });
+    } else {
+      const objectDetail: ObjectDetail | null = await this.getObjectDetail(
+        bucketName,
+        fileName,
+        accessToken
+      );
+      if (!objectDetail) {
+        return new Promise((resolve, reject) => {
+          reject(`Fail to get object detail for file ${fileName}`);
+        });
+      }
+      const fileModel = {
+        bucketName: bucketName,
+        fileName: fileName,
+        contentLength: buffer.length,
+        versionFile: objectDetail.versionId,
+        dateVersionFile: objectDetail.lastModified,
+      };
+
+      return new Promise((resolve, reject) => {
+        resolve(fileModel);
+      });
+    }
+  }
+
+  public async validateFileSize(fileName: string, fileSize: number) {
+    var sizeAllowed = await this.isFileSizeAllowed(fileSize);
+    if (!sizeAllowed) {
+      console.error(
+        `File size of ${fileName} too big to upload. Currently max file size allowed is ${
+          Number(ConfigFileRules.MaxChunkCountAllowed) *
+          Number(ConfigFileRules.ChunkSize)
+        } bytes`
+      );
+      //   throw new OssApiError(`${requestId} File size too big to upload. Currently max file size allowed is ${Number(ConfigFileRules.MaxChunkCountAllowed) * Number(Constants.ChunkSize)} bytes`);
+    }
+  }
+
+  private async isFileSizeAllowed(fileSize: number): Promise<boolean> {
+    const numberOfChunks: number = this.calculateNumberOfChunks(fileSize);
+    if (numberOfChunks > ConfigFileRules.MaxChunkCountAllowed) {
+      return false;
+    }
+    return true;
+  }
+
+  public calculateNumberOfChunks(fileSize: number): number {
+    if (fileSize == 0) {
+      return 1;
+    }
+    var numberOfChunks: number = Math.trunc(
+      fileSize / ConfigFileRules.ChunkSize
+    );
+
+    if (fileSize % ConfigFileRules.ChunkSize != 0) {
+      numberOfChunks++;
+    }
+    return numberOfChunks;
+  }
+
+  public async getObjectDetail(
+    bucketName: string,
+    fileName: string,
+    accessToken?: string
+  ) {
+    try {
+      const url = `${Path.BaseURL}${Path.GetObjectDetail}`;
+      const headers: any = {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        "ngrok-skip-browser-warning": true,
+      };
+      let queryParams: any;
+      if (validString(bucketName)) {
+        queryParams = { ...queryParams, bucketName: bucketName };
+      }
+      if (validString(fileName)) {
+        queryParams = { ...queryParams, objectName: fileName };
+      }
+      const response = await fetch(
+        `${url}?${new URLSearchParams(queryParams)}`,
+        {
+          method: "GET",
+          headers: headers,
+        }
+      );
+      if (response.ok) {
+        const json: BaseReponseModel<ObjectDetail> =
+          (await response.json()) as BaseReponseModel<ObjectDetail>;
+        if (json.statusCode === ApiStatus.Success) {
+          return json.data;
+        } else {
+          console.error(
+            `Fail to generate presigned urls with message error: ${json.message}`
+          );
+        }
+      } else {
+        console.error(
+          `Fail to generate presigned urls with status ${response.statusText} and error: ${response.statusText}`
+        );
+      }
+    } catch (error) {
+      console.error(`Error when get file info: ${error}`);
+    }
+
+    return null;
+  }
+
+  public async initMultiPartUpload(
+    bucketName: string,
+    fileName: string,
+    accessToken?: string,
+    autoCreateBucket?: boolean | false,
+    cancellationToken?: AbortController
+  ) {
+    try {
+      const url = `${Path.BaseURL}${Path.InitiateMultipartUpload}`;
+      const headers: any = {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        "ngrok-skip-browser-warning": true,
+      };
+
+      let queryParams: any;
+      if (validString(bucketName)) {
+        queryParams = { ...queryParams, bucketName: bucketName };
+      }
+      if (validString(fileName)) {
+        queryParams = { ...queryParams, objectName: fileName };
+      }
+      if (autoCreateBucket === true) {
+        queryParams = { ...queryParams, autoCreateBucket: autoCreateBucket };
+      }
+
+      queryParams = { ...queryParams, setPermission: false };
+
+      const response = await fetch(
+        `${url}?${new URLSearchParams(queryParams)}`,
+        {
+          method: "GET",
+          headers: headers,
+        }
+      );
+      if (response.ok) {
+        const json: BaseReponseModel<InitUploadResponse> =
+          (await response.json()) as BaseReponseModel<InitUploadResponse>;
+        if (json.statusCode === ApiStatus.Success) {
+          return json.data;
+        } else {
+          console.error(
+            `Fail to initiate multipart upload with message error: ${json.message}`
+          );
+        }
+      } else {
+        console.error(
+          `Fail to initiate multipart upload with status ${response.statusText} and error: ${response.statusText}`
+        );
+      }
+    } catch (error) {
+      console.error(`Error when initiate multipart upload: ${error}`);
+    }
+
+    return undefined;
+  }
+
+  public async generatePresignedUrls(
+    bucketName: string,
+    fileName: string,
+    initUpload: InitUploadResponse,
+    totalPart: number,
+    accessToken: string,
+    cancellationToken?: AbortController
+  ) {
+    try {
+      const url = `${Path.BaseURL}${Path.GeneratePresignedUrls}`;
+      const headers = initUpload.headers;
+
+      let queryParams: any;
+      if (validString(bucketName)) {
+        queryParams = { ...queryParams, bucketName: bucketName };
+      }
+      if (validString(fileName)) {
+        queryParams = { ...queryParams, objectName: fileName };
+      }
+      if (validString(initUpload.uploadId)) {
+        queryParams = { ...queryParams, uploadId: initUpload.uploadId };
+      }
+      if (totalPart > 0) {
+        queryParams = { ...queryParams, totalPart: totalPart };
+      }
+
+      const newHeaders: any = {
+        Authorization: `Bearer ${accessToken}`,
+        "ngrok-skip-browser-warning": true,
+      };
+      const response = await fetch(
+        `${url}?${new URLSearchParams(queryParams)}`,
+        {
+          method: "GET",
+          headers: { ...headers, ...newHeaders },
+          signal: cancellationToken?.signal
+        }
+      );
+      if (response.ok) {
+        const json: BaseReponseModel<string[]> =
+          (await response.json()) as BaseReponseModel<string[]>;
+        if (json.statusCode === ApiStatus.Success) {
+          return json.data;
+        } else {
+          console.error(
+            `Fail to generate presigned urls with message error: ${json.message}`
+          );
+        }
+      } else {
+        console.error(
+          `Fail to generate presigned urls with status ${response.statusText} and error: ${response.statusText}`
+        );
+      }
+
+      return null;
+    } catch (error) {
+      console.error(`Error when generate presigned urls: ${error}`);
+    }
+  }
+
+  public throwIfCancellationRequested(
+    cancellationToken: AbortController,
+    fileName: string
+  ) {
+    if (cancellationToken.signal.aborted) {
+      console.error(`${fileName} Cancellation requested.`);
+      cancellationToken.signal.throwIfAborted();
+    }
+  }
+
+  // public readFileBytes(file: Buffer, start: number, end: number): Buffer {
+  //   const fileReader = file.subarray(start, end);
+  //   return fileReader;
+  // }
+
+  public readFileBytes(file: File, start: number, end: number): Promise<ArrayBuffer> {
+    return new Promise((resolve, reject) => {
+      const blob = file.slice(start, end); // tạo blob từ phần file cần đọc
+      const reader = new FileReader();
+  
+      reader.onload = () => {
+        if (reader.result instanceof ArrayBuffer) {
+          resolve(reader.result);
+        } else {
+          reject(new Error("Failed to read as ArrayBuffer"));
+        }
+      };
+  
+      reader.onerror = () => reject(reader.error);
+      reader.readAsArrayBuffer(blob); // đọc phần blob thành ArrayBuffer
+    });
+  }
+  
+  public async completeMultipartUpload(
+    bucketName: string,
+    fileName: string,
+    uploadId: string,
+    eTags: object,
+    accessToken?: string,
+    cancellationToken?: AbortController
+  ) {
+    try {
+      const url = `${Path.BaseURL}${Path.CompleteMultipartUpload}`;
+      const headers: any = {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        "ngrok-skip-browser-warning": true,
+      };
+
+      let body: any;
+      if (validString(bucketName)) {
+        body = { ...body, bucketName: bucketName };
+      }
+      if (validString(fileName)) {
+        body = { ...body, objectName: fileName };
+      }
+      if (validString(uploadId)) {
+        body = { ...body, uploadId: uploadId };
+      }
+      if (eTags) {
+        body = { ...body, eTags: eTags };
+      }
+      const bodyString = JSON.stringify(body);
+      const response = await fetch(url, {
+        method: "POST",
+        headers: headers,
+        body: bodyString,
+        signal: cancellationToken?.signal
+      });
+      if (response.ok) {
+        const json: BaseReponseModel<CompleteMultipartUploadResponse> =
+          (await response.json()) as BaseReponseModel<CompleteMultipartUploadResponse>;
+        if (json.statusCode === ApiStatus.Success) {
+          return json.data;
+        } else {
+          console.error(
+            `Fail to complete multiple part upload with message error: ${json.message}`
+          );
+        }
+      } else {
+        console.error(
+          `Fail to complete multiple part upload with status ${response.statusText} and error: ${response.statusText}`
+        );
+      }
+
+      return false;
+    } catch (error) {
+      console.error(`Error when complete multiple part upload: ${error}`);
+    }
+  }
+
+  public async generateMultiPresignedUrl(
+    bucketName: string,
+    filesName: string[],
+    accessToken?: string,
+    cancellationToken?: AbortController
+  ) {
+    try {
+      const url = `${Path.BaseURL}${Path.GenerateMultiPresignedURL}`;
+      // const url = `https://localhost:7193/api/Object/GenerateMultiPresignedURL`;
+      const headers: any = {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        "ngrok-skip-browser-warning": true,
+      };
+
+      const body = {
+        bucketName: bucketName,
+        objectNames: filesName,
+        setPermission: false
+      };
+      const bodyString = JSON.stringify(body);
+
+      const response = await fetch(url,
+        {
+          method: "POST",
+          headers: headers,
+          body: bodyString,
+          signal: cancellationToken?.signal
+        }
+      );
+      if (response.ok) {
+        const json: BaseReponseModel<MultiPresignURLResponse> =
+          (await response.json()) as BaseReponseModel<MultiPresignURLResponse>;
+        if (json.statusCode === ApiStatus.Success) {
+          return json.data;
+        } else {
+          console.error(
+            `Fail to generate multiple presigned url with message error: ${json.message}`
+          );
+        }
+      } else {
+        console.error(
+          `Fail to generate multiple presigned url with status ${response.statusText} and error: ${response.statusText}`
+        );
+      }
+
+      return null;
+    } catch (error) {
+      console.error(`Error when generate multiple presigned url: ${error}`);
+    }
+  }
+  //#endregion
+}