public async Task ShouldReturnSuccessWhenCommandIsValid()
{
Guid administratorId = Guid.NewGuid();
var fakeUserRepository = new Mock <IUserRepository>();
var fakeChannelRepository = new Mock <IChannelRepository>();
fakeChannelRepository
.Setup(repository => repository.GetById(It.IsAny <Guid>()))
.ReturnsAsync((Guid id) => new GetChannelByIdQueryResult
{
Id = id,
Name = "channelOne",
Description = "The first channel",
AdministratorId = administratorId
});
var command = new DeleteChannelCommand
{
ChannelId = Guid.NewGuid(),
AdministratorId = administratorId
};
var handler = new ChannelHandler(fakeChannelRepository.Object, fakeUserRepository.Object);
ICommandResult result = await handler.HandleAsync(command);
result.Success.Should().BeTrue();
result.Errors.Should().BeNullOrEmpty();
handler.Valid.Should().BeTrue();
fakeChannelRepository.Verify(
repository => repository.DeleteChannel(It.Is <Guid>(id => id == command.ChannelId)),
Times.Once());
}
public async Task ShouldReturnErrorWhenAdministratorIdDoesNotMatch()
{
Guid adminstratorId = Guid.NewGuid();
Guid commandAdministratorId = Guid.NewGuid();
var fakeUserRepository = new Mock <IUserRepository>();
var fakeChannelRepository = new Mock <IChannelRepository>();
fakeChannelRepository
.Setup(repository => repository.GetById(It.IsAny <Guid>()))
.ReturnsAsync((Guid id) => new GetChannelByIdQueryResult
{
Id = id,
Name = "channelOne",
Description = "The first channel",
AdministratorId = adminstratorId
});
var command = new DeleteChannelCommand
{
ChannelId = Guid.NewGuid(),
AdministratorId = commandAdministratorId
};
var handler = new ChannelHandler(fakeChannelRepository.Object, fakeUserRepository.Object);
ICommandResult result = await handler.HandleAsync(command);
result.Success.Should().BeFalse();
result.Errors.Should().HaveCountGreaterThan(0);
handler.Invalid.Should().BeTrue();
}
public async Task <ActionResult> DeleteChannel([FromRoute] Guid id,
[FromHeader] Guid authorization,
[FromServices] IHandler <DeleteChannelCommand> handler)
{
var command = new DeleteChannelCommand
{
ChannelId = id,
AdministratorId = authorization
};
ICommandResult result = await handler.HandleAsync(command);
if (!result.Success)
{
var channelHandler = handler as ChannelHandler;
if (channelHandler.Notifications.Any(notification => notification.Message == "Channel not found"))
{
return(NotFound(new ErrorViewModel(result)));
}
if (channelHandler.Notifications
.Any(notification => notification.Message == "AdministratorId does't match channel administrator id"))
{
return(Unauthorized());
}
return(BadRequest(new ErrorViewModel(result)));
}
return(NoContent());
}
public async Task WhenDeletingChannel_ItShouldIssueDeleteChannelCommand()
{
var command = new DeleteChannelCommand(Requester, ChannelId);
this.requesterContext.Setup(_ => _.GetRequesterAsync()).ReturnsAsync(Requester);
this.deleteChannel.Setup(v => v.HandleAsync(command)).Returns(Task.FromResult(0)).Verifiable();
var result = await this.target.DeleteChannelAsync(ChannelId.Value.EncodeGuid());
Assert.IsInstanceOfType(result, typeof(OkResult));
this.updateChannel.Verify();
}
public void ShouldReturnSuccessWhenChannelIdAndAdministratorIdIsValid()
{
var command = new DeleteChannelCommand
{
ChannelId = Guid.NewGuid(),
AdministratorId = Guid.NewGuid()
};
command.Validate();
command.Valid.Should().BeTrue();
}
public void ShouldReturnErrorWhenChannelIdAndAdministratorIdIsEmpty()
{
var command = new DeleteChannelCommand
{
ChannelId = Guid.Empty,
AdministratorId = Guid.Empty
};
command.Validate();
command.Invalid.Should().BeTrue();
}
public async Task ShouldReturnErrorWhenChannelIdAndAdministratorIdIsEmpty()
{
var fakeUserRepository = new Mock <IUserRepository>();
var fakeChannelRepository = new Mock <IChannelRepository>();
var command = new DeleteChannelCommand
{
ChannelId = Guid.Empty,
AdministratorId = Guid.Empty
};
var handler = new ChannelHandler(fakeChannelRepository.Object, fakeUserRepository.Object);
ICommandResult result = await handler.HandleAsync(command);
result.Success.Should().BeFalse();
result.Errors.Should().HaveCountGreaterThan(0);
handler.Invalid.Should().BeTrue();
}
public async Task ShouldReturnErrorWhenChannelNotFound()
{
var fakeUserRepository = new Mock <IUserRepository>();
var fakeChannelRepository = new Mock <IChannelRepository>();
fakeChannelRepository
.Setup(repository => repository.GetById(It.IsAny <Guid>()))
.Returns(Task.FromResult <GetChannelByIdQueryResult>(null));
var command = new DeleteChannelCommand
{
ChannelId = Guid.NewGuid(),
AdministratorId = Guid.NewGuid()
};
var handler = new ChannelHandler(fakeChannelRepository.Object, fakeUserRepository.Object);
ICommandResult result = await handler.HandleAsync(command);
result.Success.Should().BeFalse();
result.Errors.Should().HaveCountGreaterThan(0);
handler.Invalid.Should().BeTrue();
}
public async Task <ICommandResult> HandleAsync(DeleteChannelCommand command)
{
command.Validate();
if (command.Invalid)
{
AddNotifications(command);
return(new CommandResult(false, "Could not delete this channel", Errors));
}
GetChannelByIdQueryResult channel = await _channelRepository.GetById(command.ChannelId);
if (channel is null)
{
AddNotification(nameof(command.ChannelId), "Channel not found");
return(new CommandResult(false, "Could not delete this channel", Errors));
}
if (channel.AdministratorId != command.AdministratorId)
{
AddNotification(nameof(command.AdministratorId), "AdministratorId does't match channel administrator id");
return(new CommandResult(false, "User does't have permission to delete this channel", Errors));
}
await _channelRepository.DeleteChannel(channel.Id);
return(new CommandResult(true, "Channel successfully deleted", null, null));
}
public PodcastViewModel(IScreen hostScreen,
IPlayerModel player,
IEventAggregator eventAggregator,
IDialogService dialogService,
IFeedParser feedParser,
IChannelStore channelStore,
IPlaylistStore playlistStore)
: base(eventAggregator)
{
HostScreen = hostScreen;
Player = player;
DialogService = dialogService;
FeedParser = feedParser;
this.channelStore = channelStore;
this.playlistStore = playlistStore;
GetChannelsCommand = ReactiveCommand.CreateFromTask(async _ => await GetChannels());
GetChannelsCommand.IsExecuting.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => OnChannelsBusy(GetChannelsCommand.GetHashCode(), _));
PlayItemCommand = ReactiveCommand.CreateFromTask <IPlayable>(async _ => await OnPlayEpisode(_ as Episode));
// open url
OpenUrlDialogCommand = ReactiveCommand.CreateFromTask(async _ => await OpenUrlDialog());
OpenUrlDialogCommand.ThrownExceptions.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => LogAndNotify(NotificationType.Error, Messages.ERR_CHANNEL_LOAD));
// channels busy indicator
this.WhenAnyObservable(_ => _.ChannelsBusyList.CountChanged).DistinctUntilChanged()
.Subscribe(_ => IsChannelsBusy = _ > 0);
// episodes busy indicator
this.WhenAnyObservable(_ => _.EpisodesBusyList.CountChanged).DistinctUntilChanged()
.Subscribe(_ => IsEpisodesBusy = _ > 0);
OpenUrlCommand = ReactiveCommand.CreateFromTask <string>(async _ => await OnOpenUrl(_));
OpenUrlCommand.ThrownExceptions.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => LogAndNotify(NotificationType.Error, Messages.ERR_CHANNEL_LOAD));
// load channel
LoadChannelFromUrlCommand = ReactiveCommand.CreateFromTask <string>(LoadChannelFromUrlAsync);
OpenUrlCommand.IsExecuting.ObserveOn(RxApp.MainThreadScheduler).Subscribe(_ =>
{
OnChannelsBusy(OpenUrlCommand.GetHashCode(), _);
OnEpisodesBusy(OpenUrlCommand.GetHashCode(), _);
});
LoadChannelFromUrlCommand.ThrownExceptions.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => LogAndNotify(NotificationType.Error, Messages.ERR_CHANNEL_LOAD));
// delete channel
ConfirmDeleteChannelCommand = ReactiveCommand.CreateFromTask <Channel>(async _ => await ConfirmDelete(_));
DeleteChannelCommand = ReactiveCommand.CreateFromTask <Channel>(async _ => await DeleteChannel(_));
DeleteChannelCommand.ThrownExceptions.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => LogAndNotify(NotificationType.Error, Messages.ERR_CHANNEL_DELETE));
DeleteChannelCommand.IsExecuting.Subscribe(_ =>
{
OnChannelsBusy(DeleteChannelCommand.GetHashCode(), _);
OnEpisodesBusy(DeleteChannelCommand.GetHashCode(), _);
});
var existsSelectedChannel = this.WhenAny(vm => vm.SelectedChannel, _ => SelectedChannel != null);
this.WhenAnyValue(vm => vm.SelectedChannel).Select(_ => _ == null ? 0 : SelectedChannel.Id)
.ToProperty(this, _ => _.SelectedChannelId, out selectedChannelId);
RemoveFilterCommand = ReactiveCommand.Create <Unit>(_ => SelectedChannel = null, existsSelectedChannel);
MarkAllPlayedCommand = ReactiveCommand.CreateFromTask <Channel>(async _ => await MarkChannelPlayed(_));
CopyUrlCommand = ReactiveCommand.Create <Channel>(_ => Clipboard.SetText(_.Link));
var episodeSet = this.WhenAnyValue(_ => _.SelectedEpisode);
// detail
this.WhenAnyValue(vm => vm.SelectedChannel).NotNull().Cast <IDetailEntity>()
.Merge(episodeSet.Cast <IDetailEntity>())
.ToProperty(this, _ => _.CurrentDetailEntity, out currentDetailEntity);
this.WhenAnyValue(vm => vm.Player.LocateCurrent).NotNull()
.Subscribe(c => c.Subscribe(_ => LocatePageForCurrent()));
// episode list is loading
this.WhenAnyValue(_ => _.EpisodeList.IsLoading).SubscribeOn(RxApp.MainThreadScheduler)
.Subscribe(_ => OnEpisodesBusy(EpisodeList.GetHashCode(), _));
ScrollIntoView = ReactiveCommand.Create <int, int>(_ => _);
// playlist
AddToPlaylist = ReactiveCommand.CreateFromTask <Playlist>(async _ => await AddEpisodeToPlaylist(_));
// sort order
this.WhenAnyValue(_ => _.SelectedEpisodeSortOrder)
.Subscribe(_ => EpisodeOrderBy.OnNext(GetEpisodeSortOrder(_)));
ToggleSortDirectionCommand =
ReactiveCommand.Create(
() => EpisodeOrderBy.OnNext(GetEpisodeSortOrder(SelectedEpisodeSortOrder, false)));
// on channels changed
this.WhenAnyValue(_ => _.Channels).NotNull().Subscribe(_ => OnChannelsChanged());
// update channels
var canUpdate = new BehaviorSubject <bool>(false);
UpdateChannelsCommand = ReactiveCommand.CreateFromTask(async _ => await UpdateChannelsAsync(),
canUpdate.DistinctUntilChanged());
UpdateChannelsCommand.IsExecuting.CombineLatest(this.WhenAnyValue(_ => _.Channels.IsEmpty),
(exec, empty) => !exec && !empty && IsUpdateEnabled).DistinctUntilChanged()
.Subscribe(_ => canUpdate.OnNext(_));
UpdateChannelsCommand.IsExecuting.ObserveOn(RxApp.MainThreadScheduler).Subscribe(_ => IsUpdating = _);
UpdateChannelsCommand.ThrownExceptions.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => LogAndNotify(NotificationType.Error, Messages.ERR_CHANNEL_UPDATE));
// init episodes
EpisodeList = InitEpisodeList();
EpisodeList.Changed.Subscribe(_ => InitActivePlaylist());
// detail
ToggleShowDetailCommand = ReactiveCommand.Create <bool, bool>(_ => _);
DeactivateCommand = ReactiveCommand.Create(() => { });
}
