abmp-npm 2.0.72 → 2.0.74

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

@@ -0,0 +1,54 @@
+const { CONFIG_KEYS } = require('../consts');
+const { prepareMemberForQALogin, getQAUsers } = require('../members-data-methods');
+const { getSecret, getSiteConfigs } = require('../utils');
+
+const { generateMemberSessionToken } = require('./generate-member-session-token');
+
+const validateQAUser = async userEmail => {
+  const qaUsers = await getQAUsers();
+  const matchingUserEmail = qaUsers.find(user => user.email === userEmail)?.email;
+  if (!matchingUserEmail) {
+    return { error: `Invalid user email: ${userEmail}` };
+  }
+  return { valid: true, email: matchingUserEmail };
+};
+
+/**
+ * Login a QA user
+ * @param {Object} params - The parameters for the login
+ * @param {string} params.userEmail - The email of the user to login
+ * @param {string} params.secret - The secret of the user to login
+ * @returns {Promise<Object>} The result of the login
+ */
+const loginQAMember = async ({ userEmail, secret }) => {
+  try {
+    const [qaSecret, allowAnyMember] = await Promise.all([
+      getSecret('ABMP_QA_SECRET'),
+      getSiteConfigs(CONFIG_KEYS.QA_ALLOW_ANY_MEMBER),
+    ]);
+    if (secret !== qaSecret) {
+      return { success: false, error: 'Invalid secret' };
+    }
+    if (!allowAnyMember) {
+      const userValidation = await validateQAUser(userEmail);
+      if (userValidation.error) {
+        return { success: false, error: userValidation.error };
+      }
+    }
+
+    const memberData = await prepareMemberForQALogin(userEmail);
+    const token = await generateMemberSessionToken(memberData.email);
+    return {
+      success: true,
+      token,
+      memberCMSId: memberData._id,
+    };
+  } catch (error) {
+    console.error('QA login error:', error);
+    return { error: 'Failed to generate session token' };
+  }
+};
+
+module.exports = {
+  loginQAMember,
+};

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

@@ -0,0 +1,159 @@
+const { createHmac } = require('crypto');
+
+const axios = require('axios');
+const { decode } = require('jwt-js-decode');
+
+const { CONFIG_KEYS, SSO_TOKEN_AUTH_API_URL } = require('../consts');
+const { MEMBER_ACTIONS } = require('../daily-pull/consts');
+const { getCurrentMember } = require('../members-area-methods');
+const { getCMSMemberByWixMemberId, prepareMemberForSSOLogin } = require('../members-data-methods');
+const {
+  formatDateToMonthYear,
+  getAddressDisplayOptions,
+  isStudent,
+  getSiteConfigs,
+  getSecret,
+} = require('../utils');
+
+const { generateMemberSessionToken } = require('./generate-member-session-token');
+
+/**
+ * Validates member token and retrieves member data
+ * @param {string} memberIdInput - The member ID to validate
+ * @returns {Promise<{memberData: Object|null, isValid: boolean}>} Validation result with member data
+ */
+async function validateMemberToken(memberIdInput) {
+  const invalidTokenResponse = { memberData: null, isValid: false };
+
+  if (!memberIdInput) {
+    return invalidTokenResponse;
+  }
+
+  try {
+    const member = await getCurrentMember();
+    if (!member || !member._id) {
+      console.log(
+        'member not found from members.getCurrentMember() for memberIdInput',
+        memberIdInput
+      );
+      return invalidTokenResponse;
+    }
+
+    const [dbMember, siteConfigs] = await Promise.all([
+      getCMSMemberByWixMemberId(member._id),
+      getSiteConfigs(),
+    ]);
+    const siteAssociation = siteConfigs[CONFIG_KEYS.SITE_ASSOCIATION];
+    const membersExternalPortalUrl = siteConfigs[CONFIG_KEYS.MEMBERS_EXTERNAL_PORTAL_URL];
+    console.log('dbMember by wix member id is:', dbMember);
+    console.log('member._id', member._id);
+
+    if (!dbMember?._id) {
+      const errorMessage = `No record found in DB for logged in Member [Corrupted Data - Duplicate Members? ] - There is no match in DB for currentMember: ${JSON.stringify(
+        { memberIdInput, currentMemberId: member._id }
+      )}`;
+      console.error(errorMessage);
+      throw new Error('CORRUPTED_MEMBER_DATA');
+    }
+
+    console.log(`Id found in DB for memberIdInput :${memberIdInput} is ${dbMember?._id}`);
+
+    const memberData = dbMember;
+
+    // Format membership dates
+    memberData.memberships = memberData.memberships.map(membership => ({
+      ...membership,
+      membersince: formatDateToMonthYear(membership.membersince),
+      isSiteAssociation: membership.association === siteAssociation,
+    }));
+
+    const savedMemberId = memberData?._id;
+    const isValid = savedMemberId === memberIdInput;
+
+    if (!savedMemberId || !isValid) {
+      return invalidTokenResponse;
+    }
+
+    // Check if member is dropped
+    if (memberData.action === MEMBER_ACTIONS.DROP) {
+      return invalidTokenResponse;
+    }
+
+    // Add computed properties
+    memberData.addressDisplayOption = getAddressDisplayOptions(memberData);
+    console.log('memberData', memberData);
+    memberData.isStudent = isStudent(memberData);
+
+    return { memberData, isValid, membersExternalPortalUrl };
+  } catch (error) {
+    console.error('Error in validateMemberToken:', error);
+    throw error;
+  }
+}
+async function checkAndFetchSSO(token) {
+  const SSO_TOKEN_AUTH_API_KEY = await getSecret('SSO_TOKEN_AUTH_API_KEY');
+  const signature = createHmac('sha256', SSO_TOKEN_AUTH_API_KEY).update(token).digest('hex');
+  const professionalassistcorpUrl = `${SSO_TOKEN_AUTH_API_URL}/eweb/SSOToken.ashx?token=${token}&Partner=Wix&Signature=${signature}`;
+  try {
+    const httpResponse = await axios.get(professionalassistcorpUrl, {
+      transformResponse: [d => d],
+      validateStatus: () => true,
+    });
+    console.log('httpResponse status', httpResponse.status);
+    if (httpResponse.status < 200 || httpResponse.status >= 300) {
+      throw new Error('Fetch did not succeed with status: ' + httpResponse.status);
+    }
+    return httpResponse.data;
+  } catch (error) {
+    console.error('Error in checkAndFetchSSO', error);
+    return null;
+  }
+}
+
+/**
+ * Authenticate an SSO token
+ * @param {Object} params - The parameters for the authentication
+ * @param {string} params.token - The token to authenticate
+ * @returns {Promise<Object>} The result of the authentication
+ */
+const authenticateSSOToken = async ({ token }) => {
+  const responseToken = await checkAndFetchSSO(token);
+  const isValidToken = Boolean(
+    responseToken && typeof responseToken === 'string' && responseToken?.trim()
+  );
+  const toLogTokenData = {
+    isValidToken,
+    tokenData: responseToken
+      ? {
+          length: responseToken.length,
+          preview: responseToken.substring(0, 50),
+        }
+      : 'No token',
+  };
+  console.log('checkAndFetchSSO responseToken data', JSON.stringify(toLogTokenData, null, 2));
+  if (isValidToken) {
+    const jwt = decode(responseToken);
+    const payload = jwt.payload;
+    const memberData = await prepareMemberForSSOLogin(payload);
+    console.log('memberDataCollectionId', memberData._id);
+    const sessionToken = await generateMemberSessionToken(memberData.email);
+    const authObj = {
+      type: 'success',
+      memberId: memberData._id,
+      sessionToken,
+    };
+    return authObj;
+  } else {
+    console.log('invalid Token responseToken is: ', responseToken);
+    return {
+      type: 'error',
+      memberId: '',
+      sessionToken: '',
+    };
+  }
+};
+
+module.exports = {
+  validateMemberToken,
+  authenticateSSOToken,
+};

package/.claude/worktrees/fix-save-button-disable/backend/member-contact-orchestration.js

@@ -0,0 +1,111 @@
+/**
+ * Orchestrates syncing between Wix Members and CRM Contacts.
+ * Returns member data to save; caller does a single updateMember to avoid double-write.
+ */
+const { emailsMatch } = require('../public/Utils/sharedUtils');
+
+const { createSiteContact, updateContactInfo, deleteSiteContact } = require('./contacts-methods');
+
+/**
+ * Updates contact email in CRM. Returns member patch { wixContactId } when member record
+ * must change; otherwise null. Caller merges and saves once.
+ */
+async function updateContactEmail(newContactEmail, existingMemberData) {
+  if (!newContactEmail) {
+    throw new Error('New email is required');
+  }
+  if (!existingMemberData || existingMemberData.wixContactId == null) {
+    throw new Error('Existing member data with wixContactId is required');
+  }
+
+  const { wixContactId, wixMemberId, email: loginEmail } = existingMemberData;
+  const isSingleEntity = wixContactId === wixMemberId;
+  // Compare case-insensitively: Wix CRM enforces email uniqueness without regard to case,
+  // so a contact email that equals the login email (e.g. different casing) must collapse to
+  // a single entity rather than attempt a duplicate contact write.
+  const contactEmailDiffersFromLogin = !emailsMatch(loginEmail, newContactEmail);
+
+  if (!contactEmailDiffersFromLogin) {
+    if (isSingleEntity) {
+      return null;
+    }
+    await deleteSiteContact(wixContactId);
+    return { wixContactId: wixMemberId };
+  }
+
+  if (isSingleEntity) {
+    const newWixContactId = await createSiteContact({
+      firstName: existingMemberData.firstName,
+      lastName: existingMemberData.lastName,
+      contactFormEmail: newContactEmail,
+    });
+    return { wixContactId: newWixContactId };
+  }
+
+  await updateContactInfo(
+    wixContactId,
+    currentInfo => ({
+      ...currentInfo,
+      emails: {
+        items: [{ email: newContactEmail, primary: true }],
+      },
+    }),
+    'update contact email'
+  );
+  return null;
+}
+
+async function updateContactNames({ wixContactId, firstName, lastName }) {
+  if (!firstName && !lastName) {
+    throw new Error('First name or last name is required');
+  }
+  const createNameUpdate = currentInfo => ({
+    ...currentInfo,
+    name: {
+      first: firstName || currentInfo?.name?.first || '',
+      last: lastName || currentInfo?.name?.last || '',
+    },
+  });
+  return await updateContactInfo(wixContactId, createNameUpdate, 'update contact names');
+}
+
+/**
+ * Syncs contact with member (email, names). Contact CRUD only; returns member data to save.
+ * Caller must call updateMember once with the result.
+ */
+async function updateMemberContactInfo(data, existingMemberData) {
+  const { wixContactId } = existingMemberData;
+  if (!wixContactId) {
+    throw new Error('Wix Contact ID is required');
+  }
+  const updateConfig = [
+    {
+      fields: ['contactFormEmail'],
+      updater: updateContactEmail,
+      args: ([email]) => [email, existingMemberData],
+      returnsMemberPatch: true,
+    },
+    {
+      fields: ['firstName', 'lastName'],
+      updater: updateContactNames,
+      args: ([firstName, lastName]) => [{ firstName, lastName, wixContactId }],
+      returnsMemberPatch: false,
+    },
+  ];
+
+  const results = await Promise.all(
+    updateConfig.map(async ({ fields, updater, args, returnsMemberPatch }) => {
+      const existingValues = fields.map(field => existingMemberData[field]);
+      const newValues = fields.map(field => data[field]);
+      const hasChanged = existingValues.some((val, idx) => val !== newValues[idx]);
+      if (!hasChanged) return null;
+      const result = await updater(...args(newValues));
+      return returnsMemberPatch ? result : null;
+    })
+  );
+
+  const memberPatch = results.reduce((acc, patch) => (patch ? { ...acc, ...patch } : acc), {});
+  return { ...data, ...memberPatch };
+}
+
+module.exports = { updateMemberContactInfo };

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

@@ -0,0 +1,88 @@
+const { auth } = require('@wix/essentials');
+const { members, authentication } = require('@wix/members');
+
+const { LOGIN_EMAIL_SYNC_STATUS } = require('./consts');
+
+const elevatedCreateMember = auth.elevate(members.createMember);
+const elevatedChangeLoginEmail = auth.elevate(authentication.changeLoginEmail);
+
+const LOG = '[loginEmailSync]';
+
+function prepareMemberData(partner) {
+  const options = {
+    member: {
+      loginEmail: partner.email,
+      contact: {
+        firstName: partner.firstName,
+        lastName: partner.lastName,
+      },
+    },
+  };
+  return options;
+}
+async function createMemberFunction(member) {
+  const newMember = await elevatedCreateMember(member);
+  console.log('[createMemberFunction]newMember', JSON.stringify(newMember, null, 2));
+  return newMember._id;
+}
+const createSiteMember = async memberDetails => {
+  console.log('createSiteMember memberDetails', memberDetails);
+  try {
+    const options = prepareMemberData(memberDetails);
+    return await createMemberFunction(options);
+  } catch (error) {
+    console.error(`Error in createSiteMember ${error.message}`);
+    throw error;
+  }
+};
+
+const getCurrentMember = async () => {
+  const member = await members.getCurrentMember();
+  return member.member;
+};
+
+/**
+ * Attempts to change a Wix member's login email to `member.email` and reports a structured
+ * outcome instead of swallowing failures. Never throws.
+ *
+ * Outcomes:
+ *  - SKIPPED: member has no wixMemberId, nothing to change.
+ *  - UPDATED: Wix login email changed successfully.
+ *  - FAILED:  change failed. The caller keeps the CMS login email unchanged (so it stays
+ *             consistent with Wix) and reports the member in the task result for manual handling.
+ *
+ * @param {Object} member - Member with { memberId, wixMemberId, email }
+ * @returns {Promise<Object>} outcome
+ */
+async function updateWixMemberLoginEmail(member) {
+  const desiredEmail = member.email;
+  const base = { memberId: member.memberId, wixMemberId: member.wixMemberId, desiredEmail };
+
+  if (!member.wixMemberId) {
+    console.log(`${LOG} member ${member.memberId} has no wixMemberId - skipping`);
+    return { ...base, status: LOGIN_EMAIL_SYNC_STATUS.SKIPPED };
+  }
+
+  console.log(
+    `${LOG} attempting login-email change for member ${member.memberId} (wixMemberId: ${member.wixMemberId}) -> ${desiredEmail}`
+  );
+
+  try {
+    const updatedWixMember = await elevatedChangeLoginEmail(member.wixMemberId, desiredEmail);
+    console.log(
+      `${LOG} ✅ updated member ${member.memberId} (wixMemberId: ${member.wixMemberId}) -> ${updatedWixMember.loginEmail}`
+    );
+    return { ...base, status: LOGIN_EMAIL_SYNC_STATUS.UPDATED };
+  } catch (error) {
+    console.error(
+      `${LOG} ❌ login-email change failed for member ${member.memberId} (wixMemberId: ${member.wixMemberId}) -> ${desiredEmail}: ${error.message}`
+    );
+    return { ...base, status: LOGIN_EMAIL_SYNC_STATUS.FAILED, error: error.message };
+  }
+}
+
+module.exports = {
+  createSiteMember,
+  getCurrentMember,
+  updateWixMemberLoginEmail,
+};