refactor(appointments/referrals): fill data automatically when request user is specialist

Author: julianosill

infra/database/migrations/1771606365676-add-relations.ts

@@ -0,0 +1,16 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddRelations1771606365676 implements MigrationInterface {
+    name = 'AddRelations1771606365676'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE \`referrals\` ADD \`user_id\` varchar(255) NULL`);
+        await queryRunner.query(`ALTER TABLE \`appointments\` ADD \`user_id\` varchar(255) NULL`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE \`appointments\` DROP COLUMN \`user_id\``);
+        await queryRunner.query(`ALTER TABLE \`referrals\` DROP COLUMN \`user_id\``);
+    }
+
+}

src/app/http/appointments/appointments.module.ts

@@ -3,6 +3,7 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 
 import { Appointment } from '@/domain/entities/appointment';
 import { Patient } from '@/domain/entities/patient';
+import { User } from '@/domain/entities/user';
 
 import { AppointmentsController } from './appointments.controller';
 import { CancelAppointmentUseCase } from './use-cases/cancel-appointment.use-case';
@@ -11,7 +12,7 @@ import { GetAppointmentsUseCase } from './use-cases/get-appointments.use-case';
 import { UpdateAppointmentUseCase } from './use-cases/update-appointment.use-case';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Appointment, Patient])],
+  imports: [TypeOrmModule.forFeature([Appointment, Patient, User])],
   controllers: [AppointmentsController],
   providers: [
     GetAppointmentsUseCase,

src/app/http/appointments/use-cases/create-appointment.use-case.ts

@@ -1,16 +1,17 @@
-import { BadRequestException, Injectable, Logger } from '@nestjs/common';
+import { Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import type { Repository } from 'typeorm';
 
 import { Appointment } from '@/domain/entities/appointment';
 import { Patient } from '@/domain/entities/patient';
+import { User } from '@/domain/entities/user';
 
 import type { AuthUserDto } from '../../auth/auth.dtos';
 import type { CreateAppointmentDto } from '../appointments.dtos';
 
 interface CreateAppointmentUseCaseInput {
-  createAppointmentDto: CreateAppointmentDto;
   user: AuthUserDto;
+  createAppointmentDto: CreateAppointmentDto;
 }
 
 @Injectable()
@@ -22,42 +23,48 @@ export class CreateAppointmentUseCase {
     private readonly appointmentsRepository: Repository<Appointment>,
     @InjectRepository(Patient)
     private readonly patientsRepository: Repository<Patient>,
+    @InjectRepository(User)
+    private readonly usersRepository: Repository<User>,
   ) {}
 
   async execute({
     createAppointmentDto,
     user,
   }: CreateAppointmentUseCaseInput): Promise<void> {
-    const { patient_id: patientId, date } = createAppointmentDto;
-
-    const MAX_APPOINTMENT_MONTHS_LIMIT = 3;
-    const appointmentDate = new Date(date);
-    const maxAppointmentDate = new Date();
-
-    maxAppointmentDate.setMonth(
-      maxAppointmentDate.getMonth() + MAX_APPOINTMENT_MONTHS_LIMIT,
-    );
-
-    if (appointmentDate > maxAppointmentDate) {
-      throw new BadRequestException(
-        'A data de atendimento deve estar dentro dos próximos 3 meses.',
-      );
-    }
+    const { patient_id: patientId } = createAppointmentDto;
 
     const patient = await this.patientsRepository.findOne({
       where: { id: patientId },
       select: { id: true },
     });
 
     if (!patient) {
-      throw new BadRequestException('Paciente não encontrado.');
+      throw new NotFoundException('Paciente não encontrado.');
     }
 
-    const appointment = this.appointmentsRepository.create({
+    const appointmentPayload: Partial<Appointment> = {
       ...createAppointmentDto,
+      patient_id: patientId,
+      status: 'scheduled',
       created_by: user.id,
-    });
+    };
+
+    if (user.role === 'specialist') {
+      const specialist = await this.usersRepository.findOne({
+        select: { id: true, name: true, specialty: true },
+        where: { id: user.id },
+      });
+
+      if (!specialist || !specialist.specialty) {
+        throw new NotFoundException('Especialista não encontrado.');
+      }
+
+      appointmentPayload.user_id = specialist.id;
+      appointmentPayload.professional_name = specialist.name;
+      appointmentPayload.category = specialist.specialty;
+    }
 
+    const appointment = this.appointmentsRepository.create(appointmentPayload);
     await this.appointmentsRepository.save(appointment);
 
     this.logger.log(

src/app/http/patients/use-cases/get-patient-options.use-case.ts

@@ -26,6 +26,7 @@ export class GetPatientOptionsUseCase {
 
     const patients = await this.patientsRepository.find({
       select: { id: true, name: true, cpf: true },
+      order: { name: 'ASC' },
       where,
     });
 

src/app/http/referrals/referrals.module.ts

@@ -3,6 +3,7 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 
 import { Patient } from '@/domain/entities/patient';
 import { Referral } from '@/domain/entities/referral';
+import { User } from '@/domain/entities/user';
 
 import { ReferralsController } from './referrals.controller';
 import { CancelReferralUseCase } from './use-cases/cancel-referral.use-case';
@@ -11,7 +12,7 @@ import { GetReferralsUseCase } from './use-cases/get-referrals.use-case';
 import { UpdateReferralUseCase } from './use-cases/update-referral.use-case';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Patient, Referral])],
+  imports: [TypeOrmModule.forFeature([Referral, Patient, User])],
   controllers: [ReferralsController],
   providers: [
     GetReferralsUseCase,

src/app/http/referrals/use-cases/create-referrals.use-case.ts

@@ -4,6 +4,7 @@ import { type Repository } from 'typeorm';
 
 import { Patient } from '@/domain/entities/patient';
 import { Referral } from '@/domain/entities/referral';
+import { User } from '@/domain/entities/user';
 
 import type { AuthUserDto } from '../../auth/auth.dtos';
 import { CreateReferralDto } from '../referrals.dtos';
@@ -20,9 +21,12 @@ export class CreateReferralUseCase {
   constructor(
     @InjectRepository(Patient)
     private readonly patientsRepository: Repository<Patient>,
+    @InjectRepository(User)
+    private readonly usersRepository: Repository<User>,
     @InjectRepository(Referral)
     private readonly referralsRepository: Repository<Referral>,
   ) {}
+
   async execute({
     user,
     createReferralDto,
@@ -38,11 +42,30 @@ export class CreateReferralUseCase {
       throw new NotFoundException('Paciente não encontrado.');
     }
 
-    const referral = await this.referralsRepository.save({
+    const referralPayload: Partial<Referral> = {
       ...createReferralDto,
+      patient_id: patientId,
       status: 'scheduled',
       created_by: user.id,
-    });
+    };
+
+    if (user.role === 'specialist') {
+      const specialist = await this.usersRepository.findOne({
+        select: { id: true, name: true, specialty: true },
+        where: { id: user.id },
+      });
+
+      if (!specialist || !specialist.specialty) {
+        throw new NotFoundException('Especialista não encontrado.');
+      }
+
+      referralPayload.user_id = specialist.id;
+      referralPayload.professional_name = specialist.name;
+      referralPayload.category = specialist.specialty;
+    }
+
+    const referral = this.referralsRepository.create(referralPayload);
+    await this.referralsRepository.save(referral);
 
     this.logger.log(
       {

src/domain/entities/appointment.ts

@@ -43,6 +43,9 @@ export class Appointment implements AppointmentSchema {
   @Column({ type: 'varchar', length: 64, nullable: true })
   professional_name: string | null;
 
+  @Column({ type: 'uuid', nullable: true })
+  user_id: string | null;
+
   @Column('uuid')
   created_by: string;
 

src/domain/entities/referral.ts

@@ -40,6 +40,9 @@ export class Referral implements ReferralSchema {
   @Column({ type: 'varchar', length: 64, nullable: true })
   professional_name: string | null;
 
+  @Column({ type: 'uuid', nullable: true })
+  user_id: string | null;
+
   @Column('uuid')
   created_by: string;
 

src/domain/schemas/appointments/index.ts

@@ -14,6 +14,7 @@ export const appointmentSchema = z
     condition: patientConditionSchema,
     annotation: z.string().max(500).nullable(),
     professional_name: nameSchema.nullable(),
+    user_id: z.string().uuid().nullable(),
     created_by: z.string().uuid(),
     created_at: z.coerce.date(),
     updated_at: z.coerce.date(),

src/domain/schemas/appointments/responses.ts

@@ -17,6 +17,7 @@ export const getAppointmentsResponseSchema = baseResponseSchema.extend({
           condition: true,
           annotation: true,
           professional_name: true,
+          user_id: true,
           created_at: true,
           updated_at: true,
         })