@blackcode_sa/metaestetics-api 1.4.2 → 1.4.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.4.2",
+  "version": "1.4.4",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/services/auth.service.ts

@@ -45,6 +45,21 @@ import { FirebaseError } from "../errors/firebase.errors";
 import { BaseService } from "./base.service";
 import { UserService } from "./user.service";
 import { throws } from "assert";
+import {
+  ClinicGroup,
+  AdminToken,
+  AdminTokenStatus,
+  CreateClinicGroupData,
+  CreateClinicAdminData,
+  ContactPerson,
+  ClinicAdminSignupData,
+  SubscriptionModel,
+  CLINIC_GROUPS_COLLECTION,
+} from "../types/clinic";
+import { clinicAdminSignupSchema } from "../validations/clinic.schema";
+import { ClinicGroupService } from "./clinic/clinic-group.service";
+import { ClinicAdminService } from "./clinic/clinic-admin.service";
+import { ClinicService } from "./clinic/clinic.service";
 
 export class AuthService extends BaseService {
   private googleProvider = new GoogleAuthProvider();
@@ -84,6 +99,168 @@ export class AuthService extends BaseService {
     return this.userService.createUser(firebaseUser, [initialRole]);
   }
 
+  /**
+   * Registers a new clinic admin user with email and password
+   * Can either create a new clinic group or join an existing one with a token
+   *
+   * @param data - Clinic admin signup data
+   * @returns The created user
+   */
+  async signUpClinicAdmin(data: ClinicAdminSignupData): Promise<User> {
+    try {
+      // Validate data
+      await clinicAdminSignupSchema.parseAsync(data);
+
+      // Create Firebase user
+      const { user: firebaseUser } = await createUserWithEmailAndPassword(
+        this.auth,
+        data.email,
+        data.password
+      );
+
+      // Create user with CLINIC_ADMIN role
+      const user = await this.userService.createUser(
+        firebaseUser,
+        [UserRole.CLINIC_ADMIN],
+        {
+          skipProfileCreation: true,
+        }
+      );
+
+      // Create contact person object
+      const contactPerson: ContactPerson = {
+        firstName: data.firstName,
+        lastName: data.lastName,
+        title: data.title,
+        email: data.email,
+        phoneNumber: data.phoneNumber,
+      };
+
+      // Initialize services
+      const clinicAdminService = new ClinicAdminService(
+        this.db,
+        this.auth,
+        this.app
+      );
+      const clinicGroupService = new ClinicGroupService(
+        this.db,
+        this.auth,
+        this.app,
+        clinicAdminService
+      );
+      const clinicService = new ClinicService(
+        this.db,
+        this.auth,
+        this.app,
+        clinicGroupService,
+        clinicAdminService
+      );
+
+      // Set services to resolve circular dependencies
+      clinicAdminService.setServices(clinicGroupService, clinicService);
+
+      if (data.isCreatingNewGroup) {
+        // Create new clinic group
+        if (!data.clinicGroupData) {
+          throw new Error(
+            "Clinic group data is required when creating a new group"
+          );
+        }
+
+        // Create clinic group
+        const createClinicGroupData: CreateClinicGroupData = {
+          name: data.clinicGroupData.name,
+          hqLocation: data.clinicGroupData.hqLocation,
+          contactInfo: data.clinicGroupData.contactInfo,
+          contactPerson: contactPerson,
+          ownerId: firebaseUser.uid,
+          isActive: true,
+          logo: data.clinicGroupData.logo,
+          subscriptionModel:
+            data.clinicGroupData.subscriptionModel ||
+            SubscriptionModel.NO_SUBSCRIPTION,
+        };
+
+        // Create clinic group
+        await clinicGroupService.createClinicGroup(
+          createClinicGroupData,
+          firebaseUser.uid,
+          true
+        );
+      } else {
+        // Join existing clinic group with token
+        if (!data.inviteToken) {
+          throw new Error(
+            "Invite token is required when joining an existing group"
+          );
+        }
+
+        // Find the token in the database
+        const groupsRef = collection(this.db, CLINIC_GROUPS_COLLECTION);
+        const q = query(groupsRef);
+        const querySnapshot = await getDocs(q);
+
+        let foundGroup: ClinicGroup | null = null;
+        let foundToken: AdminToken | null = null;
+
+        for (const docSnapshot of querySnapshot.docs) {
+          const group = docSnapshot.data() as ClinicGroup;
+
+          // Find the token in the group's tokens
+          const token = group.adminTokens.find(
+            (t) =>
+              t.token === data.inviteToken &&
+              t.status === AdminTokenStatus.ACTIVE &&
+              new Date(t.expiresAt.toDate()) > new Date()
+          );
+
+          if (token) {
+            foundGroup = group;
+            foundToken = token;
+            break;
+          }
+        }
+
+        if (!foundGroup || !foundToken) {
+          throw new Error("Invalid or expired invite token");
+        }
+
+        // Create clinic admin
+        const createClinicAdminData: CreateClinicAdminData = {
+          userRef: firebaseUser.uid,
+          clinicGroupId: foundGroup.id,
+          isGroupOwner: false,
+          clinicsManaged: [],
+          contactInfo: contactPerson,
+          roleTitle: data.title,
+          isActive: true,
+        };
+
+        await clinicAdminService.createClinicAdmin(createClinicAdminData);
+
+        // Mark token as used
+        await clinicGroupService.verifyAndUseAdminToken(
+          foundGroup.id,
+          data.inviteToken,
+          firebaseUser.uid
+        );
+      }
+
+      return user;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        throw AUTH_ERRORS.VALIDATION_ERROR;
+      }
+
+      const firebaseError = error as FirebaseError;
+      if (firebaseError.code === FirebaseErrorCode.EMAIL_ALREADY_IN_USE) {
+        throw AUTH_ERRORS.EMAIL_ALREADY_EXISTS;
+      }
+
+      throw error;
+    }
+  }
+
   /**
    * Prijavljuje korisnika sa email-om i lozinkom
    */

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

@@ -10,6 +10,7 @@ import {
   deleteDoc,
   Timestamp,
   serverTimestamp,
+  FieldValue,
 } from "firebase/firestore";
 import { BaseService } from "../base.service";
 import {
@@ -19,6 +20,8 @@ import {
   AdminToken,
   AdminTokenStatus,
   CreateAdminTokenData,
+  ClinicGroupSetupData,
+  UpdateClinicGroupData,
 } from "../../types/clinic";
 import { ClinicAdminService } from "./clinic-admin.service";
 import { geohashForLocation } from "geofire-common";
@@ -107,6 +110,37 @@ export class ClinicGroupService extends BaseService {
     return ClinicGroupUtils.deactivateClinicGroup(this.db, groupId);
   }
 
+  /**
+   * Sets up additional clinic group information after initial creation
+   *
+   * @param groupId - The ID of the clinic group to set up
+   * @param setupData - The setup data for the clinic group
+   * @returns The updated clinic group
+   */
+  async setupClinicGroup(
+    groupId: string,
+    setupData: ClinicGroupSetupData
+  ): Promise<ClinicGroup> {
+    // Get the clinic group
+    const clinicGroup = await this.getClinicGroup(groupId);
+    if (!clinicGroup) {
+      throw new Error(`Clinic group with ID ${groupId} not found`);
+    }
+
+    // Update the clinic group with the setup data
+    const updateData = {
+      languages: setupData.languages,
+      practiceType: setupData.practiceType,
+      description: setupData.description,
+      logo: setupData.logo,
+      calendarSyncEnabled: setupData.calendarSyncEnabled,
+      autoConfirmAppointments: setupData.autoConfirmAppointments,
+    };
+
+    // Update the clinic group
+    return this.updateClinicGroup(groupId, updateData);
+  }
+
   /**
    * Kreira admin token za grupaciju
    */

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

@@ -12,6 +12,7 @@ import {
   serverTimestamp,
   GeoPoint,
   QueryConstraint,
+  FieldValue,
 } from "firebase/firestore";
 import { BaseService } from "../base.service";
 import {
@@ -22,6 +23,8 @@ import {
   ClinicTag,
   ClinicTags,
   ClinicGroup,
+  ClinicBranchSetupData,
+  CLINIC_ADMINS_COLLECTION,
 } from "../../types/clinic";
 import { ClinicGroupService } from "./clinic-group.service";
 import { ClinicAdminService } from "./clinic-admin.service";
@@ -43,6 +46,7 @@ import * as ClinicUtils from "./utils/clinic.utils";
 import * as ReviewUtils from "./utils/review.utils";
 import * as TagUtils from "./utils/tag.utils";
 import * as SearchUtils from "./utils/search.utils";
+import * as AdminUtils from "./utils/admin.utils";
 
 export class ClinicService extends BaseService {
   private clinicGroupService: ClinicGroupService;
@@ -219,4 +223,53 @@ export class ClinicService extends BaseService {
       this.clinicGroupService
     );
   }
+
+  /**
+   * Creates a new clinic branch for a clinic group
+   *
+   * @param clinicGroupId - The ID of the clinic group
+   * @param setupData - The setup data for the clinic branch
+   * @param adminId - The ID of the admin creating the branch
+   * @returns The created clinic
+   */
+  async createClinicBranch(
+    clinicGroupId: string,
+    setupData: ClinicBranchSetupData,
+    adminId: string
+  ): Promise<Clinic> {
+    // Validate that the clinic group exists
+    const clinicGroup = await this.clinicGroupService.getClinicGroup(
+      clinicGroupId
+    );
+    if (!clinicGroup) {
+      throw new Error(`Clinic group with ID ${clinicGroupId} not found`);
+    }
+
+    // Create the clinic data
+    const createClinicData: CreateClinicData = {
+      clinicGroupId,
+      name: setupData.name,
+      description: setupData.description,
+      location: setupData.location,
+      contactInfo: setupData.contactInfo,
+      workingHours: setupData.workingHours,
+      tags: setupData.tags,
+      photos: setupData.photos,
+      photosWithTags: setupData.photosWithTags,
+      doctors: [],
+      services: [],
+      admins: [adminId],
+      isActive: true,
+      isVerified: false,
+      logo: setupData.logo,
+      featuredPhotos: setupData.featuredPhotos || [],
+    };
+
+    // Create the clinic
+    const clinic = await this.createClinic(createClinicData, adminId);
+
+    // Note: The createClinic method already adds the clinic to the admin's managed clinics
+
+    return clinic;
+  }
 }

package/src/services/user.service.ts

@@ -86,6 +86,7 @@ export class UserService extends BaseService {
         groupToken?: string;
         groupId?: string;
       };
+      skipProfileCreation?: boolean;
     }
   ): Promise<User> {
     const userData: CreateUserData = {
@@ -142,6 +143,7 @@ export class UserService extends BaseService {
         groupToken?: string;
         groupId?: string;
       };
+      skipProfileCreation?: boolean;
     }
   ): Promise<{
     patientProfile?: string;
@@ -172,6 +174,12 @@ export class UserService extends BaseService {
           profiles.patientProfile = patientProfile.id;
           break;
         case UserRole.CLINIC_ADMIN:
+          // Skip profile creation if explicitly requested
+          // This is used when we know the profile will be created elsewhere (e.g. in signUpClinicAdmin)
+          if (options?.skipProfileCreation) {
+            break;
+          }
+
           // Ako imamo token, verifikujemo ga i dodajemo admina u postojeću grupu
           if (
             options?.clinicAdminData?.groupToken &&