@blackcode_sa/metaestetics-api 1.7.26 → 1.7.27

package/package.json

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

package/src/index.ts

@@ -31,6 +31,7 @@ export {
   FilledDocumentService,
 } from "./services/documentation-templates";
 export { CalendarServiceV2 } from "./services/calendar/calendar-refactored.service";
+export { CalendarServiceV3 } from "./services/calendar/calendar.v3.service";
 export { SyncedCalendarsService } from "./services/calendar/synced-calendars.service";
 export { ReviewService } from "./services/reviews/reviews.service";
 export { AppointmentService } from "./services/appointment/appointment.service";
@@ -237,6 +238,8 @@ export type {
   SyncedCalendarEvent,
   CreateAppointmentParams,
   UpdateAppointmentParams,
+  CreateBlockingEventParams,
+  UpdateBlockingEventParams,
 } from "./types/calendar";
 
 export {

package/src/recommender/admin/index.ts

@@ -0,0 +1 @@
+// Cloud functions recommender index file

package/src/recommender/admin/services/recommender.service.admin.ts

@@ -0,0 +1,5 @@
+// Here we will add cloud functions for recommender system
+
+// Here we will do the calculation logic and cloud logic for all the recommendation calculations
+
+// This is a main file, but I want it to use different calculations that will be placed in UTILS folder, not to contain all the logic for easier maintenance and readability

package/src/recommender/front/index.ts

@@ -0,0 +1 @@
+// Frontend recommender index file

package/src/recommender/front/services/onboarding.service.ts

@@ -0,0 +1,5 @@
+// This service will be used for managing onboarding process for the patient, it will handle all data entry and retreive results
+
+// This service will fill special fields and types that will be defined in types folder
+
+// This service is not retreiving any recommendations in the UI and is only used by onboarding module (form and survey)

package/src/recommender/front/services/recommender.service.ts

@@ -0,0 +1,3 @@
+// This is a frontend UI implementation of recommender service, it will use cloud functions for calculations (HTTP callable), but it will wrap logic for getting results for the frontend
+
+// This service should not be heavy, it should fetch recommendations, maybe even handle like/dislike for the results (for further refining if we implement that), but no more than that

package/src/recommender/index.ts

@@ -0,0 +1 @@
+// Recommender module re-exportindex file

package/src/services/calendar/calendar.v3.service.ts

@@ -0,0 +1,313 @@
+import { Auth } from "firebase/auth";
+import { Firestore, Timestamp, serverTimestamp } from "firebase/firestore";
+import { FirebaseApp } from "firebase/app";
+import { BaseService } from "../base.service";
+import {
+  CalendarEvent,
+  CalendarEventStatus,
+  CalendarEventTime,
+  CalendarEventType,
+  CalendarSyncStatus,
+  CreateCalendarEventData,
+  UpdateCalendarEventData,
+  CALENDAR_COLLECTION,
+  SearchCalendarEventsParams,
+  SearchLocationEnum,
+  DateRange,
+  CreateBlockingEventParams,
+  UpdateBlockingEventParams,
+} from "../../types/calendar";
+import { PRACTITIONERS_COLLECTION } from "../../types/practitioner";
+import { CLINICS_COLLECTION } from "../../types/clinic";
+import { doc, getDoc, setDoc, updateDoc, deleteDoc } from "firebase/firestore";
+
+// Import utility functions
+import { searchCalendarEventsUtil } from "./utils/calendar-event.utils";
+
+/**
+ * Calendar Service V3
+ * Focused on blocking event management and calendar event search
+ * Appointment logic is handled by AppointmentService and BookingAdmin
+ * External calendar sync is handled by dedicated cloud functions
+ */
+export class CalendarServiceV3 extends BaseService {
+  /**
+   * Creates a new CalendarServiceV3 instance
+   * @param db - Firestore instance
+   * @param auth - Firebase Auth instance
+   * @param app - Firebase App instance
+   */
+  constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
+    super(db, auth, app);
+  }
+
+  // #region Blocking Event CRUD Operations
+
+  /**
+   * Creates a blocking event for a practitioner or clinic
+   * @param params - Blocking event creation parameters
+   * @returns Created calendar event
+   */
+  async createBlockingEvent(
+    params: CreateBlockingEventParams
+  ): Promise<CalendarEvent> {
+    // Validate input parameters
+    this.validateBlockingEventParams(params);
+
+    // Generate a unique ID for the event
+    const eventId = this.generateId();
+
+    // Determine the collection path based on entity type
+    const collectionPath = this.getEntityCalendarPath(
+      params.entityType,
+      params.entityId
+    );
+
+    // Create the event document reference
+    const eventRef = doc(this.db, collectionPath, eventId);
+
+    // Prepare the event data
+    const eventData: CreateCalendarEventData = {
+      id: eventId,
+      eventName: params.eventName,
+      eventTime: params.eventTime,
+      eventType: params.eventType,
+      description: params.description || "",
+      status: CalendarEventStatus.CONFIRMED, // Blocking events are always confirmed
+      syncStatus: CalendarSyncStatus.INTERNAL,
+      createdAt: serverTimestamp(),
+      updatedAt: serverTimestamp(),
+    };
+
+    // Set entity-specific fields
+    if (params.entityType === "practitioner") {
+      eventData.practitionerProfileId = params.entityId;
+    } else {
+      eventData.clinicBranchId = params.entityId;
+    }
+
+    // Create the event
+    await setDoc(eventRef, eventData);
+
+    // Return the created event
+    return {
+      ...eventData,
+      createdAt: Timestamp.now(),
+      updatedAt: Timestamp.now(),
+    } as CalendarEvent;
+  }
+
+  /**
+   * Updates a blocking event
+   * @param params - Blocking event update parameters
+   * @returns Updated calendar event
+   */
+  async updateBlockingEvent(
+    params: UpdateBlockingEventParams
+  ): Promise<CalendarEvent> {
+    // Determine the collection path
+    const collectionPath = this.getEntityCalendarPath(
+      params.entityType,
+      params.entityId
+    );
+    const eventRef = doc(this.db, collectionPath, params.eventId);
+
+    // Check if event exists
+    const eventDoc = await getDoc(eventRef);
+    if (!eventDoc.exists()) {
+      throw new Error(`Blocking event with ID ${params.eventId} not found`);
+    }
+
+    // Prepare update data
+    const updateData: Partial<UpdateCalendarEventData> = {
+      updatedAt: serverTimestamp(),
+    };
+
+    if (params.eventName !== undefined) {
+      updateData.eventName = params.eventName;
+    }
+    if (params.eventTime !== undefined) {
+      updateData.eventTime = params.eventTime;
+    }
+    if (params.description !== undefined) {
+      updateData.description = params.description;
+    }
+    if (params.status !== undefined) {
+      updateData.status = params.status;
+    }
+
+    // Update the event
+    await updateDoc(eventRef, updateData);
+
+    // Get and return the updated event
+    const updatedEventDoc = await getDoc(eventRef);
+    return updatedEventDoc.data() as CalendarEvent;
+  }
+
+  /**
+   * Deletes a blocking event
+   * @param entityType - Type of entity (practitioner or clinic)
+   * @param entityId - ID of the entity
+   * @param eventId - ID of the event to delete
+   */
+  async deleteBlockingEvent(
+    entityType: "practitioner" | "clinic",
+    entityId: string,
+    eventId: string
+  ): Promise<void> {
+    // Determine the collection path
+    const collectionPath = this.getEntityCalendarPath(entityType, entityId);
+    const eventRef = doc(this.db, collectionPath, eventId);
+
+    // Check if event exists
+    const eventDoc = await getDoc(eventRef);
+    if (!eventDoc.exists()) {
+      throw new Error(`Blocking event with ID ${eventId} not found`);
+    }
+
+    // Delete the event
+    await deleteDoc(eventRef);
+  }
+
+  /**
+   * Gets a specific blocking event
+   * @param entityType - Type of entity (practitioner or clinic)
+   * @param entityId - ID of the entity
+   * @param eventId - ID of the event to retrieve
+   * @returns Calendar event or null if not found
+   */
+  async getBlockingEvent(
+    entityType: "practitioner" | "clinic",
+    entityId: string,
+    eventId: string
+  ): Promise<CalendarEvent | null> {
+    // Determine the collection path
+    const collectionPath = this.getEntityCalendarPath(entityType, entityId);
+    const eventRef = doc(this.db, collectionPath, eventId);
+
+    // Get the event
+    const eventDoc = await getDoc(eventRef);
+    if (!eventDoc.exists()) {
+      return null;
+    }
+
+    return eventDoc.data() as CalendarEvent;
+  }
+
+  /**
+   * Gets blocking events for a specific entity
+   * @param entityType - Type of entity (practitioner or clinic)
+   * @param entityId - ID of the entity
+   * @param dateRange - Optional date range filter
+   * @param eventType - Optional event type filter
+   * @returns Array of calendar events
+   */
+  async getEntityBlockingEvents(
+    entityType: "practitioner" | "clinic",
+    entityId: string,
+    dateRange?: DateRange,
+    eventType?: CalendarEventType
+  ): Promise<CalendarEvent[]> {
+    // Use the existing search functionality
+    const searchParams: SearchCalendarEventsParams = {
+      searchLocation:
+        entityType === "practitioner"
+          ? SearchLocationEnum.PRACTITIONER
+          : SearchLocationEnum.CLINIC,
+      entityId,
+      dateRange,
+      eventType,
+    };
+
+    // Filter to only blocking-type events if no specific eventType is provided
+    if (!eventType) {
+      // We'll need to filter the results to only include blocking-type events
+      const allEvents = await searchCalendarEventsUtil(this.db, searchParams);
+      return allEvents.filter(
+        (event) =>
+          event.eventType === CalendarEventType.BLOCKING ||
+          event.eventType === CalendarEventType.BREAK ||
+          event.eventType === CalendarEventType.FREE_DAY ||
+          event.eventType === CalendarEventType.OTHER
+      );
+    }
+
+    return searchCalendarEventsUtil(this.db, searchParams);
+  }
+
+  // #endregion
+
+  // #region Calendar Event Search
+
+  /**
+   * Searches for calendar events based on specified criteria.
+   * This method supports searching for ALL event types (appointments, blocking events, etc.)
+   *
+   * @param params - The search parameters
+   * @returns A promise that resolves to an array of matching calendar events
+   */
+  async searchCalendarEvents(
+    params: SearchCalendarEventsParams
+  ): Promise<CalendarEvent[]> {
+    // Use the utility function to perform the search
+    return searchCalendarEventsUtil(this.db, params);
+  }
+
+  // #endregion
+
+  // #region Private Helper Methods
+
+  /**
+   * Gets the calendar collection path for a specific entity
+   * @param entityType - Type of entity (practitioner or clinic)
+   * @param entityId - ID of the entity
+   * @returns Collection path string
+   */
+  private getEntityCalendarPath(
+    entityType: "practitioner" | "clinic",
+    entityId: string
+  ): string {
+    if (entityType === "practitioner") {
+      return `${PRACTITIONERS_COLLECTION}/${entityId}/${CALENDAR_COLLECTION}`;
+    } else {
+      return `${CLINICS_COLLECTION}/${entityId}/${CALENDAR_COLLECTION}`;
+    }
+  }
+
+  /**
+   * Validates blocking event creation parameters
+   * @param params - Parameters to validate
+   * @throws Error if validation fails
+   */
+  private validateBlockingEventParams(params: CreateBlockingEventParams): void {
+    if (!params.entityType || !params.entityId) {
+      throw new Error("Entity type and ID are required");
+    }
+
+    if (!params.eventName || params.eventName.trim() === "") {
+      throw new Error("Event name is required");
+    }
+
+    if (!params.eventTime || !params.eventTime.start || !params.eventTime.end) {
+      throw new Error("Event time with start and end is required");
+    }
+
+    // Validate that end time is after start time
+    if (params.eventTime.end.toMillis() <= params.eventTime.start.toMillis()) {
+      throw new Error("Event end time must be after start time");
+    }
+
+    // Validate event type is one of the blocking types
+    const validTypes = [
+      CalendarEventType.BLOCKING,
+      CalendarEventType.BREAK,
+      CalendarEventType.FREE_DAY,
+      CalendarEventType.OTHER,
+    ];
+    if (!validTypes.includes(params.eventType)) {
+      throw new Error("Invalid event type for blocking events");
+    }
+  }
+
+  // #endregion
+}

package/src/types/calendar/index.ts

@@ -227,3 +227,32 @@ export interface SearchCalendarEventsParams {
   /** Optional filter for event type. */
   eventType?: CalendarEventType;
 }
+
+/**
+ * Interface for creating blocking events
+ */
+export interface CreateBlockingEventParams {
+  entityType: "practitioner" | "clinic";
+  entityId: string;
+  eventName: string;
+  eventTime: CalendarEventTime;
+  eventType:
+    | CalendarEventType.BLOCKING
+    | CalendarEventType.BREAK
+    | CalendarEventType.FREE_DAY
+    | CalendarEventType.OTHER;
+  description?: string;
+}
+
+/**
+ * Interface for updating blocking events
+ */
+export interface UpdateBlockingEventParams {
+  entityType: "practitioner" | "clinic";
+  entityId: string;
+  eventId: string;
+  eventName?: string;
+  eventTime?: CalendarEventTime;
+  description?: string;
+  status?: CalendarEventStatus;
+}

package/src/validations/calendar.schema.ts

@@ -4,6 +4,8 @@ import {
   CalendarEventStatus,
   CalendarEventType,
   CalendarSyncStatus,
+  CreateBlockingEventParams,
+  UpdateBlockingEventParams,
 } from "../types/calendar";
 import { SyncedCalendarProvider } from "../types/calendar/synced-calendar.types";
 import {
@@ -221,3 +223,42 @@ export const calendarEventSchema = z.object({
   createdAt: z.instanceof(Date).or(z.instanceof(Timestamp)),
   updatedAt: z.instanceof(Date).or(z.instanceof(Timestamp)),
 });
+
+/**
+ * Validation schema for creating blocking events
+ * Based on CreateBlockingEventParams interface
+ */
+export const createBlockingEventSchema = z.object({
+  entityType: z.enum(["practitioner", "clinic"]),
+  entityId: z.string().min(1, "Entity ID is required"),
+  eventName: z
+    .string()
+    .min(1, "Event name is required")
+    .max(200, "Event name too long"),
+  eventTime: calendarEventTimeSchema,
+  eventType: z.enum([
+    CalendarEventType.BLOCKING,
+    CalendarEventType.BREAK,
+    CalendarEventType.FREE_DAY,
+    CalendarEventType.OTHER,
+  ]),
+  description: z.string().max(1000, "Description too long").optional(),
+});
+
+/**
+ * Validation schema for updating blocking events
+ * Based on UpdateBlockingEventParams interface
+ */
+export const updateBlockingEventSchema = z.object({
+  entityType: z.enum(["practitioner", "clinic"]),
+  entityId: z.string().min(1, "Entity ID is required"),
+  eventId: z.string().min(1, "Event ID is required"),
+  eventName: z
+    .string()
+    .min(1, "Event name is required")
+    .max(200, "Event name too long")
+    .optional(),
+  eventTime: calendarEventTimeSchema.optional(),
+  description: z.string().max(1000, "Description too long").optional(),
+  status: z.nativeEnum(CalendarEventStatus).optional(),
+});