@timardex/cluemart-server-shared 1.0.284 → 1.0.287

package/dist/mongoose/index.mjs

@@ -40,7 +40,7 @@ import {
   socialShareResourceSchema,
   termsAgreementSchema,
   userLicenseSchema
-} from "../chunk-4FWW5CDC.mjs";
+} from "../chunk-6EDO734D.mjs";
 export {
   APP_SETTINGS_ID,
   AdModel,

package/dist/service/index.cjs

@@ -33,12 +33,15 @@ __export(service_exports, {
   ACTIVE_NOT_DELETED_FILTER: () => ACTIVE_NOT_DELETED_FILTER,
   AFFILIATE_REWARDS: () => AFFILIATE_REWARDS,
   activeAffiliateCodeExists: () => activeAffiliateCodeExists,
+  awardAffiliateVendorSubscriptionRewards: () => awardAffiliateVendorSubscriptionRewards,
   connectToDatabase: () => connectToDatabase,
   convertObjectIdsToStrings: () => convertObjectIdsToStrings,
   createAffiliateReward: () => createAffiliateReward,
   didRemoveAnyEventDates: () => didRemoveAnyEventDates,
   findAffiliateByPromoCode: () => findAffiliateByPromoCode,
   findEventOrImportedMarketById: () => findEventOrImportedMarketById,
+  getSubscriptionRewardPeriodBounds: () => getSubscriptionRewardPeriodBounds,
+  mapVendorLicenceToSubscriptionRewardType: () => mapVendorLicenceToSubscriptionRewardType,
   normalizeAffiliatePromoCodes: () => normalizeAffiliatePromoCodes,
   normalizePromoCode: () => normalizePromoCode,
   saveNotificationsInDb: () => saveNotificationsInDb,
@@ -3661,14 +3664,14 @@ var EnumGameType = /* @__PURE__ */ ((EnumGameType2) => {
   EnumGameType2["ODD_ONE_OUT"] = "oddOneOut";
   return EnumGameType2;
 })(EnumGameType || {});
-var EnumAffiliateRewardType = /* @__PURE__ */ ((EnumAffiliateRewardType2) => {
-  EnumAffiliateRewardType2["ACTIVE_EVENT_WITH_VENDOR_REGISTRATIONS"] = "ACTIVE_EVENT_WITH_VENDOR_REGISTRATIONS";
-  EnumAffiliateRewardType2["ACTIVE_VENDOR_BONUS_REWARD"] = "ACTIVE_VENDOR_BONUS_REWARD";
-  EnumAffiliateRewardType2["ACTIVE_VENDOR_PRO_SUBSCRIPTION"] = "ACTIVE_VENDOR_PRO_SUBSCRIPTION";
-  EnumAffiliateRewardType2["ACTIVE_VENDOR_STANDARD_SUBSCRIPTION"] = "ACTIVE_VENDOR_STANDARD_SUBSCRIPTION";
-  EnumAffiliateRewardType2["NEW_EVENT_REGISTRATION"] = "NEW_EVENT_REGISTRATION";
-  EnumAffiliateRewardType2["NEW_VENDOR_REGISTRATION"] = "NEW_VENDOR_REGISTRATION";
-  return EnumAffiliateRewardType2;
+var EnumAffiliateRewardType = /* @__PURE__ */ ((EnumAffiliateRewardType22) => {
+  EnumAffiliateRewardType22["ACTIVE_EVENT_WITH_VENDOR_REGISTRATIONS"] = "ACTIVE_EVENT_WITH_VENDOR_REGISTRATIONS";
+  EnumAffiliateRewardType22["ACTIVE_VENDOR_BONUS_REWARD"] = "ACTIVE_VENDOR_BONUS_REWARD";
+  EnumAffiliateRewardType22["ACTIVE_VENDOR_PRO_SUBSCRIPTION"] = "ACTIVE_VENDOR_PRO_SUBSCRIPTION";
+  EnumAffiliateRewardType22["ACTIVE_VENDOR_STANDARD_SUBSCRIPTION"] = "ACTIVE_VENDOR_STANDARD_SUBSCRIPTION";
+  EnumAffiliateRewardType22["NEW_EVENT_REGISTRATION"] = "NEW_EVENT_REGISTRATION";
+  EnumAffiliateRewardType22["NEW_VENDOR_REGISTRATION"] = "NEW_VENDOR_REGISTRATION";
+  return EnumAffiliateRewardType22;
 })(EnumAffiliateRewardType || {});
 var statusOptions = [
   ...Object.values(EnumInviteStatus).map((status) => ({
@@ -9366,89 +9369,12 @@ async function activeAffiliateCodeExists(affiliateCode) {
   return existing !== null;
 }
 
-// src/service/affiliate/createAffiliateReward.ts
-var AFFILIATE_REWARDS = {
-  [EnumAffiliateRewardType.NEW_EVENT_REGISTRATION]: {
-    description: "10 points for new event registration (one-time reward)",
-    value: 10
-  },
-  [EnumAffiliateRewardType.NEW_VENDOR_REGISTRATION]: {
-    description: "5 points for new vendor registration (one-time reward)",
-    value: 5
-  },
-  [EnumAffiliateRewardType.ACTIVE_VENDOR_PRO_SUBSCRIPTION]: {
-    description: "3 points for active vendor pro subscription (monthly reward)",
-    value: 3
-  },
-  [EnumAffiliateRewardType.ACTIVE_VENDOR_STANDARD_SUBSCRIPTION]: {
-    description: "1 point for active vendor standard subscription (monthly reward)",
-    value: 1
-  },
-  [EnumAffiliateRewardType.ACTIVE_VENDOR_BONUS_REWARD]: {
-    description: "5 bonus points for every 10th active vendor (one-time reward)",
-    value: 5
-  },
-  [EnumAffiliateRewardType.ACTIVE_EVENT_WITH_VENDOR_REGISTRATIONS]: {
-    description: "50 points for active event with vendor registrations (one-time reward)",
-    value: 50
-  }
-};
-function createAffiliateReward(rewardType, createdAt) {
-  const reward = AFFILIATE_REWARDS[rewardType];
-  return {
-    createdAt,
-    redeemedAt: null,
-    rewardDescription: reward.description,
-    rewardType,
-    rewardValue: reward.value
-  };
-}
-
-// src/service/affiliate/findAffiliateByPromoCode.ts
-async function findAffiliateByPromoCode(promoCode) {
-  return AffiliateModel.findOne({
-    affiliateCode: promoCode,
-    deletedAt: null
-  }).exec();
-}
-
 // src/service/promoCode/normalizePromoCode.ts
 function normalizePromoCode(decoratedPromoCode) {
   const normalized = decoratedPromoCode?.trim().toUpperCase();
   return normalized || null;
 }
 
-// src/service/affiliate/normalizeAffiliatePromoCodes.ts
-function normalizeAffiliatePromoCodes(promoCodes) {
-  const normalized = (promoCodes ?? []).map((code) => normalizePromoCode(code)).filter((code) => code !== null);
-  return [...new Set(normalized)];
-}
-
-// src/service/database.ts
-var import_mongoose28 = __toESM(require("mongoose"));
-var connectToDatabase = async ({
-  appName,
-  dbName,
-  dbPassword,
-  dbUser,
-  mongodbUri
-}) => {
-  try {
-    const mongoUri = mongodbUri ? mongodbUri : (
-      // Fallback to MongoDB Atlas connection string
-      `mongodb+srv://${dbUser}:${dbPassword}@${dbName}.mongodb.net/?retryWrites=true&w=majority&appName=${appName}`
-    );
-    await import_mongoose28.default.connect(mongoUri);
-    const connectionType = mongodbUri ? "Local MongoDB" : "MongoDB Atlas";
-    console.log(
-      `${connectionType} connected from server/src/service/database.ts`
-    );
-  } catch (err) {
-    console.error("Error connecting to MongoDB:", err);
-    throw err;
-  }
-};
-
 // src/service/saveNotificationsInDb.ts
 async function saveNotificationsInDb(payload) {
   const { data, message, title, type, userIds } = payload;
@@ -9582,6 +9508,285 @@ async function sendPushNotifications({
   }
 }
 
+// src/service/affiliate/createAffiliateReward.ts
+var AFFILIATE_REWARDS = {
+  [EnumAffiliateRewardType.NEW_EVENT_REGISTRATION]: {
+    description: "10 points for new event registration (one-time reward)",
+    value: 10
+  },
+  [EnumAffiliateRewardType.NEW_VENDOR_REGISTRATION]: {
+    description: "5 points for new vendor registration (one-time reward)",
+    value: 5
+  },
+  [EnumAffiliateRewardType.ACTIVE_VENDOR_PRO_SUBSCRIPTION]: {
+    description: "3 points for active vendor pro subscription (monthly reward)",
+    value: 3
+  },
+  [EnumAffiliateRewardType.ACTIVE_VENDOR_STANDARD_SUBSCRIPTION]: {
+    description: "1 point for active vendor standard subscription (monthly reward)",
+    value: 1
+  },
+  [EnumAffiliateRewardType.ACTIVE_VENDOR_BONUS_REWARD]: {
+    description: "5 bonus points for every 10th active vendor (one-time reward)",
+    value: 5
+  },
+  [EnumAffiliateRewardType.ACTIVE_EVENT_WITH_VENDOR_REGISTRATIONS]: {
+    description: "50 points for active event with vendor registrations (one-time reward)",
+    value: 50
+  }
+};
+function createAffiliateReward(rewardType, createdAt) {
+  const reward = AFFILIATE_REWARDS[rewardType];
+  return {
+    createdAt,
+    redeemedAt: null,
+    rewardDescription: reward.description,
+    rewardType,
+    rewardValue: reward.value
+  };
+}
+
+// src/service/affiliate/vendorSubscriptionRewards.ts
+function mapVendorLicenceToSubscriptionRewardType(licences, now = /* @__PURE__ */ new Date()) {
+  const validTypes = new Set(
+    (licences ?? []).filter(
+      (licence) => new Date(licence.expiryDate).getTime() > now.getTime()
+    ).map((licence) => licence.licenceType)
+  );
+  if (validTypes.has(EnumUserLicence.PRO_VENDOR) || validTypes.has(EnumUserLicence.PRO_PLUS_VENDOR)) {
+    return EnumAffiliateRewardType.ACTIVE_VENDOR_PRO_SUBSCRIPTION;
+  }
+  if (validTypes.has(EnumUserLicence.STANDARD_VENDOR)) {
+    return EnumAffiliateRewardType.ACTIVE_VENDOR_STANDARD_SUBSCRIPTION;
+  }
+  return null;
+}
+function getSubscriptionRewardPeriodBounds(now = /* @__PURE__ */ new Date()) {
+  const periodStart = new Date(
+    Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1)
+  );
+  const periodEnd = new Date(
+    Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1)
+  );
+  return { periodEnd, periodStart };
+}
+
+// src/service/affiliate/awardAffiliateVendorSubscriptionRewards.ts
+function isEligibleVendorResource(resource) {
+  return resource.resourceType === EnumResourceType.VENDOR && resource.resourceActive === true && resource.resourceDeletedAt == null;
+}
+async function findAffiliatesWithActiveVendorReferrals() {
+  return await AffiliateModel.find({
+    affiliateResources: {
+      $elemMatch: {
+        resourceActive: true,
+        resourceDeletedAt: null,
+        resourceType: EnumResourceType.VENDOR
+      }
+    },
+    deletedAt: null
+  }).select("_id affiliateCode affiliateResources owner").lean().exec();
+}
+async function findEligibleReferredVendor(resourceId, affiliateCode) {
+  return await VendorModel.findOne({
+    _id: resourceId,
+    active: true,
+    deletedAt: null,
+    promoCodes: affiliateCode
+  }).select("_id name owner.userId").lean().exec();
+}
+async function resolveSubscriptionRewardTypeForVendorOwner(vendorOwnerUserId, now) {
+  const vendorOwner = await UserModel.findById(vendorOwnerUserId).select("licences").lean().exec();
+  return mapVendorLicenceToSubscriptionRewardType(vendorOwner?.licences, now);
+}
+async function notifyAffiliateOwnerOfSubscriptionReward({
+  affiliateId,
+  affiliateOwnerUserId,
+  resourceName,
+  rewardValue
+}) {
+  const payload = {
+    data: {
+      resourceId: String(affiliateId),
+      resourceName,
+      resourceType: EnumNotificationResourceType.AFFILIATE_REWARD_RECEIVED
+    },
+    message: `You earned ${rewardValue} points! Your referred vendor "${resourceName}" has an active subscription.`,
+    title: "Affiliate points earned",
+    type: EnumNotificationType.SYSTEM,
+    userIds: [affiliateOwnerUserId]
+  };
+  try {
+    await saveNotificationsInDb(payload);
+    await sendPushNotifications(payload);
+  } catch (error) {
+    console.error(
+      `[affiliate] subscription reward notification failed for affiliate ${String(affiliateId)}:`,
+      error instanceof Error ? error.message : error
+    );
+  }
+}
+async function tryAwardSubscriptionReward({
+  affiliate,
+  createdAt,
+  period,
+  resource,
+  rewardType,
+  vendor
+}) {
+  const reward = createAffiliateReward(rewardType, createdAt);
+  const updateResult = await AffiliateModel.updateOne(
+    {
+      _id: affiliate._id,
+      affiliateResources: {
+        $elemMatch: {
+          resourceActive: true,
+          resourceDeletedAt: null,
+          resourceId: vendor._id,
+          resourceType: EnumResourceType.VENDOR,
+          rewards: {
+            $not: {
+              $elemMatch: {
+                createdAt: {
+                  $gte: period.periodStart,
+                  $lt: period.periodEnd
+                },
+                rewardType
+              }
+            }
+          }
+        }
+      },
+      deletedAt: null
+    },
+    {
+      $inc: { overallPoints: reward.rewardValue },
+      $push: { "affiliateResources.$.rewards": reward }
+    }
+  ).exec();
+  if (updateResult.modifiedCount === 0) {
+    return "skipped";
+  }
+  const affiliateOwnerUserId = affiliate.owner?.userId;
+  if (affiliateOwnerUserId) {
+    await notifyAffiliateOwnerOfSubscriptionReward({
+      affiliateId: affiliate._id,
+      affiliateOwnerUserId,
+      resourceName: resource.resourceName || vendor.name || "vendor",
+      rewardValue: reward.rewardValue
+    });
+  }
+  return "awarded";
+}
+async function processAffiliateVendorReferral({
+  affiliate,
+  affiliateCode,
+  createdAt,
+  now,
+  period,
+  resource
+}) {
+  const vendor = await findEligibleReferredVendor(
+    resource.resourceId,
+    affiliateCode
+  );
+  if (!vendor?.owner?.userId) {
+    return "skipped";
+  }
+  const rewardType = await resolveSubscriptionRewardTypeForVendorOwner(
+    vendor.owner.userId,
+    now
+  );
+  if (!rewardType) {
+    return "skipped";
+  }
+  return tryAwardSubscriptionReward({
+    affiliate,
+    createdAt,
+    period,
+    resource,
+    rewardType,
+    vendor
+  });
+}
+async function awardAffiliateVendorSubscriptionRewards(now = /* @__PURE__ */ new Date()) {
+  const period = getSubscriptionRewardPeriodBounds(now);
+  const createdAt = now;
+  const affiliates = await findAffiliatesWithActiveVendorReferrals();
+  let awarded = 0;
+  let skipped = 0;
+  const seenPairs = /* @__PURE__ */ new Set();
+  for (const affiliate of affiliates) {
+    const affiliateCode = normalizePromoCode(affiliate.affiliateCode);
+    if (!affiliateCode) {
+      continue;
+    }
+    for (const resource of affiliate.affiliateResources) {
+      if (!isEligibleVendorResource(resource)) {
+        continue;
+      }
+      const pairKey = `${String(affiliate._id)}:${String(resource.resourceId)}`;
+      if (seenPairs.has(pairKey)) {
+        continue;
+      }
+      seenPairs.add(pairKey);
+      const outcome = await processAffiliateVendorReferral({
+        affiliate,
+        affiliateCode,
+        createdAt,
+        now,
+        period,
+        resource
+      });
+      if (outcome === "awarded") {
+        awarded += 1;
+      } else {
+        skipped += 1;
+      }
+    }
+  }
+  return { awarded, skipped };
+}
+
+// src/service/affiliate/findAffiliateByPromoCode.ts
+async function findAffiliateByPromoCode(promoCode) {
+  return AffiliateModel.findOne({
+    affiliateCode: promoCode,
+    deletedAt: null
+  }).exec();
+}
+
+// src/service/affiliate/normalizeAffiliatePromoCodes.ts
+function normalizeAffiliatePromoCodes(promoCodes) {
+  const normalized = (promoCodes ?? []).map((code) => normalizePromoCode(code)).filter((code) => code !== null);
+  return [...new Set(normalized)];
+}
+
+// src/service/database.ts
+var import_mongoose29 = __toESM(require("mongoose"));
+var connectToDatabase = async ({
+  appName,
+  dbName,
+  dbPassword,
+  dbUser,
+  mongodbUri
+}) => {
+  try {
+    const mongoUri = mongodbUri ? mongodbUri : (
+      // Fallback to MongoDB Atlas connection string
+      `mongodb+srv://${dbUser}:${dbPassword}@${dbName}.mongodb.net/?retryWrites=true&w=majority&appName=${appName}`
+    );
+    await import_mongoose29.default.connect(mongoUri);
+    const connectionType = mongodbUri ? "Local MongoDB" : "MongoDB Atlas";
+    console.log(
+      `${connectionType} connected from server/src/service/database.ts`
+    );
+  } catch (err) {
+    console.error("Error connecting to MongoDB:", err);
+    throw err;
+  }
+};
+
 // src/service/updateAdStatus.ts
 async function updateAdStatuses() {
   const now = /* @__PURE__ */ new Date();
@@ -9618,9 +9823,9 @@ async function updateAdStatuses() {
 }
 
 // src/service/associate.ts
-var import_mongoose30 = __toESM(require("mongoose"));
+var import_mongoose31 = __toESM(require("mongoose"));
 function normalizeObjectId(id) {
-  return typeof id === "string" ? new import_mongoose30.default.Types.ObjectId(id) : id;
+  return typeof id === "string" ? new import_mongoose31.default.Types.ObjectId(id) : id;
 }
 async function getAssociateEmailsForResource({
   normalizedResourceId,
@@ -9772,12 +9977,12 @@ async function updateVendorBasedOnUserLicense(userId, licenceType) {
 }
 
 // src/service/objectIdToString.ts
-var import_mongoose33 = __toESM(require("mongoose"));
+var import_mongoose34 = __toESM(require("mongoose"));
 function convertObjectIdsToStrings(obj) {
   if (obj === null || obj === void 0) {
     return obj;
   }
-  if (obj instanceof import_mongoose33.default.Types.ObjectId) {
+  if (obj instanceof import_mongoose34.default.Types.ObjectId) {
     return obj.toString();
   }
   if (obj instanceof Date) {
@@ -9963,12 +10168,15 @@ function updateRelationDatesToUnavailable(relationDates, eventDateTime) {
   ACTIVE_NOT_DELETED_FILTER,
   AFFILIATE_REWARDS,
   activeAffiliateCodeExists,
+  awardAffiliateVendorSubscriptionRewards,
   connectToDatabase,
   convertObjectIdsToStrings,
   createAffiliateReward,
   didRemoveAnyEventDates,
   findAffiliateByPromoCode,
   findEventOrImportedMarketById,
+  getSubscriptionRewardPeriodBounds,
+  mapVendorLicenceToSubscriptionRewardType,
   normalizeAffiliatePromoCodes,
   normalizePromoCode,
   saveNotificationsInDb,