@stamhoofd/models 2.1.1

package/dist/src/models/Order.js

@@ -0,0 +1,912 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Order = void 0;
+const tslib_1 = require("tslib");
+const simple_database_1 = require("@simonbackx/simple-database");
+const simple_errors_1 = require("@simonbackx/simple-errors");
+const email_1 = require("@stamhoofd/email");
+const queues_1 = require("@stamhoofd/queues");
+const structures_1 = require("@stamhoofd/structures");
+const utility_1 = require("@stamhoofd/utility");
+const uuid_1 = require("uuid");
+const EmailBuilder_1 = require("../helpers/EmailBuilder");
+const WebshopCounter_1 = require("../helpers/WebshopCounter");
+const _1 = require("./");
+class Order extends simple_database_1.Model {
+    constructor() {
+        super(...arguments);
+        this.paymentId = null;
+        this.userId = null;
+        this.number = null;
+        this.validAt = null;
+        this.status = structures_1.OrderStatus.Created;
+    }
+    getTransferReplacements() {
+        var _a, _b, _c, _d, _e, _f;
+        return {
+            nr: (_b = (_a = this.number) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : "",
+            email: (_c = this.data.customer.email) !== null && _c !== void 0 ? _c : '',
+            phone: (_d = this.data.customer.phone) !== null && _d !== void 0 ? _d : '',
+            name: (_e = this.data.customer.name) !== null && _e !== void 0 ? _e : '',
+            naam: (_f = this.data.customer.name) !== null && _f !== void 0 ? _f : '',
+        };
+    }
+    getUrl() {
+        // Country locales are disabled on webshops (always the same country). But we need to add the language if it isn't the same as the organization default language
+        let locale = "";
+        if (this.data.consumerLanguage != this.webshop.organization.i18n.language) {
+            locale = "/" + this.data.consumerLanguage;
+        }
+        return "https://" + this.webshop.getHost() + locale + "/order/" + this.id;
+    }
+    generateBalanceDescription(webshop) {
+        if (!this.number) {
+            return 'Bestelling - ' + webshop.meta.name;
+        }
+        return 'Bestelling #' + this.number.toString() + ' - ' + webshop.meta.name;
+    }
+    /**
+     * Fetch an order
+     */
+    static async getForPayment(organizationId, paymentId) {
+        const order = (await this.where({ paymentId }, { limit: 1 }))[0];
+        if (!order) {
+            return;
+        }
+        if (organizationId !== null && order.organizationId !== organizationId) {
+            // Security check
+            return;
+        }
+        return order;
+    }
+    shouldIncludeStock() {
+        return this.status !== structures_1.OrderStatus.Canceled && this.status !== structures_1.OrderStatus.Deleted;
+    }
+    async shouldCreateTickets() {
+        if (this.status === structures_1.OrderStatus.Canceled || this.status === structures_1.OrderStatus.Deleted || this.id === undefined || this.id === null) {
+            return false;
+        }
+        if (this.data.paymentMethod === structures_1.PaymentMethod.PointOfSale || this.data.paymentMethod === structures_1.PaymentMethod.Unknown || this.data.totalPrice === 0) {
+            return true;
+        }
+        // Check we paid at least 1 cent
+        const allBalanceItems = await _1.BalanceItem.where({ orderId: this.id });
+        if (allBalanceItems.find(b => b.pricePaid > 0)) {
+            return true;
+        }
+        return false;
+    }
+    get totalToPay() {
+        if (this.status === structures_1.OrderStatus.Canceled || this.status === structures_1.OrderStatus.Deleted) {
+            return 0;
+        }
+        return this.data.totalPrice;
+    }
+    async undoPaymentFailed(_payment, _organization) {
+        if (this.status !== structures_1.OrderStatus.Deleted && this.status !== structures_1.OrderStatus.Canceled) {
+            this.markUpdated();
+            await this.save();
+            const webshop = await _1.Webshop.getByID(this.webshopId);
+            if (webshop) {
+                await this.setRelation(Order.webshop, webshop).updateTickets();
+            }
+            return;
+        }
+        console.log('Undoing payment failed for order ' + this.id);
+        this.markUpdated();
+        this.status = structures_1.OrderStatus.Created;
+        await this.save();
+        const webshop = await queues_1.QueueHandler.schedule("webshop-stock/" + this.webshopId, async () => {
+            // Fetch webshop inside queue to make sure the stock is up to date
+            const webshop = await _1.Webshop.getByID(this.webshopId);
+            if (!webshop) {
+                // ignore for now
+                console.error("Missing webshop with id " + this.webshopId + " in webshop stock queue for order " + this.id);
+                return;
+            }
+            await this.setRelation(Order.webshop, webshop).updateStock(); // readd reserved stock
+            return webshop;
+        });
+        if (webshop) {
+            await this.setRelation(Order.webshop, webshop).updateTickets();
+        }
+    }
+    async deleteOrderBecauseOfCreationError() {
+        this.status = structures_1.OrderStatus.Deleted;
+        await this.save();
+        const webshop = await queues_1.QueueHandler.schedule("webshop-stock/" + this.webshopId, async () => {
+            // Fetch webshop inside queue to make sure the stock is up to date
+            const webshop = await _1.Webshop.getByID(this.webshopId);
+            if (!webshop) {
+                // ignore for now
+                console.error("Missing webshop with id " + this.webshopId + " in webshop stock queue for order " + this.id);
+                return;
+            }
+            await this.setRelation(Order.webshop, webshop).updateStock(); // readd reserved stock
+            return webshop;
+        });
+        if (webshop) {
+            await this.setRelation(Order.webshop, webshop).updateTickets();
+        }
+    }
+    async onPaymentFailed(payment, organization) {
+        if (this.shouldIncludeStock()) {
+            this.markUpdated();
+            if (this.number === null) {
+                this.status = structures_1.OrderStatus.Deleted;
+            }
+            await this.save();
+            const webshop = await queues_1.QueueHandler.schedule("webshop-stock/" + this.webshopId, async () => {
+                // Fetch webshop inside queue to make sure the stock is up to date
+                const webshop = await _1.Webshop.getByID(this.webshopId);
+                if (!webshop) {
+                    // ignore for now
+                    console.error("Missing webshop with id " + this.webshopId + " in webshop stock queue for order " + this.id);
+                    return;
+                }
+                await this.setRelation(Order.webshop, webshop).updateStock(); // remove reserved stock
+                return webshop;
+            });
+            if (webshop) {
+                await this.setRelation(Order.webshop, webshop).updateTickets();
+            }
+            // Send an email if the payment failed after 15 minutes being pending
+            // const difference = new Date().getTime() - this.createdAt.getTime()
+            // if (difference > 1000 * 60 * 30 && difference < 1000 * 60 * 60 * 24) {
+            //    if (payment && payment.method !== PaymentMethod.Transfer && payment.method !== PaymentMethod.PointOfSale) {
+            //        console.log('Marked order '+this.id+' as payment failed after ' + (difference / 1000 / 60).toFixed(1) + ' mins. Sending email.')
+            //        const webshop = await Webshop.getByID(this.webshopId)
+            //        if (!webshop) {
+            //            console.error("Missing organization or webshop for order "+this.id)
+            //            return
+            //        }
+            //        const { from, replyTo } = organization.getEmail(webshop.privateMeta.defaultEmailId, true)
+            //        await this.setRelation(Order.webshop, webshop.setRelation(Order.organization, organization)).sendEmailTemplate({
+            //            type: EmailTemplateType.OrderOnlinePaymentFailed,
+            //            from,
+            //            replyTo
+            //        })
+            //    } else {
+            //        console.log('Marked order '+this.id+' as payment failed after ' + (difference / 1000 / 60).toFixed(1) + ' mins. Payment method not matching.')
+            //    }
+            // } else {
+            //     console.log('Marked order '+this.id+' as payment failed after ' + (difference / 1000 / 60).toFixed(1) + ' mins. Not sending email.')
+            // }
+        }
+        else {
+            this.markUpdated();
+            await this.save();
+        }
+    }
+    /**
+     * Adds or removes the order to the stock of the webshop (if it wasn't already included). If amounts were changed, only those
+     * changes will get added
+     * Should always happen in the webshop-stock queue to prevent multiple webshop writes at the same time
+     * + in combination with validation and reading the webshop
+     */
+    async updateStock(previousData = null) {
+        // Previous data?
+        var _a, _b, _c, _d, _e, _f;
+        // Add or delete this order from the stock?
+        const add = this.shouldIncludeStock();
+        let changed = false;
+        const discountCodeUsageMap = new Map();
+        if (previousData !== null) {
+            // Remove stock from old items without modifying old data
+            for (const item of previousData.cart.items) {
+                const product = this.webshop.products.find(p => p.id === item.product.id);
+                if (product) {
+                    if (item.reservedAmount > 0) {
+                        product.usedStock -= item.reservedAmount;
+                        if (product.usedStock < 0) {
+                            product.usedStock = 0;
+                        }
+                        changed = true;
+                    }
+                    // Product price
+                    for (const [priceId, amount] of item.reservedPrices) {
+                        const productPrice = product.prices.find(p => p.id === priceId);
+                        if (productPrice) {
+                            productPrice.usedStock -= amount;
+                            if (productPrice.usedStock < 0) {
+                                productPrice.usedStock = 0;
+                            }
+                            changed = true;
+                        }
+                    }
+                    // Options
+                    for (const [optionId, amount] of item.reservedOptions) {
+                        const option = product.optionMenus.flatMap(om => om.options).find(o => o.id === optionId);
+                        if (option) {
+                            option.usedStock -= amount;
+                            if (option.usedStock < 0) {
+                                option.usedStock = 0;
+                            }
+                            changed = true;
+                        }
+                    }
+                    // Seats
+                    if (item.reservedSeats.length > 0) {
+                        for (const seat of item.reservedSeats) {
+                            // Only remove each seat once
+                            const reservedIndex = product.reservedSeats.findIndex(s => s.equals(seat));
+                            if (reservedIndex !== -1) {
+                                product.reservedSeats.splice(reservedIndex, 1);
+                                changed = true;
+                            }
+                        }
+                        item.reservedSeats = [];
+                    }
+                }
+            }
+            for (const code of previousData.discountCodes) {
+                if (code.reserved) {
+                    // Remove usage
+                    code.reserved = false;
+                    discountCodeUsageMap.set(code.id, ((_a = discountCodeUsageMap.get(code.id)) !== null && _a !== void 0 ? _a : 0) - 1);
+                }
+            }
+        }
+        for (const item of this.data.cart.items) {
+            if (previousData !== null) {
+                // If we have previousData, we already removed the stock from the old items, so reservedAmount is always zero
+                item.reservedAmount = 0;
+                item.reservedPrices = new Map();
+                item.reservedOptions = new Map();
+                changed = true;
+            }
+            const difference = add ? (item.amount - item.reservedAmount) : -item.reservedAmount;
+            if (difference !== 0) {
+                const product = this.webshop.products.find(p => p.id === item.product.id);
+                if (product) {
+                    product.usedStock += difference;
+                    if (product.usedStock < 0) {
+                        product.usedStock = 0;
+                    }
+                    // Keep track that we included this order in the stock already
+                    item.reservedAmount += difference;
+                    changed = true;
+                    const productPrice = product.prices.find(p => p.id === item.productPrice.id);
+                    if (productPrice) {
+                        productPrice.usedStock += difference;
+                        if (productPrice.usedStock < 0) {
+                            productPrice.usedStock = 0;
+                        }
+                        // Keep track that we included this order in the stock already
+                        item.reservedPrices.set(productPrice.id, ((_b = item.reservedPrices.get(productPrice.id)) !== null && _b !== void 0 ? _b : 0) + difference);
+                    }
+                    // Options
+                    for (const cartItemOption of item.options) {
+                        const option = (_c = product.optionMenus.find(om => om.id === cartItemOption.optionMenu.id)) === null || _c === void 0 ? void 0 : _c.options.find(o => o.id === cartItemOption.option.id);
+                        if (option) {
+                            option.usedStock += difference;
+                            if (option.usedStock < 0) {
+                                option.usedStock = 0;
+                            }
+                            // Keep track that we included this order in the stock already
+                            item.reservedOptions.set(option.id, ((_d = item.reservedOptions.get(option.id)) !== null && _d !== void 0 ? _d : 0) + difference);
+                        }
+                    }
+                }
+            }
+        }
+        if (previousData !== null && previousData.timeSlot) {
+            // Changed timeslot. Remove all reserved ones
+            const ps = previousData.timeSlot;
+            const timeSlot = this.webshop.meta.checkoutMethods.flatMap(m => m.timeSlots).flatMap(t => t.timeSlots).find(t => t.id === ps.id);
+            if (timeSlot) {
+                // Remove any reserved stock
+                const updated = Order.updateTimeSlotStock(timeSlot, this.data, false);
+                changed = changed || updated;
+            }
+            else {
+                this.data.reservedOrder = false;
+                this.data.reservedPersons = 0;
+                changed = true;
+            }
+        }
+        if (this.data.timeSlot !== null) {
+            const s = this.data.timeSlot;
+            const timeSlot = this.webshop.meta.checkoutMethods.flatMap(m => m.timeSlots).flatMap(t => t.timeSlots).find(t => t.id === s.id);
+            if (timeSlot) {
+                const updated = Order.updateTimeSlotStock(timeSlot, this.data, add);
+                changed = changed || updated;
+            }
+            else {
+                console.error("Missing timeslot " + s.id + " in webshop " + this.webshopId);
+            }
+        }
+        // Seats
+        for (const item of this.data.cart.items) {
+            if (item.seats.length > 0) {
+                const product = this.webshop.products.find(p => p.id === item.product.id);
+                if (product) {
+                    if (previousData !== null) {
+                        // Already removed
+                        item.reservedSeats = [];
+                        changed = true;
+                    }
+                    // First remove all (but only once!), to avoid duplicates
+                    for (const seat of item.reservedSeats) {
+                        const reservedIndex = product.reservedSeats.findIndex(s => s.equals(seat));
+                        if (reservedIndex !== -1) {
+                            product.reservedSeats.splice(reservedIndex, 1);
+                        }
+                    }
+                    // First remove all (but only once!), to avoid duplicates
+                    if (add) {
+                        for (const seat of item.seats) {
+                            product.reservedSeats.push(seat);
+                        }
+                    }
+                    changed = true;
+                    item.reservedSeats = add ? item.seats : [];
+                }
+            }
+        }
+        // Discount codes
+        for (const code of this.data.discountCodes) {
+            if (previousData !== null) {
+                code.reserved = false;
+                changed = true;
+            }
+            if (code.reserved && !add) {
+                // Remove usage
+                code.reserved = false;
+                discountCodeUsageMap.set(code.id, ((_e = discountCodeUsageMap.get(code.id)) !== null && _e !== void 0 ? _e : 0) - 1);
+                changed = true;
+            }
+            else if (!code.reserved && add) {
+                code.reserved = true;
+                discountCodeUsageMap.set(code.id, ((_f = discountCodeUsageMap.get(code.id)) !== null && _f !== void 0 ? _f : 0) + 1);
+                changed = true;
+            }
+        }
+        for (const [id, amount] of discountCodeUsageMap) {
+            if (amount !== 0) {
+                const code = await _1.WebshopDiscountCode.getByID(id);
+                if (code) {
+                    code.usageCount += amount;
+                    await code.save();
+                    changed = true;
+                }
+            }
+        }
+        if (changed) {
+            await this.webshop.save();
+            await this.save();
+        }
+    }
+    static updateTimeSlotStock(timeSlot, data, add) {
+        let changed = false;
+        if (data.reservedOrder !== add) {
+            data.reservedOrder = add;
+            timeSlot.usedOrders += add ? 1 : -1;
+            if (timeSlot.usedOrders < 0) {
+                timeSlot.usedOrders = 0;
+            }
+            changed = true;
+        }
+        const personDifference = (add ? data.cart.persons : 0) - data.reservedPersons;
+        if (personDifference !== 0) {
+            timeSlot.usedPersons += personDifference;
+            if (timeSlot.usedPersons < 0) {
+                timeSlot.usedPersons = 0;
+            }
+            data.reservedPersons += personDifference;
+            changed = true;
+        }
+        return changed;
+    }
+    async updateTickets() {
+        var _a;
+        const webshop = this.webshop;
+        if (webshop.meta.ticketType !== structures_1.WebshopTicketType.Tickets && webshop.meta.ticketType !== structures_1.WebshopTicketType.SingleTicket) {
+            return { tickets: [], didCreateTickets: false };
+        }
+        const existingTickets = !this.id ? [] : await _1.Ticket.where({ orderId: this.id });
+        if (!(await this.shouldCreateTickets())) {
+            // Delete all existing tickets
+            for (const ticket of existingTickets) {
+                if (ticket.isDeleted) {
+                    continue;
+                }
+                console.log("Deleting ticket for order " + this.id + ", ticket id = " + ticket.id);
+                await ticket.softDelete();
+            }
+            return { tickets: [], didCreateTickets: false };
+        }
+        // Create tickets if needed (we might already be valid in case of transfer payments)
+        let tickets = [];
+        if (webshop.meta.ticketType === structures_1.WebshopTicketType.Tickets) {
+            const ticketMap = new Map();
+            for (const item of this.data.cart.items) {
+                if (item.product.type === structures_1.ProductType.Ticket || item.product.type === structures_1.ProductType.Voucher) {
+                    const offset = (_a = ticketMap.get(item.product.id)) !== null && _a !== void 0 ? _a : 0;
+                    // Separate ticket if multiple amounts
+                    for (let index = 0; index < item.amount; index++) {
+                        const ticket = new _1.Ticket();
+                        ticket.orderId = this.id;
+                        ticket.itemId = item.id;
+                        ticket.organizationId = this.organizationId;
+                        ticket.webshopId = this.webshopId;
+                        // Relative index for items with same properties
+                        ticket.index = offset + index + 1;
+                        ticket.total = item.getTotalAmount(this.data.cart);
+                        // Seat
+                        ticket.seat = item.seats.length > 0 ? item.seats[index] : null;
+                        ticket.originalSeat = ticket.seat;
+                        // Do not save yet
+                        tickets.push(ticket);
+                    }
+                    ticketMap.set(item.product.id, offset + item.amount);
+                }
+            }
+        }
+        else {
+            // Create a shared ticket for the whole order
+            const ticket = new _1.Ticket();
+            ticket.orderId = this.id;
+            ticket.itemId = null;
+            ticket.organizationId = this.organizationId;
+            ticket.webshopId = this.webshopId;
+            // Relative index for items with same properties
+            ticket.index = 1;
+            ticket.total = 1;
+            // Do not save yet
+            tickets.push(ticket);
+        }
+        let didCreateTickets = false;
+        if (!this.id) {
+            await this.save();
+            for (const ticket of tickets) {
+                ticket.orderId = this.id;
+            }
+        }
+        // First check if we already have tickets
+        const mergedTickets = [];
+        // First try to keep existing tickets
+        for (const existing of existingTickets) {
+            if (existing.originalSeat) {
+                const index = tickets.findIndex(t => t.seat && t.seat.equals(existing.originalSeat));
+                if (index !== -1) {
+                    const ticket = tickets[index];
+                    tickets.splice(index, 1);
+                    existing.itemId = ticket.itemId;
+                    existing.index = ticket.index;
+                    existing.total = ticket.total;
+                    existing.seat = ticket.seat;
+                    existing.deletedAt = null;
+                    mergedTickets.push(existing);
+                }
+                continue;
+            }
+            const index = tickets.findIndex(ticket => existing.itemId === ticket.itemId && ticket.index === existing.index);
+            if (index !== -1) {
+                const ticket = tickets[index];
+                tickets.splice(index, 1);
+                existing.itemId = ticket.itemId;
+                existing.index = ticket.index;
+                existing.total = ticket.total;
+                existing.seat = ticket.seat;
+                existing.deletedAt = null;
+                mergedTickets.push(existing);
+            }
+        }
+        // Try to reuse tickets instead of recreating if no match is found
+        for (const existing of existingTickets) {
+            if (mergedTickets.find(m => m.id === existing.id)) {
+                // Already mapped
+                continue;
+            }
+            const index = tickets.findIndex(ticket => existing.itemId === ticket.itemId);
+            if (index !== -1) {
+                const ticket = tickets[index];
+                tickets.splice(index, 1);
+                existing.itemId = ticket.itemId;
+                existing.index = ticket.index;
+                existing.total = ticket.total;
+                existing.seat = ticket.seat;
+                existing.deletedAt = null;
+                mergedTickets.push(existing);
+            }
+        }
+        // Remaining tickets that were not reused
+        for (const ticket of tickets) {
+            didCreateTickets = true;
+            mergedTickets.push(ticket);
+        }
+        tickets = mergedTickets;
+        // Wait to save them all
+        console.log("Saving merged tickets for order " + this.id);
+        await Promise.all(tickets.map((ticket) => ticket.save()));
+        // Delete others
+        for (const existing of existingTickets) {
+            if (!mergedTickets.find(m => m.id === existing.id)) {
+                if (existing.isDeleted) {
+                    continue;
+                }
+                console.log("Deleting ticket for order " + this.id + ", ticket id = " + existing.id);
+                await existing.softDelete();
+            }
+        }
+        return { tickets, didCreateTickets };
+    }
+    markUpdated() {
+        this.updatedAt = new Date();
+        // Also save if this is the only saved property
+        this.forceSaveProperty("updatedAt");
+    }
+    /**
+     * A payment changed the total paid amount
+     */
+    async paymentChanged(payment, organization, knownWebshop) {
+        this.markUpdated();
+        await this.save();
+    }
+    async undoPaid(payment, organization, knownWebshop) {
+        var _a;
+        this.markUpdated();
+        await this.save();
+        const webshop = (_a = (knownWebshop !== null && knownWebshop !== void 0 ? knownWebshop : (await _1.Webshop.getByID(this.webshopId)))) === null || _a === void 0 ? void 0 : _a.setRelation(_1.Webshop.organization, organization);
+        if (!webshop) {
+            console.error("Missing webshop for order " + this.id);
+            return;
+        }
+        await this.setRelation(Order.webshop, webshop).updateTickets();
+    }
+    /**
+     * Only call this once! Make sure you use the queues correctly
+     */
+    async markPaid(payment, organization, knownWebshop) {
+        var _a;
+        console.log("Marking order " + this.id + " as paid");
+        this.markUpdated();
+        await this.save();
+        const webshop = (_a = (knownWebshop !== null && knownWebshop !== void 0 ? knownWebshop : (await _1.Webshop.getByID(this.webshopId)))) === null || _a === void 0 ? void 0 : _a.setRelation(_1.Webshop.organization, organization);
+        if (!webshop) {
+            console.error("Missing webshop for order " + this.id);
+            return;
+        }
+        if (this.status === structures_1.OrderStatus.Deleted) {
+            await this.undoPaymentFailed(payment, organization);
+        }
+        const { tickets, didCreateTickets } = await this.setRelation(Order.webshop, webshop).updateTickets();
+        // Needs to happen before validation, because we can include the tickets in the validation that way
+        if (this.validAt === null) {
+            await this.setRelation(Order.webshop, webshop).markValid(payment, tickets);
+        }
+        else {
+            if (!this.data.shouldSendPaymentUpdates) {
+                console.log("Skip sending paid email for order " + this.id);
+                return;
+            }
+            if (this.data.customer.email.length > 0) {
+                if (didCreateTickets) {
+                    await this.setRelation(Order.webshop, webshop).sendTickets();
+                }
+                else {
+                    if (payment && payment.method === structures_1.PaymentMethod.Transfer) {
+                        await this.setRelation(Order.webshop, webshop).sendPaidMail();
+                    }
+                }
+            }
+        }
+    }
+    async sendPaidMail() {
+        const organization = this.webshop.organization;
+        const { from, replyTo } = organization.getEmail(this.webshop.privateMeta.defaultEmailId, true);
+        await this.sendEmailTemplate({
+            type: structures_1.EmailTemplateType.OrderReceivedTransfer,
+            from,
+            replyTo
+        });
+    }
+    async sendTickets() {
+        const organization = this.webshop.organization;
+        const { from, replyTo } = organization.getEmail(this.webshop.privateMeta.defaultEmailId, true);
+        await this.sendEmailTemplate({
+            type: structures_1.EmailTemplateType.TicketsReceivedTransfer,
+            from,
+            replyTo
+        });
+    }
+    getStructureWithoutPayment() {
+        return structures_1.Order.create({
+            id: this.id,
+            webshopId: this.webshopId,
+            number: this.number,
+            data: this.data,
+            status: this.status,
+            balanceItems: [],
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt,
+            validAt: this.validAt,
+        });
+    }
+    static async getStructures(orders) {
+        var _a, _b, _c;
+        if (orders.length === 0) {
+            return [];
+        }
+        // Balance items
+        const allBalanceItems = await _1.BalanceItem.where({ orderId: {
+                sign: "IN",
+                value: orders.map(o => o.id)
+            } });
+        const { payments, balanceItemPayments } = await _1.BalanceItem.loadPayments(allBalanceItems);
+        const structures = [];
+        for (const order of orders) {
+            const balanceItems = allBalanceItems.filter(b => b.orderId === order.id);
+            const balanceItemStructures = balanceItems.map((balanceItem) => {
+                return structures_1.BalanceItemWithPayments.create({
+                    ...balanceItem,
+                    payments: balanceItemPayments.filter(b => b.balanceItemId === balanceItem.id).map(balanceItemPayment => {
+                        const payment = payments.find(pp => pp.id === balanceItemPayment.paymentId);
+                        return structures_1.MemberBalanceItemPayment.create({
+                            ...balanceItemPayment,
+                            payment: structures_1.Payment.create(payment)
+                        });
+                    })
+                });
+            });
+            structures.push(structures_1.Order.create({
+                ...order,
+                balanceItems: balanceItemStructures,
+                // Compatibility
+                payment: (_c = (_b = (_a = balanceItemStructures[0]) === null || _a === void 0 ? void 0 : _a.payments[0]) === null || _b === void 0 ? void 0 : _b.payment) !== null && _c !== void 0 ? _c : null
+            }));
+        }
+        return structures;
+    }
+    static async getPrivateStructures(orders) {
+        var _a, _b, _c;
+        if (orders.length === 0) {
+            return [];
+        }
+        // Balance items
+        const allBalanceItems = await _1.BalanceItem.where({ orderId: {
+                sign: "IN",
+                value: orders.map(o => o.id)
+            } });
+        const { payments, balanceItemPayments } = await _1.BalanceItem.loadPayments(allBalanceItems);
+        const structures = [];
+        for (const order of orders) {
+            const balanceItems = allBalanceItems.filter(b => b.orderId === order.id);
+            const balanceItemStructures = balanceItems.map((balanceItem) => {
+                return structures_1.BalanceItemWithPrivatePayments.create({
+                    ...balanceItem,
+                    payments: balanceItemPayments.filter(b => b.balanceItemId === balanceItem.id).map(balanceItemPayment => {
+                        const payment = payments.find(pp => pp.id === balanceItemPayment.paymentId);
+                        return structures_1.BalanceItemPaymentWithPrivatePayment.create({
+                            ...balanceItemPayment,
+                            payment: structures_1.PrivatePayment.create(payment)
+                        });
+                    })
+                });
+            });
+            structures.push(structures_1.PrivateOrder.create({
+                ...order,
+                balanceItems: balanceItemStructures,
+                // Compatibility
+                payment: (_c = (_b = (_a = balanceItemStructures[0]) === null || _a === void 0 ? void 0 : _a.payments[0]) === null || _b === void 0 ? void 0 : _b.payment) !== null && _c !== void 0 ? _c : null
+            }));
+        }
+        return structures;
+    }
+    async getStructure() {
+        return (await Order.getStructures([this]))[0];
+    }
+    async sendEmailTemplate(data) {
+        // Never send an email for archived webshops
+        if (this.webshop.meta.status === structures_1.WebshopStatus.Archived) {
+            return;
+        }
+        // First fetch template
+        let templates = (await _1.EmailTemplate.where({ type: data.type, webshopId: this.webshop.id }));
+        if (templates.length == 0) {
+            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];
+        let recipient = (await this.getStructure()).getRecipient(await this.webshop.organization.getStructure({ emptyGroups: true }), structures_1.WebshopPreview.create(this.webshop));
+        if (data.to) {
+            // Clear first and last name
+            recipient.firstName = null;
+            recipient.lastName = null;
+            recipient.replacements = recipient.replacements.filter(r => !['firstName', 'lastName'].includes(r.token));
+            data.to.merge(recipient);
+            recipient = data.to;
+        }
+        // Create e-mail builder
+        const builder = await (0, EmailBuilder_1.getEmailBuilder)(this.webshop.organization, {
+            recipients: [recipient],
+            subject: template.subject,
+            html: template.html,
+            // text: template.text,
+            from: data.from,
+            replyTo: data.replyTo,
+            type: 'transactional',
+            defaultReplacements: this.webshop.meta.getEmailReplacements()
+        });
+        email_1.Email.schedule(builder);
+    }
+    /**
+     * WARNING: this should always run inside a queue so it only runs once for the same orde
+     * Include any tickets that are generated and should be included in the e-mail
+     */
+    async markValid(payment, tickets) {
+        var _a;
+        const webshop = this.webshop;
+        const organization = webshop.organization;
+        console.log("Marking as valid: order " + this.id);
+        const wasValid = this.validAt !== null;
+        if (wasValid) {
+            console.warn("Warning: already validated an order");
+            return;
+        }
+        this.validAt = new Date(); // will get flattened AFTER calculations
+        this.validAt.setMilliseconds(0);
+        this.number = await WebshopCounter_1.WebshopCounter.getNextNumber(this.webshopId, this.webshop.privateMeta.numberingType);
+        if (payment && !Order.payment.isLoaded(this)) {
+            this.setRelation(Order.payment, payment);
+        }
+        // Now we have a number, update the payment
+        if (payment && payment.method === structures_1.PaymentMethod.Transfer) {
+            // Only now we can update the transfer description, since we need the order number as a reference
+            payment.transferSettings = webshop.meta.transferSettings.fillMissing(organization.mappedTransferSettings);
+            if (!payment.transferSettings.iban) {
+                throw new simple_errors_1.SimpleError({
+                    code: "missing_iban",
+                    message: "Missing IBAN",
+                    human: "Er is geen rekeningnummer ingesteld voor overschrijvingen. Contacteer de beheerder."
+                });
+            }
+            payment.generateDescription(organization, this.number.toString(), this.getTransferReplacements());
+            await payment.save();
+        }
+        await this.save();
+        if (this.data.customer.email.length > 0) {
+            const webshop = this.webshop;
+            const organization = webshop.organization;
+            const { from, replyTo } = organization.getEmail(webshop.privateMeta.defaultEmailId, true);
+            if (tickets.length > 0) {
+                // Also send a copy
+                if (payment && payment.method === structures_1.PaymentMethod.PointOfSale) {
+                    await this.sendEmailTemplate({
+                        type: structures_1.EmailTemplateType.TicketsConfirmationPOS,
+                        from,
+                        replyTo
+                    });
+                }
+                else {
+                    await this.sendEmailTemplate({
+                        type: structures_1.EmailTemplateType.TicketsConfirmation,
+                        from,
+                        replyTo
+                    });
+                }
+            }
+            else {
+                if (this.webshop.meta.ticketType === structures_1.WebshopTicketType.None) {
+                    if (payment && payment.method === structures_1.PaymentMethod.Transfer) {
+                        // Also send a copy
+                        await this.sendEmailTemplate({
+                            type: structures_1.EmailTemplateType.OrderConfirmationTransfer,
+                            from,
+                            replyTo
+                        });
+                    }
+                    else if (payment && payment.method === structures_1.PaymentMethod.PointOfSale) {
+                        await this.sendEmailTemplate({
+                            type: structures_1.EmailTemplateType.OrderConfirmationPOS,
+                            from,
+                            replyTo
+                        });
+                    }
+                    else {
+                        // Also send a copy
+                        await this.sendEmailTemplate({
+                            type: structures_1.EmailTemplateType.OrderConfirmationOnline,
+                            from,
+                            replyTo
+                        });
+                    }
+                }
+                else {
+                    await this.sendEmailTemplate({
+                        type: structures_1.EmailTemplateType.TicketsConfirmationTransfer,
+                        from,
+                        replyTo
+                    });
+                }
+            }
+        }
+        if (this.webshop.privateMeta.notificationEmails) {
+            const webshop = this.webshop;
+            const organization = webshop.organization;
+            const { from, replyTo } = organization.getEmail(webshop.privateMeta.defaultEmailId, true);
+            const i18n = organization.i18n;
+            const webshopDashboardUrl = "https://" + ((_a = STAMHOOFD.domains.dashboard) !== null && _a !== void 0 ? _a : "stamhoofd.app") + "/" + i18n.locale + '/webshops/' + utility_1.Formatter.slug(webshop.meta.name) + '/orders';
+            // Send an email to all these notification emails
+            for (const email of this.webshop.privateMeta.notificationEmails) {
+                await this.sendEmailTemplate({
+                    type: structures_1.EmailTemplateType.OrderNotification,
+                    from,
+                    replyTo,
+                    to: structures_1.Recipient.create({
+                        email,
+                        replacements: [
+                            structures_1.Replacement.create({
+                                token: 'orderUrl',
+                                value: webshopDashboardUrl
+                            })
+                        ]
+                    })
+                });
+            }
+        }
+    }
+}
+exports.Order = Order;
+Order.table = "webshop_orders";
+Order.webshop = new simple_database_1.ManyToOneRelation(_1.Webshop, "webshop");
+Order.payment = new simple_database_1.ManyToOneRelation(_1.Payment, "payment");
+Order.organization = new simple_database_1.ManyToOneRelation(_1.Organization, "organization");
+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)();
+        }
+    })
+], Order.prototype, "id", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({ foreignKey: Order.organization, type: "string" })
+], Order.prototype, "organizationId", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({ foreignKey: Order.webshop, type: "string" })
+], Order.prototype, "webshopId", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({ type: "string", nullable: true, foreignKey: Order.payment })
+], Order.prototype, "paymentId", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({ type: "string", nullable: true })
+], Order.prototype, "userId", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({ type: "json", decoder: structures_1.OrderData })
+], Order.prototype, "data", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({ type: "integer", nullable: true })
+], Order.prototype, "number", 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;
+        }
+    })
+], Order.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
+    })
+], Order.prototype, "updatedAt", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({ type: "datetime", nullable: true })
+], Order.prototype, "validAt", void 0);
+tslib_1.__decorate([
+    (0, simple_database_1.column)({ type: "string" })
+], Order.prototype, "status", void 0);
+//# sourceMappingURL=Order.js.map