abmp-npm 1.8.1 → 1.8.2

package/backend/cms-data-methods.js

@@ -0,0 +1,209 @@
+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 { PRECISION, MAX__MEMBERS_SEARCH_RESULTS, WIX_QUERY_MAX_LIMIT } = 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')
+        .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, 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', '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,
+  };
+}
+
+module.exports = {
+  buildMembersSearchQuery,
+  fetchAllItemsInParallel,
+};

package/backend/consts.js

@@ -8,6 +8,13 @@ const CONFIG_KEYS = {
   SITE_ASSOCIATION: 'SITE_ASSOCIATION',
 };
 
+const PRECISION = 3;
+const MAX__MEMBERS_SEARCH_RESULTS = 120;
+const WIX_QUERY_MAX_LIMIT = 1000;
+
 module.exports = {
   CONFIG_KEYS,
+  PRECISION,
+  MAX__MEMBERS_SEARCH_RESULTS,
+  WIX_QUERY_MAX_LIMIT,
 };

package/backend/forms-methods.js

@@ -1,4 +1,4 @@
-const { COLLECTIONS } = require('../public');
+const { COLLECTIONS } = require('../public/consts');
 
 const { triggerAutomation } = require('./automations-methods');
 const { CONFIG_KEYS } = require('./consts');

package/backend/index.js

@@ -1,3 +1,4 @@
 module.exports = {
   ...require('./forms-methods'),
+  ...require('./search-filters-methods'),
 };

package/backend/members-data-methods.js

@@ -1,4 +1,4 @@
-const { COLLECTIONS } = require('../public');
+const { COLLECTIONS } = require('../public/consts');
 
 const { wixData } = require('./elevated-modules');
 const { createSiteMember } = require('./members-area-methods');

package/backend/search-filters-methods.js

@@ -0,0 +1,121 @@
+const { COLLECTIONS } = require('../public/consts');
+
+const { buildMembersSearchQuery } = require('./cms-data-methods');
+const { wixData } = require('./elevated-modules');
+const { retrieveAllItems } = require('./utils');
+
+const getCompiledFiltersOptions = () =>
+  wixData.get(COLLECTIONS.COMPILED_STATE_CITY_MAP, 'SINGLE_ITEM_ID');
+
+const getNonCompiledFiltersOptions = async () => {
+  const [completeStateList, areasOfPracticesList, stateCityMapList] = await Promise.all([
+    getCompleteStateList(),
+    getAreasOfPracticeList(),
+    getStateCityMap(),
+  ]);
+  return { completeStateList, areasOfPracticesList, stateCityMapList };
+};
+const filterProfiles = async data => {
+  const membersSearchQuery = buildMembersSearchQuery({ ...data, includeStudents: false });
+  const query = await membersSearchQuery.get();
+  return membersSearchQuery.run(query);
+};
+
+async function getAreasOfPracticeList() {
+  const interestsData = await retrieveAllItems(COLLECTIONS.INTERESTS);
+  return interestsData.map(({ title }) => ({ label: title, value: title }));
+}
+
+async function getStateCityMap() {
+  const getAllCitiesMap = async () => {
+    const totalCount = await wixData.query(COLLECTIONS.STATE_CITY_MAP).count();
+    const baseQuery = wixData.query(COLLECTIONS.STATE_CITY_MAP).limit(1000);
+    const batchedQueries = Array.from({ length: Math.ceil(totalCount / 1000) }, (_, i) =>
+      baseQuery.skip(i * 1000)
+    );
+    const allCities = await Promise.all(
+      batchedQueries.map(query => query.find({ omitTotalCount: true }).then(res => res.items))
+    );
+    return allCities.flat();
+  };
+  const allCities = await getAllCitiesMap();
+  const stateCityMap = new Map();
+  allCities.forEach(cityObj => {
+    const state = cityObj.stateText;
+    const city = cityObj.title;
+    const cityArray = stateCityMap.has(state) ? [...stateCityMap.get(state), city] : [city];
+    stateCityMap.set(state, cityArray);
+  });
+  return Object.fromEntries(stateCityMap);
+}
+//Besan comments on moved code: Below code assumes that Velo can cache value, however this isn't valid so it needs adjustment
+// Cache for state list
+let stateListCache = null;
+let lastCacheTime = 0;
+const CACHE_DURATION = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
+
+async function getCompleteStateList() {
+  // Check if we have a valid cache
+  const now = Date.now();
+  if (stateListCache && now - lastCacheTime < CACHE_DURATION) {
+    return stateListCache;
+  }
+
+  // 1. fire both queries at once:
+  const [stateRecords, memberStates] = await Promise.all([
+    retrieveAllItems(COLLECTIONS.STATE),
+    getMembersStateList(), //this method a
+  ]);
+
+  const fullNameByCode = new Map(stateRecords.map(st => [st.title, st.name]));
+
+  const states = memberStates.map(({ value: code }) => ({
+    value: code,
+    label: fullNameByCode.get(code) || code,
+  }));
+
+  // Update cache
+  stateListCache = states;
+  lastCacheTime = now;
+
+  return states;
+}
+//Besan Comments on moved code: THIS WILL IGNORE SOME STATES VALUES while we should return all states AFAIU
+async function getMembersStateList() {
+  try {
+    // Use a more efficient query to get only the addresses field
+    const results = await wixData
+      .query(COLLECTIONS.MEMBERS_DATA)
+      .fields('addresses')
+      .limit(1000)
+      .find();
+
+    // Extract all state codes from addresses
+    const allStates = new Set();
+    results.items.forEach(member => {
+      if (Array.isArray(member.addresses)) {
+        member.addresses.forEach(addr => {
+          if (addr.state) allStates.add(addr.state);
+        });
+      }
+    });
+
+    // Convert to array and sort
+    const uniqueStates = Array.from(allStates).sort();
+
+    // Map to label/value format
+    return uniqueStates.map(stateCode => ({
+      label: stateCode,
+      value: stateCode,
+    }));
+  } catch (error) {
+    console.error('Error in getMembersStateList:', error);
+    return [];
+  }
+}
+
+module.exports = {
+  getCompiledFiltersOptions,
+  getNonCompiledFiltersOptions,
+  filterProfiles,
+};

package/backend/utils.js

@@ -29,6 +29,17 @@ const getSiteConfigs = async configKey => {
   return siteConfigs;
 };
 
+const retrieveAllItems = async collectionName => {
+  let results = await wixData.query(collectionName).limit(1000).find();
+  let allItems = results.items;
+  while (results.hasNext()) {
+    results = await results.next();
+    allItems = allItems.concat(results.items);
+  }
+  return allItems;
+};
+
 module.exports = {
   getSiteConfigs,
+  retrieveAllItems,
 };

package/eslint.config.js

@@ -54,7 +54,13 @@ module.exports = [
           alphabetize: { order: 'asc', caseInsensitive: true },
         },
       ],
-      'import/no-unresolved': 'error',
+      'import/no-unresolved': [
+        'error',
+        {
+          commonjs: true,
+          caseSensitive: true,
+        },
+      ],
       'import/no-duplicates': 'error',
       'import/no-commonjs': 'off',
       'import/no-dynamic-require': 'off',
@@ -88,6 +94,7 @@ module.exports = [
       'import/resolver': {
         node: {
           extensions: ['.js', '.jsx', '.ts', '.tsx'],
+          moduleDirectory: ['node_modules', 'public', 'backend', 'pages'],
         },
       },
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abmp-npm",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -17,6 +17,7 @@
     "@eslint/js": "^9.12.0",
     "eslint": "^9.12.0",
     "eslint-config-prettier": "^9.1.0",
+    "eslint-import-resolver-node": "^0.3.9",
     "eslint-plugin-import": "^2.30.0",
     "eslint-plugin-prettier": "^5.2.1",
     "eslint-plugin-promise": "^7.1.0",
@@ -30,7 +31,10 @@
     "@wix/data": "^1.0.303",
     "@wix/essentials": "^0.1.28",
     "@wix/members": "^1.0.330",
+    "@wix/site-location": "^1.31.0",
     "@wix/site-window": "^1.44.0",
-    "phone": "^3.1.67"
+    "ngeohash": "^0.6.3",
+    "phone": "^3.1.67",
+    "psdev-utils": "1.1.1"
   }
 }