@blackcode_sa/metaestetics-api 1.5.28 → 1.5.29

package/src/validations/practitioner.schema.ts

@@ -8,6 +8,13 @@ import {
   PractitionerStatus,
   PractitionerTokenStatus,
 } from "../types/practitioner";
+import { practitionerReviewInfoSchema } from "./reviews.schema";
+import { clinicInfoSchema } from "./clinic.schema";
+import { ProcedureFamily } from "../backoffice/types/static/procedure-family.types";
+import {
+  Currency,
+  PricingMeasure,
+} from "../backoffice/types/static/pricing.types";
 
 /**
  * Šema za validaciju osnovnih informacija o zdravstvenom radniku
@@ -18,7 +25,7 @@ export const practitionerBasicInfoSchema = z.object({
   title: z.string().min(2).max(100),
   email: z.string().email(),
   phoneNumber: z.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number"),
-  dateOfBirth: z.instanceof(Timestamp),
+  dateOfBirth: z.instanceof(Timestamp).or(z.date()),
   gender: z.enum(["male", "female", "other"]),
   profileImageUrl: z.string().url().optional(),
   bio: z.string().max(1000).optional(),
@@ -33,8 +40,8 @@ export const practitionerCertificationSchema = z.object({
   specialties: z.array(z.nativeEnum(CertificationSpecialty)),
   licenseNumber: z.string().min(3).max(50),
   issuingAuthority: z.string().min(2).max(100),
-  issueDate: z.instanceof(Timestamp),
-  expiryDate: z.instanceof(Timestamp).optional(),
+  issueDate: z.instanceof(Timestamp).or(z.date()),
+  expiryDate: z.instanceof(Timestamp).or(z.date()).optional(),
   verificationStatus: z.enum(["pending", "verified", "rejected"]),
 });
 
@@ -60,8 +67,8 @@ export const practitionerWorkingHoursSchema = z.object({
   friday: timeSlotSchema,
   saturday: timeSlotSchema,
   sunday: timeSlotSchema,
-  createdAt: z.instanceof(Timestamp),
-  updatedAt: z.instanceof(Timestamp),
+  createdAt: z.instanceof(Timestamp).or(z.date()),
+  updatedAt: z.instanceof(Timestamp).or(z.date()),
 });
 
 /**
@@ -79,35 +86,30 @@ export const practitionerClinicWorkingHoursSchema = z.object({
     sunday: timeSlotSchema,
   }),
   isActive: z.boolean(),
-  createdAt: z.instanceof(Timestamp),
-  updatedAt: z.instanceof(Timestamp),
+  createdAt: z.instanceof(Timestamp).or(z.date()),
+  updatedAt: z.instanceof(Timestamp).or(z.date()),
 });
 
 /**
- * Šema za validaciju recenzije zdravstvenog radnika
+ * Schema matching ProcedureSummaryInfo interface
  */
-export const practitionerReviewSchema = z.object({
+export const procedureSummaryInfoSchema = z.object({
   id: z.string().min(1),
-  practitionerId: z.string().min(1),
-  patientId: z.string().min(1),
+  name: z.string().min(1),
+  description: z.string().optional(),
+  photo: z.string().optional(),
+  family: z.nativeEnum(ProcedureFamily),
+  categoryName: z.string(),
+  subcategoryName: z.string(),
+  technologyName: z.string(),
+  price: z.number().nonnegative(),
+  pricingMeasure: z.nativeEnum(PricingMeasure),
+  currency: z.nativeEnum(Currency),
+  duration: z.number().int().positive(),
   clinicId: z.string().min(1),
-  rating: z.number().min(1).max(5),
-  comment: z.string().max(1000),
-  createdAt: z.instanceof(Timestamp),
-  updatedAt: z.instanceof(Timestamp),
-  isVerified: z.boolean(),
-});
-
-/**
- * Šema za validaciju procedura koje zdravstveni radnik izvodi u klinici
- */
-export const practitionerClinicProceduresSchema = z.object({
+  clinicName: z.string().min(1),
   practitionerId: z.string().min(1),
-  clinicId: z.string().min(1),
-  procedures: z.array(z.string()).min(1),
-  isActive: z.boolean(),
-  createdAt: z.instanceof(Timestamp),
-  updatedAt: z.instanceof(Timestamp),
+  practitionerName: z.string().min(1),
 });
 
 /**
@@ -120,11 +122,15 @@ export const practitionerSchema = z.object({
   certification: practitionerCertificationSchema,
   clinics: z.array(z.string()),
   clinicWorkingHours: z.array(practitionerClinicWorkingHoursSchema),
+  clinicsInfo: z.array(clinicInfoSchema),
+  procedures: z.array(z.string()),
+  proceduresInfo: z.array(procedureSummaryInfoSchema),
+  reviewInfo: practitionerReviewInfoSchema,
   isActive: z.boolean(),
   isVerified: z.boolean(),
   status: z.nativeEnum(PractitionerStatus),
-  createdAt: z.instanceof(Timestamp),
-  updatedAt: z.instanceof(Timestamp),
+  createdAt: z.instanceof(Timestamp).or(z.date()),
+  updatedAt: z.instanceof(Timestamp).or(z.date()),
 });
 
 /**
@@ -136,6 +142,8 @@ export const createPractitionerSchema = z.object({
   certification: practitionerCertificationSchema,
   clinics: z.array(z.string()).optional(),
   clinicWorkingHours: z.array(practitionerClinicWorkingHoursSchema).optional(),
+  clinicsInfo: z.array(clinicInfoSchema).optional(),
+  proceduresInfo: z.array(procedureSummaryInfoSchema).optional(),
   isActive: z.boolean(),
   isVerified: z.boolean(),
   status: z.nativeEnum(PractitionerStatus).optional(),
@@ -149,6 +157,8 @@ export const createDraftPractitionerSchema = z.object({
   certification: practitionerCertificationSchema,
   clinics: z.array(z.string()).optional(),
   clinicWorkingHours: z.array(practitionerClinicWorkingHoursSchema).optional(),
+  clinicsInfo: z.array(clinicInfoSchema).optional(),
+  proceduresInfo: z.array(procedureSummaryInfoSchema).optional(),
   isActive: z.boolean().optional().default(false),
   isVerified: z.boolean().optional().default(false),
 });
@@ -164,10 +174,10 @@ export const practitionerTokenSchema = z.object({
   clinicId: z.string().min(1),
   status: z.nativeEnum(PractitionerTokenStatus),
   createdBy: z.string().min(1),
-  createdAt: z.instanceof(Timestamp),
-  expiresAt: z.instanceof(Timestamp),
+  createdAt: z.instanceof(Timestamp).or(z.date()),
+  expiresAt: z.instanceof(Timestamp).or(z.date()),
   usedBy: z.string().optional(),
-  usedAt: z.instanceof(Timestamp).optional(),
+  usedAt: z.instanceof(Timestamp).or(z.date()).optional(),
 });
 
 /**

package/src/validations/procedure.schema.ts

@@ -5,6 +5,7 @@ import {
   PricingMeasure,
 } from "../backoffice/types/static/pricing.types";
 import { clinicInfoSchema, doctorInfoSchema } from "./clinic.schema";
+import { procedureReviewInfoSchema } from "./reviews.schema";
 
 /**
  * Schema for creating a new procedure
@@ -29,13 +30,19 @@ export const createProcedureSchema = z.object({
  * Schema for updating an existing procedure
  */
 export const updateProcedureSchema = z.object({
-  name: z.string().min(1).max(200).optional(),
-  description: z.string().min(1).max(2000).optional(),
+  name: z.string().min(3).max(100).optional(),
+  description: z.string().min(3).max(1000).optional(),
   price: z.number().min(0).optional(),
   currency: z.nativeEnum(Currency).optional(),
   pricingMeasure: z.nativeEnum(PricingMeasure).optional(),
-  duration: z.number().min(1).max(480).optional(), // Max 8 hours
+  duration: z.number().min(0).optional(),
   isActive: z.boolean().optional(),
+  practitionerId: z.string().optional(),
+  categoryId: z.string().optional(),
+  subcategoryId: z.string().optional(),
+  technologyId: z.string().optional(),
+  productId: z.string().optional(),
+  clinicBranchId: z.string().optional(),
 });
 
 /**
@@ -55,6 +62,7 @@ export const procedureSchema = createProcedureSchema.extend({
   documentationTemplates: z.array(z.any()), // We'll validate documentation templates separately
   clinicInfo: clinicInfoSchema, // Clinic info validation
   doctorInfo: doctorInfoSchema, // Doctor info validation
+  reviewInfo: procedureReviewInfoSchema, // Procedure review info validation
   isActive: z.boolean(),
   createdAt: z.date(),
   updatedAt: z.date(),

package/src/validations/reviews.schema.ts

@@ -0,0 +1,189 @@
+import { z } from "zod";
+
+/**
+ * Base review schema with common properties
+ */
+const baseReviewSchema = z.object({
+  id: z.string().min(1),
+  patientId: z.string().min(1),
+  fullReviewId: z.string().min(1),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  comment: z.string().min(1).max(2000),
+  isVerified: z.boolean(),
+  isPublished: z.boolean(),
+});
+
+/**
+ * Base review creation schema
+ */
+const baseReviewCreateSchema = z.object({
+  patientId: z.string().min(1),
+  comment: z.string().min(1).max(2000),
+  isVerified: z.boolean().default(false),
+  isPublished: z.boolean().default(true),
+});
+
+/**
+ * Clinic review schema
+ */
+export const clinicReviewSchema = baseReviewSchema.extend({
+  clinicId: z.string().min(1),
+  cleanliness: z.number().min(1).max(5),
+  facilities: z.number().min(1).max(5),
+  staffFriendliness: z.number().min(1).max(5),
+  waitingTime: z.number().min(1).max(5),
+  accessibility: z.number().min(1).max(5),
+  overallRating: z.number().min(1).max(5),
+  wouldRecommend: z.boolean(),
+});
+
+/**
+ * Clinic review creation schema
+ */
+export const createClinicReviewSchema = baseReviewCreateSchema.extend({
+  clinicId: z.string().min(1),
+  cleanliness: z.number().min(1).max(5),
+  facilities: z.number().min(1).max(5),
+  staffFriendliness: z.number().min(1).max(5),
+  waitingTime: z.number().min(1).max(5),
+  accessibility: z.number().min(1).max(5),
+  wouldRecommend: z.boolean(),
+});
+
+/**
+ * Practitioner review schema
+ */
+export const practitionerReviewSchema = baseReviewSchema.extend({
+  practitionerId: z.string().min(1),
+  knowledgeAndExpertise: z.number().min(1).max(5),
+  communicationSkills: z.number().min(1).max(5),
+  bedSideManner: z.number().min(1).max(5),
+  thoroughness: z.number().min(1).max(5),
+  trustworthiness: z.number().min(1).max(5),
+  overallRating: z.number().min(1).max(5),
+  wouldRecommend: z.boolean(),
+});
+
+/**
+ * Practitioner review creation schema
+ */
+export const createPractitionerReviewSchema = baseReviewCreateSchema.extend({
+  practitionerId: z.string().min(1),
+  knowledgeAndExpertise: z.number().min(1).max(5),
+  communicationSkills: z.number().min(1).max(5),
+  bedSideManner: z.number().min(1).max(5),
+  thoroughness: z.number().min(1).max(5),
+  trustworthiness: z.number().min(1).max(5),
+  wouldRecommend: z.boolean(),
+});
+
+/**
+ * Procedure review schema
+ */
+export const procedureReviewSchema = baseReviewSchema.extend({
+  procedureId: z.string().min(1),
+  effectivenessOfTreatment: z.number().min(1).max(5),
+  outcomeExplanation: z.number().min(1).max(5),
+  painManagement: z.number().min(1).max(5),
+  followUpCare: z.number().min(1).max(5),
+  valueForMoney: z.number().min(1).max(5),
+  overallRating: z.number().min(1).max(5),
+  wouldRecommend: z.boolean(),
+});
+
+/**
+ * Procedure review creation schema
+ */
+export const createProcedureReviewSchema = baseReviewCreateSchema.extend({
+  procedureId: z.string().min(1),
+  effectivenessOfTreatment: z.number().min(1).max(5),
+  outcomeExplanation: z.number().min(1).max(5),
+  painManagement: z.number().min(1).max(5),
+  followUpCare: z.number().min(1).max(5),
+  valueForMoney: z.number().min(1).max(5),
+  wouldRecommend: z.boolean(),
+});
+
+/**
+ * Review info (condensed) schema for clinic
+ */
+export const clinicReviewInfoSchema = z.object({
+  totalReviews: z.number().min(0),
+  averageRating: z.number().min(0).max(5),
+  cleanliness: z.number().min(0).max(5),
+  facilities: z.number().min(0).max(5),
+  staffFriendliness: z.number().min(0).max(5),
+  waitingTime: z.number().min(0).max(5),
+  accessibility: z.number().min(0).max(5),
+  recommendationPercentage: z.number().min(0).max(100),
+});
+
+/**
+ * Review info (condensed) schema for practitioner
+ */
+export const practitionerReviewInfoSchema = z.object({
+  totalReviews: z.number().min(0),
+  averageRating: z.number().min(0).max(5),
+  knowledgeAndExpertise: z.number().min(0).max(5),
+  communicationSkills: z.number().min(0).max(5),
+  bedSideManner: z.number().min(0).max(5),
+  thoroughness: z.number().min(0).max(5),
+  trustworthiness: z.number().min(0).max(5),
+  recommendationPercentage: z.number().min(0).max(100),
+});
+
+/**
+ * Review info (condensed) schema for procedure
+ */
+export const procedureReviewInfoSchema = z.object({
+  totalReviews: z.number().min(0),
+  averageRating: z.number().min(0).max(5),
+  effectivenessOfTreatment: z.number().min(0).max(5),
+  outcomeExplanation: z.number().min(0).max(5),
+  painManagement: z.number().min(0).max(5),
+  followUpCare: z.number().min(0).max(5),
+  valueForMoney: z.number().min(0).max(5),
+  recommendationPercentage: z.number().min(0).max(100),
+});
+
+/**
+ * Combined review schema
+ */
+export const reviewSchema = z.object({
+  id: z.string().min(1),
+  appointmentId: z.string().min(1),
+  patientId: z.string().min(1),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  clinicReview: clinicReviewSchema.optional(),
+  practitionerReview: practitionerReviewSchema.optional(),
+  procedureReview: procedureReviewSchema.optional(),
+  overallComment: z.string().min(1).max(2000),
+  overallRating: z.number().min(1).max(5),
+});
+
+/**
+ * Combined review creation schema
+ */
+export const createReviewSchema = z
+  .object({
+    patientId: z.string().min(1),
+    clinicReview: createClinicReviewSchema.optional(),
+    practitionerReview: createPractitionerReviewSchema.optional(),
+    procedureReview: createProcedureReviewSchema.optional(),
+    overallComment: z.string().min(1).max(2000),
+  })
+  .refine(
+    (data) => {
+      // Ensure at least one review type is provided
+      return (
+        data.clinicReview || data.practitionerReview || data.procedureReview
+      );
+    },
+    {
+      message:
+        "At least one review type (clinic, practitioner, or procedure) must be provided",
+      path: ["reviewType"],
+    }
+  );

package/src/services/clinic/utils/review.utils.ts

@@ -1,93 +0,0 @@
-import {
-  collection,
-  doc,
-  setDoc,
-  Timestamp,
-  Firestore,
-  getDoc,
-  addDoc,
-} from "firebase/firestore";
-import { Clinic, ClinicReview } from "../../../types/clinic";
-import { clinicReviewSchema } from "../../../validations/clinic.schema";
-import { getClinic, updateClinic } from "./clinic.utils";
-import { FirebaseApp } from "firebase/app";
-
-/**
- * Adds a review to a clinic
- * @param db - Firestore database instance
- * @param clinicId - ID of the clinic to add the review to
- * @param review - Review data
- * @param app - Firebase app instance
- * @returns The created review
- */
-export async function addReview(
-  db: Firestore,
-  clinicId: string,
-  review: Omit<
-    ClinicReview,
-    "id" | "clinicId" | "createdAt" | "updatedAt" | "isVerified"
-  >,
-  app: FirebaseApp
-): Promise<ClinicReview> {
-  // Proveravamo da li klinika postoji
-  const clinicRef = doc(db, "clinics", clinicId);
-  const clinicSnap = await getDoc(clinicRef);
-
-  if (!clinicSnap.exists()) {
-    throw new Error("Clinic not found");
-  }
-
-  const clinic = clinicSnap.data();
-
-  // Kreiramo recenziju
-  const now = Timestamp.now();
-  const reviewData: ClinicReview = {
-    ...review,
-    id: doc(collection(db, "clinic_reviews")).id,
-    clinicId,
-    createdAt: now,
-    updatedAt: now,
-    isVerified: false,
-  };
-
-  // Validacija
-  clinicReviewSchema.parse(reviewData);
-
-  // Čuvamo recenziju
-  await addDoc(collection(db, "clinic_reviews"), reviewData);
-
-  // Ažuriramo prosečnu ocenu klinike
-  const newRating = clinic.rating
-    ? {
-        average:
-          (clinic.rating.average * clinic.rating.count + review.rating) /
-          (clinic.rating.count + 1),
-        count: clinic.rating.count + 1,
-      }
-    : { average: review.rating, count: 1 };
-
-  await updateClinic(
-    db,
-    clinicId,
-    {
-      rating: newRating,
-      reviews: [...clinic.reviews, reviewData.id],
-      // Add the review info to reviewsInfo array
-      reviewsInfo: [
-        ...clinic.reviewsInfo,
-        {
-          id: reviewData.id,
-          patientId: reviewData.patientId,
-          rating: reviewData.rating,
-          comment: reviewData.comment,
-          createdAt: reviewData.createdAt,
-        },
-      ],
-    },
-    "system", // System update, no admin ID needed
-    null, // No clinic admin service needed for system updates
-    app
-  );
-
-  return reviewData;
-}