@blackcode_sa/metaestetics-api 1.14.78 → 1.15.2

package/src/services/clinic/__tests__/clinic-group.service.test.ts

@@ -9,7 +9,6 @@ import {
   query,
   where,
   updateDoc,
-  deleteDoc,
   setDoc,
 } from "firebase/firestore";
 
@@ -48,7 +47,12 @@ describe("ClinicGroupService", () => {
       analytics: null,
     });
 
-    clinicGroupService = new ClinicGroupService();
+    clinicGroupService = new ClinicGroupService(
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any
+    );
 
     // Mock Firestore functions
     (doc as jest.Mock).mockReturnValue("doc-ref");
@@ -57,8 +61,6 @@ describe("ClinicGroupService", () => {
     (where as jest.Mock).mockReturnValue("where-clause");
     (setDoc as jest.Mock).mockResolvedValue(undefined);
     (updateDoc as jest.Mock).mockResolvedValue(undefined);
-    (deleteDoc as jest.Mock).mockResolvedValue(undefined);
-
     // Mock getDoc response
     (getDoc as jest.Mock).mockResolvedValue({
       exists: () => true,
@@ -92,13 +94,24 @@ describe("ClinicGroupService", () => {
         name: "New Clinic Group",
         description: "New Description",
         logo: "new-logo-url",
-        website: "https://new.com",
+        hqLocation: {
+          address: "New Address",
+          city: "New City",
+          country: "New Country",
+          postalCode: "12345",
+          latitude: 45.0,
+          longitude: 20.0,
+        },
         contactInfo: {
           email: "contact@new.com",
-          phone: "+0987654321",
-          address: "New Address",
+          phoneNumber: "+0987654321",
+        },
+        contactPerson: {
+          firstName: "John",
+          lastName: "Doe",
+          email: "john@new.com",
         },
-        clinics: [],
+        ownerId: null,
         isActive: true,
       };
 
@@ -148,30 +161,6 @@ describe("ClinicGroupService", () => {
     });
   });
 
-  describe("getClinicGroupsByOwner", () => {
-    it("treba da vrati kliničke grupe po vlasniku", async () => {
-      const result = await clinicGroupService.getClinicGroupsByOwner(
-        mockClinicGroup.ownerId
-      );
-
-      expect(collection).toHaveBeenCalled();
-      expect(query).toHaveBeenCalled();
-      expect(where).toHaveBeenCalledWith(
-        "ownerId",
-        "==",
-        mockClinicGroup.ownerId
-      );
-      expect(result).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            id: mockClinicGroup.id,
-            ownerId: mockClinicGroup.ownerId,
-          }),
-        ])
-      );
-    });
-  });
-
   describe("updateClinicGroup", () => {
     it("treba da ažurira kliničku grupu", async () => {
       const updates = {
@@ -205,74 +194,6 @@ describe("ClinicGroupService", () => {
     });
   });
 
-  describe("deleteClinicGroup", () => {
-    it("treba da obriše kliničku grupu", async () => {
-      await clinicGroupService.deleteClinicGroup(mockClinicGroup.id);
-
-      expect(deleteDoc).toHaveBeenCalledWith("doc-ref");
-    });
-
-    it("treba da baci grešku ako grupa ne postoji", async () => {
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => false,
-      });
-
-      await expect(
-        clinicGroupService.deleteClinicGroup("non-existent")
-      ).rejects.toThrow();
-    });
-  });
-
-  describe("addClinicToGroup", () => {
-    it("treba da doda kliniku u grupu", async () => {
-      const clinicId = "new-clinic-id";
-      const result = await clinicGroupService.addClinicToGroup(
-        mockClinicGroup.id,
-        clinicId
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result.clinics).toContain(clinicId);
-    });
-  });
-
-  describe("removeClinicFromGroup", () => {
-    it("treba da ukloni kliniku iz grupe", async () => {
-      const clinicId = mockClinicGroup.clinics[0];
-      const result = await clinicGroupService.removeClinicFromGroup(
-        mockClinicGroup.id,
-        clinicId
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result.clinics).not.toContain(clinicId);
-    });
-  });
-
-  describe("getClinicGroupByAdmin", () => {
-    it("treba da vrati kliničke grupe po admin ID-u", async () => {
-      const result = await clinicGroupService.getClinicGroupByAdmin(
-        mockClinicGroup.ownerId
-      );
-
-      expect(collection).toHaveBeenCalled();
-      expect(query).toHaveBeenCalled();
-      expect(where).toHaveBeenCalledWith(
-        "admins",
-        "array-contains",
-        mockClinicGroup.ownerId
-      );
-      expect(result).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            id: mockClinicGroup.id,
-            ownerId: mockClinicGroup.ownerId,
-          }),
-        ])
-      );
-    });
-  });
-
   describe("deactivateClinicGroup", () => {
     it("treba da deaktivira kliničku grupu", async () => {
       await clinicGroupService.deactivateClinicGroup(mockClinicGroup.id);
@@ -298,55 +219,4 @@ describe("ClinicGroupService", () => {
     });
   });
 
-  describe("addClinic", () => {
-    it("treba da doda kliniku u grupu", async () => {
-      const clinicId = "new-clinic-id";
-      const result = await clinicGroupService.addClinic(
-        mockClinicGroup.id,
-        clinicId
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result.clinics).toContain(clinicId);
-    });
-  });
-
-  describe("removeClinic", () => {
-    it("treba da ukloni kliniku iz grupe", async () => {
-      const clinicId = mockClinicGroup.clinics[0];
-      const result = await clinicGroupService.removeClinic(
-        mockClinicGroup.id,
-        clinicId
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result.clinics).not.toContain(clinicId);
-    });
-  });
-
-  describe("addAdmin", () => {
-    it("treba da doda admina u grupu", async () => {
-      const adminId = "new-admin-id";
-      const result = await clinicGroupService.addAdmin(
-        mockClinicGroup.id,
-        adminId
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result.admins).toContain(adminId);
-    });
-  });
-
-  describe("removeAdmin", () => {
-    it("treba da ukloni admina iz grupe", async () => {
-      const adminId = "admin-to-remove";
-      const result = await clinicGroupService.removeAdmin(
-        mockClinicGroup.id,
-        adminId
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result.admins).not.toContain(adminId);
-    });
-  });
 });

package/src/services/clinic/__tests__/clinic.service.test.ts

@@ -50,7 +50,7 @@ describe("ClinicService", () => {
       saturday: null,
       sunday: null,
     },
-    tags: [ClinicTag.PARKING, ClinicTag.WHEELCHAIR_ACCESS],
+    tags: [ClinicTag.PARKING, ClinicTag.WIFI],
     customTags: ["special-service"],
     isActive: true,
     createdAt: mockTimestamp.now().toDate(),
@@ -67,7 +67,14 @@ describe("ClinicService", () => {
       analytics: null,
     });
 
-    clinicService = new ClinicService();
+    clinicService = new ClinicService(
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any
+    );
 
     // Mock Firestore functions
     (doc as jest.Mock).mockReturnValue("doc-ref");
@@ -107,14 +114,14 @@ describe("ClinicService", () => {
 
   describe("createClinic", () => {
     it("treba da kreira novu kliniku", async () => {
-      const clinicData = {
+      const clinicData: any = {
         name: "New Clinic",
         description: "New Description",
         logo: "new-logo-url",
-        groupId: "new-group-id",
+        clinicGroupId: "new-group-id",
         contactInfo: {
           email: "new@clinic.test",
-          phoneNumbers: ["+0987654321"],
+          phoneNumber: "+0987654321",
           website: "https://new.clinic",
         },
         location: {
@@ -136,7 +143,7 @@ describe("ClinicService", () => {
           sunday: null,
         },
         tags: [ClinicTag.PARKING],
-        customTags: [],
+        admins: ["test-admin-id"],
         isActive: true,
       };
 
@@ -260,40 +267,14 @@ describe("ClinicService", () => {
     });
   });
 
-  describe("searchClinics", () => {
-    it("treba da pronađe klinike po tagovima", async () => {
-      const searchParams = {
-        tags: [ClinicTag.PARKING],
-        isActive: true,
-      };
-      const result = await clinicService.searchClinics(searchParams);
-
-      expect(collection).toHaveBeenCalled();
-      expect(query).toHaveBeenCalled();
-      expect(where).toHaveBeenCalledWith(
-        "tags",
-        "array-contains-any",
-        searchParams.tags
-      );
-      expect(result).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            id: mockClinic.id,
-            tags: expect.arrayContaining(searchParams.tags),
-          }),
-        ])
-      );
-    });
-  });
-
   describe("addTags", () => {
     it("treba da doda tagove klinici", async () => {
       const newTags = [ClinicTag.WIFI];
       const adminId = "test-admin-id";
       const result = await clinicService.addTags(
         mockClinic.id,
-        newTags,
-        adminId
+        adminId,
+        { tags: newTags }
       );
 
       expect(updateDoc).toHaveBeenCalled();
@@ -309,8 +290,8 @@ describe("ClinicService", () => {
       const adminId = "test-admin-id";
       const result = await clinicService.removeTags(
         mockClinic.id,
-        tagsToRemove,
-        adminId
+        adminId,
+        { tags: tagsToRemove }
       );
 
       expect(updateDoc).toHaveBeenCalled();
@@ -318,37 +299,4 @@ describe("ClinicService", () => {
     });
   });
 
-  describe("addCustomTags", () => {
-    it("treba da doda custom tagove klinici", async () => {
-      const newCustomTags = ["new-service"];
-      const adminId = "test-admin-id";
-      const result = await clinicService.addCustomTags(
-        mockClinic.id,
-        newCustomTags,
-        adminId
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result.customTags).toEqual(
-        expect.arrayContaining([...mockClinic.customTags, ...newCustomTags])
-      );
-    });
-  });
-
-  describe("removeCustomTags", () => {
-    it("treba da ukloni custom tagove iz klinike", async () => {
-      const customTagsToRemove = [mockClinic.customTags[0]];
-      const adminId = "test-admin-id";
-      const result = await clinicService.removeCustomTags(
-        mockClinic.id,
-        customTagsToRemove,
-        adminId
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result.customTags).not.toEqual(
-        expect.arrayContaining(customTagsToRemove)
-      );
-    });
-  });
 });

package/src/services/clinic/utils/clinic-group.utils.ts

@@ -74,7 +74,7 @@ export async function createClinicGroup(
   let validatedData: CreateClinicGroupData;
   // Validacija podataka
   try {
-    validatedData = createClinicGroupSchema.parse(data);
+    validatedData = createClinicGroupSchema.parse(data) as CreateClinicGroupData;
     console.log("[CLINIC_GROUP] Data validation passed");
   } catch (validationError) {
     console.error("[CLINIC_GROUP] Data validation failed:", validationError);
@@ -138,7 +138,7 @@ export async function createClinicGroup(
 
   // Handle logo upload if provided
   let logoUrl = await uploadPhoto(
-    validatedData.logo || null,
+    (validatedData.logo as string) || null,
     "clinic-groups",
     groupId,
     "logo",

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

@@ -145,7 +145,7 @@ export async function createClinic(
     console.log("[CLINIC] Processing logo");
     try {
       logoUrl = await uploadPhoto(
-        validatedData.logo,
+        validatedData.logo as string,
         "clinics",
         clinicId,
         "logo",
@@ -164,7 +164,7 @@ export async function createClinic(
     console.log("[CLINIC] Processing cover photo");
     try {
       processedCoverPhoto = await uploadPhoto(
-        validatedData.coverPhoto,
+        validatedData.coverPhoto as string,
         "clinics",
         clinicId,
         "cover",
@@ -176,19 +176,21 @@ export async function createClinic(
     } catch (coverPhotoError) {
       console.error("[CLINIC] Error processing cover photo:", coverPhotoError);
       // Continue with clinic creation even if cover photo upload fails
-      processedCoverPhoto = validatedData.coverPhoto.startsWith("data:")
+      const coverPhotoStr = validatedData.coverPhoto as string;
+      processedCoverPhoto = coverPhotoStr.startsWith("data:")
         ? null
-        : validatedData.coverPhoto;
+        : coverPhotoStr;
     }
   }
 
   // Handle featured photos upload
   let processedFeaturedPhotos: string[] = [];
-  if (validatedData.featuredPhotos && validatedData.featuredPhotos.length > 0) {
+  const featuredPhotosStr = (validatedData.featuredPhotos || []) as string[];
+  if (featuredPhotosStr.length > 0) {
     console.log("[CLINIC] Processing featured photos");
     try {
       processedFeaturedPhotos = await uploadMultiplePhotos(
-        validatedData.featuredPhotos,
+        featuredPhotosStr,
         "clinics",
         clinicId,
         "featured",
@@ -203,22 +205,23 @@ export async function createClinic(
         featuredError
       );
       // Continue with clinic creation even if featured photos upload fails
-      processedFeaturedPhotos = validatedData.featuredPhotos.filter(
+      processedFeaturedPhotos = featuredPhotosStr.filter(
         (photo) => !photo.startsWith("data:")
       );
     }
   }
 
   // Handle photos with tags
-  let processedPhotosWithTags = validatedData.photosWithTags || [];
+  let processedPhotosWithTags: any[] = validatedData.photosWithTags || [];
   if (processedPhotosWithTags.length > 0) {
     console.log("[CLINIC] Processing photos with tags");
     try {
-      const updatedPhotosWithTags = [];
+      const updatedPhotosWithTags: any[] = [];
       for (const photoWithTag of processedPhotosWithTags) {
-        if (photoWithTag.url && photoWithTag.url.startsWith("data:")) {
+        const photoUrl = photoWithTag.url as string;
+        if (photoUrl && photoUrl.startsWith("data:")) {
           const uploadedUrl = await uploadPhoto(
-            photoWithTag.url,
+            photoUrl,
             "clinics",
             clinicId,
             `tagged-${photoWithTag.tag}`,
@@ -243,7 +246,7 @@ export async function createClinic(
       // Continue with clinic creation even if photos with tags upload fails
       processedPhotosWithTags =
         validatedData.photosWithTags?.filter(
-          (photo) => !photo.url.startsWith("data:")
+          (photo) => !(photo.url as string).startsWith("data:")
         ) || [];
     }
   }
@@ -254,6 +257,7 @@ export async function createClinic(
   const clinicData: Clinic = {
     ...validatedData,
     id: clinicId,
+    nameLower: (validatedData.name || "").toLowerCase(),
     description: validatedData.description || "",
     location: {
       address: validatedData.location.address || "",
@@ -617,10 +621,11 @@ export async function updateClinic(
     console.log("[CLINIC] Processing featured photos update");
     try {
       // Filter out only data URLs that need to be uploaded
-      const dataUrlPhotos = data.featuredPhotos.filter(
+      const allPhotos = data.featuredPhotos as string[];
+      const dataUrlPhotos = allPhotos.filter(
         (photo) => typeof photo === "string" && photo.startsWith("data:")
       );
-      const existingPhotos = data.featuredPhotos.filter(
+      const existingPhotos = allPhotos.filter(
         (photo) => typeof photo === "string" && !photo.startsWith("data:")
       );
 
@@ -637,10 +642,10 @@ export async function updateClinic(
         });
 
         // Combine existing photos with newly uploaded ones
-        updatedData.featuredPhotos = [...existingPhotos, ...uploadedPhotos];
+        updatedData.featuredPhotos = [...existingPhotos, ...uploadedPhotos] as any;
       } else {
         // If no new photos to upload, just use the existing ones
-        updatedData.featuredPhotos = existingPhotos;
+        updatedData.featuredPhotos = existingPhotos as any;
       }
     } catch (featuredError) {
       console.error(
@@ -648,9 +653,9 @@ export async function updateClinic(
         featuredError
       );
       // Continue with update even if featured photos upload fails
-      updatedData.featuredPhotos = data.featuredPhotos.filter(
+      updatedData.featuredPhotos = (data.featuredPhotos as string[]).filter(
         (photo) => typeof photo === "string" && !photo.startsWith("data:")
-      );
+      ) as any;
     }
   }
 
@@ -658,14 +663,15 @@ export async function updateClinic(
   if (data.photosWithTags && data.photosWithTags.length > 0) {
     console.log("[CLINIC] Processing photos with tags update");
     try {
-      const updatedPhotosWithTags = [];
+      const updatedPhotosWithTags: any[] = [];
 
       // Process each photo with tag
       for (const photoWithTag of data.photosWithTags) {
-        if (photoWithTag.url && photoWithTag.url.startsWith("data:")) {
+        const photoUrl = photoWithTag.url as string;
+        if (photoUrl && photoUrl.startsWith("data:")) {
           // Upload new photo
           const uploadedUrl = await uploadPhoto(
-            photoWithTag.url,
+            photoUrl,
             "clinics",
             clinicId,
             `tagged-${photoWithTag.tag}`,
@@ -695,7 +701,7 @@ export async function updateClinic(
       );
       // Continue with update even if photos with tags upload fails
       updatedData.photosWithTags = data.photosWithTags.filter(
-        (photo) => !photo.url.startsWith("data:")
+        (photo) => !(photo.url as string).startsWith("data:")
       );
     }
   }

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

@@ -6,6 +6,5 @@
 export * from "./clinic.utils";
 export * from "./clinic-group.utils";
 export * from "./admin.utils";
-export * from "./review.utils";
 export * from "./tag.utils";
 export * from "./search.utils";

package/src/services/notifications/__tests__/notification.service.test.ts

@@ -4,7 +4,7 @@ import {
   NotificationStatus,
   NotificationType,
   NOTIFICATIONS_COLLECTION,
-  AppointmentNotification,
+  AppointmentStatusChangeNotification,
 } from "../../../types/notifications";
 import { UserRole } from "../../../types";
 import {
@@ -37,18 +37,18 @@ jest.mock("../../../config/firebase", () => ({
 describe("NotificationService", () => {
   let service: NotificationService;
   const mockNotification: Omit<
-    AppointmentNotification,
+    AppointmentStatusChangeNotification,
     "id" | "createdAt" | "updatedAt"
   > = {
     title: "Test Notification",
     body: "Test Body",
-    notificationType: NotificationType.APPOINTMENT_NOTIFICATION,
+    notificationType: NotificationType.APPOINTMENT_STATUS_CHANGE,
     userId: "test-user-id",
     status: NotificationStatus.PENDING,
     isRead: false,
     userRole: UserRole.PATIENT,
     appointmentId: "test-appointment-id",
-    appointmentStatus: "confirmed",
+    newStatus: "confirmed",
     previousStatus: "pending",
     notificationTime: Timestamp.now(),
     notificationTokens: ["test-token"],
@@ -64,7 +64,7 @@ describe("NotificationService", () => {
 
   beforeEach(async () => {
     jest.clearAllMocks();
-    service = new NotificationService();
+    service = new NotificationService({} as any, {} as any, {} as any);
     await (service as any).initialized;
   }, 10000);
 

package/src/services/patient/__tests__/patient.service.test.ts

@@ -4,7 +4,7 @@ import {
   CreatePatientProfileData,
   PATIENTS_COLLECTION,
   Gender,
-  Location,
+  LocationData,
 } from "../../../types/patient";
 import { UserRole } from "../../../types";
 import {
@@ -44,7 +44,7 @@ jest.mock("../../../config/firebase");
 
 describe("PatientService", () => {
   let service: PatientService;
-  const mockLocation: Location = {
+  const mockLocation: LocationData = {
     latitude: 44.8125,
     longitude: 20.4612,
     geohash: "mock-geohash",
@@ -52,28 +52,26 @@ describe("PatientService", () => {
 
   const mockCreateData: CreatePatientProfileData = {
     userRef: "test-user-id",
-    firstName: "Test",
-    lastName: "Patient",
-    gender: Gender.MALE,
-    contactInfo: {
-      email: "test@example.com",
-      phoneNumber: "+381601234567",
-    },
-    location: {
-      latitude: mockLocation.latitude,
-      longitude: mockLocation.longitude,
-      geohash: mockLocation.geohash,
-    },
+    displayName: "Test Patient",
     expoTokens: [],
     isActive: true,
     isVerified: false,
+    isManual: false,
   };
 
   const mockPatientProfile: PatientProfile = {
     ...mockCreateData,
-    id: mockCreateData.userRef,
-    location: mockLocation,
+    id: mockCreateData.userRef as string,
+    displayName: "Test Patient",
     gamification: { level: 1, points: 0 },
+    expoTokens: [],
+    isActive: true,
+    isVerified: false,
+    isManual: false,
+    doctors: [],
+    clinics: [],
+    doctorIds: [],
+    clinicIds: [],
     createdAt: Timestamp.now(),
     updatedAt: Timestamp.now(),
   };
@@ -90,7 +88,7 @@ describe("PatientService", () => {
       analytics: null,
     });
 
-    service = new PatientService();
+    service = new PatientService(mockDb as any, mockAuth as any, {} as any);
 
     // Mock Firestore functions
     (doc as jest.Mock).mockReturnValue("doc-ref");
@@ -159,10 +157,6 @@ describe("PatientService", () => {
         expect.objectContaining({
           ...mockCreateData,
           id: mockCreateData.userRef,
-          location: {
-            ...mockCreateData.location,
-            geohash: "hash123",
-          },
           gamification: { level: 1, points: 0 },
         })
       );
@@ -174,8 +168,7 @@ describe("PatientService", () => {
     it("treba da vrati profil pacijenta ako postoji", async () => {
       const mockProfile = {
         id: "test-user-id",
-        firstName: "Test",
-        lastName: "User",
+        displayName: "Test User",
         createdAt: mockTimestamp.now().toDate(),
         updatedAt: mockTimestamp.now().toDate(),
       };
@@ -214,8 +207,7 @@ describe("PatientService", () => {
   describe("updatePatientProfile", () => {
     it("treba da ažurira profil pacijenta", async () => {
       const updates = {
-        firstName: "Updated",
-        lastName: "Name",
+        displayName: "Updated Name",
       };
       const mockTimestamp = new Date();
       (serverTimestamp as jest.Mock).mockReturnValue(mockTimestamp);