finalizare 1.0

backend/.idea/.idea.HealthcareManagerAPI/.idea/dataSources.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="DataSourceManagerImpl" format="xml" multifile-model="true">
+    <data-source source="LOCAL" name="HealthcareManager@90.84.229.219" uuid="f6be1e56-3512-42f6-bedf-802e64a8abba">
+      <driver-ref>postgresql</driver-ref>
+      <synchronize>true</synchronize>
+      <configured-by-url>true</configured-by-url>
+      <jdbc-driver>org.postgresql.Driver</jdbc-driver>
+      <jdbc-url>jdbc:postgresql://90.84.229.219:5432/HealthcareManager?password=postgres&amp;user=andrei_cerbu</jdbc-url>
+      <jdbc-additional-properties>
+        <property name="com.intellij.clouds.kubernetes.db.host.port" />
+        <property name="com.intellij.clouds.kubernetes.db.enabled" value="false" />
+        <property name="com.intellij.clouds.kubernetes.db.container.port" />
+      </jdbc-additional-properties>
+      <working-dir>$ProjectFileDir$</working-dir>
+    </data-source>
+    <data-source source="LOCAL" name="HealthcareManager@90.84.229.219 [2]" uuid="c2359f9f-6745-4157-82b7-903ad4f11f73">
+      <driver-ref>mongo</driver-ref>
+      <synchronize>true</synchronize>
+      <configured-by-url>true</configured-by-url>
+      <jdbc-driver>com.dbschema.MongoJdbcDriver</jdbc-driver>
+      <jdbc-url>mongodb://andrei_cerbu:mongodb@90.84.229.219:27017/HealthcareManager?ssl=false&amp;authSource=admin&amp;authMechanism=SCRAM-SHA-1</jdbc-url>
+      <working-dir>$ProjectFileDir$</working-dir>
+    </data-source>
+  </component>
+</project>

backend/.idea/.idea.HealthcareManagerAPI/.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.12 (backend)" />
+  </component>
+</project>

backend/API/API.csproj

@@ -8,6 +8,8 @@
 
     <ItemGroup>
         <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="8.0.3"/>
+        <PackageReference Include="MongoDB.Driver" Version="2.25.0"/>
+        <PackageReference Include="Newtonsoft.Json" Version="13.0.3"/>
         <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0"/>
     </ItemGroup>
 

backend/API/Controllers/AppointmentsController.cs

@@ -1,57 +1,58 @@
 using Application.Endpoints;
 using Application.Endpoints.Appointments;
+using Application.Endpoints.Appointments.CreateAppointment;
+using Application.Endpoints.Appointments.DeleteAppointment;
+using Application.Endpoints.Appointments.QuerriesAppointments;
 using Application.Services.Database.MongoDB;
 using Application.Services.Database.PostgreSQL;
+using Domain;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
 namespace API.Controllers;
 
 [Route("api/[controller]")]
-public class AppointmentsController : BaseApiController
+public class AppointmentsController(
+    IAppointmentsMongoDbService appointmentsMongoDbService,
+    IPatientRepository patientRepository,
+    IDoctorRepository doctorRepository)
+    : BaseApiController
 {
-    private readonly IAppointmentsMongoDbService _appointmentsMongoDbService;
+    [Authorize(Policy = Policies.ClientsOnlyPolicy)]
-    private readonly IDoctorRepository _doctorRepository;
-    private readonly IPatientRepository _patientRepository;
-
-    public AppointmentsController(IAppointmentsMongoDbService appointmentsMongoDbService,
-        IPatientRepository patientRepository, IDoctorRepository doctorRepository)
-    {
-        _appointmentsMongoDbService = appointmentsMongoDbService;
-        _patientRepository = patientRepository;
-        _doctorRepository = doctorRepository;
-    }
-
     [HttpPost]
-    public async Task<ActionResult<BaseResponse>> CreateAppointment(AppointmentManagementDto dto)
+    public async Task<ActionResult<BaseResponse>> CreateAppointment(AppointmentInformation request,
+        CancellationToken token)
     {
-        var handler =
+        var handler = new CreateAppointmentHandler(appointmentsMongoDbService, patientRepository, doctorRepository);
-            new AppointmentManagementHandler(_appointmentsMongoDbService, _patientRepository, _doctorRepository);
+        var response = await handler.Handle(request, token);
-        var response = await handler.HandleCreateAppointment(dto).ConfigureAwait(false);
         return StatusCode(response.StatusCode, response);
     }
 
-    [HttpDelete]
+    [Authorize(Policy = Policies.ClientsOnlyPolicy)]
-    public async Task<ActionResult<BaseResponse>> DeleteAppointment(AppointmentManagementDto dto)
+    [HttpPut]
+    public async Task<ActionResult<BaseResponse>> DeleteAppointment(AppointmentInformation request,
+        CancellationToken token)
     {
-        var handler =
+        var handler = new DeleteAppointmentHandler(appointmentsMongoDbService, patientRepository, doctorRepository);
-            new AppointmentManagementHandler(_appointmentsMongoDbService, _patientRepository, _doctorRepository);
+        var response = await handler.Handle(request, token);
-        var response = await handler.HandleDeleteAppointment(dto).ConfigureAwait(false);
         return StatusCode(response.StatusCode, response);
     }
 
+    [Authorize(Policy = Policies.ClientsOnlyPolicy)]
     [HttpGet("patient/{id:guid}")]
-    public async Task<ActionResult<BaseResponse>> GetAppointmentsByPatient(Guid id)
+    public async Task<ActionResult<BaseResponse>> GetAppointmentsByPatient(Guid id, CancellationToken token)
     {
-        var handler = new AppointmentManagementHandler(_appointmentsMongoDbService, _patientRepository, _doctorRepository);
+        var handler = new QuerriesAppointmentHandler(appointmentsMongoDbService);
-        var response = await handler.HandleGetAppointmentsByPatientId(id);
+        var response = await handler.GetByPatientId(id, token);
         return StatusCode(response.StatusCode, response);
     }
 
+    [Authorize(Policy = Policies.ClientsOnlyPolicy)]
     [HttpGet("doctor/{id:guid}")]
-    public async Task<ActionResult<BaseResponse>> GetAppointmentsByDoctor(Guid id)
+    public async Task<ActionResult<BaseResponse>> GetAppointmentsByDoctor(Guid id, CancellationToken token)
     {
-        var handler = new AppointmentManagementHandler(_appointmentsMongoDbService, _patientRepository, _doctorRepository);
+        var handler = new QuerriesAppointmentHandler(appointmentsMongoDbService);
-        var response = await handler.HandleGetAppointmentsByDoctorId(id);
+        var response = await handler.GetsByDoctorId(id, token);
         return StatusCode(response.StatusCode, response);
     }
 }

backend/API/Controllers/AuthorizationController.cs

@@ -1,148 +1,68 @@
 using Application.Endpoints;
-using Application.Endpoints.Authorization;
+using Application.Endpoints.Authorization.RefreshToken;
-using Application.Endpoints.Authorization.Doctor;
+using Application.Endpoints.Authorization.UserLogin;
-using Application.Endpoints.Authorization.Patient;
+using Application.Endpoints.Authorization.UserRegister;
+using Application.Endpoints.Authorization.UserResetPassword;
 using Application.Services.Database.PostgreSQL;
 using Application.Services.Email;
 using Application.Services.HashingAlgorithms;
 using Application.Services.Jwt;
-using Core.Entities;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
 namespace API.Controllers;
 
 [Route("api/[controller]")]
-public class AuthorizationController : BaseApiController
+public class AuthorizationController(
-{
+    IEmailService emailService,
-    private readonly IJwtService _jwtService;
+    IJwtService jwtService,
-    private readonly IEmailService _emailService;
+    IPatientRepository patientRepository,
-    private readonly IPatientRepository _patientRepository;
+    IDoctorRepository doctorRepository,
-    private readonly IDoctorRepository _doctorRepository;
+    IAdminRepository adminRepository,
-    private readonly IHashingAlgorithms _hashingAlgorithms;
-
-    public AuthorizationController(IEmailService emailService, IJwtService jwtService,
-        IPatientRepository patientRepository, IDoctorRepository doctorRepository,
     IHashingAlgorithms hashingAlgorithms)
-    {
+    : BaseApiController
-        _jwtService = jwtService;
+{
-        _emailService = emailService;
+    [Authorize(Policy = Policies.AnonymousPolicy)]
-        _patientRepository = patientRepository;
-        _doctorRepository = doctorRepository;
-        _hashingAlgorithms = hashingAlgorithms;
-    }
-    
     [HttpPost("login")]
-    public async Task<ActionResult<BaseResponse>> Login(UserLoginModel dto)
+    public async Task<ActionResult<BaseResponse>> Login(UserLoginCommand request, CancellationToken token)
     {
-        BaseResponse? response = null;
+        var handler = new UserLoginHandler(jwtService, hashingAlgorithms, doctorRepository,
-        var loginInfo = new LoginDto();
+            patientRepository, adminRepository);
-        loginInfo.Email = dto.Email;
-        loginInfo.Password = dto.Password;
 
-        switch (dto.UserType)
+        var result = await handler.Handle(request, token);
-        {
+        return StatusCode(result.StatusCode, result);
-            case "doctor":
-                var handlerDoctor = new DoctorLoginHandler(_doctorRepository, _hashingAlgorithms);
-                response = await handlerDoctor.Handle(loginInfo).ConfigureAwait(false);
-                
-                if (response.Data != null)
-                {
-                    Doctor patient = (Doctor)response.Data;
-                    var authToken = _jwtService.GenerateJwtToken(patient.Email);
-                    Console.WriteLine(patient.Email);
-
-                    HttpContext.Response.Headers.Add("Authorization", $"Bearer {authToken}");
-                }
-                break;
-            case "patient":
-                var handlerPatient = new PatientLoginHandler(_patientRepository, _hashingAlgorithms);
-                response = await handlerPatient.Handle(loginInfo).ConfigureAwait(false);
-                
-                if (response.Data != null)
-                {
-                    Patient patient = (Patient)response.Data;
-                    var authToken = _jwtService.GenerateJwtToken(patient.Email);
-
-                    HttpContext.Response.Headers.Add("Authorization", $"Bearer {authToken}");
-                }
-                break;
-            default:
-                return new ActionResult<BaseResponse>(new BaseResponse
-                {
-                    StatusCode = HttpStatusCodes.BadRequest,
-                    Message = "Need user type.",
-                    Data = null
-                });
     }
 
-        return StatusCode(response.StatusCode, response);
+    [Authorize(Policy = Policies.AnonymousPolicy)]
+    [HttpPost("register")]
+    public async Task<ActionResult<BaseResponse>> Register(UserRegisterCommand request, CancellationToken token)
+    {
+        var handler = new UserRegisterHandler(emailService, hashingAlgorithms, doctorRepository,
+            patientRepository, adminRepository);
+
+        var result = await handler.Handle(request, token);
+        return StatusCode(result.StatusCode, result);
     }
 
+    [Authorize(Policy = Policies.AnonymousPolicy)]
     [HttpPost("reset_password")]
-    public async Task<ActionResult<BaseResponse>> ResetPassword(UserLoginModel dto)
+    public async Task<ActionResult<BaseResponse>> ResetPassword(UserResetPasswordCommand request,
+        CancellationToken token)
     {
-        BaseResponse? response = null;
+        var handler = new UserResetPasswordHandler(emailService, hashingAlgorithms, doctorRepository,
-        var loginInfo = new LoginDto();
+            patientRepository, adminRepository);
-        loginInfo.Email = dto.Email;
-        loginInfo.Password = dto.Password;
 
-        switch (dto.UserType)
+        var result = await handler.Handle(request, token);
-        {
+        return StatusCode(result.StatusCode, result);
-            case "doctor":
-                var handlerDoctor = new DoctorResetPasswordHandler(_doctorRepository, _hashingAlgorithms);
-                response = await handlerDoctor.Handle(loginInfo).ConfigureAwait(false);
-                break;
-            case "patient":
-                var handlerPatient = new PatientResetPasswordHandler(_patientRepository, _hashingAlgorithms);
-                response = await handlerPatient.Handle(loginInfo).ConfigureAwait(false);
-                break;
-            default:
-                return new ActionResult<BaseResponse>(new BaseResponse
-                {
-                    StatusCode = HttpStatusCodes.BadRequest,
-                    Message = "Need user type.",
-                    Data = null
-                });
-        }
-
-        if (response.StatusCode < HttpStatusCodes.BadRequest)
-        {
-            var body = _emailService.GenerateResetCredentialsEmailBody(
-                loginInfo.Email, loginInfo.Password);
-            await _emailService.SendEmailAsync(loginInfo.Email, "Password reset successfully!", body);
-        }
-
-        return StatusCode(response.StatusCode, response);
     }
 
+    [Authorize(Policy = Policies.AnonymousPolicy)]
     [HttpPost("refresh_token")]
-    public async Task<ActionResult<BaseResponse>> RefreshToken()
+    public async Task<ActionResult<BaseResponse>> RefreshToken([FromBody] RefreshJwtCommand request,
+        CancellationToken cancellationToken)
     {
-        var authorizationHeader = Request.Headers["Authorization"].FirstOrDefault();
+        var handler = new RefreshJwtHandler(jwtService);
-        if (string.IsNullOrEmpty(authorizationHeader) || !authorizationHeader.StartsWith("Bearer "))
+        var result = await handler.Handle(request, cancellationToken);
-            return StatusCode(HttpStatusCodes.BadRequest, new BaseResponse
+        return StatusCode(result.StatusCode, result);
-            {
-                StatusCode = HttpStatusCodes.BadRequest,
-                Message = "Invalid request header format.",
-                Data = null
-            });
-
-        var oldToken = authorizationHeader.Substring("Bearer ".Length).Trim();
-
-        if (!_jwtService.ValidateJwtToken(oldToken))
-            return StatusCode(HttpStatusCodes.Unauthorized, new BaseResponse
-            {
-                StatusCode = HttpStatusCodes.Unauthorized,
-                Message = "Invalid JWT token.",
-                Data = null
-            });
-
-        var newToken = _jwtService.RefreshToken(oldToken);
-        return StatusCode(HttpStatusCodes.OK, new BaseResponse
-        {
-            StatusCode = HttpStatusCodes.OK,
-            Message = "Token refreshed successfully.",
-            Data = new { Token = newToken }
-        });
     }
 }

backend/API/Controllers/ChatController.cs

@@ -1,39 +1,37 @@
 using Application.Endpoints;
 using Application.Endpoints.Chats;
+using Application.Endpoints.Chats.GetChats;
+using Application.Endpoints.Chats.SendMessage;
 using Application.Services.Database.MongoDB;
 using Application.Services.Database.PostgreSQL;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
 namespace API.Controllers;
 
 [Route("api/[controller]")]
-public class ChatController : BaseApiController
+public class ChatController(
-{
+    IChatMongoDbService chatMongoDbService,
-    private readonly IChatMongoDbService _chatMongoDbService;
+    IPatientRepository patientRepository,
-    private readonly IDoctorRepository _doctorRepository;
-    private readonly IPatientRepository _patientRepository;
-
-    public ChatController(IChatMongoDbService chatMongoDbService, IPatientRepository patientRepository,
     IDoctorRepository doctorRepository)
-    {
+    : BaseApiController
-        _chatMongoDbService = chatMongoDbService;
+{
-        _patientRepository = patientRepository;
+    [Authorize(Policy = Policies.ClientsOnlyPolicy)]
-        _doctorRepository = doctorRepository;
-    }
-
     [HttpPost("send_message")]
-    public async Task<ActionResult<BaseResponse>> SendMessage(SendMessageDto sendMessageDto)
+    public async Task<ActionResult<BaseResponse>> SendMessage(SendMessageCommand request, CancellationToken token)
     {
-        var handler = new ChatHandler(_chatMongoDbService, _patientRepository, _doctorRepository);
+        var handler = new SendMessageHandler(chatMongoDbService, patientRepository, doctorRepository);
-        var response = await handler.HandleSendMessage(sendMessageDto).ConfigureAwait(false);
+        var response = await handler.Handle(request, token);
         return StatusCode(response.StatusCode, response);
     }
 
+    [Authorize(Policy = Policies.ClientsOnlyPolicy)]
     [HttpPost("get_conversation")]
-    public async Task<ActionResult<BaseResponse>> GetConversation(GetConversationDto getConversationDto)
+    public async Task<ActionResult<BaseResponse>> GetConversation(
+        GetConversationsCommand request, CancellationToken token)
     {
-        var handler = new ChatHandler(_chatMongoDbService, _patientRepository, _doctorRepository);
+        var handler = new GetConversationsHandler(chatMongoDbService, patientRepository, doctorRepository);
-        var response = await handler.HandleGetConversation(getConversationDto).ConfigureAwait(false);
+        var response = await handler.HandleGetConversation(request, token);
         return StatusCode(response.StatusCode, response);
     }
 }

backend/API/Controllers/DoctorsController.cs

@@ -1,94 +1,72 @@
 using Application.Endpoints;
-using Application.Endpoints.Authorization.Doctor;
+using Application.Endpoints.Doctors.DeleteDoctor;
-using Application.Endpoints.Doctors.Profile;
+using Application.Endpoints.Doctors.ModifyDoctor;
-using Application.Endpoints.Doctors.Registration;
+using Application.Endpoints.Doctors.QuerriesDoctors;
 using Application.Services.Database.MongoDB;
 using Application.Services.Database.PostgreSQL;
 using Application.Services.Email;
 using Application.Services.HashingAlgorithms;
-using Application.Services.Jwt;
+using Domain.Entities;
-using Core.Entities;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
 namespace API.Controllers;
 
 [ApiController]
 [Route("api/[controller]")]
-public class DoctorsController : ControllerBase
+public class DoctorsController(
+    IDoctorRepository doctorRepository,
+    IPatientRepository patientRepository,
+    IAdminRepository adminRepository,
+    IHashingAlgorithms hashingAlgorithms,
+    IAppointmentsMongoDbService appointmentsMongoDbService)
+    : ControllerBase
 {
-    private readonly IAppointmentsMongoDbService _appointmentsMongoDbService;
+    [Authorize(Policy = Policies.AuthenticatedPolicy)]
-    private readonly IDoctorRepository _doctorRepository;
-    private readonly IHashingAlgorithms _hashingAlgorithms;
-    private readonly IEmailService _emailService;
-
-    public DoctorsController(IDoctorRepository doctorRepository, IHashingAlgorithms hashingAlgorithms,
-        IAppointmentsMongoDbService appointmentsMongoDbService, IEmailService emailService)
-    {
-        _doctorRepository = doctorRepository;
-        _hashingAlgorithms = hashingAlgorithms;
-        _appointmentsMongoDbService = appointmentsMongoDbService;
-        _emailService = emailService;
-    }
-
-    [HttpPost("register")]
-    public async Task<ActionResult<BaseResponse>> Register(DoctorRegistrationDto doctorRegistrationDto)
-    {
-        var handler = new DoctorRegistrationHandler(_doctorRepository, _hashingAlgorithms);
-        var response = await handler.Handle(doctorRegistrationDto).ConfigureAwait(false);
-        
-        if (response.StatusCode < HttpStatusCodes.BadRequest)
-        {
-            var body = _emailService.GenerateCredentialsEmailBody(
-                doctorRegistrationDto.Email, doctorRegistrationDto.Password);
-            await _emailService.SendEmailAsync(doctorRegistrationDto.Email, "Successful registration!", body);
-        }
-        
-        return StatusCode(response.StatusCode, response);
-    }
-
     [HttpGet]
-    public async Task<ActionResult<BaseResponse>> GetAllDoctors()
+    public async Task<ActionResult<BaseResponse>> GetAllDoctors(CancellationToken token)
     {
-        var handler = new DoctorProfileHandler(_doctorRepository, _hashingAlgorithms);
+        var handler = new QuerriesDoctorsHandler(doctorRepository);
-        var response = await handler.HandleGetAll();
+        var response = await handler.HandleGetAll(token);
         return StatusCode(response.StatusCode, response);
     }
 
+    [Authorize(Policy = Policies.AuthenticatedPolicy)]
     [HttpGet("{id}")]
-    public async Task<ActionResult<BaseResponse>> GetDoctor(Guid id)
+    public async Task<ActionResult<BaseResponse>> GetDoctor(Guid id, CancellationToken token)
     {
-        var handler = new DoctorProfileHandler(_doctorRepository, _hashingAlgorithms);
+        var handler = new QuerriesDoctorsHandler(doctorRepository);
-        var response = await handler.HandleGet(id);
+        var response = await handler.HandleGet(id, token);
+        if (response.StatusCode == HttpStatusCodes.NotFound)
+        {
+            return NotFound();
+        }
         return StatusCode(response.StatusCode, response);
     }
 
+    [Authorize(Policy = Policies.DoctorPolicy)]
     [HttpPut]
-    public async Task<ActionResult<BaseResponse>> UpdateDoctorProfile(DoctorProfileUpdateDto doctorUpdateDto)
+    public async Task<ActionResult<BaseResponse>> ModifyDoctor(ModifyDoctorCommand request, CancellationToken token)
     {
-        var handler = new DoctorProfileHandler(_doctorRepository, _hashingAlgorithms);
+        var handler = new ModifyDoctorHandler(hashingAlgorithms, doctorRepository, patientRepository, adminRepository);
-        var response = await handler.HandleUpdate(doctorUpdateDto).ConfigureAwait(false);
+        var response = await handler.Handle(request, token);
+        if (response.StatusCode == HttpStatusCodes.NoContent)
+        {
+            return NoContent();
+        }
         return StatusCode(response.StatusCode, response);
     }
 
+    [Authorize(Policy = Policies.DoctorPolicy)]
     [HttpDelete("{id}")]
-    public async Task<ActionResult<BaseResponse>> DeleteDoctorProfile(Guid id)
+    public async Task<ActionResult<BaseResponse>> DeleteDoctor(Guid id, CancellationToken token)
     {
-        var handler = new DoctorProfileHandler(_doctorRepository, _hashingAlgorithms);
+        var handler = new DeleteDoctorHandler(doctorRepository, appointmentsMongoDbService);
-        var response = await handler.HandleDelete(id).ConfigureAwait(false);
+        var response = await handler.Handle(id, token);
-
+        if (response.StatusCode == HttpStatusCodes.NoContent)
-        if (response.StatusCode < HttpStatusCodes.BadRequest) DeleteDoctorAppointments(id);
+        {
-
+            return NoContent();
-        return StatusCode(response.StatusCode, response);
         }
-
+        return StatusCode(response.StatusCode, response);
-    private async void DeleteDoctorAppointments(Guid doctorId)
-    {
-        var criteria = new List<(string FieldName, string Value)>
-        {
-            ("DoctorId", doctorId.ToString())
-        };
-        var appointments = await _appointmentsMongoDbService.FindAsync<Appointment>(criteria);
-        if (!appointments.Any()) return;
-        await _appointmentsMongoDbService.DeleteByIdAsync<Appointment>(appointments[0].Id);
     }
 }

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,
-    private readonly IDoctorRepository _doctorRepository;
+    IPatientRepository patientRepository,
-    private readonly IMedicalHistoryMongoDbService _medicalHistoryMongoDbService;
+    IMedicalHistoryMongoDbService medicalHistoryMongoDbService,
-    private readonly IMedicalHistoryRepository _medicalHistoryRepository;
-    private readonly IPatientRepository _patientRepository;
-
-    public MedicalHistoryController(IMedicalHistoryRepository medicalHistoryRepository,
-        IPatientRepository patientRepository, IMedicalHistoryMongoDbService mongoDbService,
     IDoctorRepository doctorRepository)
-    {
+    : ControllerBase
-        _medicalHistoryRepository = medicalHistoryRepository;
+{
-        _patientRepository = patientRepository;
+    [Authorize(Policy = Policies.ClientsOnlyPolicy)]
-        _medicalHistoryMongoDbService = mongoDbService;
-        _doctorRepository = doctorRepository;
-    }
-
     [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,
+        var handler = new QuerriesMedicalHistoriesHandler(medicalHistoryRepository);
-            _medicalHistoryMongoDbService);
+        var response = await handler.HandleGet(id, token);
-        var response = await handler.HandleGet(id);
         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,
+        var handler = new QuerriesMedicalHistoriesHandler(medicalHistoryRepository);
-            _medicalHistoryMongoDbService);
+        var response = await handler.HandleGetAll(token);
-        var response = await handler.HandleGetAll();
         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,
+        var handler =
-            _medicalHistoryMongoDbService);
+            new CreateMedicalHistoryHandler(medicalHistoryRepository, patientRepository, medicalHistoryMongoDbService);
-        var response = await handler.HandleCreate(medicalHistoryCreateDto);
+        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,
+        var handler = new ModifyMedicalHistoryHandler(medicalHistoryRepository);
-            _medicalHistoryMongoDbService);
+        var response = await handler.Handle(request, token);
-        var response = await handler.HandleUpdate(medicalHistoryUpdateDto).ConfigureAwait(false);
         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,
+        var handler = new DeleteMedicalHistoryHandler(medicalHistoryRepository, medicalHistoryMongoDbService);
-            _medicalHistoryMongoDbService);
+        var response = await handler.Handle(id, token);
-        var response = await handler.HandleDelete(id);
         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,
+        var handler = new MedicalHistoryManageAuthorizationHandler(medicalHistoryRepository,
-            _medicalHistoryMongoDbService, _doctorRepository);
+            medicalHistoryMongoDbService, doctorRepository);
-        var response = await handler.HandleGrantDoctorAccess(infoDto);
+        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,
+        var handler = new MedicalHistoryManageAuthorizationHandler(medicalHistoryRepository,
-            _medicalHistoryMongoDbService, _doctorRepository);
+            medicalHistoryMongoDbService, doctorRepository);
-        var response = await handler.HandleRevokeDoctorAccess(infoDto);
+        var response = await handler.HandleRevokeDoctorAccess(request, token);
         return StatusCode(response.StatusCode, response);
     }
 }

backend/API/Controllers/PatientsController.cs

@@ -1,93 +1,74 @@
 using Application.Endpoints;
-using Application.Endpoints.Patients.Profile;
+using Application.Endpoints.Patients.DeletePatient;
-using Application.Endpoints.Patients.Registration;
+using Application.Endpoints.Patients.ModifyPatient;
+using Application.Endpoints.Patients.QuerriesPatients;
+using Application.Services.Database.MongoDB;
 using Application.Services.Database.PostgreSQL;
-using Application.Services.HashingAlgorithms;
 using Application.Services.Email;
-using Application.Services.Jwt;
+using Application.Services.HashingAlgorithms;
-using Core.Entities;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
 namespace API.Controllers;
 
 [ApiController]
 [Route("api/[controller]")]
-public class PatientsController : ControllerBase
+public class PatientsController(
+    IPatientRepository patientRepository,
+    IDoctorRepository doctorRepository,
+    IAdminRepository adminRepository,
+    IHashingAlgorithms hashingAlgorithms,
+    IMedicalHistoryRepository medicalHistory,
+    IMedicalHistoryMongoDbService medicalHistoryMongoDbService)
+    : ControllerBase
 {
-    private readonly IHashingAlgorithms _hashingAlgorithms;
+    [Authorize(Policy = Policies.AuthenticatedPolicy)]
-    private readonly IMedicalHistoryRepository _medicalHistory;
-    private readonly IPatientRepository _patientRepository;
-    private readonly IEmailService _emailService;
-
-    public PatientsController(IPatientRepository patientRepository, IHashingAlgorithms hashingAlgorithms,
-        IMedicalHistoryRepository medicalHistory, IEmailService emailService)
-    {
-        _patientRepository = patientRepository;
-        _hashingAlgorithms = hashingAlgorithms;
-        _medicalHistory = medicalHistory;
-        _emailService = emailService;
-    }
-
     [HttpGet]
-    public async Task<ActionResult<BaseResponse>> GetAllPatients()
+    public async Task<ActionResult<BaseResponse>> GetAllPatients(CancellationToken token)
     {
-        var handler = new PatientProfileHandler(_patientRepository, _hashingAlgorithms);
+        var handler = new QuerriesPatientsHandle(patientRepository);
-        var response = await handler.HandleGetAll();
+        var response = await handler.HandleGetAll(token);
-        return StatusCode(response.StatusCode, response);
-    }
-
-    [HttpPost("register")]
-    public async Task<ActionResult<BaseResponse>> Register(PatientRegistrationDto patientRegistrationDto)
-    {
-        Console.WriteLine("Esti aici");
-        var handler = new PatientRegistrationHandler(_patientRepository, _hashingAlgorithms);
-        var response = await handler.Handle(patientRegistrationDto).ConfigureAwait(false);
-
-        if (response.StatusCode < HttpStatusCodes.BadRequest)
-        {
-            var body = _emailService.GenerateCredentialsEmailBody(
-                patientRegistrationDto.Email, patientRegistrationDto.Password);
-            await _emailService.SendEmailAsync(patientRegistrationDto.Email, "Successful registration!", body);
-        }
-        
         return StatusCode(response.StatusCode, response);
     }
 
+    [Authorize(Policy = Policies.AuthenticatedPolicy)]
     [HttpGet("{id}")]
-    public async Task<ActionResult<BaseResponse>> GetPatient(Guid id)
+    public async Task<ActionResult<BaseResponse>> GetPatient(Guid id, CancellationToken token)
     {
-        var handler = new PatientProfileHandler(_patientRepository, _hashingAlgorithms);
+        var handler = new QuerriesPatientsHandle(patientRepository);
-        var response = await handler.HandleGet(id);
+        var response = await handler.HandleGet(id, token);
+        if (response.StatusCode == HttpStatusCodes.NotFound)
+        {
+            return NotFound();
+        }
         return StatusCode(response.StatusCode, response);
     }
 
+    [Authorize(Policy = Policies.PatientPolicy)]
     [HttpPut]
-    public async Task<ActionResult<BaseResponse>> UpdatePatientProfile(PatientProfileDto patientDto)
+    public async Task<ActionResult<BaseResponse>> ModifyPatient(
+        ModifyPatientCommand request, CancellationToken token)
     {
-        var handler = new PatientProfileHandler(_patientRepository, _hashingAlgorithms);
+        var handler = new ModifyPatientHandler(hashingAlgorithms,
-        var response = await handler.HandleUpdate(patientDto).ConfigureAwait(false);
+            patientRepository, doctorRepository, adminRepository);
+        var response = await handler.Handle(request, token);
+        if (response.StatusCode == HttpStatusCodes.NoContent)
+        {
+            return NoContent();
+        }
         return StatusCode(response.StatusCode, response);
     }
 
+    [Authorize(Policy = Policies.PatientPolicy)]
     [HttpDelete("{id}")]
-    public async Task<ActionResult<BaseResponse>> DeletePatientProfile(Guid id)
+    public async Task<ActionResult<BaseResponse>> DeletePatientProfile(Guid id, CancellationToken token)
     {
-        var handler = new PatientProfileHandler(_patientRepository, _hashingAlgorithms);
+        var handler = new DeletePatientHandler(patientRepository, medicalHistory, medicalHistoryMongoDbService);
-        var response = await handler.HandleDelete(id).ConfigureAwait(false);
+        var response = await handler.Handle(id, token);
-
+        if (response.StatusCode == HttpStatusCodes.NoContent)
-        if (response.StatusCode < HttpStatusCodes.BadRequest) DeleteMedicalHistory(id);
+        {
-
+            return NoContent();
+        }
         return StatusCode(response.StatusCode, response);
     }
-
-    private async void DeleteMedicalHistory(Guid patientId)
-    {
-        var medicalHistoryList = await _medicalHistory.GetAllAsync();
-        foreach (var med in medicalHistoryList)
-            if (med.UserId == patientId)
-            {
-                await _medicalHistory.DeleteAsync(med);
-                return;
-            }
-    }
 }

backend/API/Controllers/SicknessPredictionController.cs

@@ -1,5 +1,6 @@
 using Application.Endpoints;
 using Application.Endpoints.SicknessPrediction;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
 namespace API.Controllers;
@@ -7,11 +8,11 @@ namespace API.Controllers;
 [Route("api/[controller]")]
 public class SicknessPredictionController : BaseApiController
 {
+    [Authorize(Policy = Policies.DoctorPolicy)]
     [HttpPost]
-    public async Task<ActionResult<BaseResponse>> GetPrediction(SicknessPredictionDto dto)
+    public async Task<ActionResult<BaseResponse>> GetPrediction(SicknessPredictionCommand command)
     {
-        var handler = new SicknessPredictionHandler();
+        var result = await SicknessPredictionHandler.GetPrediction(command);
-        var result = await handler.GetPrediction(dto);
         return StatusCode(result.StatusCode, result);
     }
 }

backend/API/Middlewares/ApiKeyValidationMiddleware.cs

@@ -1,35 +0,0 @@
-using Application.Endpoints;
-
-namespace API.Middlewares;
-
-public class ApiKeyMiddleware
-{
-    private const string API_KEY_HEADER_NAME = "ApiKey";
-    private readonly string _apiKey;
-    private readonly RequestDelegate _next;
-
-    public ApiKeyMiddleware(RequestDelegate next, IConfiguration configuration)
-    {
-        _next = next;
-        _apiKey = configuration.GetValue<string>("ApiKeySettings:ApiKey");
-    }
-
-    public async Task InvokeAsync(HttpContext context)
-    {
-        if (!context.Request.Headers.TryGetValue(API_KEY_HEADER_NAME, out var extractedApiKey))
-        {
-            context.Response.StatusCode = HttpStatusCodes.Unauthorized; // Unauthorized
-            await context.Response.WriteAsync("API Key is missing");
-            return;
-        }
-
-        if (!_apiKey.Equals(extractedApiKey))
-        {
-            context.Response.StatusCode = HttpStatusCodes.Forbidden; // Forbidden
-            await context.Response.WriteAsync("Invalid API Key");
-            return;
-        }
-
-        await _next(context); // API Key is valid, proceed to the next middleware
-    }
-}

backend/API/Middlewares/BodyCheckMiddleware.cs

@@ -1,34 +0,0 @@
-using System.Net;
-using System.Text;
-
-namespace API.Middlewares;
-
-public class BodyCheckMiddleware(RequestDelegate next)
-{
-    private readonly RequestDelegate _next = next;
-
-    public async Task InvokeAsync(HttpContext context)
-    {
-        // Only check the body for POST and PUT requests
-        if (context.Request.Method == HttpMethods.Post || context.Request.Method == HttpMethods.Put)
-        {
-            // Enable buffering so we can read the stream without issues downstream
-            context.Request.EnableBuffering();
-
-            var buffer = new byte[Convert.ToInt32(context.Request.ContentLength)];
-            await context.Request.Body.ReadAsync(buffer, 0, buffer.Length);
-            var requestBody = Encoding.UTF8.GetString(buffer);
-            context.Request.Body.Seek(0, SeekOrigin.Begin); // Reset the stream for next middleware
-
-            // Check if the body is empty
-            if (string.IsNullOrEmpty(requestBody))
-            {
-                context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
-                await context.Response.WriteAsync("Request body cannot be empty.");
-                return;
-            }
-        }
-
-        await _next(context);
-    }
-}

backend/API/Middlewares/JwtMiddleware.cs

@@ -1,58 +0,0 @@
-using System.Text.Json;
-using Application.Endpoints;
-using Application.Services.Jwt;
-
-namespace API.Middlewares;
-
-public class JwtMiddleware
-{
-    private readonly IJwtService _jwtService;
-    private readonly RequestDelegate _next;
-    private readonly ILogger<JwtMiddleware> _logger;
-
-    public JwtMiddleware(RequestDelegate next, IJwtService jwtService, ILogger<JwtMiddleware> logger)
-    {
-        _next = next;
-        _jwtService = jwtService;
-        _logger = logger;
-    }
-
-    public async Task Invoke(HttpContext context)
-    {
-        var path = context.Request.Path.ToString().ToLower();
-        var bypassPaths = new[]
-        {
-            "/api/authorization/login",
-            "/api/doctors/register",
-            "/api/patients/register",
-            "/api/authorization/reset_password"
-        };
-
-        if (bypassPaths.Contains(path))
-        {
-            await _next(context);
-        }
-        else
-        {
-            var token = context.Request.Headers.Authorization.FirstOrDefault()?.Split(" ").Last();
-            _logger.LogInformation(token);
-            if (token != null && _jwtService.ValidateJwtToken(token))
-            {
-                await _next(context);
-            }
-            else
-            {
-                context.Response.StatusCode = StatusCodes.Status401Unauthorized;
-                context.Response.ContentType = "application/json";
-                var response = new BaseResponse
-                {
-                    StatusCode = StatusCodes.Status401Unauthorized,
-                    Message = "Invalid JWT Token",
-                    Data = null
-                };
-                var responseJson = JsonSerializer.Serialize(response);
-                await context.Response.WriteAsync(responseJson);
-            }
-        }
-    }
-}

backend/API/Policies.cs

@@ -0,0 +1,11 @@
+namespace API;
+
+public static class Policies
+{
+    public const string AdminPolicy = "AdminPolicy";
+    public const string DoctorPolicy = "DoctorPolicy";
+    public const string PatientPolicy = "PatientPolicy";
+    public const string AuthenticatedPolicy = "AuthenticatedPolicy";
+    public const string ClientsOnlyPolicy = "ClientsOnlyPolicy";
+    public const string AnonymousPolicy = "AnonymousPolicy";
+}

backend/API/Program.cs

@@ -1,23 +1,30 @@
-using API.Middlewares;
+using System.Text;
+using API;
+using Domain;
 using Infrastructure;
-using Infrastructure.Data;
+using Infrastructure.Services.Authentication;
-using Microsoft.EntityFrameworkCore;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.IdentityModel.Tokens;
 using Microsoft.OpenApi.Models;
 
 var builder = WebApplication.CreateBuilder(args);
 
-// Configure Kestrel with certificate paths from appsettings.json
+StartupHelper.EnsureKeysGenerated(builder.Configuration, builder.Environment.ContentRootPath);
+StartupHelper.EnsureMongoDatabaseAndCollectionsExist(builder.Configuration);
+StartupHelper.EnsurePythonEnvironment(builder.Environment.ContentRootPath);
+
 builder.WebHost.ConfigureKestrel((context, serverOptions) =>
 {
-    serverOptions.Configure(context.Configuration.GetSection("Kestrel"), reloadOnChange: true);
+    serverOptions.Configure(context.Configuration.GetSection("Kestrel"), true);
 });
 
 builder.Services.AddCors(options =>
 {
     options.AddPolicy("AllowAll",
-        builder =>
+        corsPolicyBuilder =>
         {
-            builder.AllowAnyOrigin()
+            corsPolicyBuilder.AllowAnyOrigin()
                 .AllowAnyMethod()
                 .AllowAnyHeader()
                 .WithExposedHeaders("*"); // This exposes all headers
@@ -30,15 +37,62 @@ builder.Services.AddInfrastructureServices(builder.Configuration);
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen(c =>
 {
+    // Add Bearer token authentication
+    c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
+    {
+        Description = "JWT Authorization header using the Bearer scheme. Example: 'Authorization: Bearer {token}'",
+        Name = "Authorization",
+        In = ParameterLocation.Header,
+        Type = SecuritySchemeType.Http,
+        Scheme = "Bearer"
+    });
+
+    c.AddSecurityRequirement(new OpenApiSecurityRequirement
+    {
+        {
+            new OpenApiSecurityScheme
+            {
+                Reference = new OpenApiReference
+                {
+                    Type = ReferenceType.SecurityScheme,
+                    Id = "Bearer"
+                },
+                Scheme = "oauth2",
+                Name = "Bearer",
+                In = ParameterLocation.Header
+            },
+            new List<string>()
+        }
+    });
+
+    // Add API key authentication
     c.AddSecurityDefinition("ApiKey", new OpenApiSecurityScheme
     {
-        Description = "ApiKey must appear in header",
+        Description = "API key needed to access the endpoints. ApiKey must appear in header",
         Type = SecuritySchemeType.ApiKey,
         Name = "ApiKey",
-        In = ParameterLocation.Header,
+        In = ParameterLocation.Header
-        Scheme = "ApiKeyScheme"
     });
-    var key = new OpenApiSecurityScheme
+
+    // Apply the security to all Swagger documents
+    c.AddSecurityRequirement(new OpenApiSecurityRequirement()
+    {
+        {
+            new OpenApiSecurityScheme
+            {
+                Reference = new OpenApiReference
+                {
+                    Type = ReferenceType.SecurityScheme,
+                    Id = "Bearer"
+                },
+                Scheme = "oauth2",
+                Name = "Bearer",
+                In = ParameterLocation.Header
+            },
+            new List<string>()
+        },
+        {
+            new OpenApiSecurityScheme
             {
                 Reference = new OpenApiReference
                 {
@@ -46,14 +100,61 @@ builder.Services.AddSwaggerGen(c =>
                     Id = "ApiKey"
                 },
                 In = ParameterLocation.Header
-    };
+            },
-    var requirement = new OpenApiSecurityRequirement
+            new List<string>()
-    {
+        }
-        { key, new List<string>() }
+    });
-    };
-    c.AddSecurityRequirement(requirement);
 });
 
+
+builder.Services.AddAuthentication(options =>
+    {
+        options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
+        options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
+    })
+    .AddJwtBearer(options =>
+    {
+        options.Events = new JwtBearerEvents
+        {
+            OnAuthenticationFailed = context =>
+            {
+                Console.WriteLine("Authentication failed: " + context.Exception.Message);
+                return Task.CompletedTask;
+            },
+            OnTokenValidated = context =>
+            {
+                Console.WriteLine("Token validated: " + context.SecurityToken);
+                return Task.CompletedTask;
+            },
+            OnChallenge = context =>
+            {
+                Console.WriteLine("OnChallenge error: " + context.ErrorDescription);
+                return Task.CompletedTask;
+            }
+        };
+        options.TokenValidationParameters = new TokenValidationParameters
+        {
+            ValidateIssuerSigningKey = true,
+            IssuerSigningKey =
+                new SymmetricSecurityKey(Encoding.ASCII.GetBytes(builder.Configuration["Jwt:SecretKey"])),
+            ValidateIssuer = true,
+            ValidateAudience = true,
+            ValidIssuer = builder.Configuration["Jwt:Issuer"],
+            ValidAudience = builder.Configuration["Jwt:Audience"],
+            ClockSkew = TimeSpan.Zero
+        };
+    })
+    .AddScheme<AuthenticationSchemeOptions, ApiKeyAuthenticationHandler>("ApiKey", options => { });
+
+builder.Services.AddAuthorizationBuilder()
+    .AddPolicy(Policies.AdminPolicy, policy => { policy.RequireRole(UserRoles.Admin); })
+    .AddPolicy(Policies.DoctorPolicy, policy => { policy.RequireRole(UserRoles.Admin, UserRoles.Doctor); })
+    .AddPolicy(Policies.PatientPolicy, policy => { policy.RequireRole(UserRoles.Patient, UserRoles.Admin); })
+    .AddPolicy(Policies.AuthenticatedPolicy,
+        policy => { policy.RequireRole(UserRoles.Patient, UserRoles.Admin, UserRoles.Doctor); })
+    .AddPolicy(Policies.ClientsOnlyPolicy, policy => { policy.RequireRole(UserRoles.Patient, UserRoles.Doctor); })
+    .AddPolicy(Policies.AnonymousPolicy, policy => { policy.RequireAssertion(_ => true); });
+
 var app = builder.Build();
 
 if (app.Environment.IsDevelopment())
@@ -63,25 +164,16 @@ if (app.Environment.IsDevelopment())
 }
 
 app.UseCors("AllowAll");
-app.UseHttpsRedirection();
+app.UseAuthentication();
-app.MapControllers();
+app.UseAuthorization();
 
-// Middlewares
+app.MapControllers();
-app.UseMiddleware<ApiKeyMiddleware>();
-app.UseMiddleware<BodyCheckMiddleware>();
-app.UseMiddleware<JwtMiddleware>();
 
 using (var scope = app.Services.CreateScope())
 {
     var services = scope.ServiceProvider;
     var dbContext = services.GetRequiredService<HealthcareManagerDatabase>(); // Directly resolving your DbContext
-    EnsureDatabaseCreated(dbContext);
+    StartupHelper.EnsureDatabaseCreated(dbContext);
 }
 
 app.Run();
-
-static void EnsureDatabaseCreated(HealthcareManagerDatabase dbContext)
-{
-    // Checking for pending migrations is more efficient than applying migrations unconditionally
-    if (dbContext.Database.GetPendingMigrations().Any()) dbContext.Database.Migrate();
-}

backend/API/Properties/launchSettings.json

@@ -4,8 +4,7 @@
     "windowsAuthentication": false,
     "anonymousAuthentication": true,
     "iisExpress": {
-      "applicationUrl": "http://localhost:5000",
+      "applicationUrl": "http://localhost:5000"
-      "sslPort": 5001
     }
   },
   "profiles": {
@@ -14,17 +13,9 @@
       "dotnetRunMessages": true,
       "launchBrowser": false,
       "launchUrl": "swagger",
-      "applicationUrl": "http://localhost:5000;https://localhost:5001",
+      "applicationUrl": "http://localhost:5000",
       "environmentVariables": {
-        "ASPNETCORE_ENVIRONMENT": "Production"
+        "ASPNETCORE_ENVIRONMENT": "Development"
-      }
-    },
-    "IIS Express": {
-      "commandName": "IISExpress",
-      "launchBrowser": false,
-      "launchUrl": "swagger",
-      "environmentVariables": {
-        "ASPNETCORE_ENVIRONMENT": "Production"
       }
     }
   }

backend/API/StartupHelper.cs

@@ -0,0 +1,128 @@
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using Application.Helpers;
+using Infrastructure;
+using Microsoft.EntityFrameworkCore;
+using MongoDB.Driver;
+using Newtonsoft.Json.Linq;
+
+namespace API;
+
+public static class StartupHelper
+{
+    public static void EnsurePythonEnvironment(string contentRootPath)
+    {
+        contentRootPath = Path.Combine(contentRootPath, "..");
+        var venvPath = Path.Combine(contentRootPath, "venv");
+
+        if (!Directory.Exists(venvPath))
+        {
+            Console.WriteLine("Setting up Python virtual environment...");
+
+            // Create virtual environment
+            ExecuteCommand($"python -m venv \"{venvPath}\"");
+
+            // Upgrade pip and install requirements
+            var pipExecutable = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "Scripts\\pip.exe" : "bin/pip";
+            var pipPath = Path.Combine(venvPath, pipExecutable);
+            ExecuteCommand($"\"{pipPath}\" install --upgrade pip");
+            ExecuteCommand($"\"{pipPath}\" install -r \"{Path.Combine(contentRootPath, "requirements.txt")}\"");
+        }
+        else
+        {
+            Console.WriteLine("Python virtual environment already exists.");
+        }
+    }
+
+    private static void ExecuteCommand(string command)
+    {
+        string fileName, argument;
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            fileName = "cmd.exe";
+            // Wrap the entire command string in quotes to handle spaces
+            argument = "/c \"" + command + "\"";
+        }
+        else
+        {
+            fileName = "/bin/bash";
+            // Use single quotes around the command for UNIX shells
+            argument = "-c '" + command.Replace("'", "'\\''") + "'";
+        }
+
+        var processInfo = new ProcessStartInfo(fileName, argument)
+        {
+            CreateNoWindow = true,
+            UseShellExecute = false,
+            RedirectStandardOutput = true,
+            RedirectStandardError = true
+        };
+
+        using (var process = Process.Start(processInfo))
+        {
+            if (process != null)
+            {
+                process.WaitForExit();
+
+                var output = process.StandardOutput.ReadToEnd();
+                var error = process.StandardError.ReadToEnd();
+
+                Console.WriteLine("Command executed: " + command);
+                if (!string.IsNullOrEmpty(output)) Console.WriteLine("Output: " + output);
+                if (!string.IsNullOrEmpty(error)) Console.WriteLine("Error: " + error);
+            }
+        }
+    }
+
+
+    public static void EnsureKeysGenerated(IConfiguration configuration, string contentRootPath)
+    {
+        var apiKey = configuration["ApiKey"];
+        var jwtSecretKey = configuration["Jwt:SecretKey"];
+        var appSettingsPath = Path.Combine(contentRootPath, "appsettings.json");
+        var json = JObject.Parse(File.ReadAllText(appSettingsPath));
+        var modified = false;
+
+        if (string.IsNullOrEmpty(apiKey))
+        {
+            var newApiKey = KeyGenerator.GenerateApiKey();
+            json["ApiKey"] = newApiKey;
+            modified = true;
+        }
+
+        if (string.IsNullOrEmpty(jwtSecretKey))
+        {
+            var newJwtSecretKey = KeyGenerator.GenerateJwtSecretKey();
+            json["Jwt"]["SecretKey"] = newJwtSecretKey;
+            modified = true;
+        }
+
+        if (modified) File.WriteAllText(appSettingsPath, json.ToString());
+    }
+
+    public static void EnsureMongoDatabaseAndCollectionsExist(IConfiguration configuration)
+    {
+        var mongoConnectionString = configuration["ConnectionStrings:MongoDBConnection"];
+        var mongoClient = new MongoClient(mongoConnectionString);
+        var databaseName = configuration["HealthcareManagerDatabase:Name"];
+        var database = mongoClient.GetDatabase(databaseName);
+
+        var requiredCollections = new List<string>
+        {
+            configuration["HealthcareManagerDatabase:MedicalRecordCollectionName"],
+            configuration["HealthcareManagerDatabase:ChatCollectionName"],
+            configuration["HealthcareManagerDatabase:AppointmentsCollectionName"]
+        };
+
+        var existingCollections = database.ListCollectionNames().ToList();
+
+        foreach (var collectionName in requiredCollections)
+            if (!existingCollections.Contains(collectionName))
+                database.CreateCollection(collectionName);
+    }
+
+    public static void EnsureDatabaseCreated(HealthcareManagerDatabase dbContext)
+    {
+        if (dbContext.Database.GetPendingMigrations().Any()) dbContext.Database.Migrate();
+    }
+}

backend/API/appsettings.json

@@ -8,20 +8,13 @@
   "Kestrel": {
     "Endpoints": {
       "Http": {
-          "Url": "http://*:5000"
+        "Url": "http://localhost:5000"
-        },
-        "Https": {
-          "Url": "https://*:5001",
-          "Certificate": {
-            "Path": "/etc/letsencrypt/live/healthcaremanager.ddns.net/fullchain.pem",
-            "KeyPath": "/etc/letsencrypt/live/healthcaremanager.ddns.net/privkey.pem"
-          }
       }
     }
   },
   "ConnectionStrings": {
-    "HealthcareManagerDatabase": "Host=postgresrv.postgres.database.azure.com;Database=postgres;Port=5432;User Id=postgre;Password=Password1;Ssl Mode=Require;",
+    "HealthcareManagerDatabase": "Host=90.84.229.219;Port=5432;Database=HealthcareManager;Username=andrei_cerbu;Password=postgres",
-    "MongoDBConnection": "mongodb+srv://mongodb:Password1@healthcaremanagermongodb.mongocluster.cosmos.azure.com/?tls=true&authMechanism=SCRAM-SHA-256&retrywrites=false&maxIdleTimeMS=120000"
+    "MongoDBConnection": "mongodb://andrei_cerbu:mongodb@90.84.229.219:27017/HealthcareManager?ssl=false&authSource=admin&authMechanism=SCRAM-SHA-1"
   },
   "HealthcareManagerDatabase": {
     "Name": "HealthcareManager",
@@ -29,11 +22,9 @@
     "ChatCollectionName": "Chat",
     "AppointmentsCollectionName": "Appointments"
   },
-  "ApiKeySettings": {
+  "ApiKey": "K6iadsnb1DFdt/n9VGzMop31W71cxW9JAHk0AXvGrWg=",
-    "ApiKey": "testapikey"
-  },
   "Jwt": {
-    "SecretKey": "f76bf7dc6e8a260f725f8a50ef9a8c4bd08ba2ae38e3b51d77d66617d1d6b7c0",
+    "SecretKey": "1ZWBi389z6RvJBrvwbXqeBNbzaYVpHbIfGQmIsV1gwI=",
     "Issuer": "HealthcareManager",
     "Audience": "HealthCareManagerUsers",
     "ExpirationTime": 1440
@@ -46,5 +37,10 @@
     "UserName": "andreimihneacerbu@gmail.com",
     "Password": "zpK3w71LkNa0sGt6"
   },
+  "AdminSettings": {
+    "Name": "Admin",
+    "Email": "admin@domain.com",
+    "Password": "administrator"
+  },
   "AllowedHosts": "*"
 }

backend/API/bin/Debug/net8.0/API.deps.json

@@ -11,6 +11,8 @@
           "Application": "1.0.0",
           "Infrastructure": "1.0.0",
           "Microsoft.AspNetCore.Authentication.JwtBearer": "8.0.3",
+          "MongoDB.Driver": "2.25.0",
+          "Newtonsoft.Json": "13.0.3",
           "Swashbuckle.AspNetCore": "6.5.0"
         },
         "runtime": {
@@ -55,6 +57,31 @@
           }
         }
       },
+      "Microsoft.AspNetCore.Authentication/2.2.0": {
+        "dependencies": {
+          "Microsoft.AspNetCore.Authentication.Core": "2.2.0",
+          "Microsoft.AspNetCore.DataProtection": "2.2.0",
+          "Microsoft.AspNetCore.Http": "2.2.0",
+          "Microsoft.AspNetCore.Http.Extensions": "2.2.0",
+          "Microsoft.Extensions.Logging.Abstractions": "8.0.0",
+          "Microsoft.Extensions.Options": "8.0.2",
+          "Microsoft.Extensions.WebEncoders": "2.2.0"
+        }
+      },
+      "Microsoft.AspNetCore.Authentication.Abstractions/2.2.0": {
+        "dependencies": {
+          "Microsoft.AspNetCore.Http.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Logging.Abstractions": "8.0.0",
+          "Microsoft.Extensions.Options": "8.0.2"
+        }
+      },
+      "Microsoft.AspNetCore.Authentication.Core/2.2.0": {
+        "dependencies": {
+          "Microsoft.AspNetCore.Authentication.Abstractions": "2.2.0",
+          "Microsoft.AspNetCore.Http": "2.2.0",
+          "Microsoft.AspNetCore.Http.Extensions": "2.2.0"
+        }
+      },
       "Microsoft.AspNetCore.Authentication.JwtBearer/8.0.3": {
         "dependencies": {
           "Microsoft.IdentityModel.Protocols.OpenIdConnect": "7.1.2"
@@ -66,38 +93,131 @@
           }
         }
       },
-      "Microsoft.EntityFrameworkCore/8.0.3": {
+      "Microsoft.AspNetCore.Cryptography.Internal/8.0.5": {
+        "runtime": {
+          "lib/net8.0/Microsoft.AspNetCore.Cryptography.Internal.dll": {
+            "assemblyVersion": "8.0.0.0",
+            "fileVersion": "8.0.524.22404"
+          }
+        }
+      },
+      "Microsoft.AspNetCore.Cryptography.KeyDerivation/8.0.5": {
         "dependencies": {
-          "Microsoft.EntityFrameworkCore.Abstractions": "8.0.3",
+          "Microsoft.AspNetCore.Cryptography.Internal": "8.0.5"
-          "Microsoft.EntityFrameworkCore.Analyzers": "8.0.3",
+        },
+        "runtime": {
+          "lib/net8.0/Microsoft.AspNetCore.Cryptography.KeyDerivation.dll": {
+            "assemblyVersion": "8.0.0.0",
+            "fileVersion": "8.0.524.22404"
+          }
+        }
+      },
+      "Microsoft.AspNetCore.DataProtection/2.2.0": {
+        "dependencies": {
+          "Microsoft.AspNetCore.Cryptography.Internal": "8.0.5",
+          "Microsoft.AspNetCore.DataProtection.Abstractions": "2.2.0",
+          "Microsoft.AspNetCore.Hosting.Abstractions": "2.2.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0",
+          "Microsoft.Extensions.Logging.Abstractions": "8.0.0",
+          "Microsoft.Extensions.Options": "8.0.2",
+          "Microsoft.Win32.Registry": "5.0.0",
+          "System.Security.Cryptography.Xml": "4.5.0",
+          "System.Security.Principal.Windows": "5.0.0"
+        }
+      },
+      "Microsoft.AspNetCore.DataProtection.Abstractions/2.2.0": {},
+      "Microsoft.AspNetCore.Hosting.Abstractions/2.2.0": {
+        "dependencies": {
+          "Microsoft.AspNetCore.Hosting.Server.Abstractions": "2.2.0",
+          "Microsoft.AspNetCore.Http.Abstractions": "2.2.0",
+          "Microsoft.Extensions.Hosting.Abstractions": "2.2.0"
+        }
+      },
+      "Microsoft.AspNetCore.Hosting.Server.Abstractions/2.2.0": {
+        "dependencies": {
+          "Microsoft.AspNetCore.Http.Features": "6.0.0-preview.4.21253.5",
+          "Microsoft.Extensions.Configuration.Abstractions": "8.0.0"
+        }
+      },
+      "Microsoft.AspNetCore.Http/2.2.0": {
+        "dependencies": {
+          "Microsoft.AspNetCore.Http.Abstractions": "2.2.0",
+          "Microsoft.AspNetCore.WebUtilities": "2.2.0",
+          "Microsoft.Extensions.ObjectPool": "2.2.0",
+          "Microsoft.Extensions.Options": "8.0.2",
+          "Microsoft.Net.Http.Headers": "2.2.0"
+        }
+      },
+      "Microsoft.AspNetCore.Http.Abstractions/2.2.0": {
+        "dependencies": {
+          "Microsoft.AspNetCore.Http.Features": "6.0.0-preview.4.21253.5",
+          "System.Text.Encodings.Web": "8.0.0"
+        }
+      },
+      "Microsoft.AspNetCore.Http.Extensions/2.2.0": {
+        "dependencies": {
+          "Microsoft.AspNetCore.Http.Abstractions": "2.2.0",
+          "Microsoft.Extensions.FileProviders.Abstractions": "8.0.0",
+          "Microsoft.Net.Http.Headers": "2.2.0",
+          "System.Buffers": "4.5.1"
+        }
+      },
+      "Microsoft.AspNetCore.Http.Features/6.0.0-preview.4.21253.5": {
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "8.0.0",
+          "System.IO.Pipelines": "6.0.0-preview.4.21253.7"
+        }
+      },
+      "Microsoft.AspNetCore.Identity.EntityFrameworkCore/8.0.5": {
+        "dependencies": {
+          "Microsoft.EntityFrameworkCore.Relational": "8.0.5",
+          "Microsoft.Extensions.Identity.Stores": "8.0.5"
+        },
+        "runtime": {
+          "lib/net8.0/Microsoft.AspNetCore.Identity.EntityFrameworkCore.dll": {
+            "assemblyVersion": "8.0.5.0",
+            "fileVersion": "8.0.524.22404"
+          }
+        }
+      },
+      "Microsoft.AspNetCore.WebUtilities/2.2.0": {
+        "dependencies": {
+          "Microsoft.Net.Http.Headers": "2.2.0",
+          "System.Text.Encodings.Web": "8.0.0"
+        }
+      },
+      "Microsoft.EntityFrameworkCore/8.0.5": {
+        "dependencies": {
+          "Microsoft.EntityFrameworkCore.Abstractions": "8.0.5",
+          "Microsoft.EntityFrameworkCore.Analyzers": "8.0.5",
           "Microsoft.Extensions.Caching.Memory": "8.0.0",
           "Microsoft.Extensions.Logging": "8.0.0"
         },
         "runtime": {
           "lib/net8.0/Microsoft.EntityFrameworkCore.dll": {
-            "assemblyVersion": "8.0.3.0",
+            "assemblyVersion": "8.0.5.0",
-            "fileVersion": "8.0.324.11510"
+            "fileVersion": "8.0.524.21704"
           }
         }
       },
-      "Microsoft.EntityFrameworkCore.Abstractions/8.0.3": {
+      "Microsoft.EntityFrameworkCore.Abstractions/8.0.5": {
         "runtime": {
           "lib/net8.0/Microsoft.EntityFrameworkCore.Abstractions.dll": {
-            "assemblyVersion": "8.0.3.0",
+            "assemblyVersion": "8.0.5.0",
-            "fileVersion": "8.0.324.11510"
+            "fileVersion": "8.0.524.21704"
           }
         }
       },
-      "Microsoft.EntityFrameworkCore.Analyzers/8.0.3": {},
+      "Microsoft.EntityFrameworkCore.Analyzers/8.0.5": {},
-      "Microsoft.EntityFrameworkCore.Relational/8.0.3": {
+      "Microsoft.EntityFrameworkCore.Relational/8.0.5": {
         "dependencies": {
-          "Microsoft.EntityFrameworkCore": "8.0.3",
+          "Microsoft.EntityFrameworkCore": "8.0.5",
           "Microsoft.Extensions.Configuration.Abstractions": "8.0.0"
         },
         "runtime": {
           "lib/net8.0/Microsoft.EntityFrameworkCore.Relational.dll": {
-            "assemblyVersion": "8.0.3.0",
+            "assemblyVersion": "8.0.5.0",
-            "fileVersion": "8.0.324.11510"
+            "fileVersion": "8.0.524.21704"
           }
         }
       },
@@ -112,7 +232,7 @@
           "Microsoft.Extensions.Caching.Abstractions": "8.0.0",
           "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0",
           "Microsoft.Extensions.Logging.Abstractions": "8.0.0",
-          "Microsoft.Extensions.Options": "8.0.0",
+          "Microsoft.Extensions.Options": "8.0.2",
           "Microsoft.Extensions.Primitives": "8.0.0"
         }
       },
@@ -169,11 +289,45 @@
         }
       },
       "Microsoft.Extensions.FileSystemGlobbing/8.0.0": {},
+      "Microsoft.Extensions.Hosting.Abstractions/2.2.0": {
+        "dependencies": {
+          "Microsoft.Extensions.Configuration.Abstractions": "8.0.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0",
+          "Microsoft.Extensions.FileProviders.Abstractions": "8.0.0",
+          "Microsoft.Extensions.Logging.Abstractions": "8.0.0"
+        }
+      },
+      "Microsoft.Extensions.Identity.Core/8.0.5": {
+        "dependencies": {
+          "Microsoft.AspNetCore.Cryptography.KeyDerivation": "8.0.5",
+          "Microsoft.Extensions.Logging": "8.0.0",
+          "Microsoft.Extensions.Options": "8.0.2"
+        },
+        "runtime": {
+          "lib/net8.0/Microsoft.Extensions.Identity.Core.dll": {
+            "assemblyVersion": "8.0.0.0",
+            "fileVersion": "8.0.524.22404"
+          }
+        }
+      },
+      "Microsoft.Extensions.Identity.Stores/8.0.5": {
+        "dependencies": {
+          "Microsoft.Extensions.Caching.Abstractions": "8.0.0",
+          "Microsoft.Extensions.Identity.Core": "8.0.5",
+          "Microsoft.Extensions.Logging": "8.0.0"
+        },
+        "runtime": {
+          "lib/net8.0/Microsoft.Extensions.Identity.Stores.dll": {
+            "assemblyVersion": "8.0.0.0",
+            "fileVersion": "8.0.524.22404"
+          }
+        }
+      },
       "Microsoft.Extensions.Logging/8.0.0": {
         "dependencies": {
           "Microsoft.Extensions.DependencyInjection": "8.0.0",
           "Microsoft.Extensions.Logging.Abstractions": "8.0.0",
-          "Microsoft.Extensions.Options": "8.0.0"
+          "Microsoft.Extensions.Options": "8.0.2"
         }
       },
       "Microsoft.Extensions.Logging.Abstractions/8.0.0": {
@@ -181,10 +335,17 @@
           "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0"
         }
       },
-      "Microsoft.Extensions.Options/8.0.0": {
+      "Microsoft.Extensions.ObjectPool/2.2.0": {},
+      "Microsoft.Extensions.Options/8.0.2": {
         "dependencies": {
           "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0",
           "Microsoft.Extensions.Primitives": "8.0.0"
+        },
+        "runtime": {
+          "lib/net8.0/Microsoft.Extensions.Options.dll": {
+            "assemblyVersion": "8.0.0.0",
+            "fileVersion": "8.0.224.6711"
+          }
         }
       },
       "Microsoft.Extensions.Options.ConfigurationExtensions/8.0.0": {
@@ -192,11 +353,18 @@
           "Microsoft.Extensions.Configuration.Abstractions": "8.0.0",
           "Microsoft.Extensions.Configuration.Binder": "8.0.0",
           "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0",
-          "Microsoft.Extensions.Options": "8.0.0",
+          "Microsoft.Extensions.Options": "8.0.2",
           "Microsoft.Extensions.Primitives": "8.0.0"
         }
       },
       "Microsoft.Extensions.Primitives/8.0.0": {},
+      "Microsoft.Extensions.WebEncoders/2.2.0": {
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0",
+          "Microsoft.Extensions.Options": "8.0.2",
+          "System.Text.Encodings.Web": "8.0.0"
+        }
+      },
       "Microsoft.IdentityModel.Abstractions/7.5.1": {
         "runtime": {
           "lib/net8.0/Microsoft.IdentityModel.Abstractions.dll": {
@@ -262,6 +430,12 @@
           }
         }
       },
+      "Microsoft.Net.Http.Headers/2.2.0": {
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "8.0.0",
+          "System.Buffers": "4.5.1"
+        }
+      },
       "Microsoft.NETCore.Platforms/5.0.0": {},
       "Microsoft.OpenApi/1.2.3": {
         "runtime": {
@@ -277,38 +451,38 @@
           "System.Security.Principal.Windows": "5.0.0"
         }
       },
-      "MongoDB.Bson/2.24.0": {
+      "MongoDB.Bson/2.25.0": {
         "dependencies": {
           "System.Memory": "4.5.5",
           "System.Runtime.CompilerServices.Unsafe": "5.0.0"
         },
         "runtime": {
           "lib/netstandard2.1/MongoDB.Bson.dll": {
-            "assemblyVersion": "2.24.0.0",
+            "assemblyVersion": "2.25.0.0",
-            "fileVersion": "2.24.0.0"
+            "fileVersion": "2.25.0.0"
           }
         }
       },
-      "MongoDB.Driver/2.24.0": {
+      "MongoDB.Driver/2.25.0": {
         "dependencies": {
           "Microsoft.Extensions.Logging.Abstractions": "8.0.0",
-          "MongoDB.Bson": "2.24.0",
+          "MongoDB.Bson": "2.25.0",
-          "MongoDB.Driver.Core": "2.24.0",
+          "MongoDB.Driver.Core": "2.25.0",
           "MongoDB.Libmongocrypt": "1.8.2"
         },
         "runtime": {
           "lib/netstandard2.1/MongoDB.Driver.dll": {
-            "assemblyVersion": "2.24.0.0",
+            "assemblyVersion": "2.25.0.0",
-            "fileVersion": "2.24.0.0"
+            "fileVersion": "2.25.0.0"
           }
         }
       },
-      "MongoDB.Driver.Core/2.24.0": {
+      "MongoDB.Driver.Core/2.25.0": {
         "dependencies": {
           "AWSSDK.SecurityToken": "3.7.100.14",
           "DnsClient": "1.6.1",
           "Microsoft.Extensions.Logging.Abstractions": "8.0.0",
-          "MongoDB.Bson": "2.24.0",
+          "MongoDB.Bson": "2.25.0",
           "MongoDB.Libmongocrypt": "1.8.2",
           "SharpCompress": "0.30.1",
           "Snappier": "1.0.0",
@@ -317,8 +491,8 @@
         },
         "runtime": {
           "lib/netstandard2.1/MongoDB.Driver.Core.dll": {
-            "assemblyVersion": "2.24.0.0",
+            "assemblyVersion": "2.25.0.0",
-            "fileVersion": "2.24.0.0"
+            "fileVersion": "2.25.0.0"
           }
         }
       },
@@ -347,28 +521,36 @@
           }
         }
       },
-      "Npgsql/8.0.2": {
+      "Newtonsoft.Json/13.0.3": {
+        "runtime": {
+          "lib/net6.0/Newtonsoft.Json.dll": {
+            "assemblyVersion": "13.0.0.0",
+            "fileVersion": "13.0.3.27908"
+          }
+        }
+      },
+      "Npgsql/8.0.3": {
         "dependencies": {
           "Microsoft.Extensions.Logging.Abstractions": "8.0.0"
         },
         "runtime": {
           "lib/net8.0/Npgsql.dll": {
-            "assemblyVersion": "8.0.2.0",
+            "assemblyVersion": "8.0.3.0",
-            "fileVersion": "8.0.2.0"
+            "fileVersion": "8.0.3.0"
           }
         }
       },
-      "Npgsql.EntityFrameworkCore.PostgreSQL/8.0.2": {
+      "Npgsql.EntityFrameworkCore.PostgreSQL/8.0.4": {
         "dependencies": {
-          "Microsoft.EntityFrameworkCore": "8.0.3",
+          "Microsoft.EntityFrameworkCore": "8.0.5",
-          "Microsoft.EntityFrameworkCore.Abstractions": "8.0.3",
+          "Microsoft.EntityFrameworkCore.Abstractions": "8.0.5",
-          "Microsoft.EntityFrameworkCore.Relational": "8.0.3",
+          "Microsoft.EntityFrameworkCore.Relational": "8.0.5",
-          "Npgsql": "8.0.2"
+          "Npgsql": "8.0.3"
         },
         "runtime": {
           "lib/net8.0/Npgsql.EntityFrameworkCore.PostgreSQL.dll": {
-            "assemblyVersion": "8.0.2.0",
+            "assemblyVersion": "8.0.4.0",
-            "fileVersion": "8.0.2.0"
+            "fileVersion": "8.0.4.0"
           }
         }
       },
@@ -439,6 +621,7 @@
           }
         }
       },
+      "System.IO.Pipelines/6.0.0-preview.4.21253.7": {},
       "System.Memory/4.5.5": {},
       "System.Runtime.CompilerServices.Unsafe/5.0.0": {},
       "System.Security.AccessControl/5.0.0": {
@@ -447,6 +630,29 @@
           "System.Security.Principal.Windows": "5.0.0"
         }
       },
+      "System.Security.Cryptography.Cng/4.5.0": {},
+      "System.Security.Cryptography.Pkcs/4.5.0": {
+        "dependencies": {
+          "System.Security.Cryptography.Cng": "4.5.0"
+        }
+      },
+      "System.Security.Cryptography.Xml/4.5.0": {
+        "dependencies": {
+          "System.Security.Cryptography.Pkcs": "4.5.0",
+          "System.Security.Permissions": "4.5.0"
+        }
+      },
+      "System.Security.Permissions/4.5.0": {
+        "dependencies": {
+          "System.Security.AccessControl": "5.0.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/System.Security.Permissions.dll": {
+            "assemblyVersion": "4.0.1.0",
+            "fileVersion": "4.6.26515.6"
+          }
+        }
+      },
       "System.Security.Principal.Windows/5.0.0": {},
       "System.Text.Encodings.Web/8.0.0": {},
       "System.Text.Json/8.0.0": {
@@ -464,34 +670,38 @@
       },
       "Application/1.0.0": {
         "dependencies": {
-          "Core": "1.0.0",
+          "Domain": "1.0.0",
           "FluentValidation": "11.9.0",
-          "MongoDB.Driver": "2.24.0"
+          "MongoDB.Driver": "2.25.0",
+          "Newtonsoft.Json": "13.0.3"
         },
         "runtime": {
           "Application.dll": {}
         }
       },
-      "Core/1.0.0": {
+      "Domain/1.0.0": {
         "dependencies": {
-          "MongoDB.Bson": "2.24.0"
+          "MongoDB.Bson": "2.25.0"
         },
         "runtime": {
-          "Core.dll": {}
+          "Domain.dll": {}
         }
       },
       "Infrastructure/1.0.0": {
         "dependencies": {
           "Application": "1.0.0",
-          "Core": "1.0.0",
+          "Domain": "1.0.0",
-          "Microsoft.EntityFrameworkCore": "8.0.3",
+          "Microsoft.AspNetCore.Authentication": "2.2.0",
-          "Microsoft.EntityFrameworkCore.Relational": "8.0.3",
+          "Microsoft.AspNetCore.Http.Features": "6.0.0-preview.4.21253.5",
+          "Microsoft.AspNetCore.Identity.EntityFrameworkCore": "8.0.5",
+          "Microsoft.EntityFrameworkCore": "8.0.5",
+          "Microsoft.EntityFrameworkCore.Relational": "8.0.5",
           "Microsoft.Extensions.Configuration": "8.0.0",
           "Microsoft.Extensions.Configuration.Json": "8.0.0",
           "Microsoft.Extensions.Options.ConfigurationExtensions": "8.0.0",
           "Microsoft.IdentityModel.Tokens": "7.5.1",
-          "MongoDB.Driver": "2.24.0",
+          "MongoDB.Driver": "2.25.0",
-          "Npgsql.EntityFrameworkCore.PostgreSQL": "8.0.2",
+          "Npgsql.EntityFrameworkCore.PostgreSQL": "8.0.4",
           "System.IdentityModel.Tokens.Jwt": "7.5.1"
         },
         "runtime": {
@@ -534,6 +744,27 @@
       "path": "fluentvalidation/11.9.0",
       "hashPath": "fluentvalidation.11.9.0.nupkg.sha512"
     },
+    "Microsoft.AspNetCore.Authentication/2.2.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-b0R9X7L6zMqNsssKDvhYHuNi5x0s4DyHTeXybIAyGaitKiW1Q5aAGKdV2codHPiePv9yHfC9hAMyScXQ/xXhPw==",
+      "path": "microsoft.aspnetcore.authentication/2.2.0",
+      "hashPath": "microsoft.aspnetcore.authentication.2.2.0.nupkg.sha512"
+    },
+    "Microsoft.AspNetCore.Authentication.Abstractions/2.2.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-VloMLDJMf3n/9ic5lCBOa42IBYJgyB1JhzLsL68Zqg+2bEPWfGBj/xCJy/LrKTArN0coOcZp3wyVTZlx0y9pHQ==",
+      "path": "microsoft.aspnetcore.authentication.abstractions/2.2.0",
+      "hashPath": "microsoft.aspnetcore.authentication.abstractions.2.2.0.nupkg.sha512"
+    },
+    "Microsoft.AspNetCore.Authentication.Core/2.2.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-XlVJzJ5wPOYW+Y0J6Q/LVTEyfS4ssLXmt60T0SPP+D8abVhBTl+cgw2gDHlyKYIkcJg7btMVh383NDkMVqD/fg==",
+      "path": "microsoft.aspnetcore.authentication.core/2.2.0",
+      "hashPath": "microsoft.aspnetcore.authentication.core.2.2.0.nupkg.sha512"
+    },
     "Microsoft.AspNetCore.Authentication.JwtBearer/8.0.3": {
       "type": "package",
       "serviceable": true,
@@ -541,33 +772,117 @@
       "path": "microsoft.aspnetcore.authentication.jwtbearer/8.0.3",
       "hashPath": "microsoft.aspnetcore.authentication.jwtbearer.8.0.3.nupkg.sha512"
     },
-    "Microsoft.EntityFrameworkCore/8.0.3": {
+    "Microsoft.AspNetCore.Cryptography.Internal/8.0.5": {
       "type": "package",
       "serviceable": true,
-      "sha512": "sha512-QUPQbeq4yCjgIL/6PzkhfwhljXmai3CNOsErWFJ/WJ1Z41V8+At0Bi4PT8/2pX25kPgf83g0CUKIZd0QbeKT4A==",
+      "sha512": "sha512-bu8jQbBpKuqubTsGSTR/mosNw2bNg7NRmgOpPgHiWIiHnYHvyuJWVjgGxKzhkztw53z9aAgiOHbgAm7SsKJihQ==",
-      "path": "microsoft.entityframeworkcore/8.0.3",
+      "path": "microsoft.aspnetcore.cryptography.internal/8.0.5",
-      "hashPath": "microsoft.entityframeworkcore.8.0.3.nupkg.sha512"
+      "hashPath": "microsoft.aspnetcore.cryptography.internal.8.0.5.nupkg.sha512"
     },
-    "Microsoft.EntityFrameworkCore.Abstractions/8.0.3": {
+    "Microsoft.AspNetCore.Cryptography.KeyDerivation/8.0.5": {
       "type": "package",
       "serviceable": true,
-      "sha512": "sha512-cW+SKdx34wZ25ZVKCpk/6+6z27wrZlQ1qXyx7UWpy34s9CyAojH0QiYlV/2owNOGSAH67rm+LxAjUOicsqlGzQ==",
+      "sha512": "sha512-VQL44/kuHkyQtHKAxNklV9xn/7AYQwVT7aAUHD0JpkhsPp/93VmVOoM6llmllzs2u7USW0dG18o//JOBdZfhow==",
-      "path": "microsoft.entityframeworkcore.abstractions/8.0.3",
+      "path": "microsoft.aspnetcore.cryptography.keyderivation/8.0.5",
-      "hashPath": "microsoft.entityframeworkcore.abstractions.8.0.3.nupkg.sha512"
+      "hashPath": "microsoft.aspnetcore.cryptography.keyderivation.8.0.5.nupkg.sha512"
     },
-    "Microsoft.EntityFrameworkCore.Analyzers/8.0.3": {
+    "Microsoft.AspNetCore.DataProtection/2.2.0": {
       "type": "package",
       "serviceable": true,
-      "sha512": "sha512-3csRAzz5O5Gn+GQBMyLn26OICtEo2/U2iDDygQhKb3LnC78bAUvutkMqvb0Ek5A6uHrBcZQrKQJfkgfnRT5XZw==",
+      "sha512": "sha512-G6dvu5Nd2vjpYbzazZ//qBFbSEf2wmBUbyAR7E4AwO3gWjhoJD5YxpThcGJb7oE3VUcW65SVMXT+cPCiiBg8Sg==",
-      "path": "microsoft.entityframeworkcore.analyzers/8.0.3",
+      "path": "microsoft.aspnetcore.dataprotection/2.2.0",
-      "hashPath": "microsoft.entityframeworkcore.analyzers.8.0.3.nupkg.sha512"
+      "hashPath": "microsoft.aspnetcore.dataprotection.2.2.0.nupkg.sha512"
     },
-    "Microsoft.EntityFrameworkCore.Relational/8.0.3": {
+    "Microsoft.AspNetCore.DataProtection.Abstractions/2.2.0": {
       "type": "package",
       "serviceable": true,
-      "sha512": "sha512-8JnVZHWaNFkrrD/FC0O4jekiHIYey8y6TQ4Co3OzLz0wd5Dm1cwJfTp++1TvaVu0BBd4bVDtiktppa5epuoPrA==",
+      "sha512": "sha512-seANFXmp8mb5Y12m1ShiElJ3ZdOT3mBN3wA1GPhHJIvZ/BxOCPyqEOR+810OWsxEZwA5r5fDRNpG/CqiJmQnJg==",
-      "path": "microsoft.entityframeworkcore.relational/8.0.3",
+      "path": "microsoft.aspnetcore.dataprotection.abstractions/2.2.0",
-      "hashPath": "microsoft.entityframeworkcore.relational.8.0.3.nupkg.sha512"
+      "hashPath": "microsoft.aspnetcore.dataprotection.abstractions.2.2.0.nupkg.sha512"
+    },
+    "Microsoft.AspNetCore.Hosting.Abstractions/2.2.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ubycklv+ZY7Kutdwuy1W4upWcZ6VFR8WUXU7l7B2+mvbDBBPAcfpi+E+Y5GFe+Q157YfA3C49D2GCjAZc7Mobw==",
+      "path": "microsoft.aspnetcore.hosting.abstractions/2.2.0",
+      "hashPath": "microsoft.aspnetcore.hosting.abstractions.2.2.0.nupkg.sha512"
+    },
+    "Microsoft.AspNetCore.Hosting.Server.Abstractions/2.2.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-1PMijw8RMtuQF60SsD/JlKtVfvh4NORAhF4wjysdABhlhTrYmtgssqyncR0Stq5vqtjplZcj6kbT4LRTglt9IQ==",
+      "path": "microsoft.aspnetcore.hosting.server.abstractions/2.2.0",
+      "hashPath": "microsoft.aspnetcore.hosting.server.abstractions.2.2.0.nupkg.sha512"
+    },
+    "Microsoft.AspNetCore.Http/2.2.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-YogBSMotWPAS/X5967pZ+yyWPQkThxhmzAwyCHCSSldzYBkW5W5d6oPfBaPqQOnSHYTpSOSOkpZoAce0vwb6+A==",
+      "path": "microsoft.aspnetcore.http/2.2.0",
+      "hashPath": "microsoft.aspnetcore.http.2.2.0.nupkg.sha512"
+    },
+    "Microsoft.AspNetCore.Http.Abstractions/2.2.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-Nxs7Z1q3f1STfLYKJSVXCs1iBl+Ya6E8o4Oy1bCxJ/rNI44E/0f6tbsrVqAWfB7jlnJfyaAtIalBVxPKUPQb4Q==",
+      "path": "microsoft.aspnetcore.http.abstractions/2.2.0",
+      "hashPath": "microsoft.aspnetcore.http.abstractions.2.2.0.nupkg.sha512"
+    },
+    "Microsoft.AspNetCore.Http.Extensions/2.2.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-2DgZ9rWrJtuR7RYiew01nGRzuQBDaGHGmK56Rk54vsLLsCdzuFUPqbDTJCS1qJQWTbmbIQ9wGIOjpxA1t0l7/w==",
+      "path": "microsoft.aspnetcore.http.extensions/2.2.0",
+      "hashPath": "microsoft.aspnetcore.http.extensions.2.2.0.nupkg.sha512"
+    },
+    "Microsoft.AspNetCore.Http.Features/6.0.0-preview.4.21253.5": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-R3MUGcafdytxU9Bv5PWy46MPlHtPLgjCX9ay+Y7VPyvaxtpCijz6tMBUPletOUeAcmyYpwBgWU1FwdyuZn0n8w==",
+      "path": "microsoft.aspnetcore.http.features/6.0.0-preview.4.21253.5",
+      "hashPath": "microsoft.aspnetcore.http.features.6.0.0-preview.4.21253.5.nupkg.sha512"
+    },
+    "Microsoft.AspNetCore.Identity.EntityFrameworkCore/8.0.5": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-p3didtXm9oj3ThPtsM6ePyD7A+fD2DUMPpD3d9XfbiVd8S7Ugiynb7Xa7XjN9zih07PPhkdt9s1NmpYWoBgUlA==",
+      "path": "microsoft.aspnetcore.identity.entityframeworkcore/8.0.5",
+      "hashPath": "microsoft.aspnetcore.identity.entityframeworkcore.8.0.5.nupkg.sha512"
+    },
+    "Microsoft.AspNetCore.WebUtilities/2.2.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-9ErxAAKaDzxXASB/b5uLEkLgUWv1QbeVxyJYEHQwMaxXOeFFVkQxiq8RyfVcifLU7NR0QY0p3acqx4ZpYfhHDg==",
+      "path": "microsoft.aspnetcore.webutilities/2.2.0",
+      "hashPath": "microsoft.aspnetcore.webutilities.2.2.0.nupkg.sha512"
+    },
+    "Microsoft.EntityFrameworkCore/8.0.5": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-sqpDZgfzmTPXy/jCekqTaPDwqRDjtdGmIL+eqFfXtVAoH4AanWjeyxQ1ej3uVnTQO6f23+m9+ggJDVcgyPJxcA==",
+      "path": "microsoft.entityframeworkcore/8.0.5",
+      "hashPath": "microsoft.entityframeworkcore.8.0.5.nupkg.sha512"
+    },
+    "Microsoft.EntityFrameworkCore.Abstractions/8.0.5": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-qwYdfjFKtmTXX8NIm0MuZxUkon1tcw+aF5huzR7YOVr/tR3s4fqw9DWcvc23l3Jhpo/uGHWZcNPyFlI2CD3Usg==",
+      "path": "microsoft.entityframeworkcore.abstractions/8.0.5",
+      "hashPath": "microsoft.entityframeworkcore.abstractions.8.0.5.nupkg.sha512"
+    },
+    "Microsoft.EntityFrameworkCore.Analyzers/8.0.5": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-LzoKedC+9A8inF5d3iIzgyv/JDXgKrtpYoGIC3EqGWuHVDm9s/IHHApeTOTbzvnr7yBVV+nmYfyT1nwtzRDp0Q==",
+      "path": "microsoft.entityframeworkcore.analyzers/8.0.5",
+      "hashPath": "microsoft.entityframeworkcore.analyzers.8.0.5.nupkg.sha512"
+    },
+    "Microsoft.EntityFrameworkCore.Relational/8.0.5": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-x2bdSK3eKKEQkDdYcGxxDU+S7NqhBiz/Fciz01Mafz9P71VRdP3JskKHaZvwK0/sNEAT3hS7BTsDQGUA2F9mAA==",
+      "path": "microsoft.entityframeworkcore.relational/8.0.5",
+      "hashPath": "microsoft.entityframeworkcore.relational.8.0.5.nupkg.sha512"
     },
     "Microsoft.Extensions.ApiDescription.Server/6.0.5": {
       "type": "package",
@@ -660,6 +975,27 @@
       "path": "microsoft.extensions.filesystemglobbing/8.0.0",
       "hashPath": "microsoft.extensions.filesystemglobbing.8.0.0.nupkg.sha512"
     },
+    "Microsoft.Extensions.Hosting.Abstractions/2.2.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-+k4AEn68HOJat5gj1TWa6X28WlirNQO9sPIIeQbia+91n03esEtMSSoekSTpMjUzjqtJWQN3McVx0GvSPFHF/Q==",
+      "path": "microsoft.extensions.hosting.abstractions/2.2.0",
+      "hashPath": "microsoft.extensions.hosting.abstractions.2.2.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.Identity.Core/8.0.5": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-zl/dTogiyBA2D1NBgEQfJRq/5M7aHWU8qp5l6rq4U+hKFcDdd9YDeDaEEtiuYxTpfXn2VoxZten2MljK0kLNiA==",
+      "path": "microsoft.extensions.identity.core/8.0.5",
+      "hashPath": "microsoft.extensions.identity.core.8.0.5.nupkg.sha512"
+    },
+    "Microsoft.Extensions.Identity.Stores/8.0.5": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-R6OeFrKxq3kAP/r7Uz5By8QUKnvS7ah/ubM/xbSRfGoyftCTzn4Gd9CZMW+9G67tHR3UX+sZXcjDacD7CFG9Bg==",
+      "path": "microsoft.extensions.identity.stores/8.0.5",
+      "hashPath": "microsoft.extensions.identity.stores.8.0.5.nupkg.sha512"
+    },
     "Microsoft.Extensions.Logging/8.0.0": {
       "type": "package",
       "serviceable": true,
@@ -674,12 +1010,19 @@
       "path": "microsoft.extensions.logging.abstractions/8.0.0",
       "hashPath": "microsoft.extensions.logging.abstractions.8.0.0.nupkg.sha512"
     },
-    "Microsoft.Extensions.Options/8.0.0": {
+    "Microsoft.Extensions.ObjectPool/2.2.0": {
       "type": "package",
       "serviceable": true,
-      "sha512": "sha512-JOVOfqpnqlVLUzINQ2fox8evY2SKLYJ3BV8QDe/Jyp21u1T7r45x/R/5QdteURMR5r01GxeJSBBUOCOyaNXA3g==",
+      "sha512": "sha512-gA8H7uQOnM5gb+L0uTNjViHYr+hRDqCdfugheGo/MxQnuHzmhhzCBTIPm19qL1z1Xe0NEMabfcOBGv9QghlZ8g==",
-      "path": "microsoft.extensions.options/8.0.0",
+      "path": "microsoft.extensions.objectpool/2.2.0",
-      "hashPath": "microsoft.extensions.options.8.0.0.nupkg.sha512"
+      "hashPath": "microsoft.extensions.objectpool.2.2.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.Options/8.0.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-dWGKvhFybsaZpGmzkGCbNNwBD1rVlWzrZKANLW/CcbFJpCEceMCGzT7zZwHOGBCbwM0SzBuceMj5HN1LKV1QqA==",
+      "path": "microsoft.extensions.options/8.0.2",
+      "hashPath": "microsoft.extensions.options.8.0.2.nupkg.sha512"
     },
     "Microsoft.Extensions.Options.ConfigurationExtensions/8.0.0": {
       "type": "package",
@@ -695,6 +1038,13 @@
       "path": "microsoft.extensions.primitives/8.0.0",
       "hashPath": "microsoft.extensions.primitives.8.0.0.nupkg.sha512"
     },
+    "Microsoft.Extensions.WebEncoders/2.2.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-V8XcqYcpcdBAxUhLeyYcuKmxu4CtNQA9IphTnARpQGhkop4A93v2XgM3AtaVVJo3H2cDWxWM6aeO8HxkifREqw==",
+      "path": "microsoft.extensions.webencoders/2.2.0",
+      "hashPath": "microsoft.extensions.webencoders.2.2.0.nupkg.sha512"
+    },
     "Microsoft.IdentityModel.Abstractions/7.5.1": {
       "type": "package",
       "serviceable": true,
@@ -737,6 +1087,13 @@
       "path": "microsoft.identitymodel.tokens/7.5.1",
       "hashPath": "microsoft.identitymodel.tokens.7.5.1.nupkg.sha512"
     },
+    "Microsoft.Net.Http.Headers/2.2.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-iZNkjYqlo8sIOI0bQfpsSoMTmB/kyvmV2h225ihyZT33aTp48ZpF6qYnXxzSXmHt8DpBAwBTX+1s1UFLbYfZKg==",
+      "path": "microsoft.net.http.headers/2.2.0",
+      "hashPath": "microsoft.net.http.headers.2.2.0.nupkg.sha512"
+    },
     "Microsoft.NETCore.Platforms/5.0.0": {
       "type": "package",
       "serviceable": true,
@@ -758,26 +1115,26 @@
       "path": "microsoft.win32.registry/5.0.0",
       "hashPath": "microsoft.win32.registry.5.0.0.nupkg.sha512"
     },
-    "MongoDB.Bson/2.24.0": {
+    "MongoDB.Bson/2.25.0": {
       "type": "package",
       "serviceable": true,
-      "sha512": "sha512-n8CWaA4iTuoEQYv0+FSKNTX/hJozFQa5EgSILVNPhTGHcrbABHhpVrT1NwRRAAS6sUb8ZyhHmLPBa88LJemptA==",
+      "sha512": "sha512-xQx/qtC2nu9oGiyNqAwfiDpUMweLi0nID677cyKykpwmj5AVMrnd//UwmcmuX95178DeY6rf7cjmA613TQXPiA==",
-      "path": "mongodb.bson/2.24.0",
+      "path": "mongodb.bson/2.25.0",
-      "hashPath": "mongodb.bson.2.24.0.nupkg.sha512"
+      "hashPath": "mongodb.bson.2.25.0.nupkg.sha512"
     },
-    "MongoDB.Driver/2.24.0": {
+    "MongoDB.Driver/2.25.0": {
       "type": "package",
       "serviceable": true,
-      "sha512": "sha512-j1q11iMk3LN38ze6jgV1ATp+WKVVQbsGrhFkuOcHwRNtIk70TpLKjOD1Z3CCkyrzxCsUyhwk745tK2ASNOI4WA==",
+      "sha512": "sha512-dMqnZTV6MuvoEI4yFtSvKJdAoN6NeyAEvG8aoxnrLIVd7bR84QxLgpsM1nhK17qkOcIx/IrpMIfrvp5iMnYGBg==",
-      "path": "mongodb.driver/2.24.0",
+      "path": "mongodb.driver/2.25.0",
-      "hashPath": "mongodb.driver.2.24.0.nupkg.sha512"
+      "hashPath": "mongodb.driver.2.25.0.nupkg.sha512"
     },
-    "MongoDB.Driver.Core/2.24.0": {
+    "MongoDB.Driver.Core/2.25.0": {
       "type": "package",
       "serviceable": true,
-      "sha512": "sha512-UW0yadpMPi9+MtLHy6onpol3D9tXMRg61P0ROnij+h35EOr0vt/nxvlPrDcUjl3SvttvpsEXQKxb2lQShBA1dA==",
+      "sha512": "sha512-oN4nLgO5HQEThTg/zqeoHqaO2+q64DBVb4r7BvhaFb0p0TM9jZKnCKvh1EA8d9E9swIz0CgvMrvL1mPyRCZzag==",
-      "path": "mongodb.driver.core/2.24.0",
+      "path": "mongodb.driver.core/2.25.0",
-      "hashPath": "mongodb.driver.core.2.24.0.nupkg.sha512"
+      "hashPath": "mongodb.driver.core.2.25.0.nupkg.sha512"
     },
     "MongoDB.Libmongocrypt/1.8.2": {
       "type": "package",
@@ -786,19 +1143,26 @@
       "path": "mongodb.libmongocrypt/1.8.2",
       "hashPath": "mongodb.libmongocrypt.1.8.2.nupkg.sha512"
     },
-    "Npgsql/8.0.2": {
+    "Newtonsoft.Json/13.0.3": {
       "type": "package",
       "serviceable": true,
-      "sha512": "sha512-MuJzLoWCaQhQAR3oh66YR0Ir6mxuezncGX3f8wxvAc21g0+9HICktJQlqMoODhxztZKXE5k9GxRxqUAN+vPb4g==",
+      "sha512": "sha512-HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ==",
-      "path": "npgsql/8.0.2",
+      "path": "newtonsoft.json/13.0.3",
-      "hashPath": "npgsql.8.0.2.nupkg.sha512"
+      "hashPath": "newtonsoft.json.13.0.3.nupkg.sha512"
     },
-    "Npgsql.EntityFrameworkCore.PostgreSQL/8.0.2": {
+    "Npgsql/8.0.3": {
       "type": "package",
       "serviceable": true,
-      "sha512": "sha512-eoZPynwkZTWFTgnocvXORuCL2yFZtscrUdqVhjxiRULpC7BMg9zhLM5oDZAU5PoX1PgN77hmkKE4a3PQiHqh7Q==",
+      "sha512": "sha512-6WEmzsQJCZAlUG1pThKg/RmeF6V+I0DmBBBE/8YzpRtEzhyZzKcK7ulMANDm5CkxrALBEC8H+5plxHWtIL7xnA==",
-      "path": "npgsql.entityframeworkcore.postgresql/8.0.2",
+      "path": "npgsql/8.0.3",
-      "hashPath": "npgsql.entityframeworkcore.postgresql.8.0.2.nupkg.sha512"
+      "hashPath": "npgsql.8.0.3.nupkg.sha512"
+    },
+    "Npgsql.EntityFrameworkCore.PostgreSQL/8.0.4": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-/hHd9MqTRVDgIpsToCcxMDxZqla0HAQACiITkq1+L9J2hmHKV6lBAPlauF+dlNSfHpus7rrljWx4nAanKD6qAw==",
+      "path": "npgsql.entityframeworkcore.postgresql/8.0.4",
+      "hashPath": "npgsql.entityframeworkcore.postgresql.8.0.4.nupkg.sha512"
     },
     "SharpCompress/0.30.1": {
       "type": "package",
@@ -856,6 +1220,13 @@
       "path": "system.identitymodel.tokens.jwt/7.5.1",
       "hashPath": "system.identitymodel.tokens.jwt.7.5.1.nupkg.sha512"
     },
+    "System.IO.Pipelines/6.0.0-preview.4.21253.7": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-vFgm2rr53rp46mFmO+ihwVf9zOZu4sA11ULmCbmvrYEG3XR45ql1CYBSEEsntMQeZG0B/qiOOifnLTxB5G1C0A==",
+      "path": "system.io.pipelines/6.0.0-preview.4.21253.7",
+      "hashPath": "system.io.pipelines.6.0.0-preview.4.21253.7.nupkg.sha512"
+    },
     "System.Memory/4.5.5": {
       "type": "package",
       "serviceable": true,
@@ -877,6 +1248,34 @@
       "path": "system.security.accesscontrol/5.0.0",
       "hashPath": "system.security.accesscontrol.5.0.0.nupkg.sha512"
     },
+    "System.Security.Cryptography.Cng/4.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-WG3r7EyjUe9CMPFSs6bty5doUqT+q9pbI80hlNzo2SkPkZ4VTuZkGWjpp77JB8+uaL4DFPRdBsAY+DX3dBK92A==",
+      "path": "system.security.cryptography.cng/4.5.0",
+      "hashPath": "system.security.cryptography.cng.4.5.0.nupkg.sha512"
+    },
+    "System.Security.Cryptography.Pkcs/4.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-TGQX51gxpY3K3I6LJlE2LAftVlIMqJf0cBGhz68Y89jjk3LJCB6SrwiD+YN1fkqemBvWGs+GjyMJukl6d6goyQ==",
+      "path": "system.security.cryptography.pkcs/4.5.0",
+      "hashPath": "system.security.cryptography.pkcs.4.5.0.nupkg.sha512"
+    },
+    "System.Security.Cryptography.Xml/4.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-i2Jn6rGXR63J0zIklImGRkDIJL4b1NfPSEbIVHBlqoIb12lfXIigCbDRpDmIEzwSo/v1U5y/rYJdzZYSyCWxvg==",
+      "path": "system.security.cryptography.xml/4.5.0",
+      "hashPath": "system.security.cryptography.xml.4.5.0.nupkg.sha512"
+    },
+    "System.Security.Permissions/4.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-9gdyuARhUR7H+p5CjyUB/zPk7/Xut3wUSP8NJQB6iZr8L3XUXTMdoLeVAg9N4rqF8oIpE7MpdqHdDHQ7XgJe0g==",
+      "path": "system.security.permissions/4.5.0",
+      "hashPath": "system.security.permissions.4.5.0.nupkg.sha512"
+    },
     "System.Security.Principal.Windows/5.0.0": {
       "type": "package",
       "serviceable": true,
@@ -910,7 +1309,7 @@
       "serviceable": false,
       "sha512": ""
     },
-    "Core/1.0.0": {
+    "Domain/1.0.0": {
       "type": "project",
       "serviceable": false,
       "sha512": ""

backend/API/bin/Debug/net8.0/appsettings.json

@@ -8,20 +8,13 @@
   "Kestrel": {
     "Endpoints": {
       "Http": {
-          "Url": "http://*:5000"
+        "Url": "http://localhost:5000"
-        },
-        "Https": {
-          "Url": "https://*:5001",
-          "Certificate": {
-            "Path": "/etc/letsencrypt/live/healthcaremanager.ddns.net/fullchain.pem",
-            "KeyPath": "/etc/letsencrypt/live/healthcaremanager.ddns.net/privkey.pem"
-          }
       }
     }
   },
   "ConnectionStrings": {
-    "HealthcareManagerDatabase": "Host=postgresrv.postgres.database.azure.com;Database=postgres;Port=5432;User Id=postgre;Password=Password1;Ssl Mode=Require;",
+    "HealthcareManagerDatabase": "Host=90.84.229.219;Port=5432;Database=HealthcareManager;Username=andrei_cerbu;Password=postgres",
-    "MongoDBConnection": "mongodb+srv://mongodb:Password1@healthcaremanagermongodb.mongocluster.cosmos.azure.com/?tls=true&authMechanism=SCRAM-SHA-256&retrywrites=false&maxIdleTimeMS=120000"
+    "MongoDBConnection": "mongodb://andrei_cerbu:mongodb@90.84.229.219:27017/HealthcareManager?ssl=false&authSource=admin&authMechanism=SCRAM-SHA-1"
   },
   "HealthcareManagerDatabase": {
     "Name": "HealthcareManager",
@@ -29,11 +22,9 @@
     "ChatCollectionName": "Chat",
     "AppointmentsCollectionName": "Appointments"
   },
-  "ApiKeySettings": {
+  "ApiKey": "K6iadsnb1DFdt/n9VGzMop31W71cxW9JAHk0AXvGrWg=",
-    "ApiKey": "testapikey"
-  },
   "Jwt": {
-    "SecretKey": "f76bf7dc6e8a260f725f8a50ef9a8c4bd08ba2ae38e3b51d77d66617d1d6b7c0",
+    "SecretKey": "1ZWBi389z6RvJBrvwbXqeBNbzaYVpHbIfGQmIsV1gwI=",
     "Issuer": "HealthcareManager",
     "Audience": "HealthCareManagerUsers",
     "ExpirationTime": 1440
@@ -46,5 +37,10 @@
     "UserName": "andreimihneacerbu@gmail.com",
     "Password": "zpK3w71LkNa0sGt6"
   },
+  "AdminSettings": {
+    "Name": "Admin",
+    "Email": "admin@domain.com",
+    "Password": "administrator"
+  },
   "AllowedHosts": "*"
 }

backend/API/disease_prediction.log

@@ -31,3 +31,123 @@ Initializing DiseasePredictor
 2024-04-12 12:20:55,715 INFO:Making a prediction
 2024-04-12 12:20:55,715 INFO:Extracting features from text
 2024-04-12 12:20:55,715 INFO:Tokens extracted: {'Disease': 'No', 'Fever': 'Yes', 'Cough': 'No', 'Fatigue': 'No', 'Difficulty Breathing': 'No', 'Blood Pressure': 'Yes', 'Cholesterol Level': 'No', 'Age': 40, 'Gender': 'Male'}
+2024-05-20 04:09:22,628 INFO:
+
+Initializing DiseasePredictor
+2024-05-20 04:09:22,645 INFO:Training model
+2024-05-20 04:09:22,767 INFO:Training accuracy: 0.77
+2024-05-20 04:09:22,767 INFO:Making a prediction
+2024-05-20 04:09:22,767 INFO:Extracting features from text
+2024-05-20 04:09:22,767 INFO:Tokens extracted: {'Disease': 'No', 'Fever': 'No', 'Cough': 'No', 'Fatigue': 'No', 'Difficulty Breathing': 'No', 'Blood Pressure': 'No', 'Cholesterol Level': 'No', 'Age': nan, 'Gender': nan}
+2024-05-20 04:10:25,589 INFO:
+
+Initializing DiseasePredictor
+2024-05-20 04:10:25,592 INFO:Training model
+2024-05-20 04:10:25,707 INFO:Training accuracy: 0.77
+2024-05-20 04:10:25,707 INFO:Making a prediction
+2024-05-20 04:10:25,707 INFO:Extracting features from text
+2024-05-20 04:10:25,707 INFO:Tokens extracted: {'Disease': 'No', 'Fever': 'No', 'Cough': 'No', 'Fatigue': 'No', 'Difficulty Breathing': 'No', 'Blood Pressure': 'No', 'Cholesterol Level': 'No', 'Age': nan, 'Gender': nan}
+2024-05-20 04:13:44,611 INFO:
+
+Initializing DiseasePredictor
+2024-05-20 04:13:44,614 INFO:Training model
+2024-05-20 04:13:44,729 INFO:Training accuracy: 0.77
+2024-05-20 04:13:44,729 INFO:Making a prediction
+2024-05-20 04:13:44,729 INFO:Extracting features from text
+2024-05-20 04:13:44,729 INFO:Tokens extracted: {'Disease': 'No', 'Fever': 'No', 'Cough': 'No', 'Fatigue': 'No', 'Difficulty Breathing': 'No', 'Blood Pressure': 'No', 'Cholesterol Level': 'No', 'Age': nan, 'Gender': nan}
+2024-05-20 04:15:15,264 INFO:
+
+Initializing DiseasePredictor
+2024-05-20 04:15:15,269 INFO:Training model
+2024-05-20 04:15:15,414 INFO:Training accuracy: 0.77
+2024-05-20 04:15:15,414 INFO:Making a prediction
+2024-05-20 04:15:15,414 INFO:Extracting features from text
+2024-05-20 04:15:15,414 INFO:Tokens extracted: {'Disease': 'No', 'Fever': 'No', 'Cough': 'No', 'Fatigue': 'No', 'Difficulty Breathing': 'No', 'Blood Pressure': 'No', 'Cholesterol Level': 'No', 'Age': nan, 'Gender': nan}
+2024-05-20 04:15:53,123 INFO:
+
+Initializing DiseasePredictor
+2024-05-20 04:15:53,128 INFO:Training model
+2024-05-20 04:15:53,248 INFO:Training accuracy: 0.77
+2024-05-20 04:15:53,248 INFO:Making a prediction
+2024-05-20 04:15:53,249 INFO:Extracting features from text
+2024-05-20 04:15:53,249 INFO:Tokens extracted: {'Disease': 'No', 'Fever': 'No', 'Cough': 'No', 'Fatigue': 'No', 'Difficulty Breathing': 'No', 'Blood Pressure': 'No', 'Cholesterol Level': 'No', 'Age': nan, 'Gender': nan}
+2024-05-20 04:20:38,455 INFO:
+
+Initializing DiseasePredictor
+2024-05-20 04:20:38,458 INFO:Training model
+2024-05-20 04:20:38,571 INFO:Training accuracy: 0.77
+2024-05-20 04:20:38,571 INFO:Making a prediction
+2024-05-20 04:20:38,571 INFO:Extracting features from text
+2024-05-20 04:20:38,571 INFO:Tokens extracted: {'Disease': 'No', 'Fever': 'No', 'Cough': 'No', 'Fatigue': 'No', 'Difficulty Breathing': 'No', 'Blood Pressure': 'No', 'Cholesterol Level': 'No', 'Age': nan, 'Gender': nan}
+2024-05-20 04:23:53,816 INFO:
+
+Initializing DiseasePredictor
+2024-05-20 04:23:53,820 INFO:Training model
+2024-05-20 04:23:53,933 INFO:Training accuracy: 0.77
+2024-05-20 04:23:53,933 INFO:Making a prediction
+2024-05-20 04:23:53,933 INFO:Extracting features from text
+2024-05-20 04:23:53,933 INFO:Tokens extracted: {'Disease': 'No', 'Fever': 'No', 'Cough': 'No', 'Fatigue': 'No', 'Difficulty Breathing': 'No', 'Blood Pressure': 'No', 'Cholesterol Level': 'No', 'Age': nan, 'Gender': nan}
+2024-05-20 04:27:20,294 INFO:
+
+Initializing DiseasePredictor
+2024-05-20 04:27:20,297 INFO:Training model
+2024-05-20 04:27:20,418 INFO:Training accuracy: 0.77
+2024-05-20 04:27:20,418 INFO:Making a prediction
+2024-05-20 04:27:20,418 INFO:Extracting features from text
+2024-05-20 04:27:20,418 INFO:Tokens extracted: {'Disease': 'No', 'Fever': 'No', 'Cough': 'No', 'Fatigue': 'No', 'Difficulty Breathing': 'No', 'Blood Pressure': 'No', 'Cholesterol Level': 'No', 'Age': nan, 'Gender': nan}
+2024-05-20 04:30:00,948 INFO:
+
+Initializing DiseasePredictor
+2024-05-20 04:30:00,951 INFO:Training model
+2024-05-20 04:30:01,093 INFO:Training accuracy: 0.77
+2024-05-20 04:30:01,093 INFO:Making a prediction
+2024-05-20 04:30:01,093 INFO:Extracting features from text
+2024-05-20 04:30:01,093 INFO:Tokens extracted: {'Disease': 'No', 'Fever': 'No', 'Cough': 'No', 'Fatigue': 'No', 'Difficulty Breathing': 'No', 'Blood Pressure': 'No', 'Cholesterol Level': 'No', 'Age': nan, 'Gender': nan}
+2024-05-20 04:30:23,770 INFO:
+
+Initializing DiseasePredictor
+2024-05-20 04:30:23,773 INFO:Training model
+2024-05-20 04:30:23,885 INFO:Training accuracy: 0.77
+2024-05-20 04:30:23,885 INFO:Making a prediction
+2024-05-20 04:30:23,885 INFO:Extracting features from text
+2024-05-20 04:30:23,885 INFO:Tokens extracted: {'Disease': 'No', 'Fever': 'No', 'Cough': 'No', 'Fatigue': 'No', 'Difficulty Breathing': 'No', 'Blood Pressure': 'No', 'Cholesterol Level': 'No', 'Age': nan, 'Gender': nan}
+2024-05-20 04:59:30,991 INFO:
+
+Initializing DiseasePredictor
+2024-05-20 04:59:30,994 INFO:Training model
+2024-05-20 04:59:31,111 INFO:Training accuracy: 0.77
+2024-05-20 04:59:31,111 INFO:Making a prediction
+2024-05-20 04:59:31,112 INFO:Extracting features from text
+2024-05-20 04:59:31,112 INFO:Tokens extracted: {'Disease': 'No', 'Fever': 'No', 'Cough': 'No', 'Fatigue': 'No', 'Difficulty Breathing': 'No', 'Blood Pressure': 'No', 'Cholesterol Level': 'No', 'Age': nan, 'Gender': nan}
+2024-05-21 09:13:50,570 INFO:
+
+Initializing DiseasePredictor
+2024-05-21 09:13:50,589 INFO:Training model
+2024-05-21 09:13:50,711 INFO:Training accuracy: 0.77
+2024-05-21 09:13:50,711 INFO:Making a prediction
+2024-05-21 09:13:50,711 INFO:Extracting features from text
+2024-05-21 09:13:50,711 INFO:Tokens extracted: {'Disease': 'No', 'Fever': 'No', 'Cough': 'No', 'Fatigue': 'No', 'Difficulty Breathing': 'No', 'Blood Pressure': 'No', 'Cholesterol Level': 'No', 'Age': nan, 'Gender': nan}
+2024-05-21 09:14:34,067 INFO:
+
+Initializing DiseasePredictor
+2024-05-21 09:14:34,071 INFO:Training model
+2024-05-21 09:14:34,179 INFO:Training accuracy: 0.77
+2024-05-21 09:14:34,179 INFO:Making a prediction
+2024-05-21 09:14:34,179 INFO:Extracting features from text
+2024-05-21 09:14:34,180 INFO:Tokens extracted: {'Disease': 'No', 'Fever': 'No', 'Cough': 'No', 'Fatigue': 'No', 'Difficulty Breathing': 'No', 'Blood Pressure': 'No', 'Cholesterol Level': 'No', 'Age': nan, 'Gender': 'Male'}
+2024-05-21 09:14:39,006 INFO:
+
+Initializing DiseasePredictor
+2024-05-21 09:14:39,009 INFO:Training model
+2024-05-21 09:14:39,127 INFO:Training accuracy: 0.77
+2024-05-21 09:14:39,127 INFO:Making a prediction
+2024-05-21 09:14:39,127 INFO:Extracting features from text
+2024-05-21 09:14:39,127 INFO:Tokens extracted: {'Disease': 'No', 'Fever': 'No', 'Cough': 'No', 'Fatigue': 'No', 'Difficulty Breathing': 'No', 'Blood Pressure': 'No', 'Cholesterol Level': 'No', 'Age': nan, 'Gender': 'Male'}
+2024-05-21 09:49:20,294 INFO:
+
+Initializing DiseasePredictor
+2024-05-21 09:49:20,304 INFO:Training model
+2024-05-21 09:49:20,424 INFO:Training accuracy: 0.77
+2024-05-21 09:49:20,424 INFO:Making a prediction
+2024-05-21 09:49:20,425 INFO:Extracting features from text
+2024-05-21 09:49:20,425 INFO:Tokens extracted: {'Disease': 'No', 'Fever': 'No', 'Cough': 'Yes', 'Fatigue': 'No', 'Difficulty Breathing': 'No', 'Blood Pressure': 'Yes', 'Cholesterol Level': 'No', 'Age': nan, 'Gender': nan}

backend/API/obj/API.csproj.nuget.dgspec.json

@@ -1,20 +1,20 @@
 {
   "format": 1,
   "restore": {
-    "/home/azureuser/CC-FinalProj/backend/API/API.csproj": {}
+    "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\API\\API.csproj": {}
   },
   "projects": {
-    "/home/azureuser/CC-FinalProj/backend/API/API.csproj": {
+    "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\API\\API.csproj": {
       "version": "1.0.0",
       "restore": {
-        "projectUniqueName": "/home/azureuser/CC-FinalProj/backend/API/API.csproj",
+        "projectUniqueName": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\API\\API.csproj",
         "projectName": "API",
-        "projectPath": "/home/azureuser/CC-FinalProj/backend/API/API.csproj",
+        "projectPath": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\API\\API.csproj",
-        "packagesPath": "/root/.nuget/packages/",
+        "packagesPath": "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\",
-        "outputPath": "/home/azureuser/CC-FinalProj/backend/API/obj/",
+        "outputPath": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\API\\obj\\",
         "projectStyle": "PackageReference",
         "configFilePaths": [
-          "/root/.nuget/NuGet/NuGet.Config"
+          "C:\\Users\\Andrei Cerbu\\AppData\\Roaming\\NuGet\\NuGet.Config"
         ],
         "originalTargetFrameworks": [
           "net8.0"
@@ -26,11 +26,11 @@
           "net8.0": {
             "targetAlias": "net8.0",
             "projectReferences": {
-              "/home/azureuser/CC-FinalProj/backend/Application/Application.csproj": {
+              "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Application\\Application.csproj": {
-                "projectPath": "/home/azureuser/CC-FinalProj/backend/Application/Application.csproj"
+                "projectPath": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Application\\Application.csproj"
               },
-              "/home/azureuser/CC-FinalProj/backend/Infrastructure/Infrastructure.csproj": {
+              "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Infrastructure\\Infrastructure.csproj": {
-                "projectPath": "/home/azureuser/CC-FinalProj/backend/Infrastructure/Infrastructure.csproj"
+                "projectPath": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Infrastructure\\Infrastructure.csproj"
               }
             }
           }
@@ -39,11 +39,6 @@
           "warnAsError": [
             "NU1605"
           ]
-        },
-        "restoreAuditProperties": {
-          "enableAudit": "true",
-          "auditLevel": "low",
-          "auditMode": "direct"
         }
       },
       "frameworks": {
@@ -54,6 +49,14 @@
               "target": "Package",
               "version": "[8.0.3, )"
             },
+            "MongoDB.Driver": {
+              "target": "Package",
+              "version": "[2.25.0, )"
+            },
+            "Newtonsoft.Json": {
+              "target": "Package",
+              "version": "[13.0.3, )"
+            },
             "Swashbuckle.AspNetCore": {
               "target": "Package",
               "version": "[6.5.0, )"
@@ -78,21 +81,21 @@
               "privateAssets": "all"
             }
           },
-          "runtimeIdentifierGraphPath": "/usr/share/dotnet/sdk/8.0.204/PortableRuntimeIdentifierGraph.json"
+          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\8.0.204/PortableRuntimeIdentifierGraph.json"
         }
       }
     },
-    "/home/azureuser/CC-FinalProj/backend/Application/Application.csproj": {
+    "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Application\\Application.csproj": {
       "version": "1.0.0",
       "restore": {
-        "projectUniqueName": "/home/azureuser/CC-FinalProj/backend/Application/Application.csproj",
+        "projectUniqueName": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Application\\Application.csproj",
         "projectName": "Application",
-        "projectPath": "/home/azureuser/CC-FinalProj/backend/Application/Application.csproj",
+        "projectPath": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Application\\Application.csproj",
-        "packagesPath": "/root/.nuget/packages/",
+        "packagesPath": "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\",
-        "outputPath": "/home/azureuser/CC-FinalProj/backend/Application/obj/",
+        "outputPath": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Application\\obj\\",
         "projectStyle": "PackageReference",
         "configFilePaths": [
-          "/root/.nuget/NuGet/NuGet.Config"
+          "C:\\Users\\Andrei Cerbu\\AppData\\Roaming\\NuGet\\NuGet.Config"
         ],
         "originalTargetFrameworks": [
           "net8.0"
@@ -104,8 +107,8 @@
           "net8.0": {
             "targetAlias": "net8.0",
             "projectReferences": {
-              "/home/azureuser/CC-FinalProj/backend/Core/Core.csproj": {
+              "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Domain\\Domain.csproj": {
-                "projectPath": "/home/azureuser/CC-FinalProj/backend/Core/Core.csproj"
+                "projectPath": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Domain\\Domain.csproj"
               }
             }
           }
@@ -114,11 +117,6 @@
           "warnAsError": [
             "NU1605"
           ]
-        },
-        "restoreAuditProperties": {
-          "enableAudit": "true",
-          "auditLevel": "low",
-          "auditMode": "direct"
         }
       },
       "frameworks": {
@@ -132,6 +130,10 @@
             "MongoDB.Driver": {
               "target": "Package",
               "version": "[2.24.0, )"
+            },
+            "Newtonsoft.Json": {
+              "target": "Package",
+              "version": "[13.0.3, )"
             }
           },
           "imports": [
@@ -150,21 +152,21 @@
               "privateAssets": "all"
             }
           },
-          "runtimeIdentifierGraphPath": "/usr/share/dotnet/sdk/8.0.204/PortableRuntimeIdentifierGraph.json"
+          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\8.0.204/PortableRuntimeIdentifierGraph.json"
         }
       }
     },
-    "/home/azureuser/CC-FinalProj/backend/Core/Core.csproj": {
+    "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Domain\\Domain.csproj": {
       "version": "1.0.0",
       "restore": {
-        "projectUniqueName": "/home/azureuser/CC-FinalProj/backend/Core/Core.csproj",
+        "projectUniqueName": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Domain\\Domain.csproj",
-        "projectName": "Core",
+        "projectName": "Domain",
-        "projectPath": "/home/azureuser/CC-FinalProj/backend/Core/Core.csproj",
+        "projectPath": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Domain\\Domain.csproj",
-        "packagesPath": "/root/.nuget/packages/",
+        "packagesPath": "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\",
-        "outputPath": "/home/azureuser/CC-FinalProj/backend/Core/obj/",
+        "outputPath": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Domain\\obj\\",
         "projectStyle": "PackageReference",
         "configFilePaths": [
-          "/root/.nuget/NuGet/NuGet.Config"
+          "C:\\Users\\Andrei Cerbu\\AppData\\Roaming\\NuGet\\NuGet.Config"
         ],
         "originalTargetFrameworks": [
           "net8.0"
@@ -182,11 +184,6 @@
           "warnAsError": [
             "NU1605"
           ]
-        },
-        "restoreAuditProperties": {
-          "enableAudit": "true",
-          "auditLevel": "low",
-          "auditMode": "direct"
         }
       },
       "frameworks": {
@@ -214,21 +211,21 @@
               "privateAssets": "all"
             }
           },
-          "runtimeIdentifierGraphPath": "/usr/share/dotnet/sdk/8.0.204/PortableRuntimeIdentifierGraph.json"
+          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\8.0.204/PortableRuntimeIdentifierGraph.json"
         }
       }
     },
-    "/home/azureuser/CC-FinalProj/backend/Infrastructure/Infrastructure.csproj": {
+    "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Infrastructure\\Infrastructure.csproj": {
       "version": "1.0.0",
       "restore": {
-        "projectUniqueName": "/home/azureuser/CC-FinalProj/backend/Infrastructure/Infrastructure.csproj",
+        "projectUniqueName": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Infrastructure\\Infrastructure.csproj",
         "projectName": "Infrastructure",
-        "projectPath": "/home/azureuser/CC-FinalProj/backend/Infrastructure/Infrastructure.csproj",
+        "projectPath": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Infrastructure\\Infrastructure.csproj",
-        "packagesPath": "/root/.nuget/packages/",
+        "packagesPath": "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\",
-        "outputPath": "/home/azureuser/CC-FinalProj/backend/Infrastructure/obj/",
+        "outputPath": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Infrastructure\\obj\\",
         "projectStyle": "PackageReference",
         "configFilePaths": [
-          "/root/.nuget/NuGet/NuGet.Config"
+          "C:\\Users\\Andrei Cerbu\\AppData\\Roaming\\NuGet\\NuGet.Config"
         ],
         "originalTargetFrameworks": [
           "net8.0"
@@ -240,11 +237,11 @@
           "net8.0": {
             "targetAlias": "net8.0",
             "projectReferences": {
-              "/home/azureuser/CC-FinalProj/backend/Application/Application.csproj": {
+              "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Application\\Application.csproj": {
-                "projectPath": "/home/azureuser/CC-FinalProj/backend/Application/Application.csproj"
+                "projectPath": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Application\\Application.csproj"
               },
-              "/home/azureuser/CC-FinalProj/backend/Core/Core.csproj": {
+              "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Domain\\Domain.csproj": {
-                "projectPath": "/home/azureuser/CC-FinalProj/backend/Core/Core.csproj"
+                "projectPath": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Domain\\Domain.csproj"
               }
             }
           }
@@ -253,30 +250,37 @@
           "warnAsError": [
             "NU1605"
           ]
-        },
-        "restoreAuditProperties": {
-          "enableAudit": "true",
-          "auditLevel": "low",
-          "auditMode": "direct"
         }
       },
       "frameworks": {
         "net8.0": {
           "targetAlias": "net8.0",
           "dependencies": {
+            "Microsoft.AspNetCore.Authentication": {
+              "target": "Package",
+              "version": "[2.2.0, )"
+            },
+            "Microsoft.AspNetCore.Http.Features": {
+              "target": "Package",
+              "version": "[6.0.0-preview.4.21253.5, )"
+            },
+            "Microsoft.AspNetCore.Identity.EntityFrameworkCore": {
+              "target": "Package",
+              "version": "[8.0.5, )"
+            },
             "Microsoft.EntityFrameworkCore": {
               "target": "Package",
-              "version": "[8.0.3, )"
+              "version": "[8.0.5, )"
             },
             "Microsoft.EntityFrameworkCore.Design": {
               "include": "Runtime, Build, Native, ContentFiles, Analyzers, BuildTransitive",
               "suppressParent": "All",
               "target": "Package",
-              "version": "[8.0.3, )"
+              "version": "[8.0.5, )"
             },
             "Microsoft.EntityFrameworkCore.Relational": {
               "target": "Package",
-              "version": "[8.0.3, )"
+              "version": "[8.0.5, )"
             },
             "Microsoft.Extensions.Configuration": {
               "target": "Package",
@@ -300,7 +304,7 @@
             },
             "Npgsql.EntityFrameworkCore.PostgreSQL": {
               "target": "Package",
-              "version": "[8.0.2, )"
+              "version": "[8.0.4, )"
             },
             "System.IdentityModel.Tokens.Jwt": {
               "target": "Package",
@@ -323,7 +327,7 @@
               "privateAssets": "all"
             }
           },
-          "runtimeIdentifierGraphPath": "/usr/share/dotnet/sdk/8.0.204/PortableRuntimeIdentifierGraph.json"
+          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\8.0.204/PortableRuntimeIdentifierGraph.json"
         }
       }
     }

backend/API/obj/API.csproj.nuget.g.props

@@ -4,22 +4,22 @@
     <RestoreSuccess Condition=" '$(RestoreSuccess)' == '' ">True</RestoreSuccess>
     <RestoreTool Condition=" '$(RestoreTool)' == '' ">NuGet</RestoreTool>
     <ProjectAssetsFile Condition=" '$(ProjectAssetsFile)' == '' ">$(MSBuildThisFileDirectory)project.assets.json</ProjectAssetsFile>
-    <NuGetPackageRoot Condition=" '$(NuGetPackageRoot)' == '' ">/root/.nuget/packages/</NuGetPackageRoot>
+    <NuGetPackageRoot Condition=" '$(NuGetPackageRoot)' == '' ">$(UserProfile)\.nuget\packages\</NuGetPackageRoot>
-    <NuGetPackageFolders Condition=" '$(NuGetPackageFolders)' == '' ">/root/.nuget/packages/</NuGetPackageFolders>
+    <NuGetPackageFolders Condition=" '$(NuGetPackageFolders)' == '' ">C:\Users\Andrei Cerbu\.nuget\packages\</NuGetPackageFolders>
     <NuGetProjectStyle Condition=" '$(NuGetProjectStyle)' == '' ">PackageReference</NuGetProjectStyle>
     <NuGetToolVersion Condition=" '$(NuGetToolVersion)' == '' ">6.9.1</NuGetToolVersion>
   </PropertyGroup>
   <ItemGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
-    <SourceRoot Include="/root/.nuget/packages/" />
+    <SourceRoot Include="C:\Users\Andrei Cerbu\.nuget\packages\" />
   </ItemGroup>
   <ImportGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
-    <Import Project="$(NuGetPackageRoot)microsoft.extensions.apidescription.server/6.0.5/build/Microsoft.Extensions.ApiDescription.Server.props" Condition="Exists('$(NuGetPackageRoot)microsoft.extensions.apidescription.server/6.0.5/build/Microsoft.Extensions.ApiDescription.Server.props')" />
+    <Import Project="$(NuGetPackageRoot)microsoft.extensions.apidescription.server\6.0.5\build\Microsoft.Extensions.ApiDescription.Server.props" Condition="Exists('$(NuGetPackageRoot)microsoft.extensions.apidescription.server\6.0.5\build\Microsoft.Extensions.ApiDescription.Server.props')" />
-    <Import Project="$(NuGetPackageRoot)swashbuckle.aspnetcore/6.5.0/build/Swashbuckle.AspNetCore.props" Condition="Exists('$(NuGetPackageRoot)swashbuckle.aspnetcore/6.5.0/build/Swashbuckle.AspNetCore.props')" />
+    <Import Project="$(NuGetPackageRoot)swashbuckle.aspnetcore\6.5.0\build\Swashbuckle.AspNetCore.props" Condition="Exists('$(NuGetPackageRoot)swashbuckle.aspnetcore\6.5.0\build\Swashbuckle.AspNetCore.props')" />
-    <Import Project="$(NuGetPackageRoot)microsoft.entityframeworkcore/8.0.3/buildTransitive/net8.0/Microsoft.EntityFrameworkCore.props" Condition="Exists('$(NuGetPackageRoot)microsoft.entityframeworkcore/8.0.3/buildTransitive/net8.0/Microsoft.EntityFrameworkCore.props')" />
+    <Import Project="$(NuGetPackageRoot)microsoft.entityframeworkcore\8.0.5\buildTransitive\net8.0\Microsoft.EntityFrameworkCore.props" Condition="Exists('$(NuGetPackageRoot)microsoft.entityframeworkcore\8.0.5\buildTransitive\net8.0\Microsoft.EntityFrameworkCore.props')" />
   </ImportGroup>
   <PropertyGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
-    <PkgMicrosoft_Extensions_ApiDescription_Server Condition=" '$(PkgMicrosoft_Extensions_ApiDescription_Server)' == '' ">/root/.nuget/packages/microsoft.extensions.apidescription.server/6.0.5</PkgMicrosoft_Extensions_ApiDescription_Server>
+    <PkgMicrosoft_Extensions_ApiDescription_Server Condition=" '$(PkgMicrosoft_Extensions_ApiDescription_Server)' == '' ">C:\Users\Andrei Cerbu\.nuget\packages\microsoft.extensions.apidescription.server\6.0.5</PkgMicrosoft_Extensions_ApiDescription_Server>
-    <PkgAWSSDK_Core Condition=" '$(PkgAWSSDK_Core)' == '' ">/root/.nuget/packages/awssdk.core/3.7.100.14</PkgAWSSDK_Core>
+    <PkgAWSSDK_Core Condition=" '$(PkgAWSSDK_Core)' == '' ">C:\Users\Andrei Cerbu\.nuget\packages\awssdk.core\3.7.100.14</PkgAWSSDK_Core>
-    <PkgAWSSDK_SecurityToken Condition=" '$(PkgAWSSDK_SecurityToken)' == '' ">/root/.nuget/packages/awssdk.securitytoken/3.7.100.14</PkgAWSSDK_SecurityToken>
+    <PkgAWSSDK_SecurityToken Condition=" '$(PkgAWSSDK_SecurityToken)' == '' ">C:\Users\Andrei Cerbu\.nuget\packages\awssdk.securitytoken\3.7.100.14</PkgAWSSDK_SecurityToken>
   </PropertyGroup>
 </Project>

backend/API/obj/API.csproj.nuget.g.targets

@@ -1,10 +1,10 @@
 <?xml version="1.0" encoding="utf-8" standalone="no"?>
 <Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ImportGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
-    <Import Project="$(NuGetPackageRoot)system.text.json/8.0.0/buildTransitive/net6.0/System.Text.Json.targets" Condition="Exists('$(NuGetPackageRoot)system.text.json/8.0.0/buildTransitive/net6.0/System.Text.Json.targets')" />
+    <Import Project="$(NuGetPackageRoot)system.text.json\8.0.0\buildTransitive\net6.0\System.Text.Json.targets" Condition="Exists('$(NuGetPackageRoot)system.text.json\8.0.0\buildTransitive\net6.0\System.Text.Json.targets')" />
-    <Import Project="$(NuGetPackageRoot)microsoft.extensions.apidescription.server/6.0.5/build/Microsoft.Extensions.ApiDescription.Server.targets" Condition="Exists('$(NuGetPackageRoot)microsoft.extensions.apidescription.server/6.0.5/build/Microsoft.Extensions.ApiDescription.Server.targets')" />
+    <Import Project="$(NuGetPackageRoot)microsoft.extensions.apidescription.server\6.0.5\build\Microsoft.Extensions.ApiDescription.Server.targets" Condition="Exists('$(NuGetPackageRoot)microsoft.extensions.apidescription.server\6.0.5\build\Microsoft.Extensions.ApiDescription.Server.targets')" />
-    <Import Project="$(NuGetPackageRoot)microsoft.extensions.logging.abstractions/8.0.0/buildTransitive/net6.0/Microsoft.Extensions.Logging.Abstractions.targets" Condition="Exists('$(NuGetPackageRoot)microsoft.extensions.logging.abstractions/8.0.0/buildTransitive/net6.0/Microsoft.Extensions.Logging.Abstractions.targets')" />
+    <Import Project="$(NuGetPackageRoot)microsoft.extensions.logging.abstractions\8.0.0\buildTransitive\net6.0\Microsoft.Extensions.Logging.Abstractions.targets" Condition="Exists('$(NuGetPackageRoot)microsoft.extensions.logging.abstractions\8.0.0\buildTransitive\net6.0\Microsoft.Extensions.Logging.Abstractions.targets')" />
-    <Import Project="$(NuGetPackageRoot)microsoft.extensions.options/8.0.0/buildTransitive/net6.0/Microsoft.Extensions.Options.targets" Condition="Exists('$(NuGetPackageRoot)microsoft.extensions.options/8.0.0/buildTransitive/net6.0/Microsoft.Extensions.Options.targets')" />
+    <Import Project="$(NuGetPackageRoot)microsoft.extensions.options\8.0.2\buildTransitive\net6.0\Microsoft.Extensions.Options.targets" Condition="Exists('$(NuGetPackageRoot)microsoft.extensions.options\8.0.2\buildTransitive\net6.0\Microsoft.Extensions.Options.targets')" />
-    <Import Project="$(NuGetPackageRoot)microsoft.extensions.configuration.binder/8.0.0/buildTransitive/netstandard2.0/Microsoft.Extensions.Configuration.Binder.targets" Condition="Exists('$(NuGetPackageRoot)microsoft.extensions.configuration.binder/8.0.0/buildTransitive/netstandard2.0/Microsoft.Extensions.Configuration.Binder.targets')" />
+    <Import Project="$(NuGetPackageRoot)microsoft.extensions.configuration.binder\8.0.0\buildTransitive\netstandard2.0\Microsoft.Extensions.Configuration.Binder.targets" Condition="Exists('$(NuGetPackageRoot)microsoft.extensions.configuration.binder\8.0.0\buildTransitive\netstandard2.0\Microsoft.Extensions.Configuration.Binder.targets')" />
   </ImportGroup>
 </Project>

backend/API/obj/Debug/net8.0/API.AssemblyInfo.cs

@@ -13,7 +13,7 @@ using System.Reflection;
 [assembly: System.Reflection.AssemblyCompanyAttribute("API")]
 [assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")]
 [assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
-[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+8d0553a7baf3abb4e5ff26719515fdb7a34f9565")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0")]
 [assembly: System.Reflection.AssemblyProductAttribute("API")]
 [assembly: System.Reflection.AssemblyTitleAttribute("API")]
 [assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]

backend/API/obj/Debug/net8.0/API.AssemblyInfoInputs.cache

@@ -1 +1 @@
-9fbd513f0786806c17766b2e68ccd1c9a18b73413a04aa4dc46ee10e0fff22a9
+7cf0cf1bc0c1bb1fa8ec578557b749a7cc57ef8cae429498fee10b33ff11b247

backend/API/obj/Debug/net8.0/API.GeneratedMSBuildEditorConfig.editorconfig

@@ -9,11 +9,11 @@ build_property.EnforceExtendedAnalyzerRules =
 build_property._SupportedPlatformList = Linux,macOS,Windows
 build_property.RootNamespace = API
 build_property.RootNamespace = API
-build_property.ProjectDir = /home/azureuser/CC-FinalProj/backend/API/
+build_property.ProjectDir = C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\
 build_property.EnableComHosting = 
 build_property.EnableGeneratedComInterfaceComImportInterop = 
 build_property.RazorLangVersion = 8.0
 build_property.SupportLocalizedComponentNames = 
 build_property.GenerateRazorMetadataSourceChecksumAttributes = 
-build_property.MSBuildProjectDirectory = /home/azureuser/CC-FinalProj/backend/API
+build_property.MSBuildProjectDirectory = C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API
 build_property._RazorSourceGeneratorDebug = 

backend/API/obj/Debug/net8.0/API.csproj.CoreCompileInputs.cache

@@ -1 +1 @@
-233ebfe2d35d45f34e572600746f65e38b167c7292d5dc26d4ccae73dbd11a81
+a89e77aa6fef42385391cd29691ef89581a70559b935a6874369da932f8414b1

backend/API/obj/Debug/net8.0/API.csproj.FileListAbsolute.txt

@@ -260,3 +260,222 @@ C:/Users/Andrei Cerbu/Documents/FACULTATE/CC-FinalProj/backend/API/obj/Debug/net
 /home/azureuser/CC-FinalProj/backend/API/obj/Debug/net8.0/API.pdb
 /home/azureuser/CC-FinalProj/backend/API/obj/Debug/net8.0/API.genruntimeconfig.cache
 /home/azureuser/CC-FinalProj/backend/API/obj/Debug/net8.0/ref/API.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/appsettings.Development.json
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/appsettings.json
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/API.exe
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/API.deps.json
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/API.runtimeconfig.json
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/API.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/API.pdb
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/AWSSDK.Core.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/AWSSDK.SecurityToken.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/DnsClient.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/FluentValidation.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Microsoft.AspNetCore.Authentication.JwtBearer.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Microsoft.EntityFrameworkCore.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Microsoft.EntityFrameworkCore.Abstractions.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Microsoft.EntityFrameworkCore.Relational.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Microsoft.IdentityModel.Abstractions.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Microsoft.IdentityModel.JsonWebTokens.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Microsoft.IdentityModel.Logging.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Microsoft.IdentityModel.Protocols.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Microsoft.IdentityModel.Protocols.OpenIdConnect.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Microsoft.IdentityModel.Tokens.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Microsoft.OpenApi.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/MongoDB.Bson.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/MongoDB.Driver.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/MongoDB.Driver.Core.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/MongoDB.Libmongocrypt.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Npgsql.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Npgsql.EntityFrameworkCore.PostgreSQL.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/SharpCompress.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Snappier.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Swashbuckle.AspNetCore.Swagger.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Swashbuckle.AspNetCore.SwaggerGen.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Swashbuckle.AspNetCore.SwaggerUI.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/System.IdentityModel.Tokens.Jwt.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/ZstdSharp.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/runtimes/linux/native/libmongocrypt.so
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/runtimes/osx/native/libmongocrypt.dylib
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/runtimes/win/native/mongocrypt.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Application.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Domain.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Infrastructure.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Application.pdb
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Infrastructure.pdb
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Domain.pdb
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/API.csproj.AssemblyReference.cache
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/API.GeneratedMSBuildEditorConfig.editorconfig
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/API.AssemblyInfoInputs.cache
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/API.AssemblyInfo.cs
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/API.csproj.CoreCompileInputs.cache
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/API.MvcApplicationPartsAssemblyInfo.cs
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/API.MvcApplicationPartsAssemblyInfo.cache
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/staticwebassets.build.json
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/staticwebassets.development.json
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/staticwebassets/msbuild.API.Microsoft.AspNetCore.StaticWebAssets.props
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/staticwebassets/msbuild.build.API.props
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/staticwebassets/msbuild.buildMultiTargeting.API.props
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/staticwebassets/msbuild.buildTransitive.API.props
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/staticwebassets.pack.json
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/scopedcss/bundle/API.styles.css
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/API.csproj.Up2Date
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/API.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/refint/API.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/API.pdb
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/API.genruntimeconfig.cache
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/obj/Debug/net8.0/ref/API.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Microsoft.AspNetCore.Cryptography.Internal.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Microsoft.AspNetCore.Cryptography.KeyDerivation.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Microsoft.AspNetCore.Identity.EntityFrameworkCore.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Microsoft.Extensions.Identity.Core.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Microsoft.Extensions.Identity.Stores.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Microsoft.Extensions.Options.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/Newtonsoft.Json.dll
+C:/Users/Andrei Cerbu/Desktop/HealthcareMAnagerToImprove/backend/API/bin/Debug/net8.0/System.Security.Permissions.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/appsettings.Development.json
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/appsettings.json
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/API
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/API.deps.json
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/API.runtimeconfig.json
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/API.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/API.pdb
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/AWSSDK.Core.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/AWSSDK.SecurityToken.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/DnsClient.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/FluentValidation.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Microsoft.AspNetCore.Authentication.JwtBearer.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Microsoft.AspNetCore.Cryptography.Internal.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Microsoft.AspNetCore.Cryptography.KeyDerivation.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Microsoft.AspNetCore.Identity.EntityFrameworkCore.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Microsoft.EntityFrameworkCore.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Microsoft.EntityFrameworkCore.Abstractions.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Microsoft.EntityFrameworkCore.Relational.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Microsoft.Extensions.Identity.Core.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Microsoft.Extensions.Identity.Stores.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Microsoft.Extensions.Options.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Microsoft.IdentityModel.Abstractions.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Microsoft.IdentityModel.JsonWebTokens.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Microsoft.IdentityModel.Logging.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Microsoft.IdentityModel.Protocols.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Microsoft.IdentityModel.Protocols.OpenIdConnect.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Microsoft.IdentityModel.Tokens.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Microsoft.OpenApi.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/MongoDB.Bson.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/MongoDB.Driver.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/MongoDB.Driver.Core.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/MongoDB.Libmongocrypt.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Newtonsoft.Json.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Npgsql.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Npgsql.EntityFrameworkCore.PostgreSQL.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/SharpCompress.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Snappier.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Swashbuckle.AspNetCore.Swagger.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Swashbuckle.AspNetCore.SwaggerGen.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Swashbuckle.AspNetCore.SwaggerUI.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/System.IdentityModel.Tokens.Jwt.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/System.Security.Permissions.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/ZstdSharp.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/runtimes/linux/native/libmongocrypt.so
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/runtimes/osx/native/libmongocrypt.dylib
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/runtimes/win/native/mongocrypt.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Application.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Domain.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Infrastructure.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Application.pdb
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Infrastructure.pdb
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/bin/Debug/net8.0/Domain.pdb
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/API.csproj.AssemblyReference.cache
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/API.GeneratedMSBuildEditorConfig.editorconfig
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/API.AssemblyInfoInputs.cache
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/API.AssemblyInfo.cs
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/API.csproj.CoreCompileInputs.cache
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/API.MvcApplicationPartsAssemblyInfo.cs
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/API.MvcApplicationPartsAssemblyInfo.cache
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/staticwebassets.build.json
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/staticwebassets.development.json
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/staticwebassets/msbuild.API.Microsoft.AspNetCore.StaticWebAssets.props
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/staticwebassets/msbuild.build.API.props
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/staticwebassets/msbuild.buildMultiTargeting.API.props
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/staticwebassets/msbuild.buildTransitive.API.props
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/staticwebassets.pack.json
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/scopedcss/bundle/API.styles.css
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/API.csproj.Up2Date
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/API.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/refint/API.dll
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/API.pdb
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/API.genruntimeconfig.cache
+/home/andrei/Documents/Projects/HealthcareManager/backend/API/obj/Debug/net8.0/ref/API.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\appsettings.Development.json
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\appsettings.json
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\API.exe
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\API.deps.json
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\API.runtimeconfig.json
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\API.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\API.pdb
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\AWSSDK.Core.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\AWSSDK.SecurityToken.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\DnsClient.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\FluentValidation.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Microsoft.AspNetCore.Authentication.JwtBearer.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Microsoft.AspNetCore.Cryptography.Internal.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Microsoft.AspNetCore.Cryptography.KeyDerivation.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Microsoft.AspNetCore.Identity.EntityFrameworkCore.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Microsoft.EntityFrameworkCore.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Microsoft.EntityFrameworkCore.Abstractions.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Microsoft.EntityFrameworkCore.Relational.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Microsoft.Extensions.Identity.Core.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Microsoft.Extensions.Identity.Stores.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Microsoft.Extensions.Options.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Microsoft.IdentityModel.Abstractions.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Microsoft.IdentityModel.JsonWebTokens.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Microsoft.IdentityModel.Logging.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Microsoft.IdentityModel.Protocols.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Microsoft.IdentityModel.Protocols.OpenIdConnect.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Microsoft.IdentityModel.Tokens.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Microsoft.OpenApi.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\MongoDB.Bson.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\MongoDB.Driver.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\MongoDB.Driver.Core.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\MongoDB.Libmongocrypt.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Newtonsoft.Json.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Npgsql.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Npgsql.EntityFrameworkCore.PostgreSQL.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\SharpCompress.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Snappier.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Swashbuckle.AspNetCore.Swagger.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Swashbuckle.AspNetCore.SwaggerGen.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Swashbuckle.AspNetCore.SwaggerUI.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\System.IdentityModel.Tokens.Jwt.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\System.Security.Permissions.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\ZstdSharp.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\runtimes\linux\native\libmongocrypt.so
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\runtimes\osx\native\libmongocrypt.dylib
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\runtimes\win\native\mongocrypt.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Application.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Domain.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Infrastructure.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Application.pdb
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Infrastructure.pdb
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\bin\Debug\net8.0\Domain.pdb
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\API.csproj.AssemblyReference.cache
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\API.GeneratedMSBuildEditorConfig.editorconfig
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\API.AssemblyInfoInputs.cache
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\API.AssemblyInfo.cs
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\API.csproj.CoreCompileInputs.cache
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\API.MvcApplicationPartsAssemblyInfo.cs
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\API.MvcApplicationPartsAssemblyInfo.cache
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\staticwebassets.build.json
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\staticwebassets.development.json
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\staticwebassets\msbuild.API.Microsoft.AspNetCore.StaticWebAssets.props
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\staticwebassets\msbuild.build.API.props
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\staticwebassets\msbuild.buildMultiTargeting.API.props
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\staticwebassets\msbuild.buildTransitive.API.props
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\staticwebassets.pack.json
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\scopedcss\bundle\API.styles.css
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\API.csproj.Up2Date
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\API.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\refint\API.dll
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\API.pdb
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\API.genruntimeconfig.cache
+C:\Users\Andrei Cerbu\Desktop\HealthcareMAnagerToImprove\backend\API\obj\Debug\net8.0\ref\API.dll

backend/API/obj/Debug/net8.0/API.genruntimeconfig.cache

@@ -1 +1 @@
-b79ca47763b1beb23cc810d75f5f6679835ca6ae5ee3371bc8b58e5ba8b88be8
+748b0238424c8ac4f7a3b475e06903e48212c169b799479438192d1be8cf2e03

backend/API/obj/Debug/net8.0/API.sourcelink.json

@@ -1 +0,0 @@
-{"documents":{"/home/azureuser/CC-FinalProj/*":"https://raw.githubusercontent.com/andrei-mihnea-cerbu/CC-FinalProj/8d0553a7baf3abb4e5ff26719515fdb7a34f9565/*"}}

backend/API/obj/Debug/net8.0/staticwebassets/msbuild.buildMultiTargeting.API.props

@@ -1,3 +1,3 @@
 <Project>
-  <Import Project="../build/API.props" />
+  <Import Project="..\build\API.props" />
 </Project>

backend/API/obj/Debug/net8.0/staticwebassets/msbuild.buildTransitive.API.props

@@ -1,3 +1,3 @@
 <Project>
-  <Import Project="../buildMultiTargeting/API.props" />
+  <Import Project="..\buildMultiTargeting\API.props" />
 </Project>

backend/API/obj/project.nuget.cache

@@ -1,66 +1,93 @@
 {
   "version": 2,
-  "dgSpecHash": "CcGZQ4bqkKNDq76D4OQ5Zaf4Emo2Mbnp6kQREOsFXrF85CirurFnuuGKOJuX1pAI8vToy+s+5qp+7fP/fW661Q==",
+  "dgSpecHash": "TQBfopoanV+qOunkiXV8QolkeO4NLwCuJara5nEFOV+hpvd3tn+GaByUNuy35POCaugaB9iYKd/FD8utiP6sDQ==",
   "success": true,
-  "projectFilePath": "/home/azureuser/CC-FinalProj/backend/API/API.csproj",
+  "projectFilePath": "C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\API\\API.csproj",
   "expectedPackageFiles": [
-    "/root/.nuget/packages/awssdk.core/3.7.100.14/awssdk.core.3.7.100.14.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\awssdk.core\\3.7.100.14\\awssdk.core.3.7.100.14.nupkg.sha512",
-    "/root/.nuget/packages/awssdk.securitytoken/3.7.100.14/awssdk.securitytoken.3.7.100.14.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\awssdk.securitytoken\\3.7.100.14\\awssdk.securitytoken.3.7.100.14.nupkg.sha512",
-    "/root/.nuget/packages/dnsclient/1.6.1/dnsclient.1.6.1.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\dnsclient\\1.6.1\\dnsclient.1.6.1.nupkg.sha512",
-    "/root/.nuget/packages/fluentvalidation/11.9.0/fluentvalidation.11.9.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\fluentvalidation\\11.9.0\\fluentvalidation.11.9.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.aspnetcore.authentication.jwtbearer/8.0.3/microsoft.aspnetcore.authentication.jwtbearer.8.0.3.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.aspnetcore.authentication\\2.2.0\\microsoft.aspnetcore.authentication.2.2.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.entityframeworkcore/8.0.3/microsoft.entityframeworkcore.8.0.3.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.aspnetcore.authentication.abstractions\\2.2.0\\microsoft.aspnetcore.authentication.abstractions.2.2.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.entityframeworkcore.abstractions/8.0.3/microsoft.entityframeworkcore.abstractions.8.0.3.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.aspnetcore.authentication.core\\2.2.0\\microsoft.aspnetcore.authentication.core.2.2.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.entityframeworkcore.analyzers/8.0.3/microsoft.entityframeworkcore.analyzers.8.0.3.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.aspnetcore.authentication.jwtbearer\\8.0.3\\microsoft.aspnetcore.authentication.jwtbearer.8.0.3.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.entityframeworkcore.relational/8.0.3/microsoft.entityframeworkcore.relational.8.0.3.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.aspnetcore.cryptography.internal\\8.0.5\\microsoft.aspnetcore.cryptography.internal.8.0.5.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.apidescription.server/6.0.5/microsoft.extensions.apidescription.server.6.0.5.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.aspnetcore.cryptography.keyderivation\\8.0.5\\microsoft.aspnetcore.cryptography.keyderivation.8.0.5.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.caching.abstractions/8.0.0/microsoft.extensions.caching.abstractions.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.aspnetcore.dataprotection\\2.2.0\\microsoft.aspnetcore.dataprotection.2.2.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.caching.memory/8.0.0/microsoft.extensions.caching.memory.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.aspnetcore.dataprotection.abstractions\\2.2.0\\microsoft.aspnetcore.dataprotection.abstractions.2.2.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.configuration/8.0.0/microsoft.extensions.configuration.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.aspnetcore.hosting.abstractions\\2.2.0\\microsoft.aspnetcore.hosting.abstractions.2.2.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.configuration.abstractions/8.0.0/microsoft.extensions.configuration.abstractions.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.aspnetcore.hosting.server.abstractions\\2.2.0\\microsoft.aspnetcore.hosting.server.abstractions.2.2.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.configuration.binder/8.0.0/microsoft.extensions.configuration.binder.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.aspnetcore.http\\2.2.0\\microsoft.aspnetcore.http.2.2.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.configuration.fileextensions/8.0.0/microsoft.extensions.configuration.fileextensions.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.aspnetcore.http.abstractions\\2.2.0\\microsoft.aspnetcore.http.abstractions.2.2.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.configuration.json/8.0.0/microsoft.extensions.configuration.json.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.aspnetcore.http.extensions\\2.2.0\\microsoft.aspnetcore.http.extensions.2.2.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.dependencyinjection/8.0.0/microsoft.extensions.dependencyinjection.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.aspnetcore.http.features\\6.0.0-preview.4.21253.5\\microsoft.aspnetcore.http.features.6.0.0-preview.4.21253.5.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.dependencyinjection.abstractions/8.0.0/microsoft.extensions.dependencyinjection.abstractions.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.aspnetcore.identity.entityframeworkcore\\8.0.5\\microsoft.aspnetcore.identity.entityframeworkcore.8.0.5.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.fileproviders.abstractions/8.0.0/microsoft.extensions.fileproviders.abstractions.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.aspnetcore.webutilities\\2.2.0\\microsoft.aspnetcore.webutilities.2.2.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.fileproviders.physical/8.0.0/microsoft.extensions.fileproviders.physical.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.entityframeworkcore\\8.0.5\\microsoft.entityframeworkcore.8.0.5.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.filesystemglobbing/8.0.0/microsoft.extensions.filesystemglobbing.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.entityframeworkcore.abstractions\\8.0.5\\microsoft.entityframeworkcore.abstractions.8.0.5.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.logging/8.0.0/microsoft.extensions.logging.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.entityframeworkcore.analyzers\\8.0.5\\microsoft.entityframeworkcore.analyzers.8.0.5.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.logging.abstractions/8.0.0/microsoft.extensions.logging.abstractions.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.entityframeworkcore.relational\\8.0.5\\microsoft.entityframeworkcore.relational.8.0.5.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.options/8.0.0/microsoft.extensions.options.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.apidescription.server\\6.0.5\\microsoft.extensions.apidescription.server.6.0.5.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.options.configurationextensions/8.0.0/microsoft.extensions.options.configurationextensions.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.caching.abstractions\\8.0.0\\microsoft.extensions.caching.abstractions.8.0.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.extensions.primitives/8.0.0/microsoft.extensions.primitives.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.caching.memory\\8.0.0\\microsoft.extensions.caching.memory.8.0.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.identitymodel.abstractions/7.5.1/microsoft.identitymodel.abstractions.7.5.1.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.configuration\\8.0.0\\microsoft.extensions.configuration.8.0.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.identitymodel.jsonwebtokens/7.5.1/microsoft.identitymodel.jsonwebtokens.7.5.1.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.configuration.abstractions\\8.0.0\\microsoft.extensions.configuration.abstractions.8.0.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.identitymodel.logging/7.5.1/microsoft.identitymodel.logging.7.5.1.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.configuration.binder\\8.0.0\\microsoft.extensions.configuration.binder.8.0.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.identitymodel.protocols/7.1.2/microsoft.identitymodel.protocols.7.1.2.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.configuration.fileextensions\\8.0.0\\microsoft.extensions.configuration.fileextensions.8.0.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.identitymodel.protocols.openidconnect/7.1.2/microsoft.identitymodel.protocols.openidconnect.7.1.2.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.configuration.json\\8.0.0\\microsoft.extensions.configuration.json.8.0.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.identitymodel.tokens/7.5.1/microsoft.identitymodel.tokens.7.5.1.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.dependencyinjection\\8.0.0\\microsoft.extensions.dependencyinjection.8.0.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.netcore.platforms/5.0.0/microsoft.netcore.platforms.5.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.dependencyinjection.abstractions\\8.0.0\\microsoft.extensions.dependencyinjection.abstractions.8.0.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.openapi/1.2.3/microsoft.openapi.1.2.3.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.fileproviders.abstractions\\8.0.0\\microsoft.extensions.fileproviders.abstractions.8.0.0.nupkg.sha512",
-    "/root/.nuget/packages/microsoft.win32.registry/5.0.0/microsoft.win32.registry.5.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.fileproviders.physical\\8.0.0\\microsoft.extensions.fileproviders.physical.8.0.0.nupkg.sha512",
-    "/root/.nuget/packages/mongodb.bson/2.24.0/mongodb.bson.2.24.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.filesystemglobbing\\8.0.0\\microsoft.extensions.filesystemglobbing.8.0.0.nupkg.sha512",
-    "/root/.nuget/packages/mongodb.driver/2.24.0/mongodb.driver.2.24.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.hosting.abstractions\\2.2.0\\microsoft.extensions.hosting.abstractions.2.2.0.nupkg.sha512",
-    "/root/.nuget/packages/mongodb.driver.core/2.24.0/mongodb.driver.core.2.24.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.identity.core\\8.0.5\\microsoft.extensions.identity.core.8.0.5.nupkg.sha512",
-    "/root/.nuget/packages/mongodb.libmongocrypt/1.8.2/mongodb.libmongocrypt.1.8.2.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.identity.stores\\8.0.5\\microsoft.extensions.identity.stores.8.0.5.nupkg.sha512",
-    "/root/.nuget/packages/npgsql/8.0.2/npgsql.8.0.2.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.logging\\8.0.0\\microsoft.extensions.logging.8.0.0.nupkg.sha512",
-    "/root/.nuget/packages/npgsql.entityframeworkcore.postgresql/8.0.2/npgsql.entityframeworkcore.postgresql.8.0.2.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.logging.abstractions\\8.0.0\\microsoft.extensions.logging.abstractions.8.0.0.nupkg.sha512",
-    "/root/.nuget/packages/sharpcompress/0.30.1/sharpcompress.0.30.1.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.objectpool\\2.2.0\\microsoft.extensions.objectpool.2.2.0.nupkg.sha512",
-    "/root/.nuget/packages/snappier/1.0.0/snappier.1.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.options\\8.0.2\\microsoft.extensions.options.8.0.2.nupkg.sha512",
-    "/root/.nuget/packages/swashbuckle.aspnetcore/6.5.0/swashbuckle.aspnetcore.6.5.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.options.configurationextensions\\8.0.0\\microsoft.extensions.options.configurationextensions.8.0.0.nupkg.sha512",
-    "/root/.nuget/packages/swashbuckle.aspnetcore.swagger/6.5.0/swashbuckle.aspnetcore.swagger.6.5.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.primitives\\8.0.0\\microsoft.extensions.primitives.8.0.0.nupkg.sha512",
-    "/root/.nuget/packages/swashbuckle.aspnetcore.swaggergen/6.5.0/swashbuckle.aspnetcore.swaggergen.6.5.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.extensions.webencoders\\2.2.0\\microsoft.extensions.webencoders.2.2.0.nupkg.sha512",
-    "/root/.nuget/packages/swashbuckle.aspnetcore.swaggerui/6.5.0/swashbuckle.aspnetcore.swaggerui.6.5.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.identitymodel.abstractions\\7.5.1\\microsoft.identitymodel.abstractions.7.5.1.nupkg.sha512",
-    "/root/.nuget/packages/system.buffers/4.5.1/system.buffers.4.5.1.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.identitymodel.jsonwebtokens\\7.5.1\\microsoft.identitymodel.jsonwebtokens.7.5.1.nupkg.sha512",
-    "/root/.nuget/packages/system.identitymodel.tokens.jwt/7.5.1/system.identitymodel.tokens.jwt.7.5.1.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.identitymodel.logging\\7.5.1\\microsoft.identitymodel.logging.7.5.1.nupkg.sha512",
-    "/root/.nuget/packages/system.memory/4.5.5/system.memory.4.5.5.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.identitymodel.protocols\\7.1.2\\microsoft.identitymodel.protocols.7.1.2.nupkg.sha512",
-    "/root/.nuget/packages/system.runtime.compilerservices.unsafe/5.0.0/system.runtime.compilerservices.unsafe.5.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.identitymodel.protocols.openidconnect\\7.1.2\\microsoft.identitymodel.protocols.openidconnect.7.1.2.nupkg.sha512",
-    "/root/.nuget/packages/system.security.accesscontrol/5.0.0/system.security.accesscontrol.5.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.identitymodel.tokens\\7.5.1\\microsoft.identitymodel.tokens.7.5.1.nupkg.sha512",
-    "/root/.nuget/packages/system.security.principal.windows/5.0.0/system.security.principal.windows.5.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.net.http.headers\\2.2.0\\microsoft.net.http.headers.2.2.0.nupkg.sha512",
-    "/root/.nuget/packages/system.text.encodings.web/8.0.0/system.text.encodings.web.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.netcore.platforms\\5.0.0\\microsoft.netcore.platforms.5.0.0.nupkg.sha512",
-    "/root/.nuget/packages/system.text.json/8.0.0/system.text.json.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.openapi\\1.2.3\\microsoft.openapi.1.2.3.nupkg.sha512",
-    "/root/.nuget/packages/zstdsharp.port/0.7.3/zstdsharp.port.0.7.3.nupkg.sha512"
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\microsoft.win32.registry\\5.0.0\\microsoft.win32.registry.5.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\mongodb.bson\\2.25.0\\mongodb.bson.2.25.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\mongodb.driver\\2.25.0\\mongodb.driver.2.25.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\mongodb.driver.core\\2.25.0\\mongodb.driver.core.2.25.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\mongodb.libmongocrypt\\1.8.2\\mongodb.libmongocrypt.1.8.2.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\newtonsoft.json\\13.0.3\\newtonsoft.json.13.0.3.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\npgsql\\8.0.3\\npgsql.8.0.3.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\npgsql.entityframeworkcore.postgresql\\8.0.4\\npgsql.entityframeworkcore.postgresql.8.0.4.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\sharpcompress\\0.30.1\\sharpcompress.0.30.1.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\snappier\\1.0.0\\snappier.1.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\swashbuckle.aspnetcore\\6.5.0\\swashbuckle.aspnetcore.6.5.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\swashbuckle.aspnetcore.swagger\\6.5.0\\swashbuckle.aspnetcore.swagger.6.5.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\swashbuckle.aspnetcore.swaggergen\\6.5.0\\swashbuckle.aspnetcore.swaggergen.6.5.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\swashbuckle.aspnetcore.swaggerui\\6.5.0\\swashbuckle.aspnetcore.swaggerui.6.5.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\system.buffers\\4.5.1\\system.buffers.4.5.1.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\system.identitymodel.tokens.jwt\\7.5.1\\system.identitymodel.tokens.jwt.7.5.1.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\system.io.pipelines\\6.0.0-preview.4.21253.7\\system.io.pipelines.6.0.0-preview.4.21253.7.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\system.memory\\4.5.5\\system.memory.4.5.5.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\system.runtime.compilerservices.unsafe\\5.0.0\\system.runtime.compilerservices.unsafe.5.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\system.security.accesscontrol\\5.0.0\\system.security.accesscontrol.5.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\system.security.cryptography.cng\\4.5.0\\system.security.cryptography.cng.4.5.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\system.security.cryptography.pkcs\\4.5.0\\system.security.cryptography.pkcs.4.5.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\system.security.cryptography.xml\\4.5.0\\system.security.cryptography.xml.4.5.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\system.security.permissions\\4.5.0\\system.security.permissions.4.5.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\system.security.principal.windows\\5.0.0\\system.security.principal.windows.5.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\system.text.encodings.web\\8.0.0\\system.text.encodings.web.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\system.text.json\\8.0.0\\system.text.json.8.0.0.nupkg.sha512",
+    "C:\\Users\\Andrei Cerbu\\.nuget\\packages\\zstdsharp.port\\0.7.3\\zstdsharp.port.0.7.3.nupkg.sha512"
   ],
   "logs": []
 }

backend/API/obj/project.packagespec.json

@@ -1 +1 @@
-"restore":{"projectUniqueName":"/home/azureuser/CC-FinalProj/backend/API/API.csproj","projectName":"API","projectPath":"/home/azureuser/CC-FinalProj/backend/API/API.csproj","outputPath":"/home/azureuser/CC-FinalProj/backend/API/obj/","projectStyle":"PackageReference","originalTargetFrameworks":["net8.0"],"sources":{"https://api.nuget.org/v3/index.json":{}},"frameworks":{"net8.0":{"targetAlias":"net8.0","projectReferences":{"/home/azureuser/CC-FinalProj/backend/Application/Application.csproj":{"projectPath":"/home/azureuser/CC-FinalProj/backend/Application/Application.csproj"},"/home/azureuser/CC-FinalProj/backend/Infrastructure/Infrastructure.csproj":{"projectPath":"/home/azureuser/CC-FinalProj/backend/Infrastructure/Infrastructure.csproj"}}}},"warningProperties":{"warnAsError":["NU1605"]}}"frameworks":{"net8.0":{"targetAlias":"net8.0","dependencies":{"Microsoft.AspNetCore.Authentication.JwtBearer":{"target":"Package","version":"[8.0.3, )"},"Swashbuckle.AspNetCore":{"target":"Package","version":"[6.5.0, )"}},"imports":["net461","net462","net47","net471","net472","net48","net481"],"assetTargetFallback":true,"warn":true,"frameworkReferences":{"Microsoft.AspNetCore.App":{"privateAssets":"none"},"Microsoft.NETCore.App":{"privateAssets":"all"}},"runtimeIdentifierGraphPath":"/usr/share/dotnet/sdk/8.0.204/PortableRuntimeIdentifierGraph.json"}}
+"restore":{"projectUniqueName":"C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\API\\API.csproj","projectName":"API","projectPath":"C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\API\\API.csproj","outputPath":"C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\API\\obj\\","projectStyle":"PackageReference","originalTargetFrameworks":["net8.0"],"sources":{"https://api.nuget.org/v3/index.json":{}},"frameworks":{"net8.0":{"targetAlias":"net8.0","projectReferences":{"C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Application\\Application.csproj":{"projectPath":"C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Application\\Application.csproj"},"C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Infrastructure\\Infrastructure.csproj":{"projectPath":"C:\\Users\\Andrei Cerbu\\Desktop\\HealthcareMAnagerToImprove\\backend\\Infrastructure\\Infrastructure.csproj"}}}},"warningProperties":{"warnAsError":["NU1605"]}}"frameworks":{"net8.0":{"targetAlias":"net8.0","dependencies":{"Microsoft.AspNetCore.Authentication.JwtBearer":{"target":"Package","version":"[8.0.3, )"},"MongoDB.Driver":{"target":"Package","version":"[2.25.0, )"},"Newtonsoft.Json":{"target":"Package","version":"[13.0.3, )"},"Swashbuckle.AspNetCore":{"target":"Package","version":"[6.5.0, )"}},"imports":["net461","net462","net47","net471","net472","net48","net481"],"assetTargetFallback":true,"warn":true,"frameworkReferences":{"Microsoft.AspNetCore.App":{"privateAssets":"none"},"Microsoft.NETCore.App":{"privateAssets":"all"}},"runtimeIdentifierGraphPath":"C:\\Program Files\\dotnet\\sdk\\8.0.204/PortableRuntimeIdentifierGraph.json"}}

backend/API/obj/rider.project.model.nuget.info

@@ -1 +1 @@
-17146535760032822
+17161675838414673

backend/API/obj/rider.project.restore.info

@@ -1 +1 @@
-17146529143845776
+17161675838414673

backend/Application/Application.csproj

@@ -9,10 +9,15 @@
     <ItemGroup>
         <PackageReference Include="FluentValidation" Version="11.9.0"/>
         <PackageReference Include="MongoDB.Driver" Version="2.24.0"/>
+        <PackageReference Include="Newtonsoft.Json" Version="13.0.3"/>
     </ItemGroup>
 
     <ItemGroup>
-        <ProjectReference Include="..\Core\Core.csproj"/>
+        <ProjectReference Include="..\Domain\Domain.csproj"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <Folder Include="Endpoints\Authorization\UserResetPassword\"/>
     </ItemGroup>
 
 </Project>

backend/Application/Endpoints/Appointments/AppointmentInformation.cs

@@ -0,0 +1,8 @@
+namespace Application.Endpoints.Appointments;
+
+public class AppointmentInformation
+{
+    public Guid DoctorId { get; set; }
+    public Guid PatientId { get; set; }
+    public DateTime Appointment { get; set; }
+}

backend/Application/Endpoints/Appointments/AppointmentManagementDto.cs

@@ -1,8 +0,0 @@
-namespace Application.Endpoints.Appointments;
-
-public class AppointmentManagementDto
-{
-    public Guid DoctorId { get; set; }
-    public Guid PatientId { get; set; }
-    public DateTime Appointment { get; set; }
-}

backend/Application/Endpoints/Appointments/AppointmentManagementHandler.cs

@@ -1,165 +0,0 @@
-using Application.Services.Database.MongoDB;
-using Application.Services.Database.PostgreSQL;
-using Core.Entities;
-
-namespace Application.Endpoints.Appointments;
-
-public class AppointmentManagementHandler
-{
-    private readonly IAppointmentsMongoDbService _appointmentsMongoDbService;
-    private readonly IDoctorRepository _doctorRepository;
-    private readonly IPatientRepository _patientRepository;
-
-    public AppointmentManagementHandler(IAppointmentsMongoDbService appointmentsMongoDbService,
-        IPatientRepository patientRepository, IDoctorRepository doctorRepository)
-    {
-        _appointmentsMongoDbService = appointmentsMongoDbService;
-        _patientRepository = patientRepository;
-        _doctorRepository = doctorRepository;
-    }
-
-    public async Task<BaseResponse> HandleCreateAppointment(AppointmentManagementDto dto)
-    {
-        var validation = new CreateAppointmentValidator(_appointmentsMongoDbService,
-            _doctorRepository, _patientRepository);
-        var validationResult = await validation.ValidateAsync(dto);
-
-        if (!validationResult.IsValid)
-        {
-            var firstError = validationResult.Errors.FirstOrDefault();
-            var errorCode = int.TryParse(firstError.ErrorCode, out var code) ? code : -1;
-            var errorMessage = firstError.ErrorMessage;
-
-            return new BaseResponse
-            {
-                StatusCode = errorCode,
-                Message = errorMessage,
-                Data = null
-            };
-        }
-
-        var appointmentId = IdentifierGenerator.GenerateId(dto.DoctorId, dto.PatientId);
-        var criteria = new List<(string FieldName, string Value)>
-        {
-            ("_id", appointmentId)
-        };
-        var appointments = await _appointmentsMongoDbService.FindAsync<Appointment>(criteria);
-
-        if (!appointments.Any())
-        {
-            var appointment = new Appointment();
-            appointment.SetId(appointmentId);
-            appointment.SetDoctorIid(dto.DoctorId.ToString());
-            appointment.SetPatientId(dto.PatientId.ToString());
-            appointment.AddAppointment(dto.Appointment);
-
-            await _appointmentsMongoDbService.AddAsync(appointment);
-        }
-        else
-        {
-            var appointment = appointments[0];
-            appointment.AddAppointment(dto.Appointment);
-            await _appointmentsMongoDbService.ModifyAsync("_id", appointmentId, appointment);
-        }
-
-        return new BaseResponse
-        {
-            StatusCode = HttpStatusCodes.Created,
-            Message = "Appointment successfully created.",
-            Data = null
-        };
-    }
-
-    public async Task<BaseResponse> HandleDeleteAppointment(AppointmentManagementDto dto)
-    {
-        var validation = new DeleteAppointmentValidator(_appointmentsMongoDbService,
-            _doctorRepository, _patientRepository);
-        var validationResult = await validation.ValidateAsync(dto);
-
-        if (!validationResult.IsValid)
-        {
-            var firstError = validationResult.Errors.FirstOrDefault();
-            var errorCode = int.TryParse(firstError.ErrorCode, out var code) ? code : -1;
-            var errorMessage = firstError.ErrorMessage;
-
-            return new BaseResponse
-            {
-                StatusCode = errorCode,
-                Message = errorMessage,
-                Data = null
-            };
-        }
-
-        var appointmentId = IdentifierGenerator.GenerateId(dto.DoctorId, dto.PatientId);
-        var criteria = new List<(string FieldName, string Value)>
-        {
-            ("_id", appointmentId)
-        };
-        var appointments = await _appointmentsMongoDbService.FindAsync<Appointment>(criteria);
-
-        if (!appointments.Any())
-            return new BaseResponse
-            {
-                StatusCode = HttpStatusCodes.NotFound,
-                Message = "Appointment not found in system.",
-                Data = null
-            };
-
-        var appointment = appointments[0];
-        appointment.RemoveAppointment(dto.Appointment);
-        await _appointmentsMongoDbService.ModifyAsync("_id", appointmentId, appointment);
-
-        return new BaseResponse
-        {
-            StatusCode = HttpStatusCodes.OK,
-            Message = "Appointment successfully removed.",
-            Data = null
-        };
-    }
-    
-    public async Task<BaseResponse> HandleGetAppointmentsByPatientId(Guid patientId)
-    {
-        var criteria = new List<(string FieldName, string Value)>
-        {
-            ("PatientId", patientId.ToString())
-        };
-        var appointments = await _appointmentsMongoDbService.FindAsync<Appointment>(criteria);
-        
-        if (appointments.Count == 0)
-            return new BaseResponse
-            {
-                StatusCode = HttpStatusCodes.NotFound,
-                Message = $"Appointments not found in system for patient with id {patientId}.",
-                Data = null
-            };
-        return new BaseResponse
-        {
-            StatusCode = HttpStatusCodes.OK,
-            Message = $"Appointments for patient with id {patientId} successfully retrieved.",
-            Data = appointments
-        };
-    }
-    
-    public async Task<BaseResponse> HandleGetAppointmentsByDoctorId(Guid doctorId)
-    {
-        var criteria = new List<(string FieldName, string Value)>
-        {
-            ("DoctorId", doctorId.ToString())
-        };
-        var appointments = await _appointmentsMongoDbService.FindAsync<Appointment>(criteria);
-
-        if (appointments.Count == 0)
-            return new BaseResponse
-            {
-                StatusCode = HttpStatusCodes.NotFound,
-                Message = $"Appointments not found in system for doctor with id {doctorId}.",
-                Data = null
-            };
-        return new BaseResponse
-        {
-            StatusCode = HttpStatusCodes.OK,
-            Message = $"Appointments for doctor with id {doctorId} successfully retrieved.",
-            Data = appointments
-        };
-    }
-}

backend/Application/Endpoints/Appointments/CreateAppointment/CreateAppointmentHandler.cs

@@ -0,0 +1,63 @@
+using Application.Services.Database.MongoDB;
+using Application.Services.Database.PostgreSQL;
+using Domain.Entities;
+
+namespace Application.Endpoints.Appointments.CreateAppointment;
+
+public class CreateAppointmentHandler(
+    IAppointmentsMongoDbService appointmentsMongoDbService,
+    IPatientRepository patientRepository,
+    IDoctorRepository doctorRepository)
+{
+    public async Task<BaseResponse> Handle(AppointmentInformation request, CancellationToken token)
+    {
+        var validation = new CreateAppointmentValidator(appointmentsMongoDbService,
+            doctorRepository, patientRepository);
+        var validationResult = await validation.ValidateAsync(request, token);
+
+        if (!validationResult.IsValid)
+        {
+            var firstError = validationResult.Errors.FirstOrDefault();
+            var errorCode = int.TryParse(firstError.ErrorCode, out var code) ? code : -1;
+            var errorMessage = firstError.ErrorMessage;
+
+            return new BaseResponse
+            {
+                StatusCode = errorCode,
+                Message = errorMessage,
+                Data = null
+            };
+        }
+
+        var appointmentId = IdentifierGenerator.GenerateId(request.DoctorId, request.PatientId);
+        var criteria = new List<(string FieldName, string Value)>
+        {
+            ("_id", appointmentId)
+        };
+        var appointments = await appointmentsMongoDbService.FindAsync<Appointment>(criteria, token);
+
+        if (appointments.Count == 0)
+        {
+            var appointment = new Appointment();
+            appointment.SetId(appointmentId);
+            appointment.SetDoctorIid(request.DoctorId.ToString());
+            appointment.SetPatientId(request.PatientId.ToString());
+            appointment.AddAppointment(request.Appointment);
+
+            await appointmentsMongoDbService.AddAsync(appointment, token);
+        }
+        else
+        {
+            var appointment = appointments[0];
+            appointment.AddAppointment(request.Appointment);
+            await appointmentsMongoDbService.ModifyAsync("_id", appointmentId, appointment, token);
+        }
+
+        return new BaseResponse
+        {
+            StatusCode = HttpStatusCodes.Created,
+            Message = "Appointment successfully created.",
+            Data = null
+        };
+    }
+}

backend/Application/Endpoints/Appointments/CreateAppointment/CreateAppointmentValidator.cs

@@ -2,9 +2,9 @@
 using Application.Services.Database.PostgreSQL;
 using FluentValidation;
 
-namespace Application.Endpoints.Appointments;
+namespace Application.Endpoints.Appointments.CreateAppointment;
 
-public class CreateAppointmentValidator : AbstractValidator<AppointmentManagementDto>
+public class CreateAppointmentValidator : AbstractValidator<AppointmentInformation>
 {
     private readonly IAppointmentsMongoDbService _appointmentsMongoDbService;
     private readonly IDoctorRepository _doctorRepository;
@@ -28,7 +28,8 @@ public class CreateAppointmentValidator : AbstractValidator<AppointmentManagemen
             .WithErrorCode(HttpStatusCodes.BadRequest.ToString());
 
         RuleFor(x => x)
-            .MustAsync(IsAppointmentUnique).WithMessage("Appointment already in system.")
+            .MustAsync(IsAppointmentUnique)
+            .WithMessage("Appointment already in system.")
             .WithErrorCode(HttpStatusCodes.Conflict.ToString());
 
         _appointmentsMongoDbService = appointmentsMongoDbService;
@@ -36,15 +37,15 @@ public class CreateAppointmentValidator : AbstractValidator<AppointmentManagemen
         _patientRepository = patientRepository;
     }
 
-    private async Task<bool> IsDoctorRegistered(Guid id, CancellationToken cancellationToken)
+    private async Task<bool> IsDoctorRegistered(Guid id, CancellationToken token)
     {
-        var doctor = await _doctorRepository.GetByIdAsync(id);
+        var doctor = await _doctorRepository.GetByIdAsync(id, token);
         return doctor != null;
     }
 
-    private async Task<bool> IsPatientRegistered(Guid id, CancellationToken cancellationToken)
+    private async Task<bool> IsPatientRegistered(Guid id, CancellationToken token)
     {
-        var patient = await _patientRepository.GetByIdAsync(id);
+        var patient = await _patientRepository.GetByIdAsync(id, token);
         return patient != null;
     }
 
@@ -59,8 +60,8 @@ public class CreateAppointmentValidator : AbstractValidator<AppointmentManagemen
         return true;
     }
 
-    private async Task<bool> IsAppointmentUnique(AppointmentManagementDto dto, CancellationToken cancellationToken)
+    private async Task<bool> IsAppointmentUnique(AppointmentInformation request, CancellationToken token)
     {
-        return await _appointmentsMongoDbService.IsAppointmentUnique(dto);
+        return await _appointmentsMongoDbService.IsAppointmentUnique(request, token);
     }
 }

backend/Application/Endpoints/Appointments/DeleteAppointment/DeleteAppointmentHandler.cs

@@ -0,0 +1,58 @@
+using Application.Services.Database.MongoDB;
+using Application.Services.Database.PostgreSQL;
+using Domain.Entities;
+
+namespace Application.Endpoints.Appointments.DeleteAppointment;
+
+public class DeleteAppointmentHandler(
+    IAppointmentsMongoDbService appointmentsMongoDbService,
+    IPatientRepository patientRepository,
+    IDoctorRepository doctorRepository)
+{
+    public async Task<BaseResponse> Handle(AppointmentInformation request, CancellationToken token)
+    {
+        var validation = new DeleteAppointmentValidator(appointmentsMongoDbService,
+            doctorRepository, patientRepository);
+        var validationResult = await validation.ValidateAsync(request, token);
+
+        if (!validationResult.IsValid)
+        {
+            var firstError = validationResult.Errors.FirstOrDefault();
+            var errorCode = int.TryParse(firstError.ErrorCode, out var code) ? code : -1;
+            var errorMessage = firstError.ErrorMessage;
+
+            return new BaseResponse
+            {
+                StatusCode = errorCode,
+                Message = errorMessage,
+                Data = null
+            };
+        }
+
+        var appointmentId = IdentifierGenerator.GenerateId(request.DoctorId, request.PatientId);
+        var criteria = new List<(string FieldName, string Value)>
+        {
+            ("_id", appointmentId)
+        };
+        var appointments = await appointmentsMongoDbService.FindAsync<Appointment>(criteria, token);
+
+        if (!appointments.Any())
+            return new BaseResponse
+            {
+                StatusCode = HttpStatusCodes.NotFound,
+                Message = "Appointment not found in system.",
+                Data = null
+            };
+
+        var appointment = appointments[0];
+        appointment.RemoveAppointment(request.Appointment);
+        await appointmentsMongoDbService.ModifyAsync("_id", appointmentId, appointment, token);
+
+        return new BaseResponse
+        {
+            StatusCode = HttpStatusCodes.OK,
+            Message = "Appointment successfully removed.",
+            Data = null
+        };
+    }
+}

backend/Application/Endpoints/Appointments/DeleteAppointment/DeleteAppointmentValidator.cs

@@ -1,10 +1,11 @@
 using Application.Services.Database.MongoDB;
 using Application.Services.Database.PostgreSQL;
+using Domain.Entities;
 using FluentValidation;
 
-namespace Application.Endpoints.Appointments;
+namespace Application.Endpoints.Appointments.DeleteAppointment;
 
-public class DeleteAppointmentValidator : AbstractValidator<AppointmentManagementDto>
+public class DeleteAppointmentValidator : AbstractValidator<AppointmentInformation>
 {
     private readonly IAppointmentsMongoDbService _appointmentsMongoDbService;
     private readonly IDoctorRepository _doctorRepository;
@@ -36,15 +37,15 @@ public class DeleteAppointmentValidator : AbstractValidator<AppointmentManagemen
         _patientRepository = patientRepository;
     }
 
-    private async Task<bool> IsDoctorRegistered(Guid id, CancellationToken cancellationToken)
+    private async Task<bool> IsDoctorRegistered(Guid id, CancellationToken token)
     {
-        var doctor = await _doctorRepository.GetByIdAsync(id);
+        var doctor = await _doctorRepository.GetByIdAsync(id, token);
         return doctor != null;
     }
 
-    private async Task<bool> IsPatientRegistered(Guid id, CancellationToken cancellationToken)
+    private async Task<bool> IsPatientRegistered(Guid id, CancellationToken token)
     {
-        var patient = await _patientRepository.GetByIdAsync(id);
+        var patient = await _patientRepository.GetByIdAsync(id, token);
         return patient != null;
     }
 
@@ -59,8 +60,8 @@ public class DeleteAppointmentValidator : AbstractValidator<AppointmentManagemen
         return true;
     }
 
-    private async Task<bool> DoesAppointmentExists(AppointmentManagementDto dto, CancellationToken cancellationToken)
+    private async Task<bool> DoesAppointmentExists(AppointmentInformation request, CancellationToken token)
     {
-        return await _appointmentsMongoDbService.DoesAppointmentExists(dto);
+        return await _appointmentsMongoDbService.DoesAppointmentExists(request, token);
     }
 }

backend/Application/Endpoints/Appointments/QuerriesAppointments/QuerriesAppointmentHandler.cs

@@ -0,0 +1,54 @@
+using Application.Services.Database.MongoDB;
+using Application.Services.Database.PostgreSQL;
+using Domain.Entities;
+
+namespace Application.Endpoints.Appointments.QuerriesAppointments;
+
+public class QuerriesAppointmentHandler(IAppointmentsMongoDbService appointmentsMongoDbService)
+{
+    public async Task<BaseResponse> GetByPatientId(Guid patientId, CancellationToken token)
+    {
+        var criteria = new List<(string FieldName, string Value)>
+        {
+            ("PatientId", patientId.ToString())
+        };
+        var appointments = await appointmentsMongoDbService.FindAsync<Appointment>(criteria, token);
+
+        if (appointments.Count == 0)
+            return new BaseResponse
+            {
+                StatusCode = HttpStatusCodes.NotFound,
+                Message = $"Appointments not found in system.",
+                Data = null
+            };
+        return new BaseResponse
+        {
+            StatusCode = HttpStatusCodes.OK,
+            Message = $"Appointments successfully retrieved.",
+            Data = appointments
+        };
+    }
+
+    public async Task<BaseResponse> GetsByDoctorId(Guid doctorId, CancellationToken token)
+    {
+        var criteria = new List<(string FieldName, string Value)>
+        {
+            ("DoctorId", doctorId.ToString())
+        };
+        var appointments = await appointmentsMongoDbService.FindAsync<Appointment>(criteria, token);
+
+        if (appointments.Count == 0)
+            return new BaseResponse
+            {
+                StatusCode = HttpStatusCodes.NotFound,
+                Message = $"Appointments not found in system.",
+                Data = null
+            };
+        return new BaseResponse
+        {
+            StatusCode = HttpStatusCodes.OK,
+            Message = $"Appointments successfully retrieved.",
+            Data = appointments
+        };
+    }
+}

backend/Application/Endpoints/Authorization/Doctor/DoctorLoginHandler.cs

@@ -1,45 +0,0 @@
-using Application.Services.Database.PostgreSQL;
-using Application.Services.HashingAlgorithms;
-
-namespace Application.Endpoints.Authorization.Doctor;
-
-public class DoctorLoginHandler
-{
-    private readonly IDoctorRepository _database;
-    private readonly IHashingAlgorithms _hashingAlgorithms;
-
-    public DoctorLoginHandler(IDoctorRepository database, IHashingAlgorithms hashingAlgorithms)
-    {
-        _database = database;
-        _hashingAlgorithms = hashingAlgorithms;
-    }
-
-    public async Task<BaseResponse> Handle(LoginDto loginDTO)
-    {
-        loginDTO.Password = _hashingAlgorithms.SHA256Algorithm(loginDTO.Password);
-
-        var validation = new DoctorLoginValidation(_database);
-        var validationResult = await validation.ValidateAsync(loginDTO);
-
-        if (validationResult.IsValid)
-        {
-            var doctor = await _database.FindByEmailAsync(loginDTO.Email);
-            return new BaseResponse
-            {
-                StatusCode = HttpStatusCodes.OK,
-                Message = "Authentication successful",
-                Data = doctor
-            };
-        }
-
-        var firstError = validationResult.Errors.FirstOrDefault();
-        var errorCode = int.TryParse(firstError.ErrorCode, out var code) ? code : -1;
-        var errorMessage = firstError.ErrorMessage;
-        return new BaseResponse
-        {
-            StatusCode = errorCode,
-            Message = errorMessage,
-            Data = null
-        };
-    }
-}

backend/Application/Endpoints/Authorization/Doctor/DoctorLoginValidation.cs

@@ -1,33 +0,0 @@
-using Application.Services.Database.PostgreSQL;
-using FluentValidation;
-
-namespace Application.Endpoints.Authorization.Doctor;
-
-public class DoctorLoginValidation : AbstractValidator<LoginDto>
-{
-    private readonly IDoctorRepository _doctorRepository;
-
-    public DoctorLoginValidation(IDoctorRepository doctorRepository)
-    {
-        _doctorRepository = doctorRepository;
-
-        RuleFor(x => x.Email)
-            .NotEmpty().WithMessage("Email is required.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
-            .EmailAddress().WithMessage("Invalid email format.").WithErrorCode(HttpStatusCodes.BadRequest.ToString());
-
-        RuleFor(x => x.Password)
-            .NotEmpty().WithMessage("Password is required.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
-            .MinimumLength(8).WithMessage("Password must be at least 8 characters long.")
-            .WithErrorCode(HttpStatusCodes.BadRequest.ToString());
-
-        RuleFor(x => x)
-            .MustAsync(CredentialsMatch).WithMessage("Invalid credentials")
-            .WithErrorCode(HttpStatusCodes.Unauthorized.ToString());
-    }
-
-    private async Task<bool> CredentialsMatch(LoginDto dto, CancellationToken cancellationToken)
-    {
-        var code = await _doctorRepository.CredentialsMatch(dto.Email, dto.Password);
-        return code;
-    }
-}

backend/Application/Endpoints/Authorization/Doctor/DoctorResetPasswordHandler.cs

@@ -1,49 +0,0 @@
-using Application.Services.Database.PostgreSQL;
-using Application.Services.HashingAlgorithms;
-
-namespace Application.Endpoints.Authorization.Doctor;
-
-public class DoctorResetPasswordHandler
-{
-    private readonly IDoctorRepository _doctorRepository;
-    private readonly IHashingAlgorithms _hashingAlgorithms;
-
-    public DoctorResetPasswordHandler(IDoctorRepository doctorRepository, IHashingAlgorithms hashingAlgorithms)
-    {
-        _doctorRepository = doctorRepository;
-        _hashingAlgorithms = hashingAlgorithms;
-    }
-
-    public async Task<BaseResponse> Handle(LoginDto resetDoctorDto)
-    {
-        var validation = new DoctorResetPasswordValidation(_doctorRepository, _hashingAlgorithms);
-        var validationResult = await validation.ValidateAsync(resetDoctorDto);
-
-        if (!validationResult.IsValid)
-        {
-            var firstError = validationResult.Errors.FirstOrDefault();
-            var errorCode = int.TryParse(firstError.ErrorCode, out var code) ? code : -1;
-            var errorMessage = firstError.ErrorMessage;
-
-            return new BaseResponse
-            {
-                StatusCode = errorCode,
-                Message = errorMessage,
-                Data = null
-            };
-        }
-
-        var currentDoctor = await _doctorRepository.FindByEmailAsync(resetDoctorDto.Email);
-        var updatedDoctor = currentDoctor;
-        updatedDoctor.SetPassword(_hashingAlgorithms.SHA256Algorithm(resetDoctorDto.Password));
-
-        await _doctorRepository.UpdateAsync(updatedDoctor);
-
-        return new BaseResponse
-        {
-            StatusCode = HttpStatusCodes.OK,
-            Message = "Password successfully changed!",
-            Data = null
-        };
-    }
-}

backend/Application/Endpoints/Authorization/Doctor/DoctorResetPasswordValidation.cs

@@ -1,45 +0,0 @@
-using System.Net;
-using Application.Services.Database.PostgreSQL;
-using Application.Services.HashingAlgorithms;
-using FluentValidation;
-
-namespace Application.Endpoints.Authorization.Doctor;
-
-public class DoctorResetPasswordValidation : AbstractValidator<LoginDto>
-{
-    private readonly IDoctorRepository _doctorRepository;
-    private readonly IHashingAlgorithms _hashingAlgorithms;
-
-    public DoctorResetPasswordValidation(IDoctorRepository doctorRepository, IHashingAlgorithms hashingAlgorithms)
-    {
-        _doctorRepository = doctorRepository;
-        _hashingAlgorithms = hashingAlgorithms;
-
-        RuleFor(x => x.Email)
-            .NotEmpty().WithMessage("Email is required.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
-            .EmailAddress().WithMessage("Invalid email format.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
-            .MustAsync(BeExistingDoctor).WithMessage("Patient with this email does not exist.")
-            .WithErrorCode(HttpStatusCodes.NotFound.ToString());
-
-        RuleFor(x => x.Password)
-            .NotEmpty().WithMessage("Password is required.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
-            .WithErrorCode(HttpStatusCode.BadRequest.ToString());
-
-        RuleFor(x => x)
-            .MustAsync(BeDifferentFromOldPassword).WithMessage("Password can't be as the previous.")
-            .WithErrorCode(HttpStatusCode.BadRequest.ToString()).WithErrorCode(HttpStatusCodes.BadRequest.ToString());
-    }
-
-    private async Task<bool> BeExistingDoctor(string email, CancellationToken cancellationToken)
-    {
-        var doctor = await _doctorRepository.FindByEmailAsync(email);
-        return doctor != null;
-    }
-
-    private async Task<bool> BeDifferentFromOldPassword(LoginDto dto, CancellationToken cancellationToken)
-    {
-        var currentPatient = await _doctorRepository.FindByEmailAsync(dto.Email);
-        return !_hashingAlgorithms.SHA256Algorithm(dto.Password)
-            .Equals(currentPatient?.Password, StringComparison.Ordinal);
-    }
-}

backend/Application/Endpoints/Authorization/LoginDto.cs

@@ -1,7 +0,0 @@
-namespace Application.Endpoints.Authorization;
-
-public class LoginDto
-{
-    public string Email;
-    public string Password;
-}

backend/Application/Endpoints/Authorization/Patient/PatientLoginHandler.cs

@@ -1,43 +0,0 @@
-using Application.Services.Database.PostgreSQL;
-using Application.Services.HashingAlgorithms;
-
-namespace Application.Endpoints.Authorization.Patient;
-
-public class PatientLoginHandler
-{
-    private readonly IPatientRepository _patientRepository;
-    private readonly IHashingAlgorithms _hashingAlgorithms;
-
-    public PatientLoginHandler(IPatientRepository patientRepository, IHashingAlgorithms hashingAlgorithms)
-    {
-        _patientRepository = patientRepository;
-        _hashingAlgorithms = hashingAlgorithms;
-    }
-
-    public async Task<BaseResponse> Handle(LoginDto loginDTO)
-    {
-        var validation = new PatientLoginValidation(_patientRepository, _hashingAlgorithms);
-        var validationResult = await validation.ValidateAsync(loginDTO);
-
-        if (validationResult.IsValid)
-        {
-            var patient = await _patientRepository.FindByEmailAsync(loginDTO.Email);
-            return new BaseResponse
-            {
-                StatusCode = HttpStatusCodes.OK,
-                Message = "Authentication successful",
-                Data = patient
-            };
-        }
-
-        var firstError = validationResult.Errors.FirstOrDefault();
-        var errorCode = int.TryParse(firstError.ErrorCode, out var code) ? code : -1;
-        var errorMessage = firstError.ErrorMessage;
-        return new BaseResponse
-        {
-            StatusCode = errorCode,
-            Message = errorMessage,
-            Data = null
-        };
-    }
-}

backend/Application/Endpoints/Authorization/Patient/PatientLoginValidation.cs

@@ -1,37 +0,0 @@
-using Application.Services.Database.PostgreSQL;
-using Application.Services.HashingAlgorithms;
-using FluentValidation;
-
-namespace Application.Endpoints.Authorization.Patient;
-
-public class PatientLoginValidation : AbstractValidator<LoginDto>
-{
-    private readonly IPatientRepository _patientRepository;
-    private readonly IHashingAlgorithms _hashingAlgorithms;
-
-    public PatientLoginValidation(IPatientRepository patientRepository, IHashingAlgorithms hashingAlgorithms)
-    {
-        _patientRepository = patientRepository;
-        _hashingAlgorithms = hashingAlgorithms;
-
-        RuleFor(x => x.Email)
-            .NotEmpty().WithMessage("Email is required.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
-            .EmailAddress().WithMessage("Invalid email format.").WithErrorCode(HttpStatusCodes.BadRequest.ToString());
-
-        RuleFor(x => x.Password)
-            .NotEmpty().WithMessage("Password is required.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
-            .MinimumLength(8).WithMessage("Password must be at least 8 characters long.")
-            .WithErrorCode(HttpStatusCodes.BadRequest.ToString());
-        
-        RuleFor(x => x)
-            .MustAsync(CredentialsMatch).WithMessage("Invalid credentials")
-            .WithErrorCode(HttpStatusCodes.Unauthorized.ToString());
-    }
-    
-    private async Task<bool> CredentialsMatch(LoginDto dto, CancellationToken cancellationToken)
-    {
-        var code = await _patientRepository.CredentialsMatch(
-            dto.Email, _hashingAlgorithms.SHA256Algorithm(dto.Password));
-        return code;
-    }
-}

backend/Application/Endpoints/Authorization/Patient/PatientResetPasswordHandler.cs

@@ -1,49 +0,0 @@
-using Application.Services.Database.PostgreSQL;
-using Application.Services.HashingAlgorithms;
-
-namespace Application.Endpoints.Authorization.Patient;
-
-public class PatientResetPasswordHandler
-{
-    private readonly IHashingAlgorithms _hashingAlgorithms;
-    private readonly IPatientRepository _patientRepository;
-
-    public PatientResetPasswordHandler(IPatientRepository patientRepository, IHashingAlgorithms hashingAlgorithms)
-    {
-        _patientRepository = patientRepository;
-        _hashingAlgorithms = hashingAlgorithms;
-    }
-
-    public async Task<BaseResponse> Handle(LoginDto patientResetPasswordDto)
-    {
-        var validation = new PatientResetPasswordValidation(_patientRepository, _hashingAlgorithms);
-        var validationResult = await validation.ValidateAsync(patientResetPasswordDto);
-
-        if (!validationResult.IsValid)
-        {
-            var firstError = validationResult.Errors.FirstOrDefault();
-            var errorCode = int.TryParse(firstError.ErrorCode, out var code) ? code : -1;
-            var errorMessage = firstError.ErrorMessage;
-
-            return new BaseResponse
-            {
-                StatusCode = errorCode,
-                Message = errorMessage,
-                Data = null
-            };
-        }
-
-        var currentPatient = await _patientRepository.FindByEmailAsync(patientResetPasswordDto.Email);
-        var updatedPatient = currentPatient;
-        updatedPatient.SetPassword(_hashingAlgorithms.SHA256Algorithm(patientResetPasswordDto.Password));
-
-        await _patientRepository.UpdateAsync(updatedPatient);
-
-        return new BaseResponse
-        {
-            StatusCode = HttpStatusCodes.OK,
-            Message = "Password successfully changed!",
-            Data = null
-        };
-    }
-}

backend/Application/Endpoints/Authorization/Patient/PatientResetPasswordValidation.cs

@@ -1,46 +0,0 @@
-using System.Net;
-using Application.Services.Database.PostgreSQL;
-using Application.Services.HashingAlgorithms;
-using FluentValidation;
-
-namespace Application.Endpoints.Authorization.Patient;
-
-public class PatientResetPasswordValidation : AbstractValidator<LoginDto>
-{
-    private readonly IPatientRepository _patientRepository;
-    private readonly IHashingAlgorithms _hashingAlgorithms;
-
-    public PatientResetPasswordValidation(IPatientRepository patientRepository, 
-        IHashingAlgorithms hashingAlgorithms)
-    {
-        _patientRepository = patientRepository;
-        _hashingAlgorithms = hashingAlgorithms;
-
-        RuleFor(x => x.Email)
-            .NotEmpty().WithMessage("Email is required.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
-            .EmailAddress().WithMessage("Invalid email format.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
-            .MustAsync(BeExistingPatient).WithMessage("Patient with this email does not exist.")
-            .WithErrorCode(HttpStatusCodes.NotFound.ToString());
-
-        RuleFor(x => x.Password)
-            .NotEmpty().WithMessage("Password is required.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
-            .WithErrorCode(HttpStatusCode.BadRequest.ToString());
-
-        RuleFor(x => x)
-            .MustAsync(BeDifferentFromOldPassword).WithMessage("Password can't be as the previous.")
-            .WithErrorCode(HttpStatusCode.BadRequest.ToString()).WithErrorCode(HttpStatusCodes.BadRequest.ToString());
-    }
-
-    private async Task<bool> BeExistingPatient(string email, CancellationToken cancellationToken)
-    {
-        var patient = await _patientRepository.FindByEmailAsync(email);
-        return patient != null;
-    }
-
-    private async Task<bool> BeDifferentFromOldPassword(LoginDto dto, CancellationToken cancellationToken)
-    {
-        var currentPatient = await _patientRepository.FindByEmailAsync(dto.Email);
-        return !_hashingAlgorithms.SHA256Algorithm(dto.Password)
-            .Equals(currentPatient?.Password, StringComparison.Ordinal);
-    }
-}

backend/Application/Endpoints/Authorization/RefreshToken/RefreshTokenCommand.cs

@@ -0,0 +1,6 @@
+namespace Application.Endpoints.Authorization.RefreshToken;
+
+public class RefreshJwtCommand
+{
+    public string Token { get; set; } = string.Empty;
+}

backend/Application/Endpoints/Authorization/RefreshToken/RefreshTokenHandler.cs

@@ -0,0 +1,30 @@
+using Application.Services.Jwt;
+
+namespace Application.Endpoints.Authorization.RefreshToken;
+
+public class RefreshJwtHandler(IJwtService jwtService)
+{
+    public async Task<BaseResponse> Handle(RefreshJwtCommand command, CancellationToken cancellationToken)
+    {
+        var validator = new RefreshJwtValidator(jwtService);
+        var validationResult = await validator.ValidateAsync(command, cancellationToken);
+
+        if (!validationResult.IsValid)
+        {
+            var firstError = validationResult.Errors.FirstOrDefault();
+            return new BaseResponse
+            {
+                StatusCode = HttpStatusCodes.Unauthorized,
+                Message = firstError?.ErrorMessage
+            };
+        }
+
+        var newToken = jwtService.RefreshToken(command.Token);
+        return new BaseResponse
+        {
+            StatusCode = HttpStatusCodes.OK,
+            Message = "Token refreshed successfully.",
+            Data = newToken
+        };
+    }
+}

backend/Application/Endpoints/Authorization/RefreshToken/RefreshTokenValidator.cs

@@ -0,0 +1,23 @@
+using Application.Services.Jwt;
+using FluentValidation;
+
+namespace Application.Endpoints.Authorization.RefreshToken;
+
+public class RefreshJwtValidator : AbstractValidator<RefreshJwtCommand>
+{
+    private readonly IJwtService _jwtService;
+
+    public RefreshJwtValidator(IJwtService jwtService)
+    {
+        _jwtService = jwtService;
+
+        RuleFor(x => x.Token)
+            .NotEmpty().WithMessage("Token is required.")
+            .Must(BeAValidToken).WithMessage("Token is invalid or expired.");
+    }
+
+    private bool BeAValidToken(string token)
+    {
+        return _jwtService.ValidateJwtToken(token);
+    }
+}

backend/Application/Endpoints/Authorization/UserLogin/UserLoginCommand.cs

@@ -0,0 +1,7 @@
+namespace Application.Endpoints.Authorization.UserLogin;
+
+public class UserLoginCommand
+{
+    public string Email { get; set; } = string.Empty;
+    public string Password { get; set; } = string.Empty;
+}

backend/Application/Endpoints/Authorization/UserLogin/UserLoginHandler.cs

@@ -0,0 +1,79 @@
+using Application.Services.Database.PostgreSQL;
+using Application.Services.HashingAlgorithms;
+using Application.Services.Jwt;
+using Domain;
+
+namespace Application.Endpoints.Authorization.UserLogin;
+
+public class UserLoginHandler(
+    IJwtService jwtService,
+    IHashingAlgorithms hashingAlgorithms,
+    IDoctorRepository doctorRepository,
+    IPatientRepository patientRepository,
+    IAdminRepository adminRepository)
+{
+    public async Task<BaseResponse> Handle(UserLoginCommand request, CancellationToken token)
+    {
+        var validator = new UserLoginValidator();
+        var result = await validator.ValidateAsync(request, token);
+        if (!result.IsValid)
+        {
+            var firstError = result.Errors.FirstOrDefault();
+            var errorCode = int.TryParse(firstError.ErrorCode, out var code) ? code : -1;
+            var errorMessage = firstError.ErrorMessage;
+
+            return new BaseResponse
+            {
+                StatusCode = errorCode,
+                Message = errorMessage,
+                Data = null
+            };
+        }
+
+        var email = request.Email;
+        var password = hashingAlgorithms.Sha256Algorithm(request.Password);
+
+        if (await doctorRepository.CredentialsMatch(email, password, token))
+        {
+            var doctor = await doctorRepository.FindByEmailAsync(email, token);
+            var authToken = jwtService.GenerateJwtToken(doctor.Id, UserRoles.Doctor, doctor.Name);
+            return new BaseResponse
+            {
+                StatusCode = HttpStatusCodes.OK,
+                Message = "Doctor logged in successfully.",
+                Data = authToken
+            };
+        }
+
+        if (await patientRepository.CredentialsMatch(email, password, token))
+        {
+            var patient = await patientRepository.FindByEmailAsync(email, token);
+            var authToken = jwtService.GenerateJwtToken(patient.Id, UserRoles.Patient, patient.Name);
+            return new BaseResponse
+            {
+                StatusCode = HttpStatusCodes.OK,
+                Message = "Patient logged in successfully.",
+                Data = authToken
+            };
+        }
+
+        if (await adminRepository.CredentialsMatch(email, password, token))
+        {
+            var admin = await adminRepository.FindByEmailAsync(email, token);
+            var authToken = jwtService.GenerateJwtToken(admin.Id, UserRoles.Admin, admin.Name);
+            return new BaseResponse
+            {
+                StatusCode = HttpStatusCodes.OK,
+                Message = "Admin logged in successfully.",
+                Data = authToken
+            };
+        }
+
+        return new BaseResponse
+        {
+            StatusCode = HttpStatusCodes.NotFound,
+            Message = "User not registered in our system.",
+            Data = null
+        };
+    }
+}

backend/Application/Endpoints/Authorization/UserLogin/UserLoginValidator.cs

@@ -0,0 +1,18 @@
+using FluentValidation;
+
+namespace Application.Endpoints.Authorization.UserLogin;
+
+public class UserLoginValidator : AbstractValidator<UserLoginCommand>
+{
+    public UserLoginValidator()
+    {
+        RuleFor(x => x.Email)
+            .NotEmpty().WithMessage("Email is required.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
+            .EmailAddress().WithMessage("Invalid email format.").WithErrorCode(HttpStatusCodes.BadRequest.ToString());
+
+        RuleFor(x => x.Password)
+            .NotEmpty().WithMessage("Password is required.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
+            .MinimumLength(8).WithMessage("Password must be at least 8 characters long.")
+            .WithErrorCode(HttpStatusCodes.BadRequest.ToString());
+    }
+}

backend/Application/Endpoints/Authorization/UserLoginDto.cs

@@ -1,8 +0,0 @@
-namespace Application.Endpoints.Authorization;
-
-public class UserLoginModel
-{
-    public string? UserType { get; set; }
-    public string Email { get; set; }
-    public string Password { get; set; }
-}

backend/Application/Endpoints/Authorization/UserRegister/UserRegisterCommand.cs

@@ -0,0 +1,9 @@
+namespace Application.Endpoints.Authorization.UserRegister;
+
+public class UserRegisterCommand
+{
+    public string Name { get; set; } = string.Empty;
+    public string Email { get; set; } = string.Empty;
+    public string Password { get; set; } = string.Empty;
+    public string Role { get; set; } = string.Empty;
+}

backend/Application/Endpoints/Authorization/UserRegister/UserRegisterHandler.cs

@@ -0,0 +1,73 @@
+using Application.Services.Database.PostgreSQL;
+using Application.Services.Email;
+using Application.Services.HashingAlgorithms;
+using Domain;
+using Domain.Entities;
+
+namespace Application.Endpoints.Authorization.UserRegister;
+
+public class UserRegisterHandler(
+    IEmailService emailService,
+    IHashingAlgorithms hashingAlgorithms,
+    IDoctorRepository doctorRepository,
+    IPatientRepository patientRepository,
+    IAdminRepository adminRepository)
+{
+    public async Task<BaseResponse> Handle(UserRegisterCommand request, CancellationToken token)
+    {
+        var validator = new UserRegisterValidator(
+            patientRepository, doctorRepository, adminRepository);
+        var result = await validator.ValidateAsync(request, token);
+        if (!result.IsValid)
+        {
+            var firstError = result.Errors.FirstOrDefault();
+            var errorCode = int.TryParse(firstError.ErrorCode, out var code) ? code : -1;
+            var errorMessage = firstError.ErrorMessage;
+
+            return new BaseResponse
+            {
+                StatusCode = errorCode,
+                Message = errorMessage,
+                Data = null
+            };
+        }
+
+        switch (request.Role)
+        {
+            case UserRoles.Admin:
+                var admin = new Admin();
+                admin.SetName(request.Name);
+                admin.SetEmail(request.Email);
+                admin.SetPassword(hashingAlgorithms.Sha256Algorithm(request.Password));
+
+                await adminRepository.AddAsync(admin, token);
+                break;
+            case UserRoles.Doctor:
+                var doctor = new Doctor();
+                doctor.SetName(request.Name);
+                doctor.SetEmail(request.Email);
+                doctor.SetPassword(hashingAlgorithms.Sha256Algorithm(request.Password));
+
+                await doctorRepository.AddAsync(doctor, token);
+                break;
+            case UserRoles.Patient:
+                var patient = new Patient();
+                patient.SetName(request.Name);
+                patient.SetEmail(request.Email);
+                patient.SetPassword(hashingAlgorithms.Sha256Algorithm(request.Password));
+
+                await patientRepository.AddAsync(patient, token);
+                break;
+        }
+
+        var emailBody = emailService.GenerateCredentialsEmailBody(request.Name, request.Email, request.Password);
+        await emailService.SendEmailAsync(request.Email, emailService.GetSuccessfulRegistrationSubject(), emailBody);
+
+        return new BaseResponse
+        {
+            StatusCode = HttpStatusCodes.Created,
+            Message = "User created successfully",
+            Data = null
+        };
+    }
+}

backend/Application/Endpoints/Authorization/UserRegister/UserRegisterValidator.cs

@@ -0,0 +1,57 @@
+using Application.Services.Database.PostgreSQL;
+using Application.Services.HashingAlgorithms;
+using Domain;
+using FluentValidation;
+
+namespace Application.Endpoints.Authorization.UserRegister;
+
+public class UserRegisterValidator : AbstractValidator<UserRegisterCommand>
+{
+    private readonly IAdminRepository _adminRepository;
+    private readonly IDoctorRepository _doctorRepository;
+    private readonly IPatientRepository _patientRepository;
+
+    public UserRegisterValidator(IPatientRepository patientRepository,
+        IDoctorRepository doctorRepository, IAdminRepository adminRepository)
+    {
+        _patientRepository = patientRepository;
+        _doctorRepository = doctorRepository;
+        _adminRepository = adminRepository;
+
+        RuleFor(x => x.Name)
+            .NotEmpty().WithMessage("Name is required.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
+            .MaximumLength(30).WithMessage("Maximum name length of 30 characters")
+            .WithErrorCode(HttpStatusCodes.BadRequest.ToString());
+
+        RuleFor(x => x.Email)
+            .NotEmpty().WithMessage("Email is required.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
+            .EmailAddress().WithMessage("Invalid email format.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
+            .MustAsync(async (email, token) => await AccountNotRegistered(email, token))
+            .WithMessage("Account already registered in system.").WithErrorCode(HttpStatusCodes.BadRequest.ToString());
+
+        RuleFor(x => x.Password)
+            .NotEmpty().WithMessage("Password is required.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
+            .MinimumLength(8).WithMessage("Password must be at least 8 characters long.")
+            .WithErrorCode(HttpStatusCodes.BadRequest.ToString());
+
+        RuleFor(x => x.Role)
+            .NotEmpty().WithMessage("Role is required.").WithErrorCode(HttpStatusCodes.BadRequest.ToString())
+            .Must(BeAValidRole).WithMessage("Invalid role specified.")
+            .WithErrorCode(HttpStatusCodes.BadRequest.ToString());
+    }
+
+    private bool BeAValidRole(string role)
+    {
+        var validRoles = new[] { UserRoles.Admin, UserRoles.Doctor, UserRoles.Patient };
+        return validRoles.Contains(role);
+    }
+
+    private async Task<bool> AccountNotRegistered(string email, CancellationToken token)
+    {
+        var patient = await _patientRepository.FindByEmailAsync(email, token);
+        var doctor = await _doctorRepository.FindByEmailAsync(email, token);
+        var admin = await _adminRepository.FindByEmailAsync(email, token);
+
+        return patient == null && doctor == null && admin == null;
+    }
+}