@stamhoofd/models 2.63.0 → 2.65.0

package/src/models/CachedBalance.ts

@@ -1,13 +1,14 @@
-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 { column } from '@simonbackx/simple-database';
+import { QueryableModel, SQL, SQLAlias, SQLMin, 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';
+import { MemberUser } from './MemberUser';
 
 /**
  * Keeps track of how much a member/user owes or needs to be reimbursed.
  */
-export class CachedBalance extends Model {
+export class CachedBalance extends QueryableModel {
     static table = 'cached_outstanding_balances';
 
     @column({
@@ -33,7 +34,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
@@ -47,6 +51,15 @@ export class CachedBalance extends Model {
     @column({ type: 'datetime', nullable: true })
     nextDueAt: Date | null = null;
 
+    @column({ type: 'datetime', nullable: true })
+    lastReminderEmail: Date | null = null;
+
+    @column({ type: 'integer' })
+    lastReminderAmountOpen = 0;
+
+    @column({ type: 'integer' })
+    reminderEmailCount = 0;
+
     @column({
         type: 'datetime', beforeSave(old?: any) {
             if (old !== undefined) {
@@ -70,6 +83,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 +98,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,17 +112,26 @@ 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) {
+    static async balanceForObjects(organizationId: string, objectIds: string[], objectType: ReceivableBalanceType, includeUserMembers = false) {
+        if (objectIds.length === 0) {
+            return [];
+        }
+
         switch (objectType) {
             case ReceivableBalanceType.organization:
                 return await this.balanceForOrganizations(organizationId, objectIds);
             case ReceivableBalanceType.member:
                 return await this.balanceForMembers(organizationId, objectIds);
             case ReceivableBalanceType.user:
-                return await this.balanceForUsers(organizationId, objectIds);
+                return await this.balanceForUsers(organizationId, objectIds, includeUserMembers);
+            case ReceivableBalanceType.registration:
+                return await this.balanceForRegistrations(organizationId, objectIds);
         }
     }
 
@@ -122,15 +152,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 +202,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 +231,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 +242,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 +276,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,77 +288,103 @@ 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;
         }
-        const query = SQL.insert(this.table)
+        const query = this.insert()
             .columns(
                 'id',
                 'organizationId',
                 'objectId',
                 'objectType',
-                'amount',
+                'amountPaid',
+                'amountOpen',
                 'amountPending',
                 'nextDueAt',
                 'createdAt',
                 'updatedAt',
+                'reminderEmailCount',
             )
-            .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(),
                     new Date(),
+                    0,
                 ];
             }))
             .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')),
+
+                // Reset email count if amountOpen is zero
+                SQL.assignment(
+                    'reminderEmailCount',
+                    SQL.if(SQL.column('v', 'amountOpen'), 0)
+                        .then(0)
+                        .else(SQL.column('reminderEmailCount')),
+                ),
+
+                // Reset lastReminderEmail if amountOpen is zero
+                SQL.assignment(
+                    'lastReminderEmail',
+                    SQL.if(SQL.column('v', 'amountOpen'), 0)
+                        .then(null)
+                        .else(SQL.column('lastReminderEmail')),
+                ),
             );
 
         await query.insert();
@@ -328,11 +406,55 @@ 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;
         }
-        const results = await this.fetchForObjects(organizationId, userIds, 'userId', SQL.where('memberId', null));
+        const results = await this.fetchForObjects(
+            organizationId,
+            userIds,
+            'userId',
+            SQL.where('memberId', null),
+        );
+
+        // We also need to include the balance of the related members for each user
+
+        // Fetch members of these users
+        const memberUsers = await MemberUser.select().where('usersId', userIds).fetch();
+
+        const memberCachedBalances = await this.getForObjects(memberUsers.map(mu => mu.membersId), organizationId);
+
+        for (const memberCachedBalance of memberCachedBalances) {
+            const userIds = memberUsers.filter(mu => mu.membersId === memberCachedBalance.objectId).map(mu => mu.usersId);
+
+            for (const userId of userIds) {
+                // if already in results: append
+                const result = results.find(([objectId]) => objectId === userId);
+
+                if (result) {
+                    result[1].amountPaid += memberCachedBalance.amountPaid;
+                    result[1].amountOpen += memberCachedBalance.amountOpen;
+                    result[1].amountPending += memberCachedBalance.amountPending;
+                    if (memberCachedBalance.nextDueAt && (!result[1].nextDueAt || memberCachedBalance.nextDueAt > result[1].nextDueAt)) {
+                        result[1].nextDueAt = memberCachedBalance.nextDueAt;
+                    }
+                }
+                else {
+                    // Not possible
+                    throw new Error('User not found in results');
+                }
+            }
+        }
+
+        // Fetch cached balance of these members and merge the results
         await this.setForResults(organizationId, results, ReceivableBalanceType.user);
     }
 
@@ -350,28 +472,26 @@ export class CachedBalance extends Model {
         return await this.fetchBalanceItems(organizationId, memberIds, 'memberId');
     }
 
-    static async balanceForUsers(organizationId: string, userIds: string[]) {
+    static async balanceForUsers(organizationId: string, userIds: string[], includeUserMembers = false) {
         if (userIds.length === 0) {
             return [];
         }
-        return await this.fetchBalanceItems(organizationId, userIds, 'userId', SQL.where('memberId', null));
-    }
+        const base = await this.fetchBalanceItems(organizationId, userIds, 'userId', SQL.where('memberId', null));
 
-    /**
-     * Experimental: needs to move to library
-     */
-    static select() {
-        const transformer = (row: SQLResultNamespacedRow): CachedBalance => {
-            const d = (this as typeof CachedBalance & typeof Model).fromRow(row[this.table] as any) as CachedBalance | undefined;
-
-            if (!d) {
-                throw new Error('EmailTemplate not found');
-            }
+        if (!includeUserMembers) {
+            return base;
+        }
 
-            return d;
-        };
+        const memberUsers = await MemberUser.select().where('usersId', userIds).fetch();
+        const memberIds = memberUsers.map(mu => mu.membersId);
+        const memberCachedBalances = await this.balanceForMembers(organizationId, memberIds);
+        return base.concat(memberCachedBalances);
+    }
 
-        const select = new SQLSelect(transformer, SQL.wildcard());
-        return select.from(SQL.table(this.table));
+    static async balanceForRegistrations(organizationId: string, registrationIds: string[]) {
+        if (registrationIds.length === 0) {
+            return [];
+        }
+        return await this.fetchBalanceItems(organizationId, registrationIds, 'registrationId');
     }
 }

package/src/models/Document.ts

@@ -1,14 +1,15 @@
-import { column, Model } from '@simonbackx/simple-database';
-import { Document as DocumentStruct, DocumentData, DocumentStatus, Platform, Version } from '@stamhoofd/structures';
+import { column } from '@simonbackx/simple-database';
+import { DocumentData, DocumentStatus, Document as DocumentStruct, Platform, Version } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from 'uuid';
 
+import { QueryableModel } from '@stamhoofd/sql';
 import { render } from '../helpers/Handlebars';
 import { RegistrationWithMember } from './Member';
 import { Organization } from './Organization';
 import { Registration } from './Registration';
 
-export class Document extends Model {
+export class Document extends QueryableModel {
     static table = 'documents';
 
     @column({ primary: true, type: 'string', beforeSave(value) {

package/src/models/DocumentTemplate.ts

@@ -1,20 +1,21 @@
-import { column, Model } from '@simonbackx/simple-database';
+import { column } from '@simonbackx/simple-database';
 import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-errors';
 import { QueueHandler } from '@stamhoofd/queues';
 import { BalanceItemStatus, DocumentData, DocumentPrivateSettings, DocumentSettings, DocumentStatus, DocumentTemplatePrivate, GroupType, NationalRegisterNumberOptOut, Parent, RecordAddressAnswer, RecordAnswer, RecordAnswerDecoder, RecordDateAnswer, RecordPriceAnswer, RecordSettings, RecordTextAnswer, RecordType } from '@stamhoofd/structures';
 import { Sorter } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from 'uuid';
 
+import { QueryableModel } from '@stamhoofd/sql';
 import { render } from '../helpers/Handlebars';
 import { BalanceItem } from './BalanceItem';
 import { Document } from './Document';
 import { Group } from './Group';
 import { Member, RegistrationWithMember } from './Member';
 import { Organization } from './Organization';
-import { User } from './User';
 import { Registration } from './Registration';
+import { User } from './User';
 
-export class DocumentTemplate extends Model {
+export class DocumentTemplate extends QueryableModel {
     static table = 'document_templates';
 
     @column({ primary: true, type: 'string', beforeSave(value) {
@@ -74,9 +75,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 +105,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 +117,36 @@ export class DocumentTemplate extends Model {
             'registration.price':
                 RecordPriceAnswer.create({
                     settings: RecordSettings.create({
+                        id: 'registration.price',
+                        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.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: registration.price,
+                    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 +506,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;
             }
         }