127 lines
5.7 KiB
TypeScript
127 lines
5.7 KiB
TypeScript
import { getReminderTimeZone } from './reminderDate.js';
|
|
import { randomUUID } from 'node:crypto';
|
|
import { db } from '../db/client.js';
|
|
|
|
export type WeightReminder = {
|
|
bird_id: string;
|
|
workspace_id: number;
|
|
bird_name: string;
|
|
species: string;
|
|
photo_data_url: string | null;
|
|
photo_object_key: string | null;
|
|
workspace_name: string;
|
|
activity_at: string;
|
|
recipient: string;
|
|
};
|
|
|
|
// Use entry creation time: recorded_on is a date and cannot measure elapsed hours.
|
|
// Editing an existing entry does not reset the reminder clock.
|
|
export const listDueWeightReminders = async () => {
|
|
const result = await db.query<WeightReminder>(`
|
|
WITH activity AS (
|
|
SELECT birds.id AS bird_id, birds.workspace_id, birds.name AS bird_name,
|
|
workspaces.name AS workspace_name,
|
|
GREATEST(birds.created_at, COALESCE(MAX(weight_records.created_at), birds.created_at)) AS activity_at
|
|
FROM birds
|
|
JOIN workspaces ON workspaces.id = birds.workspace_id
|
|
LEFT JOIN weight_records ON weight_records.bird_id = birds.id
|
|
WHERE birds.memorialized_at IS NULL
|
|
GROUP BY birds.id, workspaces.name
|
|
), recipients AS (
|
|
SELECT DISTINCT workspace_id, LOWER(TRIM(users.email)) AS recipient
|
|
FROM workspace_members
|
|
JOIN users ON users.id = workspace_members.user_id
|
|
WHERE accepted_at IS NOT NULL
|
|
AND role IN ('owner', 'assistant', 'caregiver')
|
|
)
|
|
SELECT activity.bird_id, activity.workspace_id, activity.bird_name, activity.workspace_name,
|
|
activity.activity_at::text, recipients.recipient, birds.species, birds.photo_data_url, birds.photo_object_key
|
|
FROM activity
|
|
JOIN recipients USING (workspace_id)
|
|
JOIN birds ON birds.id = activity.bird_id
|
|
WHERE activity_at <= CURRENT_TIMESTAMP - INTERVAL '48 hours'
|
|
AND recipients.recipient <> ''
|
|
AND NOT EXISTS (
|
|
SELECT 1 FROM weight_reminder_deliveries d
|
|
WHERE d.bird_id = activity.bird_id AND d.workspace_id = activity.workspace_id
|
|
AND d.activity_at = activity.activity_at AND d.recipient = recipients.recipient
|
|
AND ((d.delivered_at AT TIME ZONE $1)::date >= (CURRENT_TIMESTAMP AT TIME ZONE $1)::date
|
|
OR (d.delivered_at IS NULL AND d.claimed_at > CURRENT_TIMESTAMP - INTERVAL '15 minutes'))
|
|
)
|
|
ORDER BY activity.workspace_id, activity.bird_id, recipients.recipient
|
|
`, [getReminderTimeZone()]);
|
|
return result.rows;
|
|
};
|
|
|
|
export const claimWeightReminder = async (reminder: WeightReminder, token: string) => {
|
|
const result = await db.query(`
|
|
INSERT INTO weight_reminder_deliveries (bird_id, workspace_id, activity_at, recipient, claim_token)
|
|
SELECT $1, $2, $3, $4, $5
|
|
WHERE EXISTS (
|
|
SELECT 1 FROM birds
|
|
WHERE id = $1 AND workspace_id = $2 AND memorialized_at IS NULL
|
|
AND GREATEST(created_at, COALESCE((SELECT MAX(created_at) FROM weight_records WHERE bird_id = $1), created_at)) = $3::timestamptz
|
|
)
|
|
ON CONFLICT (bird_id, workspace_id, activity_at, recipient) DO UPDATE
|
|
SET claim_token = EXCLUDED.claim_token, claimed_at = CURRENT_TIMESTAMP, delivered_at = NULL
|
|
WHERE (weight_reminder_deliveries.delivered_at AT TIME ZONE $6)::date < (CURRENT_TIMESTAMP AT TIME ZONE $6)::date
|
|
OR (weight_reminder_deliveries.delivered_at IS NULL
|
|
AND weight_reminder_deliveries.claimed_at <= CURRENT_TIMESTAMP - INTERVAL '15 minutes')
|
|
RETURNING bird_id
|
|
`, [reminder.bird_id, reminder.workspace_id, reminder.activity_at, reminder.recipient, token, getReminderTimeZone()]);
|
|
return Boolean(result.rowCount);
|
|
};
|
|
|
|
export const finishWeightReminder = async (token: string, delivered: boolean) => {
|
|
if (delivered) {
|
|
await db.query('UPDATE weight_reminder_deliveries SET delivered_at = CURRENT_TIMESTAMP WHERE claim_token = $1', [token]);
|
|
} else {
|
|
await db.query('DELETE FROM weight_reminder_deliveries WHERE claim_token = $1 AND delivered_at IS NULL', [token]);
|
|
}
|
|
};
|
|
|
|
type Dependencies = {
|
|
list: typeof listDueWeightReminders;
|
|
claim: typeof claimWeightReminder;
|
|
finish: typeof finishWeightReminder;
|
|
};
|
|
|
|
export const runWeightReminders = async (
|
|
send: (reminders: WeightReminder[]) => Promise<boolean>,
|
|
dependencies: Dependencies = { list: listDueWeightReminders, claim: claimWeightReminder, finish: finishWeightReminder },
|
|
) => {
|
|
const reminders = await dependencies.list();
|
|
const result = { checked: reminders.length, sent: 0, skipped: 0, failed: 0 };
|
|
const groups = new Map<string, WeightReminder[]>();
|
|
for (const reminder of reminders) {
|
|
const key = JSON.stringify([reminder.workspace_id, reminder.recipient]);
|
|
groups.set(key, [...(groups.get(key) ?? []), reminder]);
|
|
}
|
|
for (const group of groups.values()) {
|
|
const claimed: { reminder: WeightReminder; token: string }[] = [];
|
|
let delivered = false;
|
|
try {
|
|
for (const reminder of group) {
|
|
const token = randomUUID();
|
|
if (await dependencies.claim(reminder, token)) claimed.push({ reminder, token });
|
|
else result.skipped += 1;
|
|
}
|
|
if (!claimed.length) continue;
|
|
delivered = await send(claimed.map(({ reminder }) => reminder));
|
|
for (const { token } of claimed) await dependencies.finish(token, delivered);
|
|
if (delivered) result.sent += 1;
|
|
else result.skipped += claimed.length;
|
|
} catch (error) {
|
|
result.failed += 1;
|
|
// Keep leases if SMTP accepted the email but saving delivery failed.
|
|
if (!delivered) {
|
|
for (const { token } of claimed) {
|
|
await dependencies.finish(token, false).catch((cleanupError) => console.error('Weight reminder claim cleanup failed', cleanupError));
|
|
}
|
|
}
|
|
console.error(`Weight reminder failed for flock ${group[0].workspace_id}`, error);
|
|
}
|
|
}
|
|
return result;
|
|
};
|