abmp-npm 1.10.3 → 1.10.4

package/backend/consts.js

@@ -1,4 +1,5 @@
 const PAC_API_URL = 'https://members.abmp.com/eweb/api/Wix';
+const BACKUP_API_URL = 'https://psdevteamenterpris.wixstudio.com/abmp-backup/_functions';
 const SSO_TOKEN_AUTH_API_URL = 'https://members.professionalassistcorp.com/';
 
 /**
@@ -40,4 +41,5 @@ module.exports = {
   COMPILED_FILTERS_FIELDS,
   MEMBERSHIPS_TYPES,
   SSO_TOKEN_AUTH_API_URL,
+  BACKUP_API_URL,
 };

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

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

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/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
@@ -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: 160,
+  },
+  [TASKS_NAMES.migrateUrlsChunk]: {
+    name: TASKS_NAMES.migrateUrlsChunk,
+    getIdentifier: task => `chunk-${task.data.chunkIndex}`,
+    process: migrateUrlsChunk,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
+  [TASKS_NAMES.scheduleGenerateMissingUrls]: {
+    name: TASKS_NAMES.scheduleGenerateMissingUrls,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: scheduleGenerateMissingUrls,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 160,
+  },
+  [TASKS_NAMES.generateUrlsChunk]: {
+    name: TASKS_NAMES.generateUrlsChunk,
+    getIdentifier: task => `chunk-${task.data.chunkIndex}`,
+    process: generateUrlsChunk,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
 };
 
 module.exports = { TASKS };

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

@@ -0,0 +1,376 @@
+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 {
+      // keep bulk save as comment for now, since we are just testing the query and update logic
+      // 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();
+
+      if (!name) {
+        console.error(`Member ${memberId} has no name data - skipping`);
+        result.failed++;
+        result.failedIds.push(memberId);
+        result.errors.push({
+          memberId,
+          error: 'No name data available',
+        });
+        continue;
+      }
+
+      try {
+        const uniqueUrl = await ensureUniqueUrl({
+          url: '',
+          memberId: member._id,
+          fullName: name,
+        });
+
+        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 {
+      // keep bulk save as comment for now, since we are just testing the query and update logic
+      // 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/backend/utils.js

@@ -111,8 +111,10 @@ const getAllItems = async querySearchResult => {
   let oldResults = querySearchResult;
   console.log(`found items: ${oldResults.items.length}`);
   const allItems = oldResults.items;
+  console.log(`total pages: ${oldResults.totalPages}`);
   while (oldResults.hasNext()) {
     oldResults = await oldResults.next();
+    console.log(`next page: ${oldResults.currentPage}`);
     allItems.push(...oldResults.items);
   }
   console.log(`all items count : ${allItems.length}`);

package/package.json

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

package/pages/personalDetails.js

@@ -1858,15 +1858,8 @@ async function personalDetailsOnReady({
         itemMemberObj.toShowPhone = null;
       }
 
-      if (itemMemberObj.phones) {
-        itemMemberObj.phones = itemMemberObj.phones.filter(
-          phone => phone !== phoneToRemove.phoneNumber
-        );
-      }
-
       const updatedData = currentData.filter(item => item._id !== phoneId);
       renderPhonesList(updatedData);
-      checkFormChanges(FORM_SECTION_HANDLER_MAP.CONTACT_BOOKING);
     }
   }