84 lines
2.9 KiB
TypeScript
84 lines
2.9 KiB
TypeScript
import type { ComposeContext } from "./api";
|
|
|
|
/** Promesse autour des API asynchrones Office (callback AsyncResult). */
|
|
export function officeAsync<T>(call: (cb: (r: Office.AsyncResult<T>) => void) => void): Promise<T> {
|
|
return new Promise((resolve, reject) => {
|
|
call((r) => (r.status === Office.AsyncResultStatus.Succeeded ? resolve(r.value) : reject(r.error)));
|
|
});
|
|
}
|
|
|
|
type ComposeItem = Office.MessageCompose | Office.AppointmentCompose;
|
|
|
|
export function currentItem(): ComposeItem {
|
|
return Office.context.mailbox.item as ComposeItem;
|
|
}
|
|
|
|
export function isAppointment(item: ComposeItem): item is Office.AppointmentCompose {
|
|
return item.itemType === Office.MailboxEnums.ItemType.Appointment;
|
|
}
|
|
|
|
/** new / reply / forward pour un message, appointment pour une invitation. */
|
|
export async function getComposeContext(item: ComposeItem): Promise<ComposeContext> {
|
|
if (isAppointment(item)) return "appointment";
|
|
const msg = item as Office.MessageCompose;
|
|
if (typeof msg.getComposeTypeAsync !== "function") return "new";
|
|
try {
|
|
const v = await officeAsync<{ composeType: string }>((cb) => msg.getComposeTypeAsync(cb));
|
|
switch (v.composeType) {
|
|
case Office.MailboxEnums.ComposeType.Reply:
|
|
return "reply";
|
|
case Office.MailboxEnums.ComposeType.Forward:
|
|
return "forward";
|
|
default:
|
|
return "new";
|
|
}
|
|
} catch {
|
|
return "new";
|
|
}
|
|
}
|
|
|
|
/** Adresse de la boîte émettrice (boîte partagée si l'agent a changé le champ De). */
|
|
export async function getMailbox(item: ComposeItem): Promise<string | null> {
|
|
try {
|
|
if (isAppointment(item)) {
|
|
const o = await officeAsync<Office.EmailAddressDetails>((cb) => item.organizer.getAsync(cb));
|
|
return o?.emailAddress?.toLowerCase() ?? null;
|
|
}
|
|
const f = await officeAsync<Office.EmailAddressDetails>((cb) => (item as Office.MessageCompose).from.getAsync(cb));
|
|
return f?.emailAddress?.toLowerCase() ?? null;
|
|
} catch {
|
|
return Office.context.mailbox.userProfile?.emailAddress?.toLowerCase() ?? null;
|
|
}
|
|
}
|
|
|
|
export async function applySignature(item: ComposeItem, html: string): Promise<void> {
|
|
await officeAsync<void>((cb) => item.body.setSignatureAsync(html, { coercionType: Office.CoercionType.Html }, cb));
|
|
// Neutralise la signature native d'Outlook (sinon doublon). Ignoré si non supporté.
|
|
if (typeof item.disableClientSignatureAsync === "function") {
|
|
try {
|
|
await officeAsync<void>((cb) => item.disableClientSignatureAsync(cb));
|
|
} catch {
|
|
/* non bloquant */
|
|
}
|
|
}
|
|
}
|
|
|
|
export function notify(item: ComposeItem, message: string): Promise<void> {
|
|
return new Promise((resolve) => {
|
|
try {
|
|
item.notificationMessages.replaceAsync(
|
|
"cabm_signature",
|
|
{
|
|
type: Office.MailboxEnums.ItemNotificationMessageType.InformationalMessage,
|
|
message,
|
|
icon: "Icon.16x16",
|
|
persistent: false,
|
|
},
|
|
() => resolve(),
|
|
);
|
|
} catch {
|
|
resolve();
|
|
}
|
|
});
|
|
}
|