STD-40 | Realize TheoryBlock Controller

server/StudySharp.API/Controllers/TheoryBlockController.cs

@@ -0,0 +1,91 @@
+using System.Threading.Tasks;
+using AutoMapper;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using StudySharp.API.Requests.TheoryBlocks;
+using StudySharp.API.Responses.TheoryBlocks;
+using StudySharp.ApplicationServices.Commands;
+using StudySharp.ApplicationServices.Queries;
+using StudySharp.Domain.General;
+
+namespace StudySharp.API.Controllers
+{
+    [Authorize]
+    [ApiController]
+    [Route("api/courses")]
+
+    public class TheoryBlockController : ControllerBase
+    {
+        private readonly IMediator _mediator;
+        private readonly IMapper _mapper;
+
+        public TheoryBlockController(IMediator mediator, IMapper mapper)
+        {
+            _mapper = mapper;
+            _mediator = mediator;
+        }
+
+        [HttpPost("{courseId:int}/theory-blocks")]
+        public async Task<OperationResult> Add([FromRoute] int courseId, [FromBody] AddTheoryBlockRequest addTheoryBlockRequest)
+        {
+            var addTheoryBlockCommand = _mapper.Map<AddTheoryBlockCommand>(addTheoryBlockRequest);
+            addTheoryBlockCommand.CourseId = courseId;
+            return await _mediator.Send(addTheoryBlockCommand);
+        }
+
+        [HttpDelete("{courseId:int}/theory-blocks/{id:int}")]
+        public async Task<OperationResult> Remove([FromRoute] RemoveTheoryBlockByIdRequest removeTheoryBlockByIdRequest)
+        {
+            var removeTheoryBlockByIdCommand = _mapper.Map<RemoveTheoryBlockByIdCommand>(removeTheoryBlockByIdRequest);
+            return await _mediator.Send(removeTheoryBlockByIdCommand);
+        }
+
+        [HttpGet("{courseId:int}/theory-blocks/{id:int}")]
+        public async Task<OperationResult<GetTheoryBlockByIdResponse>> GetTheoryBlockById([FromRoute] GetTheoryBlockByIdRequest getTheoryBlockByIdRequest)
+        {
+            var getTheoryBlockByIdQuery = _mapper.Map<GetTheoryBlockByIdQuery>(getTheoryBlockByIdRequest);
+            var operationResult = await _mediator.Send(getTheoryBlockByIdQuery);
+
+            if (!operationResult.IsSucceeded)
+            {
+                return OperationResult.Fail<GetTheoryBlockByIdResponse>(operationResult.Errors);
+            }
+
+            var response = _mapper.Map<GetTheoryBlockByIdResponse>(operationResult.Result);
+            return OperationResult.Ok(response);
+        }
+
+        [HttpPut("{courseId:int}/theory-blocks/{id:int}")]
+        public async Task<OperationResult<UpdateTheoryBlockResponse>> Update([FromRoute] int id, [FromRoute] int courseId, [FromBody] UpdateTheoryBlockByIdRequest updateTheoryBlockByIdRequest)
+        {
+            var updateTheoryBlockCommand = _mapper.Map<UpdateTheoryBlockCommand>(updateTheoryBlockByIdRequest);
+            updateTheoryBlockCommand.Id = id;
+            updateTheoryBlockCommand.CourseId = courseId;
+            var operationResult = await _mediator.Send(updateTheoryBlockCommand);
+
+            if (!operationResult.IsSucceeded)
+            {
+                return OperationResult.Fail<UpdateTheoryBlockResponse>(operationResult.Errors);
+            }
+
+            var response = _mapper.Map<UpdateTheoryBlockResponse>(operationResult);
+            return OperationResult.Ok(response);
+        }
+
+        [HttpGet("{courseId:int}/theory-blocks")]
+        public async Task<OperationResult<GetTheoryBlocksByCourseIdResponse>> GetTheoryBlocksByCourseId([FromRoute] GetTheoryBlocksByCourseIdRequest getTheoryBlockByCourseIdRequest)
+        {
+            var getTheoryBlockByCourseIdQuery = _mapper.Map<GetTheoryBlocksByCourseIdQuery>(getTheoryBlockByCourseIdRequest);
+            var operationResult = await _mediator.Send(getTheoryBlockByCourseIdQuery);
+
+            if (!operationResult.IsSucceeded)
+            {
+                return OperationResult.Fail<GetTheoryBlocksByCourseIdResponse>(operationResult.Errors);
+            }
+
+            var response = _mapper.Map<GetTheoryBlocksByCourseIdResponse>(operationResult.Result);
+            return OperationResult.Ok(response);
+        }
+    }
+}

server/StudySharp.API/MapperProfiles/TheoryBlockProfile.cs

@@ -0,0 +1,19 @@
+using AutoMapper;
+using StudySharp.API.Requests.TheoryBlocks;
+using StudySharp.ApplicationServices.Commands;
+using StudySharp.ApplicationServices.Queries;
+
+namespace StudySharp.API.MapperProfiles
+{
+    public class TheoryBlockProfile : Profile
+    {
+        public TheoryBlockProfile()
+        {
+            CreateMap<AddTheoryBlockRequest, AddTheoryBlockCommand>();
+            CreateMap<RemoveTheoryBlockByIdRequest, RemoveTheoryBlockByIdCommand>();
+            CreateMap<GetTheoryBlockByIdRequest, GetTheoryBlockByIdQuery>();
+            CreateMap<UpdateTheoryBlockByIdRequest, UpdateTheoryBlockCommand>();
+            CreateMap<GetTheoryBlocksByCourseIdRequest, GetTheoryBlocksByCourseIdQuery>();
+        }
+    }
+}

server/StudySharp.API/Requests/TheoryBlocks/AddTheoryBlockRequest.cs

@@ -0,0 +1,10 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace StudySharp.API.Requests.TheoryBlocks
+{
+    public class AddTheoryBlockRequest
+    {
+        public string Name { get; set; }
+        public string Description { get; set; }
+    }
+}

server/StudySharp.API/Requests/TheoryBlocks/GetTheoryBlockByIdRequest.cs

@@ -0,0 +1,12 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace StudySharp.API.Requests.TheoryBlocks
+{
+    public class GetTheoryBlockByIdRequest
+    {
+        [BindProperty(Name = "id", SupportsGet = true)]
+        public int Id { get; set; }
+        [BindProperty(Name = "courseId", SupportsGet = true)]
+        public int CourseId { get; set; }
+    }
+}

server/StudySharp.API/Requests/TheoryBlocks/GetTheoryBlocksByCourseIdRequest.cs

@@ -0,0 +1,10 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace StudySharp.API.Requests.TheoryBlocks
+{
+    public class GetTheoryBlocksByCourseIdRequest
+    {
+        [BindProperty(Name = "courseId", SupportsGet = true)]
+        public int CourseId { get; set; }
+    }
+}

server/StudySharp.API/Requests/TheoryBlocks/RemoveTheoryBlockByIdRequest.cs

@@ -0,0 +1,12 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace StudySharp.API.Requests.TheoryBlocks
+{
+    public class RemoveTheoryBlockByIdRequest
+    {
+        [BindProperty(Name = "id", SupportsGet = true)]
+        public int Id { get; set; }
+        [BindProperty(Name = "courseId", SupportsGet = true)]
+        public int CourseId { get; set; }
+    }
+}

server/StudySharp.API/Requests/TheoryBlocks/UpdateTheoryBlockByIdRequest.cs

@@ -0,0 +1,8 @@
+namespace StudySharp.API.Requests.TheoryBlocks
+{
+    public class UpdateTheoryBlockByIdRequest
+    {
+        public string Name { get; set; }
+        public string Description { get; set; }
+    }
+}

server/StudySharp.API/Responses/TheoryBlocks/GetTheoryBlockByIdResponse.cs

@@ -0,0 +1,13 @@
+using StudySharp.Domain.Models;
+
+namespace StudySharp.API.Responses.TheoryBlocks
+{
+    public class GetTheoryBlockByIdResponse
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public string Description { get; set; }
+        public int CourseId { get; set; }
+        public Course Course { get; set; }
+    }
+}

server/StudySharp.API/Responses/TheoryBlocks/GetTheoryBlocksByCourseIdResponse.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using StudySharp.Domain.Models;
+
+namespace StudySharp.API.Responses.TheoryBlocks
+{
+    public class GetTheoryBlocksByCourseIdResponse
+    {
+        public List<TheoryBlock> TheoryBlocks { get; set; }
+    }
+}

server/StudySharp.API/Responses/TheoryBlocks/UpdateTheoryBlockResponse.cs

@@ -0,0 +1,6 @@
+namespace StudySharp.API.Responses.TheoryBlocks
+{
+    public class UpdateTheoryBlockResponse
+    {
+    }
+}

server/StudySharp.ApplicationServices/Commands/AddTheoryBlockCommand.cs

@@ -27,9 +27,13 @@ public AddTheoryBlockCommandHandler(StudySharpDbContext sharpDbContext)
 
         public async Task<OperationResult> Handle(AddTheoryBlockCommand request, CancellationToken cancellationToken)
         {
-            if (await _context.TheoryBlocks.AnyAsync(
-                _ => _.Name.ToLower().Equals(request.Name.ToLower()) && _.CourseId == request.CourseId,
-                cancellationToken))
+            var courseExistent = await _context.Courses.AnyAsync(_ => _.Id == request.CourseId, cancellationToken);
+            if (!courseExistent)
+            {
+                return OperationResult.Fail(string.Format(ErrorConstants.EntityNotFound, nameof(Course), nameof(Course.Id), request.CourseId));
+            }
+
+            if (await _context.TheoryBlocks.AnyAsync(_ => _.Name.ToLower().Equals(request.Name.ToLower()), cancellationToken))
             {
                 return OperationResult.Fail(string.Format(ErrorConstants.EntityAlreadyExists, nameof(TheoryBlock), nameof(TheoryBlock.Name), request.Name));
             }

server/StudySharp.ApplicationServices/Commands/RemoveTheoryBlockByIdCommand.cs

@@ -1,6 +1,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using MediatR;
+using Microsoft.EntityFrameworkCore;
 using StudySharp.Domain.Constants;
 using StudySharp.Domain.General;
 using StudySharp.Domain.Models;
@@ -11,6 +12,7 @@ namespace StudySharp.ApplicationServices.Commands
     public sealed class RemoveTheoryBlockByIdCommand : IRequest<OperationResult>
     {
         public int Id { get; set; }
+        public int CourseId { get; set; }
     }
 
     public sealed class RemoveTheoryBlockByIdCommandHandler : IRequestHandler<RemoveTheoryBlockByIdCommand, OperationResult>
@@ -22,15 +24,19 @@ public RemoveTheoryBlockByIdCommandHandler(StudySharpDbContext sharpDbContext)
             _context = sharpDbContext;
         }
 
-        public async Task<OperationResult> Handle(
-            RemoveTheoryBlockByIdCommand request,
-            CancellationToken cancellationToken)
+        public async Task<OperationResult> Handle(RemoveTheoryBlockByIdCommand request, CancellationToken cancellationToken)
         {
-            var theoryBlock = await _context.TheoryBlocks.FindAsync(request.Id, cancellationToken);
+            var courseExistent = await _context.Courses.AnyAsync(_ => _.Id == request.CourseId, cancellationToken);
+            if (!courseExistent)
+            {
+                return OperationResult.Fail(string.Format(ErrorConstants.EntityNotFound, nameof(Course), nameof(Course.Id), request.CourseId));
+            }
+
+            var theoryBlock = await _context.TheoryBlocks.FirstOrDefaultAsync(_ => _.Id == request.Id, cancellationToken);
 
             if (theoryBlock == null)
             {
-                return OperationResult.Fail(string.Format(ErrorConstants.EntityNotFound, nameof(TheoryBlock), nameof(TheoryBlock.Name), request.Id));
+                return OperationResult.Fail(string.Format(ErrorConstants.EntityNotFound, nameof(TheoryBlock), nameof(TheoryBlock.Id), request.Id));
             }
 
             _context.TheoryBlocks.Remove(theoryBlock);

server/StudySharp.ApplicationServices/Commands/UpdateTheoryBlockCommand.cs

@@ -0,0 +1,51 @@
+using System.Threading;
+using System.Threading.Tasks;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using StudySharp.Domain.Constants;
+using StudySharp.Domain.General;
+using StudySharp.Domain.Models;
+using StudySharp.DomainServices;
+
+namespace StudySharp.ApplicationServices.Commands
+{
+    public sealed class UpdateTheoryBlockCommand : IRequest<OperationResult>
+    {
+        public int Id { get; set; }
+        public int CourseId { get; set; }
+        public string Name { get; set; }
+        public string Description { get; set; }
+    }
+
+    public sealed class UpdateTheoryBlockCommandHandler : IRequestHandler<UpdateTheoryBlockCommand, OperationResult>
+    {
+        private readonly StudySharpDbContext _context;
+
+        public UpdateTheoryBlockCommandHandler(StudySharpDbContext sharpDbContext)
+        {
+            _context = sharpDbContext;
+        }
+
+        public async Task<OperationResult> Handle(UpdateTheoryBlockCommand request, CancellationToken cancellationToken)
+        {
+            var courseExistent = await _context.Courses.AnyAsync(_ => _.Id == request.CourseId, cancellationToken);
+            if (!courseExistent)
+            {
+                return OperationResult.Fail(string.Format(ErrorConstants.EntityNotFound, nameof(Course), nameof(Course.Id), request.CourseId));
+            }
+
+            var theoryBlock = await _context.TheoryBlocks.FirstOrDefaultAsync(_ => _.Id == request.Id, cancellationToken);
+            if (theoryBlock == null)
+            {
+                return OperationResult.Fail(string.Format(ErrorConstants.EntityNotFound, nameof(TheoryBlock), nameof(TheoryBlock.Id), request.Id));
+            }
+
+            theoryBlock.Name = request.Name;
+            theoryBlock.Description = request.Description;
+
+            _context.TheoryBlocks.Update(theoryBlock);
+            await _context.SaveChangesAsync(cancellationToken);
+            return OperationResult.Ok();
+        }
+    }
+}

server/StudySharp.ApplicationServices/Queries/GetTheoryBlockByIdQuery.cs

@@ -1,6 +1,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using MediatR;
+using Microsoft.EntityFrameworkCore;
 using StudySharp.Domain.Constants;
 using StudySharp.Domain.General;
 using StudySharp.Domain.Models;
@@ -11,6 +12,7 @@ namespace StudySharp.ApplicationServices.Queries
     public sealed class GetTheoryBlockByIdQuery : IRequest<OperationResult<TheoryBlock>>
     {
         public int Id { get; set; }
+        public int CourseId { get; set; }
     }
 
     public sealed class GetTheoryBlockByIdQueryHandler : IRequestHandler<GetTheoryBlockByIdQuery, OperationResult<TheoryBlock>>
@@ -22,11 +24,15 @@ public GetTheoryBlockByIdQueryHandler(StudySharpDbContext studySharpDbContext)
             _context = studySharpDbContext;
         }
 
-        public async Task<OperationResult<TheoryBlock>> Handle(
-            GetTheoryBlockByIdQuery request,
-            CancellationToken cancellationToken)
+        public async Task<OperationResult<TheoryBlock>> Handle(GetTheoryBlockByIdQuery request, CancellationToken cancellationToken)
         {
-            var theoryBlock = await _context.TheoryBlocks.FindAsync(request.Id, cancellationToken);
+            var courseExistent = await _context.Courses.AnyAsync(_ => _.Id == request.CourseId, cancellationToken);
+            if (!courseExistent)
+            {
+                return OperationResult.Fail<TheoryBlock>(string.Format(ErrorConstants.EntityNotFound, nameof(Course), nameof(Course.Id), request.CourseId));
+            }
+
+            var theoryBlock = await _context.TheoryBlocks.FirstOrDefaultAsync(_ => _.Id == request.Id && _.CourseId == request.CourseId, cancellationToken);
             if (theoryBlock == null)
             {
                 return OperationResult.Fail<TheoryBlock>(string.Format(ErrorConstants.EntityNotFound, nameof(TheoryBlock), nameof(TheoryBlock.Id), request.Id));