@stamhoofd/backend 2.22.0 → 2.24.0

package/.env.template.json

@@ -12,6 +12,11 @@
             "BE": "www.be.stamhoofd",
             "NL": "www.nl.stamhoofd"
         },
+        "documentation": {
+            "": "www.be.stamhoofd/docs",
+            "BE": "www.be.stamhoofd/docs",
+            "NL": "www.nl.stamhoofd/docs"
+        },
         "webshop": {
             "": "shop.be.stamhoofd",
             "BE": "shop.be.stamhoofd",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.22.0",
+    "version": "2.24.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -36,14 +36,14 @@
         "@simonbackx/simple-encoding": "2.15.0",
         "@simonbackx/simple-endpoints": "1.14.0",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.22.0",
-        "@stamhoofd/backend-middleware": "2.22.0",
-        "@stamhoofd/email": "2.22.0",
-        "@stamhoofd/models": "2.22.0",
-        "@stamhoofd/queues": "2.22.0",
-        "@stamhoofd/sql": "2.22.0",
-        "@stamhoofd/structures": "2.22.0",
-        "@stamhoofd/utility": "2.22.0",
+        "@stamhoofd/backend-i18n": "2.24.0",
+        "@stamhoofd/backend-middleware": "2.24.0",
+        "@stamhoofd/email": "2.24.0",
+        "@stamhoofd/models": "2.24.0",
+        "@stamhoofd/queues": "2.24.0",
+        "@stamhoofd/sql": "2.24.0",
+        "@stamhoofd/structures": "2.24.0",
+        "@stamhoofd/utility": "2.24.0",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -60,5 +60,5 @@
         "postmark": "4.0.2",
         "stripe": "^16.6.0"
     },
-    "gitHead": "b3590dcb37d7f65be2663b11a6f025cf5f36a278"
+    "gitHead": "bad7d2adfa412af0b0de101274e46ed0b539ae38"
 }

package/src/endpoints/auth/DeleteTokenEndpoint.ts

@@ -7,7 +7,7 @@ type Query = undefined;
 type Body = undefined;
 type ResponseBody = undefined;
 
-export class CreateTokenEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+export class DeleteTokenEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method != "DELETE") {
             return [false];

package/src/endpoints/auth/DeleteUserEndpoint.ts

@@ -0,0 +1,58 @@
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+
+import { getDefaultEmailFrom, sendEmailTemplate } from '@stamhoofd/models';
+import { EmailTemplateType, Recipient } from '@stamhoofd/structures';
+import { Context } from '../../helpers/Context';
+
+type Params = Record<string, never>;
+type Query = undefined;
+type Body = undefined;
+type ResponseBody = undefined;
+
+export class DeleteUserEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "DELETE") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/user", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(_: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOptionalOrganizationScope()
+        const {user, token} = await Context.authenticate({allowWithoutAccount: true})
+        
+        // Send an e-mail to inform everyone about this action
+
+        // Delete the account
+
+        const bcc = (await getDefaultEmailFrom(null, {
+            template: {}
+        }))
+        await sendEmailTemplate(organization, {
+            recipients: [
+                Recipient.create({
+                    email: user.email
+                })
+            ],
+            singleBcc: bcc.replyTo || bcc.from,
+            template: {
+                type: EmailTemplateType.DeleteAccountConfirmation,
+            },
+            type: 'transactional'
+        })
+
+        // Soft delete until processed manually
+        user.verified = false;
+        user.password = null;
+        await user.save()
+        await token.delete()
+        
+        return new Response(undefined)
+    }
+}

package/src/endpoints/auth/SignupEndpoint.ts

@@ -64,7 +64,7 @@ export class SignupEndpoint extends Endpoint<Params, Query, Body, ResponseBody>
                     replyTo: undefined
                 }
                 
-                const footer = (!user.permissions && organization ? "\n\n—\n\nOnze ledenadministratie werkt via het Stamhoofd platform, op maat van verenigingen. Probeer het ook via https://"+request.i18n.$t("shared.domains.marketing")+"/ledenadministratie\n\n" : '')
+                const footer = (!user.permissions && organization ? "\n\n—\n\nOnze ledenadministratie werkt via het Stamhoofd platform, op maat van verenigingen. Probeer het ook via https://"+request.i18n.localizedDomains.marketing()+"/ledenadministratie\n\n" : '')
 
                 const name = organization ? organization.name : 'Stamhoofd'
                 // Send email

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

@@ -3,7 +3,7 @@ import { ConvertArrayToPatchableArray, Decoder, PatchableArrayAutoEncoder, Patch
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { SimpleError } from "@simonbackx/simple-errors";
 import { BalanceItem, Document, Group, Member, MemberFactory, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, Organization, Platform, Registration, User } from '@stamhoofd/models';
-import { MemberWithRegistrationsBlob, MembersBlob, PermissionLevel } from "@stamhoofd/structures";
+import { GroupType, MemberWithRegistrationsBlob, MembersBlob, PermissionLevel } from "@stamhoofd/structures";
 import { Formatter } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
@@ -267,6 +267,33 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                     })
                 }
 
+                const hasRegistration = member.registrations.some(registration => {
+                    if (platformResponsibility) {
+                        if (registration.group.defaultAgeGroupId === null) {
+                            return false;
+                        }
+                    }
+
+                    if (org) {
+                        if (registration.periodId !== org.periodId) {
+                            return false;
+                        }
+                    } else {
+                        if (registration.periodId !== platform.periodId) {
+                            return false;
+                        }
+                    }
+                    return registration.deactivatedAt === null && registration.registeredAt !== null && registration.group.type === GroupType.Membership
+                })
+
+                if (!hasRegistration) {
+                    throw new SimpleError({
+                        code: "invalid_field",
+                        message: "Invalid organization",
+                        human: "Je kan een functie enkel toekennen aan leden die zijn ingeschreven in het huidige werkjaar",
+                    })
+                }
+
                 const model = new MemberResponsibilityRecord()
                 model.memberId = member.id
                 model.responsibilityId = responsibility.id

package/src/endpoints/global/platform/PatchPlatformEnpoint.ts

@@ -6,6 +6,7 @@ import { MemberResponsibility, PlatformConfig, PlatformPremiseType, Platform as
 import { SimpleError } from "@simonbackx/simple-errors";
 import { Context } from "../../../helpers/Context";
 import { SetupStepUpdater } from "../../../helpers/SetupStepsUpdater";
+import { PeriodHelper } from "../../../helpers/PeriodHelper";
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -73,6 +74,7 @@ export class PatchPlatformEndpoint extends Endpoint<
         }
 
         let shouldUpdateSetupSteps = false;
+        let shouldMoveToPeriod: RegistrationPeriod | null = null;
 
         if (request.body.config) {
             if (!Context.auth.hasPlatformFullAccess()) {
@@ -113,6 +115,8 @@ export class PatchPlatformEndpoint extends Endpoint<
                 });
             }
             platform.periodId = period.id;
+            shouldUpdateSetupSteps = true;
+            shouldMoveToPeriod = period;
         }
 
         if (request.body.membershipOrganizationId !== undefined) {
@@ -155,7 +159,10 @@ export class PatchPlatformEndpoint extends Endpoint<
 
         await platform.save();
 
-        if(shouldUpdateSetupSteps) {
+        if (shouldMoveToPeriod) {
+            PeriodHelper.moveAllOrganizationsToPeriod(shouldMoveToPeriod).catch(console.error)
+        } else if(shouldUpdateSetupSteps) {
+            // Do not call this right away when moving to a period, because this needs to happen AFTER moving to the period
             SetupStepUpdater.updateSetupStepsForAllOrganizationsInCurrentPeriod().catch(console.error);
         }
 

package/src/endpoints/organization/dashboard/organization/PatchOrganizationEndpoint.ts

@@ -101,6 +101,10 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
 
             if (request.body.privateMeta && request.body.privateMeta.isPatch()) {
                 organization.privateMeta.emails = request.body.privateMeta.emails.applyTo(organization.privateMeta.emails)
+                if(request.body.privateMeta.emails) {
+                    shouldUpdateSetupSteps = true;
+                }
+
                 organization.privateMeta.premises = patchObject(organization.privateMeta.premises, request.body.privateMeta.premises);
                 if(request.body.privateMeta.premises) {
                     shouldUpdateSetupSteps = true;

package/src/endpoints/organization/dashboard/registration-periods/PatchOrganizationRegistrationPeriodsEndpoint.ts

@@ -1,11 +1,11 @@
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { Group as GroupStruct, GroupPrivateSettings, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, PermissionLevel, PermissionsResourceType, ResourcePermissions, Version, GroupType } from "@stamhoofd/structures";
+import { GroupPrivateSettings, Group as GroupStruct, GroupType, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, PermissionLevel, PermissionsResourceType, ResourcePermissions, Version } from "@stamhoofd/structures";
 
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from "@simonbackx/simple-encoding";
-import { Context } from "../../../../helpers/Context";
-import { Group, Member, OrganizationRegistrationPeriod, Platform, RegistrationPeriod } from "@stamhoofd/models";
 import { SimpleError } from "@simonbackx/simple-errors";
+import { Group, Member, Organization, OrganizationRegistrationPeriod, Platform, RegistrationPeriod } from "@stamhoofd/models";
 import { AuthenticatedStructures } from "../../../../helpers/AuthenticatedStructures";
+import { Context } from "../../../../helpers/Context";
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -46,9 +46,12 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
             if (!await Context.auth.hasFullAccess(organization.id)) {
                 throw Context.auth.error()
             }
-            const period = await RegistrationPeriod.getByID(put.period.id);
+            periods.push(await PatchOrganizationRegistrationPeriodsEndpoint.createOrganizationPeriod(organization, put));
+        }
 
-            if (!period) {
+        for (const patch of request.body.getPatches()) {
+            const organizationPeriod = await OrganizationRegistrationPeriod.getByID(patch.id);
+            if (!organizationPeriod || organizationPeriod.organizationId !== organization.id) {
                 throw new SimpleError({
                     code: "not_found",
                     message: "Period not found",
@@ -56,38 +59,33 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
                 })
             }
 
-            const organizationPeriod = new OrganizationRegistrationPeriod();
-            organizationPeriod.id = put.id;
-            organizationPeriod.organizationId = organization.id;
-            organizationPeriod.periodId = put.period.id;
-            organizationPeriod.settings = put.settings;
-            await organizationPeriod.save();
+            const period = await RegistrationPeriod.getByID(organizationPeriod.periodId);
 
-            for (const struct of put.groups) {
-                await PatchOrganizationRegistrationPeriodsEndpoint.createGroup(struct, organization.id, organizationPeriod.periodId)
+            if (!period) {
+                throw new SimpleError({
+                    code: "not_found",
+                    message: "Period not found",
+                    statusCode: 404
+                })
             }
-            const groups = await Group.getAll(organization.id, organizationPeriod.periodId)
-
-            // Delete unreachable categories first
-            await organizationPeriod.cleanCategories(groups);
-            await Group.deleteUnreachable(organization.id, organizationPeriod, groups)
-            periods.push(organizationPeriod);
-        }
 
-        for (const patch of request.body.getPatches()) {
-            const organizationPeriod = await OrganizationRegistrationPeriod.getByID(patch.id);
-            if (!organizationPeriod || organizationPeriod.organizationId !== organization.id) {
+            if (period.locked) {
                 throw new SimpleError({
                     code: "not_found",
                     message: "Period not found",
+                    human: 'Je kan geen wijzigingen meer aanbrengen in ' + period.getStructure().name + ' omdat deze is afgesloten',
                     statusCode: 404
                 })
             }
+
             let deleteUnreachable = false
             const allowedIds: string[] = []
 
             if (await Context.auth.hasFullAccess(organization.id)) {
                 if (patch.settings) {
+                    if(patch.settings.categories) {
+                        deleteUnreachable = true;
+                    }
                     organizationPeriod.settings.patchOrPut(patch.settings);
                 }
             } else {
@@ -174,6 +172,36 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
         })
     }
 
+    static async createOrganizationPeriod(organization: Organization, struct: OrganizationRegistrationPeriodStruct) {
+        const period = await RegistrationPeriod.getByID(struct.period.id);
+
+        if (!period || period.locked) {
+            throw new SimpleError({
+                code: "not_found",
+                message: "Period not found",
+                statusCode: 404
+            })
+        }
+
+        const organizationPeriod = new OrganizationRegistrationPeriod();
+        organizationPeriod.id = struct.id;
+        organizationPeriod.organizationId = organization.id;
+        organizationPeriod.periodId = struct.period.id;
+        organizationPeriod.settings = struct.settings;
+        await organizationPeriod.save();
+
+        for (const s of struct.groups) {
+            await PatchOrganizationRegistrationPeriodsEndpoint.createGroup(s, organization.id, organizationPeriod.periodId)
+        }
+        const groups = await Group.getAll(organization.id, organizationPeriod.periodId)
+
+        // Delete unreachable categories first
+        await organizationPeriod.cleanCategories(groups);
+        await Group.deleteUnreachable(organization.id, organizationPeriod, groups)
+
+        return organizationPeriod
+    }
+
     static async deleteGroup(id: string) {
         const model = await Group.getByID(id)
         if (!model || !await Context.auth.canAccessGroup(model, PermissionLevel.Full)) {
@@ -263,6 +291,15 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
                         })
                     }
 
+                    if (existing.periodId !== model.periodId) {
+                        throw new SimpleError({
+                            code: 'invalid_field',
+                            field: 'waitingList',
+                            message: 'Waiting list group is already used in another period',
+                            human: 'Een wachtlijst kan momenteel niet gedeeld worden tussen verschillende werkjaren'
+                        })
+                    }
+
                     model.waitingListId = existing.id
                 } else {
                     const group = await PatchOrganizationRegistrationPeriodsEndpoint.createGroup(

package/src/helpers/AuthenticatedStructures.ts

@@ -262,14 +262,43 @@ export class AuthenticatedStructures {
             }
         }
 
+        const organizationStructs = await Promise.all([...organizations.values()].filter(o => o.active).map(o => this.organization(o)))
+
+        // Load missing groups
+        const allGroups = new Map<string, GroupStruct>()
+        for (const organization of organizationStructs) {
+            for (const group of organization.period.groups) {
+                allGroups.set(group.id, group)
+            }
+        }
+
         for (const blob of memberBlobs) {
-            blob.responsibilities = responsibilities.filter(r => r.memberId == blob.id).map(r => r.getStructure())
+            for (const registration of blob.registrations) {
+                if (registration.group) {
+                    allGroups.set(registration.group.id, registration.group)
+                }
+            }
+        }
+
+        const groupIds = Formatter.uniqueArray(responsibilities.map(r => r.groupId).filter(id => id !== null)).filter(id => !allGroups.has(id))
+        const groups = groupIds.length > 0 ? await Group.getByIDs(...groupIds) : []
+        const groupStructs = await this.groups(groups)
+        
+        for (const group of groupStructs) {
+            allGroups.set(group.id, group)
+        }
+
+        for (const blob of memberBlobs) {
+            blob.responsibilities = responsibilities.filter(r => r.memberId == blob.id).map(r => {
+                const group = allGroups.get(r.groupId ?? '') ?? null
+                return r.getStructure(group)
+            })
             blob.platformMemberships = platformMemberships.filter(r => r.memberId == blob.id).map(r => MemberPlatformMembershipStruct.create(r))
         }
 
         return MembersBlob.create({
             members: memberBlobs,
-            organizations: await Promise.all([...organizations.values()].filter(o => o.active).map(o => this.organization(o)))
+            organizations: organizationStructs
         })
     }
 

package/src/helpers/MemberUserSyncer.ts

@@ -116,14 +116,14 @@ export class MemberUserSyncerStatic {
             if (organizationId === null) {
                 const patch = user.permissions.convertPlatformPatch(
                     Permissions.patch({
-                        responsibilities: (responsibilitiesByOrganization.get(organizationId) ?? []).map(r => r.getStructure()) as any
+                        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.getStructure()) as any
+                        responsibilities: (responsibilitiesByOrganization.get(organizationId) ?? []).map(r => r.getBaseStructure()) as any
                     }),
                     organizationId
                 )

package/src/helpers/PeriodHelper.ts

@@ -0,0 +1,70 @@
+
+import { Organization, OrganizationRegistrationPeriod, RegistrationPeriod } from "@stamhoofd/models";
+import { AuthenticatedStructures } from "./AuthenticatedStructures";
+import { PatchOrganizationRegistrationPeriodsEndpoint } from "../endpoints/organization/dashboard/registration-periods/PatchOrganizationRegistrationPeriodsEndpoint";
+import { QueueHandler } from "@stamhoofd/queues";
+import { SetupStepUpdater } from "./SetupStepsUpdater";
+
+export class PeriodHelper {
+    static async moveOrganizationToPeriod(organization: Organization, period: RegistrationPeriod) {
+        console.log('moveOrganizationToPeriod', organization.id, period.id)
+        
+        await this.createOrganizationPeriodForPeriod(organization, period)
+        organization.periodId = period.id
+        await organization.save()
+    }
+
+    static async createOrganizationPeriodForPeriod(organization: Organization, period: RegistrationPeriod) {
+        const oPeriods = await OrganizationRegistrationPeriod.where({ periodId: period.id, organizationId: organization.id }, {limit: 1})
+        
+        if (oPeriods.length) {
+            // Already created
+            return oPeriods[0]
+        }
+
+        const currentPeriod = await organization.getPeriod()
+        if (currentPeriod.periodId === period.id) {
+            return currentPeriod
+        }
+
+        const struct = await AuthenticatedStructures.organizationRegistrationPeriod(currentPeriod)
+
+        const duplicate = struct.duplicate(period.getStructure())
+        return await PatchOrganizationRegistrationPeriodsEndpoint.createOrganizationPeriod(organization, duplicate)
+    }
+
+    static async moveAllOrganizationsToPeriod(period: RegistrationPeriod) {
+        const tag = "moveAllOrganizationsToPeriod";
+        const batchSize = 10;
+        QueueHandler.cancel(tag);
+
+        await QueueHandler.schedule(tag, async () => {
+            let lastId = "";
+
+            while (true) {
+                const organizations = await Organization.where(
+                    {
+                        id: { sign: ">", value: lastId },
+                    },
+                    { 
+                        limit: batchSize, 
+                        sort: ["id"] 
+                    }
+                );
+
+                for (const organization of organizations) {
+                    await this.moveOrganizationToPeriod(organization, period);
+                    lastId = organization.id;
+                }
+
+                if (organizations.length < batchSize) {
+                    break;
+                }
+
+            }
+        });
+
+        // When done: update setup steps
+        await SetupStepUpdater.updateSetupStepsForAllOrganizationsInCurrentPeriod()
+    }
+}

package/src/helpers/SetupStepsUpdater.ts

@@ -1,5 +1,6 @@
 import {
     Group,
+    Member,
     MemberResponsibilityRecord,
     Organization,
     OrganizationRegistrationPeriod,
@@ -8,11 +9,13 @@ import {
 import { QueueHandler } from "@stamhoofd/queues";
 import { SQL, SQLWhereSign } from "@stamhoofd/sql";
 import {
+    GroupType,
     MemberResponsibility,
     Platform as PlatformStruct,
     SetupStepType,
     SetupSteps
 } from "@stamhoofd/structures";
+import { Formatter } from "@stamhoofd/utility";
 
 type SetupStepOperation = (setupSteps: SetupSteps, organization: Organization, platform: PlatformStruct) => void | Promise<void>;
 
@@ -25,6 +28,8 @@ export class SetupStepUpdater {
         [SetupStepType.Companies]: this.updateStepCompanies,
         [SetupStepType.Groups]: this.updateStepGroups,
         [SetupStepType.Premises]: this.updateStepPremises,
+        [SetupStepType.Emails]: this.updateStepEmails,
+        [SetupStepType.Payment]: this.updateStepPayment
     };
 
     static async updateSetupStepsForAllOrganizationsInCurrentPeriod({
@@ -242,12 +247,21 @@ export class SetupStepUpdater {
 
         const responsibilityIds = organizationBasedResponsibilitiesWithRestriction.map(r => r.id);
 
-        const records = await MemberResponsibilityRecord.select()
+        const allRecords = await MemberResponsibilityRecord.select()
             .where('responsibilityId', responsibilityIds)
             .where('organizationId', organization.id)
             .where(SQL.where('endDate', SQLWhereSign.Greater, now).or('endDate', null))
             .fetch();
 
+        // Remove invalid responsibilities: members that are not registered in the current period
+        const memberIds = Formatter.uniqueArray(allRecords.map(r => r.memberId));
+        const members = await Member.getBlobByIds(...memberIds);
+        const validMembers = members.filter(m => m.registrations.some(r => r.organizationId === organization.id && r.periodId === organization.periodId && r.group.type === GroupType.Membership && r.deactivatedAt === null && r.registeredAt !== null));
+
+        const validMembersIds = validMembers.map(m => m.id);
+
+        const records = allRecords.filter(r => validMembersIds.includes(r.memberId));
+
         let totalSteps = 0;
         let finishedSteps = 0;
 
@@ -277,11 +291,11 @@ export class SetupStepUpdater {
         for(const {responsibility, group} of flatResponsibilities) {
             const { minimumMembers: min, maximumMembers: max } = responsibility;
 
-            if (min === null && max === null) {
+            if (min === null) {
                 continue;
             }
 
-            totalSteps++;
+            totalSteps += min;
 
             const responsibilityId = responsibility.id;
             let totalRecordsWithThisResponsibility = 0;
@@ -301,14 +315,11 @@ export class SetupStepUpdater {
             }
 
             if (max !== null && totalRecordsWithThisResponsibility > max) {
+                // Not added
                 continue;
             }
 
-            if (min !== null && totalRecordsWithThisResponsibility < min) {
-                continue;
-            }
-
-            finishedSteps++;
+            finishedSteps += Math.min(min, totalRecordsWithThisResponsibility);
         }
 
         setupSteps.update(SetupStepType.Responsibilities, {
@@ -316,4 +327,35 @@ export class SetupStepUpdater {
             finishedSteps,
         });
     }
+
+    private static updateStepEmails(setupSteps: SetupSteps,
+        organization: Organization,
+        _platform: PlatformStruct) {
+
+            const totalSteps = 1;
+            let finishedSteps = 0;
+
+            const emails = organization.privateMeta.emails;
+
+            // organization should have 1 default email
+            if(emails.some(e => e.default)) {
+                finishedSteps = 1;
+            }
+
+            setupSteps.update(SetupStepType.Emails, {
+                totalSteps,
+                finishedSteps,
+            });
+
+            setupSteps.markReviewed(SetupStepType.Emails, {userId: 'backend', userName: 'backend'});
+    }
+
+    private static updateStepPayment(setupSteps: SetupSteps,
+        _organization: Organization,
+        _platform: PlatformStruct) {
+            setupSteps.update(SetupStepType.Payment, {
+                totalSteps: 0,
+                finishedSteps: 0,
+            });
+    }
 }