public IActionResult Error()
{
return(StatusCodeAndDtoWrapper.BuildSuccess(new ErrorDtoResponse
{
RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier
}));
}
public async Task <IActionResult> GetCompleted([FromQuery] int page = 1, [FromQuery] int pageSize = 5)
{
var result = await _todosService.FetchMany(page, pageSize, TodoShow.Completed);
return(StatusCodeAndDtoWrapper.BuildSuccess(TodoListResponse.Build(result.Item2, Request.Path, page,
pageSize, result.Item1)));
}
public async Task <IActionResult> Update([FromBody] CreateOrEditCommentDto dto, [FromRoute] long id, long slug)
{
// we need to load the user in order to let the Handler check it agains the owner if needed
Comment comment = await _commentService.FetchCommentByIdAsync(id, includeUser : true);
if (comment == null)
{
return(StatusCodeAndDtoWrapper.BuildGenericNotFound());
}
var result = await _authorizationService.AuthorizeAsync(User, comment,
_configService.GetDeleteCommentPolicyName());
if (result.Succeeded)
{
int result2 = await _commentService.UpdateAsync(comment, dto);
return(StatusCodeAndDtoWrapper.BuildSuccess(CommentDetailsDto.Build(comment),
"Comment updated successfully"));
//return StatusCodeAndDtoWrapper.BuildSuccess("Comment updated successfully");
}
else
{
return(StatusCodeAndDtoWrapper.BuildUnauthorized("Permission denied"));
}
}
public async Task <IActionResult> Delete([FromRoute] long id, string slug)
{
Comment comment = await _commentService.FetchCommentByIdAsync(id);
if (comment == null)
{
return(StatusCodeAndDtoWrapper.BuildGenericNotFound());
}
var result = await _authorizationService.AuthorizeAsync(User, comment,
_configService.GetDeleteCommentPolicyName());
if (result.Succeeded)
{
if ((await _commentService.DeleteAsync(id)) > 0)
{
return(StatusCodeAndDtoWrapper.BuildSuccess("Comment deleted successfully"));
}
else
{
return(StatusCodeAndDtoWrapper.BuildErrorResponse("An error occured, try later"));
}
}
else
{
throw new PermissionDeniedException();
}
}
public async Task <IActionResult> GetByCategory([FromRoute] string category, int page = 1, int pageSize = 5)
{
Tuple <int, List <Article> > articles = await _articlesService.GetArticlesByCategory(category, pageSize, page);
return(StatusCodeAndDtoWrapper.BuildSuccess(ArticleListDtoResponse.Build(articles.Item2,
"/by_category/{category}", page, pageSize, articles.Item1)));
}
public async Task <IActionResult> GetByCategory([FromRoute] string category, int page = 1, int pageSize = 5)
{
Tuple <int, List <Product> > products = await _productsService.FetchPageByCategory(category, pageSize, page);
return(StatusCodeAndDtoWrapper.BuildSuccess(ProductListDtoResponse.Build(products.Item2,
"/by_category/{category}", page, pageSize, products.Item1)));
}
public async Task <IActionResult> Index()
{
Tuple <int, List <Tag> > tags = await _tagsService.FetchPageWithImages(1, 3);
Tuple <int, List <Category> > categories = await _categoriesService.FetchPageWithImages(1, 3);
return(StatusCodeAndDtoWrapper.BuildSuccess(HomeResponse.Build(tags.Item2, categories.Item2)));
}
public async Task <IActionResult> GetMyLikes([FromQuery] int page = 1, [FromQuery] int pageSize = 5)
{
Tuple <int, List <Like> > likes =
await _likesService.GetUserLikes(await _usersService.GetCurrentUserAsync(), page, pageSize, true, true);
return(StatusCodeAndDtoWrapper.BuildSuccess(LikesListDto.Build(likes.Item2, Request.Path, page, pageSize,
likes.Item1, true)));
}
public async Task <IActionResult> Create([FromBody] CreateOrEditAddressDto dto)
{
var address = await _addressesService.Create(await _usersService.GetCurrentUserAsync(), dto.FirstName,
dto.Lastname, dto.Country, dto.City, dto.StreetAddress, dto.ZipCode);
return(StatusCodeAndDtoWrapper.BuildSuccess(AddressDto.Build(address)));
}
public async Task <HttpResponseMessage> GetCompleted([FromUri] int page = 1, [FromUri] int pageSize = 5)
{
var result = await _todosService.FetchMany(page, pageSize, TodoShow.Completed);
return(StatusCodeAndDtoWrapper.BuildSuccess(TodoListResponse.Build(result.Item2,
Request.RequestUri.LocalPath, page,
pageSize, result.Item1)));
}
public async Task <IActionResult> GetComments(string slug, [FromQuery] int page = 1,
[FromQuery] int pageSize = 5)
{
Tuple <int, List <Comment> > comments = await _commentService.FetchPageByProduct(slug);
return(StatusCodeAndDtoWrapper.BuildSuccess(
CommentListDto.Build(comments.Item2, Request.Path, page, pageSize, comments.Item1)
));
}
public async Task <IActionResult> GetCategories([FromQuery] int page = 1, [FromQuery] int pageSize = 5)
{
var categories = await _categoriesService.FetchPage(page, pageSize);
var basePath = Request.Path;
return(StatusCodeAndDtoWrapper.BuildSuccess(CategoryListDtoResponse.Build(categories.Item2, basePath,
currentPage: page, pageSize: pageSize, totalItemCount: categories.Item1)));
}
public async Task <IActionResult> GetAll([FromQuery] int page = 1, [FromQuery] int pageSize = 5)
{
// Get Orders from current User
long userId = Convert.ToInt64(_usersService.GetCurrentUserId());
Tuple <int, List <Order> > orders = await _orderService.FetchPageFromUser(userId);
return(StatusCodeAndDtoWrapper.BuildSuccess(OrdersListDtoResponse.Build(orders.Item2, Request.Path,
currentPage: page, pageSize: pageSize, totalItemCount: orders.Item1)));
}
public async Task <IActionResult> GetTodoDetails(int id)
{
var todo = await _todosService.GetById(id);
if (todo == null)
{
return(StatusCodeAndDtoWrapper.BuildNotFound("Todo was not found"));
}
return(StatusCodeAndDtoWrapper.BuildSuccess(TodoDetailsDto.Build(todo)));
}
public async Task <IActionResult> Index(
[FromQuery] int page = 1, [FromQuery] int pageSize = 5)
{
var articles = await _articlesService.GetArticles(pageSize, pageSize);
var basePath = Request.Path;
return(StatusCodeAndDtoWrapper.BuildSuccess(ArticleListDtoResponse.Build(articles.Item2, basePath,
currentPage: page, pageSize: pageSize, totalItemCount: articles.Item1)));
}
public async Task <IActionResult> GetTodos([FromQuery] int page = 1, [FromQuery] int pageSize = 5)
{
var result = await _mediator.Send(new GetTodosCommand
{
Page = page, PageSize = pageSize
});
return(StatusCodeAndDtoWrapper.BuildSuccess(TodoListResponse.Build(result.Item2, Request.Path, page,
pageSize, result.Item1)));
}
public async Task <HttpResponseMessage> GetTodoDetails(int id)
{
var todo = await _todosService.GetById(id);
if (todo != null)
{
return(StatusCodeAndDtoWrapper.BuildSuccess(TodoDetailsDto.Build(todo)));
}
return(StatusCodeAndDtoWrapper.BuildNotFound("Requested todo not found"));
}
public async Task <IActionResult> Index(
[FromQuery] int page = 1, [FromQuery] int pageSize = 5)
{
var products = await _productsService.FetchPage(page, pageSize);
var basePath = Request.Path;
return(StatusCodeAndDtoWrapper.BuildSuccess(ProductListDtoResponse.Build(products.Item2, basePath,
currentPage: page, pageSize: pageSize, totalItemCount: products.Item1)));
}
public async Task <IActionResult> GetMyUserSubscriptions([FromQuery] int page = 1, [FromQuery] int pageSize = 5)
{
var result = await _userSubscriptions.GetUserSubscriptions(_usersService.GetCurrentUserId());
List <ApplicationUser> following = result.Item1;
List <ApplicationUser> followers = result.Item2;
int relationsCount = result.Item3;
return(StatusCodeAndDtoWrapper.BuildSuccess(UserSubscriptionsDto.Build(following, followers, relationsCount,
Request.Path, page, pageSize)));
}
public async Task <IActionResult> Index([FromQuery] int page = 1, [FromQuery] int pageSize = 5)
{
var addresses =
await _addressesService.FetchPageByUser(await _usersService.GetCurrentUserAsync(), page,
pageSize);
var basePath = Request.Path;
return(StatusCodeAndDtoWrapper.BuildSuccess(AddressesListDtoResponse.Build(addresses.Item2, basePath,
currentPage: page, pageSize: pageSize, totalItemCount: addresses.Item1)));
}
public async Task <IActionResult> GetTodoDetails(int id)
{
var todo = await _mediator.Send(new GetTodoCommand { Id = id });
if (todo == null)
{
return(StatusCodeAndDtoWrapper.BuildNotFound(id));
}
return(StatusCodeAndDtoWrapper.BuildSuccess(TodoDetailsDto.Build(todo)));
}
public async Task <HttpResponseMessage> UpdateTodo(int id, [FromBody] Todo todo)
{
var todoFromDb = await _todosService.GetProxyById(id);
if (todoFromDb != null)
{
return(StatusCodeAndDtoWrapper.BuildSuccess(
TodoDetailsDto.Build(await _todosService.Update(todoFromDb, todo)),
"Todo Updated Successfully"));
}
return(StatusCodeAndDtoWrapper.BuildNotFound("Todo Was not found"));
}
public async Task <IActionResult> UpdateProduct(string slug, [FromBody] CreateOrEditProduct dto)
{
if (!ModelState.IsValid)
{
return(StatusCodeAndDtoWrapper.BuilBadRequest(ModelState));
}
Product product = await _productsService.Update(slug, dto);
return(StatusCodeAndDtoWrapper.BuildSuccess(ProductDetailsDto.Build(product), "Updated successfully"));
}
public async Task <IActionResult> CreateTag(string name, string description, List <IFormFile> images)
{
// If the user sends `images` POST param then the list<IFormFile> will be populated, if the user sends `images[]` instead, then it will be empty
// this is why I populate that list with this little trick
if (images?.Count == 0)
{
images = Request.Form.Files.GetFiles("images[]").ToList();
}
Tag tag = await _tagsService.Create(name, description, images);
return(StatusCodeAndDtoWrapper.BuildSuccess(TagDto.Build(tag), "Tag created successfully"));
}
public async Task <IActionResult> UpdateArticle(string slug, [FromBody] CreateOrEditArticleDto dto)
{
if (!ModelState.IsValid)
{
return(StatusCodeAndDtoWrapper.BuilBadRequest(ModelState));
}
Article article = await _articlesService.UpdateArticle(slug, dto);
return(StatusCodeAndDtoWrapper.BuildSuccess(ArticleDetailsDto.Build(article), "Updated successfully"));
}
public async Task <IActionResult> DeleteTodo(int id)
{
var todoFromDb = await _todosService.GetProxyById(id);
if (todoFromDb == null)
{
return(StatusCodeAndDtoWrapper.BuildNotFound("Specified Todo was not found"));
}
await _todosService.Delete(id);
return(StatusCodeAndDtoWrapper.BuildSuccess("Todo Deleted Successfully"));
}
public async Task <IActionResult> DeleteTodo(int id)
{
var todoFromDb = await _mediator.Send(new GetTodoCommand { Id = id });
if (todoFromDb == null)
{
return(StatusCodeAndDtoWrapper.BuildNotFound(id));
}
var success = await _mediator.Send(new DeleteTodoCommand { Id = id });
return(StatusCodeAndDtoWrapper.BuildSuccess("Todo Deleted Successfully"));
}
public async Task <IActionResult> CreateTodo([FromBody] Todo todo)
{
var command = new CreateTodoCommand
{
Title = todo.Title,
Description = todo.Description
};
var persistedTodo = await _mediator.Send(command);
return(StatusCodeAndDtoWrapper.BuildSuccess(TodoDetailsDto.Build(persistedTodo),
"Todo Created Successfully"));
}
public async Task <IActionResult> CreateCategory(string name, string description, List <IFormFile> images)
{
// If the user sends `images` POST param then the list<IFormFile> will be populated, if the user sends `images[]` instead, then it will be empty
// this is why I populate that list with this little trick
if (images?.Count == 0)
{
images = Request.Form.Files.GetFiles("images[]").ToList();
}
Category category = await _categoriesService.Create(name, description, images, Convert.ToInt64(_usersService.GetCurrentUserId()));
return(StatusCodeAndDtoWrapper.BuildSuccess(CategoryDto.Build(category), "Category created successfully"));
}
public async Task <IActionResult> UpdateTodo(int id, [FromBody] Todo todo)
{
var todoFromDb = await _todosService.GetProxyById(id);
if (todoFromDb == null)
{
return(StatusCodeAndDtoWrapper.BuildNotFound("Specified Todo was not found"));
}
return(StatusCodeAndDtoWrapper.BuildSuccess(
TodoDetailsDto.Build(await _todosService.Update(todoFromDb, todo)),
"Todo Updated Successfully"));
}