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); }