@stamhoofd/backend 2.60.0 → 2.61.1

package/src/crons/postmark.ts

@@ -0,0 +1,223 @@
+import { Email, EmailAddress } from '@stamhoofd/email';
+import { AuditLog, Organization } from '@stamhoofd/models';
+import { DateTime } from 'luxon';
+
+import { registerCron } from '@stamhoofd/crons';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogSource, AuditLogType } from '@stamhoofd/structures';
+
+// Importing postmark returns undefined (this is a bug, so we need to use require)
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const postmark = require('postmark') as typeof import('postmark');
+
+let lastPostmarkCheck: Date | null = null;
+let lastPostmarkIds: Set<number> = new Set();
+
+registerCron('checkPostmarkBounces', checkPostmarkBounces);
+
+async function saveLog({ email, organization, type, subType, id, response, subject, sender }: { id: number; sender: string; email: string; response: string; subject: string;organization: Organization | undefined; type: AuditLogType; subType?: string }) {
+    const log = new AuditLog();
+    log.organizationId = organization?.id ?? null;
+    log.externalId = 'postmark-bounce-' + id.toString();
+    log.type = type;
+    log.objectId = email;
+    log.source = AuditLogSource.System;
+    log.replacements = new Map([
+        ['e', AuditLogReplacement.create({
+            value: email || '',
+            type: AuditLogReplacementType.EmailAddress,
+        })],
+        ['subType', AuditLogReplacement.key(subType || 'unknown')],
+        ['response', AuditLogReplacement.longText(response)],
+        ['sender', AuditLogReplacement.create({
+            value: sender,
+            type: AuditLogReplacementType.EmailAddress,
+        })],
+    ]);
+
+    if (subject) {
+        log.replacements.set('subject', AuditLogReplacement.string(subject));
+    }
+
+    // Check if we already logged this bounce
+    const existing = await AuditLog.select().where('externalId', log.externalId).first(false);
+    if (existing) {
+        console.log('Already logged this bounce, skipping');
+        return;
+    }
+
+    await log.save();
+}
+
+async function checkPostmarkBounces() {
+    if (STAMHOOFD.environment !== 'production') {
+        return;
+    }
+
+    const token = STAMHOOFD.POSTMARK_SERVER_TOKEN;
+    if (!token) {
+        console.log('No postmark token, skipping postmark bounces');
+        return;
+    }
+    const fromDate = (lastPostmarkCheck ?? new Date(new Date().getTime() - 24 * 60 * 60 * 1000 * 2));
+    const ET = DateTime.fromJSDate(fromDate).setZone('EST').toISO({ includeOffset: false });
+
+    if (!ET) {
+        console.error('Could not convert date to EST:', fromDate);
+        return;
+    }
+    console.log('Checking bounces from Postmark since', fromDate, ET);
+    const client = new postmark.ServerClient(token);
+
+    const toDate = DateTime.now().setZone('EST').toISO({ includeOffset: false });
+
+    if (!toDate) {
+        console.error('Could not convert date to EST:', new Date());
+        return;
+    }
+
+    let offset = 0;
+    let total = 1;
+    const count = 500;
+
+    // Sadly the postmark api returns bounces in the wrong order, to make them easier fetchable so we need to fetch them all in one go every time
+    while (offset < total && offset <= 10000 - count) {
+        const bounces = await client.getBounces({
+            fromDate: ET,
+            toDate,
+            count,
+            offset,
+        });
+
+        if (bounces.TotalCount === 0) {
+            console.log('No Postmark bounces at this time');
+            return;
+        }
+
+        total = bounces.TotalCount;
+
+        console.log('Found', bounces.TotalCount, 'bounces from Postmark');
+
+        let lastId: number | null = null;
+        const idList = new Set<number>();
+        let newEventCount = 0;
+
+        for (const bounce of bounces.Bounces) {
+            idList.add(bounce.ID);
+            if (lastPostmarkIds.has(bounce.ID)) {
+                lastId = bounce.ID;
+                continue;
+            }
+            newEventCount += 1;
+
+            // Try to get the organization, if possible, else default to global blocking: "null", which is not visible for an organization, but it is applied
+            const source = bounce.From;
+            const organization = source ? await Organization.getByEmail(source) : undefined;
+            console.log(bounce);
+
+            if (bounce.Type === 'SpamComplaint' || bounce.Type === 'SpamNotification' || bounce.Type === 'VirusNotification') {
+                console.log('Postmark ' + bounce.Type + ' for: ', bounce.Email, 'from', source, 'organization', organization?.name);
+                const emailAddress = await EmailAddress.getOrCreate(bounce.Email, organization?.id ?? null);
+                emailAddress.markedAsSpam = true;
+                await emailAddress.save();
+
+                if (bounce.Type === 'VirusNotification') {
+                    await saveLog({
+                        email: bounce.Email,
+                        organization,
+                        type: AuditLogType.EmailAddressFraudComplaint,
+                        subType: bounce.Type,
+                        response: bounce.Details,
+                        id: bounce.ID,
+                        subject: bounce.Subject,
+                        sender: bounce.From,
+                    });
+                }
+                else {
+                    await saveLog({
+                        email: bounce.Email,
+                        organization,
+                        type: AuditLogType.EmailAddressMarkedAsSpam,
+                        subType: bounce.Type,
+                        response: bounce.Details,
+                        id: bounce.ID,
+                        subject: bounce.Subject,
+                        sender: bounce.From,
+                    });
+                }
+            }
+            else if (bounce.Inactive) {
+                // Block for everyone, but not visible
+                console.log('Postmark ' + bounce.Type + ' for: ', bounce.Email, 'from', source, 'organization', organization?.name);
+                const emailAddress = await EmailAddress.getOrCreate(bounce.Email, organization?.id ?? null);
+                emailAddress.hardBounce = true;
+                await emailAddress.save();
+                await saveLog({
+                    email: bounce.Email,
+                    organization,
+                    type: AuditLogType.EmailAddressHardBounced,
+                    subType: bounce.Type,
+                    response: bounce.Details,
+                    id: bounce.ID,
+                    subject: bounce.Subject,
+                    sender: bounce.From,
+                });
+            }
+            else {
+                if (bounce.Type === 'SMTPApiError' && bounce.Details.startsWith("ErrorCode: '406'")) {
+                    console.log('Email on Postmark suppression list: ' + bounce.Type + ': ', bounce.Email, 'from', source, 'organization', organization?.name);
+
+                    // We've sent a message to an email that is blocked by Postmark
+                    await saveLog({
+                        email: bounce.Email,
+                        organization,
+                        type: AuditLogType.EmailAddressHardBounced,
+                        subType: 'ExternalSuppressionList',
+                        response: bounce.Details,
+                        id: bounce.ID,
+                        subject: '', // bounce.Subject is not correct here for some reason
+                        sender: bounce.From,
+                    });
+                }
+                else {
+                    if (bounce.Type === 'SMTPApiError') {
+                        // Log internally
+                        Email.sendWebmaster({
+                            subject: 'Received an SMTPApiError from Postmark',
+                            text: 'We received an SMTPApiError for an e-mail from the organization: ' + organization?.name + '. Please check and adjust if needed.\n' + JSON.stringify(bounce, undefined, 4),
+                        });
+                    }
+                    else {
+                        console.log('Unhandled Postmark ' + bounce.Type + ': ', bounce.Email, 'from', source, 'organization', organization?.name);
+
+                        await saveLog({
+                            email: bounce.Email,
+                            organization,
+                            type: AuditLogType.EmailAddressSoftBounced,
+                            subType: bounce.Type,
+                            response: bounce.Details,
+                            id: bounce.ID,
+                            subject: bounce.Subject,
+                            sender: bounce.From,
+                        });
+                    }
+                }
+            }
+
+            const bouncedAt = new Date(bounce.BouncedAt);
+            lastPostmarkCheck = lastPostmarkCheck ? new Date(Math.max(bouncedAt.getTime(), lastPostmarkCheck.getTime())) : bouncedAt;
+
+            lastId = bounce.ID;
+        }
+
+        if (lastId && newEventCount === 0) {
+            console.log('Postmark has no new bounces');
+            // Increase timestamp by one second to avoid refetching it every time
+            if (lastPostmarkCheck) {
+                lastPostmarkCheck = new Date(lastPostmarkCheck.getTime() + 1000);
+            }
+        }
+        lastPostmarkIds = idList;
+
+        offset += bounces.Bounces.length;
+    }
+}

package/src/crons.ts

@@ -1,25 +1,13 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
 import { Database } from '@simonbackx/simple-database';
-import { Email, EmailAddress } from '@stamhoofd/email';
 import { Group, Organization, Payment, Registration, STPackage, Webshop } from '@stamhoofd/models';
 import { PaymentMethod, PaymentProvider, PaymentStatus } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
-import AWS from 'aws-sdk';
-import { DateTime } from 'luxon';
 
 import { registerCron } from '@stamhoofd/crons';
-import { clearExcelCache } from './crons/clearExcelCache';
-import { endFunctionsOfUsersWithoutRegistration } from './crons/endFunctionsOfUsersWithoutRegistration';
-import { ExchangePaymentEndpoint } from './endpoints/organization/shared/ExchangePaymentEndpoint';
 import { checkSettlements } from './helpers/CheckSettlements';
-import { ForwardHandler } from './helpers/ForwardHandler';
 import { PaymentService } from './services/PaymentService';
 import { RegistrationService } from './services/RegistrationService';
 
-// Importing postmark returns undefined (this is a bug, so we need to use require)
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const postmark = require('postmark');
-
 let lastDNSCheck: Date | null = null;
 let lastDNSId = '';
 async function checkDNS() {
@@ -133,303 +121,6 @@ async function checkWebshopDNS() {
     lastWebshopDNSId = webshops[webshops.length - 1].id;
 }
 
-async function checkReplies() {
-    if (STAMHOOFD.environment !== 'production' || !STAMHOOFD.AWS_ACCESS_KEY_ID) {
-        return;
-    }
-
-    console.log('Checking replies from AWS SQS');
-    const sqs = new AWS.SQS();
-    const messages = await sqs.receiveMessage({ QueueUrl: 'https://sqs.eu-west-1.amazonaws.com/118244293157/stamhoofd-email-forwarding', MaxNumberOfMessages: 10 }).promise();
-    if (messages.Messages) {
-        for (const message of messages.Messages) {
-            console.log('Received message from forwarding queue');
-
-            if (message.ReceiptHandle) {
-                if (STAMHOOFD.environment === 'production') {
-                    await sqs.deleteMessage({
-                        QueueUrl: 'https://sqs.eu-west-1.amazonaws.com/118244293157/stamhoofd-email-forwarding',
-                        ReceiptHandle: message.ReceiptHandle,
-                    }).promise();
-                    console.log('Deleted from queue');
-                }
-            }
-
-            try {
-                if (message.Body) {
-                    // decode the JSON value
-                    const bounce = JSON.parse(message.Body);
-
-                    if (bounce.Message) {
-                        const message = JSON.parse(bounce.Message);
-
-                        // Read message content
-                        if (message.mail && message.content && message.receipt) {
-                            const content = message.content;
-                            const receipt = message.receipt as {
-                                recipients: string[];
-                                spamVerdict: { status: 'PASS' | string };
-                                virusVerdict: { status: 'PASS' | string };
-                                spfVerdict: { status: 'PASS' | string };
-                                dkimVerdict: { status: 'PASS' | string };
-                                dmarcVerdict: { status: 'PASS' | string };
-                            };
-
-                            const options = await ForwardHandler.handle(content, receipt);
-                            if (options) {
-                                if (STAMHOOFD.environment === 'production') {
-                                    Email.send(options);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            catch (e) {
-                console.error(e);
-            }
-        }
-    }
-}
-
-let lastPostmarkCheck: Date | null = null;
-let lastPostmarkId: string | null = null;
-async function checkPostmarkBounces() {
-    if (STAMHOOFD.environment !== 'production') {
-        return;
-    }
-
-    const token = STAMHOOFD.POSTMARK_SERVER_TOKEN;
-    if (!token) {
-        console.log('[POSTMARK BOUNCES] No postmark token, skipping postmark bounces');
-        return;
-    }
-    const fromDate = (lastPostmarkCheck ?? new Date(new Date().getTime() - 24 * 60 * 60 * 1000 * 2));
-    const ET = DateTime.fromJSDate(fromDate).setZone('EST').toISO({ includeOffset: false });
-    console.log('[POSTMARK BOUNCES] Checking bounces from Postmark since', fromDate, ET);
-    const client = new postmark.ServerClient(token);
-
-    const bounces = await client.getBounces({
-        fromdate: ET,
-        todate: DateTime.now().setZone('EST').toISO({ includeOffset: false }),
-        count: 500,
-        offset: 0,
-    });
-
-    if (bounces.TotalCount == 0) {
-        console.log('[POSTMARK BOUNCES] No Postmark bounces at this time');
-        return;
-    }
-
-    let lastId: string | null = null;
-
-    for (const bounce of bounces.Bounces) {
-        // Try to get the organization, if possible, else default to global blocking: "null", which is not visible for an organization, but it is applied
-        const source = bounce.From;
-        const organization = source ? await Organization.getByEmail(source) : undefined;
-
-        if (bounce.Type === 'HardBounce' || bounce.Type === 'BadEmailAddress' || bounce.Type === 'Blocked') {
-            // Block for everyone, but not visible
-            console.log('[POSTMARK BOUNCES] Postmark ' + bounce.Type + ' for: ', bounce.Email, 'from', source, 'organization', organization?.name);
-            const emailAddress = await EmailAddress.getOrCreate(bounce.Email, organization?.id ?? null);
-            emailAddress.hardBounce = true;
-            await emailAddress.save();
-        }
-        else if (bounce.Type === 'SpamComplaint' || bounce.Type === 'SpamNotification' || bounce.Type === 'VirusNotification') {
-            console.log('[POSTMARK BOUNCES] Postmark ' + bounce.Type + ' for: ', bounce.Email, 'from', source, 'organization', organization?.name);
-            const emailAddress = await EmailAddress.getOrCreate(bounce.Email, organization?.id ?? null);
-            emailAddress.markedAsSpam = true;
-            await emailAddress.save();
-        }
-        else {
-            console.log('[POSTMARK BOUNCES] Unhandled Postmark ' + bounce.Type + ': ', bounce.Email, 'from', source, 'organization', organization?.name);
-            console.error('[POSTMARK BOUNCES] Unhandled Postmark ' + bounce.Type + ': ', bounce.Email, 'from', source, 'organization', organization?.name);
-        }
-
-        const bouncedAt = new Date(bounce.BouncedAt);
-        lastPostmarkCheck = lastPostmarkCheck ? new Date(Math.max(bouncedAt.getTime(), lastPostmarkCheck.getTime())) : bouncedAt;
-
-        lastId = bounce.ID;
-    }
-
-    if (lastId && lastPostmarkId) {
-        if (lastId === lastPostmarkId) {
-            console.log('[POSTMARK BOUNCES] Postmark has no new bounces');
-            // Increase timestamp by one second to avoid refetching it every time
-            if (lastPostmarkCheck) {
-                lastPostmarkCheck = new Date(lastPostmarkCheck.getTime() + 1000);
-            }
-        }
-    }
-    lastPostmarkId = lastId;
-}
-
-async function checkBounces() {
-    if (STAMHOOFD.environment !== 'production' || !STAMHOOFD.AWS_ACCESS_KEY_ID) {
-        return;
-    }
-
-    console.log('[AWS BOUNCES] Checking bounces from AWS SQS');
-    const sqs = new AWS.SQS();
-    const messages = await sqs.receiveMessage({ QueueUrl: 'https://sqs.eu-west-1.amazonaws.com/118244293157/stamhoofd-bounces-queue', MaxNumberOfMessages: 10 }).promise();
-    if (messages.Messages) {
-        for (const message of messages.Messages) {
-            console.log('[AWS BOUNCES] Received bounce message');
-            console.log('[AWS BOUNCES]', message);
-
-            if (message.ReceiptHandle) {
-                if (STAMHOOFD.environment === 'production') {
-                    await sqs.deleteMessage({
-                        QueueUrl: 'https://sqs.eu-west-1.amazonaws.com/118244293157/stamhoofd-bounces-queue',
-                        ReceiptHandle: message.ReceiptHandle,
-                    }).promise();
-                    console.log('[AWS BOUNCES] Deleted from queue');
-                }
-            }
-
-            try {
-                if (message.Body) {
-                    // decode the JSON value
-                    const bounce = JSON.parse(message.Body);
-
-                    if (bounce.Message) {
-                        const message = JSON.parse(bounce.Message);
-
-                        if (message.bounce) {
-                            const b = message.bounce;
-                            // Block all receivers that generate a permanent bounce
-                            const type = b.bounceType;
-
-                            const source = message.mail.source;
-
-                            // try to find organization that is responsible for this e-mail address
-
-                            for (const recipient of b.bouncedRecipients) {
-                                const email = recipient.emailAddress;
-
-                                if (
-                                    type === 'Permanent'
-                                    || (
-                                        recipient.diagnosticCode && (
-                                            (recipient.diagnosticCode as string).toLowerCase().includes('invalid domain')
-                                            || (recipient.diagnosticCode as string).toLowerCase().includes('unable to lookup dns')
-                                        )
-                                    )
-                                ) {
-                                    const organization: Organization | undefined = source ? await Organization.getByEmail(source) : undefined;
-                                    if (organization) {
-                                        const emailAddress = await EmailAddress.getOrCreate(email, organization.id);
-                                        emailAddress.hardBounce = true;
-                                        await emailAddress.save();
-                                    }
-                                    else {
-                                        console.error('[AWS BOUNCES] Unknown organization for email address ' + source);
-                                    }
-                                }
-                            }
-                            console.log('[AWS BOUNCES] For domain ' + source);
-                        }
-                        else {
-                            console.log("[AWS BOUNCES] 'bounce' field missing in bounce message");
-                        }
-                    }
-                    else {
-                        console.log("[AWS BOUNCES] 'Message' field missing in bounce message");
-                    }
-                }
-                else {
-                    console.log('[AWS BOUNCES] Message Body missing in bounce');
-                }
-            }
-            catch (e) {
-                console.log('[AWS BOUNCES] Bounce message processing failed:');
-                console.error('[AWS BOUNCES] Bounce message processing failed:');
-                console.error('[AWS BOUNCES]', e);
-            }
-        }
-    }
-}
-
-async function checkComplaints() {
-    if (STAMHOOFD.environment !== 'production' || !STAMHOOFD.AWS_ACCESS_KEY_ID) {
-        return;
-    }
-
-    console.log('[AWS COMPLAINTS] Checking complaints from AWS SQS');
-    const sqs = new AWS.SQS();
-    const messages = await sqs.receiveMessage({ QueueUrl: 'https://sqs.eu-west-1.amazonaws.com/118244293157/stamhoofd-complaints-queue', MaxNumberOfMessages: 10 }).promise();
-    if (messages.Messages) {
-        for (const message of messages.Messages) {
-            console.log('[AWS COMPLAINTS] Received complaint message');
-            console.log('[AWS COMPLAINTS]', message);
-
-            if (message.ReceiptHandle) {
-                if (STAMHOOFD.environment === 'production') {
-                    await sqs.deleteMessage({
-                        QueueUrl: 'https://sqs.eu-west-1.amazonaws.com/118244293157/stamhoofd-complaints-queue',
-                        ReceiptHandle: message.ReceiptHandle,
-                    }).promise();
-                    console.log('[AWS COMPLAINTS] Deleted from queue');
-                }
-            }
-
-            try {
-                if (message.Body) {
-                    // decode the JSON value
-                    const complaint = JSON.parse(message.Body);
-                    console.log('[AWS COMPLAINTS]', complaint);
-
-                    if (complaint.Message) {
-                        const message = JSON.parse(complaint.Message);
-
-                        if (message.complaint) {
-                            const b = message.complaint;
-                            const source = message.mail.source;
-                            const organization: Organization | undefined = source ? await Organization.getByEmail(source) : undefined;
-
-                            const type: 'abuse' | 'auth-failure' | 'fraud' | 'not-spam' | 'other' | 'virus' = b.complaintFeedbackType;
-
-                            if (organization) {
-                                for (const recipient of b.complainedRecipients) {
-                                    const email = recipient.emailAddress;
-                                    const emailAddress = await EmailAddress.getOrCreate(email, organization.id);
-                                    emailAddress.markedAsSpam = type !== 'not-spam';
-                                    await emailAddress.save();
-                                }
-                            }
-                            else {
-                                console.error('[AWS COMPLAINTS] Unknown organization for email address ' + source);
-                            }
-
-                            if (type == 'virus' || type == 'fraud') {
-                                console.error('[AWS COMPLAINTS] Received virus / fraud complaint!');
-                                console.error('[AWS COMPLAINTS]', complaint);
-                                if (STAMHOOFD.environment === 'production') {
-                                    Email.sendWebmaster({
-                                        subject: 'Received a ' + type + ' email notification',
-                                        text: 'We received a ' + type + ' notification for an e-mail from the organization: ' + organization?.name + '. Please check and adjust if needed.\n',
-                                    });
-                                }
-                            }
-                        }
-                        else {
-                            console.log('[AWS COMPLAINTS] Missing complaint field');
-                        }
-                    }
-                    else {
-                        console.log('[AWS COMPLAINTS] Missing message field in complaint');
-                    }
-                }
-            }
-            catch (e) {
-                console.log('[AWS COMPLAINTS] Complain message processing failed:');
-                console.error('[AWS COMPLAINTS] Complain message processing failed:');
-                console.error('[AWS COMPLAINTS]', e);
-            }
-        }
-    }
-}
-
 // Keep checking pending paymetns for 3 days
 async function checkPayments() {
     if (STAMHOOFD.environment === 'development') {
@@ -658,14 +349,11 @@ async function checkDrips() {
 
 registerCron('checkSettlements', checkSettlements);
 registerCron('checkExpirationEmails', checkExpirationEmails);
-registerCron('checkPostmarkBounces', checkPostmarkBounces);
 registerCron('checkReservedUntil', checkReservedUntil);
-registerCron('checkComplaints', checkComplaints);
-registerCron('checkReplies', checkReplies);
-registerCron('checkBounces', checkBounces);
 registerCron('checkDNS', checkDNS);
 registerCron('checkWebshopDNS', checkWebshopDNS);
 registerCron('checkPayments', checkPayments);
 registerCron('checkDrips', checkDrips);
-registerCron('clearExcelCache', clearExcelCache);
-registerCron('endFunctionsOfUsersWithoutRegistration', endFunctionsOfUsersWithoutRegistration);
+
+// Register other crons
+import './crons/index.js';

package/src/helpers/MemberUserSyncer.ts

@@ -187,7 +187,6 @@ export class MemberUserSyncerStatic {
 
         if (user.memberId === member.id) {
             user.memberId = null;
-            await user.save();
         }
 
         // Update model relation to correct response
@@ -239,11 +238,7 @@ export class MemberUserSyncerStatic {
                 await this.updateInheritedPermissions(user);
             }
             else {
-                if (user.memberId === member.id) {
-                    // Unlink: parents are never 'equal' to the member
-                    user.memberId = null;
-                    await this.updateInheritedPermissions(user);
-                }
+                let shouldSave = false;
 
                 if (!user.firstName && !user.lastName) {
                     const parents = member.details.parents.filter(p => p.email === email);
@@ -252,13 +247,22 @@ export class MemberUserSyncerStatic {
                             user.firstName = parents[0].firstName;
                             user.lastName = parents[0].lastName;
                         }
-                        await user.save();
+                        shouldSave = true;
                     }
                 }
 
                 if (user.firstName === member.details.firstName && user.lastName === member.details.lastName) {
                     user.firstName = null;
                     user.lastName = null;
+                    shouldSave = true;
+                }
+
+                if (user.memberId === member.id) {
+                    // Unlink: parents are never 'equal' to the member
+                    user.memberId = null;
+                    await this.updateInheritedPermissions(user);
+                }
+                if (shouldSave) {
                     await user.save();
                 }
             }

package/src/services/AuditLogService.ts

@@ -16,6 +16,10 @@ import { RegistrationLogger } from '../audit-logs/RegistrationLogger';
 import { RegistrationPeriodLogger } from '../audit-logs/RegistrationPeriodLogger';
 import { StripeAccountLogger } from '../audit-logs/StripeAccountLogger';
 import { WebshopLogger } from '../audit-logs/WebshopLogger';
+import { EmailLogger } from '../audit-logs/EmailLogger';
+import { EmailTemplateLogger } from '../audit-logs/EmailTemplateLogger';
+import { EmailAddressLogger } from '../audit-logs/EmailAddressLogger';
+import { UserLogger } from '../audit-logs/UserLogger';
 
 export type AuditLogContextSettings = {
     disable?: boolean;
@@ -100,3 +104,7 @@ modelLogDefinitions.set(PaymentLogger.model, PaymentLogger);
 modelLogDefinitions.set(MemberPlatformMembershipLogger.model, MemberPlatformMembershipLogger);
 modelLogDefinitions.set(MemberResponsibilityRecordLogger.model, MemberResponsibilityRecordLogger);
 modelLogDefinitions.set(DocumentTemplateLogger.model, DocumentTemplateLogger);
+modelLogDefinitions.set(EmailLogger.model, EmailLogger);
+modelLogDefinitions.set(EmailTemplateLogger.model, EmailTemplateLogger);
+modelLogDefinitions.set(EmailAddressLogger.model, EmailAddressLogger);
+modelLogDefinitions.set(UserLogger.model, UserLogger);

package/src/services/diff.ts

@@ -84,6 +84,9 @@ function getDiffName(autoEncoder: unknown): AuditLogReplacement | null {
         if (typeof name === 'string') {
             return name ? AuditLogReplacement.string(name) : AuditLogReplacement.key('untitled');
         }
+        if (name instanceof AuditLogReplacement) {
+            return name;
+        }
     }
 
     if (typeof autoEncoder === 'object' && autoEncoder !== null && 'name' in autoEncoder && typeof autoEncoder.name === 'string') {
@@ -109,6 +112,12 @@ function getDiffValue(autoEncoder: unknown, key?: AuditLogReplacement): AuditLog
         if (DataValidator.isUuid(autoEncoder)) {
             return AuditLogReplacement.uuid(autoEncoder);
         }
+
+        // Is html
+        if (autoEncoder.startsWith('<!DOCTYPE html>')) {
+            return AuditLogReplacement.html(autoEncoder);
+        }
+
         if (key && key?.lastValue() === 'status') {
             // Will be an enum
             return AuditLogReplacement.key(autoEncoder);
@@ -157,13 +166,6 @@ function getDiffValue(autoEncoder: unknown, key?: AuditLogReplacement): AuditLog
     return null;
 }
 
-function getKeySingular(key?: string) {
-    if (key === undefined) {
-        return undefined;
-    }
-    return key.replace(/ies$/, 'y').replace(/s$/, '');
-}
-
 function findOriginalById(id: unknown, oldArray: unknown[]): unknown | null {
     return id ? oldArray.find(v => getId(v) === id) : null;
 }
@@ -397,7 +399,7 @@ export function diffUnknown(oldValue: unknown, value: unknown, key?: AuditLogRep
 
     if (v && ov) {
         // Simplify change
-        if (v.toString() === ov.toString()) {
+        if (v.toKey() === ov.toKey()) {
             v = null;
             ov = null;