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