@stamhoofd/backend 2.99.1 → 2.100.1

package/src/helpers/FlagMomentCleanup.ts

@@ -1,4 +1,4 @@
-import { Group, Member, MemberResponsibilityRecord, Platform, Registration } from '@stamhoofd/models';
+import { Group, Member, MemberResponsibilityRecord, Organization, Platform, Registration } from '@stamhoofd/models';
 import { SQL, SQLWhereExists } from '@stamhoofd/sql';
 import { GroupType } from '@stamhoofd/structures';
 import { MemberUserSyncer } from './MemberUserSyncer';
@@ -26,60 +26,113 @@ export class FlagMomentCleanup {
     }
 
     static async getActiveMemberResponsibilityRecordsForOrganizationWithoutRegistrationInCurrentPeriod() {
-        const platform = await Platform.getShared();
-        const currentPeriodId = platform.periodId;
-        const platformResponsibilityIds = platform.config.responsibilities.map(r => r.id);
+        if (STAMHOOFD.userMode === 'platform') {
+            const platform = await Platform.getShared();
+            const currentPeriodId = platform.periodId;
+            const platformResponsibilityIds = platform.config.responsibilities.map(r => r.id);
 
-        return await MemberResponsibilityRecord.select()
-            .whereNot('organizationId', null)
-            .where(
-                MemberResponsibilityRecord.whereActive,
-            )
-            .whereNot(
-                new SQLWhereExists(
-                    SQL.select()
-                        .from(Registration.table)
-                        .join(
-                            SQL.innerJoin(SQL.table(Group.table))
-                                .where(
-                                    SQL.column(Group.table, 'id'),
-                                    SQL.column(Registration.table, 'groupId'),
+            return await MemberResponsibilityRecord.select()
+                .whereNot('organizationId', null)
+                .where(
+                    MemberResponsibilityRecord.whereActive,
+                )
+                .whereNot(
+                    new SQLWhereExists(
+                        SQL.select()
+                            .from(Registration.table)
+                            .join(
+                                SQL.innerJoin(SQL.table(Group.table))
+                                    .where(
+                                        SQL.column(Group.table, 'id'),
+                                        SQL.column(Registration.table, 'groupId'),
+                                    ),
+                            )
+                            .where(
+                                SQL.column(Registration.table, 'memberId'),
+                                SQL.column(MemberResponsibilityRecord.table, 'memberId'),
+                            ).where(
+                                SQL.column(Registration.table, 'organizationId'),
+                                SQL.column(MemberResponsibilityRecord.table, 'organizationId'),
+                            ).where(
+                                SQL.column(Registration.table, 'periodId'),
+                                currentPeriodId,
+                            ).where(
+                                SQL.column(Registration.table, 'deactivatedAt'),
+                                null,
+                            ).whereNot(
+                                SQL.column(Registration.table, 'registeredAt'),
+                                null,
+                            ).where(
+                                SQL.column(Group.table, 'type'),
+                                GroupType.Membership,
+                            ).where(
+                                SQL.where(
+                                    SQL.column(Group.table, 'defaultAgeGroupId'),
+                                    '!=',
+                                    null,
+                                ).or(
+                                    SQL.column(MemberResponsibilityRecord.table, 'responsibilityId'),
+                                    '!=',
+                                    platformResponsibilityIds,
                                 ),
-                        )
-                        .where(
-                            SQL.column(Registration.table, 'memberId'),
-                            SQL.column(MemberResponsibilityRecord.table, 'memberId'),
-                        ).where(
-                            SQL.column(Registration.table, 'organizationId'),
-                            SQL.column(MemberResponsibilityRecord.table, 'organizationId'),
-                        ).where(
-                            SQL.column(Registration.table, 'periodId'),
-                            currentPeriodId,
-                        ).where(
-                            SQL.column(Registration.table, 'deactivatedAt'),
-                            null,
-                        ).whereNot(
-                            SQL.column(Registration.table, 'registeredAt'),
-                            null,
-                        ).where(
-                            SQL.column(Group.table, 'type'),
-                            GroupType.Membership,
-                        ).where(
-                            SQL.where(
-                                SQL.column(Group.table, 'defaultAgeGroupId'),
-                                '!=',
+                            ).where(
+                                SQL.column(Group.table, 'deletedAt'),
+                                null,
+                            ),
+                    ),
+                )
+                .fetch();
+        }
+        else {
+            return await MemberResponsibilityRecord.select()
+                .join(SQL.innerJoin(
+                    SQL.table(Organization.table))
+                    .where(
+                        SQL.column(Organization.table, 'id'),
+                        SQL.column(MemberResponsibilityRecord.table, 'organizationId'),
+                    ),
+                )
+                .whereNot('organizationId', null)
+                .whereNot(SQL.column(Organization.table, 'periodId'), null)
+                .where(
+                    MemberResponsibilityRecord.whereActive,
+                )
+                .whereNot(
+                    new SQLWhereExists(
+                        SQL.select()
+                            .from(Registration.table)
+                            .join(
+                                SQL.innerJoin(SQL.table(Group.table))
+                                    .where(
+                                        SQL.column(Group.table, 'id'),
+                                        SQL.column(Registration.table, 'groupId'),
+                                    ),
+                            )
+                            .where(
+                                SQL.column(Registration.table, 'memberId'),
+                                SQL.column(MemberResponsibilityRecord.table, 'memberId'),
+                            ).where(
+                                SQL.column(Registration.table, 'organizationId'),
+                                SQL.column(MemberResponsibilityRecord.table, 'organizationId'),
+                            ).where(
+                                SQL.column(Registration.table, 'periodId'),
+                                SQL.column(Organization.table, 'periodId'),
+                            ).where(
+                                SQL.column(Registration.table, 'deactivatedAt'),
+                                null,
+                            ).whereNot(
+                                SQL.column(Registration.table, 'registeredAt'),
+                                null,
+                            ).where(
+                                SQL.column(Group.table, 'type'),
+                                GroupType.Membership,
+                            ).where(
+                                SQL.column(Group.table, 'deletedAt'),
                                 null,
-                            ).or(
-                                SQL.column(MemberResponsibilityRecord.table, 'responsibilityId'),
-                                '!=',
-                                platformResponsibilityIds,
                             ),
-                        ).where(
-                            SQL.column(Group.table, 'deletedAt'),
-                            null,
-                        ),
-                ),
-            )
-            .fetch();
+                    ),
+                )
+                .fetch();
+        }
     }
 }

package/src/helpers/PeriodHelper.ts

@@ -1,10 +1,11 @@
 import { SimpleError } from '@simonbackx/simple-errors';
-import { Group, Organization, OrganizationRegistrationPeriod, RegistrationPeriod } from '@stamhoofd/models';
+import { Group, Member, MemberResponsibilityRecord, Organization, OrganizationRegistrationPeriod, Platform, RegistrationPeriod } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
-import { AuditLogSource, Group as GroupStruct } from '@stamhoofd/structures';
+import { AuditLogSource, Group as GroupStruct, PermissionLevel } from '@stamhoofd/structures';
 import { PatchOrganizationRegistrationPeriodsEndpoint } from '../endpoints/organization/dashboard/registration-periods/PatchOrganizationRegistrationPeriodsEndpoint';
 import { AuditLogService } from '../services/AuditLogService';
 import { AuthenticatedStructures } from './AuthenticatedStructures';
+import { MemberUserSyncer } from './MemberUserSyncer';
 import { SetupStepUpdater } from './SetupStepUpdater';
 
 export class PeriodHelper {
@@ -17,6 +18,88 @@ export class PeriodHelper {
         });
     }
 
+    static async stopAllResponsibilities() {
+        console.log('Stopping all responsibilities');
+        const platform = await Platform.getSharedPrivateStruct();
+        const keepPlatformResponsibilityIds = platform.config.responsibilities.filter(r => !r.organizationBased).map(r => r.id);
+        const keepResponsibilityIds = platform.config.responsibilities.filter(r => !r.organizationBased || r.permissions?.level === PermissionLevel.Full).map(r => r.id);
+        const batchSize = 100;
+
+        let lastId = '';
+        let c = 0;
+
+        while (true) {
+            const records = await MemberResponsibilityRecord.where(
+                {
+                    id: { sign: '>', value: lastId },
+                    endDate: null,
+                },
+                {
+                    limit: batchSize,
+                    sort: ['id'],
+                },
+            );
+
+            for (const record of records) {
+                lastId = record.id;
+
+                const invalid = keepPlatformResponsibilityIds.includes(record.responsibilityId) && record.organizationId;
+
+                if (!keepResponsibilityIds.includes(record.responsibilityId) || invalid) {
+                    record.endDate = new Date();
+                    await record.save();
+                    c++;
+                }
+            }
+
+            if (records.length < batchSize) {
+                break;
+            }
+        }
+
+        console.log('Done: stopped all responsibilities: ' + c);
+    }
+
+    static async syncAllMemberUsers() {
+        console.log('Syncing all members');
+
+        let c = 0;
+        let lastId: string = '';
+
+        while (true) {
+            const rawMembers = await Member.where({
+                id: {
+                    value: lastId,
+                    sign: '>',
+                },
+            }, { limit: 500, sort: ['id'] });
+
+            if (rawMembers.length === 0) {
+                break;
+            }
+
+            const membersWithRegistrations = await Member.getBlobByIds(...rawMembers.map(m => m.id));
+
+            const promises: Promise<any>[] = [];
+
+            for (const memberWithRegistrations of membersWithRegistrations) {
+                promises.push((async () => {
+                    await MemberUserSyncer.onChangeMember(memberWithRegistrations);
+                    c++;
+
+                    if (c % 10000 === 0) {
+                        console.log('Synced ' + c + ' members');
+                    }
+                })());
+            }
+
+            await Promise.all(promises);
+            lastId = rawMembers[rawMembers.length - 1].id;
+        }
+
+        console.log('Done: synced all members: ' + c);
+    }
+
     static async createOrganizationPeriodForPeriod(organization: Organization, period: RegistrationPeriod) {
         const oPeriods = await OrganizationRegistrationPeriod.where({ periodId: period.id, organizationId: organization.id }, { limit: 1 });
 

package/src/sql-filters/registration-periods.ts

@@ -10,7 +10,7 @@ export const registrationPeriodFilterCompilers: SQLFilterDefinitions = {
     organizationId: createColumnFilter({
         expression: SQL.column('organizationId'),
         type: SQLValueType.String,
-        nullable: false,
+        nullable: true,
     }),
     startDate: createColumnFilter({
         expression: SQL.column('startDate'),

package/tests/jest.setup.ts

@@ -52,7 +52,9 @@ beforeAll(async () => {
     await Database.delete('DELETE FROM `groups`');
     await Database.delete('DELETE FROM `email_addresses`');
 
+    await Database.update('UPDATE registration_periods set organizationId = null, customName = ? where organizationId is not null', ['delete']);
     await Database.delete('DELETE FROM `organizations`');
+    await Database.delete('DELETE FROM `registration_periods` where customName = ?', ['delete']);
 
     await Database.delete('DELETE FROM `payments`');
     await Database.delete('OPTIMIZE TABLE organizations;'); // fix breaking of indexes due to deletes (mysql bug?)