public override IEnumerable <Team> Execute(GetUserOwnedTeamsQuery query, ICommandAndQueryDispatcher dispatcher)
{
return(db.Teams
.Include(x => x.Owner)
.Include(x => x.Members.Select(m => m.User))
.Where(x => x.Owner.Id == query.UserId).ToList());
}
private void SetupContainer()
{
AutoMapperConfig.RegisterMappings();
var container = new Container();
container.RegisterSingle(() => new ApplicationDb());
container.RegisterSingle <IUserStore <ApplicationUser>, ApplicationUserStore>();
container.RegisterSingle <UserManager <ApplicationUser> >();
//Register all of our Command and Query handlers in the application
IEnumerable <Type> commandHandlerTypes =
typeof(CreateNewTeamCommandHandler).Assembly.GetTypes()
.Where(x => typeof(ICommandHandler).IsAssignableFrom(x));
IEnumerable <Type> queryHandlerTypes =
typeof(GetAllTeamsQueryHandler).Assembly.GetTypes()
.Where(x => typeof(IQueryHandler).IsAssignableFrom(x));
container.RegisterAll <ICommandHandler>(commandHandlerTypes);
container.RegisterAll <IQueryHandler>(queryHandlerTypes);
//Register the command and query dispatcher
container.Register <ICommandAndQueryDispatcher, CommandAndQueryDispatcher>();
container.Verify();
dispatcher = container.GetInstance <ICommandAndQueryDispatcher>();
db = container.GetInstance <ApplicationDb>();
userManager = container.GetInstance <UserManager <ApplicationUser> >();
context.TeamController = new TeamController(dispatcher);
context.HomeController = new HomeController(dispatcher);
context.Dispatcher = dispatcher;
context.UserManager = userManager;
context.Db = db;
}
public override void Execute(DeleteTeamCommand command, ICommandAndQueryDispatcher dispatcher)
{
Team team = dispatcher.ExecuteQuery(new GetTeamByIdQuery(command.TeamId));
if (CurrentUserCanDeleteTeams(team, dispatcher))
{
db.Teams.Remove(team);
db.SaveChanges();
}
}
public override IEnumerable <Team> Execute(GetTeamsUserDoesNotBelongToQuery query,
ICommandAndQueryDispatcher dispatcher)
{
return(db.Teams
.Include(x => x.Owner)
.Include(x => x.Members.Select(m => m.User))
.Where(x => x.Owner.Id != query.UserId
&&
!x.Members.Select(m => m.User.Id)
.Contains(query.UserId))
.ToList());
}
public override void Execute(JoinTeamCommand command, ICommandAndQueryDispatcher dispatcher)
{
var teamQuery = new GetTeamByIdQuery(command.TeamId);
Team team = dispatcher.ExecuteQuery(teamQuery);
if (UserIsNotAMemberOfTeam(command.GetUserId, team))
{
var userQuery = new GetUserByIdQuery(command.GetUserId);
team.Members.Add(new TeamMembership(dispatcher.ExecuteQuery(userQuery), MembershipStatus.Pending));
}
db.SaveChanges();
}
public override Team Execute(GetTeamByIdQuery query, ICommandAndQueryDispatcher dispatcher)
{
Team team = db.Teams
.Include(x => x.Owner)
.Include(x => x.Members.Select(m => m.User))
.FirstOrDefault(t => t.Id == query.TeamId);
if (team == null)
{
throw new CommandExecutionException(CommandExecutionExceptionMessages.TeamDoesNotExist(query.TeamId));
}
return(team);
}
public override IEnumerable <Team> Execute(GetUserConfirmedTeamsQuery query,
ICommandAndQueryDispatcher dispatcher)
{
return(db.Teams
.Include(x => x.Owner)
.Include(x => x.Members.Select(m => m.User))
.Where(
x =>
x.Owner.Id == query.UserId ||
x.Members.Where(m => m.Status == MembershipStatus.Confimed)
.Select(m => m.User.Id)
.Contains(query.UserId))
.ToList());
}
private static bool CurrentUserCanDeleteTeams(Team team, ICommandAndQueryDispatcher dispatcher)
{
if (!team.Owner.IsCurrentUser())
{
ApplicationUser user =
dispatcher.ExecuteQuery(new GetUserByIdQuery(Thread.CurrentPrincipal.Identity.GetUserId()));
if (!user.IsInRole(RoleName.TeamManagement))
{
return(false);
}
}
return(true);
}
public override void Execute(RemoveUserFromTeamCommand command, ICommandAndQueryDispatcher dispatcher)
{
Team team = dispatcher.ExecuteQuery(new GetTeamByIdQuery(command.TeamId));
if (CurrentUserIsAllowedToRemoveTargetUser(command, team))
{
TeamMembership membership = team.Members.SingleOrDefault(m => m.User.Id == command.UserId);
if (membership != null)
{
team.Members.Remove(membership);
}
db.SaveChanges();
}
}
public override void Execute(UpdateMembershipStatusCommand command, ICommandAndQueryDispatcher dispatcher)
{
var getTeamQuery = new GetTeamByIdQuery(command.TeamId);
Team team = dispatcher.ExecuteQuery(getTeamQuery);
if (!team.Owner.IsCurrentUser())
{
throw new InvalidOperationException("Only the owner of the team can update the membership status");
}
TeamMembership teamMembership = team.Members.Single(m => m.User.Id == command.UserIdToUpdate);
teamMembership.Status = command.NewStatus;
db.SaveChanges();
}
public override void Execute(CreateNewTeamCommand command, ICommandAndQueryDispatcher dispatcher)
{
if (!command.TeamName.HasValue)
{
throw new ArgumentException("The team name was invalid, it cannot be blank.");
}
var teamExistsQuery = new GetUserOwnedTeamsQuery(command.TeamOwnerId.Id);
if (dispatcher.ExecuteQuery(teamExistsQuery).Any(t => t.Name == command.TeamName.Value))
{
//team with this name already exists, so we can't add a new one
throw new ArgumentException(
string.Format("The team name was invalid. A team called '{0}' already exists.",
command.TeamName.Value));
}
var team = new Team(command.TeamName.Value, command.TeamOwnerId);
db.Teams.Add(team);
db.SaveChanges();
command.TeamId = team.Id;
}
public override IEnumerable <PendingMembershipResult> Execute(GetPendingMembershipsForUsersTeamsQuery query,
ICommandAndQueryDispatcher dispatcher)
{
var pendingMemberships =
db.Teams.Where(
t => t.Owner.Id == query.UserId && t.Members.Any(m => m.Status == MembershipStatus.Pending))
.SelectMany(
t =>
t.Members.Where(m => m.Status == MembershipStatus.Pending)
.Select(m => new { UserId = m.User.Id, TeamId = t.Id, m.User.UserName, TeamName = t.Name }))
.ToList();
return
(pendingMemberships.Select(
pendingMembership =>
new PendingMembershipResult
{
UserId = pendingMembership.UserId,
TeamId = pendingMembership.TeamId,
UserName = pendingMembership.UserName,
TeamName = pendingMembership.TeamName
}).ToList());
}
public override ApplicationUser Execute(GetUserByIdQuery query, ICommandAndQueryDispatcher dispatcher)
{
return(db.Users.Find(query.GetUserId));
}
public abstract void Execute(TCommand command, ICommandAndQueryDispatcher dispatcher);
/// <summary>
/// This method simply casts the command to the expected type and calls the abstract execute method.
/// </summary>
/// <param name="command">The command to execute, whcih should be an object of type ICommand</param>
/// <param name="dispatcher"></param>
public void Execute(object command, ICommandAndQueryDispatcher dispatcher)
{
Execute((TCommand)command, dispatcher);
}
public override void Execute(T command, ICommandAndQueryDispatcher dispatcher)
{
commandExecuted = command;
}
public abstract TResult Execute(TQuery query, ICommandAndQueryDispatcher dispatcher);
public object Execute(object query, ICommandAndQueryDispatcher dispatcher)
{
return(Execute((TQuery)query, dispatcher));
}
public override TResult Execute(T query, ICommandAndQueryDispatcher dispatcher)
{
QueryExecuted = query;
return(expectedResult);
}
public TeamController(ICommandAndQueryDispatcher dispatcher)
{
this.dispatcher = dispatcher;
}
