public async Task Handle_BoardIdExists_ReturnsCardsInOrder()
{
var dbName = $"{nameof(GetBoardQueryHandlerTests)}_{nameof(Handle_BoardIdExists_ReturnsCardsInOrder)}";
using var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var boardFactory = new BoardFactory();
var board = boardFactory.Create("board-title");
var card1 = Card.Create("card1-title", 1);
var card2 = Card.Create("card2-title", 0);
board.AddCard(card1);
board.AddCard(card2);
context.Boards.Add(board);
await context.SaveChangesAsync(cancellationToken);
var orderedCardIds = await context.Cards
.Where(c => c.BoardId == board.Id)
.OrderBy(c => c.Order)
.Select(c => c.Id)
.ToListAsync(cancellationToken);
var handler = new GetBoardQueryHandler(context);
var request = new GetBoardQuery(1);
var dto = await handler.Handle(request, cancellationToken);
var dtoCardIds = dto.Cards.Select(c => c.Id).ToList();
Assert.Equal(orderedCardIds, dtoCardIds);
}
public async Task <IActionResult> Board(string id)
{
var query = new GetBoardQuery(id);
var board = await _memstateClient.Execute(query);
return(View(board));
}
public async Task Handle_BoardIdExists_ReturnsBoardUserType()
{
var dbName = $"{nameof(GetBoardQueryHandlerTests)}_{nameof(Handle_BoardIdExists_ReturnsBoardUserType)}";
using var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var boardFactory = new BoardFactory();
var boardUserFactory = new BoardUserFactory();
var userId = "user-id";
var board = boardFactory.Create("board-title");
var boardUser = boardUserFactory.CreateOwner(1, userId);
var boardUserType = boardUser.Type.ToString().ToLower();
context.Boards.Add(board);
context.BoardUsers.Add(boardUser);
await context.SaveChangesAsync(cancellationToken);
var handler = new GetBoardQueryHandler(context);
var request = new GetBoardQuery(1);
var dto = await handler.Handle(request, cancellationToken);
Assert.Equal(boardUserType, dto.BoardUserType);
}
public async Task Handle_BoardIdExists_ReturnDto()
{
var dbName = $"{nameof(GetBoardQueryHandlerTests)}_{nameof(Handle_BoardIdExists_ReturnDto)}";
using var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var boardFactory = new BoardFactory();
var board = boardFactory.Create("board-title");
var card = Card.Create("card-title");
var activity = Activity.Create("activity-title");
board.AddCard(card);
card.AddActivity(activity);
context.Boards.Add(board);
await context.SaveChangesAsync(cancellationToken);
var handler = new GetBoardQueryHandler(context);
var request = new GetBoardQuery(1);
var dto = await handler.Handle(request, cancellationToken);
var dtoCard = dto.Cards.FirstOrDefault();
var dtoActivity = dtoCard.Activities.FirstOrDefault();
Assert.NotNull(dto);
Assert.Equal(1, dto.Id);
Assert.NotNull(dto.Cards);
Assert.Single(dto.Cards);
Assert.Equal(1, dtoCard.Id);
Assert.NotNull(dtoCard.Activities);
Assert.Single(dtoCard.Activities);
Assert.Equal(1, dtoActivity.Id);
}
public async Task <GetBoardByIdResponse> Handle(GetBoardByIdRequest request, CancellationToken cancellationToken)
{
if (request.AuthenticatorRole == AppRole.Employee)
{
return(new GetBoardByIdResponse()
{
Error = new ErrorModel(ErrorType.Unauthorized)
});
}
var query = new GetBoardQuery()
{
Id = request.BoardId
};
var board = await queryExecutor.Execute(query);
if (board == null)
{
return(new GetBoardByIdResponse()
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var mappedBoard = mapper.Map <BoardDto>(board);
return(new GetBoardByIdResponse()
{
Data = mappedBoard
});
}
public async Task ShouldRequireMinimumFields()
{
await SeedTestData();
var command = new GetBoardQuery();
FluentActions.Invoking(() =>
SendAsync(command))
.Should().Throw <ValidationException>();
}
public async Task ShouldNotThrow()
{
await SeedTestData();
var command = new GetBoardQuery()
{
ShortUrl = "tb1"
};
FluentActions.Invoking(() =>
SendAsync(command))
.Should().NotThrow();
}
public async Task ShouldReturnAnyData()
{
await SeedTestData();
var command = new GetBoardQuery()
{
ShortUrl = "tb1"
};
var result = await SendAsync(command);
result.Should().NotBeNull();
}
public async Task Handle_BoardIdNotExists_ThrowsNotFoundApplicationException()
{
var dbName = $"{nameof(GetBoardQueryHandlerTests)}_{nameof(Handle_BoardIdNotExists_ThrowsNotFoundApplicationException)}";
using var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var handler = new GetBoardQueryHandler(context);
var request = new GetBoardQuery(1);
Task <GetBoardDto> action() => handler.Handle(request, cancellationToken);
await Assert.ThrowsAsync <NotFoundApplicationException>(action);
}
public async Task ShouldThrowOnNotExistinUrl()
{
await SeedTestData();
var command = new GetBoardQuery()
{
ShortUrl = "not-existing-url"
};
FluentActions.Invoking(() =>
SendAsync(command))
.Should().Throw <NotFoundException>();
}
public async Task <IViewComponentResult> InvokeAsync(GetArticleModel articleModel, string imageDataUrl, bool displayText = false)
{
// TODO: test with deleted boards
var getBoardQuery = new GetBoardQuery(articleModel.BoardId);
GetBoardModel board = await getBoardQuery.DefaultIfExceptionAsync(_mediator);
// TODO: returns null, which throws exception in view, if user is deleted
var getuserQuery = new GetPublicUserQuery(articleModel.UserId);
GetPublicUserModel user = await getuserQuery.DefaultIfExceptionAsync(_mediator);
string jwt = _apiJwtManager.GetToken();
bool loggedIn = false;
bool saved = false;
bool userUpvoted = false;
bool userDownvoted = false;
bool userCreatedArticle = false;
try
{
var loggedInUser = await _mediator.Send(new GetAuthenticatedUserQuery());
if (loggedInUser != null)
{
loggedIn = true;
}
saved = loggedInUser.SavedArticles.Any(articleId => articleId == articleModel.Id);
userUpvoted = loggedInUser.LikedArticles.Any(articleId => articleId == articleModel.Id);
userDownvoted = loggedInUser.DislikedArticles.Any(articleId => articleId == articleModel.Id);
userCreatedArticle = loggedInUser.ArticleIds.Any(articleId => articleId == articleModel.Id);
}
catch { }
var viewModel = new ArticleCardViewModel
{
Article = articleModel,
Board = board,
User = user,
Jwt = jwt,
LoggedIn = loggedIn,
Saved = saved,
UserUpvoted = userUpvoted,
UserDownvoted = userDownvoted,
UserCreatedArticle = userCreatedArticle,
ImageDataUrl = imageDataUrl,
DisplayText = displayText,
BaseUrl = _baseUrl
};
return(View(viewModel));
}
public async Task <ViewResult> Details(int id, PagingParams pagingParams)
{
var articleModel = await Mediator.Send(new GetArticleQuery(id));
var getArticleCommentsQuery = new GetCommentsByIdsQuery(articleModel.CommentIds, pagingParams);
var articleComments = await getArticleCommentsQuery.DefaultIfExceptionAsync(Mediator);
var getBoardQuery = new GetBoardQuery(articleModel.BoardId);
GetBoardModel board = await getBoardQuery.DefaultIfExceptionAsync(Mediator);
var getUserQuery = new GetPublicUserQuery(articleModel.UserId);
GetPublicUserModel user = await getUserQuery.DefaultIfExceptionAsync(Mediator);
var privateUser = await new GetAuthenticatedUserQuery().DefaultIfExceptionAsync(Mediator);
var loggedIn = privateUser != null && privateUser.Id != 0;
var savedArticle = loggedIn && privateUser.SavedArticles.Contains(id);
var wroteArticle = loggedIn && privateUser.ArticleIds.Contains(id);
string imageDataURL = "";
if (articleModel.AssociatedImageId > 0)
{
GetImageModel img = await Mediator.Send(new GetImageByIdQuery(articleModel.AssociatedImageId));
imageDataURL = _imageDataHelper.ConvertImageDataToDataUrl(img.ImageData, img.ContentType);
}
var viewModel = new ArticleDetailsViewModel
{
Article = articleModel,
Board = board,
CommentPage = new FrontendPage <GetCommentModel>(articleComments),
LoggedIn = loggedIn,
User = user,
UserSavedArticle = savedArticle,
UserWroteArticle = wroteArticle,
AssociatedImageDataUrl = imageDataURL
};
return(View(viewModel));
}
public async Task <PutBoardByIdResponse> Handle(PutBoardByIdRequest request, CancellationToken cancellationToken)
{
if (request.AuthenticatorRole == AppRole.Employee)
{
return(new PutBoardByIdResponse()
{
Error = new ErrorModel(ErrorType.Unauthorized)
});
}
var query = new GetBoardQuery()
{
Id = request.Id
};
var query2 = new GetEmployeeQuery()
{
Id = request.EmployeeId
};
var board = await queryExecutor.Execute(query);
var employee = await queryExecutor.Execute(query2);
if (board == null || employee == null)
{
return(new PutBoardByIdResponse()
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var updateBoard = mapper.Map <Board>(request);
var command = new PutBoardCommand
{
Parameter = updateBoard
};
var updatedBoard = await commandExecutor.Execute(command);
var response = mapper.Map <BoardDto>(updatedBoard);
return(new PutBoardByIdResponse
{
Data = response
});
}
public async Task <PutAssignmentByIdResponse> Handle(PutAssignmentByIdRequest request, CancellationToken cancellationToken)
{
var query = new GetBoardQuery()
{
Id = request.BoardId
};
var query2 = new GetCustomerQuery()
{
Id = request.CustomerId,
CompanyId = request.AuthenticatorCompanyId
};
var query3 = new GetAssignmentQuery()
{
Id = request.Id
};
var board = await queryExecutor.Execute(query);
var customer = await queryExecutor.Execute(query2);
var assignment = await queryExecutor.Execute(query3);
if (board == null || customer == null || assignment == null)
{
return(new PutAssignmentByIdResponse()
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var updateAssignment = mapper.Map <Assignment>(request);
var command = new PutAssignmentCommand
{
Parameter = updateAssignment
};
var updatedAssignment = await commandExecutor.Execute(command);
var response = mapper.Map <AssignmentDto>(updatedAssignment);
return(new PutAssignmentByIdResponse
{
Data = response
});
}
public async Task <AddAssignmentResponse> Handle(AddAssignmentRequest request, CancellationToken cancellationToken)
{
var query = new GetBoardQuery()
{
Id = request.BoardId
};
var query2 = new GetCustomerQuery()
{
Id = request.CustomerId,
CompanyId = request.AuthenticatorCompanyId
};
var board = await queryExecutor.Execute(query);
var customer = await queryExecutor.Execute(query2);
if (board == null || customer == null)
{
return(new AddAssignmentResponse()
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var assignment = mapper.Map <Assignment>(request);
var command = new AddAssignmentCommand()
{
Parameter = assignment
};
var assignmentFromDb = await this.commandExecutor.Execute(command);
assignmentFromDb.Board.AssignmentList = null;
assignmentFromDb.Customer.AssignmentList = null;
return(new AddAssignmentResponse()
{
Data = mapper.Map <AssignmentDto>(assignmentFromDb)
});
}
public async Task <DeleteBoardByIdResponse> Handle(DeleteBoardByIdRequest request, CancellationToken cancellationToken)
{
if (request.AuthenticatorRole == AppRole.Employee)
{
return(new DeleteBoardByIdResponse()
{
Error = new ErrorModel(ErrorType.Unauthorized)
});
}
var query = new GetBoardQuery()
{
Id = request.BoardId
};
var board = await queryExecutor.Execute(query);
if (board == null)
{
return(new DeleteBoardByIdResponse()
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var command = new DeleteBoardCommand()
{
Parameter = board
};
var deletedBoard = await commandExecutor.Execute(command);
return(new DeleteBoardByIdResponse
{
Data = deletedBoard
});
}
public async Task <IViewComponentResult> InvokeAsync(GetCommentModel commentModel)
{
// TODO: test with deleted boards
var getBoardQuery = new GetBoardQuery(commentModel.BoardId);
var board = await getBoardQuery.DefaultIfExceptionAsync(_mediator);
var getArticleQuery = new GetArticleQuery(commentModel.ParentArticleId);
GetArticleModel parentArticle = await getArticleQuery.DefaultIfExceptionAsync(_mediator);
var getCommentQuery = new GetCommentQuery(commentModel.ParentCommentId);
GetCommentModel parentComment = await getCommentQuery.DefaultIfExceptionAsync(_mediator);
// TODO: will most likely return null when user is deleted
var getUserQuery = new GetPublicUserQuery(commentModel.UserId);
GetPublicUserModel user = await getUserQuery.DefaultIfExceptionAsync(_mediator);
string jwt = _apiJwtManager.GetToken();
bool loggedIn = false;
bool saved = false;
bool userUpvoted = false;
bool userDownvoted = false;
bool userCreatedComment = false;
try
{
var loggedInUser = await _mediator.Send(new GetAuthenticatedUserQuery());
if (loggedInUser != null)
{
loggedIn = true;
}
saved = loggedInUser.SavedComments.Any(commentId => commentId == commentModel.Id);
userUpvoted = loggedInUser.LikedComments.Any(commentId => commentId == commentModel.Id);
userDownvoted = loggedInUser.DislikedComments.Any(commentId => commentId == commentModel.Id);
userCreatedComment = commentModel.UserId == loggedInUser.Id;
}
catch (System.Exception)
{
loggedIn = false;
}
var model = new CommentCardViewModel
{
Comment = commentModel,
Board = board,
ParentArticle = parentArticle,
ParentComment = parentComment,
User = user,
Jwt = jwt,
LoggedIn = loggedIn,
Saved = saved,
UserUpvoted = userUpvoted,
UserDownvoted = userDownvoted,
UserCreatedComment = userCreatedComment
};
return(View(model));
}
