pushed api files

pushed middlewares
2024-04-07 02:49:34 +03:00
parent 55eaa0d53a
commit 2ccec617a5
11 changed files with 390 additions and 54 deletions
@@ -1,10 +1,9 @@
 using Microsoft.AspNetCore.Mvc;

-namespace HealthcareManager.API.Controllers
+namespace HealthcareManager.API.Controllers;
+
+[Route("api/v1/[controller]")]
+[ApiController]
+public abstract class BaseApiController : ControllerBase
 {
-    [Route("api/v1/[controller]")]
-    [ApiController]
-    public abstract class BaseApiController : ControllerBase
-    {
-    }
 }
@@ -1,16 +1,14 @@
 using Infrastructure.Services.MongoDB;
-using Microsoft.AspNetCore.Mvc;

-namespace HealthcareManager.API.Controllers
+namespace HealthcareManager.API.Controllers;
+
+public class ChatController : BaseApiController
 {
-    public class ChatController : BaseApiController
+    private readonly MongoDbService _mongoDbService;
+
+    public ChatController(MongoDbService mongoDbService)
    {
-        private readonly MongoDbService _mongoDbService;
-
-        public ChatController(MongoDbService mongoDbService)
-        {
-            _mongoDbService = mongoDbService;
-        }
-
+        _mongoDbService = mongoDbService;
    }
+
 }
@@ -2,50 +2,116 @@
 using Core.Entities;
 using Application.Endpoints.Doctors.Login;
 using Application.Services.Database;
+using Application.Endpoints.Doctors.Registration;
+using Application.Endpoints.Doctors.ResetPassword;
+using Application.Endpoints.Doctors.Profile;

-namespace HealthcareManager.API.Controllers
+namespace HealthcareManager.API.Controllers;
+
+[ApiController]
+[Route("api/[controller]")]
+public class DoctorsController : ControllerBase
 {
-    [ApiController]
-    [Route("api/[controller]")]
-    public class DoctorsController : ControllerBase
+    private readonly IDoctorRepository _database;
+
+    public DoctorsController(IDoctorRepository database)
    {
-        private readonly IDoctorRepository _database;
+        _database = database ?? throw new ArgumentNullException(nameof(database));
+    }

-        public DoctorsController(IDoctorRepository database)
+    [HttpGet]
+    public async Task<ActionResult<Doctor>> GetAllDoctors()
+    {
+        var handler = new DoctorProfileHandler(_database);
+        var response = await handler.HandleGetAll();
+        if (!response.Success)
        {
-            _database = database ?? throw new ArgumentNullException(nameof(database));
+            return BadRequest(response);
        }

-        [HttpGet("{id}")]
-        public async Task<ActionResult<Doctor>> GetDoctor(int id)
+        return Ok(response.Data);
+    }
+
+    [HttpGet("{id}")]
+    public async Task<ActionResult<Doctor>> GetDoctor(Guid id)
+    {
+        var handler = new DoctorProfileHandler(_database);
+        var response = await handler.HandleGet(id);
+        if (!response.Success)
        {
-            return NotFound();
+            return BadRequest(response);
        }

-        [HttpPost]
-        public async Task<ActionResult<Doctor>> Login(DoctorLoginDTO doctor)
+        return Ok(response.Data);
+    }
+
+    [HttpPost("login")]
+    public async Task<ActionResult<Doctor>> Login(DoctorLoginDTO doctor)
+    {
+        var handler = new DoctorLoginHandler(_database);
+        var response = await handler.Handle(doctor).ConfigureAwait(false);
+
+        if(!response.Success) 
        {
-            var handler = new DoctorLoginHandler(_database);
-            var response = handler.Handle(doctor).Result;
+            return Unauthorized(response);
+        }

-            if(!response.Success) 
-            {
-                return Unauthorized(response);
-            }
+        return Ok(response);
+    }

+    [HttpPost("register")]
+    public async Task<ActionResult<Doctor>> Register(DoctorRegistrationDto doctor)
+    {
+        var handler = new DoctorRegistrationHandler(_database);
+        var response = await handler.Handle(doctor).ConfigureAwait(false);
+
+        if (!response.Success)
+        {
+            return Unauthorized(response);
+        }
+
+        return Ok(response);
+    }
+
+    [HttpPost("resetPassword")]
+    public async Task<IActionResult> ResetPassword(DoctorLoginDTO resetDoctorDto)
+    {
+        var handler = new DoctorResetPasswordHandler(_database);
+        var response = await handler.Handle(resetDoctorDto).ConfigureAwait(false);
+        
+        if (response.Success)
+        {
            return Ok(response);
        }

-        [HttpPut("{id}")]
-        public async Task<IActionResult> PutDoctor(int id, Doctor doctor)
+        return BadRequest(response);
+    }
+
+    [HttpPut("{id}/profile")]
+    public async Task<IActionResult> UpdateDoctorProfile(Guid id, [FromBody]DoctorProfileDTO doctorDto)
+    {
+        var handler = new DoctorProfileHandler(_database);
+        var response = await handler.HandleUpdate(id, doctorDto).ConfigureAwait(false);
+
+        if (response.Success)
        {
-            return NotFound();
+            return Ok(response);
        }

-        [HttpDelete("{id}")]
-        public async Task<IActionResult> DeleteDoctor(int id)
+        return BadRequest(response);
+    }
+
+    [HttpDelete("{id}/profile")]
+    public async Task<IActionResult> DeleteDoctorProfile(Guid id)
+    {
+        var handler = new DoctorProfileHandler(_database);
+        var response = await handler.HandleDelete(id).ConfigureAwait(false);
+
+        if (response.Success)
        {
-            return NotFound();
+            return NoContent();
        }
+
+        return BadRequest(response);
    }
 }
@@ -1,9 +1,67 @@
-using Microsoft.AspNetCore.Mvc;
+using Application.Endpoints.MedicalHistories;
+using Application.Services.Database;
+using Core.Entities;
+using Microsoft.AspNetCore.Mvc;

-namespace HealthcareManager.API.Controllers
+namespace HealthcareManager.API.Controllers;
+
+[ApiController]
+[Route("api/[controller]")]
+public class MedicalHistoryController : ControllerBase
 {
-    public class MedicalHistoryController : BaseApiController
-    {
+    private readonly IMedicalHistoryRepository _medicalHistoryRepository;
+    private readonly IPacientRepository _pacientRepository;

+    public MedicalHistoryController(IMedicalHistoryRepository medicalHistoryRepository, IPacientRepository pacientRepository)
+    {
+        _medicalHistoryRepository = medicalHistoryRepository ?? throw new ArgumentNullException(nameof(medicalHistoryRepository));
+        _pacientRepository = pacientRepository ?? throw new ArgumentNullException(nameof(pacientRepository));
+    }
+
+    [HttpGet("{id}")]
+    public async Task<ActionResult<MedicalHistory>> GetAsync(Guid id)
+    {
+        var handler = new MedicalHistoryHandler(_medicalHistoryRepository, _pacientRepository);
+        var response = await handler.HandleGet(id);
+        if (!response.Success)
+        {
+            return BadRequest(response);
+        }
+
+        return Ok(response.Data);
+    }
+
+    [HttpPost("{id}")]
+    public async Task<ActionResult<MedicalHistory>> PostAsync(Guid id, [FromBody] byte[] description)
+    {
+        var handler = new MedicalHistoryHandler(_medicalHistoryRepository, _pacientRepository);
+        var response = await handler.HandleCreate(id, description).ConfigureAwait(false);
+
+        if (!response.Success)
+        {
+            return Unauthorized(response);
+        }
+
+        return Ok(response);
+    }
+
+    [HttpPut("{id}")]
+    public async Task<IActionResult> UpdateAsync(Guid id, [FromBody] MedicalHistoryDTO medicalHistoryDTO)
+    {
+        var handler = new MedicalHistoryHandler(_medicalHistoryRepository, _pacientRepository);
+        var response = await handler.HandleUpdate(id, medicalHistoryDTO).ConfigureAwait(false);
+
+        if (response.Success)
+        {
+            return Ok(response);
+        }
+
+        return BadRequest(response);
+    }
+
+    [HttpPut("grant_access")]
+    public async Task<IActionResult> GrantAccessToMedicalHistory(Guid id)
+    {
+        return NotFound();
    }
 }
@@ -1,9 +1,117 @@
 using Microsoft.AspNetCore.Mvc;
+using Core.Entities;
+using Application.Endpoints.Pacients.Login;
+using Application.Services.Database;
+using Application.Endpoints.Pacients.Registration;
+using Application.Endpoints.Pacients.ResetPassword;
+using Application.Endpoints.Pacients.Profile;

-namespace HealthcareManager.API.Controllers
+namespace HealthcareManager.API.Controllers;
+
+[ApiController]
+[Route("api/[controller]")]
+public class PacientsController : ControllerBase
 {
-    public class PacientsController : BaseApiController
+    private readonly IPacientRepository _database;
+
+    public PacientsController(IPacientRepository database)
    {
-    
+        _database = database ?? throw new ArgumentNullException(nameof(database));
+    }
+
+    [HttpGet]
+    public async Task<ActionResult<Pacient>> GetAllPacients()
+    {
+        var handler = new PacientProfileHandler(_database);
+        var response = await handler.HandleGetAll();
+        if (!response.Success)
+        {
+            return BadRequest(response);
+        }
+
+        return Ok(response.Data);
+    }
+
+    [HttpGet("{id}")]
+    public async Task<ActionResult<Pacient>> GetPacient(Guid id)
+    {
+        var handler = new PacientProfileHandler(_database);
+        var response = await handler.HandleGet(id);
+        if (!response.Success)
+        {
+            return BadRequest(response);
+        }
+
+        return Ok(response.Data);
+    }
+
+    [HttpPost("login")]
+    public async Task<ActionResult<Pacient>> Login(PacientLoginDTO pacient)
+    {
+        var handler = new PacientLoginHandler(_database);
+        var response = await handler.Handle(pacient).ConfigureAwait(false);
+
+        if (!response.Success)
+        {
+            return Unauthorized(response);
+        }
+
+        return Ok(response);
+    }
+
+    [HttpPost("register")]
+    public async Task<ActionResult<Pacient>> Register(PacientRegistrationDto pacient)
+    {
+        var handler = new PacientRegistrationHandler(_database);
+        var response = await handler.Handle(pacient).ConfigureAwait(false);
+
+        if (!response.Success)
+        {
+            return Unauthorized(response);
+        }
+
+        return Ok(response);
+    }
+
+    [HttpPost("resetPassword")]
+    public async Task<IActionResult> ResetPassword(PacientLoginDTO resetPacientDto)
+    {
+        var handler = new PacientResetPasswordHandler(_database);
+        var response = await handler.Handle(resetPacientDto).ConfigureAwait(false);
+
+        if (response.Success)
+        {
+            return Ok(response);
+        }
+
+        return BadRequest(response);
+    }
+
+    [HttpPut("{id}/profile")]
+    public async Task<IActionResult> UpdatePacientProfile(Guid id, [FromBody] PacientProfileDTO pacientDto)
+    {
+        var handler = new PacientProfileHandler(_database);
+        var response = await handler.HandleUpdate(id, pacientDto).ConfigureAwait(false);
+
+        if (response.Success)
+        {
+            return Ok(response);
+        }
+
+        return BadRequest(response);
+    }
+
+    [HttpDelete("{id}/profile")]
+    public async Task<IActionResult> DeletePacientProfile(Guid id)
+    {
+        var handler = new PacientProfileHandler(_database);
+        var response = await handler.HandleDelete(id).ConfigureAwait(false);
+
+        if (response.Success)
+        {
+            return NoContent();
+        }
+
+        return BadRequest(response);
    }
 }