abmp-npm 2.0.49 → 2.0.52

package/backend/__tests__/url-uniqueness.test.js

@@ -0,0 +1,194 @@
+const { incrementUrlCounter, extractBaseUrl } = require('../daily-pull/utils');
+const {
+  normalizeUrlForComparison,
+  sortByUrlCounterDescending,
+  extractUrlCounter,
+} = require('../utils');
+
+// ─── Helpers ─────────────────────────────────────────────────────────
+
+/**
+ * Simulates getMemberBySlug's normalized-comparison branch using
+ * the ACTUAL production sort comparator imported from utils.js.
+ */
+function simulateGetHighestMember(allMembers, slug) {
+  const matching = allMembers.filter(
+    m => m.url && normalizeUrlForComparison(m.url) === slug.toLowerCase()
+  );
+  matching.sort(sortByUrlCounterDescending);
+  return matching[0] || null;
+}
+
+/**
+ * Simulates ensureUniqueUrl's counter-increment logic given the
+ * "highest" member returned by getMemberBySlug.
+ */
+function simulateEnsureUniqueUrl(baseSlug, highestMember) {
+  if (!highestMember || !highestMember.url) return baseSlug;
+  return incrementUrlCounter(highestMember?.url, baseSlug);
+}
+
+// ─── Test data ───────────────────────────────────────────────────────
+
+function buildMembersInDb() {
+  return [
+    { memberId: 1, url: 'firstNameLastName' },
+    { memberId: 2, url: 'firstNameLastName-1' },
+    { memberId: 3, url: 'firstNameLastName-2' },
+    { memberId: 4, url: 'firstNameLastName-3' },
+    { memberId: 5, url: 'firstNameLastName-4' },
+    { memberId: 6, url: 'firstNameLastName-5' },
+    { memberId: 7, url: 'firstNameLastName-6' },
+    { memberId: 8, url: 'firstNameLastName-7' },
+    { memberId: 9, url: 'firstNameLastName-8' },
+    { memberId: 10, url: 'firstNameLastName-9' },
+    { memberId: 11, url: 'firstNameLastName-10' },
+    { memberId: 12, url: 'firstNameLastName-11' },
+    { memberId: 13, url: 'firstNameLastName-12' },
+  ];
+}
+
+function buildLargeCounterMembers() {
+  const members = [];
+  for (let i = 0; i <= 105; i++) {
+    members.push({ memberId: i, url: i === 0 ? 'testUser' : `testUser-${i}` });
+  }
+  return members;
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────
+
+describe('Production sort: getMemberBySlug must return the HIGHEST counter', () => {
+  test('should return -12 as the highest URL (not -9)', () => {
+    const members = buildMembersInDb();
+    const highest = simulateGetHighestMember(members, 'firstnamelastname');
+
+    expect(highest.url).toBe('firstNameLastName-12');
+  });
+
+  test('should sort -12 above -9 in descending order', () => {
+    const members = buildMembersInDb();
+    const sorted = [...members]
+      .filter(m => normalizeUrlForComparison(m.url) === 'firstnamelastname')
+      .sort(sortByUrlCounterDescending);
+    const sortedUrls = sorted.map(m => m.url);
+
+    const indexOf9 = sortedUrls.indexOf('firstNameLastName-9');
+    const indexOf12 = sortedUrls.indexOf('firstNameLastName-12');
+
+    expect(indexOf12).toBeLessThan(indexOf9);
+  });
+
+  test('should handle large counters (100+) correctly', () => {
+    const members = buildLargeCounterMembers();
+    const highest = simulateGetHighestMember(members, 'testuser');
+
+    expect(highest.url).toBe('testUser-105');
+  });
+
+  test('should handle hyphenated names (mary-jane) correctly', () => {
+    const members = [
+      { memberId: 1, url: 'mary-jane' },
+      { memberId: 2, url: 'mary-jane-1' },
+      { memberId: 3, url: 'mary-jane-2' },
+      { memberId: 4, url: 'mary-jane-10' },
+    ];
+
+    const highest = simulateGetHighestMember(members, 'mary-jane');
+    expect(highest.url).toBe('mary-jane-10');
+  });
+});
+
+describe('Production sort: ensureUniqueUrl must generate a truly unique URL', () => {
+  test('should generate -13 (not -10) when DB has URLs up to -12', () => {
+    const members = buildMembersInDb();
+    const highest = simulateGetHighestMember(members, 'firstnamelastname');
+    const newUrl = simulateEnsureUniqueUrl('firstNameLastName', highest);
+
+    expect(newUrl).toBe('firstNameLastName-13');
+
+    const existingUrls = members.map(m => m.url);
+    expect(existingUrls).not.toContain(newUrl);
+  });
+
+  test('repeated daily pulls should produce sequential unique URLs', () => {
+    const members = buildMembersInDb();
+    const generatedUrls = [];
+
+    for (let day = 0; day < 5; day++) {
+      const highest = simulateGetHighestMember(members, 'firstnamelastname');
+      const newUrl = simulateEnsureUniqueUrl('firstNameLastName', highest);
+      generatedUrls.push(newUrl);
+      members.push({ memberId: 100 + day, url: newUrl });
+    }
+
+    expect(new Set(generatedUrls).size).toBe(5);
+    expect(generatedUrls).toEqual([
+      'firstNameLastName-13',
+      'firstNameLastName-14',
+      'firstNameLastName-15',
+      'firstNameLastName-16',
+      'firstNameLastName-17',
+    ]);
+  });
+
+  test('should NOT produce duplicates (the -10 bug)', () => {
+    const members = buildMembersInDb();
+    const highest = simulateGetHighestMember(members, 'firstnamelastname');
+    const newUrl = simulateEnsureUniqueUrl('firstNameLastName', highest);
+
+    expect(newUrl).not.toBe('firstNameLastName-10');
+  });
+});
+
+describe('Production sort: ensureUniqueUrlsInBatch single-member path', () => {
+  test('incrementUrlCounter should produce a unique URL from highest DB member', () => {
+    const members = buildMembersInDb();
+    const dbMember = simulateGetHighestMember(members, 'firstnamelastname');
+    const result = incrementUrlCounter(dbMember.url, 'firstNameLastName');
+
+    expect(result).toBe('firstNameLastName-13');
+
+    const existingUrls = members.map(m => m.url);
+    expect(existingUrls).not.toContain(result);
+  });
+});
+
+describe('Utility functions', () => {
+  test('normalizeUrlForComparison strips trailing counter', () => {
+    expect(normalizeUrlForComparison('firstNameLastName')).toBe('firstnamelastname');
+    expect(normalizeUrlForComparison('firstNameLastName-1')).toBe('firstnamelastname');
+    expect(normalizeUrlForComparison('firstNameLastName-9')).toBe('firstnamelastname');
+    expect(normalizeUrlForComparison('firstNameLastName-10')).toBe('firstnamelastname');
+    expect(normalizeUrlForComparison('firstNameLastName-100')).toBe('firstnamelastname');
+  });
+
+  test('extractUrlCounter returns numeric counter', () => {
+    expect(extractUrlCounter('firstNameLastName')).toBe(-1);
+    expect(extractUrlCounter('firstNameLastName-1')).toBe(1);
+    expect(extractUrlCounter('firstNameLastName-9')).toBe(9);
+    expect(extractUrlCounter('firstNameLastName-10')).toBe(10);
+    expect(extractUrlCounter('firstNameLastName-100')).toBe(100);
+    expect(extractUrlCounter(null)).toBe(-1);
+    expect(extractUrlCounter('')).toBe(-1);
+  });
+
+  test('extractBaseUrl strips numeric counter', () => {
+    expect(extractBaseUrl('firstNameLastName-10')).toBe('firstNameLastName');
+    expect(extractBaseUrl('firstNameLastName-1')).toBe('firstNameLastName');
+    expect(extractBaseUrl('firstNameLastName')).toBe('firstNameLastName');
+    expect(extractBaseUrl('john-doe-3')).toBe('john-doe');
+  });
+
+  test('incrementUrlCounter increments correctly', () => {
+    expect(incrementUrlCounter('firstNameLastName-9', 'firstNameLastName')).toBe(
+      'firstNameLastName-10'
+    );
+    expect(incrementUrlCounter('firstNameLastName-10', 'firstNameLastName')).toBe(
+      'firstNameLastName-11'
+    );
+    expect(incrementUrlCounter('firstNameLastName', 'firstNameLastName')).toBe(
+      'firstNameLastName-1'
+    );
+  });
+});

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

@@ -1,12 +1,8 @@
 const { bulkSaveMembers, getMemberBySlug } = require('../members-data-methods');
+const { extractUrlCounter } = require('../utils');
 
 const { generateUpdatedMemberData } = require('./process-member-methods');
-const {
-  changeWixMembersEmails,
-  extractUrlCounter,
-  incrementUrlCounter,
-  extractBaseUrl,
-} = require('./utils');
+const { changeWixMembersEmails, incrementUrlCounter, extractBaseUrl } = require('./utils');
 
 /**
  * Ensures unique URLs within a batch of members by deduplicating URLs
@@ -80,14 +76,9 @@ async function ensureUniqueUrlsInBatch(memberDataList) {
     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;
-        }
+      const urlCounter = extractUrlCounter(originalUrl);
+      if (urlCounter > batchMaxCounter) {
+        batchMaxCounter = urlCounter;
       }
     });
 

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

@@ -3,6 +3,7 @@ const { findMemberById, getMemberBySlug } = require('../members-data-methods');
 const { isValidArray, generateGeoHash } = require('../utils');
 
 const { MEMBER_ACTIONS, DEFAULT_MEMBER_DISPLAY_SETTINGS } = require('./consts');
+const { incrementUrlCounter } = require('./utils');
 const { validateCoreMemberData, containsNonEnglish, createFullName } = require('./utils');
 
 /**
@@ -44,9 +45,7 @@ const ensureUniqueUrl = async ({ url, memberId, fullName }) => {
     console.log(
       `Found member with same url ${existingMember.url} for memberId ${memberId} and URL ${uniqueUrl}, increasing counter by 1`
     );
-    const lastSegment = existingMember.url.split('-').pop() || '0';
-    const lastCounter = parseInt(lastSegment, 10) || 0;
-    uniqueUrl = `${uniqueUrl}-${lastCounter + 1}`;
+    uniqueUrl = incrementUrlCounter(existingMember.url, uniqueUrl);
   }
   if (uniqueUrl !== baseUrl) {
     console.log(`URL conflict resolved: ${baseUrl} -> ${uniqueUrl} for member ${memberId}`);

package/backend/daily-pull/utils.js

@@ -1,4 +1,5 @@
 const { updateWixMemberLoginEmail } = require('../members-area-methods');
+const { extractUrlCounter } = require('../utils');
 
 const { MEMBER_ACTIONS } = require('./consts');
 
@@ -15,21 +16,12 @@ 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) {
+  const lastCounter = extractUrlCounter(url);
+  if (lastCounter > 0) {
     // Remove the numeric counter to get the base URL
-    return urlParts.slice(0, -1).join('-');
+    return url.split('-').slice(0, -1).join('-');
   }
   // No counter found, return the URL as-is
   return url;
@@ -49,9 +41,7 @@ const incrementUrlCounter = (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;
+    const lastCounter = Math.max(0, extractUrlCounter(existingUrl));
     return `${baseUrl}-${lastCounter + 1}`;
   }
 
@@ -118,7 +108,6 @@ module.exports = {
   validateCoreMemberData,
   containsNonEnglish,
   createFullName,
-  extractUrlCounter,
   incrementUrlCounter,
   extractBaseUrl,
 };

package/backend/members-data-methods.js

@@ -10,6 +10,7 @@ const { createSiteMember, getCurrentMember } = require('./members-area-methods')
 const {
   chunkArray,
   normalizeUrlForComparison,
+  sortByUrlCounterDescending,
   queryAllItems,
   generateGeoHash,
   searchAllItems,
@@ -176,7 +177,7 @@ async function getMemberBySlug({
           //remove trailing "-1", "-2", etc.
           item => item.url && normalizeUrlForComparison(item.url) === slug.toLowerCase()
         )
-        .sort((a, b) => b.url.toLowerCase().localeCompare(a.url.toLowerCase()));
+        .sort(sortByUrlCounterDescending);
     }
     if (matchingMembers.length > 1) {
       const queryResultMsg = `Multiple members found with same slug ${slug} membersIds are : [${matchingMembers
@@ -411,7 +412,7 @@ async function getMembersWithWixUrl() {
     .ne('action', MEMBER_ACTIONS.DROP)
     .ne('memberships.membertype', MEMBERSHIPS_TYPES.PAC_STAFF)
     .ne('memberships.membertype', MEMBERSHIPS_TYPES.STUDENT)
-    .isNotEmpty('url')
+    //.isNotEmpty('url') - not used because it's not working as expected
     .limit(1000);
   let currentResults = await membersQuery.find();
   let i = 0;
@@ -423,7 +424,9 @@ async function getMembersWithWixUrl() {
     i++;
   }
   console.log('i is ', i);
-  const filtered = allItems.filter(item => typeof item.url === 'string' && !item.url.includes('/'));
+  const filtered = allItems.filter(
+    item => typeof item.url === 'string' && !item.url.includes('/') && item.url !== ''
+  );
   console.log('filtered is ', filtered.length);
   return filtered;
 }

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

@@ -32,7 +32,7 @@ async function scheduleFixPrimaryAddressForMembers() {
 
     const membersToFix = members.filter(member => {
       const addresses = Array.isArray(member.addresses) ? member.addresses : [];
-      if (addresses.length <= 1) {
+      if (addresses.length === 0) {
         return false;
       }
       return !hasPrimaryAddress(member.addressDisplayOption);
@@ -45,7 +45,7 @@ async function scheduleFixPrimaryAddressForMembers() {
           .filter(memberId => Number.isFinite(memberId) && memberId > 0)
       ),
     ];
-    console.log(`Members with multiple addresses and no primary: ${memberIds.length}`);
+    console.log(`Members with addresses and no primary: ${memberIds.length}`);
 
     if (memberIds.length === 0) {
       console.log('No members need primary address fixes');
@@ -109,7 +109,7 @@ async function fixPrimaryAddressChunk(data) {
     skippedIds: [],
     failedIds: [],
   };
-  const skippedNoMultiAddress = [];
+  const skippedNoAddress = [];
   const skippedHasPrimary = [];
   const updatedIds = [];
 
@@ -120,11 +120,11 @@ async function fixPrimaryAddressChunk(data) {
 
     members.forEach(member => {
       const addresses = Array.isArray(member.addresses) ? member.addresses : [];
-      if (addresses.length <= 1) {
+      if (addresses.length === 0) {
         result.skipped++;
         result.skippedIds.push(member.memberId);
-        if (skippedNoMultiAddress.length < 20) {
-          skippedNoMultiAddress.push(member.memberId);
+        if (skippedNoAddress.length < 20) {
+          skippedNoAddress.push(member.memberId);
         }
         return;
       }
@@ -191,8 +191,8 @@ async function fixPrimaryAddressChunk(data) {
       });
     }
 
-    if (skippedNoMultiAddress.length > 0) {
-      console.log(`Skipped (<=1 address) sample: ${skippedNoMultiAddress.join(', ')}`);
+    if (skippedNoAddress.length > 0) {
+      console.log(`Skipped (no addresses) sample: ${skippedNoAddress.join(', ')}`);
     }
     if (skippedHasPrimary.length > 0) {
       console.log(`Skipped (already has primary) sample: ${skippedHasPrimary.join(', ')}`);
@@ -205,7 +205,52 @@ async function fixPrimaryAddressChunk(data) {
   }
 }
 
+/**
+ * Returns count of members with addresses but no primary address.
+ */
+async function countMembersMissingPrimaryAddress() {
+  console.log('=== Counting Members Missing Primary Address ===');
+
+  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;
+      }
+      return !hasPrimaryAddress(member.addressDisplayOption);
+    });
+
+    const memberIds = [
+      ...new Set(
+        membersToFix
+          .map(member => Number(member.memberId))
+          .filter(memberId => Number.isFinite(memberId) && memberId > 0)
+      ),
+    ];
+
+    const result = {
+      success: true,
+      totalMembers: memberIds.length,
+      sampleMemberIds: memberIds.slice(0, 20),
+    };
+
+    console.log(JSON.stringify(result, null, 2));
+    return result;
+  } catch (error) {
+    console.error('Error counting members missing primary address:', error);
+    throw error;
+  }
+}
+
 module.exports = {
   scheduleFixPrimaryAddressForMembers,
   fixPrimaryAddressChunk,
+  countMembersMissingPrimaryAddress,
 };

package/backend/utils.js

@@ -164,6 +164,14 @@ const normalizeUrlForComparison = url => {
   return url.toLowerCase().replace(/-\d+$/, '');
 };
 
+const extractUrlCounter = url => {
+  if (!url) return -1;
+  const lastSegment = url.split('-').pop() || '0';
+  return /^\d+$/.test(lastSegment) ? parseInt(lastSegment, 10) : -1;
+};
+
+const sortByUrlCounterDescending = (a, b) => extractUrlCounter(b.url) - extractUrlCounter(a.url);
+
 async function getSecret(secretKey) {
   return (await elevatedGetSecretValue(secretKey)).value;
 }
@@ -209,6 +217,8 @@ module.exports = {
   generateGeoHash,
   isValidArray,
   normalizeUrlForComparison,
+  sortByUrlCounterDescending,
+  extractUrlCounter,
   queryAllItems,
   formatDateToMonthYear,
   isStudent,

package/dev-only-scripts/extract-duplicate-url-groups.js

@@ -0,0 +1,201 @@
+const fs = require('fs');
+const path = require('path');
+
+const csv = require('csv-parser');
+
+/**
+ * Reads a Members Data CSV and extracts groups of non-unique URLs:
+ * each group is a URL plus the list of IDs and memberIds that share that URL.
+ * Only outputs groups where the same URL appears more than once.
+ * Report includes duplicateUrls, memberIdsWithDuplicateUrls (flat array of unique memberIds
+ * in duplicate groups), and nonUniqueMemberIds (memberIds that appear more than once, with count).
+ *
+ * Usage: node dev-only-scripts/extract-duplicate-url-groups.js <path-to-csv> [output-json-path]
+ * Example: node dev-only-scripts/extract-duplicate-url-groups.js "/Users/Besan/Downloads/Members+Data+Latest (17).csv"
+ *
+ * CSV must have columns: "url", "ID", and "memberId" (case-insensitive).
+ */
+function extractDuplicateUrlGroups(csvFilePath, outputJsonPath) {
+  if (!csvFilePath) {
+    console.error('Error: CSV file path is required');
+    console.error(
+      'Usage: node dev-only-scripts/extract-duplicate-url-groups.js <path-to-csv> [output-json-path]'
+    );
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(csvFilePath)) {
+    console.error(`Error: File not found: ${csvFilePath}`);
+    process.exit(1);
+  }
+
+  const urlToRows = new Map(); // url -> [{ id, memberId }, ...]
+  let totalRows = 0;
+  let headersValidated = false;
+  let headers = null;
+  let urlColumnName = null;
+  let idColumnName = null;
+  let memberIdColumnName = null;
+
+  return new Promise((resolve, reject) => {
+    fs.createReadStream(csvFilePath)
+      .pipe(csv())
+      .on('headers', receivedHeaders => {
+        headers = receivedHeaders;
+        const normalizedHeaders = headers.map(h => {
+          const normalized = String(h).trim().replace(/["']/g, '');
+          return normalized.toLowerCase().trim();
+        });
+
+        const urlIndex = normalizedHeaders.indexOf('url');
+        const idIndex = normalizedHeaders.indexOf('id');
+        const memberIdIndex = normalizedHeaders.indexOf('memberid');
+
+        if (urlIndex === -1 || idIndex === -1 || memberIdIndex === -1) {
+          console.error(
+            'Error: CSV must contain "url", "ID", and "memberId" columns (case-insensitive)'
+          );
+          console.error(`Found columns: ${headers.join(', ')}`);
+          process.exit(1);
+        }
+
+        urlColumnName = headers[urlIndex];
+        idColumnName = headers[idIndex];
+        memberIdColumnName = headers[memberIdIndex];
+        headersValidated = true;
+      })
+      .on('data', row => {
+        if (!headersValidated) {
+          headers = Object.keys(row);
+          const normalizedHeaders = headers.map(h => {
+            const normalized = String(h).trim().replace(/["']/g, '');
+            return normalized.toLowerCase().trim();
+          });
+          const urlIndex = normalizedHeaders.indexOf('url');
+          const idIndex = normalizedHeaders.indexOf('id');
+          const memberIdIndex = normalizedHeaders.indexOf('memberid');
+          if (urlIndex === -1 || idIndex === -1 || memberIdIndex === -1) {
+            console.error(
+              'Error: CSV must contain "url", "ID", and "memberId" columns (case-insensitive)'
+            );
+            process.exit(1);
+          }
+          urlColumnName = headers[urlIndex];
+          idColumnName = headers[idIndex];
+          memberIdColumnName = headers[memberIdIndex];
+          headersValidated = true;
+        }
+
+        totalRows++;
+
+        const url = row[urlColumnName];
+        const id = row[idColumnName];
+        const memberId = row[memberIdColumnName];
+
+        if (!url || !id) {
+          return;
+        }
+
+        const trimmedUrl = url.trim();
+        const trimmedId = id.trim();
+        const trimmedMemberId =
+          memberId != null && String(memberId).trim() !== '' ? String(memberId).trim() : null;
+
+        if (!urlToRows.has(trimmedUrl)) {
+          urlToRows.set(trimmedUrl, []);
+        }
+        urlToRows.get(trimmedUrl).push({ id: trimmedId, memberId: 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);
+        }
+
+        const groups = [];
+        for (const [url, rows] of urlToRows.entries()) {
+          if (rows.length > 1) {
+            const ids = rows.map(r => r.id);
+            const memberIds = rows.map(r => r.memberId).filter(Boolean);
+            groups.push({ url, ids, memberIds });
+          }
+        }
+
+        groups.sort((a, b) => {
+          if (b.ids.length !== a.ids.length) return b.ids.length - a.ids.length;
+          return a.url.localeCompare(b.url);
+        });
+
+        const totalIdsInGroups = groups.reduce((sum, g) => sum + g.ids.length, 0);
+        const duplicateUrls = groups.map(g => g.url);
+        const allMemberIdOccurrences = groups.flatMap(g => g.memberIds);
+        const memberIdsWithDuplicateUrls = [...new Set(allMemberIdOccurrences)];
+
+        const memberIdCounts = new Map();
+        for (const memberId of allMemberIdOccurrences) {
+          memberIdCounts.set(memberId, (memberIdCounts.get(memberId) || 0) + 1);
+        }
+        const nonUniqueMemberIds = [...memberIdCounts.entries()]
+          .filter(([, count]) => count > 1)
+          .map(([memberId, count]) => ({ memberId, count }))
+          .sort((a, b) => b.count - a.count);
+
+        const report = {
+          totalRowsProcessed: totalRows,
+          totalDuplicateGroups: groups.length,
+          totalIdsInDuplicateGroups: totalIdsInGroups,
+          totalMemberIdOccurrencesInDuplicateGroups: allMemberIdOccurrences.length,
+          uniqueMemberIdsWithDuplicateUrls: memberIdsWithDuplicateUrls.length,
+          nonUniqueMemberIdsCount: nonUniqueMemberIds.length,
+          duplicateUrls,
+          memberIdsWithDuplicateUrls,
+          nonUniqueMemberIds,
+          groups,
+        };
+
+        if (outputJsonPath) {
+          fs.writeFileSync(outputJsonPath, JSON.stringify(report, null, 2), 'utf8');
+          console.log(`Report written to: ${outputJsonPath}`);
+        } else {
+          const csvDir = path.dirname(csvFilePath);
+          const csvBasename = path.basename(csvFilePath, path.extname(csvFilePath));
+          const defaultPath = path.join(csvDir, `${csvBasename}-duplicate-url-groups.json`);
+          fs.writeFileSync(defaultPath, JSON.stringify(report, null, 2), 'utf8');
+          console.log(`Report written to: ${defaultPath}`);
+        }
+
+        console.log('\n=== Non-unique URL groups (same URL → list of IDs, memberIds) ===');
+        console.log(`Total rows processed: ${totalRows}`);
+        console.log(`Number of duplicate URL groups: ${groups.length}`);
+        console.log(`Total IDs in those groups: ${totalIdsInGroups}`);
+        console.log(`Total memberId occurrences in those groups: ${allMemberIdOccurrences.length}`);
+        console.log(`Unique memberIds in those groups: ${memberIdsWithDuplicateUrls.length}`);
+        console.log(
+          `MemberIds that appear more than once (non-unique): ${nonUniqueMemberIds.length}`
+        );
+        if (duplicateUrls.length > 0) {
+          console.log('\nFirst 15 duplicate URLs:');
+          duplicateUrls.slice(0, 15).forEach((url, i) => {
+            console.log(`  ${i + 1}. ${url}`);
+          });
+        }
+
+        resolve(report);
+      });
+  });
+}
+
+if (require.main === module) {
+  const csvFilePath = process.argv[2];
+  const outputJsonPath = process.argv[3];
+  extractDuplicateUrlGroups(csvFilePath, outputJsonPath).catch(error => {
+    console.error('Fatal error:', error.message);
+    process.exit(1);
+  });
+}
+
+module.exports = { extractDuplicateUrlGroups };

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

@@ -0,0 +1,159 @@
+const fs = require('fs');
+const path = require('path');
+
+const csv = require('csv-parser');
+
+/**
+ * Reads a Members Data CSV and finds duplicate memberIds: any memberId (memberId column)
+ * that appears in more than one row. Outputs a JSON report with the list of
+ * duplicate memberIds and, per memberId, the rows (e.g. ID, url) where it appears.
+ *
+ * Usage: node dev-only-scripts/find-duplicate-ids.js <path-to-csv> [output-json-path]
+ *
+ * CSV must have a "memberId" column (case-insensitive). Optional: "ID", "url" for row details.
+ */
+function findDuplicateMemberIds(csvFilePath, outputJsonPath) {
+  if (!csvFilePath) {
+    console.error('Error: CSV file path is required');
+    console.error(
+      'Usage: node dev-only-scripts/find-duplicate-ids.js <path-to-csv> [output-json-path]'
+    );
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(csvFilePath)) {
+    console.error(`Error: File not found: ${csvFilePath}`);
+    process.exit(1);
+  }
+
+  const memberIdToRows = new Map(); // memberId -> [{ rowNumber, id?, url? }, ...]
+  let totalRows = 0;
+  let headersValidated = false;
+  let headers = null;
+  let memberIdColumnName = null;
+  let idColumnName = null;
+  let urlColumnName = null;
+
+  return new Promise((resolve, reject) => {
+    fs.createReadStream(csvFilePath)
+      .pipe(csv())
+      .on('headers', receivedHeaders => {
+        headers = receivedHeaders;
+        const normalizedHeaders = headers.map(h => {
+          const normalized = String(h).trim().replace(/["']/g, '');
+          return normalized.toLowerCase().trim();
+        });
+
+        const memberIdIndex = normalizedHeaders.indexOf('memberid');
+        if (memberIdIndex === -1) {
+          console.error('Error: CSV must contain a "memberId" column (case-insensitive)');
+          console.error(`Found columns: ${headers.join(', ')}`);
+          process.exit(1);
+        }
+
+        memberIdColumnName = headers[memberIdIndex];
+        idColumnName = headers[normalizedHeaders.indexOf('id')] || null;
+        urlColumnName = headers[normalizedHeaders.indexOf('url')] || null;
+        headersValidated = true;
+      })
+      .on('data', row => {
+        if (!headersValidated) {
+          headers = Object.keys(row);
+          const normalizedHeaders = headers.map(h => {
+            const normalized = String(h).trim().replace(/["']/g, '');
+            return normalized.toLowerCase().trim();
+          });
+          const memberIdIndex = normalizedHeaders.indexOf('memberid');
+          if (memberIdIndex === -1) {
+            console.error('Error: CSV must contain a "memberId" column (case-insensitive)');
+            process.exit(1);
+          }
+          memberIdColumnName = headers[memberIdIndex];
+          idColumnName = headers[normalizedHeaders.indexOf('id')] || null;
+          urlColumnName = headers[normalizedHeaders.indexOf('url')] || null;
+          headersValidated = true;
+        }
+
+        totalRows++;
+        const memberId = row[memberIdColumnName];
+        if (memberId == null || String(memberId).trim() === '') return;
+
+        const trimmedMemberId = String(memberId).trim();
+        const rowInfo = { rowNumber: totalRows };
+        if (idColumnName && row[idColumnName] != null)
+          rowInfo.id = String(row[idColumnName]).trim();
+        if (urlColumnName && row[urlColumnName] != null)
+          rowInfo.url = String(row[urlColumnName]).trim();
+
+        if (!memberIdToRows.has(trimmedMemberId)) {
+          memberIdToRows.set(trimmedMemberId, []);
+        }
+        memberIdToRows.get(trimmedMemberId).push(rowInfo);
+      })
+      .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);
+        }
+
+        const groups = [];
+        for (const [memberId, rows] of memberIdToRows.entries()) {
+          if (rows.length > 1) {
+            groups.push({ memberId, count: rows.length, rows });
+          }
+        }
+
+        groups.sort((a, b) => b.count - a.count);
+
+        const duplicateMemberIds = groups.map(g => g.memberId);
+        const totalDuplicateRows = groups.reduce((sum, g) => sum + g.count, 0);
+
+        const report = {
+          totalRowsProcessed: totalRows,
+          totalDuplicateMemberIds: groups.length,
+          totalRowsWithDuplicateMemberIds: totalDuplicateRows,
+          duplicateMemberIds,
+          groups,
+        };
+
+        if (outputJsonPath) {
+          fs.writeFileSync(outputJsonPath, JSON.stringify(report, null, 2), 'utf8');
+          console.log(`Report written to: ${outputJsonPath}`);
+        } else {
+          const csvDir = path.dirname(csvFilePath);
+          const csvBasename = path.basename(csvFilePath, path.extname(csvFilePath));
+          const defaultPath = path.join(csvDir, `${csvBasename}-duplicate-member-ids-report.json`);
+          fs.writeFileSync(defaultPath, JSON.stringify(report, null, 2), 'utf8');
+          console.log(`Report written to: ${defaultPath}`);
+        }
+
+        console.log('\n=== Duplicate memberIds Report ===');
+        console.log(`Total rows processed: ${totalRows}`);
+        console.log(`memberIds that appear more than once: ${groups.length}`);
+        console.log(`Total rows with those memberIds: ${totalDuplicateRows}`);
+        if (groups.length > 0) {
+          console.log('\nDuplicate memberIds (first 20):');
+          groups.slice(0, 20).forEach((g, i) => {
+            console.log(`  ${i + 1}. ${g.memberId} (${g.count} rows)`);
+          });
+        }
+
+        resolve(report);
+      });
+  });
+}
+
+if (require.main === module) {
+  const csvFilePath = process.argv[2];
+  const outputJsonPath = process.argv[3];
+  findDuplicateMemberIds(csvFilePath, outputJsonPath).catch(error => {
+    console.error('Fatal error:', error.message);
+    process.exit(1);
+  });
+}
+
+module.exports = { findDuplicateMemberIds };

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "abmp-npm",
-  "version": "2.0.49",
+  "version": "2.0.52",
   "main": "index.js",
   "scripts": {
     "check-cycles": "madge --circular .",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest backend/__tests__",
     "lint": "npm run check-cycles && eslint .",
     "lint:fix": "eslint . --fix",
     "format": "prettier --write \"**/*.{js,json,md}\"",
     "format:check": "prettier --check \"**/*.{js,json,md}\"",
     "prepare": "husky",
-    "find-duplicates": "node dev-only-scripts/find-duplicate-urls.js"
+    "find-duplicates": "node dev-only-scripts/find-duplicate-urls.js",
+    "extract-duplicate-url-groups": "node dev-only-scripts/extract-duplicate-url-groups.js",
+    "find-duplicate-ids": "node dev-only-scripts/find-duplicate-ids.js"
   },
   "author": "",
   "license": "ISC",
@@ -25,6 +27,7 @@
     "eslint-plugin-promise": "^7.1.0",
     "globals": "^15.10.0",
     "husky": "^9.1.6",
+    "jest": "^30.3.0",
     "madge": "^8.0.0",
     "prettier": "^3.3.3"
   },
@@ -45,9 +48,9 @@
     "aws4": "^1.13.2",
     "axios": "^1.13.1",
     "crypto": "^1.0.1",
+    "csv-parser": "^3.0.0",
     "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.10",

package/pages/personalDetails.js

@@ -358,8 +358,8 @@ async function personalDetailsOnReady({
   }
 
   function handleOptWebsiteCheckboxEnable(showExistingWebsite) {
-    _$w('#optWebsiteCheckbox').checked = !showExistingWebsite;
     if (showExistingWebsite) {
+      _$w('#optWebsiteCheckbox').checked = false;
       _$w('#optWebsiteCheckbox').customClassList.add('disabled-text');
       _$w('#optWebsiteCheckbox').customClassList.add('disabled-checkbox');
       _$w('#optWebsiteCheckbox').disable();