@stamhoofd/backend 1.0.0

package/src/endpoints/global/registration-periods/GetRegistrationPeriodsEndpoint.ts

@@ -0,0 +1,37 @@
+import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { RegistrationPeriod as RegistrationPeriodStruct } from "@stamhoofd/structures";
+
+import { RegistrationPeriod } from '@stamhoofd/models';
+
+type Params = Record<string, never>;
+type Query = undefined;
+type Body = undefined
+type ResponseBody = RegistrationPeriodStruct[]
+
+/**
+ * One endpoint to create, patch and delete members and their registrations and payments
+ */
+
+export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "GET") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/registration-periods", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const periods = await RegistrationPeriod.all()
+
+        return new Response(
+            periods.map(p => p.getStructure())
+        );
+    }
+
+}

package/src/endpoints/global/registration-periods/PatchRegistrationPeriodsEndpoint.ts

@@ -0,0 +1,115 @@
+import { ConvertArrayToPatchableArray, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder, patchObject } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { RegistrationPeriod as RegistrationPeriodStruct } from "@stamhoofd/structures";
+
+import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
+import { Context } from '../../../helpers/Context';
+import { RegistrationPeriod } from '@stamhoofd/models';
+import { SimpleError } from '@simonbackx/simple-errors';
+
+type Params = Record<string, never>;
+type Query = undefined;
+type Body = PatchableArrayAutoEncoder<RegistrationPeriodStruct>
+type ResponseBody = RegistrationPeriodStruct[]
+
+/**
+ * One endpoint to create, patch and delete members and their registrations and payments
+ */
+
+export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    bodyDecoder = new PatchableArrayDecoder(RegistrationPeriodStruct as any, RegistrationPeriodStruct.patchType(), StringDecoder) as any as Decoder<ConvertArrayToPatchableArray<RegistrationPeriodStruct[]>>
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "PATCH") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/registration-periods", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setUserOrganizationScope();
+        await Context.authenticate()
+
+        // Fast throw first (more in depth checking for patches later)
+        if (organization) {
+            if (!await Context.auth.hasFullAccess(organization.id)) {
+                throw Context.auth.error()
+            } 
+        } else {
+            if (!Context.auth.hasPlatformFullAccess()) {
+                throw Context.auth.error()
+            } 
+        }
+
+        const periods: RegistrationPeriod[] = [];
+
+        for (const {put} of request.body.getPuts()) {
+            const period = new RegistrationPeriod();
+            period.id = put.id;
+            period.startDate = put.startDate;
+            period.endDate = put.endDate;
+            period.locked = put.locked;
+            period.settings = put.settings;
+            period.organizationId = organization?.id ?? null;
+
+            await period.save();
+            periods.push(period);
+        }
+
+        for (const patch of request.body.getPatches()) {
+            const model = await RegistrationPeriod.getByID(patch.id);
+
+            if (!model || model.organizationId !== (organization?.id ?? null)) {
+                throw new SimpleError({
+                    code: "not_found",
+                    statusCode: 404,
+                    message: "Registration period not found",
+                });
+            }
+
+            if (patch.startDate !== undefined) {
+                model.startDate = patch.startDate;
+            }
+
+            if (patch.endDate !== undefined) {
+                model.endDate = patch.endDate;
+            }
+
+            if (patch.locked !== undefined) {
+                model.locked = patch.locked;
+            }
+
+            if (patch.settings !== undefined) {
+                model.settings = patchObject(model.settings, patch.settings);
+            }
+
+            await model.save();
+        }
+
+        for (const id of request.body.getDeletes()) {
+            const model = await RegistrationPeriod.getByID(id);
+
+            if (!model || model.organizationId !== (organization?.id ?? null)) {
+                throw new SimpleError({
+                    code: "not_found",
+                    statusCode: 404,
+                    message: "Registration period not found",
+                });
+            }
+
+            await model.delete();
+        }
+
+        return new Response(
+            periods.map(p => p.getStructure())
+        );
+    }
+
+}

package/src/endpoints/global/webshops/GetWebshopFromDomainEndpoint.ts

@@ -0,0 +1,187 @@
+import { AutoEncoder, Decoder,field, StringDecoder } from "@simonbackx/simple-encoding";
+import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Organization } from '@stamhoofd/models';
+import { Webshop } from '@stamhoofd/models';
+import { GetWebshopFromDomainResult, Webshop as WebshopStruct, WebshopPreview } from "@stamhoofd/structures";
+import { GoogleTranslateHelper, Sorter } from "@stamhoofd/utility";
+type Params = Record<string, never>;
+
+class Query extends AutoEncoder {
+    @field({ decoder: StringDecoder })
+    domain: string;
+
+    @field({ decoder: StringDecoder, nullable: true })
+    uri: string | null;
+}
+
+type Body = undefined
+type ResponseBody = GetWebshopFromDomainResult;
+
+/**
+ * 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 GetWebshopFromDomainEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = Query as Decoder<Query>
+    webshopDomains = [
+        ...new Set([
+            ...Object.values(STAMHOOFD.domains.webshop), 
+            ...Object.values(STAMHOOFD.domains.marketing)
+        ])
+    ]
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "GET") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/webshop-from-domain", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        // check if the domain ends on .stamhoofd.be
+        if (!STAMHOOFD.domains.webshop) {
+            throw new Error("Expected environment variable HOSTNAME_WEBSHOP")
+        }
+
+        // Clean up google translate domains -> make sure we can translate register pages
+        request.query.domain = GoogleTranslateHelper.getDomainFromTranslateDomain(request.query.domain)
+
+        if (request.query.uri) {
+            for (const domain of this.webshopDomains) {
+                if (request.query.domain === domain) {
+                    // Search webshop
+                    const webshop = await Webshop.getByURI(request.query.uri)
+
+                    if (!webshop) {
+                        throw new SimpleError({
+                            code: "unknown_webshop",
+                            message: "No webshop registered with this name",
+                            statusCode: 404
+                        })
+                    }
+
+                    const organization = await Organization.getByID(webshop.organizationId)
+
+                    if (!organization) {
+                        throw new SimpleError({
+                            code: "unknown_organization",
+                            message: "No organization registered with this domain name",
+                            statusCode: 404
+                        })
+                    }
+
+                    return new Response(GetWebshopFromDomainResult.create({
+                        organization: await organization.getStructure({emptyGroups: true}),
+                        webshop: WebshopStruct.create(webshop)
+                    }));
+                }
+            }
+        }
+        
+        // If ends with the legacy webshop domain
+        if (STAMHOOFD.domains.legacyWebshop && request.query.domain.endsWith("." + STAMHOOFD.domains.legacyWebshop)) {
+            const strippped = request.query.domain.substr(0, request.query.domain.length - ("." + STAMHOOFD.domains.legacyWebshop).length )
+            if (strippped.includes(".")) {
+                throw new SimpleError({
+                    code: "invalid_domain",
+                    message: "This domain format is not supported",
+                    statusCode: 404
+                })
+            }
+
+            // Search for the URI
+            const organization = await Organization.getByURI(strippped)
+
+            if (!organization) {
+                throw new SimpleError({
+                    code: "unknown_organization",
+                    message: "No organization registered with this domain name",
+                    statusCode: 404
+                })
+            }
+
+            // Search webshop
+            const webshop = await Webshop.getByLegacyURI(organization.id, request.query.uri ?? "")
+
+            if (!webshop) {
+                // Return organization, so we know the locale + can do some custom logic
+                return new Response(GetWebshopFromDomainResult.create({
+                    organization: await organization.getStructure({emptyGroups: true}),
+                    webshop: null,
+                    webshops: []
+                }));
+            }
+
+            return new Response(GetWebshopFromDomainResult.create({
+                organization: await organization.getStructure({emptyGroups: true}),
+                webshop: WebshopStruct.create(webshop)
+            }));
+        }
+
+        // Check if we have an organization with a custom domain name
+
+        const webshop = await Webshop.getByDomain(request.query.domain, request.query.uri)
+
+        if (!webshop) {
+            // If uri is empty, check if we have multiple webshops with the same domain
+            // Check organization
+            if (!request.query.uri) {
+                const webshops = await Webshop.getByDomainOnly(request.query.domain)
+                const organizationId = Sorter.getMostOccuringElement(webshops.map(w => w.organizationId))
+
+                if (webshops.length == 0 || !organizationId) {
+                    throw new SimpleError({
+                        code: "unknown_webshop",
+                        message: "No webshop registered with this domain name",
+                        statusCode: 404
+                    })
+                }
+
+                const organization = await Organization.getByID(organizationId)
+
+                if (!organization) {
+                    throw new SimpleError({
+                        code: "unknown_webshop",
+                        message: "No webshop registered with this domain name",
+                        statusCode: 404
+                    })
+                }
+
+                // Return organization, and the known webshops on this domain
+                return new Response(GetWebshopFromDomainResult.create({
+                    organization: await organization.getStructure({emptyGroups: true}),
+                    webshop: null,
+                    webshops: webshops.map(w => WebshopPreview.create(w)).filter(w => w.isClosed(0) === false).sort((a, b) => Sorter.byStringValue(a.meta.name, b.meta.name))
+                }));
+            }
+            
+            throw new SimpleError({
+                code: "unknown_webshop",
+                message: "No webshop registered with this domain name",
+                statusCode: 404
+            })
+        }
+
+        const organization = await Organization.getByID(webshop.organizationId)
+
+        if (!organization) {
+            throw new SimpleError({
+                code: "unknown_organization",
+                message: "No organization registered with this domain name",
+                statusCode: 404
+            })
+        }
+
+        return new Response(GetWebshopFromDomainResult.create({
+            organization: await organization.getStructure({emptyGroups: true}),
+            webshop: WebshopStruct.create(webshop)
+        }));
+    }
+}