public static async Task UploadLargeAttachmentWithCallBack(IBaseClient graphClient, string messageId) { await using Stream stream = Program.GetFileStream(); var uploadSession = await CreateFileAttachmentUploadSession(graphClient, messageId, stream.Length); // Create task var maxSliceSize = 320 * 1024; // 320 KB - Change this to your slice size. LargeFileUploadTask <FileAttachment> largeFileUploadTask = new LargeFileUploadTask <FileAttachment>(uploadSession, stream, maxSliceSize); // Setup the progress mechanism IProgress <long> progress = new Progress <long>(progressCallback => { Console.WriteLine($"Uploaded {progressCallback} bytes of {stream.Length} bytes"); }); try { var uploadResult = await largeFileUploadTask.UploadAsync(progress); if (uploadResult.UploadSucceeded) { Console.WriteLine(uploadResult.Location); } } catch (ServiceException e) { Console.WriteLine("Something went wrong with the upload"); Console.WriteLine(e.Message); } }
public async Task <DriveItem> UploadLargeFileAsync(Stream stream, string targetPath, int maxSliceSize = -1, IProgress <long> progress = null) { // TODO: Support fileUploadTask.ResumeAsnyc var uploadSession = await AppRoot.ItemWithPath(targetPath) .CreateUploadSession().Request().PostAsync().ConfigureAwait(false); var fileUploadTask = new LargeFileUploadTask <DriveItem>(uploadSession, stream, maxSliceSize < 0 ? 1024 * 320 : maxSliceSize); try { var uploadResult = await fileUploadTask.UploadAsync(progress).ConfigureAwait(false); if (uploadResult.UploadSucceeded) { return(uploadResult.ItemResponse); } else { return(null); } } catch (ServiceException) { throw; } }
/// <summary> /// Upload a large file using callbacks /// </summary> /// <param name="graphClient">Client for upload</param> /// <param name="itemId">itemId for upload</param> /// <returns></returns> public static async Task UploadLargeFileWithCallBacks(IBaseClient graphClient, string itemId) { await using Stream stream = Program.GetFileStream(); // POST /v1.0/drive/items/01KGPRHTV6Y2GOVW7725BZO354PWSELRRZ:/SWEBOKv3.pdf:/microsoft.graph.createUploadSession var uploadSession = await CreateDriveItemUploadSession(graphClient, itemId); // Create task var maxSliceSize = 320 * 1024; // 320 KB - Change this to your chunk size. 5MB is the default. LargeFileUploadTask <DriveItem> largeFileUploadTask = new LargeFileUploadTask <DriveItem>(uploadSession, stream, maxSliceSize); // Setup the progress monitoring IProgress <long> progress = new Progress <long>(progressCallBack => { Console.WriteLine($"Uploaded {progressCallBack} bytes of {stream.Length} bytes"); }); try { var uploadResult = await largeFileUploadTask.UploadAsync(progress); if (uploadResult.UploadSucceeded) { Console.WriteLine($"File Uploaded {uploadResult.ItemResponse.Id}");//Successful Upload } } catch (ServiceException e) { Console.WriteLine("Something went wrong with the upload"); Console.WriteLine(e.Message); } }
public async Task UploadDocumentAsync(string directory, string fileName, Stream content) { // Based on example at https://docs.microsoft.com/en-us/graph/sdks/large-file-upload?tabs=csharp var filePath = $"{directory}/{fileName}"; var uploadProps = new DriveItemUploadableProperties { ODataType = null, AdditionalData = new Dictionary <string, object> { { "@microsoft.graph.conflictBehavior", "replace" } } }; // Create the upload session // itemPath does not need to be a path to an existing item var uploadSession = await _client.Drives[_fileStorageConfig.DriveId].Root .ItemWithPath(filePath) .CreateUploadSession(uploadProps) .Request() .PostAsync(); // Max slice size must be a multiple of 320 KiB int maxSliceSize = 320 * 1024; var fileUploadTask = new LargeFileUploadTask <DriveItem>(uploadSession, content, maxSliceSize); _logger.LogInformation($"Starting upload file to drive {_fileStorageConfig.DriveId} on path {filePath}"); // Create a callback that is invoked after each slice is uploaded IProgress <long> progress = new Progress <long>(progress => { _logger.LogDebug($"Uploaded {progress} bytes of stream"); }); try { var uploadResult = await fileUploadTask.UploadAsync(progress); if (uploadResult.UploadSucceeded) { _logger.LogInformation($"Uploading file to drive {_fileStorageConfig.DriveId} on path {directory} succeeded (item id: {uploadResult.ItemResponse.Id}"); } else { _logger.LogError($"Uploading file to drive {_fileStorageConfig.DriveId} on path {directory} failed."); throw new CodedException("UploadFailed", "Upload failed", $"Uploading file to drive {_fileStorageConfig.DriveId} on path {directory} failed."); } } catch (TaskCanceledException ex) { _logger.LogError($"Uploading file to drive {_fileStorageConfig.DriveId} on path {directory} failed: {ex.ToString()}"); throw ex; } catch (ServiceException ex) { _logger.LogError($"Uploading file to drive {_fileStorageConfig.DriveId} on path {directory} failed: {ex.ToString()}"); throw ex; } }
public async void UploadToOneDrive(string filepath, string onedrivepath) { var graphServiceClient = new GraphServiceClient( new DelegateAuthenticationProvider((requestMessage) => { requestMessage.Headers.Authorization = new AuthenticationHeaderValue("bearer", AccessToken); return(Task.CompletedTask); })); //GraphServiceClient graphClient = new GraphServiceClient("https://graph.microsoft.com/v1.0", new DelegateAuthenticationProvider(async (requestMessage) => //{ // requestMessage.Headers.Authorization = new AuthenticationHeaderValue("bearer", AccessToken); //})); using (var fileStream = System.IO.File.OpenRead(filepath)) { // 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" } } }; // Create the upload session // itemPath does not need to be a path to an existing item var uploadSession = await graphServiceClient.Me.Drive.Root.ItemWithPath(onedrivepath).CreateUploadSession(uploadProps).Request().PostAsync(); // Max slice size must be a multiple of 320 KiB int maxSliceSize = 320 * 1024; var fileUploadTask = new LargeFileUploadTask <DriveItem>(uploadSession, fileStream, maxSliceSize); try { // Upload the file var uploadResult = await fileUploadTask.UploadAsync(); if (uploadResult.UploadSucceeded) { toolStripStatusLabel1.Text = filepath + " 上传成功"; } else { MessageBox.Show("上传失败,请检查网络!"); } } catch (ServiceException ex) { MessageBox.Show($"在上传过程中出现错误: {ex}"); } } }
public static async Task <DriveItem> UploadDocumentAsync(IDriveItemRequestBuilder driveItemRequestBuilder, string filename, Stream fileStream, string conflictBehaviour = ConflictBehaviour.Rename) { UploadSession uploadSession = null; try { var uploadProps = new DriveItemUploadableProperties { ODataType = null, AdditionalData = new Dictionary <string, object> { ["@microsoft.graph.conflictBehavior"] = conflictBehaviour } }; uploadSession = await driveItemRequestBuilder .ItemWithPath(filename) .CreateUploadSession(uploadProps) .Request() .PostAsync(); } catch (ServiceException ex) { throw new Exception("An error occured while creating upload session.", ex); } if (uploadSession == null) { throw new Exception("Upload session is null."); } try { // Performs upload, slice by slice int maxSliceSize = 5 * 1024 * 1024; //5MB var fileUploadTask = new LargeFileUploadTask <DriveItem>(uploadSession, fileStream, maxSliceSize); var uploadResult = await fileUploadTask.UploadAsync(); if (!uploadResult.UploadSucceeded) { throw new Exception("File upload failed!"); } else { return(uploadResult.ItemResponse); } } catch (Exception ex) { throw new Exception("An error occurred while trying to upload document.", ex); } }
// Upload attachments public async Task <UploadResult <AttachmentItem> > UploadAttachment(UploadSession uploadSession, FileStream attachmentStream) { int fileSlice = 320 * 1024; var fileUploadTask = new LargeFileUploadTask <AttachmentItem>(uploadSession, attachmentStream, fileSlice); IProgress <long> progress = new Progress <long>(progress => { Console.WriteLine($"Uploaded {progress} bytes of {attachmentStream.Length} bytes"); }); // Upload the file return(await fileUploadTask.UploadAsync(progress)); }
/// <summary> /// Take a file greater than 4MB and upload it to the service /// </summary> /// <param name="fileToUpload">The file that we want to upload</param> /// <param name="uploadToSharePoint">Should we upload to SharePoint or OneDrive?</param> public async Task <DriveItem> UploadLargeFile(string fileToUpload, bool uploadToSharePoint) { DriveItem uploadedFile = null; FileStream fileStream = new FileStream(fileToUpload, FileMode.Open); UploadSession uploadSession = null; // Do we want OneDrive for Business/Consumer or do we want a SharePoint Site? if (uploadToSharePoint) { uploadSession = await _graphClient.Sites["root"].Drive.Root.ItemWithPath(fileToUpload).CreateUploadSession().Request().PostAsync(); } else { uploadSession = await _graphClient.Me.Drive.Root.ItemWithPath(fileToUpload).CreateUploadSession().Request().PostAsync(); } if (uploadSession != null) { // Chunk size must be divisible by 320KiB, our chunk size will be slightly more than 1MB int maxSizeChunk = (320 * 1024) * 4; var fileUploadTask = new LargeFileUploadTask <DriveItem>(uploadSession, fileStream, maxSizeChunk); // Create a callback that is invoked after each slice is uploaded IProgress <long> progress = new Progress <long>(prog => { Console.WriteLine($"Uploaded {prog} bytes of {fileStream.Length} bytes"); }); try { // Upload the file var uploadResult = await fileUploadTask.UploadAsync(progress); if (uploadResult.UploadSucceeded) { uploadedFile = uploadResult.ItemResponse; } else { Console.WriteLine("Upload failed"); } } catch (ServiceException ex) { Console.WriteLine($"Error uploading: {ex.ToString()}"); } } return(uploadedFile); }
public UploadResult <DriveItem> ReplaceLargeFile(DriveItem item, Stream stream) { UploadResult <DriveItem> uploadResult = null; using (var fileStream = (FileStream)stream) { var uploadProps = new DriveItemUploadableProperties { ODataType = null, AdditionalData = new Dictionary <string, object> { { "@microsoft.graph.conflictBehavior", "replace" } } }; var uploadSession = graphClient.Drive.Root .ItemWithPath(item.Name) .CreateUploadSession(uploadProps) .Request() .PostAsync(); int maxSliceSize = 320 * 1024; var fileUploadTask = new LargeFileUploadTask <DriveItem>(uploadSession.Result, fileStream, maxSliceSize); IProgress <long> progress = new Progress <long>(slice => { Console.WriteLine($"Uploaded {slice} bytes of {fileStream.Length} bytes"); }); try { uploadResult = fileUploadTask.UploadAsync(progress).Result; if (uploadResult.UploadSucceeded) { Console.WriteLine($"Upload complete, item ID: {uploadResult.ItemResponse.Id}"); } else { Console.WriteLine("Upload failed"); } } catch (ServiceException ex) { Console.WriteLine($"Error uploading: {ex.ToString()}"); } } return(uploadResult); }
public async Task UploadLargeFileAsync(string siteUrl, string pathToFile) { var uriSite = new Uri(siteUrl); var siteCollection = await graphServiceClient.Sites.GetByPath(uriSite.AbsolutePath, uriSite.Host).Request().GetAsync(); var drive = graphServiceClient.Sites[siteCollection.Id].Drive.Root; using var fileStream = new FileStream(pathToFile, FileMode.Open, FileAccess.Read); var uploadProps = new DriveItemUploadableProperties { ODataType = null, AdditionalData = new Dictionary <string, object> { { "@microsoft.graph.conflictBehavior", "replace" } } }; var uploadSession = await drive .ItemWithPath("Engagement Request File/AuvenirApis.docx") .CreateUploadSession(uploadProps) .Request() .PostAsync(); int maxSliceSize = 320 * 1024; var fileUploadTask = new LargeFileUploadTask <DriveItem>(uploadSession, fileStream, maxSliceSize); IProgress <long> progress = new Progress <long>(progress => { Console.WriteLine($"Uploaded {progress} bytes of {fileStream.Length} bytes"); }); try { var uploadResult = await fileUploadTask.UploadAsync(progress); if (uploadResult.UploadSucceeded) { Console.WriteLine($"Upload complete, item ID: {uploadResult.ItemResponse.Id}"); } else { Console.WriteLine("Upload failed"); } } catch (ServiceException ex) { Console.WriteLine($"Error uploading: {ex.ToString()}"); } }
public async Task <bool> UploadFileAsync(StorageFile localFile, CancellationToken cancellationToken) { if (!await IsAuthenticatedAsync().ConfigureAwait(false)) { return(false); } try { bool uploadSucceeded = await CoreHelper.RetryAsync(async() => { using (await _semaphore.WaitAsync(cancellationToken).ConfigureAwait(false)) using (IRandomAccessStream localFileContent = await localFile.OpenReadAsync()) using (Stream localFileContentStream = localFileContent.AsStreamForRead()) { // the main data file may be > 4 MB, so we use an upload session in case. UploadSession uploadSession = await _graphClient.Drive.Special.AppRoot .ItemWithPath(localFile.Name) .CreateUploadSession().Request() .PostAsync(cancellationToken).ConfigureAwait(false); var largeFileUploadTask = new LargeFileUploadTask <DriveItem>(uploadSession, localFileContentStream, TransferBufferSize); UploadResult <DriveItem> uploadedFile = await largeFileUploadTask.UploadAsync().ConfigureAwait(false); return(uploadedFile.UploadSucceeded); } }).ConfigureAwait(false); _logger.LogEvent(UploadFileEvent, $"Upload succeeded == {uploadSucceeded}"); return(uploadSucceeded); } catch (Exception ex) { _logger.LogFault(UploadFileFaultEvent, "Unable to upload a file.", ex); return(false); } }
private async Task <bool> MessageCreateUploadSession(string messageId, string fileName, byte[] bytes) { try { using (Stream stream = new MemoryStream(bytes)) { var attachmentItem = new AttachmentItem { AttachmentType = AttachmentType.File, Name = fileName, Size = stream.Length }; var uploadSession = await graphClient.Me.Messages[messageId].Attachments .CreateUploadSession(attachmentItem) .Request() .PostAsync(); var maxChunkSize = 320 * 1024; var largeFileUploadTask = new LargeFileUploadTask <FileAttachment>(uploadSession, stream, maxChunkSize); var uploadResult = await largeFileUploadTask.UploadAsync(); if (uploadResult.UploadSucceeded) { return(true); } return(false); } } catch (Exception ex) { //Logger.ErrorFormat("CreateUploadSession - Upload failed ex: {0}", ex); return(false); } }
/// <summary> /// Allows you to send files to sharepoint. Repository: https://github.com/MarcinMichnik-HiQ/Frends.Office /// </summary> /// <param name="input"></param> /// <returns>Returns JToken.</returns> public static async Task <JToken> ExportFileToSharepoint(ExportFileToSharepointInput input) { IConfidentialClientApplication confidentialClientApplication = ConfidentialClientApplicationBuilder .Create(input.clientID) .WithTenantId(input.tenantID) .WithClientSecret(input.clientSecret) .Build(); ClientCredentialProvider authProvider = new ClientCredentialProvider(confidentialClientApplication); // Create a new instance of GraphServiceClient with the authentication provider. IGraphServiceClient graphClient = new GraphServiceClient(authProvider); string fileLength; string url = ""; // Get fileName from the sourceFilePath string[] sourcePathSplit = input.sourceFilePath.Split('\\'); string fileName = sourcePathSplit.Last(); try { using (FileStream fileStream = System.IO.File.OpenRead(input.sourceFilePath)) { fileLength = fileStream.Length.ToString(); try { // Use properties to specify the conflict behavior // in this case, replace DriveItemUploadableProperties uploadProps = new DriveItemUploadableProperties { ODataType = null, AdditionalData = new Dictionary <string, object> { { "@microsoft.graph.conflictBehavior", "replace" } } }; // Create the upload session // itemPath does not need to be a path to an existing item UploadSession uploadSession = await graphClient .Sites[input.siteID] .Drives[input.driveID] .Root .ItemWithPath(input.targetFolderPath + fileName) .CreateUploadSession(uploadProps) .Request() .PostAsync(); // Max slice size must be a multiple of 320 KiB int maxSliceSize = 320 * 2048; LargeFileUploadTask <DriveItem> fileUploadTask = new LargeFileUploadTask <DriveItem>(uploadSession, fileStream, maxSliceSize); // Create a callback that is invoked after each slice is uploaded IProgress <long> progress = new Progress <long>(); url = uploadSession.UploadUrl; try { // Upload the file UploadResult <DriveItem> uploadResult = await fileUploadTask.UploadAsync(progress); } catch (ServiceException ex) { await fileUploadTask.DeleteSessionAsync(); throw new Exception("Unable to send file.", ex); } } catch (ServiceException ex) { throw new Exception("Unable to establish connection to Sharepoint.", ex); } } } catch (ServiceException ex) { throw new Exception("Unable to open file.", ex); } JToken taskResponse = JToken.Parse("{}"); taskResponse["FileSize"] = fileLength; taskResponse["Path"] = input.sourceFilePath.ToString(); taskResponse["FileName"] = fileName.ToString(); taskResponse["TargetFolderName"] = input.targetFolderPath.ToString(); taskResponse["ClientID"] = input.clientID; taskResponse["TenantID"] = input.tenantID.ToString(); taskResponse["SiteID"] = input.siteID.ToString(); taskResponse["DriveID"] = input.driveID.ToString(); taskResponse["UploadUrl"] = url; return(taskResponse); }
public static void Main(string[] args) { var config = LoadAppSettings(); if (config == null) { Console.WriteLine("Invalid appsettings.json file."); return; } var client = GetAuthenticatedGraphClient(config); var profileResponse = client.Me.Request().GetAsync().Result; Console.WriteLine("Hello " + profileResponse.DisplayName); // request 1 - upload small file to user's onedrive // var fileName = "smallfile.txt"; // var filePath = Path.Combine(System.IO.Directory.GetCurrentDirectory(), fileName); // Console.WriteLine("Uploading file: " + fileName); // FileStream fileStream = new FileStream(filePath, FileMode.Open); // var uploadedFile = client.Me.Drive.Root // .ItemWithPath("smallfile.txt") // .Content // .Request() // .PutAsync<DriveItem>(fileStream) // .Result; // Console.WriteLine("File uploaded to: " + uploadedFile.WebUrl); // request 2 - upload large file to user's onedrive var fileName = "largefile.zip"; var filePath = Path.Combine(System.IO.Directory.GetCurrentDirectory(), fileName); Console.WriteLine("Uploading file: " + fileName); // load resource as a stream using (Stream stream = new FileStream(filePath, FileMode.Open)) { var uploadSession = client.Me.Drive.Root .ItemWithPath(fileName) .CreateUploadSession() .Request() .PostAsync() .Result; // create upload task var maxChunkSize = 320 * 1024; var largeUploadTask = new LargeFileUploadTask <DriveItem>(uploadSession, stream, maxChunkSize); // create progress implementation IProgress <long> uploadProgress = new Progress <long>(uploadBytes => { Console.WriteLine($"Uploaded {uploadBytes} bytes of {stream.Length} bytes"); }); // upload file UploadResult <DriveItem> uploadResult = largeUploadTask.UploadAsync(uploadProgress).Result; if (uploadResult.UploadSucceeded) { Console.WriteLine("File uploaded to user's OneDrive root folder."); } } }
private void UploadFile(string path, MemoryStream stream) { try { Task.Run(async() => { PathItemBuilder pathItemBuilder = await GetPathItemBuilder(path); //for small files <2MB use the direct upload: if (stream.Length < 2 * 1024 * 1024) { return(await pathItemBuilder .getPathItem() .Content .Request() .PutAsync <DriveItem>(stream)); } //for larger files use an upload session. This is required for 4MB and beyond, but as the docs are not very clear about this //limit, let's use it a bit more often to be safe. var uploadProps = new DriveItemUploadableProperties { ODataType = null, AdditionalData = new Dictionary <string, object> { { "@microsoft.graph.conflictBehavior", "replace" } } }; var uploadSession = await pathItemBuilder .getPathItem() .CreateUploadSession(uploadProps) .Request() .PostAsync(); // Max slice size must be a multiple of 320 KiB int maxSliceSize = 320 * 1024; var fileUploadTask = new LargeFileUploadTask <DriveItem>(uploadSession, stream, maxSliceSize); var uploadResult = await fileUploadTask.UploadAsync(); if (!uploadResult.UploadSucceeded) { throw new Exception("Failed to upload data!"); } return(uploadResult.ItemResponse); }).Wait(); } catch (Exception e) { Task.Run(async() => { PathItemBuilder pathItemBuilder = await GetPathItemBuilder(path); pathItemBuilder.verbose = true; pathItemBuilder.getPathItem(); }).Wait(); throw convertException(e); } }
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); }
public async Task <IActionResult> UploadFile(string folderId, List <IFormFile> uploadFiles) { if (string.IsNullOrEmpty(folderId)) { return(RedirectToAction("UploadFile") .WithError("No folder ID was specified")); } try { var graphClient = GetGraphClientForScopes(_filesScopes); var file = uploadFiles.First(); // 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" } } }; // POST /me/drive/items/folderId:/fileName:/createUploadSession var uploadSession = await graphClient.Me .Drive .Items[folderId] .ItemWithPath(file.FileName) .CreateUploadSession(uploadProps) .Request() .PostAsync(); // Max slice size must be a multiple of 320 KiB // This amount of bytes will be uploaded each iteration int maxSliceSize = 320 * 1024; var fileUploadTask = new LargeFileUploadTask <DriveItem>(uploadSession, file.OpenReadStream(), maxSliceSize); // Create a callback that is invoked after each slice is uploaded IProgress <long> callback = new Progress <long>(progress => { _logger.LogInformation($"Uploaded {progress} bytes of {file.Length} bytes"); }); // Start the upload var uploadResult = await fileUploadTask.UploadAsync(callback); if (uploadResult.UploadSucceeded) { // On success, the new file is contained in the // ItemResponse property of the result return(RedirectToAction("Display", new { fileId = uploadResult.ItemResponse.Id }) .WithSuccess("File uploaded")); } return(RedirectToAction("Index", new { folderId = folderId }) .WithError("Error uploading file")); } catch (ServiceException ex) { InvokeAuthIfNeeded(ex); return(RedirectToAction("Index", new { folderId = folderId }) .WithError("Error uploading file", ex.Error.Message)); } }
// Upload File to Onedrive public async Task <string> transferDataToOnedrive(String FilePath) { var fileName = Path.GetFileName(FilePath); if (null == this.graphClient) { return(""); } Label lb = (Label)System.Windows.Forms.Application.OpenForms["Form1"].Controls.Find("label4", false).FirstOrDefault(); using (var fileStream = System.IO.File.OpenRead(FilePath)) { // 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" } } }; // Create the upload session // itemPath does not need to be a path to an existing item var uploadSession = await graphClient.Me.Drive.Root .ItemWithPath("ClipboardShare/" + fileName) .CreateUploadSession(uploadProps) .Request() .PostAsync(); int maxSliceSize = UploadDownloadChunkSize; var fileUploadTask = new LargeFileUploadTask <DriveItem>(uploadSession, fileStream, maxSliceSize); // Create a callback that is invoked after each slice is uploaded IProgress <long> progress = new Progress <long>(progress => { Console.WriteLine($"Uploaded {progress} bytes of {fileStream.Length} bytes"); lb.Text = StaticHelpers.BytesToString(progress) + " " + ($" from { StaticHelpers.BytesToString(fileStream.Length) }"); }); try { // Upload the file var uploadResult = await fileUploadTask.UploadAsync(progress); if (uploadResult.UploadSucceeded) { // The ItemResponse object in the result represents the // created item. Console.WriteLine($"Upload complete, item ID: {uploadResult.ItemResponse.Id}"); } else { Console.WriteLine("Upload failed"); } } catch (ServiceException ex) { Console.WriteLine($"Error uploading: {ex.ToString()}"); } } lb.Text = ""; return(""); }