abmp-npm 2.0.7 → 2.0.10

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/bulk-process-methods.js

@@ -1,7 +1,123 @@
-const { bulkSaveMembers } = require('../members-data-methods');
+const { bulkSaveMembers, getMemberBySlug } = require('../members-data-methods');
 
 const { generateUpdatedMemberData } = require('./process-member-methods');
-const { changeWixMembersEmails } = require('./utils');
+const {
+  changeWixMembersEmails,
+  extractUrlCounter,
+  incrementUrlCounter,
+  extractBaseUrl,
+} = require('./utils');
+
+/**
+ * Ensures unique URLs within a batch of members by deduplicating URLs
+ * Groups members by their base URL (normalized) and assigns unique counters
+ * Also checks database to handle cross-page conflicts
+ * @param {Array} memberDataList - Array of processed member data
+ * @returns {Promise<Array>} - Array of members with unique URLs assigned
+ */
+async function ensureUniqueUrlsInBatch(memberDataList) {
+  if (!Array.isArray(memberDataList) || memberDataList.length === 0) {
+    return memberDataList;
+  }
+
+  // Group members by their normalized base URL
+  const urlGroups = new Map();
+
+  memberDataList.forEach(member => {
+    if (!member || !member.url) {
+      return;
+    }
+
+    // Extract the base URL (without any counter) for grouping
+    const baseUrl = extractBaseUrl(member.url);
+    if (!urlGroups.has(baseUrl)) {
+      urlGroups.set(baseUrl, []);
+    }
+    urlGroups.get(baseUrl).push(member);
+  });
+
+  // For each group, check database and assign unique URLs sequentially
+  for (const [baseUrl, members] of urlGroups.entries()) {
+    if (members.length <= 1) {
+      // Single member - still check DB to ensure it doesn't conflict with other pages
+      const member = members[0];
+      if (member) {
+        const dbMember = await getMemberBySlug({
+          slug: baseUrl,
+          excludeDropped: false,
+          normalizeSlugForComparison: true,
+        });
+
+        if (dbMember && dbMember.url) {
+          // Conflict found in DB, need to add counter
+          member.url = incrementUrlCounter(dbMember.url, baseUrl);
+          console.log(
+            `Found DB conflict for single member with base URL "${baseUrl}", assigned: ${member.url}`
+          );
+        }
+      }
+      continue;
+    }
+
+    // Sort members to ensure consistent ordering
+    members.sort((a, b) => {
+      if (a.url && b.url) {
+        return String(a.url).localeCompare(String(b.url));
+      }
+      return 0;
+    });
+
+    // Check database for existing members with this base URL to find highest counter
+    const dbMember = await getMemberBySlug({
+      slug: baseUrl,
+      excludeDropped: false,
+      normalizeSlugForComparison: true,
+    });
+
+    const dbMaxCounter = extractUrlCounter(dbMember?.url);
+
+    // Find the highest existing counter among all members in this batch group
+    let batchMaxCounter = -1;
+    members.forEach(member => {
+      const originalUrl = member.url;
+      const urlParts = originalUrl.split('-');
+      const lastSegment = urlParts[urlParts.length - 1];
+      const isNumeric = /^\d+$/.test(lastSegment);
+      if (isNumeric) {
+        const counter = parseInt(lastSegment, 10);
+        if (counter > batchMaxCounter) {
+          batchMaxCounter = counter;
+        }
+      }
+    });
+
+    // Start index from the maximum of DB counter and batch counter + 1
+    const maxCounter = Math.max(dbMaxCounter, batchMaxCounter);
+    const startIndex = maxCounter + 1;
+
+    // Assign unique URLs: start from the appropriate index
+    members.forEach((member, index) => {
+      const assignedIndex = startIndex + index;
+      if (assignedIndex === 0) {
+        // Index 0 means no counter, use baseUrl
+        member.url = baseUrl;
+      } else {
+        // Index > 0 means add counter
+        member.url = `${baseUrl}-${assignedIndex}`;
+      }
+    });
+
+    console.log(
+      `Deduplicated ${
+        members.length
+      } members with base URL "${baseUrl}" (DB max: ${dbMaxCounter}, batch max: ${batchMaxCounter}, start: ${startIndex}): ${members
+        .map(m => m.url)
+        .join(', ')}`
+    );
+  }
+
+  return memberDataList;
+}
 
 /**
  * Processes and saves multiple member records in bulk
@@ -36,7 +152,6 @@ const bulkProcessAndSaveMemberData = async ({
     const validMemberData = processedMemberDataList.filter(
       data => data !== null && data !== undefined
     );
-
     if (validMemberData.length === 0) {
       return {
         totalProcessed: memberDataList.length,
@@ -45,9 +160,14 @@ const bulkProcessAndSaveMemberData = async ({
         processingTime: Date.now() - startTime,
       };
     }
+    const newMembers = validMemberData.filter(data => data.isNewToDb);
+    const existingMembers = validMemberData.filter(data => !data.isNewToDb);
+    // Ensure unique URLs within the batch to prevent duplicates (also checks DB for cross-page conflicts)
+    const uniqueUrlsNewToDBMembersList = await ensureUniqueUrlsInBatch(newMembers);
+    const uniqueUrlsMembersData = [...uniqueUrlsNewToDBMembersList, ...existingMembers];
     const toChangeWixMembersEmails = [];
-    const toSaveMembersData = validMemberData.map(member => {
-      const { isLoginEmailChanged, ...restMemberData } = member;
+    const toSaveMembersData = uniqueUrlsMembersData.map(member => {
+      const { isLoginEmailChanged, isNewToDb: _isNewToDb, ...restMemberData } = member;
       if (member.contactId && isLoginEmailChanged) {
         toChangeWixMembersEmails.push(member);
       }
@@ -73,4 +193,4 @@ const bulkProcessAndSaveMemberData = async ({
   }
 };
 
-module.exports = { bulkProcessAndSaveMemberData };
+module.exports = { bulkProcessAndSaveMemberData, ensureUniqueUrlsInBatch };

package/backend/daily-pull/index.js

@@ -1,4 +1,5 @@
 module.exports = {
   ...require('./sync-to-cms-methods'),
   ...require('./consts'), //TODO: remove it once we finish NPM movement
+  ...require('./bulk-process-methods'),
 };

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

@@ -39,7 +39,7 @@ const ensureUniqueUrl = async ({ url, memberId, fullName }) => {
 
   const existingMember = await getMemberBySlug({
     slug: uniqueUrl,
-    excludeDropped: true,
+    excludeDropped: false,
     excludeSearchedMember: true,
     memberId,
     normalizeSlugForComparison: true,
@@ -105,7 +105,7 @@ async function generateUpdatedMemberData({
     );
   }
 
-  return updatedMemberData;
+  return { ...updatedMemberData, isNewToDb: !existingDbMember };
 }
 
 /**

package/backend/daily-pull/utils.js

@@ -15,6 +15,36 @@ const changeWixMembersEmails = async toChangeWixMembersEmails => {
   );
 };
 
+const extractUrlCounter = url => {
+  if (!url) return -1;
+  const lastSegment = url.split('-').pop() || '0';
+  const isNumeric = /^\d+$/.test(lastSegment);
+  return isNumeric ? parseInt(lastSegment, 10) : -1;
+};
+
+const extractBaseUrl = url => {
+  if (!url) return url;
+  const urlParts = url.split('-');
+  const lastSegment = urlParts[urlParts.length - 1];
+  const isNumeric = /^\d+$/.test(lastSegment);
+  if (isNumeric && urlParts.length > 1) {
+    // Remove the numeric counter to get the base URL
+    return urlParts.slice(0, -1).join('-');
+  }
+  // No counter found, return the URL as-is
+  return url;
+};
+const incrementUrlCounter = (existingUrl, baseUrl) => {
+  if (existingUrl && existingUrl === baseUrl) {
+    console.log(
+      `Found member with same url ${existingUrl} for baseUrl ${baseUrl}, increasing counter by 1`
+    );
+    const lastSegment = existingUrl.split('-').pop() || '0';
+    const isNumeric = /^\d+$/.test(lastSegment);
+    const lastCounter = isNumeric ? parseInt(lastSegment, 10) : 0;
+    return `${baseUrl}-${lastCounter + 1}`;
+  }
+};
 /**
  * Validates core member data requirements
  * @param {Object} inputMemberData - Raw member data from API to validate
@@ -75,4 +105,7 @@ module.exports = {
   validateCoreMemberData,
   containsNonEnglish,
   createFullName,
+  extractUrlCounter,
+  incrementUrlCounter,
+  extractBaseUrl,
 };

package/backend/dev-only-methods.js

@@ -0,0 +1,18 @@
+const { ensureUniqueUrlsInBatch } = require('./daily-pull/bulk-process-methods');
+const { wixData } = require('./elevated-modules');
+const { bulkSaveMembers } = require('./members-data-methods');
+const { queryAllItems } = require('./utils');
+
+async function deduplicateURls(collectionName, duplicateUrlsList) {
+  const query = await wixData.query(collectionName).hasSome('url', duplicateUrlsList).limit(1000);
+  const membersWithSameUrl = await queryAllItems(query);
+
+  console.log({ membersWithSameUrl });
+  const membersWithUniqueUrls = await ensureUniqueUrlsInBatch(membersWithSameUrl);
+  console.log({ membersWithUniqueUrls });
+  const deduplicatedUrls = membersWithUniqueUrls.map(m => m.url);
+  console.log({ deduplicatedUrls });
+  return await bulkSaveMembers(membersWithUniqueUrls, collectionName);
+}
+
+module.exports = { deduplicateURls };

package/backend/elevated-modules.js

@@ -12,7 +12,7 @@ const wixData = {
   get: auth.elevate(items.get),
   truncate: auth.elevate(items.truncate),
   bulkSave: auth.elevate(items.bulkSave),
+  search: auth.elevate(items.search),
   //TODO: add other methods here as needed
 };
-
 module.exports = { wixData };

package/backend/index.js

@@ -13,4 +13,5 @@ module.exports = {
   ...require('./login'),
   ...require('./data-hooks'),
   ...require('./http-functions'),
+  ...require('./dev-only-methods'),
 };

package/backend/members-data-methods.js

@@ -10,6 +10,7 @@ const {
   normalizeUrlForComparison,
   queryAllItems,
   generateGeoHash,
+  searchAllItems,
 } = require('./utils');
 
 /**
@@ -60,9 +61,10 @@ async function createContactAndMemberIfNew(memberData) {
 
 /** Performs bulk save operation for member data
  * @param { Array } memberDataList - Array of member data objects to save
+ * @param { string } [collectionName] - The collection name to save the members to (default: COLLECTIONS.MEMBERS_DATA)
  * @returns { Promise < Object >} - Bulk save operation result
  */
-async function bulkSaveMembers(memberDataList) {
+async function bulkSaveMembers(memberDataList, collectionName = COLLECTIONS.MEMBERS_DATA) {
   if (!Array.isArray(memberDataList) || memberDataList.length === 0) {
     throw new Error('Invalid member data list provided for bulk save');
   }
@@ -70,9 +72,7 @@ async function bulkSaveMembers(memberDataList) {
   try {
     // bulkSave all with batches of 1000 items as this is the Velo limit for bulkSave
     const batches = chunkArray(memberDataList, 1000);
-    return await Promise.all(
-      batches.map(batch => wixData.bulkSave(COLLECTIONS.MEMBERS_DATA, batch))
-    );
+    return await Promise.all(batches.map(batch => wixData.bulkSave(collectionName, batch)));
   } catch (error) {
     console.error('Error bulk saving members:', error);
     throw new Error(`Bulk save failed: ${error.message}`);
@@ -121,7 +121,7 @@ async function getMemberBySlug({
   if (!slug) return null;
 
   try {
-    let query = wixData.query(COLLECTIONS.MEMBERS_DATA).contains('url', slug);
+    let query = wixData.search(COLLECTIONS.MEMBERS_DATA).expression(slug);
 
     if (excludeDropped) {
       query = query.ne('action', 'drop');
@@ -131,7 +131,8 @@ async function getMemberBySlug({
       query = query.ne('memberId', memberId);
     }
     query = query.limit(1000);
-    const membersList = await queryAllItems(query);
+    const searchResult = await searchAllItems(query);
+    const membersList = searchResult.filter(item => item.url && item.url.includes(slug)); //replacement for contains
     let matchingMembers = membersList.filter(
       item => item.url && item.url.toLowerCase() === slug.toLowerCase()
     );
@@ -268,23 +269,13 @@ async function urlExists(url, excludeMemberId) {
   if (!url) return false;
 
   try {
-    let query = wixData
-      .query(COLLECTIONS.MEMBERS_DATA)
-      .contains('url', url)
-      .ne('action', MEMBER_ACTIONS.DROP);
-
-    if (excludeMemberId) {
-      query = query.ne('memberId', excludeMemberId);
-    }
-
-    const { items } = await query.find();
-
-    // Case-insensitive comparison
-    const matchingMembers = items.filter(
-      item => item.url && item.url.toLowerCase() === url.toLowerCase()
-    );
-
-    return matchingMembers.length > 0;
+    const member = await getMemberBySlug({
+      slug: url,
+      excludeDropped: false,
+      excludeSearchedMember: true,
+      memberId: excludeMemberId,
+    });
+    return member !== null;
   } catch (error) {
     console.error('Error checking URL existence:', error);
     return false;

package/backend/utils.js

@@ -107,18 +107,28 @@ function getAddressesByStatus(addresses = [], addressDisplayOption = []) {
     })
     .filter(Boolean);
 }
-const queryAllItems = async query => {
-  console.log('start query');
-  let oldResults = await query.find();
+const getAllItems = async querySearchResult => {
+  let oldResults = querySearchResult;
   console.log(`found items: ${oldResults.items.length}`);
   const allItems = oldResults.items;
   while (oldResults.hasNext()) {
     oldResults = await oldResults.next();
     allItems.push(...oldResults.items);
   }
-  console.log(`all items: ${allItems.length}`);
+  console.log(`all items count : ${allItems.length}`);
   return allItems;
 };
+const searchAllItems = async searchQuery => {
+  console.log('start search');
+  const searchResults = await searchQuery.run();
+  return getAllItems(searchResults);
+};
+
+const queryAllItems = async query => {
+  console.log('start query');
+  const queryResults = await query.find();
+  return getAllItems(queryResults);
+};
 /**
  * Chunks large arrays into smaller chunks for processing
  * @param {Array} array - Array to chunk
@@ -206,4 +216,5 @@ module.exports = {
   formatDateOnly,
   getAddressesByStatus,
   isPAC_STAFF,
+  searchAllItems,
 };

package/dev-only-scripts/find-duplicate-urls.js

@@ -0,0 +1,201 @@
+const fs = require('fs');
+const path = require('path');
+
+const csv = require('csv-parser');
+
+/**
+ * Finds duplicate URLs in a CSV file and generates a JSON report
+ * Usage: node scripts/find-duplicate-urls.js <path-to-csv-file>
+ */
+function findDuplicateUrls(csvFilePath) {
+  // Validate command-line argument
+  if (!csvFilePath) {
+    console.error('Error: CSV file path is required');
+    console.error('Usage: node scripts/find-duplicate-urls.js <path-to-csv-file>');
+    process.exit(1);
+  }
+
+  // Validate file exists and is readable
+  if (!fs.existsSync(csvFilePath)) {
+    console.error(`Error: File not found: ${csvFilePath}`);
+    process.exit(1);
+  }
+
+  const urlMap = new Map(); // url -> [memberId1, memberId2, ...]
+  let totalMembers = 0;
+  let rowNumber = 0;
+  let headersValidated = false;
+  let headers = null;
+  let urlColumnName = null;
+  let memberIdColumnName = null;
+
+  return new Promise((resolve, reject) => {
+    fs.createReadStream(csvFilePath)
+      .pipe(csv())
+      .on('headers', receivedHeaders => {
+        headers = receivedHeaders;
+        // Validate required columns exist - normalize by removing quotes, trimming, and lowercasing
+        const normalizedHeaders = headers.map(h => {
+          let normalized = String(h).trim();
+          // Remove all quotes (single and double) from the string
+          normalized = normalized.replace(/["']/g, '');
+          return normalized.toLowerCase().trim();
+        });
+
+        // Find the actual column names for url and memberId
+        const urlIndex = normalizedHeaders.indexOf('url');
+        const memberIdIndex = normalizedHeaders.indexOf('memberid');
+
+        if (urlIndex === -1 || memberIdIndex === -1) {
+          console.error('Error: CSV must contain "url" and "memberId" columns (case-insensitive)');
+          console.error(`Found columns: ${headers.join(', ')}`);
+          console.error(`Normalized columns: ${normalizedHeaders.join(', ')}`);
+          process.exit(1);
+        }
+
+        // Store the actual column names (with original casing/quotes)
+        urlColumnName = headers[urlIndex];
+        memberIdColumnName = headers[memberIdIndex];
+        headersValidated = true;
+      })
+      .on('data', row => {
+        // Validate headers on first data row if headers event didn't fire
+        if (!headersValidated) {
+          headers = Object.keys(row);
+          // Normalize by removing quotes, trimming, and lowercasing
+          const normalizedHeaders = headers.map(h => {
+            let normalized = String(h).trim();
+            // Remove all quotes (single and double) from the string
+            normalized = normalized.replace(/["']/g, '');
+            return normalized.toLowerCase().trim();
+          });
+
+          const urlIndex = normalizedHeaders.indexOf('url');
+          const memberIdIndex = normalizedHeaders.indexOf('memberid');
+
+          if (urlIndex === -1 || memberIdIndex === -1) {
+            console.error(
+              'Error: CSV must contain "url" and "memberId" columns (case-insensitive)'
+            );
+            console.error(`Found columns: ${headers.join(', ')}`);
+            console.error(`Normalized columns: ${normalizedHeaders.join(', ')}`);
+            process.exit(1);
+          }
+
+          // Store the actual column names
+          urlColumnName = headers[urlIndex];
+          memberIdColumnName = headers[memberIdIndex];
+          headersValidated = true;
+        }
+
+        rowNumber++;
+        totalMembers++;
+
+        // Get URL and memberId using the actual column names from headers
+        const url = row[urlColumnName];
+        const memberId = row[memberIdColumnName];
+
+        // Skip rows with missing URL or memberId
+        if (!url || !memberId) {
+          console.warn(
+            `Warning: Row ${rowNumber} skipped - missing url or memberId (url: ${url}, memberId: ${memberId})`
+          );
+          return;
+        }
+
+        const trimmedUrl = url.trim();
+        const trimmedMemberId = memberId.trim();
+
+        // Track URL occurrences
+        if (!urlMap.has(trimmedUrl)) {
+          urlMap.set(trimmedUrl, []);
+        }
+        urlMap.get(trimmedUrl).push(trimmedMemberId);
+      })
+      .on('error', error => {
+        console.error('Error reading CSV file:', error.message);
+        reject(error);
+      })
+      .on('end', () => {
+        if (!headersValidated) {
+          console.error('Error: Could not read CSV headers');
+          process.exit(1);
+        }
+
+        // Find duplicates (URLs with count > 1)
+        const duplicateUrls = [];
+        let totalDuplicates = 0;
+
+        for (const [url, memberIds] of urlMap.entries()) {
+          if (memberIds.length > 1) {
+            duplicateUrls.push({
+              url: url,
+              count: memberIds.length,
+              memberIds: memberIds,
+            });
+            totalDuplicates += memberIds.length;
+          }
+        }
+
+        // Sort by count (descending) then by URL (ascending)
+        duplicateUrls.sort((a, b) => {
+          if (b.count !== a.count) {
+            return b.count - a.count;
+          }
+          return a.url.localeCompare(b.url);
+        });
+
+        const totalUniqueUrls = urlMap.size;
+        const uniqueDuplicateUrls = duplicateUrls.length;
+
+        // Create a simple list of duplicated URLs (just the URL strings)
+        const duplicatedUrlsList = duplicateUrls.map(item => item.url);
+
+        // Generate report
+        const report = {
+          totalMembers: totalMembers,
+          totalUniqueUrls: totalUniqueUrls,
+          duplicateUrls: duplicateUrls,
+          duplicatedUrlsList: duplicatedUrlsList,
+          summary: {
+            totalDuplicates: totalDuplicates,
+            uniqueDuplicateUrls: uniqueDuplicateUrls,
+          },
+        };
+
+        // Generate output filename
+        const csvDir = path.dirname(csvFilePath);
+        const csvBasename = path.basename(csvFilePath, path.extname(csvFilePath));
+        const outputPath = path.join(csvDir, `${csvBasename}-duplicate-urls-report.json`);
+
+        // Write JSON report
+        fs.writeFileSync(outputPath, JSON.stringify(report, null, 2), 'utf8');
+
+        console.log('\n=== Duplicate URL Report ===');
+        console.log(`Total members processed: ${totalMembers}`);
+        console.log(`Total unique URLs: ${totalUniqueUrls}`);
+        console.log(`Unique URLs with duplicates: ${uniqueDuplicateUrls}`);
+        console.log(`Total duplicate entries: ${totalDuplicates}`);
+        console.log(`\nReport saved to: ${outputPath}`);
+        console.log(`\nTop 10 most duplicated URLs:`);
+        duplicateUrls.slice(0, 10).forEach((item, index) => {
+          console.log(
+            `  ${index + 1}. "${item.url}" - appears ${item.count} times (memberIds: ${item.memberIds.join(', ')})`
+          );
+        });
+
+        resolve(report);
+      });
+  });
+}
+
+// Run if executed directly
+if (require.main === module) {
+  const csvFilePath = process.argv[2];
+  findDuplicateUrls(csvFilePath).catch(error => {
+    console.error('Fatal error:', error.message);
+    process.exit(1);
+  });
+}
+
+module.exports = { findDuplicateUrls };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abmp-npm",
-  "version": "2.0.7",
+  "version": "2.0.10",
   "main": "index.js",
   "scripts": {
     "check-cycles": "madge --circular .",
@@ -9,7 +9,8 @@
     "lint:fix": "eslint . --fix",
     "format": "prettier --write \"**/*.{js,json,md}\"",
     "format:check": "prettier --check \"**/*.{js,json,md}\"",
-    "prepare": "husky"
+    "prepare": "husky",
+    "find-duplicates": "node dev-only-scripts/find-duplicate-urls.js"
   },
   "author": "",
   "license": "ISC",
@@ -46,6 +47,7 @@
     "crypto": "^1.0.1",
     "jwt-js-decode": "^1.9.0",
     "lodash": "^4.17.21",
+    "csv-parser": "^3.0.0",
     "ngeohash": "^0.6.3",
     "phone": "^3.1.67",
     "psdev-task-manager": "1.1.7",

package/pages/personalDetails.js

@@ -1106,6 +1106,7 @@ async function personalDetailsOnReady({
         });
         _$w('#profileLink').text = newProfileLink;
         _$w('#profileLink').link = newProfileLink;
+        _$w('#urlWebsiteText').text = newProfileLink;
 
         _$w(SLUG_FLAGS.VALID).collapse();
         _$w(SLUG_FLAGS.INVALID).collapse();
@@ -1858,8 +1859,15 @@ 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);
     }
   }