@stamhoofd/models 2.39.0 → 2.40.0

package/src/models/Group.ts

@@ -1,130 +1,131 @@
 import { column, Database, ManyToOneRelation, Model, OneToManyRelation } from '@simonbackx/simple-database';
-import { GroupCategory, GroupPrivateSettings, GroupSettings, GroupStatus, Group as GroupStruct, GroupType, StockReservation } from '@stamhoofd/structures';
-import { v4 as uuidv4 } from "uuid";
+import { GroupCategory, GroupPrivateSettings, GroupSettings, GroupStatus, Group as GroupStruct, GroupType, minimumRegistrationCount, StockReservation } from '@stamhoofd/structures';
+import { v4 as uuidv4 } from 'uuid';
 
+import { ArrayDecoder } from '@simonbackx/simple-encoding';
+import { QueueHandler } from '@stamhoofd/queues';
 import { Formatter } from '@stamhoofd/utility';
+import { SetupStepUpdater } from '../helpers/SetupStepsUpdater';
 import { Member, MemberWithRegistrations, OrganizationRegistrationPeriod, Payment, Registration, User } from './';
-import { QueueHandler } from '@stamhoofd/queues';
-import { ArrayDecoder } from '@simonbackx/simple-encoding';
 
 if (Member === undefined) {
-    throw new Error("Import Member is undefined")
+    throw new Error('Import Member is undefined');
 }
 if (User === undefined) {
-    throw new Error("Import User is undefined")
+    throw new Error('Import User is undefined');
 }
 if (Payment === undefined) {
-    throw new Error("Import Payment is undefined")
+    throw new Error('Import Payment is undefined');
 }
 if (Registration === undefined) {
-    throw new Error("Import Registration is undefined")
+    throw new Error('Import Registration is undefined');
 }
 
 export class Group extends Model {
-    static table = "groups";
+    static table = 'groups';
 
     @column({
-        primary: true, type: "string", beforeSave(value) {
+        primary: true, type: 'string', beforeSave(value) {
             return value ?? uuidv4();
-        }
+        },
     })
     id!: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     type = GroupType.Membership;
 
-    @column({ type: "json", decoder: GroupSettings })
+    @column({ type: 'json', decoder: GroupSettings })
     settings: GroupSettings;
 
-    @column({ 
-        type: "json", decoder: GroupPrivateSettings
+    @column({
+        type: 'json', decoder: GroupPrivateSettings,
     })
-    privateSettings = GroupPrivateSettings.create({})
+    privateSettings = GroupPrivateSettings.create({});
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     organizationId: string;
 
-    @column({ type: "string", nullable: true })
-    waitingListId: string | null = null
+    @column({ type: 'string', nullable: true })
+    waitingListId: string | null = null;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     periodId: string;
 
-    @column({ type: "string", nullable: true })
-    defaultAgeGroupId: string | null = null
+    @column({ type: 'string', nullable: true })
+    defaultAgeGroupId: string | null = null;
 
     /**
      * Every time a new registration period starts, this number increases. This is used to mark all older registrations as 'out of date' automatically
      */
-    @column({ type: "integer" })
+    @column({ type: 'integer' })
     cycle = 0;
 
     @column({
-        type: "datetime", beforeSave(old?: any) {
+        type: 'datetime', beforeSave(old?: any) {
             if (old !== undefined) {
                 return old;
             }
-            const date = new Date()
-            date.setMilliseconds(0)
-            return date
-        }
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
+        },
     })
-    createdAt: Date
+    createdAt: Date;
 
     @column({
-        type: "datetime", beforeSave() {
-            const date = new Date()
-            date.setMilliseconds(0)
-            return date
+        type: 'datetime', beforeSave() {
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
         },
-        skipUpdate: true
+        skipUpdate: true,
     })
-    updatedAt: Date
+    updatedAt: Date;
 
     @column({
-        type: "datetime",
-        nullable: true
+        type: 'datetime',
+        nullable: true,
     })
-    deletedAt: Date | null = null
+    deletedAt: Date | null = null;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     status = GroupStatus.Open;
 
     /**
      * Editing this field is only allowed when running inside the QueueHandler
      */
-    @column({ type: "json", decoder: new ArrayDecoder(StockReservation) })
-    stockReservations: StockReservation[] = []
+    @column({ type: 'json', decoder: new ArrayDecoder(StockReservation) })
+    stockReservations: StockReservation[] = [];
 
-    static async getAll(organizationId: string, periodId: string|null, active = true) {
-        const w: any = periodId ? {periodId} : {}
+    static async getAll(organizationId: string, periodId: string | null, active = true) {
+        const w: any = periodId ? { periodId } : {};
         if (active) {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            return await Group.where({ organizationId, deletedAt: null, ...w })
+            return await Group.where({ organizationId, deletedAt: null, ...w });
         }
         // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        return await Group.where({ organizationId, ...w })
+        return await Group.where({ organizationId, ...w });
     }
 
     /**
      * Returns all parent and grandparents of this group
      */
     getParentCategories(all: GroupCategory[], recursive = true): GroupCategory[] {
-        const map = new Map<string, GroupCategory>()
-        
-        const parents = all.filter(g => g.groupIds.includes(this.id))
+        const map = new Map<string, GroupCategory>();
+
+        const parents = all.filter(g => g.groupIds.includes(this.id));
         for (const parent of parents) {
-            map.set(parent.id, parent)
+            map.set(parent.id, parent);
 
             if (recursive) {
-                const hisParents = parent.getParentCategories(all)
+                const hisParents = parent.getParentCategories(all);
                 for (const pp of hisParents) {
-                    map.set(pp.id, pp)
+                    map.set(pp.id, pp);
                 }
             }
         }
 
-        return [...map.values()]
+        return [...map.values()];
     }
 
     /**
@@ -132,177 +133,189 @@ export class Group extends Model {
      */
     async getMembersWithRegistration(waitingList = false, cycleOffset = 0): Promise<MemberWithRegistrations[]> {
         let query = `SELECT ${Member.getDefaultSelect()}, ${Registration.getDefaultSelect()}, ${User.getDefaultSelect()} from \`${Member.table}\`\n`;
-        
-        query += `JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND (\`${Registration.table}\`.\`registeredAt\` is not null OR \`${Registration.table}\`.\`waitingList\` = 1)\n`
+
+        query += `JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND (\`${Registration.table}\`.\`registeredAt\` is not null OR \`${Registration.table}\`.\`waitingList\` = 1)\n`;
 
         if (waitingList) {
-            query += `JOIN \`${Registration.table}\` as reg_filter ON reg_filter.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND reg_filter.\`waitingList\` = 1\n`
-        } else {
-            query += `JOIN \`${Registration.table}\` as reg_filter ON reg_filter.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND reg_filter.\`waitingList\` = 0 AND reg_filter.\`registeredAt\` is not null\n`
+            query += `JOIN \`${Registration.table}\` as reg_filter ON reg_filter.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND reg_filter.\`waitingList\` = 1\n`;
+        }
+        else {
+            query += `JOIN \`${Registration.table}\` as reg_filter ON reg_filter.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND reg_filter.\`waitingList\` = 0 AND reg_filter.\`registeredAt\` is not null\n`;
         }
 
-        query += Member.users.joinQuery(Member.table, User.table)+"\n"
+        query += Member.users.joinQuery(Member.table, User.table) + '\n';
 
         // We do an extra join because we also need to get the other registrations of each member (only one regitration has to match the query)
-        query += `where reg_filter.\`groupId\` = ? AND reg_filter.\`cycle\` = ?`
+        query += `where reg_filter.\`groupId\` = ? AND reg_filter.\`cycle\` = ?`;
 
-        const [results] = await Database.select(query, [this.id, this.cycle - cycleOffset])
-        const members: MemberWithRegistrations[] = []
+        const [results] = await Database.select(query, [this.id, this.cycle - cycleOffset]);
+        const members: MemberWithRegistrations[] = [];
 
-        const groupIds = results.map(r => r[Registration.table]?.groupId).filter(id => id) as string[]
-        const groups = await Group.getByIDs(...Formatter.uniqueArray(groupIds))
+        const groupIds = results.map(r => r[Registration.table]?.groupId).filter(id => id) as string[];
+        const groups = await Group.getByIDs(...Formatter.uniqueArray(groupIds));
 
         for (const row of results) {
-            const foundMember = Member.fromRow(row[Member.table])
+            const foundMember = Member.fromRow(row[Member.table]);
             if (!foundMember) {
-                throw new Error("Expected member in every row")
+                throw new Error('Expected member in every row');
             }
-            const _f = foundMember.setManyRelation(Member.registrations as unknown as OneToManyRelation<"registrations", Member, Registration & {group: Group}>, []).setManyRelation(Member.users, [])
+            const _f = foundMember.setManyRelation(Member.registrations as unknown as OneToManyRelation<'registrations', Member, Registration & { group: Group }>, []).setManyRelation(Member.users, []);
 
             // Seach if we already got this member?
-            const existingMember = members.find(m => m.id == _f.id)
+            const existingMember = members.find(m => m.id == _f.id);
 
-            const member: MemberWithRegistrations = (existingMember ?? _f)
+            const member: MemberWithRegistrations = (existingMember ?? _f);
             if (!existingMember) {
-                members.push(member)
+                members.push(member);
             }
 
             // Check if we have a registration with a payment
-            const registration = Registration.fromRow(row[Registration.table])
+            const registration = Registration.fromRow(row[Registration.table]);
             if (registration) {
                 // Check if we already have this registration
                 if (!member.registrations.find(r => r.id == registration.id)) {
-                    const group = groups.find(g => g.id == registration.groupId)
+                    const group = groups.find(g => g.id == registration.groupId);
                     if (!group) {
-                        throw new Error("Expected group")
+                        throw new Error('Expected group');
                     }
-                    member.registrations.push(registration.setRelation(Registration.group, group))
+                    member.registrations.push(registration.setRelation(Registration.group, group));
                 }
             }
 
             // Check if we have a user
-            const user = User.fromRow(row[User.table])
+            const user = User.fromRow(row[User.table]);
             if (user) {
                 // Check if we already have this registration
                 if (!member.users.find(r => r.id == user.id)) {
-                    member.users.push(user)
+                    member.users.push(user);
                 }
             }
         }
 
-        return members
-
+        return members;
     }
 
     /**
      * @deprecated
      */
     getStructure() {
-        return GroupStruct.create({ ...this, privateSettings: null })
+        return GroupStruct.create({ ...this, privateSettings: null });
     }
 
     /**
      * @deprecated
      */
     getPrivateStructure() {
-        return GroupStruct.create(this)
+        return GroupStruct.create(this);
     }
 
     private static async getCount(where: string, params: any[]) {
-        const query = `select count(*) as c from \`${Registration.table}\` where ${where}`
-        
-        const [results] = await Database.select(query, params)
+        const query = `select count(*) as c from \`${Registration.table}\` where ${where}`;
+
+        const [results] = await Database.select(query, params);
         const count = results[0]['']['c'];
         if (Number.isInteger(count)) {
-            return count as number
+            return count as number;
         }
-        return null
+        return null;
     }
 
-    async updateOccupancy() {
-        this.settings.registeredMembers = await Group.getCount(
-            "groupId = ? and registeredAt is not null AND deactivatedAt is null",
-            [this.id]
-        )
+    async updateOccupancy(options?: { isNew?: boolean }) {
+        const registeredMembersBefore = this.settings.registeredMembers ?? 0;
+
+        const registeredMembersAfter = await Group.getCount(
+            'groupId = ? and registeredAt is not null AND deactivatedAt is null',
+            [this.id],
+        );
+
+        this.settings.registeredMembers = registeredMembersAfter;
 
         this.settings.reservedMembers = await Group.getCount(
-            "groupId = ? and registeredAt is null AND (canRegister = 1 OR reservedUntil >= ?)",
-            [this.id, new Date()]
-        )
+            'groupId = ? and registeredAt is null AND (canRegister = 1 OR reservedUntil >= ?)',
+            [this.id, new Date()],
+        );
+
+        if (this.defaultAgeGroupId) {
+            const hasSufficientMembersBefore = registeredMembersBefore >= minimumRegistrationCount;
+            const hasSufficientMembersAfter = (registeredMembersAfter ?? 0) >= minimumRegistrationCount;
+
+            if (options?.isNew || hasSufficientMembersAfter !== hasSufficientMembersBefore) {
+                SetupStepUpdater.updateForOrganizationId(this.organizationId)
+                    .catch(console.error);
+            }
+        }
     }
 
     static async deleteUnreachable(organizationId: string, period: OrganizationRegistrationPeriod, allGroups: Group[]) {
-        const reachable = new Map<string, boolean>()
+        const reachable = new Map<string, boolean>();
 
-        const visited = new Map<string, boolean>()
-        const queue = [period.settings.rootCategoryId]
-        visited.set(period.settings.rootCategoryId, true)
+        const visited = new Map<string, boolean>();
+        const queue = [period.settings.rootCategoryId];
+        visited.set(period.settings.rootCategoryId, true);
 
         while (queue.length > 0) {
-            const id = queue.shift()
+            const id = queue.shift();
             if (!id) {
-                break
+                break;
             }
 
-            const category = period.settings.categories.find(c => c.id === id)
+            const category = period.settings.categories.find(c => c.id === id);
             if (!category) {
-                continue
+                continue;
             }
 
             for (const i of category.categoryIds) {
                 if (!visited.get(i)) {
-                    queue.push(i)
-                    visited.set(i, true)
+                    queue.push(i);
+                    visited.set(i, true);
                 }
             }
 
             for (const g of category.groupIds) {
-                reachable.set(g, true)
+                reachable.set(g, true);
             }
         }
 
         for (const group of allGroups) {
             if (group.periodId !== period.periodId) {
-                continue
+                continue;
             }
 
             if (group.type !== GroupType.Membership) {
-                continue
+                continue;
             }
 
             if (!reachable.get(group.id) && group.deletedAt === null) {
-                console.log("Deleting unreachable group "+group.id+" from organization "+organizationId + " org period "+period.id)
-                group.deletedAt = new Date()
-                await group.save()
+                console.log('Deleting unreachable group ' + group.id + ' from organization ' + organizationId + ' org period ' + period.id);
+                group.deletedAt = new Date();
+                await group.save();
 
-                Member.updateMembershipsForGroupId(group.id)
+                Member.updateMembershipsForGroupId(group.id);
             }
         }
     }
 
     static async applyStockReservations(groupId: string, addStockReservations: StockReservation[], free = false) {
-        await QueueHandler.schedule('group-stock-update-'+groupId, async () => {
-            const updatedGroup = await Group.getByID(groupId)
+        await QueueHandler.schedule('group-stock-update-' + groupId, async () => {
+            const updatedGroup = await Group.getByID(groupId);
             if (!updatedGroup) {
-                throw new Error("Expected group")
+                throw new Error('Expected group');
             }
 
             if (!free) {
-                updatedGroup.stockReservations = StockReservation.added(updatedGroup.stockReservations, addStockReservations)
-            } else {
-                updatedGroup.stockReservations = StockReservation.removed(updatedGroup.stockReservations, addStockReservations)
+                updatedGroup.stockReservations = StockReservation.added(updatedGroup.stockReservations, addStockReservations);
             }
-            await updatedGroup.save()
-        })
-
+            else {
+                updatedGroup.stockReservations = StockReservation.removed(updatedGroup.stockReservations, addStockReservations);
+            }
+            await updatedGroup.save();
+        });
     }
 
     static async freeStockReservations(groupId: string, reservations: StockReservation[]) {
-        return await this.applyStockReservations(groupId, reservations, true)
+        return await this.applyStockReservations(groupId, reservations, true);
     }
-
-
 }
 
-Registration.group = new ManyToOneRelation(Group, "group")
-Registration.group.foreignKey = "groupId"
+Registration.group = new ManyToOneRelation(Group, 'group');
+Registration.group.foreignKey = 'groupId';

package/src/models/Image.ts

@@ -1,73 +1,73 @@
-
-import { column, Model } from "@simonbackx/simple-database";
+import { column, Model } from '@simonbackx/simple-database';
 import { ArrayDecoder } from '@simonbackx/simple-encoding';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { File, Resolution, ResolutionRequest } from '@stamhoofd/structures';
 import AWS from 'aws-sdk';
-import sharp from "sharp";
-import { v4 as uuidv4 } from "uuid";
+import sharp from 'sharp';
+import { v4 as uuidv4 } from 'uuid';
 
 export class Image extends Model {
-    static table = "images";
+    static table = 'images';
 
-    @column({ primary: true, type: "string", beforeSave(value) {
+    @column({ primary: true, type: 'string', beforeSave(value) {
         return value ?? uuidv4();
     } })
     id!: string;
 
-    @column({ type: "json", decoder: File })
-    source: File
+    @column({ type: 'json', decoder: File })
+    source: File;
 
-    @column({ type: "json", decoder: new ArrayDecoder(Resolution) })
-    resolutions: Resolution[] = []
+    @column({ type: 'json', decoder: new ArrayDecoder(Resolution) })
+    resolutions: Resolution[] = [];
 
-    @column({ type: "datetime" })
-    createdAt: Date = new Date()
+    @column({ type: 'datetime' })
+    createdAt: Date = new Date();
 
     static async create(fileContent: string | Buffer, type: string | undefined, resolutions: ResolutionRequest[]): Promise<Image> {
         if (!STAMHOOFD.SPACES_BUCKET || !STAMHOOFD.SPACES_ENDPOINT || !STAMHOOFD.SPACES_KEY || !STAMHOOFD.SPACES_SECRET) {
             throw new SimpleError({
-                code: "not_available",
-                message: "Uploading is not available",
-                statusCode: 503
-            })
+                code: 'not_available',
+                message: 'Uploading is not available',
+                statusCode: 503,
+            });
         }
 
         let fileType = 'png';
-        if (type == "image/jpeg" || type == "image/jpg") {
-            fileType = "jpg";
+        if (type == 'image/jpeg' || type == 'image/jpg') {
+            fileType = 'jpg';
         }
-        if (type === "image/svg+xml" || type === "image/svg") {
-            fileType = "svg";
+        if (type === 'image/svg+xml' || type === 'image/svg') {
+            fileType = 'svg';
         }
 
-        console.log('creating image', fileType, type, resolutions)
+        console.log('creating image', fileType, type, resolutions);
 
-        const supportsTransparency = fileType == "png" || fileType == "svg"
-        const promises: Promise<{data: Buffer;info: sharp.OutputInfo}>[] = [];
+        const supportsTransparency = fileType == 'png' || fileType == 'svg';
+        const promises: Promise<{ data: Buffer;info: sharp.OutputInfo }>[] = [];
 
         if (resolutions.length) {
-            let sharpStream = sharp(fileContent, fileType === 'svg' ? {density: 600} : {}).rotate(); 
+            let sharpStream = sharp(fileContent, fileType === 'svg' ? { density: 600 } : {}).rotate();
             if (!supportsTransparency) {
-                sharpStream = sharpStream.flatten({background: {r: 255, g: 255, b: 255}});
+                sharpStream = sharpStream.flatten({ background: { r: 255, g: 255, b: 255 } });
             }
 
-            for(const r of resolutions) {
+            for (const r of resolutions) {
                 const size = {
                     width: r.width ?? undefined,
                     height: r.height ?? undefined,
                     fit: r.fit,
-                    withoutEnlargement: type !== "image/svg+xml"
-                }
+                    withoutEnlargement: type !== 'image/svg+xml',
+                };
 
                 let t = sharpStream.resize(size);
 
                 // Generate the image data
                 if (!supportsTransparency) {
                     t = t.jpeg({
-                            quality: 80,
-                        });
-                } else {
+                        quality: 80,
+                    });
+                }
+                else {
                     t = t.png();
                 }
 
@@ -80,37 +80,37 @@ export class Image extends Model {
         const s3 = new AWS.S3({
             endpoint: STAMHOOFD.SPACES_ENDPOINT,
             accessKeyId: STAMHOOFD.SPACES_KEY,
-            secretAccessKey: STAMHOOFD.SPACES_SECRET
+            secretAccessKey: STAMHOOFD.SPACES_SECRET,
         });
 
-        let prefix = (STAMHOOFD.SPACES_PREFIX ?? "")
+        let prefix = (STAMHOOFD.SPACES_PREFIX ?? '');
         if (prefix.length > 0) {
-            prefix += "/"
+            prefix += '/';
         }
 
-        const uploadPromises: Promise<any>[] = []
-        const image = new Image()
+        const uploadPromises: Promise<any>[] = [];
+        const image = new Image();
         image.id = uuidv4();
 
         for (const f of files) {
             const fileId = uuidv4();
 
-            const key = prefix+(STAMHOOFD.environment ?? "development")+"/"+image.id+"/"+fileId+(!supportsTransparency ? '.jpg' : '.png');
+            const key = prefix + (STAMHOOFD.environment ?? 'development') + '/' + image.id + '/' + fileId + (!supportsTransparency ? '.jpg' : '.png');
             const params = {
                 Bucket: STAMHOOFD.SPACES_BUCKET,
                 Key: key,
                 Body: f.data,
                 ContentType: !supportsTransparency ? 'image/jpeg' : 'image/png',
-                ACL: "public-read"
+                ACL: 'public-read',
             };
 
             uploadPromises.push(s3.putObject(params).promise());
 
             const _file = new File({
                 id: fileId,
-                server: "https://"+STAMHOOFD.SPACES_BUCKET+"."+STAMHOOFD.SPACES_ENDPOINT,
+                server: 'https://' + STAMHOOFD.SPACES_BUCKET + '.' + STAMHOOFD.SPACES_ENDPOINT,
                 path: key,
-                size: f.info.size
+                size: f.info.size,
             });
 
             const _image = new Resolution({
@@ -118,32 +118,32 @@ export class Image extends Model {
                 width: f.info.width,
                 height: f.info.height,
             });
-            image.resolutions.push(_image)
+            image.resolutions.push(_image);
         }
 
         // Also include the source, in private mode
         const fileId = uuidv4();
-        const uploadExt = fileType
-        const key = prefix+(STAMHOOFD.environment ?? "development")+"/"+image.id+"/"+fileId+"."+uploadExt;
+        const uploadExt = fileType;
+        const key = prefix + (STAMHOOFD.environment ?? 'development') + '/' + image.id + '/' + fileId + '.' + uploadExt;
         const params = {
             Bucket: STAMHOOFD.SPACES_BUCKET,
             Key: key,
             Body: fileContent,
-            ContentType: type ?? "image/jpeg",
-            ACL: "private"
+            ContentType: type ?? 'image/jpeg',
+            ACL: 'private',
         };
 
         image.source = new File({
             id: fileId,
-            server: "https://"+STAMHOOFD.SPACES_BUCKET+"."+STAMHOOFD.SPACES_ENDPOINT,
+            server: 'https://' + STAMHOOFD.SPACES_BUCKET + '.' + STAMHOOFD.SPACES_ENDPOINT,
             path: key,
-            size: fileContent.length
+            size: fileContent.length,
         });
 
         uploadPromises.push(s3.putObject(params).promise());
 
         await Promise.all(uploadPromises);
         await image.save();
-        return image
+        return image;
     }
 }