@blackcode_sa/metaestetics-api 1.4.18 → 1.5.0

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
  */

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/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(),
 });

package/src/validations/profile-info.schema.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { Timestamp } from "firebase/firestore";
+import { clinicLocationSchema, clinicContactInfoSchema } from "./clinic.schema";
+import { practitionerCertificationSchema } from "./practitioner.schema";
+import { Gender } from "../types/patient";
+
+/**
+ * Validation schema for clinic info
+ */
+export const clinicInfoSchema = z.object({
+  id: z.string(),
+  featuredPhoto: z.string(),
+  name: z.string(),
+  description: z.string(),
+  location: clinicLocationSchema,
+  contactInfo: clinicContactInfoSchema,
+});
+
+/**
+ * Validation schema for practitioner profile info
+ */
+export const practitionerProfileInfoSchema = z.object({
+  id: z.string(),
+  practitionerPhoto: z.string().nullable(),
+  name: z.string(),
+  email: z.string().email(),
+  phone: z.string().nullable(),
+  certification: practitionerCertificationSchema,
+});
+
+/**
+ * Validation schema for patient profile info
+ */
+export const patientProfileInfoSchema = z.object({
+  id: z.string(),
+  fullName: z.string(),
+  email: z.string().email(),
+  phone: z.string().nullable(),
+  dateOfBirth: z.instanceof(Timestamp),
+  gender: z.nativeEnum(Gender),
+});