functions/src/notifications/membershipStatusNotifications.ts

@@ -13,7 +13,6 @@ interface MembershipData {
   subscription?: {
     name: string;
     frequency: string;
-    assignedAt?: admin.firestore.Timestamp;
   };
 }
 
@@ -113,7 +112,10 @@ async function findExpiredMemberships(): Promise<
   }
 }
 
-async function checkIfMembershipExpired(membershipId: string, data: MembershipData): Promise<boolean> {
+async function checkIfMembershipExpired(
+  membershipId: string,
+  data: MembershipData
+): Promise<boolean> {
   try {
     if (!data.subscription || !data.subscription.frequency) {
       logger.warn(
@@ -124,40 +126,48 @@ async function checkIfMembershipExpired(membershipId: string, data: MembershipDa
 
     let startDate: Date;
 
-    if (data.subscription.assignedAt) {
-      startDate = (data.subscription.assignedAt as admin.firestore.Timestamp).toDate();
-    } else {
-      logger.info(`Using payment logic for membership ${membershipId} as assignedAt is missing`);
-      
     const payments = await getPaymentsForMembership(membershipId);
     if (payments.length === 0) {
-        logger.warn(`No payments found for membership ${membershipId}, cannot determine expiry`);
+      logger.warn(
+        `No payments found for membership ${membershipId}, cannot determine expiry`
+      );
       return false;
     }
 
     const latestPayment = payments[0];
     startDate = latestPayment.dateTimestamp;
 
-      logger.info(`Using latest payment date ${startDate.toISOString()} for membership ${membershipId}`);
+    logger.info(
-    }
+      `Using latest payment date ${startDate.toISOString()} for membership ${membershipId}`
+    );
 
-    const expiryDate = calculateExpiryDate(startDate, data.subscription.frequency);
+    const expiryDate = calculateExpiryDate(
+      startDate,
+      data.subscription.frequency
+    );
     const now = new Date();
 
     const isExpired = now > expiryDate;
 
     if (isExpired) {
-      logger.info(`Membership ${membershipId} expired on ${expiryDate.toISOString()}`);
+      logger.info(
+        `Membership ${membershipId} expired on ${expiryDate.toISOString()}`
+      );
     }
 
     return isExpired;
   } catch (error) {
-    logger.error(`Error checking expiry for membership ${membershipId}:`, error);
+    logger.error(
+      `Error checking expiry for membership ${membershipId}:`,
+      error
+    );
     return false;
   }
 }
 
-async function getPaymentsForMembership(membershipId: string): Promise<PaymentData[]> {
+async function getPaymentsForMembership(
+  membershipId: string
+): Promise<PaymentData[]> {
   try {
     const docSnapshot = await app
       .firestore()
@@ -178,16 +188,23 @@ async function getPaymentsForMembership(membershipId: string): Promise<PaymentDa
       amount: payment.amount,
       paymentMethod: payment.paymentMethod,
       referenceNumber: payment.referenceNumber,
-      dateTimestamp: payment.dateTimestamp.toDate ? payment.dateTimestamp.toDate() : new Date(payment.dateTimestamp),
+      dateTimestamp: payment.dateTimestamp.toDate
-      createdAt: payment.createdAt.toDate ? payment.createdAt.toDate() : new Date(payment.createdAt),
+        ? payment.dateTimestamp.toDate()
-      discount: payment.discount
+        : new Date(payment.dateTimestamp),
+      createdAt: payment.createdAt.toDate
+        ? payment.createdAt.toDate()
+        : new Date(payment.createdAt),
+      discount: payment.discount,
     }));
 
     payments.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
 
     return payments;
   } catch (error) {
-    logger.error(`Error getting payments for membership ${membershipId}:`, error);
+    logger.error(
+      `Error getting payments for membership ${membershipId}:`,
+      error
+    );
     return [];
   }
 }
@@ -213,21 +230,24 @@ function calculateExpiryDate(startDate: Date, frequency: string): Date {
   return expiry;
 }
 
-function calculateRenewalDateFromPayment(subscription: any, paymentDate: Date): Date {
+function calculateRenewalDateFromPayment(
+  subscription: any,
+  paymentDate: Date
+): Date {
   const renewalDate = new Date(paymentDate);
-  const frequency = subscription.frequency || 'Monthly';
+  const frequency = subscription.frequency || "Monthly";
 
   switch (frequency.toLowerCase()) {
-    case 'monthly':
+    case "monthly":
       renewalDate.setMonth(renewalDate.getMonth() + 1);
       break;
-    case 'quarterly':
+    case "quarterly":
       renewalDate.setMonth(renewalDate.getMonth() + 3);
       break;
-    case 'half-yearly':
+    case "half-yearly":
       renewalDate.setMonth(renewalDate.getMonth() + 6);
       break;
-    case 'yearly':
+    case "yearly":
       renewalDate.setFullYear(renewalDate.getFullYear() + 1);
       break;
     default:
@@ -279,14 +299,6 @@ async function sendPlanExpiredNotification(
     let expiryDate: Date | undefined;
     let formattedDate = "Unknown Date";
 
-    if (membershipData.subscription?.assignedAt) {
-      expiryDate = membershipData.subscription.assignedAt.toDate();
-      formattedDate = expiryDate.toLocaleDateString("en-US", {
-        year: "numeric",
-        month: "long",
-        day: "numeric",
-      });
-    } else {
     const payments = await getPaymentsForMembership(membershipId);
     if (payments.length > 0) {
       const latestPayment = payments[0];
@@ -300,7 +312,6 @@ async function sendPlanExpiredNotification(
         day: "numeric",
       });
     }
-    }
 
     await app
       .firestore()