abmp-npm 2.0.41 → 2.0.43

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

@@ -1,3 +1,4 @@
+const { ADDRESS_STATUS_TYPES } = require('../../public/consts');
 const { findMemberById, getMemberBySlug } = require('../members-data-methods');
 const { isValidArray, generateGeoHash } = require('../utils');
 
@@ -82,7 +83,21 @@ async function generateUpdatedMemberData({ inputMemberData, currentPageNumber })
 
   // Only add address data for new members
   if (!existingDbMember && isValidArray(inputMemberData.addresses)) {
-    updatedMemberData.addresses = inputMemberData.addresses;
+    const normalizedAddresses = inputMemberData.addresses.map((address, index) => {
+      const key = address?.key || `address_${index}`;
+      const rawStatus = address?.addressStatus;
+      const resolvedStatus =
+        index === 0 && rawStatus === ADDRESS_STATUS_TYPES.DONT_SHOW
+          ? ADDRESS_STATUS_TYPES.STATE_CITY_ZIP
+          : rawStatus || ADDRESS_STATUS_TYPES.STATE_CITY_ZIP;
+      return {
+        ...address,
+        key,
+        addressStatus: resolvedStatus,
+      };
+    });
+    updatedMemberData.addresses = normalizedAddresses;
+    updatedMemberData.addressDisplayOption = [{ key: normalizedAddresses[0].key, isMain: true }];
   }
 
   return { ...updatedMemberData, isNewToDb: !existingDbMember };

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

@@ -0,0 +1,211 @@
+const { taskManager } = require('psdev-task-manager');
+
+const { COLLECTIONS } = 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);
+
+/**
+ * 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;
+  }
+}
+
+module.exports = {
+  scheduleFixPrimaryAddressForMembers,
+  fixPrimaryAddressChunk,
+};

package/backend/tasks/consts.js

@@ -18,6 +18,8 @@ const TASKS_NAMES = {
   generateUrlsChunk: 'generateUrlsChunk',
   scheduleCreateContactsFromMembers: 'scheduleCreateContactsFromMembers',
   createContactsFromMembers: 'createContactsFromMembers',
+  scheduleFixPrimaryAddressForMembers: 'scheduleFixPrimaryAddressForMembers',
+  fixPrimaryAddressChunk: 'fixPrimaryAddressChunk',
 };
 
 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,10 @@ const {
   syncMembersDataPerAction,
 } = require('../daily-pull/sync-to-cms-methods');
 
+const {
+  scheduleFixPrimaryAddressForMembers,
+  fixPrimaryAddressChunk,
+} = require('./address-primary-methods');
 const { TASKS_NAMES } = require('./consts');
 const {
   scheduleTaskForEmptyAboutYouMembers,
@@ -169,6 +173,20 @@ 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,
+  },
 };
 
 module.exports = { TASKS };

package/package.json

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