@stamhoofd/backend 2.107.3 → 2.109.0

package/src/endpoints/organization/dashboard/documents/GetDocumentTemplatesEndpoint.ts

@@ -1,16 +1,25 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { SimpleError } from '@simonbackx/simple-errors';
-import { DocumentTemplate, Token } from '@stamhoofd/models';
-import { DocumentTemplatePrivate } from '@stamhoofd/structures';
+import { DocumentTemplate } from '@stamhoofd/models';
+import { assertSort, CountFilteredRequest, DocumentTemplatePrivate, LimitedFilteredRequest, PaginatedResponse, SearchFilterFactory, StamhoofdFilter } from '@stamhoofd/structures';
 
-import { Context } from '../../../../helpers/Context';
+import { Decoder } from '@simonbackx/simple-encoding';
+import { applySQLSorter, compileToSQLFilter, SQL, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
+import { Context } from '../../../../helpers/Context.js';
+import { LimitedFilteredRequestHelper } from '../../../../helpers/LimitedFilteredRequestHelper.js';
+import { documentTemplateFilterCompilers } from '../../../../sql-filters/document-templates.js';
+import { documentTemplateSorters } from '../../../../sql-sorters/document-templates.js';
 
 type Params = Record<string, never>;
-type Query = undefined;
+type Query = LimitedFilteredRequest;
 type Body = undefined;
-type ResponseBody = DocumentTemplatePrivate[];
+type ResponseBody = PaginatedResponse<DocumentTemplatePrivate[], LimitedFilteredRequest>;
+
+const filterCompilers: SQLFilterDefinitions = documentTemplateFilterCompilers;
+const sorters: SQLSortDefinitions<DocumentTemplate> = documentTemplateSorters;
 
 export class GetDocumentTemplatesEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
+
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method !== 'GET') {
             return [false];
@@ -24,7 +33,60 @@ export class GetDocumentTemplatesEndpoint extends Endpoint<Params, Query, Body,
         return [false];
     }
 
-    async handle(_: DecodedRequest<Params, Query, Body>) {
+    static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
+        const organization = Context.organization!;
+
+        const templatesTable: string = DocumentTemplate.table;
+
+        const query = SQL
+            .select(SQL.wildcard(templatesTable))
+            .from(SQL.table(templatesTable))
+            .where('organizationId', organization.id);
+
+        if (q.filter) {
+            query.where(await compileToSQLFilter(q.filter, filterCompilers));
+        }
+
+        if (q.search) {
+            const searchFilter: StamhoofdFilter | null = getDocumentTemplateSearchFilter(q.search);
+
+            if (searchFilter) {
+                query.where(await compileToSQLFilter(searchFilter, filterCompilers));
+            }
+        }
+
+        if (q instanceof LimitedFilteredRequest) {
+            if (q.pageFilter) {
+                query.where(await compileToSQLFilter(q.pageFilter, filterCompilers));
+            }
+
+            q.sort = assertSort(q.sort, [{ key: 'id' }]);
+            applySQLSorter(query, q.sort, sorters);
+            query.limit(q.limit);
+        }
+
+        return query;
+    }
+
+    static async buildData(requestQuery: LimitedFilteredRequest) {
+        const query = await this.buildQuery(requestQuery);
+        const data = await query.fetch();
+
+        const templates: DocumentTemplate[] = DocumentTemplate.fromRows(data, DocumentTemplate.table);
+
+        const next = LimitedFilteredRequestHelper.fixInfiniteLoadingLoop({
+            request: requestQuery,
+            results: templates,
+            sorters,
+        });
+
+        return new PaginatedResponse<DocumentTemplatePrivate[], LimitedFilteredRequest>({
+            results: templates.map(t => t.getPrivateStructure()),
+            next,
+        });
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
         await Context.authenticate();
 
@@ -32,19 +94,33 @@ export class GetDocumentTemplatesEndpoint extends Endpoint<Params, Query, Body,
             throw Context.auth.error();
         }
 
-        const templates = await DocumentTemplate.where(
-            {
-                organizationId: organization.id,
-            },
-            {
-                sort: [{
-                    column: 'createdAt',
-                    direction: 'ASC',
-                }],
-            },
-        );
+        LimitedFilteredRequestHelper.throwIfInvalidLimit({
+            request: request.query,
+            maxLimit: Context.auth.hasSomePlatformAccess() ? 1000 : 100,
+        });
+
         return new Response(
-            templates.map(t => t.getPrivateStructure()),
+            await GetDocumentTemplatesEndpoint.buildData(request.query),
         );
     }
 }
+
+function getDocumentTemplateSearchFilter(search: string | null): StamhoofdFilter | null {
+    if (search === null || search === undefined) {
+        return null;
+    }
+
+    const numberFilter = SearchFilterFactory.getIntegerFilter(search);
+
+    if (numberFilter) {
+        return {
+            year: numberFilter,
+        };
+    }
+
+    return {
+        name: {
+            $contains: search,
+        },
+    };
+}

package/src/endpoints/organization/dashboard/documents/PatchDocumentTemplatesEndpoint.test.ts

@@ -0,0 +1,282 @@
+import { PatchableArray } from '@simonbackx/simple-encoding';
+import { Endpoint, Request } from '@simonbackx/simple-endpoints';
+import { DocumentTemplate, DocumentTemplateFactory, Organization, OrganizationFactory, RegistrationPeriod, RegistrationPeriodFactory, Token, User, UserFactory } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+import { DocumentPrivateSettings, DocumentStatus, DocumentTemplateDefinition, DocumentTemplatePrivate, PermissionLevel, Permissions } from '@stamhoofd/structures';
+import { STExpect, TestUtils } from '@stamhoofd/test-utils';
+import { testServer } from '../../../../../tests/helpers/TestServer.js';
+import { PatchDocumentTemplatesEndpoint } from './PatchDocumentTemplatesEndpoint.js';
+
+const baseUrl = `/organization/document-templates`;
+const endpoint = new PatchDocumentTemplatesEndpoint();
+type EndpointType = typeof endpoint;
+type Body = EndpointType extends Endpoint<any, any, infer B, any> ? B : never;
+
+describe('Endpoint.PatchDocumentTemplatesEndpoint', () => {
+    let period: RegistrationPeriod;
+    let organization: Organization;
+    let user: User;
+    let token: Token;
+
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    beforeAll(async () => {
+        period = await new RegistrationPeriodFactory({
+            startDate: new Date(2023, 0, 1),
+            endDate: new Date(2023, 11, 31),
+        }).create();
+
+        organization = await new OrganizationFactory({ period })
+            .create();
+
+        user = await new UserFactory({
+            organization,
+            permissions: Permissions.create({
+                level: PermissionLevel.Full,
+            }),
+        }).create();
+
+        token = await Token.createToken(user);
+    });
+
+    describe('put fiscal document', () => {
+        it('should throw if already has fiscal document in year', async () => {
+            // create existing fiscal document in same year
+            await new DocumentTemplateFactory({
+                organizationId: organization.id,
+                type: 'fiscal',
+                groups: [],
+                year: 2022,
+            }).create();
+
+            // create new fiscal document in same year
+            const arr: Body = new PatchableArray();
+            const newDocumentModel: DocumentTemplate = (await new DocumentTemplateFactory({
+                organizationId: organization.id,
+                type: 'fiscal',
+                groups: [],
+                year: 2022,
+            }).createWithoutSave());
+
+            const newDocument = newDocumentModel.getPrivateStructure();
+            arr.addPut(newDocument);
+
+            const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+            request.headers.authorization = 'Bearer ' + token.accessToken;
+
+            await expect(testServer.test(endpoint, request))
+                .rejects
+                .toThrow(STExpect.errorWithCode('double_fiscal_document'));
+        });
+
+        it('should not throw if first fiscal document in year', async () => {
+            // delete existing docs from organization
+            await SQL.delete().from(SQL.table(DocumentTemplate.table)).where('organizationId', organization.id);
+
+            const arr: Body = new PatchableArray();
+            const newDocumentModel: DocumentTemplate = (await new DocumentTemplateFactory({
+                organizationId: organization.id,
+                type: 'fiscal',
+                groups: [],
+                year: 2022,
+            }).createWithoutSave());
+
+            const newDocument = newDocumentModel.getPrivateStructure();
+            arr.addPut(newDocument);
+
+            const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+            request.headers.authorization = 'Bearer ' + token.accessToken;
+
+            const result = await testServer.test(endpoint, request);
+
+            expect(result).toBeDefined();
+            expect(result.status).toBe(200);
+        });
+    });
+
+    describe('patch fiscal document', () => {
+        describe('change type to fiscal', () => {
+            it('should throw if already has fiscal document in year', async () => {
+                // create existing fiscal document in same year
+                await new DocumentTemplateFactory({
+                    organizationId: organization.id,
+                    type: 'fiscal',
+                    groups: [],
+                    year: 2022,
+                }).create();
+
+                // create new fiscal document in same year
+                const arr: Body = new PatchableArray();
+
+                // create new participation document in same year
+                const newDocumentModel: DocumentTemplate = (await new DocumentTemplateFactory({
+                    organizationId: organization.id,
+                    type: 'participation',
+                    groups: [],
+                    year: 2022,
+                }).create());
+
+                // change type to fiscal
+                arr.addPatch(DocumentTemplatePrivate.patch({
+                    id: newDocumentModel.id,
+                    privateSettings: DocumentPrivateSettings.patch({
+                        templateDefinition: DocumentTemplateDefinition.patch({
+                            type: 'fiscal',
+                        }),
+                    }),
+                }));
+
+                const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+                request.headers.authorization = 'Bearer ' + token.accessToken;
+
+                await expect(testServer.test(endpoint, request))
+                    .rejects
+                    .toThrow(STExpect.errorWithCode('double_fiscal_document'));
+            });
+
+            it('should not throw if first fiscal document in year', async () => {
+                // delete existing docs from organization
+                await SQL.delete().from(SQL.table(DocumentTemplate.table)).where('organizationId', organization.id);
+
+                // create new fiscal document in same year
+                const arr: Body = new PatchableArray();
+
+                // create new participation document in same year
+                const newDocumentModel: DocumentTemplate = (await new DocumentTemplateFactory({
+                    organizationId: organization.id,
+                    type: 'participation',
+                    groups: [],
+                    year: 2022,
+                }).create());
+
+                // change type to fiscal
+                arr.addPatch(DocumentTemplatePrivate.patch({
+                    id: newDocumentModel.id,
+                    privateSettings: DocumentPrivateSettings.patch({
+                        templateDefinition: DocumentTemplateDefinition.patch({
+                            type: 'fiscal',
+                        }),
+                    }),
+                }));
+
+                const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+                request.headers.authorization = 'Bearer ' + token.accessToken;
+
+                const result = await testServer.test(endpoint, request);
+
+                expect(result).toBeDefined();
+                expect(result.status).toBe(200);
+            });
+        });
+
+        describe('change year', () => {
+            it('should throw if already has fiscal document in year', async () => {
+                // create existing fiscal document in same year
+                await new DocumentTemplateFactory({
+                    organizationId: organization.id,
+                    type: 'fiscal',
+                    groups: [],
+                    year: 2022,
+                }).create();
+
+                // create new fiscal document in same year
+                const arr: Body = new PatchableArray();
+
+                // create new participation document in other year
+                const newDocumentModel: DocumentTemplate = (await new DocumentTemplateFactory({
+                    organizationId: organization.id,
+                    type: 'fiscal',
+                    groups: [],
+                    year: 2021,
+                }).create());
+
+                // change year to same year as other existing document
+                arr.addPatch(DocumentTemplatePrivate.patch({
+                    id: newDocumentModel.id,
+                    year: 2022,
+                }));
+
+                const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+                request.headers.authorization = 'Bearer ' + token.accessToken;
+
+                await expect(testServer.test(endpoint, request))
+                    .rejects
+                    .toThrow(STExpect.errorWithCode('double_fiscal_document'));
+            });
+
+            it('should not throw if first fiscal document in year', async () => {
+                // delete existing docs from organization
+                await SQL.delete().from(SQL.table(DocumentTemplate.table)).where('organizationId', organization.id);
+
+                // create new fiscal document in same year
+                const arr: Body = new PatchableArray();
+
+                // create new participation document in other year
+                const newDocumentModel: DocumentTemplate = (await new DocumentTemplateFactory({
+                    organizationId: organization.id,
+                    type: 'fiscal',
+                    groups: [],
+                    year: 2021,
+                }).create());
+
+                // change year to same year as other existing document
+                arr.addPatch(DocumentTemplatePrivate.patch({
+                    id: newDocumentModel.id,
+                    year: 2022,
+                }));
+
+                const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+                request.headers.authorization = 'Bearer ' + token.accessToken;
+
+                const result = await testServer.test(endpoint, request);
+
+                expect(result).toBeDefined();
+                expect(result.status).toBe(200);
+            });
+        });
+
+        describe('do not change type or year of existing fiscal document', () => {
+            it('should not throw if multiple fiscal documents in year', async () => {
+                // delete existing docs from organization
+                await SQL.delete().from(SQL.table(DocumentTemplate.table)).where('organizationId', organization.id);
+
+                // create existing fiscal document in same year
+                await new DocumentTemplateFactory({
+                    organizationId: organization.id,
+                    type: 'fiscal',
+                    groups: [],
+                    year: 2022,
+                }).create();
+
+                // create new fiscal document in same year
+                const arr: Body = new PatchableArray();
+
+                // create double fiscal document in same year
+                const newDocumentModel: DocumentTemplate = (await new DocumentTemplateFactory({
+                    organizationId: organization.id,
+                    type: 'fiscal',
+                    groups: [],
+                    year: 2022,
+                }).create());
+
+                // change status to published (do not change year or type)
+                arr.addPatch(DocumentTemplatePrivate.patch({
+                    id: newDocumentModel.id,
+                    status: DocumentStatus.Published,
+                }));
+
+                const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+                request.headers.authorization = 'Bearer ' + token.accessToken;
+
+                const result = await testServer.test(endpoint, request);
+
+                expect(result).toBeDefined();
+                expect(result.status).toBe(200);
+                expect(result.body.length).toBe(1);
+                expect(result.body[0].status).toBe(DocumentStatus.Published);
+            });
+        });
+    });
+});

package/src/endpoints/organization/dashboard/documents/{PatchDocumentTemplateEndpoint.ts → PatchDocumentTemplatesEndpoint.ts}

@@ -1,10 +1,11 @@
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { DocumentTemplate, Token } from '@stamhoofd/models';
+import { DocumentTemplate } from '@stamhoofd/models';
 import { DocumentTemplatePrivate, PermissionLevel } from '@stamhoofd/structures';
 
-import { Context } from '../../../../helpers/Context';
+import { SQL, SQLWhereSign } from '@stamhoofd/sql';
+import { Context } from '../../../../helpers/Context.js';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -15,7 +16,7 @@ type ResponseBody = DocumentTemplatePrivate[];
  * One endpoint to create, patch and delete groups. Usefull because on organization setup, we need to create multiple groups at once. Also, sometimes we need to link values and update multiple groups at once
  */
 
-export class PatchDocumentTemplateEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+export class PatchDocumentTemplatesEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     bodyDecoder = new PatchableArrayDecoder(DocumentTemplatePrivate as Decoder<DocumentTemplatePrivate>, DocumentTemplatePrivate.patchType() as Decoder<AutoEncoderPatchType<DocumentTemplatePrivate>>, StringDecoder);
 
     protected doesMatch(request: Request): [true, Params] | [false] {
@@ -49,7 +50,19 @@ export class PatchDocumentTemplateEndpoint extends Endpoint<Params, Query, Body,
             template.status = put.status;
             template.html = put.html;
             template.updatesEnabled = put.updatesEnabled;
+            template.year = put.year;
             template.organizationId = organization.id;
+
+            if (await this.doesYearAlreadyHaveFiscalDocument(template)) {
+                throw new SimpleError({
+                    code: 'double_fiscal_document',
+                    field: 'year',
+                    message: 'This year already has a fiscal document',
+                    human: $t('475f5f96-86bf-4124-a005-9904aaf72b37'),
+
+                });
+            }
+
             await template.save();
 
             // todo: Generate documents (maybe in background)
@@ -65,7 +78,14 @@ export class PatchDocumentTemplateEndpoint extends Endpoint<Params, Query, Body,
                 throw Context.auth.notFoundOrNoAccess($t(`148bfab7-ca0e-4fac-8a0a-302ca7855fc8`));
             }
 
+            let shouldCheckIfAlreadyHasFiscalDocument = false;
+
             if (patch.privateSettings) {
+                const patchType = patch.privateSettings.templateDefinition?.type;
+
+                // only check if type has changed and new type is fiscal
+                shouldCheckIfAlreadyHasFiscalDocument = patchType !== undefined && template.privateSettings.templateDefinition.type !== patchType && patchType === 'fiscal';
+
                 template.privateSettings.patchOrPut(patch.privateSettings);
             }
 
@@ -85,6 +105,23 @@ export class PatchDocumentTemplateEndpoint extends Endpoint<Params, Query, Body,
                 template.html = patch.html;
             }
 
+            if (patch.year) {
+                if (shouldCheckIfAlreadyHasFiscalDocument === false) {
+                    shouldCheckIfAlreadyHasFiscalDocument = template.year !== patch.year;
+                }
+
+                template.year = patch.year;
+            }
+
+            if (shouldCheckIfAlreadyHasFiscalDocument && await this.doesYearAlreadyHaveFiscalDocument(template)) {
+                throw new SimpleError({
+                    code: 'double_fiscal_document',
+                    field: 'year',
+                    message: 'This year already has a fiscal document',
+                    human: $t('475f5f96-86bf-4124-a005-9904aaf72b37'),
+                });
+            }
+
             await template.save();
 
             // Update documents
@@ -111,4 +148,20 @@ export class PatchDocumentTemplateEndpoint extends Endpoint<Params, Query, Body,
             updatedTemplates,
         );
     }
+
+    private async doesYearAlreadyHaveFiscalDocument(template: DocumentTemplate) {
+        let query = SQL.select().from(SQL.table(DocumentTemplate.table))
+            .where(SQL.column('organizationId'), template.organizationId)
+            .where(SQL.column('year'), template.year)
+            .where(SQL.jsonExtract(SQL.column('privateSettings'), '$.value.templateDefinition.type'), 'fiscal');
+
+        // id is not set if put
+        if (template.id) {
+            query = query.where(SQL.column('id'), SQLWhereSign.NotEqual, template.id);
+        }
+
+        const result = await query.limit(1).count();
+
+        return result > 0;
+    }
 }

package/src/excel-loaders/members.ts

@@ -1,12 +1,12 @@
 import { XlsxBuiltInNumberFormat, XlsxTransformerColumn, XlsxTransformerSheet } from '@stamhoofd/excel-writer';
 import { Platform } from '@stamhoofd/models';
-import { ExcelExportType, Gender, GroupType, LimitedFilteredRequest, PlatformFamily, PlatformMember, Platform as PlatformStruct, UnencodeablePaginatedResponse } from '@stamhoofd/structures';
+import { ExcelExportType, Gender, GroupType, LimitedFilteredRequest, MembershipStatus, PlatformFamily, PlatformMember, Platform as PlatformStruct, UnencodeablePaginatedResponse } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
-import { ExportToExcelEndpoint } from '../endpoints/global/files/ExportToExcelEndpoint';
-import { GetMembersEndpoint } from '../endpoints/global/members/GetMembersEndpoint';
-import { AuthenticatedStructures } from '../helpers/AuthenticatedStructures';
-import { Context } from '../helpers/Context';
-import { XlsxTransformerColumnHelper } from '../helpers/XlsxTransformerColumnHelper';
+import { ExportToExcelEndpoint } from '../endpoints/global/files/ExportToExcelEndpoint.js';
+import { GetMembersEndpoint } from '../endpoints/global/members/GetMembersEndpoint.js';
+import { AuthenticatedStructures } from '../helpers/AuthenticatedStructures.js';
+import { Context } from '../helpers/Context.js';
+import { XlsxTransformerColumnHelper } from '../helpers/XlsxTransformerColumnHelper.js';
 
 export const baseMemberColumns: XlsxTransformerColumn<PlatformMember>[] = [
     {
@@ -150,6 +150,16 @@ export const baseMemberColumns: XlsxTransformerColumn<PlatformMember>[] = [
             value: object.details.nationalRegisterNumber?.toString() ?? '',
         }),
     },
+    {
+        id: 'membership',
+        name: $t(`c7d995f1-36a0-446e-9fcf-17ffb69f3f45`),
+        width: 20,
+        getValue: (member: PlatformMember) => {
+            return {
+                value: formatMembershipStatus(member.membershipStatus),
+            };
+        },
+    },
 
     ...XlsxTransformerColumnHelper.creatColumnsForParents(),
 
@@ -260,6 +270,35 @@ const sheet: XlsxTransformerSheet<PlatformMember, PlatformMember> = {
                 };
             },
         },
+        {
+            id: 'outstandingBalance',
+            name: $t(`beb45452-dee7-4a7f-956c-e6db06aac20f`),
+            width: 30,
+            getValue: (v) => {
+                return {
+                    value: v.member.balances.reduce((sum, r) => sum + (r.amountOpen), 0) / 1_0000,
+                    style: {
+                        numberFormat: {
+                            id: XlsxBuiltInNumberFormat.Currency2DecimalWithRed,
+                        },
+                    },
+                };
+            },
+
+        },
+        {
+            id: 'createdAt',
+            name: $t('c38e774e-e8ab-4549-b119-4eed380c626c'),
+            width: 20,
+            getValue: v => ({
+                value: v.member.createdAt,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.DateSlash,
+                    },
+                },
+            }),
+        },
 
         // Registration records
         {
@@ -340,7 +379,7 @@ const sheet: XlsxTransformerSheet<PlatformMember, PlatformMember> = {
                                                         },
                                                     }
                                                 : {},
-                                            value: options.length === 1 && returnAmount ? options[0].amount : options.map(option => returnAmount ? option.amount : option).join(', '),
+                                            value: options.map(option => returnAmount ? option.amount : option.option.name).join(', '),
                                         };
                                     },
                                 },
@@ -427,10 +466,25 @@ ExportToExcelEndpoint.loaders.set(ExcelExportType.Members, {
     ],
 });
 
-function formatGender(gender: Gender) {
+function formatGender(gender: Gender): string {
     switch (gender) {
         case Gender.Male: return $t(`f972abd4-de1e-484b-b7da-ad4c75d37808`);
         case Gender.Female: return $t(`e21f499d-1078-4044-be5d-6693d2636699`);
         default: return $t(`60f13ba4-c6c9-4388-9add-43a996bf6bee`);
     }
 }
+
+function formatMembershipStatus(status: MembershipStatus): string {
+    switch (status) {
+        case MembershipStatus.Trial:
+            return $t(`47c7c3c4-9246-40b7-b1e0-2cb408d5f79e`);
+        case MembershipStatus.Active:
+            return $t(`b56351e9-4847-4a0c-9eec-348d75c794c4`);
+        case MembershipStatus.Expiring:
+            return $t(`d9858110-37d9-4b4a-8bfb-d76b3cc5ef27`);
+        case MembershipStatus.Temporary:
+            return $t(`75e62d3c-f348-4104-8a1e-e11e6e7fbe32`);
+        case MembershipStatus.Inactive:
+            return $t(`1f8620fa-e8a5-4665-99c8-c1907a5b5768`);
+    }
+}