Relay transactional email through Salesforce instead of SMTP (#9)

Reviewed-on: #9
Co-authored-by: Patrick Müller <patrick@mueller-patrick.tech>
Co-committed-by: Patrick Müller <patrick@mueller-patrick.tech>

src/models/tickets/admin/redemptions.admin.router.ts

@@ -204,6 +204,55 @@ redemptionsAdminRouter.post('/:redemptionId/undo', async (req: Request, res: Res
 	}
 });
 
+/**
+ * @swagger
+ * /tickets/admin/redemptions/{redemptionId}/resend-confirmation:
+ *      post:
+ *          summary: Resend the redemption confirmation email
+ *          description: Rebuilds the confirmation email from the stored redemption data and sends it again, then records the outcome on the redemption. Intended for redemptions whose original confirmation email failed.
+ *          tags: [tickets-admin]
+ *          parameters:
+ *              - $ref: '#/components/parameters/SessionIdHeader'
+ *              - $ref: '#/components/parameters/SessionKeyHeader'
+ *              - in: path
+ *                name: redemptionId
+ *                required: true
+ *                schema:
+ *                    type: integer
+ *          responses:
+ *              200:
+ *                  description: The email was accepted for delivery
+ *              404:
+ *                  description: Unknown redemption
+ *              409:
+ *                  description: Redemption is not active
+ *              502:
+ *                  description: The email relay rejected the send
+ *              401:
+ *                  description: Unauthorized
+ */
+redemptionsAdminRouter.post('/:redemptionId/resend-confirmation', async (req: Request, res: Response) => {
+	try {
+		const result = await RedemptionsAdminService.resendRedemptionConfirmation(Number(req.params.redemptionId));
+		switch (result) {
+			case 'SENT':
+				res.status(200).send({status: 'OK'});
+				return;
+			case 'NOT_FOUND':
+				res.status(404).send({status: 'NOT_FOUND'});
+				return;
+			case 'NOT_ACTIVE':
+				res.status(409).send({status: 'NOT_ACTIVE', message: 'This redemption is not active.'});
+				return;
+			case 'FAILED':
+				res.status(502).send({status: 'SEND_FAILED', message: 'Die E-Mail konnte nicht versendet werden. Bitte später erneut versuchen.'});
+				return;
+		}
+	} catch (e: any) {
+		sendServerError(res, e);
+	}
+});
+
 /**
  * @swagger
  * /tickets/admin/vouchers/{code}/history:

src/models/tickets/admin/redemptions.admin.service.ts

@@ -1,5 +1,6 @@
 import {NachklangTicketsDB} from '../Tickets.db';
 import {getEventTicketState} from '../tickets.capacity';
+import {recordConfirmationEmailResult, sendRedemptionConfirmation} from '../tickets.confirmation-email';
 import {AuditLogEntry, RedemptionSummary} from '../tickets.interface';
 import {isValidEmail} from '../tickets.validation';
 
@@ -13,7 +14,8 @@ const mapRedemptionRow = (row: any, guests: string[]): RedemptionSummary => ({
 	contactAddress: row.contact_address,
 	guestCount: row.guest_count,
 	guests,
-	redeemedAt: row.redeemed_at
+	redeemedAt: row.redeemed_at,
+	confirmationEmailStatus: row.confirmation_email_status ?? null
 });
 
 export interface ListRedemptionsFilter {
@@ -227,6 +229,29 @@ export const editRedemption = async (redemptionId: number, input: EditRedemption
 	}
 };
 
+export type ResendConfirmationResult = 'SENT' | 'FAILED' | 'NOT_FOUND' | 'NOT_ACTIVE';
+
+/**
+ * Rebuilds and re-sends the redemption confirmation email from the stored
+ * redemption data, then records the new outcome on the row. Used by the admin
+ * UI's "resend" action on a redemption whose confirmation email failed. Only
+ * active redemptions can be resent.
+ */
+export const resendRedemptionConfirmation = async (redemptionId: number): Promise<ResendConfirmationResult> => {
+	const redemption = await getRedemption(redemptionId);
+	if (!redemption) return 'NOT_FOUND';
+	if (redemption.status !== 'ACTIVE') return 'NOT_ACTIVE';
+
+	const sent = await sendRedemptionConfirmation({
+		eventId: redemption.eventId,
+		contactName: redemption.contactName,
+		contactEmail: redemption.contactEmail,
+		guestNames: redemption.guests
+	});
+	await recordConfirmationEmailResult(redemptionId, sent);
+	return sent ? 'SENT' : 'FAILED';
+};
+
 export const getAuditHistory = async (code: string): Promise<AuditLogEntry[]> => {
 	let conn = await NachklangTicketsDB.getConnection();
 	try {

src/models/tickets/public/voucher.public.service.ts

@@ -1,20 +1,11 @@
 import * as EventsService from '../../calendar/events/events.service';
-import * as IcalService from '../../calendar/events/icalgenerator.service';
-import {MailService} from '../../../common/common.mail.nodemailer';
 import logger from '../../../middleware/logger';
 import {NachklangTicketsDB} from '../Tickets.db';
 import {getEventTicketState} from '../tickets.capacity';
+import {recordConfirmationEmailResult, sendRedemptionConfirmation} from '../tickets.confirmation-email';
 import {EligibleEvent, RedeemRequest, VoucherValidation} from '../tickets.interface';
 import {isValidEmail} from '../tickets.validation';
 
-const formatGermanDateTime = (date: Date): string => {
-	return new Intl.DateTimeFormat('de-DE', {
-		dateStyle: 'full',
-		timeStyle: 'short',
-		timeZone: 'Europe/Berlin'
-	}).format(date);
-};
-
 /**
  * Builds the eligible-events list for a code: for each event it's linked
  * to, merges live Calendar event details with the Tickets module's own
@@ -173,43 +164,21 @@ export const redeemVoucher = async (code: string, request: RedeemRequest): Promi
 	}
 
 	// Sent after commit, mirroring the Calendar/Feedback convention: a mail
-	// delivery failure shouldn't roll back a successful redemption. Caught
-	// rather than left to propagate - the redemption already succeeded, so
-	// a mail-server hiccup must not turn into a false failure response to
-	// a guest who has, in fact, already secured their spot.
+	// delivery failure shouldn't roll back a successful redemption, and the
+	// guest has in fact already secured their spot. The send itself no longer
+	// throws on a delivery problem; its result is recorded on the redemption
+	// so staff can spot and resend a failed confirmation from the admin UI.
 	try {
-		await sendConfirmationEmail(eventId, request, redemptionId);
+		const sent = await sendRedemptionConfirmation({
+			eventId,
+			contactName: request.contactName,
+			contactEmail: request.contactEmail,
+			guestNames: request.guests.map(g => g.name)
+		});
+		await recordConfirmationEmailResult(redemptionId, sent);
 	} catch (e: any) {
-		logger.error('Redemption ' + redemptionId + ' succeeded but confirmation email failed to send: ' + e.message);
+		logger.error('Redemption ' + redemptionId + ' committed but the confirmation email step failed: ' + e.message);
 	}
 
 	return {status: 'OK', redemptionId};
 };
-
-const sendConfirmationEmail = async (eventId: number, request: RedeemRequest, redemptionId: number): Promise<void> => {
-	const event = await EventsService.getEventById(eventId);
-	if (!event) return;
-
-	const guestList = request.guests.map(g => `- ${g.name}`).join('\n');
-	const body = `Hallo ${request.contactName},\n\n` +
-		`vielen Dank für deine Anmeldung zu "${event.name}"!\n\n` +
-		`Termin: ${formatGermanDateTime(event.startDateTime)}\n` +
-		`Ort: ${event.location}\n\n` +
-		`Angemeldete Gäste:\n${guestList}\n\n` +
-		`Wir freuen uns auf dich!\n\nDein Nachklang-Team`;
-
-	let icsAttachment;
-	try {
-		const ics = await IcalService.convertToIcal([event]);
-		icsAttachment = [{filename: 'konzert.ics', content: ics, contentType: 'text/calendar'}];
-	} catch {
-		icsAttachment = undefined;
-	}
-
-	await MailService.sendMail(
-		request.contactEmail,
-		`Bestätigung: ${event.name}`,
-		body,
-		{attachments: icsAttachment}
-	);
-};

src/models/tickets/tickets.confirmation-email.ts

@@ -0,0 +1,76 @@
+import * as EventsService from '../calendar/events/events.service';
+import * as IcalService from '../calendar/events/icalgenerator.service';
+import {MailService} from '../../common/common.mail';
+import logger from '../../middleware/logger';
+import {NachklangTicketsDB} from './Tickets.db';
+
+export type ConfirmationEmailStatus = 'SENT' | 'FAILED';
+
+// The redemption confirmation email is built and sent from here so the public
+// redeem path and the admin "resend" action share one copy of the German text
+// and the .ics attachment logic.
+
+const formatGermanDateTime = (date: Date): string =>
+	new Intl.DateTimeFormat('de-DE', {
+		dateStyle: 'full',
+		timeStyle: 'short',
+		timeZone: 'Europe/Berlin'
+	}).format(date);
+
+export interface ConfirmationRecipient {
+	eventId: number;
+	contactName: string;
+	contactEmail: string;
+	guestNames: string[];
+}
+
+/**
+ * Sends the redemption confirmation email for one redemption. Returns whether
+ * the mail was accepted by the relay. Never throws: a missing event is treated
+ * as "not sent", and MailService.sendMail already swallows delivery failures.
+ */
+export const sendRedemptionConfirmation = async (recipient: ConfirmationRecipient): Promise<boolean> => {
+	const event = await EventsService.getEventById(recipient.eventId);
+	if (!event) {
+		logger.error('Confirmation email skipped: event ' + recipient.eventId + ' no longer exists');
+		return false;
+	}
+
+	const guestList = recipient.guestNames.map(name => `- ${name}`).join('\n');
+	const body =
+		`Hallo ${recipient.contactName},\n\n` +
+		`vielen Dank für deine Anmeldung zu "${event.name}"!\n\n` +
+		`Termin: ${formatGermanDateTime(event.startDateTime)}\n` +
+		`Ort: ${event.location}\n\n` +
+		`Angemeldete Gäste:\n${guestList}\n\n` +
+		`Wir freuen uns auf dich!\n\nDein Nachklang-Team`;
+
+	let icsAttachment;
+	try {
+		const ics = await IcalService.convertToIcal([event]);
+		icsAttachment = [{filename: 'konzert.ics', content: ics, contentType: 'text/calendar'}];
+	} catch (e: any) {
+		// Non-fatal: the confirmation still goes out, just without the calendar file.
+		logger.warn('Confirmation email for event ' + recipient.eventId + ' sent without .ics attachment: ' + e?.message);
+		icsAttachment = undefined;
+	}
+
+	return MailService.sendMail(recipient.contactEmail, `Bestätigung: ${event.name}`, body, {attachments: icsAttachment});
+};
+
+/**
+ * Records the outcome of a confirmation-email send on the redemption row so the
+ * admin UI can flag failures. Best-effort: a failure to write the flag is
+ * logged, never thrown - the redemption itself already succeeded.
+ */
+export const recordConfirmationEmailResult = async (redemptionId: number, sent: boolean): Promise<void> => {
+	const status: ConfirmationEmailStatus = sent ? 'SENT' : 'FAILED';
+	let conn = await NachklangTicketsDB.getConnection();
+	try {
+		await conn.query('UPDATE redemptions SET confirmation_email_status = ? WHERE redemption_id = ?', [status, redemptionId]);
+	} catch (err: any) {
+		logger.error('Could not record confirmation email status for redemption ' + redemptionId + ': ' + err?.message);
+	} finally {
+		await conn.end();
+	}
+};

src/models/tickets/tickets.interface.ts

@@ -109,6 +109,11 @@
  *         redeemedAt:
  *           type: string
  *           format: date-time
+ *         confirmationEmailStatus:
+ *           type: string
+ *           enum: [SENT, FAILED]
+ *           nullable: true
+ *           description: Outcome of the redemption confirmation email. null until the send resolves.
  *     VoucherCode:
  *       type: object
  *       required: [code, status, maxGuests, createdByEmail, createdAt, eligibleEventIds]
@@ -258,6 +263,8 @@ export interface RedemptionSummary {
 	guestCount: number;
 	guests: string[];
 	redeemedAt: Date;
+	// null until the post-redemption confirmation email send resolves.
+	confirmationEmailStatus: 'SENT' | 'FAILED' | null;
 }
 
 export interface VoucherCode {