abmp-npm 1.8.31 → 1.8.33

package/backend/cms-data-methods.js

@@ -4,7 +4,11 @@ const { COLLECTIONS, MEMBERS_FIELDS } = require('../public/consts.js');
 const { findMainAddress } = require('../public/Utils/sharedUtils.js');
 const { calculateDistance, shuffleArray } = require('../public/Utils/sharedUtils.js');
 
-const { PRECISION, MAX__MEMBERS_SEARCH_RESULTS, WIX_QUERY_MAX_LIMIT } = require('./consts.js');
+const {
+  GEO_HASH_PRECISION,
+  MAX__MEMBERS_SEARCH_RESULTS,
+  WIX_QUERY_MAX_LIMIT,
+} = require('./consts.js');
 const { wixData } = require('./elevated-modules');
 
 function buildMembersSearchQuery(data) {
@@ -92,7 +96,7 @@ function buildMembersSearchQuery(data) {
         query = applyFilterToQuery(query, config, filter);
       });
       if (isUserLocationEnabled && isSearchingNearby) {
-        const userGeohash = geohash.encode(filter.latitude, filter.longitude, PRECISION);
+        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);
@@ -203,7 +207,33 @@ async function fetchAllItemsInParallel(query) {
   };
 }
 
+/**
+ * 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;
+  }
+}
+
 module.exports = {
   buildMembersSearchQuery,
   fetchAllItemsInParallel,
+  getInterestAll,
 };

package/backend/consts.js

@@ -8,26 +8,21 @@ const CONFIG_KEYS = {
   SITE_ASSOCIATION: 'SITE_ASSOCIATION',
 };
 
-const PRECISION = 3;
 const MAX__MEMBERS_SEARCH_RESULTS = 120;
 const WIX_QUERY_MAX_LIMIT = 1000;
 
-/**
- * Member action types
- * @readonly
- * @enum {string}
- */
-const MEMBER_ACTIONS = {
-  UPDATE: 'update',
-  NEW: 'new',
-  DROP: 'drop',
-  NONE: 'none',
+const TASKS_NAMES = {
+  ScheduleDailyMembersDataSync: 'ScheduleDailyMembersDataSync',
+  ScheduleMembersDataPerAction: 'ScheduleMembersDataPerAction',
+  SyncMembers: 'SyncMembers',
 };
 
+const GEO_HASH_PRECISION = 3;
+
 module.exports = {
   CONFIG_KEYS,
-  PRECISION,
   MAX__MEMBERS_SEARCH_RESULTS,
   WIX_QUERY_MAX_LIMIT,
-  MEMBER_ACTIONS,
+  TASKS_NAMES,
+  GEO_HASH_PRECISION,
 };

package/backend/contacts-methods.js

@@ -0,0 +1,130 @@
+const { contacts } = require('@wix/crm');
+const { auth } = require('@wix/essentials');
+const elevatedGetContact = auth.elevate(contacts.getContact);
+const elevatedUpdateContact = auth.elevate(contacts.updateContact);
+
+const { findMemberByWixDataId } = require('./members-data-methods');
+
+/**
+ * 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, { info: 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 {string} id - Member ID
+ * @param {Object} data - New member data
+ */
+const updateMemberContactInfo = async (id, data) => {
+  const existing = await findMemberByWixDataId(id);
+  const { contactId } = existing;
+
+  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 => existing[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,65 @@
+const { bulkSaveMembers } = require('../members-data-methods');
+
+const { generateUpdatedMemberData } = require('./process-member-methods');
+const { changeWixMembersEmails } = require('./utils');
+
+/**
+ * Processes and saves multiple member records in bulk
+ * @param {Array} memberDataList - Array of member data from API
+ * @param {number} currentPageNumber - Current page number being processed
+ * @returns {Promise<Object>} - Bulk save operation result with statistics
+ */
+const bulkProcessAndSaveMemberData = async (memberDataList, currentPageNumber) => {
+  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(memberData, currentPageNumber)
+    );
+
+    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 toChangeWixMembersEmails = [];
+    const toSaveMembersData = validMemberData.map(member => {
+      const { isLoginEmailChanged, ...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 };

package/backend/daily-pull/consts.js

@@ -0,0 +1,34 @@
+const PAC_API_URL = 'https://members.abmp.com/eweb/api/Wix';
+
+const MEMBER_ACTIONS = {
+  UPDATE: 'update',
+  NEW: 'new',
+  DROP: 'drop',
+  NONE: 'none',
+};
+
+/**
+ * Address visibility configuration options
+ */
+const ADDRESS_VISIBILITY_OPTIONS = {
+  ALL: 'all',
+  NONE: 'none',
+};
+
+/**
+ * Default display settings for member profiles
+ */
+const DEFAULT_MEMBER_DISPLAY_SETTINGS = {
+  showLicenseNo: true,
+  showName: true,
+  showBookingUrl: false,
+  showWebsite: false,
+  showWixUrl: true,
+};
+
+module.exports = {
+  MEMBER_ACTIONS,
+  ADDRESS_VISIBILITY_OPTIONS,
+  DEFAULT_MEMBER_DISPLAY_SETTINGS,
+  PAC_API_URL,
+};

package/backend/daily-pull/index.js

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

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

@@ -0,0 +1,290 @@
+const { ADDRESS_STATUS_TYPES } = require('../../public/consts');
+const { findMemberById, getMemberBySlug } = require('../members-data-methods');
+const { isValidArray, generateGeoHash } = require('../utils');
+
+const {
+  MEMBER_ACTIONS,
+  ADDRESS_VISIBILITY_OPTIONS,
+  DEFAULT_MEMBER_DISPLAY_SETTINGS,
+} = require('./consts');
+const { validateCoreMemberData, containsNonEnglish, createFullName } = require('./utils');
+
+/**
+ * Ensures a URL is unique by appending a counter if necessary
+ * @param {Object} options - The options object
+ * @param {string} options.url - The base URL to make unique
+ * @param {string|number} options.memberId - The member ID requesting this URL
+ * @param {string} options.fullName - The full name of the member
+ * @returns {Promise<string>} - A unique URL
+ */
+const ensureUniqueUrl = async ({ url, memberId, fullName }) => {
+  const baseUrl = url;
+  let uniqueUrl = url;
+  if (!url) {
+    console.log(`member with id ${memberId} has no url, creating one`);
+    const fullNameWithoutSpace = fullName?.replace(/ /g, '');
+    if (!fullNameWithoutSpace || containsNonEnglish(fullNameWithoutSpace)) {
+      console.log(
+        `member with id ${memberId} has non-english full name, will use fallback url: 'firstNameLastName'`
+      );
+      uniqueUrl = 'firstNameLastName';
+    } else {
+      uniqueUrl = fullNameWithoutSpace; //fallback if there is no full name for this user
+    }
+    console.log(
+      `member with id ${memberId} and  no API provided url, will have this initial url ${uniqueUrl}`
+    );
+  }
+  if (!memberId) throw new Error('Member ID is required');
+
+  const existingMember = await getMemberBySlug({
+    slug: uniqueUrl,
+    excludeDropped: true,
+    excludeSearchedMember: true,
+    memberId,
+    queryAllMatches: true,
+  });
+  if (existingMember && existingMember.url) {
+    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}`;
+  }
+  if (uniqueUrl !== baseUrl) {
+    console.log(`URL conflict resolved: ${baseUrl} -> ${uniqueUrl} for member ${memberId}`);
+  }
+  return uniqueUrl;
+};
+
+/**
+ * Generates complete updated member data by combining existing and migration data
+ * @param {Object} inputMemberData - Raw member data from API
+ * @param {number} currentPageNumber - Current page number being processed
+ * @returns {Promise<Object|null>} - Complete updated member data or null if validation fails
+ */
+async function generateUpdatedMemberData(inputMemberData, currentPageNumber) {
+  if (!validateCoreMemberData(inputMemberData)) {
+    throw new Error(
+      'Invalid member data: memberid, email (valid string), and memberships (array) are required'
+    );
+  }
+
+  const existingDbMember = await findMemberById(inputMemberData.memberid);
+
+  const updatedMemberData = await createCoreMemberData(
+    inputMemberData,
+    existingDbMember,
+    currentPageNumber
+  );
+
+  // If createCoreMemberData returns null due to validation failure, return null
+  if (!updatedMemberData) {
+    return null;
+  }
+
+  // Only enrich with migration and address data for new members
+  if (!existingDbMember) {
+    enrichWithMigrationData(updatedMemberData, inputMemberData.migrationData);
+
+    enrichWithAddressData(
+      updatedMemberData,
+      inputMemberData.addresses,
+      inputMemberData.migrationData?.addressinfo
+    );
+  }
+
+  return updatedMemberData;
+}
+
+/**
+ * Processes and adds address data with proper status
+ * @param {Object} memberDataToUpdate - Member data object to enhance
+ * @param {Array} addressesList - Array of address objects
+ * @param {Object} addressDisplayInfo - Address visibility configuration
+ */
+function enrichWithAddressData(memberDataToUpdate, addressesList, addressDisplayInfo) {
+  if (isValidArray(addressesList)) {
+    memberDataToUpdate.addresses = processAddressesWithStatus(addressesList, addressDisplayInfo);
+  }
+}
+
+/**
+ * Processes multiple addresses with their display statuses
+ * @param {Array} addressesList - Array of address objects
+ * @param {Object} displayConfiguration - Address display configuration
+ * @returns {Array} - Processed addresses with status information
+ */
+function processAddressesWithStatus(addressesList, displayConfiguration = {}) {
+  if (!isValidArray(addressesList)) {
+    return [];
+  }
+
+  return addressesList.map(address => {
+    const displayStatus = displayConfiguration[address.key]
+      ? determineAddressDisplayStatus(displayConfiguration[address.key])
+      : ADDRESS_STATUS_TYPES.STATE_CITY_ZIP;
+
+    return {
+      ...address,
+      addressStatus: displayStatus,
+    };
+  });
+}
+
+/**
+ * Determines address display status based on visibility settings
+ * @param {string} visibilityValue - The address visibility value from migration data
+ * @returns {string} - The corresponding address status
+ */
+function determineAddressDisplayStatus(visibilityValue) {
+  if (!visibilityValue) {
+    return ADDRESS_STATUS_TYPES.STATE_CITY_ZIP;
+  }
+
+  const normalizedValue = visibilityValue.trim().toLowerCase();
+
+  switch (normalizedValue) {
+    case ADDRESS_VISIBILITY_OPTIONS.ALL:
+      return ADDRESS_STATUS_TYPES.FULL_ADDRESS;
+    case ADDRESS_VISIBILITY_OPTIONS.NONE:
+      return ADDRESS_STATUS_TYPES.DONT_SHOW;
+    default:
+      return ADDRESS_STATUS_TYPES.STATE_CITY_ZIP;
+  }
+}
+/**
+ * Helper function to get fields that should only be set for new members
+ * @param {Object} inputMemberData - Raw member data from API
+ * @param {Object} existingDbMember - Existing member data from database
+ * @returns {Promise<Object>} - Object with fields that should only be set for new members
+ */
+async function getNewMemberOnlyFields(inputMemberData, existingDbMember) {
+  if (existingDbMember) {
+    return {};
+  }
+
+  // Only set these fields for new members
+  const sanitizedFirstName = inputMemberData.firstname?.trim() || '';
+  const sanitizedLastName = inputMemberData.lastname?.trim() || '';
+  const fullName = createFullName(sanitizedFirstName, sanitizedLastName);
+
+  const uniqueUrl = await ensureUniqueUrl({
+    url: inputMemberData.url,
+    memberId: inputMemberData.memberid,
+    fullName,
+  });
+  return {
+    memberId: inputMemberData.memberid,
+    firstName: sanitizedFirstName,
+    lastName: sanitizedLastName,
+    fullName,
+    phones: inputMemberData.phones || [],
+    toShowPhone: inputMemberData.migrationData?.show_phone || '',
+    optOut: inputMemberData.migrationData?.opted_out || false,
+    url: uniqueUrl,
+    showContactForm: true,
+    bookingUrl: inputMemberData.migrationData?.schedule_code?.startsWith('http')
+      ? inputMemberData.migrationData?.schedule_code
+      : '',
+    APIBookingUrl: inputMemberData.migrationData?.schedule_code,
+    showABMP: inputMemberData.migrationData?.show_member_since || false,
+    locHash: generateGeoHash(inputMemberData.addresses || []),
+    ...DEFAULT_MEMBER_DISPLAY_SETTINGS,
+  };
+}
+/**
+ * Enriches member data with optional migration properties
+ * @param {Object} memberDataToUpdate - Member data object to enhance
+ * @param {Object} migrationData - Migration data containing optional properties
+ */
+function enrichWithMigrationData(memberDataToUpdate, migrationData) {
+  if (!migrationData) return;
+
+  memberDataToUpdate.addressInfo = migrationData.addressinfo;
+
+  if (migrationData.website) {
+    memberDataToUpdate.website = migrationData.website;
+    memberDataToUpdate.showWebsite = true;
+  }
+
+  if (migrationData.interests) {
+    memberDataToUpdate.areasOfPractices = processInterests(migrationData.interests);
+  }
+}
+/**
+ * Processes interests string into clean array
+ * @param {string} interestsString - Comma-separated interests string
+ * @returns {Array} - Array of trimmed, non-empty interests
+ */
+function processInterests(interestsString) {
+  if (!interestsString) return [];
+
+  return interestsString
+    .split(',')
+    .map(interest => interest.trim())
+    .filter(interest => interest.length > 0);
+}
+/**
+ * Creates base member data structure with core properties
+ * @param {Object} inputMemberData - Raw member data from API
+ * @param {Object} existingDbMember - Existing member data from database
+ * @param {number} currentPageNumber - Current page number being processed
+ * @returns {Promise<Object|null>} - Structured base member data or null if required fields are missing
+ */
+async function createCoreMemberData(inputMemberData, existingDbMember, currentPageNumber) {
+  if (!validateCoreMemberData(inputMemberData)) {
+    return null;
+  }
+
+  const getMemberEmails = () => {
+    // Update both loginEmail & contactFormEmail only for new members who don't exist in DB
+    // Note: PAC API member actions are not reliable, so we need to check if the member exists in DB to know if it's a new member or not
+    const newEmail = inputMemberData.email.trim();
+    const isMemberExistInDb = Boolean(existingDbMember?._id);
+    if (!isMemberExistInDb) {
+      return {
+        email: newEmail,
+        contactFormEmail: newEmail,
+      };
+    }
+    //If exists in DB then only update loginEmail for those who came in with action new based on logic below, otherwise we don't update emails
+    const isMemberReinstatedWithNewEmail =
+      inputMemberData.action === MEMBER_ACTIONS.NEW &&
+      newEmail &&
+      existingDbMember.email !== newEmail;
+    if (isMemberReinstatedWithNewEmail) {
+      // If exists in DB, and email was changed means this user was dropped before that's why it exists in DB, then only update loginEmail not contactFormEmail
+      return {
+        email: newEmail,
+        isLoginEmailChanged: true,
+      };
+    }
+    //If exists in DB but not reinstated with new email, then don't update emails
+    return {};
+  };
+
+  const newMemberFields = await getNewMemberOnlyFields(inputMemberData, existingDbMember);
+
+  return {
+    ...existingDbMember,
+
+    // Always update these core fields from API
+    action: inputMemberData.action,
+    licenses: inputMemberData.licenses || [],
+    memberships: inputMemberData.memberships,
+    pageNumber: currentPageNumber,
+    isVisible: inputMemberData.action !== MEMBER_ACTIONS.DROP,
+
+    // Handle Member emails
+    ...getMemberEmails(),
+
+    // Handle fields that should only be set for new members
+    ...newMemberFields,
+  };
+}
+
+module.exports = {
+  generateUpdatedMemberData,
+};