protected async Task On(AssignContributor command, CommandContext context)
{
if (await userResolver.FindByIdAsync(command.ContributorId) == null)
{
var error =
new ValidationError("Cannot find contributor the contributor",
nameof(AssignContributor.ContributorId));
throw new ValidationException("Cannot assign contributor to app", error);
}
await handler.UpdateAsync <AppDomainObject>(context, a =>
{
var oldContributors = a.ContributorCount;
var maxContributors = appPlansProvider.GetPlan(a.PlanId).MaxContributors;
a.AssignContributor(command);
if (maxContributors > 0 && a.ContributorCount > oldContributors && a.ContributorCount > maxContributors)
{
var error = new ValidationError("You have reached your max number of contributors");
throw new ValidationException("Cannot assign contributor to app", error);
}
});
}
public static Task CanAssign(AppContributors contributors, AssignContributor command, IUserResolver users, IAppLimitsPlan plan)
{
Guard.NotNull(command, nameof(command));
return(Validate.It(() => "Cannot assign contributor.", async error =>
{
if (!command.Permission.IsEnumValue())
{
error(new ValidationError("Permission is not valid.", nameof(command.Permission)));
}
if (string.IsNullOrWhiteSpace(command.ContributorId))
{
error(new ValidationError("Contributor id not assigned.", nameof(command.ContributorId)));
}
else
{
if (await users.FindByIdAsync(command.ContributorId) == null)
{
error(new ValidationError("Cannot find contributor id.", nameof(command.ContributorId)));
}
else if (contributors.TryGetValue(command.ContributorId, out var existing))
{
if (existing == command.Permission)
{
error(new ValidationError("Contributor has already this permission.", nameof(command.Permission)));
}
}
else if (plan.MaxContributors == contributors.Count)
{
error(new ValidationError("You have reached the maximum number of contributors for your plan."));
}
}
}));
}
public Task CanAssign_should_throw_exception_if_contributor_id_is_null()
{
var command = new AssignContributor();
return(ValidationAssert.ThrowsAsync(() => GuardAppContributors.CanAssign(contributors_0, command, users, appPlan, roles),
new ValidationError("Contributor id is required.", "ContributorId")));
}
public async Task CanAssign_should_throw_exception_if_contributor_id_is_null()
{
var command = new AssignContributor();
await ValidationAssert.ThrowsAsync(() => GuardAppContributors.CanAssign(command, App(contributors_0), users, appPlan),
new ValidationError("Contributor ID or email is required.", "ContributorId"));
}
public async Task CanAssign_should_throw_exception_if_user_is_actor()
{
var command = new AssignContributor {
ContributorId = "3", Role = Role.Editor, Actor = RefToken.User("3")
};
await Assert.ThrowsAsync <DomainForbiddenException>(() => GuardAppContributors.CanAssign(command, App(contributors_0), users, appPlan));
}
public Task CanAssign_should_throw_exception_if_user_not_found()
{
var command = new AssignContributor {
ContributorId = "notfound", Role = Role.Owner
};
return(Assert.ThrowsAsync <DomainObjectNotFoundException>(() => GuardAppContributors.CanAssign(contributors_0, command, users, appPlan, roles)));
}
public AppDomainObject AssignContributor(AssignContributor command)
{
ThrowIfNotCreated();
RaiseEvent(SimpleMapper.Map(command, new AppContributorAssigned()));
return(this);
}
public Task CanAssign_should_throw_exception_if_user_is_actor()
{
var command = new AssignContributor {
ContributorId = "3", Role = Role.Editor, Actor = new RefToken("user", "3")
};
return(Assert.ThrowsAsync <DomainForbiddenException>(() => GuardAppContributors.CanAssign(contributors_0, command, users, appPlan, roles)));
}
public Task CanAssign_should_not_throw_exception_if_user_found()
{
var command = new AssignContributor {
ContributorId = "1"
};
return(GuardAppContributors.CanAssign(contributors_0, command, users, appPlan, roles));
}
public Task CanAssign_should_throw_exception_if_user_is_actor()
{
var command = new AssignContributor {
ContributorId = "3", Permission = AppContributorPermission.Editor, Actor = new RefToken("user", "3")
};
return(Assert.ThrowsAsync <SecurityException>(() => GuardAppContributors.CanAssign(contributors_0, command, users, appPlan)));
}
public Task CanAssign_should_throw_exception_if_permission_not_valid()
{
var command = new AssignContributor {
ContributorId = "1", Permission = (AppContributorPermission)10
};
return(Assert.ThrowsAsync <ValidationException>(() => GuardAppContributors.CanAssign(contributors_0, command, users, appPlan)));
}
protected Task On(AssignContributor command, CommandContext context)
{
return(handler.UpdateSyncedAsync <AppDomainObject>(context, async a =>
{
await GuardAppContributors.CanAssign(a.Snapshot.Contributors, command, userResolver, appPlansProvider.GetPlan(a.Snapshot.Plan?.PlanId));
a.AssignContributor(command);
}));
}
public Task CanAssign_should_throw_exception_if_role_not_valid()
{
var command = new AssignContributor {
ContributorId = "1", Role = "Invalid"
};
return(ValidationAssert.ThrowsAsync(() => GuardAppContributors.CanAssign(contributors_0, command, users, appPlan, roles),
new ValidationError("Role is not a valid value.", "Role")));
}
public Task CanAssign_should_throw_exception_if_user_already_exists_with_same_permission()
{
var command = new AssignContributor {
ContributorId = "1"
};
var contributors_1 = contributors_0.Assign("1", AppContributorPermission.Owner);
return(Assert.ThrowsAsync <ValidationException>(() => GuardAppContributors.CanAssign(contributors_1, command, users, appPlan)));
}
public async Task CanAssign_should_not_throw_exception_if_user_already_exists_with_some_role_but_is_from_restore()
{
var command = new AssignContributor {
ContributorId = "1", Role = Role.Owner, Restoring = true
};
var contributors_1 = contributors_0.Assign("1", Role.Owner);
await GuardAppContributors.CanAssign(contributors_1, roles, command, users, appPlan);
}
public async Task CanAssign_should_not_throw_exception_if_contributor_has_another_role()
{
var command = new AssignContributor {
ContributorId = "1"
};
var contributors_1 = contributors_0.Assign("1", Role.Developer);
await GuardAppContributors.CanAssign(contributors_1, roles, command, users, appPlan);
}
public AppDomainObject AssignContributor(AssignContributor command)
{
Guard.Valid(command, nameof(command), () => "Cannot assign contributor");
ThrowIfNotCreated();
RaiseEvent(SimpleMapper.Map(command, new AppContributorAssigned()));
return(this);
}
public Task CanAssign_should_not_throw_exception_if_contributor_has_another_permission()
{
var command = new AssignContributor {
ContributorId = "1"
};
var contributors_1 = contributors_0.Assign("1", AppContributorPermission.Editor);
return(GuardAppContributors.CanAssign(contributors_1, command, users, appPlan));
}
public Task CanAssign_should_not_throw_exception_if_contributor_has_another_role()
{
var command = new AssignContributor {
ContributorId = "1", Role = Role.Developer
};
var contributors_1 = contributors_0.Assign("1", Role.Editor);
return(GuardAppContributors.CanAssign(contributors_1, command, users, appPlan, roles));
}
public async Task CanAssign_should_not_throw_exception_if_user_already_exists_with_same_role()
{
var command = new AssignContributor {
ContributorId = "1", Role = Role.Owner
};
var contributors_1 = contributors_0.Assign("1", Role.Owner);
await GuardAppContributors.CanAssign(command, App(contributors_1), users, appPlan);
}
public async Task CanAssign_assign_if_if_user_added_by_email()
{
var command = new AssignContributor {
ContributorId = "*****@*****.**"
};
await GuardAppContributors.CanAssign(contributors_0, command, users, appPlan, roles);
Assert.Equal("1", command.ContributorId);
}
public Task CanAssign_should_throw_exception_if_user_not_found()
{
A.CallTo(() => users.FindByIdAsync(A <string> .Ignored))
.Returns(Task.FromResult <IUser>(null));
var command = new AssignContributor {
ContributorId = "1", Permission = (AppContributorPermission)10
};
return(Assert.ThrowsAsync <ValidationException>(() => GuardAppContributors.CanAssign(contributors_0, command, users, appPlan)));
}
public async Task CanAssign_should_not_throw_exception_if_user_found()
{
A.CallTo(() => appPlan.MaxContributors)
.Returns(-1);
var command = new AssignContributor {
ContributorId = "1"
};
await GuardAppContributors.CanAssign(contributors_0, roles, command, users, appPlan);
}
public Task CanAssign_should_throw_exception_if_user_already_exists_with_same_role()
{
var command = new AssignContributor {
ContributorId = "1", Role = Role.Owner
};
var contributors_1 = contributors_0.Assign("1", Role.Owner);
return(ValidationAssert.ThrowsAsync(() => GuardAppContributors.CanAssign(contributors_1, command, users, appPlan, roles),
new ValidationError("Contributor has already this role.", "Role")));
}
public async Task Should_not_calls_user_resolver_if_not_email()
{
var command = new AssignContributor {
ContributorId = "123", IsInviting = true
};
var context = new CommandContext(command, commandBus);
await sut.HandleAsync(context);
A.CallTo(() => userResolver.CreateUserIfNotExists(A <string> .Ignored))
.MustNotHaveHappened();
}
protected async Task On(AssignContributor command, CommandContext context)
{
if (await userRepository.FindUserByIdAsync(command.ContributorId) == null)
{
var error =
new ValidationError("Cannot find contributor the contributor",
nameof(AssignContributor.ContributorId));
throw new ValidationException("Cannot assign contributor to app", error);
}
await handler.UpdateAsync <AppDomainObject>(context, a => a.AssignContributor(command));
}
public static Task CanAssign(AppContributors contributors, Roles roles, AssignContributor command, IUserResolver users, IAppLimitsPlan plan)
{
Guard.NotNull(command, nameof(command));
return(Validate.It(() => "Cannot assign contributor.", async e =>
{
if (!roles.ContainsKey(command.Role))
{
e(Not.Valid("role"), nameof(command.Role));
}
if (string.IsNullOrWhiteSpace(command.ContributorId))
{
e(Not.Defined("Contributor id"), nameof(command.ContributorId));
}
else
{
var user = await users.FindByIdOrEmailAsync(command.ContributorId);
if (user == null)
{
throw new DomainObjectNotFoundException(command.ContributorId, "Contributors", typeof(IAppEntity));
}
command.ContributorId = user.Id;
if (!command.IsRestore)
{
if (string.Equals(command.ContributorId, command.Actor?.Identifier, StringComparison.OrdinalIgnoreCase))
{
throw new DomainForbiddenException("You cannot change your own role.");
}
if (contributors.TryGetValue(command.ContributorId, out var role))
{
if (role == command.Role)
{
e(Not.New("Contributor", "role"), nameof(command.Role));
}
}
else
{
if (plan.MaxContributors > 0 && contributors.Count >= plan.MaxContributors)
{
e("You have reached the maximum number of contributors for your plan.");
}
}
}
}
}));
}
public Task CanAssign_should_throw_exception_if_contributor_max_reached()
{
A.CallTo(() => appPlan.MaxContributors)
.Returns(2);
var command = new AssignContributor {
ContributorId = "3"
};
var contributors_1 = contributors_0.Assign("1", AppContributorPermission.Owner);
var contributors_2 = contributors_1.Assign("2", AppContributorPermission.Editor);
return(Assert.ThrowsAsync <ValidationException>(() => GuardAppContributors.CanAssign(contributors_2, command, users, appPlan)));
}
public async Task CanAssign_should_not_throw_exception_if_contributor_max_reached_but_from_restore()
{
A.CallTo(() => appPlan.MaxContributors)
.Returns(2);
var command = new AssignContributor {
ContributorId = "3", Restoring = true
};
var contributors_1 = contributors_0.Assign("1", Role.Editor);
var contributors_2 = contributors_1.Assign("2", Role.Editor);
await GuardAppContributors.CanAssign(contributors_2, roles, command, users, appPlan);
}
public Task CanAssign_should_not_throw_exception_if_contributor_max_reached_but_role_changed()
{
A.CallTo(() => appPlan.MaxContributors)
.Returns(2);
var command = new AssignContributor {
ContributorId = "1", Role = Role.Developer
};
var contributors_1 = contributors_0.Assign("1", Role.Editor);
var contributors_2 = contributors_1.Assign("2", Role.Editor);
return(GuardAppContributors.CanAssign(contributors_2, command, users, appPlan, roles));
}
