abmp-npm 10.0.49 → 10.0.50

package/backend/jobs.js

@@ -68,6 +68,34 @@ async function scheduleCreateContactsFromMembersTask() {
   }
 }
 
+async function scheduleFixPrimaryAddressForMembersTask() {
+  try {
+    console.log('scheduleFixPrimaryAddressForMembers started!');
+    return await taskManager().schedule({
+      name: TASKS_NAMES.scheduleFixPrimaryAddressForMembers,
+      data: {},
+      type: 'scheduled',
+    });
+  } catch (error) {
+    console.error(`Failed to scheduleFixPrimaryAddressForMembers: ${error.message}`);
+    throw new Error(`Failed to scheduleFixPrimaryAddressForMembers: ${error.message}`);
+  }
+}
+
+async function scheduleFixPrimaryAddressVisibilityForMembersTask() {
+  try {
+    console.log('scheduleFixPrimaryAddressVisibilityForMembers started!');
+    return await taskManager().schedule({
+      name: TASKS_NAMES.scheduleFixPrimaryAddressVisibilityForMembers,
+      data: {},
+      type: 'scheduled',
+    });
+  } catch (error) {
+    console.error(`Failed to scheduleFixPrimaryAddressVisibilityForMembers: ${error.message}`);
+    throw new Error(`Failed to scheduleFixPrimaryAddressVisibilityForMembers: ${error.message}`);
+  }
+}
+
 async function updateSiteMapS3() {
   try {
     return await taskManager().schedule({
@@ -85,4 +113,6 @@ module.exports = {
   scheduleDailyPullTask,
   updateSiteMapS3,
   scheduleCreateContactsFromMembersTask,
+  scheduleFixPrimaryAddressForMembersTask,
+  scheduleFixPrimaryAddressVisibilityForMembersTask,
 };

package/backend/tasks/address-primary-methods.js

@@ -0,0 +1,424 @@
+const { taskManager } = require('psdev-task-manager');
+
+const { COLLECTIONS, ADDRESS_STATUS_TYPES } = require('../../public/consts');
+const { wixData } = require('../elevated-modules');
+const { bulkSaveMembers, getMembersByIds } = require('../members-data-methods');
+const { chunkArray, queryAllItems } = require('../utils');
+
+const { TASKS_NAMES } = require('./consts');
+
+const CHUNK_SIZE = 1000;
+
+const getAddressKey = (address, index) =>
+  address?.key || address?.addressid || address?.addressId || `address_${index}`;
+
+const hasPrimaryAddress = addressDisplayOption =>
+  Array.isArray(addressDisplayOption) &&
+  addressDisplayOption.some(option => option?.isMain === true);
+
+const getPrimaryAddressKey = addressDisplayOption =>
+  Array.isArray(addressDisplayOption)
+    ? addressDisplayOption.find(option => option?.isMain === true)?.key
+    : null;
+
+const needsPrimaryAddressVisibilityFix = (address, index) => {
+  if (!address) {
+    return false;
+  }
+  const status = address?.addressStatus;
+  if (index === 0 && status === ADDRESS_STATUS_TYPES.DONT_SHOW) {
+    return true;
+  }
+  return !status || status === ADDRESS_STATUS_TYPES.DONT_SHOW;
+};
+
+/**
+ * Schedules tasks to fix members with multiple addresses and no primary address.
+ */
+async function scheduleFixPrimaryAddressForMembers() {
+  console.log('=== Scheduling Fix Primary Address Tasks ===');
+
+  try {
+    const membersQuery = await wixData
+      .query(COLLECTIONS.MEMBERS_DATA)
+      .isNotEmpty('addresses')
+      .limit(1000);
+    const members = await queryAllItems(membersQuery);
+    console.log(`Fetched ${members.length} members with addresses`);
+
+    const membersToFix = members.filter(member => {
+      const addresses = Array.isArray(member.addresses) ? member.addresses : [];
+      if (addresses.length <= 1) {
+        return false;
+      }
+      return !hasPrimaryAddress(member.addressDisplayOption);
+    });
+
+    const memberIds = [
+      ...new Set(
+        membersToFix
+          .map(member => Number(member.memberId))
+          .filter(memberId => Number.isFinite(memberId) && memberId > 0)
+      ),
+    ];
+    console.log(`Members with multiple addresses and no primary: ${memberIds.length}`);
+
+    if (memberIds.length === 0) {
+      console.log('No members need primary address fixes');
+      return {
+        success: true,
+        message: 'No members need primary address fixes',
+        totalMembers: 0,
+        tasksScheduled: 0,
+      };
+    }
+
+    const chunks = chunkArray(memberIds, CHUNK_SIZE);
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const task = {
+        name: TASKS_NAMES.fixPrimaryAddressChunk,
+        data: {
+          memberIds: chunk,
+          chunkIndex: i,
+          totalChunks: chunks.length,
+        },
+        type: 'scheduled',
+      };
+      await taskManager().schedule(task);
+      console.log(`Scheduled task ${i + 1}/${chunks.length} (${chunk.length} members)`);
+    }
+
+    const result = {
+      success: true,
+      message: `Scheduled ${chunks.length} tasks for ${memberIds.length} members`,
+      totalMembers: memberIds.length,
+      tasksScheduled: chunks.length,
+    };
+
+    console.log('=== Scheduling Complete ===');
+    console.log(`Sample memberIds: ${memberIds.slice(0, 10).join(', ')}`);
+    console.log(JSON.stringify(result, null, 2));
+
+    return result;
+  } catch (error) {
+    console.error('Error scheduling primary address fix:', error);
+    throw error;
+  }
+}
+
+/**
+ * Processes a chunk of members and sets the first address as primary
+ * when a member has multiple addresses and no primary address.
+ */
+async function fixPrimaryAddressChunk(data) {
+  const { memberIds, chunkIndex, totalChunks } = data;
+  console.log(
+    `Processing primary address fix chunk ${chunkIndex + 1}/${totalChunks} (${memberIds.length} members)`
+  );
+
+  const result = {
+    successful: 0,
+    failed: 0,
+    skipped: 0,
+    errors: [],
+    skippedIds: [],
+    failedIds: [],
+  };
+  const skippedNoMultiAddress = [];
+  const skippedHasPrimary = [];
+  const updatedIds = [];
+
+  try {
+    const members = await getMembersByIds(memberIds);
+    console.log(`Loaded ${members.length} members for this chunk`);
+    const membersToUpdate = [];
+
+    members.forEach(member => {
+      const addresses = Array.isArray(member.addresses) ? member.addresses : [];
+      if (addresses.length <= 1) {
+        result.skipped++;
+        result.skippedIds.push(member.memberId);
+        if (skippedNoMultiAddress.length < 20) {
+          skippedNoMultiAddress.push(member.memberId);
+        }
+        return;
+      }
+      if (hasPrimaryAddress(member.addressDisplayOption)) {
+        result.skipped++;
+        result.skippedIds.push(member.memberId);
+        if (skippedHasPrimary.length < 20) {
+          skippedHasPrimary.push(member.memberId);
+        }
+        return;
+      }
+
+      const firstKey = getAddressKey(addresses[0], 0);
+      const normalizedAddresses = addresses.map((address, index) => {
+        if (index !== 0 || address?.key) {
+          return address;
+        }
+        return { ...address, key: firstKey };
+      });
+
+      const updatedDisplayOptions = Array.isArray(member.addressDisplayOption)
+        ? member.addressDisplayOption.map(option => ({
+            ...option,
+            isMain: false,
+          }))
+        : [];
+
+      const existingOption = updatedDisplayOptions.find(option => option?.key === firstKey);
+      if (existingOption) {
+        existingOption.isMain = true;
+      } else {
+        updatedDisplayOptions.push({ key: firstKey, isMain: true });
+      }
+
+      membersToUpdate.push({
+        ...member,
+        addresses: normalizedAddresses,
+        addressDisplayOption: updatedDisplayOptions,
+      });
+      if (updatedIds.length < 20) {
+        updatedIds.push(member.memberId);
+      }
+    });
+
+    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 updated ${membersToUpdate.length} members`);
+      if (updatedIds.length > 0) {
+        console.log(`Updated memberIds (sample): ${updatedIds.join(', ')}`);
+      }
+    } 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,
+      });
+    }
+
+    if (skippedNoMultiAddress.length > 0) {
+      console.log(`Skipped (<=1 address) sample: ${skippedNoMultiAddress.join(', ')}`);
+    }
+    if (skippedHasPrimary.length > 0) {
+      console.log(`Skipped (already has primary) sample: ${skippedHasPrimary.join(', ')}`);
+    }
+
+    return result;
+  } catch (error) {
+    console.error(`Error processing primary address fix chunk ${chunkIndex}:`, error);
+    throw error;
+  }
+}
+
+/**
+ * Schedules tasks to fix primary address visibility when missing or DONT_SHOW.
+ */
+async function scheduleFixPrimaryAddressVisibilityForMembers() {
+  console.log('=== Scheduling Fix Primary Address Visibility Tasks ===');
+
+  try {
+    const membersQuery = await wixData
+      .query(COLLECTIONS.MEMBERS_DATA)
+      .isNotEmpty('addresses')
+      .limit(1000);
+    const members = await queryAllItems(membersQuery);
+    console.log(`Fetched ${members.length} members with addresses`);
+
+    const membersToFix = members.filter(member => {
+      const addresses = Array.isArray(member.addresses) ? member.addresses : [];
+      if (addresses.length === 0) {
+        return false;
+      }
+      const primaryKey = getPrimaryAddressKey(member.addressDisplayOption);
+      if (!primaryKey) {
+        return false;
+      }
+      const addressIndex = addresses.findIndex(address => getAddressKey(address, 0) === primaryKey);
+      if (addressIndex === -1) {
+        return false;
+      }
+      return needsPrimaryAddressVisibilityFix(addresses[addressIndex], addressIndex);
+    });
+
+    const memberIds = [
+      ...new Set(
+        membersToFix
+          .map(member => Number(member.memberId))
+          .filter(memberId => Number.isFinite(memberId) && memberId > 0)
+      ),
+    ];
+    console.log(`Members with primary address visibility issues: ${memberIds.length}`);
+
+    if (memberIds.length === 0) {
+      console.log('No members need primary address visibility fixes');
+      return {
+        success: true,
+        message: 'No members need primary address visibility fixes',
+        totalMembers: 0,
+        tasksScheduled: 0,
+      };
+    }
+
+    const chunks = chunkArray(memberIds, CHUNK_SIZE);
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const task = {
+        name: TASKS_NAMES.fixPrimaryAddressVisibilityChunk,
+        data: {
+          memberIds: chunk,
+          chunkIndex: i,
+          totalChunks: chunks.length,
+        },
+        type: 'scheduled',
+      };
+      await taskManager().schedule(task);
+      console.log(`Scheduled task ${i + 1}/${chunks.length} (${chunk.length} members)`);
+    }
+
+    const result = {
+      success: true,
+      message: `Scheduled ${chunks.length} tasks for ${memberIds.length} members`,
+      totalMembers: memberIds.length,
+      tasksScheduled: chunks.length,
+    };
+
+    console.log('=== Scheduling Complete ===');
+    console.log(`Sample memberIds: ${memberIds.slice(0, 10).join(', ')}`);
+    console.log(JSON.stringify(result, null, 2));
+
+    return result;
+  } catch (error) {
+    console.error('Error scheduling primary address visibility fix:', error);
+    throw error;
+  }
+}
+
+/**
+ * Processes a chunk of members and fixes primary address visibility when missing or DONT_SHOW.
+ */
+async function fixPrimaryAddressVisibilityChunk(data) {
+  const { memberIds, chunkIndex, totalChunks } = data;
+  console.log(
+    `Processing primary address visibility chunk ${chunkIndex + 1}/${totalChunks} (${memberIds.length} members)`
+  );
+
+  const result = {
+    successful: 0,
+    failed: 0,
+    skipped: 0,
+    errors: [],
+    skippedIds: [],
+    failedIds: [],
+  };
+  const skippedNoPrimary = [];
+  const skippedNoAddressMatch = [];
+  const updatedIds = [];
+
+  try {
+    const members = await getMembersByIds(memberIds);
+    console.log(`Loaded ${members.length} members for this chunk`);
+    const membersToUpdate = [];
+
+    members.forEach(member => {
+      const addresses = Array.isArray(member.addresses) ? member.addresses : [];
+      const primaryKey = getPrimaryAddressKey(member.addressDisplayOption);
+      if (!primaryKey) {
+        result.skipped++;
+        result.skippedIds.push(member.memberId);
+        if (skippedNoPrimary.length < 20) {
+          skippedNoPrimary.push(member.memberId);
+        }
+        return;
+      }
+
+      const addressIndex = addresses.findIndex(address => getAddressKey(address, 0) === primaryKey);
+      if (addressIndex === -1) {
+        result.skipped++;
+        result.skippedIds.push(member.memberId);
+        if (skippedNoAddressMatch.length < 20) {
+          skippedNoAddressMatch.push(member.memberId);
+        }
+        return;
+      }
+
+      const targetAddress = addresses[addressIndex];
+      if (!needsPrimaryAddressVisibilityFix(targetAddress, addressIndex)) {
+        result.skipped++;
+        result.skippedIds.push(member.memberId);
+        return;
+      }
+
+      const updatedAddresses = addresses.map((address, index) => {
+        if (index !== addressIndex) {
+          return address;
+        }
+        return {
+          ...address,
+          addressStatus: ADDRESS_STATUS_TYPES.STATE_CITY_ZIP,
+        };
+      });
+
+      membersToUpdate.push({
+        ...member,
+        addresses: updatedAddresses,
+      });
+      if (updatedIds.length < 20) {
+        updatedIds.push(member.memberId);
+      }
+    });
+
+    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 updated ${membersToUpdate.length} members`);
+      if (updatedIds.length > 0) {
+        console.log(`Updated memberIds (sample): ${updatedIds.join(', ')}`);
+      }
+    } 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,
+      });
+    }
+
+    if (skippedNoPrimary.length > 0) {
+      console.log(`Skipped (no primary address) sample: ${skippedNoPrimary.join(', ')}`);
+    }
+    if (skippedNoAddressMatch.length > 0) {
+      console.log(
+        `Skipped (primary address not found) sample: ${skippedNoAddressMatch.join(', ')}`
+      );
+    }
+
+    return result;
+  } catch (error) {
+    console.error(`Error processing primary address visibility chunk ${chunkIndex}:`, error);
+    throw error;
+  }
+}
+
+module.exports = {
+  scheduleFixPrimaryAddressForMembers,
+  fixPrimaryAddressChunk,
+  scheduleFixPrimaryAddressVisibilityForMembers,
+  fixPrimaryAddressVisibilityChunk,
+};

package/backend/tasks/consts.js

@@ -18,6 +18,10 @@ const TASKS_NAMES = {
   generateUrlsChunk: 'generateUrlsChunk',
   scheduleCreateContactsFromMembers: 'scheduleCreateContactsFromMembers',
   createContactsFromMembers: 'createContactsFromMembers',
+  scheduleFixPrimaryAddressForMembers: 'scheduleFixPrimaryAddressForMembers',
+  fixPrimaryAddressChunk: 'fixPrimaryAddressChunk',
+  scheduleFixPrimaryAddressVisibilityForMembers: 'scheduleFixPrimaryAddressVisibilityForMembers',
+  fixPrimaryAddressVisibilityChunk: 'fixPrimaryAddressVisibilityChunk',
 };
 
 module.exports = {

package/backend/tasks/index.js

@@ -4,4 +4,5 @@ module.exports = {
   ...require('./tasks-process-methods'),
   ...require('./migration-methods'),
   ...require('./url-migration-methods'),
+  ...require('./address-primary-methods'),
 };

package/backend/tasks/tasks-configs.js

@@ -4,6 +4,12 @@ const {
   syncMembersDataPerAction,
 } = require('../daily-pull/sync-to-cms-methods');
 
+const {
+  scheduleFixPrimaryAddressForMembers,
+  fixPrimaryAddressChunk,
+  scheduleFixPrimaryAddressVisibilityForMembers,
+  fixPrimaryAddressVisibilityChunk,
+} = require('./address-primary-methods');
 const { TASKS_NAMES } = require('./consts');
 const {
   scheduleTaskForEmptyAboutYouMembers,
@@ -169,6 +175,34 @@ const TASKS = {
     shouldSkipCheck: () => false,
     estimatedDurationSec: 80,
   },
+  [TASKS_NAMES.scheduleFixPrimaryAddressForMembers]: {
+    name: TASKS_NAMES.scheduleFixPrimaryAddressForMembers,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: scheduleFixPrimaryAddressForMembers,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
+  [TASKS_NAMES.fixPrimaryAddressChunk]: {
+    name: TASKS_NAMES.fixPrimaryAddressChunk,
+    getIdentifier: task => task.data,
+    process: fixPrimaryAddressChunk,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
+  [TASKS_NAMES.scheduleFixPrimaryAddressVisibilityForMembers]: {
+    name: TASKS_NAMES.scheduleFixPrimaryAddressVisibilityForMembers,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: scheduleFixPrimaryAddressVisibilityForMembers,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
+  [TASKS_NAMES.fixPrimaryAddressVisibilityChunk]: {
+    name: TASKS_NAMES.fixPrimaryAddressVisibilityChunk,
+    getIdentifier: task => task.data,
+    process: fixPrimaryAddressVisibilityChunk,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
 };
 
 module.exports = { TASKS };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abmp-npm",
-  "version": "10.0.49",
+  "version": "10.0.50",
   "main": "index.js",
   "scripts": {
     "check-cycles": "madge --circular .",

package/pages/LoadingPage.js

@@ -14,7 +14,6 @@ async function loadingPageOnReady(authenticateSSOToken) {
       console.error(`Something went wrong while logging in: ${error}`);
       // If we already have a session (memberId), redirect to form instead of showing error.
       const storedMemberId = await local.getItem('memberId');
-      console.log('storedMemberId', storedMemberId);
       if (storedMemberId) {
         const redirectTo = `${PAGES_PATHS.MEMBERS_FORM}?token=${encodeURIComponent(storedMemberId)}`;
         await wixLocationFrontend.to(`/${redirectTo}`);

package/pages/personalDetails.js

@@ -1556,9 +1556,23 @@ async function personalDetailsOnReady({
       _$w('#mainAddressCheckbox').checked = false;
       checkbox.checked = true;
 
+      // Primary address cannot be hidden: update model and repeater data so UI and save stay in sync
       if (clickedItemData.address.addressStatus === ADDRESS_STATUS_TYPES.DONT_SHOW) {
         updateAddressStatus(clickedItemData._id, ADDRESS_STATUS_TYPES.STATE_CITY_ZIP);
         $item('#addressStatusOptions').value = ADDRESS_STATUS_TYPES.STATE_CITY_ZIP;
+        const currentData = _$w('#addressesList').data || [];
+        const dataWithStatusFixed = currentData.map(item =>
+          item._id === clickedItemData._id
+            ? {
+                ...item,
+                address: {
+                  ...item.address,
+                  addressStatus: ADDRESS_STATUS_TYPES.STATE_CITY_ZIP,
+                },
+              }
+            : item
+        );
+        _$w('#addressesList').data = dataWithStatusFixed;
       }
 
       updateMainAddressSelection(clickedItemData._id);
@@ -1567,7 +1581,7 @@ async function personalDetailsOnReady({
     });
 
     _$w('#addressStatusOptions').onChange(event => {
-      const data = _$w('#addressesList').data;
+      const data = _$w('#addressesList').data || [];
       const clickedItemData = data.find(item => item._id === event.context.itemId);
       const newStatus = event.target.value;
       const $item = _$w.at(event.context);
@@ -1579,6 +1593,15 @@ async function personalDetailsOnReady({
       }
 
       updateAddressStatus(clickedItemData._id, newStatus);
+
+      // Keep repeater data in sync (required for new addresses not yet in itemMemberObj.addresses)
+      const updatedData = data.map(item =>
+        item._id === clickedItemData._id
+          ? { ...item, address: { ...item.address, addressStatus: newStatus } }
+          : item
+      );
+      _$w('#addressesList').data = updatedData;
+
       checkFormChanges(FORM_SECTION_HANDLER_MAP.CONTACT_BOOKING);
     });