@blackcode_sa/metaestetics-api 1.6.2 → 1.6.4

package/src/index.ts

@@ -33,6 +33,7 @@ export { CalendarServiceV2 } from "./services/calendar/calendar-refactored.servi
 export { SyncedCalendarsService } from "./services/calendar/synced-calendars.service";
 export { ReviewService } from "./services/reviews/reviews.service";
 export { AppointmentService } from "./services/appointment/appointment.service";
+export { PatientRequirementsService } from "./services/patient/patientRequirements.service";
 
 // Backoffice services
 export { BrandService } from "./backoffice/services/brand.service";
@@ -74,7 +75,6 @@ export type {
   PreRequirementNotification,
   PostRequirementNotification,
   AppointmentReminderNotification,
-  AppointmentNotification,
 } from "./types/notifications";
 export { NotificationType, NotificationStatus } from "./types/notifications";
 
@@ -346,3 +346,18 @@ export {
   reviewSchema,
   createReviewSchema,
 } from "./validations/reviews.schema";
+
+// Patient Requirement Types
+export type {
+  PatientRequirementInstance,
+  PatientRequirementInstruction,
+} from "./types/patient/patient-requirements";
+export {
+  PatientInstructionStatus,
+  PatientRequirementOverallStatus,
+  PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME,
+} from "./types/patient/patient-requirements";
+
+// Patient Requirement Validation Schemas (if they exist and are for client use)
+// Assuming the path, add if it exists and is needed:
+// export * from "./validations/patient/patient-requirements.schema";

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

@@ -3,6 +3,8 @@ import {
   Timestamp,
   DocumentSnapshot,
   serverTimestamp,
+  arrayUnion,
+  arrayRemove,
 } from "firebase/firestore";
 import { Auth } from "firebase/auth";
 import { FirebaseApp } from "firebase/app";
@@ -15,6 +17,9 @@ import {
   UpdateAppointmentData,
   SearchAppointmentsParams,
   PaymentStatus,
+  AppointmentMediaItem,
+  PatientReviewInfo,
+  LinkedFormInfo,
 } from "../../types/appointment";
 import {
   createAppointmentSchema,
@@ -27,6 +32,7 @@ import { CalendarServiceV2 } from "../calendar/calendar-refactored.service";
 import { PatientService } from "../patient/patient.service";
 import { PractitionerService } from "../practitioner/practitioner.service";
 import { ClinicService } from "../clinic/clinic.service";
+import { FilledDocumentService } from "../documentation-templates/filled-document.service";
 
 // Import utility functions
 import {
@@ -54,6 +60,7 @@ export class AppointmentService extends BaseService {
   private patientService: PatientService;
   private practitionerService: PractitionerService;
   private clinicService: ClinicService;
+  private filledDocumentService: FilledDocumentService;
   private functions: Functions;
 
   /**
@@ -74,13 +81,15 @@ export class AppointmentService extends BaseService {
     calendarService: CalendarServiceV2,
     patientService: PatientService,
     practitionerService: PractitionerService,
-    clinicService: ClinicService
+    clinicService: ClinicService,
+    filledDocumentService: FilledDocumentService
   ) {
     super(db, auth, app);
     this.calendarService = calendarService;
     this.patientService = patientService;
     this.practitionerService = practitionerService;
     this.clinicService = clinicService;
+    this.filledDocumentService = filledDocumentService;
     this.functions = getFunctions(app, "europe-west6"); // Initialize Firebase Functions with the correct region
   }
 
@@ -580,61 +589,67 @@ export class AppointmentService extends BaseService {
    *
    * @param appointmentId ID of the appointment
    * @param newStatus New status to set
-   * @param cancellationReason Required if canceling the appointment
-   * @param canceledBy Required if canceling the appointment
+   * @param details Optional details for the status change
    * @returns The updated appointment
    */
   async updateAppointmentStatus(
     appointmentId: string,
     newStatus: AppointmentStatus,
-    cancellationReason?: string,
-    canceledBy?: "patient" | "clinic" | "practitioner" | "system"
+    details?: {
+      cancellationReason?: string;
+      canceledBy?: "patient" | "clinic" | "practitioner" | "system";
+    }
   ): Promise<Appointment> {
     console.log(
       `[APPOINTMENT_SERVICE] Updating status of appointment ${appointmentId} to ${newStatus}`
     );
+    const updateData: UpdateAppointmentData = {
+      status: newStatus,
+      updatedAt: serverTimestamp(),
+    };
 
-    // Create update data based on the new status
-    const updateData: UpdateAppointmentData = { status: newStatus };
-
-    // Add cancellation details if applicable
     if (
       newStatus === AppointmentStatus.CANCELED_CLINIC ||
-      newStatus === AppointmentStatus.CANCELED_PATIENT
+      newStatus === AppointmentStatus.CANCELED_PATIENT ||
+      newStatus === AppointmentStatus.CANCELED_PATIENT_RESCHEDULED
     ) {
-      if (!cancellationReason) {
-        throw new Error(
-          "Cancellation reason is required when canceling an appointment"
-        );
+      if (!details?.cancellationReason) {
+        throw new Error("Cancellation reason is required when canceling.");
       }
-      if (!canceledBy) {
-        throw new Error(
-          "Canceled by is required when canceling an appointment"
-        );
+      if (!details?.canceledBy) {
+        throw new Error("Canceled by is required when canceling.");
       }
-
-      updateData.cancellationReason = cancellationReason;
-      updateData.canceledBy = canceledBy;
+      updateData.cancellationReason = details.cancellationReason;
+      updateData.canceledBy = details.canceledBy;
+      updateData.cancellationTime = Timestamp.now();
     }
 
-    // Add confirmation time if confirming
     if (newStatus === AppointmentStatus.CONFIRMED) {
       updateData.confirmationTime = Timestamp.now();
     }
 
+    if (newStatus === AppointmentStatus.RESCHEDULED_BY_CLINIC) {
+      updateData.rescheduleTime = Timestamp.now();
+    }
+
     return this.updateAppointment(appointmentId, updateData);
   }
 
   /**
-   * Confirms an appointment.
-   *
-   * @param appointmentId ID of the appointment to confirm
-   * @returns The confirmed appointment
+   * Confirms a PENDING appointment by an Admin/Clinic.
    */
-  async confirmAppointment(appointmentId: string): Promise<Appointment> {
+  async confirmAppointmentAdmin(appointmentId: string): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Confirming appointment: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] Admin confirming appointment: ${appointmentId}`
     );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+    if (appointment.status !== AppointmentStatus.PENDING) {
+      throw new Error(
+        `Appointment ${appointmentId} is not in PENDING state to be confirmed.`
+      );
+    }
     return this.updateAppointmentStatus(
       appointmentId,
       AppointmentStatus.CONFIRMED
@@ -642,125 +657,340 @@ export class AppointmentService extends BaseService {
   }
 
   /**
-   * Cancels an appointment from the clinic side.
-   *
-   * @param appointmentId ID of the appointment to cancel
-   * @param reason Reason for cancellation
-   * @returns The canceled appointment
+   * Cancels an appointment by the User (Patient).
    */
-  async cancelAppointmentByClinic(
+  async cancelAppointmentUser(
     appointmentId: string,
     reason: string
   ): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Canceling appointment by clinic: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] User canceling appointment: ${appointmentId}`
     );
     return this.updateAppointmentStatus(
       appointmentId,
-      AppointmentStatus.CANCELED_CLINIC,
-      reason,
-      "clinic"
+      AppointmentStatus.CANCELED_PATIENT,
+      {
+        cancellationReason: reason,
+        canceledBy: "patient",
+      }
     );
   }
 
   /**
-   * Cancels an appointment from the patient side.
-   *
-   * @param appointmentId ID of the appointment to cancel
-   * @param reason Reason for cancellation
-   * @returns The canceled appointment
+   * Cancels an appointment by an Admin/Clinic.
    */
-  async cancelAppointmentByPatient(
+  async cancelAppointmentAdmin(
     appointmentId: string,
     reason: string
   ): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Canceling appointment by patient: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] Admin canceling appointment: ${appointmentId}`
     );
     return this.updateAppointmentStatus(
       appointmentId,
-      AppointmentStatus.CANCELED_PATIENT,
-      reason,
-      "patient"
+      AppointmentStatus.CANCELED_CLINIC,
+      {
+        cancellationReason: reason,
+        canceledBy: "clinic",
+      }
     );
   }
 
   /**
-   * Marks an appointment as checked in.
-   *
-   * @param appointmentId ID of the appointment
-   * @returns The updated appointment
+   * 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> {
+    console.log(
+      `[APPOINTMENT_SERVICE] Admin rescheduling appointment: ${appointmentId}`
+    );
+    if (newEndTime.toMillis() <= newStartTime.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,
+      rescheduleTime: Timestamp.now(),
+      confirmationTime: null,
+      updatedAt: serverTimestamp(),
+    };
+    return this.updateAppointment(appointmentId, updateData);
+  }
+
+  /**
+   * User confirms a reschedule proposed by the clinic.
+   * Status changes from RESCHEDULED_BY_CLINIC to CONFIRMED.
    */
-  async checkInAppointment(appointmentId: string): Promise<Appointment> {
+  async rescheduleAppointmentConfirmUser(
+    appointmentId: string
+  ): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Checking in appointment: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] User confirming reschedule for: ${appointmentId}`
     );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+    if (appointment.status !== AppointmentStatus.RESCHEDULED_BY_CLINIC) {
+      throw new Error(
+        `Appointment ${appointmentId} is not in RESCHEDULED_BY_CLINIC state.`
+      );
+    }
     return this.updateAppointmentStatus(
       appointmentId,
-      AppointmentStatus.CHECKED_IN
+      AppointmentStatus.CONFIRMED
     );
   }
 
   /**
-   * Marks an appointment as in progress.
-   *
-   * @param appointmentId ID of the appointment
-   * @returns The updated appointment
+   * User rejects a reschedule proposed by the clinic.
+   * Status changes from RESCHEDULED_BY_CLINIC to CANCELED_PATIENT_RESCHEDULED.
    */
-  async startAppointment(appointmentId: string): Promise<Appointment> {
-    console.log(`[APPOINTMENT_SERVICE] Starting appointment: ${appointmentId}`);
+  async rescheduleAppointmentRejectUser(
+    appointmentId: string,
+    reason: string
+  ): Promise<Appointment> {
+    console.log(
+      `[APPOINTMENT_SERVICE] User rejecting reschedule for: ${appointmentId}`
+    );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+    if (appointment.status !== AppointmentStatus.RESCHEDULED_BY_CLINIC) {
+      throw new Error(
+        `Appointment ${appointmentId} is not in RESCHEDULED_BY_CLINIC state.`
+      );
+    }
     return this.updateAppointmentStatus(
       appointmentId,
-      AppointmentStatus.IN_PROGRESS
+      AppointmentStatus.CANCELED_PATIENT_RESCHEDULED,
+      {
+        cancellationReason: reason,
+        canceledBy: "patient",
+      }
     );
   }
 
   /**
-   * Marks an appointment as completed.
-   *
-   * @param appointmentId ID of the appointment
-   * @param actualDurationMinutes Actual duration of the appointment in minutes
-   * @returns The updated appointment
+   * Admin checks in a patient for their appointment.
+   * Requires all pending user forms to be completed.
    */
-  async completeAppointment(
+  async checkInPatientAdmin(appointmentId: string): Promise<Appointment> {
+    console.log(
+      `[APPOINTMENT_SERVICE] Admin checking in patient for: ${appointmentId}`
+    );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+
+    if (
+      appointment.pendingUserFormsIds &&
+      appointment.pendingUserFormsIds.length > 0
+    ) {
+      throw new Error(
+        `Cannot check in: Patient has ${
+          appointment.pendingUserFormsIds.length
+        } pending required form(s). IDs: ${appointment.pendingUserFormsIds.join(
+          ", "
+        )}`
+      );
+    }
+    if (
+      appointment.status !== AppointmentStatus.CONFIRMED &&
+      appointment.status !== AppointmentStatus.RESCHEDULED_BY_CLINIC
+    ) {
+      console.warn(
+        `Checking in appointment ${appointmentId} with status ${appointment.status}. Ensure this is intended.`
+      );
+    }
+
+    return this.updateAppointmentStatus(
+      appointmentId,
+      AppointmentStatus.CHECKED_IN
+    );
+  }
+
+  /**
+   * Doctor starts the appointment procedure.
+   */
+  async startAppointmentDoctor(appointmentId: string): Promise<Appointment> {
+    console.log(
+      `[APPOINTMENT_SERVICE] Doctor starting appointment: ${appointmentId}`
+    );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+    if (appointment.status !== AppointmentStatus.CHECKED_IN) {
+      throw new Error(
+        `Appointment ${appointmentId} must be CHECKED_IN to start.`
+      );
+    }
+    // Update status and set procedureActualStartTime
+    const updateData: UpdateAppointmentData = {
+      status: AppointmentStatus.IN_PROGRESS,
+      procedureActualStartTime: Timestamp.now(), // Set actual start time
+      updatedAt: serverTimestamp(),
+    };
+    return this.updateAppointment(appointmentId, updateData);
+  }
+
+  /**
+   * Doctor completes and finalizes the appointment.
+   */
+  async completeAppointmentDoctor(
     appointmentId: string,
-    actualDurationMinutes?: number
+    finalizationNotes: string,
+    actualDurationMinutesInput?: number // Renamed to avoid conflict if we calculate
   ): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Completing appointment: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] Doctor completing appointment: ${appointmentId}`
     );
+    const currentUser = this.auth.currentUser;
+    if (!currentUser)
+      throw new Error("Authentication required to complete appointment.");
+
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+
+    let calculatedDurationMinutes = actualDurationMinutesInput;
+    const procedureCompletionTime = Timestamp.now();
+
+    // Calculate duration if not provided and actual start time is available
+    if (
+      calculatedDurationMinutes === undefined &&
+      appointment.procedureActualStartTime
+    ) {
+      const startTimeMillis = appointment.procedureActualStartTime.toMillis();
+      const endTimeMillis = procedureCompletionTime.toMillis();
+      if (endTimeMillis > startTimeMillis) {
+        calculatedDurationMinutes = Math.round(
+          (endTimeMillis - startTimeMillis) / 60000
+        );
+      }
+    }
 
     const updateData: UpdateAppointmentData = {
       status: AppointmentStatus.COMPLETED,
-      actualDurationMinutes,
+      actualDurationMinutes: calculatedDurationMinutes, // Use calculated or provided duration
+      finalizedDetails: {
+        by: currentUser.uid, // This is used ID, not practitioner's profile ID (just so we know who completed the appointment)
+        at: procedureCompletionTime, // Use consistent completion timestamp
+        notes: finalizationNotes,
+      },
+      // Optionally update appointmentEndTime to the actual completion time
+      // appointmentEndTime: procedureCompletionTime,
+      updatedAt: serverTimestamp(),
     };
-
     return this.updateAppointment(appointmentId, updateData);
   }
 
   /**
-   * Marks an appointment as no-show.
-   *
-   * @param appointmentId ID of the appointment
-   * @returns The updated appointment
+   * Admin marks an appointment as No-Show.
    */
-  async markNoShow(appointmentId: string): Promise<Appointment> {
+  async markNoShowAdmin(appointmentId: string): Promise<Appointment> {
     console.log(
-      `[APPOINTMENT_SERVICE] Marking appointment as no-show: ${appointmentId}`
+      `[APPOINTMENT_SERVICE] Admin marking no-show for: ${appointmentId}`
     );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment)
+      throw new Error(`Appointment ${appointmentId} not found.`);
+    if (
+      Timestamp.now().toMillis() < appointment.appointmentStartTime.toMillis()
+    ) {
+      throw new Error("Cannot mark no-show before appointment start time.");
+    }
     return this.updateAppointmentStatus(
       appointmentId,
-      AppointmentStatus.NO_SHOW
+      AppointmentStatus.NO_SHOW,
+      {
+        cancellationReason: "Patient did not show up for the appointment.",
+        canceledBy: "clinic",
+      }
     );
   }
 
+  /**
+   * Adds a media item to an appointment.
+   */
+  async addMediaToAppointment(
+    appointmentId: string,
+    mediaItemData: Omit<AppointmentMediaItem, "id" | "uploadedAt">
+  ): Promise<Appointment> {
+    console.log(
+      `[APPOINTMENT_SERVICE] Adding media to appointment ${appointmentId}`
+    );
+    const currentUser = this.auth.currentUser;
+    if (!currentUser) throw new Error("Authentication required.");
+
+    const newMediaItem: AppointmentMediaItem = {
+      ...mediaItemData,
+      id: this.generateId(),
+      uploadedAt: Timestamp.now(),
+      uploadedBy: currentUser.uid,
+    };
+
+    const updateData: UpdateAppointmentData = {
+      media: arrayUnion(newMediaItem) as any,
+      updatedAt: serverTimestamp(),
+    };
+    return this.updateAppointment(appointmentId, updateData);
+  }
+
+  /**
+   * Removes a media item from an appointment.
+   */
+  async removeMediaFromAppointment(
+    appointmentId: string,
+    mediaItemId: string
+  ): Promise<Appointment> {
+    console.log(
+      `[APPOINTMENT_SERVICE] Removing media ${mediaItemId} from appointment ${appointmentId}`
+    );
+    const appointment = await this.getAppointmentById(appointmentId);
+    if (!appointment || !appointment.media) {
+      throw new Error("Appointment or media list not found.");
+    }
+    const mediaToRemove = appointment.media.find((m) => m.id === mediaItemId);
+    if (!mediaToRemove) {
+      throw new Error(`Media item ${mediaItemId} not found in appointment.`);
+    }
+
+    const updateData: UpdateAppointmentData = {
+      media: arrayRemove(mediaToRemove) as any,
+      updatedAt: serverTimestamp(),
+    };
+    return this.updateAppointment(appointmentId, updateData);
+  }
+
+  /**
+   * Adds or updates review information for an appointment.
+   */
+  async addReviewToAppointment(
+    appointmentId: string,
+    reviewData: Omit<PatientReviewInfo, "reviewedAt" | "reviewId">
+  ): Promise<Appointment> {
+    console.log(
+      `[APPOINTMENT_SERVICE] Adding review to appointment ${appointmentId}`
+    );
+    const newReviewInfo: PatientReviewInfo = {
+      ...reviewData,
+      reviewId: this.generateId(),
+      reviewedAt: Timestamp.now(),
+    };
+    const updateData: UpdateAppointmentData = {
+      reviewInfo: newReviewInfo,
+      updatedAt: serverTimestamp(),
+    };
+    return this.updateAppointment(appointmentId, updateData);
+  }
+
   /**
    * Updates the payment status of an appointment.
-   *
-   * @param appointmentId ID of the appointment
-   * @param paymentStatus New payment status
-   * @param paymentTransactionId Optional transaction ID for the payment
-   * @returns The updated appointment
    */
   async updatePaymentStatus(
     appointmentId: string,
@@ -770,12 +1000,11 @@ export class AppointmentService extends BaseService {
     console.log(
       `[APPOINTMENT_SERVICE] Updating payment status of appointment ${appointmentId} to ${paymentStatus}`
     );
-
     const updateData: UpdateAppointmentData = {
       paymentStatus,
       paymentTransactionId: paymentTransactionId || null,
+      updatedAt: serverTimestamp(),
     };
-
     return this.updateAppointment(appointmentId, updateData);
   }
 

package/src/services/clinic/clinic-admin.service.ts

@@ -197,4 +197,7 @@ export class ClinicAdminService extends BaseService {
       this.getClinicService()
     );
   }
+
+  // TODO: Add more methods for clinic admins for managing permissions, editing profiles by the admin, or by the clinic group owner and so on
+  // Generally refactor admin permissions and clinic group permissions and systems for admin management
 }

package/src/services/clinic/clinic-group.service.ts

@@ -253,4 +253,12 @@ export class ClinicGroupService extends BaseService {
       this.app
     );
   }
+
+  // TODO: Add a method to get all admin tokens for a clinic group (not just active ones)
+
+  // TODO: Refactor admin token methods not to add tokens to the clinicGroup document,
+  // but to add them to a subcollection called adminTokens that belongs to a specific clinicGroup document
+
+  // TODO: Add granular control over admin permissions, e.g. only allow admins to manage certain clinics to tokens directly
+  // TODO: Generally refactor admin tokens and invites, also create cloud function to send invites and send updates when sombody uses the token
 }

package/src/services/documentation-templates/documentation-template.service.ts

@@ -23,10 +23,7 @@ import {
   DocumentTemplate,
   UpdateDocumentTemplateData,
 } from "../../types";
-import {
-  FILLED_DOCUMENTS_COLLECTION,
-  DOCUMENTATION_TEMPLATES_COLLECTION,
-} from "../../types";
+import { DOCUMENTATION_TEMPLATES_COLLECTION } from "../../types";
 import {
   createDocumentTemplateSchema,
   updateDocumentTemplateSchema,
@@ -76,6 +73,9 @@ export class DocumentationTemplateService extends BaseService {
       version: 1,
       isActive: true,
       tags: validatedData.tags || [],
+      isUserForm: validatedData.isUserForm || false,
+      isRequired: validatedData.isRequired || false,
+      sortingOrder: validatedData.sortingOrder || 0,
     };
 
     // Save to Firestore
@@ -123,30 +123,38 @@ export class DocumentationTemplateService extends BaseService {
     // Process elements if provided
     let updatedElements = template.elements;
     if (validatedData.elements) {
-      // Generate IDs for new elements
       updatedElements = validatedData.elements.map((element) => ({
         ...element,
-        id: this.generateId(),
+        id: (element as any).id || this.generateId(),
       })) as DocumentElement[];
     }
 
-    // Create update object
-    const updateData: Partial<DocumentTemplate> = {
-      ...validatedData,
+    const updatePayload: Partial<DocumentTemplate> = {
       elements: updatedElements,
       updatedAt: Date.now(),
       version: template.version + 1,
     };
 
-    // Update in Firestore
+    // Conditionally add fields from validatedData to avoid overwriting with undefined
+    if (validatedData.title !== undefined)
+      updatePayload.title = validatedData.title;
+    if (validatedData.description !== undefined)
+      updatePayload.description = validatedData.description;
+    if (validatedData.isActive !== undefined)
+      updatePayload.isActive = validatedData.isActive;
+    if (validatedData.tags !== undefined)
+      updatePayload.tags = validatedData.tags;
+    if (validatedData.isUserForm !== undefined)
+      updatePayload.isUserForm = validatedData.isUserForm;
+    if (validatedData.isRequired !== undefined)
+      updatePayload.isRequired = validatedData.isRequired;
+    if (validatedData.sortingOrder !== undefined)
+      updatePayload.sortingOrder = validatedData.sortingOrder;
+
     const docRef = doc(this.collectionRef, templateId);
-    await updateDoc(docRef, updateData);
+    await updateDoc(docRef, updatePayload);
 
-    // Return updated template
-    return {
-      ...template,
-      ...updateData,
-    } as DocumentTemplate;
+    return { ...template, ...updatePayload } as DocumentTemplate;
   }
 
   /**