finalizare 1.0

backend/API/Controllers/MedicalHistoryController.cs

@@ -1,94 +1,113 @@
 using Application.Endpoints;
-using Application.Endpoints.MedicalHistories.FileManagement;
+using Application.Endpoints.MedicalHistories;
+using Application.Endpoints.MedicalHistories.CreateMedicalHistory;
+using Application.Endpoints.MedicalHistories.DeleteMedicalHistory;
 using Application.Endpoints.MedicalHistories.ManageAuthorization;
+using Application.Endpoints.MedicalHistories.ModifyMedicalHistory;
+using Application.Endpoints.MedicalHistories.QuerriesMedicalHistories;
 using Application.Services.Database.MongoDB;
 using Application.Services.Database.PostgreSQL;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
 namespace API.Controllers;
 
 [ApiController]
 [Route("api/[controller]")]
-public class MedicalHistoryController : ControllerBase
+public class MedicalHistoryController(
+    IMedicalHistoryRepository medicalHistoryRepository,
+    IPatientRepository patientRepository,
+    IMedicalHistoryMongoDbService medicalHistoryMongoDbService,
+    IDoctorRepository doctorRepository)
+    : ControllerBase
 {
-    private readonly IDoctorRepository _doctorRepository;
-    private readonly IMedicalHistoryMongoDbService _medicalHistoryMongoDbService;
-    private readonly IMedicalHistoryRepository _medicalHistoryRepository;
-    private readonly IPatientRepository _patientRepository;
-
-    public MedicalHistoryController(IMedicalHistoryRepository medicalHistoryRepository,
-        IPatientRepository patientRepository, IMedicalHistoryMongoDbService mongoDbService,
-        IDoctorRepository doctorRepository)
-    {
-        _medicalHistoryRepository = medicalHistoryRepository;
-        _patientRepository = patientRepository;
-        _medicalHistoryMongoDbService = mongoDbService;
-        _doctorRepository = doctorRepository;
-    }
-
+    [Authorize(Policy = Policies.ClientsOnlyPolicy)]
     [HttpGet("{id}")]
-    public async Task<ActionResult<BaseResponse>> GetAsync(Guid id)
+    public async Task<ActionResult<BaseResponse>> GetMedicalHistory(Guid id, CancellationToken token)
     {
-        var handler = new MedicalHistoryFileManagementHandler(_medicalHistoryRepository, _patientRepository,
-            _medicalHistoryMongoDbService);
-        var response = await handler.HandleGet(id);
+        var handler = new QuerriesMedicalHistoriesHandler(medicalHistoryRepository);
+        var response = await handler.HandleGet(id, token);
+        return StatusCode(response.StatusCode, response);
+    }
+    
+    [Authorize(Policy = Policies.ClientsOnlyPolicy)]
+    [HttpGet("user/{userId}")]
+    public async Task<ActionResult<BaseResponse>> GetMedicalHistoryByUserId(Guid userId, CancellationToken token)
+    {
+        var handler = new QuerriesMedicalHistoriesHandler(medicalHistoryRepository);
+        var response = await handler.HandleGetByPatientId(userId, token);
         return StatusCode(response.StatusCode, response);
     }
 
+    [Authorize(Policy = Policies.ClientsOnlyPolicy)]
     [HttpGet]
-    public async Task<ActionResult<BaseResponse>> GetAllDoctors()
+    public async Task<ActionResult<BaseResponse>> GetAllMedicalHistories(CancellationToken token)
     {
-        var handler = new MedicalHistoryFileManagementHandler(_medicalHistoryRepository, _patientRepository,
-            _medicalHistoryMongoDbService);
-        var response = await handler.HandleGetAll();
+        var handler = new QuerriesMedicalHistoriesHandler(medicalHistoryRepository);
+        var response = await handler.HandleGetAll(token);
         return StatusCode(response.StatusCode, response);
     }
 
+    [Authorize(Policy = Policies.PatientPolicy)]
     [HttpPost]
-    public async Task<ActionResult<BaseResponse>> PostAsync(MedicalHistoryCreateDto medicalHistoryCreateDto)
+    public async Task<ActionResult<BaseResponse>> CreateMedicalHistory(
+        CreateMedicalHistoryCommand request, CancellationToken token)
     {
-        var handler = new MedicalHistoryFileManagementHandler(_medicalHistoryRepository, _patientRepository,
-            _medicalHistoryMongoDbService);
-        var response = await handler.HandleCreate(medicalHistoryCreateDto);
+        var handler =
+            new CreateMedicalHistoryHandler(medicalHistoryRepository, patientRepository, medicalHistoryMongoDbService);
+        var response = await handler.Handle(request, token);
         return StatusCode(response.StatusCode, response);
     }
 
+    [Authorize(Policy = Policies.ClientsOnlyPolicy)]
     [HttpPut]
-    public async Task<ActionResult<BaseResponse>> UpdateAsync(MedicalHistoryUpdateDto medicalHistoryUpdateDto)
+    public async Task<ActionResult<BaseResponse>> ModifyMedicalHistory(
+        ModifyMedicalHistoryCommand request, CancellationToken token)
     {
-        var handler = new MedicalHistoryFileManagementHandler(_medicalHistoryRepository, _patientRepository,
-            _medicalHistoryMongoDbService);
-        var response = await handler.HandleUpdate(medicalHistoryUpdateDto).ConfigureAwait(false);
+        var handler = new ModifyMedicalHistoryHandler(medicalHistoryRepository);
+        var response = await handler.Handle(request, token);
         return StatusCode(response.StatusCode, response);
     }
 
+    [Authorize(Policy = Policies.PatientPolicy)]
     [HttpDelete("{id}")]
-    public async Task<ActionResult<BaseResponse>> DeleteAsync(Guid id)
+    public async Task<ActionResult<BaseResponse>> DeleteMedicalHistory(Guid id, CancellationToken token)
     {
-        var handler = new MedicalHistoryFileManagementHandler(_medicalHistoryRepository, _patientRepository,
-            _medicalHistoryMongoDbService);
-        var response = await handler.HandleDelete(id);
+        var handler = new DeleteMedicalHistoryHandler(medicalHistoryRepository, medicalHistoryMongoDbService);
+        var response = await handler.Handle(id, token);
         return StatusCode(response.StatusCode, response);
     }
 
+    [Authorize(Policy = Policies.AuthenticatedPolicy)]
+    [HttpPost("check_access")]
+    public async Task<ActionResult<BaseResponse>> CheckAccessToMedicalHistory(
+        MedicalHistoryAuthorizationInfo request, CancellationToken token)
+    {
+        var handler = new MedicalHistoryManageAuthorizationHandler(medicalHistoryRepository,
+            medicalHistoryMongoDbService, doctorRepository);
+        var response = await handler.HandleCheckAccessToMedicalHistory(request, token);
+        return StatusCode(response.StatusCode, response);
+    }
 
+    [Authorize(Policy = Policies.PatientPolicy)]
     [HttpPut("grant_access")]
     public async Task<ActionResult<BaseResponse>> GrantAccessToMedicalHistory(
-        MedicalHistoryManageAuthorizationDoctorDto infoDto)
+        MedicalHistoryAuthorizationInfo request, CancellationToken token)
     {
-        var handler = new MedicalHistoryManageAuthorizationHandler(_medicalHistoryRepository,
-            _medicalHistoryMongoDbService, _doctorRepository);
-        var response = await handler.HandleGrantDoctorAccess(infoDto);
+        var handler = new MedicalHistoryManageAuthorizationHandler(medicalHistoryRepository,
+            medicalHistoryMongoDbService, doctorRepository);
+        var response = await handler.HandleGrantDoctorAccess(request, token);
         return StatusCode(response.StatusCode, response);
     }
 
+    [Authorize(Policy = Policies.PatientPolicy)]
     [HttpPut("revoke_access")]
     public async Task<ActionResult<BaseResponse>> RevokeAccessToMedicalHistory(
-        MedicalHistoryManageAuthorizationDoctorDto infoDto)
+        MedicalHistoryAuthorizationInfo request, CancellationToken token)
     {
-        var handler = new MedicalHistoryManageAuthorizationHandler(_medicalHistoryRepository,
-            _medicalHistoryMongoDbService, _doctorRepository);
-        var response = await handler.HandleRevokeDoctorAccess(infoDto);
+        var handler = new MedicalHistoryManageAuthorizationHandler(medicalHistoryRepository,
+            medicalHistoryMongoDbService, doctorRepository);
+        var response = await handler.HandleRevokeDoctorAccess(request, token);
         return StatusCode(response.StatusCode, response);
     }
 }