abmp-npm 10.3.15 → 10.3.17

package/backend/association-expiry.js

@@ -0,0 +1,144 @@
+// The per-association expiry rule, shared by the sync, the backfill and the read paths so they
+// cannot drift on what "expired" means. Deliberately free of Wix imports.
+
+const ASSOCIATION_EXPIRATION_FIELD = 'associationExpiration';
+const ASSOCIATION_TIME_ZONE = 'America/Denver';
+
+const EXPIRATION_DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})/;
+
+const EXPIRATION_OUTCOMES = {
+  RESOLVED: 'resolved',
+  NO_SITE_ASSOCIATION: 'noSiteAssociation',
+  NO_MEMBERSHIP_FOR_ASSOCIATION: 'noMembershipForAssociation',
+  MISSING_EXPIRATION: 'missingExpiration',
+  UNREADABLE_EXPIRATION: 'unreadableExpiration',
+};
+
+// PAC sends zoneless ISO strings, which `new Date()` would read as local time - the same feed
+// would then mean different days depending on where it ran.
+const parseExpirationToUtcDate = expiration => {
+  if (typeof expiration !== 'string') return null;
+
+  const match = EXPIRATION_DATE_PATTERN.exec(expiration.trim());
+  if (!match) return null;
+
+  const [, year, month, day] = match.map(Number);
+  const parsed = new Date(Date.UTC(year, month - 1, day));
+
+  // Date.UTC rolls 2026-02-31 forward to 3 March rather than rejecting it.
+  const isRealDate =
+    parsed.getUTCFullYear() === year &&
+    parsed.getUTCMonth() === month - 1 &&
+    parsed.getUTCDate() === day;
+
+  return isRealDate ? parsed : null;
+};
+
+// outcome explains a null date for the backfill report: no entry for this association is a very
+// different thing from a malformed one.
+const classifyAssociationExpiration = (member, siteAssociation) => {
+  if (!siteAssociation) {
+    return { date: null, outcome: EXPIRATION_OUTCOMES.NO_SITE_ASSOCIATION };
+  }
+
+  const memberships = Array.isArray(member?.memberships) ? member.memberships : [];
+  const membership = memberships.find(entry => entry?.association === siteAssociation);
+
+  if (!membership) {
+    return { date: null, outcome: EXPIRATION_OUTCOMES.NO_MEMBERSHIP_FOR_ASSOCIATION };
+  }
+
+  const raw = membership.expiration;
+  if (raw === null || raw === undefined || (typeof raw === 'string' && !raw.trim())) {
+    return { date: null, outcome: EXPIRATION_OUTCOMES.MISSING_EXPIRATION };
+  }
+
+  const date = parseExpirationToUtcDate(raw);
+
+  return date
+    ? { date, outcome: EXPIRATION_OUTCOMES.RESOLVED }
+    : { date: null, outcome: EXPIRATION_OUTCOMES.UNREADABLE_EXPIRATION };
+};
+
+const resolveAssociationExpiration = (member, siteAssociation) =>
+  classifyAssociationExpiration(member, siteAssociation).date;
+
+const summarizeExpirationOutcomes = (members = [], siteAssociation) => {
+  const counts = Object.values(EXPIRATION_OUTCOMES).reduce(
+    (acc, outcome) => ({ ...acc, [outcome]: 0 }),
+    {}
+  );
+
+  (Array.isArray(members) ? members : []).forEach(member => {
+    counts[classifyAssociationExpiration(member, siteAssociation).outcome] += 1;
+  });
+
+  return counts;
+};
+
+/** Keeps the backfill idempotent. Accepts a Date or the ISO string the CMS may return. */
+const memberNeedsAssociationExpirationBackfill = (member, siteAssociation) => {
+  const resolved = resolveAssociationExpiration(member, siteAssociation);
+  const stored = member?.[ASSOCIATION_EXPIRATION_FIELD];
+
+  const storedTime =
+    stored instanceof Date ? stored.getTime() : stored ? new Date(stored).getTime() : null;
+  const resolvedTime = resolved ? resolved.getTime() : null;
+
+  if (storedTime === null && resolvedTime === null) return false;
+  if (storedTime === null || resolvedTime === null) return true;
+
+  return storedTime !== resolvedTime;
+};
+
+// Today in Denver, where PAC operates. UTC rolls over first, so a UTC-derived today would hide
+// everyone expiring that day up to seven hours early, every evening.
+const getTodayInAssociationTimeZone = (now = new Date()) => {
+  try {
+    const parts = new Intl.DateTimeFormat('en-US', {
+      timeZone: ASSOCIATION_TIME_ZONE,
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+    }).formatToParts(now);
+
+    const valueOf = type => Number(parts.find(part => part.type === type)?.value);
+    const [year, month, day] = [valueOf('year'), valueOf('month'), valueOf('day')];
+
+    if (![year, month, day].every(Number.isFinite)) {
+      throw new Error('incomplete date parts');
+    }
+
+    return new Date(Date.UTC(year, month - 1, day));
+  } catch (error) {
+    // Hiding people a few hours early beats throwing on every search.
+    console.error(
+      `[associationExpiry] cannot resolve ${ASSOCIATION_TIME_ZONE}, using the UTC date instead. Members may be hidden up to 7 hours early. ${error.message}`
+    );
+    return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
+  }
+};
+
+// Mirrors the directory query's `.ge()` for a record already in hand, so search, the profile page
+// and the members area cannot disagree. Missing or unreadable is not current, as in the query.
+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,
+  resolveAssociationExpiration,
+  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,11 @@ function buildMembersSearchQuery(data) {
         .ne('action', 'drop')
         .ne('memberships.membertype', MEMBERSHIPS_TYPES.PAC_STAFF)
         .eq('isVisible', true);
+
+      // Filter in the query, not after it: count() and skip() in run() then page over the
+      // filtered set. Do not publish this to a site whose backfill has not run - members with no
+      // date are excluded, and before the backfill that is all of them.
+      query = query.ge(ASSOCIATION_EXPIRATION_FIELD, getTodayInAssociationTimeZone());
       let filterConfig = [
         {
           filterKey: 'practiceAreas',

package/backend/consts.js

@@ -43,6 +43,12 @@ const LOGIN_EMAIL_SYNC_STATUS = {
   SKIPPED: 'skipped', // member has no wixMemberId, nothing to change
 };
 
+// Thrown by the data layer, recognised by the login layer, which turns it into the ordinary error
+// response rather than a 500.
+const LOGIN_REFUSAL_REASONS = {
+  ASSOCIATION_MEMBERSHIP_EXPIRED: 'ASSOCIATION_MEMBERSHIP_EXPIRED',
+};
+
 module.exports = {
   CONFIG_KEYS,
   MAX__MEMBERS_SEARCH_RESULTS,
@@ -55,4 +61,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,9 @@ async function createCoreMemberData(inputMemberData, existingDbMember, currentPa
     memberships: inputMemberData.memberships,
     pageNumber: currentPageNumber,
     isVisible: inputMemberData.action !== MEMBER_ACTIONS.DROP,
+    // Belongs here, not in getNewMemberOnlyFields: that returns {} for existing members, so the
+    // date would never refresh on renewal and a member who paid would stay hidden. null = hidden.
+    [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,12 @@ async function synchronizeSinglePage(taskObject) {
       }
       return isUpdatedMember(member);
     });
-    const toSyncMembersWithFilteredLicenses = toSyncMembers.map(member =>
-      filterLicensesByAssociation(member, siteAssociation)
-    );
+    // Narrow each member to this site's association: licenses filtered to it, and its expiration
+    // lifted out of the memberships array into a scalar the directory query can filter on.
+    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

@@ -133,6 +133,27 @@ async function runDailyPullExecutionCheck(options = {}) {
   }
 }
 
+/**
+ * One-off backfill of associationExpiration. Run with `{ dryRun: true }` first: it counts the
+ * members that resolve to no date, and would therefore be hidden, without writing anything.
+ * @param {Object} [options]
+ * @param {boolean} [options.dryRun]
+ */
+async function scheduleAssociationExpiryBackfillTask(options = {}) {
+  try {
+    const { dryRun = false } = options || {};
+    console.log(`scheduleAssociationExpiryBackfill started! dryRun=${dryRun}`);
+    return await taskManager().schedule({
+      name: TASKS_NAMES.scheduleAssociationExpiryBackfill,
+      data: { dryRun },
+      type: 'scheduled',
+    });
+  } catch (error) {
+    console.error(`Failed to scheduleAssociationExpiryBackfill: ${error.message}`);
+    throw new Error(`Failed to scheduleAssociationExpiryBackfill: ${error.message}`);
+  }
+}
+
 async function updateSiteMapS3() {
   try {
     return await taskManager().schedule({
@@ -154,5 +175,6 @@ module.exports = {
   scheduleFixUrlsWithSpacesTask,
   scheduleNormalizeMemberEmailsTask,
   scheduleSetAddressesToCityStateTask,
+  scheduleAssociationExpiryBackfillTask,
   runDailyPullExecutionCheck,
 };

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,15 @@ async function validateMemberToken(memberIdInput) {
       return invalidTokenResponse;
     }
 
+    // Ends an already-open session once the association lapses. Without this, a member logged in
+    // before their expiry date keeps editing a listing the directory no longer shows.
+    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 +144,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,7 +1,8 @@
 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');
@@ -560,6 +561,22 @@ const getAllMembersWithoutContactFormEmail = async () => {
   }
 };
 
+/**
+ * Every member, unfiltered. Filtering would hide the very records the expiry backfill's report
+ * exists to surface - the ones with no readable expiration.
+ * @returns {Promise<Array>} - Array of member data
+ */
+const getAllMembers = async () => {
+  try {
+    const membersQuery = wixData.query(COLLECTIONS.MEMBERS_DATA).limit(1000);
+
+    return await queryAllItems(membersQuery);
+  } catch (error) {
+    console.error('Error getting all members:', error);
+    throw new Error(`Failed to get all members: ${error.message}`);
+  }
+};
+
 /**
  * Gets all members whose email or contactFormEmail is stored with non-canonical casing
  * (or surrounding whitespace) and therefore needs the normalization backfill.
@@ -680,6 +697,14 @@ async function prepareMemberForSSOLogin(data) {
     if (!memberData) {
       throw new Error(`Member data not found for memberId ${memberId}`);
     }
+    // Before ensureWixMemberAndContactExist, which creates the Wix member and contact when they are
+    // missing - refusing later would still provision an account for someone who cannot use it.
+    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) {
@@ -775,6 +800,7 @@ module.exports = {
   getAllMembersWithExternalImages,
   getMembersWithWixUrl,
   getAllMembersWithoutContactFormEmail,
+  getAllMembers,
   getAllMembersNeedingEmailNormalization,
   memberNeedsEmailNormalization,
   getAllUpdatedLoginEmails,

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,13 @@ const getMemberProfileData = async (slug, siteAssociation) => {
       return null;
     }
 
+    // Gated here rather than in getMemberBySlug: that also backs URL uniqueness during the sync,
+    // where an expired member's slug must still count as taken or a new member could claim it.
+    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/association-expiry-backfill-methods.js

@@ -0,0 +1,178 @@
+const { taskManager } = require('psdev-task-manager');
+
+const {
+  memberNeedsAssociationExpirationBackfill,
+  resolveAssociationExpiration,
+  summarizeExpirationOutcomes,
+  ASSOCIATION_EXPIRATION_FIELD,
+  EXPIRATION_OUTCOMES,
+} = require('../association-expiry');
+const { CONFIG_KEYS } = require('../consts');
+const { bulkSaveMembers, getMembersByIds, getAllMembers } = require('../members-data-methods');
+const { chunkArray, getSiteConfigs } = require('../utils');
+
+const { TASKS_NAMES } = require('./consts');
+
+const CHUNK_SIZE = 1000;
+
+/**
+ * One-off backfill of associationExpiration for members the daily sync will not touch.
+ * @param {Object} [data]
+ * @param {boolean} [data.dryRun] count without writing
+ */
+async function scheduleAssociationExpiryBackfill(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(
+      `scheduleAssociationExpiryBackfill 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 Association Expiry Backfill${dryRun ? ' (DRY RUN)' : ''} ===`);
+
+  try {
+    const siteAssociation = await getSiteConfigs(CONFIG_KEYS.SITE_ASSOCIATION);
+    if (!siteAssociation) {
+      // Every member would resolve to null, i.e. hidden.
+      throw new Error('SITE_ASSOCIATION is not configured; refusing to run the backfill');
+    }
+
+    const members = await getAllMembers();
+    console.log(`Fetched ${members.length} members for association '${siteAssociation}'`);
+
+    // Over every member, not just those needing a write, so a re-run still reports the true total.
+    const outcomes = summarizeExpirationOutcomes(members, siteAssociation);
+    const hiddenByThisChange =
+      outcomes[EXPIRATION_OUTCOMES.NO_MEMBERSHIP_FOR_ASSOCIATION] +
+      outcomes[EXPIRATION_OUTCOMES.MISSING_EXPIRATION] +
+      outcomes[EXPIRATION_OUTCOMES.UNREADABLE_EXPIRATION];
+
+    console.log(`Outcome breakdown: ${JSON.stringify(outcomes)}`);
+    console.log(
+      `Will resolve to no date, so hidden once the query gates on it: ${hiddenByThisChange} of ${members.length}`
+    );
+
+    const memberIds = [
+      ...new Set(
+        members
+          .filter(member => memberNeedsAssociationExpirationBackfill(member, siteAssociation))
+          .map(member => Number(member.memberId))
+          .filter(memberId => Number.isFinite(memberId) && memberId > 0)
+      ),
+    ];
+    console.log(`Members whose stored value is out of date: ${memberIds.length}`);
+
+    const summary = {
+      success: true,
+      dryRun,
+      siteAssociation,
+      totalMembers: members.length,
+      outcomes,
+      hiddenByThisChange,
+      membersNeedingUpdate: memberIds.length,
+      tasksScheduled: 0,
+    };
+
+    if (dryRun) {
+      summary.message = `Dry run: nothing written. ${hiddenByThisChange} of ${members.length} members resolve to no date`;
+      console.log('=== Dry Run Complete, nothing written ===');
+      console.log(JSON.stringify(summary, null, 2));
+      return summary;
+    }
+
+    if (memberIds.length === 0) {
+      summary.message = 'Every member already has the correct associationExpiration';
+      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.associationExpiryBackfillChunk,
+        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 association expiry backfill:', error);
+    throw error;
+  }
+}
+
+/**
+ * Members are reloaded and re-resolved rather than trusting the queued data: a chunk can run long
+ * after it was scheduled, and the daily sync may have rewritten the record in between.
+ */
+async function associationExpiryBackfillChunk(data) {
+  const { memberIds, chunkIndex, totalChunks } = data;
+  console.log(
+    `Processing association expiry chunk ${chunkIndex + 1}/${totalChunks} (${memberIds.length} members)`
+  );
+
+  const result = {
+    successful: 0,
+    failed: 0,
+    skipped: 0,
+    errors: [],
+    failedIds: [],
+  };
+
+  try {
+    const siteAssociation = await getSiteConfigs(CONFIG_KEYS.SITE_ASSOCIATION);
+    if (!siteAssociation) {
+      throw new Error('SITE_ASSOCIATION is not configured; refusing to write');
+    }
+
+    const members = await getMembersByIds(memberIds);
+    console.log(`Loaded ${members.length} members for this chunk`);
+
+    const membersToUpdate = members
+      .filter(member => memberNeedsAssociationExpirationBackfill(member, siteAssociation))
+      .map(member => ({
+        ...member,
+        [ASSOCIATION_EXPIRATION_FIELD]: resolveAssociationExpiration(member, siteAssociation),
+      }));
+
+    result.skipped = members.length - membersToUpdate.length;
+    result.outcomes = summarizeExpirationOutcomes(members, siteAssociation);
+
+    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 association expiry chunk ${chunkIndex}:`, error);
+    throw error;
+  }
+}
+
+module.exports = {
+  scheduleAssociationExpiryBackfill,
+  associationExpiryBackfillChunk,
+};

package/backend/tasks/consts.js

@@ -27,6 +27,8 @@ const TASKS_NAMES = {
   scheduleNormalizeMemberEmails: 'scheduleNormalizeMemberEmails',
   normalizeMemberEmailsChunk: 'normalizeMemberEmailsChunk',
   dailyPullExecutionCheck: 'dailyPullExecutionCheck',
+  scheduleAssociationExpiryBackfill: 'scheduleAssociationExpiryBackfill',
+  associationExpiryBackfillChunk: 'associationExpiryBackfillChunk',
 };
 
 module.exports = {

package/backend/tasks/index.js

@@ -7,4 +7,5 @@ module.exports = {
   ...require('./address-primary-methods'),
   ...require('./url-space-fix-methods'),
   ...require('./daily-pull-check-methods'),
+  ...require('./association-expiry-backfill-methods'),
 };

package/backend/tasks/tasks-configs.js

@@ -12,6 +12,10 @@ const {
   scheduleSetAddressesToCityState,
   setAddressesToCityStateChunk,
 } = require('./address-visibility-methods');
+const {
+  scheduleAssociationExpiryBackfill,
+  associationExpiryBackfillChunk,
+} = require('./association-expiry-backfill-methods');
 const { TASKS_NAMES } = require('./consts');
 const { dailyPullExecutionCheck } = require('./daily-pull-check-methods');
 const {
@@ -239,6 +243,23 @@ const TASKS = {
     shouldSkipCheck: () => false,
     estimatedDurationSec: 80,
   },
+  [TASKS_NAMES.scheduleAssociationExpiryBackfill]: {
+    name: TASKS_NAMES.scheduleAssociationExpiryBackfill,
+    // Must pass task.data through - process() receives this, and the backfill needs its dryRun.
+    getIdentifier: task => task.data,
+    process: scheduleAssociationExpiryBackfill,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 120,
+  },
+  [TASKS_NAMES.associationExpiryBackfillChunk]: {
+    name: TASKS_NAMES.associationExpiryBackfillChunk,
+    getIdentifier: task => task.data,
+    process: associationExpiryBackfillChunk,
+    shouldSkipCheck: () => false,
+    // A packing budget, not a timeout: the manager fills each 240s tick with tasks costing
+    // estimate x 1.5. Chunks measured at ~6.5s, so 10 gives 16 per tick with room to spare.
+    estimatedDurationSec: 10,
+  },
   [TASKS_NAMES.dailyPullExecutionCheck]: {
     name: TASKS_NAMES.dailyPullExecutionCheck,
     getIdentifier: task => task.data,

package/package.json

@@ -1,7 +1,14 @@
 {
   "name": "abmp-npm",
-  "version": "10.3.15",
+  "version": "10.3.17",
   "main": "index.js",
+  "files": [
+    "index.js",
+    "backend",
+    "pages",
+    "public",
+    "!backend/__tests__"
+  ],
   "scripts": {
     "check-cycles": "madge --circular .",
     "test": "jest backend/__tests__",

package/pages/Home.js

@@ -3,14 +3,14 @@ const { location: wixLocation } = require('@wix/site-location');
 const { window: wixWindow, rendering } = require('@wix/site-window');
 const { withWarmUpData } = require('psdev-utils/frontend');
 
-const { ADDRESS_STATUS_TYPES, DEFAULT_FILTER, DROPDOWN_OPTIONS } = require('../public/consts.js');
+const { DEFAULT_FILTER, DROPDOWN_OPTIONS } = require('../public/consts.js');
 const { createHomepageUtils } = require('../public/Utils/homePage.js');
 const {
   getMainAddress,
   formatPracticeAreasForDisplay,
-  checkAddressIsVisible,
   isWixHostedImage,
   normalizeExternalUrl,
+  buildDirectionsLink,
 } = require('../public/Utils/sharedUtils.js');
 
 let filter = JSON.parse(JSON.stringify(DEFAULT_FILTER));
@@ -225,20 +225,18 @@ const homePageOnReady = async ({
         $item('#milesAwayText').text = '';
       }
 
-      // 7) "Show maps" button enabled only if there's a full address with valid coordinates
-      const visible = checkAddressIsVisible(addresses);
-      const fullAddressWithValidCoords = visible.find(
-        addr =>
-          addr.addressStatus === ADDRESS_STATUS_TYPES.FULL_ADDRESS &&
-          addr.latitude &&
-          addr.longitude
-      );
+      // 7) "Show maps" button - only for members who selected "Show Full Address".
+      //
+      // buildDirectionsLink owns the rule and returns '' when the button should be
+      // hidden: city/state/ZIP and hidden members get nothing, and a full-address
+      // member gets a link built from their address text rather than their NetForum
+      // coordinates, which are unreliable (Monday 12596102059).
+      const mapLink = buildDirectionsLink(itemData.addressDisplayOption, addresses);
 
-      if (fullAddressWithValidCoords) {
+      if (mapLink) {
         $item('#showMaps').enable();
         $item('#showMaps').show();
-        const { latitude, longitude } = fullAddressWithValidCoords;
-        $item('#showMaps').link = `https://maps.google.com/?q=${latitude},${longitude}`;
+        $item('#showMaps').link = mapLink;
         $item('#showMaps').target = '_blank';
       } else {
         $item('#showMaps').hide();