From 449edd6c686efa758f25ef71b82e6154a562094d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Patrick=20M=C3=BCller?= Date: Mon, 31 Aug 2026 16:17:59 +0000 Subject: [PATCH] Relay transactional email through Salesforce instead of SMTP (#9) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reviewed-on: https://git.plutodev.de/Nachklang/API/pulls/9 Co-authored-by: Patrick Müller Co-committed-by: Patrick Müller --- package.json | 2 - .../003_add_confirmation_email_status.sql | 7 + src/common/common.mail.nodemailer.ts | 42 ------ src/common/common.mail.ts | 107 ++++++++++++++ src/common/salesforce.client.ts | 66 +++++++++ src/models/calendar/users/users.service.ts | 7 +- .../integrations/salesforce.service.ts | 55 +------- .../tickets/admin/redemptions.admin.router.ts | 49 +++++++ .../admin/redemptions.admin.service.ts | 27 +++- .../tickets/public/voucher.public.service.ts | 57 ++------ .../tickets/tickets.confirmation-email.ts | 76 ++++++++++ src/models/tickets/tickets.interface.ts | 7 + test/common/common.mail.test.ts | 115 +++++++++++++++ test/common/salesforce.client.test.ts | 124 +++++++++++++++++ test/tickets/confirmation-email.test.ts | 131 ++++++++++++++++++ test/tickets/redemptions.admin.resend.test.ts | 88 ++++++++++++ 16 files changed, 819 insertions(+), 141 deletions(-) create mode 100644 sql/tickets/003_add_confirmation_email_status.sql delete mode 100644 src/common/common.mail.nodemailer.ts create mode 100644 src/common/common.mail.ts create mode 100644 src/common/salesforce.client.ts create mode 100644 src/models/tickets/tickets.confirmation-email.ts create mode 100644 test/common/common.mail.test.ts create mode 100644 test/common/salesforce.client.test.ts create mode 100644 test/tickets/confirmation-email.test.ts create mode 100644 test/tickets/redemptions.admin.resend.test.ts diff --git a/package.json b/package.json index 1706a36..2daa028 100644 --- a/package.json +++ b/package.json @@ -22,7 +22,6 @@ "express": "^4.18.2", "guid-typescript": "^1.0.9", "mariadb": "^3.0.2", - "nodemailer": "^6.9.8", "random-words": "^1.1.1", "swagger-jsdoc": "^6.1.0", "swagger-ui-express": "^4.3.0", @@ -35,7 +34,6 @@ "@types/express": "^4.17.15", "@types/jest": "^28.1.3", "@types/node": "^18.11.17", - "@types/nodemailer": "^6.4.14", "@types/random-words": "^1.1.2", "@types/swagger-jsdoc": "^6.0.1", "@types/swagger-ui-express": "^4.1.3", diff --git a/sql/tickets/003_add_confirmation_email_status.sql b/sql/tickets/003_add_confirmation_email_status.sql new file mode 100644 index 0000000..ce1f8fa --- /dev/null +++ b/sql/tickets/003_add_confirmation_email_status.sql @@ -0,0 +1,7 @@ +-- Nachklang e.V. Tickets module — records the outcome of the redemption +-- confirmation email on the redemption itself, so the admin UI can flag a +-- failed send and offer a resend. NULL until the post-commit send resolves. +-- Apply manually against TICKETS_DB, after 002_add_require_address.sql: +-- mysql -h -u -p < 003_add_confirmation_email_status.sql +ALTER TABLE redemptions + ADD COLUMN confirmation_email_status ENUM('SENT','FAILED') NULL DEFAULT NULL AFTER redeemed_at; diff --git a/src/common/common.mail.nodemailer.ts b/src/common/common.mail.nodemailer.ts deleted file mode 100644 index aa2e9f8..0000000 --- a/src/common/common.mail.nodemailer.ts +++ /dev/null @@ -1,42 +0,0 @@ -import * as nodemailer from 'nodemailer'; - -export namespace MailService { - const transporter = nodemailer.createTransport({ - host: process.env.EMAIL_HOST, - pool: true, - port: 465, - secure: true, - auth: { - user: process.env.EMAIL_USERNAME, - pass: process.env.EMAIL_PASSWORD - }, - tls: {rejectUnauthorized: false} - }); - - export interface MailAttachment { - filename: string; - content: string | Buffer; - contentType?: string; - } - - export interface SendMailOptions { - html?: string; - attachments?: MailAttachment[]; - } - - // Builds a fresh options object per call rather than mutating a shared - // module-level one - the transporter is pooled, so overlapping sendMail - // calls (e.g. two guests redeeming at once) previously risked one - // call's recipient/subject/body being overwritten by another's before - // transporter.sendMail() read it. - export const sendMail = async (recipientAddress: string, subject: string, body: string, options?: SendMailOptions) => { - await transporter.sendMail({ - from: 'noreply@nachklang.art', - to: recipientAddress, - subject: subject, - text: body, - html: options?.html, - attachments: options?.attachments - }); - }; -} diff --git a/src/common/common.mail.ts b/src/common/common.mail.ts new file mode 100644 index 0000000..57e0482 --- /dev/null +++ b/src/common/common.mail.ts @@ -0,0 +1,107 @@ +import logger from '../middleware/logger'; +import {salesforceApexRestPost, salesforceEnabled} from './salesforce.client'; + +// Transactional email for the ticketing/calendar flows (voucher redemption +// confirmations, account activation links, password-reset tokens) is relayed +// through the Nachklang Salesforce org rather than sent over our own SMTP host: +// that host's IP reputation gets it blocked by allowlist-based receivers +// (notably t-online.de). Salesforce's MTA plus the org's DKIM signature for +// nachklang.art get the mail delivered. The org endpoint is EmailSendResource +// (POST /services/apexrest/email/send); the From address is fixed server-side +// there and is never sent from here. +// +// sendMail never throws on a delivery problem. Every caller has already +// committed its own work (a registration, a password-reset token, a +// redemption) by the time mail goes out, so a mail failure must not surface as +// a user-facing error. It returns whether the mail was accepted so the one +// caller that shows failures to staff (the voucher confirmation) can record it. + +export namespace MailService { + export interface MailAttachment { + filename: string; + content: string | Buffer; + contentType?: string; + } + + export interface SendMailOptions { + html?: string; + attachments?: MailAttachment[]; + } + + interface EmailSendResponse { + status: 'SENT'; + } + + // Practical ceiling, well under Apex REST's 6 MB request-body limit once + // base64 inflation (~33%) is accounted for. The only attachment today is a + // ~1 KB .ics file. + const MAX_ATTACHMENT_BYTES = 3 * 1024 * 1024; + + const isRetriable = (err: any): boolean => { + const status = err?.response?.status; + if (status !== undefined) { + return status >= 500; + } + // No response at all - network error or timeout. + return true; + }; + + /** + * Relays one email through the Salesforce org. Retries once on a transient + * failure (5xx / network / timeout), then logs and returns false rather + * than throwing. Returns false immediately (without a callout) when the + * Salesforce integration is disabled. + */ + export const sendMail = async ( + recipientAddress: string, + subject: string, + body: string, + options?: SendMailOptions + ): Promise => { + if (!salesforceEnabled()) { + logger.info('MailService: SALESFORCE_ENABLED is false, would have sent', {recipientAddress, subject}); + return false; + } + + let attachments: {filename: string; contentType?: string; contentBase64: string}[]; + try { + attachments = (options?.attachments ?? []).map(attachment => { + const buffer = Buffer.isBuffer(attachment.content) + ? attachment.content + : Buffer.from(attachment.content, 'utf-8'); + if (buffer.byteLength > MAX_ATTACHMENT_BYTES) { + throw new Error(`attachment ${attachment.filename} is ${buffer.byteLength} bytes, over the ${MAX_ATTACHMENT_BYTES} limit`); + } + return {filename: attachment.filename, contentType: attachment.contentType, contentBase64: buffer.toString('base64')}; + }); + } catch (err: any) { + logger.error('MailService: could not prepare attachments', {recipientAddress, subject, detail: err?.message}); + return false; + } + + const payload = { + to: recipientAddress, + subject, + textBody: body, + htmlBody: options?.html ?? null, + attachments + }; + + for (let attempt = 1; attempt <= 2; attempt++) { + try { + await salesforceApexRestPost('/services/apexrest/email/send', payload); + return true; + } catch (err: any) { + const status = err?.response?.status; + const detail = err?.response?.data?.errorCode || err?.response?.data?.message || err?.message || 'unknown error'; + if (attempt === 1 && isRetriable(err)) { + logger.warn('MailService: send failed, retrying once', {recipientAddress, subject, status, detail}); + continue; + } + logger.error('MailService: send failed', {recipientAddress, subject, status, detail}); + return false; + } + } + return false; + }; +} diff --git a/src/common/salesforce.client.ts b/src/common/salesforce.client.ts new file mode 100644 index 0000000..0e98e3a --- /dev/null +++ b/src/common/salesforce.client.ts @@ -0,0 +1,66 @@ +import axios from 'axios'; + +// Shared server-to-server access to the one Nachklang Salesforce org. Both the +// newsletter-signup sync (feedback module) and the transactional-email relay +// (common.mail) authenticate the same way - OAuth 2.0 client credentials +// against the nk_Nachklang_API_Integration external client app - so the token +// cache and the retry-once-on-401 live here rather than being duplicated. +// +// Salesforce's client-credentials token response does not reliably include +// expires_in, so the cache lifetime is a conservative guess rather than a +// value read from the response - a 401 on the next call just triggers a fresh +// fetch (see salesforceApexRestPost). + +const TOKEN_CACHE_MS = 15 * 60 * 1000; +let cachedToken: {accessToken: string; fetchedAt: number} | null = null; + +export const salesforceEnabled = (): boolean => process.env.SALESFORCE_ENABLED === 'true'; + +const readConfig = (): {instanceUrl: string; clientId: string; clientSecret: string} => { + const instanceUrl = process.env.SALESFORCE_API_URL; + const clientId = process.env.SALESFORCE_CLIENT_ID; + const clientSecret = process.env.SALESFORCE_CLIENT_SECRET; + if (!instanceUrl || !clientId || !clientSecret) { + throw new Error('SALESFORCE_ENABLED is true but SALESFORCE_API_URL/SALESFORCE_CLIENT_ID/SALESFORCE_CLIENT_SECRET are not fully configured.'); + } + return {instanceUrl, clientId, clientSecret}; +}; + +const getAccessToken = async (forceRefresh: boolean): Promise => { + if (!forceRefresh && cachedToken && Date.now() - cachedToken.fetchedAt < TOKEN_CACHE_MS) { + return cachedToken.accessToken; + } + + const {instanceUrl, clientId, clientSecret} = readConfig(); + const res = await axios.post( + `${instanceUrl}/services/oauth2/token`, + new URLSearchParams({grant_type: 'client_credentials', client_id: clientId, client_secret: clientSecret}).toString(), + {headers: {'Content-Type': 'application/x-www-form-urlencoded'}, timeout: 10000} + ); + cachedToken = {accessToken: res.data.access_token, fetchedAt: Date.now()}; + return cachedToken.accessToken; +}; + +/** + * POSTs a JSON body to an Apex REST path (e.g. '/services/apexrest/newsletter/signup') + * and returns the parsed response body. Retries once with a forced token + * refresh on a 401 - the server-side token may have expired even though our + * conservative local TTL has not. All other errors propagate to the caller. + */ +export const salesforceApexRestPost = async (path: string, body: unknown): Promise => { + const {instanceUrl} = readConfig(); + const url = `${instanceUrl}${path}`; + + try { + const token = await getAccessToken(false); + const res = await axios.post(url, body, {headers: {Authorization: `Bearer ${token}`}, timeout: 10000}); + return res.data; + } catch (err: any) { + if (err?.response?.status === 401) { + const token = await getAccessToken(true); + const res = await axios.post(url, body, {headers: {Authorization: `Bearer ${token}`}, timeout: 10000}); + return res.data; + } + throw err; + } +}; diff --git a/src/models/calendar/users/users.service.ts b/src/models/calendar/users/users.service.ts index 6ef36ac..d7e990a 100644 --- a/src/models/calendar/users/users.service.ts +++ b/src/models/calendar/users/users.service.ts @@ -4,7 +4,7 @@ import {Guid} from 'guid-typescript'; import {User} from './user.interface'; import {Session} from './session.interface'; import {NachklangCalendarDB} from '../Calendar.db'; -import {MailService} from "../../../common/common.mail.nodemailer"; +import {MailService} from "../../../common/common.mail"; dotenv.config(); @@ -54,7 +54,10 @@ export const createUser = async (email: string, password: string, fullName: stri sessionId = row.session_id; } - // Send email with activation link (after commit so we don't block on email delivery) + // Send email with activation link (after commit so we don't block on email + // delivery). sendMail never throws on a delivery failure - it logs and + // returns false - so a mail-server problem here can't roll back the + // already-committed user and leave registration reporting a false error. await MailService.sendMail(email, 'Activate your Nachklang account', `Hi ${fullName},\n\nPlease click on the following link to activate your account:\n\nhttps://api.nachklang.art/calendar/users/activate?id=${userId}&token=${activationToken}`); return { diff --git a/src/models/feedback/integrations/salesforce.service.ts b/src/models/feedback/integrations/salesforce.service.ts index 5534fae..bc8ace6 100644 --- a/src/models/feedback/integrations/salesforce.service.ts +++ b/src/models/feedback/integrations/salesforce.service.ts @@ -1,6 +1,6 @@ -import axios from 'axios'; import {NachklangFeedbackDB} from '../Feedback.db'; import logger from '../../../middleware/logger'; +import {salesforceApexRestPost} from '../../../common/salesforce.client'; // Newsletter opt-ins sync to Salesforce, which already runs a full // double-opt-in subscription flow (Person Account for existing constituents, @@ -9,7 +9,8 @@ import logger from '../../../middleware/logger'; // This is the one file that knows that contract exists; submissions.service.ts // only ever calls syncNewsletterSignup(signupId) after its own transaction // commits, fire-and-forget, so a Salesforce outage can never delay or fail a -// visitor's feedback submission. +// visitor's feedback submission. The OAuth token cache and retry-once-on-401 +// live in common/salesforce.client.ts, shared with the transactional-email relay. interface SalesforceSuccessResponse { status: 'PENDING_CONFIRMATION' | 'ALREADY_SUBSCRIBED'; @@ -26,54 +27,8 @@ interface NewsletterSignupRow { event_name: string; } -// Salesforce's client-credentials token response does not reliably include -// expires_in, so the cache lifetime is a conservative guess rather than a -// value read from the response - a 401 on the next call just triggers a -// fresh fetch (see the retry-once logic in postSignup). -const TOKEN_CACHE_MS = 15 * 60 * 1000; -let cachedToken: {accessToken: string; fetchedAt: number} | null = null; - -const getAccessToken = async (forceRefresh: boolean): Promise => { - if (!forceRefresh && cachedToken && Date.now() - cachedToken.fetchedAt < TOKEN_CACHE_MS) { - return cachedToken.accessToken; - } - - const instanceUrl = process.env.SALESFORCE_API_URL; - const clientId = process.env.SALESFORCE_CLIENT_ID; - const clientSecret = process.env.SALESFORCE_CLIENT_SECRET; - if (!instanceUrl || !clientId || !clientSecret) { - throw new Error('SALESFORCE_ENABLED is true but SALESFORCE_API_URL/SALESFORCE_CLIENT_ID/SALESFORCE_CLIENT_SECRET are not fully configured.'); - } - - const res = await axios.post( - `${instanceUrl}/services/oauth2/token`, - new URLSearchParams({grant_type: 'client_credentials', client_id: clientId, client_secret: clientSecret}).toString(), - {headers: {'Content-Type': 'application/x-www-form-urlencoded'}, timeout: 10000} - ); - cachedToken = {accessToken: res.data.access_token, fetchedAt: Date.now()}; - return cachedToken.accessToken; -}; - -const postSignup = async (payload: {firstName: string; lastName: string; email: string; eventName: string}): Promise => { - const instanceUrl = process.env.SALESFORCE_API_URL; - const url = `${instanceUrl}/services/apexrest/newsletter/signup`; - - try { - const token = await getAccessToken(false); - const res = await axios.post(url, payload, {headers: {Authorization: `Bearer ${token}`}, timeout: 10000}); - return res.data; - } catch (err: any) { - // The cached token may have expired server-side even though our - // conservative local TTL hasn't - retry once with a forced refresh - // before treating this as a real failure. - if (err?.response?.status === 401) { - const token = await getAccessToken(true); - const res = await axios.post(url, payload, {headers: {Authorization: `Bearer ${token}`}, timeout: 10000}); - return res.data; - } - throw err; - } -}; +const postSignup = (payload: {firstName: string; lastName: string; email: string; eventName: string}): Promise => + salesforceApexRestPost('/services/apexrest/newsletter/signup', payload); const markSynced = async (signupId: number, externalId: string): Promise => { let conn = await NachklangFeedbackDB.getConnection(); diff --git a/src/models/tickets/admin/redemptions.admin.router.ts b/src/models/tickets/admin/redemptions.admin.router.ts index d047e28..8b1b65a 100644 --- a/src/models/tickets/admin/redemptions.admin.router.ts +++ b/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: diff --git a/src/models/tickets/admin/redemptions.admin.service.ts b/src/models/tickets/admin/redemptions.admin.service.ts index 383883b..5e80627 100644 --- a/src/models/tickets/admin/redemptions.admin.service.ts +++ b/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 => { + 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 => { let conn = await NachklangTicketsDB.getConnection(); try { diff --git a/src/models/tickets/public/voucher.public.service.ts b/src/models/tickets/public/voucher.public.service.ts index 4f3c5fd..b68e1f4 100644 --- a/src/models/tickets/public/voucher.public.service.ts +++ b/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 => { - 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} - ); -}; diff --git a/src/models/tickets/tickets.confirmation-email.ts b/src/models/tickets/tickets.confirmation-email.ts new file mode 100644 index 0000000..8a8b488 --- /dev/null +++ b/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 => { + 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 => { + 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(); + } +}; diff --git a/src/models/tickets/tickets.interface.ts b/src/models/tickets/tickets.interface.ts index b9adce2..d74d331 100644 --- a/src/models/tickets/tickets.interface.ts +++ b/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 { diff --git a/test/common/common.mail.test.ts b/test/common/common.mail.test.ts new file mode 100644 index 0000000..8459493 --- /dev/null +++ b/test/common/common.mail.test.ts @@ -0,0 +1,115 @@ +// common.mail relays one email through the Salesforce org (see +// src/common/common.mail.ts). These tests mock the shared Salesforce client so +// no network is touched, and check: the payload shape, base64 attachment +// encoding, the attachment size cap, the retry-once-on-transient-failure +// behaviour, and that a delivery failure is swallowed (returns false, never +// throws). + +jest.mock('../../src/common/salesforce.client'); +jest.mock('../../src/middleware/logger', () => ({ + __esModule: true, + default: {info: jest.fn(), warn: jest.fn(), error: jest.fn()} +})); + +import {MailService} from '../../src/common/common.mail'; +import {salesforceApexRestPost, salesforceEnabled} from '../../src/common/salesforce.client'; + +const mockPost = salesforceApexRestPost as jest.Mock; +const mockEnabled = salesforceEnabled as jest.Mock; + +const httpError = (status: number, body?: any): any => { + const err: any = new Error('request failed with ' + status); + err.response = {status, data: body}; + return err; +}; + +beforeEach(() => { + jest.clearAllMocks(); + mockEnabled.mockReturnValue(true); + mockPost.mockResolvedValue({status: 'SENT'}); +}); + +describe('MailService.sendMail', () => { + it('returns false without a callout when Salesforce is disabled', async () => { + mockEnabled.mockReturnValue(false); + + const result = await MailService.sendMail('guest@example.com', 'Hi', 'Hallo'); + + expect(result).toBe(false); + expect(mockPost).not.toHaveBeenCalled(); + }); + + it('posts the email to the Apex REST endpoint and returns true on success', async () => { + const result = await MailService.sendMail('guest@example.com', 'Bestätigung', 'Hallo', {html: '

Hallo

'}); + + expect(result).toBe(true); + expect(mockPost).toHaveBeenCalledWith('/services/apexrest/email/send', { + to: 'guest@example.com', + subject: 'Bestätigung', + textBody: 'Hallo', + htmlBody: '

Hallo

', + attachments: [] + }); + }); + + it('sends htmlBody as null when no HTML is given', async () => { + await MailService.sendMail('guest@example.com', 'Hi', 'Hallo'); + + expect(mockPost).toHaveBeenCalledWith('/services/apexrest/email/send', expect.objectContaining({htmlBody: null})); + }); + + it('base64-encodes attachments', async () => { + await MailService.sendMail('guest@example.com', 'Hi', 'Hallo', { + attachments: [{filename: 'konzert.ics', content: 'BEGIN:VCALENDAR', contentType: 'text/calendar'}] + }); + + expect(mockPost).toHaveBeenCalledWith( + '/services/apexrest/email/send', + expect.objectContaining({ + attachments: [{ + filename: 'konzert.ics', + contentType: 'text/calendar', + contentBase64: Buffer.from('BEGIN:VCALENDAR', 'utf-8').toString('base64') + }] + }) + ); + }); + + it('rejects an attachment over the size cap without sending', async () => { + const huge = Buffer.alloc(3 * 1024 * 1024 + 1); + + const result = await MailService.sendMail('guest@example.com', 'Hi', 'Hallo', { + attachments: [{filename: 'big.pdf', content: huge}] + }); + + expect(result).toBe(false); + expect(mockPost).not.toHaveBeenCalled(); + }); + + it('retries once on a 5xx and returns false when the retry also fails', async () => { + mockPost.mockRejectedValue(httpError(503)); + + const result = await MailService.sendMail('guest@example.com', 'Hi', 'Hallo'); + + expect(result).toBe(false); + expect(mockPost).toHaveBeenCalledTimes(2); + }); + + it('retries once on a network error (no response) then succeeds', async () => { + mockPost.mockRejectedValueOnce(new Error('socket hang up')).mockResolvedValueOnce({status: 'SENT'}); + + const result = await MailService.sendMail('guest@example.com', 'Hi', 'Hallo'); + + expect(result).toBe(true); + expect(mockPost).toHaveBeenCalledTimes(2); + }); + + it('does not retry on a 4xx (e.g. the 429 limit response) and returns false', async () => { + mockPost.mockRejectedValue(httpError(429, {errorCode: 'LIMIT_REACHED'})); + + const result = await MailService.sendMail('guest@example.com', 'Hi', 'Hallo'); + + expect(result).toBe(false); + expect(mockPost).toHaveBeenCalledTimes(1); + }); +}); diff --git a/test/common/salesforce.client.test.ts b/test/common/salesforce.client.test.ts new file mode 100644 index 0000000..8f73d2c --- /dev/null +++ b/test/common/salesforce.client.test.ts @@ -0,0 +1,124 @@ +// salesforce.client caches the OAuth token at module scope, so every test +// resets the module registry for a clean cache and re-requires axios + the +// module under test after the reset (same approach as +// test/feedback/salesforce.service.test.ts). + +export {}; // isolate module scope from other script-style test files + +jest.mock('axios'); + +const freshImports = () => { + const axios = require('axios'); + const {salesforceApexRestPost, salesforceEnabled} = require('../../src/common/salesforce.client'); + return {axios, salesforceApexRestPost, salesforceEnabled}; +}; + +const ORIGINAL_ENV = {...process.env}; +const ENABLED_ENV = { + ...ORIGINAL_ENV, + SALESFORCE_ENABLED: 'true', + SALESFORCE_API_URL: 'https://example.my.salesforce.com', + SALESFORCE_CLIENT_ID: 'client-id', + SALESFORCE_CLIENT_SECRET: 'client-secret' +}; + +beforeEach(() => { + jest.resetModules(); + process.env = {...ENABLED_ENV}; +}); + +afterAll(() => { + process.env = {...ORIGINAL_ENV}; +}); + +describe('salesforceEnabled', () => { + it('is true only when SALESFORCE_ENABLED === "true"', () => { + process.env.SALESFORCE_ENABLED = 'true'; + expect(freshImports().salesforceEnabled()).toBe(true); + + jest.resetModules(); + process.env.SALESFORCE_ENABLED = 'false'; + expect(freshImports().salesforceEnabled()).toBe(false); + }); +}); + +describe('salesforceApexRestPost', () => { + it('fetches a token, posts to the given Apex REST path, and returns the response body', async () => { + const {axios, salesforceApexRestPost} = freshImports(); + axios.post.mockImplementation((url: string) => { + if (url.endsWith('/services/oauth2/token')) return Promise.resolve({data: {access_token: 'tok-1'}}); + return Promise.resolve({data: {ok: true}}); + }); + + const result = await salesforceApexRestPost('/services/apexrest/email/send', {to: 'x@example.com'}); + + expect(result).toEqual({ok: true}); + expect(axios.post).toHaveBeenCalledWith( + 'https://example.my.salesforce.com/services/oauth2/token', + expect.any(String), + expect.objectContaining({headers: {'Content-Type': 'application/x-www-form-urlencoded'}}) + ); + expect(axios.post).toHaveBeenCalledWith( + 'https://example.my.salesforce.com/services/apexrest/email/send', + {to: 'x@example.com'}, + expect.objectContaining({headers: {Authorization: 'Bearer tok-1'}}) + ); + }); + + it('reuses the cached token across calls instead of fetching twice', async () => { + const {axios, salesforceApexRestPost} = freshImports(); + axios.post.mockImplementation((url: string) => { + if (url.endsWith('/services/oauth2/token')) return Promise.resolve({data: {access_token: 'tok-1'}}); + return Promise.resolve({data: {}}); + }); + + await salesforceApexRestPost('/services/apexrest/email/send', {}); + await salesforceApexRestPost('/services/apexrest/email/send', {}); + + const tokenCalls = axios.post.mock.calls.filter(([url]: [string]) => url.endsWith('/services/oauth2/token')); + expect(tokenCalls).toHaveLength(1); + }); + + it('retries once with a fresh token on a 401, then succeeds', async () => { + const {axios, salesforceApexRestPost} = freshImports(); + let tokenFetches = 0; + axios.post.mockImplementation((url: string) => { + if (url.endsWith('/services/oauth2/token')) { + tokenFetches += 1; + return Promise.resolve({data: {access_token: `tok-${tokenFetches}`}}); + } + if (tokenFetches === 1) { + const err: any = new Error('Unauthorized'); + err.response = {status: 401}; + return Promise.reject(err); + } + return Promise.resolve({data: {ok: true}}); + }); + + const result = await salesforceApexRestPost('/services/apexrest/email/send', {}); + + expect(result).toEqual({ok: true}); + expect(tokenFetches).toBe(2); + }); + + it('does not retry on a non-401 error and rethrows it', async () => { + const {axios, salesforceApexRestPost} = freshImports(); + axios.post.mockImplementation((url: string) => { + if (url.endsWith('/services/oauth2/token')) return Promise.resolve({data: {access_token: 'tok-1'}}); + const err: any = new Error('Server error'); + err.response = {status: 500}; + return Promise.reject(err); + }); + + await expect(salesforceApexRestPost('/services/apexrest/email/send', {})).rejects.toThrow('Server error'); + const endpointCalls = axios.post.mock.calls.filter(([url]: [string]) => url.endsWith('/email/send')); + expect(endpointCalls).toHaveLength(1); + }); + + it('throws a clear error when client credentials are not configured', async () => { + process.env.SALESFORCE_CLIENT_ID = ''; + const {salesforceApexRestPost} = freshImports(); + + await expect(salesforceApexRestPost('/services/apexrest/email/send', {})).rejects.toThrow('SALESFORCE_CLIENT_ID'); + }); +}); diff --git a/test/tickets/confirmation-email.test.ts b/test/tickets/confirmation-email.test.ts new file mode 100644 index 0000000..4e8a13e --- /dev/null +++ b/test/tickets/confirmation-email.test.ts @@ -0,0 +1,131 @@ +// tickets.confirmation-email builds and sends the redemption confirmation +// email, shared by the public redeem path and the admin resend action. + +jest.mock('../../src/models/calendar/events/events.service', () => ({ + getEventById: jest.fn() +})); +jest.mock('../../src/models/calendar/events/icalgenerator.service', () => ({ + convertToIcal: jest.fn() +})); +jest.mock('../../src/common/common.mail', () => ({ + MailService: {sendMail: jest.fn()} +})); +jest.mock('../../src/models/tickets/Tickets.db', () => ({ + NachklangTicketsDB: {getConnection: jest.fn()} +})); +jest.mock('../../src/middleware/logger', () => ({ + __esModule: true, + default: {info: jest.fn(), warn: jest.fn(), error: jest.fn()} +})); + +import * as EventsService from '../../src/models/calendar/events/events.service'; +import * as IcalService from '../../src/models/calendar/events/icalgenerator.service'; +import {MailService} from '../../src/common/common.mail'; +import logger from '../../src/middleware/logger'; +import {NachklangTicketsDB} from '../../src/models/tickets/Tickets.db'; +import {recordConfirmationEmailResult, sendRedemptionConfirmation} from '../../src/models/tickets/tickets.confirmation-email'; + +const mockGetEvent = EventsService.getEventById as jest.Mock; +const mockToIcal = IcalService.convertToIcal as jest.Mock; +const mockSendMail = MailService.sendMail as jest.Mock; +const mockLogger = logger as unknown as {info: jest.Mock; warn: jest.Mock; error: jest.Mock}; +const mockGetConnection = NachklangTicketsDB.getConnection as jest.Mock; + +const EVENT = { + eventId: 42, + name: 'Sommerkonzert 2026', + startDateTime: new Date('2026-07-01T19:00:00Z'), + location: 'Christuskirche', + status: 'PUBLISHED' +}; + +const RECIPIENT = { + eventId: 42, + contactName: 'Erika Mustermann', + contactEmail: 'erika@example.com', + guestNames: ['Erika Mustermann', 'Hans Mustermann'] +}; + +beforeEach(() => { + jest.clearAllMocks(); + mockGetEvent.mockResolvedValue(EVENT); + mockToIcal.mockResolvedValue('BEGIN:VCALENDAR\nEND:VCALENDAR'); + mockSendMail.mockResolvedValue(true); +}); + +describe('sendRedemptionConfirmation', () => { + it('sends the German confirmation with the event details, guest list and .ics attachment', async () => { + const result = await sendRedemptionConfirmation(RECIPIENT); + + expect(result).toBe(true); + expect(mockSendMail).toHaveBeenCalledTimes(1); + const [to, subject, body, options] = mockSendMail.mock.calls[0]; + expect(to).toBe('erika@example.com'); + expect(subject).toBe('Bestätigung: Sommerkonzert 2026'); + expect(body).toContain('Hallo Erika Mustermann,'); + expect(body).toContain('"Sommerkonzert 2026"'); + expect(body).toContain('- Hans Mustermann'); + expect(options.attachments).toEqual([ + {filename: 'konzert.ics', content: 'BEGIN:VCALENDAR\nEND:VCALENDAR', contentType: 'text/calendar'} + ]); + }); + + it('still sends (without an attachment) and warns when the .ics build fails', async () => { + mockToIcal.mockRejectedValue(new Error('ical boom')); + + await sendRedemptionConfirmation(RECIPIENT); + + const options = mockSendMail.mock.calls[0][3]; + expect(options.attachments).toBeUndefined(); + expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining('without .ics attachment')); + }); + + it('returns false and does not send when the event no longer exists', async () => { + mockGetEvent.mockResolvedValue(null); + + const result = await sendRedemptionConfirmation(RECIPIENT); + + expect(result).toBe(false); + expect(mockSendMail).not.toHaveBeenCalled(); + }); + + it('propagates the relay result', async () => { + mockSendMail.mockResolvedValue(false); + + expect(await sendRedemptionConfirmation(RECIPIENT)).toBe(false); + }); +}); + +describe('recordConfirmationEmailResult', () => { + const makeConn = () => ({query: jest.fn().mockResolvedValue(undefined), end: jest.fn().mockResolvedValue(undefined)}); + + it('writes SENT when the mail was accepted', async () => { + const conn = makeConn(); + mockGetConnection.mockResolvedValue(conn); + + await recordConfirmationEmailResult(7, true); + + expect(conn.query).toHaveBeenCalledWith( + 'UPDATE redemptions SET confirmation_email_status = ? WHERE redemption_id = ?', + ['SENT', 7] + ); + expect(conn.end).toHaveBeenCalled(); + }); + + it('writes FAILED when the mail was not accepted', async () => { + const conn = makeConn(); + mockGetConnection.mockResolvedValue(conn); + + await recordConfirmationEmailResult(7, false); + + expect(conn.query).toHaveBeenCalledWith(expect.any(String), ['FAILED', 7]); + }); + + it('swallows a DB error rather than throwing', async () => { + const conn = {query: jest.fn().mockRejectedValue(new Error('db down')), end: jest.fn().mockResolvedValue(undefined)}; + mockGetConnection.mockResolvedValue(conn); + + await expect(recordConfirmationEmailResult(7, true)).resolves.toBeUndefined(); + expect(conn.end).toHaveBeenCalled(); + }); +}); diff --git a/test/tickets/redemptions.admin.resend.test.ts b/test/tickets/redemptions.admin.resend.test.ts new file mode 100644 index 0000000..5f218c0 --- /dev/null +++ b/test/tickets/redemptions.admin.resend.test.ts @@ -0,0 +1,88 @@ +// resendRedemptionConfirmation rebuilds the confirmation email from stored +// redemption data and records the new outcome. Only the resend path is +// exercised here; the shared send/record logic is covered by +// confirmation-email.test.ts. + +jest.mock('../../src/models/tickets/Tickets.db', () => ({ + NachklangTicketsDB: {getConnection: jest.fn()} +})); +jest.mock('../../src/models/tickets/tickets.confirmation-email', () => ({ + sendRedemptionConfirmation: jest.fn(), + recordConfirmationEmailResult: jest.fn() +})); + +import {NachklangTicketsDB} from '../../src/models/tickets/Tickets.db'; +import {recordConfirmationEmailResult, sendRedemptionConfirmation} from '../../src/models/tickets/tickets.confirmation-email'; +import {resendRedemptionConfirmation} from '../../src/models/tickets/admin/redemptions.admin.service'; + +const mockGetConnection = NachklangTicketsDB.getConnection as jest.Mock; +const mockSend = sendRedemptionConfirmation as jest.Mock; +const mockRecord = recordConfirmationEmailResult as jest.Mock; + +const ACTIVE_ROW = { + redemption_id: 5, + code: 'ABC123', + event_id: 42, + status: 'ACTIVE', + contact_name: 'Erika Mustermann', + contact_email: 'erika@example.com', + contact_address: null, + guest_count: 2, + redeemed_at: new Date('2026-06-01T10:00:00Z'), + confirmation_email_status: 'FAILED' +}; + +// getRedemption issues: 1) SELECT redemptions, 2) SELECT redemption_guests +const connFor = (redemptionRows: any[], guestRows: any[] = []) => ({ + query: jest + .fn() + .mockResolvedValueOnce(redemptionRows) + .mockResolvedValueOnce(guestRows), + end: jest.fn().mockResolvedValue(undefined) +}); + +beforeEach(() => { + jest.clearAllMocks(); + mockSend.mockResolvedValue(true); +}); + +describe('resendRedemptionConfirmation', () => { + it('returns NOT_FOUND when the redemption does not exist', async () => { + mockGetConnection.mockResolvedValue(connFor([])); + + expect(await resendRedemptionConfirmation(5)).toBe('NOT_FOUND'); + expect(mockSend).not.toHaveBeenCalled(); + }); + + it('returns NOT_ACTIVE for an undone redemption', async () => { + mockGetConnection.mockResolvedValue(connFor([{...ACTIVE_ROW, status: 'UNDONE'}])); + + expect(await resendRedemptionConfirmation(5)).toBe('NOT_ACTIVE'); + expect(mockSend).not.toHaveBeenCalled(); + }); + + it('resends from the stored data and records SENT on success', async () => { + mockGetConnection.mockResolvedValue(connFor([ACTIVE_ROW], [{name: 'Erika Mustermann'}, {name: 'Hans Mustermann'}])); + + const result = await resendRedemptionConfirmation(5); + + expect(result).toBe('SENT'); + expect(mockSend).toHaveBeenCalledWith({ + eventId: 42, + contactName: 'Erika Mustermann', + contactEmail: 'erika@example.com', + guestNames: ['Erika Mustermann', 'Hans Mustermann'] + }); + expect(mockRecord).toHaveBeenCalledWith(5, true); + }); + + it('records FAILED and returns FAILED when the relay rejects the send', async () => { + mockGetConnection.mockResolvedValue(connFor([ACTIVE_ROW], [{name: 'Erika Mustermann'}])); + mockSend.mockResolvedValue(false); + + const result = await resendRedemptionConfirmation(5); + + expect(result).toBe('FAILED'); + expect(mockRecord).toHaveBeenCalledWith(5, false); + }); +});