@stamhoofd/backend 2.117.0 → 2.118.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.117.0",
+    "version": "2.118.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -55,14 +55,14 @@
         "@simonbackx/simple-encoding": "2.23.1",
         "@simonbackx/simple-endpoints": "1.20.1",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.117.0",
-        "@stamhoofd/backend-middleware": "2.117.0",
-        "@stamhoofd/email": "2.117.0",
-        "@stamhoofd/models": "2.117.0",
-        "@stamhoofd/queues": "2.117.0",
-        "@stamhoofd/sql": "2.117.0",
-        "@stamhoofd/structures": "2.117.0",
-        "@stamhoofd/utility": "2.117.0",
+        "@stamhoofd/backend-i18n": "2.118.0",
+        "@stamhoofd/backend-middleware": "2.118.0",
+        "@stamhoofd/email": "2.118.0",
+        "@stamhoofd/models": "2.118.0",
+        "@stamhoofd/queues": "2.118.0",
+        "@stamhoofd/sql": "2.118.0",
+        "@stamhoofd/structures": "2.118.0",
+        "@stamhoofd/utility": "2.118.0",
         "archiver": "^7.0.1",
         "axios": "^1.13.2",
         "cookie": "^0.7.0",
@@ -80,5 +80,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "ad4b006dca3aa5a7c14b2afc83b6df3c2a72424c"
+    "gitHead": "57fe442b1afa0bb2645295bed467c303b39a2573"
 }

package/src/endpoints/global/events/PatchEventsEndpoint.ts

@@ -1,6 +1,6 @@
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, patchObject, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { Event, Group, Platform, RegistrationPeriod, Webshop } from '@stamhoofd/models';
+import { Event, Group, OrganizationRegistrationPeriod, Platform, RegistrationPeriod, Webshop } from '@stamhoofd/models';
 import { AuditLogSource, Event as EventStruct, Group as GroupStruct, GroupType, NamedObject, PermissionLevel } from '@stamhoofd/structures';
 
 import { SimpleError } from '@simonbackx/simple-errors';
@@ -134,26 +134,18 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             event.name = put.name;
             event.startDate = put.startDate;
             event.endDate = put.endDate;
+            event.typeId = put.typeId;
 
-            const type = await PatchEventsEndpoint.getEventType(put.typeId);
-            event.typeId = type.id;
             event.meta.organizationCache = eventOrganization ? NamedObject.create({ id: eventOrganization.id, name: eventOrganization.name }) : null;
             await PatchEventsEndpoint.checkEventLimits(event);
 
             if (put.group) {
-                const group = await this.putEventGroup(event, put.group);
-                await AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
-                    await event.syncGroupRequirements(group);
-                });
-                event.groupId = group.id;
+                await this.saveEventAndLinkExistingGroup(event, put.group);
             }
-
-            if (type.isLocationRequired === true) {
-                PatchEventsEndpoint.throwIfAddressIsMissing(event);
+            else {
+                await event.save();
             }
 
-            await event.save();
-
             events.push(event);
         }
 
@@ -228,10 +220,8 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             event.startDate = patch.startDate ?? event.startDate;
             event.endDate = patch.endDate ?? event.endDate;
 
-            const type = await PatchEventsEndpoint.getEventType(patch.typeId ?? event.typeId);
-
             if (patch.typeId) {
-                event.typeId = type.id;
+                event.typeId = patch.typeId;
             }
 
             await PatchEventsEndpoint.checkEventLimits(event);
@@ -317,10 +307,6 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                 }
             }
 
-            if (type.isLocationRequired === true) {
-                PatchEventsEndpoint.throwIfAddressIsMissing(event);
-            }
-
             if (patch.webshopId !== undefined) {
                 if (patch.webshopId === null) {
                     event.webshopId = null;
@@ -399,6 +385,21 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
     static async checkEventLimits(event: Event) {
         const type = await this.getEventType(event.typeId);
 
+        if (type.isLocationRequired) {
+            const address = event.meta.location?.address;
+
+            if (!address) {
+                throw new SimpleError({
+                    code: 'invalid_field',
+                    message: 'Empty number',
+                    human: $t(`6b72f8bd-cd5b-423f-a556-be102d3c22e9`),
+                    field: 'event_required',
+                });
+            }
+
+            address.throwIfIncomplete();
+        }
+
         if (event.name.length < 2) {
             throw new SimpleError({
                 code: 'invalid_field',
@@ -484,18 +485,85 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
         }
     }
 
-    private static throwIfAddressIsMissing(event: Event) {
-        const address = event.meta.location?.address;
+    private async saveEventAndLinkExistingGroup(event: Event, putGroup: GroupStruct): Promise<void> {
+        const existingGroup = await Group.getByID(putGroup.id);
 
-        if (!address) {
+        if (!existingGroup) {
             throw new SimpleError({
-                code: 'invalid_field',
-                message: 'Empty number',
-                human: $t(`6b72f8bd-cd5b-423f-a556-be102d3c22e9`),
-                field: 'event_required',
+                code: 'group_not_found',
+                message: `Group with id ${putGroup.id} does not exist`,
+            });
+        }
+
+        // keep track of original data for reset in case of failure
+        const originalGroupType = existingGroup.type;
+
+        if (!await Context.auth.canAccessGroup(existingGroup)) {
+            throw Context.auth.error($t(`Je hebt geen toegangsrechten om de groep te wijzigen.`));
+        }
+
+        if (event.organizationId !== existingGroup.organizationId) {
+            throw new SimpleError({
+                code: 'invalid_group',
+                message: 'Group has different organization id',
+            });
+        }
+
+        if (existingGroup.settings.eventId !== null && existingGroup.settings.eventId !== event.id) {
+            throw new SimpleError({
+                code: 'invalid_group',
+                message: 'Group is already linked to another event',
             });
         }
 
-        address.throwIfIncomplete();
+        if (existingGroup.type !== GroupType.EventRegistration) {
+            if (existingGroup.type !== GroupType.Membership) {
+                throw new SimpleError({
+                    code: 'invalid_group',
+                    message: 'Can only link a group of type EventRegistration or Membership',
+                });
+            }
+            existingGroup.type = GroupType.EventRegistration;
+        }
+
+        existingGroup.settings.eventId = event.id;
+
+        // update group categories
+        const period = await RegistrationPeriod.getByID(existingGroup.periodId);
+        if (!period) {
+            throw new SimpleError({
+                code: 'not_found',
+                message: 'No period found for group',
+            });
+        }
+
+        const organizationPeriod = await OrganizationRegistrationPeriod.select().where('organizationId', existingGroup.organizationId).where('periodId', period.id).first(true);
+        if (!organizationPeriod) {
+            throw new SimpleError({
+                code: 'not_found',
+                message: 'No organization period found for group',
+            });
+        }
+        event.groupId = existingGroup.id;
+        await event.save();
+
+        try {
+            await AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
+                await event.syncGroupRequirements(existingGroup);
+            });
+        }
+        catch (e) {
+            // reset the group
+            existingGroup.type = originalGroupType;
+            existingGroup.settings.eventId = null;
+            await existingGroup.save();
+
+            // delete the event again if failed to link the group
+            await event.delete();
+            throw e;
+        }
+
+        const allGroups = await Group.getAll(organizationPeriod.organizationId, organizationPeriod.periodId);
+        await organizationPeriod.cleanCategories(allGroups);
     }
 }

package/src/endpoints/global/members/PatchOrganizationMembersEndpoint.ts

@@ -3,7 +3,7 @@ import { AutoEncoderPatchType, ConvertArrayToPatchableArray, Decoder, isEmptyPat
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { AuditLog, BalanceItem, Document, Group, Member, MemberFactory, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, MemberWithUsersAndRegistrations, MemberWithUsersRegistrationsAndGroups, mergeTwoMembers, Organization, Platform, RateLimiter, Registration, RegistrationPeriod, User } from '@stamhoofd/models';
-import { AuditLogReplacement, AuditLogReplacementType, AuditLogSource, AuditLogType, EmergencyContact, GroupType, MemberDetails, MemberResponsibility, MembersBlob, MemberWithRegistrationsBlob, Parent, PermissionLevel, SetupStepType } from '@stamhoofd/structures';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogSource, AuditLogType, EmergencyContact, GroupType, MemberDetails, MemberResponsibility, MembersBlob, MemberWithRegistrationsBlob, Parent, PermissionLevel, PlatformMembershipTypeBehaviour, SetupStepType } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 
 import { Email } from '@stamhoofd/email';
@@ -535,14 +535,41 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                     )
                     .first(false);
 
-                if (existing) {
+                if (existing && (membershipType.behaviour === PlatformMembershipTypeBehaviour.Days || !existing.generated || existing.locked || existing.price < membership.price)) {
+                    if (membershipType.behaviour === PlatformMembershipTypeBehaviour.Days) {
+                        throw new SimpleError({
+                            code: 'invalid_field',
+                            field: 'startDate',
+                            message: 'Overlapping memberships',
+                            human: $t(`Je kan geen aansluiting toevoegen die overlapt met een bestaande aansluiting.`),
+                        });
+                    }
+                    if (existing.locked) {
+                        throw new SimpleError({
+                            code: 'invalid_field',
+                            field: 'startDate',
+                            message: 'Overlapping memberships',
+                            human: $t(`Je kan geen aansluiting toevoegen die overlapt met een bestaande aansluiting die al vergendeld is.`),
+                        });
+                    }
+                    if (!existing.generated) {
+                        throw new SimpleError({
+                            code: 'invalid_field',
+                            field: 'startDate',
+                            message: 'Overlapping memberships',
+                            human: $t(`Je kan geen aansluiting toevoegen die overlapt met een bestaande aansluiting die manueel werd aangemaakt.`),
+                        });
+                    }
                     throw new SimpleError({
                         code: 'invalid_field',
                         field: 'startDate',
-                        message: 'Invalid start date',
-                        human: $t(`faf8b6bb-2727-4d2f-847f-203cf3979dfb`),
+                        message: 'Overlapping memberships',
+                        human: $t(`Je kan geen aansluiting toevoegen die overlapt met een bestaande aansluiting die goedkoper is.`),
                     });
                 }
+                else if (existing) {
+                    await existing.doDelete();
+                }
 
                 // Save if okay
                 await membership.save();

package/src/seeds/1752848561-groups-registration-periods.test.ts

@@ -0,0 +1,87 @@
+import { GroupFactory, OrganizationFactory, RegistrationPeriodFactory } from '@stamhoofd/models';
+import { checkShouldSetCustomDates } from './1752848561-groups-registration-periods.js';
+
+describe('migration.groupsRegistrationPeriods', () => {
+    describe('checkShouldSetCustomDate', () => {
+        const cases: { group: { startDate: Date; endDate: Date }; period: { startDate: Date; endDate: Date }; expected: boolean }[] = [
+            // case 1
+            {
+                group: {
+                    startDate: new Date(2023, 0, 1),
+                    endDate: new Date(2023, 11, 31),
+                },
+                period: {
+                    startDate: new Date(2023, 0, 1),
+                    endDate: new Date(2023, 11, 31),
+                },
+                expected: false,
+            },
+            // case 2
+            {
+                group: {
+                    startDate: new Date(2023, 0, 1),
+                    endDate: new Date(2023, 11, 31),
+                },
+                period: {
+                    startDate: new Date(2023, 0, 29),
+                    endDate: new Date(2023, 11, 31),
+                },
+                expected: false,
+            },
+            // case 3
+            {
+                group: {
+                    startDate: new Date(2023, 0, 1),
+                    endDate: new Date(2023, 11, 31),
+                },
+                period: {
+                    startDate: new Date(2023, 0, 1),
+                    endDate: new Date(2024, 0, 28),
+                },
+                expected: false,
+            },
+            // case 4
+            {
+                group: {
+                    startDate: new Date(2023, 0, 1),
+                    endDate: new Date(2023, 11, 31),
+                },
+                period: {
+                    startDate: new Date(2023, 1, 1),
+                    endDate: new Date(2023, 11, 31),
+                },
+                expected: true,
+            },
+            // case 5
+            {
+                group: {
+                    startDate: new Date(2023, 0, 1),
+                    endDate: new Date(2023, 11, 31),
+                },
+                period: {
+                    startDate: new Date(2023, 0, 1),
+                    endDate: new Date(2023, 10, 30),
+                },
+                expected: true,
+            },
+        ];
+
+        cases.forEach((testCase, index) => {
+            it(`Case ${index + 1}`, async () => {
+                // arrange
+                const period = await new RegistrationPeriodFactory(testCase.period).create();
+                const organization = await new OrganizationFactory({ period }).create();
+                period.organizationId = organization.id;
+                await period.save();
+                const group = await new GroupFactory({ organization, period }).create();
+                group.settings.startDate = testCase.group.startDate;
+                group.settings.endDate = testCase.group.endDate;
+                await group.save();
+
+                // act
+                const result = checkShouldSetCustomDates(group, period);
+                expect(result).toBe(testCase.expected);
+            });
+        });
+    });
+});

package/src/seeds/1752848561-groups-registration-periods.ts

@@ -119,6 +119,7 @@ async function migrateGroups({ groups, organization, periodSpan }: { groups: Gro
         const currentCycle = originalGroup.cycle;
         const originalGroupId: string = originalGroup.id;
         originalGroup.periodId = currentGroupPeriod.id;
+        originalGroup.settings.hasCustomDates = checkShouldSetCustomDates(originalGroup, currentGroupPeriod);
 
         // first migrate registrations for the current cycle
         await migrateRegistrations({ organization, period: currentGroupPeriod, originalGroup, newGroup: originalGroup, cycle: currentCycle }, dryRun);
@@ -360,6 +361,24 @@ async function migrateGroups({ groups, organization, periodSpan }: { groups: Gro
     return result;
 }
 
+export function checkShouldSetCustomDates(group: Group, period: RegistrationPeriod): boolean {
+    // if difference between period start and group start, or between period and group end is bigger than 1 month
+    return isDifferenceBiggerThanMonth(period.startDate, group.settings.startDate) || isDifferenceBiggerThanMonth(period.endDate, group.settings.endDate);
+}
+
+/**
+ * True if difference larger than 30 days.
+ * @param date1
+ * @param date2
+ */
+function isDifferenceBiggerThanMonth(date1: Date, date2: Date): boolean {
+    const diffMs = Math.abs(date1.getTime() - date2.getTime());
+    const msPerDay = 24 * 60 * 60 * 1000;
+    const diffDays = diffMs / msPerDay;
+
+    return diffDays > 30;
+}
+
 async function migrateRegistrations({ organization, period, originalGroup, newGroup, cycle }: { organization: Organization; period: RegistrationPeriod; originalGroup: Group; newGroup: Group; cycle: number }, dryRun: boolean) {
     // what for waiting lists of archive groups (previous cycles)?
     let waitingList: Group | null = null;
@@ -742,6 +761,7 @@ function createPreviousGroup({ originalGroup, period, cycleInformation, index }:
             name: new TranslatedString(`${originalSettings.name.toString()} (${extraName})`),
             startDate,
             endDate,
+            hasCustomDates: true,
         });
     newGroup.type = originalGroup.type;
 

package/src/services/PlatformMembershipService.ts

@@ -251,22 +251,40 @@ export class PlatformMembershipService {
                     const cheapestMembership = defaultMembershipsWithOrganization.sort((a, b) => {
                         const tagIdsA = a.organization?.meta.tags ?? [];
                         const tagIdsB = b.organization?.meta.tags ?? [];
-                        const aPrice = a.membership.getPrice(
+                        let aPrice = a.membership.getPrice(
                             period.id,
                             a.registration.startDate ?? a.registration.registeredAt ?? a.registration.createdAt,
                             tagIdsA,
                             shouldApplyReducedPrice,
                         ) ?? 10000000;
-                        const bPrice = b.membership.getPrice(
+                        let bPrice = b.membership.getPrice(
                             period.id,
                             b.registration.startDate ?? b.registration.registeredAt ?? b.registration.createdAt,
                             tagIdsB,
                             shouldApplyReducedPrice,
                         ) ?? 10000000;
 
+                        const chargeVia = platform.membershipOrganizationId;
+                        if (a.registration.organizationId === chargeVia) {
+                            aPrice = 0;
+                        }
+
+                        if (b.registration.organizationId === chargeVia) {
+                            bPrice = 0;
+                        }
+
                         const diff = aPrice - bPrice;
                         if (diff === 0) {
-                            return Sorter.byDateValue(b.registration.startDate ?? b.registration.registeredAt ?? b.registration.createdAt, a.registration.startDate ?? a.registration.registeredAt ?? a.registration.createdAt);
+                            return Sorter.stack(
+                                Sorter.byDateValue(
+                                    b.registration.startDate ?? b.registration.registeredAt ?? b.registration.createdAt,
+                                    a.registration.startDate ?? a.registration.registeredAt ?? a.registration.createdAt,
+                                ),
+                                Sorter.byDateValue(
+                                    b.registration.createdAt,
+                                    a.registration.createdAt,
+                                ),
+                            );
                         }
                         return diff;
                     })[0];
@@ -291,10 +309,47 @@ export class PlatformMembershipService {
                         }
                     }
 
+                    const membership = new MemberPlatformMembership();
+
+                    if (!didFind) {
+                        // Calculate price - do not save yet
+                        const periodConfig = cheapestMembership.membership.periods.get(period.id);
+                        if (!periodConfig) {
+                            console.error('Missing membership prices for membership type ' + cheapestMembership.membership.id + ' and period ' + period.id);
+                            continue;
+                        }
+
+                        // Pre calculate the price
+                        membership.memberId = me.id;
+                        membership.membershipTypeId = cheapestMembership.membership.id;
+                        membership.organizationId = cheapestMembership.registration.organizationId;
+                        membership.periodId = period.id;
+
+                        // Note: the dates will get modified in the price calculation
+                        membership.startDate = periodConfig.startDate;
+                        membership.endDate = periodConfig.endDate;
+                        membership.expireDate = periodConfig.expireDate;
+                        membership.generated = true;
+                        await membership.calculatePrice(me, cheapestMembership.registration);
+
+                        // Check if we have a not-locked but non-generated one that is cheaper
+                        // if so, we stop and don't create a new one (but still delete others if required)
+                        for (const m of activeMemberships) {
+                            if (m.membershipTypeId === cheapestMembership.membership.id && !m.generated) {
+                                // is this cheaper?
+                                if (m.price <= membership.price) { // todo expand with more details price comparison
+                                    // Cheaper
+                                    didFind = m;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+
                     // Then update all memberships from the same organization for the selected registration date range
                     for (const m of activeMemberships) {
                         if (m.membershipTypeId === cheapestMembership.membership.id && m.organizationId === cheapestMembership.registration.organizationId) {
-                            if (!m.locked) {
+                            if (!m.locked && m.generated) {
                                 // Update the price and dates of this active membership (could have changed)
                                 try {
                                     await m.calculatePrice(me, cheapestMembership.registration);
@@ -323,7 +378,7 @@ export class PlatformMembershipService {
                                 }
                                 await m.doDelete();
                             }
-                            else {
+                            else if (m.membershipTypeId === cheapestMembership.membership.id) {
                                 // Update price
                                 if (!m.locked) {
                                     try {
@@ -346,31 +401,11 @@ export class PlatformMembershipService {
                         continue;
                     }
 
-                    // Otherwise make sure we create a new membership
-
-                    const periodConfig = cheapestMembership.membership.periods.get(period.id);
-                    if (!periodConfig) {
-                        console.error('Missing membership prices for membership type ' + cheapestMembership.membership.id + ' and period ' + period.id);
-                        continue;
-                    }
-
                     // Can we revive an earlier deleted membership?
                     if (!silent) {
                         console.log('Creating automatic membership for: ' + me.id + ' - membership type ' + cheapestMembership.membership.id);
                     }
 
-                    const membership = new MemberPlatformMembership();
-                    membership.memberId = me.id;
-                    membership.membershipTypeId = cheapestMembership.membership.id;
-                    membership.organizationId = cheapestMembership.registration.organizationId;
-                    membership.periodId = period.id;
-
-                    // Note: the dates will get modified in the price calculation
-                    membership.startDate = periodConfig.startDate;
-                    membership.endDate = periodConfig.endDate;
-                    membership.expireDate = periodConfig.expireDate;
-                    membership.generated = true;
-
                     if (me.details.memberNumber === null) {
                         try {
                             await MemberNumberService.assignMemberNumber(me, membership);
@@ -382,7 +417,6 @@ export class PlatformMembershipService {
                         }
                     }
 
-                    await membership.calculatePrice(me, cheapestMembership.registration);
                     await membership.save();
                 }
             });