public async Task <ItemInformation[]> GetFilesList(string path)
{
try
{
ListFolderResult list = await client.Files.ListFolderAsync(path, recursive : false, includeMediaInfo : true);
ItemInformation[] res = new ItemInformation[list.Entries.Count];
Metadata element;
for (int i = 0; i < res.Length; i++)
{
element = list.Entries[i];
res[i] = new ItemInformation();
res[i].Name = element.Name;
res[i].Fullpath = element.PathDisplay;
if (element.IsFolder)
{
res[i].Type = ElementType.dir;
}
else
{
string[] temp = element.Name.Split('.');
res[i].Type = GetItemType(temp[temp.Length - 1]);
res[i].Size = element.AsFile.Size;
res[i].EditDate = element.AsFile.ServerModified;
}
}
return(res);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(null);
}
}
/// <summary>
/// Lists the items within a folder.
/// </summary>
/// <remarks>This demonstrates calling an RPC style API in the Files namespace.</remarks>
/// <param name="path">The path to list.</param>
/// <returns>The result from the ListFolderAsync call.</returns>
private async Task <DataTable> ListFoldersAsync(string path = "")
{
DataTable result = null;
try
{
var list = new ListFolderResult();
list = await this.dbc.Files.ListFolderAsync(path);
AppObjects.Log.Log("--- Files ---");
result = new DataTable();
result.Columns.Add("Name");
result.Columns.Add("IsFile", typeof(bool));
if (!string.IsNullOrWhiteSpace(path))
{
// Root - Add the "..."
DataRow row = result.NewRow();
row[0] = "...";
row[1] = false;
result.Rows.Add(row);
}
// show folders then files
foreach (var item in list.Entries.Where(i => i.IsFolder))
{
Console.WriteLine("D {0}/", item.Name);
DataRow row = result.NewRow();
row[0] = item.Name;
row[1] = false;
result.Rows.Add(row);
}
foreach (var item in list.Entries.Where(i => i.IsFile))
{
var file = item.AsFile;
Console.WriteLine("F{0,8} {1}", file.Size, item.Name);
DataRow row = result.NewRow();
row[0] = item.Name;
row[1] = true;
result.Rows.Add(row);
}
if (list.HasMore)
{
AppObjects.Log.Log(" ...");
}
else
{
AppObjects.Log.Log("--- End Files ---");
}
}
catch (Exception ex)
{
AppObjects.Log.LogException(ex);
result = null;
}
return(result);
}
//get all for info
private async void button13_Click(object sender, EventArgs e)
{
toolStripStatusLabel1.Text = "Getting folders list ...";
list = await client.Files.ListFolderAsync(new ListFolderArg(string.Empty, true));
if (list != null)
{
toolStripStatusLabel1.Text = "Getting folders list succeed!";
}
TreeNode[] root = treeView3.Nodes.Find("root", false);
root[0].Nodes.Clear();
foreach (var item in list.Entries.Where(i => i.IsFolder))
{
int pos = item.PathDisplay.LastIndexOf("/");
if (pos == 0)
{
treeView3.BeginUpdate();
root[0].Nodes.Add(item.Name, item.Name);
treeView3.EndUpdate();
}
else
{
string[] names = getChildParent(item.PathDisplay, pos);
// parsePath(item.PathDisplay, root);
TreeNode[] node = root[0].Nodes.Find(names[0], true);
treeView3.BeginUpdate();
node[0].Nodes.Add(names[1], names[1]);
treeView3.EndUpdate();
}
}
foreach (var item in list.Entries.Where(i => i.IsFile))
{
int pos = item.PathDisplay.LastIndexOf("/");
if (pos == 0)
{
treeView3.BeginUpdate();
root[0].Nodes.Add(item.Name, item.Name);
treeView3.EndUpdate();
}
else
{
string[] names = getChildParent(item.PathDisplay, pos);
TreeNode[] node = root[0].Nodes.Find(names[0], true);
// if (node.Length == 1)
//{
treeView3.BeginUpdate();
node[0].Nodes.Add(names[1], names[1]);
treeView3.EndUpdate();
// }
// else
// {
//}
}
}
treeView3.ExpandAll();
}
protected override async Task PerformIO()
{
ListFolderResult data = await _client.Files.ListFolderAsync(FolderPath);
ListFolderPathLower = data.Entries.Select(x => x.PathLower).ToList();
ListFolderPathsDisplay = data.Entries.Select(x => x.PathDisplay).ToList();
}
// static async Task<int> GetSharedFolderFileCount(DropboxClient userClient, string folderPath)
static async Task <int> GetSharedFolderFileCount(DropboxClient userClient, SharedFolderMetadata sharedFolderMetadata)
{
if (_debug)
{
Console.WriteLine("-------------------------------------");
Console.WriteLine("GetSharedFolderFileCount() called...");
}
ListFolderResult listFolderResult = await userClient.Files.ListFolderAsync(sharedFolderMetadata.PathLower);
int fileCount = listFolderResult.Entries.Count();
if (_debug)
{
Console.WriteLine("----------------");
Console.WriteLine($"fileCount: {fileCount}");
}
while (listFolderResult.HasMore)
{
listFolderResult = await userClient.Files.ListFolderContinueAsync(listFolderResult.Cursor);
fileCount += listFolderResult.Entries.Count();
if (_debug)
{
Console.WriteLine("----------------");
Console.WriteLine($"updated fileCount: {fileCount}");
}
}
return(fileCount);
}
public async Task <IEnumerable <DropboxFileMetadata> > ListFolderContentAsync(string path, bool recursive, CancellationToken cancellationToken)
{
ValidatePathAndCancellationToken(path, cancellationToken);
List <DropboxFileMetadata> folderContent = new List <DropboxFileMetadata>();
ListFolderResult list = await _dropboxClient.Files.ListFolderAsync(path);
//await Task.Factory.FromAsync(_dropboxClient.Files.BeginListFolder(path, recursive), _dropboxClient.Files.EndListFolder);
folderContent.AddRange(list.Entries.Where(f => f.IsFile).Select(f => f.ToFileMetadata()));
//foreach (var item in list.Entries.Where(i => i.IsFile))
//{
// Console.WriteLine("F{0,8} {1}", item.AsFile.Size, item.Name);
//}
if (recursive)
{
foreach (var folder in list.Entries.Where(i => i.IsFolder))
{
//Console.WriteLine("D {0}/", item.Name);
folderContent.AddRange(await ListFolderContentAsync(folder.PathLower, recursive, cancellationToken));
}
}
return(null);
}
/// <summary>Loads the of dropbox a folder.</summary>
/// <param name="pathOfCloud">The path of cloud.</param>
/// <param name="pathToDownload">The path to download.</param>
/// <param name="user">The user.</param>
/// <param name="extensions">The extensions.</param>
public static void LoadOfDropboxAFolder(string pathOfCloud, string pathToDownload, User user, List <string> extensions)
{
DropboxClient client = new DropboxClient(user.AccessToken);
ListFolderResult cloudList = client.Files.ListFolderAsync(pathOfCloud, true).Result;
List <Metadata> listFiles = cloudList.Entries.ToList().FindAll(i => i.IsFile).FindAll(i => extensions.Any(j => i.Name.Contains(j)));
for (int i = 0; i < listFiles.Count; i++)
{
string path = pathToDownload + Path.GetDirectoryName(listFiles[i].PathLower);
string pathWithFile = pathToDownload + listFiles[i].PathLower;
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
if (File.Exists(pathWithFile))
{
File.Delete(pathWithFile);
}
Stream stream = client.Files.DownloadAsync(listFiles[i].PathLower).Result.GetContentAsStreamAsync().Result;
FileStream file = File.Create(pathWithFile);
stream.CopyTo(file);
file.Close();
}
}
private async Task <IList <DropBoxImageModel> > DownloadImagesForUser(string username)
{
ListFolderResult fileList = await this.dropboxClient.Files.ListFolderAsync(string.Format("{0}/{1}", DropboxImagesFolderName, username));
if (fileList.Entries.Count == 0)
{
throw new InvalidOperationException("Invalid user specified or user has no images.");
}
var result = new List <DropBoxImageModel>();
foreach (var imageFile in fileList.Entries)
{
using (var response = await this.dropboxClient.Files.DownloadAsync(string.Format("{0}/{1}/{2}", DropboxImagesFolderName, username, imageFile.Name)))
{
byte[] data = await response.GetContentAsByteArrayAsync();
var currentImage = new DropBoxImageModel()
{
Data = data,
ImageName = imageFile.Name,
UserName = username
};
result.Add(currentImage);
}
}
return(result);
}
public async Task <IReadOnlyList <RemoteFileInfo> > GetFilesAsync(int maxFileCount, CancellationToken cancellationToken)
{
if (!await IsAuthenticatedAsync().ConfigureAwait(false))
{
return(Array.Empty <RemoteFileInfo>());
}
using (await _semaphore.WaitAsync(cancellationToken).ConfigureAwait(false))
{
ListFolderResult files
= await _dropboxClient.Files.ListFolderAsync(
path : string.Empty, // root of AppFolder.
limit : (uint)maxFileCount,
includeNonDownloadableFiles : false,
includeMediaInfo : true).ConfigureAwait(false);
var results = new List <RemoteFileInfo>();
for (int i = 0; i < files.Entries.Count; i++)
{
if (files.Entries[i].IsFile) // if it's a file
{
FileMetadata file = files.Entries[i].AsFile;
results.Add(new RemoteFileInfo(file.Name, file.ServerModified));
}
}
_logger.LogEvent(GetFilesEvent, string.Empty);
return(results);
}
}
/// <summary>Numbers the of files in folder of dropbox.</summary>
/// <param name="path">The path.</param>
/// <returns>Return num of files in folder</returns>
public static int NumOfFilesInFolderOfDropbox(string pathOfCloud, User user, List <string> extensions)
{
DropboxClient client = new DropboxClient(user.AccessToken);
ListFolderResult cloudList = client.Files.ListFolderAsync(pathOfCloud, true).Result;
List <Metadata> listFiles = cloudList.Entries.ToList().FindAll(i => i.IsFile).FindAll(i => extensions.Any(j => i.Name.Contains(j)));
return(listFiles.Count);
}
public async Task LoadFileList()
{
using (var client = new DropboxClient(AccessToken))
{
ListFolderResult list = await client.Files.ListFolderAsync(string.Empty);
Files = list.Entries;
}
}
public static async Task <Dictionary <string, string> > getLastUploads(string userID)
{
try
{
Regex exp = new Regex(RFCregexp);
Dictionary <string, Metadata> metadatos = new Dictionary <string, Metadata>();
Dictionary <string, string> ret = new Dictionary <string, string>();
ListFolderResult res = await listFiles(userID, true);
foreach (Metadata m in res.Entries)
{
if (m.IsFile && exp.IsMatch(m.AsFile.Name))
{
//Obtenemos el RFC
string[] arr = exp.Split(m.AsFile.Name);
if (!metadatos.ContainsKey(arr[1]))//No existe
{
metadatos.Add(arr[1], m);
}
else
{
Metadata pre = metadatos[arr[1]];
//La fecha de M es mas reciente
if (pre.AsFile.ServerModified.CompareTo(m.AsFile.ServerModified) < 0)
{
metadatos.Remove(arr[1]);
metadatos.Add(arr[1], m);
}
}
}
}
foreach (string client in metadatos.Keys)
{
FileMetadata fileData = metadatos[client].AsFile;
string fechaAno = fileData.Name.Substring(fileData.Name.Length - 22, 4);
string fechaDia = fileData.Name.Substring(fileData.Name.Length - 18, 2);
string fechames = fileData.Name.Substring(fileData.Name.Length - 16, 2);
string fechahora = fileData.Name.Substring(fileData.Name.Length - 14, 2);
string fechaminuto = fileData.Name.Substring(fileData.Name.Length - 12, 2);
string fechasegundo = fileData.Name.Substring(fileData.Name.Length - 10, 2);
string fecha = fechaDia + "/" + fechames + "/" + fechaAno + " " + fechahora + ":" + fechaminuto + ":" + fechasegundo;
ret.Add(client, fecha);
}
return(ret);
}
catch (Exception)
{
return(null);
}
}
private static async Task <ListFolderResult> listFiles(string path)
{
ListFolderResult list = null;
try
{
clientConf = new DropboxClientConfig("ScandaV1");
client = new DropboxClient(APITOKEN);
list = await client.Files.ListFolderAsync("/" + path);
}
catch (BadInputException ex)
{
Console.WriteLine("Error de Token");
Console.WriteLine(ex.Message);
}
catch (ApiException <ListFolderError> ex)
{
//ApiException<ListFolderError>
ListFolderError err = ex.ErrorResponse;
if (err.IsPath)
{
LookupError lerr = err.AsPath.Value;
if (lerr.IsMalformedPath)
{
Console.WriteLine("Ruta Mal Formateada");
}
if (lerr.IsNotFile)
{
Console.WriteLine("No es un archivo");
}
if (lerr.IsNotFolder)
{
Console.WriteLine("No es un Folder");
}
if (lerr.IsNotFound)
{
Console.WriteLine("Ruta no Hallada");
}
if (lerr.IsRestrictedContent)
{
Console.WriteLine("No tiene permisos");
}
}
else
{
Console.WriteLine("Error No Indentificado");
}
}
catch (Exception)
{
Console.WriteLine("Fallo Desconocido");
}
return(list);
}
public static async Task <long> getUsedSpace(string userID, int s = 1)
{
//obtengo todos los archivos
ListFolderResult res = await listFiles(userID, true);
List <Metadata> todo = res.Entries as List <Metadata>;
List <FileMetadata> archivos = todo.Where(x => x.IsFile).Select(y => y.AsFile).ToList();
long tam = (long)archivos.Select((x) => { return(x.Size); }).Aggregate((x, y) => { return(x + y); });
return((long)(Math.Ceiling((double)tam / (double)B_TO_MB)));
}
//si cantidad -1 no hay limite
public static async Task <long> obtenerEspacioUsado(string userID, int cant, Config config)
{
if (cant == -1)
{
return(0);
}
long tamanoALiberar = 0; // Este es el tamaño que dejara disponible un archivo cuando sea eliminado en la nube en la etapa final
//obtengo todos los archivos
ListFolderResult res = await listFiles(userID, true);
List <Metadata> todo = res.Entries as List <Metadata>;
List <FileMetadata> archivos = todo.Where(x => x.IsFile).Select(y => y.AsFile).ToList();
archivos.Sort((a, b) => a.ServerModified.CompareTo(b.ServerModified)); //Ordenamos , mas viejos primero
int dif = archivos.Count - cant; //Cuantos debo de eliminar
if (dif < 0)
{
return(0); //quiere decir que no hay archivos por borrar
}
dif += 1; //se suma uno porque se tiene que considerar el archivo que se pretende subir
foreach (FileMetadata fm in archivos.Take(dif))
{
//Necesitamos crear un cliente
try
{
var espacio_archivo_borrar = (long)fm.Size;
tamanoALiberar += espacio_archivo_borrar;
}
catch (BadInputException ex)
{
await Logger.sendLog(string.Format("{0} | {1} | {2}", ex.Message, ex.StackTrace, "Scanda.ClassLibrary.obtenerEspacioUsado "), "E");
Console.WriteLine("Error de Token");
Console.WriteLine(ex.Message);
}
catch (Exception ex)
{
await Logger.sendLog(string.Format("{0} | {1} | {2}", ex.Message, ex.StackTrace, "Scanda.ClassLibrary.obtenerEspacioUsado "), "E");
Console.WriteLine(ex.Message);
}
}
var espacio_usado = await ScandaConector.getUsedSpace(config.id_customer);
long espacioFuturoFinal = Math.Abs(tamanoALiberar / B_TO_MB - espacio_usado);
return(espacioFuturoFinal);
}
public void DropboxListFolderSuccesResult_GivenListFolderResult_Expect_ILIstFolderResult()
{
//---------------Set up test pack-------------------
var expected = new ListFolderResult();
var dropboxListFolderSuccesResult = new DropboxListFolderSuccesResult(expected);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var result = dropboxListFolderSuccesResult.GetListFolderResult();
//---------------Test Result -----------------------
Assert.IsNotNull(result as IListFolderResult);
}
public async Task <string> ForEachAsync(string path, bool recursive, bool deleted, Action <FileItem> action)
{
const string logstem = "ForEachAsync():{0}";
Action <Metadata> handleEntry = (entry) =>
{
var item = FileItem.Create(entry);
if (item.Path != this.context.RemotePath)
{
action(item);
}
};
var args0 = new ListFolderArg(path, recursive, false, deleted);
ListFolderResult result = await this.Client.Files
.ListFolderAsync(args0)
.WithTimeout(TimeSpan.FromSeconds(this.context.HttpReadTimeoutInSeconds));
// These logging calls are very expensive so check we're enabled first
if (log.IsDebugEnabled)
{
log.DebugFormat(logstem, "Request:" + Json.ToString(args0));
log.DebugFormat(logstem, "Result:" + Json.ToString(result));
}
foreach (var entry in result.Entries)
{
handleEntry(entry);
}
while (result.HasMore)
{
var args1 = new ListFolderContinueArg(result.Cursor);
result = await this.Client.Files
.ListFolderContinueAsync(args1)
.WithTimeout(TimeSpan.FromSeconds(this.context.HttpReadTimeoutInSeconds));
if (log.IsDebugEnabled)
{
log.DebugFormat(logstem, "Request:" + Json.ToString(args1));
log.DebugFormat(logstem, "Result:" + Json.ToString(result));
}
foreach (var entry in result.Entries)
{
handleEntry(entry);
}
}
return(result.Cursor);
}
private async void Form2_Load(object sender, EventArgs e)
{
DropboxClient client = new DropboxClient(access_token);
ListFolderResult result = await client.Files.ListFolderAsync("");
IEnumerable <Metadata> myfiles = result.Entries;
List <object> fnames = new List <object>();
foreach (var item in myfiles)
{
fnames.Add(item.Name);
}
listBox1.Items.AddRange(fnames.ToArray());
}
public void failureResult_GivenException_ShouldRetunNewFailureResult()
{
//---------------Set up test pack-------------------
var fileMetadata = new ListFolderResult();
var mock = new Mock <ListFolderResult>();
var failureResult = new DropboxListFolderSuccesResult(mock.Object);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var expected = failureResult.GetListFolderResulResult();
//---------------Test Result -----------------------
Assert.AreEqual(expected, mock.Object);
}
private void ShowContent(string path = "")
{
label_loading.Show();
listView1.Clear();
currentPath = path;
menuTextBox.Text = currentPath;
content = client.Files.ListFolderAsync(path).Result;
foreach (var item in content.Entries)
{
// If folder - item.SubItems[1].Text (size) == ""
listView1.Items.Add(new ListViewItem(new string[] { item.Name, item.AsFile?.Size.ToString() }, item.IsFolder ? 0 : 1));
}
statusStrip1.Items["itemsCount"].Text = listView1.Items.Count.ToString();
label_loading.Hide();
}
public static async Task <List <Metadata> > GetFolderContent(DropboxClient client, string path, bool recursive)
{
ListFolderResult result = await client.Files.ListFolderAsync(path, recursive);
List <Metadata> list = result.Entries.ToList();
while (result.HasMore)
{
result = await client.Files.ListFolderContinueAsync(result.Cursor);
list.AddRange(result.Entries.ToList());
}
return(list);
}
public static object ToSerialisable(ListFolderResult r)
{
IList <object> entries = new List <object>();
foreach (var e in r.Entries)
{
entries.Add(ToSerialisable(e));
}
return(new
{
Cursor = r.Cursor,
Entries = entries,
HasMore = r.HasMore
});
}
public override async Task <CloudProviderResponse <List <CloudStorageProviderFileBase> > > ListFiles()
{
try
{
Logger.Log(LoggerMessageType.Information | LoggerMessageType.VerboseHigh, "DropboxStorageProvider ListFiles.");
List <CloudStorageProviderFileBase> files = new List <CloudStorageProviderFileBase>();
ListFolderArg arg = new ListFolderArg(String.Empty, true);
ListFolderResult listFolderResult = await _client.Files.ListFolderAsync(arg);
foreach (Metadata curFile in listFolderResult.Entries)
{
DropboxStorageProviderFile file = DropboxStorageProviderFile.FromMetadata(curFile);
if (!file.IsFolder)
{
if (file.Path.ToLower().EndsWith(".vault"))
{
files.Add(file);
}
}
}
return(new CloudProviderResponse <List <CloudStorageProviderFileBase> >(files));
}
catch (AuthException ae)
{
Logger.Log(LoggerMessageType.Information | LoggerMessageType.VerboseHigh, "An authorisation error occurred whilst attempting to list files from DropboxStorageProvider. {0}", ae.Message);
return(new CloudProviderResponse <List <CloudStorageProviderFileBase> >(CloudProviderResponse <List <CloudStorageProviderFileBase> > .Response.AuthenticationError, ae));
}
catch (DropboxException de)
{
Logger.Log(LoggerMessageType.Information | LoggerMessageType.VerboseHigh, "An error occurred whilst attempting to list files from DropboxStorageProvider. {0}", de.Message);
if (de.Message.ToLower().Contains("not_found"))
{
return(new CloudProviderResponse <List <CloudStorageProviderFileBase> >(CloudProviderResponse <List <CloudStorageProviderFileBase> > .Response.NotFound, de));
}
else
{
return(new CloudProviderResponse <List <CloudStorageProviderFileBase> >(CloudProviderResponse <List <CloudStorageProviderFileBase> > .Response.UnknownError, de));
}
}
catch (Exception ex)
{
Logger.Log(LoggerMessageType.Information | LoggerMessageType.VerboseHigh, "An unknown error occurred whilst attempting to list files from DropboxStorageProvider. {1}", ex.Message);
return(new CloudProviderResponse <List <CloudStorageProviderFileBase> >(CloudProviderResponse <List <CloudStorageProviderFileBase> > .Response.UnknownError, ex));
}
}
public async Task <List <AbstractFile> > GetList(string path)
{
if (String.IsNullOrEmpty(path))
{
path = string.Empty;
}
List <AbstractFile> FilesList = new List <AbstractFile>();
ListFolderResult list = await client.Files.ListFolderAsync(path);
int index = 0;
if (!String.IsNullOrEmpty(path) && path != "/")
{
FilesList.Add(Creator.GetNew(FileDir.Folder));
ConcreteFolder UpFolder = (ConcreteFolder)FilesList[0];
UpFolder.FolderName = "..";
UpFolder.FolderPath = path.Remove(path.LastIndexOf(@"/"), path.Length - path.LastIndexOf(@"/"));
FilesList[0] = UpFolder;
index = 1;
}
foreach (var item in list.Entries.Where(i => i.IsFolder))
{
FilesList.Add(Creator.GetNew(FileDir.Folder));
ConcreteFolder fle = (ConcreteFolder)FilesList[index];
fle.FolderName = item.Name;
fle.FolderPath = item.PathLower;
FilesList[index] = fle;
index++;
}
foreach (var item in list.Entries.Where(i => i.IsFile))
{
FilesList.Add(Creator.GetNew(FileDir.File));
ConcreteFile fle = (ConcreteFile)FilesList[index];
fle.FileName = item.Name;
fle.FilePath = item.PathLower;
FilesList[index] = fle;
index++;
}
index = 0;
return(FilesList);
}
public async Task <List <Metadata> > GetDropBoxFilesforweb(string token)
{
DropboxClient client = new DropboxClient(token);
ListFolderResult files = await client.Files.ListFolderAsync("");
List <Metadata> myfiles = (List <Metadata>)files.Entries;
for (int i = myfiles.Count - 1; i >= 0; i--)
{
if (myfiles[i].IsFolder)
{
myfiles.RemoveAt(i);
}
}
return(myfiles);
}
////-------------------------------------------------------------------------------------------------------------------------------
//public static List<string> ListFolderRecursive(string folder) {
// var task = Task.Run(() => DropboxWrapper.ListFolderRecursive(folder));
// List<string> all = task.Result;
// return all;
//}
//-------------------------------------------------------------------------------------------------------------------------------
public static async Task <List <Metadata> > ListFolderRecursive(string folder)
{
List <Metadata> allMetadata = new List <Metadata>();
try {
ListFolderResult list = await dbx.Files.ListFolderAsync(folder, true);
// Check we have something so that the folder exists ... Dropbox.Api.Files.Metadata ...
if (list != null && list.Entries != null && list.Entries.Count > 0)
{
bool finished = false;
while (finished == false)
{
// show folders then files
foreach (var item in list.Entries.Where(i => i.IsFolder))
{
Console.WriteLine("D {0}/", item.Name);
allMetadata.Add(item);
}
foreach (var item in list.Entries.Where(i => i.IsFile))
{
Console.WriteLine("F{0,8} {1}", item.AsFile.Size, item.Name);
allMetadata.Add(item);
}
if (list.HasMore == true)
{
list = await dbx.Files.ListFolderContinueAsync(list.Cursor);
}
else
{
finished = true;
}
}
}
} catch (Exception ex) {
Logger.LogError(4, "DropboxWrapper.ListFolderRecursive crashed - probably because folder name " + folder + " does not exist. The specific exception was: " + ex.ToString());
}
return(allMetadata);
}
static void recorreListFolderResult(ListFolderResult lf)
{
if (lf != null)
{
foreach (Metadata m in lf.Entries)
{
if (m.IsFile)
{
Console.WriteLine(m.Name + " " + m.AsFile.Size);
}
if (m.IsFolder)
{
Console.WriteLine(m.Name + " " + m.AsFolder.PathLower);
}
}
}
else
{
Console.WriteLine("Resultado Vacio");
}
}
public static List <string> getFiles(string path)
{
try
{
List <string> lista = new List <string>();
var x = listFiles(path);
x.Wait();
ListFolderResult res = x.Result;
foreach (Metadata m in res.Entries)
{
if (m.IsFile)
{
lista.Add(m.Name);
}
}
return(lista);
}
catch (Exception)
{
return(new List <string>()); //Lista vacia
}
}
public static async Task <List <string> > getFolders(string path, bool recursive = false)
{
try
{
List <string> lista = new List <string>();
var x = await listFiles(path, recursive);
ListFolderResult res = x;
foreach (Metadata m in res.Entries)
{
if (m.IsFolder)
{
lista.Add(m.Name);
}
}
return(lista);
}
catch (Exception)
{
return(new List <string>()); //Lista vacia
}
}
/// <inheritdoc/>
public async Task <CloudFolder> GetAppFolderAsync()
{
ThrowIfNotConnected();
ListFolderResult listFolder = null;
var files = new List <CloudFile>();
do
{
if (listFolder == null)
{
listFolder = await _client.Files.ListFolderAsync(string.Empty);
}
else
{
listFolder = await _client.Files.ListFolderContinueAsync(listFolder.Cursor);
}
foreach (var file in listFolder.Entries.Where(entry => entry.IsFile))
{
files.Add(new CloudFile
{
Name = file.Name,
FullPath = file.PathLower,
LastModificationUtcDate = file.AsFile.ServerModified
});
}
} while (listFolder.HasMore);
return(new CloudFolder
{
Name = "Clipboard",
Size = 0,
FullPath = "/",
Files = files
});
}