File Handling

import { FileRepository } from '@amityco/ts-sdk';

async function uploadFile(file: File) {
  const formData = new FormData();
  formData.append('files', file);

  const { data: files } = await FileRepository.uploadFile(formData, percent => {
    console.log(`Upload progress: ${percent}%`);
  });

  const uploadedFile = files[0];
  return uploadedFile.fileId;
}

let fileURL = URL(fileURLWithPath: "/tmp/document.pdf")

let uploadedFile = try await fileRepository.uploadFile(
    with: fileURL,
    fileName: "document.pdf",
    progress: { progress in
        print("Upload progress: \(progress)")
    }
)

let uploadedFileId = uploadedFile.fileId

val fileUri = Uri.parse("file:///tmp/document.pdf")

AmityCoreClient.newFileRepository()
    .uploadFile(fileUri)
    .doOnNext { result: AmityUploadResult<AmityFile> ->
        when (result) {
            is AmityUploadResult.PROGRESS -> {
                val progress = result.getUploadInfo().getProgressPercentage()
            }
            is AmityUploadResult.COMPLETE -> {
                val uploadedFile = result.getFile()
                val uploadedFileId = uploadedFile.getFileId()
            }
            is AmityUploadResult.ERROR -> {
                val error = AmityError.from(result.getError())
            }
            is AmityUploadResult.CANCELLED -> {
                // Upload was canceled.
            }
        }
    }
    .subscribe()

import 'dart:io';

final file = File('/tmp/document.pdf');

AmityCoreClient.newFileRepository()
    .uploadFile(file)
    .stream
    .listen((AmityUploadResult<AmityFile> result) {
  result.when(
    progress: (uploadInfo, cancelToken) {
      final progress = uploadInfo.getProgressPercentage();
    },
    complete: (uploadedFile) {
      final uploadedFileId = uploadedFile.fileId;
      final uploadedFileUrl = uploadedFile.getUrl;
    },
    error: (error) {
      final exception = error;
    },
    cancel: () {
      // Upload was canceled.
    },
  );
});

import { FileRepository } from '@amityco/ts-sdk';

async function getFile(fileId: string) {
  const { data: file } = await FileRepository.getFile<'file'>(fileId);

  return {
    fileId: file.fileId,
    fileUrl: file.fileUrl,
    name: file.attributes.name,
    mimeType: file.attributes.mimeType,
  };
}

let rawFile = try await fileRepository.getFile(fileId: fileId)

if rawFile.type == .file, let fileData = rawFile.mapToFileData() {
    let localURL = try await fileRepository.downloadFile(fromURL: fileData.fileURL)
    print("Downloaded file to \(localURL)")
}

AmityCoreClient.newFileRepository()
    .getFile(fileId)
    .doOnSuccess { rawFile: AmityRawFile ->
        if (rawFile.getFileType() == AmityFileType.FILE) {
            val file = rawFile.asAmityFile()
            val fileUrl = file.getUrl()
            val fileName = file.getFileName()
        }
    }
    .subscribe()

void inspectFile(AmityFile uploadedFile) {
  final uploadedFileId = uploadedFile.fileId;
  final uploadedFileUrl = uploadedFile.getUrl;
  final uploadedFileName = uploadedFile.fileName;
}

import { FileRepository } from '@amityco/ts-sdk';

async function deleteFile(fileId: string) {
  const { success } = await FileRepository.deleteFile(fileId);
  return success;
}

try await fileRepository.deleteFile(fileId: fileId)

AmityCoreClient.newFileRepository()
    .deleteFile(fileId)
    .subscribe()