abmp-npm 1.0.0 → 1.7.2

package/README.md

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

package/backend/consts.js

@@ -0,0 +1,52 @@
+/**
+ * Default display settings for member profiles
+ */
+const DEFAULT_MEMBER_DISPLAY_SETTINGS = {
+    showLicenseNo: true,
+    showName: true,
+    showBookingUrl: false,
+    showWebsite: false,
+    showWixUrl: true,
+  };
+  
+  /**
+   * Address display status types
+   */
+  const ADDRESS_STATUS_TYPES = {
+    FULL_ADDRESS: 'full_address',
+    STATE_CITY_ZIP: 'state_city_zip',
+    DONT_SHOW: 'dont_show',
+  };
+  
+  /**
+   * Address visibility configuration options
+   */
+  const ADDRESS_VISIBILITY_OPTIONS = {
+    ALL: 'all',
+    NONE: 'none',
+  };
+
+  const COLLECTIONS = {
+    MEMBERS_DATA: 'MembersDataLatest',
+  };
+  
+  
+
+   const MEMBER_ACTIONS = {
+    UPDATE: 'update',
+    NEW: 'new',
+    DROP: 'drop',
+    NONE: 'none'
+};
+  
+  const PRECISION = 3;
+  
+  module.exports = {
+    DEFAULT_MEMBER_DISPLAY_SETTINGS,
+    ADDRESS_STATUS_TYPES,
+    ADDRESS_VISIBILITY_OPTIONS,
+    PRECISION,
+    COLLECTIONS,
+    MEMBER_ACTIONS,
+  };
+  

package/backend/index.js

@@ -0,0 +1,6 @@
+module.exports = {
+    ...require('./consts'),
+    ...require('./utils'),
+    ...require('./updateMemberData'),
+  };
+  

package/backend/updateMemberData.js

@@ -0,0 +1,210 @@
+import { generateGeoHash } from './utils.js';
+import {
+  ADDRESS_STATUS_TYPES,
+  DEFAULT_MEMBER_DISPLAY_SETTINGS,
+  MEMBER_ACTIONS,
+} from './consts.js';
+import {
+  determineAddressDisplayStatus,
+  isValidArray,
+  processInterests,
+  createFullName,
+} from './utils.js';
+import { findMemberById } from './utils.js';
+
+/**
+ * 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;
+};
+
+/**
+ * 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 {Object|null} - Structured base member data or null if required fields are missing
+ */
+const createCoreMemberData = (
+  inputMemberData,
+  existingDbMember,
+  currentPageNumber
+) => {
+  // Validate required fields
+  if (!validateCoreMemberData(inputMemberData)) {
+    return null;
+  }
+
+  const sanitizedFirstName = inputMemberData.firstname?.trim() || '';
+  const sanitizedLastName = inputMemberData.lastname?.trim() || '';
+  const bookingUrl = inputMemberData.migrationData?.schedule_code?.startsWith('http') ? inputMemberData.migrationData?.schedule_code : '';
+  return {
+    ...existingDbMember,
+    memberId: inputMemberData.memberid,
+    firstName: sanitizedFirstName,
+    lastName: sanitizedLastName,
+    fullName: createFullName(sanitizedFirstName, sanitizedLastName),
+    email: inputMemberData.email.trim(),
+    phones: inputMemberData.phones || [],
+    toShowPhone: inputMemberData.migrationData?.show_phone || '',
+    action: inputMemberData.action,
+    licenses: inputMemberData.licenses || [],
+    memberships: inputMemberData.memberships,
+    pageNumber: currentPageNumber,
+    optOut: inputMemberData.migrationData?.opted_out || false,
+    showABMP: inputMemberData.migrationData?.show_member_since || false,
+    locHash: generateGeoHash(inputMemberData.addresses || []),
+    ...DEFAULT_MEMBER_DISPLAY_SETTINGS,
+    isVisible: inputMemberData.action !== MEMBER_ACTIONS.DROP,
+    url: inputMemberData.url,
+    bookingUrl,
+    APIBookingUrl: inputMemberData.migrationData?.schedule_code,//keeping it as a ref if in future they want original
+  };
+};
+
+/**
+ * Enriches member data with optional migration properties
+ * @param {Object} memberDataToUpdate - Member data object to enhance
+ * @param {Object} migrationData - Migration data containing optional properties
+ */
+const enrichWithMigrationData = (memberDataToUpdate, migrationData) => {
+  if (!migrationData) return;
+
+  memberDataToUpdate.logoImage = migrationData.logo_url;
+  memberDataToUpdate.aboutYouHtml = migrationData.detailtext;
+  memberDataToUpdate.addressInfo = migrationData.addressinfo;
+  
+
+  if (migrationData.website) {
+    memberDataToUpdate.website = migrationData.website;
+    memberDataToUpdate.showWebsite = true;
+  }
+
+  if (migrationData.interests) {
+    memberDataToUpdate.areasOfPractices = processInterests(
+      migrationData.interests
+    );
+  }
+};
+
+/**
+ * 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
+ */
+const 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,
+    };
+  });
+};
+
+/**
+ * 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
+ */
+const enrichWithAddressData = (
+  memberDataToUpdate,
+  addressesList,
+  addressDisplayInfo
+) => {
+  if (isValidArray(addressesList)) {
+    memberDataToUpdate.addresses = processAddressesWithStatus(
+      addressesList,
+      addressDisplayInfo
+    );
+  }
+};
+
+/**
+ * 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
+ */
+const generateUpdatedMemberData = async (
+  inputMemberData,
+  currentPageNumber,
+  isVelo = false
+) => {
+  if (!validateCoreMemberData(inputMemberData)) {
+    throw new Error('Invalid member data: memberid, email (valid string), and memberships (array) are required');
+  }
+
+  try {
+
+    const existingDbMember = isVelo? await findMemberById(inputMemberData.memberid) : {};
+    const updatedMemberData = createCoreMemberData(
+      inputMemberData,
+      existingDbMember,
+      currentPageNumber
+    );
+
+    // If createCoreMemberData returns null due to validation failure, return null
+    if (!updatedMemberData) {
+      return null;
+    }
+
+    enrichWithMigrationData(updatedMemberData, inputMemberData.migrationData);
+
+    enrichWithAddressData(
+      updatedMemberData,
+      inputMemberData.addresses,
+      inputMemberData.migrationData?.addressinfo
+    );
+
+    return updatedMemberData;
+  } catch (error) {
+    throw error;
+  }
+}
+
+module.exports = {
+  validateCoreMemberData,
+  createCoreMemberData,
+  enrichWithMigrationData,
+  processAddressesWithStatus,
+  enrichWithAddressData,
+  generateUpdatedMemberData,
+};
+
+

package/backend/utils.js

@@ -0,0 +1,134 @@
+const {
+    ADDRESS_STATUS_TYPES,
+    ADDRESS_VISIBILITY_OPTIONS,
+    COLLECTIONS,
+  } = require('./consts.js');
+  
+  /**
+   * Safely adds optional properties from source to target object
+   * @param {Object} targetObject - Object to add properties to
+   * @param {Object} sourceObject - Object to get properties from
+   * @param {string} sourcePropertyKey - Key to get from source
+   * @param {string} targetPropertyKey - Key to set on target (defaults to sourcePropertyKey)
+   */
+  const addOptionalProperty = (
+    targetObject,
+    sourceObject,
+    sourcePropertyKey,
+    targetPropertyKey = sourcePropertyKey
+  ) => {
+    if (sourceObject && sourceObject[sourcePropertyKey]) {
+      targetObject[targetPropertyKey] = sourceObject[sourcePropertyKey];
+    }
+  };
+  
+  /**
+   * Safely trims a string value with fallback
+   * @param {string} value - The string to trim
+   * @param {string} fallback - Fallback value if input is invalid
+   * @returns {string} - The trimmed string or fallback
+   */
+  const safeTrim = (value, fallback = '') => {
+    return value ? value.toString().trim() : fallback;
+  };
+  
+  /**
+   * Determines address display status based on visibility settings
+   * @param {string} visibilityValue - The address visibility value from migration data
+   * @returns {string} - The corresponding address status
+   */
+  const 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;
+    }
+  };
+  
+  /**
+   * Validates if input is a non-empty array
+   * @param {*} input - Input to validate
+   * @returns {boolean} - True if input is a non-empty array
+   */
+  const isValidArray = (input) => {
+    return Array.isArray(input) && input.length > 0;
+  };
+  
+  /**
+   * Processes interests string into clean array
+   * @param {string} interestsString - Comma-separated interests string
+   * @returns {Array} - Array of trimmed, non-empty interests
+   */
+  const processInterests = (interestsString) => {
+    if (!interestsString) return [];
+  
+    return interestsString
+      .split(',')
+      .map((interest) => interest.trim())
+      .filter((interest) => interest.length > 0);
+  };
+  
+  /**
+   * 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();
+  };
+
+  function generateGeoHash(addresses) {
+    const geohash = addresses
+      ?.filter((address) =>
+        isNaN(address?.latitude) && isNaN(address?.longitude) ? false : address
+      )
+      ?.map((address) =>
+        ngeohash.encode(address.latitude, address.longitude, PRECISION)
+      );
+    return geohash && geohash.length > 0 ? geohash : [];
+  }
+
+  /**
+ * 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
+ */
+const findMemberById = async (memberId) => {
+    if (!memberId) {
+        throw new Error('Member ID is required');
+    }
+
+    try {
+        const queryResult = await wixData.query(COLLECTIONS.MEMBERS_DATA)
+            .eq("memberId", memberId)
+            .find({ suppressAuth: true });
+        
+        return queryResult.items.length > 0 ? queryResult.items[0] : null;
+    } catch (error) {
+        throw new Error(`Failed to retrieve member data: ${error.message}`);
+    }
+}
+  
+  module.exports = {
+    addOptionalProperty,
+    safeTrim,
+    determineAddressDisplayStatus,
+    isValidArray,
+    processInterests,
+    createFullName,
+    generateGeoHash,
+    findMemberById,
+  };
+  

package/index.js

@@ -1,5 +1,5 @@
-function helloNpm() {
-    return "hello NPM"
-  }
-  
-  module.exports = helloNpm
+module.exports = {
+  ...require('./public'),
+  ...require('./pages'),
+  ...require('./backend'),
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abmp-npm",
-  "version": "1.0.0",
+  "version": "1.7.2",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"