Full Materials for Subjects

Author: Dacoband

FPTStella/FPTStella.API/Controllers/MaterialController.cs

@@ -0,0 +1,205 @@
+using FPTStella.Application.Common.Interfaces.Services;
+using FPTStella.Contracts.DTOs.Materials;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace FPTStella.API.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class MaterialController : BaseController
+    {
+        private readonly IMaterialService _materialService;
+        public MaterialController(IMaterialService materialService)
+        {
+            _materialService = materialService;
+        }
+        [HttpGet]
+        public async Task<IActionResult> GetAllMaterials()
+        {
+            try
+            {
+                var materials = await _materialService.GetAllMaterialsAsync();
+                return Ok(materials);
+            }
+            catch (Exception ex)
+            {
+                return HandleException(ex);
+            }
+        }
+
+        [HttpGet("{id}")]
+        public async Task<IActionResult> GetMaterialById(string id)
+        {
+            try
+            {
+                var material = await _materialService.GetMaterialByIdAsync(id);
+                return Ok(material);
+            }
+            catch (KeyNotFoundException ex)
+            {
+                return NotFound(ex.Message);
+            }
+            catch (Exception ex)
+            {
+                return HandleException(ex);
+            }
+        }
+
+        [HttpGet("name/{name}")]
+        public async Task<IActionResult> GetMaterialByName(string name)
+        {
+            try
+            {
+                var material = await _materialService.GetMaterialByNameAsync(name);
+                if (material == null)
+                {
+                    return NotFound($"Material with name '{name}' not found.");
+                }
+                return Ok(material);
+            }
+            catch (Exception ex)
+            {
+                return HandleException(ex);
+            }
+        }
+
+        [HttpGet("subject/{subjectId}")]
+        public async Task<IActionResult> GetMaterialsBySubjectId(Guid subjectId)
+        {
+            try
+            {
+                var materials = await _materialService.GetMaterialsBySubjectIdAsync(subjectId);
+                return Ok(materials);
+            }
+            catch (Exception ex)
+            {
+                return HandleException(ex);
+            }
+        }
+
+        [HttpGet("type/{type}")]
+        public async Task<IActionResult> GetMaterialsByType(string type)
+        {
+            try
+            {
+                var materials = await _materialService.GetMaterialsByTypeAsync(type);
+                return Ok(materials);
+            }
+            catch (Exception ex)
+            {
+                return HandleException(ex);
+            }
+        }
+
+        /// <summary>
+        /// Search for materials with filters and pagination
+        /// </summary>
+        /// <param name="searchTerm">Optional search term</param>
+        /// <param name="subjectId">Optional subject ID filter</param>
+        /// <param name="materialType">Optional material type filter</param>
+        /// <param name="pageNumber">Page number (default: 1)</param>
+        /// <param name="pageSize">Page size (default: 10)</param>
+        /// <returns>Paged results of materials</returns>
+        [HttpGet("search")]
+        public async Task<IActionResult> SearchMaterials(
+            [FromQuery] string? searchTerm = null,
+            [FromQuery] Guid? subjectId = null,
+            [FromQuery] string? materialType = null,
+            [FromQuery] int pageNumber = 1,
+            [FromQuery] int pageSize = 10)
+        {
+            try
+            {
+                var results = await _materialService.SearchMaterialsAsync(
+                    searchTerm,
+                    subjectId,
+                    materialType,
+                    pageNumber,
+                    pageSize);
+
+                return Ok(results);
+            }
+            catch (Exception ex)
+            {
+                return HandleException(ex);
+            }
+        }
+
+        [HttpPost]
+        public async Task<IActionResult> CreateMaterial([FromBody] CreateMaterialDto createMaterialDto)
+        {
+            try
+            {
+                var material = await _materialService.CreateMaterialAsync(createMaterialDto);
+                return CreatedAtAction(nameof(GetMaterialById), new { id = material.Id }, material);
+            }
+            catch (InvalidOperationException ex)
+            {
+                return BadRequest(ex.Message);
+            }
+            catch (KeyNotFoundException ex)
+            {
+                return NotFound(ex.Message);
+            }
+            catch (Exception ex)
+            {
+                return HandleException(ex);
+            }
+        }
+
+        [HttpPut("{id}")]
+        public async Task<IActionResult> UpdateMaterial(string id, [FromBody] UpdateMaterialDto updateMaterialDto)
+        {
+            try
+            {
+                var success = await _materialService.UpdateMaterialAsync(id, updateMaterialDto);
+                return success ? NoContent() : BadRequest("Failed to update material.");
+            }
+            catch (KeyNotFoundException ex)
+            {
+                return NotFound(ex.Message);
+            }
+            catch (InvalidOperationException ex)
+            {
+                return BadRequest(ex.Message);
+            }
+            catch (Exception ex)
+            {
+                return HandleException(ex);
+            }
+        }
+
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeleteMaterial(string id)
+        {
+            try
+            {
+                var success = await _materialService.DeleteMaterialAsync(id);
+                return success ? NoContent() : BadRequest("Failed to delete material.");
+            }
+            catch (KeyNotFoundException ex)
+            {
+                return NotFound(ex.Message);
+            }
+            catch (Exception ex)
+            {
+                return HandleException(ex);
+            }
+        }
+
+        [HttpDelete("subject/{subjectId}")]
+        public async Task<IActionResult> DeleteMaterialsBySubjectId(Guid subjectId)
+        {
+            try
+            {
+                var success = await _materialService.DeleteMaterialsBySubjectIdAsync(subjectId);
+                return success ? NoContent() : BadRequest("Failed to delete materials for subject.");
+            }
+            catch (Exception ex)
+            {
+                return HandleException(ex);
+            }
+        }
+    }
+}

FPTStella/FPTStella.API/Program.cs

@@ -47,6 +47,7 @@
 builder.Services.AddSingleton<ISubjectComboSubjectRepository, SubjectComboSubjectRepository>();
 builder.Services.AddSingleton<IToolRepository, ToolRepository>();
 builder.Services.AddScoped<ISubjectToolRepository, SubjectToolRepository>();
+builder.Services.AddSingleton<IMaterialRepository, MaterialRepository>();
 
 
 // Đăng ký DI cho Application
@@ -65,6 +66,7 @@
 builder.Services.AddSingleton<ISubjectComboService, SubjectComboService>();
 builder.Services.AddSingleton<ISubjectComboSubjectService, SubjectComboSubjectService>();
 builder.Services.AddSingleton<IToolService, ToolService>();
+builder.Services.AddSingleton<IMaterialService, MaterialService>();
 
 builder.Services.AddScoped<IGoogleAuthService, GoogleAuthService>();
 builder.Services.AddScoped<GoogleLoginUseCase>();
@@ -97,7 +99,7 @@
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen(c =>
 {
-    c.SwaggerDoc("v1", new OpenApiInfo { Title = "✨ FPT Stella ✨", Version = "v1.3.0" });
+    c.SwaggerDoc("v1", new OpenApiInfo { Title = "✨ FPT Stella ✨", Version = "v2.0.0" });
 
     // Cấu hình Bearer token 
     c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme

FPTStella/FPTStella.Application/Common/Interfaces/Repositories/IMaterialRepository.cs

@@ -0,0 +1,46 @@
+using FPTStella.Application.Common.Interfaces.UnitOfWorks;
+using FPTStella.Domain.Common;
+using FPTStella.Domain.Entities;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FPTStella.Application.Common.Interfaces.Repositories
+{
+    public interface IMaterialRepository : IRepository<Materials>
+    {
+        /// <summary>
+        /// Gets materials by subject ID
+        /// </summary>
+        /// <param name="subjectId">The subject ID to search for</param>
+        /// <returns>List of materials related to the subject</returns>
+        Task<List<Materials>> GetBySubjectIdAsync(Guid subjectId);
+        /// <summary>
+        /// Gets a material by its name
+        /// </summary>
+        /// <param name="materialName">The material name to search for</param>
+        /// <returns>The material if found, otherwise null</returns>
+        Task<Materials?> GetByMaterialNameAsync(string materialName);
+        /// <summary>
+        /// Gets materials by material type
+        /// </summary>
+        /// <param name="materialType">The material type to search for</param>
+        /// <returns>List of materials of the specified type</returns>
+        Task<List<Materials>> GetByMaterialTypeAsync(string materialType);
+        /// <summary>
+        /// Searches for materials with advanced filtering options and pagination
+        /// </summary>
+        /// <param name="searchTerm">Optional search term for text-based fields</param>
+        /// <param name="subjectId">Optional subject ID filter</param>
+        /// <param name="materialType">Optional material type filter</param>
+        /// <param name="paginationParams">Pagination parameters</param>
+        /// <returns>Paginated results of materials</returns>
+        Task<PagedResult<Materials>> SearchMaterialsAsync(
+            string? searchTerm = null,
+            Guid? subjectId = null,
+            string? materialType = null,
+            PaginationParams? paginationParams = null);
+    }
+}

FPTStella/FPTStella.Application/Common/Interfaces/Services/IMaterialService.cs

@@ -0,0 +1,83 @@
+using FPTStella.Contracts.DTOs.Materials;
+using FPTStella.Domain.Common;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FPTStella.Application.Common.Interfaces.Services
+{
+    public interface IMaterialService
+    {
+        /// <summary>
+        /// Creates a new material
+        /// </summary>
+        /// <param name="createMaterialDto">The data for the new material</param>
+        /// <returns>The created material as a DTO</returns>
+        Task<MaterialDto> CreateMaterialAsync(CreateMaterialDto createMaterialDto);
+        /// <summary>
+        /// Gets a material by its ID
+        /// </summary>
+        /// <param name="id">The ID of the material</param>
+        /// <returns>The material as a DTO if found</returns>
+        Task<MaterialDto> GetMaterialByIdAsync(string id);
+        /// <summary>
+        /// Gets a material by its name
+        /// </summary>
+        /// <param name="materialName">The name of the material</param>
+        /// <returns>The material as a DTO if found, otherwise null</returns>
+        Task<MaterialDto?> GetMaterialByNameAsync(string materialName);
+        /// <summary>
+        /// Gets all materials for a specific subject
+        /// </summary>
+        /// <param name="subjectId">The subject ID</param>
+        /// <returns>List of materials as DTOs</returns>
+        Task<List<MaterialDto>> GetMaterialsBySubjectIdAsync(Guid subjectId);
+        /// <summary>
+        /// Gets all materials with a specific type
+        /// </summary>
+        /// <param name="materialType">The material type</param>
+        /// <returns>List of materials as DTOs</returns>
+        Task<List<MaterialDto>> GetMaterialsByTypeAsync(string materialType);
+        /// <summary>
+        /// Gets all materials
+        /// </summary>
+        /// <returns>List of all materials as DTOs</returns>
+        Task<List<MaterialDto>> GetAllMaterialsAsync();
+        /// <summary>
+        /// Updates a material
+        /// </summary>
+        /// <param name="id">The ID of the material to update</param>
+        /// <param name="updateMaterialDto">The update data</param>
+        /// <returns>True if successful, otherwise false</returns>
+        Task<bool> UpdateMaterialAsync(string id, UpdateMaterialDto updateMaterialDto);
+        /// <summary>
+        /// Deletes a material by its ID
+        /// </summary>
+        /// <param name="id">The ID of the material to delete</param>
+        /// <returns>True if successful, otherwise false</returns>
+        Task<bool> DeleteMaterialAsync(string id);
+        /// <summary>
+        /// Deletes all materials for a specific subject
+        /// </summary>
+        /// <param name="subjectId">The subject ID</param>
+        /// <returns>True if successful, otherwise false</returns>
+        Task<bool> DeleteMaterialsBySubjectIdAsync(Guid subjectId);
+        /// <summary>
+        /// Searches for materials with pagination
+        /// </summary>
+        /// <param name="searchTerm">Optional search term for material name or description</param>
+        /// <param name="subjectId">Optional subject ID filter</param>
+        /// <param name="materialType">Optional material type filter</param>
+        /// <param name="pageNumber">Page number (default: 1)</param>
+        /// <param name="pageSize">Page size (default: 10)</param>
+        /// <returns>Paged result of materials as DTOs</returns>
+        Task<PagedResult<MaterialDto>> SearchMaterialsAsync(
+            string? searchTerm = null,
+            Guid? subjectId = null,
+            string? materialType = null,
+            int pageNumber = 1,
+            int pageSize = 10);
+    }
+}