private static async Task sync_updateAccount(Config config, string config_path)
        {
            try
            {
                await Logger.sendLog(string.Format("{0} | {1} | {2}", "", "Comienza actualizando informacion del usuario...", "Scanda.AppTray.ScandaConector.syncUpdateAccount"), "T");

                // Obtenemos los datos de dropbox
                var x = await ScandaConector.getUsedSpace(config.id_customer);

                string url = ConfigurationManager.AppSettings["api_url"];
                using (var client = new HttpClient())
                {
                    client.BaseAddress = new Uri(url);
                    client.DefaultRequestHeaders.Accept.Clear();
                    client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                    HttpResponseMessage response = await client.GetAsync(string.Format("CustomerStorage_SET?UsedStorage={2}&User={0}&Password={1}", config.user, config.password, x));

                    if (response.IsSuccessStatusCode)
                    {
                    }
                }
                await Logger.sendLog(string.Format("{0} | {1} | {2}", "", "informacion del usuario actualizada", "Scanda.AppTray.ScandaConector.syncUpdateAccount"), "T");
            }
            catch (Exception ex)
            {
                await Logger.sendLog(string.Format("{0} | {1} | {2}", ex.Message, ex.StackTrace, "Scadna.AppTray.ScandaConector.sync_updateAccount"), "E");
            }
        }
        //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.AppTray.ScandaConector.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.AppTray.ScandaConector.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);
        }
        //si cantidad -1 no hay limite
        public static async Task deleteHistory(string userID, int cant, Config config)
        {
            if (cant == -1)
            {
                return;
            }
            else
            {
                //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

                if (archivos.Count < cant)                                             //Aun tiene lugar en el historico
                {
                    return;
                }
                else
                {
                    int dif = archivos.Count - cant; //Cuantos debo de eliminar
                    foreach (FileMetadata fm in archivos.Take(dif))
                    {
                        //Necesitamos crear un cliente
                        try
                        {
                            await client.Files.DeleteAsync(fm.PathDisplay);


                            var espacio_usado = await ScandaConector.getUsedSpace(config.id_customer) * B_TO_MB;


                            double espacio = (double)espacio_usado / (double)1024 / (double)1024;



                            int    espacio_usado_Final = (int)Math.Ceiling(espacio);
                            string url = ConfigurationManager.AppSettings["api_url"];
                            using (var client = new HttpClient())
                            {
                                client.BaseAddress = new Uri(url);
                                client.DefaultRequestHeaders.Accept.Clear();
                                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                                string llamada = string.Format("CustomerStorage_SET?UsedStorage={2}&User={0}&Password={1}", config.user, config.password, espacio_usado_Final);
                                HttpResponseMessage response = await client.GetAsync(llamada);

                                if (response.IsSuccessStatusCode)
                                {
                                }
                            }
                        }
                        catch (BadInputException ex)
                        {
                            await Logger.sendLog(string.Format("{0} | {1} | {2}", ex.Message, ex.StackTrace, "Scanda.AppTray.ScandaConector.deleteHistory "), "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.AppTray.ScandaConector.deleteHistory "), "E");

                            Console.WriteLine(ex.Message);
                        }
                    }
                }
            }
        }