private static BackupResult ToResult(IProgressItem task)
{
if (task == null)
{
return(null);
}
if (task.Error != null)
{
throw new FaultException(((Exception)task.Error).Message);
}
var result = new BackupResult
{
Id = task.Id.ToString(),
Completed = task.IsCompleted,
Percent = (int)task.Percentage,
};
var backupTask = task as BackupTask;
if (backupTask != null)
{
result.Link = task.Status as string;
result.ExpireDate = backupTask.ExpireDate;
}
return(result);
}
private static BackupProgress ToBackupProgress(IProgressItem progressItem)
{
if (progressItem == null)
{
return(null);
}
var progress = new BackupProgress
{
IsCompleted = progressItem.IsCompleted,
Progress = (int)progressItem.Percentage,
Error = progressItem.Error != null ? ((Exception)progressItem.Error).Message : null
};
var backupProgressItem = progressItem as BackupProgressItem;
if (backupProgressItem != null)
{
progress.Link = backupProgressItem.Link;
}
else
{
var transferProgressItem = progressItem as TransferProgressItem;
if (transferProgressItem != null)
{
progress.Link = transferProgressItem.Link;
}
}
return(progress);
}
/// <summary>
/// Determines whether <see cref="ActiveItems"/> contains the progress item.
/// </summary>
/// <param name="item">The progress item.</param>
/// <returns><c>true</c> if <see cref="ActiveItems"/> contains the progress item; otherwise, <c>false</c>.</returns>
public bool Contains(IProgressItem item)
{
lock (this.activeItems)
{
return(this.activeItems.Contains(item));
}
}
/// <summary>
/// Initializes the progress item view model.
/// </summary>
/// <param name="progItem">The progress item.</param>
protected void Initialize(IProgressItem progItem)
{
this.ReleaseProgressItem();
this.progressItem = progItem;
if (this.progressItem == null)
{
this.Title = string.Empty;
this.Text = string.Empty;
this.Percentage = 0;
this.cancelCommand.IsExecutable = false;
this.IsBusy = false;
}
else
{
this.Title = this.progressItem.Title;
this.Text = this.progressItem.Text;
this.Percentage = this.progressItem.Percentage;
this.cancelCommand.IsExecutable = this.progressItem.CancelEnabled;
this.progressItem.Changed += this.ProgressItemChangedHandler;
this.progressItem.Canceled += this.ProgressItemCanceledHandler;
this.progressItem.Completed += this.ProgressItemCompletedHandler;
this.IsBusy = true;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ProgressItemVm" /> class.
/// </summary>
/// <param name="progressItem">The progress item.</param>
public ProgressItemVm(IProgressItem progressItem)
{
this.cancelCommand = new DelegateCommand(this.Cancel);
this.progressItem = null;
this.Initialize(progressItem);
}
/// <summary>
/// Initializes a new instance of the <see cref="ProgressBarVm" /> class.
/// </summary>
/// <param name="progressItem">The progress item.</param>
public ProgressBarVm(IProgressItem progressItem)
{
this.CancelButtonVisibility = Visibility.Collapsed;
this.cancelCommand = new DelegateCommand(this.Cancel);
this.progressItem = null;
this.UpdateProgressItem(progressItem);
}
/// <summary>
/// Releases the progress item.
/// </summary>
private void ReleaseProgressItem()
{
if (this.progressItem != null)
{
this.progressItem.Changed -= this.ProgressItemChangedHandler;
this.progressItem.Canceled -= this.ProgressItemCanceledHandler;
this.progressItem.Completed -= this.ProgressItemCompletedHandler;
this.progressItem = null;
}
}
/// <summary>
/// Removes a progress item.
/// </summary>
/// <param name="progItem">The progress item.</param>
public void Remove(IProgressItem progItem)
{
foreach (var progressItemViewModel in this.Items)
{
if (progressItemViewModel.ProgressItem == progItem)
{
progressItemViewModel.Completed -= this.ProgressItemCompletedHandler;
this.Items.Remove(progressItemViewModel);
this.IsBusy = this.Items.Count > 0;
return;
}
}
}
/// <summary>
/// Called when a progress item is removed.
/// </summary>
/// <param name="item">The progress item, which has been removed.</param>
private void OnItemRemoved(IProgressItem item)
{
if (Logger.IsDebugEnabled)
{
var message = string.Format(CultureInfo.CurrentUICulture, Resources.ProgressItemWithTitle_HasBeenRemovedFromProgressList, item.Title);
Logger.Debug(message);
}
var itemRemoved = this.ItemRemoved;
if (itemRemoved != null)
{
itemRemoved(null, new ProgressEventArgs(item));
}
}
/// <summary>
/// Updates the progress item.
/// </summary>
/// <param name="progItem">The progress item.</param>
public void UpdateProgressItem(IProgressItem progItem)
{
if (this.CheckAccess())
{
this.ReleaseProgressItem();
this.progressItem = progItem;
if (this.progressItem == null)
{
this.Title = string.Empty;
this.Subtitle = string.Empty;
this.Percentage = 0;
this.cancelCommand.IsExecutable = false;
this.CancelButtonVisibility = Visibility.Collapsed;
this.IsBusy = false;
}
else
{
this.Title = this.progressItem.Title;
this.Subtitle = this.progressItem.Text;
this.Percentage = this.progressItem.Percentage;
if (this.disableCancelButton)
{
this.cancelCommand.IsExecutable = false;
this.CancelButtonVisibility = Visibility.Collapsed;
}
else
{
this.CancelButtonVisibility = Visibility.Visible;
this.cancelCommand.IsExecutable = this.progressItem.CancelEnabled;
}
this.progressItem.Changed += this.ProgressItemChangedHandler;
this.progressItem.Canceled += this.ProgressItemCanceledHandler;
this.progressItem.Completed += this.ProgressItemCompletedHandler;
this.IsBusy = true;
}
}
else
{
// again, but in correct thread
this.Dispatcher.Invoke(new Action <IProgressItem>(this.UpdateProgressItem), new[] { progItem });
}
}
/// <summary>
/// Add a progress item.
/// </summary>
/// <param name="progItem">The progress item.</param>
public void Add(IProgressItem progItem)
{
var progressItemViewModel = new ProgressItemVm(progItem);
this.Title = progressItemViewModel.Title;
this.Subtitle = progressItemViewModel.Text;
this.Percentage = progressItemViewModel.Percentage;
progressItemViewModel.Completed += this.ProgressItemCompletedHandler;
if (progressItemViewModel.IsBusy)
{
this.Items.Add(progressItemViewModel);
this.IsBusy = true;
}
else
{
progressItemViewModel.Completed -= this.ProgressItemCompletedHandler;
}
}
/// <summary>
/// Called when a progress item has changed.
/// </summary>
/// <param name="item">The progress item, which has changed.</param>
public void OnItemChanged(IProgressItem item)
{
if (item == null)
{
throw new ArgumentNullException(@"item");
}
if (Logger.IsDebugEnabled)
{
var message = string.Format(CultureInfo.CurrentUICulture, Resources.ProgressItemWithTitle_HasChanged, item.Title);
Logger.Debug(message);
}
var itemChanged = this.ItemChanged;
if (itemChanged != null)
{
itemChanged(null, new ProgressEventArgs(item));
}
}
/// <summary>
/// Removes a progress item from <see cref="ActiveItems"/>.
/// </summary>
/// <param name="item">The item to be removed.</param>
public void Remove(IProgressItem item)
{
if (item == null)
{
throw new ArgumentNullException(@"item");
}
lock (this.activeItems)
{
if (this.activeItems.Contains(item))
{
if (Logger.IsDebugEnabled)
{
var message = string.Format(CultureInfo.CurrentUICulture, Resources.RemovingProgressItemWithTitle_FromProgressList, item.Title);
Logger.Debug(message);
}
this.activeItems.Remove(item);
this.OnItemRemoved(item);
}
}
}
/// <summary>
/// Dispose(bool disposing) executes in two distinct scenarios.
/// If disposing equals true, the method has been called directly
/// or indirectly by a user's code. Managed and unmanaged resources
/// can be disposed.
/// If disposing equals false, the method has been called by the
/// runtime from inside the finalizer and you should not reference
/// other objects. Only unmanaged resources can be disposed.
/// </summary>
/// <param name="disposing">If equals true, method is called directly or indirectly
/// by a user's code. If equals to false, method is called by the runtime from inside
/// a finalizer.</param>
private void Dispose(bool disposing)
{
// Check to see if Dispose has already been called.
if (!this.disposed)
{
// If disposing equals true, dispose all managed
// and unmanaged resources.
if (disposing)
{
}
this.ProgressItem = null;
this.host.DoEvents();
// Call the appropriate methods to clean up
// unmanaged resources here.
// If disposing is false,
// only the following code is executed.
}
this.disposed = true;
}
public BackupResult RestorePortal(int tenantID, string demoID)
{
lock (tasks.SynchRoot)
{
IProgressItem task = tasks.GetItems().FirstOrDefault(t => (int)t.Id == tenantID);
if (task != null && task.IsCompleted)
{
tasks.Remove(task);
task = null;
}
if (task == null)
{
var config = BackupConfigurationSection.GetSection();
var demoPortal = config.DemoPortals.GetDemoPortal(demoID) ?? config.DemoPortals.Default;
if (demoPortal == null)
{
throw new FaultException("Can't find demo portal with id = " + demoID);
}
task = new RestoreTask(tenantID, demoPortal.DataPath);
tasks.Add(task);
}
return(ToResult(task));
}
}
private static BackupResult ToResult(IProgressItem task)
{
if (task == null)
return null;
if (task.Error != null)
throw new FaultException(((Exception)task.Error).Message);
var result = new BackupResult
{
Id = task.Id.ToString(),
Completed = task.IsCompleted,
Percent = (int)task.Percentage,
};
var backupTask = task as BackupTask;
if (backupTask != null)
{
result.Link = task.Status as string;
result.ExpireDate = backupTask.ExpireDate;
}
return result;
}
public ActionIndexMap(IProgressItem action)
{
this.Action = action;
// index isn't known yet
this.Index = -1;
}
/// <summary>
/// Add an action to the collection
/// </summary>
/// <param name="action">action to be added</param>
public void AddAction(IProgressItem action)
{
ActionIndexMap map = new ActionIndexMap(action);
this.actions.Add(map);
}
/// <summary>
/// Initializes a new instance of the <see cref="ProgressEventArgs"/> class.
/// </summary>
/// <param name="item">The item.</param>
public ProgressEventArgs(IProgressItem item)
{
this.Item = item;
}
