Feat/get categories

TickAPI/TickAPI.Tests/Categories/Controllers/CategoryControllerTests.cs

@@ -0,0 +1,39 @@
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using TickAPI.Categories.Abstractions;
+using TickAPI.Categories.Controllers;
+using TickAPI.Categories.DTOs.Response;
+using TickAPI.Common.Pagination.Responses;
+using TickAPI.Common.Results;
+using TickAPI.Common.Results.Generic;
+using TickAPI.Events.DTOs.Response;
+
+namespace TickAPI.Tests.Categories.Controllers;
+
+public class CategoryControllerTests
+{
+    [Fact]
+
+    public async Task GetCategories_WhenDataIsValid_ShouldReturnOk()
+    {
+        //arrange
+        int pageSize = 20;
+        int pageNumber = 0;
+        var categoryServiceMock = new Mock<ICategoryService>();
+        categoryServiceMock.Setup(m => m.GetCategoriesResponsesAsync(pageSize, pageNumber)).ReturnsAsync(
+            Result<PaginatedData<GetCategoryResponseDto>>.Success(new PaginatedData<GetCategoryResponseDto>(new List<GetCategoryResponseDto>(), pageNumber, pageSize, true, true,
+                new PaginationDetails(0, 0))));
+
+        var sut = new CategoryController(categoryServiceMock.Object);
+
+        //act
+        var res = await sut.GetCategories(pageSize, pageNumber);
+
+        //assert
+        var result = Assert.IsType<ActionResult<PaginatedData<GetCategoryResponseDto>>>(res);
+        var objectResult = Assert.IsType<OkObjectResult>(result.Result);
+        Assert.Equal(200, objectResult.StatusCode);
+        Assert.NotNull(objectResult.Value);
+    }
+
+}

TickAPI/TickAPI.Tests/Categories/Services/CategoryServiceTests.cs

@@ -0,0 +1,42 @@
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using TickAPI.Categories.Abstractions;
+using TickAPI.Categories.DTOs.Response;
+using TickAPI.Categories.Models;
+using TickAPI.Categories.Services;
+using TickAPI.Common.Pagination.Abstractions;
+using TickAPI.Common.Pagination.Responses;
+using TickAPI.Common.Results;
+using TickAPI.Common.Results.Generic;
+
+namespace TickAPI.Tests.Categories.Services;
+
+public class CategoryServiceTests
+{
+    [Fact]
+
+    public async Task GetCategories_WhenDataIsValid_ShouldReturnOk()
+    {
+        //arrange
+        int pageSize = 10;
+        int page = 0;
+        var categoryRepositoryMock = new Mock<ICategoryRepository>();
+        categoryRepositoryMock.Setup(repo => repo.GetCategoriesAsync())
+            .ReturnsAsync(new List<Category>());
+
+        var paginationServiceMock = new Mock<IPaginationService>();
+        paginationServiceMock.Setup(p => p.Paginate(new List<Category>(), pageSize, page)).Returns(
+            Result<PaginatedData<Category>>.Success(new PaginatedData<Category>(new List<Category>(), page, pageSize,
+                false, false, new PaginationDetails(0, 0)))
+        );
+
+        var sut = new CategoryService(categoryRepositoryMock.Object, paginationServiceMock.Object);
+
+        //act
+        var res = await sut.GetCategoriesResponsesAsync(pageSize, page);
+
+        //assert
+        var result = Assert.IsType<Result<PaginatedData<GetCategoryResponseDto>>>(res);
+        Assert.True(result.IsSuccess);
+    }
+}

TickAPI/TickAPI/Categories/Abstractions/ICategoryRepository.cs

@@ -0,0 +1,9 @@
+using TickAPI.Categories.Models;
+using TickAPI.Common.Results.Generic;
+
+namespace TickAPI.Categories.Abstractions;
+
+public interface ICategoryRepository
+{
+    public Task<ICollection<Category>> GetCategoriesAsync();
+}

TickAPI/TickAPI/Categories/Abstractions/ICategoryService.cs

@@ -0,0 +1,11 @@
+using TickAPI.Categories.DTOs.Response;
+using TickAPI.Categories.Models;
+using TickAPI.Common.Pagination.Responses;
+using TickAPI.Common.Results.Generic;
+
+namespace TickAPI.Categories.Abstractions;
+
+public interface ICategoryService
+{
+    public Task<Result<PaginatedData<GetCategoryResponseDto>>> GetCategoriesResponsesAsync(int pageSize, int page);
+}

TickAPI/TickAPI/Categories/Controllers/CategoryController.cs

@@ -0,0 +1,35 @@
+using Microsoft.AspNetCore.Mvc;
+using TickAPI.Categories.Abstractions;
+using TickAPI.Categories.DTOs.Response;
+using TickAPI.Common.Auth.Attributes;
+using TickAPI.Common.Auth.Enums;
+using TickAPI.Common.Pagination.Responses;
+
+
+namespace TickAPI.Categories.Controllers;
+
+[ApiController]
+[Route("api/[controller]")]
+
+public class CategoryController : Controller
+{
+
+    private readonly ICategoryService _categoryService;
+
+    public CategoryController(ICategoryService categoryService)
+    {
+        _categoryService = categoryService;
+    }
+
+    [AuthorizeWithPolicy(AuthPolicies.VerifiedUserPolicy)]
+    [HttpPost("get-categories")]
+    public async Task<ActionResult<PaginatedData<GetCategoryResponseDto>>> GetCategories([FromQuery] int pageSize, [FromQuery] int page)
+    {
+        var res = await _categoryService.GetCategoriesResponsesAsync(pageSize, page);
+        if (!res.IsSuccess)
+        {
+            return StatusCode(StatusCodes.Status500InternalServerError, res.ErrorMsg);
+        }
+        return Ok(res.Value);
+    }
+}

TickAPI/TickAPI/Categories/DTOs/Response/GetCategoryResponseDto.cs

@@ -0,0 +1,7 @@
+using TickAPI.Common.Pagination.Responses;
+
+namespace TickAPI.Categories.DTOs.Response;
+
+public record GetCategoryResponseDto(
+    string CategoryName
+);

TickAPI/TickAPI/Categories/Respositories/CategoryRepository.cs

@@ -0,0 +1,22 @@
+using Microsoft.EntityFrameworkCore;
+using TickAPI.Categories.Abstractions;
+using TickAPI.Categories.Models;
+using TickAPI.Common.Results.Generic;
+using TickAPI.Common.TickApiDbContext;
+namespace TickAPI.Categories.Respositories;
+
+public class CategoryRepository : ICategoryRepository
+{
+    private readonly TickApiDbContext _tickApiDbContext;
+
+    public CategoryRepository(TickApiDbContext tickApiDbContext)
+    {
+        _tickApiDbContext = tickApiDbContext;
+    }
+
+    public async Task<ICollection<Category>> GetCategoriesAsync()
+    {
+        var list = await _tickApiDbContext.Categories.ToListAsync();
+        return list;
+    }
+}

TickAPI/TickAPI/Categories/Services/CategoryService.cs

@@ -0,0 +1,40 @@
+using TickAPI.Categories.Abstractions;
+using TickAPI.Categories.DTOs.Response;
+using TickAPI.Categories.Models;
+using TickAPI.Common.Pagination.Abstractions;
+using TickAPI.Common.Pagination.Responses;
+using TickAPI.Common.Results.Generic;
+
+namespace TickAPI.Categories.Services;
+
+public class CategoryService : ICategoryService
+{
+    private readonly ICategoryRepository _categoryRepository;
+    private readonly IPaginationService _paginationService;
+
+    public CategoryService(ICategoryRepository categoryRepository,  IPaginationService paginationService)
+    {
+        _categoryRepository = categoryRepository;
+        _paginationService = paginationService;
+    }
+
+    public async Task<Result<PaginatedData<GetCategoryResponseDto>>> GetCategoriesResponsesAsync(int pageSize, int page)
+    {
+        var categoriesAllResponse = await  _categoryRepository.GetCategoriesAsync();
+        List<GetCategoryResponseDto> categories = new List<GetCategoryResponseDto>();
+        var categoriesPaginated = _paginationService.Paginate<Category>(categoriesAllResponse, pageSize, page);
+        if (!categoriesPaginated.IsSuccess)
+        {
+            return Result<PaginatedData<GetCategoryResponseDto>>.PropagateError(categoriesPaginated);
+        }
+
+        foreach (var category in categoriesPaginated.Value.Data)
+        {
+            categories.Add(new GetCategoryResponseDto(category.CategoryName));
+        }
+
+        return Result<PaginatedData<GetCategoryResponseDto>>.Success(new PaginatedData<GetCategoryResponseDto>(categories, categoriesPaginated.Value.PageNumber
+        ,categoriesPaginated.Value.PageSize, categoriesPaginated.Value.HasNextPage, categoriesPaginated.Value.HasPreviousPage,
+        categoriesPaginated.Value.PaginationDetails));
+    }
+}

TickAPI/TickAPI/Common/Auth/Enums/AuthPolicies.cs

@@ -7,4 +7,5 @@ public enum AuthPolicies
     CustomerPolicy,
     NewOrganizerPolicy,
     CreatedOrganizerPolicy,
+    VerifiedUserPolicy,
 }

TickAPI/TickAPI/Program.cs

@@ -30,6 +30,9 @@
 using TickAPI.Addresses.Abstractions;
 using TickAPI.Addresses.Repositories;
 using TickAPI.Addresses.Services;
+using TickAPI.Categories.Abstractions;
+using TickAPI.Categories.Respositories;
+using TickAPI.Categories.Services;
 using TickAPI.Common.Claims.Abstractions;
 using TickAPI.Common.Claims.Services;
 
@@ -49,8 +52,8 @@
     })
     .AddGoogle(options =>
     {
         options.ClientId = builder.Configuration["Authentication:Google:ClientId"];
         options.ClientSecret = builder.Configuration["Authentication:Google:ClientSecret"];
     })
     .AddJwtBearer(options =>
     {
@@ -62,7 +65,7 @@
             ValidateIssuerSigningKey = true,
             ValidIssuer = builder.Configuration["Authentication:Jwt:Issuer"],
             IssuerSigningKey = new SymmetricSecurityKey(
                 Encoding.UTF8.GetBytes(builder.Configuration["Authentication:Jwt:SecurityKey"]))
         };
     });
 
@@ -75,6 +78,7 @@
 
     options.AddPolicy(AuthPolicies.NewOrganizerPolicy.ToString(), policy => policy.RequireRole(UserRole.NewOrganizer.ToString()));
     options.AddPolicy(AuthPolicies.CreatedOrganizerPolicy.ToString(), policy => policy.RequireRole(UserRole.UnverifiedOrganizer.ToString(), UserRole.Organizer.ToString()));
+    options.AddPolicy(AuthPolicies.VerifiedUserPolicy.ToString(), policy => policy.RequireRole(UserRole.Admin.ToString(), UserRole.Organizer.ToString(), UserRole.Customer.ToString()));
 });
 
 // Add admin services.
@@ -101,6 +105,10 @@
 builder.Services.AddScoped<ITicketService, TicketService>();
 builder.Services.AddScoped<ITicketRepository, TicketRepository>();
 
+// Add category services.
+builder.Services.AddScoped<ICategoryService, CategoryService>();
+builder.Services.AddScoped<ICategoryRepository, CategoryRepository>();
+
 // Add common services.
 builder.Services.AddScoped<IGoogleAuthService, GoogleAuthService>();
 builder.Services.AddScoped<IJwtService, JwtService>();