private async Task sync_lastestUploads()
{
try
{
List <Historico> items = new List <Historico>()
{
};
var response = await ScandaConector.getLastUploads(config.id_customer);
if (response != null)
{
foreach (string key in response.Keys)
{
string item = response[key];
var strs = item.Split(' ');
items.Add(new Historico()
{
RFC = key, Fecha = strs[0] + " " + strs[1]
});
}
}
}
catch (Exception ex) {
await Logger.sendLog(string.Format("{0} | {1} | {2}", ex.Message, ex.StackTrace, "Scanda.AppTray.LoginForm.sync_lastestUploads"), "E");
/*Logger.sendLog(ex.Message
+ "\n" + ex.Source
+ "\n" + ex.StackTrace
+ "\n" + ex.StackTrace
+ "\n");*/
}
}
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);
}
private async void RecuperarForm_Load(object sender, EventArgs e)
{
// Obtenemos el listado de Folders
List <string> files = await ScandaConector.getFolders(config.id_customer);
int x = 0;
foreach (string anio in files)
{
var tile = new MetroTile();
tile.Text = anio;
tile.TextAlign = ContentAlignment.MiddleCenter;
tile.Location = new Point(x, 19);
tile.Width = 150;
tile.Height = 150;
tile.Click += MetroTile_Click;
metroTabPageRespaldos.Controls.Add(tile);
x += 160;
}
}
private async void MetroTile_Click(object sender, EventArgs e)
{
var obj = (MetroTile)sender;
var tab = new MetroTabPage();
tab.Name = "Tab_" + obj.Text;
tab.Text = obj.Text;
tab.AutoScroll = true;
List <FileDetail> storage_files = new List <FileDetail>()
{
};
// Obtenemos el Listado de meses de ese año
List <string> meses = await ScandaConector.getMonths(config.id_customer, obj.Text);
foreach (string mes in meses)
{
List <string> files = await ScandaConector.getFiles(config.id_customer, obj.Text, mes);
foreach (string file in files)
{
var match = Regex.Match(file, RFCregexp);
storage_files.Add(new FileDetail()
{
file = file, mes = mes, rfc = match.ToString()
});
}
// storage_files.AddRange(files);
}
int y = 20;
var parents = storage_files.Where(ent => ent.rfc != "").Select(ent => ent.rfc).Distinct().ToArray();
foreach (var parent in parents)
{
FileDetail[] files = storage_files.Where(ent => ent.rfc == parent).ToArray <FileDetail>();
Label lblGroup = new Label();
lblGroup.Text = parent + "\n______________________________________";
lblGroup.BackColor = Color.White;
lblGroup.Width = 200;
lblGroup.TextAlign = ContentAlignment.MiddleCenter;
lblGroup.Location = new Point(0, y);
y += 25;
tab.Controls.Add(lblGroup);
foreach (FileDetail file in files)
{
var checkbox = new MetroCheckBox();
checkbox.Text = file.file;// string.Format("archivo_{0}.zip", i);
checkbox.Name = obj.Text + "_" + file.mes + "_" + file.file;
checkbox.Width = 300;
checkbox.Location = new Point(0, y);
y += 20;
tab.Controls.Add(checkbox);
}
y += 30;
}
bool found = false;
foreach (MetroTabPage page in metroTabControlPrincipal.TabPages)
{
if (tab.Name == page.Name)
{
metroTabControlPrincipal.SelectedTab = page;
found = true;
}
}
if (!found)
{
metroTabControlPrincipal.TabPages.Add(tab);
}
}
private async void syncNowToolStripMenuItem_Click(object sender, EventArgs e)
{
try
{
json = File.ReadAllText(configuration_path);
config = JsonConvert.DeserializeObject <Config>(json);
string base_url = string.Empty;
if (!string.IsNullOrEmpty(config.path))
{
base_url = ConfigurationManager.AppSettings["api_url"];
syncNowToolStripMenuItem.Enabled = false;
configuracionToolStripMenuItem.Enabled = false;
descargarToolStripMenuItem.Enabled = false;
syncNowToolStripMenuItem.Text = "Sincronizando...";
}
#region Validacion de Directorios
// Revisamos si existe el directorio de respaldos
if (!string.IsNullOrEmpty(config.path) && !Directory.Exists(config.path))
{
Directory.CreateDirectory(config.path);
}
// Revisamos si existe el directorio de historicos, si esta en configuracion 3 significa que el archivo localmente se tiene que borrar, por tanto no es necesario crear una carpeta
if (!string.IsNullOrEmpty(config.hist_path) && !Directory.Exists(config.hist_path) && config.type_storage != "3")
{
Directory.CreateDirectory(config.hist_path);
}
#endregion
// Obtenemos listado de archivos del directorio
if (!string.IsNullOrEmpty(config.path))
{
//string[] fileEntries = Directory.GetFiles(config.path);
List <string> fileEntries = Directory.GetFiles(config.path).Where(ent => isValidFileName(ent) && isValidExt(ent, config.extensions)).ToList();
//if (fileEntries != null && fileEntries.Length>0)
if (fileEntries != null && fileEntries.Count > 0)
{
notifyIconScanda.ShowBalloonTip(1000, "Sincronizando", "Se estan sicronizando los archivos a su dispositivo de la nube", ToolTipIcon.Info);
foreach (string file in fileEntries)
{
Status temp2 = new Status(base_url, notifyIconScanda, syncNowToolStripMenuItem, config.user, config.password);
FileInfo info = new FileInfo(file);
var x = await ScandaConector.uploadFile(file, config.id_customer, temp2, config.extensions, config, configuration_path);
if (!x)
{
notifyIconScanda.ShowBalloonTip(1000, "Alerta", string.Format("Error al sincronizar {0}", info.Name), ToolTipIcon.Error);
await Logger.sendLog(string.Format("{0} | {1} | {2}", info.Name, "Error al sincronizar ", "Scanda.AppTray.FormTray.syncNowToolStripMenuItem_Click"), "E");
}
else
{
notifyIconScanda.ShowBalloonTip(1000, "DBProtector", string.Format("Finalizo subida de {0}", info.Name), ToolTipIcon.Info);
await Logger.sendLog(string.Format("{0} | {1} | {2}", info.Name, "Archivo subido correctamente ", "Scanda.AppTray.FormTray.syncNowToolStripMenuItem_Click"), "T");
}
}
}
else
{
notifyIconScanda.ShowBalloonTip(1000, "Sincronizando", "No hay respaldos pendientes por sincronizar", ToolTipIcon.Warning);
}
}
// Termino de hacer todos los respaldos
syncNowToolStripMenuItem.Text = "Sincronizar ahora";
syncNowToolStripMenuItem.Enabled = true;
configuracionToolStripMenuItem.Enabled = true;
descargarToolStripMenuItem.Enabled = true;
}
catch (Exception ex)
{
// Termino de hacer todos los respaldos
syncNowToolStripMenuItem.Text = "Sincronizar ahora";
syncNowToolStripMenuItem.Enabled = true;
configuracionToolStripMenuItem.Enabled = true;
descargarToolStripMenuItem.Enabled = true;
await Logger.sendLog(string.Format("{0} | {1} | {2}", ex.Message, ex.StackTrace, "Scanda.AppTray.FormTray.syncNowToolStripMenuItem_Click"), "E");
/*Logger.sendLog(ex.Message
+ "\n" + ex.Source
+ "\n" + ex.StackTrace
+ "\n" + ex.StackTrace
+ "\n", "E");*/
}
finally
{
syncNowToolStripMenuItem.Text = "Sincronizar ahora";
syncNowToolStripMenuItem.Enabled = true;
configuracionToolStripMenuItem.Enabled = true;
descargarToolStripMenuItem.Enabled = true;
}
}
async void RecuperarForm_Close(object sender, EventArgs e)
{
try
{
var form = (RecuperarForm)sender;
string base_url = ConfigurationManager.AppSettings["api_url"];
//Bitmap bmp = Properties.Resources.QuotaDownload;
//notifyIconScanda.Icon = Icon.FromHandle(bmp.GetHicon());
#region Validacion de Directorios
// Revisamos si existe el directorio de respaldos
if (!string.IsNullOrEmpty(config.path) && !Directory.Exists(config.path))
{
Directory.CreateDirectory(config.path);
}
if (!string.IsNullOrEmpty(config.hist_path))
{
// Revisamos si existe el directorio de historicos
if (!Directory.Exists(config.hist_path))
{
Directory.CreateDirectory(config.hist_path);
}
}
#endregion
if (form.controls.Count > 0)
{
syncNowToolStripMenuItem.Enabled = false;
configuracionToolStripMenuItem.Enabled = false;
descargarToolStripMenuItem.Enabled = false;
foreach (Control ctrl in form.controls)
{
string[] file = ctrl.Name.Split('_');
Status temp = new Status(base_url, notifyIconScanda, descargarToolStripMenuItem, config.user, config.password);
// Pedimos donde descargar el archivo
FolderBrowserDialog fbd = new FolderBrowserDialog();
fbd.Description = "Seleccione el folder donde desea almacenar su historico";
if (fbd.ShowDialog() == DialogResult.OK)
{
var selectedPath = fbd.SelectedPath;
notifyIconScanda.ShowBalloonTip(1000, "Sincronizando", "Se estan sicronizando los archivos a su dispositivo", ToolTipIcon.Info);
var res = await ScandaConector.downloadFile(config.id_customer, file[0], file[1], file[2], temp, config.path);
if (!res)
{
notifyIconScanda.ShowBalloonTip(1000, "Alerta", string.Format("Error al sincronizar {0}", file[2]), ToolTipIcon.Error);
await Logger.sendLog(string.Format("{0} | {1} | {2}", file[2], "Error al sincronizar ", "Scanda.AppTray.FormTray.RecuperarForm_Close"), "E");
}
else
{
notifyIconScanda.ShowBalloonTip(1000, "DBProtector", string.Format("Finalizo descarga de {0}", file[2]), ToolTipIcon.Info);
await Logger.sendLog(string.Format("{0} | {1} | {2}", file[2], "Finalizo descarga ", "Scanda.AppTray.FormTray.RecuperarForm_Close"), "T");
switch (int.Parse(config.type_storage))
{
case 1:
if (File.Exists(config.path + "\\" + file[2]))
{
// Se copia a respaldados
File.Move(config.path + "\\" + file[2], selectedPath + "\\" + file[2]);
}
break;
case 2:
if (File.Exists(config.path + "\\" + file[2]))
{
// Se copia a la carpeta seleccionada
File.Move(config.path + "\\" + file[2], selectedPath + "\\" + file[2]);
// File.Move(config.path + "\\" + file[2], config.user_path + "\\" + file[2]);
}
break;
case 3:
if (File.Exists(config.path + "\\" + file[2]))
{
// Se copia a la carpeta seleccionada
File.Move(config.path + "\\" + file[2], selectedPath + "\\" + file[2]);
// File.Delete(config.path + "\\" + file[2]);
}
break;
}
}
}
}
}
// notifyIconScanda.Icon = Properties.Resources.AppIcon;
} catch (Exception ex) {
await Logger.sendLog(string.Format("{0} | {1} | {2}", ex.Message, ex.StackTrace, "Scanda.AppTray.FormTray.RecuperarForm_Close"), "E");
}
finally
{
if (string.IsNullOrEmpty(config.path))
{
syncNowToolStripMenuItem.Enabled = false;
}
else
{
syncNowToolStripMenuItem.Enabled = true;
}
configuracionToolStripMenuItem.Enabled = true;
descargarToolStripMenuItem.Enabled = true;
}
}
public static async Task <bool> uploadFile(string archivo, string usrId, Status status, List <string> extensions = null, Config config = null, string config_path = null)
{
status.upload.file = archivo;
status.upload.status = 1;
try
{
FileInfo info = new FileInfo(archivo);
//validamos extensiones
if (!isValidExt(info.Extension, extensions))
{
return(false); // No es una extension valida
}
double size = (double)info.Length / (double)B_TO_MB;
//Validamos el tamanio
bool esvalido = await isValidSize(Math.Ceiling(size), config);
if (!esvalido)
{
return(false);
}
string name = info.Name;
status.upload.file = info.Name;
//NOmbre del archivo
if (!isValidFileName(name))
{
return(false);
}
//Generamos la ruta
DateTime date = DateTime.Today;
string year;
string month;
year = date.Year + "";
if (date.Month < 10)
{
month = "0" + date.Month;
}
else
{
month = "" + date.Month;
}
//Zipeamos l archivo
await Logger.sendLog(string.Format("{0} | {1} | {2}", archivo, "Cifrando archivo...", "Scanda.AppTray.ScandaConector.uploadFile"), "T");
string zip = cifrar(archivo, usrId);
await Logger.sendLog(string.Format("{0} | {1} | {2}", archivo, "Cifrando completo...", "Scanda.AppTray.ScandaConector.uploadFile"), "T");
string ruta = usrId + "/" + year + "/" + month;
status.upload.status = 1;
await Logger.sendLog(string.Format("{0} | {1} | {2}", archivo, "Comenzando subida...", "Scanda.AppTray.ScandaConector.uploadFile"), "T");
var res = await uploadZipFile(zip, ruta, status);
if (res)
{
await Logger.sendLog(string.Format("{0} | {1} | {2}", archivo, "subida terminada...", "Scanda.AppTray.ScandaConector.uploadFile"), "T");
await sync_accountinfo(config, config_path);
// Realizamos la limpieza en Cloud
await Logger.sendLog(string.Format("{0} | {1} | {2}", "", "Comienza limpieza en la nube", "Scanda.AppTray.FormTray.syncNowToolStripMenuItem_Click"), "T");
await ScandaConector.deleteHistory(config.id_customer, int.Parse(config.cloud_historical), config);
await Logger.sendLog(string.Format("{0} | {1} | {2}", "", "Termina limpieza en la nube", "Scanda.AppTray.Scanda.AppTray.ScandaConector.uploadFile"), "T");
#region Realizamos el movimiento de los archivos que se suben a la carpeta historicos
if (!string.IsNullOrEmpty(config.type_storage) && config.type_storage != "3")
{
// Comenzamos a mover los archivos
// List<FileInfo> fileEntries2 = new DirectoryInfo(config.path).GetFiles().Where(ent => isValidFileName(ent.Name) && isValidExt(ent.Name, config.extensions)).OrderBy(f => f.LastWriteTime).ToList();
// foreach (FileInfo file in fileEntries2)
//{
if (isValidFileName(info.Name))
{
//cuando vale 1 y 2 se mueve a una carpeta el respaldo, cuanfdo vale 3 se borra localmente
if (config.type_storage == "1" || config.type_storage == "2")
{
// Se copia a Historicos
if (File.Exists(config.hist_path + "\\" + info.Name))
{
File.Delete(config.hist_path + "\\" + info.Name);
}
File.Copy(config.path + "\\" + info.Name, config.hist_path + "\\" + info.Name);
}
File.Delete(config.path + "\\" + info.Name);
}
//}
List <FileInfo> histFileEntries = new DirectoryInfo(config.hist_path).GetFiles().OrderBy(f => f.LastWriteTime).ToList();
// verificamos el limite
//Borramos en la nube
//ScandaConector.deleteHistory(config.id_customer, config.file_historical);
//Borramos local
bool canTransfer = false;
while (!canTransfer)
{
if (histFileEntries.Count() <= int.Parse(config.file_historical))
{
canTransfer = true;
}
else
{
FileInfo item = histFileEntries.FirstOrDefault();
if (item != null)
{
File.Delete(config.hist_path + "\\" + item.Name);
}
histFileEntries.Remove(item);
}
}
}
else if (config.type_storage == "3")
{
// Comenzamos a mover los archivos
// List<FileInfo> fileEntries2 = new DirectoryInfo(config.path).GetFiles().OrderBy(f => f.LastWriteTime).ToList();
// foreach (FileInfo file in fileEntries2)
// {
if (isValidFileName(info.Name))
{
// Se borra el archivo localmente porque la configurcion es 3
File.Delete(config.path + "\\" + info.Name);
}
//}
}
#endregion
await Logger.sendLog(string.Format("{0} | {1} | {2}", "", "Termina limpieza de archivos temporales local", "Scanda.AppTray.ScandaConector.syncNowToolStripMenuItem_Click"), "T");
await sync_accountinfo(config, config_path);
await sync_updateAccount(config, config_path);
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
await Logger.sendLog(string.Format("{0} | Error al sincronizar {1} | {2}", "Scanda.AppTray.ScandaConector.uploadFile", ex.Message, ex.StackTrace), "E");
return(false);
}
finally
{
//Se borran los archivos zip de la carpeta dbprotector
List <string> eliminables = Directory.GetFiles("C:\\DBProtector\\").Where(ent => { return(ent.EndsWith(".zip")); }).ToList();
if (eliminables != null)
{
foreach (string file in eliminables)
{
File.Delete(file); //Se borra el zip creado
}
}
}
}
//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);
}
}
}
}
}