@stamhoofd/models 2.63.0 → 2.64.0

package/src/models/CachedBalance.ts

@@ -1,6 +1,6 @@
 import { column, Model, SQLResultNamespacedRow } from '@simonbackx/simple-database';
-import { SQL, SQLAlias, SQLCalculation, SQLGreatest, SQLMin, SQLMinusSign, SQLMultiplicationSign, SQLSelect, SQLSelectAs, SQLSum, SQLWhere, SQLWhereSign } from '@stamhoofd/sql';
-import { BalanceItem as BalanceItemStruct, BalanceItemStatus, ReceivableBalanceType } from '@stamhoofd/structures';
+import { SQL, SQLAlias, SQLMin, SQLSelect, SQLSelectAs, SQLSum, SQLWhere, SQLWhereSign } from '@stamhoofd/sql';
+import { BalanceItemStatus, BalanceItem as BalanceItemStruct, ReceivableBalanceType } from '@stamhoofd/structures';
 import { v4 as uuidv4 } from 'uuid';
 import { BalanceItem } from './BalanceItem';
 
@@ -33,7 +33,10 @@ export class CachedBalance extends Model {
     objectType: ReceivableBalanceType;
 
     @column({ type: 'integer' })
-    amount = 0;
+    amountPaid = 0;
+
+    @column({ type: 'integer' })
+    amountOpen = 0;
 
     /**
      * The sum of unconfirmed payments
@@ -70,6 +73,10 @@ export class CachedBalance extends Model {
     updatedAt: Date;
 
     static async getForObjects(objectIds: string[], limitOrganizationId?: string | null): Promise<CachedBalance[]> {
+        if (objectIds.length === 0) {
+            return [];
+        }
+
         const query = this.select()
             .where('objectId', objectIds);
 
@@ -81,6 +88,10 @@ export class CachedBalance extends Model {
     }
 
     static async updateForObjects(organizationId: string, objectIds: string[], objectType: ReceivableBalanceType) {
+        if (objectIds.length === 0) {
+            return;
+        }
+
         switch (objectType) {
             case ReceivableBalanceType.organization:
                 await this.updateForOrganizations(organizationId, objectIds);
@@ -91,10 +102,17 @@ export class CachedBalance extends Model {
             case ReceivableBalanceType.user:
                 await this.updateForUsers(organizationId, objectIds);
                 break;
+            case ReceivableBalanceType.registration:
+                await this.updateForRegistrations(organizationId, objectIds);
+                break;
         }
     }
 
     static async balanceForObjects(organizationId: string, objectIds: string[], objectType: ReceivableBalanceType) {
+        if (objectIds.length === 0) {
+            return [];
+        }
+
         switch (objectType) {
             case ReceivableBalanceType.organization:
                 return await this.balanceForOrganizations(organizationId, objectIds);
@@ -102,6 +120,8 @@ export class CachedBalance extends Model {
                 return await this.balanceForMembers(organizationId, objectIds);
             case ReceivableBalanceType.user:
                 return await this.balanceForUsers(organizationId, objectIds);
+            case ReceivableBalanceType.registration:
+                return await this.balanceForRegistrations(organizationId, objectIds);
         }
     }
 
@@ -122,15 +142,25 @@ export class CachedBalance extends Model {
         return await query.fetch();
     }
 
+    static whereNeedsUpdate() {
+        return SQL.where('nextDueAt', SQLWhereSign.LessEqual, BalanceItemStruct.getDueOffset());
+    }
+
     private static async fetchForObjects(organizationId: string, objectIds: string[], columnName: string, customWhere?: SQLWhere) {
         const dueOffset = BalanceItemStruct.getDueOffset();
         const query = SQL.select(
             SQL.column(columnName),
+            new SQLSelectAs(
+                new SQLSum(
+                    SQL.column('pricePaid'),
+                ),
+                new SQLAlias('data__amountPaid'),
+            ),
             new SQLSelectAs(
                 new SQLSum(
                     SQL.column('priceOpen'),
                 ),
-                new SQLAlias('data__amount'),
+                new SQLAlias('data__amountOpen'),
             ),
             new SQLSelectAs(
                 new SQLSum(
@@ -162,11 +192,17 @@ export class CachedBalance extends Model {
                 new SQLAlias('data__dueAt'),
             ),
             // If the current amount_due is negative, we can ignore that negative part if there is a future due item
+            new SQLSelectAs(
+                new SQLSum(
+                    SQL.column('pricePaid'),
+                ),
+                new SQLAlias('data__amountPaid'),
+            ),
             new SQLSelectAs(
                 new SQLSum(
                     SQL.column('priceOpen'),
                 ),
-                new SQLAlias('data__amount'),
+                new SQLAlias('data__amountOpen'),
             ),
             new SQLSelectAs(
                 new SQLSum(
@@ -185,7 +221,7 @@ export class CachedBalance extends Model {
 
         const dueResult = await dueQuery.fetch();
 
-        const results: [string, { amount: number; amountPending: number; nextDueAt: Date | null }][] = [];
+        const results: [string, { amountPaid: number; amountOpen: number; amountPending: number; nextDueAt: Date | null }][] = [];
         for (const row of result) {
             if (!row['data']) {
                 throw new Error('Invalid data namespace');
@@ -196,22 +232,27 @@ export class CachedBalance extends Model {
             }
 
             const objectId = row[BalanceItem.table][columnName];
-            const amount = row['data']['amount'];
+            const amountOpen = row['data']['amountOpen'];
             const amountPending = row['data']['amountPending'];
+            const amountPaid = row['data']['amountPaid'];
 
             if (typeof objectId !== 'string') {
                 throw new Error('Invalid objectId');
             }
 
-            if (typeof amount !== 'number') {
-                throw new Error('Invalid amount');
+            if (typeof amountOpen !== 'number') {
+                throw new Error('Invalid amountOpen');
             }
 
             if (typeof amountPending !== 'number') {
                 throw new Error('Invalid amountPending');
             }
 
-            results.push([objectId, { amount, amountPending, nextDueAt: null }]);
+            if (typeof amountPaid !== 'number') {
+                throw new Error('Invalid amountPaid');
+            }
+
+            results.push([objectId, { amountPaid, amountOpen, amountPending, nextDueAt: null }]);
         }
 
         for (const row of dueResult) {
@@ -225,8 +266,9 @@ export class CachedBalance extends Model {
 
             const objectId = row[BalanceItem.table][columnName];
             const dueAt = row['data']['dueAt'];
-            const amount = row['data']['amount'];
+            const amountOpen = row['data']['amountOpen'];
             const amountPending = row['data']['amountPending'];
+            const amountPaid = row['data']['amountPaid'];
 
             if (typeof objectId !== 'string') {
                 throw new Error('Invalid objectId');
@@ -236,43 +278,48 @@ export class CachedBalance extends Model {
                 throw new Error('Invalid dueAt');
             }
 
-            if (typeof amount !== 'number') {
-                throw new Error('Invalid amount');
+            if (typeof amountOpen !== 'number') {
+                throw new Error('Invalid amountOpen');
             }
 
             if (typeof amountPending !== 'number') {
                 throw new Error('Invalid amountPending');
             }
 
+            if (typeof amountPaid !== 'number') {
+                throw new Error('Invalid amountPaid');
+            }
+
             const result = results.find(r => r[0] === objectId);
             if (result) {
                 result[1].nextDueAt = dueAt;
 
-                if (result[1].amount < 0) {
-                    if (amount > 0) {
+                if (result[1].amountOpen < 0) {
+                    if (amountOpen > 0) {
                         // Let the future due amount fill in the gap until maximum 0
-                        result[1].amount = Math.min(0, result[1].amount + amount);
+                        result[1].amountOpen = Math.min(0, result[1].amountOpen + amountOpen);
                     }
                 }
 
                 result[1].amountPending += amountPending;
+                result[1].amountPaid += amountPaid;
             }
             else {
-                results.push([objectId, { amount: 0, amountPending: amountPending, nextDueAt: dueAt }]);
+                results.push([objectId, { amountPaid, amountOpen: 0, amountPending, nextDueAt: dueAt }]);
             }
         }
 
         // Add missing object ids (with 0 amount, otherwise we don't reset the amounts back to zero when all the balance items are hidden)
         for (const objectId of objectIds) {
             if (!results.find(([id]) => id === objectId)) {
-                results.push([objectId, { amount: 0, amountPending: 0, nextDueAt: null }]);
+                results.push([objectId, { amountPaid: 0, amountOpen: 0, amountPending: 0, nextDueAt: null }]);
             }
         }
 
         return results;
     }
 
-    private static async setForResults(organizationId: string, result: [string, { amount: number; amountPending: number; nextDueAt: null | Date }][], objectType: ReceivableBalanceType) {
+    private static async setForResults(organizationId: string, result: [string, { amountPaid: number; amountOpen: number; amountPending: number; nextDueAt: null | Date }][], objectType: ReceivableBalanceType) {
         if (result.length === 0) {
             return;
         }
@@ -282,19 +329,21 @@ export class CachedBalance extends Model {
                 'organizationId',
                 'objectId',
                 'objectType',
-                'amount',
+                'amountPaid',
+                'amountOpen',
                 'amountPending',
                 'nextDueAt',
                 'createdAt',
                 'updatedAt',
             )
-            .values(...result.map(([objectId, { amount, amountPending, nextDueAt }]) => {
+            .values(...result.map(([objectId, { amountPaid, amountOpen, amountPending, nextDueAt }]) => {
                 return [
                     uuidv4(),
                     organizationId,
                     objectId,
                     objectType,
-                    amount,
+                    amountPaid,
+                    amountOpen,
                     amountPending,
                     nextDueAt,
                     new Date(),
@@ -303,7 +352,8 @@ export class CachedBalance extends Model {
             }))
             .as('v')
             .onDuplicateKeyUpdate(
-                SQL.assignment('amount', SQL.column('v', 'amount')),
+                SQL.assignment('amountPaid', SQL.column('v', 'amountPaid')),
+                SQL.assignment('amountOpen', SQL.column('v', 'amountOpen')),
                 SQL.assignment('amountPending', SQL.column('v', 'amountPending')),
                 SQL.assignment('nextDueAt', SQL.column('v', 'nextDueAt')),
                 SQL.assignment('updatedAt', SQL.column('v', 'updatedAt')),
@@ -328,6 +378,14 @@ export class CachedBalance extends Model {
         await this.setForResults(organizationId, results, ReceivableBalanceType.member);
     }
 
+    static async updateForRegistrations(organizationId: string, registrationIds: string[]) {
+        if (registrationIds.length === 0) {
+            return;
+        }
+        const results = await this.fetchForObjects(organizationId, registrationIds, 'registrationId');
+        await this.setForResults(organizationId, results, ReceivableBalanceType.registration);
+    }
+
     static async updateForUsers(organizationId: string, userIds: string[]) {
         if (userIds.length === 0) {
             return;
@@ -357,6 +415,13 @@ export class CachedBalance extends Model {
         return await this.fetchBalanceItems(organizationId, userIds, 'userId', SQL.where('memberId', null));
     }
 
+    static async balanceForRegistrations(organizationId: string, registrationIds: string[]) {
+        if (registrationIds.length === 0) {
+            return [];
+        }
+        return await this.fetchBalanceItems(organizationId, registrationIds, 'registrationId');
+    }
+
     /**
      * Experimental: needs to move to library
      */

package/src/models/DocumentTemplate.ts

@@ -74,9 +74,11 @@ export class DocumentTemplate extends Model {
         let missingData = false;
 
         const group = await Group.getByID(registration.groupId);
-        const { items: balanceItems, payments } = await BalanceItem.getForRegistration(registration.id);
+        const { items: balanceItems, payments } = await BalanceItem.getForRegistration(registration.id, this.organizationId);
 
         const paidAtDates = payments.flatMap(p => p.paidAt ? [p.paidAt?.getTime()] : []);
+        const price = balanceItems.reduce((sum, item) => sum + item.price, 0);
+        const pricePaid = balanceItems.reduce((sum, item) => sum + item.pricePaid, 0);
 
         // We take the minimum date here, because there is a highter change of later paymetns to be for other things than the registration itself
         const paidAt = paidAtDates.length ? new Date(Math.min(...paidAtDates)) : null;
@@ -102,7 +104,7 @@ export class DocumentTemplate extends Model {
                     id: 'registration.startDate',
                     type: RecordType.Date,
                 }), // settings will be overwritten
-                dateValue: group?.settings?.startDate,
+                dateValue: registration.startDate ?? group?.settings?.startDate,
             }),
             'registration.endDate': RecordDateAnswer.create({
                 settings: RecordSettings.create({
@@ -114,16 +116,36 @@ export class DocumentTemplate extends Model {
             'registration.price':
                 RecordPriceAnswer.create({
                     settings: RecordSettings.create({
+                        id: 'registration.price',
                         type: RecordType.Price,
                     }), // settings will be overwritten
-                    value: registration.price,
+                    value: price,
+                }),
+            // This one is duplicated in case it got disabled (we need to use it to check if document is included)
+            'registration.priceOriginal':
+                RecordPriceAnswer.create({
+                    settings: RecordSettings.create({
+                        id: 'registration.priceOriginal',
+                        type: RecordType.Price,
+                    }), // settings will be overwritten
+                    value: price,
+                }),
+            // This one is duplicated in case it got disabled (we need to use it to check if document is included)
+            'registration.pricePaidOriginal':
+                RecordPriceAnswer.create({
+                    settings: RecordSettings.create({
+                        id: 'registration.pricePaidOriginal',
+                        type: RecordType.Price,
+                    }), // settings will be overwritten
+                    value: pricePaid,
                 }),
             'registration.pricePaid':
                 RecordPriceAnswer.create({
                     settings: RecordSettings.create({
+                        id: 'registration.pricePaid',
                         type: RecordType.Price,
                     }), // settings will be overwritten
-                    value: registration.pricePaid,
+                    value: pricePaid,
                 }),
             'registration.paidAt':
                 RecordDateAnswer.create({
@@ -483,14 +505,22 @@ export class DocumentTemplate extends Model {
             }
         }
 
-        if (this.settings.minPrice !== null) {
-            if ((registration.price ?? 0) < this.settings.minPrice) {
-                return false;
+        if (this.settings.minPrice !== null && this.settings.minPrice > 0) {
+            const priceAnswer = fieldAnswers.get('registration.priceOriginal');
+            if (priceAnswer && priceAnswer instanceof RecordPriceAnswer) {
+                if ((priceAnswer.value ?? 0) < this.settings.minPrice) {
+                    return false;
+                }
             }
         }
 
-        if (this.settings.minPricePaid !== null) {
-            if ((registration.pricePaid ?? 0) < this.settings.minPricePaid && (registration.price ?? 0) > 0) {
+        if (this.settings.minPricePaid !== null && this.settings.minPricePaid > 0) {
+            const pricePaidAnswer = fieldAnswers.get('registration.pricePaidOriginal');
+            const priceAnswer = fieldAnswers.get('registration.priceOriginal');
+            const price = (priceAnswer instanceof RecordPriceAnswer ? priceAnswer.value : 0) ?? 0;
+            const pricePaid = (pricePaidAnswer instanceof RecordPriceAnswer ? pricePaidAnswer.value : 0) ?? 0;
+
+            if (pricePaid < this.settings.minPricePaid && price > 0) {
                 return false;
             }
         }

package/src/models/Member.ts

@@ -63,7 +63,8 @@ export class Member extends Model {
     details: MemberDetails;
 
     /**
-     * Not yet paid balance
+     * @deprecated
+     * Unreliable since a member can have outstanding balance to multiple organizations now
      */
     @column({ type: 'integer' })
     outstandingBalance = 0;
@@ -103,44 +104,6 @@ export class Member extends Model {
         return (await this.getBlobByIds(id))[0] ?? null;
     }
 
-    /**
-     * Update the outstanding balance of multiple members in one go (or all members)
-     */
-    static async updateOutstandingBalance(memberIds: string[] | 'all') {
-        if (memberIds !== 'all' && memberIds.length == 0) {
-            return;
-        }
-
-        const params: any[] = [];
-        let firstWhere = '';
-        let secondWhere = '';
-
-        if (memberIds !== 'all') {
-            firstWhere = ` AND memberId IN (?)`;
-            params.push(memberIds);
-
-            secondWhere = `WHERE members.id IN (?)`;
-            params.push(memberIds);
-        }
-
-        const query = `UPDATE
-            members
-            LEFT JOIN (
-                SELECT
-                    memberId,
-                    sum(unitPrice * amount) - sum(pricePaid) AS outstandingBalance
-                FROM
-                    balance_items
-                WHERE status != 'Hidden'${firstWhere}
-                GROUP BY
-                    memberId
-            ) i ON i.memberId = members.id 
-        SET members.outstandingBalance = COALESCE(i.outstandingBalance, 0)
-        ${secondWhere}`;
-
-        await Database.update(query, params);
-    }
-
     /**
      * Fetch all registrations with members with their corresponding (valid) registrations
      */
@@ -377,15 +340,6 @@ export class Member extends Model {
         return this.getBlobByIds(...(await this.getMemberIdsWithRegistrationForUser(user)));
     }
 
-    getStructureWithRegistrations(this: MemberWithRegistrations, forOrganization: null | boolean = null) {
-        return MemberWithRegistrationsBlob.create({
-            ...this,
-            registrations: this.registrations.map(r => r.getStructure()),
-            details: this.details,
-            users: this.users.map(u => u.getStructure()),
-        });
-    }
-
     static getRegistrationWithMemberStructure(registration: RegistrationWithMember & { group: import('./Group').Group }): RegistrationWithMemberStruct {
         return RegistrationWithMemberStruct.create({
             ...registration.getStructure(),

package/src/models/MemberPlatformMembership.ts

@@ -4,10 +4,12 @@ import { SQL, SQLSelect, SQLWhereSign } from '@stamhoofd/sql';
 import { PlatformMembershipTypeBehaviour } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from 'uuid';
+import { BalanceItem } from './BalanceItem';
 import { Member } from './Member';
 import { Organization } from './Organization';
 import { Platform } from './Platform';
-import { BalanceItem } from './BalanceItem';
+import { Registration } from './Registration';
+import { RegistrationPeriod } from './RegistrationPeriod';
 
 export class MemberPlatformMembership extends Model {
     static table = 'member_platform_memberships';
@@ -38,6 +40,15 @@ export class MemberPlatformMembership extends Model {
     @column({ type: 'date' })
     endDate: Date;
 
+    /**
+     * This membership won't get charged before this day.
+     * The membership can still get removed before this day.
+     *
+     * If a membership is deleted during trial -> do not set deletedAt, but set price to 0 and set trialUntil and endDate to the current date
+     */
+    @column({ type: 'date', nullable: true })
+    trialUntil: Date | null = null;
+
     @column({ type: 'date', nullable: true })
     expireDate: Date | null = null;
 
@@ -104,14 +115,44 @@ export class MemberPlatformMembership extends Model {
         throw new Error('Cannot delete a membership. Use the deletedAt column.');
     }
 
-    async calculatePrice(member: Member) {
+    async isElegibleForTrial(member: Member) {
+        const period = await RegistrationPeriod.getByID(this.periodId);
+        if (!period) {
+            return false;
+        }
+
+        if (!period.previousPeriodId) {
+            // We have no previous period = no data = no trials
+            return false;
+        }
+
+        const platform = await Platform.getSharedStruct();
+        const typeIds = platform.config.membershipTypes.filter(m => m.behaviour === PlatformMembershipTypeBehaviour.Period).map(m => m.id);
+
+        const membership = await MemberPlatformMembership.select()
+            .where('memberId', member.id)
+            .where('deletedAt', null)
+            .where('periodId', period.previousPeriodId)
+            .where('membershipTypeId', typeIds)
+            .first(false);
+
+        const hasBlockingMemberships = !!membership;
+
+        if (hasBlockingMemberships) {
+            return false;
+        }
+
+        return true;
+    }
+
+    async calculatePrice(member: Member, registration?: Registration) {
         const platform = await Platform.getSharedPrivateStruct();
-        const membershipType = platform.config.membershipTypes.find(m => m.id == this.membershipTypeId);
+        const membershipType = platform.config.membershipTypes.find(m => m.id === this.membershipTypeId);
 
         if (!membershipType) {
             throw new SimpleError({
                 code: 'invalid_membership_type',
-                message: 'Uknown membership type',
+                message: 'Unknown membership type',
                 human: 'Deze aansluiting is niet (meer) beschikbaar',
             });
         }
@@ -192,7 +233,6 @@ export class MemberPlatformMembership extends Model {
         else {
             this.priceWithoutDiscount = earliestPriceConfig.getBasePrice(tagIds, false);
             this.price = priceConfig.getBasePrice(tagIds, shouldApplyReducedPrice);
-            this.startDate = periodConfig.startDate;
             this.endDate = periodConfig.endDate;
             this.expireDate = periodConfig.expireDate;
             this.maximumFreeAmount = this.price > 0 ? 1 : 0;
@@ -202,6 +242,53 @@ export class MemberPlatformMembership extends Model {
                 this.price = 0;
                 this.freeAmount = 1;
             }
+
+            // Alter start date
+            if (registration && registration.startDate) {
+                this.startDate = periodConfig.startDate;
+
+                if (registration.startDate > periodConfig.startDate && registration.startDate < periodConfig.endDate) {
+                    let startBrussels = Formatter.luxon(registration.startDate);
+                    startBrussels = startBrussels.set({ hour: 0, minute: 0, second: 0, millisecond: 0 });
+                    this.startDate = startBrussels.toJSDate();
+                }
+            }
+            else {
+                let startBrussels = Formatter.luxon(this.startDate);
+                startBrussels = startBrussels.set({ hour: 0, minute: 0, second: 0, millisecond: 0 });
+                this.startDate = startBrussels.toJSDate();
+            }
+        }
+
+        if (periodConfig.trialDays) {
+            // Check whether you are elegible for a trial
+            if (await this.isElegibleForTrial(member)) {
+                // Allowed to set trial until, maximum periodConfig.trialDays after startDate
+                let trialUntil = Formatter.luxon(this.startDate).plus({ days: periodConfig.trialDays });
+                trialUntil = trialUntil.set({ hour: 23, minute: 59, second: 59, millisecond: 0 });
+
+                // Max end date
+                if (trialUntil.toJSDate() > this.endDate) {
+                    trialUntil = Formatter.luxon(this.endDate).set({ hour: 23, minute: 59, second: 59, millisecond: 0 });
+                }
+
+                this.trialUntil = trialUntil.toJSDate();
+            }
+            else {
+                this.trialUntil = null;
+            }
+        }
+        else {
+            // No trial
+            this.trialUntil = null;
+        }
+
+        // Never charge itself
+        const chargeVia = platform.membershipOrganizationId;
+        if (this.organizationId === chargeVia) {
+            this.price = 0;
+            this.priceWithoutDiscount = 0;
+            this.freeAmount = 0;
         }
 
         if (this.balanceItemId) {

package/src/models/MergedMember.ts

@@ -41,7 +41,7 @@ export class MergedMember extends Model {
     details: MemberDetails;
 
     /**
-     * Not yet paid balance
+     * @deprecated
      */
     @column({ type: 'integer' })
     outstandingBalance = 0;

package/src/models/Platform.ts

@@ -20,6 +20,9 @@ export class Platform extends Model {
     @column({ type: 'string' })
     periodId: string;
 
+    @column({ type: 'string', nullable: true })
+    previousPeriodId: string | null = null;
+
     @column({ type: 'string', nullable: true })
     membershipOrganizationId: string | null = null;
 
@@ -37,6 +40,11 @@ export class Platform extends Model {
         return clone;
     }
 
+    async setPreviousPeriodId() {
+        const period = await RegistrationPeriod.getByID(this.periodId);
+        this.previousPeriodId = period?.previousPeriodId ?? null;
+    }
+
     static async getSharedPrivateStruct(): Promise<PlatformStruct & { privateConfig: PlatformPrivateConfig }> {
         if (this.sharedStruct && this.sharedStruct.privateConfig) {
             return this.sharedStruct as any;
@@ -76,8 +84,8 @@ export class Platform extends Model {
     }
 
     async save() {
-        Platform.clearCache();
         const s = await super.save();
+        Platform.clearCache();
 
         // Force update cache immediately
         await Platform.getSharedStruct();