@stamhoofd/models 2.1.1

package/src/factories/MemberFactory.ts

@@ -0,0 +1,122 @@
+import { Factory } from "@simonbackx/simple-database";
+import { Gender, MemberDetails, ParentType } from '@stamhoofd/structures';
+import { Formatter } from "@stamhoofd/utility";
+
+import { Member, MemberWithRegistrations } from "../models/Member";
+import { Organization } from "../models/Organization";
+import { User } from "../models/User";
+import { EmergencyContactFactory } from './EmergencyContactFactory';
+import { OrganizationFactory } from './OrganizationFactory';
+import { ParentFactory } from './ParentFactory';
+
+class Options {
+    organization?: Organization;
+    user?: User;
+
+    /// In order to add something to the keychain, we need the private key of the user (since everything needs to be signed)
+    userPrivateKey?: string;
+
+    minAge?: number
+    maxAge?: number
+}
+
+export class MemberFactory extends Factory<Options, MemberWithRegistrations> {
+    async create(): Promise<MemberWithRegistrations> {
+        const organization = this.options.organization
+            ?? await new OrganizationFactory({}).create()
+
+        const memberDetails = new MemberDetails()
+        const minAge = (this.options.minAge ?? 6)
+        const maxAge = this.options.maxAge ?? 18
+
+        memberDetails.gender = Math.random() >= 0.05 ? (Math.random() >= 0.5 ? Gender.Male : Gender.Female) : Gender.Other;
+        memberDetails.firstName = this.randomFirstName(memberDetails.gender);
+        memberDetails.birthDay = new Date(
+            new Date().getFullYear() -
+            (minAge + Math.floor(Math.random() * (maxAge - minAge + 1))),
+            Math.floor(Math.random() * 12), // 11 = 12
+            Math.floor(Math.random() * 31)
+        );
+
+        // For now only generate -18
+        memberDetails.address = null;
+
+        if (memberDetails.age! >= 14) {
+            memberDetails.phone =
+                "+32 47" +
+                Math.floor(Math.random() * 10) +
+                " " +
+                Math.floor(Math.random() * 10) +
+                Math.floor(Math.random() * 10) +
+                " " +
+                Math.floor(Math.random() * 10) +
+                Math.floor(Math.random() * 10) +
+                " " +
+                Math.floor(Math.random() * 10) +
+                Math.floor(Math.random() * 10);
+        }
+
+        let parentFactory = new ParentFactory({});
+
+        memberDetails.parents.push(await parentFactory.create());
+
+        // 80% chance to have 2 parents if not guardian
+        if (Math.random() >= 0.2 && memberDetails.parents[0].type != ParentType.Other) {
+            // 90% chance to have parents of different gender
+            parentFactory = new ParentFactory({
+                type:
+                    Math.random() >= 0.2
+                        ? memberDetails.parents[0].type == ParentType.Mother
+                            ? ParentType.Father
+                            : ParentType.Mother
+                        : undefined,
+            });
+
+            memberDetails.parents.push(await parentFactory.create());
+
+            if (Math.random() >= 0.1) {
+                // 10% chance to have divorced parents
+                memberDetails.parents[1].address = memberDetails.parents[0].address;
+            }
+        }
+
+        // Sort
+
+        if (memberDetails.parents.length == 2 && Math.random() >= 0.9) {
+            memberDetails.lastName = memberDetails.parents[0].lastName + "-" + memberDetails.parents[1].lastName;
+        } else {
+            if (memberDetails.parents[0].type == ParentType.Father) {
+                memberDetails.lastName = memberDetails.parents[0].lastName;
+            } else if (memberDetails.parents[1] && memberDetails.parents[1].type == ParentType.Father) {
+                memberDetails.lastName = memberDetails.parents[1].lastName;
+            } else {
+                memberDetails.lastName = memberDetails.parents[0].lastName;
+            }
+        }
+
+        if (memberDetails.age! >= 16) {
+            memberDetails.email = Formatter.slugEmail(memberDetails.firstName + "-" + memberDetails.lastName) + "@geen-email.com";
+        }
+
+        const emergencyContactFactory = new EmergencyContactFactory({});
+        memberDetails.emergencyContacts.push(await emergencyContactFactory.create());
+        if (Math.random() >= 0.9) {
+            memberDetails.emergencyContacts.push(await emergencyContactFactory.create());
+        }
+
+        const member = new Member()
+            .setManyRelation(Member.registrations, [])
+            .setManyRelation(Member.users, this.options.user ? [this.options.user] : [])
+
+        member.organizationId = organization.id
+        member.details = memberDetails
+        await member.save()
+
+        // Give user access to the encrypted data
+        if (this.options.user) {
+            await Member.users.link(member, [this.options.user])
+        }
+        
+        return member as any;
+    }
+}

package/src/factories/OrganizationFactory.ts

@@ -0,0 +1,45 @@
+import { Factory } from "@simonbackx/simple-database";
+import { Address,Country,OrganizationMetaData, OrganizationType, PermissionRoleDetailed } from "@stamhoofd/structures";
+import { Formatter } from "@stamhoofd/utility"; 
+
+import { Organization } from "../models/Organization";
+
+class Options {
+    uri?: string;
+    domain?: string;
+    meta?: OrganizationMetaData;
+    name?: string;
+    city?: string;
+    roles?: PermissionRoleDetailed[];
+}
+
+export class OrganizationFactory extends Factory<Options, Organization> {
+    async create(): Promise<Organization> {
+        const organization = new Organization();
+        organization.name = this.options.name ?? "Organization " + (new Date().getTime() + Math.floor(Math.random() * 999999));
+        organization.website = "https://domain.com";
+        organization.registerDomain = this.options.domain ?? null;
+        organization.uri = this.options.uri ?? Formatter.slug(organization.name);
+        organization.meta = this.options.meta ?? OrganizationMetaData.create({
+            type: this.randomEnum(OrganizationType),
+            umbrellaOrganization: null,
+            defaultEndDate: new Date(),
+            defaultStartDate: new Date(),
+            defaultPrices: []
+        });
+        organization.address = Address.create({
+            street: "Demostraat",
+            number: "12",
+            city: this.options.city ?? "Gent",
+            postalCode: "9000",
+            country: Country.Belgium
+        })
+
+        if (this.options.roles) {
+            organization.privateMeta.roles = this.options.roles;
+        }
+
+        await organization.save();
+        return organization;
+    }
+}

package/src/factories/ParentFactory.ts

@@ -0,0 +1,49 @@
+import { Factory } from "@simonbackx/simple-database";
+import { Gender, Parent, ParentType } from '@stamhoofd/structures';
+import { Formatter } from "@stamhoofd/utility";
+
+import { AddressFactory } from "./AddressFactory";
+
+interface Options {
+    type?: ParentType;
+}
+
+export class ParentFactory extends Factory<Options, Parent> {
+    async create(): Promise<Parent> {
+        const parent = new Parent();
+        parent.type = this.options.type ?? this.randomArray([ParentType.Mother, ParentType.Father, ParentType.Stepfather, ParentType.Stepmother, ParentType.Other]);
+        if (parent.type == ParentType.Other) {
+            // Second spin
+            parent.type = this.options.type ?? this.randomArray([ParentType.Mother, ParentType.Father, ParentType.Stepfather, ParentType.Stepmother, ParentType.Other]);
+        }
+
+        parent.firstName = this.randomFirstName(parent.type == ParentType.Mother ? Gender.Female : Gender.Male);
+        parent.lastName = this.randomLastName();
+
+        parent.address = await new AddressFactory({}).create();
+        parent.phone =
+            "+32 47" +
+            Math.floor(Math.random() * 10) +
+            " " +
+            Math.floor(Math.random() * 10) +
+            Math.floor(Math.random() * 10) +
+            " " +
+            Math.floor(Math.random() * 10) +
+            Math.floor(Math.random() * 10) +
+            " " +
+            Math.floor(Math.random() * 10) +
+            Math.floor(Math.random() * 10);
+
+        parent.email =
+            Formatter.slugEmail(
+                (Math.random() >= 0.5 ? parent.firstName.toLowerCase() : parent.firstName.toLowerCase()[0]) +
+                (Math.random() >= 0.5 ? "." : Math.random() >= 0.5 ? "_" : "") +
+                parent.lastName.toLowerCase().replace(" ", "")
+            ) +
+            "@" +
+            this.randomArray([
+                "geen-email.com"
+            ]);
+        return parent;
+    }
+}

package/src/factories/RecordFactory.ts

@@ -0,0 +1,12 @@
+import { Factory } from "@simonbackx/simple-database";
+import { LegacyRecord, LegacyRecordType } from '@stamhoofd/structures';
+
+interface Options {}
+
+export class RecordFactory extends Factory<Options, LegacyRecord> {LegacyRecordLegacyRecord
+    create(): Promise<LegacyRecord> {
+        return Promise.resolve(LegacyRecord.create({
+            type: this.randomArray(Object.values(LegacyRecordType))
+        }));
+    }
+}

package/src/factories/RegisterCodeFactory.ts

@@ -0,0 +1,25 @@
+import { Factory } from "@simonbackx/simple-database";
+
+import { RegisterCode } from "../models";
+
+type OrganizationOptions = {
+    organizationId: string
+} | {organization: {id: string}}
+
+type Options = OrganizationOptions & {
+    value?: number;
+    description?: string;
+}
+
+export class RegisterCodeFactory extends Factory<Options, RegisterCode> {
+    async create(): Promise<RegisterCode> {
+        const code = new RegisterCode();
+        code.organizationId = "organizationId" in this.options ? this.options.organizationId : this.options.organization.id;
+        code.value = this.options.value ?? (25 * 100);
+        code.description = this.options.description ?? "Test code";
+
+        await code.generateCode();
+        await code.save();
+        return code;
+    }
+}

package/src/factories/RegistrationFactory.ts

@@ -0,0 +1,32 @@
+import { Factory } from "@simonbackx/simple-database";
+
+import { Group } from "../models/Group";
+import { Member } from '../models/Member';
+import { Registration } from '../models/Registration';
+
+class Options {
+    member: Member;
+    group: Group;
+    waitingList?: boolean
+}
+
+export class RegistrationFactory extends Factory<Options, Registration> {
+    async create(): Promise<Registration> {
+        const registration = new Registration()
+        registration.memberId = this.options.member.id
+        registration.groupId = this.options.group.id
+        registration.periodId = this.options.group.periodId
+        registration.organizationId = this.options.group.organizationId
+        registration.cycle = this.options.group.cycle
+
+        if (this.options.waitingList !== true) {
+            registration.registeredAt = new Date()
+            registration.registeredAt.setMilliseconds(0)
+        } else {
+            registration.waitingList = true
+        }
+        
+        await registration.save()
+        return registration;
+    }
+}

package/src/factories/UserFactory.ts

@@ -0,0 +1,66 @@
+import { Factory } from "@simonbackx/simple-database";
+import { NewUser, Permissions, UserPermissions } from '@stamhoofd/structures';
+
+import { Organization } from "../models/Organization";
+import { User } from "../models/User";
+import { OrganizationFactory } from './OrganizationFactory';
+
+class Options {
+    organization?: Organization;
+    email?: string;
+    password?: string;
+    firstName?: string;
+    lastName?: string;
+    /**
+     * Default is true
+     */
+    verified?: boolean;
+    permissions?: Permissions | null
+    globalPermissions?: Permissions | null
+}
+
+export class UserFactory extends Factory<Options, User> {
+    async create(): Promise<User> {
+        let organization: Organization
+
+        if (!this.options.organization) {
+            const organizationFactory = new OrganizationFactory({})
+            organization = await organizationFactory.create()
+        } else {
+            organization = this.options.organization
+        }
+        
+        const email = this.options.email ?? "generated-email-" + this.randomString(20) + "@domain.com";
+        const password = this.options.password ?? this.randomString(20);
+
+        const user = await User.register(organization, NewUser.create({
+            email,
+            organizationId: organization.id,
+            password
+        }));
+        if (!user) {
+            throw new Error("Unexpected failure when creating user in factory");
+        }
+
+        if (this.options.permissions) {
+            user.permissions = UserPermissions.create({})
+            user.permissions.organizationPermissions.set(organization.id, this.options.permissions)
+        }
+
+        if (this.options.globalPermissions) {
+            if (!user.permissions) {
+                user.permissions = UserPermissions.create({})
+            }
+            user.permissions.globalPermissions = this.options.globalPermissions
+        }
+
+        user.firstName = this.options.firstName ?? null;
+        user.lastName = this.options.lastName ?? null;
+        
+        if (this.options.verified === undefined || this.options.verified === true) {
+            user.verified = true;
+        }
+        await user.save();
+        return user;
+    }
+}

package/src/factories/WebshopFactory.ts

@@ -0,0 +1,43 @@
+import { Factory } from "@simonbackx/simple-database";
+import { AutoEncoderPatchType } from "@simonbackx/simple-encoding";
+import { Product, WebshopMetaData, WebshopPrivateMetaData } from "@stamhoofd/structures";
+import { Formatter } from "@stamhoofd/utility";
+
+import { Webshop } from "../models";
+import { OrganizationFactory } from "./OrganizationFactory";
+
+class Options {
+    organizationId?: string
+    name?: string
+    meta?: WebshopMetaData|AutoEncoderPatchType<WebshopMetaData>
+    privateMeta?: WebshopPrivateMetaData|AutoEncoderPatchType<WebshopPrivateMetaData>
+    products?: Product[]
+}
+
+export class WebshopFactory extends Factory<Options, Webshop> {
+    async create(): Promise<Webshop> {
+        const organizationId = this.options.organizationId ?? (await new OrganizationFactory({}).create()).id;
+
+        const webshop = new Webshop();
+        webshop.organizationId = organizationId;
+        webshop.meta = WebshopMetaData.create({
+            name: this.options?.name ?? ("Webshop " + (new Date().getTime() + Math.floor(Math.random() * 999999)))
+        });
+        webshop.uri = Formatter.slug(this.randomString(20));
+
+        if (this.options.meta) {
+            webshop.meta.patchOrPut(this.options.meta);
+        }
+
+        if (this.options.privateMeta) {
+            webshop.privateMeta.patchOrPut(this.options.privateMeta);   
+        }
+
+        if (this.options.products) {
+            webshop.products = this.options.products;
+        }
+       
+        await webshop.save();
+        return webshop;
+    }
+}

package/src/helpers/DNSValidator.ts

@@ -0,0 +1,153 @@
+import { SimpleErrors, SimpleError } from "@simonbackx/simple-errors";
+import { DNSRecord, DNSRecordStatus, DNSRecordType } from "@stamhoofd/structures";
+import { sleep } from "@stamhoofd/utility";
+
+const { Resolver } = require('dns').promises;
+
+export async function validateDNSRecords(dnsRecords: DNSRecord[], didRetry = false) {
+     // Revalidate all
+    const resolver = new Resolver();
+    resolver.setServers(['1.1.1.1', '8.8.8.8', '8.8.4.4']);
+
+    let allValid = true
+
+    // If all non-TXT records are valid, we can already setup the register domain
+    let hasAllNonTXT = true
+
+    for (const record of dnsRecords) {
+        try {
+            switch (record.type) {
+                case DNSRecordType.CNAME: {
+
+                    const addresses: string[] = await resolver.resolveCname(record.name.substr(0, record.name.length - 1))
+                    record.errors = null;
+
+                    if (addresses.length == 0) {
+                        record.status = DNSRecordStatus.Pending
+                        allValid = false
+                        hasAllNonTXT = false
+
+                        record.errors = new SimpleErrors(new SimpleError({
+                            code: "not_found",
+                            message: "",
+                            human: "We konden de CNAME-record " + record.name + " nog niet vinden. Hou er rekening mee dat het even (tot 24u) kan duren voor we deze kunnen zien."
+                        }))
+                    } else if (addresses.length > 1) {
+                        record.status = DNSRecordStatus.Failed
+                        allValid = false
+                        hasAllNonTXT = false
+
+                        record.errors = new SimpleErrors(new SimpleError({
+                            code: "too_many_fields",
+                            message: "",
+                            human: "Er zijn meerdere CNAME records ingesteld voor " + record.name + ", kijk na of je er geen moet verwijderen of per ongeluk meerder hebt aangemaakt"
+                        }))
+                    } else {
+                        if (addresses[0] + "." === record.value) {
+                            record.status = DNSRecordStatus.Valid
+                        } else {
+                            record.status = DNSRecordStatus.Failed
+                            allValid = false
+                            hasAllNonTXT = false
+
+                            record.errors = new SimpleErrors(new SimpleError({
+                                code: "wrong_value",
+                                message: "",
+                                human: "Er is een andere waarde ingesteld voor de CNAME-record " + record.name + ", kijk na of je geen typfout hebt gemaakt. Gevonden: " + addresses[0] + "."
+                            }))
+                        }
+                    }
+
+                    break;
+                }
+
+                case DNSRecordType.TXT: {
+                    const records: string[][] = await resolver.resolveTxt(record.name.substr(0, record.name.length - 1))
+
+                    record.errors = null;
+
+                    if (records.length == 0) {
+                        record.status = DNSRecordStatus.Pending
+                        allValid = false
+
+                        record.errors = new SimpleErrors(new SimpleError({
+                            code: "not_found",
+                            message: "",
+                            human: "We konden de TXT-record " + record.name + " nog niet vinden. Hou er rekening mee dat het even (tot 24u) kan duren voor we deze kunnen zien."
+                        }))
+                    } else if (records.length > 1) {
+                        record.status = DNSRecordStatus.Failed
+                        allValid = false
+                        record.errors = new SimpleErrors(new SimpleError({
+                            code: "too_many_fields",
+                            message: "",
+                            human: "Er zijn meerdere TXT-records ingesteld voor " + record.name + ", kijk na of je er geen moet verwijderen of per ongeluk meerdere hebt aangemaakt"
+                        }))
+                    } else {
+                        const val = records[0].join("").trim()
+                        if (val === record.value.trim()) {
+                            /*if (records[0].length > 1 && val.length <= 255) {
+                                // Split was not needed and is not supported by SES
+                                record.status = DNSRecordStatus.Failed
+                                allValid = false
+
+                                record.errors = new SimpleErrors(new SimpleError({
+                                    code: "wrong_value",
+                                    message: "",
+                                    human: "De waarde komt overeen maar is op één of andere manier opgesplitst in meerdere stukken, terwijl dat niet nodig is. Dit wordt niet ondersteund door onze e-mailprovider. Contacteer ons als je de oorzaak niet kan achterhalen."
+                                }))
+                            } else {*/
+                                record.status = DNSRecordStatus.Valid
+                            //}
+                        } else {
+                            record.status = DNSRecordStatus.Failed
+                            allValid = false
+
+                            record.errors = new SimpleErrors(new SimpleError({
+                                code: "wrong_value",
+                                message: "",
+                                human: "Er is een andere waarde ingesteld voor de TXT-record " + record.name + ", kijk na of je geen typfout hebt gemaakt. Gevonden: " + records[0].join("")
+                            }))
+                        }
+                    }
+                    break;
+                }
+
+            }
+        } catch (e) {
+            record.status = DNSRecordStatus.Pending
+
+            if (e.code && (e.code == "ENOTFOUND" || e.code == "ENODATA")) {
+                record.errors = new SimpleErrors(new SimpleError({
+                    code: "not_found",
+                    message: "",
+                    human: "We konden de record " + record.name + " nog niet vinden. Hou er rekening mee dat het even (tot 24u) kan duren voor we deze kunnen zien."
+                }))
+            } else {
+                console.error(e)
+
+                record.errors = new SimpleErrors(new SimpleError({
+                    code: "not_found",
+                    message: "",
+                    human: "Er ging iets mis. Deze record lijkt niet goed ingesteld te zijn."
+                }))
+            }
+            allValid = false
+
+            if (record.type !== DNSRecordType.TXT) {
+                hasAllNonTXT = false
+            }
+        }
+    }
+
+    if (!allValid && !didRetry) {
+        // Do a retry once
+        await sleep(100)
+        return validateDNSRecords(dnsRecords, true)
+    }
+
+    return {
+        hasAllNonTXT,
+        allValid
+    }
+}

package/src/helpers/EmailBuilder.ts

@@ -0,0 +1,127 @@
+import { EmailAddress, EmailBuilder } from "@stamhoofd/email";
+import { Recipient, Replacement } from "@stamhoofd/structures";
+import { Formatter } from "@stamhoofd/utility";
+
+import { Organization, PasswordToken, User } from "../models";
+
+export async function getEmailBuilder(organization: Organization, email: {
+    defaultReplacements?: Replacement[],
+    recipients: Recipient[], 
+    from: string, 
+    replyTo?: string, 
+    subject: string, 
+    //text: string | null, 
+    html: string | null,
+    attachments?: {
+        filename: string;
+        content: string;
+        contentType: string | undefined;
+        encoding: string;
+    }[],
+    type?: "transactional" | "broadcast",
+    unsubscribeType?: 'all'|'marketing',
+    fromStamhoofd?: boolean,
+    singleBcc?: string
+}) {
+    // Update recipients
+    const cleaned: Recipient[] = []
+    for (const recipient of email.recipients) {
+        try {
+            const unsubscribe = await EmailAddress.getOrCreate(recipient.email, email.fromStamhoofd ? null : organization.id)
+
+            if (unsubscribe.unsubscribedAll || unsubscribe.hardBounce || unsubscribe.markedAsSpam || !unsubscribe.token || (unsubscribe.unsubscribedMarketing && email.unsubscribeType === 'marketing')) {
+                // Ignore
+                continue
+            }
+            recipient.replacements.push(Replacement.create({
+                token: "unsubscribeUrl",
+                value: "https://"+STAMHOOFD.domains.dashboard+"/"+organization.i18n.locale+"/unsubscribe?id="+encodeURIComponent(unsubscribe.id)+"&token="+encodeURIComponent(unsubscribe.token)+"&type="+encodeURIComponent(email.unsubscribeType ?? 'all')
+            }))
+
+            // Override headers
+            recipient.headers = {
+                'List-Unsubscribe': "<mailto:unsubscribe+"+unsubscribe.id+"@stamhoofd.email>",
+                'List-Unsubscribe-Post': 'List-Unsubscribe=One-Click'
+            }
+            cleaned.push(recipient)
+        } catch (e) {
+            console.error(e)
+        }
+    }
+    email.recipients = cleaned
+
+    // Update recipients
+    for (const recipient of email.recipients) {
+        recipient.replacements = recipient.replacements.slice()
+
+        // Default signInUrl
+        let signInUrl = "https://"+organization.getHost()+"/login?email="+encodeURIComponent(recipient.email)
+
+        if (recipient.userId) {
+            const recipientUser = await User.getByID(recipient.userId)
+            if (recipientUser && recipientUser.organizationId === organization.id && recipientUser.email === recipient.email) {
+                // We can create a special token
+                signInUrl = await PasswordToken.getMagicSignInUrl(recipientUser, organization)
+            }
+        }
+
+        recipient.replacements.push(Replacement.create({
+            token: "signInUrl",
+            value: signInUrl
+        }))
+
+        if (email.defaultReplacements) {
+            recipient.replacements.push(...email.defaultReplacements)
+        }
+
+        const extra = organization.meta.getEmailReplacements()
+        recipient.replacements.push(...extra)
+    }
+
+    const queue = email.recipients.slice()
+
+    let emailIndex = 0;
+
+    // Create e-mail builder
+    const builder: EmailBuilder = () => {
+        const recipient = queue.shift()
+        if (!recipient) {
+            return undefined
+        }
+
+        let replacedHtml = email.html
+        let replacedSubject = email.subject
+        //let replacedText = email.text
+
+        for (const replacement of recipient.replacements) {
+            if (replacedHtml) {
+                replacedHtml = replacedHtml.replaceAll("{{"+replacement.token+"}}", replacement.html ?? Formatter.escapeHtml(replacement.value))
+            }
+            //if (replacedText) {
+            //    replacedText = replacedText.replaceAll("{{"+replacement.token+"}}", replacement.value)
+            //}
+            replacedSubject = replacedSubject.replaceAll("{{"+replacement.token+"}}", replacement.value)
+        }
+
+        emailIndex += 1;
+
+        return {
+            from: email.from,
+            replyTo: email.replyTo,
+            bcc: emailIndex === 1 ? email.singleBcc : undefined,
+            to: [
+                {
+                    // Name will get cleaned by email service
+                    name: (recipient.firstName??'')+" "+(recipient.lastName??''),
+                    email: recipient.email
+                }
+            ],
+            subject: replacedSubject,
+            html: replacedHtml ?? undefined,
+            attachments: email.attachments,
+            headers: recipient.headers,
+            type: email.type
+        }
+    }
+    return builder;
+}