abmp-npm 1.0.0 → 1.0.105

package/.husky/pre-commit

@@ -0,0 +1,22 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+echo "Running ESLint check..."
+npm run lint
+
+if [ $? -ne 0 ]; then
+  echo "❌ ESLint check failed. Please fix the linting errors before committing."
+  exit 1
+fi
+
+echo "Running Prettier check..."
+npm run format:check
+
+if [ $? -ne 0 ]; then
+  echo "❌ Prettier check failed. Please format your code before committing."
+  echo "Run 'npm run format' to automatically format your files."
+  exit 1
+fi
+
+echo "✅ All checks passed!"
+

package/.prettierignore

@@ -0,0 +1,7 @@
+node_modules
+dist
+build
+coverage
+*.min.js
+package-lock.json
+

package/.prettierrc.json

@@ -0,0 +1,16 @@
+{
+  "singleQuote": true,
+  "trailingComma": "es5",
+  "printWidth": 100,
+  "tabWidth": 2,
+  "semi": true,
+  "bracketSpacing": true,
+  "bracketSameLine": false,
+  "arrowParens": "avoid",
+  "endOfLine": "lf",
+  "quoteProps": "as-needed",
+  "jsxSingleQuote": false,
+  "requirePragma": false,
+  "insertPragma": false,
+  "proseWrap": "preserve"
+}

package/README.md

@@ -0,0 +1 @@
+# abmp-npm

package/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/backend/cms-data-methods.js

@@ -0,0 +1,249 @@
+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)
+          ),
+        }));
+        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/backend/consts.js

@@ -0,0 +1,45 @@
+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/';
+
+/**
+ * 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',
+};
+
+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',
+};
+
+module.exports = {
+  CONFIG_KEYS,
+  MAX__MEMBERS_SEARCH_RESULTS,
+  WIX_QUERY_MAX_LIMIT,
+  GEO_HASH_PRECISION,
+  PAC_API_URL,
+  COMPILED_FILTERS_FIELDS,
+  MEMBERSHIPS_TYPES,
+  SSO_TOKEN_AUTH_API_URL,
+  BACKUP_API_URL,
+};

package/backend/contacts-methods.js

@@ -0,0 +1,128 @@
+const { contacts } = require('@wix/crm');
+const { auth } = require('@wix/essentials');
+
+const elevatedGetContact = auth.elevate(contacts.getContact);
+const elevatedUpdateContact = auth.elevate(contacts.updateContact);
+
+/**
+ * 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}`);
+  }
+}
+
+/**
+ * Updates contact email in Wix CRM
+ * @param {string} contactId - The contact ID in Wix CRM
+ * @param {string} newEmail - The new email address
+ */
+async function updateContactEmail(contactId, newEmail) {
+  if (!newEmail) {
+    throw new Error('New email is required');
+  }
+
+  return await updateContactInfo(
+    contactId,
+    currentInfo => ({
+      ...currentInfo,
+      emails: {
+        items: [
+          {
+            email: newEmail,
+            primary: true,
+          },
+        ],
+      },
+    }),
+    'update contact email'
+  );
+}
+
+/**
+ * Updates contact names in Wix CRM
+ * @param {string} contactId - The contact ID in Wix CRM
+ * @param {string} firstName - The new first name
+ * @param {string} lastName - The new last name
+ */
+async function updateContactNames(contactId, firstName, lastName) {
+  if (!firstName && !lastName) {
+    throw new Error('At least one name field is required');
+  }
+
+  return await updateContactInfo(
+    contactId,
+    currentInfo => ({
+      ...currentInfo,
+      name: {
+        first: firstName || currentInfo?.name?.first || '',
+        last: lastName || currentInfo?.name?.last || '',
+      },
+    }),
+    'update contact names'
+  );
+}
+
+/**
+ * Update fields if they have changed
+ * @param {Array} existingValues - Current values for comparison
+ * @param {Array} newValues - New values to compare against
+ * @param {Function} updater - Function to call if values changed
+ * @param {Function} argsBuilder - Function to build arguments for updater
+ */
+const updateIfChanged = (existingValues, newValues, updater, argsBuilder) => {
+  const hasChanged = existingValues.some((val, idx) => val !== newValues[idx]);
+  if (!hasChanged) return null;
+  return updater(...argsBuilder(newValues));
+};
+
+/**
+ * Updates member contact information in CRM if fields have changed
+ * @param {Object} data - New member data
+ * @param {Object} existingMemberData - Existing member data
+ */
+const updateMemberContactInfo = async (data, existingMemberData) => {
+  const { contactId } = existingMemberData;
+
+  const updateConfig = [
+    {
+      fields: ['contactFormEmail'],
+      updater: updateContactEmail,
+      args: ([email]) => [contactId, email],
+    },
+    {
+      fields: ['firstName', 'lastName'],
+      updater: updateContactNames,
+      args: ([firstName, lastName]) => [contactId, firstName, lastName],
+    },
+  ];
+
+  const updatePromises = updateConfig
+    .map(({ fields, updater, args }) => {
+      const existingValues = fields.map(field => existingMemberData[field]);
+      const newValues = fields.map(field => data[field]);
+      return updateIfChanged(existingValues, newValues, updater, args);
+    })
+    .filter(Boolean);
+
+  await Promise.all(updatePromises);
+};
+
+module.exports = {
+  updateMemberContactInfo,
+};

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

@@ -0,0 +1,196 @@
+const { bulkSaveMembers, getMemberBySlug } = require('../members-data-methods');
+
+const { generateUpdatedMemberData } = require('./process-member-methods');
+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
+ * @param {Object} options - The options object
+ * @param {Array} options.memberDataList - Array of member data from API
+ * @param {number} options.currentPageNumber - Current page number being processed
+ * @param {boolean} [options.addInterests=true] - Whether to add interests to the member data
+ * @param {Array} memberDataList - Array of member data from API
+ * @returns {Promise<Object>} - Bulk save operation result with statistics
+ */
+const bulkProcessAndSaveMemberData = async ({
+  memberDataList,
+  currentPageNumber,
+  addInterests = true,
+}) => {
+  if (!Array.isArray(memberDataList) || memberDataList.length === 0) {
+    throw new Error('Invalid member data list provided');
+  }
+
+  const startTime = Date.now();
+
+  try {
+    const processedMemberDataPromises = memberDataList.map(memberData =>
+      generateUpdatedMemberData({
+        inputMemberData: memberData,
+        currentPageNumber,
+        addInterests,
+      })
+    );
+
+    const processedMemberDataList = await Promise.all(processedMemberDataPromises);
+    const validMemberData = processedMemberDataList.filter(
+      data => data !== null && data !== undefined
+    );
+    if (validMemberData.length === 0) {
+      return {
+        totalProcessed: memberDataList.length,
+        totalSaved: 0,
+        totalFailed: memberDataList.length,
+        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 = uniqueUrlsMembersData.map(member => {
+      const { isLoginEmailChanged, isNewToDb: _isNewToDb, ...restMemberData } = member;
+      if (member.contactId && isLoginEmailChanged) {
+        toChangeWixMembersEmails.push(member);
+      }
+      return restMemberData; //we don't want to store the isLoginEmailChanged in the database, it's just a flag to know if we need to change the login email in Members area
+    });
+    const saveResult = await bulkSaveMembers(toSaveMembersData);
+    // Change login emails for users who was dropped but now are back to system as new members and have different loginEmail for users with action DROP
+    if (toChangeWixMembersEmails.length > 0) {
+      await changeWixMembersEmails(toChangeWixMembersEmails);
+    }
+    const totalFailed = memberDataList.length - validMemberData.length;
+    const processingTime = Date.now() - startTime;
+
+    return {
+      ...saveResult,
+      totalProcessed: memberDataList.length,
+      totalSaved: validMemberData.length,
+      totalFailed: totalFailed,
+      processingTime: processingTime,
+    };
+  } catch (error) {
+    throw new Error(`Bulk operation failed: ${error.message}`);
+  }
+};
+
+module.exports = { bulkProcessAndSaveMemberData, ensureUniqueUrlsInBatch };