@blackcode_sa/metaestetics-api 1.5.29 → 1.5.30

package/dist/admin/index.mjs

@@ -20,9 +20,9 @@ var NotificationStatus = /* @__PURE__ */ ((NotificationStatus2) => {
 import * as admin from "firebase-admin";
 import { Expo } from "expo-server-sdk";
 var NotificationsAdmin = class {
-  constructor(firestore6) {
+  constructor(firestore7) {
     this.expo = new Expo();
-    this.db = firestore6 || admin.firestore();
+    this.db = firestore7 || admin.firestore();
   }
   /**
    * Dohvata notifikaciju po ID-u
@@ -209,8 +209,8 @@ var ClinicAggregationService = class {
    * Constructor for ClinicAggregationService.
    * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
    */
-  constructor(firestore6) {
-    this.db = firestore6 || admin2.firestore();
+  constructor(firestore7) {
+    this.db = firestore7 || admin2.firestore();
   }
   /**
    * Adds clinic information to a clinic group when a new clinic is created
@@ -684,8 +684,8 @@ var ClinicAggregationService = class {
 import * as admin3 from "firebase-admin";
 var CALENDAR_SUBCOLLECTION_ID2 = "calendar";
 var PractitionerAggregationService = class {
-  constructor(firestore6) {
-    this.db = firestore6 || admin3.firestore();
+  constructor(firestore7) {
+    this.db = firestore7 || admin3.firestore();
   }
   /**
    * Adds practitioner information to a clinic when a new practitioner is created
@@ -1020,8 +1020,8 @@ var PractitionerAggregationService = class {
 import * as admin4 from "firebase-admin";
 var CALENDAR_SUBCOLLECTION_ID3 = "calendar";
 var ProcedureAggregationService = class {
-  constructor(firestore6) {
-    this.db = firestore6 || admin4.firestore();
+  constructor(firestore7) {
+    this.db = firestore7 || admin4.firestore();
   }
   /**
    * Adds procedure information to a practitioner when a new procedure is created
@@ -1405,8 +1405,8 @@ var ProcedureAggregationService = class {
 import * as admin5 from "firebase-admin";
 var CALENDAR_SUBCOLLECTION_ID4 = "calendar";
 var PatientAggregationService = class {
-  constructor(firestore6) {
-    this.db = firestore6 || admin5.firestore();
+  constructor(firestore7) {
+    this.db = firestore7 || admin5.firestore();
   }
   // --- Methods for Patient Creation --- >
   // No specific aggregations defined for patient creation in the plan.
@@ -1510,6 +1510,339 @@ var PatientAggregationService = class {
   }
 };
 
+// src/admin/mailing/base.mailing.service.ts
+import * as admin6 from "firebase-admin";
+var BaseMailingService = class {
+  // Removed config property as it's no longer managed here
+  // protected config: MailgunConfig;
+  /**
+   * Constructor for BaseMailingService
+   * @param firestore Firestore instance provided by the caller
+   * @param mailgunClient Mailgun client instance provided by the caller
+   */
+  constructor(firestore7, mailgunClient) {
+    this.db = firestore7;
+    this.mailgunClient = mailgunClient;
+  }
+  /**
+   * Sends an email using Mailgun
+   * @param data Email data to send, including the 'from' address
+   * @returns Promise with the sending result
+   */
+  async sendEmail(data) {
+    try {
+      if (!data.from) {
+        throw new Error(
+          "Email 'from' address must be provided in sendEmail data."
+        );
+      }
+      return await new Promise(
+        (resolve, reject) => {
+          this.mailgunClient.messages().send(data, (error, body) => {
+            if (error) {
+              console.error("[BaseMailingService] Error sending email:", error);
+              reject(error);
+            } else {
+              console.log(
+                "[BaseMailingService] Email sent successfully:",
+                body
+              );
+              resolve(body);
+            }
+          });
+        }
+      );
+    } catch (error) {
+      console.error("[BaseMailingService] Error in sendEmail:", error);
+      throw error;
+    }
+  }
+  /**
+   * Logs email sending attempt to Firestore for tracking
+   * @param emailData Email data that was sent
+   * @param success Whether the email was sent successfully
+   * @param error Error object if the email failed to send
+   */
+  async logEmailAttempt(emailData, success, error) {
+    try {
+      const emailLogRef = this.db.collection("email_logs").doc();
+      await emailLogRef.set({
+        to: emailData.to,
+        subject: emailData.subject,
+        templateName: emailData.templateName,
+        success,
+        error: error ? JSON.stringify(error) : null,
+        sentAt: admin6.firestore.FieldValue.serverTimestamp()
+      });
+    } catch (logError) {
+      console.error(
+        "[BaseMailingService] Error logging email attempt:",
+        logError
+      );
+    }
+  }
+  /**
+   * Renders a simple HTML email template with variables
+   * @param template HTML template string
+   * @param variables Key-value pairs to replace in the template
+   * @returns Rendered HTML string
+   */
+  renderTemplate(template, variables) {
+    let rendered = template;
+    Object.entries(variables).forEach(([key, value]) => {
+      const regex = new RegExp(`{{\\s*${key}\\s*}}`, "g");
+      rendered = rendered.replace(regex, value);
+    });
+    return rendered;
+  }
+};
+
+// src/admin/mailing/practitionerInvite/templates/invitation.template.ts
+var practitionerInvitationTemplate = `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Join {{clinicName}} as a Practitioner</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      line-height: 1.6;
+      color: #333;
+      margin: 0;
+      padding: 0;
+    }
+    .container {
+      max-width: 600px;
+      margin: 0 auto;
+      padding: 20px;
+    }
+    .header {
+      background-color: #4A90E2;
+      padding: 20px;
+      text-align: center;
+      color: white;
+    }
+    .content {
+      padding: 20px;
+      background-color: #f9f9f9;
+    }
+    .footer {
+      padding: 20px;
+      text-align: center;
+      font-size: 12px;
+      color: #888;
+    }
+    .button {
+      display: inline-block;
+      background-color: #4A90E2;
+      color: white;
+      text-decoration: none;
+      padding: 12px 24px;
+      border-radius: 4px;
+      margin: 20px 0;
+      font-weight: bold;
+    }
+    .token {
+      font-size: 24px;
+      font-weight: bold;
+      color: #4A90E2;
+      padding: 10px;
+      background-color: #e9f0f9;
+      border-radius: 4px;
+      display: inline-block;
+      letter-spacing: 2px;
+      margin: 10px 0;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="header">
+      <h1>You've Been Invited</h1>
+    </div>
+    <div class="content">
+      <p>Hello {{practitionerName}},</p>
+      
+      <p>You have been invited to join <strong>{{clinicName}}</strong> as a healthcare practitioner.</p>
+      
+      <p>Your profile has been created and is ready for you to claim. Please use the following token to register:</p>
+      
+      <div style="text-align: center;">
+        <span class="token">{{inviteToken}}</span>
+      </div>
+      
+      <p>This token will expire on <strong>{{expirationDate}}</strong>.</p>
+      
+      <p>To create your account:</p>
+      <ol>
+        <li>Visit {{registrationUrl}}</li>
+        <li>Enter your email and create a password</li>
+        <li>When prompted, enter the token above</li>
+      </ol>
+      
+      <div style="text-align: center;">
+        <a href="{{registrationUrl}}" class="button">Create Your Account</a>
+      </div>
+      
+      <p>If you have any questions, please contact {{contactName}} at {{contactEmail}}.</p>
+    </div>
+    <div class="footer">
+      <p>This is an automated message from {{clinicName}}. Please do not reply to this email.</p>
+      <p>&copy; {{currentYear}} {{clinicName}}. All rights reserved.</p>
+    </div>
+  </div>
+</body>
+</html>
+`;
+
+// src/admin/mailing/practitionerInvite/practitionerInvite.mailing.ts
+var PractitionerInviteMailingService = class extends BaseMailingService {
+  /**
+   * Constructor for PractitionerInviteMailingService
+   * @param firestore Firestore instance provided by the caller
+   * @param mailgunClient Mailgun client instance provided by the caller
+   */
+  constructor(firestore7, mailgunClient) {
+    super(firestore7, mailgunClient);
+    this.DEFAULT_REGISTRATION_URL = "https://app.medclinic.com/register";
+    this.DEFAULT_SUBJECT = "You've Been Invited to Join as a Practitioner";
+    this.DEFAULT_FROM_ADDRESS = "MedClinic <no-reply@your-domain.com>";
+  }
+  /**
+   * Sends a practitioner invitation email
+   * @param data The practitioner invitation data
+   * @returns Promise resolved when email is sent
+   */
+  async sendInvitationEmail(data) {
+    var _a, _b, _c, _d;
+    try {
+      console.log(
+        "[PractitionerInviteMailingService] Sending invitation email to",
+        data.token.email
+      );
+      const expirationDate = data.token.expiresAt.toDate().toLocaleDateString("en-US", {
+        weekday: "long",
+        year: "numeric",
+        month: "long",
+        day: "numeric"
+      });
+      const registrationUrl = ((_a = data.options) == null ? void 0 : _a.registrationUrl) || this.DEFAULT_REGISTRATION_URL;
+      const contactName = data.clinic.contactName || "Clinic Administrator";
+      const contactEmail = data.clinic.contactEmail;
+      const subject = ((_b = data.options) == null ? void 0 : _b.customSubject) || this.DEFAULT_SUBJECT;
+      const fromAddress = ((_c = data.options) == null ? void 0 : _c.fromAddress) || this.DEFAULT_FROM_ADDRESS;
+      const currentYear = (/* @__PURE__ */ new Date()).getFullYear().toString();
+      const practitionerName = `${data.practitioner.firstName} ${data.practitioner.lastName}`;
+      const templateVariables = {
+        clinicName: data.clinic.name,
+        practitionerName,
+        inviteToken: data.token.token,
+        expirationDate,
+        registrationUrl,
+        contactName,
+        contactEmail,
+        currentYear
+      };
+      const html = this.renderTemplate(
+        practitionerInvitationTemplate,
+        templateVariables
+      );
+      const emailData = {
+        to: data.token.email,
+        from: fromAddress,
+        subject,
+        html
+      };
+      const result = await this.sendEmail(emailData);
+      await this.logEmailAttempt(
+        {
+          to: data.token.email,
+          subject,
+          templateName: "practitioner_invitation"
+        },
+        true
+      );
+      return result;
+    } catch (error) {
+      console.error(
+        "[PractitionerInviteMailingService] Error sending invitation email:",
+        error
+      );
+      await this.logEmailAttempt(
+        {
+          to: data.token.email,
+          subject: ((_d = data.options) == null ? void 0 : _d.customSubject) || this.DEFAULT_SUBJECT,
+          templateName: "practitioner_invitation"
+        },
+        false,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Handles the practitioner token creation event from Cloud Functions
+   * Fetches necessary data using defined types and collection constants,
+   * and sends the invitation email.
+   * @param tokenData The fully typed token object including its id
+   * @param fromAddress The 'from' email address to use, obtained from config
+   * @returns Promise resolved when the email is sent
+   */
+  async handleTokenCreationEvent(tokenData, fromAddress) {
+    try {
+      console.log(
+        "[PractitionerInviteMailingService] Handling token creation event for token:",
+        tokenData.id
+      );
+      const practitionerRef = this.db.collection(PRACTITIONERS_COLLECTION).doc(tokenData.practitionerId);
+      const practitionerDoc = await practitionerRef.get();
+      if (!practitionerDoc.exists) {
+        throw new Error(`Practitioner ${tokenData.practitionerId} not found`);
+      }
+      const practitionerData = practitionerDoc.data();
+      const clinicRef = this.db.collection(CLINICS_COLLECTION).doc(tokenData.clinicId);
+      const clinicDoc = await clinicRef.get();
+      if (!clinicDoc.exists) {
+        throw new Error(`Clinic ${tokenData.clinicId} not found`);
+      }
+      const clinicData = clinicDoc.data();
+      const emailData = {
+        token: {
+          id: tokenData.id,
+          token: tokenData.token,
+          practitionerId: tokenData.practitionerId,
+          email: tokenData.email,
+          clinicId: tokenData.clinicId,
+          expiresAt: tokenData.expiresAt
+        },
+        practitioner: {
+          firstName: practitionerData.basicInfo.firstName || "",
+          lastName: practitionerData.basicInfo.lastName || ""
+        },
+        clinic: {
+          name: clinicData.name || "Medical Clinic",
+          contactEmail: clinicData.contactInfo.email || "contact@medclinic.com"
+        },
+        options: {
+          fromAddress
+        }
+      };
+      await this.sendInvitationEmail(emailData);
+      console.log(
+        "[PractitionerInviteMailingService] Invitation email sent successfully"
+      );
+    } catch (error) {
+      console.error(
+        "[PractitionerInviteMailingService] Error handling token creation event:",
+        error
+      );
+      throw error;
+    }
+  }
+};
+
 // src/types/index.ts
 var UserRole = /* @__PURE__ */ ((UserRole2) => {
   UserRole2["PATIENT"] = "patient";
@@ -1522,6 +1855,7 @@ var UserRole = /* @__PURE__ */ ((UserRole2) => {
 // src/admin/index.ts
 console.log("[Admin Module] Initialized and services exported.");
 export {
+  BaseMailingService,
   ClinicAggregationService,
   NOTIFICATIONS_COLLECTION,
   NotificationStatus,
@@ -1529,6 +1863,7 @@ export {
   NotificationsAdmin,
   PatientAggregationService,
   PractitionerAggregationService,
+  PractitionerInviteMailingService,
   ProcedureAggregationService,
   UserRole
 };

package/dist/index.d.mts

@@ -4545,31 +4545,16 @@ declare class ClinicService extends BaseService {
     private clinicGroupService;
     private clinicAdminService;
     constructor(db: Firestore, auth: Auth, app: FirebaseApp, clinicGroupService: ClinicGroupService, clinicAdminService: ClinicAdminService);
-    /**
-     * Creates an aggregated ClinicInfo object from Clinic data.
-     * @param clinic The clinic object
-     * @returns ClinicInfo object
-     */
-    private _createClinicInfoForAggregation;
-    /**
-     * Updates the ClinicInfo within the clinicsInfo array for multiple practitioners.
-     * @param practitionerIds IDs of practitioners to update
-     * @param clinicInfo The updated ClinicInfo object
-     */
-    private _updateClinicInfoInPractitioners;
     /**
      * Creates a new clinic.
-     * Initializes empty doctorsInfo and proceduresInfo.
-     * Aggregation into Clinic happens via PractitionerService and ProcedureService.
      */
     createClinic(data: CreateClinicData, creatorAdminId: string): Promise<Clinic>;
     /**
-     * Updates a clinic and propagates changes (ClinicInfo) to associated practitioners.
+     * Updates a clinic.
      */
     updateClinic(clinicId: string, data: Partial<Omit<Clinic, "id" | "createdAt" | "clinicGroupId">>, adminId: string): Promise<Clinic>;
     /**
      * Deactivates a clinic.
-     * Note: Does not currently remove ClinicInfo from practitioners (might be desired).
      */
     deactivateClinic(clinicId: string, adminId: string): Promise<void>;
     /**
@@ -4582,7 +4567,6 @@ declare class ClinicService extends BaseService {
     getClinicsByGroup(groupId: string): Promise<Clinic[]>;
     /**
      * Pretražuje klinike u određenom radijusu
-     * REVIEW: SearchUtils.findClinicsInRadius might need updating for filters.
      */
     findClinicsInRadius(center: {
         latitude: number;
@@ -4708,28 +4692,9 @@ declare class PractitionerService extends BaseService {
     private clinicService?;
     constructor(db: Firestore, auth: Auth, app: FirebaseApp, clinicService?: ClinicService);
     private getClinicService;
-    /**
-     * Postavlja referencu na ClinicService nakon inicijalizacije
-     */
     setClinicService(clinicService: ClinicService): void;
     /**
-     * Aggregates clinic information for a practitioner
-     * @param clinicIds Array of clinic IDs the practitioner works at
-     * @returns Array of ClinicInfo objects
-     */
-    private aggregateClinicInfo;
-    /**
-     * @deprecated Aggregation of procedure info is now handled by ProcedureService.
-     */
-    private aggregateProcedureInfo;
-    /**
-     * Updates aggregated data (clinics and procedures) for a practitioner
-     * @param practitionerId ID of the practitioner to update
-     * @returns Updated practitioner
-     */
-    updateAggregatedData(practitionerId: string): Promise<Practitioner | null>;
-    /**
-     * Kreira novog zdravstvenog radnika
+     * Creates a new practitioner
      */
     createPractitioner(data: CreatePractitionerData): Promise<Practitioner>;
     /**
@@ -4791,15 +4756,15 @@ declare class PractitionerService extends BaseService {
      */
     getDraftPractitionersByClinic(clinicId: string): Promise<Practitioner[]>;
     /**
-     * Ažurira profil zdravstvenog radnika
+     * Updates a practitioner
      */
     updatePractitioner(practitionerId: string, data: UpdatePractitionerData): Promise<Practitioner>;
     /**
-     * Dodaje kliniku zdravstvenom radniku
+     * Adds a clinic to a practitioner
      */
     addClinic(practitionerId: string, clinicId: string): Promise<void>;
     /**
-     * Uklanja kliniku iz liste klinika zdravstvenog radnika
+     * Removes a clinic from a practitioner
      */
     removeClinic(practitionerId: string, clinicId: string): Promise<void>;
     /**
@@ -4880,30 +4845,6 @@ declare class PractitionerService extends BaseService {
         practitioners: Practitioner[];
         lastDoc: any;
     }>;
-    /**
-     * Aggregates essential clinic information for embedding in Practitioner.
-     * @param clinicIds Array of clinic IDs the practitioner works at
-     * @returns Array of ClinicInfo objects
-     */
-    private _aggregateClinicInfoForPractitioner;
-    /**
-     * Creates an aggregated DoctorInfo object from Practitioner data.
-     * @param practitioner The practitioner object
-     * @returns DoctorInfo object
-     */
-    private _createDoctorInfoForClinic;
-    /**
-     * Updates the DoctorInfo within the doctorsInfo array for multiple clinics.
-     * @param clinicIds IDs of clinics to update
-     * @param doctorInfo The updated DoctorInfo object
-     */
-    private _updateDoctorInfoInClinics;
-    /**
-     * Removes DoctorInfo from the doctorsInfo array for multiple clinics.
-     * @param clinicIds IDs of clinics to update
-     * @param practitionerId ID of the practitioner whose info should be removed
-     */
-    private _removeDoctorInfoFromClinics;
 }
 
 declare class UserService extends BaseService {
@@ -5225,11 +5166,8 @@ declare class ProcedureService extends BaseService {
     private technologyService;
     private productService;
     constructor(db: Firestore, auth: Auth, app: FirebaseApp, categoryService: CategoryService, subcategoryService: SubcategoryService, technologyService: TechnologyService, productService: ProductService);
-    private _createProcedureSummaryInfo;
-    private _updatePractitionerProcedures;
-    private _updateClinicProcedures;
     /**
-     * Creates a new procedure and updates related practitioner/clinic aggregates
+     * Creates a new procedure
      * @param data - The data for creating a new procedure
      * @returns The created procedure
      */
@@ -5253,19 +5191,19 @@ declare class ProcedureService extends BaseService {
      */
     getProceduresByPractitioner(practitionerId: string): Promise<Procedure[]>;
     /**
-     * Updates a procedure and its related aggregates in Practitioner and Clinic docs
+     * Updates a procedure
      * @param id - The ID of the procedure to update
      * @param data - The data to update the procedure with
      * @returns The updated procedure
      */
     updateProcedure(id: string, data: UpdateProcedureData): Promise<Procedure>;
     /**
-     * Deactivates a procedure (soft delete) and updates aggregates
+     * Deactivates a procedure (soft delete)
      * @param id - The ID of the procedure to deactivate
      */
     deactivateProcedure(id: string): Promise<void>;
     /**
-     * Deletes a procedure permanently and updates related aggregates
+     * Deletes a procedure permanently
      * @param id - The ID of the procedure to delete
      * @returns A boolean indicating if the deletion was successful
      */
@@ -5292,6 +5230,61 @@ declare class ProcedureService extends BaseService {
         procedures: Procedure[];
         lastDoc: any;
     }>;
+    /**
+     * Searches and filters procedures based on multiple criteria
+     *
+     * @param filters - Various filters to apply
+     * @param filters.nameSearch - Optional search text for procedure name
+     * @param filters.treatmentBenefits - Optional array of treatment benefits to filter by
+     * @param filters.procedureFamily - Optional procedure family to filter by
+     * @param filters.procedureCategory - Optional procedure category to filter by
+     * @param filters.procedureSubcategory - Optional procedure subcategory to filter by
+     * @param filters.procedureTechnology - Optional procedure technology to filter by
+     * @param filters.location - Optional location for distance-based search
+     * @param filters.radiusInKm - Optional radius in kilometers (required if location is provided)
+     * @param filters.minPrice - Optional minimum price
+     * @param filters.maxPrice - Optional maximum price
+     * @param filters.minRating - Optional minimum rating (0-5)
+     * @param filters.maxRating - Optional maximum rating (0-5)
+     * @param filters.pagination - Optional number of results per page
+     * @param filters.lastDoc - Optional last document for pagination
+     * @param filters.isActive - Optional filter for active procedures only
+     * @returns Filtered procedures and the last document for pagination
+     */
+    getProceduresByFilters(filters: {
+        nameSearch?: string;
+        treatmentBenefits?: TreatmentBenefit[];
+        procedureFamily?: ProcedureFamily;
+        procedureCategory?: string;
+        procedureSubcategory?: string;
+        procedureTechnology?: string;
+        location?: {
+            latitude: number;
+            longitude: number;
+        };
+        radiusInKm?: number;
+        minPrice?: number;
+        maxPrice?: number;
+        minRating?: number;
+        maxRating?: number;
+        pagination?: number;
+        lastDoc?: any;
+        isActive?: boolean;
+    }): Promise<{
+        procedures: (Procedure & {
+            distance?: number;
+        })[];
+        lastDoc: any;
+    }>;
+    /**
+     * Helper method to apply in-memory filters to procedures
+     * Used by getProceduresByFilters to apply filters that can't be done in Firestore queries
+     *
+     * @param procedures - The procedures to filter
+     * @param filters - The filters to apply
+     * @returns Filtered procedures
+     */
+    private applyInMemoryFilters;
 }
 
 /**