private async Task <(CloudStorageResult, CloudStorageFile)> UploadFileToFolderByPathAsync(string filePath, string folderName, CancellationToken ct)
{
CloudStorageResult result = new CloudStorageResult();
CloudStorageFile cloudFile = null;
try
{
FileInfo fileInfo = new FileInfo(filePath);
if (!fileInfo.Exists)
{
result.Status = Status.NotFound;
result.Message = $"File '{filePath}' does not exist.";
return(result, null);
}
// upload to dropbox root folder if folderName is empty
if (string.IsNullOrEmpty(folderName))
{
folderName = "/";
}
long fileSize = fileInfo.Length;
if (fileSize <= CHUNK_SIZE)
{
cloudFile = await UploadSmaillFile(filePath, folderName);
OnProgressChanged(fileSize); // 一次回報全部進度
}
else
{
cloudFile = await UploadBigFile(filePath, folderName, ct);
}
result.Status = Status.Success;
}
catch (TaskCanceledException ex)
{
result.Status = Status.Cancelled;
result.Message = ex.Message;
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return(result, cloudFile);
}
/// <summary>
/// 上傳小於等於 CHUNK_SIZE 的檔案。不檢查輸入檔案，不會回報進度，也不能取消。
/// </summary>
private async Task <CloudStorageFile> UploadSmaillFile(string filePath, string parentFolder)
{
using (FileStream fileStream = new FileStream(filePath, FileMode.Open))
{
if (!parentFolder.EndsWith("/"))
{
parentFolder += "/";
}
parentFolder += Path.GetFileName(filePath);
var uploadResult = await dropboxClient.Files.UploadAsync(parentFolder, autorename : true, body : fileStream);
Console.WriteLine("Finished small file: " + uploadResult.PathDisplay);
CloudStorageFile cloudFile = new CloudStorageFile()
{
Id = uploadResult.Id,
ModifiedTime = uploadResult.ServerModified,
Name = uploadResult.Name,
Size = (long)uploadResult.Size
};
return(cloudFile);
}
}
public async Task <IEnumerable <CloudStorageFile> > GetFileInfosInPathAsync(string folderId)
{
List <CloudStorageFile> fileInfos = new List <CloudStorageFile>();
try
{
var listResult = await dropboxClient.Files.ListFolderAsync(folderId);
AddEntries(listResult.Entries);
while (listResult.HasMore)
{
listResult = await dropboxClient.Files.ListFolderContinueAsync(listResult.Cursor);
AddEntries(listResult.Entries);
}
void AddEntries(IEnumerable <Metadata> entries)
{
foreach (var f in entries)
{
CloudStorageFile file = new CloudStorageFile
{
Name = f.Name,
//CreatedTime = ;
ModifiedTime = f.AsFile.ServerModified,
Id = f.AsFile.Id,
Size = (long)f.AsFile.Size
};
fileInfos.Add(file);
}
}
}
catch (Exception ex)
{
throw new FileNotFoundException(ex.Message, folderId);
}
return(fileInfos);
}
public async Task <CloudStorageFile> GetFileInfoAsync(string fileId)
{
CloudStorageFile fileInfo;
try
{
var metadata = await dropboxClient.Files.GetMetadataAsync(fileId);
fileInfo = new CloudStorageFile
{
Name = metadata.Name,
//CreatedTime = ;
ModifiedTime = metadata.AsFile.ServerModified,
Id = metadata.AsFile.Id,
Size = (long)metadata.AsFile.Size
};
}
catch (Exception ex)
{
throw new FileNotFoundException(ex.Message, fileId);
}
return(fileInfo);
}
public async Task <(CloudStorageResult, CloudStorageFile)> UploadFileToFolderByIdAsync(string filePath, string folderId, CancellationToken ct)
{
IDriveItemRequestBuilder driveItemsRequest;
if (string.IsNullOrEmpty(folderId))
{
driveItemsRequest = myDriveBuilder.Root;
}
else
{
driveItemsRequest = myDriveBuilder.Items[folderId];
}
CloudStorageResult result = new CloudStorageResult();
CloudStorageFile file = null;
// Use properties to specify the conflict behavior in this case, replace
var uploadProps = new DriveItemUploadableProperties
{
ODataType = null,
AdditionalData = new Dictionary <string, object>
{
{ "@microsoft.graph.conflictBehavior", "replace" }
}
};
try
{
// Create an upload session for a file with the same name of the user selected file
UploadSession session = await driveItemsRequest.ItemWithPath(Path.GetFileName(filePath)).CreateUploadSession(uploadProps).Request().PostAsync(ct);
using (FileStream fileStream = new FileStream(filePath, FileMode.Open))
{
var fileUploadTask = new LargeFileUploadTask <DriveItem>(session, fileStream, CHUNK_SIZE);
// Create a callback that is invoked after each slice is uploaded
IProgress <long> progressCallback = new Progress <long>((progress) =>
{
Console.WriteLine($"Uploaded {progress} bytes.");
OnProgressChanged(progress);
});
// Upload the file
var uploadResult = await fileUploadTask.UploadAsync(progressCallback);
if (uploadResult.UploadSucceeded)
{
// The ItemResponse object in the result represents the created item.
file = new CloudStorageFile()
{
Name = uploadResult.ItemResponse.Name,
Id = uploadResult.ItemResponse.Id,
CreatedTime = uploadResult.ItemResponse.CreatedDateTime?.DateTime ?? DateTime.MinValue,
ModifiedTime = uploadResult.ItemResponse.LastModifiedDateTime?.DateTime ?? DateTime.MinValue,
Size = uploadResult.ItemResponse.Size ?? 0
};
result.Status = Status.Success;
}
else
{
result.Message = "Upload failed.";
}
}
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return(result, file);
}
/// <summary>
/// 批次上傳大檔案，必須要大於 CHUNK_SIZE。僅會檢查檔案大小是否夠大。
/// </summary>
private async Task <CloudStorageFile> UploadBigFile(string filePath, string parentFolder, CancellationToken ct)
{
FileInfo fileInfo = new FileInfo(filePath);
// file size must larger than 1 chunk size
long fileSize = fileInfo.Length;
if (fileSize <= CHUNK_SIZE)
{
return(null);
}
using (FileStream fileStream = new FileStream(filePath, FileMode.Open))
{
byte[] buffer = new byte[CHUNK_SIZE];
long uploaded = 0;
string sessionId;
// read first chunk from file
int length = await fileStream.ReadAsync(buffer, 0, CHUNK_SIZE, ct);
// upload first chunk
using (MemoryStream firstStream = new MemoryStream(buffer, 0, length, false))
{
var startResult = await dropboxClient.Files.UploadSessionStartAsync(body : firstStream);
sessionId = startResult.SessionId;
firstStream.Close();
}
// update progress bar of first chunk
OnProgressChanged(length);
uploaded += length;
// upload middle chunks
while (true)
{
// check cancel
if (ct.IsCancellationRequested)
{
throw new TaskCanceledException("Upload cancelled.");
}
// read next chunk from file
length = await fileStream.ReadAsync(buffer, 0, CHUNK_SIZE, ct);
if (length <= 0)
{
break;
}
// if we reach last chung, don't upload now!
if (uploaded + length >= fileSize)
{
break;
}
// upload each chunk
using (MemoryStream tempStream = new MemoryStream(buffer, 0, length, false))
{
UploadSessionCursor cursor = new UploadSessionCursor(sessionId, (ulong)uploaded);
await dropboxClient.Files.UploadSessionAppendV2Async(cursor, body : tempStream);
tempStream.Close();
}
// Update progress bar
OnProgressChanged(length);
uploaded += length;
}
// ending upload session
UploadSessionCursor endCursor = new UploadSessionCursor(sessionId, (ulong)uploaded);
// prepare file info
if (!parentFolder.EndsWith("/"))
{
parentFolder += "/";
}
parentFolder += Path.GetFileName(filePath);
CommitInfo info = new CommitInfo(parentFolder, autorename: true);
// do last session
FileMetadata finishResult;
using (MemoryStream tempStream = new MemoryStream(buffer, 0, length, false))
{
finishResult = await dropboxClient.Files.UploadSessionFinishAsync(endCursor, info, tempStream);
Console.WriteLine("Finished large file: " + finishResult.PathDisplay);
}
// update last progress
OnProgressChanged(length);
fileStream.Close();
// return new file info
CloudStorageFile cloudFile = new CloudStorageFile()
{
Id = finishResult.Id,
ModifiedTime = finishResult.ServerModified,
Name = finishResult.Name,
Size = (long)finishResult.Size
};
return(cloudFile);
}
}
public ActionResult DeleteFile(CloudStorageFile file)
{
GoogleDriveFilesRepository.DeleteFile(file);
return(RedirectToAction("GetGoogleDriveFiles"));
}
