private static async Task SyncBackup()
{
var settingsFacade = new SettingsFacade(new SettingsAdapter());
if (!settingsFacade.IsBackupAutouploadEnabled || !settingsFacade.IsLoggedInToBackupService)
{
return;
}
try
{
var pca = PublicClientApplicationBuilder
.Create(ServiceConstants.MSAL_APPLICATION_ID)
.WithRedirectUri($"msal{ServiceConstants.MSAL_APPLICATION_ID}://auth")
.WithIosKeychainSecurityGroup("com.microsoft.adalcache")
.Build();
var backupManager = new BackupManager(
new OneDriveService(pca),
ServiceLocator.Current.GetInstance <IFileStore>(),
new ConnectivityAdapter());
var backupService = new BackupService(backupManager, settingsFacade);
var backupDate = await backupService.GetBackupDate();
if (settingsFacade.LastDatabaseUpdate > backupDate)
{
return;
}
await backupService.RestoreBackup();
} catch (Exception ex)
{
Debug.Write(ex);
} finally
{
settingsFacade.LastExecutionTimeStampSyncBackup = DateTime.Now;
}
}
private void LoadME2FilesList()
{
var me2files = new List <BackupFile>();
var bup = BackupService.GetGameBackupPath(Mod.MEGame.ME2);
if (bup != null)
{
var target = new GameTarget(Mod.MEGame.ME2, bup, false);
var cookedPath = MEDirectories.CookedPath(target);
foreach (var f in Extensions.GetFiles(cookedPath, @"\.pcc|\.tfc|\.afc|\.bin|\.tlk", SearchOption.AllDirectories))
{
me2files.Add(new BackupFile(@"BASEGAME", Path.GetFileName(f)));
}
me2files.Sort(); //sort basegame
var dlcDir = MEDirectories.DLCPath(target);
var officialDLC = VanillaDatabaseService.GetInstalledOfficialDLC(target);
foreach (var v in officialDLC)
{
var cookedDLCPath = Path.Combine(dlcDir, v, @"CookedPC");
if (Directory.Exists(cookedDLCPath))
{
var filesToAdd = new List <BackupFile>();
foreach (var f in Directory.EnumerateFiles(cookedDLCPath, @"*.pcc", SearchOption.TopDirectoryOnly))
{
filesToAdd.Add(new BackupFile(v, Path.GetFileName(f)));
}
filesToAdd.Sort();
me2files.AddRange(filesToAdd);
}
}
}
Application.Current.Dispatcher.Invoke(delegate
{
ME2Files.ReplaceAll(me2files);
});
Debug.WriteLine(@"Num ME2 files: " + ME2Files.Count);
}
public async Task IsBackupExisting_NoNamesFound()
{
// Arrange
connectivityAdapterMock.SetupGet(x => x.IsConnected).Returns(true);
cloudBackupServiceMock.Setup(x => x.GetFileNamesAsync())
.ReturnsAsync(new List <string>());
var backupService = new BackupService(cloudBackupServiceMock.Object,
fileStoreMock.Object,
settingsFacadeMock.Object,
connectivityAdapterMock.Object,
contextAdapterMock.Object,
messengerMock.Object,
toastService);
// Act
bool result = await backupService.IsBackupExistingAsync();
// Assert
result.ShouldBeFalse();
}
public async Task Logout_loginSuccess_SettingsUpdated()
{
// Arrange
var backupManagerMock = new Mock <IBackupManager>();
backupManagerMock.Setup(x => x.Logout())
.ReturnsAsync(OperationResult.Succeeded());
var settingsFacade = new Mock <ISettingsFacade>();
settingsFacade.SetupAllProperties();
var backupService = new BackupService(backupManagerMock.Object, settingsFacade.Object);
// Act
var result = await backupService.Logout();
// Assert
result.Success.ShouldBeTrue();
settingsFacade.Object.IsBackupAutouploadEnabled.ShouldBeFalse();
settingsFacade.Object.IsLoggedInToBackupService.ShouldBeFalse();
}
public async Task Login_loginSuccess_SettingsUpdated()
{
// Arrange
connectivityAdapterMock.SetupGet(x => x.IsConnected).Returns(true);
cloudBackupServiceMock.Setup(x => x.LoginAsync()).Returns(Task.CompletedTask);
settingsFacadeMock.SetupAllProperties();
var backupService = new BackupService(cloudBackupServiceMock.Object,
fileStoreMock.Object,
settingsFacadeMock.Object,
connectivityAdapterMock.Object,
contextAdapterMock.Object);
// Act
await backupService.LoginAsync();
// Assert
settingsFacadeMock.Object.IsBackupAutouploadEnabled.ShouldBeTrue();
settingsFacadeMock.Object.IsLoggedInToBackupService.ShouldBeTrue();
}
public async Task EnqueueBackupTask_AutoUploadDisabled_NothingCalled()
{
// Arrange
var backupManagerMock = new Mock <IBackupManager>();
backupManagerMock.Setup(x => x.EnqueueBackupTask(It.IsAny <int>()))
.ReturnsAsync(OperationResult.Succeeded);
var settingsFacade = new Mock <ISettingsFacade>();
settingsFacade.SetupGet(x => x.IsBackupAutouploadEnabled).Returns(false);
var backupService = new BackupService(backupManagerMock.Object, settingsFacade.Object);
// Act
OperationResult result = await backupService.EnqueueBackupTask();
// Assert
backupManagerMock.Verify(x => x.Login(), Times.Never);
backupManagerMock.Verify(x => x.EnqueueBackupTask(It.IsAny <int>()), Times.Never);
result.Success.ShouldBeTrue();
}
public ModUpdateInformation(List <OnlineContent.ModUpdateInfo> modsWithUpdates)
{
modsWithUpdates.ForEach(x =>
{
x.ApplyUpdateCommand = new RelayCommand(ApplyUpdateToMod, CanApplyUpdateToMod);
if (x.mod.ModModMakerID > 0 && BackupService.GetGameBackupPath(x.mod.Game) == null)
{
x.DownloadButtonText = M3L.GetString(M3L.string_requiresBackup);
}
else if (x.mod.ModClassicUpdateCode > 0 || x.mod.ModModMakerID > 0)
{
x.DownloadButtonText = M3L.GetString(M3L.string_downloadUpdate);
}
else
{
x.DownloadButtonText = M3L.GetString(M3L.string_downloadUpdateFromNexusMods);
}
});
UpdatableMods.ReplaceAll(modsWithUpdates);
LoadCommands();
InitializeComponent();
}
public async Task EnqueueBackupTask_LoggedIn_EnqueueCalled()
{
// Arrange
var backupManagerMock = new Mock <IBackupManager>();
backupManagerMock.Setup(x => x.EnqueueBackupTaskAsync(It.IsAny <int>()))
.Returns(Task.CompletedTask);
var settingsFacade = new Mock <ISettingsFacade>();
settingsFacade.SetupGet(x => x.IsBackupAutouploadEnabled).Returns(true);
settingsFacade.SetupGet(x => x.IsLoggedInToBackupService).Returns(true);
var backupService = new BackupService(backupManagerMock.Object, settingsFacade.Object);
// Act
await backupService.EnqueueBackupTaskAsync();
// Assert
backupManagerMock.Verify(x => x.LoginAsync(), Times.Never);
backupManagerMock.Verify(x => x.EnqueueBackupTaskAsync(It.IsAny <int>()), Times.Once);
}
public async Task GetBackupDate_CorrectCall()
{
// Arrange
settingsFacadeMock.SetupGet(x => x.IsBackupAutouploadEnabled).Returns(true);
settingsFacadeMock.SetupGet(x => x.IsLoggedInToBackupService).Returns(true);
connectivityAdapterMock.SetupGet(x => x.IsConnected).Returns(true);
cloudBackupServiceMock.Setup(x => x.GetBackupDateAsync()).ReturnsAsync(DateTime.Today);
var backupService = new BackupService(cloudBackupServiceMock.Object,
fileStoreMock.Object,
settingsFacadeMock.Object,
connectivityAdapterMock.Object,
contextAdapterMock.Object,
longRunningTaskRequesterMock.Object);
// Act
DateTime result = await backupService.GetBackupDateAsync();
// Assert
result.ShouldEqual(DateTime.Today);
}
private async void RestoreBkpCommandExecute()
{
FileData fileData = null;
try
{
fileData = await CrossFilePicker.Current.PickFile();
var answer = await DialogService.DisplayAlertAsync($"Gostaria de restaurar este backup?", "O processo apagará os dados atuais e restaurará o do backup", "Sim", "Não");
if (fileData != null && answer)
{
string reportJson = Encoding.UTF8.GetString(fileData.DataArray, 0, fileData.DataArray.Length);
BackupService.ImportDatabaseFromJson(reportJson);
await DialogService.DisplayAlertAsync("Backup", $"Backup {fileData.FileName} Restaurado", "OK");
}
}
catch (Exception)
{
await DialogService.DisplayAlertAsync("Erro", $"Erro ao restaurar backup {fileData.FileName}", "Fechar");
}
}
public async Task RestoreBackup_Failed_LastBackupTimestampNotUpdated()
{
// Arrange
connectivityAdapterMock.SetupGet(x => x.IsConnected).Returns(true);
DateTime expectedPassedDate = DateTime.Now.AddDays(-3);
settingsFacadeMock.SetupAllProperties();
settingsFacadeMock.Object.LastDatabaseUpdate = expectedPassedDate;
settingsFacadeMock.SetupGet(x => x.IsBackupAutouploadEnabled).Returns(true);
settingsFacadeMock.SetupGet(x => x.IsLoggedInToBackupService).Returns(true);
cloudBackupServiceMock.Setup(x => x.GetFileNamesAsync())
.ReturnsAsync(new List <string> {
DatabaseConstants.BACKUP_NAME
});
cloudBackupServiceMock.Setup(x => x.RestoreAsync(It.IsAny <string>(), It.IsAny <string>()))
#pragma warning disable S3626 // Jump statements should not be redundant
.Callback(() => throw new BackupException());
#pragma warning restore S3626 // Jump statements should not be redundant
cloudBackupServiceMock.Setup(x => x.GetBackupDateAsync()).ReturnsAsync(DateTime.Now);
var backupService = new BackupService(cloudBackupServiceMock.Object,
fileStoreMock.Object,
settingsFacadeMock.Object,
connectivityAdapterMock.Object,
contextAdapterMock.Object,
messengerMock.Object,
toastService);
// Act
await Assert.ThrowsAsync <BackupException>(async() => await backupService.RestoreBackupAsync());
// Assert
settingsFacadeMock.Object.LastDatabaseUpdate.ShouldEqual(expectedPassedDate);
}
public ActionResult dbBackup_Restore()
{
string backupDIR = @"C:\eStore_BackupDB\";
if (!System.IO.Directory.Exists(backupDIR))
{
System.IO.Directory.CreateDirectory(backupDIR);
}
try
{
var connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
// string folderpath = "C:\\SQLBackup";
BackupService bs = new BackupService(connectionString, backupDIR);
bs.BackupDatabase(dbName);
TempData["success"] = "Database backup is successfully.";
}
catch (Exception ex)
{
TempData["error"] = "Database backup fail, Reason: " + ex.Message;
}
return(View("dashboard"));
}
protected override void SaveWorkerDoWork(object sender, DoWorkEventArgs e)
{
Utils.EnsureCulture();
Dispatcher.Invoke(new Action(() => {
btnStart.IsEnabled = btnClose.IsEnabled = false;
aiLoader.Visibility = Visibility.Visible;
}));
Thread.Sleep(new Random().Next(2500, 7500));
Dispatcher.Invoke(new Action(() => {
aiLoader.Visibility = Visibility.Collapsed;
btnStart.IsEnabled = btnClose.IsEnabled = true;
if (BackupService.MakeBackup(_pathAndFileName))
{
MessageWindowHelpers.Show(this,
string.Format(BackupResources.BackupCreationSuceeded, _pathAndFileName));
}
else
{
MessageWindowHelpers.Show(this, BackupResources.BackupCreationFailed, MessageBoxButton.OK,
MessageBoxImage.Hand);
}
}));
}
public async Task Login_loginFailed_SettingsNotUpdated()
{
// Arrange
connectivityAdapterMock.SetupGet(x => x.IsConnected).Returns(true);
cloudBackupServiceMock.Setup(x => x.LoginAsync())
.Callback(() => throw new BackupException());
settingsFacadeMock.SetupAllProperties();
var backupService = new BackupService(cloudBackupServiceMock.Object,
fileStoreMock.Object,
settingsFacadeMock.Object,
connectivityAdapterMock.Object,
contextAdapterMock.Object);
// Act
await Assert.ThrowsAsync <BackupException>(async() => await backupService.LoginAsync());
// Assert
settingsFacadeMock.Object.IsBackupAutouploadEnabled.ShouldBeFalse();
settingsFacadeMock.Object.IsLoggedInToBackupService.ShouldBeFalse();
}
public async Task UploadBackupAsync_LoggedIn_EnqueueCalled()
{
// Arrange
connectivityAdapterMock.SetupGet(x => x.IsConnected).Returns(true);
cloudBackupServiceMock.Setup(x => x.UploadAsync(It.IsAny <Stream>())).ReturnsAsync(true);
settingsFacadeMock.SetupGet(x => x.IsBackupAutouploadEnabled).Returns(true);
settingsFacadeMock.SetupGet(x => x.IsLoggedInToBackupService).Returns(true);
var backupService = new BackupService(cloudBackupServiceMock.Object,
fileStoreMock.Object,
settingsFacadeMock.Object,
connectivityAdapterMock.Object,
contextAdapterMock.Object);
// Act
await backupService.UploadBackupAsync();
// Assert
cloudBackupServiceMock.Verify(x => x.LoginAsync(), Times.Never);
cloudBackupServiceMock.Verify(x => x.UploadAsync(It.IsAny <Stream>()), Times.Once);
}
public async Task Logout_loginFailed_SettingsNotUpdated()
{
// Arrange
var backupManagerMock = new Mock <IBackupManager>();
backupManagerMock.Setup(x => x.LogoutAsync())
.Callback(() => throw new BackupException());
var settingsFacade = new Mock <ISettingsFacade>();
settingsFacade.SetupAllProperties();
settingsFacade.Object.IsBackupAutouploadEnabled = true;
settingsFacade.Object.IsLoggedInToBackupService = true;
var backupService = new BackupService(backupManagerMock.Object, settingsFacade.Object);
// Act
await Assert.ThrowsAsync <BackupException>(async() => await backupService.LogoutAsync());
// Assert
settingsFacade.Object.IsBackupAutouploadEnabled.ShouldBeTrue();
settingsFacade.Object.IsLoggedInToBackupService.ShouldBeTrue();
}
public async Task RestoreBackup_Success_LastBackupTimestampNotUpdated()
{
// Arrange
DateTime expectedPassedDate = DateTime.Now.AddDays(-3);
var backupManagerMock = new Mock <IBackupManager>();
backupManagerMock.Setup(x => x.RestoreBackupAsync())
.Returns(Task.CompletedTask);
var settingsFacade = new Mock <ISettingsFacade>();
settingsFacade.SetupAllProperties();
settingsFacade.Object.LastDatabaseUpdate = expectedPassedDate;
var backupService = new BackupService(backupManagerMock.Object, settingsFacade.Object);
// Act
await backupService.RestoreBackupAsync();
// Assert
settingsFacade.Object.LastDatabaseUpdate.ShouldBeInRange(DateTime.Now.AddMinutes(-2), DateTime.Now);
}
public async Task RestoreBackup_Failed_LastBackupTimestampNotUpdated()
{
// Arrange
DateTime expectedPassedDate = DateTime.Now.AddDays(-3);
var backupManagerMock = new Mock <IBackupManager>();
backupManagerMock.Setup(x => x.RestoreBackupAsync())
.Callback(() => throw new BackupException());
var settingsFacade = new Mock <ISettingsFacade>();
settingsFacade.SetupAllProperties();
settingsFacade.Object.LastDatabaseUpdate = expectedPassedDate;
var backupService = new BackupService(backupManagerMock.Object, settingsFacade.Object);
// Act
await Assert.ThrowsAsync <BackupException>(async() => await backupService.RestoreBackupAsync());
// Assert
settingsFacade.Object.LastDatabaseUpdate.ShouldEqual(expectedPassedDate);
}
private void UnlinkBackup()
{
var gbPath = BackupService.GetGameBackupPath(Game, false, false, forceReturnPath: true);
Log.Information($@"User is attempting to unlink backup for {Game}");
var message = M3L.GetString(M3L.string_dialog_unlinkingBackup, Utilities.GetGameName(Game), gbPath, Utilities.GetGameName(Game));
var shouldUnlink = M3L.ShowDialog(window, message, M3L.GetString(M3L.string_unlinkingBackup), MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes;
if (shouldUnlink)
{
// Unlink
Log.Information($@"Unlinking backup for {Game}");
if (gbPath != null)
{
var cmmVanilla = Path.Combine(gbPath, @"cmm_vanilla");
if (File.Exists(cmmVanilla))
{
Log.Information(@"Deleted cmm_vanilla file: " + cmmVanilla);
File.Delete(cmmVanilla);
}
}
switch (Game)
{
case MEGame.ME1:
case MEGame.ME2:
RegistryHandler.DeleteRegistryKey(Registry.CurrentUser, @"Software\ALOTAddon",
Game + @"VanillaBackupLocation");
break;
case MEGame.ME3:
RegistryHandler.DeleteRegistryKey(Registry.CurrentUser, @"Software\Mass Effect 3 Mod Manager",
@"VanillaCopyLocation");
break;
}
BackupService.RefreshBackupStatus(window, Game);
}
}
public async Task RestoreBackup_Success_LastBackupTimestampNotUpdated()
{
// Arrange
connectivityAdapterMock.SetupGet(x => x.IsConnected).Returns(true);
DateTime expectedPassedDate = DateTime.Now.AddDays(-3);
settingsFacadeMock.SetupAllProperties();
settingsFacadeMock.Object.LastDatabaseUpdate = expectedPassedDate;
settingsFacadeMock.SetupGet(x => x.IsBackupAutouploadEnabled).Returns(true);
settingsFacadeMock.SetupGet(x => x.IsLoggedInToBackupService).Returns(true);
cloudBackupServiceMock.Setup(x => x.RestoreAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(new Mock <Stream>().Object);
cloudBackupServiceMock.Setup(x => x.GetFileNamesAsync())
.ReturnsAsync(new List <string> {
"asd"
});
var backupService = new BackupService(cloudBackupServiceMock.Object,
fileStoreMock.Object,
settingsFacadeMock.Object,
connectivityAdapterMock.Object,
contextAdapterMock.Object,
messengerMock.Object,
toastService);
// Act
await backupService.RestoreBackupAsync();
// Assert
settingsFacadeMock.Object.LastDatabaseUpdate
.Should()
.BeBefore(DateTime.Now.AddSeconds(-1));
}
public ComponentHistoryService(
ComponentRegistryService componentRegistryService,
HistoryService historyService,
StorageService storageService,
SystemStatusService systemStatusService,
SystemCancellationToken systemCancellationToken,
BackupService backupService,
ILogger <ComponentHistoryService> logger)
{
_componentRegistryService = componentRegistryService ?? throw new ArgumentNullException(nameof(componentRegistryService));
_historyService = historyService ?? throw new ArgumentNullException(nameof(historyService));
_storageService = storageService ?? throw new ArgumentNullException(nameof(storageService));
_systemCancellationToken = systemCancellationToken ?? throw new ArgumentNullException(nameof(systemCancellationToken));
_backupService = backupService ?? throw new ArgumentNullException(nameof(backupService));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
if (systemStatusService == null)
{
throw new ArgumentNullException(nameof(systemStatusService));
}
systemStatusService.Set("component_history.pending_status_work_items", _pendingStatusWorkItems.Count);
_componentRegistryService.ComponentStatusChanged += OnComponentStatusChanged;
}
public async Task EnqueueBackupTask_NotLoggedIn_RepeatedLogin()
{
// Arrange
var backupManagerMock = new Mock <IBackupManager>();
backupManagerMock.Setup(x => x.EnqueueBackupTaskAsync(It.IsAny <int>()))
.Returns(Task.CompletedTask);
backupManagerMock.Setup(x => x.LoginAsync())
.Callback(() => throw new BackupException());
var settingsFacade = new Mock <ISettingsFacade>();
settingsFacade.SetupGet(x => x.IsBackupAutouploadEnabled).Returns(true);
settingsFacade.SetupGet(x => x.IsLoggedInToBackupService).Returns(false);
var backupService = new BackupService(backupManagerMock.Object, settingsFacade.Object);
// Act
await Assert.ThrowsAsync <BackupException>(async() => await backupService.EnqueueBackupTaskAsync());
// Assert
backupManagerMock.Verify(x => x.LoginAsync(), Times.Once);
backupManagerMock.Verify(x => x.EnqueueBackupTaskAsync(It.IsAny <int>()), Times.Never);
}
public TestController()
{
Log.Instance = new TestLogger();
// Create root services first.
var systemInformationService = new SystemInformationService();
var apiService = new ApiService();
ApiService = new ApiService();
BackupService = new BackupService();
StorageService = new StorageService();
TimerService = new TestTimerService();
DaylightService = new TestDaylightService();
DateTimeService = new TestDateTimeService();
SettingsService = new SettingsService(BackupService, StorageService);
ResourceService = new ResourceService(BackupService, StorageService, SettingsService);
SchedulerService = new SchedulerService(TimerService, DateTimeService);
NotificationService = new NotificationService(DateTimeService, ApiService, SchedulerService, SettingsService, StorageService, ResourceService);
SystemEventsService = new SystemEventsService(this, NotificationService, ResourceService);
AutomationService = new AutomationService(SystemEventsService, systemInformationService, apiService);
ComponentService = new ComponentService(SystemEventsService, systemInformationService, apiService, SettingsService);
AreaService = new AreaService(ComponentService, AutomationService, SystemEventsService, systemInformationService, apiService, SettingsService);
}
/// <summary>
/// Initializes a new instance of the <see cref="TodoistClient" /> class.
/// </summary>
/// <param name="token">The token.</param>
/// <param name="restClient">The rest client.</param>
/// <exception cref="System.ArgumentException">Value cannot be null or empty - token</exception>
internal TodoistClient(string token, ITodoistRestClient restClient)
{
if (string.IsNullOrEmpty(token))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(token));
}
_token = token;
_restClient = restClient;
Projects = new ProjectsService(this);
Templates = new TemplateService(this);
Items = new ItemsService(this);
Labels = new LabelsService(this);
Notes = new NotesService(this);
Uploads = new UploadService(this);
Filters = new FiltersService(this);
Activity = new ActivityService(this);
Notifications = new NotificationsService(this);
Backups = new BackupService(this);
Reminders = new ReminersService(this);
Users = new UsersService(this);
Sharing = new SharingService(this);
}
public async Task Execute(string storageKey, string storageSecret, string endpointSuffix = null)
{
Console.WriteLine("");
Console.WriteLine(this.GetType().FullName);
// Export Table
using (var storageContext = new StorageContext(storageKey, storageSecret, endpointSuffix))
{
using (var textWriter = new StreamWriter("/tmp/test.json"))
{
await storageContext.ExportToJsonAsync("ExportDemo", textWriter);
}
}
// Export to Blob
using (var storageContext = new StorageContext(storageKey, storageSecret, endpointSuffix))
{
var backupStorage = new CloudStorageAccount(new StorageCredentials(storageKey, storageSecret), endpointSuffix, true);
var backupService = new BackupService(storageContext, backupStorage, new DemoStorageLogger());
await backupService.Backup("DemoBck", "bck01");
}
}
public async Task RestoreBackup_Failed_LastBackupTimestampNotUpdated()
{
// Arrange
DateTime expectedPassedDate = DateTime.Now.AddDays(-3);
var backupManagerMock = new Mock <IBackupManager>();
backupManagerMock.Setup(x => x.RestoreBackup())
.ReturnsAsync(OperationResult.Failed(""));
var settingsFacade = new Mock <ISettingsFacade>();
settingsFacade.SetupAllProperties();
settingsFacade.Object.LastDatabaseUpdate = expectedPassedDate;
var backupService = new BackupService(backupManagerMock.Object, settingsFacade.Object);
// Act
OperationResult result = await backupService.RestoreBackup();
// Assert
result.Success.ShouldBeFalse();
settingsFacade.Object.LastDatabaseUpdate.ShouldEqual(expectedPassedDate);
}
private bool CanRestoreSFAR()
{
if (Restoring)
{
return(false);
}
if (OtherSFARBeingRestored)
{
return(false);
}
if (checkedForBackupFile)
{
return(canRestoreSfar);
}
var backupPath = BackupService.GetGameBackupPath(target.Game);
canRestoreSfar = backupPath != null && File.Exists(Path.Combine(backupPath, FilePath));
checkedForBackupFile = true;
if (!canRestoreSfar)
{
RestoreButtonContent = M3L.GetString(M3L.string_noBackup);
}
return(canRestoreSfar);
}
public static Task BackupAsync(this BackupService bs, DiscordMessage msg)
{
ulong gid = msg.Channel.GuildId;
ulong cid = msg.ChannelId;
if (bs.IsChannelExempted(gid, cid))
{
return(Task.CompletedTask);
}
var sb = new StringBuilder();
sb.Append('[').Append(msg.CreationTimestamp).Append("] ").Append(msg.Author.ToDiscriminatorString()).AppendLine(":");
if (!string.IsNullOrWhiteSpace(msg.Content))
{
sb.AppendLine(msg.Content);
}
foreach (DiscordEmbed e in msg.Embeds)
{
sb.Append("----- ").Append(e.Title).AppendLine(" -----");
sb.AppendLine(e.Description);
if (e.Fields is { })
private void MainWindow_Load(object sender, EventArgs e)
{
if (Thread.CurrentThread.Name == null)
{
Thread.CurrentThread.Name = "UI";
}
ExceptionReporter.EnableLogUnhandledOnThread();
SizeChanged += OnMinimizeWindow;
_stashManager = new StashManager(_playerItemDao, _databaseItemStatDao, SetFeedback, ListviewUpdateTrigger);
_stashFileMonitor.OnStashModified += (_, __) => {
StashEventArg args = __ as StashEventArg;
if (_stashManager != null && _stashManager.TryLootStashFile(args?.Filename))
{
// STOP TIMER
_stashFileMonitor.CancelQueuedNotify();
} // TODO: This logic should be changed to 're queue' but only trigger once, if its slow it triggers multiple times.
};
if (!_stashFileMonitor.StartMonitorStashfile(GlobalPaths.SavePath))
{
MessageBox.Show("Ooops!\nIt seems you are synchronizing your saves to steam cloud..\nThis tool is unfortunately not compatible.\n");
Process.Start("http://www.grimdawn.com/forums/showthread.php?t=20752");
if (!Debugger.IsAttached)
{
Close();
}
}
// Chicken and the egg..
SearchController searchController = new SearchController(
_databaseItemDao,
_playerItemDao,
_databaseItemStatDao,
_itemSkillDao,
_buddyItemDao,
_stashManager,
_augmentationItemRepo
);
_cefBrowserHandler.InitializeChromium(searchController.JsBind, Browser_IsBrowserInitializedChanged);
searchController.Browser = _cefBrowserHandler;
searchController.JsBind.OnClipboard += SetItemsClipboard;
// Load the grim database
string gdPath = GrimDawnDetector.GetGrimLocation();
if (!string.IsNullOrEmpty(gdPath))
{
}
else
{
Logger.Warn("Could not find the Grim Dawn install location");
statusLabel.Text = "Could not find the Grim Dawn install location";
var timer = new System.Windows.Forms.Timer();
timer.Tick += TimerTickLookForGrimDawn;
timer.Interval = 10000;
timer.Start();
}
// Load recipes
foreach (string file in GlobalPaths.FormulasFiles)
{
if (!string.IsNullOrEmpty(file))
{
bool isHardcore = file.EndsWith("gsh");
Logger.InfoFormat("Reading recipes at \"{0}\", IsHardcore={1}", file, isHardcore);
_recipeParser.UpdateFormulas(file, isHardcore);
}
}
var addAndShow = UIHelper.AddAndShow;
// Create the tab contents
_buddySettingsWindow = new BuddySettings(delegate(bool b) { BuddySyncEnabled = b; },
_buddyItemDao,
_buddySubscriptionDao
);
addAndShow(_buddySettingsWindow, buddyPanel);
_authAuthService = new AzureAuthService(_cefBrowserHandler, new AuthenticationProvider());
var backupSettings = new BackupSettings(_playerItemDao, _authAuthService);
addAndShow(backupSettings, backupPanel);
addAndShow(new ModsDatabaseConfig(DatabaseLoadedTrigger, _playerItemDao, _parsingService), modsPanel);
addAndShow(new HelpTab(), panelHelp);
addAndShow(new LoggingWindow(), panelLogging);
var backupService = new BackupService(_authAuthService, _playerItemDao, _azurePartitionDao, () => Settings.Default.UsingDualComputer);
_backupServiceWorker = new BackupServiceWorker(backupService);
backupService.OnUploadComplete += (o, args) => _searchWindow.UpdateListView();
searchController.OnSearch += (o, args) => backupService.OnSearch();
_searchWindow = new SplitSearchWindow(_cefBrowserHandler.BrowserControl, SetFeedback, _playerItemDao, searchController, _itemTagDao);
addAndShow(_searchWindow, searchPanel);
_stashManager.StashUpdated += (_, __) => {
_searchWindow.UpdateListView();
};
addAndShow(
new SettingsWindow(
_cefBrowserHandler,
_itemTagDao,
_tooltipHelper,
ListviewUpdateTrigger,
_databaseSettingDao,
_playerItemDao,
_arzParser,
_searchWindow.ModSelectionHandler.GetAvailableModSelection(),
_stashManager,
_parsingService
),
settingsPanel);
new StashTabPicker(_stashManager.NumStashTabs).SaveStashSettingsToRegistry();
#if !DEBUG
ThreadPool.QueueUserWorkItem(m => ExceptionReporter.ReportUsage());
CheckForUpdates();
#endif
int min = 1000 * 60;
int hour = 60 * min;
_timerReportUsage = new Timer();
_timerReportUsage.Start();
_timerReportUsage.Elapsed += (a1, a2) => {
if (Thread.CurrentThread.Name == null)
{
Thread.CurrentThread.Name = "ReportUsageThread";
}
ReportUsage();
};
_timerReportUsage.Interval = 12 * hour;
_timerReportUsage.AutoReset = true;
_timerReportUsage.Start();
Shown += (_, __) => { StartInjector(); };
//settingsController.Data.budd
BuddySyncEnabled = (bool)Settings.Default.BuddySyncEnabled;
// Start the backup task
_backupBackgroundTask = new BackgroundTask(new FileBackup(_playerItemDao));
LocalizationLoader.ApplyLanguage(Controls, GlobalSettings.Language);
EasterEgg.Activate(this);
// Initialize the "stash packer" used to find item positions for transferring items ingame while the stash is open
{
_dynamicPacker.Initialize(8, 16);
var transferFiles = GlobalPaths.TransferFiles;
if (transferFiles.Count > 0)
{
var file = transferFiles.MaxBy(m => m.LastAccess);
var stash = StashManager.GetStash(file.Filename);
if (stash != null)
{
_dynamicPacker.Initialize(stash.Width, stash.Height);
if (stash.Tabs.Count >= 3)
{
foreach (var item in stash.Tabs[2].Items)
{
byte[] bx = BitConverter.GetBytes(item.XOffset);
uint x = (uint)BitConverter.ToSingle(bx, 0);
byte[] by = BitConverter.GetBytes(item.YOffset);
uint y = (uint)BitConverter.ToSingle(by, 0);
_dynamicPacker.Insert(item.BaseRecord, item.Seed, x, y);
}
}
}
}
}
_messageProcessors.Add(new ItemPositionFinder(_dynamicPacker));
_messageProcessors.Add(new PlayerPositionTracker());
_messageProcessors.Add(new StashStatusHandler());
_messageProcessors.Add(new ItemReceivedProcessor(_searchWindow, _stashFileMonitor, _playerItemDao));
_messageProcessors.Add(new ItemInjectCallbackProcessor(_searchWindow.UpdateListViewDelayed, _playerItemDao));
_messageProcessors.Add(new ItemSpawnedProcessor());
_messageProcessors.Add(new CloudDetectorProcessor(SetFeedback));
_messageProcessors.Add(new GenericErrorHandler());
//messageProcessors.Add(new LogMessageProcessor());
#if DEBUG
//messageProcessors.Add(new DebugMessageProcessor());
#endif
GlobalSettings.StashStatusChanged += GlobalSettings_StashStatusChanged;
_transferController = new ItemTransferController(
_cefBrowserHandler,
SetFeedback,
SetTooltipAtmouse,
_settingsController,
_searchWindow,
_dynamicPacker,
_playerItemDao,
_stashManager,
new ItemStatService(_databaseItemStatDao, _itemSkillDao)
);
Application.AddMessageFilter(new MousewheelMessageFilter());
var titleTag = GlobalSettings.Language.GetTag("iatag_ui_itemassistant");
if (!string.IsNullOrEmpty(titleTag))
{
this.Text += $" - {titleTag}";
}
// Popup login diag
if (_authAuthService.CheckAuthentication() == AzureAuthService.AccessStatus.Unauthorized)
{
var t = new System.Windows.Forms.Timer {
Interval = 100
};
t.Tick += (o, args) => {
if (_cefBrowserHandler.BrowserControl.IsBrowserInitialized)
{
_authAuthService.Authenticate();
t.Stop();
}
};
t.Start();
}
_cefBrowserHandler.TransferSingleRequested += TransferSingleItem;
_cefBrowserHandler.TransferAllRequested += TransferAllItems;
new WindowSizeManager(this);
}
private IBackupService GetMockBackupServiceForRestore(IBackupRepository backupRepository,
BackupOptions options)
{
Mock <IAppServiceProvider> mockAppProvider = new Mock <IAppServiceProvider>();
mockAppProvider
.Setup(a => a.GetAppsByIds(It.IsAny <IEnumerable <string> >()))
.Returns(Task.FromResult <IEnumerable <App> >(null));
Mock <IStandardServiceProvider> mockStandardProvider = new Mock <IStandardServiceProvider>();
mockStandardProvider
.Setup(a => a.GetStandardComponentsByIds(It.IsAny <IEnumerable <string> >()))
.Returns(Task.FromResult <IEnumerable <StandardComponent> >(null));
Mock <IChartServiceProvider> mockChartProvider = new Mock <IChartServiceProvider>();
mockChartProvider
.Setup(a => a.GetChartsByIds(It.IsAny <IEnumerable <string> >()))
.Returns(Task.FromResult <IEnumerable <Chart> >(null));
Mock <IDynamicListServiceProvider> mockDynamicListProvider = new Mock <IDynamicListServiceProvider>();
mockDynamicListProvider
.Setup(a => a.GetDynamicListsByIds(It.IsAny <IEnumerable <string> >()))
.Returns(Task.FromResult <IEnumerable <DynamicList> >(null));
Mock <IPageServiceProvider> mockPageProvider = new Mock <IPageServiceProvider>();
mockPageProvider
.Setup(a => a.GetPagesByIds(It.IsAny <IEnumerable <string> >()))
.Returns(Task.FromResult <IEnumerable <Page> >(null));
#pragma warning disable CA2000 // Dispose objects before losing scope
InternalDatabaseServiceProvider databaserProvider = new InternalDatabaseServiceProvider(
new DatabaseService(null, null),
new DatabaseMongoRepository(_context.GetMongoConnection()));
#pragma warning restore CA2000 // Dispose objects before losing scope
Mock <IFileSeviceProvider> mockFileProvider = new Mock <IFileSeviceProvider>();
mockFileProvider
.Setup(a => a.UploadFileAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>()))
.Returns(Task.FromResult(new ResponseUploadFile {
DownloadableUrl = "http://localhost", FileId = DataUtil.GenerateUniqueId()
}));
mockFileProvider
.Setup(a => a.ValidateFile(It.IsAny <IFormFile>()))
.Returns(Task.FromResult(true));
mockFileProvider
.Setup(a => a.DownloadFileAsync(It.IsAny <string>()))
.Returns(Task.FromResult(new ResponseDownloadFile
{
FileBytes = File.ReadAllBytes(@"Artifacts\" + zipFileName),
FileName = zipFileName,
MIMEType = "application/zip"
}));
IOptionsMonitor <BackupOptions> backupOptionsMock = Mock.Of <IOptionsMonitor <BackupOptions> >(_ => _.CurrentValue == options);
Mock <ICompositeControlServiceProvider> mockCompositeControlProvider = new Mock <ICompositeControlServiceProvider>();
mockCompositeControlProvider
.Setup(a => a.GetByIds(It.IsAny <IEnumerable <string> >()))
.Returns(Task.FromResult <IEnumerable <CompositeControl> >(null));
BackupService backupService = new BackupService(
mockAppProvider.Object,
mockStandardProvider.Object,
mockChartProvider.Object,
mockDynamicListProvider.Object,
databaserProvider,
mockPageProvider.Object,
mockFileProvider.Object,
backupRepository,
mockCompositeControlProvider.Object,
backupOptionsMock,
new FakeServiceLogger <BackupService>());
databaserProvider.Dispose();
return(backupService);
}
