private static void Refresh(object sender, ExecutedRoutedEventArgs e) { if (UIContext.Database != null) { BackgroundWorker worker = new BackgroundWorker(); MainWindow mainWindow = (MainWindow)sender; mainWindow.loadingAnimation.Visibility = Visibility.Visible; worker.DoWork += delegate(object s, DoWorkEventArgs args) { IRefreshService refreshService = ObjectLocator.GetInstance <IRefreshService>(); UIContext.Database = refreshService.RefreshDatabaseProject(UIContext.Database); mainWindow.RefreshData(); }; worker.RunWorkerCompleted += delegate(object s, RunWorkerCompletedEventArgs args) { mainWindow.loadingAnimation.Visibility = Visibility.Collapsed; }; worker.RunWorkerAsync(); } else { MessageBox.Show("There is no open database project, cannot generate report.", "Error Saving", MessageBoxButton.OK, MessageBoxImage.Exclamation); } }
public RuntimeSessionViewModel() { m_host = RuntimeManager.GetInstance(); IRefreshService refresh = (IRefreshService)m_host.GetService(typeof(IRefreshService)); refresh.AutoRefresh += this.AutoRefresh; }
private async Task HandleRefreshTasks(IRefreshService taskService, VisionDbContext context) { foreach (RefreshTask task in await context.Tasks.OrderByDescending(t => t.Created).Where(t => t.Completed == null).ToListAsync()) { task.Started = DateTime.Now; context.Tasks.Update(task); await context.SaveChangesAsync(); try { logger.LogInformation($"Starting refresh task {task.Scope.ToString()}:{task.Id}"); Task refreshTask = task.Scope switch { TaskScopeKind.Asset => taskService.RefreshAssetByIdAsync(task.TargetId), TaskScopeKind.Dependency => taskService.RefreshDependencyByIdAsync(task.TargetId), TaskScopeKind.Repository => taskService.RefreshRepositoryByIdAsync(task.TargetId), TaskScopeKind.VersionControl => taskService.RefreshVersionControlByIdAsync(task.TargetId), _ => Task.Delay(0) }; await refreshTask; task.Completed = DateTime.Now; context.Tasks.Update(task); await context.SaveChangesAsync(); } catch (Exception e) { logger.LogError(e, $"Error performing refresh task {task.Scope.ToString()}:{task.Id}."); } } }
public ShellViewModel() { // TODO: set config directly m_migrationServiceManager = MigrationServiceManager.GetInstance(); // Set up runtime view model hosting environment m_runtimeManager = RuntimeManager.GetInstance(); IRefreshService refresh = (IRefreshService)m_runtimeManager.GetService(typeof(IRefreshService)); refresh.AutoRefresh += this.AutoRefresh; // Avoid race by driving through top level refresh instead of relying upon background thread. Refresh(); ConfigurationModel.Initialize(); m_headlineViewModel = new HeadlineControlViewModel(Properties.Resources.ShellHeaderString, this); m_notificationBarVM = new NotificationBarViewModel(this); PushViewModel(new HomeViewModel(this)); m_backgroundWorker.DoWork += new DoWorkEventHandler(backgroundWorker_DoWork); m_backgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(m_backgroundWorker_RunWorkerCompleted); this.Controller.Created += this.OnCreated; this.Controller.Opened += this.OnOpened; this.Controller.Saved += this.OnSaved; }
private async Task DoWorkAsync(CancellationToken cancellationToken) { logger.LogInformation("Hosted Service started."); using (IServiceScope scope = services.CreateScope()) { IRefreshService taskService = scope.ServiceProvider.GetRequiredService <IRefreshService>(); VisionDbContext context = scope.ServiceProvider.GetRequiredService <VisionDbContext>(); while (!cancellationToken.IsCancellationRequested) { using (var transaction = await context.Database.BeginTransactionAsync()) { try { await HandleRefreshTasks(taskService, context); await HandleRepositoryCleaning(context); transaction.Commit(); } catch (Exception e) { logger.LogCritical(e, "Transaction roll back"); transaction.Rollback(); } } await Task.Delay(TimeSpan.FromSeconds(10)); } scope.Dispose(); } }
public RefreshApprenticeshipsTests() { timer = new TimerInfo(new ScheduleStub(), new ScheduleStatus()); fakeLogger = A.Fake <ILogger>(); fakeRefreshService = A.Fake <IRefreshService>(); Environment.SetEnvironmentVariable(nameof(AbortAfterErrorCount), $"{AbortAfterErrorCount}"); }
public OnRefreshFunding( ILogger logger, IRefreshService refreshService, IMessengerService messengerService, IUserProfileProvider userProfileProvider, bool useAzureStorage = false) : base(logger, messengerService, FunctionName, QueueName, useAzureStorage, userProfileProvider, refreshService) { }
public SessionGroupViewModel(Guid sessionGroupUniqueId) { m_host = RuntimeManager.GetInstance(); IRefreshService refresh = (IRefreshService)m_host.GetService(typeof(IRefreshService)); refresh.AutoRefresh += this.AutoRefresh; SessionGroupUniqueId = sessionGroupUniqueId; }
private void Attach() { if (m_refreshService == null) { RuntimeManager runtimeManager = RuntimeManager.GetInstance(); m_refreshService = (IRefreshService)runtimeManager.GetService(typeof(IRefreshService)); } m_refreshService.AutoRefresh += this.AutoRefresh; }
public StudentListViewModel(IStudentRepository StudentRepository, IClassRepository classRepository, IRefreshService refreshService, ILogger <StudentListViewModel> logger) { this.StudentRepository = StudentRepository; this.classRepository = classRepository; this.refreshService = refreshService; this.logger = logger; }
public SessionGroupRunViewModel(RTSessionGroupRun sessionGroupRun) { m_sessionGroupRun = sessionGroupRun; m_host = RuntimeManager.GetInstance(); IRefreshService refresh = (IRefreshService)m_host.GetService(typeof(IRefreshService)); refresh.AutoRefresh += this.AutoRefresh; // Avoid race by driving through top level refresh instead of relying upon background thread. Refresh(); }
public static void SetupTests(TestContext tc) { SetupTests("calcengine"); _logger = CreateLogger(); _approveService = CreateApproveService(); _publishService = CreatePublishService(); _refreshService = CreateRefreshService(); _publishedProviderReIndexerService = CreatePublishedProviderReIndexerService(); _deletePublishedProvidersService = CreateDeletePublishedProvidersService(); _userProfileProvider = CreateUserProfileProvider(); _sqlImportService = Substitute.For <ISqlImportService>(); }
public AdminViewModel(IStudentRepository StudentRepository, IClassRepository TeacherRepository, ICourseRepository CourseRepository, IRefreshService refreshService) { this.StudentRepository = StudentRepository; this.TeacherRepository = TeacherRepository; this.CourseRepository = CourseRepository; this.refreshService = refreshService; Student = new Student(); Teacher = new Teacher(); Course = new Course(); }
static async Task Main(string[] args) { string authenticationBaseUrl = "http://*****:*****@gmail.com", Username = "******", Password = "******", ConfirmPassword = "******" }); } catch (ApiException ex) { ErrorResponse errorResponse = await ex.GetContentAsAsync <ErrorResponse>(); Console.WriteLine(errorResponse.ErrorMessages.FirstOrDefault()); } AuthenticatedUserResponse loginResponse = await loginService.Login(new LoginRequest() { Username = "******", Password = "******", }); tokenStore.AccessToken = loginResponse.AccessToken; tokenStore.AccessTokenExpirationTime = loginResponse.AccessTokenExpirationTime; tokenStore.RefreshToken = loginResponse.RefreshToken; DataResponse dataResponse = await dataService.GetData(); Console.ReadKey(); }
public OneWaySessionHistoryViewModel(OneWaySessionViewModel oneWaySession) { m_context = RuntimeEntityModel.CreateInstance(); m_dispatcher = Dispatcher.CurrentDispatcher; m_oneWaySession = oneWaySession; m_worker = new BackgroundWorker(); m_worker.WorkerReportsProgress = true; m_worker.DoWork += new DoWorkEventHandler(m_worker_DoWork); m_worker.ProgressChanged += new ProgressChangedEventHandler(m_worker_ProgressChanged); m_worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(m_worker_RunWorkerCompleted); RuntimeManager runtimeManager = RuntimeManager.GetInstance(); IRefreshService refresh = (IRefreshService)runtimeManager.GetService(typeof(IRefreshService)); refresh.AutoRefresh += this.AutoRefresh; }
public DualChangeGroupViewModel(RTChangeGroup deltaTables, RTChangeGroup migrationInstructions, int count) { Name = deltaTables.Name; DeltaTables = deltaTables; MigrationInstructions = migrationInstructions; ChangeActionCount = count; IsMilestone = false; m_context = RuntimeEntityModel.CreateInstance(); RuntimeManager host = RuntimeManager.GetInstance(); IRefreshService refresh = (IRefreshService)host.GetService(typeof(IRefreshService)); refresh.AutoRefresh += this.AutoRefresh; Refresh(); m_deltaTablesStatus = (ChangeStatus)DeltaTables.Status; m_migrationInstructionsStatus = (ChangeStatus)MigrationInstructions.Status; }
public RefreshStepDefinition(IPublishFundingStepContext publishFundingStepContext, CurrentSpecificationStepContext currentSpecificationStepContext, CurrentJobStepContext currentJobStepContext, CurrentUserStepContext currentUserStepContext, IVariationServiceStepContext variationServiceStepContext, IRefreshService refreshService, IVersionRepository <PublishedProviderVersion> publishedProviderVersionRepository, ICurrentCorrelationStepContext currentCorrelationStepContext, ISpecificationService specificationService) { _publishFundingStepContext = publishFundingStepContext; _currentSpecificationStepContext = currentSpecificationStepContext; _currentJobStepContext = currentJobStepContext; _currentUserStepContext = currentUserStepContext; _variationServiceStepContext = variationServiceStepContext; _refreshService = refreshService; _currentCorrelationStepContext = currentCorrelationStepContext; _providerVersionInMemoryRepository = (PublishedProviderVersionInMemoryRepository)publishedProviderVersionRepository; _specificationInMemoryRepository = (SpecificationInMemoryRepository)specificationService; }
public AutoRefreshHttpMessageHandler(TokenStore tokenStore, IRefreshService refreshService) : base(new HttpClientHandler()) { _tokenStore = tokenStore; _refreshService = refreshService; }
public virtual void Detach() { IRefreshService refresh = (IRefreshService)m_host.GetService(typeof(IRefreshService)); refresh.AutoRefresh -= this.AutoRefresh; }
public RefreshController(IRefreshService refreshService, FeedsDbEntities context) : base(context) { _feedService = refreshService; }
public static async System.Threading.Tasks.Task RunAsync( [TimerTrigger("%RefreshApprenticeshipsCron%")] TimerInfo myTimer, ILogger log, [Inject] IRefreshService refreshService) { log.LogInformation($"{nameof(RefreshApprenticeships)}: Timer trigger function starting at: {DateTime.Now}, using TimerInfo: {myTimer.Schedule.ToString()}"); int abortAfterErrorCount = 10; int errorCount = 0; int totalErrorCount = 0; int totalSuccessCount = 0; int aVRequestsPerMinute = 240; int aVRequestsPerMinuteSettingOveride = 0; _ = int.TryParse(Environment.GetEnvironmentVariable(nameof(abortAfterErrorCount)), out abortAfterErrorCount); _ = int.TryParse(Environment.GetEnvironmentVariable(nameof(aVRequestsPerMinuteSettingOveride)), out aVRequestsPerMinuteSettingOveride); //override with a setting variable if required aVRequestsPerMinute = aVRequestsPerMinuteSettingOveride > 0 ? aVRequestsPerMinuteSettingOveride : aVRequestsPerMinute; var sleepTimeMilliSecsBetweenRequests = 60000 / (aVRequestsPerMinute / 3); //on average we make 3 calls per profile to get 2 vacancies, so divide by 3 HttpStatusCode statusCode = HttpStatusCode.OK; var simpleJobProfileModels = await refreshService.GetListAsync().ConfigureAwait(false); if (simpleJobProfileModels != null) { log.LogInformation($"{nameof(RefreshApprenticeships)}: Retrieved {simpleJobProfileModels.Count} Job Profiles"); foreach (var simpleJobProfileModel in simpleJobProfileModels) { log.LogInformation($"{nameof(RefreshApprenticeships)}: Refreshing Job Profile Apprenticeships: {simpleJobProfileModel.DocumentId} / {simpleJobProfileModel.CanonicalName}"); await Task.Delay(sleepTimeMilliSecsBetweenRequests).ConfigureAwait(false); statusCode = await refreshService.RefreshApprenticeshipsAsync(simpleJobProfileModel.DocumentId).ConfigureAwait(false); switch (statusCode) { case HttpStatusCode.OK: errorCount = 0; totalSuccessCount++; log.LogInformation($"{nameof(RefreshApprenticeships)}: Refreshed Job Profile Apprenticeships: {simpleJobProfileModel.DocumentId} / {simpleJobProfileModel.CanonicalName}"); break; default: errorCount++; totalErrorCount++; log.LogError($"{nameof(RefreshApprenticeships)}: Error refreshing Job Profile Apprenticeships: {simpleJobProfileModel.DocumentId} / {simpleJobProfileModel.CanonicalName} - Status code = {statusCode}"); break; } if (errorCount >= abortAfterErrorCount) { log.LogWarning($"{nameof(RefreshApprenticeships)}: Timer trigger aborting after {abortAfterErrorCount} consecutive errors"); break; } } } log.LogInformation($"{nameof(RefreshApprenticeships)}: Timer trigger function, Apprenticeships refreshed: {totalSuccessCount}"); log.LogInformation($"{nameof(RefreshApprenticeships)}: Timer trigger function, Apprenticeships refresh errors: {totalErrorCount}"); log.LogInformation($"{nameof(RefreshApprenticeships)}: Timer trigger function completed at: {DateTime.Now}"); // if we aborted due to the number of errors exceeding the abortAfterErrorCount if (errorCount >= abortAfterErrorCount) { throw new HttpResponseException(new HttpResponseMessage() { StatusCode = statusCode, ReasonPhrase = $"Timer trigger aborting after {abortAfterErrorCount} consecutive errors" }); } }
public static async System.Threading.Tasks.Task RunAsync( [TimerTrigger("%RefreshCoursesCron%")] TimerInfo myTimer, ILogger log, [Inject] IRefreshService refreshService) { log.LogInformation($"{nameof(RefreshCourses)}: Timer trigger function starting at: {DateTime.Now}, using TimerInfo: {myTimer.Schedule.ToString()}"); var abortAfterErrorCount = 10; var errorCount = 0; var totalErrorCount = 0; var totalSuccessCount = 0; _ = int.TryParse(Environment.GetEnvironmentVariable(nameof(abortAfterErrorCount)), out abortAfterErrorCount); HttpStatusCode statusCode = HttpStatusCode.OK; var simpleJobProfileModels = await refreshService.GetListAsync().ConfigureAwait(false); if (simpleJobProfileModels != null) { log.LogInformation($"{nameof(RefreshCourses)}: Retrieved {simpleJobProfileModels.Count} Job Profiles"); foreach (var simpleJobProfileModel in simpleJobProfileModels) { log.LogInformation($"{nameof(RefreshCourses)}: Refreshing Job Profile Courses: {simpleJobProfileModel.DocumentId} / {simpleJobProfileModel.CanonicalName}"); statusCode = await refreshService.RefreshCoursesAsync(simpleJobProfileModel.DocumentId).ConfigureAwait(false); switch (statusCode) { case HttpStatusCode.OK: errorCount = 0; totalSuccessCount++; log.LogInformation($"{nameof(RefreshCourses)}: Refreshed Job Profile Courses: {simpleJobProfileModel.DocumentId} / {simpleJobProfileModel.CanonicalName}"); break; default: errorCount++; totalErrorCount++; log.LogError($"{nameof(RefreshCourses)}: Error refreshing Job Profile Courses: {simpleJobProfileModel.DocumentId} / {simpleJobProfileModel.CanonicalName} - Status code = {statusCode}"); break; } if (errorCount >= abortAfterErrorCount) { log.LogWarning($"{nameof(RefreshCourses)}: Timer trigger aborting after {abortAfterErrorCount} consecutive errors"); break; } } } log.LogInformation($"{nameof(RefreshCourses)}: Timer trigger function, Courses refreshed: {totalSuccessCount}"); log.LogInformation($"{nameof(RefreshCourses)}: Timer trigger function, Courses refresh errors: {totalErrorCount}"); log.LogInformation($"{nameof(RefreshCourses)}: Timer trigger function completed at: {DateTime.Now}"); // if we aborted due to the number of errors exceeding the abortAfterErrorCount if (errorCount >= abortAfterErrorCount) { throw new HttpResponseException(new HttpResponseMessage() { StatusCode = statusCode, ReasonPhrase = $"Timer trigger aborting after {abortAfterErrorCount} consecutive errors" }); } }