abmp-npm 1.1.85 → 1.1.86

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

@@ -300,4 +300,5 @@ async function createCoreMemberData(inputMemberData, existingDbMember, currentPa
 
 module.exports = {
   generateUpdatedMemberData,
+  ensureUniqueUrl,
 };

package/backend/index.js

@@ -14,4 +14,6 @@ module.exports = {
   ...require('./data-hooks'),
   ...require('./http-functions'),
   ...require('./dev-only-methods'),
+  ...require('./tasks/migration-methods'),
+  ...require('./tasks/url-migration-methods'),
 };

package/backend/tasks/consts.js

@@ -12,6 +12,10 @@ const TASKS_NAMES = {
   syncMemberLoginEmails: 'syncMemberLoginEmails',
   scheduleContactFormEmailMigration: 'scheduleContactFormEmailMigration',
   migrateContactFormEmails: 'migrateContactFormEmails',
+  scheduleMigrateExistingUrls: 'scheduleMigrateExistingUrls',
+  migrateUrlsChunk: 'migrateUrlsChunk',
+  scheduleGenerateMissingUrls: 'scheduleGenerateMissingUrls',
+  generateUrlsChunk: 'generateUrlsChunk',
 };
 
 module.exports = {

package/backend/tasks/index.js

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

package/backend/tasks/migration-methods.js

@@ -20,7 +20,27 @@ function scheduleExternalProfileImageMigration() {
   });
 }
 
+// Schedule URL migration from backup collection
+function scheduleUrlMigration() {
+  return taskManager().schedule({
+    name: TASKS_NAMES.scheduleMigrateExistingUrls,
+    data: {},
+    type: 'scheduled',
+  });
+}
+
+// Schedule URL generation for members without URLs
+function scheduleUrlGeneration() {
+  return taskManager().schedule({
+    name: TASKS_NAMES.scheduleGenerateMissingUrls,
+    data: {},
+    type: 'scheduled',
+  });
+}
+
 module.exports = {
   scheduleConvertHtmlToRichContent,
   scheduleExternalProfileImageMigration,
+  scheduleUrlMigration,
+  scheduleUrlGeneration,
 };

package/backend/tasks/tasks-configs.js

@@ -17,6 +17,12 @@ const {
   scheduleEmailSync,
   syncMemberLoginEmails,
 } = require('./tasks-process-methods');
+const {
+  scheduleMigrateExistingUrls,
+  migrateUrlsChunk,
+  scheduleGenerateMissingUrls,
+  generateUrlsChunk,
+} = require('./url-migration-methods');
 
 const getDailyMembersDataSyncChildTasks = () => {
   // we don't want to sync none action as it means this members data hasn't changed and we don't need to sync it
@@ -89,7 +95,7 @@ const TASKS = {
     getIdentifier: () => 'SHOULD_NEVER_SKIP',
     process: updateSiteMapS3,
     shouldSkipCheck: () => false,
-    estimatedDurationSec: 90,
+    estimatedDurationSec: 70,
   },
   [TASKS_NAMES.scheduleContactFormEmailMigration]: {
     name: TASKS_NAMES.scheduleContactFormEmailMigration,
@@ -119,6 +125,34 @@ const TASKS = {
     shouldSkipCheck: () => false,
     estimatedDurationSec: 45,
   },
+  [TASKS_NAMES.scheduleMigrateExistingUrls]: {
+    name: TASKS_NAMES.scheduleMigrateExistingUrls,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: scheduleMigrateExistingUrls,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
+  [TASKS_NAMES.migrateUrlsChunk]: {
+    name: TASKS_NAMES.migrateUrlsChunk,
+    getIdentifier: task => task.data,
+    process: migrateUrlsChunk,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
+  [TASKS_NAMES.scheduleGenerateMissingUrls]: {
+    name: TASKS_NAMES.scheduleGenerateMissingUrls,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: scheduleGenerateMissingUrls,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
+  [TASKS_NAMES.generateUrlsChunk]: {
+    name: TASKS_NAMES.generateUrlsChunk,
+    getIdentifier: task => task.data,
+    process: generateUrlsChunk,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
 };
 
 module.exports = { TASKS };

package/backend/tasks/url-migration-methods.js

@@ -0,0 +1,363 @@
+const { taskManager } = require('psdev-task-manager');
+
+const { COLLECTIONS } = require('../../public/consts');
+const { ensureUniqueUrl } = require('../daily-pull/process-member-methods');
+const { wixData } = require('../elevated-modules');
+const { bulkSaveMembers } = require('../members-data-methods');
+const { queryAllItems, chunkArray } = require('../utils');
+
+const { TASKS_NAMES } = require('./consts');
+
+const COLLECTION_WITH_URLS = 'MembersDataWithUrls';
+const CHUNK_SIZE = 5000; // 5k members per task
+
+/**
+ * Step 1: Migrate existing URLs from backup collection
+ * Queries backup collection and schedules tasks with memberIds and URLs
+ */
+async function scheduleMigrateExistingUrls() {
+  console.log('=== Scheduling Step 1: Migrate Existing URLs ===');
+
+  try {
+    const membersQuery = await wixData.query(COLLECTION_WITH_URLS);
+    const startTime = Date.now();
+    const membersWithUrls = await queryAllItems(membersQuery);
+    const endTime = Date.now();
+    console.log(`QueryAllItems time: ${endTime - startTime}ms`);
+
+    const validMembers = membersWithUrls.filter(member => member.memberId && member.url);
+    console.log(`${validMembers.length} members have valid memberId and URL`);
+
+    if (validMembers.length === 0) {
+      console.log('No members to migrate URLs for');
+      return {
+        success: true,
+        message: 'No members need URL migration',
+        totalMembers: 0,
+        tasksScheduled: 0,
+      };
+    }
+
+    const migrationData = validMembers.map(member => ({
+      memberId: member.memberId,
+      url: member.url,
+    }));
+
+    const chunks = chunkArray(migrationData, CHUNK_SIZE);
+
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const task = {
+        name: TASKS_NAMES.migrateUrlsChunk,
+        data: {
+          urlData: chunk,
+          chunkIndex: i,
+          totalChunks: chunks.length,
+        },
+        type: 'scheduled',
+      };
+      await taskManager().schedule(task);
+      console.log(`Scheduled migration task ${i + 1}/${chunks.length} (${chunk.length} members)`);
+    }
+
+    const result = {
+      success: true,
+      message: `Scheduled ${chunks.length} tasks for ${validMembers.length} members`,
+      totalMembers: validMembers.length,
+      tasksScheduled: chunks.length,
+    };
+
+    console.log('=== Migration Scheduling Complete ===');
+    console.log(JSON.stringify(result, null, 2));
+
+    return result;
+  } catch (error) {
+    console.error('Error scheduling URL migration:', error);
+    throw error;
+  }
+}
+
+/**
+ * Process a chunk of URL migrations (called by task manager)
+ * Fetches members by memberId and updates with URLs using bulkSave
+ */
+async function migrateUrlsChunk(data) {
+  const { urlData, chunkIndex, totalChunks } = data;
+  console.log(
+    `Processing migration chunk ${chunkIndex + 1}/${totalChunks} (${urlData.length} members)`
+  );
+
+  const result = {
+    successful: 0,
+    failed: 0,
+    skipped: 0,
+    errors: [],
+    skippedIds: [],
+    failedIds: [],
+  };
+
+  try {
+    const memberIds = urlData.map(({ memberId }) => memberId);
+
+    console.log(`Fetching ${memberIds.length} members from database...`);
+    const query = await wixData.query(COLLECTIONS.MEMBERS_DATA).hasSome('memberId', memberIds);
+    const members = await queryAllItems(query);
+    console.log(`Found ${members.length} members in database`);
+
+    const memberMap = new Map();
+    members.forEach(member => {
+      if (member.memberId) {
+        memberMap.set(member.memberId, member);
+      }
+    });
+
+    const membersToUpdate = [];
+    for (const { memberId, url } of urlData) {
+      const member = memberMap.get(memberId);
+
+      if (!member) {
+        console.log(`Member with memberId ${memberId} not found - skipping`);
+        result.skipped++;
+        result.skippedIds.push(memberId);
+        continue;
+      }
+
+      if (member.url === url) {
+        console.log(`Member ${member._id} already has URL ${url} - skipping`);
+        result.skipped++;
+        result.skippedIds.push(memberId);
+        continue;
+      }
+
+      membersToUpdate.push({
+        ...member,
+        url: url,
+      });
+    }
+
+    if (membersToUpdate.length === 0) {
+      console.log('No members need updating in this batch');
+      return result;
+    }
+
+    console.log(
+      `Started updating ${membersToUpdate.length} members with URLs in chunk ${chunkIndex}`
+    );
+
+    try {
+      await bulkSaveMembers(membersToUpdate);
+      result.successful += membersToUpdate.length;
+      console.log(`✅ Successfully updated ${membersToUpdate.length} members`);
+    } catch (error) {
+      console.error(`❌ Error bulk saving members:`, error);
+      result.failed += membersToUpdate.length;
+      // Add all member IDs to failedIds
+      result.failedIds.push(...membersToUpdate.map(m => m.memberId));
+      result.errors.push({
+        error: error.message,
+        memberCount: membersToUpdate.length,
+      });
+    }
+
+    console.log(
+      `Chunk ${chunkIndex + 1} complete: ${result.successful} success, ${result.failed} failed, ${result.skipped} skipped`
+    );
+
+    // Log failed and skipped IDs if any
+    if (result.failedIds.length > 0) {
+      console.log(`❌ Failed memberIds (${result.failedIds.length}):`, result.failedIds);
+    }
+    if (result.skippedIds.length > 0) {
+      console.log(`⏭️  Skipped memberIds (${result.skippedIds.length}):`, result.skippedIds);
+    }
+
+    return result;
+  } catch (error) {
+    console.error(`Error processing migration chunk ${chunkIndex}:`, error);
+    throw error;
+  }
+}
+
+/**
+ * Step 2: Generate URLs for members without URLs
+ * Queries members without URLs and schedules generation tasks
+ */
+async function scheduleGenerateMissingUrls() {
+  console.log('=== Scheduling Step 2: Generate Missing URLs ===');
+
+  try {
+    const membersQuery = await wixData.query(COLLECTIONS.MEMBERS_DATA).isEmpty('url');
+    const membersToUpdate = await queryAllItems(membersQuery);
+
+    console.log(`Found ${membersToUpdate.length} members without URLs`);
+
+    if (membersToUpdate.length === 0) {
+      console.log('No members need URL generation');
+      return {
+        success: true,
+        message: 'No members need URL generation',
+        totalMembers: 0,
+        tasksScheduled: 0,
+      };
+    }
+
+    const chunks = chunkArray(membersToUpdate, CHUNK_SIZE);
+
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const task = {
+        name: TASKS_NAMES.generateUrlsChunk,
+        data: {
+          memberIds: chunk.map(m => m._id),
+          chunkIndex: i,
+          totalChunks: chunks.length,
+        },
+        type: 'scheduled',
+      };
+      await taskManager().schedule(task);
+      console.log(`Scheduled generation task ${i + 1}/${chunks.length} (${chunk.length} members)`);
+    }
+
+    const result = {
+      success: true,
+      message: `Scheduled ${chunks.length} tasks for ${membersToUpdate.length} members`,
+      totalMembers: membersToUpdate.length,
+      tasksScheduled: chunks.length,
+    };
+
+    console.log('=== Generation Scheduling Complete ===');
+    console.log(JSON.stringify(result, null, 2));
+
+    return result;
+  } catch (error) {
+    console.error('Error scheduling URL generation:', error);
+    throw error;
+  }
+}
+
+/**
+ * Process a chunk of URL generation (called by task manager)
+ * Fetches members, generates URLs, and bulk saves
+ */
+async function generateUrlsChunk(data) {
+  const { memberIds, chunkIndex, totalChunks } = data;
+  console.log(
+    `Processing generation chunk ${chunkIndex + 1}/${totalChunks} (${memberIds.length} members)`
+  );
+
+  const result = {
+    successful: 0,
+    failed: 0,
+    skipped: 0,
+    errors: [],
+    skippedIds: [],
+    failedIds: [],
+  };
+
+  try {
+    // Fetch all members at once using hasSome
+    console.log(`Fetching ${memberIds.length} members from database...`);
+    const members = await queryAllItems(
+      wixData.query(COLLECTIONS.MEMBERS_DATA).hasSome('_id', memberIds)
+    );
+    console.log(`Found ${members.length} members in database`);
+
+    // Create a map of _id -> member for quick lookup
+    const memberMap = new Map();
+    members.forEach(member => {
+      memberMap.set(member._id, member);
+    });
+
+    // Process each member and generate URLs
+    const membersToUpdate = [];
+    for (const memberId of memberIds) {
+      const member = memberMap.get(memberId);
+
+      if (!member) {
+        console.log(`Member ${memberId} not found - skipping`);
+        result.skipped++;
+        result.skippedIds.push(memberId);
+        continue;
+      }
+
+      if (member.url) {
+        console.log(`Member ${memberId} already has URL - skipping`);
+        result.skipped++;
+        result.skippedIds.push(memberId);
+        continue;
+      }
+
+      const name = member.fullName || `${member.firstName || ''} ${member.lastName || ''}`.trim();
+
+      try {
+        const uniqueUrl = await ensureUniqueUrl({
+          url: '',
+          memberId: member._id,
+          fullName: name || '', // Let ensureUniqueUrl handle fallback for empty names
+        });
+
+        console.log(`✅ Generated URL for member ${memberId}: ${uniqueUrl}`);
+        membersToUpdate.push({
+          ...member,
+          url: uniqueUrl,
+        });
+      } catch (error) {
+        console.error(`❌ Failed to generate URL for member ${memberId}:`, error);
+        result.failed++;
+        result.failedIds.push(memberId);
+        result.errors.push({
+          memberId,
+          error: error.message || 'Unknown error',
+        });
+      }
+    }
+
+    if (membersToUpdate.length === 0) {
+      console.log('No members need updating in this batch');
+      return result;
+    }
+
+    console.log(
+      `Started updating ${membersToUpdate.length} members with generated URLs in chunk ${chunkIndex}`
+    );
+
+    try {
+      await bulkSaveMembers(membersToUpdate);
+      result.successful += membersToUpdate.length;
+      console.log(`✅ Successfully updated ${membersToUpdate.length} members`);
+    } catch (error) {
+      console.error(`❌ Error bulk saving members:`, error);
+      result.failed += membersToUpdate.length;
+      // Add all member _ids to failedIds
+      result.failedIds.push(...membersToUpdate.map(m => m._id));
+      result.errors.push({
+        error: error.message,
+        memberCount: membersToUpdate.length,
+      });
+    }
+
+    console.log(
+      `Chunk ${chunkIndex + 1} complete: ${result.successful} success, ${result.failed} failed, ${result.skipped} skipped`
+    );
+
+    // Log failed and skipped IDs if any
+    if (result.failedIds.length > 0) {
+      console.log(`❌ Failed memberIds (${result.failedIds.length}):`, result.failedIds);
+    }
+    if (result.skippedIds.length > 0) {
+      console.log(`⏭️  Skipped memberIds (${result.skippedIds.length}):`, result.skippedIds);
+    }
+
+    return result;
+  } catch (error) {
+    console.error(`Error processing generation chunk ${chunkIndex}:`, error);
+    throw error;
+  }
+}
+
+module.exports = {
+  scheduleMigrateExistingUrls,
+  migrateUrlsChunk,
+  scheduleGenerateMissingUrls,
+  generateUrlsChunk,
+};

package/package.json

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

package/pages/personalDetails.js

@@ -1294,6 +1294,7 @@ async function personalDetailsOnReady({
       streetAddress: {
         name: extractStreetName(address.line1),
         number: extractStreetNumber(address.line1),
+        apt: address.line2 || '',
       },
       city: address.city || '',
       subdivision: address.state || '',
@@ -1309,20 +1310,49 @@ async function personalDetailsOnReady({
     if (!addressInputValue) return null;
 
     let line1 = '';
+    let line2 = '';
+
     if (addressInputValue.streetAddress) {
       const number = addressInputValue.streetAddress.number || '';
       const name = addressInputValue.streetAddress.name || '';
       line1 = `${number} ${name}`.trim();
+
+      // Capture apartment/suite/building info from streetAddress.apt (undocumented but exists)
+      if (addressInputValue.streetAddress.apt) {
+        line2 = addressInputValue.streetAddress.apt;
+      }
     }
 
     if (!line1 && addressInputValue.formatted) {
       line1 = addressInputValue.formatted.split(',')[0]?.trim() || '';
     }
 
+    // If line2 is still empty, try to extract building/suite info from formatted address
+    if (!line2 && addressInputValue.formatted) {
+      const formattedParts = addressInputValue.formatted.split(',').map(part => part.trim());
+      // Look for BLDG/STE/APT/UNIT/SUITE info in the formatted parts
+      for (let i = 1; i < formattedParts.length; i++) {
+        const part = formattedParts[i];
+        const lowerPart = part.toLowerCase();
+        if (
+          lowerPart.includes('bldg') ||
+          lowerPart.includes('ste') ||
+          lowerPart.includes('apt') ||
+          lowerPart.includes('unit') ||
+          lowerPart.includes('suite') ||
+          lowerPart.includes('#') ||
+          lowerPart.includes('building')
+        ) {
+          line2 = part;
+          break;
+        }
+      }
+    }
+
     return {
       key: existingAddress?.key || generateId(),
       line1,
-      line2: existingAddress?.line2 || '',
+      line2: line2 || existingAddress?.line2 || '',
       city: addressInputValue.city || '',
       state: addressInputValue.subdivision || '',
       postalcode: addressInputValue.postalCode || '',
@@ -1705,6 +1735,7 @@ async function personalDetailsOnReady({
     const parts = [];
 
     if (addr.line1) parts.push(addr.line1);
+    if (addr.line2) parts.push(addr.line2); // Include building/suite info
     if (addr.city) parts.push(addr.city);
     if (addr.state && addr.postalcode) {
       parts.push(`${addr.state} ${addr.postalcode}`);