@blackcode_sa/metaestetics-api 1.4.18 → 1.5.1

package/src/types/practitioner/index.ts

@@ -5,6 +5,7 @@ import {
 } from "../../backoffice/types/static/certification.types";
 
 export const PRACTITIONERS_COLLECTION = "practitioners";
+export const REGISTER_TOKENS_COLLECTION = "register_tokens";
 
 /**
  * Osnovne informacije o zdravstvenom radniku
@@ -35,6 +36,43 @@ 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;
+}
+
+/**
+ * Status of practitioner profile
+ */
+export enum PractitionerStatus {
+  DRAFT = "draft",
+  ACTIVE = "active",
+}
+
+/**
+ * Token status for practitioner invitations
+ */
+export enum PractitionerTokenStatus {
+  ACTIVE = "active",
+  USED = "used",
+  EXPIRED = "expired",
+  REVOKED = "revoked",
+}
+
 /**
  * Interfejs za zdravstvenog radnika
  */
@@ -44,8 +82,10 @@ 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;
+  status: PractitionerStatus;
   createdAt: Timestamp;
   updatedAt: Timestamp;
 }
@@ -58,8 +98,22 @@ export interface CreatePractitionerData {
   basicInfo: PractitionerBasicInfo;
   certification: PractitionerCertification;
   clinics?: string[];
+  clinicWorkingHours?: PractitionerClinicWorkingHours[];
   isActive: boolean;
   isVerified: boolean;
+  status?: PractitionerStatus;
+}
+
+/**
+ * Tip za kreiranje draft profila zdravstvenog radnika
+ */
+export interface CreateDraftPractitionerData {
+  basicInfo: PractitionerBasicInfo;
+  certification: PractitionerCertification;
+  clinics?: string[];
+  clinicWorkingHours?: PractitionerClinicWorkingHours[];
+  isActive?: boolean;
+  isVerified?: boolean;
 }
 
 /**
@@ -113,3 +167,30 @@ export interface PractitionerWorkingHours {
   createdAt: Timestamp;
   updatedAt: Timestamp;
 }
+
+/**
+ * Token za pozivanje zdravstvenog radnika
+ */
+export interface PractitionerToken {
+  id: string;
+  token: string;
+  practitionerId: string;
+  email: string;
+  clinicId: string;
+  status: PractitionerTokenStatus;
+  createdBy: string;
+  createdAt: Timestamp;
+  expiresAt: Timestamp;
+  usedBy?: string;
+  usedAt?: Timestamp;
+}
+
+/**
+ * Tip za kreiranje tokena za zdravstvenog radnika
+ */
+export interface CreatePractitionerTokenData {
+  practitionerId: string;
+  email: string;
+  clinicId: string;
+  expiresAt?: Date;
+}

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

@@ -4,6 +4,10 @@ import {
   CertificationLevel,
   CertificationSpecialty,
 } from "../backoffice/types/static/certification.types";
+import {
+  PractitionerStatus,
+  PractitionerTokenStatus,
+} from "../types/practitioner";
 
 /**
  * Šema za validaciju osnovnih informacija o zdravstvenom radniku
@@ -60,6 +64,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,8 +119,10 @@ export const practitionerSchema = z.object({
   basicInfo: practitionerBasicInfoSchema,
   certification: practitionerCertificationSchema,
   clinics: z.array(z.string()),
+  clinicWorkingHours: z.array(practitionerClinicWorkingHoursSchema),
   isActive: z.boolean(),
   isVerified: z.boolean(),
+  status: z.nativeEnum(PractitionerStatus),
   createdAt: z.instanceof(Timestamp),
   updatedAt: z.instanceof(Timestamp),
 });
@@ -110,6 +135,47 @@ 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(),
+  status: z.nativeEnum(PractitionerStatus).optional(),
+});
+
+/**
+ * Šema za validaciju podataka pri kreiranju draft profila zdravstvenog radnika
+ */
+export const createDraftPractitionerSchema = z.object({
+  basicInfo: practitionerBasicInfoSchema,
+  certification: practitionerCertificationSchema,
+  clinics: z.array(z.string()).optional(),
+  clinicWorkingHours: z.array(practitionerClinicWorkingHoursSchema).optional(),
+  isActive: z.boolean().optional().default(false),
+  isVerified: z.boolean().optional().default(false),
+});
+
+/**
+ * Šema za validaciju tokena za zdravstvenog radnika
+ */
+export const practitionerTokenSchema = z.object({
+  id: z.string().min(1),
+  token: z.string().min(6),
+  practitionerId: z.string().min(1),
+  email: z.string().email(),
+  clinicId: z.string().min(1),
+  status: z.nativeEnum(PractitionerTokenStatus),
+  createdBy: z.string().min(1),
+  createdAt: z.instanceof(Timestamp),
+  expiresAt: z.instanceof(Timestamp),
+  usedBy: z.string().optional(),
+  usedAt: z.instanceof(Timestamp).optional(),
+});
+
+/**
+ * Šema za validaciju podataka pri kreiranju tokena za zdravstvenog radnika
+ */
+export const createPractitionerTokenSchema = z.object({
+  practitionerId: z.string().min(1),
+  email: z.string().email(),
+  clinicId: z.string().min(1),
+  expiresAt: z.date().optional(),
 });

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