/// <summary>
/// <para>Get the shared link's metadata.</para>
/// </summary>
/// <param name="url">URL of the shared link.</param>
/// <param name="path">If the shared link is to a folder, this parameter can be used to
/// retrieve the metadata for a specific file or sub-folder in this folder. A relative
/// path should be used.</param>
/// <param name="linkPassword">If the shared link has a password, this parameter can be
/// used.</param>
/// <returns>The task that represents the asynchronous send operation. The TResult
/// parameter contains the response from the server.</returns>
/// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
/// processing the request; This will contain a <see
/// cref="SharedLinkError"/>.</exception>
public t.Task<SharedLinkMetadata> GetSharedLinkMetadataAsync(string url,
string path = null,
string linkPassword = null)
{
var getSharedLinkMetadataArg = new GetSharedLinkMetadataArg(url,
path,
linkPassword);
return this.GetSharedLinkMetadataAsync(getSharedLinkMetadataArg);
}
/// <summary>
/// <para>Begins an asynchronous send to the get shared link file route.</para>
/// </summary>
/// <param name="url">URL of the shared link.</param>
/// <param name="path">If the shared link is to a folder, this parameter can be used to
/// retrieve the metadata for a specific file or sub-folder in this folder. A relative
/// path should be used.</param>
/// <param name="linkPassword">If the shared link has a password, this parameter can be
/// used.</param>
/// <param name="callback">The method to be called when the asynchronous send is
/// completed.</param>
/// <param name="callbackState">A user provided object that distinguished this send
/// from other send requests.</param>
/// <returns>An object that represents the asynchronous send request.</returns>
public sys.IAsyncResult BeginGetSharedLinkFile(string url,
string path = null,
string linkPassword = null,
sys.AsyncCallback callback = null,
object callbackState = null)
{
var getSharedLinkMetadataArg = new GetSharedLinkMetadataArg(url,
path,
linkPassword);
return this.BeginGetSharedLinkFile(getSharedLinkMetadataArg, callback, callbackState);
}
/// <summary>
/// <para>Download the shared link's file from a user's Dropbox.</para>
/// </summary>
/// <param name="url">URL of the shared link.</param>
/// <param name="path">If the shared link is to a folder, this parameter can be used to
/// retrieve the metadata for a specific file or sub-folder in this folder. A relative
/// path should be used.</param>
/// <param name="linkPassword">If the shared link has a password, this parameter can be
/// used.</param>
/// <returns>The task that represents the asynchronous send operation. The TResult
/// parameter contains the response from the server.</returns>
/// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
/// processing the request; This will contain a <see
/// cref="GetSharedLinkFileError"/>.</exception>
public t.Task<enc.IDownloadResponse<SharedLinkMetadata>> GetSharedLinkFileAsync(string url,
string path = null,
string linkPassword = null)
{
var getSharedLinkMetadataArg = new GetSharedLinkMetadataArg(url,
path,
linkPassword);
return this.GetSharedLinkFileAsync(getSharedLinkMetadataArg);
}
/// <summary>
/// <para>Begins an asynchronous send to the get shared link file route.</para>
/// </summary>
/// <param name="getSharedLinkMetadataArg">The request parameters.</param>
/// <param name="callback">The method to be called when the asynchronous send is
/// completed.</param>
/// <param name="state">A user provided object that distinguished this send from other
/// send requests.</param>
/// <returns>An object that represents the asynchronous send request.</returns>
public sys.IAsyncResult BeginGetSharedLinkFile(GetSharedLinkMetadataArg getSharedLinkMetadataArg, sys.AsyncCallback callback, object state = null)
{
var task = this.GetSharedLinkFileAsync(getSharedLinkMetadataArg);
return enc.Util.ToApm(task, callback, state);
}
/// <summary>
/// <para>Download the shared link's file from a user's Dropbox.</para>
/// </summary>
/// <param name="getSharedLinkMetadataArg">The request parameters</param>
/// <returns>The task that represents the asynchronous send operation. The TResult
/// parameter contains the response from the server.</returns>
/// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
/// processing the request; This will contain a <see
/// cref="GetSharedLinkFileError"/>.</exception>
public t.Task<enc.IDownloadResponse<SharedLinkMetadata>> GetSharedLinkFileAsync(GetSharedLinkMetadataArg getSharedLinkMetadataArg)
{
return this.Transport.SendDownloadRequestAsync<GetSharedLinkMetadataArg, SharedLinkMetadata, GetSharedLinkFileError>(getSharedLinkMetadataArg, "content", "/sharing/get_shared_link_file", Dropbox.Api.Sharing.GetSharedLinkMetadataArg.Encoder, Dropbox.Api.Sharing.SharedLinkMetadata.Decoder, Dropbox.Api.Sharing.GetSharedLinkFileError.Decoder);
}
/// <summary>
/// <para>Get the shared link's metadata.</para>
/// </summary>
/// <param name="getSharedLinkMetadataArg">The request parameters</param>
/// <returns>The task that represents the asynchronous send operation. The TResult
/// parameter contains the response from the server.</returns>
/// <exception cref="Dropbox.Api.ApiException{TError}">Thrown if there is an error
/// processing the request; This will contain a <see
/// cref="SharedLinkError"/>.</exception>
public t.Task<SharedLinkMetadata> GetSharedLinkMetadataAsync(GetSharedLinkMetadataArg getSharedLinkMetadataArg)
{
return this.Transport.SendRpcRequestAsync<GetSharedLinkMetadataArg, SharedLinkMetadata, SharedLinkError>(getSharedLinkMetadataArg, "api", "/sharing/get_shared_link_metadata", Dropbox.Api.Sharing.GetSharedLinkMetadataArg.Encoder, Dropbox.Api.Sharing.SharedLinkMetadata.Decoder, Dropbox.Api.Sharing.SharedLinkError.Decoder);
}
private async Task <int> Run()
{
DropboxCertHelper.InitializeCertPinning();
string[] scopeList = new string[] { "files.metadata.read", "files.content.read", "account_info.read", "sharing.read" };
var uid = await AcquireAccessToken(scopeList, IncludeGrantedScopes.None);
if (string.IsNullOrEmpty(uid))
{
return(1);
}
// Specify socket level timeout which decides maximum waiting time when no bytes are received by the socket.
var 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)
};
try
{
var config = new DropboxClientConfig("SimpleOAuthApp")
{
HttpClient = httpClient
};
var client = new DropboxClient(Settings.Default.AccessToken, Settings.Default.RefreshToken, Settings.Default.ApiKey, Settings.Default.ApiSecret, config);
var scopes = new string[] { "files.metadata.read", "files.content.read", "sharing.read" };
await client.RefreshAccessToken(scopes);
if (Settings.Default.SharedLinks == null || Settings.Default.SharedLinks.Count == 0)
{
Settings.Default.SharedLinks = new System.Collections.Specialized.StringCollection();
Console.Write("Shared link URL: ");
var line = Console.ReadLine();
while (line.Length > 0)
{
Settings.Default.SharedLinks.Add(line);
Console.Write("Additional shared link URL (leave blank to finish): ");
line = Console.ReadLine();
}
Settings.Default.Save();
}
var sharedLinks = Settings.Default.SharedLinks;
foreach (var sharedLinkUrl in sharedLinks)
{
GetSharedLinkMetadataArg arg = new GetSharedLinkMetadataArg(sharedLinkUrl);
var sharedLinkMetaData = await client.Sharing.GetSharedLinkMetadataAsync(arg);
var localDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), sharedLinkMetaData.Name);
Directory.CreateDirectory(localDir);
Console.WriteLine($"Processing shared link name: {sharedLinkMetaData.Name}");
if (Verbose)
{
Console.WriteLine($"Shared link local folder: {localDir}");
}
SharedLink sharedLink = new SharedLink(sharedLinkUrl);
ListFolderArg listFolderArg = new ListFolderArg(path: "", sharedLink: sharedLink);
var listFiles = await client.Files.ListFolderAsync(listFolderArg);
foreach (var listFile in listFiles.Entries)
{
try
{
if (Verbose)
{
Console.WriteLine($"Processing: {listFile.Name}");
}
// Get the remote object details
var remoteFile = listFile.AsFile;
// Construct a reference to the local equivalent
var localFile = Path.Combine(localDir, listFile.Name);
if (Verbose)
{
Console.WriteLine($" Local filename: {localFile}");
}
// Do we have a file already
if (File.Exists(localFile))
{
if (Verbose)
{
Console.WriteLine($" Local file exists. Comparing timestamp");
}
var localTimestamp = File.GetLastWriteTimeUtc(localFile);
if (Verbose)
{
Console.WriteLine($" Checking {remoteFile.ServerModified} with {localTimestamp}");
}
if (DateTime.Compare(remoteFile.ServerModified, localTimestamp) == 0)
{
if (Verbose)
{
Console.WriteLine($" Skipping unchanged file: {listFile.Name}");
}
continue;
}
}
GetSharedLinkMetadataArg downloadArg = new GetSharedLinkMetadataArg(sharedLinkUrl, $"/{listFile.Name}");
if (Verbose)
{
Console.WriteLine($"SharedLinkUrl: {sharedLinkUrl}");
Console.WriteLine($" File Name: {listFile.Name}");
}
var download = await client.Sharing.GetSharedLinkFileAsync(downloadArg);
Console.WriteLine($" Downloading: {remoteFile.Name}");
using (var ms = new MemoryStream())
{
var bytes = await download.GetContentAsByteArrayAsync();
if (bytes.Length > 0)
{
File.WriteAllBytes(localFile, bytes.ToArray());
File.SetCreationTimeUtc(localFile, remoteFile.ServerModified);
File.SetLastWriteTimeUtc(localFile, remoteFile.ServerModified);
}
else
{
Console.Error.WriteLine($"No bytes downloaded");
}
}
}
catch (Exception ex)
{
Console.Error.WriteLine($"Failed during download: ${ex.Message}");
}
}
if (Verbose)
{
Console.WriteLine("Download complete!");
}
}
if (Verbose)
{
Console.WriteLine("All downloads complete!");
}
if (PromptToExit)
{
Console.WriteLine("Exit with any key");
Console.ReadKey();
}
}
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);
}
