public override async System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true) { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true)); if (refreshType.HasFlag(ModelRefreshType.Basic)) { try { System.Threading.Tasks.Task asyncTask = this.Job.RefreshAsync(OptionsModel.Instance.ListDetailLevel); if (showTrackedOperation) { AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new JobOperation(JobOperation.Refresh, this.Job.Id))); } else { AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask); } await asyncTask; this.LastUpdatedTime = DateTime.UtcNow; // // Fire property change events for this models properties // this.FireChangesOnRefresh(ModelRefreshType.Basic); } catch (Exception e) { this.HandleException(e); } } if (refreshType.HasFlag(ModelRefreshType.Children)) { try { //Set this before the children load so that on revisit we know we have loaded the children (or are in the process) this.HasLoadedChildren = true; System.Threading.Tasks.Task <List <TaskModel> > asyncTask = this.ListTasksAsync(); AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new JobOperation(JobOperation.ListTasks, this.Job.Id))); this.Tasks = await asyncTask; this.TaskCollection = CollectionViewSource.GetDefaultView(this.Tasks); this.UpdateTaskView(); } catch (Exception e) { this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time this.HandleException(e); } } Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false)); Messenger.Default.Send(new JobUpdateCompleteMessage()); }
public override async Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true) { if (refreshType.HasFlag(ModelRefreshType.Basic)) { try { Task asyncTask = this.JobSchedule.RefreshAsync(); if (showTrackedOperation) { AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new JobScheduleOperation(JobScheduleOperation.Refresh, this.JobSchedule.Id))); } else { AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask); } await asyncTask; this.LastUpdatedTime = DateTime.UtcNow; // // Fire property change events for this models properties // this.FireChangesOnRefresh(ModelRefreshType.Basic); } catch (Exception e) { this.HandleException(e); } } }
public override async System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true) { if (refreshType.HasFlag(ModelRefreshType.Basic)) { try { System.Threading.Tasks.Task asyncTask = this.WorkItem.RefreshAsync(); if (showTrackedOperation) { AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new WorkItemOperation(WorkItemOperation.Refresh, this.WorkItem.Name))); } else { AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask); } await asyncTask; this.LastUpdatedTime = DateTime.UtcNow; // // Fire property change events for this models properties // this.FireChangesOnRefresh(ModelRefreshType.Basic); } catch (Exception e) { this.HandleException(e); } } if (refreshType.HasFlag(ModelRefreshType.Children)) { try { //Set this before the children load so that on revisit we know we have loaded the children (or are in the process) this.HasLoadedChildren = true; System.Threading.Tasks.Task <List <JobModel> > asyncTask = this.ListJobsAsync(); AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new WorkItemOperation(WorkItemOperation.ListJobs, this.WorkItem.Name))); this.Jobs = await asyncTask; this.FireChangesOnRefresh(ModelRefreshType.Children); } catch (Exception e) { this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time this.HandleException(e); } } }
/// <summary> /// Fires a set of property changes on refresh based on the refresh type /// </summary> /// <param name="refreshType"></param> protected void FireChangesOnRefresh(ModelRefreshType refreshType) { Type myType = this.GetType(); //Get all the public properties of this type PropertyInfo[] properties = myType.GetProperties(BindingFlags.Public | BindingFlags.Instance); foreach (PropertyInfo property in properties) { //Find all attributes on this property Attribute[] attributes = Attribute.GetCustomAttributes(property, true); IEnumerable <ChangeTrackedAttribute> changeTrackedAttributes = attributes.OfType <ChangeTrackedAttribute>(); bool hasPropertyChanged = changeTrackedAttributes.Any() && changeTrackedAttributes.All(attribute => attribute.HasChanged(refreshType)); if (hasPropertyChanged) { this.FirePropertyChangedEvent(property.Name); //Fire the event associated with this property on change } } }
public override async Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true) { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true)); if (refreshType.HasFlag(ModelRefreshType.Basic)) { try { System.Threading.Tasks.Task asyncTask = this.Certificate.RefreshAsync(OptionsModel.Instance.ListDetailLevel); if (showTrackedOperation) { AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new CertificateOperation(CertificateOperation.Refresh, this.Certificate.Thumbprint, this.Certificate.ThumbprintAlgorithm))); } else { AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask); } await asyncTask; this.LastUpdatedTime = DateTime.UtcNow; // // Fire property change events for this models properties // this.FireChangesOnRefresh(ModelRefreshType.Basic); } catch (Exception e) { this.HandleException(e); } } Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false)); Messenger.Default.Send(new CertificateUpdateCompleteMessage()); }
public override async System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true) { if (refreshType.HasFlag(ModelRefreshType.Basic)) { try { //await this.Task.RefreshAsync(); TODO: This doesnt' work right now due to bug with OM, so must do GetTask directly Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true)); System.Threading.Tasks.Task <CloudTask> asyncTask = MainViewModel.dataProvider.Service.GetTaskAsync( this.ParentJob.Id, this.Task.Id, OptionsModel.Instance.ListDetailLevel); if (showTrackedOperation) { AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new TaskOperation(TaskOperation.Refresh, this.ParentJob.Id, this.Task.Id))); } else { AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask); } this.Task = await asyncTask; this.LastUpdatedTime = DateTime.UtcNow; // // Fire property change events for this models properties // this.FireChangesOnRefresh(ModelRefreshType.Basic); } catch (Exception e) { this.HandleException(e); } finally { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false)); } } if (refreshType.HasFlag(ModelRefreshType.Children)) { try { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, true)); //Set this before the children load so that on revisit we know we have loaded the children (or are in the process) this.HasLoadedChildren = true; try { System.Threading.Tasks.Task <List <NodeFile> > asyncTask = this.ListTaskFilesAsync(); AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new TaskOperation(TaskOperation.ListFiles, this.ParentJob.Id, this.Task.Id))); this.OutputFiles = await asyncTask; } catch (Exception) { this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time //Swallow the exception to stop popups from occuring for every bad VM } this.FireChangesOnRefresh(ModelRefreshType.Children); } catch (Exception e) { this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time this.HandleException(e); } finally { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, false)); } } }
public override async System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true) { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true)); if (refreshType.HasFlag(ModelRefreshType.Basic)) { try { System.Threading.Tasks.Task asyncTask = this.Job.RefreshAsync(OptionsModel.Instance.ListDetailLevel); if (showTrackedOperation) { AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new JobOperation(JobOperation.Refresh, this.Job.Id))); } else { AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask); } await asyncTask; this.LastUpdatedTime = DateTime.UtcNow; // // Fire property change events for this models properties // this.FireChangesOnRefresh(ModelRefreshType.Basic); } catch (Exception e) { this.HandleException(e); } } if (refreshType.HasFlag(ModelRefreshType.Children)) { try { //Set this before the children load so that on revisit we know we have loaded the children (or are in the process) this.HasLoadedChildren = true; System.Threading.Tasks.Task<List<TaskModel>> asyncTask = this.ListTasksAsync(); AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new JobOperation(JobOperation.ListTasks, this.Job.Id))); this.Tasks = await asyncTask; this.TaskCollection = CollectionViewSource.GetDefaultView(this.Tasks); this.UpdateTaskView(); } catch (Exception e) { this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time this.HandleException(e); } } Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false)); Messenger.Default.Send(new JobUpdateCompleteMessage()); }
/// <summary> /// Fires a set of property changes on refresh based on the refresh type /// </summary> /// <param name="refreshType"></param> protected void FireChangesOnRefresh(ModelRefreshType refreshType) { Type myType = this.GetType(); //Get all the public properties of this type PropertyInfo[] properties = myType.GetProperties(BindingFlags.Public | BindingFlags.Instance); foreach (PropertyInfo property in properties) { //Find all attributes on this property Attribute[] attributes = Attribute.GetCustomAttributes(property, true); IEnumerable<ChangeTrackedAttribute> changeTrackedAttributes = attributes.OfType<ChangeTrackedAttribute>(); bool hasPropertyChanged = changeTrackedAttributes.Any() && changeTrackedAttributes.All(attribute => attribute.HasChanged(refreshType)); if (hasPropertyChanged) { this.FirePropertyChangedEvent(property.Name); //Fire the event associated with this property on change } } }
/// <summary> /// Returns true if this property has been changed based on the refresh type /// </summary> /// <param name="changeRefreshType">The type of refresh which was performed</param> /// <returns></returns> public bool HasChanged(ModelRefreshType changeRefreshType) { return(this.refreshType.HasFlag(changeRefreshType)); }
public ChangeTrackedAttribute(ModelRefreshType refreshType) { this.refreshType = refreshType; }
public override async System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true) { if (refreshType.HasFlag(ModelRefreshType.Basic)) { try { //await this.Task.RefreshAsync(); TODO: This doesnt' work right now due to bug with OM, so must do GetTask directly Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true)); System.Threading.Tasks.Task<CloudTask> asyncTask = MainViewModel.dataProvider.Service.GetTaskAsync( this.ParentJob.Id, this.Task.Id, OptionsModel.Instance.ListDetailLevel); if (showTrackedOperation) { AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new TaskOperation(TaskOperation.Refresh, this.ParentJob.Id, this.Task.Id))); } else { AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask); } this.Task = await asyncTask; this.LastUpdatedTime = DateTime.UtcNow; // // Fire property change events for this models properties // this.FireChangesOnRefresh(ModelRefreshType.Basic); } catch (Exception e) { this.HandleException(e); } finally { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false)); } } if (refreshType.HasFlag(ModelRefreshType.Children)) { try { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, true)); //Set this before the children load so that on revisit we know we have loaded the children (or are in the process) this.HasLoadedChildren = true; try { System.Threading.Tasks.Task<List<NodeFile>> asyncTask = this.ListTaskFilesAsync(); AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new TaskOperation(TaskOperation.ListFiles, this.ParentJob.Id, this.Task.Id))); this.OutputFiles = await asyncTask; } catch (Exception) { this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time //Swallow the exception to stop popups from occuring for every bad VM } this.FireChangesOnRefresh(ModelRefreshType.Children); } catch (Exception e) { this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time this.HandleException(e); } finally { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, false)); } } }
/// <summary> /// Returns true if this property has been changed based on the refresh type /// </summary> /// <param name="changeRefreshType">The type of refresh which was performed</param> /// <returns></returns> public bool HasChanged(ModelRefreshType changeRefreshType) { return this.refreshType.HasFlag(changeRefreshType); }
/// <summary> /// Refreshes this model with the specified refresh type /// </summary> /// <param name="refreshType">The refresh type to use</param> /// <param name="showTrackedOperation">Show the refresh row in the tracking list</param> /// <returns></returns> public abstract System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true);
public override async System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true) { this.attemptToLoadOutputs = true; if (refreshType.HasFlag(ModelRefreshType.Basic)) { try { //await this.Task.RefreshAsync(); TODO: This doesnt' work right now due to bug with OM, so must do GetTask directly Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true)); System.Threading.Tasks.Task <CloudTask> asyncTask = MainViewModel.dataProvider.Service.GetTaskAsync( this.ParentJob.Id, this.Task.Id, OptionsModel.Instance.ListDetailLevel); if (showTrackedOperation) { AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new TaskOperation(TaskOperation.Refresh, this.ParentJob.Id, this.Task.Id))); } else { AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask); } this.Task = await asyncTask; this.LastUpdatedTime = DateTime.UtcNow; IPagedEnumerable <SubtaskInformation> subtasks = this.Task.ListSubtasks(OptionsModel.Instance.ListDetailLevel); this.SubtasksInfo = new List <SubtaskModel>(); await subtasks.ForEachAsync(item => this.SubtasksInfo.Add(new SubtaskModel(item))); // // Fire property change events for this models properties // this.FireChangesOnRefresh(ModelRefreshType.Basic); } catch (Exception e) { this.HandleException(e); } finally { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false)); } } if (refreshType.HasFlag(ModelRefreshType.Children)) { try { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, true)); //Set this before the children load so that on revisit we know we have loaded the children (or are in the process) this.HasLoadedChildren = true; try { System.Threading.Tasks.Task <List <NodeFile> > asyncTask = this.ListTaskFilesAsync(); AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new TaskOperation(TaskOperation.ListFiles, this.ParentJob.Id, this.Task.Id))); this.OutputFiles = await asyncTask; } catch (BatchException be) { StringBuilder noOutputReasonBuilder = new StringBuilder(); if (be.RequestInformation != null && be.RequestInformation.AzureError != null) { if (!string.IsNullOrEmpty(be.RequestInformation.AzureError.Code)) { noOutputReasonBuilder.AppendLine(be.RequestInformation.AzureError.Code); } if (be.RequestInformation.AzureError.Message != null && !string.IsNullOrEmpty(be.RequestInformation.AzureError.Message.Value)) { noOutputReasonBuilder.AppendLine(be.RequestInformation.AzureError.Message.Value); } if (be.RequestInformation.AzureError.Values != null) { noOutputReasonBuilder.AppendLine(); foreach (var errorDetail in be.RequestInformation.AzureError.Values) { noOutputReasonBuilder.AppendLine(string.Format("{0}: {1}", errorDetail.Key, errorDetail.Value)); } } this.NoOutputFilesReason = noOutputReasonBuilder.ToString(); } } catch (Exception) { this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time //Swallow the exception to stop popups from occuring for every bad VM } this.FireChangesOnRefresh(ModelRefreshType.Children); } catch (Exception e) { this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time this.HandleException(e); } finally { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, false)); } } }
public override async System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true) { if (refreshType.HasFlag(ModelRefreshType.Basic)) { try { System.Threading.Tasks.Task asyncTask = this.WorkItem.RefreshAsync(); if (showTrackedOperation) { AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new WorkItemOperation(WorkItemOperation.Refresh, this.WorkItem.Name))); } else { AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask); } await asyncTask; this.LastUpdatedTime = DateTime.UtcNow; // // Fire property change events for this models properties // this.FireChangesOnRefresh(ModelRefreshType.Basic); } catch (Exception e) { this.HandleException(e); } } if (refreshType.HasFlag(ModelRefreshType.Children)) { try { //Set this before the children load so that on revisit we know we have loaded the children (or are in the process) this.HasLoadedChildren = true; System.Threading.Tasks.Task<List<JobModel>> asyncTask = this.ListJobsAsync(); AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new WorkItemOperation(WorkItemOperation.ListJobs, this.WorkItem.Name))); this.Jobs = await asyncTask; this.FireChangesOnRefresh(ModelRefreshType.Children); } catch (Exception e) { this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time this.HandleException(e); } } }
public override async Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true) { if (refreshType.HasFlag(ModelRefreshType.Basic)) { try { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true)); System.Threading.Tasks.Task asyncTask = this.VM.RefreshAsync(); if (showTrackedOperation) { AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new VMOperation(VMOperation.Refresh, this.ParentPool.Name, this.VM.Name))); } else { AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask); } await asyncTask; this.LastUpdatedTime = DateTime.UtcNow; // // Fire property change events for this models properties // this.FireChangesOnRefresh(ModelRefreshType.Basic); } catch (Exception e) { this.HandleException(e); } finally { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false)); } } if (refreshType.HasFlag(ModelRefreshType.Children)) { try { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, true)); //Set this before the children load so that on revisit we know we have loaded the children (or are in the process) this.HasLoadedChildren = true; try { System.Threading.Tasks.Task <List <ITaskFile> > asyncTask = this.ListFilesAsync(); AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new VMOperation(VMOperation.ListVMFiles, this.ParentPool.Name, this.VM.Name))); this.Files = await asyncTask; } catch (Exception) { this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time //Swallow the exception to stop popups from occuring for every bad VM } this.FireChangesOnRefresh(ModelRefreshType.Children); } catch (Exception e) { this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time this.HandleException(e); } finally { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, false)); } } }
public override async System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true) { this.attemptToLoadOutputs = true; if (refreshType.HasFlag(ModelRefreshType.Basic)) { try { //await this.Task.RefreshAsync(); TODO: This doesnt' work right now due to bug with OM, so must do GetTask directly Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true)); System.Threading.Tasks.Task<CloudTask> asyncTask = MainViewModel.dataProvider.Service.GetTaskAsync( this.ParentJob.Id, this.Task.Id, OptionsModel.Instance.ListDetailLevel); if (showTrackedOperation) { AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new TaskOperation(TaskOperation.Refresh, this.ParentJob.Id, this.Task.Id))); } else { AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask); } this.Task = await asyncTask; this.LastUpdatedTime = DateTime.UtcNow; // // Fire property change events for this models properties // this.FireChangesOnRefresh(ModelRefreshType.Basic); } catch (Exception e) { this.HandleException(e); } finally { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false)); } } if (refreshType.HasFlag(ModelRefreshType.Children)) { try { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, true)); //Set this before the children load so that on revisit we know we have loaded the children (or are in the process) this.HasLoadedChildren = true; try { System.Threading.Tasks.Task<List<NodeFile>> asyncTask = this.ListTaskFilesAsync(); AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new TaskOperation(TaskOperation.ListFiles, this.ParentJob.Id, this.Task.Id))); this.OutputFiles = await asyncTask; } catch (BatchException be) { StringBuilder noOutputReasonBuilder = new StringBuilder(); if (be.RequestInformation != null && be.RequestInformation.BatchError != null) { if (!string.IsNullOrEmpty(be.RequestInformation.BatchError.Code)) { noOutputReasonBuilder.AppendLine(be.RequestInformation.BatchError.Code); } if (be.RequestInformation.BatchError.Message != null && !string.IsNullOrEmpty(be.RequestInformation.BatchError.Message.Value)) { noOutputReasonBuilder.AppendLine(be.RequestInformation.BatchError.Message.Value); } if (be.RequestInformation.BatchError.Values != null) { noOutputReasonBuilder.AppendLine(); foreach (var errorDetail in be.RequestInformation.BatchError.Values) { noOutputReasonBuilder.AppendLine(string.Format("{0}: {1}", errorDetail.Key, errorDetail.Value)); } } this.NoOutputFilesReason = noOutputReasonBuilder.ToString(); } } catch (Exception) { this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time //Swallow the exception to stop popups from occuring for every bad VM } IPagedEnumerable<SubtaskInformation> subtasks = this.Task.ListSubtasks(OptionsModel.Instance.ListDetailLevel); this.SubtasksInfo = new List<SubtaskModel>(); System.Threading.Tasks.Task asyncListSubtasksTask = subtasks.ForEachAsync(item => this.SubtasksInfo.Add(new SubtaskModel(item))); AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncListSubtasksTask, new TaskOperation(TaskOperation.ListSubtasks, this.ParentJob.Id, this.Task.Id))); await asyncListSubtasksTask; this.FireChangesOnRefresh(ModelRefreshType.Children); } catch (Exception e) { this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time this.HandleException(e); } finally { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, false)); } } }
public override async Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true) { if (refreshType.HasFlag(ModelRefreshType.Basic)) { try { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true)); Task asyncTask = this.ComputeNode.RefreshAsync(); if (showTrackedOperation) { AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new ComputeNodeOperation(ComputeNodeOperation.Refresh, this.ParentPool.Id, this.ComputeNode.Id))); } else { AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask); } await asyncTask; this.LastUpdatedTime = DateTime.UtcNow; // // Fire property change events for this models properties // this.FireChangesOnRefresh(ModelRefreshType.Basic); } catch (Exception e) { this.HandleException(e); } finally { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false)); } } if (refreshType.HasFlag(ModelRefreshType.Children)) { try { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, true)); //Set this before the children load so that on revisit we know we have loaded the children (or are in the process) this.HasLoadedChildren = true; try { Task<List<NodeFile>> asyncTask = this.ListFilesAsync(); AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel( asyncTask, new ComputeNodeOperation(ComputeNodeOperation.ListFiles, this.ParentPool.Id, this.ComputeNode.Id))); this.Files = await asyncTask; } catch (Exception) { this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time //Swallow the exception to stop popups from occuring for every bad ComputeNode } this.FireChangesOnRefresh(ModelRefreshType.Children); } catch (Exception e) { this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time this.HandleException(e); } finally { Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, false)); } } }