@stamhoofd/models 2.1.1

package/src/models/Image.ts

@@ -0,0 +1,147 @@
+
+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";
+
+export class Image extends Model {
+    static table = "images";
+
+    @column({ primary: true, type: "string", beforeSave(value) {
+        return value ?? uuidv4();
+    } })
+    id!: string;
+
+    @column({ type: "json", decoder: File })
+    source: File
+
+    @column({ type: "json", decoder: new ArrayDecoder(Resolution) })
+    resolutions: Resolution[] = []
+
+    @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
+            })
+        }
+
+        let fileType = 'png';
+        if (fileType == "image/jpeg" || fileType == "image/jpg") {
+            fileType = "jpg";
+        }
+        if (fileType === "image/svg+xml" || fileType === "image/svg") {
+            fileType = "svg";
+        }
+
+        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(); 
+            if (!supportsTransparency) {
+                sharpStream = sharpStream.flatten({background: {r: 255, g: 255, b: 255}});
+            }
+
+            for(const r of resolutions) {
+                const size = {
+                    width: r.width ?? undefined,
+                    height: r.height ?? undefined,
+                    fit: r.fit,
+                    withoutEnlargement: type !== "image/svg+xml"
+                }
+
+                let t = sharpStream.resize(size);
+
+                // Generate the image data
+                if (!supportsTransparency) {
+                    t = t.jpeg({
+                            quality: 80,
+                        });
+                } else {
+                    t = t.png();
+                }
+
+                promises.push(t.toBuffer({ resolveWithObject: true }));
+            }
+        }
+
+        const files = await Promise.all(promises);
+
+        const s3 = new AWS.S3({
+            endpoint: STAMHOOFD.SPACES_ENDPOINT,
+            accessKeyId: STAMHOOFD.SPACES_KEY,
+            secretAccessKey: STAMHOOFD.SPACES_SECRET
+        });
+
+        let prefix = (STAMHOOFD.SPACES_PREFIX ?? "")
+        if (prefix.length > 0) {
+            prefix += "/"
+        }
+
+        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 params = {
+                Bucket: STAMHOOFD.SPACES_BUCKET,
+                Key: key,
+                Body: f.data,
+                ContentType: !supportsTransparency ? 'image/jpeg' : 'image/png',
+                ACL: "public-read"
+            };
+
+            uploadPromises.push(s3.putObject(params).promise());
+
+            const _file = new File({
+                id: fileId,
+                server: "https://"+STAMHOOFD.SPACES_BUCKET+"."+STAMHOOFD.SPACES_ENDPOINT,
+                path: key,
+                size: f.info.size
+            });
+
+            const _image = new Resolution({
+                file: _file,
+                width: f.info.width,
+                height: f.info.height,
+            });
+            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 params = {
+            Bucket: STAMHOOFD.SPACES_BUCKET,
+            Key: key,
+            Body: fileContent,
+            ContentType: type ?? "image/jpeg",
+            ACL: "private"
+        };
+
+        image.source = new File({
+            id: fileId,
+            server: "https://"+STAMHOOFD.SPACES_BUCKET+"."+STAMHOOFD.SPACES_ENDPOINT,
+            path: key,
+            size: fileContent.length
+        });
+
+        uploadPromises.push(s3.putObject(params).promise());
+
+        await Promise.all(uploadPromises);
+        await image.save();
+        return image
+    }
+}

package/src/models/Member.ts

@@ -0,0 +1,386 @@
+import { column, Database, ManyToManyRelation, ManyToOneRelation, Model, OneToManyRelation } from '@simonbackx/simple-database';
+import { SQL } from "@stamhoofd/sql";
+import { Member as MemberStruct, MemberDetails, MemberWithRegistrationsBlob, RegistrationWithMember as RegistrationWithMemberStruct, User as UserStruct } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { v4 as uuidv4 } from "uuid";
+
+import { Group, Payment, Registration, User } from './';
+export type MemberWithRegistrations = Member & { 
+    users: User[], 
+    registrations: (Registration & {group: Group})[] 
+}
+
+// Defined here to prevent cycles
+export type RegistrationWithMember = Registration & { member: Member }
+
+export class Member extends Model {
+    static table = "members"
+
+    // Columns
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ type: "string", nullable: true })
+    organizationId: string|null = null;
+
+    @column({
+        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({ 
+        type: "string", 
+        nullable: true, 
+        beforeSave: function(this: Member) {
+            return this.details?.birthDay ? Formatter.dateIso(this.details.birthDay) : null
+        },
+        skipUpdate: true 
+    })
+    birthDay: string | null
+
+    @column({ type: "json", decoder: MemberDetails })
+    details: MemberDetails
+
+    /**
+     * Not yet paid balance
+     */
+    @column({ type: "integer" })
+    outstandingBalance = 0
+
+    @column({
+        type: "datetime", beforeSave(old?: any) {
+            if (old !== undefined) {
+                return old;
+            }
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        }
+    })
+    createdAt: Date
+
+    @column({
+        type: "datetime", beforeSave() {
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        },
+        skipUpdate: true
+    })
+    updatedAt: Date
+
+    static registrations = new OneToManyRelation(Member, Registration, "registrations", "memberId")
+
+    // Note: all relations should point to their parents, not the other way around to avoid reference cycles
+    static users = new ManyToManyRelation(Member, User, "users");
+
+    /**
+     * Fetch all members with their corresponding (valid) registration
+     */
+    static async getWithRegistrations(id: string): Promise<MemberWithRegistrations | null> {
+        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(price) - 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
+     */
+    static async getRegistrationWithMembersByIDs(ids: string[]): Promise<RegistrationWithMember[]> {
+        if (ids.length === 0) {
+            return []
+        }
+        let query = `SELECT ${Member.getDefaultSelect()}, ${Registration.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`
+
+        // 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 \`${Registration.table}\`.\`${Registration.primary.name}\` IN (?)`
+
+        const [results] = await Database.select(query, [ids])
+        const registrations: RegistrationWithMember[] = []
+
+         // In the future we might add a 'reverse' method on manytoone relation, instead of defining the new relation. But then we need to store 2 model types in the many to one relation.
+        const registrationMemberRelation = new ManyToOneRelation(Member, "member")
+        registrationMemberRelation.foreignKey = Member.registrations.foreignKey
+
+        for (const row of results) {
+            const registration = Registration.fromRow(row[Registration.table])
+            if (!registration) {
+                throw new Error("Expected registration in every row")
+            }
+
+            const foundMember = Member.fromRow(row[Member.table])
+            if (!foundMember) {
+                throw new Error("Expected member in every row")
+            }
+            
+            const _f = registration.setRelation(registrationMemberRelation, foundMember)           
+            registrations.push(_f)
+        }
+
+        return registrations
+    }
+
+    /**
+     * Fetch all registrations with members with their corresponding (valid) registrations
+     */
+    static async getRegistrationWithMembersForGroup(groupId: string, cycle: number): Promise<RegistrationWithMember[]> {
+        let query = `SELECT ${Member.getDefaultSelect()}, ${Registration.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`
+
+        // 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 \`${Registration.table}\`.\`groupId\` = ? AND \`${Registration.table}\`.\`cycle\` = ?`
+
+        const [results] = await Database.select(query, [groupId, cycle])
+        const registrations: RegistrationWithMember[] = []
+
+         // In the future we might add a 'reverse' method on manytoone relation, instead of defining the new relation. But then we need to store 2 model types in the many to one relation.
+        const registrationMemberRelation = new ManyToOneRelation(Member, "member")
+        registrationMemberRelation.foreignKey = Member.registrations.foreignKey
+
+        for (const row of results) {
+            const registration = Registration.fromRow(row[Registration.table])
+            if (!registration) {
+                throw new Error("Expected registration in every row")
+            }
+
+            const foundMember = Member.fromRow(row[Member.table])
+            if (!foundMember) {
+                throw new Error("Expected member in every row")
+            }
+            
+            const _f = registration.setRelation(registrationMemberRelation, foundMember)           
+            registrations.push(_f)
+        }
+
+        return registrations
+    }
+
+     /**
+     * Fetch all registrations with members with their corresponding (valid) registrations and payment
+     */
+    static async getRegistrationWithMembersForPayment(paymentId: string): Promise<RegistrationWithMember[]> {
+        const { BalanceItem, BalanceItemPayment} = await import('./');
+
+        let query = `SELECT ${Member.getDefaultSelect()}, ${Registration.getDefaultSelect()} from \`${Member.table}\`\n`;
+        
+        query += `JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\`\n`
+        
+        query += `LEFT JOIN \`${BalanceItem.table}\` ON \`${BalanceItem.table}\`.\`registrationId\` = \`${Registration.table}\`.\`${Registration.primary.name}\`\n`
+        query += `LEFT JOIN \`${BalanceItemPayment.table}\` ON \`${BalanceItemPayment.table}\`.\`${BalanceItemPayment.balanceItem.foreignKey}\` = \`${BalanceItem.table}\`.\`${BalanceItem.primary.name}\`\n`
+        query += `JOIN \`${Payment.table}\` ON \`${Payment.table}\`.\`${Payment.primary.name}\` = \`${BalanceItemPayment.table}\`.\`${BalanceItemPayment.payment.foreignKey}\`\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 \`${Payment.table}\`.\`${Payment.primary.name}\` = ?\n`
+        query += `GROUP BY \`${Registration.table}\`.\`${Registration.primary.name}\`, \`${Member.table}\`.\`${Member.primary.name}\``
+
+        const [results] = await Database.select(query, [paymentId])
+        const registrations: RegistrationWithMember[] = []
+
+         // In the future we might add a 'reverse' method on manytoone relation, instead of defining the new relation. But then we need to store 2 model types in the many to one relation.
+        const registrationMemberRelation = new ManyToOneRelation(Member, "member")
+        registrationMemberRelation.foreignKey = Member.registrations.foreignKey
+
+        for (const row of results) {
+            const registration = Registration.fromRow(row[Registration.table])
+            if (!registration) {
+                throw new Error("Expected registration in every row")
+            }
+
+            const foundMember = Member.fromRow(row[Member.table])
+            if (!foundMember) {
+                throw new Error("Expected member in every row")
+            }
+            
+            const _f = registration.setRelation(registrationMemberRelation, foundMember)           
+            registrations.push(_f)
+        }
+
+        return registrations
+    }
+
+     /**
+     * Fetch all members with their corresponding (valid) registrations, users
+     */
+    static async getBlobByIds(...ids: string[]): Promise<MemberWithRegistrations[]> {
+        if (ids.length == 0) {
+            return []
+        }
+        let query = `SELECT ${Member.getDefaultSelect()}, ${Registration.getDefaultSelect()}, ${User.getDefaultSelect()}  from \`${Member.table}\`\n`;
+        query += `LEFT 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 += 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 \`${Member.table}\`.\`${Member.primary.name}\` IN (?)`
+
+        const [results] = await Database.select(query, [ids])
+        const members: MemberWithRegistrations[] = []
+
+        // Load groups
+        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])
+            if (!foundMember) {
+                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, [])
+            
+                // Seach if we already got this member?
+            const existingMember = members.find(m => m.id == _f.id)
+
+            const member: MemberWithRegistrations = (existingMember ?? _f)
+            if (!existingMember) {
+                members.push(member)
+            }
+
+             // Check if we have a registration with a payment
+            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 g = groups.find(g => g.id == registration.groupId)
+                    if (!g) {
+                        throw new Error("Group not found")
+                    }
+                    member.registrations.push(registration.setRelation(Registration.group, g))
+                }
+            }
+
+            // Check if we have a user
+            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)
+                }
+            }
+        }
+
+        return members
+
+    }
+
+    /**
+     * Fetch all members with their corresponding (valid) registrations and payment
+     */
+    static async getFamilyWithRegistrations(id: string): Promise<MemberWithRegistrations[]> {
+        let query = `SELECT l2.membersId as id from _members_users l1\n`;
+        query += `JOIN _members_users l2 on l2.usersId = l1.usersId \n`
+        query += `where l1.membersId = ? group by l2.membersId`
+
+        const [results] = await Database.select(query, [id])
+        const ids: string[] = []
+        for (const row of results) {
+            ids.push(row["l2"]["id"] as string)
+        }
+
+        if (!ids.includes(id)) {
+            // Member has no users
+            ids.push(id)
+        }
+        
+        return await this.getBlobByIds(...ids)
+    }
+
+     /**
+     * Fetch all members with their corresponding (valid) registrations or waiting lists and payments
+     */
+    static async getMembersWithRegistrationForUser(user: User): Promise<MemberWithRegistrations[]> {
+        const query = SQL
+            .select(
+                SQL.column('id')
+            )
+            .from(SQL.table(Member.table))
+            .join(
+                SQL.leftJoin(
+                    SQL.table('_members_users')
+                ).where(
+                    SQL.column('_members_users', 'membersId'),
+                    SQL.column(Member.table, 'id'),
+                )
+            ).where(
+                SQL.column('_members_users', 'usersId'),
+                user.id,
+            )
+
+        const data = await query.fetch()
+        return this.getBlobByIds(...data.map((r) => r.members.id as string));
+    }
+
+    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 => UserStruct.create({
+                ...u, 
+                hasAccount: u.hasAccount()
+            })),
+        })
+    }
+
+    static getRegistrationWithMemberStructure(registration: RegistrationWithMember & {group: import('./Group').Group}): RegistrationWithMemberStruct {
+        return RegistrationWithMemberStruct.create({
+            ...registration.getStructure(),
+            cycle: registration.cycle,
+            member: MemberStruct.create(registration.member),
+        })
+    }
+}

package/src/models/MemberResponsibilityRecord.ts

@@ -0,0 +1,39 @@
+import { column, Model } from '@simonbackx/simple-database';
+import { v4 as uuidv4 } from "uuid";
+
+export class MemberResponsibilityRecord extends Model {
+    static table = "member_responsibility_records"
+
+    // Columns
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ type: "string", nullable: true })
+    organizationId: string|null = null;
+
+    @column({ type: "string" })
+    memberId: string
+
+    @column({ type: "string" })
+    responsibilityId: string
+
+    @column({
+        type: "datetime", beforeSave(old?: any) {
+            if (old !== undefined) {
+                return old;
+            }
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        }
+    })
+    startDate: Date
+
+    @column({ type: "datetime", nullable: true })
+    endDate: Date | null = null
+
+}

package/src/models/MolliePayment.ts

@@ -0,0 +1,19 @@
+import { column,Model } from "@simonbackx/simple-database";
+import { v4 as uuidv4 } from "uuid";
+
+export class MolliePayment extends Model {
+    static table = "mollie_payments";
+
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ type: "string" })
+    paymentId: string;
+
+    @column({ type: "string" })
+    mollieId: string;
+}