@stamhoofd/backend 2.120.6 → 2.121.0

package/src/services/PlatformMembershipService.ts

@@ -175,7 +175,7 @@ export class PlatformMembershipService {
                 }
                 const types = platform.config.membershipTypes.filter(m => m.behaviour === PlatformMembershipTypeBehaviour.Period).map(m => m.id);
                 if (types.length === 0) {
-                    if (!silent) {
+                    if (!silent && STAMHOOFD.environment !== 'test') {
                         console.warn('No membership types found for memberships');
                     }
                     return;

package/src/services/RegistrationService.ts

@@ -1,12 +1,12 @@
 import { ManyToOneRelation } from '@simonbackx/simple-database';
-import { BalanceItem, Document, Group, Member, Organization, Registration, sendEmailTemplate } from '@stamhoofd/models';
-import { AppliedRegistrationDiscount, AuditLogSource, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, EmailTemplateType, Recipient, Replacement, StockReservation, TranslatedString, Version } from '@stamhoofd/structures';
+import { encodeObject } from '@simonbackx/simple-encoding';
+import { BalanceItem, Document, Group, Member, Organization, Registration, RegistrationInvitation, sendEmailTemplate } from '@stamhoofd/models';
+import { QueueHandler } from '@stamhoofd/queues';
+import { AppliedRegistrationDiscount, AuditLogSource, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, EmailTemplateType, GroupType, Recipient, Replacement, StockReservation, Version } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
 import { AuditLogService } from './AuditLogService.js';
 import { GroupService } from './GroupService.js';
 import { PlatformMembershipService } from './PlatformMembershipService.js';
-import { QueueHandler } from '@stamhoofd/queues';
-import { Formatter } from '@stamhoofd/utility';
-import { encodeObject } from '@simonbackx/simple-encoding';
 
 export const RegistrationService = {
     /**
@@ -55,6 +55,8 @@ export const RegistrationService = {
         await registration.save();
         RegistrationService.scheduleStockUpdate(registration.id);
 
+        await this.handleWaitingListRegistrationAndInvitation(registration);
+
         await PlatformMembershipService.updateMembershipsForId(registration.memberId);
 
         if (registration.sendConfirmationEmail) {
@@ -76,6 +78,65 @@ export const RegistrationService = {
         return true;
     },
 
+    /**
+     * Delete all the invitations for the group and member linked to the registration.
+     * Will not throw if it fails.
+     * @param registration 
+     */
+    async handleWaitingListRegistrationAndInvitation(registration: Registration): Promise<void> {
+        const group = await Group.getByID(registration.groupId);
+
+        if (!group || group.type === GroupType.WaitingList) {
+            // skip if waiting list (waiting lists cannot have invitations)
+            return;
+        }
+
+        // get invitation for this group and member (can only be 1)
+        const invitation = await RegistrationInvitation.select()
+            .where('groupId', registration.groupId)
+            .andWhere('memberId', registration.memberId)
+            .first(false);
+        
+        const waitingListIds = new Set<string>();
+
+        if (group.waitingListId) {
+            // we should check if the member is on the waiting list of this group
+            waitingListIds.add(group.waitingListId);
+        }
+
+        if (invitation) {
+            // delete the invitation
+            try {
+                await invitation.delete();
+            } catch (e) {
+                // an error should not stop other logic (impact of an error is low)
+                console.error(e);
+            }
+        }
+
+        // unsubscribe from waiting list
+        if (group.waitingListId) {
+            try {
+                // get the registration for the waiting list (should only be 1)
+                const waitingListRegistration = await Registration.select()
+                    .where('groupId', group.waitingListId)
+                    .where('memberId', registration.memberId)
+                    .where('deactivatedAt', null)
+                    .whereNot('registeredAt', null)
+                    .first(false);
+                
+                if (waitingListRegistration) {
+                    // unsubscribe for waiting list (waiting lists cannot have a price -> balance items should not be updated)
+                    await RegistrationService.deactivate(waitingListRegistration);
+                    await GroupService.updateOccupancy(group.waitingListId);
+                }
+            } catch (e) {
+                // an error should not stop other logic (impact of an error is low)
+                console.error(e);
+            }
+        }
+    },
+
     async getRecipients(registration: Registration, organization: Organization, group: Group) {
         const member = await Member.getByIdWithUsers(registration.memberId);
 

package/src/services/STPackageService.ts

@@ -192,13 +192,6 @@ export class STPackageService {
         item.createdAt = now;
         item.status = BalanceItemStatus.Hidden;
 
-        if (customer && customer.company && customer.company.address) {
-            // Reverse charged vat applicable?
-            if (customer.company.address.country !== Country.Belgium) {
-                item.VATExcempt = VATExcemptReason.IntraCommunity;
-            }
-        }
-
         return item;
     }