@blackcode_sa/metaestetics-api 1.4.17 → 1.5.0

package/src/types/calendar/index.ts

@@ -0,0 +1,187 @@
+import { Timestamp, FieldValue } from "firebase/firestore";
+import type { ClinicLocation } from "../clinic";
+import type {
+  Category,
+  ProcedureFamily,
+  Product,
+  Subcategory,
+  Technology,
+} from "../../backoffice";
+import type { SyncedCalendarProvider } from "./synced-calendar.types";
+import type { Gender } from "../patient";
+import type { PractitionerCertification } from "../practitioner";
+import type { Currency } from "../../backoffice/types/static/pricing.types";
+import type {
+  ClinicInfo,
+  PractitionerProfileInfo,
+  PatientProfileInfo,
+} from "../profile";
+
+/**
+ * Enum for calendar event status
+ */
+export enum CalendarEventStatus {
+  PENDING = "pending", // When event is created, but not confirmed
+  CONFIRMED = "confirmed", // When event is confirmed and ready to be used
+  REJECTED = "rejected", // When event is rejected by the clinic administrator or patient
+  CANCELED = "canceled", // When event is canceled by the patient
+  RESCHEDULED = "rescheduled", // When event is rescheduled by the clinic administrator
+  COMPLETED = "completed", // When event is completed
+}
+
+/**
+ * Enum for calendar event sync status
+ */
+export enum CalendarSyncStatus {
+  INTERNAL = "internal",
+  EXTERNAL = "external",
+}
+
+/**
+ * Enum for calendar event types
+ */
+export enum CalendarEventType {
+  APPOINTMENT = "appointment",
+  BLOCKING = "blocking",
+  BREAK = "break",
+  FREE_DAY = "free_day",
+  OTHER = "other",
+}
+
+/**
+ * Interface for calendar event time
+ */
+export interface CalendarEventTime {
+  start: Timestamp;
+  end: Timestamp;
+}
+
+export interface ProcedureInfo {
+  // TO-DO: Create detailed procedure info when procedures are integrated
+  name: string;
+  description: string;
+  duration: number;
+  price: number;
+  currency: Currency;
+}
+
+export interface ProcedureCategorization {
+  procedureFamily: ProcedureFamily;
+  procedureCategory: Category;
+  procedureSubcategory: Subcategory;
+  procedureTechnology: Technology;
+  procedureProduct: Product;
+}
+
+export interface SyncedCalendarEvent {
+  eventId: string;
+  syncedCalendarProvider: SyncedCalendarProvider;
+  syncedAt: Timestamp; // Timestamp when the event was last synced with the external calendar
+}
+
+/**
+ * Interface for calendar event
+ */
+export interface CalendarEvent {
+  id: string;
+  clinicBranchId?: string | null;
+  clinicBranchInfo?: ClinicInfo | null;
+  practitionerProfileId?: string | null;
+  practitionerProfileInfo?: PractitionerProfileInfo | null;
+  patientProfileId?: string | null;
+  patientProfileInfo?: PatientProfileInfo | null;
+  procedureId?: string | null;
+  procedureInfo?: ProcedureInfo | null;
+  procedureCategorization?: ProcedureCategorization | null;
+  appointmentId?: string | null; // Created when calendar event is confirmed and it's type is APPOINTMENT
+  syncedCalendarEventId?: SyncedCalendarEvent[] | null;
+  eventName: string;
+  eventLocation?: ClinicLocation;
+  eventTime: CalendarEventTime;
+  description?: string;
+  status: CalendarEventStatus;
+  syncStatus: CalendarSyncStatus;
+  eventType: CalendarEventType;
+  createdAt: Timestamp;
+  updatedAt: Timestamp;
+}
+
+/**
+ * Interface for creating a calendar event
+ */
+export interface CreateCalendarEventData {
+  id: string;
+  clinicBranchId?: string | null;
+  clinicBranchInfo?: ClinicInfo | null;
+  practitionerProfileId?: string | null;
+  practitionerProfileInfo?: PractitionerProfileInfo | null;
+  patientProfileId?: string | null;
+  patientProfileInfo?: PatientProfileInfo | null;
+  procedureId?: string | null;
+  appointmentId?: string | null; // Not needed if event type is not APPOINTMENT, or if there is no automatic appointment confirmation
+  syncedCalendarEventId?: SyncedCalendarEvent[] | null;
+  eventName: string;
+  eventLocation?: ClinicLocation;
+  eventTime: CalendarEventTime;
+  description?: string;
+  status: CalendarEventStatus;
+  syncStatus: CalendarSyncStatus;
+  eventType: CalendarEventType;
+  createdAt: FieldValue;
+  updatedAt: FieldValue;
+}
+
+/**
+ * Interface for updating a calendar event
+ */
+export interface UpdateCalendarEventData {
+  syncedCalendarEventId?: SyncedCalendarEvent[] | null;
+  appointmentId?: string | null; // Updated when calendar event is confirmed and it's type is APPOINTMENT, plus Appointment is created
+  eventName?: string;
+  eventTime?: CalendarEventTime;
+  description?: string;
+  status?: CalendarEventStatus;
+  syncStatus?: CalendarSyncStatus;
+  eventType?: CalendarEventType;
+  updatedAt: FieldValue;
+}
+
+/**
+ * Interface for available time slot
+ */
+export interface TimeSlot {
+  start: Date;
+  end: Date;
+  isAvailable: boolean;
+}
+
+/**
+ * Interface for appointment creation parameters
+ */
+export interface CreateAppointmentParams {
+  clinicId: string;
+  doctorId: string;
+  patientId: string;
+  procedureId: string;
+  eventLocation: ClinicLocation;
+  eventTime: CalendarEventTime;
+  description?: string;
+}
+
+/**
+ * Interface for appointment update parameters
+ */
+export interface UpdateAppointmentParams {
+  appointmentId: string;
+  clinicId: string;
+  doctorId: string;
+  patientId: string;
+  eventTime?: CalendarEventTime;
+  description?: string;
+  status?: CalendarEventStatus;
+}
+
+/**
+ * Collection names for calendar
+ */
+export const CALENDAR_COLLECTION = "calendar";

package/src/types/calendar/synced-calendar.types.ts

@@ -0,0 +1,66 @@
+import { Timestamp, FieldValue } from "firebase/firestore";
+
+/**
+ * Enum for synced calendar provider
+ */
+export enum SyncedCalendarProvider {
+  GOOGLE = "google",
+  OUTLOOK = "outlook",
+  APPLE = "apple",
+}
+
+/**
+ * Interface for synced calendar
+ */
+export interface SyncedCalendar {
+  id: string;
+  provider: SyncedCalendarProvider;
+  name: string;
+  description?: string;
+  accessToken: string;
+  refreshToken: string;
+  tokenExpiry: Timestamp;
+  calendarId: string;
+  isActive: boolean;
+  lastSyncedAt?: Timestamp;
+  createdAt: Timestamp;
+  updatedAt: Timestamp;
+}
+
+/**
+ * Interface for creating a synced calendar
+ */
+export interface CreateSyncedCalendarData {
+  id: string;
+  provider: SyncedCalendarProvider;
+  name: string;
+  description?: string;
+  accessToken: string;
+  refreshToken: string;
+  tokenExpiry: Timestamp;
+  calendarId: string;
+  isActive: boolean;
+  lastSyncedAt?: Timestamp;
+  createdAt: FieldValue;
+  updatedAt: FieldValue;
+}
+
+/**
+ * Interface for updating a synced calendar
+ */
+export interface UpdateSyncedCalendarData {
+  name?: string;
+  description?: string;
+  accessToken?: string;
+  refreshToken?: string;
+  tokenExpiry?: Timestamp;
+  calendarId?: string;
+  isActive?: boolean;
+  lastSyncedAt?: Timestamp;
+  updatedAt: FieldValue;
+}
+
+/**
+ * Collection name for synced calendars
+ */
+export const SYNCED_CALENDARS_COLLECTION = "syncedCalendars";

package/src/types/clinic/index.ts

@@ -5,6 +5,7 @@ import type {
   Currency,
   PricingMeasure,
 } from "../../backoffice/types/static/pricing.types";
+import type { ClinicInfo } from "../profile";
 
 export const CLINIC_GROUPS_COLLECTION = "clinic_groups";
 export const CLINIC_ADMINS_COLLECTION = "clinic_admins";
@@ -94,18 +95,6 @@ export interface ContactPerson {
   phoneNumber?: string | null;
 }
 
-/**
- * Interface for clinic information
- */
-export interface ClinicInfo {
-  id: string;
-  featuredPhoto: string;
-  name: string;
-  description?: string;
-  location: ClinicLocation;
-  contactInfo: ClinicContactInfo;
-}
-
 /**
  * Interface for clinic admin
  */
@@ -308,7 +297,7 @@ export interface Clinic {
   workingHours: WorkingHours;
   tags: ClinicTag[];
   featuredPhotos: string[];
-  photos: string[];
+  coverPhoto: string | null;
   photosWithTags?: { url: string; tag: string }[];
   doctors: string[];
   doctorsInfo: DoctorInfo[];
@@ -339,7 +328,7 @@ export interface CreateClinicData {
   contactInfo: ClinicContactInfo;
   workingHours: WorkingHours;
   tags: ClinicTag[];
-  photos: string[];
+  coverPhoto: string | null;
   photosWithTags?: { url: string; tag: string }[];
   doctors: string[];
   services: string[];
@@ -418,7 +407,7 @@ export interface ClinicBranchSetupData {
   workingHours: WorkingHours;
   tags: ClinicTag[];
   logo?: string;
-  photos: string[];
+  coverPhoto: string | null;
   photosWithTags?: { url: string; tag: string }[];
   featuredPhotos?: string[];
 }

package/src/types/index.ts

@@ -41,3 +41,7 @@ export type FirebaseUser = FirebaseAuthUser;
 export * from "./documentation-templates";
 export const DOCUMENTATION_TEMPLATES_COLLECTION = "documentation-templates";
 export const FILLED_DOCUMENTS_COLLECTION = "filled-documents";
+
+// Calendar
+export * from "./calendar";
+export const CALENDAR_COLLECTION = "calendar";

package/src/types/practitioner/index.ts

@@ -35,6 +35,25 @@ export interface PractitionerCertification {
   verificationStatus: "pending" | "verified" | "rejected";
 }
 
+/**
+ * Interfejs za radno vreme zdravstvenog radnika u klinici
+ */
+export interface PractitionerClinicWorkingHours {
+  clinicId: string;
+  workingHours: {
+    monday: { start: string; end: string } | null;
+    tuesday: { start: string; end: string } | null;
+    wednesday: { start: string; end: string } | null;
+    thursday: { start: string; end: string } | null;
+    friday: { start: string; end: string } | null;
+    saturday: { start: string; end: string } | null;
+    sunday: { start: string; end: string } | null;
+  };
+  isActive: boolean;
+  createdAt: Timestamp;
+  updatedAt: Timestamp;
+}
+
 /**
  * Interfejs za zdravstvenog radnika
  */
@@ -44,6 +63,7 @@ export interface Practitioner {
   basicInfo: PractitionerBasicInfo;
   certification: PractitionerCertification;
   clinics: string[]; // Reference na klinike gde radi
+  clinicWorkingHours: PractitionerClinicWorkingHours[]; // Radno vreme za svaku kliniku
   isActive: boolean;
   isVerified: boolean;
   createdAt: Timestamp;
@@ -58,6 +78,7 @@ export interface CreatePractitionerData {
   basicInfo: PractitionerBasicInfo;
   certification: PractitionerCertification;
   clinics?: string[];
+  clinicWorkingHours?: PractitionerClinicWorkingHours[];
   isActive: boolean;
   isVerified: boolean;
 }

package/src/types/profile/index.ts

@@ -0,0 +1,39 @@
+import { Timestamp } from "firebase-admin/firestore";
+import { ClinicLocation, ClinicContactInfo } from "../clinic";
+import { PractitionerCertification } from "../practitioner";
+import { Gender } from "../patient";
+/**
+ * Interface for clinic profile information
+ */
+export interface ClinicInfo {
+  id: string;
+  featuredPhoto: string;
+  name: string;
+  description: string;
+  location: ClinicLocation;
+  contactInfo: ClinicContactInfo;
+}
+
+/**
+ * Interface for practitioner profile information
+ */
+export interface PractitionerProfileInfo {
+  id: string;
+  practitionerPhoto: string | null;
+  name: string;
+  email: string;
+  phone: string | null;
+  certification: PractitionerCertification;
+}
+
+/**
+ * Interface for patient profile information
+ */
+export interface PatientProfileInfo {
+  id: string;
+  fullName: string;
+  email: string;
+  phone: string | null;
+  dateOfBirth: Timestamp;
+  gender: Gender;
+}

package/src/validations/calendar.schema.ts

@@ -0,0 +1,223 @@
+import { z } from "zod";
+import { Timestamp, FieldValue } from "firebase/firestore";
+import {
+  CalendarEventStatus,
+  CalendarEventType,
+  CalendarSyncStatus,
+} from "../types/calendar";
+import { SyncedCalendarProvider } from "../types/calendar/synced-calendar.types";
+import {
+  Currency,
+  PricingMeasure,
+} from "../backoffice/types/static/pricing.types";
+import { clinicLocationSchema } from "./clinic.schema";
+import {
+  clinicInfoSchema,
+  patientProfileInfoSchema,
+  practitionerProfileInfoSchema,
+} from "./profile-info.schema";
+
+/**
+ * Minimum appointment duration in minutes
+ */
+const MIN_APPOINTMENT_DURATION = 15;
+
+/**
+ * Validation schema for calendar event time
+ */
+export const calendarEventTimeSchema = z
+  .object({
+    start: z.instanceof(Date).or(z.instanceof(Timestamp)),
+    end: z.instanceof(Date).or(z.instanceof(Timestamp)),
+  })
+  .refine(
+    (data) => {
+      // Convert to Date objects for comparison if they are Timestamps
+      const startDate =
+        data.start instanceof Timestamp ? data.start.toDate() : data.start;
+      const endDate =
+        data.end instanceof Timestamp ? data.end.toDate() : data.end;
+
+      // Ensure end time is after start time
+      return startDate < endDate;
+    },
+    {
+      message: "End time must be after start time",
+      path: ["end"],
+    }
+  )
+  .refine(
+    (data) => {
+      // Convert to Date objects for comparison if they are Timestamps
+      const startDate =
+        data.start instanceof Timestamp ? data.start.toDate() : data.start;
+
+      // Ensure start time is in the future
+      return startDate > new Date();
+    },
+    {
+      message: "Appointment must be scheduled in the future",
+      path: ["start"],
+    }
+  );
+
+/**
+ * Validation schema for time slot
+ */
+export const timeSlotSchema = z
+  .object({
+    start: z.date(),
+    end: z.date(),
+    isAvailable: z.boolean(),
+  })
+  .refine((data) => data.start < data.end, {
+    message: "End time must be after start time",
+    path: ["end"],
+  });
+
+/**
+ * Validation schema for synced calendar event
+ */
+export const syncedCalendarEventSchema = z.object({
+  eventId: z.string(),
+  syncedCalendarProvider: z.nativeEnum(SyncedCalendarProvider),
+  syncedAt: z.instanceof(Date).or(z.instanceof(Timestamp)),
+});
+
+/**
+ * Validation schema for procedure info
+ */
+export const procedureInfoSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  duration: z.number().min(MIN_APPOINTMENT_DURATION),
+  price: z.number().min(0),
+  currency: z.nativeEnum(Currency),
+});
+
+/**
+ * Validation schema for procedure categorization
+ */
+export const procedureCategorizationSchema = z.object({
+  procedureFamily: z.string(), // Replace with proper enum when available
+  procedureCategory: z.string(), // Replace with proper enum when available
+  procedureSubcategory: z.string(), // Replace with proper enum when available
+  procedureTechnology: z.string(), // Replace with proper enum when available
+  procedureProduct: z.string(), // Replace with proper enum when available
+});
+
+/**
+ * Validation schema for creating an appointment
+ */
+export const createAppointmentSchema = z
+  .object({
+    clinicId: z.string().min(1, "Clinic ID is required"),
+    doctorId: z.string().min(1, "Doctor ID is required"),
+    patientId: z.string().min(1, "Patient ID is required"),
+    procedureId: z.string().min(1, "Procedure ID is required"),
+    eventLocation: clinicLocationSchema,
+    eventTime: calendarEventTimeSchema,
+    description: z.string().optional(),
+  })
+  .refine(
+    (data) => {
+      // If we have access to the actual data, we could validate:
+      // - Doctor works at the clinic
+      // - Procedure is available at the clinic
+      // - Patient is eligible for the procedure
+      // These validations will be handled in the service layer
+      return true;
+    },
+    {
+      message: "Invalid appointment parameters",
+    }
+  );
+
+/**
+ * Validation schema for updating an appointment
+ */
+export const updateAppointmentSchema = z.object({
+  appointmentId: z.string().min(1, "Appointment ID is required"),
+  clinicId: z.string().min(1, "Clinic ID is required"),
+  doctorId: z.string().min(1, "Doctor ID is required"),
+  patientId: z.string().min(1, "Patient ID is required"),
+  eventTime: calendarEventTimeSchema.optional(),
+  description: z.string().optional(),
+  status: z.nativeEnum(CalendarEventStatus).optional(),
+});
+
+/**
+ * Validation schema for creating a calendar event
+ */
+export const createCalendarEventSchema = z.object({
+  id: z.string(),
+  clinicBranchId: z.string().nullable().optional(),
+  clinicBranchInfo: z.any().nullable().optional(),
+  practitionerProfileId: z.string().nullable().optional(),
+  practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
+  patientProfileId: z.string().nullable().optional(),
+  patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
+  procedureId: z.string().nullable().optional(),
+  appointmentId: z.string().nullable().optional(),
+  syncedCalendarEventId: z
+    .array(syncedCalendarEventSchema)
+    .nullable()
+    .optional(),
+  eventName: z.string().min(1, "Event name is required"),
+  eventLocation: clinicLocationSchema.optional(),
+  eventTime: calendarEventTimeSchema,
+  description: z.string().optional(),
+  status: z.nativeEnum(CalendarEventStatus),
+  syncStatus: z.nativeEnum(CalendarSyncStatus),
+  eventType: z.nativeEnum(CalendarEventType),
+  createdAt: z.any(), // FieldValue for server timestamp
+  updatedAt: z.any(), // FieldValue for server timestamp
+});
+
+/**
+ * Validation schema for updating a calendar event
+ */
+export const updateCalendarEventSchema = z.object({
+  syncedCalendarEventId: z
+    .array(syncedCalendarEventSchema)
+    .nullable()
+    .optional(),
+  appointmentId: z.string().nullable().optional(),
+  eventName: z.string().optional(),
+  eventTime: calendarEventTimeSchema.optional(),
+  description: z.string().optional(),
+  status: z.nativeEnum(CalendarEventStatus).optional(),
+  syncStatus: z.nativeEnum(CalendarSyncStatus).optional(),
+  eventType: z.nativeEnum(CalendarEventType).optional(),
+  updatedAt: z.any(), // FieldValue for server timestamp
+});
+
+/**
+ * Validation schema for calendar event
+ */
+export const calendarEventSchema = z.object({
+  id: z.string(),
+  clinicBranchId: z.string().nullable().optional(),
+  clinicBranchInfo: z.any().nullable().optional(), // Will be replaced with proper clinic info schema
+  practitionerProfileId: z.string().nullable().optional(),
+  practitionerProfileInfo: practitionerProfileInfoSchema.nullable().optional(),
+  patientProfileId: z.string().nullable().optional(),
+  patientProfileInfo: patientProfileInfoSchema.nullable().optional(),
+  procedureId: z.string().nullable().optional(),
+  procedureInfo: procedureInfoSchema.nullable().optional(),
+  procedureCategorization: procedureCategorizationSchema.nullable().optional(),
+  appointmentId: z.string().nullable().optional(),
+  syncedCalendarEventId: z
+    .array(syncedCalendarEventSchema)
+    .nullable()
+    .optional(),
+  eventName: z.string(),
+  eventLocation: clinicLocationSchema.optional(),
+  eventTime: calendarEventTimeSchema,
+  description: z.string().optional(),
+  status: z.nativeEnum(CalendarEventStatus),
+  syncStatus: z.nativeEnum(CalendarSyncStatus),
+  eventType: z.nativeEnum(CalendarEventType),
+  createdAt: z.instanceof(Date).or(z.instanceof(Timestamp)),
+  updatedAt: z.instanceof(Date).or(z.instanceof(Timestamp)),
+});

package/src/validations/clinic.schema.ts

@@ -240,7 +240,7 @@ export const clinicSchema = z.object({
   workingHours: workingHoursSchema,
   tags: z.array(z.nativeEnum(ClinicTag)),
   featuredPhotos: z.array(z.string()),
-  photos: z.array(z.string()),
+  coverPhoto: z.string().nullable(),
   photosWithTags: z
     .array(
       z.object({
@@ -316,7 +316,7 @@ export const createClinicSchema = z.object({
   contactInfo: clinicContactInfoSchema,
   workingHours: workingHoursSchema,
   tags: z.array(z.nativeEnum(ClinicTag)),
-  photos: z.array(z.string()),
+  coverPhoto: z.string().nullable(),
   photosWithTags: z
     .array(
       z.object({
@@ -403,7 +403,7 @@ export const clinicBranchSetupSchema = z.object({
   workingHours: workingHoursSchema,
   tags: z.array(z.nativeEnum(ClinicTag)),
   logo: z.string().optional(),
-  photos: z.array(z.string()),
+  coverPhoto: z.string().nullable(),
   photosWithTags: z
     .array(
       z.object({

package/src/validations/practitioner.schema.ts

@@ -60,6 +60,25 @@ export const practitionerWorkingHoursSchema = z.object({
   updatedAt: z.instanceof(Timestamp),
 });
 
+/**
+ * Šema za validaciju radnog vremena u klinici
+ */
+export const practitionerClinicWorkingHoursSchema = z.object({
+  clinicId: z.string().min(1),
+  workingHours: z.object({
+    monday: timeSlotSchema,
+    tuesday: timeSlotSchema,
+    wednesday: timeSlotSchema,
+    thursday: timeSlotSchema,
+    friday: timeSlotSchema,
+    saturday: timeSlotSchema,
+    sunday: timeSlotSchema,
+  }),
+  isActive: z.boolean(),
+  createdAt: z.instanceof(Timestamp),
+  updatedAt: z.instanceof(Timestamp),
+});
+
 /**
  * Šema za validaciju recenzije zdravstvenog radnika
  */
@@ -96,6 +115,7 @@ export const practitionerSchema = z.object({
   basicInfo: practitionerBasicInfoSchema,
   certification: practitionerCertificationSchema,
   clinics: z.array(z.string()),
+  clinicWorkingHours: z.array(practitionerClinicWorkingHoursSchema),
   isActive: z.boolean(),
   isVerified: z.boolean(),
   createdAt: z.instanceof(Timestamp),
@@ -110,6 +130,7 @@ export const createPractitionerSchema = z.object({
   basicInfo: practitionerBasicInfoSchema,
   certification: practitionerCertificationSchema,
   clinics: z.array(z.string()).optional(),
+  clinicWorkingHours: z.array(practitionerClinicWorkingHoursSchema).optional(),
   isActive: z.boolean(),
   isVerified: z.boolean(),
 });