@stamhoofd/backend 2.39.1 → 2.40.1

package/src/helpers/MemberUserSyncer.ts

@@ -1,11 +1,11 @@
-import { Member, MemberResponsibilityRecord, MemberWithRegistrations, User } from "@stamhoofd/models";
-import { SQL } from "@stamhoofd/sql";
-import { MemberDetails, Permissions, UserPermissions } from "@stamhoofd/structures";
-import crypto from "crypto";
-import basex from "base-x";
+import { Member, MemberResponsibilityRecord, MemberWithRegistrations, User } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+import { MemberDetails, Permissions, UserPermissions } from '@stamhoofd/structures';
+import crypto from 'crypto';
+import basex from 'base-x';
 
-const ALPHABET = '123456789ABCDEFGHJKMNPQRSTUVWXYZ' // Note: we removed 0, O, I and l to make it easier for humans
-const customBase = basex(ALPHABET)
+const ALPHABET = '123456789ABCDEFGHJKMNPQRSTUVWXYZ'; // Note: we removed 0, O, I and l to make it easier for humans
+const customBase = basex(ALPHABET);
 
 async function randomBytes(size: number): Promise<Buffer> {
     return new Promise((resolve, reject) => {
@@ -26,23 +26,23 @@ export class MemberUserSyncerStatic {
      * - email addresses have changed
      */
     async onChangeMember(member: MemberWithRegistrations, unlinkUsers: boolean = false) {
-        const {userEmails, parentAndUnverifiedEmails} = this.getMemberAccessEmails(member.details)
+        const { userEmails, parentAndUnverifiedEmails } = this.getMemberAccessEmails(member.details);
 
         // Make sure all these users have access to the member
         for (const email of userEmails) {
             // Link users that are found with these email addresses.
-            await this.linkUser(email, member, false, true)
+            await this.linkUser(email, member, false, true);
         }
 
         for (const email of parentAndUnverifiedEmails) {
             if (userEmails.includes(email)) {
                 continue;
             }
-            
+
             // Link parents and unverified emails
             // Now we add the responsibility permissions to the parent if there are no userEmails
             const asParent = userEmails.length > 0 || !member.details.unverifiedEmails.includes(email) || member.details.defaultAge < 16;
-            await this.linkUser(email, member, asParent, true)
+            await this.linkUser(email, member, asParent, true);
         }
 
         if (unlinkUsers && !member.details.parentsHaveAccess) {
@@ -53,226 +53,231 @@ export class MemberUserSyncerStatic {
 
             for (const user of member.users) {
                 if (!userEmails.includes(user.email) && !parentAndUnverifiedEmails.includes(user.email)) {
-                    await this.unlinkUser(user, member)
+                    await this.unlinkUser(user, member);
                 }
             }
-        } else {
+        }
+        else {
             // Only auto unlink users that do not have an account
             for (const user of member.users) {
                 if (!userEmails.includes(user.email) && !parentAndUnverifiedEmails.includes(user.email)) {
                     if (!user.hasAccount()) {
-                        await this.unlinkUser(user, member)
-                    } else {
+                        await this.unlinkUser(user, member);
+                    }
+                    else {
                         // Make sure only linked as a parent, not as user self
                         // This makes sure we don't inherit permissions and aren't counted as 'being' the member
-                        await this.linkUser(user.email, member, true)
+                        await this.linkUser(user.email, member, true);
                     }
                 }
             }
         }
 
         if (member.details.securityCode === null) {
-            console.log("Generating security code for member "+member.id)
+            console.log('Generating security code for member ' + member.id);
 
             const length = 16;
             const code = customBase.encode(await randomBytes(100)).toUpperCase().substring(0, length);
-            member.details.securityCode = code
-            await member.save()
+            member.details.securityCode = code;
+            await member.save();
         }
     }
 
     getMemberAccessEmails(details: MemberDetails) {
-        const userEmails = [...details.alternativeEmails]
+        const userEmails = [...details.alternativeEmails];
 
         if (details.email) {
-            userEmails.push(details.email)
+            userEmails.push(details.email);
         }
 
         const unverifiedEmails: string[] = details.unverifiedEmails;
-        const parentAndUnverifiedEmails = details.parentsHaveAccess ? details.parents.flatMap(p => p.email ? [p.email, ...p.alternativeEmails] : p.alternativeEmails).concat(unverifiedEmails) : details.unverifiedEmails
+        const parentAndUnverifiedEmails = details.parentsHaveAccess ? details.parents.flatMap(p => p.email ? [p.email, ...p.alternativeEmails] : p.alternativeEmails).concat(unverifiedEmails) : details.unverifiedEmails;
 
         return {
             userEmails,
             parentAndUnverifiedEmails,
-            emails: userEmails.concat(parentAndUnverifiedEmails)
-        }
+            emails: userEmails.concat(parentAndUnverifiedEmails),
+        };
     }
 
     doesEmailHaveAccess(details: MemberDetails, email: string) {
-        const {emails} = this.getMemberAccessEmails(details)
-        return emails.includes(email)
+        const { emails } = this.getMemberAccessEmails(details);
+        return emails.includes(email);
     }
 
     async onDeleteMember(member: MemberWithRegistrations) {
         for (const u of member.users) {
-            console.log("Unlinking user "+u.email+" from deleted member "+member.id)
-            await this.unlinkUser(u, member)
+            console.log('Unlinking user ' + u.email + ' from deleted member ' + member.id);
+            await this.unlinkUser(u, member);
         }
     }
 
     async getResponsibilitiesForMembers(memberIds: string[]) {
         const rows = await SQL.select()
             .from(SQL.table(MemberResponsibilityRecord.table))
-            .where(SQL.column("memberId"), memberIds)
-            .where(SQL.column("endDate"), null)
+            .where(SQL.column('memberId'), memberIds)
+            .where(SQL.column('endDate'), null)
             .fetch();
 
-        return MemberResponsibilityRecord.fromRows(rows, MemberResponsibilityRecord.table)
+        return MemberResponsibilityRecord.fromRows(rows, MemberResponsibilityRecord.table);
     }
 
     async updateInheritedPermissions(user: User) {
-        const responsibilities = user.memberId ? (await this.getResponsibilitiesForMembers([user.memberId])) : []
+        const responsibilities = user.memberId ? (await this.getResponsibilitiesForMembers([user.memberId])) : [];
 
         // Check if the member has active registrations
         // otherwise -> do not inherit any permissions
 
-        user.permissions = user.permissions ?? UserPermissions.create({})
+        user.permissions = user.permissions ?? UserPermissions.create({});
 
         // Group responsibilities by organization
-        const responsibilitiesByOrganization: Map<string|null, MemberResponsibilityRecord[]> = new Map()
+        const responsibilitiesByOrganization: Map<string | null, MemberResponsibilityRecord[]> = new Map();
 
-        responsibilitiesByOrganization.set(null, [])
+        responsibilitiesByOrganization.set(null, []);
 
         for (const organizationId of user.permissions.organizationPermissions.keys()) {
             // Make sure we reset responsibilities for organizations that are not in the list
-            responsibilitiesByOrganization.set(organizationId, [])
+            responsibilitiesByOrganization.set(organizationId, []);
         }
 
         for (const responsibility of responsibilities) {
-            const v = responsibilitiesByOrganization.get(responsibility.organizationId) ?? []
-            responsibilitiesByOrganization.set(responsibility.organizationId, v)
-            v.push(responsibility)
+            const v = responsibilitiesByOrganization.get(responsibility.organizationId) ?? [];
+            responsibilitiesByOrganization.set(responsibility.organizationId, v);
+            v.push(responsibility);
         }
 
         for (const organizationId of responsibilitiesByOrganization.keys()) {
             if (organizationId === null) {
                 const patch = user.permissions.convertPlatformPatch(
                     Permissions.patch({
-                        responsibilities: (responsibilitiesByOrganization.get(organizationId) ?? []).map(r => r.getBaseStructure()) as any
-                    })
-                )
-                user.permissions = user.permissions.patch(patch)
-            } else {
+                        responsibilities: (responsibilitiesByOrganization.get(organizationId) ?? []).map(r => r.getBaseStructure()) as any,
+                    }),
+                );
+                user.permissions = user.permissions.patch(patch);
+            }
+            else {
                 const patch = user.permissions.convertPatch(
                     Permissions.patch({
-                        responsibilities: (responsibilitiesByOrganization.get(organizationId) ?? []).map(r => r.getBaseStructure()) as any
+                        responsibilities: (responsibilitiesByOrganization.get(organizationId) ?? []).map(r => r.getBaseStructure()) as any,
                     }),
-                    organizationId
-                )
-                user.permissions = user.permissions.patch(patch)
+                    organizationId,
+                );
+                user.permissions = user.permissions.patch(patch);
             }
-            
         }
 
         // Platform permissions
-        user.permissions.clearEmptyPermissions()
+        user.permissions.clearEmptyPermissions();
 
         if (user.permissions.isEmpty) {
             user.permissions = null;
         }
 
-        await user.save()
+        await user.save();
     }
 
     async unlinkUser(user: User, member: MemberWithRegistrations) {
-        console.log("Removing access for "+ user.id +" to member "+member.id)
-        await Member.users.reverse("members").unlink(user, member)
+        console.log('Removing access for ' + user.id + ' to member ' + member.id);
+        await Member.users.reverse('members').unlink(user, member);
 
         if (user.memberId === member.id) {
             user.memberId = null;
-            await user.save()
+            await user.save();
         }
 
         // Update model relation to correct response
-        const existingIndex = member.users.findIndex(u => u.id === user.id)
+        const existingIndex = member.users.findIndex(u => u.id === user.id);
         if (existingIndex !== -1) {
-            member.users.splice(existingIndex, 1)
+            member.users.splice(existingIndex, 1);
         }
 
-        await this.updateInheritedPermissions(user)
+        await this.updateInheritedPermissions(user);
     }
 
     async linkUser(email: string, member: MemberWithRegistrations, asParent: boolean, updateNameIfEqual = true) {
-        console.log('Linking user', email, 'to member', member.id, 'as parent', asParent, 'update name if equal', updateNameIfEqual)
+        console.log('Linking user', email, 'to member', member.id, 'as parent', asParent, 'update name if equal', updateNameIfEqual);
 
-        let user = member.users.find(u => u.email.toLocaleLowerCase() === email.toLocaleLowerCase()) ?? await User.getForAuthentication(member.organizationId, email, {allowWithoutAccount: true})
+        let user = member.users.find(u => u.email.toLocaleLowerCase() === email.toLocaleLowerCase()) ?? await User.getForAuthentication(member.organizationId, email, { allowWithoutAccount: true });
 
         if (user) {
-            //console.log("Giving an existing user access to a member: " + user.id + ' - ' + member.id)
+            // console.log("Giving an existing user access to a member: " + user.id + ' - ' + member.id)
             if (!asParent) {
                 if (user.memberId && user.memberId !== member.id) {
-                    console.error('Found conflicting user with multiple members', user.id, 'members', user.memberId, 'to', member.id)
-                    
-                    const otherMember = await Member.getWithRegistrations(user.memberId)
+                    console.error('Found conflicting user with multiple members', user.id, 'members', user.memberId, 'to', member.id);
+
+                    const otherMember = await Member.getWithRegistrations(user.memberId);
 
                     if (otherMember) {
                         if (otherMember.registrations.length > 0 && member.registrations.length === 0) {
                             // Choose the other member
                             // don't make changes
-                            console.error('Resolved to current member - no changes made')
-                            return
+                            console.error('Resolved to current member - no changes made');
+                            return;
                         }
 
-                        const responsibilities = await this.getResponsibilitiesForMembers([otherMember.id, member.id])
-                        const responsibilitiesOther = responsibilities.filter(r => r.memberId === otherMember.id)
-                        const responsibilitiesCurrent = responsibilities.filter(r => r.memberId === member.id)
+                        const responsibilities = await this.getResponsibilitiesForMembers([otherMember.id, member.id]);
+                        const responsibilitiesOther = responsibilities.filter(r => r.memberId === otherMember.id);
+                        const responsibilitiesCurrent = responsibilities.filter(r => r.memberId === member.id);
 
                         if (responsibilitiesOther.length >= responsibilitiesCurrent.length) {
-                            console.error('Resolved to current member because of more responsibilities - no changes made')
-                            return
+                            console.error('Resolved to current member because of more responsibilities - no changes made');
+                            return;
                         }
                     }
                 }
 
                 if (updateNameIfEqual) {
-                    user.firstName = member.details.firstName
-                    user.lastName = member.details.lastName
+                    user.firstName = member.details.firstName;
+                    user.lastName = member.details.lastName;
                 }
                 user.memberId = member.id;
-                await this.updateInheritedPermissions(user)
-            } else {
+                await this.updateInheritedPermissions(user);
+            }
+            else {
                 if (user.memberId === member.id) {
                     // Unlink: parents are never 'equal' to the member
                     user.memberId = null;
-                    await this.updateInheritedPermissions(user)
+                    await this.updateInheritedPermissions(user);
                 }
 
                 if (!user.firstName && !user.lastName) {
-                    const parents = member.details.parents.filter(p => p.email === email)
+                    const parents = member.details.parents.filter(p => p.email === email);
                     if (parents.length === 1) {
                         if (updateNameIfEqual) {
-                            user.firstName = parents[0].firstName
-                            user.lastName = parents[0].lastName
+                            user.firstName = parents[0].firstName;
+                            user.lastName = parents[0].lastName;
                         }
-                        await user.save()
+                        await user.save();
                     }
                 }
 
                 if (user.firstName === member.details.firstName && user.lastName === member.details.lastName) {
                     user.firstName = null;
                     user.lastName = null;
-                    await user.save()
+                    await user.save();
                 }
             }
-        } else {
+        }
+        else {
             // Create a new placeholder user
-            user = new User()
-            user.organizationId = member.organizationId
-            user.email = email
+            user = new User();
+            user.organizationId = member.organizationId;
+            user.email = email;
 
             if (!asParent) {
                 if (updateNameIfEqual) {
-                    user.firstName = member.details.firstName
-                    user.lastName = member.details.lastName
+                    user.firstName = member.details.firstName;
+                    user.lastName = member.details.lastName;
                 }
                 user.memberId = member.id;
-                await this.updateInheritedPermissions(user)
-            } else {
-                const parents = member.details.parents.filter(p => p.email === email)
+                await this.updateInheritedPermissions(user);
+            }
+            else {
+                const parents = member.details.parents.filter(p => p.email === email);
                 if (parents.length === 1) {
                     if (updateNameIfEqual) {
-                        user.firstName = parents[0].firstName
-                        user.lastName = parents[0].lastName
+                        user.firstName = parents[0].firstName;
+                        user.lastName = parents[0].lastName;
                     }
                 }
 
@@ -281,18 +286,18 @@ export class MemberUserSyncerStatic {
                     user.lastName = null;
                 }
 
-                await user.save()
+                await user.save();
             }
 
-            console.log("Created new (placeholder) user that has access to a member: "+user.id)
+            console.log('Created new (placeholder) user that has access to a member: ' + user.id);
         }
 
         // Update model relation to correct response
         if (!member.users.find(u => u.id === user.id)) {
-            await Member.users.reverse("members").link(user, [member])
-            member.users.push(user)
+            await Member.users.reverse('members').link(user, [member]);
+            member.users.push(user);
         }
     }
 }
 
-export const MemberUserSyncer = new MemberUserSyncerStatic()
+export const MemberUserSyncer = new MemberUserSyncerStatic();

package/src/helpers/MembershipCharger.ts

@@ -1,35 +1,34 @@
-import { SimpleError } from "@simonbackx/simple-errors";
-import { BalanceItem, Member, MemberPlatformMembership, Platform } from "@stamhoofd/models";
-import { SQL, SQLOrderBy, SQLWhereSign } from "@stamhoofd/sql";
-import { BalanceItemRelation, BalanceItemRelationType, BalanceItemType } from "@stamhoofd/structures";
-import { Formatter } from "@stamhoofd/utility";
+import { SimpleError } from '@simonbackx/simple-errors';
+import { BalanceItem, Member, MemberPlatformMembership, Platform } from '@stamhoofd/models';
+import { SQL, SQLOrderBy, SQLWhereSign } from '@stamhoofd/sql';
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemType } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
 
 export const MembershipCharger = {
     async charge() {
-        console.log('Charging memberships...')
-        
+        console.log('Charging memberships...');
+
         // Loop all
-        let lastId = "";
-        const platform = await Platform.getShared()
-        const chargeVia = platform.membershipOrganizationId
+        let lastId = '';
+        const platform = await Platform.getShared();
+        const chargeVia = platform.membershipOrganizationId;
 
         if (!chargeVia) {
             throw new SimpleError({
                 code: 'missing_membership_organization',
                 message: 'Missing membershipOrganizationId',
-                human: 'Er is geen lokale groep verantwoordelijk voor de aanrekening van aansluitingen geconfigureerd'
-            })
+                human: 'Er is geen lokale groep verantwoordelijk voor de aanrekening van aansluitingen geconfigureerd',
+            });
         }
 
         function getType(id: string) {
-            return platform.config.membershipTypes.find(t => t.id === id)
+            return platform.config.membershipTypes.find(t => t.id === id);
         }
 
         let createdCount = 0;
         let createdPrice = 0;
         const chunkSize = 100;
 
-        // eslint-disable-next-line no-constant-condition
         while (true) {
             const memberships = await MemberPlatformMembership.select()
                 .where('id', SQLWhereSign.Greater, lastId)
@@ -40,18 +39,18 @@ export const MembershipCharger = {
                 .orderBy(
                     new SQLOrderBy({
                         column: SQL.column('id'),
-                        direction: 'ASC'
-                    })
+                        direction: 'ASC',
+                    }),
                 )
                 .fetch();
-        
+
             if (memberships.length === 0) {
                 break;
             }
 
-            const memberIds = Formatter.uniqueArray(memberships.map(m => m.memberId))
-            const members = await Member.getByIDs(...memberIds)
-            const createdBalanceItems: BalanceItem[] = []
+            const memberIds = Formatter.uniqueArray(memberships.map(m => m.memberId));
+            const members = await Member.getByIDs(...memberIds);
+            const createdBalanceItems: BalanceItem[] = [];
 
             for (const membership of memberships) {
                 // charge
@@ -61,7 +60,7 @@ export const MembershipCharger = {
 
                 const type = getType(membership.membershipTypeId);
                 if (!type) {
-                    console.error('Unknown membership type id ', membership.membershipTypeId)
+                    console.error('Unknown membership type id ', membership.membershipTypeId);
                     continue;
                 }
 
@@ -69,83 +68,83 @@ export const MembershipCharger = {
                     continue;
                 }
 
-                const member = members.find(m => m.id === membership.memberId)
+                const member = members.find(m => m.id === membership.memberId);
 
                 if (!member) {
-                    console.error('Unexpected missing member id ', membership.memberId, 'for membership', membership.id)
+                    console.error('Unexpected missing member id ', membership.memberId, 'for membership', membership.id);
                     continue;
                 }
 
                 // Force price update (required because could have changed - especially for free memberships in combination with deletes)
                 try {
-                    await membership.calculatePrice(member)
-                } catch (e) {
-                    console.error('Failed to update price for membership. Not charged.', membership.id, e)
+                    await membership.calculatePrice(member);
+                }
+                catch (e) {
+                    console.error('Failed to update price for membership. Not charged.', membership.id, e);
                     continue;
                 }
 
                 const balanceItem = new BalanceItem();
-                balanceItem.unitPrice = membership.price
-                balanceItem.amount = 1
-                balanceItem.description = Formatter.dateNumber(membership.startDate, true) + " tot " + Formatter.dateNumber(membership.expireDate ?? membership.endDate, true)
+                balanceItem.unitPrice = membership.price;
+                balanceItem.amount = 1;
+                balanceItem.description = Formatter.dateNumber(membership.startDate, true) + ' tot ' + Formatter.dateNumber(membership.expireDate ?? membership.endDate, true);
                 balanceItem.relations = new Map([
                     [
-                        BalanceItemRelationType.Member, 
+                        BalanceItemRelationType.Member,
                         BalanceItemRelation.create({
                             id: member.id,
-                            name: member.details.name
-                        })
+                            name: member.details.name,
+                        }),
                     ],
                     [
-                        BalanceItemRelationType.MembershipType, 
+                        BalanceItemRelationType.MembershipType,
                         BalanceItemRelation.create({
                             id: type.id,
-                            name: type.name
-                        })
-                    ]
-                ])
+                            name: type.name,
+                        }),
+                    ],
+                ]);
 
-                balanceItem.type = BalanceItemType.PlatformMembership
-                balanceItem.organizationId = chargeVia
-                balanceItem.payingOrganizationId = membership.organizationId
+                balanceItem.type = BalanceItemType.PlatformMembership;
+                balanceItem.organizationId = chargeVia;
+                balanceItem.payingOrganizationId = membership.organizationId;
 
                 await balanceItem.save();
                 membership.balanceItemId = balanceItem.id;
                 membership.maximumFreeAmount = membership.freeAmount;
-                await membership.save()
+                await membership.save();
 
-                createdBalanceItems.push(balanceItem)
+                createdBalanceItems.push(balanceItem);
 
                 createdCount += 1;
-                createdPrice += membership.price
+                createdPrice += membership.price;
             }
 
-            await BalanceItem.updateOutstanding(createdBalanceItems)
+            await BalanceItem.updateOutstanding(createdBalanceItems);
 
             if (memberships.length < chunkSize) {
                 break;
             }
-            
+
             const z = lastId;
             lastId = memberships[memberships.length - 1].id;
 
             if (lastId === z) {
-                throw new Error('Unexpected infinite loop found in MembershipCharger')
+                throw new Error('Unexpected infinite loop found in MembershipCharger');
             }
         }
 
-        console.log('Charged ' + Formatter.integer(createdCount) +'  memberships, for a total value of ' + Formatter.price(createdPrice))
+        console.log('Charged ' + Formatter.integer(createdCount) + '  memberships, for a total value of ' + Formatter.price(createdPrice));
     },
 
     async updatePrices(organizationId?: string) {
-        console.log('Update prices...')
-        
+        console.log('Update prices...');
+
         // Loop all
-        let lastId = "";
+        let lastId = '';
         let createdCount = 0;
         const chunkSize = 100;
 
-        // eslint-disable-next-line no-constant-condition
         while (true) {
             const q = MemberPlatformMembership.select()
                 .where('id', SQLWhereSign.Greater, lastId)
@@ -153,58 +152,59 @@ export const MembershipCharger = {
                 .where('deletedAt', null);
 
             if (organizationId) {
-                q.where('organizationId', organizationId)
+                q.where('organizationId', organizationId);
             }
-                
+
             const memberships = await q
                 .limit(chunkSize)
                 .orderBy(
                     new SQLOrderBy({
                         column: SQL.column('id'),
-                        direction: 'ASC'
-                    })
+                        direction: 'ASC',
+                    }),
                 )
                 .fetch();
-        
+
             if (memberships.length === 0) {
                 break;
             }
 
-            const memberIds = Formatter.uniqueArray(memberships.map(m => m.memberId))
-            const members = await Member.getByIDs(...memberIds)
+            const memberIds = Formatter.uniqueArray(memberships.map(m => m.memberId));
+            const members = await Member.getByIDs(...memberIds);
 
             for (const membership of memberships) {
-                const member = members.find(m => m.id === membership.memberId)
+                const member = members.find(m => m.id === membership.memberId);
 
                 if (!member) {
-                    console.error('Unexpected missing member id ', membership.memberId, 'for membership', membership.id)
+                    console.error('Unexpected missing member id ', membership.memberId, 'for membership', membership.id);
                     continue;
                 }
 
                 // Force price update (required because could have changed - especially for free memberships in combination with deletes)
                 try {
-                    await membership.calculatePrice(member)
-                    await membership.save()
-                } catch (e) {
-                    console.error('Failed to update price for membership', membership.id, e)
+                    await membership.calculatePrice(member);
+                    await membership.save();
+                }
+                catch (e) {
+                    console.error('Failed to update price for membership', membership.id, e);
                     continue;
                 }
-                console.log('Updated price for membership', membership.id, membership.price)
+                console.log('Updated price for membership', membership.id, membership.price);
                 createdCount += 1;
             }
 
             if (memberships.length < chunkSize) {
                 break;
             }
-            
+
             const z = lastId;
             lastId = memberships[memberships.length - 1].id;
 
             if (lastId === z) {
-                throw new Error('Unexpected infinite loop found in MembershipCharger')
+                throw new Error('Unexpected infinite loop found in MembershipCharger');
             }
         }
 
-        console.log('Updated prices of ' + Formatter.integer(createdCount) +'  memberships')
-    }
+        console.log('Updated prices of ' + Formatter.integer(createdCount) + '  memberships');
+    },
 };