abmp-npm 1.1.135 → 1.1.137

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
@@ -20,7 +16,8 @@ async function ensureUniqueUrlsInBatch(memberDataList) {
     return memberDataList;
   }
 
-  // Group members by their normalized base URL
+  // Group members by their normalized base URL (case-insensitive to avoid
+  // "John-12" and "john-12" being treated as different when slugs are matched case-insensitively)
   const urlGroups = new Map();
 
   memberDataList.forEach(member => {
@@ -28,16 +25,17 @@ async function ensureUniqueUrlsInBatch(memberDataList) {
       return;
     }
 
-    // Extract the base URL (without any counter) for grouping
     const baseUrl = extractBaseUrl(member.url);
-    if (!urlGroups.has(baseUrl)) {
-      urlGroups.set(baseUrl, []);
+    const groupKey = baseUrl.toLowerCase();
+    if (!urlGroups.has(groupKey)) {
+      urlGroups.set(groupKey, []);
     }
-    urlGroups.get(baseUrl).push(member);
+    urlGroups.get(groupKey).push(member);
   });
 
   // For each group, check database and assign unique URLs sequentially
-  for (const [baseUrl, members] of urlGroups.entries()) {
+  for (const [groupKey, members] of urlGroups.entries()) {
+    const baseUrl = groupKey; // lowercase for consistent slug assignment
     if (members.length <= 1) {
       // Single member - still check DB to ensure it doesn't conflict with other pages
       const member = members[0];
@@ -80,14 +78,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

@@ -1,7 +1,9 @@
+const { ADDRESS_STATUS_TYPES } = require('../../public/consts');
 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');
 
 /**
@@ -43,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}`);
@@ -82,7 +82,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/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/dev-only-methods.js

@@ -1,6 +1,7 @@
 const { COLLECTIONS } = require('../public/consts');
 
 const { ensureUniqueUrlsInBatch } = require('./daily-pull/bulk-process-methods');
+const { ensureUniqueUrl } = require('./daily-pull/process-member-methods');
 const { wixData } = require('./elevated-modules');
 const { bulkSaveMembers } = require('./members-data-methods');
 const { queryAllItems } = require('./utils');
@@ -27,4 +28,31 @@ async function copyContactIdToWixMemberId() {
   return await bulkSaveMembers(updatedMembers, COLLECTIONS.MEMBERS_DATA);
 }
 
-module.exports = { deduplicateURls, copyContactIdToWixMemberId };
+async function createMissingUrls() {
+  const query = wixData.query(COLLECTIONS.MEMBERS_DATA).isEmpty('url');
+  const members = await queryAllItems(query);
+  console.log(
+    'membersWithoutUrls info',
+    JSON.stringify({
+      count: members.length,
+      membersIds: members.map(m => m.memberId),
+    })
+  );
+
+  const membersWithGeneratedUrlsPromises = members.map(async member => ({
+    ...member,
+    url: await ensureUniqueUrl({
+      url: member.url,
+      memberId: member.memberId,
+      fullName: member.fullName,
+    }),
+  }));
+  const membersWithGeneratedUrls = await Promise.all(membersWithGeneratedUrlsPromises);
+  //recheck urls in same batch to avoid duplicates
+  const uniqueUrlsUpdatedMembers = await ensureUniqueUrlsInBatch(membersWithGeneratedUrls);
+  const urls = uniqueUrlsUpdatedMembers.map(m => m.url).filter(Boolean);
+  console.log('unique urls', [...new Set(urls)]);
+  return await bulkSaveMembers(uniqueUrlsUpdatedMembers, COLLECTIONS.MEMBERS_DATA);
+}
+
+module.exports = { deduplicateURls, copyContactIdToWixMemberId, createMissingUrls };

package/backend/jobs.js

@@ -68,6 +68,20 @@ async function scheduleCreateContactsFromMembersTask() {
   }
 }
 
+async function scheduleFixPrimaryAddressForMembersTask() {
+  try {
+    console.log('scheduleFixPrimaryAddressForMembers started!');
+    return await taskManager().schedule({
+      name: TASKS_NAMES.scheduleFixPrimaryAddressForMembers,
+      data: {},
+      type: 'scheduled',
+    });
+  } catch (error) {
+    console.error(`Failed to scheduleFixPrimaryAddressForMembers: ${error.message}`);
+    throw new Error(`Failed to scheduleFixPrimaryAddressForMembers: ${error.message}`);
+  }
+}
+
 async function updateSiteMapS3() {
   try {
     return await taskManager().schedule({
@@ -85,4 +99,5 @@ module.exports = {
   scheduleDailyPullTask,
   updateSiteMapS3,
   scheduleCreateContactsFromMembersTask,
+  scheduleFixPrimaryAddressForMembersTask,
 };

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
@@ -410,7 +411,8 @@ async function getMembersWithWixUrl() {
     .eq('showWixUrl', true)
     .ne('action', MEMBER_ACTIONS.DROP)
     .ne('memberships.membertype', MEMBERSHIPS_TYPES.PAC_STAFF)
-    .isNotEmpty('url')
+    .ne('memberships.membertype', MEMBERSHIPS_TYPES.STUDENT)
+    //.isNotEmpty('url') - not used because it's not working as expected
     .limit(1000);
   let currentResults = await membersQuery.find();
   let i = 0;
@@ -422,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/routers/methods.js

@@ -47,10 +47,12 @@ const createRoutersHandlers = wixRouterMethods => {
         }
         const profileUrl = `${request.baseUrl}/${PAGES_PATHS.PROFILE}/${profileData.url}`;
         const isPrivateMember = profileData.isPrivateMember;
+        const isStudent = profileData.shouldHaveStudentBadge;
+        const shouldNoIndex = isPrivateMember || isStudent;
         const seoData = {
           title: seoTitle,
           description: description,
-          noIndex: isPrivateMember,
+          noIndex: shouldNoIndex,
           metaTags: [
             {
               name: 'description',
@@ -69,7 +71,7 @@ const createRoutersHandlers = wixRouterMethods => {
             },
             {
               name: 'robots',
-              content: isPrivateMember ? 'noindex, nofollow' : 'index, follow',
+              content: shouldNoIndex ? 'noindex, nofollow' : 'index, follow',
             },
             // Open Graph tags
             {

package/backend/routers/utils.js

@@ -66,6 +66,11 @@ function transformMemberToProfileData(member, siteAssociation) {
           numeric: true,
         })
       ) || [];
+
+  const phones = Array.isArray(member.phones) ? member.phones : [];
+  const toShowPhone = member.toShowPhone || '';
+  const phone = toShowPhone && phones.includes(toShowPhone) ? toShowPhone : '';
+
   return {
     mainAddress,
     testimonials: member.testimonial || [],
@@ -84,7 +89,7 @@ function transformMemberToProfileData(member, siteAssociation) {
     bookingUrl: member.bookingUrl,
     aboutService: member.aboutService,
     businessName: (member.showBusinessName && member.businessName) || '',
-    phone: member.toShowPhone || '',
+    phone,
     areasOfPractices,
     gallery: member.gallery,
     bannerImages: member.bannerImages,