@stamhoofd/models 2.2.0 → 2.4.0

package/src/models/Event.ts

@@ -0,0 +1,71 @@
+
+import { column, Model } from "@simonbackx/simple-database";
+import { EventMeta, Event as EventStruct } from '@stamhoofd/structures';
+import { v4 as uuidv4 } from "uuid";
+import { Group } from "./Group";
+
+export class Event extends Model {
+    static table = "events";
+
+    @column({ primary: true, type: "string", beforeSave(value) {
+        return value ?? uuidv4();
+    } })
+    id!: string;
+
+    @column({ type: "string" })
+    name: string
+
+    @column({ type: "string" })
+    typeId: string
+
+    @column({ type: "string", nullable: true })
+    organizationId: string|null = null
+
+    @column({ type: "string", nullable: true })
+    groupId: string|null = null
+
+    @column({ type: "datetime" })
+    startDate: Date
+
+    @column({ type: "datetime" })
+    endDate: Date
+
+    @column({ type: "json", decoder: EventMeta })
+    meta = EventMeta.create({})
+
+    @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
+
+    getStructure(group?: Group|null) {
+        return EventStruct.create({
+            ...this,
+            group: group ? group.getStructure() : null
+        })
+    }
+
+    getPrivateStructure(group?: Group|null) {
+        return EventStruct.create({
+            ...this,
+            group: group ? group.getPrivateStructure() : null
+        })
+    }
+}

package/src/models/Group.ts

@@ -1,9 +1,9 @@
 import { column, Database, ManyToOneRelation, Model, OneToManyRelation } from '@simonbackx/simple-database';
-import { CycleInformation, Group as GroupStruct, GroupCategory, GroupPrivateSettings, GroupSettings, GroupStatus } from '@stamhoofd/structures';
+import { GroupCategory, GroupPrivateSettings, GroupSettings, GroupStatus, Group as GroupStruct, GroupType } from '@stamhoofd/structures';
 import { v4 as uuidv4 } from "uuid";
 
-import { Member, MemberWithRegistrations, OrganizationRegistrationPeriod, Payment, Registration, User } from './';
 import { Formatter } from '@stamhoofd/utility';
+import { Member, MemberWithRegistrations, OrganizationRegistrationPeriod, Payment, Registration, User } from './';
 
 if (Member === undefined) {
     throw new Error("Import Member is undefined")
@@ -28,6 +28,9 @@ export class Group extends Model {
     })
     id!: string;
 
+    @column({ type: "string" })
+    type = GroupType.Membership;
+
     @column({ type: "json", decoder: GroupSettings })
     settings: GroupSettings;
 
@@ -207,7 +210,6 @@ export class Group extends Model {
             "groupId = ? and cycle = ? and waitingList = 0 and registeredAt is not null",
             [this.id, this.cycle]
         )
-        //const query = `select count(*) as c from \`${Registration.table}\` where groupId = ? and cycle = ? and (((registeredAt is not null or reservedUntil >= ?) and waitingList = 0) OR (waitingList = 1 AND canRegister = 1))`
 
         this.settings.reservedMembers = await Group.getCount(
             "groupId = ? and cycle = ? and ((waitingList = 0 and registeredAt is null AND reservedUntil >= ?) OR (waitingList = 1 and canRegister = 1))",
@@ -218,37 +220,6 @@ export class Group extends Model {
             "groupId = ? and cycle = ? and waitingList = 1",
             [this.id, this.cycle, new Date()]
         )
-
-        // Loop cycle -1 until current (excluding current)
-        for (let cycle = -1; cycle < this.cycle; cycle++) {
-            if (!this.settings.cycleSettings.has(cycle)) {
-                this.settings.cycleSettings.set(cycle, CycleInformation.create({
-                    registeredMembers: 0,
-                    reservedMembers: 0,
-                    waitingListSize: 0
-                }))
-            }
-        }
-
-        // Older cycles
-        // todo: optimize this a bit
-        for (const [cycle, info] of this.settings.cycleSettings) {
-
-            info.registeredMembers = await Group.getCount(
-                "groupId = ? and cycle = ? and waitingList = 0 and registeredAt is not null",
-                [this.id, cycle]
-            )
-
-            info.reservedMembers = await Group.getCount(
-                "groupId = ? and cycle = ? and ((waitingList = 0 and registeredAt is null AND reservedUntil >= ?) OR (waitingList = 1 and canRegister = 1))",
-                [this.id, cycle, new Date()]
-            )
-
-            info.waitingListSize = await Group.getCount(
-                "groupId = ? and cycle = ? and waitingList = 1",
-                [this.id, cycle, new Date()]
-            )
-        }
     }
 
     static async deleteUnreachable(organizationId: string, period: OrganizationRegistrationPeriod, allGroups: Group[]) {
@@ -282,10 +253,12 @@ export class Group extends Model {
         }
 
         for (const group of allGroups) {
-            if (!reachable.get(group.id) && group.status !== GroupStatus.Archived) {
-                console.log("Archiving unreachable group "+group.id+" from organization "+organizationId + " org period "+period.id)
-                group.status = GroupStatus.Archived
+            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()
+
+                Member.updateMembershipsForGroupId(group.id)
             }
         }
     }

package/src/models/Member.ts

@@ -1,6 +1,6 @@
 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 { Member as MemberStruct, MemberDetails, MemberWithRegistrationsBlob, RegistrationWithMember as RegistrationWithMemberStruct, User as UserStruct, GroupStatus } from '@stamhoofd/structures';
 import { Formatter, Sorter } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from "uuid";
 
@@ -300,7 +300,9 @@ export class Member extends Model {
                     if (!g) {
                         throw new Error("Group not found")
                     }
-                    member.registrations.push(registration.setRelation(Registration.group, g))
+                    if (g.deletedAt === null) {
+                        member.registrations.push(registration.setRelation(Registration.group, g))
+                    }
                 }
             }
 
@@ -370,10 +372,7 @@ export class Member extends Model {
             ...this,
             registrations: this.registrations.map(r => r.getStructure()),
             details: this.details,
-            users: this.users.map(u => UserStruct.create({
-                ...u, 
-                hasAccount: u.hasAccount()
-            })),
+            users: this.users.map(u => u.getStructure()),
         })
     }
 
@@ -385,6 +384,36 @@ export class Member extends Model {
         })
     }
 
+    static updateMembershipsForGroupId(id: string) {
+        QueueHandler.schedule('bulk-update-memberships', async () => {
+            console.log('Bulk updating memberships for group id ', id)
+
+            // Get all members that are registered in this group
+            const memberIds = (await SQL.select(
+                    SQL.column('members', 'id')
+                )
+                .from(SQL.table(Member.table))
+                .join(
+                    SQL.leftJoin(
+                        SQL.table(Registration.table)
+                    ).where(
+                        SQL.column(Registration.table, 'memberId'),
+                        SQL.column(Member.table, 'id')
+                    )
+                ).where(
+                    SQL.column(Registration.table, 'groupId'),
+                    id
+                ).fetch()).flatMap(r => (r.members && (typeof r.members.id) === 'string') ? [r.members.id as string] : [])
+            
+            for (const id of memberIds) {
+                const member = await Member.getWithRegistrations(id)
+                await member?.updateMemberships()
+            }
+        }).catch((e) => {
+            console.error('Failed to update memberships for group id ', id), e
+        });
+    }
+
     async updateMemberships(this: MemberWithRegistrations) {
         console.log('Updating memberships for member: ' + this.id)
         return await QueueHandler.schedule('updateMemberships-' + this.id, async () => {
@@ -410,17 +439,19 @@ export class Member extends Model {
                     membership: defaultMembership,
                 }]
             })
-            // Get active memberships for this member
+            // Get active memberships for this member that
             const memberships = await MemberPlatformMembership.where({memberId: this.id, periodId: platform.periodId })
             const now = new Date()
-            const activeMemberships = memberships.filter(m => m.startDate <= now && m.endDate >= now)
+            const activeMemberships = memberships.filter(m => m.startDate <= now && m.endDate >= now && m.deletedAt === null)
+            const activeMembershipsUndeletable = activeMemberships.filter(m => !m.canDelete() || !m.generated)
 
             if (defaultMemberships.length == 0) {
-                // Stop all active memberships
+                // Stop all active memberships taht were added automatically
                 for (const membership of activeMemberships) {
-                    if (!membership.invoiceId && !membership.invoiceItemDetailId) {
+                    if (membership.canDelete() && membership.generated) {
                         console.log('Removing membership because no longer registered member and not yet invoiced for: ' + this.id + ' - membership ' + membership.id)
-                        await membership.delete()
+                        membership.deletedAt = new Date()
+                        await membership.save()
                     }
                 }
 
@@ -429,7 +460,7 @@ export class Member extends Model {
             }
 
 
-            if (activeMemberships.length) {
+            if (activeMembershipsUndeletable.length) {
                 // Skip automatic additions
                 console.log('Skipping automatic membership for: ' + this.id, ' - already has active memberships')
                 return
@@ -447,11 +478,18 @@ export class Member extends Model {
                 throw new Error("No membership found")
             }
 
+            // Check if already have the same membership
+            if (activeMemberships.find(m => m.membershipTypeId == cheapestMembership.membership.id)) {
+                console.log('Skipping automatic membership for: ' + this.id, ' - already has this membership')
+                return
+            }
+
             const periodConfig = cheapestMembership.membership.periods.get(platform.periodId)
             if (!periodConfig) {
                 throw new Error("Period config not found")
             }
 
+            // Can we revive an earlier deleted membership?
             console.log('Creating automatic membership for: ' + this.id + ' - membership type ' + cheapestMembership.membership.id)
             const membership = new MemberPlatformMembership();
             membership.memberId = this.id
@@ -462,9 +500,19 @@ export class Member extends Model {
             membership.startDate = periodConfig.startDate
             membership.endDate = periodConfig.endDate
             membership.expireDate = periodConfig.expireDate
+            membership.generated = true;
 
             await membership.calculatePrice()
             await membership.save()
+
+            // This reasoning allows us to replace an existing membership with a cheaper one (not date based ones, but type based ones)
+            for (const toDelete of activeMemberships) {
+                if (toDelete.canDelete() && toDelete.generated) {
+                    console.log('Removing membership because cheaper membership found for: ' + this.id + ' - membership ' + toDelete.id)
+                    toDelete.deletedAt = new Date()
+                    await toDelete.save()
+                }
+            }
         });
     }
 }

package/src/models/MemberPlatformMembership.ts

@@ -47,6 +47,17 @@ export class MemberPlatformMembership extends Model {
     @column({ type: "integer" })
     price = 0;
 
+    /**
+     * Whether this was added automatically by the system
+     */
+    @column({ type: "boolean" })
+    generated = false
+
+    @column({
+        type: "datetime", nullable: true
+    })
+    deletedAt: Date|null = null
+
     @column({
         type: "datetime", beforeSave(old?: any) {
             if (old !== undefined) {
@@ -69,6 +80,16 @@ export class MemberPlatformMembership extends Model {
     })
     updatedAt: Date
 
+    canDelete() {
+        if (this.invoiceId || this.invoiceItemDetailId) {
+            return false;
+        }
+        return true;
+    }
+
+    delete(): Promise<void> {
+        throw new Error('Cannot delete a membership. Use the deletedAt column.');
+    }
 
     async calculatePrice() {
         if (this.invoiceId || this.invoiceItemDetailId) {

package/src/models/MemberResponsibilityRecord.ts

@@ -1,5 +1,6 @@
 import { column, Model } from '@simonbackx/simple-database';
 import { v4 as uuidv4 } from "uuid";
+import { MemberResponsibilityRecord as MemberResponsibilityRecordStruct } from '@stamhoofd/structures';
 
 export class MemberResponsibilityRecord extends Model {
     static table = "member_responsibility_records"
@@ -15,6 +16,9 @@ export class MemberResponsibilityRecord extends Model {
     @column({ type: "string", nullable: true })
     organizationId: string|null = null;
 
+    @column({ type: "string", nullable: true })
+    groupId: string|null = null;
+
     @column({ type: "string" })
     memberId: string
 
@@ -36,4 +40,7 @@ export class MemberResponsibilityRecord extends Model {
     @column({ type: "datetime", nullable: true })
     endDate: Date | null = null
 
+    getStructure() {
+        return MemberResponsibilityRecordStruct.create(this)
+    }
 }

package/src/models/Organization.ts

@@ -3,7 +3,7 @@ import { DecodedRequest } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { I18n } from "@stamhoofd/backend-i18n";
 import { Email, EmailInterfaceRecipient } from "@stamhoofd/email";
-import { Address, Country, DNSRecordStatus, EmailTemplateType, OrganizationEmail, OrganizationMetaData, OrganizationPrivateMetaData, OrganizationRecordsConfiguration, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, Organization as OrganizationStruct, PaymentMethod, PaymentProvider, PrivatePaymentConfiguration, Recipient, Replacement, STPackageType, TransferSettings } from "@stamhoofd/structures";
+import { AccessRight, Address, Country, DNSRecordStatus, EmailTemplateType, OrganizationEmail, OrganizationMetaData, OrganizationPrivateMetaData, OrganizationRecordsConfiguration, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, Organization as OrganizationStruct, PaymentMethod, PaymentProvider, PrivatePaymentConfiguration, Recipient, Replacement, STPackageType, TransferSettings } from "@stamhoofd/structures";
 import { AWSError } from 'aws-sdk';
 import SES from 'aws-sdk/clients/sesv2';
 import { PromiseResult } from 'aws-sdk/lib/request';
@@ -13,6 +13,7 @@ import { validateDNSRecords } from "../helpers/DNSValidator";
 import { getEmailBuilder } from "../helpers/EmailBuilder";
 import { OrganizationServerMetaData } from '../structures/OrganizationServerMetaData';
 import { EmailTemplate, Group, OrganizationRegistrationPeriod, RegistrationPeriod, StripeAccount } from "./";
+import { QueueHandler } from "@stamhoofd/queues";
 
 export class Organization extends Model {
     static table = "organizations";
@@ -263,12 +264,47 @@ export class Organization extends Model {
         return this.id+"." + defaultDomain;
     }
 
-    async getStructure({emptyGroups} = {emptyGroups: false}): Promise<OrganizationStruct> {
-        const oPeriods = await OrganizationRegistrationPeriod.where({ periodId: this.periodId }, {limit: 1})
-        const oPeriod = oPeriods[0];
+    async getPeriod({emptyGroups} = {emptyGroups: false}) {
+        const oPeriods = await OrganizationRegistrationPeriod.where({ periodId: this.periodId, organizationId: this.id }, {limit: 1})
         const period = await RegistrationPeriod.getByID(this.periodId)
+
+        if (!period) {
+            throw new Error("Period not found")
+        }
+
+        let oPeriod: OrganizationRegistrationPeriod;
+        if (oPeriods.length == 0) {
+            // Automatically create a period
+            oPeriod = await QueueHandler.schedule('create-missing-organization-period', async () => {
+                // Race condition check
+                const updatedPeriods =  await OrganizationRegistrationPeriod.where({ periodId: this.periodId, organizationId: this.id }, {limit: 1})
+
+                if (updatedPeriods.length) {
+                    return updatedPeriods[0]
+                }
+
+                console.log('Automatically creating new organization registration period for organization ' + this.id + ' and period ' + this.periodId + ' - organization period is missing')
+                const created = new OrganizationRegistrationPeriod()
+                created.organizationId = this.id
+                created.periodId = this.periodId
+                await created.save()
+                return created
+            })
+        } else {
+            oPeriod = oPeriods[0];
+        }
         const groups = emptyGroups ? [] : (await (await import("./Group")).Group.getAll(this.id, this.periodId))
 
+        return {
+            organizationPeriod: oPeriod,
+            period,
+            groups
+        }
+    }
+
+    async getStructure({emptyGroups} = {emptyGroups: false}): Promise<OrganizationStruct> {
+        const {groups, organizationPeriod, period} = await this.getPeriod({emptyGroups})
+
         const struct = OrganizationStruct.create({
             id: this.id,
             name: this.name,
@@ -279,10 +315,7 @@ export class Organization extends Model {
             website: this.website,
             groups: groups.map(g => g.getStructure()),
             createdAt: this.createdAt,
-            period: OrganizationRegistrationPeriodStruct.create({
-                ...oPeriod,
-                period: period!.getStructure()
-            })
+            period: organizationPeriod.getStructure(period, groups)
         })
 
         if (this.meta.modules.disableActivities) {
@@ -879,7 +912,7 @@ export class Organization extends Model {
         // Circular reference fix
         const User = (await import('./User')).User;
         const admins = await User.where({ organizationId: this.id, permissions: { sign: "!=", value: null }})
-        const filtered = admins.filter(a => a.organizationPermissions && (a.organizationPermissions.hasFullAccess(this.privateMeta.roles) || a.organizationPermissions.hasFinanceAccess(this.privateMeta.roles)))
+        const filtered = admins.filter(a => a.permissions?.forOrganization(this)?.hasAccessRight(AccessRight.OrganizationFinanceDirector))
 
         if (filtered.length > 0) {
             return filtered.map(f => f.getEmailTo() ).join(", ")

package/src/models/OrganizationRegistrationPeriod.ts

@@ -53,6 +53,14 @@ export class OrganizationRegistrationPeriod extends Model {
         })
     }
 
+    getPrivateStructure(this: OrganizationRegistrationPeriod, period: RegistrationPeriod, groups: Group[]) {
+        return OrganizationRegistrationPeriodStruct.create({
+            ...this,
+            period: period.getStructure(),
+            groups: groups.map(g => g.getPrivateStructure()).sort(GroupStruct.defaultSort)
+        })
+    }
+
     async cleanCategories(groups: {id: string}[]) {
         const reachable = new Map<string, boolean>()
         const queue = [this.settings.rootCategoryId]

package/src/models/RegistrationPeriod.ts

@@ -1,4 +1,5 @@
 import { column, Model } from '@simonbackx/simple-database';
+import { SQL, SQLWhereSign } from '@stamhoofd/sql';
 import { RegistrationPeriodSettings, RegistrationPeriod as RegistrationPeriodStruct } from '@stamhoofd/structures';
 import { v4 as uuidv4 } from "uuid";
 
@@ -52,4 +53,17 @@ export class RegistrationPeriod extends Model {
     getStructure() {
         return RegistrationPeriodStruct.create(this)
     }
+
+    static async getByDate(date: Date): Promise<RegistrationPeriod|null> {
+        const result = await SQL.select().from(SQL.table(this.table))
+            .where(SQL.column('startDate'), SQLWhereSign.LessEqual, date)
+            .where(SQL.column('endDate'), SQLWhereSign.GreaterEqual, date)
+            .first(false);
+
+        if (result === null || !result[this.table]) {
+            return null;
+        }
+
+        return RegistrationPeriod.fromRow(result[this.table]) ?? null
+    }
 }

package/src/models/User.ts

@@ -1,11 +1,11 @@
 
 import { column, Database, ManyToOneRelation, Model } from "@simonbackx/simple-database";
 import { EmailInterfaceRecipient } from "@stamhoofd/email";
-import { LoginProviderType, NewUser, Permissions, User as UserStruct,UserMeta, UserPermissions } from "@stamhoofd/structures";
+import { LoginProviderType, NewUser, Permissions, UserMeta, UserPermissions, User as UserStruct } from "@stamhoofd/structures";
 import argon2 from "argon2";
 import { v4 as uuidv4 } from "uuid";
 
-import { Organization, Platform } from "./";
+import { Organization } from "./";
 
 export class User extends Model {
     static table = "users";
@@ -21,6 +21,9 @@ export class User extends Model {
     @column({ foreignKey: User.organization, type: "string", nullable: true })
     organizationId: string|null;
 
+    @column({ type: "string", nullable: true })
+    memberId: string|null = null
+
     @column({ type: "string", nullable: true })
     firstName: string | null = null;
 
@@ -347,6 +350,11 @@ export class User extends Model {
             throw new Error("Missing organization")
         }
 
+        if (await User.getForAuthentication(organization?.id ?? null, email, {allowWithoutAccount: true})) {
+            // Already exists
+            return;
+        }
+
         const user = new User();
         user.organizationId = STAMHOOFD.userMode === 'platform' ? null : (organization?.id ?? null)
         user.id = id ?? uuidv4()
@@ -429,7 +437,9 @@ export class User extends Model {
             email: this.email,
             verified: this.verified,
             permissions: this.permissions,
-            hasAccount: this.hasAccount()
+            hasAccount: this.hasAccount(),
+            memberId: this.memberId,
+            organizationId: this.organizationId
         });
     }
 

package/src/models/index.ts

@@ -48,3 +48,6 @@ export * from "./MemberResponsibilityRecord"
 export * from "./OrganizationRegistrationPeriod"
 export * from "./RegistrationPeriod"
 export * from "./MemberPlatformMembership"
+export * from "./Email"
+export * from "./EmailRecipient"
+export * from "./Event"