abmp-npm 1.8.31 → 1.8.33

package/backend/daily-pull/sync-to-cms-methods.js

@@ -0,0 +1,114 @@
+const { taskManager } = require('psdev-task-manager');
+
+const { TASKS_NAMES } = require('../consts');
+const { fetchPACMembers } = require('../pac-api-methods');
+
+const { bulkProcessAndSaveMemberData } = require('./bulk-process-methods');
+const { isUpdatedMember, isABMPMember } = require('./utils');
+
+async function syncMembersDataPerAction(action) {
+  try {
+    const firstPageResponse = await fetchPACMembers(1, action);
+
+    if (
+      !firstPageResponse ||
+      !firstPageResponse.results ||
+      firstPageResponse.results.length === 0
+    ) {
+      return {
+        success: true,
+        totalPagesProcessed: 0,
+        lastPageProcessed: 0,
+        completedAt: new Date().toISOString(),
+        message: 'No data found',
+      };
+    }
+
+    // Calculate total pages from API response
+    const totalResults = firstPageResponse.total_results || 0;
+    const perPage = firstPageResponse.results.length;
+    const totalPages = firstPageResponse.total_pages || 0;
+
+    // Cap at 1000 pages as safety measure
+    const pagesToProcess = Math.min(totalPages, 1000);
+
+    console.log(
+      `Scheduling ${pagesToProcess} pages for processing (${totalResults} total records, ${perPage} per page)`
+    );
+
+    // Schedule tasks for all pages at once
+    const toScheduleTasks = Array.from(
+      { length: pagesToProcess },
+      (_, i) => i + 1 // API expects page number to start from 1
+    ).map(pageNumber => ({
+      name: TASKS_NAMES.SyncMembers,
+      data: {
+        pageNumber,
+        action,
+      },
+      type: 'scheduled',
+    }));
+
+    // Wait for all scheduling to complete
+    await taskManager().scheduleInBulk(toScheduleTasks);
+
+    return {
+      success: true,
+      totalPagesProcessed: pagesToProcess,
+      lastPageProcessed: pagesToProcess,
+      totalRecords: totalResults,
+      recordsPerPage: perPage,
+      completedAt: new Date().toISOString(),
+    };
+  } catch (error) {
+    throw new Error(`Synchronization failed: ${error.message}`);
+  }
+}
+
+/**
+ * Synchronizes a single page of member data
+ * @param {Object} taskObject - Task object containing page data
+ * @returns {Promise<Object>} - Page synchronization result
+ */
+async function synchronizeSinglePage(taskObject) {
+  const { pageNumber, action } = taskObject.data;
+  try {
+    const memberDataResponse = await fetchPACMembers(pageNumber, action);
+
+    if (
+      !memberDataResponse ||
+      !memberDataResponse.results ||
+      memberDataResponse.results.length === 0
+    ) {
+      throw new Error(`No data found for page ${pageNumber}`);
+    }
+    const toSyncMembers = memberDataResponse.results.filter(
+      member => isUpdatedMember(member) && isABMPMember(member)
+    );
+    if (toSyncMembers.length === 0) {
+      return {
+        success: true,
+        pageNumber,
+        totalPageSize: memberDataResponse.results.length,
+        filteredPageSize: toSyncMembers.length,
+        message: 'No to be updated, or ABMP members found',
+      };
+    }
+    const result = await bulkProcessAndSaveMemberData(toSyncMembers, pageNumber);
+
+    return {
+      success: true,
+      pageNumber,
+      totalPageSize: memberDataResponse.results.length,
+      filteredPageSize: toSyncMembers.length,
+      ...result,
+    };
+  } catch (error) {
+    throw new Error(`Page ${pageNumber} synchronization failed: ${error.message}`);
+  }
+}
+
+module.exports = {
+  syncMembersDataPerAction,
+  synchronizeSinglePage,
+};

package/backend/daily-pull/utils.js

@@ -0,0 +1,78 @@
+const { updateWixMemberLoginEmail } = require('../members-area-methods');
+
+const { MEMBER_ACTIONS } = require('./consts');
+
+const isUpdatedMember = member => member.action !== MEMBER_ACTIONS.NONE;
+const isABMPMember = member =>
+  member.memberships.some(membership => membership.association === 'ABMP');
+
+const changeWixMembersEmails = async toChangeWixMembersEmails => {
+  console.log(
+    `Changing login emails for ${toChangeWixMembersEmails.length} members with ids: [${toChangeWixMembersEmails.map(member => member.memberId).join(', ')}]`
+  );
+  return await Promise.all(
+    toChangeWixMembersEmails.map(member => updateWixMemberLoginEmail(member, {}))
+  );
+};
+
+/**
+ * Validates core member data requirements
+ * @param {Object} inputMemberData - Raw member data from API to validate
+ * @returns {boolean} - True if all required fields are valid, false otherwise
+ */
+const validateCoreMemberData = inputMemberData => {
+  // Check memberid
+  if (!inputMemberData?.memberid) {
+    console.warn('validateCoreMemberData: Missing required field - memberid is mandatory');
+    return false;
+  }
+
+  // Check email
+  if (
+    !inputMemberData?.email ||
+    typeof inputMemberData.email !== 'string' ||
+    !inputMemberData.email.trim()
+  ) {
+    console.warn(
+      'validateCoreMemberData: Missing required field - email (valid string) is mandatory'
+    );
+    return false;
+  }
+
+  // Check memberships
+  if (
+    !inputMemberData?.memberships ||
+    !Array.isArray(inputMemberData.memberships) ||
+    inputMemberData.memberships.length === 0
+  ) {
+    console.warn(
+      'validateCoreMemberData: Missing required field - memberships (non-empty array) is mandatory'
+    );
+    return false;
+  }
+
+  return true;
+};
+
+const containsNonEnglish = str => /[^a-zA-Z0-9]/.test(str); // if it contains any non-english characters, test1 is allowed, but any others are not
+
+/**
+ * Creates a full name from first and last name components
+ * @param {string} firstName - First name
+ * @param {string} lastName - Last name
+ * @returns {string} - Combined full name
+ */
+const createFullName = (firstName, lastName) => {
+  const trimmedFirst = firstName?.trim() || '';
+  const trimmedLast = lastName?.trim() || '';
+  return `${trimmedFirst} ${trimmedLast}`.trim();
+};
+
+module.exports = {
+  isUpdatedMember,
+  isABMPMember,
+  changeWixMembersEmails,
+  validateCoreMemberData,
+  containsNonEnglish,
+  createFullName,
+};

package/backend/index.js

@@ -1,6 +1,11 @@
 module.exports = {
   ...require('./forms-methods'),
   ...require('./search-filters-methods'),
-  ...require('./members-data-methods'),
-  ...require('./utils'),
+  ...require('./jobs'),
+  ...require('./utils'), //TODO: remove it once we finish NPM movement
+  ...require('./daily-pull'), //TODO: remove it once we finish NPM movement
+  ...require('./pac-api-methods'), //TODO: remove it once we finish NPM movement
+  ...require('./members-area-methods'), //TODO: remove it once we finish NPM movement
+  ...require('./members-data-methods'), //TODO: remove it once we finish NPM movement
+  ...require('./cms-data-methods'), //TODO: remove it once we finish NPM movement
 };

package/backend/jobs.js

@@ -0,0 +1,30 @@
+const { taskManager } = require('psdev-task-manager');
+
+const { TASKS_NAMES } = require('./consts');
+const { TASKS } = require('./tasks');
+
+async function runScheduledTasks() {
+  try {
+    console.log('runScheduledTasks started');
+    return await taskManager().runScheduledTasks(TASKS);
+  } catch (error) {
+    console.error(`Failed to runScheduledTasks: ${error.message}`);
+    throw new Error(`Failed to runScheduledTasks: ${error.message}`);
+  }
+}
+
+async function scheduleDailyPullTask() {
+  try {
+    console.log('scheduleDailyPullTask started!');
+    return await taskManager().schedule({
+      name: TASKS_NAMES.ScheduleDailyMembersDataSync,
+      data: {},
+      type: 'scheduled',
+    });
+  } catch (error) {
+    console.error(`Failed to scheduleDailyPullTask: ${error.message}`);
+    throw new Error(`Failed to scheduleDailyPullTask: ${error.message}`);
+  }
+}
+
+module.exports = { runScheduledTasks, scheduleDailyPullTask };

package/backend/members-area-methods.js

@@ -1,5 +1,5 @@
 const { auth } = require('@wix/essentials');
-const { members } = require('@wix/members');
+const { members, authentication } = require('@wix/members');
 const elevatedCreateMember = auth.elevate(members.createMember);
 
 function prepareContactData(partner) {
@@ -36,7 +36,54 @@ const getCurrentMember = async () => {
   return member.member;
 };
 
+/**
+ * Updates Wix member login email if the member has a contactId (registered Wix member)
+ * @param {Object} member - Member object with contactId and email
+ * @param {Object} result - Result object to track Wix member updates
+ */
+async function updateWixMemberLoginEmail(member, result = {}) {
+  if (!member.contactId) {
+    console.log(`Member ${member.memberId} has no contactId - skipping Wix login email update`);
+    return;
+  }
+
+  try {
+    console.log(
+      `Updating Wix login email for member ${member.memberId} (contactId: ${member.contactId})`
+    );
+
+    const updatedWixMember = await authentication.changeLoginEmail(member.contactId, member.email);
+
+    console.log(
+      `✅ Successfully updated Wix login email for member ${member.memberId}: ${updatedWixMember.loginEmail}`
+    );
+
+    if (!result.wixMemberUpdates) {
+      result.wixMemberUpdates = { successful: 0, failed: 0 };
+    }
+    result.wixMemberUpdates.successful++;
+  } catch (error) {
+    console.error(`❌ Failed to update Wix login email for member ${member.memberId}:`, error);
+
+    if (!result.wixMemberUpdates) {
+      result.wixMemberUpdates = { successful: 0, failed: 0 };
+    }
+    result.wixMemberUpdates.failed++;
+
+    if (!result.wixMemberErrors) {
+      result.wixMemberErrors = [];
+    }
+    result.wixMemberErrors.push({
+      memberId: member.memberId,
+      contactId: member.contactId,
+      email: member.email,
+      error: error.message,
+    });
+  }
+}
+
 module.exports = {
   createSiteMember,
   getCurrentMember,
+  updateWixMemberLoginEmail,
 };

package/backend/members-data-methods.js

@@ -1,22 +1,19 @@
-const { contacts } = require('@wix/crm');
-const { auth } = require('@wix/essentials');
-
 const { COLLECTIONS } = require('../public/consts');
 
-const { MEMBER_ACTIONS } = require('./consts');
+const { updateMemberContactInfo } = require('./contacts-methods');
+const { MEMBER_ACTIONS } = require('./daily-pull');
 const { wixData } = require('./elevated-modules');
 const { createSiteMember, getCurrentMember } = require('./members-area-methods');
 const {
+  createBatches,
+  normalizeUrlForComparison,
+  queryAllItems,
   formatDateToMonthYear,
   getAddressDisplayOptions,
   isStudent,
   generateGeoHash,
-  urlExists,
 } = require('./utils');
 
-const elevatedGetContact = auth.elevate(contacts.getContact);
-const elevatedUpdateContact = auth.elevate(contacts.updateContact);
-
 /**
  * Retrieves member data by member ID
  * @param {string} memberId - The member ID to search for
@@ -136,145 +133,110 @@ async function validateMemberToken(memberIdInput) {
   }
 }
 
-/**
- * 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
+/** Performs bulk save operation for member data
+ * @param { Array } memberDataList - Array of member data objects to save
+ * @returns { Promise < Object >} - Bulk save operation result
  */
-async function updateContactInfo(contactId, updateInfoCallback, operationName) {
-  if (!contactId) {
-    throw new Error('Contact ID is required');
+async function bulkSaveMembers(memberDataList) {
+  if (!Array.isArray(memberDataList) || memberDataList.length === 0) {
+    throw new Error('Invalid member data list provided for bulk save');
   }
 
   try {
-    const contact = await elevatedGetContact(contactId);
-    const currentInfo = contact.info;
-    const updatedInfo = updateInfoCallback(currentInfo);
-
-    await elevatedUpdateContact(contactId, { info: updatedInfo }, contact.revision);
+    // bulkSave all with batches of 1000 items as this is the Velo limit for bulkSave
+    const batches = createBatches(memberDataList, 1000);
+    return await Promise.all(
+      batches.map(batch => wixData.bulkSave(COLLECTIONS.MEMBERS_DATA, batch))
+    );
   } catch (error) {
-    console.error(`Error in ${operationName}:`, error);
-    throw new Error(`Failed to ${operationName}: ${error.message}`);
+    console.error('Error bulk saving members:', error);
+    throw new Error(`Bulk save failed: ${error.message}`);
   }
 }
 
 /**
- * Updates contact email in Wix CRM
- * @param {string} contactId - The contact ID in Wix CRM
- * @param {string} newEmail - The new email address
+ * Retrieves member data by member ID
+ * @param {string} memberId - The member ID to search for
+ * @returns {Promise<Object|null>} - Member data or null if not found
  */
-async function updateContactEmail(contactId, newEmail) {
-  if (!newEmail) {
-    throw new Error('New email is required');
+async function findMemberById(memberId) {
+  if (!memberId) {
+    throw new Error('Member ID is required');
   }
 
-  return await updateContactInfo(
-    contactId,
-    currentInfo => ({
-      ...currentInfo,
-      emails: {
-        items: [
-          {
-            email: newEmail,
-            primary: true,
-          },
-        ],
-      },
-    }),
-    'update contact email'
-  );
-}
+  try {
+    const queryResult = await wixData
+      .query(COLLECTIONS.MEMBERS_DATA)
+      .eq('memberId', memberId)
+      .find();
 
-/**
- * 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 queryResult.items.length > 0 ? queryResult.items[0] : null;
+  } catch (error) {
+    throw new Error(`Failed to retrieve member data: ${error.message}`);
   }
-
-  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);
-};
-
-/**
- * Checks URL uniqueness for a member
- * @param {string} url - The URL to check
- * @param {string} memberId - The member ID to exclude from the check
- * @returns {Promise<Object>} Result object with isUnique boolean
+ * Method to get member by slug with flexible filtering options
+ * @param {Object} options - Query options
+ * @param {string} options.slug - The slug to search for
+ * @param {boolean} options.excludeDropped - Whether to exclude dropped members (default: true)
+ * @param {boolean} options.excludeSearchedMember - Whether to exclude a specific member (default: false)
+ * @param {string|number} [options.memberId] - Member ID to exclude when excludeSearchedMember is true (optional)
+ * @param {boolean} [options.queryAllMatches=false] - Whether to query all matches or just the first one (default: false)
+ * @returns {Promise<Object|null>} - Member data or null if not found
  */
-async function checkUrlUniqueness(url, memberId) {
-  if (!url || !memberId) {
-    throw new Error('Missing required parameters: url and memberId are required');
-  }
+async function getMemberBySlug({
+  slug,
+  excludeDropped = true,
+  excludeSearchedMember = false,
+  memberId = null,
+  queryAllMatches = false,
+}) {
+  if (!slug) return null;
 
   try {
-    const trimmedUrl = url.trim();
-    const exists = await urlExists(trimmedUrl, memberId);
+    let query = wixData.query(COLLECTIONS.MEMBERS_DATA).contains('url', slug);
 
-    return { isUnique: !exists };
+    if (excludeDropped) {
+      query = query.ne('action', 'drop');
+    }
+
+    if (excludeSearchedMember && memberId) {
+      query = query.ne('memberId', memberId);
+    }
+    let membersList;
+    if (queryAllMatches) {
+      query = query.limit(1000);
+      membersList = await queryAllItems(query);
+    } else {
+      membersList = await query.find().then(res => res.items);
+    }
+    let matchingMembers = membersList.filter(
+      item => item.url && item.url.toLowerCase() === slug.toLowerCase()
+    );
+    if (queryAllMatches) {
+      matchingMembers = membersList
+        .filter(
+          //remove trailing "-1", "-2", etc.
+          item => item.url && normalizeUrlForComparison(item.url) === slug.toLowerCase()
+        )
+        .sort((a, b) => b.url.toLowerCase().localeCompare(a.url.toLowerCase()));
+    }
+    if (matchingMembers.length > 1) {
+      const queryResultMsg = `Multiple members found with same slug ${slug} membersIds are : [${matchingMembers
+        .map(member => member.memberId)
+        .join(', ')}]`;
+      if (!queryAllMatches) {
+        throw new Error(queryResultMsg);
+      } else {
+        console.log(queryResultMsg);
+      }
+    }
+    return matchingMembers[0] || null;
   } catch (error) {
-    console.error('Error checking URL uniqueness:', error);
-    throw new Error(`Failed to check URL uniqueness: ${error.message}`);
+    console.error('Error getting member by slug:', error);
+    throw error;
   }
 }
 
@@ -321,10 +283,45 @@ async function saveRegistrationData(data, id) {
   }
 }
 
+/**
+ * Checks if a URL already exists in the database for a different member (case-insensitive)
+ * @param {string} url - The URL to check
+ * @param {string|number} excludeMemberId - Member ID to exclude from the check
+ * @returns {Promise<boolean>} - True if URL exists for another member
+ */
+async function urlExists(url, excludeMemberId) {
+  if (!url) return false;
+
+  try {
+    let query = wixData
+      .query(COLLECTIONS.MEMBERS_DATA)
+      .contains('url', url)
+      .ne('action', MEMBER_ACTIONS.DROP);
+
+    if (excludeMemberId) {
+      query = query.ne('memberId', excludeMemberId);
+    }
+
+    const { items } = await query.find();
+
+    // Case-insensitive comparison
+    const matchingMembers = items.filter(
+      item => item.url && item.url.toLowerCase() === url.toLowerCase()
+    );
+
+    return matchingMembers.length > 0;
+  } catch (error) {
+    console.error('Error checking URL existence:', error);
+    return false;
+  }
+}
+
 module.exports = {
   findMemberByWixDataId,
   createContactAndMemberIfNew,
   validateMemberToken,
-  checkUrlUniqueness,
   saveRegistrationData,
+  bulkSaveMembers,
+  findMemberById,
+  getMemberBySlug,
 };

package/backend/pac-api-methods.js

@@ -0,0 +1,35 @@
+const { secrets } = require('@wix/secrets');
+
+const { PAC_API_URL } = require('./daily-pull/consts');
+
+const getHeaders = async () => {
+  const AUTH_TOKEN = await secrets.getSecretValue('members-data-api-key');
+  const headers = {
+    Authorization: `Bearer ${AUTH_TOKEN}`,
+  };
+  return headers;
+};
+const fetchPACMembers = async (pageNum, actionFilter) => {
+  const url = `${PAC_API_URL}/Members?page=${pageNum}&actionFilter=${actionFilter}`;
+  const headers = await getHeaders();
+  const fetchOptions = {
+    method: 'get',
+    headers: headers,
+  };
+  const response = await fetch(url, fetchOptions);
+  const responseType = response.headers.get('content-type');
+  if (!responseType.includes('application/json')) {
+    const errorMessage = `[fetchPACMembers] got invalid responseType: ${responseType} for page ${pageNum} and actionFilter ${actionFilter}`;
+    console.error(errorMessage);
+    throw new Error(errorMessage);
+  }
+  if (response.ok) {
+    return response.json();
+  } else {
+    const errorMessage = `[fetchPACMembers] failed with status ${response.status} for page ${pageNum} and actionFilter ${actionFilter}`;
+    console.error(errorMessage);
+    throw new Error(errorMessage);
+  }
+};
+
+module.exports = { fetchPACMembers, getHeaders }; //TODO: remove getHeaders from exported methods once npm movement finishes

package/backend/tasks.js

@@ -0,0 +1,37 @@
+const { TASKS_NAMES } = require('./consts');
+const { MEMBER_ACTIONS, synchronizeSinglePage, syncMembersDataPerAction } = require('./daily-pull');
+
+const getDailyMembersDataSyncChildTasks = () => {
+  // we don't want to sync none action as it means this members data hasn't changed and we don't need to sync it
+  const MEMBER_ACTIONS_EXCEPT_NONE = Object.values(MEMBER_ACTIONS).filter(
+    action => action !== MEMBER_ACTIONS.NONE
+  );
+  return MEMBER_ACTIONS_EXCEPT_NONE.map(action => ({
+    name: TASKS_NAMES.ScheduleMembersDataPerAction,
+    data: { action },
+  }));
+};
+const TASKS = {
+  [TASKS_NAMES.ScheduleDailyMembersDataSync]: {
+    name: TASKS_NAMES.ScheduleDailyMembersDataSync,
+    scheduleChildrenSequentially: false,
+    estimatedDurationSec: 60,
+    childTasks: getDailyMembersDataSyncChildTasks(),
+  },
+  [TASKS_NAMES.ScheduleMembersDataPerAction]: {
+    name: TASKS_NAMES.ScheduleMembersDataPerAction,
+    getIdentifier: task => task.data.action,
+    process: syncMembersDataPerAction,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 6,
+  },
+  [TASKS_NAMES.SyncMembers]: {
+    name: TASKS_NAMES.SyncMembers,
+    getIdentifier: task => task,
+    process: synchronizeSinglePage,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 6,
+  },
+};
+
+module.exports = { TASKS };