@blackcode_sa/metaestetics-api 1.7.22 → 1.7.24

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.7.22",
+  "version": "1.7.24",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/index.ts

@@ -25,6 +25,7 @@ export { ProcedureService } from "./services/procedure/procedure.service";
 export { ClinicService } from "./services/clinic/clinic.service";
 export { ClinicAdminService } from "./services/clinic/clinic-admin.service";
 export { ClinicGroupService } from "./services/clinic/clinic-group.service";
+export { PractitionerInviteService } from "./services/clinic/practitioner-invite.service";
 export {
   DocumentationTemplateService,
   FilledDocumentService,
@@ -197,17 +198,24 @@ export type {
   CreateDefaultClinicGroupData,
   ClinicGroupSetupData,
   ClinicBranchSetupData,
+  PractitionerInvite,
+  CreatePractitionerInviteData,
+  UpdatePractitionerInviteData,
+  PractitionerInviteFilters,
+  ProposedWorkingHours,
 } from "./types/clinic";
 export {
   CLINICS_COLLECTION,
   CLINIC_GROUPS_COLLECTION,
   CLINIC_ADMINS_COLLECTION,
+  PRACTITIONER_INVITES_COLLECTION,
   PracticeType,
   Language,
   ClinicTag,
   ClinicPhotoTag,
   AdminTokenStatus,
   SubscriptionModel,
+  PractitionerInviteStatus,
 } from "./types/clinic";
 
 // Profile info types

package/src/services/appointment/appointment.service.ts

@@ -35,6 +35,7 @@ import {
   createAppointmentSchema,
   updateAppointmentSchema,
   searchAppointmentsSchema,
+  rescheduleAppointmentSchema,
 } from "../../validations/appointment.schema";
 
 // Import other services needed (dependency injection pattern)
@@ -682,26 +683,87 @@ export class AppointmentService extends BaseService {
    * Admin proposes to reschedule an appointment.
    * Sets status to RESCHEDULED_BY_CLINIC and updates times.
    */
-  async rescheduleAppointmentAdmin(
-    appointmentId: string,
-    newStartTime: Timestamp,
-    newEndTime: Timestamp
-  ): Promise<Appointment> {
+  async rescheduleAppointmentAdmin(params: {
+    appointmentId: string;
+    newStartTime: any; // Accept any type (number, string, Timestamp, etc.)
+    newEndTime: any; // Accept any type (number, string, Timestamp, etc.)
+  }): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Admin rescheduling appointment: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] Admin rescheduling appointment: ${params.appointmentId}`
+    );
+
+    // Validate input data
+    const validatedParams = await rescheduleAppointmentSchema.parseAsync(
+      params
     );
-    if (newEndTime.toMillis() <= newStartTime.toMillis()) {
+
+    // Convert input to Timestamp objects
+    const startTimestamp = this.convertToTimestamp(
+      validatedParams.newStartTime
+    );
+    const endTimestamp = this.convertToTimestamp(validatedParams.newEndTime);
+
+    if (endTimestamp.toMillis() <= startTimestamp.toMillis()) {
       throw new Error("New end time must be after new start time.");
     }
+
     const updateData: UpdateAppointmentData = {
       status: AppointmentStatus.RESCHEDULED_BY_CLINIC,
-      appointmentStartTime: newStartTime,
-      appointmentEndTime: newEndTime,
+      appointmentStartTime: startTimestamp,
+      appointmentEndTime: endTimestamp,
       rescheduleTime: Timestamp.now(),
       confirmationTime: null,
       updatedAt: serverTimestamp(),
     };
-    return this.updateAppointment(appointmentId, updateData);
+    return this.updateAppointment(validatedParams.appointmentId, updateData);
+  }
+
+  /**
+   * Helper method to convert various timestamp formats to Firestore Timestamp
+   * @param value - Any timestamp format (Timestamp, number, string, Date, serialized Timestamp)
+   * @returns Firestore Timestamp object
+   */
+  private convertToTimestamp(value: any): Timestamp {
+    console.log(`[APPOINTMENT_SERVICE] Converting timestamp:`, {
+      value,
+      type: typeof value,
+    });
+
+    // If it's already a Timestamp object with methods
+    if (value && typeof value.toMillis === "function") {
+      return value;
+    }
+
+    // If it's a number (milliseconds since epoch)
+    if (typeof value === "number") {
+      return Timestamp.fromMillis(value);
+    }
+
+    // If it's a string (ISO date string)
+    if (typeof value === "string") {
+      return Timestamp.fromDate(new Date(value));
+    }
+
+    // If it's a Date object
+    if (value instanceof Date) {
+      return Timestamp.fromDate(value);
+    }
+
+    // If it has _seconds property (serialized Timestamp) - THIS IS WHAT FRONTEND SENDS
+    if (value && typeof value._seconds === "number") {
+      return new Timestamp(value._seconds, value._nanoseconds || 0);
+    }
+
+    // If it has seconds property (serialized Timestamp)
+    if (value && typeof value.seconds === "number") {
+      return new Timestamp(value.seconds, value.nanoseconds || 0);
+    }
+
+    throw new Error(
+      `Invalid timestamp format: ${typeof value}, value: ${JSON.stringify(
+        value
+      )}`
+    );
   }
 
   /**

package/src/services/clinic/README.md

@@ -85,3 +85,120 @@ Initializes the service with Firestore, Auth, App instances, and required depend
 - **`photos.utils.ts`**: Firebase Storage interactions (`uploadPhoto`, `uploadMultiplePhotos`, `deletePhoto`).
 - **`admin.utils.ts`**: Helpers for clinic admin interactions (used by `ClinicAdminService`).
 - **`search.utils.ts`**: Geo-radius search logic (`findClinicsInRadius`).
+
+# Clinic Services
+
+This directory contains services related to clinic operations.
+
+## Services
+
+### ClinicService
+
+Handles clinic CRUD operations, searching, and management.
+
+### ClinicGroupService
+
+Manages clinic groups and their operations.
+
+### ClinicAdminService
+
+Handles clinic administrator operations.
+
+### PractitionerInviteService
+
+Manages the practitioner invitation system for clinics.
+
+## PractitionerInviteService
+
+The `PractitionerInviteService` handles the complete flow of inviting practitioners to join clinics.
+
+### Flow
+
+1. Clinic searches for active practitioners by name or email (using existing practitioner search services)
+2. Clinic creates an invite request with proposed working hours
+3. Practitioner receives the invite and can accept or reject it
+4. Admins can cancel pending invites if needed
+5. Connection between practitioner and clinic is handled by aggregation side-effects
+
+### Methods
+
+#### Core Invite Methods
+
+- `createInviteAdmin(practitionerId, clinicId, proposedWorkingHours, invitedBy, message?)` - Create a new invite
+- `acceptInviteDoctor(inviteId)` - Doctor accepts an invite
+- `rejectInviteDoctor(inviteId, rejectionReason?)` - Doctor rejects an invite
+- `cancelInviteAdmin(inviteId, cancelReason?)` - Admin cancels a pending invite
+
+#### Retrieval Methods
+
+- `getAllInvitesDoctor(practitionerId, statusFilter?)` - Get all invites for a practitioner
+- `getAllInvitesClinic(clinicId, statusFilter?)` - Get all invites for a clinic
+- `getInviteById(inviteId)` - Get a specific invite
+- `getInvitesWithFilters(filters)` - Advanced filtering
+
+#### Admin Methods
+
+- `deleteInvite(inviteId)` - Delete an invite (admin only)
+
+### Status Filtering
+
+All retrieval methods support filtering by invite status:
+
+- `PENDING` - Invite has been sent but not responded to
+- `ACCEPTED` - Practitioner has accepted the invite
+- `REJECTED` - Practitioner has rejected the invite
+- `CANCELLED` - Admin has cancelled the invite
+
+### Usage Example
+
+```typescript
+// Create service instance
+const practitionerInviteService = new PractitionerInviteService(db, auth, app);
+
+// Create an invite
+const invite = await practitionerInviteService.createInviteAdmin(
+  "practitioner123",
+  "clinic456",
+  proposedHours,
+  "admin789",
+  "We'd love to have you join our team!"
+);
+
+// Get clinic's invites
+const clinicInvites = await practitionerInviteService.getAllInvitesClinic(
+  "clinic456",
+  [PractitionerInviteStatus.PENDING]
+);
+
+// Doctor accepts invite
+const acceptedInvite = await practitionerInviteService.acceptInviteDoctor(
+  invite.id
+);
+
+// Admin cancels pending invite
+const cancelledInvite = await practitionerInviteService.cancelInviteAdmin(
+  invite.id,
+  "Position no longer available"
+);
+```
+
+### Data Structure
+
+The service uses existing aggregation types from the profile module:
+
+- `PractitionerProfileInfo` - Complete practitioner information including certification
+- `ClinicInfo` - Complete clinic information including location and contact details
+
+### Error Handling
+
+All methods include proper error handling and logging. Common errors:
+
+- Practitioner/Clinic not found
+- Duplicate pending invites
+- Invalid status transitions (only pending invites can be accepted/rejected/cancelled)
+- Permission issues
+
+### Firestore Collections
+
+- Collection: `practitioner-invites`
+- Documents contain complete invite information with embedded practitioner and clinic details