Merge branch 'develop' into feat/reporting-events-rollup
This commit is contained in:
Shivam Mishra
@@ -68,6 +68,15 @@
|
||||
- Example: `feat(auth): add user authentication`
|
||||
- Don't reference Claude in commit messages
|
||||
|
||||
## PR Description Format
|
||||
|
||||
- Start with a short, user-facing paragraph describing the product change.
|
||||
- Add a `Closes` section with relevant issue links (GitHub, Linear, etc.).
|
||||
- For feature PRs, add `How to test` from a product/UX standpoint.
|
||||
- For bugfix PRs, use `How to reproduce` when helpful.
|
||||
- Optionally add a `What changed` section for implementation highlights.
|
||||
- Do not add a `How this was tested` section listing specs/commands.
|
||||
|
||||
## Project-Specific
|
||||
|
||||
- **Translations**:
|
||||
|
||||
@@ -2,12 +2,17 @@ class Messages::Messenger::MessageBuilder
|
||||
include ::FileTypeHelper
|
||||
|
||||
def process_attachment(attachment)
|
||||
# This check handles very rare case if there are multiple files to attach with only one usupported file
|
||||
# This check handles very rare case if there are multiple files to attach with only one unsupported file
|
||||
return if unsupported_file_type?(attachment['type'])
|
||||
|
||||
attachment_obj = @message.attachments.new(attachment_params(attachment).except(:remote_file_url))
|
||||
params = attachment_params(attachment)
|
||||
attachment_obj = @message.attachments.new(params.except(:remote_file_url))
|
||||
attachment_obj.save!
|
||||
attach_file(attachment_obj, attachment_params(attachment)[:remote_file_url]) if attachment_params(attachment)[:remote_file_url]
|
||||
if facebook_reel?(attachment)
|
||||
update_facebook_reel_content(attachment)
|
||||
elsif params[:remote_file_url]
|
||||
attach_file(attachment_obj, params[:remote_file_url])
|
||||
end
|
||||
fetch_story_link(attachment_obj) if attachment_obj.file_type == 'story_mention'
|
||||
fetch_ig_story_link(attachment_obj) if attachment_obj.file_type == 'ig_story'
|
||||
fetch_ig_post_link(attachment_obj) if attachment_obj.file_type == 'ig_post'
|
||||
@@ -26,7 +31,7 @@ class Messages::Messenger::MessageBuilder
|
||||
end
|
||||
|
||||
def attachment_params(attachment)
|
||||
file_type = attachment['type'].to_sym
|
||||
file_type = normalize_file_type(attachment['type'])
|
||||
params = { file_type: file_type, account_id: @message.account_id }
|
||||
|
||||
if [:image, :file, :audio, :video, :share, :story_mention, :ig_reel, :ig_post, :ig_story].include? file_type
|
||||
@@ -100,6 +105,28 @@ class Messages::Messenger::MessageBuilder
|
||||
|
||||
private
|
||||
|
||||
# Facebook may send attachment types that don't directly match our file_type enum.
|
||||
# Map known aliases to their canonical enum values.
|
||||
FACEBOOK_FILE_TYPE_MAP = { reel: :ig_reel }.freeze
|
||||
|
||||
def normalize_file_type(type)
|
||||
sym = type.to_sym
|
||||
FACEBOOK_FILE_TYPE_MAP.fetch(sym, sym)
|
||||
end
|
||||
|
||||
# Facebook sends reel URLs as webpage links (facebook.com/reel/...) rather than
|
||||
# direct video URLs. Downloading these yields HTML, not video content.
|
||||
def facebook_reel?(attachment)
|
||||
attachment['type'].to_sym == :reel
|
||||
end
|
||||
|
||||
def update_facebook_reel_content(attachment)
|
||||
url = attachment.dig('payload', 'url')
|
||||
return if url.blank?
|
||||
|
||||
@message.update!(content: url) if @message.content.blank?
|
||||
end
|
||||
|
||||
def unsupported_file_type?(attachment_type)
|
||||
[:template, :unsupported_type, :ephemeral].include? attachment_type.to_sym
|
||||
end
|
||||
|
||||
@@ -107,7 +107,7 @@ class Api::V1::Accounts::ConversationsController < Api::V1::Accounts::BaseContro
|
||||
end
|
||||
|
||||
def toggle_typing_status
|
||||
typing_status_manager = ::Conversations::TypingStatusManager.new(@conversation, current_user, params)
|
||||
typing_status_manager = ::Conversations::TypingStatusManager.new(@conversation, Current.user, params)
|
||||
typing_status_manager.toggle_typing_status
|
||||
head :ok
|
||||
end
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
module AccessTokenAuthHelper
|
||||
BOT_ACCESSIBLE_ENDPOINTS = {
|
||||
'api/v1/accounts/conversations' => %w[toggle_status toggle_priority create update custom_attributes],
|
||||
'api/v1/accounts/conversations' => %w[toggle_status toggle_typing_status toggle_priority create update custom_attributes],
|
||||
'api/v1/accounts/conversations/messages' => ['create'],
|
||||
'api/v1/accounts/conversations/assignments' => ['create']
|
||||
}.freeze
|
||||
@@ -28,7 +28,7 @@ module AccessTokenAuthHelper
|
||||
|
||||
def validate_bot_access_token!
|
||||
return if Current.user.is_a?(User)
|
||||
return if agent_bot_accessible?
|
||||
return if @resource.is_a?(AgentBot) && agent_bot_accessible?
|
||||
|
||||
render_unauthorized('Access to this endpoint is not authorized for bots')
|
||||
end
|
||||
|
||||
+2
@@ -100,6 +100,8 @@ export default {
|
||||
onCmdSnoozeConversation(snoozeType) {
|
||||
if (snoozeType === wootConstants.SNOOZE_OPTIONS.UNTIL_CUSTOM_TIME) {
|
||||
this.showCustomTimeSnoozeModal = true;
|
||||
} else if (typeof snoozeType === 'number') {
|
||||
this.updateConversations('snoozed', snoozeType);
|
||||
} else {
|
||||
this.updateConversations('snoozed', findSnoozeTime(snoozeType) || null);
|
||||
}
|
||||
|
||||
@@ -119,6 +119,10 @@ export const COPILOT_EVENTS = Object.freeze({
|
||||
USE_CAPTAIN_RESPONSE: 'Copilot: Used captain response',
|
||||
});
|
||||
|
||||
export const SNOOZE_EVENTS = Object.freeze({
|
||||
NLP_SNOOZE_APPLIED: 'Applied snooze via text-to-date input',
|
||||
});
|
||||
|
||||
export const GENERAL_EVENTS = Object.freeze({
|
||||
COMMAND_BAR: 'Used commandbar',
|
||||
});
|
||||
|
||||
@@ -0,0 +1,12 @@
|
||||
/**
|
||||
* snoozeDateParser — Natural language date/time parser for snooze.
|
||||
*
|
||||
* Barrel re-export from submodules:
|
||||
* - parser.js: core parsing engine (parseDateFromText)
|
||||
* - localization.js: multilingual suggestion generator (generateDateSuggestions)
|
||||
* - suggestions.js: compositional suggestion engine
|
||||
* - tokenMaps.js: shared token maps and utility functions
|
||||
*/
|
||||
|
||||
export { parseDateFromText } from './parser';
|
||||
export { generateDateSuggestions } from './localization';
|
||||
@@ -0,0 +1,408 @@
|
||||
/**
|
||||
* Handles non-English input and generates the final suggestion list.
|
||||
* Translates localized words to English before parsing, then converts
|
||||
* suggestion labels back to the user's language for display.
|
||||
*/
|
||||
|
||||
import {
|
||||
WEEKDAY_MAP,
|
||||
MONTH_MAP,
|
||||
UNIT_MAP,
|
||||
WORD_NUMBER_MAP,
|
||||
RELATIVE_DAY_MAP,
|
||||
TIME_OF_DAY_MAP,
|
||||
sanitize,
|
||||
stripNoise,
|
||||
normalizeDigits,
|
||||
} from './tokenMaps';
|
||||
|
||||
import { parseDateFromText } from './parser';
|
||||
import { buildSuggestionCandidates, MAX_SUGGESTIONS } from './suggestions';
|
||||
|
||||
// ─── English Reference Data ─────────────────────────────────────────────────
|
||||
|
||||
const EN_WEEKDAYS_LIST = [
|
||||
'monday',
|
||||
'tuesday',
|
||||
'wednesday',
|
||||
'thursday',
|
||||
'friday',
|
||||
'saturday',
|
||||
'sunday',
|
||||
];
|
||||
|
||||
const EN_MONTHS_LIST = [
|
||||
'january',
|
||||
'february',
|
||||
'march',
|
||||
'april',
|
||||
'may',
|
||||
'june',
|
||||
'july',
|
||||
'august',
|
||||
'september',
|
||||
'october',
|
||||
'november',
|
||||
'december',
|
||||
];
|
||||
|
||||
const EN_DEFAULTS = {
|
||||
UNITS: {
|
||||
MINUTE: 'minute',
|
||||
MINUTES: 'minutes',
|
||||
HOUR: 'hour',
|
||||
HOURS: 'hours',
|
||||
DAY: 'day',
|
||||
DAYS: 'days',
|
||||
WEEK: 'week',
|
||||
WEEKS: 'weeks',
|
||||
MONTH: 'month',
|
||||
MONTHS: 'months',
|
||||
YEAR: 'year',
|
||||
YEARS: 'years',
|
||||
},
|
||||
RELATIVE: {
|
||||
TOMORROW: 'tomorrow',
|
||||
DAY_AFTER_TOMORROW: 'day after tomorrow',
|
||||
NEXT_WEEK: 'next week',
|
||||
NEXT_MONTH: 'next month',
|
||||
THIS_WEEKEND: 'this weekend',
|
||||
NEXT_WEEKEND: 'next weekend',
|
||||
},
|
||||
TIME_OF_DAY: {
|
||||
MORNING: 'morning',
|
||||
AFTERNOON: 'afternoon',
|
||||
EVENING: 'evening',
|
||||
NIGHT: 'night',
|
||||
NOON: 'noon',
|
||||
MIDNIGHT: 'midnight',
|
||||
},
|
||||
WORD_NUMBERS: {
|
||||
ONE: 'one',
|
||||
TWO: 'two',
|
||||
THREE: 'three',
|
||||
FOUR: 'four',
|
||||
FIVE: 'five',
|
||||
SIX: 'six',
|
||||
SEVEN: 'seven',
|
||||
EIGHT: 'eight',
|
||||
NINE: 'nine',
|
||||
TEN: 'ten',
|
||||
TWELVE: 'twelve',
|
||||
FIFTEEN: 'fifteen',
|
||||
TWENTY: 'twenty',
|
||||
THIRTY: 'thirty',
|
||||
},
|
||||
ORDINALS: {
|
||||
FIRST: 'first',
|
||||
SECOND: 'second',
|
||||
THIRD: 'third',
|
||||
FOURTH: 'fourth',
|
||||
FIFTH: 'fifth',
|
||||
},
|
||||
MERIDIEM: { AM: 'am', PM: 'pm' },
|
||||
HALF: 'half',
|
||||
NEXT: 'next',
|
||||
THIS: 'this',
|
||||
AT: 'at',
|
||||
IN: 'in',
|
||||
OF: 'of',
|
||||
AFTER: 'after',
|
||||
WEEK: 'week',
|
||||
DAY: 'day',
|
||||
FROM_NOW: 'from now',
|
||||
NEXT_YEAR: 'next year',
|
||||
};
|
||||
|
||||
const STRUCTURAL_WORDS = [
|
||||
'at',
|
||||
'in',
|
||||
'next',
|
||||
'this',
|
||||
'from',
|
||||
'now',
|
||||
'after',
|
||||
'half',
|
||||
'same',
|
||||
'time',
|
||||
'weekend',
|
||||
'end',
|
||||
'of',
|
||||
'the',
|
||||
'eod',
|
||||
'am',
|
||||
'pm',
|
||||
'week',
|
||||
'day',
|
||||
'first',
|
||||
'second',
|
||||
'third',
|
||||
'fourth',
|
||||
'fifth',
|
||||
];
|
||||
|
||||
const ENGLISH_VOCAB = new Set([
|
||||
...Object.keys(WEEKDAY_MAP),
|
||||
...Object.keys(MONTH_MAP),
|
||||
...Object.keys(UNIT_MAP),
|
||||
...Object.keys(WORD_NUMBER_MAP),
|
||||
...Object.keys(RELATIVE_DAY_MAP),
|
||||
...Object.keys(TIME_OF_DAY_MAP),
|
||||
...EN_WEEKDAYS_LIST,
|
||||
...EN_MONTHS_LIST,
|
||||
...STRUCTURAL_WORDS,
|
||||
]);
|
||||
|
||||
// ─── Regex for token replacement ────────────────────────────────────────────
|
||||
|
||||
const MONTH_NAMES = Object.keys(MONTH_MAP).join('|');
|
||||
const MONTH_NAME_RE = new RegExp(`\\b(?:${MONTH_NAMES})\\b`, 'i');
|
||||
const NUM_TOD_RE =
|
||||
/\b(\d{1,2}(?::\d{2})?)\s+(morning|noon|afternoon|evening|night)\b/g;
|
||||
const TOD_TO_MERIDIEM = {
|
||||
morning: 'am',
|
||||
noon: 'pm',
|
||||
afternoon: 'pm',
|
||||
evening: 'pm',
|
||||
night: 'pm',
|
||||
};
|
||||
|
||||
// ─── Translation Cache ──────────────────────────────────────────────────────
|
||||
|
||||
const safeString = v => (v == null ? '' : String(v));
|
||||
const MAX_PAIRS_CACHE = 20;
|
||||
const pairsCache = new Map();
|
||||
const CACHE_SECTIONS = [
|
||||
'UNITS',
|
||||
'RELATIVE',
|
||||
'TIME_OF_DAY',
|
||||
'WORD_NUMBERS',
|
||||
'ORDINALS',
|
||||
'MERIDIEM',
|
||||
];
|
||||
const SINGLE_KEYS = [
|
||||
'HALF',
|
||||
'NEXT',
|
||||
'THIS',
|
||||
'AT',
|
||||
'IN',
|
||||
'OF',
|
||||
'AFTER',
|
||||
'WEEK',
|
||||
'DAY',
|
||||
'FROM_NOW',
|
||||
'NEXT_YEAR',
|
||||
];
|
||||
|
||||
/** Create a string key from translations so we can cache results. */
|
||||
const translationSignature = translations => {
|
||||
if (!translations || typeof translations !== 'object') return 'none';
|
||||
return [
|
||||
...CACHE_SECTIONS.flatMap(section => {
|
||||
const values = translations[section] || {};
|
||||
return Object.keys(values)
|
||||
.sort()
|
||||
.map(k => `${section}.${k}:${safeString(values[k]).toLowerCase()}`);
|
||||
}),
|
||||
...SINGLE_KEYS.map(
|
||||
k => `${k}:${safeString(translations[k]).toLowerCase()}`
|
||||
),
|
||||
].join('|');
|
||||
};
|
||||
|
||||
/** Build a list of [localWord, englishWord] pairs from the translations and browser locale. */
|
||||
const buildReplacementPairsUncached = (translations, locale) => {
|
||||
const pairs = [];
|
||||
const seen = new Set();
|
||||
const t = translations || {};
|
||||
|
||||
const addPair = (local, en) => {
|
||||
const l = sanitize(safeString(local));
|
||||
const e = safeString(en).toLowerCase();
|
||||
const key = `${l}\0${e}`;
|
||||
if (l && e && l !== e && !seen.has(key)) {
|
||||
seen.add(key);
|
||||
pairs.push([l, e]);
|
||||
}
|
||||
};
|
||||
|
||||
CACHE_SECTIONS.forEach(section => {
|
||||
const localSection = t[section] || {};
|
||||
const enSection = EN_DEFAULTS[section] || {};
|
||||
Object.keys(enSection).forEach(key => {
|
||||
addPair(localSection[key], enSection[key]);
|
||||
});
|
||||
});
|
||||
|
||||
SINGLE_KEYS.forEach(key => addPair(t[key], EN_DEFAULTS[key]));
|
||||
|
||||
try {
|
||||
const wdFmt = new Intl.DateTimeFormat(locale, { weekday: 'long' });
|
||||
// Jan 1, 2024 is a Monday — aligns with EN_WEEKDAYS_LIST[0]='monday'
|
||||
EN_WEEKDAYS_LIST.forEach((en, i) => {
|
||||
addPair(wdFmt.format(new Date(2024, 0, i + 1)), en);
|
||||
});
|
||||
} catch {
|
||||
/* locale not supported */
|
||||
}
|
||||
|
||||
try {
|
||||
const moFmt = new Intl.DateTimeFormat(locale, { month: 'long' });
|
||||
EN_MONTHS_LIST.forEach((en, i) => {
|
||||
addPair(moFmt.format(new Date(2024, i, 1)), en);
|
||||
});
|
||||
} catch {
|
||||
/* locale not supported */
|
||||
}
|
||||
|
||||
pairs.sort((a, b) => b[0].length - a[0].length);
|
||||
return pairs;
|
||||
};
|
||||
|
||||
/** Same as above but cached. Keeps up to 20 entries to avoid rebuilding every call. */
|
||||
const buildReplacementPairs = (translations, locale) => {
|
||||
const cacheKey = `${locale || ''}:${translationSignature(translations)}`;
|
||||
if (pairsCache.has(cacheKey)) return pairsCache.get(cacheKey);
|
||||
const pairs = buildReplacementPairsUncached(translations, locale);
|
||||
if (pairsCache.size >= MAX_PAIRS_CACHE)
|
||||
pairsCache.delete(pairsCache.keys().next().value);
|
||||
pairsCache.set(cacheKey, pairs);
|
||||
return pairs;
|
||||
};
|
||||
|
||||
// ─── Token Replacement ──────────────────────────────────────────────────────
|
||||
|
||||
const escapeRegex = s => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
||||
|
||||
/** Swap localized words for their English versions in the text. */
|
||||
const substituteLocalTokens = (text, pairs) => {
|
||||
let r = text;
|
||||
pairs.forEach(([local, en]) => {
|
||||
const re = new RegExp(`(?<=^|\\s)${escapeRegex(local)}(?=\\s|$)`, 'g');
|
||||
r = r.replace(re, en);
|
||||
});
|
||||
return r;
|
||||
};
|
||||
|
||||
/** Drop any words the parser wouldn't understand (keeps English words and numbers). */
|
||||
const filterToEnglishVocab = text =>
|
||||
normalizeDigits(text)
|
||||
.replace(/(\d+)h\b/g, '$1:00')
|
||||
.split(/\s+/)
|
||||
.filter(w => /[\d:]/.test(w) || ENGLISH_VOCAB.has(w.toLowerCase()))
|
||||
.join(' ')
|
||||
.replace(/\s+/g, ' ')
|
||||
.trim();
|
||||
|
||||
/** Move "next year" to the right spot so the parser can read it (after the month, before time). */
|
||||
const repositionNextYear = text => {
|
||||
if (!MONTH_NAME_RE.test(text)) return text;
|
||||
let r = text.replace(/\b(?:next\s+)?year\b/i, m =>
|
||||
/next/i.test(m) ? m : 'next year'
|
||||
);
|
||||
if (!/\bnext\s+year\b/i.test(r)) return r;
|
||||
const withoutNY = r.replace(/\bnext\s+year\b/i, '').trim();
|
||||
const timeRe = /(?:(?:at\s+)?\d{1,2}(?::\d{2})?\s*(?:am|pm)?)\s*$/i;
|
||||
const timePart = withoutNY.match(timeRe);
|
||||
if (timePart) {
|
||||
const beforeTime = withoutNY.slice(0, timePart.index).trim();
|
||||
r = `${beforeTime} next year ${timePart[0].trim()}`;
|
||||
} else {
|
||||
r = `${withoutNY} next year`;
|
||||
}
|
||||
return r;
|
||||
};
|
||||
|
||||
/** Run the full translation pipeline: swap tokens, filter, fix am/pm, reposition "next year". */
|
||||
const replaceTokens = (text, pairs) => {
|
||||
const substituted = substituteLocalTokens(text, pairs);
|
||||
const filtered = filterToEnglishVocab(substituted);
|
||||
const fixed = filtered.replace(
|
||||
NUM_TOD_RE,
|
||||
(_, t, tod) => `${t}${TOD_TO_MERIDIEM[tod]}`
|
||||
);
|
||||
return stripNoise(repositionNextYear(fixed));
|
||||
};
|
||||
|
||||
/** Convert English words back to the user's language for display. */
|
||||
const reverseTokens = (text, pairs) =>
|
||||
pairs.reduce(
|
||||
(r, [local, en]) =>
|
||||
r.replace(
|
||||
new RegExp(`(?<=^|\\s)${escapeRegex(en)}(?=\\s|$)`, 'g'),
|
||||
local
|
||||
),
|
||||
text
|
||||
);
|
||||
|
||||
// ─── Main Suggestion Generator ──────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Generate snooze suggestions from what the user has typed so far.
|
||||
* Works with any language if translations are provided. Returns up to 5
|
||||
* unique results, each with a label, date, and unix timestamp.
|
||||
*
|
||||
* @param {string} text - what the user typed
|
||||
* @param {Date} [referenceDate] - treat as "now" (defaults to current time)
|
||||
* @param {{ translations?: object, locale?: string }} [options] - i18n config
|
||||
* @returns {Array<{ label: string, date: Date, unix: number }>}
|
||||
*/
|
||||
export const generateDateSuggestions = (
|
||||
text,
|
||||
referenceDate = new Date(),
|
||||
{ translations, locale } = {}
|
||||
) => {
|
||||
if (!text || typeof text !== 'string') return [];
|
||||
const normalized = sanitize(text);
|
||||
if (!normalized) return [];
|
||||
|
||||
const stripped = stripNoise(normalized);
|
||||
const pairs =
|
||||
locale && locale !== 'en'
|
||||
? buildReplacementPairs(translations, locale)
|
||||
: [];
|
||||
|
||||
// Try English parse first, then translated parse if we have locale pairs.
|
||||
// This avoids the problem where a single overlapping word (e.g. "in" in German)
|
||||
// would skip token translation entirely.
|
||||
const directParse = parseDateFromText(stripped, referenceDate);
|
||||
|
||||
const translated = pairs.length ? replaceTokens(normalized, pairs) : null;
|
||||
const translatedParse =
|
||||
translated && translated !== stripped
|
||||
? parseDateFromText(translated, referenceDate)
|
||||
: null;
|
||||
|
||||
// Prefer direct English parse; fall back to translated parse
|
||||
const useTranslated = !directParse && !!translatedParse;
|
||||
const englishInput = useTranslated ? translated : stripped;
|
||||
|
||||
const seen = new Set();
|
||||
const results = [];
|
||||
|
||||
const exact = directParse || translatedParse;
|
||||
if (exact) {
|
||||
seen.add(exact.unix);
|
||||
const exactLabel =
|
||||
useTranslated && pairs.length
|
||||
? reverseTokens(englishInput, pairs)
|
||||
: englishInput;
|
||||
results.push({ label: exactLabel, query: englishInput, ...exact });
|
||||
}
|
||||
|
||||
buildSuggestionCandidates(englishInput).some(candidate => {
|
||||
if (results.length >= MAX_SUGGESTIONS) return true;
|
||||
const result = parseDateFromText(candidate, referenceDate);
|
||||
if (result && !seen.has(result.unix)) {
|
||||
seen.add(result.unix);
|
||||
const label =
|
||||
useTranslated && pairs.length
|
||||
? reverseTokens(candidate, pairs)
|
||||
: candidate;
|
||||
results.push({ label, query: candidate, ...result });
|
||||
}
|
||||
return false;
|
||||
});
|
||||
|
||||
return results;
|
||||
};
|
||||
@@ -0,0 +1,806 @@
|
||||
/**
|
||||
* Parses natural language text into a future date.
|
||||
*
|
||||
* Flow: clean the input → try each matcher in order → return the first future date.
|
||||
* The MATCHERS order matters — see the comment above the array.
|
||||
*/
|
||||
|
||||
import {
|
||||
add,
|
||||
startOfDay,
|
||||
getDay,
|
||||
isSaturday,
|
||||
isSunday,
|
||||
nextFriday,
|
||||
nextSaturday,
|
||||
getUnixTime,
|
||||
isValid,
|
||||
startOfWeek,
|
||||
addWeeks,
|
||||
isAfter,
|
||||
isBefore,
|
||||
endOfMonth,
|
||||
} from 'date-fns';
|
||||
|
||||
import {
|
||||
WEEKDAY_MAP,
|
||||
MONTH_MAP,
|
||||
RELATIVE_DAY_MAP,
|
||||
UNIT_MAP,
|
||||
WORD_NUMBER_MAP,
|
||||
NEXT_WEEKDAY_FN,
|
||||
TIME_OF_DAY_MAP,
|
||||
TOD_HOUR_RANGE,
|
||||
HALF_UNIT_DURATIONS,
|
||||
sanitize,
|
||||
stripNoise,
|
||||
parseNumber,
|
||||
parseTimeString,
|
||||
applyTimeToDate,
|
||||
applyTimeOrDefault,
|
||||
strictDate,
|
||||
futureOrNextYear,
|
||||
ensureFutureOrNextDay,
|
||||
inferHoursFromTOD,
|
||||
addFractionalSafe,
|
||||
} from './tokenMaps';
|
||||
|
||||
// ─── Regex Fragments (derived from maps) ────────────────────────────────────
|
||||
|
||||
const WEEKDAY_NAMES = Object.keys(WEEKDAY_MAP).join('|');
|
||||
const MONTH_NAMES = Object.keys(MONTH_MAP).join('|');
|
||||
const UNIT_NAMES = Object.keys(UNIT_MAP).join('|');
|
||||
const WORD_NUMBERS = Object.keys(WORD_NUMBER_MAP).join('|');
|
||||
const RELATIVE_DAYS = Object.keys(RELATIVE_DAY_MAP).join('|');
|
||||
const TIME_OF_DAY_NAMES = 'morning|afternoon|evening|night|noon|midnight';
|
||||
|
||||
const NUM_RE = `(\\d+(?:\\.5)?|${WORD_NUMBERS})`;
|
||||
const UNIT_RE = `(${UNIT_NAMES})`;
|
||||
const TIME_SUFFIX_RE =
|
||||
'(?:\\s+(?:at\\s+)?(\\d{1,2}(?::\\d{2})?\\s*(?:am|pm|a\\.m\\.?|p\\.m\\.?)?|\\d{1,2}:\\d{2}))?';
|
||||
|
||||
const ORDINAL_MAP = {
|
||||
first: 1,
|
||||
second: 2,
|
||||
third: 3,
|
||||
fourth: 4,
|
||||
fifth: 5,
|
||||
sixth: 6,
|
||||
seventh: 7,
|
||||
eighth: 8,
|
||||
ninth: 9,
|
||||
tenth: 10,
|
||||
};
|
||||
const parseOrdinal = str => {
|
||||
if (ORDINAL_MAP[str]) return ORDINAL_MAP[str];
|
||||
return parseInt(str.replace(/(?:st|nd|rd|th)$/, ''), 10) || null;
|
||||
};
|
||||
const ORDINAL_WORDS = Object.keys(ORDINAL_MAP).join('|');
|
||||
const ORDINAL_RE = `(\\d{1,2}(?:st|nd|rd|th)?|${ORDINAL_WORDS})`;
|
||||
|
||||
// ─── Pre-compiled Regexes ───────────────────────────────────────────────────
|
||||
|
||||
const HALF_UNIT_RE = /^(?:in\s+)?half\s+(?:an?\s+)?(hour|day|week|month|year)$/;
|
||||
const RELATIVE_DURATION_RE = new RegExp(`^(?:in\\s+)?${NUM_RE}\\s+${UNIT_RE}$`);
|
||||
const DURATION_FROM_NOW_RE = new RegExp(
|
||||
`^${NUM_RE}\\s+${UNIT_RE}\\s+from\\s+now$`
|
||||
);
|
||||
const RELATIVE_DAY_ONLY_RE = new RegExp(`^(${RELATIVE_DAYS})$`);
|
||||
const RELATIVE_DAY_TOD_RE = new RegExp(
|
||||
`^(${RELATIVE_DAYS})\\s+(?:at\\s+)?(${TIME_OF_DAY_NAMES})$`
|
||||
);
|
||||
const RELATIVE_DAY_TOD_TIME_RE = new RegExp(
|
||||
`^(${RELATIVE_DAYS})\\s+(?:at\\s+)?(${TIME_OF_DAY_NAMES})\\s+(\\d{1,2}(?::\\d{2})?)$`
|
||||
);
|
||||
const RELATIVE_DAY_AT_TIME_RE = new RegExp(
|
||||
`^(${RELATIVE_DAYS})\\s+(?:at\\s+)?` +
|
||||
'(\\d{1,2}(?::\\d{2})?\\s*' +
|
||||
'(?:am|pm|a\\.m\\.?|p\\.m\\.?)?|\\d{1,2}:\\d{2})$'
|
||||
);
|
||||
const RELATIVE_DAY_SAME_TIME_RE = new RegExp(
|
||||
`^(?:(${RELATIVE_DAYS})\\s+(?:same\\s+time|this\\s+time)|(?:same\\s+time|this\\s+time)\\s+(${RELATIVE_DAYS}))$`
|
||||
);
|
||||
const NEXT_UNIT_RE = new RegExp(
|
||||
`^next\\s+(hour|minute|week|month|year)${TIME_SUFFIX_RE}$`
|
||||
);
|
||||
const NEXT_MONTH_RE = new RegExp(`^next\\s+(${MONTH_NAMES})${TIME_SUFFIX_RE}$`);
|
||||
const NEXT_WEEKDAY_TOD_RE = new RegExp(
|
||||
`^next\\s+(${WEEKDAY_NAMES})\\s+(${TIME_OF_DAY_NAMES})$`
|
||||
);
|
||||
const NEXT_WEEKDAY_RE = new RegExp(
|
||||
`^(?:(${WEEKDAY_NAMES})\\s+(?:of\\s+)?next\\s+week` +
|
||||
`|next\\s+week\\s+(${WEEKDAY_NAMES})` +
|
||||
`|next\\s+(${WEEKDAY_NAMES}))${TIME_SUFFIX_RE}$`
|
||||
);
|
||||
const SAME_TIME_WEEKDAY_RE = new RegExp(
|
||||
`^(?:same\\s+time|this\\s+time)\\s+(${WEEKDAY_NAMES})$`
|
||||
);
|
||||
const WEEKDAY_TOD_RE = new RegExp(
|
||||
`^(?:(?:this|upcoming|coming)\\s+)?` +
|
||||
`(${WEEKDAY_NAMES})\\s+(${TIME_OF_DAY_NAMES})$`
|
||||
);
|
||||
const WEEKDAY_TOD_TIME_RE = new RegExp(
|
||||
`^(?:(?:this|upcoming|coming)\\s+)?` +
|
||||
`(${WEEKDAY_NAMES})\\s+(${TIME_OF_DAY_NAMES})\\s+(\\d{1,2}(?::\\d{2})?)$`
|
||||
);
|
||||
const WEEKDAY_TIME_RE = new RegExp(
|
||||
`^(?:(?:this|upcoming|coming)\\s+)?(${WEEKDAY_NAMES})${TIME_SUFFIX_RE}$`
|
||||
);
|
||||
const TIME_ONLY_MERIDIEM_RE =
|
||||
/^(?:at\s+)?(\d{1,2}(?::\d{2})?\s*(?:am|pm|a\.m\.?|p\.m\.?))$/;
|
||||
const TIME_ONLY_24H_RE = /^(?:at\s+)?(\d{1,2}:\d{2})$/;
|
||||
const TOD_WITH_TIME_RE = new RegExp(
|
||||
`^(?:(?:this|the)\\s+)?(${TIME_OF_DAY_NAMES})\\s+` +
|
||||
'(?:at\\s+)?(\\d{1,2}(?::\\d{2})?\\s*' +
|
||||
'(?:am|pm|a\\.m\\.?|p\\.m\\.?)?)$'
|
||||
);
|
||||
const TOD_PLAIN_RE = new RegExp(
|
||||
'(?:(?:later|in)\\s+)?(?:(?:this|the)\\s+)?' +
|
||||
`(?:${TIME_OF_DAY_NAMES}|eod|end of day|end of the day)$`
|
||||
);
|
||||
const ABSOLUTE_DATE_RE = new RegExp(
|
||||
`^(${MONTH_NAMES})\\s+(\\d{1,2})(?:st|nd|rd|th)?` +
|
||||
`(?:[,\\s]+(\\d{4}|next\\s+year))?${TIME_SUFFIX_RE}$`
|
||||
);
|
||||
const ABSOLUTE_DATE_REVERSED_RE = new RegExp(
|
||||
`^(\\d{1,2})(?:st|nd|rd|th)?\\s+(${MONTH_NAMES})` +
|
||||
`(?:[,\\s]+(\\d{4}|next\\s+year))?${TIME_SUFFIX_RE}$`
|
||||
);
|
||||
const MONTH_YEAR_RE = new RegExp(`^(${MONTH_NAMES})\\s+(\\d{4})$`);
|
||||
// "april first week", "first week of april", "march 2nd day", "5th day of jan"
|
||||
const MONTH_ORDINAL_RE = new RegExp(
|
||||
`^(?:(${MONTH_NAMES})\\s+${ORDINAL_RE}\\s+(week|day)|${ORDINAL_RE}\\s+(week|day)\\s+of\\s+(${MONTH_NAMES}))${TIME_SUFFIX_RE}$`
|
||||
);
|
||||
const DAY_AFTER_TOMORROW_RE = new RegExp(
|
||||
`^day\\s+after\\s+tomorrow${TIME_SUFFIX_RE}$`
|
||||
);
|
||||
|
||||
const COMPOUND_DURATION_RE = new RegExp(
|
||||
`^(?:in\\s+)?${NUM_RE}\\s+${UNIT_RE}\\s+(?:and\\s+)?${NUM_RE}\\s+${UNIT_RE}$`
|
||||
);
|
||||
const DURATION_AT_TIME_RE = new RegExp(
|
||||
`^(?:in\\s+)?${NUM_RE}\\s+${UNIT_RE}\\s+at\\s+` +
|
||||
'(\\d{1,2}(?::\\d{2})?\\s*(?:am|pm|a\\.m\\.?|p\\.m\\.?)?)$'
|
||||
);
|
||||
const END_OF_RE = /^end\s+of\s+(?:the\s+)?(week|month|day)$/;
|
||||
const END_OF_NEXT_RE = /^end\s+of\s+(?:the\s+)?next\s+(week|month)$/;
|
||||
const START_OF_NEXT_RE =
|
||||
/^(?:beginning|start)\s+of\s+(?:the\s+)?next\s+(week|month)$/;
|
||||
const LATER_TODAY_RE = /^later\s+(?:today|this\s+(?:afternoon|evening))$/;
|
||||
const EARLY_LATE_TOD_RE = new RegExp(
|
||||
`^(early|late)\\s+(${TIME_OF_DAY_NAMES})$`
|
||||
);
|
||||
const ONE_AND_HALF_RE = new RegExp(
|
||||
`^(?:in\\s+)?(?:one\\s+and\\s+(?:a\\s+)?half|an?\\s+hour\\s+and\\s+(?:a\\s+)?half)(?:\\s+${UNIT_RE})?$`
|
||||
);
|
||||
const NEXT_BUSINESS_DAY_RE = /^next\s+(?:business|working)\s+day$/;
|
||||
|
||||
const TIME_SUFFIX_COMPILED = new RegExp(`${TIME_SUFFIX_RE}$`);
|
||||
const ISO_DATE_RE = new RegExp(
|
||||
`^(\\d{4})-(\\d{1,2})-(\\d{1,2})${TIME_SUFFIX_COMPILED.source}`
|
||||
);
|
||||
const SLASH_DATE_RE = new RegExp(
|
||||
`^(\\d{1,2})/(\\d{1,2})/(\\d{4})${TIME_SUFFIX_COMPILED.source}`
|
||||
);
|
||||
const DASH_DATE_RE = new RegExp(
|
||||
`^(\\d{1,2})-(\\d{1,2})-(\\d{4})${TIME_SUFFIX_COMPILED.source}`
|
||||
);
|
||||
const DOT_DATE_RE = new RegExp(
|
||||
`^(\\d{1,2})\\.(\\d{1,2})\\.(\\d{4})${TIME_SUFFIX_COMPILED.source}`
|
||||
);
|
||||
|
||||
// ─── Pattern Matchers ───────────────────────────────────────────────────────
|
||||
|
||||
/** Read amount and unit from a regex match, then add to now. */
|
||||
const parseDuration = (match, now) => {
|
||||
if (!match) return null;
|
||||
const amount = parseNumber(match[1]);
|
||||
const unit = UNIT_MAP[match[2]];
|
||||
if (amount == null || !unit) return null;
|
||||
return addFractionalSafe(now, unit, amount);
|
||||
};
|
||||
|
||||
/** Handle "in 2 hours", "half day", "3h30m", "5 min from now". */
|
||||
const matchDuration = (text, now) => {
|
||||
const half = text.match(HALF_UNIT_RE);
|
||||
if (half) {
|
||||
return HALF_UNIT_DURATIONS[half[1]]
|
||||
? add(now, HALF_UNIT_DURATIONS[half[1]])
|
||||
: null;
|
||||
}
|
||||
|
||||
// "one and a half hours", "an hour and a half"
|
||||
const oneHalf = text.match(ONE_AND_HALF_RE);
|
||||
if (oneHalf) {
|
||||
const unit = UNIT_MAP[oneHalf[1]] || 'hours';
|
||||
return addFractionalSafe(now, unit, 1.5);
|
||||
}
|
||||
|
||||
const compound = text.match(COMPOUND_DURATION_RE);
|
||||
if (compound) {
|
||||
const a1 = parseNumber(compound[1]);
|
||||
const u1 = UNIT_MAP[compound[2]];
|
||||
const a2 = parseNumber(compound[3]);
|
||||
const u2 = UNIT_MAP[compound[4]];
|
||||
if (a1 == null || !u1 || a2 == null || !u2) {
|
||||
return null;
|
||||
}
|
||||
return add(add(now, { [u1]: a1 }), { [u2]: a2 });
|
||||
}
|
||||
|
||||
const atTime = text.match(DURATION_AT_TIME_RE);
|
||||
if (atTime) {
|
||||
const amount = parseNumber(atTime[1]);
|
||||
const unit = UNIT_MAP[atTime[2]];
|
||||
const time = parseTimeString(atTime[3]);
|
||||
if (amount == null || !unit || !time) {
|
||||
return null;
|
||||
}
|
||||
return applyTimeToDate(
|
||||
add(now, { [unit]: amount }),
|
||||
time.hours,
|
||||
time.minutes
|
||||
);
|
||||
}
|
||||
|
||||
return (
|
||||
parseDuration(text.match(DURATION_FROM_NOW_RE), now) ||
|
||||
parseDuration(text.match(RELATIVE_DURATION_RE), now)
|
||||
);
|
||||
};
|
||||
|
||||
/** Set time on a day offset. If the result is already past, move to the next day. */
|
||||
const applyTimeWithRollover = (offset, hours, minutes, now) => {
|
||||
const base = add(startOfDay(now), { days: offset });
|
||||
const date = applyTimeToDate(base, hours, minutes);
|
||||
if (isAfter(date, now)) return date;
|
||||
return applyTimeToDate(add(base, { days: 1 }), hours, minutes);
|
||||
};
|
||||
|
||||
/** Handle "today", "tonight", "tomorrow" with optional time. */
|
||||
const matchRelativeDay = (text, now) => {
|
||||
const dayOnlyMatch = text.match(RELATIVE_DAY_ONLY_RE);
|
||||
if (dayOnlyMatch) {
|
||||
const key = dayOnlyMatch[1];
|
||||
const offset = RELATIVE_DAY_MAP[key];
|
||||
if (key === 'tonight' || key === 'tonite') {
|
||||
return ensureFutureOrNextDay(
|
||||
applyTimeToDate(add(startOfDay(now), { days: offset }), 20, 0),
|
||||
now
|
||||
);
|
||||
}
|
||||
if (offset === 1) {
|
||||
return applyTimeToDate(add(startOfDay(now), { days: 1 }), 9, 0);
|
||||
}
|
||||
return add(now, { hours: 1 });
|
||||
}
|
||||
|
||||
const dayTodTimeMatch = text.match(RELATIVE_DAY_TOD_TIME_RE);
|
||||
if (dayTodTimeMatch) {
|
||||
const timeParts = dayTodTimeMatch[3].split(':');
|
||||
const time = inferHoursFromTOD(
|
||||
dayTodTimeMatch[2],
|
||||
timeParts[0],
|
||||
timeParts[1]
|
||||
);
|
||||
if (!time) return null;
|
||||
return applyTimeWithRollover(
|
||||
RELATIVE_DAY_MAP[dayTodTimeMatch[1]],
|
||||
time.hours,
|
||||
time.minutes,
|
||||
now
|
||||
);
|
||||
}
|
||||
|
||||
const dayTodMatch = text.match(RELATIVE_DAY_TOD_RE);
|
||||
if (dayTodMatch) {
|
||||
const { hours, minutes } = TIME_OF_DAY_MAP[dayTodMatch[2]];
|
||||
return applyTimeWithRollover(
|
||||
RELATIVE_DAY_MAP[dayTodMatch[1]],
|
||||
hours,
|
||||
minutes,
|
||||
now
|
||||
);
|
||||
}
|
||||
|
||||
const dayAtTimeMatch = text.match(RELATIVE_DAY_AT_TIME_RE);
|
||||
if (dayAtTimeMatch) {
|
||||
const [, dayKey, timeRaw] = dayAtTimeMatch;
|
||||
const bare = /^(tonight|tonite)$/.test(dayKey) && !/[ap]m/i.test(timeRaw);
|
||||
const time = bare
|
||||
? inferHoursFromTOD('tonight', ...timeRaw.split(':'))
|
||||
: parseTimeString(timeRaw);
|
||||
if (!time) return null;
|
||||
return applyTimeWithRollover(
|
||||
RELATIVE_DAY_MAP[dayKey],
|
||||
time.hours,
|
||||
time.minutes,
|
||||
now
|
||||
);
|
||||
}
|
||||
|
||||
const sameTimeMatch = text.match(RELATIVE_DAY_SAME_TIME_RE);
|
||||
if (sameTimeMatch) {
|
||||
const offset = RELATIVE_DAY_MAP[sameTimeMatch[1] || sameTimeMatch[2]];
|
||||
if (offset <= 0) return null;
|
||||
return applyTimeToDate(
|
||||
add(startOfDay(now), { days: offset }),
|
||||
now.getHours(),
|
||||
now.getMinutes()
|
||||
);
|
||||
}
|
||||
|
||||
return null;
|
||||
};
|
||||
|
||||
/** Find the given weekday in next week (not this week). */
|
||||
const nextWeekdayInNextWeek = (dayIndex, now) => {
|
||||
const fn = NEXT_WEEKDAY_FN[dayIndex];
|
||||
if (!fn) return null;
|
||||
const date = fn(now);
|
||||
const sameWeek =
|
||||
startOfWeek(now, { weekStartsOn: 1 }).getTime() ===
|
||||
startOfWeek(date, { weekStartsOn: 1 }).getTime();
|
||||
return sameWeek ? fn(date) : date;
|
||||
};
|
||||
|
||||
/** Handle "next friday", "next week", "next month", "next january", etc. */
|
||||
const matchNextPattern = (text, now) => {
|
||||
const nextUnitMatch = text.match(NEXT_UNIT_RE);
|
||||
if (nextUnitMatch) {
|
||||
const unit = nextUnitMatch[1];
|
||||
if (unit === 'hour') return add(now, { hours: 1 });
|
||||
if (unit === 'minute') return add(now, { minutes: 1 });
|
||||
if (unit === 'week') {
|
||||
const base = startOfWeek(addWeeks(now, 1), { weekStartsOn: 1 });
|
||||
return applyTimeOrDefault(base, nextUnitMatch[2]);
|
||||
}
|
||||
const base = add(startOfDay(now), { [`${unit}s`]: 1 });
|
||||
return applyTimeOrDefault(base, nextUnitMatch[2]);
|
||||
}
|
||||
|
||||
const nextMonthMatch = text.match(NEXT_MONTH_RE);
|
||||
if (nextMonthMatch) {
|
||||
const monthIdx = MONTH_MAP[nextMonthMatch[1]];
|
||||
let year = now.getFullYear();
|
||||
if (monthIdx <= now.getMonth()) year += 1;
|
||||
const base = new Date(year, monthIdx, 1);
|
||||
return applyTimeOrDefault(base, nextMonthMatch[2]);
|
||||
}
|
||||
|
||||
// "next monday morning", "next friday midnight" — weekday + time-of-day
|
||||
const nextTodMatch = text.match(NEXT_WEEKDAY_TOD_RE);
|
||||
if (nextTodMatch) {
|
||||
const date = nextWeekdayInNextWeek(WEEKDAY_MAP[nextTodMatch[1]], now);
|
||||
if (!date) return null;
|
||||
const { hours, minutes } = TIME_OF_DAY_MAP[nextTodMatch[2]];
|
||||
return applyTimeToDate(date, hours, minutes);
|
||||
}
|
||||
|
||||
// "monday of next week", "next week monday", "next friday" — all with optional time
|
||||
const weekdayMatch = text.match(NEXT_WEEKDAY_RE);
|
||||
if (weekdayMatch) {
|
||||
const dayName = weekdayMatch[1] || weekdayMatch[2] || weekdayMatch[3];
|
||||
const date = nextWeekdayInNextWeek(WEEKDAY_MAP[dayName], now);
|
||||
if (!date) return null;
|
||||
return applyTimeOrDefault(date, weekdayMatch[4]);
|
||||
}
|
||||
|
||||
return null;
|
||||
};
|
||||
|
||||
/** Find the next occurrence of a weekday, with optional time. */
|
||||
const resolveWeekdayDate = (dayIndex, timeStr, now) => {
|
||||
const fn = NEXT_WEEKDAY_FN[dayIndex];
|
||||
if (!fn) return null;
|
||||
let adjusted = timeStr;
|
||||
if (timeStr && /^\d{1,2}$/.test(timeStr.trim())) {
|
||||
const h = parseInt(timeStr, 10);
|
||||
if (h >= 1 && h <= 7) adjusted = `${h}pm`;
|
||||
}
|
||||
|
||||
if (getDay(now) === dayIndex) {
|
||||
const todayDate = applyTimeOrDefault(now, adjusted);
|
||||
if (todayDate && isAfter(todayDate, now)) return todayDate;
|
||||
}
|
||||
|
||||
return applyTimeOrDefault(fn(now), adjusted);
|
||||
};
|
||||
|
||||
/** Handle "friday", "monday 3pm", "wed morning", "same time friday". */
|
||||
const matchWeekday = (text, now) => {
|
||||
const sameTimeWeekday = text.match(SAME_TIME_WEEKDAY_RE);
|
||||
if (sameTimeWeekday) {
|
||||
const dayIndex = WEEKDAY_MAP[sameTimeWeekday[1]];
|
||||
const fn = NEXT_WEEKDAY_FN[dayIndex];
|
||||
if (!fn) return null;
|
||||
const target = fn(now);
|
||||
return applyTimeToDate(target, now.getHours(), now.getMinutes());
|
||||
}
|
||||
|
||||
// "monday morning 6", "friday evening 7" — weekday + tod + bare number
|
||||
const todTimeMatch = text.match(WEEKDAY_TOD_TIME_RE);
|
||||
if (todTimeMatch) {
|
||||
const dayIndex = WEEKDAY_MAP[todTimeMatch[1]];
|
||||
const fn = NEXT_WEEKDAY_FN[dayIndex];
|
||||
if (!fn) return null;
|
||||
const timeParts = todTimeMatch[3].split(':');
|
||||
const time = inferHoursFromTOD(todTimeMatch[2], timeParts[0], timeParts[1]);
|
||||
if (!time) return null;
|
||||
const target =
|
||||
getDay(now) === dayIndex ? startOfDay(now) : startOfDay(fn(now));
|
||||
const date = applyTimeToDate(target, time.hours, time.minutes);
|
||||
return isAfter(date, now)
|
||||
? date
|
||||
: applyTimeToDate(fn(now), time.hours, time.minutes);
|
||||
}
|
||||
|
||||
// "monday morning", "friday midnight", "wednesday evening", etc.
|
||||
const todMatch = text.match(WEEKDAY_TOD_RE);
|
||||
if (todMatch) {
|
||||
const dayIndex = WEEKDAY_MAP[todMatch[1]];
|
||||
const fn = NEXT_WEEKDAY_FN[dayIndex];
|
||||
if (!fn) return null;
|
||||
const { hours, minutes } = TIME_OF_DAY_MAP[todMatch[2]];
|
||||
const target =
|
||||
getDay(now) === dayIndex ? startOfDay(now) : startOfDay(fn(now));
|
||||
const date = applyTimeToDate(target, hours, minutes);
|
||||
return isAfter(date, now) ? date : applyTimeToDate(fn(now), hours, minutes);
|
||||
}
|
||||
|
||||
const match = text.match(WEEKDAY_TIME_RE);
|
||||
if (!match) return null;
|
||||
|
||||
return resolveWeekdayDate(WEEKDAY_MAP[match[1]], match[2], now);
|
||||
};
|
||||
|
||||
/** Handle a standalone time like "3pm", "14:30", "at 9am". */
|
||||
const matchTimeOnly = (text, now) => {
|
||||
const match =
|
||||
text.match(TIME_ONLY_MERIDIEM_RE) || text.match(TIME_ONLY_24H_RE);
|
||||
if (!match) return null;
|
||||
|
||||
const time = parseTimeString(match[1]);
|
||||
if (!time) return null;
|
||||
return ensureFutureOrNextDay(
|
||||
applyTimeToDate(now, time.hours, time.minutes),
|
||||
now
|
||||
);
|
||||
};
|
||||
|
||||
/** Handle "morning", "evening 6pm", "eod", "this afternoon". */
|
||||
const matchTimeOfDay = (text, now) => {
|
||||
const todWithTime = text.match(TOD_WITH_TIME_RE);
|
||||
if (todWithTime) {
|
||||
const rawTime = todWithTime[2].trim();
|
||||
const hasMeridiem = /(?:am|pm|a\.m|p\.m)/i.test(rawTime);
|
||||
let time;
|
||||
if (hasMeridiem) {
|
||||
time = parseTimeString(rawTime);
|
||||
const range = TOD_HOUR_RANGE[todWithTime[1]];
|
||||
if (!time) return null;
|
||||
if (range) {
|
||||
const h = time.hours === 0 ? 24 : time.hours;
|
||||
if (h < range[0] || h >= range[1]) return null;
|
||||
}
|
||||
} else {
|
||||
const parts = rawTime.split(':');
|
||||
time = inferHoursFromTOD(todWithTime[1], parts[0], parts[1]);
|
||||
}
|
||||
if (!time) return null;
|
||||
return ensureFutureOrNextDay(
|
||||
applyTimeToDate(now, time.hours, time.minutes),
|
||||
now
|
||||
);
|
||||
}
|
||||
|
||||
// "early morning" → 7am, "late evening" → 21:00, "late night" → 23:00
|
||||
const earlyLate = text.match(EARLY_LATE_TOD_RE);
|
||||
if (earlyLate) {
|
||||
const tod = TIME_OF_DAY_MAP[earlyLate[2]];
|
||||
if (!tod) return null;
|
||||
const shift = earlyLate[1] === 'early' ? -1 : 2;
|
||||
return ensureFutureOrNextDay(
|
||||
applyTimeToDate(now, tod.hours + shift, 0),
|
||||
now
|
||||
);
|
||||
}
|
||||
|
||||
const match = text.match(TOD_PLAIN_RE);
|
||||
if (!match) return null;
|
||||
|
||||
const key = text
|
||||
.replace(/^(?:later|in)\s+/, '')
|
||||
.replace(/^(?:this|the)\s+/, '')
|
||||
.trim();
|
||||
const tod = TIME_OF_DAY_MAP[key];
|
||||
if (!tod) return null;
|
||||
return ensureFutureOrNextDay(
|
||||
applyTimeToDate(now, tod.hours, tod.minutes),
|
||||
now
|
||||
);
|
||||
};
|
||||
|
||||
/** Turn month + day + optional year into a future date. */
|
||||
const resolveAbsoluteDate = (month, day, yearStr, timeStr, now) => {
|
||||
let year = now.getFullYear();
|
||||
if (yearStr && /next\s+year/i.test(yearStr)) {
|
||||
year += 1;
|
||||
} else if (yearStr) {
|
||||
year = parseInt(yearStr, 10);
|
||||
}
|
||||
if (yearStr) {
|
||||
const base = strictDate(year, month, day);
|
||||
if (!base) return null;
|
||||
const date = applyTimeOrDefault(base, timeStr);
|
||||
return date && isAfter(date, now) ? date : null;
|
||||
}
|
||||
return futureOrNextYear(year, month, day, timeStr, now);
|
||||
};
|
||||
|
||||
/** Handle "jan 15", "15 march", "december 2025". */
|
||||
const matchNamedDate = (text, now) => {
|
||||
const abs = text.match(ABSOLUTE_DATE_RE);
|
||||
if (abs) {
|
||||
return resolveAbsoluteDate(
|
||||
MONTH_MAP[abs[1]],
|
||||
parseInt(abs[2], 10),
|
||||
abs[3],
|
||||
abs[4],
|
||||
now
|
||||
);
|
||||
}
|
||||
|
||||
const rev = text.match(ABSOLUTE_DATE_REVERSED_RE);
|
||||
if (rev) {
|
||||
return resolveAbsoluteDate(
|
||||
MONTH_MAP[rev[2]],
|
||||
parseInt(rev[1], 10),
|
||||
rev[3],
|
||||
rev[4],
|
||||
now
|
||||
);
|
||||
}
|
||||
|
||||
const my = text.match(MONTH_YEAR_RE);
|
||||
if (my) {
|
||||
const date = new Date(parseInt(my[2], 10), MONTH_MAP[my[1]], 1);
|
||||
if (!isValid(date)) return null;
|
||||
const result = applyTimeToDate(date, 9, 0);
|
||||
return isAfter(result, now) ? result : null;
|
||||
}
|
||||
|
||||
// "april first week", "first week of april", "march 2nd day", etc.
|
||||
const mo = text.match(MONTH_ORDINAL_RE);
|
||||
if (mo) {
|
||||
// Groups: (1)month-A (2)ordinal-A (3)unit-A | (4)ordinal-B (5)unit-B (6)month-B (7)time
|
||||
const monthIdx = MONTH_MAP[mo[1] || mo[6]];
|
||||
const num = parseOrdinal(mo[2] || mo[4]);
|
||||
const unit = mo[3] || mo[5];
|
||||
const timeStr = mo[7];
|
||||
|
||||
if (!num || num < 1) return null;
|
||||
|
||||
if (unit === 'day') {
|
||||
if (num > 31) return null;
|
||||
return resolveAbsoluteDate(monthIdx, num, null, timeStr, now);
|
||||
}
|
||||
|
||||
// unit === 'week'
|
||||
if (num > 5) return null;
|
||||
const weekStartDay = (num - 1) * 7 + 1;
|
||||
let year = now.getFullYear();
|
||||
if (
|
||||
monthIdx < now.getMonth() ||
|
||||
(monthIdx === now.getMonth() && now.getDate() > weekStartDay)
|
||||
) {
|
||||
year += 1;
|
||||
}
|
||||
// Reject if weekStartDay overflows the month (e.g. feb fifth week = day 29 in non-leap)
|
||||
const daysInMonth = new Date(year, monthIdx + 1, 0).getDate();
|
||||
if (weekStartDay > daysInMonth) return null;
|
||||
const d = new Date(year, monthIdx, weekStartDay);
|
||||
if (!isValid(d)) return null;
|
||||
const result = applyTimeOrDefault(d, timeStr);
|
||||
return result && isAfter(result, now) ? result : null;
|
||||
}
|
||||
|
||||
return null;
|
||||
};
|
||||
|
||||
/** Build a date from year/month/day numbers, with optional time. */
|
||||
const buildDateWithOptionalTime = (year, month, day, timeStr) => {
|
||||
const date = strictDate(year, month, day);
|
||||
if (!date) return null;
|
||||
return applyTimeOrDefault(date, timeStr);
|
||||
};
|
||||
|
||||
// When both values are ≤ 12 (ambiguous), dayFirst controls the fallback:
|
||||
// dayFirst=false (slash M/D/Y) → month first
|
||||
// dayFirst=true (dash/dot D-M-Y, D.M.Y) → day first
|
||||
const disambiguateDayMonth = (a, b, dayFirst = false) => {
|
||||
if (a > 12) return { day: a, month: b - 1 };
|
||||
if (b > 12) return { month: a - 1, day: b };
|
||||
return dayFirst ? { day: a, month: b - 1 } : { month: a - 1, day: b };
|
||||
};
|
||||
|
||||
/** Handle formal dates: "2025-01-15", "1/15/2025", "15.01.2025". */
|
||||
const matchFormalDate = (text, now) => {
|
||||
const ensureFuture = date => (date && isAfter(date, now) ? date : null);
|
||||
|
||||
const isoMatch = text.match(ISO_DATE_RE);
|
||||
if (isoMatch) {
|
||||
return ensureFuture(
|
||||
buildDateWithOptionalTime(
|
||||
parseInt(isoMatch[1], 10),
|
||||
parseInt(isoMatch[2], 10) - 1,
|
||||
parseInt(isoMatch[3], 10),
|
||||
isoMatch[4]
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
// Slash = M/D/Y (US), Dash/Dot = D-M-Y / D.M.Y (European)
|
||||
const formats = [
|
||||
{ re: SLASH_DATE_RE, dayFirst: false },
|
||||
{ re: DASH_DATE_RE, dayFirst: true },
|
||||
{ re: DOT_DATE_RE, dayFirst: true },
|
||||
];
|
||||
let result = null;
|
||||
formats.some(({ re, dayFirst }) => {
|
||||
const m = text.match(re);
|
||||
if (!m) return false;
|
||||
const { month, day } = disambiguateDayMonth(
|
||||
parseInt(m[1], 10),
|
||||
parseInt(m[2], 10),
|
||||
dayFirst
|
||||
);
|
||||
result = ensureFuture(
|
||||
buildDateWithOptionalTime(parseInt(m[3], 10), month, day, m[4])
|
||||
);
|
||||
return true;
|
||||
});
|
||||
return result;
|
||||
};
|
||||
|
||||
/** Handle "day after tomorrow", "end of week", "this weekend", "later today". */
|
||||
const matchSpecial = (text, now) => {
|
||||
const dat = text.match(DAY_AFTER_TOMORROW_RE);
|
||||
if (dat) return applyTimeOrDefault(add(startOfDay(now), { days: 2 }), dat[1]);
|
||||
|
||||
const eof = text.match(END_OF_RE);
|
||||
if (eof) {
|
||||
if (eof[1] === 'day') return applyTimeToDate(now, 17, 0);
|
||||
if (eof[1] === 'week') {
|
||||
const fri = applyTimeToDate(now, 17, 0);
|
||||
if (getDay(now) === 5 && isAfter(fri, now)) return fri;
|
||||
return applyTimeToDate(nextFriday(now), 17, 0);
|
||||
}
|
||||
if (eof[1] === 'month') {
|
||||
const eom = applyTimeToDate(endOfMonth(now), 17, 0);
|
||||
if (isAfter(eom, now)) return eom;
|
||||
return applyTimeToDate(endOfMonth(add(now, { months: 1 })), 17, 0);
|
||||
}
|
||||
}
|
||||
|
||||
// "end of next week", "end of next month"
|
||||
const eofNext = text.match(END_OF_NEXT_RE);
|
||||
if (eofNext) {
|
||||
if (eofNext[1] === 'week') {
|
||||
const nextWeekStart = startOfWeek(addWeeks(now, 1), { weekStartsOn: 1 });
|
||||
return applyTimeToDate(add(nextWeekStart, { days: 4 }), 17, 0);
|
||||
}
|
||||
if (eofNext[1] === 'month') {
|
||||
return applyTimeToDate(endOfMonth(add(now, { months: 1 })), 17, 0);
|
||||
}
|
||||
}
|
||||
|
||||
// "beginning of next week", "start of next month"
|
||||
const sofNext = text.match(START_OF_NEXT_RE);
|
||||
if (sofNext) {
|
||||
if (sofNext[1] === 'week') {
|
||||
return applyTimeToDate(
|
||||
startOfWeek(addWeeks(now, 1), { weekStartsOn: 1 }),
|
||||
9,
|
||||
0
|
||||
);
|
||||
}
|
||||
if (sofNext[1] === 'month') {
|
||||
const nextMonth = new Date(now.getFullYear(), now.getMonth() + 1, 1);
|
||||
return applyTimeToDate(nextMonth, 9, 0);
|
||||
}
|
||||
}
|
||||
|
||||
// "next business day", "next working day"
|
||||
if (NEXT_BUSINESS_DAY_RE.test(text)) {
|
||||
let d = add(startOfDay(now), { days: 1 });
|
||||
while (isSaturday(d) || isSunday(d)) d = add(d, { days: 1 });
|
||||
return applyTimeToDate(d, 9, 0);
|
||||
}
|
||||
|
||||
if (LATER_TODAY_RE.test(text)) return add(now, { hours: 3 });
|
||||
|
||||
const weekendMatch = text.match(
|
||||
/^(this weekend|weekend|next weekend)(?:\s+(?:at\s+)?(.+))?$/
|
||||
);
|
||||
if (weekendMatch) {
|
||||
const isNext = weekendMatch[1] === 'next weekend';
|
||||
const timeStr = weekendMatch[2];
|
||||
|
||||
if (isNext) {
|
||||
const sat = nextSaturday(now);
|
||||
const d = isSaturday(now) || isSunday(now) ? sat : add(sat, { weeks: 1 });
|
||||
return applyTimeOrDefault(d, timeStr);
|
||||
}
|
||||
|
||||
if (isSaturday(now)) {
|
||||
if (!timeStr) {
|
||||
if (now.getHours() < 10) return applyTimeToDate(now, 10, 0);
|
||||
if (now.getHours() < 18) return add(now, { hours: 2 });
|
||||
return applyTimeToDate(add(startOfDay(now), { days: 1 }), 10, 0);
|
||||
}
|
||||
const today = applyTimeOrDefault(now, timeStr);
|
||||
if (today && isAfter(today, now)) return today;
|
||||
return applyTimeOrDefault(add(startOfDay(now), { days: 1 }), timeStr);
|
||||
}
|
||||
if (isSunday(now)) {
|
||||
if (!timeStr) {
|
||||
if (now.getHours() < 10) return applyTimeToDate(now, 10, 0);
|
||||
return add(now, { hours: 2 });
|
||||
}
|
||||
const today = applyTimeOrDefault(now, timeStr);
|
||||
if (today && isAfter(today, now)) return today;
|
||||
}
|
||||
return applyTimeOrDefault(nextSaturday(now), timeStr);
|
||||
}
|
||||
|
||||
return null;
|
||||
};
|
||||
|
||||
// ─── Main Parser ────────────────────────────────────────────────────────────
|
||||
|
||||
// Order matters — first match wins. Common patterns go first.
|
||||
// Do not reorder without running the spec.
|
||||
const MATCHERS = [
|
||||
matchDuration, // "in 2 hours", "half day", "3h30m"
|
||||
matchSpecial, // "end of week", "later today", "this weekend"
|
||||
matchRelativeDay, // "tomorrow 3pm", "tonight", "today morning"
|
||||
matchNextPattern, // "next friday", "next week", "next month"
|
||||
matchTimeOfDay, // "morning", "evening 6pm", "eod"
|
||||
matchWeekday, // "friday", "monday 3pm", "wed morning"
|
||||
matchTimeOnly, // "3pm", "14:30" (must be after weekday to avoid conflicts)
|
||||
matchNamedDate, // "jan 15", "march 20 next year"
|
||||
matchFormalDate, // "2025-01-15", "1/15/2025" (least common, last)
|
||||
];
|
||||
|
||||
/**
|
||||
* Parse free-form text into a future date.
|
||||
* Returns { date, unix } or null. Only returns dates after referenceDate.
|
||||
*
|
||||
* @param {string} text - user input like "in 2 hours" or "next friday 3pm"
|
||||
* @param {Date} [referenceDate] - treat as "now" (defaults to current time)
|
||||
* @returns {{ date: Date, unix: number } | null}
|
||||
*/
|
||||
export const parseDateFromText = (text, referenceDate = new Date()) => {
|
||||
if (!text || typeof text !== 'string') return null;
|
||||
|
||||
const normalized = stripNoise(sanitize(text));
|
||||
if (!normalized) return null;
|
||||
|
||||
const maxDate = add(referenceDate, { years: 999 });
|
||||
|
||||
const isValidFuture = d =>
|
||||
d && isValid(d) && isAfter(d, referenceDate) && !isBefore(maxDate, d);
|
||||
|
||||
let result = null;
|
||||
MATCHERS.some(matcher => {
|
||||
const d = matcher(normalized, referenceDate);
|
||||
if (isValidFuture(d)) {
|
||||
result = { date: d, unix: getUnixTime(d) };
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
});
|
||||
|
||||
return result;
|
||||
};
|
||||
@@ -0,0 +1,101 @@
|
||||
/**
|
||||
* Builds autocomplete suggestions as the user types a snooze date.
|
||||
* Matches partial input against known phrases and ranks them by closeness.
|
||||
*/
|
||||
|
||||
import {
|
||||
UNIT_MAP,
|
||||
WEEKDAY_MAP,
|
||||
TIME_OF_DAY_MAP,
|
||||
RELATIVE_DAY_MAP,
|
||||
WORD_NUMBER_MAP,
|
||||
MONTH_MAP,
|
||||
HALF_UNIT_DURATIONS,
|
||||
} from './tokenMaps';
|
||||
|
||||
const SUGGESTION_UNITS = [...new Set(Object.values(UNIT_MAP))].filter(
|
||||
u => u !== 'seconds'
|
||||
);
|
||||
|
||||
const FULL_WEEKDAYS = Object.keys(WEEKDAY_MAP).filter(k => k.length > 3);
|
||||
const TOD_NAMES = Object.keys(TIME_OF_DAY_MAP).filter(k => !k.includes(' '));
|
||||
const MONTH_NAMES_LONG = Object.keys(MONTH_MAP).filter(k => k.length > 3);
|
||||
|
||||
const ALL_SUGGESTION_PHRASES = [
|
||||
...Object.keys(RELATIVE_DAY_MAP),
|
||||
...FULL_WEEKDAYS,
|
||||
...TOD_NAMES,
|
||||
'next week',
|
||||
'next month',
|
||||
'this weekend',
|
||||
'next weekend',
|
||||
'day after tomorrow',
|
||||
'later today',
|
||||
'end of day',
|
||||
'end of week',
|
||||
'end of month',
|
||||
...['morning', 'afternoon', 'evening'].map(tod => `tomorrow ${tod}`),
|
||||
...FULL_WEEKDAYS.map(wd => `next ${wd}`),
|
||||
...FULL_WEEKDAYS.map(wd => `this ${wd}`),
|
||||
...FULL_WEEKDAYS.flatMap(wd => TOD_NAMES.map(tod => `${wd} ${tod}`)),
|
||||
...FULL_WEEKDAYS.flatMap(wd => TOD_NAMES.map(tod => `next ${wd} ${tod}`)),
|
||||
...MONTH_NAMES_LONG.map(m => `${m} 1`),
|
||||
];
|
||||
|
||||
/** Check how closely the input matches a candidate. -1 = no match, 0 = exact prefix, N = extra words needed. */
|
||||
const prefixMatchScore = (candidate, input) => {
|
||||
if (candidate === input) return -1;
|
||||
if (candidate.startsWith(input)) return 0;
|
||||
const inputWords = input.split(' ');
|
||||
const candidateWords = candidate.split(' ');
|
||||
const lastIdx = inputWords.reduce((prev, iw) => {
|
||||
if (prev === -2) return -2;
|
||||
const idx = candidateWords.findIndex(
|
||||
(cw, ci) => ci > prev && cw.startsWith(iw)
|
||||
);
|
||||
return idx === -1 ? -2 : idx;
|
||||
}, -1);
|
||||
if (lastIdx === -2) return -1;
|
||||
return candidateWords.length - inputWords.length;
|
||||
};
|
||||
|
||||
export const MAX_SUGGESTIONS = 5;
|
||||
|
||||
/** Turn user input into a ranked list of suggestion strings to try parsing. */
|
||||
export const buildSuggestionCandidates = text => {
|
||||
if (!text) return [];
|
||||
|
||||
if (/^\d/.test(text)) {
|
||||
const num = text.match(/^\d+(?:\.5)?/)[0];
|
||||
const candidates = SUGGESTION_UNITS.map(u => `${num} ${u}`);
|
||||
const trimmed = text.replace(/\s+/g, ' ').trim();
|
||||
const spaced = trimmed.replace(/(\d)([a-z])/i, '$1 $2');
|
||||
return spaced.length > num.length
|
||||
? candidates.filter(c => c.startsWith(spaced))
|
||||
: candidates;
|
||||
}
|
||||
|
||||
if (text.length >= 2 && 'half'.startsWith(text)) {
|
||||
return Object.keys(HALF_UNIT_DURATIONS).map(u => `half ${u}`);
|
||||
}
|
||||
|
||||
const wordNum = WORD_NUMBER_MAP[text];
|
||||
if (wordNum != null && wordNum >= 1) {
|
||||
return SUGGESTION_UNITS.map(u => `${wordNum} ${u}`);
|
||||
}
|
||||
|
||||
const scored = ALL_SUGGESTION_PHRASES.reduce((acc, candidate) => {
|
||||
const score = prefixMatchScore(candidate, text);
|
||||
if (score >= 0) acc.push({ candidate, score });
|
||||
return acc;
|
||||
}, []);
|
||||
scored.sort((a, b) => a.score - b.score);
|
||||
const seen = new Set();
|
||||
return scored.reduce((acc, { candidate }) => {
|
||||
if (acc.length < MAX_SUGGESTIONS * 3 && !seen.has(candidate)) {
|
||||
seen.add(candidate);
|
||||
acc.push(candidate);
|
||||
}
|
||||
return acc;
|
||||
}, []);
|
||||
};
|
||||
@@ -0,0 +1,395 @@
|
||||
/**
|
||||
* Shared lookup tables and helper functions used by the parser,
|
||||
* suggestions, and localization modules.
|
||||
*/
|
||||
|
||||
import {
|
||||
add,
|
||||
set,
|
||||
isValid,
|
||||
isAfter,
|
||||
nextMonday,
|
||||
nextTuesday,
|
||||
nextWednesday,
|
||||
nextThursday,
|
||||
nextFriday,
|
||||
nextSaturday,
|
||||
nextSunday,
|
||||
} from 'date-fns';
|
||||
|
||||
// ─── Token Maps ──────────────────────────────────────────────────────────────
|
||||
// All keys are lowercase. Short forms and full names both work.
|
||||
|
||||
/** Weekday name or short form → day index (0 = Sunday). */
|
||||
export const WEEKDAY_MAP = {
|
||||
sunday: 0,
|
||||
sun: 0,
|
||||
monday: 1,
|
||||
mon: 1,
|
||||
tuesday: 2,
|
||||
tue: 2,
|
||||
tues: 2,
|
||||
wednesday: 3,
|
||||
wed: 3,
|
||||
thursday: 4,
|
||||
thu: 4,
|
||||
thur: 4,
|
||||
thurs: 4,
|
||||
friday: 5,
|
||||
fri: 5,
|
||||
saturday: 6,
|
||||
sat: 6,
|
||||
};
|
||||
|
||||
/** Month name or short form → month index (0 = January). */
|
||||
export const MONTH_MAP = {
|
||||
january: 0,
|
||||
jan: 0,
|
||||
february: 1,
|
||||
feb: 1,
|
||||
march: 2,
|
||||
mar: 2,
|
||||
april: 3,
|
||||
apr: 3,
|
||||
may: 4,
|
||||
june: 5,
|
||||
jun: 5,
|
||||
july: 6,
|
||||
jul: 6,
|
||||
august: 7,
|
||||
aug: 7,
|
||||
september: 8,
|
||||
sep: 8,
|
||||
sept: 8,
|
||||
october: 9,
|
||||
oct: 9,
|
||||
november: 10,
|
||||
nov: 10,
|
||||
december: 11,
|
||||
dec: 11,
|
||||
};
|
||||
|
||||
/** Words like "today" or "tomorrow" → how many days from now. */
|
||||
export const RELATIVE_DAY_MAP = {
|
||||
today: 0,
|
||||
tonight: 0,
|
||||
tonite: 0,
|
||||
tomorrow: 1,
|
||||
tmr: 1,
|
||||
tmrw: 1,
|
||||
};
|
||||
|
||||
/** Unit shorthand → full unit name used by date-fns. */
|
||||
export const UNIT_MAP = {
|
||||
m: 'minutes',
|
||||
min: 'minutes',
|
||||
mins: 'minutes',
|
||||
minute: 'minutes',
|
||||
minutes: 'minutes',
|
||||
h: 'hours',
|
||||
hr: 'hours',
|
||||
hrs: 'hours',
|
||||
hour: 'hours',
|
||||
hours: 'hours',
|
||||
d: 'days',
|
||||
day: 'days',
|
||||
days: 'days',
|
||||
w: 'weeks',
|
||||
wk: 'weeks',
|
||||
wks: 'weeks',
|
||||
week: 'weeks',
|
||||
weeks: 'weeks',
|
||||
mo: 'months',
|
||||
month: 'months',
|
||||
months: 'months',
|
||||
y: 'years',
|
||||
yr: 'years',
|
||||
yrs: 'years',
|
||||
year: 'years',
|
||||
years: 'years',
|
||||
};
|
||||
|
||||
/** English number words → their numeric value. */
|
||||
export const WORD_NUMBER_MAP = {
|
||||
a: 1,
|
||||
an: 1,
|
||||
one: 1,
|
||||
couple: 2,
|
||||
few: 3,
|
||||
two: 2,
|
||||
three: 3,
|
||||
four: 4,
|
||||
five: 5,
|
||||
six: 6,
|
||||
seven: 7,
|
||||
eight: 8,
|
||||
nine: 9,
|
||||
ten: 10,
|
||||
eleven: 11,
|
||||
twelve: 12,
|
||||
thirteen: 13,
|
||||
fourteen: 14,
|
||||
fifteen: 15,
|
||||
sixteen: 16,
|
||||
seventeen: 17,
|
||||
eighteen: 18,
|
||||
nineteen: 19,
|
||||
twenty: 20,
|
||||
thirty: 30,
|
||||
forty: 40,
|
||||
fifty: 50,
|
||||
sixty: 60,
|
||||
ninety: 90,
|
||||
half: 0.5,
|
||||
};
|
||||
|
||||
/** Day index → the date-fns function that finds the next occurrence. */
|
||||
export const NEXT_WEEKDAY_FN = {
|
||||
0: nextSunday,
|
||||
1: nextMonday,
|
||||
2: nextTuesday,
|
||||
3: nextWednesday,
|
||||
4: nextThursday,
|
||||
5: nextFriday,
|
||||
6: nextSaturday,
|
||||
};
|
||||
|
||||
/** Time-of-day label → default hour and minute. */
|
||||
export const TIME_OF_DAY_MAP = {
|
||||
morning: { hours: 9, minutes: 0 },
|
||||
noon: { hours: 12, minutes: 0 },
|
||||
afternoon: { hours: 14, minutes: 0 },
|
||||
evening: { hours: 18, minutes: 0 },
|
||||
night: { hours: 20, minutes: 0 },
|
||||
tonight: { hours: 20, minutes: 0 },
|
||||
midnight: { hours: 0, minutes: 0 },
|
||||
eod: { hours: 17, minutes: 0 },
|
||||
'end of day': { hours: 17, minutes: 0 },
|
||||
'end of the day': { hours: 17, minutes: 0 },
|
||||
};
|
||||
|
||||
/** Allowed hour range per label — used to pick am or pm when not specified. */
|
||||
export const TOD_HOUR_RANGE = {
|
||||
morning: [4, 12],
|
||||
noon: [11, 13],
|
||||
afternoon: [12, 18],
|
||||
evening: [16, 22],
|
||||
night: [18, 24],
|
||||
tonight: [18, 24],
|
||||
midnight: [23, 25],
|
||||
};
|
||||
|
||||
/** What "half hour", "half day", etc. actually mean in date-fns terms. */
|
||||
export const HALF_UNIT_DURATIONS = {
|
||||
hour: { minutes: 30 },
|
||||
day: { hours: 12 },
|
||||
week: { days: 3, hours: 12 },
|
||||
month: { days: 15 },
|
||||
year: { months: 6 },
|
||||
};
|
||||
|
||||
const FRACTIONAL_CONVERT = {
|
||||
hours: { unit: 'minutes', factor: 60 },
|
||||
days: { unit: 'hours', factor: 24 },
|
||||
weeks: { unit: 'days', factor: 7 },
|
||||
months: { unit: 'days', factor: 30 },
|
||||
years: { unit: 'months', factor: 12 },
|
||||
};
|
||||
|
||||
// ─── Unicode / Normalization ────────────────────────────────────────────────
|
||||
// Turn non-ASCII digits and punctuation into plain ASCII so the
|
||||
// parser only has to deal with standard characters.
|
||||
|
||||
const UNICODE_DIGIT_RANGES = [
|
||||
[0x30, 0x39],
|
||||
[0x660, 0x669], // Arabic-Indic
|
||||
[0x6f0, 0x6f9], // Eastern Arabic-Indic
|
||||
[0x966, 0x96f], // Devanagari
|
||||
[0x9e6, 0x9ef], // Bengali
|
||||
[0xa66, 0xa6f], // Gurmukhi
|
||||
[0xae6, 0xaef], // Gujarati
|
||||
[0xb66, 0xb6f], // Oriya
|
||||
[0xbe6, 0xbef], // Tamil
|
||||
[0xc66, 0xc6f], // Telugu
|
||||
[0xce6, 0xcef], // Kannada
|
||||
[0xd66, 0xd6f], // Malayalam
|
||||
];
|
||||
|
||||
const toAsciiDigit = char => {
|
||||
const code = char.codePointAt(0);
|
||||
const range = UNICODE_DIGIT_RANGES.find(
|
||||
([start, end]) => code >= start && code <= end
|
||||
);
|
||||
if (!range) return char;
|
||||
return String(code - range[0]);
|
||||
};
|
||||
|
||||
/** Turn non-ASCII digits (Arabic, Devanagari, etc.) into 0-9. */
|
||||
export const normalizeDigits = text => text.replace(/\p{Nd}/gu, toAsciiDigit);
|
||||
|
||||
const ARABIC_PUNCT_MAP = {
|
||||
'\u061f': '?',
|
||||
'\u060c': ',',
|
||||
'\u061b': ';',
|
||||
'\u066b': '.',
|
||||
};
|
||||
|
||||
const NOISE_RE =
|
||||
/^(?:(?:can|could|will|would)\s+you\s+)?(?:(?:please|pls|plz|kindly)\s+)?(?:(?:snooze|remind(?:\s+me)?|set(?:\s+(?:a|the))?(?:\s+(?:reminder|deadline|snooze|timer))?|add(?:\s+(?:a|the))?(?:\s+(?:reminder|deadline|snooze))?|schedule|postpone|defer|delay|push)(?:\s+(?:it|this))?\s+)?(?:(?:on|to|for|at|until|till|by|from|after|within)\s+)?/;
|
||||
|
||||
const APPROX_RE = /^(?:approx(?:imately)?|around|about|roughly|~)\s+/;
|
||||
|
||||
/** Clean up raw input: lowercase, remove punctuation, collapse spaces. */
|
||||
export const sanitize = text =>
|
||||
normalizeDigits(
|
||||
text
|
||||
.normalize('NFKC')
|
||||
.toLowerCase()
|
||||
.replace(/[\u200f\u200e\u066c\u0640]/g, '')
|
||||
.replace(/[\u064b-\u065f]/g, '')
|
||||
.replace(/\u00a0/g, ' ')
|
||||
.replace(/[\u061f\u060c\u061b\u066b]/g, c => ARABIC_PUNCT_MAP[c])
|
||||
)
|
||||
.replace(/[,!?;]+/g, ' ')
|
||||
.replace(/\.+$/g, '')
|
||||
.replace(/\s+/g, ' ')
|
||||
.trim();
|
||||
|
||||
/** Strip filler words like "please snooze for" and fix typos like "tommorow". */
|
||||
export const stripNoise = text => {
|
||||
let r = text
|
||||
.replace(/\ba\s+fortnight\b/g, '2 weeks')
|
||||
.replace(/\bfortnight\b/g, '2 weeks')
|
||||
.replace(NOISE_RE, '')
|
||||
.replace(APPROX_RE, '')
|
||||
.replace(/^the\s+/, '')
|
||||
.replace(/\bnxt\b/g, 'next')
|
||||
.replace(/\ba\s+couple\s+of\b/g, 'couple')
|
||||
.replace(/\bcouple\s+of\b/g, 'couple')
|
||||
.replace(/\ba\s+couple\b/g, 'couple')
|
||||
.replace(/\ba\s+few\b/g, 'few')
|
||||
.replace(
|
||||
/\b(\d+)\s*(?:h|hr|hours?)[\s]*(\d+)\s*(?:m|min|minutes?)\b/g,
|
||||
(_, h, m) =>
|
||||
`${h} ${h === '1' ? 'hour' : 'hours'} ${m} ${m === '1' ? 'minute' : 'minutes'}`
|
||||
)
|
||||
.replace(/\b(\d+)h\b/g, (_, h) => `${h} ${h === '1' ? 'hour' : 'hours'}`)
|
||||
.replace(
|
||||
/\b(\d+)m\b/g,
|
||||
(_, m) => `${m} ${m === '1' ? 'minute' : 'minutes'}`
|
||||
)
|
||||
.replace(/\btomm?orow\b/g, 'tomorrow')
|
||||
.replace(/\s+later$/, '')
|
||||
.trim();
|
||||
// bare unit without number: "month later" → "1 month", "week" stays
|
||||
r = r.replace(/^(minutes?|hours?|days?|weeks?|months?|years?)$/, '1 $1');
|
||||
return r;
|
||||
};
|
||||
|
||||
// ─── Utility Functions ──────────────────────────────────────────────────────
|
||||
|
||||
/** Turn a string into a number. Works with digits ("5") and words ("five"). */
|
||||
export const parseNumber = str => {
|
||||
if (!str) return null;
|
||||
const lower = normalizeDigits(str.toLowerCase().trim());
|
||||
if (WORD_NUMBER_MAP[lower] !== undefined) return WORD_NUMBER_MAP[lower];
|
||||
const num = Number(lower);
|
||||
return Number.isNaN(num) ? null : num;
|
||||
};
|
||||
|
||||
/** Set the time on a date, clearing seconds and milliseconds. */
|
||||
export const applyTimeToDate = (date, hours, minutes = 0) =>
|
||||
set(date, { hours, minutes, seconds: 0, milliseconds: 0 });
|
||||
|
||||
/** Parse "3pm", "14:30", or "2:00am" into { hours, minutes }. Returns null if invalid. */
|
||||
export const parseTimeString = timeStr => {
|
||||
if (!timeStr) return null;
|
||||
const match = timeStr
|
||||
.toLowerCase()
|
||||
.replace(/\s+/g, '')
|
||||
.match(/^(\d{1,2})(?::(\d{2}))?\s*(am|pm|a\.m\.?|p\.m\.?)?$/);
|
||||
if (!match) return null;
|
||||
|
||||
const raw = parseInt(match[1], 10);
|
||||
const minutes = match[2] ? parseInt(match[2], 10) : 0;
|
||||
const meridiem = match[3]?.replace(/\./g, '');
|
||||
if (meridiem && (raw < 1 || raw > 12)) return null;
|
||||
|
||||
const toHours = (h, m) => {
|
||||
if (m === 'pm' && h < 12) return h + 12;
|
||||
if (m === 'am' && h === 12) return 0;
|
||||
return h;
|
||||
};
|
||||
const hours = toHours(raw, meridiem);
|
||||
if (hours > 23 || minutes > 59) return null;
|
||||
return { hours, minutes };
|
||||
};
|
||||
|
||||
/** Apply a time string to a date. Falls back to 9 AM if no time is given. */
|
||||
export const applyTimeOrDefault = (date, timeStr, defaultHours = 9) => {
|
||||
if (timeStr) {
|
||||
const time = parseTimeString(timeStr);
|
||||
if (!time) return null;
|
||||
return applyTimeToDate(date, time.hours, time.minutes);
|
||||
}
|
||||
return applyTimeToDate(date, defaultHours, 0);
|
||||
};
|
||||
|
||||
/** Build a Date only if the day actually exists (e.g. rejects Feb 30). */
|
||||
export const strictDate = (year, month, day) => {
|
||||
const date = new Date(year, month, day);
|
||||
if (
|
||||
!isValid(date) ||
|
||||
date.getFullYear() !== year ||
|
||||
date.getMonth() !== month ||
|
||||
date.getDate() !== day
|
||||
)
|
||||
return null;
|
||||
return date;
|
||||
};
|
||||
|
||||
/** Try up to 8 years ahead to find a valid future date (handles Feb 29 leap years). */
|
||||
export const futureOrNextYear = (year, month, day, timeStr, now) => {
|
||||
for (let i = 0; i < 9; i += 1) {
|
||||
const base = strictDate(year + i, month, day);
|
||||
if (base) {
|
||||
const date = applyTimeOrDefault(base, timeStr);
|
||||
if (!date) return null;
|
||||
if (isAfter(date, now)) return date;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
};
|
||||
|
||||
/** If the date is already past, push it to the next day. */
|
||||
export const ensureFutureOrNextDay = (date, now) =>
|
||||
isAfter(date, now) ? date : add(date, { days: 1 });
|
||||
|
||||
/** Figure out am/pm from context: "morning 6" → 6am, "evening 6" → 6pm. */
|
||||
export const inferHoursFromTOD = (todLabel, rawHour, rawMinutes) => {
|
||||
const h = parseInt(rawHour, 10);
|
||||
const m = rawMinutes ? parseInt(rawMinutes, 10) : 0;
|
||||
if (Number.isNaN(h) || h < 1 || h > 12 || m > 59) return null;
|
||||
const range = TOD_HOUR_RANGE[todLabel];
|
||||
if (!range) return { hours: h, minutes: m };
|
||||
// Try both am and pm interpretations, pick the one in range
|
||||
const am = h === 12 ? 0 : h;
|
||||
const pm = h === 12 ? 12 : h + 12;
|
||||
const inRange = v => v >= range[0] && v < range[1];
|
||||
if (inRange(am)) return { hours: am, minutes: m };
|
||||
if (inRange(pm)) return { hours: pm, minutes: m };
|
||||
const mid = (range[0] + range[1]) / 2;
|
||||
return {
|
||||
hours: Math.abs(am - mid) <= Math.abs(pm - mid) ? am : pm,
|
||||
minutes: m,
|
||||
};
|
||||
};
|
||||
|
||||
/** Add a duration that might be fractional, e.g. 1.5 hours becomes 90 minutes. */
|
||||
export const addFractionalSafe = (date, unit, amount) => {
|
||||
if (Number.isInteger(amount)) return add(date, { [unit]: amount });
|
||||
if (amount % 1 !== 0.5) return null;
|
||||
const conv = FRACTIONAL_CONVERT[unit];
|
||||
if (conv) return add(date, { [conv.unit]: Math.round(amount * conv.factor) });
|
||||
return add(date, { [unit]: Math.round(amount) });
|
||||
};
|
||||
@@ -7,11 +7,17 @@ import {
|
||||
startOfMonth,
|
||||
isMonday,
|
||||
isToday,
|
||||
isSameYear,
|
||||
setHours,
|
||||
setMinutes,
|
||||
setSeconds,
|
||||
} from 'date-fns';
|
||||
import wootConstants from 'dashboard/constants/globals';
|
||||
import {
|
||||
generateDateSuggestions,
|
||||
parseDateFromText,
|
||||
} from 'dashboard/helper/snoozeDateParser';
|
||||
import { UNIT_MAP } from 'dashboard/helper/snoozeDateParser/tokenMaps';
|
||||
|
||||
const SNOOZE_OPTIONS = wootConstants.SNOOZE_OPTIONS;
|
||||
|
||||
@@ -33,65 +39,113 @@ export const findStartOfNextMonth = currentDate => {
|
||||
});
|
||||
};
|
||||
|
||||
export const findNextDay = currentDate => {
|
||||
return add(currentDate, { days: 1 });
|
||||
};
|
||||
export const findNextDay = currentDate => add(currentDate, { days: 1 });
|
||||
|
||||
export const setHoursToNine = date => {
|
||||
return setSeconds(setMinutes(setHours(date, 9), 0), 0);
|
||||
export const setHoursToNine = date =>
|
||||
setSeconds(setMinutes(setHours(date, 9), 0), 0);
|
||||
|
||||
const SNOOZE_RESOLVERS = {
|
||||
[SNOOZE_OPTIONS.AN_HOUR_FROM_NOW]: d => add(d, { hours: 1 }),
|
||||
[SNOOZE_OPTIONS.UNTIL_TOMORROW]: d => setHoursToNine(findNextDay(d)),
|
||||
[SNOOZE_OPTIONS.UNTIL_NEXT_WEEK]: d => setHoursToNine(findStartOfNextWeek(d)),
|
||||
[SNOOZE_OPTIONS.UNTIL_NEXT_MONTH]: d =>
|
||||
setHoursToNine(findStartOfNextMonth(d)),
|
||||
};
|
||||
|
||||
export const findSnoozeTime = (snoozeType, currentDate = new Date()) => {
|
||||
let parsedDate = null;
|
||||
if (snoozeType === SNOOZE_OPTIONS.AN_HOUR_FROM_NOW) {
|
||||
parsedDate = add(currentDate, { hours: 1 });
|
||||
} else if (snoozeType === SNOOZE_OPTIONS.UNTIL_TOMORROW) {
|
||||
parsedDate = setHoursToNine(findNextDay(currentDate));
|
||||
} else if (snoozeType === SNOOZE_OPTIONS.UNTIL_NEXT_WEEK) {
|
||||
parsedDate = setHoursToNine(findStartOfNextWeek(currentDate));
|
||||
} else if (snoozeType === SNOOZE_OPTIONS.UNTIL_NEXT_MONTH) {
|
||||
parsedDate = setHoursToNine(findStartOfNextMonth(currentDate));
|
||||
}
|
||||
|
||||
return parsedDate ? getUnixTime(parsedDate) : null;
|
||||
const resolve = SNOOZE_RESOLVERS[snoozeType];
|
||||
return resolve ? getUnixTime(resolve(currentDate)) : null;
|
||||
};
|
||||
|
||||
export const snoozedReopenTime = snoozedUntil => {
|
||||
if (!snoozedUntil) {
|
||||
return null;
|
||||
}
|
||||
if (!snoozedUntil) return null;
|
||||
const date = new Date(snoozedUntil);
|
||||
if (isToday(date)) return format(date, 'h.mmaaa');
|
||||
if (!isSameYear(date, new Date())) return format(date, 'd MMM yyyy, h.mmaaa');
|
||||
return format(date, 'd MMM, h.mmaaa');
|
||||
};
|
||||
|
||||
if (isToday(date)) {
|
||||
return format(date, 'h.mmaaa');
|
||||
export const snoozedReopenTimeToTimestamp = snoozedUntil =>
|
||||
snoozedUntil ? getUnixTime(new Date(snoozedUntil)) : null;
|
||||
|
||||
const formatSnoozeDate = (snoozeDate, currentDate, locale = 'en') => {
|
||||
const sameYear = isSameYear(snoozeDate, currentDate);
|
||||
try {
|
||||
const opts = {
|
||||
weekday: 'short',
|
||||
day: 'numeric',
|
||||
month: 'short',
|
||||
hour: 'numeric',
|
||||
minute: '2-digit',
|
||||
hour12: true,
|
||||
...(sameYear ? {} : { year: 'numeric' }),
|
||||
};
|
||||
return new Intl.DateTimeFormat(locale, opts).format(snoozeDate);
|
||||
} catch {
|
||||
return sameYear
|
||||
? format(snoozeDate, 'EEE, d MMM, h:mm a')
|
||||
: format(snoozeDate, 'EEE, d MMM yyyy, h:mm a');
|
||||
}
|
||||
return snoozedUntil ? format(date, 'd MMM, h.mmaaa') : null;
|
||||
};
|
||||
|
||||
export const snoozedReopenTimeToTimestamp = snoozedUntil => {
|
||||
return snoozedUntil ? getUnixTime(new Date(snoozedUntil)) : null;
|
||||
const expandUnit = (num, abbr) => {
|
||||
const full = UNIT_MAP[abbr];
|
||||
if (!full) return `${num} ${abbr}`;
|
||||
return parseFloat(num) === 1
|
||||
? `${num} ${full.replace(/s$/, '')}`
|
||||
: `${num} ${full}`;
|
||||
};
|
||||
|
||||
const capitalizeLabel = text => {
|
||||
const expanded = text
|
||||
.replace(
|
||||
/^(\d+)h(\d+)m(?:in)?$/i,
|
||||
(_, h, m) => `${expandUnit(h, 'h')} ${expandUnit(m, 'm')}`
|
||||
)
|
||||
.replace(/^(\d+(?:\.5)?)\s*([a-z]+)$/i, (_, n, u) =>
|
||||
UNIT_MAP[u.toLowerCase()] ? expandUnit(n, u.toLowerCase()) : `${n} ${u}`
|
||||
);
|
||||
return expanded.replace(/^\w/, c => c.toUpperCase());
|
||||
};
|
||||
|
||||
export const generateSnoozeSuggestions = (
|
||||
searchText,
|
||||
currentDate = new Date(),
|
||||
{ translations, locale } = {}
|
||||
) => {
|
||||
const suggestions = generateDateSuggestions(searchText, currentDate, {
|
||||
translations,
|
||||
locale,
|
||||
});
|
||||
return suggestions.map(s => ({
|
||||
date: s.date,
|
||||
unixTime: s.unix,
|
||||
query: s.query,
|
||||
label: capitalizeLabel(s.label),
|
||||
formattedDate: formatSnoozeDate(s.date, currentDate, locale),
|
||||
resolve: () => parseDateFromText(s.query)?.unix ?? s.unix,
|
||||
}));
|
||||
};
|
||||
|
||||
const UNIT_SHORT = {
|
||||
minute: 'm',
|
||||
minutes: 'm',
|
||||
hour: 'h',
|
||||
hours: 'h',
|
||||
day: 'd',
|
||||
days: 'd',
|
||||
month: 'mo',
|
||||
months: 'mo',
|
||||
year: 'y',
|
||||
years: 'y',
|
||||
};
|
||||
|
||||
export const shortenSnoozeTime = snoozedUntil => {
|
||||
if (!snoozedUntil) {
|
||||
return null;
|
||||
}
|
||||
const unitMap = {
|
||||
minutes: 'm',
|
||||
minute: 'm',
|
||||
hours: 'h',
|
||||
hour: 'h',
|
||||
days: 'd',
|
||||
day: 'd',
|
||||
months: 'mo',
|
||||
month: 'mo',
|
||||
years: 'y',
|
||||
year: 'y',
|
||||
};
|
||||
const shortenTime = snoozedUntil
|
||||
if (!snoozedUntil) return null;
|
||||
return snoozedUntil
|
||||
.replace(/^in\s+/i, '')
|
||||
.replace(
|
||||
/\s(minute|hour|day|month|year)s?\b/gi,
|
||||
(match, unit) => unitMap[unit.toLowerCase()] || match
|
||||
(match, unit) => UNIT_SHORT[unit.toLowerCase()] || match
|
||||
);
|
||||
|
||||
return shortenTime;
|
||||
};
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -7,6 +7,7 @@ import {
|
||||
setHoursToNine,
|
||||
snoozedReopenTimeToTimestamp,
|
||||
shortenSnoozeTime,
|
||||
generateSnoozeSuggestions,
|
||||
} from '../snoozeHelpers';
|
||||
|
||||
describe('#Snooze Helpers', () => {
|
||||
@@ -91,12 +92,26 @@ describe('#Snooze Helpers', () => {
|
||||
});
|
||||
|
||||
describe('snoozedReopenTime', () => {
|
||||
it('should return nil if snoozedUntil is nil', () => {
|
||||
expect(snoozedReopenTime(null)).toEqual(null);
|
||||
beforeEach(() => {
|
||||
vi.useFakeTimers();
|
||||
vi.setSystemTime(new Date('2024-01-01T12:00:00Z'));
|
||||
});
|
||||
|
||||
it('should return formatted date if snoozedUntil is not nil', () => {
|
||||
afterEach(() => {
|
||||
vi.useRealTimers();
|
||||
});
|
||||
|
||||
it('should return formatted date with year if snoozedUntil is not in current year', () => {
|
||||
// Input is 09:00 UTC.
|
||||
// If your environment is UTC, this will be 9.00am.
|
||||
expect(snoozedReopenTime('2023-06-07T09:00:00.000Z')).toEqual(
|
||||
'7 Jun 2023, 9.00am'
|
||||
);
|
||||
});
|
||||
|
||||
it('should return formatted date without year if snoozedUntil is in current year', () => {
|
||||
// This uses 2024 because we mocked the system time above
|
||||
expect(snoozedReopenTime('2024-06-07T09:00:00.000Z')).toEqual(
|
||||
'7 Jun, 9.00am'
|
||||
);
|
||||
});
|
||||
@@ -150,4 +165,56 @@ describe('#Snooze Helpers', () => {
|
||||
expect(shortenSnoozeTime(null)).toEqual(null);
|
||||
});
|
||||
});
|
||||
|
||||
describe('generateSnoozeSuggestions label expansion', () => {
|
||||
const now = new Date('2023-06-16T10:00:00');
|
||||
|
||||
it('expands abbreviated units: "1d" → "1 Day"', () => {
|
||||
const results = generateSnoozeSuggestions('1d', now);
|
||||
expect(results.length).toBeGreaterThan(0);
|
||||
expect(results[0].label).toBe('1 day');
|
||||
});
|
||||
|
||||
it('expands abbreviated units: "2 d" → "2 Days"', () => {
|
||||
const results = generateSnoozeSuggestions('2 d', now);
|
||||
expect(results.length).toBeGreaterThan(0);
|
||||
expect(results[0].label).toBe('2 days');
|
||||
});
|
||||
|
||||
it('expands abbreviated units: "1h" → "1 Hour"', () => {
|
||||
const results = generateSnoozeSuggestions('1h', now);
|
||||
expect(results.length).toBeGreaterThan(0);
|
||||
expect(results[0].label).toBe('1 hour');
|
||||
});
|
||||
|
||||
it('expands abbreviated units: "2min" → "2 Minutes"', () => {
|
||||
const results = generateSnoozeSuggestions('2min', now);
|
||||
expect(results.length).toBeGreaterThan(0);
|
||||
expect(results[0].label).toBe('2 minutes');
|
||||
});
|
||||
|
||||
it('handles singular: "1 hours" → "1 Hour"', () => {
|
||||
const results = generateSnoozeSuggestions('1 hours', now);
|
||||
expect(results.length).toBeGreaterThan(0);
|
||||
expect(results[0].label).toBe('1 hour');
|
||||
});
|
||||
|
||||
it('handles singular: "1 minutes" → "1 Minute"', () => {
|
||||
const results = generateSnoozeSuggestions('1 minutes', now);
|
||||
expect(results.length).toBeGreaterThan(0);
|
||||
expect(results[0].label).toBe('1 minute');
|
||||
});
|
||||
|
||||
it('keeps plural for non-1: "2 days" → "2 Days"', () => {
|
||||
const results = generateSnoozeSuggestions('2 days', now);
|
||||
expect(results.length).toBeGreaterThan(0);
|
||||
expect(results[0].label).toBe('2 days');
|
||||
});
|
||||
|
||||
it('expands compound: "1h30m" → "1 Hour 30 Minutes"', () => {
|
||||
const results = generateSnoozeSuggestions('1h30m', now);
|
||||
expect(results.length).toBeGreaterThan(0);
|
||||
expect(results[0].label).toBe('1 hour 30 minutes');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
@@ -182,6 +182,7 @@
|
||||
},
|
||||
"COMMAND_BAR": {
|
||||
"SEARCH_PLACEHOLDER": "Search or jump to",
|
||||
"SNOOZE_PLACEHOLDER": "Type a time e.g. tomorrow, 2 hours, next friday, jan 15...",
|
||||
"SECTIONS": {
|
||||
"GENERAL": "General",
|
||||
"REPORTS": "Reports",
|
||||
|
||||
@@ -34,6 +34,7 @@ import setNewPassword from './setNewPassword.json';
|
||||
import settings from './settings.json';
|
||||
import signup from './signup.json';
|
||||
import sla from './sla.json';
|
||||
import snooze from './snooze.json';
|
||||
import teamsSettings from './teamsSettings.json';
|
||||
import whatsappTemplates from './whatsappTemplates.json';
|
||||
import contentTemplates from './contentTemplates.json';
|
||||
@@ -77,6 +78,7 @@ export default {
|
||||
...settings,
|
||||
...signup,
|
||||
...sla,
|
||||
...snooze,
|
||||
...teamsSettings,
|
||||
...whatsappTemplates,
|
||||
...contentTemplates,
|
||||
|
||||
@@ -0,0 +1,72 @@
|
||||
{
|
||||
"SNOOZE_PARSER": {
|
||||
"UNITS": {
|
||||
"MINUTE": "minute",
|
||||
"MINUTES": "minutes",
|
||||
"HOUR": "hour",
|
||||
"HOURS": "hours",
|
||||
"DAY": "day",
|
||||
"DAYS": "days",
|
||||
"WEEK": "week",
|
||||
"WEEKS": "weeks",
|
||||
"MONTH": "month",
|
||||
"MONTHS": "months",
|
||||
"YEAR": "year",
|
||||
"YEARS": "years"
|
||||
},
|
||||
"HALF": "half",
|
||||
"NEXT": "next",
|
||||
"THIS": "this",
|
||||
"AT": "at",
|
||||
"IN": "in",
|
||||
"FROM_NOW": "from now",
|
||||
"NEXT_YEAR": "next year",
|
||||
"MERIDIEM": {
|
||||
"AM": "am",
|
||||
"PM": "pm"
|
||||
},
|
||||
"RELATIVE": {
|
||||
"TOMORROW": "tomorrow",
|
||||
"DAY_AFTER_TOMORROW": "day after tomorrow",
|
||||
"NEXT_WEEK": "next week",
|
||||
"NEXT_MONTH": "next month",
|
||||
"THIS_WEEKEND": "this weekend",
|
||||
"NEXT_WEEKEND": "next weekend"
|
||||
},
|
||||
"TIME_OF_DAY": {
|
||||
"MORNING": "morning",
|
||||
"AFTERNOON": "afternoon",
|
||||
"EVENING": "evening",
|
||||
"NIGHT": "night",
|
||||
"NOON": "noon",
|
||||
"MIDNIGHT": "midnight"
|
||||
},
|
||||
"WORD_NUMBERS": {
|
||||
"ONE": "one",
|
||||
"TWO": "two",
|
||||
"THREE": "three",
|
||||
"FOUR": "four",
|
||||
"FIVE": "five",
|
||||
"SIX": "six",
|
||||
"SEVEN": "seven",
|
||||
"EIGHT": "eight",
|
||||
"NINE": "nine",
|
||||
"TEN": "ten",
|
||||
"TWELVE": "twelve",
|
||||
"FIFTEEN": "fifteen",
|
||||
"TWENTY": "twenty",
|
||||
"THIRTY": "thirty"
|
||||
},
|
||||
"ORDINALS": {
|
||||
"FIRST": "first",
|
||||
"SECOND": "second",
|
||||
"THIRD": "third",
|
||||
"FOURTH": "fourth",
|
||||
"FIFTH": "fifth"
|
||||
},
|
||||
"OF": "of",
|
||||
"AFTER": "after",
|
||||
"WEEK": "week",
|
||||
"DAY": "day"
|
||||
}
|
||||
}
|
||||
@@ -31,6 +31,8 @@ const toggleStatus = async (status, snoozedUntil) => {
|
||||
const onCmdSnoozeConversation = snoozeType => {
|
||||
if (snoozeType === wootConstants.SNOOZE_OPTIONS.UNTIL_CUSTOM_TIME) {
|
||||
showCustomSnoozeModal.value = true;
|
||||
} else if (typeof snoozeType === 'number') {
|
||||
toggleStatus(wootConstants.STATUS_TYPE.SNOOZED, snoozeType);
|
||||
} else {
|
||||
toggleStatus(
|
||||
wootConstants.STATUS_TYPE.SNOOZED,
|
||||
|
||||
@@ -4,16 +4,29 @@ import { ref, computed, watchEffect, onMounted } from 'vue';
|
||||
import { useStore } from 'dashboard/composables/store';
|
||||
import { useTrack } from 'dashboard/composables';
|
||||
import { useI18n } from 'vue-i18n';
|
||||
import { useLocale } from 'shared/composables/useLocale';
|
||||
import { useAppearanceHotKeys } from 'dashboard/composables/commands/useAppearanceHotKeys';
|
||||
import { useInboxHotKeys } from 'dashboard/composables/commands/useInboxHotKeys';
|
||||
import { useGoToCommandHotKeys } from 'dashboard/composables/commands/useGoToCommandHotKeys';
|
||||
import { useBulkActionsHotKeys } from 'dashboard/composables/commands/useBulkActionsHotKeys';
|
||||
import { useConversationHotKeys } from 'dashboard/composables/commands/useConversationHotKeys';
|
||||
import wootConstants from 'dashboard/constants/globals';
|
||||
import { GENERAL_EVENTS } from 'dashboard/helper/AnalyticsHelper/events';
|
||||
import {
|
||||
GENERAL_EVENTS,
|
||||
SNOOZE_EVENTS,
|
||||
} from 'dashboard/helper/AnalyticsHelper/events';
|
||||
import { generateSnoozeSuggestions } from 'dashboard/helper/snoozeHelpers';
|
||||
import { ICON_SNOOZE_CONVERSATION } from 'dashboard/helper/commandbar/icons';
|
||||
import {
|
||||
CMD_SNOOZE_CONVERSATION,
|
||||
CMD_SNOOZE_NOTIFICATION,
|
||||
CMD_BULK_ACTION_SNOOZE_CONVERSATION,
|
||||
} from 'dashboard/helper/commandbar/events';
|
||||
import { emitter } from 'shared/helpers/mitt';
|
||||
|
||||
const store = useStore();
|
||||
const { t } = useI18n();
|
||||
const { t, tm } = useI18n();
|
||||
const { resolvedLocale } = useLocale();
|
||||
|
||||
const ninjakeys = ref(null);
|
||||
|
||||
@@ -28,48 +41,168 @@ const { goToCommandHotKeys } = useGoToCommandHotKeys();
|
||||
const { bulkActionsHotKeys } = useBulkActionsHotKeys();
|
||||
const { conversationHotKeys } = useConversationHotKeys();
|
||||
|
||||
const placeholder = computed(() => t('COMMAND_BAR.SEARCH_PLACEHOLDER'));
|
||||
const SNOOZE_PARENT_IDS = [
|
||||
'snooze_conversation',
|
||||
'snooze_notification',
|
||||
'bulk_action_snooze_conversation',
|
||||
];
|
||||
const DYNAMIC_SNOOZE_PREFIX = 'dynamic_snooze_';
|
||||
|
||||
const hotKeys = computed(() => [
|
||||
...inboxHotKeys.value,
|
||||
...goToCommandHotKeys.value,
|
||||
...goToAppearanceHotKeys.value,
|
||||
...bulkActionsHotKeys.value,
|
||||
...conversationHotKeys.value,
|
||||
]);
|
||||
const CUSTOM_SNOOZE = wootConstants.SNOOZE_OPTIONS.UNTIL_CUSTOM_TIME;
|
||||
|
||||
const dynamicSnoozeActions = ref([]);
|
||||
const currentCommandRoot = ref(null);
|
||||
|
||||
const placeholder = computed(() =>
|
||||
SNOOZE_PARENT_IDS.includes(currentCommandRoot.value)
|
||||
? t('COMMAND_BAR.SNOOZE_PLACEHOLDER')
|
||||
: t('COMMAND_BAR.SEARCH_PLACEHOLDER')
|
||||
);
|
||||
|
||||
const SNOOZE_PRESET_IDS = new Set(Object.values(wootConstants.SNOOZE_OPTIONS));
|
||||
|
||||
const hotKeys = computed(() => {
|
||||
const allActions = [
|
||||
...dynamicSnoozeActions.value,
|
||||
...inboxHotKeys.value,
|
||||
...goToCommandHotKeys.value,
|
||||
...goToAppearanceHotKeys.value,
|
||||
...bulkActionsHotKeys.value,
|
||||
...conversationHotKeys.value,
|
||||
];
|
||||
// When dynamic NLP snooze suggestions exist, hide all preset snooze actions to avoid duplication
|
||||
if (!dynamicSnoozeActions.value.length) return allActions;
|
||||
return allActions.filter(
|
||||
a => !SNOOZE_PRESET_IDS.has(a.id) || !SNOOZE_PARENT_IDS.includes(a.parent)
|
||||
);
|
||||
});
|
||||
|
||||
const setCommandBarData = () => {
|
||||
ninjakeys.value.data = hotKeys.value;
|
||||
};
|
||||
|
||||
const onSelected = item => {
|
||||
const {
|
||||
detail: { action: { title = null, section = null, id = null } = {} } = {},
|
||||
} = item;
|
||||
// Added this condition to prevent setting the selectedSnoozeType to null
|
||||
// When we select the "custom snooze" (CMD bar will close and the custom snooze modal will open)
|
||||
if (id === wootConstants.SNOOZE_OPTIONS.UNTIL_CUSTOM_TIME) {
|
||||
selectedSnoozeType.value = wootConstants.SNOOZE_OPTIONS.UNTIL_CUSTOM_TIME;
|
||||
} else {
|
||||
selectedSnoozeType.value = null;
|
||||
const SNOOZE_EVENT_MAP = {
|
||||
snooze_conversation: CMD_SNOOZE_CONVERSATION,
|
||||
snooze_notification: CMD_SNOOZE_NOTIFICATION,
|
||||
bulk_action_snooze_conversation: CMD_BULK_ACTION_SNOOZE_CONVERSATION,
|
||||
};
|
||||
|
||||
const SNOOZE_SECTION_MAP = {
|
||||
snooze_conversation: 'COMMAND_BAR.SECTIONS.SNOOZE_CONVERSATION',
|
||||
snooze_notification: 'COMMAND_BAR.SECTIONS.SNOOZE_NOTIFICATION',
|
||||
bulk_action_snooze_conversation: 'COMMAND_BAR.SECTIONS.BULK_ACTIONS',
|
||||
};
|
||||
|
||||
const snoozeTranslations = computed(() => {
|
||||
const raw = tm('SNOOZE_PARSER');
|
||||
if (!raw || typeof raw !== 'object') return {};
|
||||
return JSON.parse(JSON.stringify(raw));
|
||||
});
|
||||
|
||||
const buildDynamicSnoozeActions = (search, parentId) => {
|
||||
const suggestions = generateSnoozeSuggestions(search, new Date(), {
|
||||
translations: snoozeTranslations.value,
|
||||
locale: resolvedLocale.value,
|
||||
});
|
||||
if (!suggestions.length) return [];
|
||||
|
||||
const busEvent = SNOOZE_EVENT_MAP[parentId];
|
||||
const section = t(SNOOZE_SECTION_MAP[parentId]);
|
||||
|
||||
return suggestions.map((parsed, index) => ({
|
||||
id: `${DYNAMIC_SNOOZE_PREFIX}${index}`,
|
||||
title:
|
||||
parsed.label !== parsed.formattedDate
|
||||
? `${parsed.label} - ${parsed.formattedDate}`
|
||||
: parsed.formattedDate,
|
||||
parent: parentId,
|
||||
section,
|
||||
icon: ICON_SNOOZE_CONVERSATION,
|
||||
keywords: search,
|
||||
handler: () => {
|
||||
emitter.emit(busEvent, parsed.resolve());
|
||||
useTrack(SNOOZE_EVENTS.NLP_SNOOZE_APPLIED, { label: parsed.label });
|
||||
},
|
||||
}));
|
||||
};
|
||||
|
||||
const resetSnoozeState = () => {
|
||||
currentCommandRoot.value = null;
|
||||
dynamicSnoozeActions.value = [];
|
||||
};
|
||||
|
||||
const patchNinjaKeysOpenClose = el => {
|
||||
if (!el || typeof el.open !== 'function' || typeof el.close !== 'function') {
|
||||
return;
|
||||
}
|
||||
|
||||
useTrack(GENERAL_EVENTS.COMMAND_BAR, {
|
||||
section,
|
||||
action: title,
|
||||
});
|
||||
const originalOpen = el.open.bind(el);
|
||||
const originalClose = el.close.bind(el);
|
||||
|
||||
el.open = (...args) => {
|
||||
const [options = {}] = args;
|
||||
currentCommandRoot.value = options.parent || null;
|
||||
dynamicSnoozeActions.value = [];
|
||||
return originalOpen(...args);
|
||||
};
|
||||
|
||||
el.close = (...args) => {
|
||||
resetSnoozeState();
|
||||
return originalClose(...args);
|
||||
};
|
||||
};
|
||||
|
||||
const onSelected = item => {
|
||||
const {
|
||||
detail: {
|
||||
action: { title = null, section = null, id = null, children = null } = {},
|
||||
} = {},
|
||||
} = item;
|
||||
|
||||
selectedSnoozeType.value = id === CUSTOM_SNOOZE ? id : null;
|
||||
|
||||
if (Array.isArray(children) && children.length) {
|
||||
currentCommandRoot.value = id;
|
||||
}
|
||||
|
||||
useTrack(GENERAL_EVENTS.COMMAND_BAR, { section, action: title });
|
||||
setCommandBarData();
|
||||
};
|
||||
|
||||
const onClosed = () => {
|
||||
// If the selectedSnoozeType is not "SNOOZE_OPTIONS.UNTIL_CUSTOM_TIME (custom snooze)" then we set the context menu chat id to null
|
||||
// Else we do nothing and its handled in the ChatList.vue hideCustomSnoozeModal() method
|
||||
const onCommandBarChange = item => {
|
||||
const { detail: { search = '', actions = [] } = {} } = item;
|
||||
const normalizedSearch = search.trim();
|
||||
|
||||
if (actions.length > 0) {
|
||||
const uniqueParents = [
|
||||
...new Set(actions.map(action => action.parent).filter(Boolean)),
|
||||
];
|
||||
if (uniqueParents.length === 1) {
|
||||
currentCommandRoot.value = uniqueParents[0];
|
||||
} else {
|
||||
currentCommandRoot.value = null;
|
||||
}
|
||||
}
|
||||
|
||||
if (
|
||||
selectedSnoozeType.value !== wootConstants.SNOOZE_OPTIONS.UNTIL_CUSTOM_TIME
|
||||
!normalizedSearch ||
|
||||
!SNOOZE_PARENT_IDS.includes(currentCommandRoot.value || '')
|
||||
) {
|
||||
dynamicSnoozeActions.value = [];
|
||||
return;
|
||||
}
|
||||
|
||||
dynamicSnoozeActions.value = buildDynamicSnoozeActions(
|
||||
normalizedSearch,
|
||||
currentCommandRoot.value
|
||||
);
|
||||
};
|
||||
|
||||
const onClosed = () => {
|
||||
if (selectedSnoozeType.value !== CUSTOM_SNOOZE) {
|
||||
store.dispatch('setContextMenuChatId', null);
|
||||
}
|
||||
resetSnoozeState();
|
||||
};
|
||||
|
||||
watchEffect(() => {
|
||||
@@ -78,7 +211,10 @@ watchEffect(() => {
|
||||
}
|
||||
});
|
||||
|
||||
onMounted(setCommandBarData);
|
||||
onMounted(() => {
|
||||
setCommandBarData();
|
||||
patchNinjaKeysOpenClose(ninjakeys.value);
|
||||
});
|
||||
</script>
|
||||
|
||||
<!-- eslint-disable vue/attribute-hyphenation -->
|
||||
@@ -88,6 +224,7 @@ onMounted(setCommandBarData);
|
||||
noAutoLoadMdIcons
|
||||
hideBreadcrumbs
|
||||
:placeholder="placeholder"
|
||||
@change="onCommandBarChange"
|
||||
@selected="onSelected"
|
||||
@closed="onClosed"
|
||||
/>
|
||||
|
||||
@@ -69,6 +69,8 @@ export default {
|
||||
onCmdSnoozeNotification(snoozeType) {
|
||||
if (snoozeType === wootConstants.SNOOZE_OPTIONS.UNTIL_CUSTOM_TIME) {
|
||||
this.showCustomSnoozeModal = true;
|
||||
} else if (typeof snoozeType === 'number') {
|
||||
this.snoozeNotification(snoozeType);
|
||||
} else {
|
||||
const snoozedUntil = findSnoozeTime(snoozeType) || null;
|
||||
this.snoozeNotification(snoozedUntil);
|
||||
|
||||
@@ -228,7 +228,10 @@ export const mutations = {
|
||||
},
|
||||
|
||||
[types.ADD_CONVERSATION](_state, conversation) {
|
||||
_state.allConversations.push(conversation);
|
||||
const exists = _state.allConversations.some(c => c.id === conversation.id);
|
||||
if (!exists) {
|
||||
_state.allConversations.push(conversation);
|
||||
}
|
||||
},
|
||||
|
||||
[types.DELETE_CONVERSATION](_state, conversationId) {
|
||||
|
||||
@@ -975,6 +975,16 @@ describe('#mutations', () => {
|
||||
mutations[types.ADD_CONVERSATION](state, conversation);
|
||||
expect(state.allConversations).toEqual([conversation]);
|
||||
});
|
||||
|
||||
it('should not add a duplicate conversation', () => {
|
||||
const conversation = { id: 1, messages: [] };
|
||||
const state = {
|
||||
allConversations: [conversation],
|
||||
};
|
||||
|
||||
mutations[types.ADD_CONVERSATION](state, { id: 1, messages: [] });
|
||||
expect(state.allConversations).toHaveLength(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('#DELETE_CONVERSATION', () => {
|
||||
|
||||
@@ -0,0 +1,11 @@
|
||||
class Avatar::AvatarFromFaviconJob < ApplicationJob
|
||||
queue_as :purgable
|
||||
|
||||
def perform(company)
|
||||
return if company.domain.blank?
|
||||
return if company.avatar.attached?
|
||||
|
||||
favicon_url = "https://www.google.com/s2/favicons?domain=#{company.domain}&sz=256"
|
||||
Avatar::AvatarFromUrlJob.perform_now(company, favicon_url)
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,17 @@
|
||||
class Companies::FetchAvatarsJob < ApplicationJob
|
||||
queue_as :low
|
||||
|
||||
def perform(account_id)
|
||||
account = Account.find(account_id)
|
||||
companies = account.companies.where.not(domain: [nil, ''])
|
||||
.left_joins(:avatar_attachment)
|
||||
.where(active_storage_attachments: { id: nil })
|
||||
|
||||
total_companies = companies.count
|
||||
companies.find_each do |company|
|
||||
Avatar::AvatarFromFaviconJob.perform_later(company)
|
||||
end
|
||||
|
||||
Rails.logger.info "Queued #{total_companies} companies from account #{account_id} for favicon fetch"
|
||||
end
|
||||
end
|
||||
@@ -180,8 +180,14 @@ class ActionCableListener < BaseListener
|
||||
end
|
||||
|
||||
def typing_event_listener_tokens(account, conversation, user)
|
||||
current_user_token = user.is_a?(Contact) ? conversation.contact_inbox.pubsub_token : user.pubsub_token
|
||||
(user_tokens(account, conversation.inbox.members) + [conversation.contact_inbox.pubsub_token]) - [current_user_token]
|
||||
current_user_token = if user.is_a?(Contact)
|
||||
conversation.contact_inbox.pubsub_token
|
||||
elsif user.respond_to?(:pubsub_token)
|
||||
user.pubsub_token
|
||||
end
|
||||
|
||||
tokens = user_tokens(account, conversation.inbox.members) + [conversation.contact_inbox.pubsub_token]
|
||||
current_user_token.present? ? tokens - [current_user_token] : tokens
|
||||
end
|
||||
|
||||
def user_tokens(account, agents)
|
||||
|
||||
@@ -89,7 +89,7 @@ class Attachment < ApplicationRecord
|
||||
when :embed
|
||||
embed_data
|
||||
else
|
||||
file_metadata
|
||||
file.attached? ? file_metadata : { data_url: external_url, thumb_url: '' }
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
@@ -10,8 +10,7 @@ class Conversations::TypingStatusManager
|
||||
end
|
||||
|
||||
def trigger_typing_event(event, is_private)
|
||||
user = @user.presence || @resource
|
||||
Rails.configuration.dispatcher.dispatch(event, Time.zone.now, conversation: @conversation, user: user, is_private: is_private)
|
||||
Rails.configuration.dispatcher.dispatch(event, Time.zone.now, conversation: @conversation, user: @user, is_private: is_private)
|
||||
end
|
||||
|
||||
def toggle_typing_status
|
||||
|
||||
@@ -30,11 +30,13 @@ class Company < ApplicationRecord
|
||||
|
||||
belongs_to :account
|
||||
has_many :contacts, dependent: :nullify
|
||||
after_create_commit :fetch_favicon, if: -> { domain.present? }
|
||||
|
||||
scope :ordered_by_name, -> { order(:name) }
|
||||
scope :search_by_name_or_domain, lambda { |query|
|
||||
where('name ILIKE :search OR domain ILIKE :search', search: "%#{query.strip}%")
|
||||
}
|
||||
|
||||
scope :order_on_contacts_count, lambda { |direction|
|
||||
order(
|
||||
Arel::Nodes::SqlLiteral.new(
|
||||
@@ -42,4 +44,10 @@ class Company < ApplicationRecord
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
private
|
||||
|
||||
def fetch_favicon
|
||||
Avatar::AvatarFromFaviconJob.set(wait: 5.seconds).perform_later(self)
|
||||
end
|
||||
end
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
namespace :companies do
|
||||
desc 'Backfill companies from existing contact email domains'
|
||||
task backfill: :environment do
|
||||
puts 'Starting company backfill migration...'
|
||||
puts 'This will process all accounts and create companies from contact email domains.'
|
||||
puts 'The job will run in the background via Sidekiq'
|
||||
puts ''
|
||||
Migration::CompanyBackfillJob.perform_later
|
||||
puts 'Company backfill job has been enqueued.'
|
||||
puts 'Monitor progress in logs or Sidekiq dashboard.'
|
||||
end
|
||||
|
||||
desc 'Fetch favicons for companies without avatars'
|
||||
task fetch_missing_avatars: :environment do
|
||||
account_ids = companies_without_avatars
|
||||
|
||||
account_ids.each do |account_id|
|
||||
Companies::FetchAvatarsJob.perform_later(account_id)
|
||||
end
|
||||
|
||||
puts "Queued #{account_ids.count} accounts for favicon fetch"
|
||||
end
|
||||
end
|
||||
|
||||
def companies_without_avatars
|
||||
Company.left_joins(:avatar_attachment)
|
||||
.where(active_storage_attachments: { id: nil })
|
||||
.where.not(domain: [nil, ''])
|
||||
.distinct
|
||||
.pluck(:account_id)
|
||||
end
|
||||
@@ -1,12 +0,0 @@
|
||||
namespace :companies do
|
||||
desc 'Backfill companies from existing contact email domains'
|
||||
task backfill: :environment do
|
||||
puts 'Starting company backfill migration...'
|
||||
puts 'This will process all accounts and create companies from contact email domains.'
|
||||
puts 'The job will run in the background via Sidekiq'
|
||||
puts ''
|
||||
Migration::CompanyBackfillJob.perform_later
|
||||
puts 'Company backfill job has been enqueued.'
|
||||
puts 'Monitor progress in logs or Sidekiq dashboard.'
|
||||
end
|
||||
end
|
||||
@@ -89,6 +89,57 @@ describe Messages::Facebook::MessageBuilder do
|
||||
expect(message.content_attributes['external_echo']).to be true
|
||||
end
|
||||
|
||||
context 'when message contains a reel attachment' do
|
||||
let(:reel_message_object) do
|
||||
{
|
||||
messaging: {
|
||||
sender: { id: '3383290475046708' },
|
||||
recipient: { id: facebook_channel.page_id },
|
||||
timestamp: 1_772_452_164_516,
|
||||
message: {
|
||||
mid: 'm_reel_test',
|
||||
attachments: [
|
||||
{
|
||||
type: 'reel',
|
||||
payload: {
|
||||
url: 'https://www.facebook.com/reel/123456',
|
||||
title: 'Test Reel Title',
|
||||
reel_video_id: 123_456
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
}.to_json
|
||||
end
|
||||
let(:reel_message) { Integrations::Facebook::MessageParser.new(reel_message_object) }
|
||||
|
||||
before do
|
||||
allow(Koala::Facebook::API).to receive(:new).and_return(fb_object)
|
||||
allow(fb_object).to receive(:get_object).and_return(
|
||||
{ first_name: 'Jane', last_name: 'Dae', profile_pic: 'https://chatwoot-assets.local/sample.png' }.with_indifferent_access
|
||||
)
|
||||
end
|
||||
|
||||
it 'creates an ig_reel attachment without downloading the file' do
|
||||
expect(Down).not_to receive(:download)
|
||||
described_class.new(reel_message, facebook_channel.inbox).perform
|
||||
|
||||
message = facebook_channel.inbox.messages.find_by(source_id: 'm_reel_test')
|
||||
expect(message).to be_present
|
||||
expect(message.attachments.first.file_type).to eq('ig_reel')
|
||||
expect(message.attachments.first.external_url).to eq('https://www.facebook.com/reel/123456')
|
||||
expect(message.attachments.first.file.attached?).to be false
|
||||
end
|
||||
|
||||
it 'sets the reel URL as message content' do
|
||||
described_class.new(reel_message, facebook_channel.inbox).perform
|
||||
|
||||
message = facebook_channel.inbox.messages.find_by(source_id: 'm_reel_test')
|
||||
expect(message.content).to eq('https://www.facebook.com/reel/123456')
|
||||
end
|
||||
end
|
||||
|
||||
context 'when lock to single conversation' do
|
||||
subject(:mocked_message_builder) do
|
||||
described_class.new(mocked_incoming_fb_text_message, facebook_channel.inbox).perform
|
||||
|
||||
@@ -16,7 +16,9 @@ describe V2::ReportBuilder do
|
||||
create(:inbox_member, user: user, inbox: inbox)
|
||||
|
||||
gravatar_url = 'https://www.gravatar.com'
|
||||
favicon_url = 'https://www.google.com/s2/favicons'
|
||||
stub_request(:get, /#{gravatar_url}.*/).to_return(status: 404)
|
||||
stub_request(:get, /#{Regexp.escape(favicon_url)}.*/).to_return(status: 404)
|
||||
|
||||
perform_enqueued_jobs do
|
||||
10.times do
|
||||
|
||||
@@ -18,6 +18,11 @@ RSpec.describe V2::Reports::LabelSummaryBuilder do
|
||||
end
|
||||
let(:builder) { described_class.new(account: account, params: params) }
|
||||
|
||||
def stub_avatar_requests
|
||||
stub_request(:get, %r{\Ahttps://www\.gravatar\.com.*}).to_return(status: 404)
|
||||
stub_request(:get, %r{\Ahttps://www\.google\.com/s2/favicons.*}).to_return(status: 404)
|
||||
end
|
||||
|
||||
describe '#initialize' do
|
||||
let(:business_hours) { false }
|
||||
|
||||
@@ -85,8 +90,7 @@ RSpec.describe V2::Reports::LabelSummaryBuilder do
|
||||
inbox = create(:inbox, account: account)
|
||||
create(:inbox_member, user: user, inbox: inbox)
|
||||
|
||||
gravatar_url = 'https://www.gravatar.com'
|
||||
stub_request(:get, /#{gravatar_url}.*/).to_return(status: 404)
|
||||
stub_avatar_requests
|
||||
|
||||
perform_enqueued_jobs do
|
||||
# Create conversations with label_1
|
||||
@@ -223,8 +227,7 @@ RSpec.describe V2::Reports::LabelSummaryBuilder do
|
||||
inbox = create(:inbox, account: account)
|
||||
create(:inbox_member, user: user, inbox: inbox)
|
||||
|
||||
gravatar_url = 'https://www.gravatar.com'
|
||||
stub_request(:get, /#{gravatar_url}.*/).to_return(status: 404)
|
||||
stub_avatar_requests
|
||||
|
||||
perform_enqueued_jobs do
|
||||
# Conversation within range
|
||||
@@ -281,8 +284,7 @@ RSpec.describe V2::Reports::LabelSummaryBuilder do
|
||||
inbox = create(:inbox, account: account)
|
||||
create(:inbox_member, user: user, inbox: inbox)
|
||||
|
||||
gravatar_url = 'https://www.gravatar.com'
|
||||
stub_request(:get, /#{gravatar_url}.*/).to_return(status: 404)
|
||||
stub_avatar_requests
|
||||
|
||||
perform_enqueued_jobs do
|
||||
conversation = create(:conversation, account: account,
|
||||
@@ -338,8 +340,7 @@ RSpec.describe V2::Reports::LabelSummaryBuilder do
|
||||
inbox = create(:inbox, account: account2)
|
||||
create(:inbox_member, user: user, inbox: inbox)
|
||||
|
||||
gravatar_url = 'https://www.gravatar.com'
|
||||
stub_request(:get, /#{gravatar_url}.*/).to_return(status: 404)
|
||||
stub_avatar_requests
|
||||
|
||||
perform_enqueued_jobs do
|
||||
conversation = create(:conversation, account: account2,
|
||||
@@ -349,13 +350,8 @@ RSpec.describe V2::Reports::LabelSummaryBuilder do
|
||||
conversation.label_list
|
||||
conversation.save!
|
||||
|
||||
# First resolution
|
||||
conversation.resolved!
|
||||
|
||||
# Reopen conversation
|
||||
conversation.open!
|
||||
|
||||
# Second resolution
|
||||
conversation.resolved!
|
||||
end
|
||||
end
|
||||
|
||||
@@ -647,6 +647,37 @@ RSpec.describe 'Conversations API', type: :request do
|
||||
.with(Conversation::CONVERSATION_TYPING_ON, kind_of(Time), { conversation: conversation, user: agent, is_private: true })
|
||||
end
|
||||
end
|
||||
|
||||
context 'when it is an authenticated bot' do
|
||||
let(:agent_bot) { create(:agent_bot, account: account) }
|
||||
|
||||
it 'toggles the conversation typing status' do
|
||||
create(:agent_bot_inbox, inbox: conversation.inbox, agent_bot: agent_bot)
|
||||
allow(Rails.configuration.dispatcher).to receive(:dispatch)
|
||||
|
||||
post "/api/v1/accounts/#{account.id}/conversations/#{conversation.display_id}/toggle_typing_status",
|
||||
headers: { api_access_token: agent_bot.access_token.token },
|
||||
params: { typing_status: 'on', is_private: false },
|
||||
as: :json
|
||||
|
||||
expect(response).to have_http_status(:success)
|
||||
expect(Rails.configuration.dispatcher).to have_received(:dispatch)
|
||||
.with(Conversation::CONVERSATION_TYPING_ON, kind_of(Time), { conversation: conversation, user: agent_bot, is_private: false })
|
||||
end
|
||||
end
|
||||
|
||||
context 'when it is an authenticated platform app token' do
|
||||
let(:platform_app) { create(:platform_app) }
|
||||
|
||||
it 'returns unauthorized' do
|
||||
post "/api/v1/accounts/#{account.id}/conversations/#{conversation.display_id}/toggle_typing_status",
|
||||
headers: { api_access_token: platform_app.access_token.token },
|
||||
params: { typing_status: 'on', is_private: false },
|
||||
as: :json
|
||||
|
||||
expect(response).to have_http_status(:unauthorized)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
describe 'POST /api/v1/accounts/{account.id}/conversations/:id/update_last_seen' do
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
require 'rails_helper'
|
||||
|
||||
RSpec.describe Avatar::AvatarFromFaviconJob do
|
||||
let(:company) { create(:company, domain: 'wikipedia.org') }
|
||||
let(:favicon_url) { 'https://www.google.com/s2/favicons?domain=wikipedia.org&sz=256' }
|
||||
|
||||
it 'calls AvatarFromUrlJob with Google Favicon URL' do
|
||||
expect(Avatar::AvatarFromUrlJob).to receive(:perform_now).with(company, favicon_url)
|
||||
described_class.perform_now(company)
|
||||
end
|
||||
|
||||
it 'does not call AvatarFromUrlJob when domain is blank' do
|
||||
company.update(domain: '')
|
||||
expect(Avatar::AvatarFromUrlJob).not_to receive(:perform_now)
|
||||
described_class.perform_now(company)
|
||||
end
|
||||
|
||||
it 'does not call AvatarFromUrlJob when avatar is already attached' do
|
||||
company.avatar.attach(
|
||||
io: Rails.root.join('spec/assets/avatar.png').open,
|
||||
filename: 'avatar.png',
|
||||
content_type: 'image/png'
|
||||
)
|
||||
expect(Avatar::AvatarFromUrlJob).not_to receive(:perform_now)
|
||||
described_class.perform_now(company)
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,25 @@
|
||||
require 'rails_helper'
|
||||
|
||||
RSpec.describe Companies::FetchAvatarsJob do
|
||||
let(:account) { create(:account) }
|
||||
let!(:company_with_avatar) { create(:company, account: account, domain: 'example.com') }
|
||||
let!(:company_without_avatar) { create(:company, account: account, domain: 'wikipedia.org') }
|
||||
let!(:company_no_domain) { create(:company, account: account, domain: nil) }
|
||||
|
||||
before do
|
||||
# Attach avatar to first company
|
||||
company_with_avatar.avatar.attach(
|
||||
io: Rails.root.join('spec/assets/avatar.png').open,
|
||||
filename: 'avatar.png',
|
||||
content_type: 'image/png'
|
||||
)
|
||||
end
|
||||
|
||||
it 'queues Avatar::AvatarFromFaviconJob only for companies without avatars' do
|
||||
expect(Avatar::AvatarFromFaviconJob).to receive(:perform_later).with(company_without_avatar).once
|
||||
expect(Avatar::AvatarFromFaviconJob).not_to receive(:perform_later).with(company_with_avatar)
|
||||
expect(Avatar::AvatarFromFaviconJob).not_to receive(:perform_later).with(company_no_domain)
|
||||
|
||||
described_class.perform_now(account.id)
|
||||
end
|
||||
end
|
||||
@@ -6,9 +6,14 @@ RSpec.describe Conversation, type: :model do
|
||||
end
|
||||
|
||||
describe 'SLA policy updates' do
|
||||
let!(:conversation) { create(:conversation) }
|
||||
let(:conversation) { create(:conversation) }
|
||||
let!(:sla_policy) { create(:sla_policy, account: conversation.account) }
|
||||
|
||||
before do
|
||||
stub_request(:get, %r{\Ahttps://www\.gravatar\.com.*}).to_return(status: 404)
|
||||
stub_request(:get, %r{\Ahttps://www\.google\.com/s2/favicons.*}).to_return(status: 404)
|
||||
end
|
||||
|
||||
it 'generates an activity message when the SLA policy is updated' do
|
||||
conversation.update!(sla_policy_id: sla_policy.id)
|
||||
|
||||
|
||||
@@ -94,6 +94,26 @@ describe ActionCableListener do
|
||||
end
|
||||
end
|
||||
|
||||
describe '#typing_on with agent bot' do
|
||||
let(:event_name) { :'conversation.typing_on' }
|
||||
let!(:agent_bot) { create(:agent_bot, account: account) }
|
||||
let!(:event) { Events::Base.new(event_name, Time.zone.now, conversation: conversation, user: agent_bot, is_private: false) }
|
||||
|
||||
it 'sends message to account admins, inbox agents and the contact' do
|
||||
expect(conversation.inbox.reload.inbox_members.count).to eq(1)
|
||||
expect(ActionCableBroadcastJob).to receive(:perform_later).with(
|
||||
a_collection_containing_exactly(
|
||||
admin.pubsub_token, agent.pubsub_token, conversation.contact_inbox.pubsub_token
|
||||
),
|
||||
'conversation.typing_on', { conversation: conversation.push_event_data,
|
||||
user: agent_bot.push_event_data,
|
||||
account_id: account.id,
|
||||
is_private: false }
|
||||
)
|
||||
listener.conversation_typing_on(event)
|
||||
end
|
||||
end
|
||||
|
||||
describe '#typing_off' do
|
||||
let(:event_name) { :'conversation.typing_off' }
|
||||
let!(:event) { Events::Base.new(event_name, Time.zone.now, conversation: conversation, user: agent, is_private: false) }
|
||||
|
||||
@@ -155,6 +155,30 @@ RSpec.describe Attachment do
|
||||
end
|
||||
end
|
||||
|
||||
describe 'push_event_data for ig_reel attachments' do
|
||||
it 'returns external_url as data_url when no file is attached' do
|
||||
attachment = message.attachments.create!(
|
||||
account_id: message.account_id,
|
||||
file_type: :ig_reel,
|
||||
external_url: 'https://www.facebook.com/reel/123456'
|
||||
)
|
||||
|
||||
event_data = attachment.push_event_data
|
||||
expect(event_data[:data_url]).to eq('https://www.facebook.com/reel/123456')
|
||||
expect(event_data[:thumb_url]).to eq('')
|
||||
end
|
||||
|
||||
it 'returns file_url as data_url when file is attached' do
|
||||
attachment = message.attachments.new(account_id: message.account_id, file_type: :ig_reel,
|
||||
external_url: 'https://www.instagram.com/reel/123')
|
||||
attachment.file.attach(io: Rails.root.join('spec/assets/avatar.png').open, filename: 'avatar.png', content_type: 'image/png')
|
||||
attachment.save!
|
||||
|
||||
event_data = attachment.push_event_data
|
||||
expect(event_data[:data_url]).to be_present
|
||||
end
|
||||
end
|
||||
|
||||
describe 'push_event_data for embed attachments' do
|
||||
it 'returns external url as data_url' do
|
||||
attachment = message.attachments.create!(account_id: message.account_id, file_type: :embed, external_url: 'https://example.com/embed')
|
||||
|
||||
@@ -20,7 +20,7 @@ RSpec.describe Account::SignUpEmailValidationService, type: :service do
|
||||
it 'raises InvalidEmail with invalid message' do
|
||||
allow(ValidEmail2::Address).to receive(:new).with(email).and_return(invalid_email_address)
|
||||
expect { service.perform }.to raise_error do |error|
|
||||
expect(error).to be_a(CustomExceptions::Account::InvalidEmail)
|
||||
expect(error.class.name).to eq('CustomExceptions::Account::InvalidEmail')
|
||||
expect(error.message).to eq(I18n.t('errors.signup.invalid_email'))
|
||||
end
|
||||
end
|
||||
@@ -32,7 +32,7 @@ RSpec.describe Account::SignUpEmailValidationService, type: :service do
|
||||
it 'raises InvalidEmail with blocked domain message' do
|
||||
allow(ValidEmail2::Address).to receive(:new).with(email).and_return(valid_email_address)
|
||||
expect { service.perform }.to raise_error do |error|
|
||||
expect(error).to be_a(CustomExceptions::Account::InvalidEmail)
|
||||
expect(error.class.name).to eq('CustomExceptions::Account::InvalidEmail')
|
||||
expect(error.message).to eq(I18n.t('errors.signup.blocked_domain'))
|
||||
end
|
||||
end
|
||||
@@ -44,7 +44,7 @@ RSpec.describe Account::SignUpEmailValidationService, type: :service do
|
||||
it 'raises InvalidEmail with blocked domain message' do
|
||||
allow(ValidEmail2::Address).to receive(:new).with(email).and_return(valid_email_address)
|
||||
expect { service.perform }.to raise_error do |error|
|
||||
expect(error).to be_a(CustomExceptions::Account::InvalidEmail)
|
||||
expect(error.class.name).to eq('CustomExceptions::Account::InvalidEmail')
|
||||
expect(error.message).to eq(I18n.t('errors.signup.blocked_domain'))
|
||||
end
|
||||
end
|
||||
@@ -56,7 +56,7 @@ RSpec.describe Account::SignUpEmailValidationService, type: :service do
|
||||
it 'raises InvalidEmail with disposable message' do
|
||||
allow(ValidEmail2::Address).to receive(:new).with(email).and_return(disposable_email_address)
|
||||
expect { service.perform }.to raise_error do |error|
|
||||
expect(error).to be_a(CustomExceptions::Account::InvalidEmail)
|
||||
expect(error.class.name).to eq('CustomExceptions::Account::InvalidEmail')
|
||||
expect(error.message).to eq(I18n.t('errors.signup.disposable_email'))
|
||||
end
|
||||
end
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
tags:
|
||||
- Conversations
|
||||
operationId: toggle-typing-status-of-a-conversation
|
||||
summary: Toggle Typing Status
|
||||
description: Toggles the typing status for a conversation.
|
||||
security:
|
||||
- userApiKey: []
|
||||
- agentBotApiKey: []
|
||||
requestBody:
|
||||
required: true
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
type: object
|
||||
required:
|
||||
- typing_status
|
||||
properties:
|
||||
typing_status:
|
||||
type: string
|
||||
enum: ['on', 'off']
|
||||
description: Typing status to set.
|
||||
example: 'on'
|
||||
is_private:
|
||||
type: boolean
|
||||
description: Whether the typing event is for private notes.
|
||||
example: false
|
||||
responses:
|
||||
'200':
|
||||
description: Success
|
||||
'401':
|
||||
description: Unauthorized
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
$ref: '#/components/schemas/bad_request_error'
|
||||
'404':
|
||||
description: Conversation not found
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
$ref: '#/components/schemas/bad_request_error'
|
||||
@@ -367,6 +367,12 @@
|
||||
- $ref: '#/components/parameters/conversation_id'
|
||||
post:
|
||||
$ref: ./application/conversation/toggle_priority.yml
|
||||
/api/v1/accounts/{account_id}/conversations/{conversation_id}/toggle_typing_status:
|
||||
parameters:
|
||||
- $ref: '#/components/parameters/account_id'
|
||||
- $ref: '#/components/parameters/conversation_id'
|
||||
post:
|
||||
$ref: ./application/conversation/toggle_typing_status.yml
|
||||
|
||||
/api/v1/accounts/{account_id}/conversations/{conversation_id}/custom_attributes:
|
||||
parameters:
|
||||
|
||||
@@ -4938,6 +4938,86 @@
|
||||
}
|
||||
}
|
||||
},
|
||||
"/api/v1/accounts/{account_id}/conversations/{conversation_id}/toggle_typing_status": {
|
||||
"parameters": [
|
||||
{
|
||||
"$ref": "#/components/parameters/account_id"
|
||||
},
|
||||
{
|
||||
"$ref": "#/components/parameters/conversation_id"
|
||||
}
|
||||
],
|
||||
"post": {
|
||||
"tags": [
|
||||
"Conversations"
|
||||
],
|
||||
"operationId": "toggle-typing-status-of-a-conversation",
|
||||
"summary": "Toggle Typing Status",
|
||||
"description": "Toggles the typing status for a conversation.",
|
||||
"security": [
|
||||
{
|
||||
"userApiKey": []
|
||||
},
|
||||
{
|
||||
"agentBotApiKey": []
|
||||
}
|
||||
],
|
||||
"requestBody": {
|
||||
"required": true,
|
||||
"content": {
|
||||
"application/json": {
|
||||
"schema": {
|
||||
"type": "object",
|
||||
"required": [
|
||||
"typing_status"
|
||||
],
|
||||
"properties": {
|
||||
"typing_status": {
|
||||
"type": "string",
|
||||
"enum": [
|
||||
"on",
|
||||
"off"
|
||||
],
|
||||
"description": "Typing status to set.",
|
||||
"example": "on"
|
||||
},
|
||||
"is_private": {
|
||||
"type": "boolean",
|
||||
"description": "Whether the typing event is for private notes.",
|
||||
"example": false
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"responses": {
|
||||
"200": {
|
||||
"description": "Success"
|
||||
},
|
||||
"401": {
|
||||
"description": "Unauthorized",
|
||||
"content": {
|
||||
"application/json": {
|
||||
"schema": {
|
||||
"$ref": "#/components/schemas/bad_request_error"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"404": {
|
||||
"description": "Conversation not found",
|
||||
"content": {
|
||||
"application/json": {
|
||||
"schema": {
|
||||
"$ref": "#/components/schemas/bad_request_error"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"/api/v1/accounts/{account_id}/conversations/{conversation_id}/custom_attributes": {
|
||||
"parameters": [
|
||||
{
|
||||
|
||||
@@ -3481,6 +3481,86 @@
|
||||
}
|
||||
}
|
||||
},
|
||||
"/api/v1/accounts/{account_id}/conversations/{conversation_id}/toggle_typing_status": {
|
||||
"parameters": [
|
||||
{
|
||||
"$ref": "#/components/parameters/account_id"
|
||||
},
|
||||
{
|
||||
"$ref": "#/components/parameters/conversation_id"
|
||||
}
|
||||
],
|
||||
"post": {
|
||||
"tags": [
|
||||
"Conversations"
|
||||
],
|
||||
"operationId": "toggle-typing-status-of-a-conversation",
|
||||
"summary": "Toggle Typing Status",
|
||||
"description": "Toggles the typing status for a conversation.",
|
||||
"security": [
|
||||
{
|
||||
"userApiKey": []
|
||||
},
|
||||
{
|
||||
"agentBotApiKey": []
|
||||
}
|
||||
],
|
||||
"requestBody": {
|
||||
"required": true,
|
||||
"content": {
|
||||
"application/json": {
|
||||
"schema": {
|
||||
"type": "object",
|
||||
"required": [
|
||||
"typing_status"
|
||||
],
|
||||
"properties": {
|
||||
"typing_status": {
|
||||
"type": "string",
|
||||
"enum": [
|
||||
"on",
|
||||
"off"
|
||||
],
|
||||
"description": "Typing status to set.",
|
||||
"example": "on"
|
||||
},
|
||||
"is_private": {
|
||||
"type": "boolean",
|
||||
"description": "Whether the typing event is for private notes.",
|
||||
"example": false
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"responses": {
|
||||
"200": {
|
||||
"description": "Success"
|
||||
},
|
||||
"401": {
|
||||
"description": "Unauthorized",
|
||||
"content": {
|
||||
"application/json": {
|
||||
"schema": {
|
||||
"$ref": "#/components/schemas/bad_request_error"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"404": {
|
||||
"description": "Conversation not found",
|
||||
"content": {
|
||||
"application/json": {
|
||||
"schema": {
|
||||
"$ref": "#/components/schemas/bad_request_error"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"/api/v1/accounts/{account_id}/conversations/{conversation_id}/custom_attributes": {
|
||||
"parameters": [
|
||||
{
|
||||
|
||||
Reference in New Issue
Block a user