abmp-npm 2.0.72 → 2.0.74

package/.claude/worktrees/fix-save-button-disable/public/Utils/personalDetailsUtils.js

@@ -0,0 +1,25 @@
+// handle custom validation for url inputs
+function handleOnCustomValidation(element) {
+  element.onCustomValidation((value, reject) => {
+    if (isNotValidUrl(value)) {
+      reject('Please enter a valid URL');
+    }
+  });
+}
+
+// check if url is not valid using regex
+function isNotValidUrl(url) {
+  // Empty URLs are considered valid (optional field)
+  if (!url) return false;
+
+  // URL must start with protocol OR www - handles all TLDs including multi-level and query params
+  const urlRegex =
+    /^(https?:\/\/|www\.)([da-z.-]+)\.([a-z.]{2,})([/\w .-]*)*(\?[&\w=.-]*)?(#[&\w=.-]*)?\/?$/;
+
+  return !urlRegex.test(url);
+}
+
+module.exports = {
+  handleOnCustomValidation,
+  isNotValidUrl,
+};

package/.claude/worktrees/fix-save-button-disable/public/Utils/sharedUtils.js

@@ -0,0 +1,235 @@
+const { ADDRESS_STATUS_TYPES, DEBOUNCE_DELAY } = require('../consts.js');
+
+const checkAddressIsVisible = (addresses = []) => {
+  // ensure we always get an array
+  if (!Array.isArray(addresses)) return [];
+
+  return addresses.filter(
+    val => val.addressStatus === undefined || val.addressStatus !== ADDRESS_STATUS_TYPES.DONT_SHOW
+  );
+};
+
+//Formats an array of practice areas, showing as many as fit within 70 characters
+function formatPracticeAreasForDisplay(areaOfPractices = []) {
+  // always return a string
+  if (!Array.isArray(areaOfPractices) || areaOfPractices.length === 0) {
+    return '';
+  }
+
+  // Filter out null/undefined/empty
+  const validAreas = areaOfPractices.filter(
+    area => area !== null && area !== undefined && area !== ''
+  );
+
+  if (validAreas.length === 0) {
+    return '';
+  }
+
+  if (validAreas.length === 1) {
+    return validAreas[0].length > 70 ? validAreas[0].substring(0, 67) + '...' : validAreas[0];
+  }
+
+  // build up to 70-char string
+  let current = '';
+  const visible = [];
+  for (const item of validAreas) {
+    const sep = visible.length ? ', ' : '';
+    const next = current + sep + item;
+    if (next.length > 70) break;
+    visible.push(item);
+    current = next;
+  }
+
+  // if nothing fit, at least show the first (truncated)
+  if (visible.length === 0) {
+    const first = validAreas[0];
+    return first.length > 67 ? first.substring(0, 67) + '...' : first;
+  }
+
+  const remaining = validAreas.length - visible.length;
+  return remaining > 0 ? `${visible.join(', ')}, +${remaining} Techniques` : visible.join(', ');
+}
+
+function debouncedFunction({ func, debounceTimeout, timeoutType, args }) {
+  return new Promise(resolve => {
+    debounceTimeout[timeoutType] = setTimeout(async () => {
+      try {
+        const response = await func(args);
+        resolve({ success: true, response });
+      } catch (error) {
+        console.error('Error updating results:', error);
+        resolve({ success: false, error });
+      }
+    }, DEBOUNCE_DELAY[timeoutType]);
+  });
+}
+
+const isValidLocation = location => location.latitude && location.longitude;
+
+/**
+ * @param {Array} addressDisplayOption
+ * @param {Array} addresses
+ * @param {Object|boolean} [options] - Optional. Pass { requireValidCoordinates: true } for home search/distance; omit or false for profile display.
+ */
+function findMainAddress(addressDisplayOption = [], addresses = [], options = {}) {
+  const requireValidCoordinates =
+    typeof options === 'boolean' ? options : Boolean(options?.requireValidCoordinates);
+  const optionsArr = Array.isArray(addressDisplayOption) ? addressDisplayOption : [];
+  const mainOpt = optionsArr.find(opt => opt.isMain);
+  if (mainOpt) {
+    const mainAddr = addresses.find(
+      addr =>
+        addr.key === mainOpt.key &&
+        addr.addressStatus !== ADDRESS_STATUS_TYPES.DONT_SHOW &&
+        (!requireValidCoordinates || isValidLocation(addr))
+    );
+    if (mainAddr) {
+      return mainAddr;
+    }
+  }
+  const visibleAddresses = addresses.filter(
+    addr =>
+      addr.addressStatus !== ADDRESS_STATUS_TYPES.DONT_SHOW &&
+      (!requireValidCoordinates || isValidLocation(addr))
+  );
+  if (visibleAddresses.length) {
+    return visibleAddresses[0];
+  }
+  return '';
+}
+function formatAddress(item) {
+  if (!item) return '';
+  let addressParts = [];
+  const limitedPostalCode = (item.postalcode && String(item.postalcode).slice(0, 5)) || ''; //show only 5 digits to not show full user address
+  const status = item.addressStatus;
+  switch (status) {
+    case ADDRESS_STATUS_TYPES.FULL_ADDRESS:
+      addressParts = [item.line1, item.line2, item.city, item.state, limitedPostalCode];
+      break;
+    case ADDRESS_STATUS_TYPES.STATE_CITY_ZIP:
+      addressParts = [item.city, item.state, limitedPostalCode];
+      break;
+    default:
+      if (status === ADDRESS_STATUS_TYPES.DONT_SHOW) return '';
+      // Legacy addresses may have no addressStatus; show city/state/zip by default
+      addressParts = [item.city, item.state, limitedPostalCode];
+      break;
+  }
+  return addressParts.filter(Boolean).join(', ');
+}
+
+/**
+ * @param {Array} addressDisplayOption
+ * @param {Array} addresses
+ * @param {Object|boolean} [options] - Optional. Pass { requireValidCoordinates: true } for home search/distance; omit or false for profile display.
+ */
+function getMainAddress(addressDisplayOption = [], addresses = [], options = {}) {
+  const mainAddr = findMainAddress(addressDisplayOption, addresses, options);
+  if (mainAddr) {
+    return formatAddress(mainAddr);
+  }
+  return '';
+}
+function shuffleArray(array) {
+  const shuffled = [...array];
+  for (let i = shuffled.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+  }
+  return shuffled;
+}
+
+function toRadians(degrees) {
+  return degrees * (Math.PI / 180);
+}
+
+function calculateDistance(location1, location2) {
+  if (!isValidLocation(location1) || !isValidLocation(location2)) {
+    return null;
+  }
+
+  // Earth's radius in miles
+  const earthRadius = 3958.8;
+
+  // Convert latitude and longitude from degrees to radians
+  const latRad1 = toRadians(location1.latitude);
+  const lonRad1 = toRadians(location1.longitude);
+  const latRad2 = toRadians(location2.latitude);
+  const lonRad2 = toRadians(location2.longitude);
+
+  // Differences in coordinates
+  const latDiff = latRad2 - latRad1;
+  const lonDiff = lonRad2 - lonRad1;
+
+  // Haversine formula
+  const a =
+    Math.sin(latDiff / 2) * Math.sin(latDiff / 2) +
+    Math.cos(latRad1) * Math.cos(latRad2) * Math.sin(lonDiff / 2) * Math.sin(lonDiff / 2);
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  const distance = earthRadius * c;
+
+  return distance;
+}
+
+/**
+ * Generate a unique ID
+ * @returns {string} Unique identifier
+ */
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+
+function isWixHostedImage(imageUrl) {
+  return (
+    imageUrl?.trim() &&
+    (imageUrl?.startsWith('wix:') || imageUrl?.startsWith('https://static.wixstatic.com'))
+  );
+}
+
+/** Web URLs only: bare hostnames get https:// so they are not treated as site-relative paths. */
+function normalizeExternalUrl(url) {
+  if (!url || typeof url !== 'string') return url;
+  const trimmed = url.trim();
+  if (!trimmed) return trimmed;
+  if (/^https?:\/\//i.test(trimmed)) return trimmed;
+  return `https://${trimmed}`;
+}
+
+/**
+ * Normalizes an email for comparison (lowercased + trimmed).
+ * Wix CRM treats emails as case-insensitive, so comparisons must too.
+ * @param {string} email
+ * @returns {string}
+ */
+function normalizeEmail(email) {
+  return typeof email === 'string' ? email.trim().toLowerCase() : '';
+}
+
+/**
+ * Case-insensitive email equality. Two empty/missing emails are not considered a match.
+ * @param {string} a
+ * @param {string} b
+ * @returns {boolean}
+ */
+function emailsMatch(a, b) {
+  const normalizedA = normalizeEmail(a);
+  const normalizedB = normalizeEmail(b);
+  return Boolean(normalizedA) && normalizedA === normalizedB;
+}
+
+module.exports = {
+  checkAddressIsVisible,
+  formatPracticeAreasForDisplay,
+  debouncedFunction,
+  findMainAddress,
+  getMainAddress,
+  shuffleArray,
+  calculateDistance,
+  toRadians,
+  generateId,
+  formatAddress,
+  isWixHostedImage,
+  normalizeExternalUrl,
+  normalizeEmail,
+  emailsMatch,
+};

package/.claude/worktrees/fix-save-button-disable/public/consts.js

@@ -0,0 +1,113 @@
+const REGEX = {
+  NAME: /^[a-zA-Z\s'-]{2,}$/,
+  MESSAGE: /^[A-Za-z0-9\s.,!?'"-]{2,}$/,
+};
+
+const COLLECTIONS = {
+  MEMBERS_DATA: 'MembersDataLatest',
+  CONTACT_US_SUBMISSIONS: 'contactUsSubmissions',
+  SITE_CONFIGS: 'SiteConfigs',
+  COMPILED_STATE_CITY_MAP: 'CompiledStateCityMap',
+  STATE: 'State',
+  INTERESTS: 'interests',
+  STATE_CITY_MAP: 'City',
+  UPDATED_LOGIN_EMAILS: 'updatedLoginEmails',
+  QA_USERS: 'QA_Users', //Make QA users configurable per site
+  BUTTON_CLICKS: 'ButtonClicks',
+};
+
+/**
+ * Address display status types
+ */
+const ADDRESS_STATUS_TYPES = {
+  FULL_ADDRESS: 'full_address',
+  STATE_CITY_ZIP: 'state_city_zip',
+  DONT_SHOW: 'dont_show',
+};
+
+const DEFAULT_FILTER = {
+  skip: 0,
+  limit: 12,
+  practiceAreas: [],
+  practiceAreasSearch: '',
+  latitude: 0,
+  longitude: 0,
+  postalcode: null,
+  state: [],
+  stateSearch: '',
+  citySearch: '',
+  city: [],
+  searchText: null,
+};
+const DROPDOWN_OPTIONS = {
+  state: {
+    selectedOptions: [],
+    displayText: '',
+  },
+  city: {
+    selectedOptions: [],
+    displayText: '',
+  },
+  practiceAreas: {
+    selectedOptions: [],
+    displayText: '',
+  },
+};
+const DEBOUNCE_DELAY = {
+  searchTimeout: 1000,
+  filterTimeout: 300,
+  zeroTimeout: 0,
+};
+const MEMBERS_FIELDS = {
+  _id: '_id',
+  profileImage: 'profileImage',
+  fullName: 'fullName',
+  addresses: 'addresses',
+  aboutService: 'aboutService',
+  showBookingUrl: 'showBookingUrl',
+  bookingUrl: 'bookingUrl',
+  areasOfPractices: 'areasOfPractices',
+  url: 'url',
+  phones: 'phones',
+  toShowPhone: 'toShowPhone',
+  showContactForm: 'showContactForm',
+  website: 'website',
+  showWixUrl: 'showWixUrl',
+  memberships: 'memberships',
+  showWebsite: 'showWebsite',
+  addressDisplayOption: 'addressDisplayOption',
+};
+
+const LIGHTBOX_NAMES = {
+  SAVE_ALERT: 'Save Alert',
+  LOGIN_ERROR_ALERT: 'loginError',
+  DELETE_CONFIRM: 'deleteConfirm',
+  SELECT_BANNER_IMAGES: 'Select Banner Images',
+  CONTACT_US: 'Contact Us',
+  MAIN_ADDRESS_ERROR: 'mainAddressError',
+};
+
+const FREE_WEBSITE_TEXT_STATES = {
+  ENABLED: 'This is the default and will auto-populate with the information entered on this page.',
+  DISABLED: 'To deactivate, please opt in via Personal Details.',
+};
+
+const DEFAULT_BUSINESS_NAME_TEXT = 'Business name not provided';
+const PAGES_PATHS = {
+  PROFILE: 'profile',
+  MEMBERS_FORM: 'directory-website-update',
+};
+
+module.exports = {
+  REGEX,
+  COLLECTIONS,
+  ADDRESS_STATUS_TYPES,
+  DEFAULT_FILTER,
+  DROPDOWN_OPTIONS,
+  DEBOUNCE_DELAY,
+  MEMBERS_FIELDS,
+  LIGHTBOX_NAMES,
+  FREE_WEBSITE_TEXT_STATES,
+  DEFAULT_BUSINESS_NAME_TEXT,
+  PAGES_PATHS,
+};

package/.claude/worktrees/fix-save-button-disable/public/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+  ...require('./consts'),
+  ...require('./messages'),
+  ...require('./Utils/sharedUtils'),
+};

package/.claude/worktrees/fix-save-button-disable/public/messages.js

@@ -0,0 +1,16 @@
+const VALIDATION_MESSAGES = {
+  CONTACT_US: {
+    FIRST_NAME: 'Please enter a valid first name.',
+    LAST_NAME: 'Please enter a valid last name.',
+    MESSAGE: 'Please enter a valid message.',
+    PHONE: 'Please enter a valid US phone number.',
+    CAPTCHA: 'Please fix the highlighted fields before captcha verification.',
+    INVALID_FIELDS: 'Please fix the highlighted fields before submitting.',
+    SUBMISSION_FAILED: 'An error occurred. Please try again.',
+    SUBMISSION_SUCCESS: 'Contact submitted successfully',
+  },
+};
+
+module.exports = {
+  VALIDATION_MESSAGES,
+};

package/.claude/worktrees/fix-save-button-disable/public/sso-auth-methods.js

@@ -0,0 +1,43 @@
+const { location: wixLocationFrontend } = require('@wix/site-location');
+const { authentication } = require('@wix/site-members');
+const { local } = require('@wix/site-storage');
+
+const { PAGES_PATHS } = require('./consts');
+
+const checkAndLogin = async authenticateSSOToken => {
+  const query = await wixLocationFrontend.query();
+  const token = query['token']?.trim();
+  try {
+    if (token) {
+      const authObj = await authenticateSSOToken({ token });
+      console.log('authObj', authObj);
+      if (authObj.type == 'success') {
+        console.log('success');
+        await Promise.all([
+          authentication.applySessionToken(authObj?.sessionToken),
+          local.setItem('memberId', authObj.memberId),
+        ]);
+        console.log('memberId', authObj.memberId);
+        const queryParams = {
+          ...query,
+          token: authObj?.memberId,
+        };
+        const redirectTo = `${PAGES_PATHS.MEMBERS_FORM}?${new URLSearchParams(queryParams).toString()}`;
+        await wixLocationFrontend.to(`/${redirectTo}`);
+      } else {
+        console.error('Something went wrong while logging in');
+        throw new Error('Authentication failed - invalid response from server');
+      }
+    } else {
+      console.log('checkAndLogin: No token found');
+      throw new Error('No authentication token found in URL');
+    }
+  } catch (error) {
+    console.error('Error in checkAndLogin', error);
+    throw error;
+  }
+};
+
+module.exports = {
+  checkAndLogin,
+};

package/backend/jobs.js

@@ -97,6 +97,24 @@ async function scheduleNormalizeMemberEmailsTask() {
   }
 }
 
+/**
+ * Schedules setting ALL addresses for ALL members that have any address to STATE_CITY_ZIP
+ * (show city/state/zip, hide the street). Manually triggered one-off maintenance task.
+ */
+async function scheduleSetAddressesToCityStateTask() {
+  try {
+    console.log('scheduleSetAddressesToCityState started!');
+    return await taskManager().schedule({
+      name: TASKS_NAMES.scheduleSetAddressesToCityState,
+      data: {},
+      type: 'scheduled',
+    });
+  } catch (error) {
+    console.error(`Failed to scheduleSetAddressesToCityState: ${error.message}`);
+    throw new Error(`Failed to scheduleSetAddressesToCityState: ${error.message}`);
+  }
+}
+
 /**
  * Runs the daily pull execution check (watchdog).
  * @param {Object} [options]
@@ -135,5 +153,6 @@ module.exports = {
   scheduleFixPrimaryAddressForMembersTask,
   scheduleFixUrlsWithSpacesTask,
   scheduleNormalizeMemberEmailsTask,
+  scheduleSetAddressesToCityStateTask,
   runDailyPullExecutionCheck,
 };

package/backend/tasks/address-visibility-methods.js

@@ -0,0 +1,160 @@
+const { taskManager } = require('psdev-task-manager');
+
+const { COLLECTIONS, ADDRESS_STATUS_TYPES } = require('../../public/consts');
+const { wixData } = require('../elevated-modules');
+const { bulkSaveMembers, getMembersByIds } = require('../members-data-methods');
+const { chunkArray, queryAllItems } = require('../utils');
+
+const { TASKS_NAMES } = require('./consts');
+
+const CHUNK_SIZE = 1000;
+
+// Target visibility for every address: show city / state / zip, hide the street address.
+const TARGET_STATUS = ADDRESS_STATUS_TYPES.STATE_CITY_ZIP;
+
+const getMemberAddresses = member => (Array.isArray(member.addresses) ? member.addresses : []);
+
+/**
+ * Whether a member has at least one address not already at the target status.
+ * @param {Object} member
+ * @returns {boolean}
+ */
+const needsCityStateUpdate = member =>
+  getMemberAddresses(member).some(address => address && address.addressStatus !== TARGET_STATUS);
+
+/**
+ * Sets every address on a member to STATE_CITY_ZIP (other address fields are preserved).
+ * @param {Object} member
+ * @returns {Array} the member's addresses with addressStatus set to STATE_CITY_ZIP
+ */
+const setAddressesToCityState = member =>
+  getMemberAddresses(member).map(address => ({
+    ...address,
+    addressStatus: TARGET_STATUS,
+  }));
+
+/**
+ * Schedules tasks to set ALL addresses for ALL members to STATE_CITY_ZIP (show city/state/zip,
+ * hide the street). Manually triggered (not cron-wired).
+ */
+async function scheduleSetAddressesToCityState() {
+  console.log('=== Scheduling Set Addresses To City/State Tasks ===');
+
+  try {
+    const membersQuery = await wixData
+      .query(COLLECTIONS.MEMBERS_DATA)
+      .isNotEmpty('addresses')
+      .limit(1000);
+    const members = await queryAllItems(membersQuery);
+    console.log(`Fetched ${members.length} members with addresses`);
+
+    // Only members that still have an address not at the target status need updating.
+    const memberIds = [
+      ...new Set(
+        members
+          .filter(needsCityStateUpdate)
+          .map(member => Number(member.memberId))
+          .filter(memberId => Number.isFinite(memberId) && memberId > 0)
+      ),
+    ];
+    console.log(`Members needing a city/state update: ${memberIds.length}`);
+
+    if (memberIds.length === 0) {
+      console.log('No members need their addresses set to city/state');
+      return {
+        success: true,
+        message: 'No members need their addresses set to city/state',
+        totalMembers: 0,
+        tasksScheduled: 0,
+      };
+    }
+
+    const chunks = chunkArray(memberIds, CHUNK_SIZE);
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      await taskManager().schedule({
+        name: TASKS_NAMES.setAddressesToCityStateChunk,
+        data: {
+          memberIds: chunk,
+          chunkIndex: i,
+          totalChunks: chunks.length,
+        },
+        type: 'scheduled',
+      });
+      console.log(`Scheduled task ${i + 1}/${chunks.length} (${chunk.length} members)`);
+    }
+
+    const result = {
+      success: true,
+      message: `Scheduled ${chunks.length} tasks for ${memberIds.length} members`,
+      totalMembers: memberIds.length,
+      tasksScheduled: chunks.length,
+    };
+    console.log('=== Scheduling Complete ===');
+    console.log(JSON.stringify(result, null, 2));
+    return result;
+  } catch (error) {
+    console.error('Error scheduling set-addresses-to-city-state:', error);
+    throw error;
+  }
+}
+
+/**
+ * Processes a chunk of members and sets every address to STATE_CITY_ZIP.
+ * @param {Object} data
+ * @param {Array<number|string>} data.memberIds
+ * @param {number} data.chunkIndex
+ * @param {number} data.totalChunks
+ */
+async function setAddressesToCityStateChunk(data) {
+  const { memberIds, chunkIndex, totalChunks } = data;
+  console.log(
+    `Processing set-city-state chunk ${chunkIndex + 1}/${totalChunks} (${memberIds.length} members)`
+  );
+
+  const result = { successful: 0, failed: 0, skipped: 0, errors: [], failedIds: [] };
+
+  try {
+    const members = await getMembersByIds(memberIds);
+    console.log(`Loaded ${members.length} members for this chunk`);
+
+    const membersToUpdate = [];
+    members.forEach(member => {
+      // Skip members that have no address or are already all at the target status.
+      if (!needsCityStateUpdate(member)) {
+        result.skipped++;
+        return;
+      }
+      membersToUpdate.push({
+        ...member,
+        addresses: setAddressesToCityState(member),
+      });
+    });
+
+    if (membersToUpdate.length === 0) {
+      console.log('No members need updating in this batch');
+      return result;
+    }
+
+    try {
+      await bulkSaveMembers(membersToUpdate);
+      result.successful += membersToUpdate.length;
+      console.log(`✅ Set addresses to city/state for ${membersToUpdate.length} members`);
+    } catch (error) {
+      console.error('❌ Error bulk saving members:', error);
+      result.failed += membersToUpdate.length;
+      result.failedIds.push(...membersToUpdate.map(member => member.memberId));
+      result.errors.push({ error: error.message, memberCount: membersToUpdate.length });
+    }
+
+    return result;
+  } catch (error) {
+    console.error(`Error processing set-city-state chunk ${chunkIndex}:`, error);
+    throw error;
+  }
+}
+
+module.exports = {
+  scheduleSetAddressesToCityState,
+  setAddressesToCityStateChunk,
+};

package/backend/tasks/consts.js

@@ -22,6 +22,8 @@ const TASKS_NAMES = {
   fixPrimaryAddressChunk: 'fixPrimaryAddressChunk',
   scheduleFixUrlsWithSpaces: 'scheduleFixUrlsWithSpaces',
   fixUrlsWithSpacesChunk: 'fixUrlsWithSpacesChunk',
+  scheduleSetAddressesToCityState: 'scheduleSetAddressesToCityState',
+  setAddressesToCityStateChunk: 'setAddressesToCityStateChunk',
   scheduleNormalizeMemberEmails: 'scheduleNormalizeMemberEmails',
   normalizeMemberEmailsChunk: 'normalizeMemberEmailsChunk',
   dailyPullExecutionCheck: 'dailyPullExecutionCheck',

package/backend/tasks/tasks-configs.js

@@ -8,6 +8,10 @@ const {
   scheduleFixPrimaryAddressForMembers,
   fixPrimaryAddressChunk,
 } = require('./address-primary-methods');
+const {
+  scheduleSetAddressesToCityState,
+  setAddressesToCityStateChunk,
+} = require('./address-visibility-methods');
 const { TASKS_NAMES } = require('./consts');
 const { dailyPullExecutionCheck } = require('./daily-pull-check-methods');
 const {
@@ -207,6 +211,20 @@ const TASKS = {
     shouldSkipCheck: () => false,
     estimatedDurationSec: 80,
   },
+  [TASKS_NAMES.scheduleSetAddressesToCityState]: {
+    name: TASKS_NAMES.scheduleSetAddressesToCityState,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: scheduleSetAddressesToCityState,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
+  [TASKS_NAMES.setAddressesToCityStateChunk]: {
+    name: TASKS_NAMES.setAddressesToCityStateChunk,
+    getIdentifier: task => task.data,
+    process: setAddressesToCityStateChunk,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 80,
+  },
   [TASKS_NAMES.scheduleNormalizeMemberEmails]: {
     name: TASKS_NAMES.scheduleNormalizeMemberEmails,
     getIdentifier: () => 'SHOULD_NEVER_SKIP',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abmp-npm",
-  "version": "2.0.72",
+  "version": "2.0.74",
   "main": "index.js",
   "scripts": {
     "check-cycles": "madge --circular .",