Specialist dashboard

@Component({
  selector: 'app-specialist-page',
  imports: [SplashComponent, UserInformationCardComponent, AppointmentsPendingComponent],
  templateUrl: './specialist-page.component.html',
  changeDetection: ChangeDetectionStrategy.OnPush
})
export class SpecialistPageComponent {
  private readonly authFacade = inject(AuthFacade);
  readonly user: Signal<UserBase | null> = this.authFacade.user;
  readonly isCheckingAuth: Signal<boolean> = this.authFacade.isCheckingAuth;
}

export interface Specialist extends UserBase {
  specialties: Specialty[];
  availability: Availability[];
  availabilityName: string; // From "AVAILABILITY_PRESETS_OPTIONS"
}

export interface Specialty {
  id: string;
  name: string;
  description: string;
  active: boolean;
}

let appointments: Appointment[] = [];
if (user.role === UserRoles.CLIENT) {
  console.log(user.id)
  appointments = await this.appointmentService.getForClient(user.id);
} else if (user.role === UserRoles.SPECIALIST) {
  appointments = await this.appointmentService.getForSpecialist(user.id);
}

async getSpecialistAppointmentsByStatus(
  specialistId: string,
  statuses: AppointmentStatus[]
): Promise<Appointment[]> {
  this._loading.set(true);
  this._error.set(null);
  try {
    return await this.appointmentService.getForSpecialistByStatuses(
      specialistId,
      statuses
    );
  } catch (err: any) {
    this._error.set(err.message || 'Error al obtener los turnos por estado');
    return [];
  } finally {
    this._loading.set(false);
  }
}

async getAppointmentsBySpecialistAndDateRange(
  specialistId: string,
  startDate: Date,
  endDate: Date
): Promise<Appointment[]> {
  this._loading.set(true);
  this._error.set(null);
  try {
    return await this.appointmentService.getAppointmentsBySpecialistAndDateRange(
      specialistId,
      startDate,
      endDate
    );
  } catch (err: any) {
    this._error.set(err.message || 'Error al obtener los turnos del especialista');
    return [];
  } finally {
    this._loading.set(false);
  }
}

availability: Availability[];
availabilityName: string; // From "AVAILABILITY_PRESETS_OPTIONS"

// Specialist properties
specialties: [[], [Validators.required, Validators.minLength(1)]],
availability: [[], Validators.required],

async loadCompletedAppointmentsByClientId(clientId: string): Promise<void> {
  this._loading.set(true);
  this._error.set(null);
  try {
    const appointments = await this.appointmentService.getCompletedForClient(
      clientId
    );
    this._viewedClientAppointments.set(appointments);
  } catch (err: any) {
    this._error.set(err.message || 'Error al obtener la historia del cliente.');
  } finally {
    this._loading.set(false);
  }
}

specialties?.setValidators([
  Validators.required,
  Validators.minLength(1),
]);
availability?.setValidators([Validators.required]);