@stamhoofd/models 2.1.1

package/dist/src/models/Organization.js

@@ -0,0 +1,900 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Organization = void 0;
+const tslib_1 = require("tslib");
+const simple_database_1 = require("@simonbackx/simple-database");
+const simple_errors_1 = require("@simonbackx/simple-errors");
+const backend_i18n_1 = require("@stamhoofd/backend-i18n");
+const email_1 = require("@stamhoofd/email");
+const structures_1 = require("@stamhoofd/structures");
+const utility_1 = require("@stamhoofd/utility");
+const sesv2_1 = tslib_1.__importDefault(require("aws-sdk/clients/sesv2"));
+const uuid_1 = require("uuid");
+const DNSValidator_1 = require("../helpers/DNSValidator");
+const EmailBuilder_1 = require("../helpers/EmailBuilder");
+const OrganizationServerMetaData_1 = require("../structures/OrganizationServerMetaData");
+const _1 = require("./");
+class Organization extends simple_database_1.Model {
+    constructor() {
+        super(...arguments);
+        /// URL to a website page or a Facebook page (including http)
+        this.website = null;
+        /// A custom domain name that is used to host the register application (should be unique)
+        // E.g. inschrijven.scoutswetteren.be
+        this.registerDomain = null;
+        /**
+         * Data only accessible by the owners / users with special permissions
+         */
+        this.privateMeta = structures_1.OrganizationPrivateMetaData.create({});
+        /**
+         * Data only accessible by the server
+         */
+        this.serverMeta = OrganizationServerMetaData_1.OrganizationServerMetaData.create({});
+    }
+    /**
+     * Return default locale confiruation
+     */
+    get i18n() {
+        return new backend_i18n_1.I18n("nl", this.address.country);
+    }
+    /**
+     * Makes sure empty name is replaced with organization name
+     */
+    get mappedTransferSettings() {
+        return this.meta.transferSettings.fillMissing(structures_1.TransferSettings.create({ creditor: this.name }));
+    }
+    // Methods
+    static async getByURI(uri) {
+        const [rows] = await simple_database_1.Database.select(`SELECT ${this.getDefaultSelect()} FROM ${this.table} WHERE \`uri\` = ? LIMIT 1`, [uri]);
+        if (rows.length == 0) {
+            return undefined;
+        }
+        // Read member + address from first row
+        return this.fromRow(rows[0][this.table]);
+    }
+    // Methods
+    static async getByEmail(email) {
+        if (["hallo@stamhoofd.be", "hallo@stamhoofd.nl"].includes(email)) {
+            return;
+        }
+        if (email.startsWith('noreply-')) {
+            // Trim
+            email = email.substring("noreply-".length);
+        }
+        if (email.endsWith("@stamhoofd.email")) {
+            const uri = email.substring(0, email.length - "@stamhoofd.email".length);
+            return await Organization.getByURI(uri);
+        }
+        if (email.endsWith("@stamhoofd.be")) {
+            const uri = email.substring(0, email.length - "@stamhoofd.be".length);
+            return await Organization.getByURI(uri);
+        }
+        if (email.endsWith("@stamhoofd.nl")) {
+            const uri = email.substring(0, email.length - "@stamhoofd.nl".length);
+            return await Organization.getByURI(uri);
+        }
+        const at = email.indexOf("@");
+        const domain = email.substring(at + 1);
+        const [rows] = await simple_database_1.Database.select(`SELECT ${this.getDefaultSelect()} FROM ${this.table} WHERE privateMeta->"$.value.mailDomain" = ? LIMIT 1`, [domain]);
+        if (rows.length == 0) {
+            return undefined;
+        }
+        // Read member + address from first row
+        return this.fromRow(rows[0][this.table]);
+    }
+    // Methods
+    static async getByRegisterDomain(host) {
+        const [rows] = await simple_database_1.Database.select(`SELECT ${this.getDefaultSelect()} FROM ${this.table} WHERE \`registerDomain\` = ? LIMIT 1`, [host]);
+        if (rows.length == 0) {
+            return undefined;
+        }
+        // Read member + address from first row
+        return this.fromRow(rows[0][this.table]);
+    }
+    /**
+     * Get an Organization by looking at the host of a request
+     * Format is 2331c59a-0cbe-4279-871c-ea9d0474cd54.api.stamhoofd.app
+     * + switch country if needed
+     */
+    static async getFromRequest(request) {
+        const organization = await Organization.fromApiHost(request.host);
+        const i18n = backend_i18n_1.I18n.fromRequest(request);
+        i18n.switchToLocale({ country: organization.address.country });
+        return organization;
+    }
+    /**
+     * Get an Organization by looking at the host of a request
+     * Format is 2331c59a-0cbe-4279-871c-ea9d0474cd54.api.stamhoofd.app
+     */
+    static async fromApiHost(host) {
+        const splitted = host.split('.');
+        if (splitted.length < 2) {
+            throw new simple_errors_1.SimpleError({
+                code: "invalid_host",
+                message: "Please specify the organization in the hostname",
+            });
+        }
+        const id = splitted[0];
+        const organization = await this.getByID(id);
+        if (!organization) {
+            throw new simple_errors_1.SimpleError({
+                code: "invalid_organization",
+                message: "No organization known for host " + host,
+            });
+        }
+        return organization;
+    }
+    getHost() {
+        if (this.registerDomain) {
+            return this.registerDomain;
+        }
+        return this.getDefaultHost();
+    }
+    getDefaultHost() {
+        var _a;
+        const defaultDomain = (_a = STAMHOOFD.domains.registration[this.address.country]) !== null && _a !== void 0 ? _a : STAMHOOFD.domains.registration[""];
+        return this.uri + "." + defaultDomain;
+    }
+    get marketingDomain() {
+        var _a;
+        return (_a = STAMHOOFD.domains.marketing[this.address.country]) !== null && _a !== void 0 ? _a : STAMHOOFD.domains.marketing[""];
+    }
+    getApiHost() {
+        const defaultDomain = STAMHOOFD.domains.api;
+        if (!defaultDomain) {
+            throw new Error("Missing hostname in environment");
+        }
+        return this.id + "." + defaultDomain;
+    }
+    async getStructure({ emptyGroups } = { emptyGroups: false }) {
+        var _a, _b;
+        const groups = emptyGroups ? [] : (await (await Promise.resolve().then(() => tslib_1.__importStar(require("./Group")))).Group.getAll(this.id));
+        const struct = structures_1.Organization.create({
+            id: this.id,
+            name: this.name,
+            meta: this.meta,
+            address: this.address,
+            registerDomain: this.registerDomain,
+            uri: this.uri,
+            website: this.website,
+            groups: groups.map(g => g.getStructure())
+        });
+        if (this.meta.modules.disableActivities) {
+            // Only show groups that are in a given category
+            struct.groups = (_b = (_a = struct.categoryTree.categories[0]) === null || _a === void 0 ? void 0 : _a.groups) !== null && _b !== void 0 ? _b : [];
+        }
+        if (emptyGroups) {
+            // Reduce data
+            struct.meta = struct.meta.clone();
+            struct.meta.categories = [];
+            struct.meta.recordsConfiguration = structures_1.OrganizationRecordsConfiguration.create({});
+        }
+        return struct;
+    }
+    async cleanCategories(groups) {
+        const reachable = new Map();
+        const queue = [this.meta.rootCategoryId];
+        reachable.set(this.meta.rootCategoryId, true);
+        let shouldSave = false;
+        const usedGroupIds = new Set();
+        while (queue.length > 0) {
+            const id = queue.shift();
+            if (!id) {
+                break;
+            }
+            const category = this.meta.categories.find(c => c.id === id);
+            if (!category) {
+                continue;
+            }
+            for (const i of category.categoryIds) {
+                if (!reachable.get(i)) {
+                    reachable.set(i, true);
+                    queue.push(i);
+                }
+            }
+            // Remove groupIds that no longer exist or are in a different category already
+            let filtered = category.groupIds.filter(id => !!groups.find(g => g.id === id) && !usedGroupIds.has(id));
+            // Remove duplicate groups
+            filtered = utility_1.Formatter.uniqueArray(filtered);
+            if (filtered.length !== category.groupIds.length) {
+                shouldSave = true;
+                console.log("Deleted " + (category.groupIds.length - filtered.length) + " group ids from category " + category.id + ", in organization " + this.id);
+                category.groupIds = filtered;
+            }
+            for (const groupId of category.groupIds) {
+                usedGroupIds.add(groupId);
+            }
+        }
+        const reachableCategoryIds = [...reachable.keys()];
+        // Delete all categories that are not reachable anymore
+        const beforeCount = this.meta.categories.length;
+        this.meta.categories = this.meta.categories.filter(c => reachableCategoryIds.includes(c.id));
+        if (this.meta.categories.length !== beforeCount) {
+            console.log("Deleted " + (beforeCount - this.meta.categories.length) + " categories from organization " + this.id);
+            await this.save();
+        }
+        else {
+            if (shouldSave) {
+                await this.save();
+            }
+        }
+    }
+    async updateDNSRecords() {
+        var _a, _b, _c, _d;
+        const organization = this;
+        // Check initial status
+        let isValidRecords = true;
+        for (const record of organization.privateMeta.dnsRecords) {
+            if (record.status != structures_1.DNSRecordStatus.Valid) {
+                isValidRecords = false;
+            }
+        }
+        const { allValid } = await (0, DNSValidator_1.validateDNSRecords)(organization.privateMeta.dnsRecords);
+        if ((_a = organization.registerDomain) !== null && _a !== void 0 ? _a : organization.privateMeta.pendingRegisterDomain) {
+            const registerDomainRecord = ((_b = organization.privateMeta.pendingRegisterDomain) !== null && _b !== void 0 ? _b : organization.registerDomain) + ".";
+            const records = organization.privateMeta.dnsRecords.filter(r => r.name === registerDomainRecord);
+            const areRegisterDomainRecordsValid = records.length === 0 || records.every(r => r.status === structures_1.DNSRecordStatus.Valid);
+            if (areRegisterDomainRecordsValid) {
+                // We can setup the register domain if needed
+                if (organization.privateMeta.pendingRegisterDomain !== null) {
+                    organization.registerDomain = organization.privateMeta.pendingRegisterDomain;
+                    organization.privateMeta.pendingRegisterDomain = null;
+                    console.log("Did set register domain for " + this.id + " to " + organization.registerDomain);
+                }
+            }
+            else {
+                // Clear register domain
+                if (organization.registerDomain) {
+                    // We need to clear it, to prevent sending e-mails with invalid links
+                    organization.privateMeta.pendingRegisterDomain = (_c = organization.privateMeta.pendingRegisterDomain) !== null && _c !== void 0 ? _c : organization.registerDomain;
+                    organization.registerDomain = null;
+                    console.log("Cleared register domain for " + this.id + " because of invalid non txt records");
+                }
+            }
+        }
+        if (allValid) {
+            if (organization.privateMeta.pendingMailDomain !== null) {
+                organization.privateMeta.mailDomain = organization.privateMeta.pendingMailDomain;
+                organization.privateMeta.pendingMailDomain = null;
+            }
+            const wasUnstable = organization.serverMeta.isDNSUnstable;
+            organization.serverMeta.markDNSValid();
+            const didSendDomainSetupMail = organization.serverMeta.didSendDomainSetupMail;
+            const didSendWarning = organization.serverMeta.DNSRecordWarningCount > 0;
+            organization.serverMeta.DNSRecordWarningCount = 0;
+            const wasActive = this.privateMeta.mailDomainActive;
+            await this.updateAWSMailIdenitity();
+            // yay! Do not Save until after doing AWS changes
+            await organization.save();
+            if (wasUnstable && !organization.serverMeta.isDNSUnstable) {
+                console.warn('DNS settings became stable for ' + this.name + ' ' + this.id);
+                await this.sendEmailTemplate({
+                    type: structures_1.EmailTemplateType.OrganizationStableDNS,
+                    bcc: true
+                });
+            }
+            else if (!wasActive && this.privateMeta.mailDomainActive && (!didSendDomainSetupMail || didSendWarning) && !organization.serverMeta.isDNSUnstable) {
+                organization.serverMeta.didSendDomainSetupMail = true;
+                await organization.save();
+                if (!didSendDomainSetupMail) {
+                    await this.sendEmailTemplate({
+                        type: structures_1.EmailTemplateType.OrganizationDNSSetupComplete
+                    });
+                }
+                else {
+                    await this.sendEmailTemplate({
+                        type: structures_1.EmailTemplateType.OrganizationValidDNS
+                    });
+                }
+            }
+        }
+        else {
+            // DNS settings gone broken
+            if (organization.privateMeta.mailDomain) {
+                organization.privateMeta.pendingMailDomain = (_d = organization.privateMeta.pendingMailDomain) !== null && _d !== void 0 ? _d : organization.privateMeta.mailDomain;
+                organization.privateMeta.mailDomain = null;
+            }
+            const wasDNSUnstable = organization.serverMeta.isDNSUnstable;
+            organization.serverMeta.markDNSFailure();
+            // disable AWS emails
+            this.privateMeta.mailDomainActive = false;
+            // save
+            await organization.save();
+            if (!wasDNSUnstable && organization.serverMeta.isDNSUnstable) {
+                // DNS became instable
+                console.warn('DNS settings became instable for ' + this.name + ' ' + this.id);
+                await this.sendEmailTemplate({
+                    type: structures_1.EmailTemplateType.OrganizationUnstableDNS,
+                    bcc: true
+                });
+            }
+            else if (!organization.serverMeta.isDNSUnstable && organization.serverMeta.didSendDomainSetupMail && organization.serverMeta.DNSRecordWarningCount == 0) {
+                organization.serverMeta.DNSRecordWarningCount += 1;
+                await organization.save();
+                await this.sendEmailTemplate({
+                    type: structures_1.EmailTemplateType.OrganizationInvalidDNS
+                });
+            }
+        }
+    }
+    async sendEmailTemplate(data) {
+        var _a, _b;
+        // First fetch template
+        const templates = (await _1.EmailTemplate.where({ type: data.type, organizationId: null }));
+        if (templates.length == 0) {
+            console.error("Could not find email template for type " + data.type);
+            return;
+        }
+        const template = templates[0];
+        const recipients = await this.getAdminRecipients();
+        const defaultI18n = new backend_i18n_1.I18n("nl", structures_1.Country.Belgium);
+        const i18n = this.i18n;
+        const replacementStrings = [
+            {
+                from: defaultI18n.$t("shared.domains.marketing"),
+                to: i18n.$t("shared.domains.marketing")
+            },
+            {
+                from: defaultI18n.$t("shared.emails.general"),
+                to: i18n.$t("shared.emails.general")
+            },
+            {
+                from: defaultI18n.$t("shared.domains.email"),
+                to: i18n.$t("shared.domains.email")
+            }
+        ];
+        let html = template.html;
+        for (const s of replacementStrings) {
+            html = html.replaceAll(s.from, s.to);
+        }
+        // Create e-mail builder
+        const builder = await (0, EmailBuilder_1.getEmailBuilder)(this, {
+            recipients,
+            subject: template.subject,
+            html,
+            from: data.personal ? email_1.Email.getPersonalEmailFor(this.i18n) : email_1.Email.getInternalEmailFor(this.i18n),
+            singleBcc: data.bcc ? 'simon@stamhoofd.be' : undefined,
+            replyTo: data.replyTo,
+            type: 'transactional',
+            defaultReplacements: [
+                structures_1.Replacement.create({
+                    token: 'mailDomain',
+                    value: (_b = (_a = this.privateMeta.mailDomain) !== null && _a !== void 0 ? _a : this.privateMeta.pendingMailDomain) !== null && _b !== void 0 ? _b : ''
+                })
+            ],
+            unsubscribeType: 'marketing',
+            fromStamhoofd: true
+        });
+        email_1.Email.schedule(builder);
+    }
+    async deleteAWSMailIdenitity(mailDomain) {
+        // Protect specific domain names
+        if (["stamhoofd.be", "stamhoofd.nl", "stamhoofd.shop", "stamhoofd.app", "stamhoofd.email"].includes(mailDomain)) {
+            return;
+        }
+        if (STAMHOOFD.environment != "production") {
+            // Temporary ignore this
+            return;
+        }
+        const sesv2 = new sesv2_1.default();
+        // Check if mail identitiy already exists..
+        let exists = false;
+        let existing = undefined;
+        try {
+            existing = await sesv2.getEmailIdentity({
+                EmailIdentity: mailDomain
+            }).promise();
+            exists = true;
+            // Check if DKIM keys are the same
+            if (existing.VerifiedForSendingStatus === true) {
+                console.log("Cant delete AWS mail idenitiy @" + this.id + " for " + mailDomain + ": already validated and might be in use by other organizations");
+                return;
+            }
+            console.log("Deleting AWS mail idenitiy @" + this.id + " for " + mailDomain);
+            await sesv2.deleteEmailIdentity({
+                EmailIdentity: mailDomain
+            }).promise();
+            console.log("Deleted AWS mail idenitiy @" + this.id + " for " + this.privateMeta.mailDomain);
+        }
+        catch (e) {
+            console.error("Could not delete AWS email identitiy @" + this.id + " for " + this.privateMeta.mailDomain);
+            console.error(e);
+        }
+    }
+    /**
+     * Create or update the AWS mail idenitiy and also update the active state of the mailDomain
+     */
+    async updateAWSMailIdenitity() {
+        var _a, _b, _c, _d;
+        if (this.privateMeta.mailDomain === null) {
+            return;
+        }
+        // Protect specific domain names
+        if (["stamhoofd.be", "stamhoofd.nl", "stamhoofd.shop", "stamhoofd.app", "stamhoofd.email"].includes(this.privateMeta.mailDomain)) {
+            console.error("Tried to validate AWS mail identity with protected domains @" + this.id);
+            this.privateMeta.mailDomainActive = false;
+            return;
+        }
+        if (STAMHOOFD.environment != "production") {
+            // Temporary ignore this
+            this.privateMeta.mailDomainActive = true;
+            return;
+        }
+        const sesv2 = new sesv2_1.default();
+        // Check if mail identitiy already exists..
+        let exists = false;
+        let existing = undefined;
+        try {
+            existing = await sesv2.getEmailIdentity({
+                EmailIdentity: this.privateMeta.mailDomain
+            }).promise();
+            exists = true;
+            console.log("AWS mail idenitiy exists already: just checking the verification status in AWS @" + this.id);
+            if (existing.ConfigurationSetName !== "stamhoofd-domains") {
+                // Not allowed to use this identity
+                this.privateMeta.mailDomainActive = false;
+                console.error("Organization is not allowed to use email identity " + this.privateMeta.mailDomain + " @" + this.id + ", got " + existing.ConfigurationSetName);
+                return;
+            }
+            this.privateMeta.mailDomainActive = (_a = existing.VerifiedForSendingStatus) !== null && _a !== void 0 ? _a : false;
+            if (existing.VerifiedForSendingStatus !== true) {
+                console.error("Not validated @" + this.id);
+            }
+            if (existing.VerifiedForSendingStatus !== true && ((_b = existing.DkimAttributes) === null || _b === void 0 ? void 0 : _b.Status) === "FAILED") {
+                console.error("AWS failed to verify DKIM records. Triggering a forced recheck @" + this.id);
+                await sesv2.deleteEmailIdentity({
+                    EmailIdentity: this.privateMeta.mailDomain
+                }).promise();
+                // Recreate it immediately
+                exists = false;
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+        if (!exists) {
+            console.log("Creating email identity in AWS SES...");
+            const result = await sesv2.createEmailIdentity({
+                EmailIdentity: this.privateMeta.mailDomain,
+                ConfigurationSetName: "stamhoofd-domains",
+                DkimSigningAttributes: {
+                    DomainSigningPrivateKey: this.serverMeta.privateDKIMKey,
+                    DomainSigningSelector: "stamhoofd"
+                },
+                Tags: [
+                    {
+                        "Key": "OrganizationId",
+                        "Value": this.id
+                    },
+                    {
+                        "Key": "Environment",
+                        "Value": (_c = STAMHOOFD.environment) !== null && _c !== void 0 ? _c : "Unknown"
+                    }
+                ]
+            }).promise();
+            this.privateMeta.mailDomainActive = (_d = result.VerifiedForSendingStatus) !== null && _d !== void 0 ? _d : false;
+            // Disable email forwarding of bounces and complaints
+            // We handle this now with the configuration set
+            await sesv2.putEmailIdentityFeedbackAttributes({
+                EmailIdentity: this.privateMeta.mailDomain,
+                EmailForwardingEnabled: false
+            }).promise();
+        }
+        if (this.privateMeta.mailFromDomain && (!exists || (existing && (!existing.MailFromAttributes || existing.MailFromAttributes.MailFromDomain !== this.privateMeta.mailFromDomain)))) {
+            // Also set a from domain, to fix SPF
+            console.log("Setting mail from domain: " + this.privateMeta.mailFromDomain + " for " + this.id);
+            const params = {
+                EmailIdentity: this.privateMeta.mailDomain,
+                BehaviorOnMxFailure: "USE_DEFAULT_VALUE",
+                MailFromDomain: this.privateMeta.mailFromDomain,
+            };
+            await sesv2.putEmailIdentityMailFromAttributes(params).promise();
+        }
+    }
+    async checkDrips() {
+        const days7 = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+        // Welcome drip
+        // Created maximum 7 days ago
+        if (this.createdAt > days7 && !this.serverMeta.hasEmail(structures_1.EmailTemplateType.OrganizationDripWelcome)) {
+            await this.sendEmailTemplate({
+                type: structures_1.EmailTemplateType.OrganizationDripWelcome,
+                personal: true
+            });
+            this.serverMeta.addEmail(structures_1.EmailTemplateType.OrganizationDripWelcome);
+            await this.save();
+            return; // Never send more than 1 drip email on the same day
+        }
+        // Webshop trial checkin
+        if (!this.serverMeta.hasEmail(structures_1.EmailTemplateType.OrganizationDripWebshopTrialCheckin)) {
+            if (this.meta.packages.isWebshopsTrial) {
+                const activeTime = this.meta.packages.getActiveTime(structures_1.STPackageType.TrialWebshops);
+                if (activeTime !== null && activeTime > 4 * 24 * 60 * 60 * 1000) {
+                    // 7 days checkin
+                    await this.sendEmailTemplate({
+                        type: structures_1.EmailTemplateType.OrganizationDripWebshopTrialCheckin,
+                        personal: true
+                    });
+                    this.serverMeta.addEmail(structures_1.EmailTemplateType.OrganizationDripWebshopTrialCheckin);
+                    this.serverMeta.addEmail(structures_1.EmailTemplateType.OrganizationDripMembersTrialCheckin); // also mark members checkin
+                    await this.save();
+                    return; // Never send more than 1 drip email on the same day
+                }
+            }
+        }
+        // Members trial checkin
+        if (!this.serverMeta.hasEmail(structures_1.EmailTemplateType.OrganizationDripMembersTrialCheckin)) {
+            if (this.meta.packages.isMembersTrial) {
+                const activeTime = this.meta.packages.getActiveTime(structures_1.STPackageType.TrialMembers);
+                if (activeTime !== null && activeTime > 4 * 24 * 60 * 60 * 1000) {
+                    // 7 days checkin
+                    await this.sendEmailTemplate({
+                        type: structures_1.EmailTemplateType.OrganizationDripMembersTrialCheckin,
+                        personal: true
+                    });
+                    this.serverMeta.addEmail(structures_1.EmailTemplateType.OrganizationDripMembersTrialCheckin);
+                    this.serverMeta.addEmail(structures_1.EmailTemplateType.OrganizationDripWebshopTrialCheckin); // Also mark webshop trial checkin
+                    await this.save();
+                    return; // Never send more than 1 drip email on the same day
+                }
+            }
+        }
+        // Webshop trial expired after 1 week
+        if (!this.serverMeta.hasEmail(structures_1.EmailTemplateType.OrganizationDripWebshopTrialExpired)) {
+            if (!this.meta.packages.useWebshops) {
+                const deactivatedTime = this.meta.packages.getDeactivatedTime(structures_1.STPackageType.TrialWebshops);
+                if (deactivatedTime !== null && deactivatedTime < 14 * 24 * 60 * 60 * 1000 && deactivatedTime > 7 * 24 * 60 * 60 * 1000) {
+                    await this.sendEmailTemplate({
+                        type: structures_1.EmailTemplateType.OrganizationDripWebshopTrialExpired,
+                        personal: true
+                    });
+                    this.serverMeta.addEmail(structures_1.EmailTemplateType.OrganizationDripWebshopTrialExpired);
+                    this.serverMeta.addEmail(structures_1.EmailTemplateType.OrganizationDripMembersTrialExpired); // also mark members
+                    await this.save();
+                    return; // Never send more than 1 drip email on the same day
+                }
+            }
+        }
+        if (!this.serverMeta.hasEmail(structures_1.EmailTemplateType.OrganizationDripMembersTrialExpired)) {
+            if (!this.meta.packages.useMembers) {
+                const deactivatedTime = this.meta.packages.getDeactivatedTime(structures_1.STPackageType.TrialMembers);
+                if (deactivatedTime !== null && deactivatedTime < 14 * 24 * 60 * 60 * 1000 && deactivatedTime > 7 * 24 * 60 * 60 * 1000) {
+                    await this.sendEmailTemplate({
+                        type: structures_1.EmailTemplateType.OrganizationDripMembersTrialExpired,
+                        personal: true
+                    });
+                    this.serverMeta.addEmail(structures_1.EmailTemplateType.OrganizationDripMembersTrialExpired);
+                    this.serverMeta.addEmail(structures_1.EmailTemplateType.OrganizationDripWebshopTrialExpired); // also mark webshops
+                    await this.save();
+                    return; // Never send more than 1 drip email on the same day
+                }
+            }
+        }
+        // trial expired reminder (after 10 months)
+        if (!this.serverMeta.hasEmail(structures_1.EmailTemplateType.OrganizationDripTrialExpiredReminder)) {
+            if (!this.meta.packages.isPaid && !this.meta.packages.wasPaid) {
+                const deactivatedTime1 = this.meta.packages.getDeactivatedTime(structures_1.STPackageType.TrialWebshops);
+                const deactivatedTime2 = this.meta.packages.getDeactivatedTime(structures_1.STPackageType.TrialMembers);
+                const deactivatedTime = deactivatedTime1 && deactivatedTime2 ? Math.max(deactivatedTime1, deactivatedTime2) : (deactivatedTime1 ? deactivatedTime1 : deactivatedTime2);
+                if (deactivatedTime !== null && deactivatedTime > 10 * 30 * 24 * 60 * 60 * 1000 && deactivatedTime < 13 * 31 * 24 * 60 * 60 * 1000) {
+                    await this.sendEmailTemplate({
+                        type: structures_1.EmailTemplateType.OrganizationDripTrialExpiredReminder,
+                        personal: true,
+                        bcc: true
+                    });
+                    this.serverMeta.addEmail(structures_1.EmailTemplateType.OrganizationDripTrialExpiredReminder);
+                    await this.save();
+                    return; // Never send more than 1 drip email on the same day
+                }
+            }
+        }
+        if (!this.serverMeta.hasEmail(structures_1.EmailTemplateType.OrganizationDripWebshopNotRenewed)) {
+            if (!this.meta.packages.useWebshops) {
+                const deactivatedTime = this.meta.packages.getDeactivatedTime(structures_1.STPackageType.Webshops);
+                if (deactivatedTime !== null && deactivatedTime > 30 * 24 * 60 * 60 * 1000 && deactivatedTime < 30 * 3 * 24 * 60 * 60 * 1000) {
+                    await this.sendEmailTemplate({
+                        type: structures_1.EmailTemplateType.OrganizationDripWebshopNotRenewed,
+                        personal: true,
+                        bcc: true
+                    });
+                    this.serverMeta.addEmail(structures_1.EmailTemplateType.OrganizationDripWebshopNotRenewed);
+                    await this.save();
+                    return; // Never send more than 1 drip email on the same day
+                }
+            }
+        }
+        if (!this.serverMeta.hasEmail(structures_1.EmailTemplateType.OrganizationDripMembersNotRenewed)) {
+            if (!this.meta.packages.useMembers) {
+                const deactivatedTime = this.meta.packages.getDeactivatedTime(structures_1.STPackageType.Members);
+                if (deactivatedTime !== null && deactivatedTime > 30 * 24 * 60 * 60 * 1000 && deactivatedTime < 30 * 3 * 24 * 60 * 60 * 1000) {
+                    await this.sendEmailTemplate({
+                        type: structures_1.EmailTemplateType.OrganizationDripMembersNotRenewed,
+                        personal: true,
+                        bcc: true
+                    });
+                    this.serverMeta.addEmail(structures_1.EmailTemplateType.OrganizationDripMembersNotRenewed);
+                    await this.save();
+                    return; // Never send more than 1 drip email on the same day
+                }
+            }
+        }
+    }
+    /**
+     * E-mail address when we receive replies for organization@stamhoofd.email.
+     * Note that this sould be private because it can contain personal e-mail addresses if the organization is not configured correctly
+     */
+    async getReplyEmails() {
+        var _a;
+        const sender = (_a = this.privateMeta.emails.find(e => e.default)) !== null && _a !== void 0 ? _a : this.privateMeta.emails[0];
+        if (sender) {
+            return [
+                {
+                    name: sender.name,
+                    email: sender.email
+                }
+            ];
+        }
+        return await this.getAdminToEmails();
+    }
+    /**
+     * These email addresess are private
+     */
+    async getFullAdmins() {
+        // Circular reference fix
+        const User = (await Promise.resolve().then(() => tslib_1.__importStar(require('./User')))).User;
+        const admins = await User.getAdmins([this.id], { verified: true });
+        // Only full access
+        return admins.filter(a => a.permissions && a.permissions.hasFullAccess(this.privateMeta.roles));
+    }
+    /**
+     * These email addresess are private
+     */
+    async getAdminToEmails() {
+        const filtered = await this.getFullAdmins();
+        if (STAMHOOFD.environment === "production") {
+            if (filtered.length > 1) {
+                // remove stamhoofd email addresses
+                const f = filtered.flatMap(f => f.getEmailTo()).filter(e => !e.email.endsWith("@stamhoofd.be") && !e.email.endsWith("@stamhoofd.nl"));
+                if (f.length > 0) {
+                    return f;
+                }
+            }
+        }
+        return filtered.flatMap(f => f.getEmailTo());
+    }
+    /**
+     * These email addresess are private
+     */
+    async getAdminRecipients() {
+        let filtered = await this.getFullAdmins();
+        if (STAMHOOFD.environment === "production") {
+            if (filtered.length > 1) {
+                // remove stamhoofd email addresses
+                filtered = filtered.filter(e => !e.email.endsWith("@stamhoofd.be") && !e.email.endsWith("@stamhoofd.nl"));
+            }
+        }
+        return filtered.flatMap(f => {
+            var _a, _b;
+            return structures_1.Recipient.create({
+                firstName: f.firstName,
+                lastName: f.lastName,
+                email: f.email,
+                replacements: [
+                    structures_1.Replacement.create({
+                        token: "firstName",
+                        value: (_a = f.firstName) !== null && _a !== void 0 ? _a : ""
+                    }),
+                    structures_1.Replacement.create({
+                        token: "lastName",
+                        value: (_b = f.lastName) !== null && _b !== void 0 ? _b : ""
+                    }),
+                    structures_1.Replacement.create({
+                        token: "email",
+                        value: f.email
+                    }),
+                    structures_1.Replacement.create({
+                        token: "organizationName",
+                        value: this.name
+                    })
+                ]
+            });
+        });
+    }
+    /**
+     * These email addresess are private
+     */
+    async getInvoicingToEmails() {
+        // Circular reference fix
+        const User = (await Promise.resolve().then(() => tslib_1.__importStar(require('./User')))).User;
+        const admins = await User.where({ organizationId: this.id, permissions: { sign: "!=", value: null } });
+        const filtered = admins.filter(a => a.permissions && (a.permissions.hasFullAccess(this.privateMeta.roles) || a.permissions.hasFinanceAccess(this.privateMeta.roles)));
+        if (filtered.length > 0) {
+            return filtered.map(f => f.getEmailTo()).join(", ");
+        }
+        return undefined;
+    }
+    /**
+     * Return default e-mail address for important e-mails that should have the highest deliverability
+     */
+    getStrongEmail(i18n, withName = true) {
+        if (!withName) {
+            return ('noreply-' + this.uri + "@" + i18n.$t("shared.domains.email"));
+        }
+        return '"' + this.name.replaceAll("\"", "\\\"") + '" <' + ('noreply-' + this.uri + "@" + i18n.$t("shared.domains.email")) + '>';
+    }
+    getEmail(id, strongDefault = false) {
+        if (id === null) {
+            return this.getDefaultEmail(strongDefault);
+        }
+        // Send confirmation e-mail
+        let from = strongDefault ? this.getStrongEmail(this.i18n, false) : this.uri + "@stamhoofd.email";
+        const sender = this.privateMeta.emails.find(e => e.id === id);
+        let replyTo = undefined;
+        if (sender) {
+            replyTo = sender.email;
+            // Can we send from this e-mail or reply-to?
+            if (replyTo && this.privateMeta.mailDomain && this.privateMeta.mailDomainActive && sender.email.endsWith("@" + this.privateMeta.mailDomain)) {
+                from = sender.email;
+                replyTo = undefined;
+            }
+            // Include name in form field
+            if (sender.name) {
+                from = '"' + sender.name.replaceAll("\"", "\\\"") + "\" <" + from + ">";
+            }
+            else {
+                from = '"' + this.name.replaceAll("\"", "\\\"") + "\" <" + from + ">";
+            }
+            if (replyTo) {
+                if (sender.name) {
+                    replyTo = '"' + sender.name.replaceAll("\"", "\\\"") + "\" <" + replyTo + ">";
+                }
+                else {
+                    replyTo = '"' + this.name.replaceAll("\"", "\\\"") + "\" <" + replyTo + ">";
+                }
+            }
+            return { from, replyTo };
+        }
+        return this.getDefaultEmail(strongDefault);
+    }
+    getGroupEmail(group) {
+        return this.getEmail(group.privateSettings.defaultEmailId);
+    }
+    getDefaultEmail(strongDefault = false) {
+        var _a;
+        // Send confirmation e-mail
+        let from = strongDefault ? this.getStrongEmail(this.i18n, false) : this.uri + "@stamhoofd.email";
+        const sender = (_a = this.privateMeta.emails.find(e => e.default)) !== null && _a !== void 0 ? _a : this.privateMeta.emails[0];
+        let replyTo = undefined;
+        if (sender) {
+            replyTo = sender.email;
+            // Can we send from this e-mail or reply-to?
+            if (replyTo && this.privateMeta.mailDomain && this.privateMeta.mailDomainActive && sender.email.endsWith("@" + this.privateMeta.mailDomain)) {
+                from = sender.email;
+                replyTo = undefined;
+            }
+            // Include name in form field
+            if (sender.name) {
+                from = '"' + sender.name.replaceAll("\"", "\\\"") + "\" <" + from + ">";
+            }
+            else {
+                from = '"' + this.name.replaceAll("\"", "\\\"") + "\" <" + from + ">";
+            }
+            if (replyTo) {
+                if (sender.name) {
+                    replyTo = '"' + sender.name.replaceAll("\"", "\\\"") + "\" <" + replyTo + ">";
+                }
+                else {
+                    replyTo = '"' + this.name.replaceAll("\"", "\\\"") + "\" <" + replyTo + ">";
+                }
+            }
+        }
+        else {
+            from = '"' + this.name.replaceAll("\"", "\\\"") + "\" <" + from + ">";
+        }
+        return {
+            from, replyTo
+        };
+    }
+    async getPaymentProviderFor(method, config) {
+        var _a;
+        let stripeAccount = (_a = (config.stripeAccountId ? (await _1.StripeAccount.getByID(config.stripeAccountId)) : null)) !== null && _a !== void 0 ? _a : null;
+        if (stripeAccount && stripeAccount.organizationId !== this.id) {
+            console.warn('Stripe account ' + stripeAccount.id + ' is not linked to organization ' + this.id);
+            stripeAccount = null;
+        }
+        const provider = this.privateMeta.getPaymentProviderFor(method, stripeAccount === null || stripeAccount === void 0 ? void 0 : stripeAccount.meta);
+        if (provider === null && ![structures_1.PaymentMethod.Unknown, structures_1.PaymentMethod.Transfer, structures_1.PaymentMethod.PointOfSale].includes(method)) {
+            if (!stripeAccount && config.stripeAccountId) {
+                console.warn('Missing stripe account id ' + config.stripeAccountId);
+            }
+            throw new simple_errors_1.SimpleError({
+                code: 'payment_provider_not_configured',
+                message: 'Payment provider not configured for ' + method,
+                human: 'Deze betaalmethode werd helaas niet volledig geconfigureerd. Probeer later even opnieuw, neem contact met ons op of kies een andere betaalmethode.'
+            });
+        }
+        return {
+            provider,
+            stripeAccount
+        };
+    }
+    async getConnectedPaymentProviders() {
+        const allPaymentMethods = Object.values(structures_1.PaymentMethod);
+        const providers = [];
+        let stripeAccounts = await _1.StripeAccount.where({ organizationId: this.id, status: 'active' });
+        if (stripeAccounts.length === 0) {
+            stripeAccounts = [null];
+        }
+        for (const account of stripeAccounts) {
+            for (const method of allPaymentMethods) {
+                const provider = this.privateMeta.getPaymentProviderFor(method, account === null || account === void 0 ? void 0 : account.meta);
+                if (provider && !providers.includes(provider)) {
+                    providers.push(provider);
+                }
+            }
+        }
+        return providers;
+    }
+}
+exports.Organization = Organization;
+Organization.table = "organizations";
+tslib_1.__decorate([
+    (0, simple_database_1.column)({
+        primary: true, type: "string", beforeSave(value) {
+            return value !== null && value !== void 0 ? value : (0, uuid_1.v4)();
+        }
+    })
+], Organization.prototype, "id", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({ type: "string" })
+], Organization.prototype, "name", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({ type: "string", nullable: true })
+], Organization.prototype, "website", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({ type: "string", nullable: true })
+], Organization.prototype, "registerDomain", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({ type: "string" })
+], Organization.prototype, "uri", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({ type: "json", decoder: structures_1.OrganizationMetaData })
+], Organization.prototype, "meta", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({ type: "json", decoder: structures_1.OrganizationPrivateMetaData })
+], Organization.prototype, "privateMeta", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({ type: "json", decoder: OrganizationServerMetaData_1.OrganizationServerMetaData })
+], Organization.prototype, "serverMeta", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({ type: "json", decoder: structures_1.Address })
+], Organization.prototype, "address", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({
+        type: "string", beforeSave: function () {
+            return this.name + "\n" + this.address.toString();
+        }
+    })
+], Organization.prototype, "searchIndex", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({
+        type: "datetime", beforeSave(old) {
+            if (old !== undefined) {
+                return old;
+            }
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
+        }
+    })
+], Organization.prototype, "createdAt", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({
+        type: "datetime", beforeSave() {
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
+        },
+        skipUpdate: true
+    })
+], Organization.prototype, "updatedAt", void 0);
+//# sourceMappingURL=Organization.js.map