abmp-npm 2.0.73 → 2.0.74

package/.claude/worktrees/fix-save-button-disable/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/.claude/worktrees/fix-save-button-disable/backend/automations-methods.js

@@ -0,0 +1,13 @@
+const { customTrigger } = require('@wix/automations');
+const { auth } = require('@wix/essentials');
+const triggerMethod = auth.elevate(customTrigger.runTrigger);
+
+const triggerAutomation = async (triggerId, payload) =>
+  await triggerMethod({
+    triggerId,
+    payload,
+  });
+
+module.exports = {
+  triggerAutomation,
+};

package/.claude/worktrees/fix-save-button-disable/backend/cms-data-methods.js

@@ -0,0 +1,251 @@
+const geohash = require('ngeohash');
+
+const { COLLECTIONS, MEMBERS_FIELDS } = require('../public/consts.js');
+const { findMainAddress } = require('../public/Utils/sharedUtils.js');
+const { calculateDistance, shuffleArray } = require('../public/Utils/sharedUtils.js');
+
+const {
+  GEO_HASH_PRECISION,
+  MAX__MEMBERS_SEARCH_RESULTS,
+  WIX_QUERY_MAX_LIMIT,
+  MEMBERSHIPS_TYPES,
+} = require('./consts.js');
+const { wixData } = require('./elevated-modules');
+
+function buildMembersSearchQuery(data) {
+  console.log('data: ', JSON.stringify(data));
+  const { filter, isSearchingNearby, includeStudents = false } = data;
+  const isUserLocationEnabled = filter.latitude !== 0 || filter.longitude !== 0;
+  filter.searchText = filter.searchText || '';
+  filter.stateSearch = filter.stateSearch || '';
+  filter.practiceAreasSearch = filter.practiceAreasSearch || '';
+  filter.practiceAreas = filter.practiceAreas || [];
+  filter.state = filter.state || [];
+  filter.citySearch = filter.citySearch || '';
+  filter.city = filter.city || [];
+  filter.latitude = filter.latitude || 0;
+  filter.longitude = filter.longitude || 0;
+  filter.postalcode = filter.postalcode || '';
+  return {
+    get: () => {
+      let query = wixData
+        .query(COLLECTIONS.MEMBERS_DATA)
+        .ne('optOut', true)
+        .ne('action', 'drop')
+        .ne('memberships.membertype', MEMBERSHIPS_TYPES.PAC_STAFF)
+        .eq('isVisible', true);
+      let filterConfig = [
+        {
+          filterKey: 'practiceAreas',
+          queryMethod: 'hasSome',
+          queryField: 'areasOfPractices',
+          condition: value => value && value.length > 0,
+          fallback: {
+            filterKey: 'practiceAreasSearch',
+            queryMethod: 'contains',
+            queryField: 'areasOfPractices',
+            condition: value => value && value.trim() !== '',
+          },
+        },
+        {
+          filterKey: 'postalcode',
+          queryMethod: 'contains',
+          queryField: 'addresses.postalcode',
+          condition: value => value && value.trim() !== '',
+        },
+        {
+          filterKey: 'state',
+          queryMethod: 'hasSome',
+          queryField: 'addresses.state',
+          condition: value => value && value.length > 0,
+          fallback: {
+            filterKey: 'stateSearch',
+            queryMethod: 'contains',
+            queryField: 'addresses.state',
+            condition: value => value && value.trim() !== '',
+          },
+        },
+        {
+          filterKey: 'city',
+          queryMethod: 'hasSome',
+          queryField: 'addresses.city',
+          condition: value => value && value.length > 0,
+          fallback: {
+            filterKey: 'citySearch',
+            queryMethod: 'contains',
+            queryField: 'addresses.city',
+            condition: value => value && value.trim() !== '',
+          },
+        },
+      ];
+      //Ignore state, city and postal code when isSearchingNearby is true
+      if (isSearchingNearby) {
+        filterConfig = filterConfig.filter(
+          config => !['state', 'city', 'postalcode'].includes(config.filterKey)
+        );
+      }
+      const applyFilterToQuery = (query, config, filter) => {
+        const filterValue = filter[config.filterKey];
+        if (config.condition(filterValue)) {
+          return query[config.queryMethod](config.queryField, filterValue);
+        } else if (config.fallback) {
+          return applyFilterToQuery(query, config.fallback, filter);
+        }
+        return query;
+      };
+      // Apply filters using the configuration
+      filterConfig.forEach(config => {
+        query = applyFilterToQuery(query, config, filter);
+      });
+      if (isUserLocationEnabled && isSearchingNearby) {
+        const userGeohash = geohash.encode(filter.latitude, filter.longitude, GEO_HASH_PRECISION);
+        const neighborGeohashes = geohash.neighbors(userGeohash);
+        const geohashList = [userGeohash, ...neighborGeohashes];
+        query = query.hasSome('locHash', geohashList);
+      }
+      if (filter.searchText.trim() !== '') {
+        query = query.contains('fullName', filter.searchText);
+      }
+      if (!includeStudents) {
+        query = query.ne('memberships.membertype', MEMBERSHIPS_TYPES.STUDENT);
+      }
+      return query;
+    },
+    run: async query => {
+      const baseQuery = query.ascending('firstName').fields(...Object.values(MEMBERS_FIELDS));
+      const getRandomSkip = totalCount => {
+        let randomSkip = 0;
+        if (totalCount > MAX__MEMBERS_SEARCH_RESULTS) {
+          const maxSkip = totalCount - MAX__MEMBERS_SEARCH_RESULTS;
+          randomSkip = Math.floor(Math.random() * (maxSkip + 1));
+        }
+        return randomSkip;
+      };
+      const getResult = async query => {
+        if (isSearchingNearby) {
+          return fetchAllItemsInParallel(baseQuery);
+        }
+        const totalCount = await query.count();
+        const randomSkip = getRandomSkip(totalCount);
+        const result = await query
+          .skip(randomSkip)
+          .limit(MAX__MEMBERS_SEARCH_RESULTS)
+          .find({ omitTotalCount: true });
+
+        // Shuffle the result items for additional randomization
+        return {
+          ...result,
+          items: shuffleArray(result.items),
+        };
+      };
+
+      const result = await getResult(baseQuery);
+      if (isUserLocationEnabled) {
+        const withDistances = result.items.map(item => ({
+          ...item,
+          distance: calculateDistance(
+            {
+              latitude: filter.latitude,
+              longitude: filter.longitude,
+            },
+            findMainAddress(item.addressDisplayOption, item.addresses, {
+              requireValidCoordinates: true,
+            })
+          ),
+        }));
+        const resultWithDistances = {
+          ...result,
+          items: withDistances,
+        };
+        if (isSearchingNearby) {
+          return {
+            ...resultWithDistances,
+            items: withDistances
+              .filter(item => item.distance !== null)
+              .sort((a, b) => a.distance - b.distance)
+              .slice(0, MAX__MEMBERS_SEARCH_RESULTS),
+          };
+        }
+        return resultWithDistances;
+      }
+      return result;
+    },
+  };
+}
+
+// Generic parallel fetch function for large datasets
+async function fetchAllItemsInParallel(query) {
+  const batchSize = WIX_QUERY_MAX_LIMIT;
+  const allItems = [];
+
+  const firstResult = await query.skip(0).limit(batchSize).find();
+
+  const totalBatches = firstResult.totalPages;
+  allItems.push(...firstResult.items);
+
+  if (totalBatches > 1) {
+    // Create parallel promises for all remaining batches
+    const batchPromises = [];
+    for (let i = 1; i < totalBatches; i++) {
+      const skip = i * batchSize;
+      const promise = query
+        .skip(skip)
+        .limit(batchSize)
+        .find()
+        .then(result => result.items);
+      batchPromises.push(promise);
+    }
+
+    // Execute all batches in parallel
+    const batchResults = await Promise.all(batchPromises);
+    for (const items of batchResults) {
+      if (items.length > 0) {
+        allItems.push(...items);
+      }
+    }
+  }
+
+  return {
+    ...firstResult,
+    items: allItems,
+  };
+}
+
+/**
+ * Get all interests from the database
+ * @returns {Promise<Array<string>>} Array of interest titles sorted alphabetically
+ */
+async function getInterestAll() {
+  try {
+    let res = await wixData.query(COLLECTIONS.INTERESTS).limit(1000).find();
+
+    let interests = res.items.map(x => x.title);
+
+    while (res.hasNext()) {
+      res = await res.next();
+      interests.push(...res.items.map(x => x.title));
+    }
+
+    // Sort the interests alphabetically (case-insensitive)
+    interests = interests.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+
+    return interests;
+  } catch (e) {
+    console.error('Error in getInterestAll:', e);
+    throw e;
+  }
+}
+async function clearCollection(collectionName) {
+  try {
+    await wixData.truncate(collectionName);
+  } catch (err) {
+    throw new Error(`Failed to clearCollection ${collectionName} with error: ${err.message}`);
+  }
+}
+
+module.exports = {
+  buildMembersSearchQuery,
+  fetchAllItemsInParallel,
+  getInterestAll,
+  clearCollection,
+};

package/.claude/worktrees/fix-save-button-disable/backend/consts.js

@@ -0,0 +1,58 @@
+const PAC_API_URL = 'https://members.abmp.com/eweb/api/Wix';
+const TEST_PAC_API_URL = 'https://members-test.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/';
+
+/**
+ * Valid configuration keys for getSiteConfigs function
+ * @readonly
+ * @enum {string}
+ */
+const CONFIG_KEYS = {
+  AUTOMATION_EMAIL_TRIGGER_ID: 'AUTOMATION_EMAIL_TRIGGER_ID',
+  SITE_ASSOCIATION: 'SITE_ASSOCIATION',
+  DEFAULT_PROFILE_SEO_DESCRIPTION: 'DEFAULT_PROFILE_SEO_DESCRIPTION',
+  INTERESTS_API_URL: 'INTERESTS_API_URL',
+  SITE_LOGO_URL: 'SITE_LOGO_URL',
+  MEMBERS_EXTERNAL_PORTAL_URL: 'MEMBERS_EXTERNAL_PORTAL_URL',
+  DEFAULT_PROFILE_IMAGE: 'DEFAULT_PROFILE_IMAGE',
+  QA_ALLOW_ANY_MEMBER: 'QA_ALLOW_ANY_MEMBER',
+};
+
+const MAX__MEMBERS_SEARCH_RESULTS = 120;
+const WIX_QUERY_MAX_LIMIT = 1000;
+
+const GEO_HASH_PRECISION = 3;
+
+const COMPILED_FILTERS_FIELDS = {
+  COMPILED_STATE_LIST: 'COMPILED_STATE_LIST',
+  COMPILED_AREAS_OF_PRACTICES: 'COMPILED_AREAS_OF_PRACTICES',
+  COMPILED_STATE_CITY_MAP: 'COMPILED_STATE_CITY_MAP',
+};
+const MEMBERSHIPS_TYPES = {
+  STUDENT: 'Student',
+  PAC_STAFF: 'PAC STAFF',
+};
+
+/**
+ * Possible outcomes of attempting to change a Wix member's login email during the sync.
+ */
+const LOGIN_EMAIL_SYNC_STATUS = {
+  UPDATED: 'updated', // Wix login email successfully changed to the desired email
+  FAILED: 'failed', // change failed -> keep the CMS login email unchanged and report for manual handling
+  SKIPPED: 'skipped', // member has no wixMemberId, nothing to change
+};
+
+module.exports = {
+  CONFIG_KEYS,
+  MAX__MEMBERS_SEARCH_RESULTS,
+  WIX_QUERY_MAX_LIMIT,
+  GEO_HASH_PRECISION,
+  PAC_API_URL,
+  TEST_PAC_API_URL,
+  COMPILED_FILTERS_FIELDS,
+  MEMBERSHIPS_TYPES,
+  SSO_TOKEN_AUTH_API_URL,
+  BACKUP_API_URL,
+  LOGIN_EMAIL_SYNC_STATUS,
+};

package/.claude/worktrees/fix-save-button-disable/backend/contacts-methods.js

@@ -0,0 +1,67 @@
+const { contacts } = require('@wix/crm');
+const { auth } = require('@wix/essentials');
+
+const elevatedGetContact = auth.elevate(contacts.getContact);
+const elevatedUpdateContact = auth.elevate(contacts.updateContact);
+const elevatedCreateContact = auth.elevate(contacts.createContact);
+const elevatedDeleteContact = auth.elevate(contacts.deleteContact);
+
+const deleteSiteContact = contactId => elevatedDeleteContact(contactId);
+
+/**
+ * Create a contact in Wix CRM
+ * @param {Object} contactData - Contact data
+ * @returns {Promise<Object>} - Contact data
+ */
+async function createSiteContact(contactData) {
+  console.log('[createSiteContact]contactData', JSON.stringify(contactData, null, 2));
+  if (!contactData || !contactData.contactFormEmail) {
+    throw new Error('Contact data is required');
+  }
+  const contactInfo = {
+    name: {
+      first: contactData.firstName,
+      last: contactData.lastName,
+    },
+    emails: {
+      items: [{ email: contactData.contactFormEmail, primary: true }],
+    },
+  };
+  console.log('[createSiteContact]contactInfo', JSON.stringify(contactInfo, null, 2));
+  // Intentionally NOT passing allowDuplicates: Wix CRM enforces email uniqueness
+  // case-insensitively, which is the guard we want against two different members sharing an
+  // email. Same-member cases never reach here — they collapse to a single entity upstream.
+  const createContactResponse = await elevatedCreateContact(contactInfo);
+  console.log(
+    '[createSiteContact]createContactResponse',
+    JSON.stringify(createContactResponse, null, 2)
+  );
+  return createContactResponse.contact._id;
+}
+/**
+ * Generic contact update helper function
+ * @param {string} contactId - The contact ID in Wix CRM
+ * @param {function} updateInfoCallback - Function that returns the updated info object
+ * @param {string} operationName - Name of the operation for logging
+ */
+async function updateContactInfo(contactId, updateInfoCallback, operationName) {
+  if (!contactId) {
+    throw new Error('Contact ID is required');
+  }
+
+  try {
+    const contact = await elevatedGetContact(contactId);
+    const currentInfo = contact.info;
+    const updatedInfo = updateInfoCallback(currentInfo);
+    await elevatedUpdateContact(contactId, updatedInfo, contact.revision);
+  } catch (error) {
+    console.error(`Error in ${operationName}:`, error);
+    throw new Error(`Failed to ${operationName}: ${error.message}`);
+  }
+}
+
+module.exports = {
+  createSiteContact,
+  updateContactInfo,
+  deleteSiteContact,
+};