private void BtnSupSauvegarde_Click(object sender, EventArgs e)
{
Directory.Delete(this.Backups[this.lstSauvegardes.SelectedIndex].Sauvegardes[this.lstHistorique.SelectedIndex].CheminDossier, true);
this.Backups[this.lstSauvegardes.SelectedIndex].Sauvegardes.RemoveAt(this.lstHistorique.SelectedIndex);
Utilitaire.EnregistrerBackups(this.Backups);
ActualiserForm();
}
private void BtnSupprimerBackup_Click(object sender, EventArgs e)
{
this.IndexBackupSelect = this.lstSauvegardes.SelectedIndex;
this.Backups.RemoveAt(this.IndexBackupSelect);
Utilitaire.EnregistrerBackups(this.Backups);
this.TachesEnCours[this.IndexBackupSelect].Dispose();
this.TachesEnCours.RemoveAt(this.IndexBackupSelect);
this.IndexBackupSelect = -1;
this.BackupSelect = new Backup("", new List <string>(), "", 0, new List <Sauvegarde>());
ActualiserForm();
}
public static async Task CreerSauvegardeAsync(Backup backup)
{
if (backup.Destination == null)
{
throw new ArgumentNullException(null, "Aucune destination n'a été entrée.");
}
else if (!Directory.Exists(backup.Destination))
{
Directory.CreateDirectory(backup.Destination);
}
bool dossier = false;
foreach (string cheminFichier in backup.CheminsFichiersSauvegardes)
{
if (cheminFichier == null)
{
throw new ArgumentNullException(null, "Fichier à copier manquant.");
}
else if (!File.Exists(cheminFichier))
{
if (!Directory.Exists(cheminFichier))
{
throw new FileNotFoundException("Le fichier à copier n'a pas été trouvé.");
}
else
{
dossier = true;
}
}
string nomSauvegarde = $"{backup.Nom}-{DateTime.Now.Year:0000}{DateTime.Now.Month:00}{DateTime.Now.Day:00}-" +
$"{DateTime.Now.Hour:00}{DateTime.Now.Minute:00}{DateTime.Now.Second:00}";
string nomFichier = cheminFichier.Substring(cheminFichier.LastIndexOf('\\') + 1);
if (!Directory.Exists(backup.Destination + $"\\{nomSauvegarde}"))
{
Directory.CreateDirectory(backup.Destination + $"\\{nomSauvegarde}");
}
if (!dossier)
{
File.Copy(cheminFichier,
backup.Destination + $"\\{nomSauvegarde}\\{nomFichier}",
File.Exists(backup.Destination + $"\\{nomSauvegarde}\\{nomFichier}"));
}
else
{
Utilitaire.Xcopy(cheminFichier,
backup.Destination + $"\\{nomSauvegarde}\\{nomFichier}");
}
backup.Sauvegardes.Add(new Sauvegarde(nomSauvegarde, backup.Destination + $"\\{nomSauvegarde}"));
}
}
private void BtnForceSauv_Click(object sender, EventArgs e)
{
try
{
Utilitaire.CreerSauvegardeAsync(this.BackupSelect).GetAwaiter().GetResult();
this.Backups.RemoveAt(this.IndexBackupSelect);
this.Backups.Add(this.BackupSelect);
Utilitaire.EnregistrerBackups(this.Backups);
ActualiserInfos();
}
catch (Exception exception)
{
Console.WriteLine(exception);
throw;
}
}
private void ActualiserBackups()
{
if (!Directory.Exists(Utilitaire.CheminData))
{
Directory.CreateDirectory(Utilitaire.CheminData);
}
if (!File.Exists(Utilitaire.CheminData + Utilitaire.BackupsFile))
{
Utilitaire.EnregistrerBackups(new List <Backup>());
}
this.Backups = Utilitaire.ChargerBackups();
this.lstSauvegardes.Items.Clear();
foreach (Backup backup in this.Backups)
{
this.lstSauvegardes.Items.Add(backup);
}
}
private void BtnQuitter_Click(object sender, EventArgs e)
{
try
{
Utilitaire.EnregistrerBackups(this.Backups);
foreach (Task tache in this.TachesEnCours)
{
tache.Dispose();
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
finally
{
Dispose();
}
}
public async Task AutoSave()
{
this.Chrono = new Stopwatch();
AutoSaveLoop:
try
{
this.Chrono.Restart();
TimeSpan frequence = TimeSpan.FromSeconds(this.Frequence);
Thread.Sleep(frequence);
await Utilitaire.CreerSauvegardeAsync(this);
goto AutoSaveLoop;
}
catch (Exception e)
{
MessageBox.Show($"Une erreur est survenue pendant la sauvegarde avec le message suivant : {e.Message}", "Erreur", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void BtnEnregistrer_Click(object sender, EventArgs e)
{
try
{
string nomBackup = this.txtNomSauvegarde.Text.Trim();
if (String.IsNullOrWhiteSpace(nomBackup))
{
throw new ArgumentException("Nom de backup invalide.");
}
List <string> cheminsFichiersSauvegardes = new List <string>();
foreach (string cheminFichier in this.txtToSave.Text.Trim().Trim(new char[] { ';' }).Split(';'))
{
cheminsFichiersSauvegardes.Add(cheminFichier.Trim(new char[] { '"' }));
}
if (cheminsFichiersSauvegardes.Count < 1)
{
throw new ArgumentException("Aucun fichier/dossier à sauvegarder n'a été selectionné.");
}
string destination = this.txtDestination.Text;
int freqJ = int.Parse(this.txtFreqJour.Text.Replace("J", "0"));
int freqH = int.Parse(this.txtFreqHeure.Text.Replace("H", "0"));
int freqM = int.Parse(this.txtFreqMin.Text.Replace("M", "0"));
int freqS = int.Parse(this.txtFreqSec.Text.Replace("S", "0"));
TimeSpan frequence = new TimeSpan(freqJ, freqH, freqM, freqS);
if (frequence.TotalSeconds < 30)
{
throw new ArgumentException("La fréquence minimum des sauvegardes est de 30 secondes.");
}
List <Sauvegarde> sauvegardes = new List <Sauvegarde>();
if (this.lstHistorique.Items.Count > 0)
{
foreach (object o in this.lstHistorique.Items)
{
Sauvegarde sauvegarde = (Sauvegarde)o;
sauvegardes.Add(sauvegarde);
}
}
Backup nvBackup = new Backup(nomBackup, cheminsFichiersSauvegardes, destination, frequence.TotalSeconds, sauvegardes);
int indexBackup = -1;
for (int i = 0; i < this.Backups.Count; i++)
{
if (this.Backups[i].Nom == nvBackup.Nom)
{
indexBackup = i;
break;
}
}
if (indexBackup < 0)
{
this.Backups.Add(nvBackup);
}
else
{
this.Backups[indexBackup] = nvBackup;
}
Utilitaire.EnregistrerBackups(this.Backups);
this.TachesEnCours.Add(Task.Run(nvBackup.AutoSave));
ActualiserForm();
this.IndexBackupSelect = this.lstSauvegardes.SelectedIndex = this.lstSauvegardes.Items.Count - 1;
}
catch (Exception exception)
{
MessageBox.Show($"Une erreur s'est produite avec le message suivant : {exception.Message}", "Erreur", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public static List <Backup> ChargerBackups()
{
List <Backup> backups = new List <Backup>();
try
{
XmlDocument xmlDoc = Utilitaire.ChargerFichierXml(Utilitaire.CheminData + Utilitaire.BackupsFile);
XmlNodeList listeElemBackup = xmlDoc.GetElementsByTagName("backup");
string nom;
List <string> cheminsFichiersSauvegardes;
string destination;
float frequence;
List <Sauvegarde> sauvegardes;
foreach (XmlElement elemBackup in listeElemBackup)
{
nom = elemBackup.GetElementsByTagName("nom")[0].InnerText;
cheminsFichiersSauvegardes = new List <string>();
XmlNodeList listeElemFichierSauvegarde = ((XmlElement)elemBackup.GetElementsByTagName("cheminsFichiersSauvegardes")[0]).GetElementsByTagName("cheminFichierSauvegarde");
for (int i = 0; i < listeElemFichierSauvegarde.Count; i++)
{
XmlElement elemFichierSauvegarde = (XmlElement)listeElemFichierSauvegarde.Item(i);
if (elemFichierSauvegarde == null)
{
throw new ArgumentNullException(null, "Fichier sauvegardé manquant dans le fichier XML.");
}
cheminsFichiersSauvegardes.Add(elemFichierSauvegarde.InnerText);
}
destination = elemBackup.GetElementsByTagName("destination")[0].InnerText;
frequence = float.Parse(elemBackup.GetElementsByTagName("frequence")[0].InnerText);
sauvegardes = new List <Sauvegarde>();
XmlNodeList listeElemSauvegarde = ((XmlElement)elemBackup.GetElementsByTagName("sauvegardes")[0]).GetElementsByTagName("sauvegarde");
for (int i = 0; i < listeElemSauvegarde.Count; i++)
{
XmlElement elemSauvegarde = (XmlElement)listeElemSauvegarde.Item(i);
if (elemSauvegarde == null)
{
throw new ArgumentNullException(null, "Sauvegarde manquante dans le fichier XML.");
}
string nomSauvegarde = elemSauvegarde.GetElementsByTagName("nom")[0].InnerText;
string dossierSauvegarde = elemBackup.GetElementsByTagName("dossier")[0].InnerText;
if (Directory.Exists(dossierSauvegarde))
{
sauvegardes.Add(new Sauvegarde(nomSauvegarde, dossierSauvegarde));
}
}
backups.Add(new Backup(nom, cheminsFichiersSauvegardes, destination, frequence, sauvegardes));
}
Utilitaire.EnregistrerBackups(backups);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
return(backups);
}
