public bool RestoreBackup(BackupTask lBackupTask, string lBackupFilePath)
{
if (lBackupTask.Settings.SourcePathHelper.PathCorrect && lBackupTask.Settings.DestinationPathHelper.PathCorrect)
{
bool lFileModified = false; // TODO maybe warning on restore that files changed
bool lFileLocked = false;
string lErrorMessage = "";
// some file is locked, stop restore
if (CheckFilesToBackup(lBackupTask, ref lFileModified, ref lFileLocked, ref lErrorMessage) && !lFileLocked)
{
try
{
ZipHelper.ExtractToDirectory(lBackupFilePath, lBackupTask.Settings.SourcePathHelper.DirectoryPath);
return(true);
}
catch
{
}
}
else
{
// TODO error message
}
}
return(false);
}
private void textBoxSavesDirectory_TextChanged(object sender, TextChangedEventArgs e)
{
if (!fGUI_Reload)
{
BackupTask lBackupTask = fSettings.Settings.BackupTasks[fSelectedBackupTaskIndex];
lBackupTask.Settings.SavesPath = textBoxSavesPath.Text;
lBackupTask.UpdateSourceWatcher();
// set DestinationPath only if app is running and value of "textBoxSavesFolder" change
// don't change DestinationPath if it is already set (e.g manually)
if (lBackupTask.Settings.DestinationPath.Length == 0)
{
lBackupTask.Settings.DestinationPath = GetDefaultDestinationPath(lBackupTask.Settings.SavesPath);
}
}
// simple validation
if (Directory.Exists(textBoxSavesPath.Text) || File.Exists(textBoxSavesPath.Text))
{
textBoxSavesPath.BorderBrush = Brushes.Black;
}
else
{
textBoxSavesPath.BorderBrush = Brushes.Red;
}
}
public bool CheckBackupFrequency(BackupTask lBackupTask)
{
// function check if frequency + last backup time passed and next backup should be made
// if last backup was unsuccessful then we will return true (checking this task every tick)
DateTime lNextCheckTime = lBackupTask.LastBackupTime.AddMinutes(lBackupTask.Settings.BackupEvery);
return(lNextCheckTime < DateTime.Now);
}
private void decimalUpDownBackupEvery_ValueChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
if (!fGUI_Reload)
{
BackupTask lBackupTask = fSettings.Settings.BackupTasks[fSelectedBackupTaskIndex];
lBackupTask.Settings.BackupEvery = (int)decimalUpDownBackupEvery.Value;
}
}
public void RefreshDestinationDirectorySize(BackupTask pBackupTask)
{
pBackupTask.DestinationDirectorySize = GetDirectorySize(pBackupTask.Settings.DestinationPath);
long lManualSize = GetDirectorySize(Path.Combine(pBackupTask.Settings.DestinationPath, "Manual"));
long lPreRestore = GetDirectorySize(Path.Combine(pBackupTask.Settings.DestinationPath, "Pre-Restore"));
pBackupTask.ManualAndPreRestoreBackupsSize = (lManualSize > 0 ? lManualSize: 0) + (lPreRestore > 0 ? lPreRestore : 0);
}
public bool SetBackupMakerAndTask(BackupMaker lBackupMaker, BackupTask lBackupTask)
{
fBackupMaker = lBackupMaker;
fBackupTask = lBackupTask;
this.Title = "Restore: " + lBackupTask.Settings.Name;
return(ListFiles());
}
private void textBoxFileNameFilter_TextChanged(object sender, TextChangedEventArgs e)
{
if (!fGUI_Reload)
{
BackupTask lBackupTask = fSettings.Settings.BackupTasks[fSelectedBackupTaskIndex];
lBackupTask.Settings.FileFilterRegex = textBoxFileNameFilter.Text;
}
}
private void textBoxTaskName_TextChanged(object sender, TextChangedEventArgs e)
{
if (!fGUI_Reload)
{
BackupTask lBackupTask = fSettings.Settings.BackupTasks[fSelectedBackupTaskIndex];
lBackupTask.Settings.Name = textBoxTaskName.Text;
}
}
private void textBoxBackupFileNamePattern_TextChanged(object sender, TextChangedEventArgs e)
{
if (!fGUI_Reload)
{
BackupTask lBackupTask = fSettings.Settings.BackupTasks[fSelectedBackupTaskIndex];
lBackupTask.Settings.BackupFileNamePattern = textBoxBackupFileNamePattern.Text;
}
}
private void checkBoxAutomaticDestinationDirSizeLimit_CheckedChanged(object sender, RoutedEventArgs e)
{
if (!fGUI_Reload)
{
BackupTask lBackupTask = fSettings.Settings.BackupTasks[fSelectedBackupTaskIndex];
lBackupTask.Settings.DestinationDirSizeLimitEnabled = (checkBoxAutomaticDestinationDirSizeLimit.IsChecked == true);
}
}
private void decimalUpDownDestinationDirSizeLimit_ValueChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
if (!fGUI_Reload)
{
BackupTask lBackupTask = fSettings.Settings.BackupTasks[fSelectedBackupTaskIndex];
lBackupTask.Settings.DestinationDirSizeLimit = (int)decimalUpDownDestinationDirSizeLimit.Value;
}
}
public bool CheckFilesToBackup(BackupTask lBackupTask, ref bool pFileModified, ref bool pFileLocked, ref string pErrorMessage)
{
// return on true success, false if error occurred
//pFileModified = false; // at least one file changed
//pFileLocked = false; // at least one file locked
//pErrorMessage = "";
bool lResult = false;
if (lBackupTask.Settings.SourcePathHelper.IsNotEmpty)
{
try
{
if (!lBackupTask.Settings.SourcePathHelper.ReCheck())
{
throw new ArgumentException("Wrong source directory");
}
// check if we have path to directory or to single file
string[] lAllFiles = lBackupTask.Settings.SourcePathHelper.GetAllFiles();
foreach (var lFile in lAllFiles)
{
// ignore log files
if (!CheckFilterForFile(lBackupTask.Settings.FileFilterRegex, lFile))
{
// check every file to find if any of them are locked
if (IsFileLocked(lFile, ref pErrorMessage))
{
pFileLocked = true;
break;
}
// check if file was modified, do that until first modified file is found
else if (!pFileModified)
{
FileInfo lInfo = new FileInfo(lFile);
if (lInfo.LastWriteTime > lBackupTask.LastBackupTime)
{
pFileModified = true;
}
}
}
}
// if file locked then this is error else success
// to consider: check both FileLocked and FileModified simultaneously and return error only if is Modified and is Locked instead if it is only Locked (in other words report error only if files did change but they are locked)
lResult = !pFileLocked;
}
catch (Exception E)
{
pErrorMessage = E.Message;
}
}
return(lResult);
}
private void buttonAddBackupTask_Click(object sender, RoutedEventArgs e)
{
BackupTask lBackupTask = new BackupTask();
lBackupTask.SetDefault();
fSettings.Settings.BackupTasks.Add(lBackupTask);
FillComboBoxItems();
SelectTaskByIndex(fSettings.Settings.BackupTasks.Count - 1, false);
}
private void buttonManualBackup_Click(object sender, RoutedEventArgs e)
{
BackupTask lBackupTask = fSettings.Settings.BackupTasks[fSelectedBackupTaskIndex];
string lErrorMessage = "";
lBackupTask.SetLastBackupStatus(fBackupMaker.MakeBackup(lBackupTask, BackupType.btManual, ref lErrorMessage), lErrorMessage);
fBackupMaker.RefreshDestinationDirectorySize(lBackupTask);
// we made backup of currently selected item, refresh GUI to refresh last backup time
SelectTaskByIndex(-1, false); // reselect same item, refresh interface
}
private void checkBox_CheckedChanged(object sender, RoutedEventArgs e)
{
if (!fGUI_Reload)
{
BackupTask lBackupTask = fSettings.Settings.BackupTasks[fSelectedBackupTaskIndex];
lBackupTask.Settings.IsAutoBackupActive = (checkBoxAutomaticBackup.IsChecked == true);
lBackupTask.UpdateSourceWatcher();
// status change, refill combobox to refresh names
FillComboBoxItems();
SelectTaskByIndex(-1, true); // reselect same item
}
}
public string[] GetBackupsList(BackupTask lBackupTask, ref string pErrorMessage)
{
// return list of files
// pErrorMessage = "";
if (lBackupTask.Settings.DestinationPathHelper.IsNotEmpty)
{
try
{
return(lBackupTask.Settings.DestinationPathHelper.GetAllFiles());
}
catch (Exception E)
{
pErrorMessage = E.Message;
}
}
return(null);
}
public bool MakeBackup(BackupTask lBackupTask, BackupType lType, string lManualPostfix, ref string pErrorMessage)
{
string lBackupFileName = DateTime.Now.ToString(lBackupTask.Settings.BackupFileNamePattern);
lBackupFileName += BackupTypeToFilePostfix(lType, lManualPostfix);
lBackupFileName += ".zip";
string lDestinationPath = DirectoryForBakupType(lType, lBackupTask.Settings.DestinationPath);
try
{
// to be sure that backup dir exists
Directory.CreateDirectory(lDestinationPath);
// try to make a backup
if (lBackupTask.Settings.SourcePathHelper.IsFile)
{
ZipHelper.CreateFromFile(lBackupTask.Settings.SourcePathHelper.FilePath, lDestinationPath + lBackupFileName, CompressionLevel.Fastest, false, null, null);
}
else
{
ZipHelper.CreateFromDirectory(lBackupTask.Settings.SourcePathHelper.DirectoryPath, lDestinationPath + lBackupFileName, CompressionLevel.Fastest, false, null, lFilterFileName => !CheckFilterForFile(lBackupTask.Settings.FileFilterRegex, lFilterFileName));
}
pErrorMessage = "";
return(true);
}
catch (Exception E)
{
pErrorMessage = E.Message;
try
{
// probably file was created but content is corrupted or just not complete, remove it
File.Delete(lDestinationPath + lBackupFileName);
}
catch
{
// not important
}
return(false);
}
}
private void buttonNamedBackup_Click(object sender, RoutedEventArgs e)
{
NamedBackup lNamedBackupWindow = new NamedBackup();
lNamedBackupWindow.Owner = this;
lNamedBackupWindow.WindowStartupLocation = WindowStartupLocation.CenterOwner;
if (lNamedBackupWindow.ShowDialog() == true)
{
BackupTask lBackupTask = fSettings.Settings.BackupTasks[fSelectedBackupTaskIndex];
string lErrorMessage = "";
lBackupTask.SetLastBackupStatus(fBackupMaker.MakeBackup(lBackupTask, BackupType.btManualWithCustomPostfix, lNamedBackupWindow.GetBackupName(), ref lErrorMessage), lErrorMessage);
fBackupMaker.RefreshDestinationDirectorySize(lBackupTask);
// we made backup of currently selected item, refresh GUI to refresh last backup time
SelectTaskByIndex(-1, false); // reselect same item, refresh interface
}
}
private void textBoxDestinationPath_TextChanged(object sender, TextChangedEventArgs e)
{
if (!fGUI_Reload)
{
BackupTask lBackupTask = fSettings.Settings.BackupTasks[fSelectedBackupTaskIndex];
if (textBoxDestinationPath.Text.Length > 0)
{
// if path has no trailing backslash add it
if (!textBoxDestinationPath.Text.EndsWith("\\"))
{
textBoxDestinationPath.Text += "\\";
}
lBackupTask.Settings.DestinationPath = textBoxDestinationPath.Text;
}
else
{
lBackupTask.Settings.DestinationPath = GetDefaultDestinationPath(lBackupTask.Settings.SavesPath);
}
lBackupTask.UpdateDestinationWatcher();
}
}
public void CleanUpOldBackups(BackupTask lBackupTask, ref string pErrorMessage)
{
if (lBackupTask.DestinationDirectorySizeLimitReached())
{
DirectoryInfo lDirInfo = new DirectoryInfo(lBackupTask.Settings.DestinationPath);
FileInfo[] lFiles = lDirInfo.GetFiles().OrderBy(f => f.CreationTime).ToArray();
try
{
int lFilesCount = lFiles.Length;
foreach (FileInfo lFile in lFiles)
{
// even if limit is reached we leave at least 4 files
if (lFilesCount <= 4)
{
return;
}
// remove current file
lFile.Delete();
lFilesCount--;
RefreshDestinationDirectorySize(lBackupTask);
if (!lBackupTask.DestinationDirectorySizeLimitReached())
{
break;
}
}
}
catch (Exception E)
{
pErrorMessage = E.Message;
}
}
}
private void SelectTaskByIndex(int lIndex, bool lComboBoxOnly)
{
// set lIndex to -1 to reselect item previously selected
if ((lIndex == -1) && (fSelectedBackupTaskIndex > -1))
{
lIndex = fSelectedBackupTaskIndex;
}
if (lIndex >= fSettings.Settings.BackupTasks.Count)
{
lIndex = 0;
}
if ((lIndex >= 0) && (lIndex < fSettings.Settings.BackupTasks.Count))
{
fGUI_Reload = true;
BackupTask lBackupTask = fSettings.Settings.BackupTasks[lIndex];
fSelectedBackupTaskIndex = lIndex;
comboBoxBackupTasks.SelectedIndex = lIndex;
fSettings.Settings.LastSelectedTaskIndex = lIndex;
// check if we want to refresh all or just reselect combobox
if (!lComboBoxOnly)
{
checkBoxAutomaticBackup.IsChecked = lBackupTask.Settings.IsAutoBackupActive;
textBoxTaskName.Text = lBackupTask.Settings.Name;
textBoxSavesPath.Text = lBackupTask.Settings.SavesPath;
textBoxDestinationPath.Text = lBackupTask.Settings.DestinationPath;
textBoxFileNameFilter.Text = lBackupTask.Settings.FileFilterRegex;
textBoxBackupFileNamePattern.Text = lBackupTask.Settings.BackupFileNamePattern;
if (lBackupTask.DestinationDirectorySize > 0)
{
if (lBackupTask.ManualAndPreRestoreBackupsSize > 0)
{
labelDestinationDirSizeValue.Content = ByteSize.FromBytes(lBackupTask.DestinationDirectorySize).ToString() + " + " + ByteSize.FromBytes(lBackupTask.ManualAndPreRestoreBackupsSize).ToString();
}
else
{
labelDestinationDirSizeValue.Content = ByteSize.FromBytes(lBackupTask.DestinationDirectorySize).ToString();
}
}
else if (lBackupTask.DestinationDirectorySize == 0)
{
labelDestinationDirSizeValue.Content = "[empty]";
}
else
{
labelDestinationDirSizeValue.Content = "[unknown]";
}
// if directory was not set (eg. older version of app) set it to default one
if (lBackupTask.Settings.DestinationPath.Length == 0)
{
lBackupTask.Settings.DestinationPath = GetDefaultDestinationPath(lBackupTask.Settings.SavesPath);
}
checkBoxAutomaticDestinationDirSizeLimit.IsChecked = lBackupTask.Settings.DestinationDirSizeLimitEnabled;
decimalUpDownDestinationDirSizeLimit.Value = lBackupTask.Settings.DestinationDirSizeLimit;
decimalUpDownBackupEvery.Value = lBackupTask.Settings.BackupEvery;
SetMakeBackupStatus(lBackupTask.BackupChecked, String.IsNullOrEmpty(lBackupTask.LastBackupErrorMessage));
// set last backup time
labelLastBackupValue.Content = lBackupTask.GetLastBackupTime();
if (String.IsNullOrEmpty(lBackupTask.LastBackupErrorMessage))
{
textBlockLastError.Text = "none";
}
else
{
textBlockLastError.Text = lBackupTask.LastBackupErrorMessage;
}
}
fGUI_Reload = false;
}
}
private void CheckTasks()
{
bool lRefreshComboBox = false;
Int64 lSettingsChangeCounter = 0;
for (int lIndex = 0; lIndex < fSettings.Settings.BackupTasks.Count; ++lIndex)
{
BackupTask lBackupTask = fSettings.Settings.BackupTasks[lIndex];
bool lItemUpdateNeeded = false;
// calculate global ChangeCount of all task, it will be used to see if there was some change made recently
// we calculate ChangeCount only for parameters that we want to check
lSettingsChangeCounter += lBackupTask.ChangeCounter + lBackupTask.Settings.ChangeCounter;
// if paths are wrong we can't do anything, go to next task
if (lBackupTask.Settings.SourcePathHelper.IsEmpty || String.IsNullOrEmpty(lBackupTask.Settings.DestinationPath))
{
continue;
}
// check flag from SourceFileWatcher
if (lBackupTask.SourceFilesChanged)
{
// if auto backup enabled and check frequency
if (lBackupTask.Settings.IsAutoBackupActive && fBackupMaker.CheckBackupFrequency(lBackupTask))
{
string lErrorMessage = "";
bool lErrorOccurred = false;
bool lFileWasModified = false;
bool lFileIsLocked = false;
// we will do something, anything happens it GUI need to be updated
lItemUpdateNeeded = true;
// check for files modification, function result success/error
if (!fBackupMaker.CheckFilesToBackup(lBackupTask, ref lFileWasModified, ref lFileIsLocked, ref lErrorMessage))
{
// error occurred (or file is locked)
lRefreshComboBox = true;
lErrorOccurred = true;
lBackupTask.SetLastBackupStatus(!lErrorOccurred, lErrorMessage);
}
else if (lFileWasModified)
{
// success and file was modified
lErrorOccurred = !fBackupMaker.MakeBackup(lBackupTask, BackupType.btNormal, ref lErrorMessage);
lBackupTask.SetLastBackupStatus(!lErrorOccurred, lErrorMessage);
lRefreshComboBox = true;
}
else
{
// no error (and files are not locked) but also nothing changed
if (!String.IsNullOrEmpty(lBackupTask.LastBackupErrorMessage))
{
lBackupTask.LastBackupErrorMessage = "";
lRefreshComboBox = true;
}
}
// backup was updated or there was no change that is important for us
// if error then try again latter (do not reset FilesChanged flag)
if (!lErrorOccurred)
{
lBackupTask.SourceFilesChanged = false;
}
}
}
// check flag from DestinationFileWatcher
if (lBackupTask.DestinationDirectoryChanged)
{
string lErrorMessage = "";
// to check if Size was changed
long lLastDestinationDirectorySize = lBackupTask.DestinationDirectorySize;
// backup was made so we need to update destination directory size once more
fBackupMaker.RefreshDestinationDirectorySize(lBackupTask);
// if destination directory size limit is set then remove older files
fBackupMaker.CleanUpOldBackups(lBackupTask, ref lErrorMessage);
lBackupTask.DestinationDirectoryChanged = false;
// if size is same as before skip updating
lItemUpdateNeeded = (lLastDestinationDirectorySize != lBackupTask.DestinationDirectorySize);
}
// if we made a backup of currently selected item we need to refresh data on GUI
if (fSelectedBackupTaskIndex == lIndex)
{
// check if something change or maybe we updated destination directory size
if (lItemUpdateNeeded)
{
SelectTaskByIndex(lIndex, false); // reselect same item, refresh interface
}
}
}
fTasksCheckedAtLeastOnce = true;
// Last Backup Time of some item changed, refresh list
if (lRefreshComboBox)
{
FillComboBoxItems();
}
// save settings if something changed
if (fSettingsChangeCounter != lSettingsChangeCounter)
{
if (fSettingsChangeCounter != -1)
{
fSettings.SaveConfig();
}
fSettingsChangeCounter = lSettingsChangeCounter;
}
}
public bool MakeBackup(BackupTask lBackupTask, BackupType lType, ref string pErrorMessage)
{
return(MakeBackup(lBackupTask, lType, "", ref pErrorMessage));
}
