Yeabsira.asessment

Backend/backend_assessment/CineFlex/CineFlex.API/Controllers/BookingsController.cs

@@ -0,0 +1,42 @@
+using CineFlex.Application.Features.Bookings.CQRS.Handlers;
+using CineFlex.Application.Features.Bookings.CQRS.Requests.Commands;
+using CineFlex.Application.Features.Bookings.CQRS.Requests.Queries;
+using CineFlex.Application.Features.Bookings.DTOs;
+using CineFlex.Application.Features.Movies.CQRS.Commands;
+using CineFlex.Application.Features.Movies.CQRS.Queries;
+using CineFlex.Application.Features.Movies.DTOs;
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CineFlex.API.Controllers;
+
+public class BookingsController : BaseApiController
+{
+    private readonly IMediator _mediator;
+
+    public BookingsController(IMediator mediator)
+    {
+        _mediator = mediator;
+    }
+
+    [HttpGet("{id}")]
+    public async Task<IActionResult> Get(int id)
+    {
+        return HandleResult(await _mediator.Send(new GetBookingDetailQuery() { Id = id }));
+
+    }
+
+    [HttpPost]
+    public async Task<IActionResult> Post([FromBody] CreateBookingDto createBookingDto)
+    {
+        var command = new CreateBookingCommand() {CreateBookingDto  = createBookingDto };
+        return HandleResult(await _mediator.Send(command));
+    }
+
+    [HttpDelete("{id}")]
+    public async Task<IActionResult> Delete(int id)
+    {
+        var command = new DeleteBookingCommand() { Id = id };
+        return HandleResult(await _mediator.Send(command));
+    }
+}   

Backend/backend_assessment/CineFlex/CineFlex.API/Controllers/MovieController.cs

@@ -34,15 +34,14 @@ public async Task<IActionResult> Get(int id)
         [HttpPost]
         public async Task<IActionResult> Post([FromBody] CreateMovieDto createMovie)
         {
+            // TODO: 
             var command = new CreateMovieCommand { MovieDto = createMovie };
             return HandleResult(await _mediator.Send(command));
         }
 
         [HttpPut]
         public async Task<IActionResult> Put([FromBody] UpdateMovieDto movieDto)
         {
-
-
             var command = new UpdateMovieCommand { MovieDto = movieDto };
             return HandleResult(await _mediator.Send(command));
         }

Backend/backend_assessment/CineFlex/CineFlex.API/Controllers/SeatsController.cs

@@ -0,0 +1,55 @@
+using CineFlex.Application.Features.Movies.CQRS.Commands;
+using CineFlex.Application.Features.Movies.CQRS.Queries;
+using CineFlex.Application.Features.Movies.DTOs;
+using CineFlex.Application.Features.Seats.CQRS.Requests.Commands;
+using CineFlex.Application.Features.Seats.CQRS.Requests.Queries;
+using CineFlex.Application.Features.Seats.DTOs;
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CineFlex.API.Controllers;
+
+public class SeatsController: BaseApiController
+{
+
+    private readonly IMediator _mediator;
+
+    public SeatsController(IMediator mediator)
+    {
+        _mediator = mediator;
+    }
+
+    [HttpPost("all")]
+    public async Task<ActionResult<List<SeatDetailsDto>>> Get([FromBody] GetAllSeatsDto getAllSeatsDto)
+    {
+        return HandleResult(await _mediator.Send(new GetAllSeatsQuery(){GetAllSeatsDto = getAllSeatsDto}));
+    }
+
+    [HttpGet("{id}")]
+    public async Task<IActionResult> Get(int id)
+    {
+        return HandleResult(await _mediator.Send(new GetSeatDetailsQuery { Id = id }));
+
+    }
+
+    [HttpPost]
+    public async Task<IActionResult> Post([FromBody] CreateSeatDto createSeatDto)
+    {
+        var command = new CreateSeatCommand() { CreateSeatDto = createSeatDto };
+        return HandleResult(await _mediator.Send(command));
+    }
+
+    [HttpPut]
+    public async Task<IActionResult> Put([FromBody] UpdateSeatDto updateSeatDto)
+    {
+        var command = new UpdateSeatCommand {  UpdateSeatDto = updateSeatDto};
+        return HandleResult(await _mediator.Send(command));
+    }
+
+    [HttpDelete("{id}")]
+    public async Task<IActionResult> Delete(int id)
+    {
+        var command = new DeleteSeatCommand { Id = id };
+        return HandleResult(await _mediator.Send(command));
+    }
+}

Backend/backend_assessment/CineFlex/CineFlex.API/Controllers/UsersController.cs

@@ -0,0 +1,68 @@
+using System.Security.Claims;
+using CineFlex.Domain;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CineFlex.API.Controllers;
+
+public class UsersController: BaseApiController
+{
+
+    private readonly UserManager<User> _userManager;
+    private readonly SignInManager<User> _signInManager;
+
+    public UsersController(UserManager<User> userManager, SignInManager<User> signInManager)
+    {
+        _userManager = userManager;
+        _signInManager = signInManager;
+    }
+
+    [HttpPost("/login")]
+    public async Task<ActionResult> Login([FromBody] LoginInfo loginInfo)
+    {
+        var user = await _userManager.FindByEmailAsync(email: loginInfo.email);
+
+        if (user == null)
+            return NotFound("User not found");
+
+        var signInResult = await _signInManager.PasswordSignInAsync(user, loginInfo.password, false, false);
+
+        if (signInResult.Succeeded)
+            return Ok("SUCCEEDED");
+
+        return Ok("DENIED");
+    }
+
+    [HttpPost("/signup")]
+    public async Task<ActionResult> Signup([FromBody] SignupInfo signupInfo)
+    {
+        var newUser = new User { UserName = signupInfo.username, Email = signupInfo.email};
+
+        var result = await _userManager.CreateAsync(newUser, signupInfo.password);
+
+        if (result.Succeeded)
+        {
+            var claimResult = await _userManager.AddClaimAsync(newUser, new Claim("Role", "User"));
+
+            if (claimResult.Succeeded)
+                return Ok("Created");
+        }
+
+        return Ok(result.Errors.First().Description);
+    }
+
+    public class LoginInfo
+    {
+        public string email { get; set; }
+        public string password { get; set; }
+    }
+
+    public class SignupInfo
+    {
+        public string username { get; set; }
+        public string email { get; set; }
+        public string password { get; set; }
+    }
+
+}

Backend/backend_assessment/CineFlex/CineFlex.API/Program.cs

@@ -1,4 +1,5 @@
 using CineFlex.Application;
+using CineFlex.Domain;
 using CineFlex.Persistence;
 using Microsoft.OpenApi.Models;
 using Microsoft.AspNetCore.Identity;
@@ -12,6 +13,12 @@
 AddSwaggerDoc(builder.Services);
 builder.Services.AddControllers();
 
+// builder.Services.AddIdentity<User, IdentityRole>(options =>
+//     {
+//         options.User.RequireUniqueEmail = true;
+//         options.SignIn.RequireConfirmedAccount = false;
+//     })
+//     .AddEntityFrameworkStores<CineFlexDbContex>();
 
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen();

Backend/backend_assessment/CineFlex/CineFlex.API/Properties/launchSettings.json

@@ -21,7 +21,7 @@
     },
     "IIS Express": {
       "commandName": "IISExpress",
-      "launchBrowser": true,
+      "launchBrowser": false,
       "launchUrl": "swagger",
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development"

Backend/backend_assessment/CineFlex/CineFlex.API/appsettings.json

@@ -1,6 +1,6 @@
 {
   "ConnectionStrings": {
-    "CineFlexConnectionString": "User ID=postgres;Password=1234;Server=localhost;Port=5432;Database=CineFlex;Integrated Security=true;Pooling=true;"
+    "CineFlexConnectionString": "User ID=postgres;Password=dr;Server=localhost;Database=CineFlex"
   },
   "Logging": {
     "LogLevel": {

Backend/backend_assessment/CineFlex/CineFlex.Application.UnitTest/CineFlex.Application.UnitTest.csproj

@@ -28,8 +28,4 @@
     <ProjectReference Include="..\CineFlex.Domain\CineFlex.Domain.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <Folder Include="Mocks\" />
-  </ItemGroup>
-
 </Project>

Backend/backend_assessment/CineFlex/CineFlex.Application.UnitTest/Mocks/MockSeatRepository.cs

@@ -0,0 +1,58 @@
+using CineFlex.Application.Contracts.Persistence;
+using CineFlex.Domain;
+using Moq;
+
+namespace BlogApp.Tests.Mocks;
+
+public static class MockSeatRepository
+{
+    public static Mock<ISeatRepository> GetBlogRepository()
+    {
+        var seats = new List<Seat>
+        {
+            new ()
+            {
+                Movie = new Movie(){Genre = "genre", Title = "Title"},
+                Cinema = new CinemaEntity() {Location = "the location", Name = "The name"}, 
+                Location = "kjdkjsd",    
+                Taken = false,
+            }
+        };
+
+        var mockRepo = new Mock<ISeatRepository>();
+
+        mockRepo.Setup(r => r.GetAll()).ReturnsAsync(seats);
+
+        mockRepo.Setup(r => r.Add(It.IsAny<Seat>())).ReturnsAsync((Seat seat) =>
+        {
+            seat.Id = seats.Count() + 1;
+            seats.Add(seat);
+            return seat; 
+        });
+
+        mockRepo.Setup(r => r.Update(It.IsAny<Seat>())).Callback((Seat seat) =>
+        {
+            var newSeats = seats.Where((r) => r.Id != seat.Id).ToList();
+            newSeats.Add(seat);
+        });
+
+        mockRepo.Setup(r => r.Delete(It.IsAny<Seat>())).Callback((Seat seat) =>
+        {
+            if (seats.Exists(b => b.Id == seat.Id))
+                seats.Remove(seats.Find(b => b.Id == seat.Id)!);
+        });
+
+        mockRepo.Setup(r => r.Exists(It.IsAny<int>())).ReturnsAsync((int id) =>
+        {
+            var rate = seats.FirstOrDefault((r) => r.Id == id);
+            return rate != null;
+        });
+
+        mockRepo.Setup(r => r.Get(It.IsAny<int>()))!.ReturnsAsync((int id) =>
+        {
+            return seats.FirstOrDefault((r) => r.Id == id);
+        });
+
+        return mockRepo;
+    }
+}

Backend/backend_assessment/CineFlex/CineFlex.Application.UnitTest/Mocks/MockUnitOfWork.cs

@@ -0,0 +1,18 @@
+using CineFlex.Application.Contracts.Persistence;
+using Moq;
+
+namespace BlogApp.Tests.Mocks
+{
+    public static class MockUnitOfWork
+    {
+        public static Mock<IUnitOfWork> GetUnitOfWork()
+        {
+            var mockUow = new Mock<IUnitOfWork>();
+            var mockSeatRepo = MockSeatRepository.GetBlogRepository();
+            mockUow.Setup(r => r.SeatRepository).Returns(mockSeatRepo.Object);
+            mockUow.Setup(r => r.Save()).ReturnsAsync(1);
+            return mockUow;
+        }
+    }
+}
+

Backend/backend_assessment/CineFlex/CineFlex.Application.UnitTest/Seat/Command/CreateBlogCommandHandlerTest.cs

@@ -0,0 +1,69 @@
+using AutoMapper;
+using Shouldly;
+using Moq;
+using Xunit;
+using BlogApp.Tests.Mocks;
+using CineFlex.Application.Contracts.Persistence;
+using CineFlex.Application.Features.Seats.CQRS.Handlers.Commands;
+using CineFlex.Application.Features.Seats.DTOs;
+using CineFlex.Application.Profiles;
+
+namespace BlogApp.Tests.Blog.Command;
+
+public class CreateBlogCommandHandlerTest
+{
+       private IMapper _mapper { get; set; }
+       private Mock<IUnitOfWork> _mockUnitOfWork { get; set; }
+       private CreateSeatCommandHandler _handler { get; set; }
+
+
+       public CreateBlogCommandHandlerTest()
+       {
+              _mockUnitOfWork = MockUnitOfWork.GetUnitOfWork();
+
+              _mapper = new MapperConfiguration(c =>
+              {
+                     c.AddProfile<MappingProfile>();
+              }).CreateMapper();
+
+              _handler = new CreateSeatCommandHandler(_mockUnitOfWork.Object, _mapper);
+       }
+
+
+       [Fact]
+       public async Task CreateBlogValid()
+       {
+
+              CreateSeatDto createBlogDto = new()
+              {
+                     Movie = 1,
+                     Cinema = 1,
+                     Location = "dkjsd"
+              };
+
+              // var result = await _handler.Handle(new CreateBlogCommand() { CreateBlogDto = createBlogDto }, CancellationToken.None);
+              //
+              // result.Value.Content.ShouldBeEquivalentTo(createBlogDto.Content);
+              // result.Value.Title.ShouldBeEquivalentTo(createBlogDto.Title);
+              //
+              // (await _mockUnitOfWork.Object.BlogRepository.GetAll()).Count.ShouldBe(3);
+       }
+
+       // [Fact]
+       // public async Task CreateBlogInvalid()
+       // {
+       //
+       //        CreateBlogDto createBlogDto = new()
+       //        {
+       //               Title = "", // Title can't be empty 
+       //               Content = "Body of the new blog",
+       //               Publish = true,
+       //        };
+       //        
+       //        var result = await _handler.Handle(new CreateBlogCommand() { CreateBlogDto = createBlogDto }, CancellationToken.None);
+       //        
+       //        result.Value.ShouldBe(null);
+       // }
+}
+
+