abmp-npm 2.0.82 → 2.0.84

package/backend/association-expiry.js

@@ -119,6 +119,15 @@ const getTodayInAssociationTimeZone = (now = new Date()) => {
   }
 };
 
+const isAssociationExpirationCurrent = (member, now) => {
+  const stored = member?.[ASSOCIATION_EXPIRATION_FIELD];
+  const expiration = stored instanceof Date ? stored : stored ? new Date(stored) : null;
+
+  if (!expiration || Number.isNaN(expiration.getTime())) return false;
+
+  return expiration.getTime() >= getTodayInAssociationTimeZone(now).getTime();
+};
+
 module.exports = {
   parseExpirationToUtcDate,
   classifyAssociationExpiration,
@@ -126,6 +135,7 @@ module.exports = {
   summarizeExpirationOutcomes,
   memberNeedsAssociationExpirationBackfill,
   getTodayInAssociationTimeZone,
+  isAssociationExpirationCurrent,
   ASSOCIATION_EXPIRATION_FIELD,
   ASSOCIATION_TIME_ZONE,
   EXPIRATION_OUTCOMES,

package/backend/cms-data-methods.js

@@ -4,6 +4,10 @@ const { COLLECTIONS, MEMBERS_FIELDS } = require('../public/consts.js');
 const { findMainAddress } = require('../public/Utils/sharedUtils.js');
 const { calculateDistance, shuffleArray } = require('../public/Utils/sharedUtils.js');
 
+const {
+  getTodayInAssociationTimeZone,
+  ASSOCIATION_EXPIRATION_FIELD,
+} = require('./association-expiry');
 const {
   GEO_HASH_PRECISION,
   MAX__MEMBERS_SEARCH_RESULTS,
@@ -34,6 +38,8 @@ function buildMembersSearchQuery(data) {
         .ne('action', 'drop')
         .ne('memberships.membertype', MEMBERSHIPS_TYPES.PAC_STAFF)
         .eq('isVisible', true);
+
+      query = query.ge(ASSOCIATION_EXPIRATION_FIELD, getTodayInAssociationTimeZone());
       let filterConfig = [
         {
           filterKey: 'practiceAreas',

package/backend/consts.js

@@ -43,6 +43,10 @@ const LOGIN_EMAIL_SYNC_STATUS = {
   SKIPPED: 'skipped', // member has no wixMemberId, nothing to change
 };
 
+const LOGIN_REFUSAL_REASONS = {
+  ASSOCIATION_MEMBERSHIP_EXPIRED: 'ASSOCIATION_MEMBERSHIP_EXPIRED',
+};
+
 module.exports = {
   CONFIG_KEYS,
   MAX__MEMBERS_SEARCH_RESULTS,
@@ -55,4 +59,5 @@ module.exports = {
   SSO_TOKEN_AUTH_API_URL,
   BACKUP_API_URL,
   LOGIN_EMAIL_SYNC_STATUS,
+  LOGIN_REFUSAL_REASONS,
 };

package/backend/daily-pull/process-member-methods.js

@@ -1,4 +1,5 @@
 const { ADDRESS_STATUS_TYPES } = require('../../public/consts');
+const { ASSOCIATION_EXPIRATION_FIELD } = require('../association-expiry');
 const { findMemberById, getMemberBySlug } = require('../members-data-methods');
 const { isValidArray, generateGeoHash } = require('../utils');
 
@@ -198,6 +199,7 @@ async function createCoreMemberData(inputMemberData, existingDbMember, currentPa
     memberships: inputMemberData.memberships,
     pageNumber: currentPageNumber,
     isVisible: inputMemberData.action !== MEMBER_ACTIONS.DROP,
+    [ASSOCIATION_EXPIRATION_FIELD]: inputMemberData[ASSOCIATION_EXPIRATION_FIELD] ?? null,
 
     // Handle Member emails
     ...getMemberEmails(),

package/backend/daily-pull/sync-to-cms-methods.js

@@ -1,5 +1,9 @@
 const { taskManager } = require('psdev-task-manager');
 
+const {
+  resolveAssociationExpiration,
+  ASSOCIATION_EXPIRATION_FIELD,
+} = require('../association-expiry');
 const { CONFIG_KEYS } = require('../consts');
 const { fetchPACMembers } = require('../pac-api-methods');
 const { TASKS_NAMES } = require('../tasks/consts');
@@ -126,9 +130,10 @@ async function synchronizeSinglePage(taskObject) {
       }
       return isUpdatedMember(member);
     });
-    const toSyncMembersWithFilteredLicenses = toSyncMembers.map(member =>
-      filterLicensesByAssociation(member, siteAssociation)
-    );
+    const toSyncMembersWithFilteredLicenses = toSyncMembers.map(member => ({
+      ...filterLicensesByAssociation(member, siteAssociation),
+      [ASSOCIATION_EXPIRATION_FIELD]: resolveAssociationExpiration(member, siteAssociation),
+    }));
     if (toSyncMembers.length === 0) {
       return {
         success: true,

package/backend/jobs.js

@@ -154,6 +154,27 @@ async function scheduleAssociationExpiryBackfillTask(options = {}) {
   }
 }
 
+/**
+ * One-off backfill of memberUpdated. Run with `{ dryRun: true }` first: it reports the tier split
+ * across the whole collection without writing anything.
+ * @param {Object} [options]
+ * @param {boolean} [options.dryRun]
+ */
+async function scheduleMemberUpdatedBackfillTask(options = {}) {
+  try {
+    const { dryRun = false } = options || {};
+    console.log(`scheduleMemberUpdatedBackfill started! dryRun=${dryRun}`);
+    return await taskManager().schedule({
+      name: TASKS_NAMES.scheduleMemberUpdatedBackfill,
+      data: { dryRun },
+      type: 'scheduled',
+    });
+  } catch (error) {
+    console.error(`Failed to scheduleMemberUpdatedBackfill: ${error.message}`);
+    throw new Error(`Failed to scheduleMemberUpdatedBackfill: ${error.message}`);
+  }
+}
+
 async function updateSiteMapS3() {
   try {
     return await taskManager().schedule({
@@ -176,5 +197,6 @@ module.exports = {
   scheduleNormalizeMemberEmailsTask,
   scheduleSetAddressesToCityStateTask,
   scheduleAssociationExpiryBackfillTask,
+  scheduleMemberUpdatedBackfillTask,
   runDailyPullExecutionCheck,
 };

package/backend/listing-priority.js

@@ -0,0 +1,66 @@
+// What makes a listing "updated", shared by the backfill and the search ordering so they cannot
+// drift on the definition. Deliberately free of Wix imports.
+//
+// The flag is the durable answer: once a member saves their form it is set and stays set. The
+// content check below is only how we approximate that for members who saved before the flag
+// existed, which is why the backfill sets it true and never back to false.
+
+const MEMBER_UPDATED_FIELD = 'memberUpdated';
+
+// The five fields the PAC migration had no counterpart for, so content in any of them can only
+// have been entered by the member. profileImage and businessName hold strings; gallery,
+// bannerImages and testimonial hold arrays.
+const MEMBER_ENTERED_FIELDS = [
+  'profileImage',
+  'gallery',
+  'bannerImages',
+  'testimonial',
+  'businessName',
+];
+
+const hasContent = value => {
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === 'string') return value.trim() !== '';
+  return false;
+};
+
+const hasMemberEnteredContent = (member = {}) =>
+  MEMBER_ENTERED_FIELDS.some(field => hasContent(member?.[field]));
+
+const isMemberUpdated = member => member?.[MEMBER_UPDATED_FIELD] === true;
+
+const memberNeedsUpdatedFlagBackfill = member =>
+  hasMemberEnteredContent(member) && !isMemberUpdated(member);
+
+/**
+ * Counts for the dry run, over every member rather than only those needing a write, so a re-run
+ * still reports the true tier split.
+ * @param {Array} members
+ * @returns {{total: number, tierOne: number, tierTwo: number, alreadyFlagged: number, needingBackfill: number}}
+ */
+const summarizeUpdatedOutcomes = (members = []) => {
+  const summary = {
+    total: members.length,
+    tierOne: 0,
+    tierTwo: 0,
+    alreadyFlagged: 0,
+    needingBackfill: 0,
+  };
+  members.forEach(member => {
+    const flagged = isMemberUpdated(member);
+    const willBeTierOne = flagged || hasMemberEnteredContent(member);
+    willBeTierOne ? (summary.tierOne += 1) : (summary.tierTwo += 1);
+    if (flagged) summary.alreadyFlagged += 1;
+    if (memberNeedsUpdatedFlagBackfill(member)) summary.needingBackfill += 1;
+  });
+  return summary;
+};
+
+module.exports = {
+  MEMBER_UPDATED_FIELD,
+  MEMBER_ENTERED_FIELDS,
+  hasMemberEnteredContent,
+  isMemberUpdated,
+  memberNeedsUpdatedFlagBackfill,
+  summarizeUpdatedOutcomes,
+};

package/backend/login/sso-methods.js

@@ -3,7 +3,8 @@ const { createHmac } = require('crypto');
 const axios = require('axios');
 const { decode } = require('jwt-js-decode');
 
-const { CONFIG_KEYS, SSO_TOKEN_AUTH_API_URL } = require('../consts');
+const { isAssociationExpirationCurrent } = require('../association-expiry');
+const { CONFIG_KEYS, SSO_TOKEN_AUTH_API_URL, LOGIN_REFUSAL_REASONS } = require('../consts');
 const { MEMBER_ACTIONS } = require('../daily-pull/consts');
 const { getCurrentMember } = require('../members-area-methods');
 const { getCMSMemberByWixMemberId, prepareMemberForSSOLogin } = require('../members-data-methods');
@@ -79,6 +80,13 @@ async function validateMemberToken(memberIdInput) {
       return invalidTokenResponse;
     }
 
+    if (!isAssociationExpirationCurrent(memberData)) {
+      console.log(
+        `[validateMemberToken] association membership expired for memberId ${memberData.memberId}`
+      );
+      return invalidTokenResponse;
+    }
+
     // Add computed properties
     memberData.addressDisplayOption = getAddressDisplayOptions(memberData);
     console.log('memberData', memberData);
@@ -134,7 +142,14 @@ const authenticateSSOToken = async ({ token }) => {
   if (isValidToken) {
     const jwt = decode(responseToken);
     const payload = jwt.payload;
-    const memberData = await prepareMemberForSSOLogin(payload);
+    let memberData;
+    try {
+      memberData = await prepareMemberForSSOLogin(payload);
+    } catch (error) {
+      if (error.message !== LOGIN_REFUSAL_REASONS.ASSOCIATION_MEMBERSHIP_EXPIRED) throw error;
+      console.log('[authenticateSSOToken] refusing login, association membership expired');
+      return { type: 'error', memberId: '', sessionToken: '' };
+    }
     console.log('memberDataCollectionId', memberData._id);
     const sessionToken = await generateMemberSessionToken(memberData.email);
     const authObj = {

package/backend/members-data-methods.js

@@ -1,10 +1,12 @@
 const { COLLECTIONS } = require('../public/consts');
 const { isWixHostedImage, emailsMatch, normalizeEmail } = require('../public/Utils/sharedUtils');
 
-const { MEMBERSHIPS_TYPES } = require('./consts');
+const { isAssociationExpirationCurrent } = require('./association-expiry');
+const { MEMBERSHIPS_TYPES, LOGIN_REFUSAL_REASONS } = require('./consts');
 const { createSiteContact } = require('./contacts-methods');
 const { MEMBER_ACTIONS } = require('./daily-pull/consts');
 const { wixData } = require('./elevated-modules');
+const { MEMBER_UPDATED_FIELD } = require('./listing-priority');
 const { updateMemberContactInfo } = require('./member-contact-orchestration');
 const { createSiteMember, getCurrentMember } = require('./members-area-methods');
 const {
@@ -423,6 +425,9 @@ async function saveRegistrationData(data, id) {
     const mergedData = {
       ...existingMemberData,
       ...data,
+      // Every member-facing save funnels through here, and PAC asked for any save to count.
+      // Never set back to false: it records that the member has been in, not what they left behind.
+      [MEMBER_UPDATED_FIELD]: true,
     };
 
     if (data.addresses && Array.isArray(data.addresses)) {
@@ -696,6 +701,12 @@ async function prepareMemberForSSOLogin(data) {
     if (!memberData) {
       throw new Error(`Member data not found for memberId ${memberId}`);
     }
+    if (!isAssociationExpirationCurrent(memberData)) {
+      console.log(
+        `[prepareMemberForSSOLogin] refusing login, association membership expired for memberId ${memberId}`
+      );
+      throw new Error(LOGIN_REFUSAL_REASONS.ASSOCIATION_MEMBERSHIP_EXPIRED);
+    }
     console.log('memberData', memberData);
     return await ensureWixMemberAndContactExist(memberData);
   } catch (error) {

package/backend/routers/utils.js

@@ -1,4 +1,5 @@
 const { getMainAddress } = require('../../public/Utils/sharedUtils');
+const { isAssociationExpirationCurrent } = require('../association-expiry');
 const { getMemberBySlug } = require('../members-data-methods');
 const {
   getMoreAddressesToDisplay,
@@ -113,6 +114,11 @@ const getMemberProfileData = async (slug, siteAssociation) => {
       return null;
     }
 
+    if (!isAssociationExpirationCurrent(member)) {
+      console.log(`[getMemberProfileData] Association membership expired for slug: ${slug}`);
+      return null;
+    }
+
     return transformMemberToProfileData(member, siteAssociation);
   } catch (error) {
     const errorMessage = `Error in getMemberProfileData for slug: ${slug} : ${error.message}`;

package/backend/tasks/consts.js

@@ -29,6 +29,8 @@ const TASKS_NAMES = {
   dailyPullExecutionCheck: 'dailyPullExecutionCheck',
   scheduleAssociationExpiryBackfill: 'scheduleAssociationExpiryBackfill',
   associationExpiryBackfillChunk: 'associationExpiryBackfillChunk',
+  scheduleMemberUpdatedBackfill: 'scheduleMemberUpdatedBackfill',
+  memberUpdatedBackfillChunk: 'memberUpdatedBackfillChunk',
 };
 
 module.exports = {

package/backend/tasks/member-updated-backfill-methods.js

@@ -0,0 +1,158 @@
+const { taskManager } = require('psdev-task-manager');
+
+const {
+  MEMBER_UPDATED_FIELD,
+  memberNeedsUpdatedFlagBackfill,
+  summarizeUpdatedOutcomes,
+} = require('../listing-priority');
+const { bulkSaveMembers, getMembersByIds, getAllMembers } = require('../members-data-methods');
+const { chunkArray } = require('../utils');
+
+const { TASKS_NAMES } = require('./consts');
+
+const CHUNK_SIZE = 1000;
+
+/**
+ * One-off backfill of memberUpdated for members who filled their listing out before the flag
+ * existed. Sets the flag true and never false: it records that the member has been in, so a
+ * listing that was filled and later emptied keeps it.
+ * @param {Object} [data]
+ * @param {boolean} [data.dryRun] count without writing
+ */
+async function scheduleMemberUpdatedBackfill(data = {}) {
+  // process() receives whatever getIdentifier returns. A sentinel string there would read as
+  // dryRun: false and write to every member instead of counting them.
+  if (data === null || typeof data !== 'object') {
+    throw new Error(
+      `scheduleMemberUpdatedBackfill expected its task data object but received ${typeof data}. ` +
+        'Check getIdentifier for this task in tasks-configs.js: it must be `task => task.data`.'
+    );
+  }
+
+  const dryRun = data.dryRun === true;
+  console.log(`=== Scheduling Member Updated Backfill${dryRun ? ' (DRY RUN)' : ''} ===`);
+
+  try {
+    const members = await getAllMembers();
+    console.log(`Fetched ${members.length} members`);
+
+    // Over every member, not just those needing a write, so a re-run still reports the true split.
+    const outcomes = summarizeUpdatedOutcomes(members);
+    const tierOneShare = members.length
+      ? ((outcomes.tierOne / members.length) * 100).toFixed(1)
+      : '0.0';
+
+    console.log(`Outcome breakdown: ${JSON.stringify(outcomes)}`);
+    console.log(`Will rank first: ${outcomes.tierOne} of ${members.length} (${tierOneShare}%)`);
+
+    const memberIds = [
+      ...new Set(
+        members
+          .filter(memberNeedsUpdatedFlagBackfill)
+          .map(member => Number(member.memberId))
+          .filter(memberId => Number.isFinite(memberId) && memberId > 0)
+      ),
+    ];
+    console.log(`Members whose flag is not yet set: ${memberIds.length}`);
+
+    const summary = {
+      success: true,
+      dryRun,
+      totalMembers: members.length,
+      outcomes,
+      tierOneShare: `${tierOneShare}%`,
+      membersNeedingUpdate: memberIds.length,
+      tasksScheduled: 0,
+    };
+
+    if (dryRun) {
+      summary.message = `Dry run: nothing written. ${outcomes.tierOne} of ${members.length} members (${tierOneShare}%) would rank first`;
+      console.log('=== Dry Run Complete, nothing written ===');
+      console.log(JSON.stringify(summary, null, 2));
+      return summary;
+    }
+
+    if (memberIds.length === 0) {
+      summary.message = 'Every member who has entered content is already flagged';
+      console.log(summary.message);
+      return summary;
+    }
+
+    const chunks = chunkArray(memberIds, CHUNK_SIZE);
+    for (let i = 0; i < chunks.length; i++) {
+      await taskManager().schedule({
+        name: TASKS_NAMES.memberUpdatedBackfillChunk,
+        data: { memberIds: chunks[i], chunkIndex: i, totalChunks: chunks.length },
+        type: 'scheduled',
+      });
+      console.log(`Scheduled task ${i + 1}/${chunks.length} (${chunks[i].length} members)`);
+    }
+
+    summary.tasksScheduled = chunks.length;
+    summary.message = `Scheduled ${chunks.length} tasks for ${memberIds.length} members`;
+
+    console.log('=== Scheduling Complete ===');
+    console.log(JSON.stringify(summary, null, 2));
+
+    return summary;
+  } catch (error) {
+    console.error('Error scheduling member updated backfill:', error);
+    throw error;
+  }
+}
+
+/**
+ * Members are reloaded and re-checked rather than trusting the queued data: a chunk can run long
+ * after it was scheduled, and the member may have saved their form in between.
+ */
+async function memberUpdatedBackfillChunk(data) {
+  const { memberIds, chunkIndex, totalChunks } = data;
+  console.log(
+    `Processing member updated chunk ${chunkIndex + 1}/${totalChunks} (${memberIds.length} members)`
+  );
+
+  const result = {
+    successful: 0,
+    failed: 0,
+    skipped: 0,
+    errors: [],
+    failedIds: [],
+  };
+
+  try {
+    const members = await getMembersByIds(memberIds);
+    console.log(`Loaded ${members.length} members for this chunk`);
+
+    const membersToUpdate = members
+      .filter(memberNeedsUpdatedFlagBackfill)
+      .map(member => ({ ...member, [MEMBER_UPDATED_FIELD]: true }));
+
+    result.skipped = members.length - membersToUpdate.length;
+
+    if (membersToUpdate.length === 0) {
+      console.log('No members need updating in this batch');
+      return result;
+    }
+
+    try {
+      await bulkSaveMembers(membersToUpdate);
+      result.successful += membersToUpdate.length;
+      console.log(`✅ Successfully backfilled ${membersToUpdate.length} members`);
+    } catch (error) {
+      console.error('❌ Error bulk saving members:', error);
+      result.failed += membersToUpdate.length;
+      result.failedIds.push(...membersToUpdate.map(member => member.memberId));
+      result.errors.push({ error: error.message, memberCount: membersToUpdate.length });
+    }
+
+    return result;
+  } catch (error) {
+    console.error(`Error processing member updated chunk ${chunkIndex}:`, error);
+    throw error;
+  }
+}
+
+module.exports = {
+  scheduleMemberUpdatedBackfill,
+  memberUpdatedBackfillChunk,
+};

package/backend/tasks/tasks-configs.js

@@ -22,6 +22,10 @@ const {
   scheduleNormalizeMemberEmails,
   normalizeMemberEmailsChunk,
 } = require('./email-normalize-methods');
+const {
+  scheduleMemberUpdatedBackfill,
+  memberUpdatedBackfillChunk,
+} = require('./member-updated-backfill-methods');
 const {
   scheduleTaskForEmptyAboutYouMembers,
   convertAboutYouHtmlToRichContent,
@@ -251,6 +255,23 @@ const TASKS = {
     shouldSkipCheck: () => false,
     estimatedDurationSec: 120,
   },
+  [TASKS_NAMES.scheduleMemberUpdatedBackfill]: {
+    name: TASKS_NAMES.scheduleMemberUpdatedBackfill,
+    // Must pass task.data through - process() receives this, and the backfill needs its dryRun.
+    getIdentifier: task => task.data,
+    process: scheduleMemberUpdatedBackfill,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 120,
+  },
+  [TASKS_NAMES.memberUpdatedBackfillChunk]: {
+    name: TASKS_NAMES.memberUpdatedBackfillChunk,
+    getIdentifier: task => task.data,
+    process: memberUpdatedBackfillChunk,
+    shouldSkipCheck: () => false,
+    // A packing budget, not a timeout. Same shape of write as the expiry chunks, which measured
+    // at ~6.5s, so 10 leaves the manager room in each 240s tick.
+    estimatedDurationSec: 10,
+  },
   [TASKS_NAMES.associationExpiryBackfillChunk]: {
     name: TASKS_NAMES.associationExpiryBackfillChunk,
     getIdentifier: task => task.data,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abmp-npm",
-  "version": "2.0.82",
+  "version": "2.0.84",
   "main": "index.js",
   "files": [
     "index.js",

package/public/consts.js

@@ -76,6 +76,8 @@ const MEMBERS_FIELDS = {
   memberships: 'memberships',
   showWebsite: 'showWebsite',
   addressDisplayOption: 'addressDisplayOption',
+  // Search projects only these fields, so the tier is invisible to the ordering code without it.
+  memberUpdated: 'memberUpdated',
 };
 
 const LIGHTBOX_NAMES = {