/// <summary>Uploads file in existing folder in Dropbox.</summary> /// <param name="folder"> /// Path to the folder. Always begin with "/" - the root Dropbox folder. Example: "/Contests/Active" /// </param> /// <param name="file">Name of the file with the filename extension. Example: "Abstract5567.jpg"</param> /// <param name="content">A generic view of a sequence of bytes. (Stream)</param> /// <returns>On success returns shared link of the file, otherwise null.</returns> public static async Task<string> Upload(string folder, string file, Stream content) { string sharedLink = null; using (var dbx = new DropboxClient(DropboxAppAccessToken)) { using (var mem = new MemoryStream()) { content.Position = 0; content.CopyTo(mem); mem.Position = 0; try { var uploaded = await dbx.Files.UploadAsync( folder + "/" + file, WriteMode.Overwrite.Instance, body: mem); var sharedLinkArg = new Dropbox.Api.Sharing.CreateSharedLinkArg(folder + "/" + file); var link = await dbx.Sharing.CreateSharedLinkAsync(sharedLinkArg); sharedLink = link.Url; } catch (Exception) { } } } return sharedLink; }
public async Task<DocumentMetadata> Upload(string folder, string file, Stream content) { using (DropboxClient dropboxClient = new DropboxClient(this.accessToken)) { try { folder = folder.TrimEnd('/', '\\').Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); file = file.TrimStart('/', '\\'); var updated = await dropboxClient.Files.UploadAsync( folder + "/" + file, WriteMode.Overwrite.Instance, false, null, false, content); return new DocumentMetadata { Id = updated.Id, RevisionId = updated.Rev, ServerModified = updated.ServerModified, Size = updated.Size }; } catch (ApiException<UploadError> ex) { throw new UploadFailedException( string.Format("Upload failed for the next file: {0}", Path.Combine(folder, file)), ex); } } }
public DropboxClientWrapper() { dropboxClient = new DropboxClient(Config.DropBoxAuthKey); dropboxHttpClient = new HttpClient(); dropboxHttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Config.DropBoxAuthKey); }
public async Task GetAccount() { using (var client = new DropboxClient(AccessToken)) { Account = await client.Users.GetCurrentAccountAsync(); } }
public async Task Connetti(string token) { Connection = new DropboxClient(token); await Credenziali(); await RefreshFolderList(); await RefreshFileList(); }
public async Task<byte[]> DownloadContentAsByteArray(DropboxClient client, DownloadArg arg) { using (var response = await client.Files.DownloadAsync(arg)) { return await response.GetContentAsByteArrayAsync(); } }
public DropBox(string loginAccessToken) { DropboxClientConfig config; HttpClient httpClient; Dropbox.Api.Users.FullAccount userDropoBox; httpClient = new HttpClient(new WebRequestHandler { ReadWriteTimeout = 10 * 1000 }) { // Specify request level timeout which decides maximum time that can be spent on // download/upload files. Timeout = TimeSpan.FromMinutes(20) }; config = new DropboxClientConfig() { HttpClient = httpClient }; AccessToken = loginAccessToken; client = new Dropbox.Api.DropboxClient(AccessToken, config); userDropoBox = client.Users.GetCurrentAccountAsync().Result; User = new User(userDropoBox.Name.DisplayName, userDropoBox.Locale, userDropoBox.Email, userDropoBox.ProfilePhotoUrl, userDropoBox.EmailVerified); }
public static async Task<Dictionary<string, List<Tuple<string, string>>>> GetAllSharedLinks() { var linkList = new Dictionary<string, List<Tuple<string, string>>>(); using (var dbx = new DropboxClient(DropboxAppAccessToken)) { //var arg = new Dropbox.Api.Sharing.GetSharedLinksArg("folder"); var list = await dbx.Sharing.GetSharedLinksAsync(); foreach(var link in list.Links) { var imgName = link.AsPath.Path.Substring(link.AsPath.Path.LastIndexOf('/') + 1); string path = link.AsPath.Path.Replace("/" + imgName, ""); string rawUrl = link.Url.Substring(0, link.Url.Length - DropboxURLSuffix.Length) + RawURLSuffix; if (path != string.Empty && imgName != "www.dropbox.com.url") { if (!linkList.ContainsKey(path)) { linkList.Add(path, new List<Tuple<string, string>>()); } linkList[path].Add(new Tuple<string, string>(rawUrl, imgName)); } } } return linkList; }
public async Task<ActionResult> GetFiles(string folder) { using (var dropboxClient = new DropboxClient(Common.Constants.ServerConstants.DropboxClient)) { var files = await ListUserFiles(dropboxClient, folder); return Json(files, JsonRequestBehavior.AllowGet); } }
public async Task LoadFileList() { using (var client = new DropboxClient(AccessToken)) { ListFolderResult list = await client.Files.ListFolderAsync(string.Empty); Files = list.Entries; } }
public async Task Download(string folder, string file) { using (var client = new DropboxClient(AccessToken)) { using (IDownloadResponse<FileMetadata> response = await client.Files.DownloadAsync(folder + "/" + file)) { LastDownloadedFile = await response.GetContentAsByteArrayAsync(); } } }
private static async Task Upload(DropboxClient dbx, string folder, string file, byte[] content) { using (var mem = new MemoryStream(content)) { FileMetadata updated = await dbx.Files.UploadAsync( folder + "/" + file, WriteMode.Overwrite.Instance, body: mem); Console.WriteLine("Saved {0}/{1} rev {2}", folder, file, updated.Rev); } }
public static DropboxClient GetApi(string accessToken) { var config = new DropboxClientConfig { HttpClient = ProxyTools.CreateHttpClient() }; var api = new DropboxClient(accessToken, config); return api; }
public async Task Upload(DropboxClient dbx, string folder, string file, string content) { using (var mem = new MemoryStream(Encoding.UTF8.GetBytes(content))) { var updated = await dbx.Files.UploadAsync( folder + "/" + file, Dropbox.Api.Files.WriteMode.Overwrite.Instance, body: mem); Console.WriteLine("Saved {0}/{1} rev {2}", folder, file, updated.Rev); } }
public async Task<UserInfo> GetUserInfoAsync() { UserInfo user = new UserInfo(); var config = new DropboxClientConfig() { HttpClient = client }; using (var dbx = new DropboxClient(AccessToken, config)) { var full = await dbx.Users.GetCurrentAccountAsync(); user.Email = full.Email; user.Name = full.Name.DisplayName; } return user; }
/* * ============================================ * Public * ============================================ */ /// <summary> /// Initialize the DropboxClient by login using an access token. /// </summary> public bool Login() { // No access token, we need a new one if (!this.HasAccessToken && !this.OAuth()) { return(false); } this.dbx = new DropboxApi.DropboxClient(Properties.Settings.Default.DropboxAccessToken); return(true); }
private async Task<int> Run() { InitializeCertPinning(); var accessToken = await this.GetAccessToken(); if (string.IsNullOrEmpty(accessToken)) { return 1; } // Specify socket level timeout which decides maximum waiting time when on bytes are // received by the socket. var httpClient = new HttpClient(new WebRequestHandler { ReadWriteTimeout = 10 * 1000 }) { // Specify request level timeout which decides maximum time taht can be spent on // download/upload files. Timeout = TimeSpan.FromMinutes(20) }; this.client = new DropboxClient(accessToken, userAgent: "SimpleTestApp", httpClient: httpClient); try { await GetCurrentAccount(); var path = "/DotNetApi/Help"; var list = await ListFolder(path); var firstFile = list.Entries.FirstOrDefault(i => i.IsFile); if (firstFile != null) { await Download(path, firstFile.AsFile); } await Upload(path, "Test.txt", "This is a text file"); await ChunkUpload(path, "Binary"); } catch (HttpException e) { Console.WriteLine("Exception reported from RPC layer"); Console.WriteLine(" Status code: {0}", e.StatusCode); Console.WriteLine(" Message : {0}", e.Message); if (e.RequestUri != null) { Console.WriteLine(" Request uri: {0}", e.RequestUri); } } return 0; }
public static async Task<int> UploadFile(string token, byte[] contentFile, IFileProvider fileProvider, string filename, int moduleId = -1, int hwId = -1) { string username = TokenHelper.GetFromToken(token, "username"); string role = TokenHelper.GetFromToken(token, "role"); string path = "/" + role + "/" + username + "/" + filename; var key = WebConfigurationManager.AppSettings["DropboxToken"]; var dbx = new DropboxClient(key); FileType fileType; var lastOrDefault = filename.Split('.').LastOrDefault(); if (lastOrDefault != null) if (Enum.TryParse(lastOrDefault, out fileType)) { using (var memoryStream = new MemoryStream(contentFile)) { try { await dbx.Files.UploadAsync( path, WriteMode.Add.Instance.AsAdd, body: memoryStream); Logger.Logger.Instance.LogAction(LoggerHelper.GetActionString(username, "Upload File")); } catch (Exception ex) { Logger.Logger.Instance.LogError(ex); throw; } var input = new FileDTO { Path = path, FileType = fileType, FileName = filename }; var fileId = fileProvider.SaveUploadedFilePath(input, moduleId, hwId); if (fileId < 0) throw new Exception("Cannot save file path"); else return fileId; } } else throw new Exception("File tye not supported"); else throw new Exception("Not a file type"); }
public async Task ListRootFolder(DropboxClient dbx) { var list = await dbx.Files.ListFolderAsync(string.Empty); // show folders, then files foreach (var item in list.Entries.Where(i => i.IsFolder)) { Console.WriteLine("D {0}/", item.Name); } foreach (var item in list.Entries.Where(i => i.IsFile)) { Console.WriteLine("F{0,8} {1}", item.AsFile.Size, item.Name); } }
public async Task Upload(string folder, string file, byte[] content, Action onSuccess) { using (var client = new DropboxClient(AccessToken)) { using (var mem = new MemoryStream(content)) { await client.Files.UploadAsync( folder + "/" + file, WriteMode.Overwrite.Instance, body: mem); onSuccess(); } } }
public async Task<FileMetadata> Upload(string file, string content) { using (var dbx = new DropboxClient(_accessToken)) { using (var mem = new MemoryStream(Encoding.UTF8.GetBytes(content))) { var updated = await dbx.Files.UploadAsync( "/" + file, WriteMode.Overwrite.Instance, body: mem); return updated; } } }
public async Task<bool> SendAsync (string csv, string participantId) { var fileName = string.Format (Resources.Export.FileNameFormat, participantId, DateTime.Now); var filePath = string.Format ("/{0}", fileName); try { using (var dbx = new DropboxClient (Resources.Export.Dropbox.AccessToken)) { using (var mem = new MemoryStream (Encoding.UTF8.GetBytes (csv))) { await dbx.Files.UploadAsync (filePath, WriteMode.Overwrite.Instance, body: mem); } return true; } } catch { return false; } }
public async Task<string> UploadAsync(byte[] content, string extension) { string guid = Guid.NewGuid().ToString(); string imageUrl = string.Format("/{0}.{1}", guid, extension); using (var mem = new MemoryStream(content)) using (var dbx = new DropboxClient(Token)) { var image = await dbx.Files.UploadAsync(new CommitInfo(imageUrl), body: mem); var shareLink = await dbx.Sharing.CreateSharedLinkAsync(image.PathLower); var rawLink = ProcessImageLink(shareLink.Url); return rawLink; } }
private static async Task Run() { using (var dropboxAccount = new DropboxClient(GlobalConstatns.AccessTokenDropBox)) { FullAccount full = await dropboxAccount.Users.GetCurrentAccountAsync(); Console.WriteLine("Hello {0} !", full.Name.DisplayName); string[] catPictures = Directory.GetFiles(Directory.GetCurrentDirectory() + "..\\..\\..\\Album"); foreach (var cat in catPictures) { byte[] bytes = ReadBinaryFile(cat); await Upload(dropboxAccount, "/Cats", cat.Substring(cat.LastIndexOf("\\") + 1), bytes); } } }
private async Task<UserFilesViewModel> ListUserFiles(DropboxClient dropboxClient, string folder) { if (string.IsNullOrEmpty(folder)) { folder = this.User.Identity.Name; } var list = await dropboxClient.Files.ListFolderAsync("/" + folder); var userFiles = new UserFilesViewModel(); userFiles.Folders = list.Entries.Where(i => i.IsFolder).Select(i => i.Name).ToList(); userFiles.Files = list.Entries.Where(i => i.IsFile).Select(i => i.Name).ToList(); return userFiles; }
/// <summary> /// Run tests for user-level operations. /// </summary> /// <param name="client">The Dropbox client.</param> /// <returns>An asynchronous task.</returns> private async Task RunUserTests(DropboxClient client) { await GetCurrentAccount(client); var path = "/DotNetApi/Help"; var list = await ListFolder(client, path); var firstFile = list.Entries.FirstOrDefault(i => i.IsFile); if (firstFile != null) { await Download(client, path, firstFile.AsFile); } await Upload(client, path, "Test.txt", "This is a text file"); await ChunkUpload(client, path, "Binary"); }
private async Task<int> Run() { InitializeCertPinning(); var accessToken = await this.GetAccessToken(); if (string.IsNullOrEmpty(accessToken)) { return 1; } // Specify socket level timeout which decides maximum waiting time when on bytes are // received by the socket. var httpClient = new HttpClient(new WebRequestHandler { ReadWriteTimeout = 10 * 1000 }) { // Specify request level timeout which decides maximum time taht can be spent on // download/upload files. Timeout = TimeSpan.FromMinutes(20) }; try { var client = new DropboxClient(accessToken, userAgent: "SimpleTestApp", httpClient: httpClient); await RunUserTests(client); // Tests below are for Dropbox Business endpoints. To run these tests, make sure the ApiKey is for // a Dropbox Business app and you have an admin account to log in. /* var client = new DropboxTeamClient(accessToken, userAgent: "SimpleTeamTestApp", httpClient: httpClient); await RunTeamTests(client); */ } catch (HttpException e) { Console.WriteLine("Exception reported from RPC layer"); Console.WriteLine(" Status code: {0}", e.StatusCode); Console.WriteLine(" Message : {0}", e.Message); if (e.RequestUri != null) { Console.WriteLine(" Request uri: {0}", e.RequestUri); } } return 0; }
/// <summary> /// Deletes file or entire folder(with or without content). /// </summary> /// <param name="path">If the target is a folder - path to the folder. Example: "/Contests/Active". /// If the target is file - the path includes the filename and extension. Example: "/Contests/Active/Abstract5567.jpg" /// The path is relevant to the root Dropbox folder - i.e. the path always starts with "/" /// </param> /// <returns>On success returns true, otherwise false.</returns> public static async Task<bool> Delete(string path) { using (var dbx = new DropboxClient(DropboxAppAccessToken)) { var folderArg = new Dropbox.Api.Files.DeleteArg(path); bool success = true; try { var folder = await dbx.Files.DeleteAsync(folderArg); } catch (Exception) { success = false; } return success; } }
public async Task<AccountConfiguration> CreateAccount() { var isOk = OAuth2Flow.TryAuthenticate(this); if (!isOk) return null; var api = new DropboxClient(_oauthResponse.AccessToken); var owner = await api.Users.GetCurrentAccountAsync(); var account = new AccountConfiguration() { Id = owner.AccountId, Name = owner.Name.DisplayName, Type = StorageType.Dropbox, Secret = _oauthResponse.AccessToken, }; return account; }
public DropboxFolder(string authorisationCode) { base.AuthorisationCode = authorisationCode; dropboxClient = DropboxClientAccess(); }
public static async Task<Blog> FromUserAsync(UserProfile user) { if (string.IsNullOrWhiteSpace(user.BlogName) || string.IsNullOrWhiteSpace(user.DropboxAccessToken)) { return null; } using (var client = new DropboxClient(user.DropboxAccessToken, userAgent: "SimpleBlogDemo")) { return new Blog { BlogName = user.BlogName, BlogArticles = new List<ArticleMetadata>(await client.GetArticleList()).AsReadOnly() }; } }
public async Task<ActionResult> CreateFile() { if (Request.Files.Count == 0) { return this.RedirectToAction("Index", "MyFiles"); } using (var dropboxClient = new DropboxClient(Common.Constants.ServerConstants.DropboxClient)) { string path = "/" + User.Identity.Name; string filename = Path.GetFileName(Request.Files[0].FileName); int contentLength = Request.Files[0].ContentLength; byte[] contentBuffer = new byte[contentLength]; Request.Files[0].InputStream.Read(contentBuffer, 0, contentLength); BinaryReader contentBinaryReader = new BinaryReader(Request.Files[0].InputStream); byte[] binaryData = contentBinaryReader.ReadBytes(contentLength); string result = System.Text.Encoding.UTF8.GetString(binaryData); using (var fileContentReader = new MemoryStream(Encoding.UTF8.GetBytes(result))) { var updated = await dropboxClient.Files.UploadAsync( "/" + User.Identity.Name + "/" + Request.Files[0].FileName, WriteMode.Overwrite.Instance, body: fileContentReader); return this.RedirectToAction("Index", "MyFiles"); } } }
public async Task<IHttpActionResult> DownloadLink(int moduleId) { var key = WebConfigurationManager.AppSettings["DropboxToken"]; var dbx = new DropboxClient(key); var files = _fileProvider.GetByModule(moduleId); var model = new List<FileViewModel>(); foreach (var file in files) { try { var downloadLink = await dbx.Sharing.CreateSharedLinkAsync(file.Path, false); var viewModel = new FileViewModel { Filename = file.FileName, Path = downloadLink.Url.Remove(downloadLink.Url.Length - 1) + "1" }; model.Add(viewModel); } catch (Exception ex) { Logger.Logger.Instance.LogError(ex); return InternalServerError(ex); } } return Ok(model); }