@blackcode_sa/metaestetics-api 1.14.77 → 1.14.79

package/src/services/auth/auth.v2.service.ts

@@ -424,7 +424,7 @@ export class AuthServiceV2 extends BaseService {
       >(functions, "createAnonymousPatientProfile");
 
       const result = await createAnonymousPatientProfile({});
-      return result.data.user;
+      return (result.data as any).user;
     }
   }
 
@@ -450,7 +450,7 @@ export class AuthServiceV2 extends BaseService {
       );
 
       const result = await createAnonymousPatientProfile({});
-      return result.data.user;
+      return (result.data as any).user;
     }
   }
 
@@ -468,7 +468,7 @@ export class AuthServiceV2 extends BaseService {
     );
 
     const result = await createAnonymousPatientProfile({});
-    return result.data.user;
+    return (result.data as any).user;
   }
 
   /**
@@ -545,7 +545,7 @@ export class AuthServiceV2 extends BaseService {
         },
       });
 
-      return result.data.user;
+      return (result.data as any).user;
     } catch (error) {
       if (error instanceof z.ZodError) {
         throw AUTH_ERRORS.VALIDATION_ERROR;
@@ -598,7 +598,7 @@ export class AuthServiceV2 extends BaseService {
         },
       });
 
-      return result.data.user;
+      return (result.data as any).user;
     } catch (error: unknown) {
       const firebaseError = error as FirebaseError;
       if (firebaseError.code === FirebaseErrorCode.POPUP_CLOSED_BY_USER) {
@@ -645,7 +645,7 @@ export class AuthServiceV2 extends BaseService {
         },
       });
 
-      return result.data.user;
+      return (result.data as any).user;
     } catch (error: unknown) {
       const firebaseError = error as FirebaseError;
       if (firebaseError.code === FirebaseErrorCode.POPUP_CLOSED_BY_USER) {
@@ -693,7 +693,7 @@ export class AuthServiceV2 extends BaseService {
         },
       });
 
-      return result.data.user;
+      return (result.data as any).user;
     } catch (error: unknown) {
       const firebaseError = error as FirebaseError;
       if (firebaseError.code === FirebaseErrorCode.POPUP_CLOSED_BY_USER) {

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

@@ -14,7 +14,7 @@ import {
 import {
   CreateClinicAdminData,
   ClinicAdmin,
-} from "../../../types/clinic-admin";
+} from "../../../types/clinic";
 import { CLINIC_ADMIN_ERRORS } from "../../../errors/clinic.errors";
 
 // Mock Firebase
@@ -30,6 +30,7 @@ describe("ClinicAdminService", () => {
     clinicGroupId: "test-group-id",
     isGroupOwner: false,
     clinicsManaged: ["clinic-1", "clinic-2"],
+    clinicsManagedInfo: [],
     contactInfo: {
       firstName: "John",
       lastName: "Doe",
@@ -39,8 +40,8 @@ describe("ClinicAdminService", () => {
     },
     roleTitle: "Clinic Administrator",
     isActive: true,
-    createdAt: mockTimestamp.now().toDate(),
-    updatedAt: mockTimestamp.now().toDate(),
+    createdAt: mockTimestamp.now(),
+    updatedAt: mockTimestamp.now(),
   };
 
   beforeEach(() => {
@@ -53,7 +54,11 @@ describe("ClinicAdminService", () => {
       analytics: null,
     });
 
-    clinicAdminService = new ClinicAdminService();
+    clinicAdminService = new ClinicAdminService(
+      {} as any,
+      {} as any,
+      {} as any
+    );
 
     // Mock Firestore functions
     (doc as jest.Mock).mockReturnValue("doc-ref");
@@ -218,41 +223,15 @@ describe("ClinicAdminService", () => {
     });
   });
 
-  describe("setActive", () => {
-    it("treba da aktivira/deaktivira clinic admina", async () => {
-      await clinicAdminService.setActive(mockClinicAdmin.id, false);
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(updateDoc).toHaveBeenCalledWith(
-        "doc-ref",
-        expect.objectContaining({
-          isActive: false,
-          updatedAt: expect.any(Date),
-        })
-      );
-    });
-
-    it("treba da baci grešku ako admin ne postoji", async () => {
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => false,
-      });
-
-      await expect(
-        clinicAdminService.setActive("non-existent", false)
-      ).rejects.toThrow(CLINIC_ADMIN_ERRORS.NOT_FOUND);
-    });
-  });
-
   describe("addClinicToManaged", () => {
     it("treba da doda kliniku admin-u", async () => {
       const clinicId = "new-clinic-id";
-      const result = await clinicAdminService.addClinicToManaged(
+      await clinicAdminService.addClinicToManaged(
         mockClinicAdmin.id,
         clinicId
       );
 
       expect(updateDoc).toHaveBeenCalled();
-      expect(result.clinicsManaged).toContain(clinicId);
     });
 
     it("treba da baci grešku ako klinika već postoji", async () => {
@@ -267,13 +246,12 @@ describe("ClinicAdminService", () => {
   describe("removeClinicFromManaged", () => {
     it("treba da ukloni kliniku iz admin-a", async () => {
       const clinicId = mockClinicAdmin.clinicsManaged[0];
-      const result = await clinicAdminService.removeClinicFromManaged(
+      await clinicAdminService.removeClinicFromManaged(
         mockClinicAdmin.id,
         clinicId
       );
 
       expect(updateDoc).toHaveBeenCalled();
-      expect(result.clinicsManaged).not.toContain(clinicId);
     });
 
     it("treba da baci grešku ako klinika ne postoji", async () => {

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:")
       );
     }
   }