Refresh HiveGrid Cloud reference snapshot
This commit is contained in:
1 parent
5e99e14772
commit
7f88026f79
5955 files changed
+1177325
-188362
No files matched your search
+660
@@ -0,0 +1,660 @@
|
||||
import type {
|
||||
AdminEmailOutboundPolicy,
|
||||
Prisma,
|
||||
PrismaClient,
|
||||
} from "../generated/prisma/client/client.js";
|
||||
import { writeAdminSalesAudit } from "./admin-sales-core.server.js";
|
||||
|
||||
const CLAIM_TIMEOUT_MS = 15 * 60 * 1_000;
|
||||
const SENT_LOOKBACK_MS = 48 * 60 * 60 * 1_000;
|
||||
|
||||
export type ClaimedAdminEmail = {
|
||||
readonly id: string;
|
||||
readonly adminUserId: string;
|
||||
readonly connectionId: string;
|
||||
readonly provider: "google_mail" | "microsoft_mail";
|
||||
readonly mailboxId: string;
|
||||
readonly fromAddress: string;
|
||||
readonly fromName: string | null;
|
||||
readonly contactId: string | null;
|
||||
readonly leadId: string | null;
|
||||
readonly dealId: string | null;
|
||||
readonly threadId: string | null;
|
||||
readonly bulkRunId: string | null;
|
||||
readonly providerThreadId: string | null;
|
||||
readonly toAddresses: readonly string[];
|
||||
readonly ccAddresses: readonly string[];
|
||||
readonly bccAddresses: readonly string[];
|
||||
readonly subject: string;
|
||||
readonly bodyHtml: string;
|
||||
readonly bodyText: string | null;
|
||||
readonly idempotencyKey: string;
|
||||
readonly noReplyAfterDays: number | null;
|
||||
readonly trackingEnabled: boolean;
|
||||
readonly liveOpenEnabled: boolean;
|
||||
readonly trackingRetentionDays: number;
|
||||
};
|
||||
|
||||
export type AdminEmailDeliveryResult = {
|
||||
readonly inspected: number;
|
||||
readonly claimed: readonly ClaimedAdminEmail[];
|
||||
readonly blocked: number;
|
||||
readonly deferred: number;
|
||||
readonly recoveredUnknown: number;
|
||||
};
|
||||
|
||||
export async function claimDueAdminEmails(
|
||||
client: PrismaClient,
|
||||
input: {
|
||||
readonly now?: Date;
|
||||
readonly take?: number;
|
||||
readonly claimTimeoutMs?: number;
|
||||
} = {}
|
||||
): Promise<AdminEmailDeliveryResult> {
|
||||
const now = input.now ?? new Date();
|
||||
const take = Math.max(1, Math.min(input.take ?? 50, 250));
|
||||
return client.$transaction(async (tx) => {
|
||||
const recovered = await tx.adminScheduledEmail.updateMany({
|
||||
where: {
|
||||
status: "sending",
|
||||
claimedAt: {
|
||||
lte: new Date(
|
||||
now.getTime() - (input.claimTimeoutMs ?? CLAIM_TIMEOUT_MS)
|
||||
),
|
||||
},
|
||||
},
|
||||
data: {
|
||||
status: "failed",
|
||||
lastErrorMessageKey: "admin.sales.email.delivery.errors.providerOutcomeUnknown",
|
||||
},
|
||||
});
|
||||
const candidates = await tx.adminScheduledEmail.findMany({
|
||||
where: { status: "queued", scheduledFor: { lte: now } },
|
||||
orderBy: [{ scheduledFor: "asc" }, { id: "asc" }],
|
||||
take,
|
||||
include: {
|
||||
mailbox: {
|
||||
select: {
|
||||
emailAddress: true,
|
||||
displayName: true,
|
||||
status: true,
|
||||
archivedAt: true,
|
||||
connection: {
|
||||
select: {
|
||||
id: true,
|
||||
provider: true,
|
||||
status: true,
|
||||
archivedAt: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
thread: { select: { providerThreadId: true } },
|
||||
},
|
||||
});
|
||||
const recentSent = await tx.adminScheduledEmail.findMany({
|
||||
where: {
|
||||
status: "sent",
|
||||
sentAt: { gte: new Date(now.getTime() - SENT_LOOKBACK_MS) },
|
||||
},
|
||||
select: { adminUserId: true, sentAt: true },
|
||||
});
|
||||
const policyByOwner = new Map<string, AdminEmailOutboundPolicy | null>();
|
||||
const claimed: ClaimedAdminEmail[] = [];
|
||||
let blocked = 0;
|
||||
let deferred = 0;
|
||||
|
||||
for (const candidate of candidates) {
|
||||
let policy = policyByOwner.get(candidate.adminUserId);
|
||||
if (policy === undefined) {
|
||||
policy = await tx.adminEmailOutboundPolicy.findUnique({
|
||||
where: { adminUserId: candidate.adminUserId },
|
||||
});
|
||||
policyByOwner.set(candidate.adminUserId, policy);
|
||||
}
|
||||
if (
|
||||
!isConfiguredPolicy(policy) ||
|
||||
candidate.mailbox.status !== "active" ||
|
||||
candidate.mailbox.archivedAt ||
|
||||
candidate.mailbox.connection.status !== "active" ||
|
||||
candidate.mailbox.connection.archivedAt ||
|
||||
!isMailProvider(candidate.mailbox.connection.provider)
|
||||
) {
|
||||
await tx.adminScheduledEmail.updateMany({
|
||||
where: { id: candidate.id, status: "queued" },
|
||||
data: {
|
||||
status: "blocked",
|
||||
lastErrorMessageKey: "admin.sales.email.delivery.errors.outboundLocked",
|
||||
},
|
||||
});
|
||||
blocked += 1;
|
||||
continue;
|
||||
}
|
||||
if (!isInsideAdminEmailWorkWindow(policy, now)) {
|
||||
deferred += 1;
|
||||
continue;
|
||||
}
|
||||
const localDay = localDateKey(now, policy.timeZone);
|
||||
const sentToday =
|
||||
recentSent.filter(
|
||||
(row) =>
|
||||
row.adminUserId === candidate.adminUserId &&
|
||||
row.sentAt &&
|
||||
localDateKey(row.sentAt, policy.timeZone) === localDay
|
||||
).length +
|
||||
claimed.filter((row) => row.adminUserId === candidate.adminUserId)
|
||||
.length;
|
||||
if (sentToday >= policy.dailySendLimit) {
|
||||
await tx.adminScheduledEmail.updateMany({
|
||||
where: { id: candidate.id, status: "queued" },
|
||||
data: { lastErrorMessageKey: "admin.sales.email.delivery.errors.dailySendLimitReached" },
|
||||
});
|
||||
deferred += 1;
|
||||
continue;
|
||||
}
|
||||
const claim = await tx.adminScheduledEmail.updateMany({
|
||||
where: { id: candidate.id, status: "queued" },
|
||||
data: {
|
||||
status: "sending",
|
||||
claimedAt: now,
|
||||
sendAttemptCount: { increment: 1 },
|
||||
lastErrorMessageKey: null,
|
||||
},
|
||||
});
|
||||
if (claim.count !== 1) continue;
|
||||
if (candidate.bulkRunId) {
|
||||
await tx.adminBulkEmailRun.updateMany({
|
||||
where: { id: candidate.bulkRunId, status: "queued" },
|
||||
data: { status: "running" },
|
||||
});
|
||||
}
|
||||
claimed.push({
|
||||
id: candidate.id,
|
||||
adminUserId: candidate.adminUserId,
|
||||
connectionId: candidate.mailbox.connection.id,
|
||||
provider: candidate.mailbox.connection.provider,
|
||||
mailboxId: candidate.mailboxId,
|
||||
fromAddress: candidate.mailbox.emailAddress,
|
||||
fromName: candidate.mailbox.displayName,
|
||||
contactId: candidate.contactId,
|
||||
leadId: candidate.leadId,
|
||||
dealId: candidate.dealId,
|
||||
threadId: candidate.threadId,
|
||||
bulkRunId: candidate.bulkRunId,
|
||||
providerThreadId: candidate.thread?.providerThreadId ?? null,
|
||||
toAddresses: candidate.toAddresses,
|
||||
ccAddresses: candidate.ccAddresses,
|
||||
bccAddresses: candidate.bccAddresses,
|
||||
subject: candidate.subject,
|
||||
bodyHtml: candidate.bodyHtml,
|
||||
bodyText: candidate.bodyText,
|
||||
idempotencyKey: candidate.idempotencyKey,
|
||||
noReplyAfterDays: candidate.noReplyAfterDays,
|
||||
trackingEnabled: policy.trackingEnabled,
|
||||
liveOpenEnabled: policy.liveOpenEnabled,
|
||||
trackingRetentionDays: policy.trackingRetentionDays,
|
||||
});
|
||||
}
|
||||
return {
|
||||
inspected: candidates.length,
|
||||
claimed,
|
||||
blocked,
|
||||
deferred,
|
||||
recoveredUnknown: recovered.count,
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
export async function completeAdminEmailDelivery(
|
||||
client: PrismaClient,
|
||||
input: {
|
||||
readonly email: ClaimedAdminEmail;
|
||||
readonly providerMessageId: string | null;
|
||||
readonly providerThreadId?: string | null;
|
||||
readonly sentAt?: Date;
|
||||
readonly deliveredBodyHtml?: string;
|
||||
readonly trackingLinks?: readonly {
|
||||
readonly destinationUrl: string;
|
||||
readonly trackingTokenHash: string;
|
||||
}[];
|
||||
}
|
||||
): Promise<{ readonly messageId: string }> {
|
||||
const sentAt = input.sentAt ?? new Date();
|
||||
return client.$transaction(async (tx) => {
|
||||
const scheduled = await tx.adminScheduledEmail.findFirst({
|
||||
where: { id: input.email.id, status: "sending" },
|
||||
select: { id: true },
|
||||
});
|
||||
if (!scheduled) {
|
||||
throw new AdminEmailDeliveryError("delivery_not_claimed");
|
||||
}
|
||||
const thread = input.email.threadId
|
||||
? await tx.adminEmailThread.findFirst({
|
||||
where: {
|
||||
id: input.email.threadId,
|
||||
adminUserId: input.email.adminUserId,
|
||||
mailboxId: input.email.mailboxId,
|
||||
},
|
||||
})
|
||||
: null;
|
||||
const activeThread =
|
||||
thread ??
|
||||
(await tx.adminEmailThread.create({
|
||||
data: {
|
||||
adminUserId: input.email.adminUserId,
|
||||
mailboxId: input.email.mailboxId,
|
||||
providerThreadId:
|
||||
input.providerThreadId ?? `scheduled:${input.email.id}`,
|
||||
normalizedSubject: input.email.subject.trim().toLowerCase(),
|
||||
latestMessageAt: sentAt,
|
||||
messageCount: 0,
|
||||
},
|
||||
}));
|
||||
const providerMessageId =
|
||||
input.providerMessageId ?? `scheduled:${input.email.id}`;
|
||||
const message = await tx.adminEmailMessage.create({
|
||||
data: {
|
||||
adminUserId: input.email.adminUserId,
|
||||
mailboxId: input.email.mailboxId,
|
||||
threadId: activeThread.id,
|
||||
providerMessageId,
|
||||
direction: "outbound",
|
||||
fromAddress: input.email.fromAddress,
|
||||
subject: input.email.subject,
|
||||
snippet: input.email.bodyText?.slice(0, 500) ?? null,
|
||||
bodyHtml: input.deliveredBodyHtml ?? input.email.bodyHtml,
|
||||
bodyText: input.email.bodyText,
|
||||
sentAt,
|
||||
isRead: true,
|
||||
matchStatus: "manual",
|
||||
matchedContactId: input.email.contactId,
|
||||
matchedLeadId: input.email.leadId,
|
||||
matchedDealId: input.email.dealId,
|
||||
matchedAt: sentAt,
|
||||
matchedByAdminUserId: input.email.adminUserId,
|
||||
matchingReason: "admin_scheduled_send",
|
||||
participants: {
|
||||
create: [
|
||||
{
|
||||
adminUserId: input.email.adminUserId,
|
||||
kind: "from",
|
||||
emailAddress: input.email.fromAddress,
|
||||
displayName: input.email.fromName,
|
||||
},
|
||||
...input.email.toAddresses.map((emailAddress) => ({
|
||||
adminUserId: input.email.adminUserId,
|
||||
kind: "to",
|
||||
emailAddress,
|
||||
})),
|
||||
...input.email.ccAddresses.map((emailAddress) => ({
|
||||
adminUserId: input.email.adminUserId,
|
||||
kind: "cc",
|
||||
emailAddress,
|
||||
})),
|
||||
...input.email.bccAddresses.map((emailAddress) => ({
|
||||
adminUserId: input.email.adminUserId,
|
||||
kind: "bcc",
|
||||
emailAddress,
|
||||
})),
|
||||
],
|
||||
},
|
||||
events: {
|
||||
create: {
|
||||
adminUserId: input.email.adminUserId,
|
||||
type: "sent",
|
||||
providerEventId: `scheduled:${input.email.id}`,
|
||||
occurredAt: sentAt,
|
||||
},
|
||||
},
|
||||
...(input.trackingLinks?.length
|
||||
? {
|
||||
links: {
|
||||
create: input.trackingLinks.map((link) => ({
|
||||
adminUserId: input.email.adminUserId,
|
||||
destinationUrl: link.destinationUrl,
|
||||
trackingTokenHash: link.trackingTokenHash,
|
||||
})),
|
||||
},
|
||||
}
|
||||
: {}),
|
||||
},
|
||||
select: { id: true },
|
||||
});
|
||||
await tx.adminEmailThread.update({
|
||||
where: { id: activeThread.id },
|
||||
data: {
|
||||
latestMessageAt: sentAt,
|
||||
messageCount: { increment: 1 },
|
||||
},
|
||||
});
|
||||
await tx.adminActivity.create({
|
||||
data: {
|
||||
type: "email",
|
||||
actorAdminUserId: input.email.adminUserId,
|
||||
contactId: input.email.contactId,
|
||||
leadId: input.email.leadId,
|
||||
dealId: input.email.dealId,
|
||||
emailMessageId: message.id,
|
||||
occurredAt: sentAt,
|
||||
summary: `E-Mail gesendet: ${input.email.subject}`,
|
||||
payload: {
|
||||
scheduledEmailId: input.email.id,
|
||||
recipientCount: input.email.toAddresses.length,
|
||||
},
|
||||
},
|
||||
});
|
||||
await tx.adminScheduledEmail.update({
|
||||
where: { id: input.email.id },
|
||||
data: {
|
||||
status: "sent",
|
||||
sentAt,
|
||||
providerMessageId,
|
||||
sentMessageId: message.id,
|
||||
lastErrorMessageKey: null,
|
||||
},
|
||||
});
|
||||
if (input.email.noReplyAfterDays) {
|
||||
await tx.adminNoReplyReminder.upsert({
|
||||
where: {
|
||||
idempotencyKey: `admin-email-no-reply:${message.id}`,
|
||||
},
|
||||
create: {
|
||||
adminUserId: input.email.adminUserId,
|
||||
outboundMessageId: message.id,
|
||||
dueAt: new Date(
|
||||
sentAt.getTime() +
|
||||
input.email.noReplyAfterDays * 24 * 60 * 60 * 1_000
|
||||
),
|
||||
status: "pending",
|
||||
idempotencyKey: `admin-email-no-reply:${message.id}`,
|
||||
},
|
||||
update: {},
|
||||
});
|
||||
}
|
||||
if (input.email.bulkRunId) {
|
||||
await recordAdminBulkEmailOutcome(tx, input.email.bulkRunId, "sent");
|
||||
}
|
||||
await writeAdminSalesAudit(tx, {
|
||||
actor: {
|
||||
adminUserId: input.email.adminUserId,
|
||||
email: "system@worker.invalid",
|
||||
reason: "Zeitgesteuerte Admin-Sales-E-Mail zugestellt",
|
||||
},
|
||||
action: "admin.sales.email.send.completed",
|
||||
targetType: "AdminScheduledEmail",
|
||||
targetId: input.email.id,
|
||||
after: {
|
||||
messageId: message.id,
|
||||
providerMessageId,
|
||||
sentAt: sentAt.toISOString(),
|
||||
} as Prisma.InputJsonValue,
|
||||
});
|
||||
return { messageId: message.id };
|
||||
});
|
||||
}
|
||||
|
||||
export async function failAdminEmailDelivery(
|
||||
client: PrismaClient,
|
||||
input: {
|
||||
readonly id: string;
|
||||
readonly errorMessageKey:
|
||||
| "admin.sales.email.delivery.errors.providerSendFailed"
|
||||
| "admin.sales.email.delivery.errors.providerOutcomeUnknown";
|
||||
}
|
||||
): Promise<boolean> {
|
||||
return client.$transaction(async (tx) => {
|
||||
const scheduled = await tx.adminScheduledEmail.findFirst({
|
||||
where: { id: input.id, status: "sending" },
|
||||
select: { bulkRunId: true },
|
||||
});
|
||||
if (!scheduled) return false;
|
||||
const result = await tx.adminScheduledEmail.updateMany({
|
||||
where: { id: input.id, status: "sending" },
|
||||
data: {
|
||||
status: "failed",
|
||||
lastErrorMessageKey: input.errorMessageKey,
|
||||
},
|
||||
});
|
||||
if (result.count === 1 && scheduled.bulkRunId) {
|
||||
await recordAdminBulkEmailOutcome(tx, scheduled.bulkRunId, "failed");
|
||||
}
|
||||
return result.count === 1;
|
||||
});
|
||||
}
|
||||
|
||||
export async function fireDueAdminNoReplyReminders(
|
||||
client: PrismaClient,
|
||||
input: {
|
||||
readonly now?: Date;
|
||||
readonly take?: number;
|
||||
} = {}
|
||||
): Promise<{ readonly scanned: number; readonly created: number }> {
|
||||
const now = input.now ?? new Date();
|
||||
const take = Math.max(1, Math.min(input.take ?? 100, 500));
|
||||
const candidates = await client.adminNoReplyReminder.findMany({
|
||||
where: {
|
||||
status: "pending",
|
||||
dueAt: { lte: now },
|
||||
},
|
||||
orderBy: [{ dueAt: "asc" }, { id: "asc" }],
|
||||
take,
|
||||
select: { id: true },
|
||||
});
|
||||
let created = 0;
|
||||
|
||||
for (const candidate of candidates) {
|
||||
const didCreate = await client.$transaction(async (tx) => {
|
||||
const reminder = await tx.adminNoReplyReminder.findFirst({
|
||||
where: {
|
||||
id: candidate.id,
|
||||
status: "pending",
|
||||
dueAt: { lte: now },
|
||||
},
|
||||
select: {
|
||||
id: true,
|
||||
adminUserId: true,
|
||||
outboundMessageId: true,
|
||||
outboundMessage: {
|
||||
select: {
|
||||
matchedContactId: true,
|
||||
matchedLeadId: true,
|
||||
matchedDealId: true,
|
||||
subject: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
});
|
||||
if (!reminder) return false;
|
||||
const claim = await tx.adminNoReplyReminder.updateMany({
|
||||
where: { id: reminder.id, status: "pending" },
|
||||
data: { status: "fired" },
|
||||
});
|
||||
if (claim.count !== 1) return false;
|
||||
const policy = await tx.adminEmailOutboundPolicy.findUnique({
|
||||
where: { adminUserId: reminder.adminUserId },
|
||||
select: { timeZone: true },
|
||||
});
|
||||
const activity = await tx.adminActivity.create({
|
||||
data: {
|
||||
type: "task_created",
|
||||
actorAdminUserId: reminder.adminUserId,
|
||||
contactId: reminder.outboundMessage.matchedContactId,
|
||||
leadId: reminder.outboundMessage.matchedLeadId,
|
||||
dealId: reminder.outboundMessage.matchedDealId,
|
||||
emailMessageId: reminder.outboundMessageId,
|
||||
occurredAt: now,
|
||||
summary: "Nachfass-Aufgabe aus E-Mail-Erinnerung erstellt",
|
||||
payload: {
|
||||
noReplyReminderId: reminder.id,
|
||||
},
|
||||
},
|
||||
select: { id: true },
|
||||
});
|
||||
const task = await tx.adminTask.create({
|
||||
data: {
|
||||
title: reminder.outboundMessage.subject
|
||||
? `E-Mail nachfassen: ${reminder.outboundMessage.subject}`
|
||||
: "E-Mail nachfassen",
|
||||
contactId: reminder.outboundMessage.matchedContactId,
|
||||
dealId: reminder.outboundMessage.matchedDealId,
|
||||
assignedToAdminUserId: reminder.adminUserId,
|
||||
createdByAdminUserId: reminder.adminUserId,
|
||||
dueAt: now,
|
||||
timeZone: policy?.timeZone ?? "Europe/Berlin",
|
||||
reminderAt: now,
|
||||
priority: "normal",
|
||||
source: "email",
|
||||
sourceActivityId: activity.id,
|
||||
},
|
||||
select: { id: true },
|
||||
});
|
||||
await Promise.all([
|
||||
tx.adminActivity.update({
|
||||
where: { id: activity.id },
|
||||
data: { taskId: task.id },
|
||||
}),
|
||||
tx.adminNoReplyReminder.update({
|
||||
where: { id: reminder.id },
|
||||
data: { taskId: task.id },
|
||||
}),
|
||||
]);
|
||||
await writeAdminSalesAudit(tx, {
|
||||
actor: {
|
||||
adminUserId: reminder.adminUserId,
|
||||
email: "system@worker.invalid",
|
||||
reason: "Nachfass-Erinnerung nach ausbleibender E-Mail-Antwort",
|
||||
},
|
||||
action: "admin.sales.email.no_reply_reminder.fired",
|
||||
targetType: "AdminNoReplyReminder",
|
||||
targetId: reminder.id,
|
||||
after: {
|
||||
taskId: task.id,
|
||||
outboundMessageId: reminder.outboundMessageId,
|
||||
} as Prisma.InputJsonValue,
|
||||
});
|
||||
return true;
|
||||
});
|
||||
if (didCreate) created += 1;
|
||||
}
|
||||
|
||||
return { scanned: candidates.length, created };
|
||||
}
|
||||
|
||||
async function recordAdminBulkEmailOutcome(
|
||||
tx: Prisma.TransactionClient,
|
||||
bulkRunId: string,
|
||||
outcome: "sent" | "failed"
|
||||
) {
|
||||
const run = await tx.adminBulkEmailRun.update({
|
||||
where: { id: bulkRunId },
|
||||
data:
|
||||
outcome === "sent"
|
||||
? { sentCount: { increment: 1 } }
|
||||
: { failedCount: { increment: 1 } },
|
||||
select: {
|
||||
recipientCount: true,
|
||||
sentCount: true,
|
||||
failedCount: true,
|
||||
},
|
||||
});
|
||||
if (run.sentCount + run.failedCount >= run.recipientCount) {
|
||||
await tx.adminBulkEmailRun.update({
|
||||
where: { id: bulkRunId },
|
||||
data: {
|
||||
status: run.failedCount > 0 ? "failed" : "complete",
|
||||
lastErrorMessageKey:
|
||||
run.failedCount > 0 ? "admin.sales.email.delivery.errors.bulkRecipientFailed" : null,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
export function isInsideAdminEmailWorkWindow(
|
||||
policy: Pick<
|
||||
AdminEmailOutboundPolicy,
|
||||
| "timeZone"
|
||||
| "allowedWeekDays"
|
||||
| "workdayStartMinutes"
|
||||
| "workdayEndMinutes"
|
||||
>,
|
||||
now: Date
|
||||
): boolean {
|
||||
const parts = zonedParts(now, policy.timeZone);
|
||||
const minuteOfDay = parts.hour * 60 + parts.minute;
|
||||
return (
|
||||
policy.allowedWeekDays.includes(parts.weekDay) &&
|
||||
minuteOfDay >= policy.workdayStartMinutes &&
|
||||
minuteOfDay < policy.workdayEndMinutes
|
||||
);
|
||||
}
|
||||
|
||||
function isConfiguredPolicy(
|
||||
policy: AdminEmailOutboundPolicy | null
|
||||
): policy is AdminEmailOutboundPolicy {
|
||||
return Boolean(
|
||||
policy?.configuredAt &&
|
||||
policy.consentRulesConfigured &&
|
||||
policy.dailySendLimit > 0 &&
|
||||
policy.allowedWeekDays.length > 0 &&
|
||||
policy.workdayStartMinutes < policy.workdayEndMinutes
|
||||
);
|
||||
}
|
||||
|
||||
function localDateKey(date: Date, timeZone: string): string {
|
||||
const parts = zonedParts(date, timeZone);
|
||||
return `${parts.year}-${String(parts.month).padStart(2, "0")}-${String(
|
||||
parts.day
|
||||
).padStart(2, "0")}`;
|
||||
}
|
||||
|
||||
function zonedParts(date: Date, timeZone: string) {
|
||||
let values: Record<string, string>;
|
||||
try {
|
||||
values = Object.fromEntries(
|
||||
new Intl.DateTimeFormat("en-US", {
|
||||
timeZone,
|
||||
weekday: "short",
|
||||
year: "numeric",
|
||||
month: "2-digit",
|
||||
day: "2-digit",
|
||||
hour: "2-digit",
|
||||
minute: "2-digit",
|
||||
hourCycle: "h23",
|
||||
})
|
||||
.formatToParts(date)
|
||||
.map((part) => [part.type, part.value])
|
||||
);
|
||||
} catch {
|
||||
throw new AdminEmailDeliveryError("invalid_time_zone");
|
||||
}
|
||||
const weekDay = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"].indexOf(
|
||||
values.weekday ?? ""
|
||||
);
|
||||
if (weekDay < 0) {
|
||||
throw new AdminEmailDeliveryError("invalid_time_zone");
|
||||
}
|
||||
return {
|
||||
year: Number(values.year),
|
||||
month: Number(values.month),
|
||||
day: Number(values.day),
|
||||
hour: Number(values.hour),
|
||||
minute: Number(values.minute),
|
||||
weekDay,
|
||||
};
|
||||
}
|
||||
|
||||
function isMailProvider(
|
||||
value: string
|
||||
): value is "google_mail" | "microsoft_mail" {
|
||||
return value === "google_mail" || value === "microsoft_mail";
|
||||
}
|
||||
|
||||
export class AdminEmailDeliveryError extends Error {
|
||||
readonly code: string;
|
||||
|
||||
constructor(code: string) {
|
||||
super(code);
|
||||
this.name = "AdminEmailDeliveryError";
|
||||
this.code = code;
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user