@stamhoofd/models 2.8.0 → 2.10.2

package/src/models/Member.ts

@@ -1,11 +1,12 @@
 import { column, Database, ManyToManyRelation, ManyToOneRelation, Model, OneToManyRelation } from '@simonbackx/simple-database';
-import { SQL } from "@stamhoofd/sql";
+import { scalarToSQLExpression, SQL, SQLWhereLike } from "@stamhoofd/sql";
 import { MemberDetails, MemberWithRegistrationsBlob, RegistrationWithMember as RegistrationWithMemberStruct, TinyMember } from '@stamhoofd/structures';
 import { Formatter, Sorter } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from "uuid";
 
+import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-errors';
 import { QueueHandler } from '@stamhoofd/queues';
-import { Group, MemberPlatformMembership, Payment, Platform, Registration, User } from './';
+import { Group, MemberPlatformMembership, Organization, Payment, Platform, Registration, User } from './';
 export type MemberWithRegistrations = Member & { 
     users: User[], 
     registrations: (Registration & {group: Group})[] 
@@ -32,16 +33,14 @@ export class Member extends Model {
         type: "string", 
         beforeSave: function() {
             return this.details?.firstName ?? ''
-        },
-        skipUpdate: true
+        }
     })
     firstName: string
 
     @column({ type: "string", 
         beforeSave: function() {
             return this.details?.lastName ?? ''
-        },
-        skipUpdate: true })
+        } })
     lastName: string
 
     @column({ 
@@ -49,11 +48,19 @@ export class Member extends Model {
         nullable: true, 
         beforeSave: function(this: Member) {
             return this.details?.birthDay ? Formatter.dateIso(this.details.birthDay) : null
-        },
-        skipUpdate: true 
+        }
     })
     birthDay: string | null
 
+    @column({
+        type: "string", 
+        nullable: true,
+        beforeSave: function() {
+            return this.details?.memberNumber ?? null
+        }
+    })
+    memberNumber: string | null
+
     @column({ type: "json", decoder: MemberDetails })
     details: MemberDetails
 
@@ -122,7 +129,7 @@ export class Member extends Model {
             LEFT JOIN (
                 SELECT
                     memberId,
-                    sum(price) - sum(pricePaid) AS outstandingBalance
+                    sum(unitPrice * amount) - sum(pricePaid) AS outstandingBalance
                 FROM
                     balance_items
                 WHERE status != 'Hidden'${firstWhere}
@@ -417,11 +424,15 @@ export class Member extends Model {
         });
     }
 
-    static async updateMembershipsForId(id: string) {
+    static async updateMembershipsForId(id: string, silent = false) {
         return await QueueHandler.schedule('updateMemberships-' + id, async function (this: undefined) {
+            console.log('update memberships for id ', id);
+            
             const me = await Member.getWithRegistrations(id)
             if (!me) {
-                console.log('Skipping automatic membership for: ' + id, ' - member not found')
+                if (!silent) {
+                    console.log('Skipping automatic membership for: ' + id, ' - member not found')
+                }
                 return
             }
             const platform = await Platform.getShared()
@@ -453,23 +464,29 @@ export class Member extends Model {
             const activeMembershipsUndeletable = activeMemberships.filter(m => !m.canDelete() || !m.generated)
 
             if (defaultMemberships.length == 0) {
-                // Stop all active memberships taht were added automatically
+                // Stop all active memberships that were added automatically
                 for (const membership of activeMemberships) {
                     if (membership.canDelete() && membership.generated) {
-                        console.log('Removing membership because no longer registered member and not yet invoiced for: ' + me.id + ' - membership ' + membership.id)
+                        if (!silent) {
+                            console.log('Removing membership because no longer registered member and not yet invoiced for: ' + me.id + ' - membership ' + membership.id)
+                        }
                         membership.deletedAt = new Date()
                         await membership.save()
                     }
                 }
 
-                console.log('Skipping automatic membership for: ' + me.id, ' - no default memberships found')
+                if (!silent) {
+                    console.log('Skipping automatic membership for: ' + me.id, ' - no default memberships found')
+                }
                 return
             }
 
 
             if (activeMembershipsUndeletable.length) {
                 // Skip automatic additions
-                console.log('Skipping automatic membership for: ' + me.id, ' - already has active memberships')
+                if (!silent) {
+                    console.log('Skipping automatic membership for: ' + me.id, ' - already has active memberships')
+                }
                 return
             }
 
@@ -487,7 +504,9 @@ export class Member extends Model {
 
             // Check if already have the same membership
             if (activeMemberships.find(m => m.membershipTypeId == cheapestMembership.membership.id)) {
-                console.log('Skipping automatic membership for: ' + me.id, ' - already has this membership')
+                if (!silent) {
+                    console.log('Skipping automatic membership for: ' + me.id, ' - already has this membership')
+                }
                 return
             }
 
@@ -497,7 +516,9 @@ export class Member extends Model {
             }
 
             // Can we revive an earlier deleted membership?
-            console.log('Creating automatic membership for: ' + me.id + ' - membership type ' + cheapestMembership.membership.id)
+            if (!silent) {
+                console.log('Creating automatic membership for: ' + me.id + ' - membership type ' + cheapestMembership.membership.id)
+            }
             const membership = new MemberPlatformMembership();
             membership.memberId = me.id
             membership.membershipTypeId = cheapestMembership.membership.id
@@ -509,13 +530,25 @@ export class Member extends Model {
             membership.expireDate = periodConfig.expireDate
             membership.generated = true;
 
+            if(me.details.memberNumber === null) {
+                try {
+                    await me.assignMemberNumber(membership);
+                } catch(error) {
+                    console.error(`Failed to assign member number for id ${me.id}: ${error.message}`);
+                    // If the assignment of the member number fails the membership is not created but the member is registered
+                    return;
+                }
+            }
+
             await membership.calculatePrice()
             await membership.save()
 
             // This reasoning allows us to replace an existing membership with a cheaper one (not date based ones, but type based ones)
             for (const toDelete of activeMemberships) {
                 if (toDelete.canDelete() && toDelete.generated) {
-                    console.log('Removing membership because cheaper membership found for: ' + me.id + ' - membership ' + toDelete.id)
+                    if (!silent) {
+                        console.log('Removing membership because cheaper membership found for: ' + me.id + ' - membership ' + toDelete.id)
+                    }
                     toDelete.deletedAt = new Date()
                     await toDelete.save()
                 }
@@ -523,6 +556,119 @@ export class Member extends Model {
         });
     }
 
+    private async assignMemberNumber(membership: MemberPlatformMembership) {
+        const member: Member = this;
+
+        if (member.details?.memberNumber) {
+            console.log('Member already has member number, should not happen');
+            return
+        }
+        
+        return await QueueHandler.schedule('assignMemberNumber', async function (this: undefined) {
+            try {
+                const memberNumber = await member.createMemberNumber(membership);
+                member.details.memberNumber = memberNumber;
+                await member.save();
+            } catch(error) {
+                if(isSimpleError(error) || isSimpleErrors(error)) {
+                    throw error;
+                } else {
+                    console.error(error);
+                    throw new SimpleError({
+                        code: 'assign_member_number',
+                        message: error.message,
+                        human: "Er is iets misgegaan bij het aanmaken van het lidnummer.",
+                    })
+                }
+            }
+        });
+    }
+
+    async createMemberNumber(membership: MemberPlatformMembership): Promise<string> {
+        // example: 5301-101012-1
+
+        //#region get birth date part (ddmmjj)
+        const birthDay = this.details?.birthDay;
+        if(!birthDay) {
+            throw new SimpleError({
+                code: 'assign_member_number',
+                message: "Missing birthDay",
+                human: "Er kon geen lidnummer aangemaakt worden omdat er geen geboortedatum is ingesteld.",
+            });
+        }
+
+        const dayPart = birthDay.getDate().toString().padStart(2, '0');
+        const monthPart = (birthDay.getMonth() + 1).toString().padStart(2, '0');
+        const yearPart = birthDay.getFullYear().toString().slice(2, 4);
+        const birthDatePart = `${dayPart}${monthPart}${yearPart}`;
+        //#endregion
+
+        //#region get group number
+        const organizationId = membership.organizationId;
+        const organization = await Organization.getByID(organizationId);
+        if(!organization) {
+            throw new Error(`Organization with id ${organizationId} not found`);
+        }
+        const groupNumber = organization.uri;
+        //#endregion
+
+        //#region get follow up number
+        const firstPart = `${groupNumber}-${birthDatePart}-`;
+
+        const query = SQL.select()
+        .from(SQL.table('members'))
+        .where(
+            new SQLWhereLike(
+                SQL.column('members', 'memberNumber'),
+                scalarToSQLExpression(`${SQLWhereLike.escape(firstPart)}%`)
+            )
+        );
+
+        const count = await query.count();
+        console.log(`Found ${count} members with a memberNumber starting with ${firstPart}`);
+
+        let followUpNumber = count;
+        //#endregion
+
+        //#region check if memberNumber is unique
+        let doesExist = true;
+        let memberNumber: string = '';
+        let tries = 0;
+
+        while(doesExist) {
+            followUpNumber++;
+            memberNumber = firstPart + followUpNumber;
+
+            const result = await SQL.select()
+            .from(SQL.table('members'))
+            .where(
+                    SQL.column('members', 'memberNumber'),
+                    scalarToSQLExpression(memberNumber)
+            )
+            .first(false);
+
+            console.log(`Is ${memberNumber} unique? ${result === null}`);
+
+            if(result !== null) {
+                tries++;
+                if(tries > 9) {
+                    throw new SimpleError({
+                        code: 'assign_member_number',
+                        message: `Duplicate member numbers (last try: ${memberNumber}, tries: ${tries})`,
+                        human: "Er kon geen uniek lidnummer aangemaakt worden. Mogelijks zijn er teveel leden met dezelfde geboortedatum. Neem contact op met de vereniging.",
+                    });
+                }
+            } else {
+                doesExist = false;
+            }
+        }
+        //#endregion
+
+        console.log(`Created member number: ${memberNumber}`);
+
+        return memberNumber;
+    }
+
     async updateMemberships() {
         return await Member.updateMembershipsForId(this.id)
     }

package/src/models/Order.ts

@@ -2,7 +2,7 @@ import { column, ManyToOneRelation, Model } from "@simonbackx/simple-database";
 import { SimpleError } from "@simonbackx/simple-errors";
 import { Email } from '@stamhoofd/email';
 import { QueueHandler } from "@stamhoofd/queues";
-import { BalanceItemPaymentWithPrivatePayment,BalanceItemWithPayments, BalanceItemWithPrivatePayments, EmailTemplateType, MemberBalanceItemPayment, Order as OrderStruct, OrderData, OrderStatus, Payment as PaymentStruct, PaymentMethod, PrivateOrder, PrivatePayment, ProductType, Recipient, Replacement, WebshopPreview, WebshopStatus, WebshopTicketType, WebshopTimeSlot } from '@stamhoofd/structures';
+import { BalanceItemPaymentWithPrivatePayment,BalanceItemWithPayments, BalanceItemWithPrivatePayments, EmailTemplateType, BalanceItemPaymentWithPayment, Order as OrderStruct, OrderData, OrderStatus, Payment as PaymentStruct, PaymentMethod, PrivateOrder, PrivatePayment, ProductType, Recipient, Replacement, WebshopPreview, WebshopStatus, WebshopTicketType, WebshopTimeSlot } from '@stamhoofd/structures';
 import { Formatter } from "@stamhoofd/utility";
 import { v4 as uuidv4 } from "uuid";
 
@@ -780,7 +780,7 @@ export class Order extends Model {
                     ...balanceItem,
                     payments: balanceItemPayments.filter(b => b.balanceItemId === balanceItem.id).map(balanceItemPayment => {
                         const payment = payments.find(pp => pp.id === balanceItemPayment.paymentId)!
-                        return MemberBalanceItemPayment.create({
+                        return BalanceItemPaymentWithPayment.create({
                             ...balanceItemPayment,
                             payment: PaymentStruct.create(payment)
                         })

package/src/models/Payment.ts

@@ -110,50 +110,33 @@ export class Payment extends Model {
         }
 
         const {balanceItemPayments, balanceItems} = await Payment.loadBalanceItems(payments)
-        const {registrations, orders, groups} = await Payment.loadBalanceItemRelations(balanceItems);
         
-        return await this.getGeneralStructureFromRelations({
+        return this.getGeneralStructureFromRelations({
             payments,
-            registrations,
-            orders,
             balanceItemPayments,
-            balanceItems,
-            groups
+            balanceItems
         }, includeSettlements)
     }
 
-    static async getGeneralStructureFromRelations({payments, registrations, orders, balanceItemPayments, balanceItems, groups}: {
+    static getGeneralStructureFromRelations({payments, balanceItemPayments, balanceItems}: {
         payments: Payment[];
-        registrations: import("./Member").RegistrationWithMember[];
-        orders: import("./Order").Order[];
         balanceItemPayments: import("./BalanceItemPayment").BalanceItemPayment[];
         balanceItems: import("./BalanceItem").BalanceItem[];
-        groups: import("./Group").Group[];
-    }, includeSettlements = false): Promise<PaymentGeneral[]> {
+    }, includeSettlements = false): PaymentGeneral[] {
         if (payments.length === 0) {
             return []
         }
-        const {Member} = (await import("./Member"));
 
         return payments.map(payment => {
             return PaymentGeneral.create({
                 ...payment,
                 balanceItemPayments: balanceItemPayments.filter(item => item.paymentId === payment.id).map((item) => {
                     const balanceItem = balanceItems.find(b => b.id === item.balanceItemId)
-                    const registration = balanceItem?.registrationId ? registrations.find(r => r.id === balanceItem.registrationId) : null
-                    const order = balanceItem?.orderId && orders.find(r => r.id === balanceItem.orderId)
-                    const group = registration ? groups.find(g => g.id === registration.groupId) : null
-
-                    if (registration && !group) {
-                        throw new Error("Group "+registration.groupId+" not found")
-                    }
 
                     return BalanceItemPaymentDetailed.create({
                         ...item,
                         balanceItem: BalanceItemDetailed.create({
-                            ...balanceItem,
-                            registration: registration ? Member.getRegistrationWithMemberStructure(registration.setRelation(Registration.group, group!)) : null,
-                            order: order ? OrderStruct.create({...order, payment: null}) : null
+                            ...balanceItem
                         })
                     })
                 }),
@@ -202,9 +185,6 @@ export class Payment extends Model {
         const registrations = await Member.getRegistrationWithMembersByIDs(registrationIds)
         const orders = await Order.getByIDs(...orderIds)
 
-        const groupIds = Formatter.uniqueArray(registrations.map(r => r.groupId))
-        const groups = await (await import("./Group")).Group.getByIDs(...groupIds)
-
-        return {registrations, orders, groups}
+        return {registrations, orders}
     }
 }

package/src/models/Registration.ts

@@ -143,7 +143,7 @@ export class Registration extends Model {
             LEFT JOIN (
                 SELECT
                     registrationId,
-                    sum(price) AS price,
+                    sum(unitPrice * amount) AS price,
                     sum(pricePaid) AS pricePaid
                 FROM
                     balance_items
@@ -196,7 +196,7 @@ export class Registration extends Model {
         await Member.updateMembershipsForId(this.memberId)
     }
 
-    async markValid(this: Registration) {
+    async markValid(this: Registration, options?: {skipEmail?: boolean}) {
         if (this.registeredAt !== null && this.deactivatedAt === null) {
             await this.save();
             return false;
@@ -212,9 +212,11 @@ export class Registration extends Model {
         const {Member} = await import('./Member');
         await Member.updateMembershipsForId(this.memberId)
 
-        await this.sendEmailTemplate({
-            type: EmailTemplateType.RegistrationConfirmation
-        });
+        if (options?.skipEmail !== true) {
+            await this.sendEmailTemplate({
+                type: EmailTemplateType.RegistrationConfirmation
+            });
+        }
 
         const member = await Member.getByID(this.memberId);
         if (member) {
@@ -346,11 +348,7 @@ export class Registration extends Model {
         const template = templates[0]
 
         const paymentGeneral = await payment.getGeneralStructure();
-        const registrations = paymentGeneral.registrations
-        let groupIds = registrations.map(r => r.groupId);
-        
-        // Remove duplicate groupIds
-        groupIds = groupIds.filter((v, i, a) => a.indexOf(v) === i);
+        const groupIds = paymentGeneral.groupIds;
 
         const recipients = [
             Recipient.create({
@@ -386,7 +384,7 @@ export class Registration extends Model {
                     }),
                     Replacement.create({
                         token: "overviewContext",
-                        value: "Inschrijving van " + paymentGeneral.memberFirstNames
+                        value: "Inschrijving van " + paymentGeneral.memberNames
                     }),
                     Replacement.create({
                         token: "memberNames",