public FolderViewModel(IProviderViewModel provider, FolderModel folder)
{
Provider = provider;
_folder = folder;
Children = folder.Children != null && folder.Children.Any()
? folder.Children.Select(f => new FolderViewModel(provider, f))
: Enumerable.Empty <IFolderViewModel>();
}
public FileViewModel(IProviderViewModel provider, FileModel file)
{
Provider = provider;
_file = file;
}
public RenameFileViewModel(RenameFileState state, IProviderViewModel owner, IProvider provider)
{
_oldName = owner
.WhenAnyValue(x => x.SelectedFile.Name)
.ToProperty(this, x => x.OldName);
this.ValidationRule(x => x.NewName,
name => !string.IsNullOrWhiteSpace(name),
"New name shouldn't be empty.");
var oldRule = this.ValidationRule(x => x.OldName,
name => !string.IsNullOrWhiteSpace(name),
"Old name shouldn't be empty.");
Rename = ReactiveCommand.CreateFromTask(
() => provider.RenameFile(owner.SelectedFile.Path, NewName),
this.IsValid());
_isLoading = Rename
.IsExecuting
.ToProperty(this, x => x.IsLoading);
var canInteract = owner
.WhenAnyValue(x => x.CanInteract)
.Skip(1)
.StartWith(true);
var canOpen = this
.WhenAnyValue(x => x.IsVisible)
.Select(visible => !visible)
.CombineLatest(
canInteract,
oldRule.WhenAnyValue(x => x.IsValid),
(visible, interact, old) => visible && old && interact);
var canClose = this
.WhenAnyValue(x => x.IsVisible)
.Select(visible => visible);
Open = ReactiveCommand.Create(() => {}, canOpen);
Close = ReactiveCommand.Create(() => {}, canClose);
Open.Select(unit => true)
.Merge(Close.Select(unit => false))
.Subscribe(visible => IsVisible = visible);
Close.Subscribe(x => NewName = string.Empty);
Rename.InvokeCommand(Close);
_hasErrorMessage = Rename
.ThrownExceptions
.Select(exception => true)
.Merge(Close.Select(x => false))
.ToProperty(this, x => x.HasErrorMessage);
_errorMessage = Rename
.ThrownExceptions
.Select(exception => exception.Message)
.Log(this, $"Rename file error occured in {provider.Name} for {OldName}")
.Merge(Close.Select(x => string.Empty))
.ToProperty(this, x => x.ErrorMessage);
NewName = state.NewName;
this.WhenAnyValue(x => x.NewName)
.Subscribe(name => state.NewName = name);
}
public RenameFileViewModel(
IProviderViewModel providerViewModel,
IProvider provider,
IScheduler current,
IScheduler main)
{
_oldName = providerViewModel
.WhenAnyValue(x => x.SelectedFile)
.Select(file => file?.Name)
.ToProperty(this, x => x.OldName, scheduler: current);
var canInteract = providerViewModel
.WhenAnyValue(x => x.CanInteract);
var oldNameValid = this
.WhenAnyValue(x => x.OldName)
.Select(old => !string.IsNullOrWhiteSpace(old));
var canOpen = this
.WhenAnyValue(x => x.IsVisible)
.Select(visible => !visible)
.CombineLatest(oldNameValid, (visible, old) => visible && old)
.CombineLatest(canInteract, (open, interact) => open && interact);
_open = ReactiveCommand.Create(
() => { IsVisible = true; },
canOpen, main);
var canClose = this
.WhenAnyValue(x => x.IsVisible)
.Select(visible => visible);
_close = ReactiveCommand.Create(
() => { IsVisible = false; },
canClose, main);
var canRename = this
.WhenAnyValue(x => x.NewName)
.Select(name => !string.IsNullOrWhiteSpace(name))
.CombineLatest(oldNameValid, (old, name) => old && name);
_rename = ReactiveCommand.CreateFromTask(
() => provider.RenameFile(providerViewModel.SelectedFile.Path, NewName),
canRename, main);
_isLoading = _rename
.IsExecuting
.ToProperty(this, x => x.IsLoading, scheduler: current);
_hasErrors = _rename
.ThrownExceptions
.Select(exception => true)
.Merge(_close.Select(x => false))
.ToProperty(this, x => x.HasErrors, scheduler: current);
_errorMessage = _rename
.ThrownExceptions
.Select(exception => exception.Message)
.Log(this, $"Rename file error occured in {provider.Name} for {OldName}")
.Merge(_close.Select(x => string.Empty))
.ToProperty(this, x => x.ErrorMessage, scheduler: current);
_rename.InvokeCommand(_close);
_close.Subscribe(x => NewName = string.Empty);
}
public CreateFolderViewModel(CreateFolderState state, IProviderViewModel owner, IProvider provider)
{
_path = owner
.WhenAnyValue(x => x.CurrentPath)
.ToProperty(this, x => x.Path);
this.ValidationRule(x => x.Name,
name => !string.IsNullOrWhiteSpace(name),
"Folder name shouldn't be empty.");
var pathRule = this.ValidationRule(x => x.Path,
path => !string.IsNullOrWhiteSpace(path),
"Path shouldn't be empty");
Create = ReactiveCommand.CreateFromTask(
() => provider.CreateFolder(Path, Name),
this.IsValid());
_isLoading = Create.IsExecuting
.ToProperty(this, x => x.IsLoading);
var canInteract = owner
.WhenAnyValue(x => x.CanInteract)
.Skip(1)
.StartWith(true);
var canOpen = this
.WhenAnyValue(x => x.IsVisible)
.Select(visible => !visible)
.CombineLatest(
canInteract,
pathRule.WhenAnyValue(x => x.IsValid),
(visible, interact, path) => visible && provider.CanCreateFolder && interact && path);
var canClose = this
.WhenAnyValue(x => x.IsVisible)
.Select(visible => visible);
Open = ReactiveCommand.Create(() => {}, canOpen);
Close = ReactiveCommand.Create(() => {}, canClose);
Open.Select(unit => true)
.Merge(Close.Select(unit => false))
.Subscribe(visible => IsVisible = visible);
Close.Subscribe(x => Name = string.Empty);
Create.InvokeCommand(Close);
_hasErrorMessage = Create
.ThrownExceptions
.Select(exception => true)
.Merge(Close.Select(unit => false))
.ToProperty(this, x => x.HasErrorMessage);
_errorMessage = Create
.ThrownExceptions
.Select(exception => exception.Message)
.Log(this, $"Create folder error occured in {provider.Name}")
.Merge(Close.Select(unit => string.Empty))
.ToProperty(this, x => x.ErrorMessage);
Name = state.Name;
IsVisible = state.IsVisible;
this.WhenAnyValue(x => x.Name)
.Subscribe(name => state.Name = name);
this.WhenAnyValue(x => x.IsVisible)
.Subscribe(visible => state.IsVisible = visible);
}
public CreateFolderViewModel(
IProviderViewModel providerViewModel,
IProvider provider,
IScheduler current,
IScheduler main)
{
_path = providerViewModel
.WhenAnyValue(x => x.CurrentPath)
.ToProperty(this, x => x.Path, scheduler: current);
var canInteract = providerViewModel
.WhenAnyValue(x => x.CanInteract);
var pathValid = this
.WhenAnyValue(x => x.Path)
.Select(path => !string.IsNullOrWhiteSpace(path));
var canCreateFolder = this
.WhenAnyValue(x => x.Name)
.Select(name => !string.IsNullOrWhiteSpace(name))
.CombineLatest(pathValid, (name, path) => name && path);
_create = ReactiveCommand.CreateFromTask(
() => provider.CreateFolder(Path, Name),
canCreateFolder, main);
var canCreate = Observable.Return(provider.CanCreateFolder);
var canOpen = this
.WhenAnyValue(x => x.IsVisible)
.Select(visible => !visible)
.CombineLatest(canCreate, pathValid, (visible, can, path) => visible && path && can)
.CombineLatest(canInteract, (open, interact) => open && interact);
_open = ReactiveCommand.Create(
() => { IsVisible = true; },
canOpen, main);
var canClose = this
.WhenAnyValue(x => x.IsVisible)
.Select(visible => visible);
_close = ReactiveCommand.Create(
() => { IsVisible = false; },
canClose, main);
_create.InvokeCommand(_close);
_close.Subscribe(x => Name = string.Empty);
_hasErrors = _create
.ThrownExceptions
.Select(exception => true)
.Merge(_close.Select(unit => false))
.ToProperty(this, x => x.HasErrors, scheduler: current);
_errorMessage = _create
.ThrownExceptions
.Select(exception => exception.Message)
.Log(this, $"Create folder error occured in {provider.Name}")
.Merge(_close.Select(unit => string.Empty))
.ToProperty(this, x => x.ErrorMessage, scheduler: current);
_isLoading = _create
.IsExecuting
.ToProperty(this, x => x.IsLoading, scheduler: current);
}
