public async Task <UserEnvelope> Handle(Command message, CancellationToken cancellationToken)
{
if (await _context.Users.AnyAsync(x => x.Email.Equals(message.User.Email), cancellationToken))
{
throw new RestException(HttpStatusCode.BadRequest, new { Email = $"The Email '{message.User.Email}' is already taken" });
}
var salt = Guid.NewGuid().ToByteArray();
var user = new User
{
Name = message.User.Name,
Email = message.User.Email,
Hash = _passwordHasher.Hash(message.User.Password, salt),
Salt = salt
};
_context.Users.Add(user);
await _context.SaveChangesAsync(cancellationToken);
var person = _mapper.Map <User, PublicUser>(user);
person.Token = await _jwtTokenGenerator.CreateToken(person.Name);
return(new UserEnvelope(person));
}
public async Task <BoardEnvelope> Handle(Command request, CancellationToken cancellationToken)
{
if (await _context.Boards.AnyAsync(x => x.Name == request.Board.Name, cancellationToken))
{
throw new RestException(HttpStatusCode.BadRequest, new { Name = Constants.IN_USE });
}
var owner = await _context.Users.SingleOrDefaultAsync(t =>
t.Email.Equals(_currentUserAccessor.GetCurrentUserEmail()), cancellationToken);
if (owner == null)
{
throw new RestException(HttpStatusCode.NotFound, new { User = Constants.NOT_FOUND });
}
var board = new Board()
{
Name = request.Board.Name, OwnerId = owner.Id
};
await _context.Boards.AddAsync(board, cancellationToken);
await _context.UserBoards.AddAsync(new UserBoard()
{
BoardId = board.Id, UserId = owner.Id
},
cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
return(new BoardEnvelope(board));
}
public async Task <UserEnvelope> Handle(Command message, CancellationToken cancellationToken)
{
var currentUserEmail = _currentUserAccessor.GetCurrentUserEmail();
var user = await _context.Users.SingleOrDefaultAsync(x => x.Email == currentUserEmail, cancellationToken);
if (user == null)
{
throw new RestException(HttpStatusCode.NotFound, new { User = Constants.NOT_FOUND });
}
user.Name = message.User.Name ?? user.Name;
user.Email = message.User.Email ?? user.Email;
user.Biography = message.User.Biography ?? user.Biography;
if (!string.IsNullOrWhiteSpace(message.User.Password))
{
var salt = Guid.NewGuid().ToByteArray();
user.Hash = _passwordHasher.Hash(message.User.Password, salt);
user.Salt = salt;
}
await _context.SaveChangesAsync(cancellationToken);
return(new UserEnvelope(_mapper.Map <User, PublicUser>(user)));
}
public static async Task <Guid> CreateTask(TasksBoardContext context, Guid userId, Guid columnId,
string header = "header",
string description = "desc",
List <Guid> assignedUsers = null)
{
var task = new Backend.Domain.Task
{
ColumnId = columnId,
OwnerId = userId,
Header = header,
Description = description,
OrderNum = context.Tasks.Any() ? context.Tasks.Max(t => t.OrderNum) + 1 : default
};
await context.Tasks.AddAsync(task);
await context.UserTasks.AddAsync(new UserTask { TaskId = task.Id, UserId = userId });
assignedUsers?.ForEach(t => context.UserTasks.Add(new UserTask {
TaskId = task.Id, UserId = t
}));
await context.SaveChangesAsync();
return(task.Id);
}
public async Task <ColumnEnvelope> Handle(Command request, CancellationToken cancellationToken)
{
var column =
await _context.Columns
.Include(t => t.Tasks)
.SingleOrDefaultAsync(t => t.Id == request.ColumnId, cancellationToken);
if (column == null)
{
throw new RestException(HttpStatusCode.NotFound, new { Column = Constants.NOT_FOUND });
}
column.Header = request.Column.Header ?? column.Header;
column.Color = request.Column.Color ?? column.Color;
column.OrderNum = request.Column.OrderNum ?? column.OrderNum;
if (request.Column.RemovedTasks?.Any() == true)
{
await HandleTasks(request.Column.RemovedTasks, t => column.Tasks.Remove(t), cancellationToken);
}
if (request.Column.AddedTasks?.Any() == true)
{
await HandleTasks(request.Column.AddedTasks, t => column.Tasks.Add(t), cancellationToken);
}
await _context.SaveChangesAsync(cancellationToken);
column.Tasks = column.Tasks.OrderBy(t => t.OrderNum).ToList();
return(new ColumnEnvelope(column));
}
public async Task <ColumnEnvelope> Handle(Command request, CancellationToken cancellationToken)
{
var owner = await _context.Users.SingleOrDefaultAsync(
t => t.Email.Equals(_currentUserAccessor.GetCurrentUserEmail()), cancellationToken);
if (owner == null)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = Constants.NOT_FOUND });
}
var board = await _context.Boards
.Include(t => t.Columns)
.SingleOrDefaultAsync(t => t.Id == request.Column.BoardId, cancellationToken);
if (board == null)
{
throw new RestException(HttpStatusCode.BadRequest, new { Board = Constants.NOT_FOUND });
}
var column = new Column()
{
BoardId = request.Column.BoardId,
Color = request.Column.Color,
Header = request.Column.Header,
OwnerId = owner.Id,
OrderNum = board.Columns.GetNextOrderNum(),
};
await _context.Columns.AddAsync(column, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
return(new ColumnEnvelope(column));
}
public static async Task <Guid> CreateColumn(TasksBoardContext context, Guid userId, string boardName = "board",
string columnHeader = "column")
{
var board = new Board {
Name = boardName, OwnerId = userId
};
await context.Boards.AddAsync(board);
await context.SaveChangesAsync();
var column = new Column {
Header = columnHeader, BoardId = board.Id, OwnerId = userId
};
await context.Columns.AddAsync(column);
await context.SaveChangesAsync();
return(column.Id);
}
public static async Task AddTasksTo(TasksBoardContext context, Guid columnId, IEnumerable <Guid> taskIds)
{
var column = await context.Columns.Include(t => t.Tasks).SingleOrDefaultAsync(t => t.Id == columnId);
var tasks = context.Tasks.Where(t => taskIds.Contains(t.Id));
await tasks.ForEachAsync(t => column.Tasks.Add(t));
await context.SaveChangesAsync();
}
public async Task <BoardEnvelope> Handle(Command request, CancellationToken cancellationToken)
{
var board = await _context.Boards
.Include(t => t.Columns)
.ThenInclude(t => t.Tasks)
.Include(t => t.UserBoards)
.ThenInclude(t => t.User)
.SingleOrDefaultAsync(t => t.Id == request.BoardId, cancellationToken);
if (board == null)
{
throw new RestException(HttpStatusCode.NotFound, new { Board = Constants.NOT_FOUND });
}
board.Name = request.Board.Name ?? board.Name;
if (request.Board.RemovedColumns?.Any() == true)
{
await HandleColumns(request.Board.RemovedColumns, t => board.Columns.Remove(t), cancellationToken);
}
if (request.Board.AddedColumns?.Any() == true)
{
await HandleColumns(request.Board.AddedColumns, board.Columns.Add, cancellationToken);
}
if (request.Board.AddedUsers?.Any() == true)
{
var addedUsers = _context.Users
.Where(t => request.Board.AddedUsers.Contains(t.Email));
await addedUsers.ForEachAsync(t =>
board.UserBoards.Add(new UserBoard()
{
BoardId = board.Id, UserId = t.Id
}), cancellationToken);
}
if (request.Board.RemovedUsers?.Any() == true)
{
var removedUsers = board.UserBoards
.Where(t => request.Board.RemovedUsers.Contains(t.User.Email))
.ToList();
foreach (var removedUser in removedUsers)
{
board.UserBoards.Remove(removedUser);
}
}
await _context.SaveChangesAsync(cancellationToken);
board.Columns = board.Columns.OrderBy(t => t.OrderNum).ToList();
return(new BoardEnvelope(board));
}
public static async Task AssignUsers(TasksBoardContext context, Guid taskId, List <Guid> userIds)
{
var task = await context.Tasks.Include(t => t.AssignedUsers).FirstOrDefaultAsync(t => t.Id == taskId);
var users = context.Users.Where(t => userIds.Contains(t.Id)).ToList();
users.ForEach(t => task.AssignedUsers.Add(new UserTask {
TaskId = taskId, UserId = t.Id
}));
await context.SaveChangesAsync();
}
public static async Task <Guid> CreateBoard(TasksBoardContext context, Guid userId, string boardName = "board")
{
var board = new Board {
Name = boardName, OwnerId = userId
};
await context.Boards.AddAsync(board);
await context.SaveChangesAsync();
return(board.Id);
}
public static async Task AddUserBoards(TasksBoardContext context, Guid boardId, IEnumerable <Guid> userIds)
{
var board = await context.Boards.Include(t => t.UserBoards).FirstOrDefaultAsync(t => t.Id == boardId);
var users = context.Users.Where(t => userIds.Contains(t.Id)).ToList();
users.ForEach(t => board.UserBoards.Add(new UserBoard()
{
BoardId = boardId, UserId = t.Id
}));
await context.SaveChangesAsync();
}
public static async Task <Guid> CreateColumn(TasksBoardContext context, Guid userId, Guid boardId,
string columnHeader = "header", string columnColor = "color")
{
var column = new Column
{
Header = columnHeader,
BoardId = boardId,
OwnerId = userId,
Color = columnColor
};
await context.Columns.AddAsync(column);
await context.SaveChangesAsync();
return(column.Id);
}
public static async Task <List <Column> > CreateColumns(TasksBoardContext context, Guid userId, Guid boardId, int columnsCount)
{
var columns = new List <Column>();
for (int i = 0; i < columnsCount; i++)
{
columns.Add(new Column
{
OwnerId = userId,
BoardId = boardId,
Header = $"header{i}",
});
}
await context.Columns.AddRangeAsync(columns);
await context.SaveChangesAsync();
return(columns.ToList());
}
public async Task <Unit> Handle(Command request, CancellationToken cancellationToken)
{
var board = await _context.Boards
.Include(t => t.Owner)
.SingleOrDefaultAsync(t => t.Id == request.BoardId, cancellationToken);
if (board == null)
{
throw new RestException(HttpStatusCode.NotFound, new { Board = Constants.NOT_FOUND });
}
if (!board.Owner.Email.Equals(_currentUserAccessor.GetCurrentUserEmail()))
{
throw new RestException(HttpStatusCode.BadRequest, new { User = Constants.NO_OWNER });
}
_context.Boards.Remove(board);
await _context.SaveChangesAsync(cancellationToken);
return(Unit.Value);
}
public static async Task <List <Backend.Domain.Task> > CreateTasks(TasksBoardContext context, Guid userId, Guid columnId,
int taskCount)
{
var tasks = new List <Backend.Domain.Task>();
for (int i = 0; i < taskCount; i++)
{
tasks.Add(new Backend.Domain.Task
{
ColumnId = columnId,
OwnerId = userId,
Header = $"header{i}",
Description = $"description{i}"
});
}
await context.Tasks.AddRangeAsync(tasks);
await context.SaveChangesAsync();
return(tasks.ToList());
}
public async Task <TaskEnvelope> Handle(Command request, CancellationToken cancellationToken)
{
var owner = await _context.Users.SingleOrDefaultAsync(t => t.Email.Equals(_userAccessor.GetCurrentUserEmail()), cancellationToken);
if (owner == null)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = Constants.NOT_FOUND });
}
var column = await _context.Columns
.Include(t => t.Tasks)
.SingleOrDefaultAsync(t => t.Id == request.Task.ColumnId, cancellationToken);
if (column == null)
{
throw new RestException(HttpStatusCode.BadRequest, new { Column = Constants.NOT_FOUND });
}
var task = new Task()
{
ColumnId = column.Id,
Header = request.Task.Header,
Description = request.Task.Description,
OrderNum = column.Tasks.GetNextOrderNum(),
OwnerId = owner.Id,
};
await _context.Tasks.AddAsync(task, cancellationToken);
await _context.UserTasks.AddAsync(new UserTask()
{
TaskId = task.Id, UserId = owner.Id
}, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
return(new TaskEnvelope(task));
}