@stamhoofd/backend 1.0.0

package/src/endpoints/global/organizations/CheckRegisterCodeEndpoint.ts

@@ -0,0 +1,45 @@
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints'
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Organization, RegisterCode } from '@stamhoofd/models';
+import {RegisterCode as RegisterCodeStruct } from "@stamhoofd/structures"
+type Params = { code: string };
+type Query = undefined;
+type Body = undefined;
+type ResponseBody = RegisterCodeStruct;
+
+export class CheckRegisterCodeEndpoint 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, "/register-code/@code", {code: String});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        
+        const code = await RegisterCode.getByID(request.params.code)
+        if (code) {
+            return new Response(RegisterCodeStruct.create({
+                code: code.code,
+                description: code.description,
+                customMessage: code.customMessage,
+                organizationName: code.organizationId ? ((await Organization.getByID(code.organizationId))!.name) : null,
+                value: code.value
+            }))
+        }
+
+        throw new SimpleError({
+            code: "invalid_code",
+            message: "Invalid code",
+            human: "Deze code is niet geldig",
+            field: "registerCode"
+        })
+    }
+}

package/src/endpoints/global/organizations/CreateOrganizationEndpoint.test.ts

@@ -0,0 +1,105 @@
+
+import { Request } from "@simonbackx/simple-endpoints";
+import { Organization, OrganizationFactory, RegisterCodeFactory, STCredit } from "@stamhoofd/models";
+import { Address, Country, CreateOrganization, NewUser, Organization as OrganizationStruct, Version } from "@stamhoofd/structures";
+
+import { testServer } from "../../../../tests/helpers/TestServer";
+import { CreateOrganizationEndpoint } from "./CreateOrganizationEndpoint";
+
+function expect_toBeDefined<T>(arg: T): asserts arg is NonNullable<T> {
+  expect(arg).toBeDefined();
+}
+
+describe("Endpoint.CreateOrganization", () => {
+    // Test endpoint
+    const endpoint = new CreateOrganizationEndpoint();
+
+    test("Can create a new organization", async () => {
+        const r = Request.buildJson("POST", `/v${Version}/organizations`, "todo-host.be", CreateOrganization.create({
+            organization: OrganizationStruct.create({
+                name: "My endpoint test organization",
+                uri: "my-endpoint-test-organization",
+                address: Address.create({
+                    street: "My street",
+                    number: "1",
+                    postalCode: "9000",
+                    city: "Gent",
+                    country: Country.Belgium
+                }),
+                
+            }),
+            user: NewUser.create({
+                email: "voorbeeld@stamhoofd.be",
+                password: "My user password",
+            }),
+        }).encode({version: Version}));
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body.token).not.toBeEmpty();
+    });
+
+    test("Creating an organization with an in-use URI throws", async () => {
+        const r = Request.buildJson("POST", `/v${Version}/organizations`, "todo-host.be", CreateOrganization.create({
+            organization: OrganizationStruct.create({
+                name: "My endpoint test organization",
+                uri: "my-endpoint-test-organization",
+                address: Address.create({
+                    street: "My street",
+                    number: "1",
+                    postalCode: "9000",
+                    city: "Gent",
+                    country: Country.Belgium
+                }),
+                
+            }),
+            user: NewUser.create({
+                email: "voorbeeld@stamhoofd.be",
+                password: "My user password",
+            })
+        }).encode({version: Version}));
+
+        await expect(testServer.test(endpoint, r)).rejects.toThrow(/name/);
+    });
+
+    test("Can create an organization with a register code and apply the discount", async () => {
+        const otherOrganization =  await new OrganizationFactory({}).create();
+        const code = await new RegisterCodeFactory({organization: otherOrganization}).create();
+        const uri = 'my-organization-with-a-discount';
+
+        const r = Request.buildJson(
+            "POST", 
+            "/organizations", 
+            "todo-host.be", 
+            CreateOrganization.create({
+                organization: OrganizationStruct.create({
+                    name: "My organization with a discount",
+                    uri,
+                    address: Address.create({
+                        street: "My street",
+                        number: "1",
+                        postalCode: "9000",
+                        city: "Gent",
+                        country: Country.Belgium
+                    }),
+                }),
+                user: NewUser.create({
+                    email: "voorbeeld@stamhoofd.be",
+                    password: "My user password",
+                }),
+                registerCode: code.code
+            })
+        );
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body.token).not.toBeEmpty();
+
+        const organization = await Organization.getByURI(uri);
+        expect_toBeDefined(organization);
+
+        // Check if this organization has an open register code
+        const credits = await STCredit.getForOrganization(organization.id);
+        expect(credits.length).toBe(1);
+        expect(credits[0].change).toBe(code.value);
+    });
+
+});

package/src/endpoints/global/organizations/CreateOrganizationEndpoint.ts

@@ -0,0 +1,146 @@
+import { Model } from '@simonbackx/simple-database';
+import { Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Email, EmailInterfaceBase } from '@stamhoofd/email';
+import { EmailVerificationCode, Organization, RegisterCode, User } from '@stamhoofd/models';
+import { CreateOrganization, PermissionLevel, Permissions, SignupResponse, UserPermissions } from "@stamhoofd/structures";
+import { Formatter } from "@stamhoofd/utility";
+
+type Params = Record<string, never>;
+type Query = undefined;
+type Body = CreateOrganization;
+type ResponseBody = SignupResponse;
+
+export class CreateOrganizationEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    bodyDecoder = CreateOrganization as Decoder<CreateOrganization>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "POST") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/organizations", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        if (STAMHOOFD.userMode === 'platform') {
+            throw new SimpleError({
+                code: "invalid_field",
+                message: "Not allowed",
+                human: "Je kan geen vereniging aanmaken"
+            })
+        }
+
+        if (request.body.organization.name.length < 4) {
+            if (request.body.organization.name.length == 0) {
+                throw new SimpleError({
+                    code: "invalid_field",
+                    message: "Should not be empty",
+                    human: "Je bent de naam van je organisatie vergeten in te vullen",
+                    field: "organization.name"
+                })
+            }
+
+            throw new SimpleError({
+                code: "invalid_field",
+                message: "Field is too short",
+                human: "Kijk de naam van je organisatie na, deze is te kort. Vul eventueel aan met de gemeente.",
+                field: "organization.name"
+            })
+        }
+
+        const uri = Formatter.slug(request.body.organization.name);
+
+        if (uri.length > 100) {
+            throw new SimpleError({
+                code: "invalid_field",
+                message: "Field is too long",
+                human: "De naam van de vereniging is te lang. Probeer de naam wat te verkorten en probeer opnieuw.",
+                field: "organization.name"
+            })
+        }
+        const alreadyExists = await Organization.getByURI(uri);
+
+        if (alreadyExists) {
+            throw new SimpleError({
+                code: "name_taken",
+                message: "An organization with the same name already exists",
+                human: "Er bestaat al een vereniging met dezelfde naam. Voeg bijvoorbeeld de naam van je gemeente toe.",
+                field: "name",
+            });
+        }
+
+        // First create the organization
+        // TODO: add some duplicate validation
+        const organization = new Organization();
+        organization.id = request.body.organization.id;
+        organization.name = request.body.organization.name;
+
+        // Delay save until after organization is saved, but do validations before the organization is saved
+        let registerCodeModels: Model[] = []
+        let delayEmails: EmailInterfaceBase[] = []
+
+        if (request.body.registerCode) {
+            const applied = await RegisterCode.applyRegisterCode(organization, request.body.registerCode)
+            registerCodeModels = applied.models
+            delayEmails = applied.emails
+        }
+
+        organization.uri = uri;
+        organization.meta = request.body.organization.meta
+        organization.address = request.body.organization.address
+        organization.privateMeta.acquisitionTypes = request.body.organization.privateMeta?.acquisitionTypes ?? []
+
+        try {
+            await organization.save();
+        } catch (e) {
+            console.error(e);
+            throw new SimpleError({
+                code: "creating_organization",
+                message: "Something went wrong while creating the organization. Please try again later or contact us.",
+                statusCode: 500
+            });
+        }
+
+        const user = await User.register(
+            organization,
+            request.body.user
+        );
+        if (!user) {
+            // This user already exists, well that is pretty impossible
+            throw new SimpleError({
+                code: "creating_user",
+                message: "Something went wrong while creating the user. Please contact us to resolve this issue.",
+                statusCode: 500
+            });
+        }
+
+        // Should prevent this extra save
+        user.permissions = UserPermissions.create({})
+        user.permissions.organizationPermissions.set(organization.id, Permissions.create({ level: PermissionLevel.Full }))
+        await user.save()
+
+        for (const model of registerCodeModels) {
+            await model.save()
+        }
+
+        const code = await EmailVerificationCode.createFor(user, user.email)
+        code.send(user, organization, request.i18n)
+
+        for (const email of delayEmails) {
+            Email.sendInternal(email, organization.i18n)
+        }
+
+        return new Response(SignupResponse.create({
+            token: code.token
+        }));
+    }
+
+    
+}

package/src/endpoints/global/organizations/GetOrganizationFromDomainEndpoint.test.ts

@@ -0,0 +1,52 @@
+import { Request } from "@simonbackx/simple-endpoints";
+import { GroupFactory, OrganizationFactory } from '@stamhoofd/models';
+import { Organization } from '@stamhoofd/structures';
+
+import { testServer } from "../../../../tests/helpers/TestServer";
+import { GetOrganizationFromDomainEndpoint } from './GetOrganizationFromDomainEndpoint';
+
+describe("Endpoint.GetOrganizationFromDomain", () => {
+    // Test endpoint
+    const endpoint = new GetOrganizationFromDomainEndpoint();
+
+    test("Get organization from default uri", async () => {
+        const organization = await new OrganizationFactory({}).create()
+        const groups = await new GroupFactory({ organization }).createMultiple(2)
+
+        const r = Request.buildJson("GET", "/v2/organization-from-domain");
+        r.query = {
+            "domain": organization.uri+".stamhoofd.dev",
+        }
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+
+        if (!(response.body instanceof Organization)) {
+            throw new Error("Expected Organization")
+        }
+
+        expect(response.body.id).toEqual(organization.id)
+        expect(response.body.groups.map(g => g.id).sort()).toEqual(groups.map(g => g.id).sort())
+    });
+
+    test("Get organization from custom domain", async () => {
+        const organization = await new OrganizationFactory({ domain: "inschrijven.mijnscouts.be"}).create()
+        const groups = await new GroupFactory({ organization }).createMultiple(2)
+
+        const r = Request.buildJson("GET", "/v2/organization-from-domain");
+        r.query = {
+            "domain": "inschrijven.mijnscouts.be",
+        }
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+
+        if (!(response.body instanceof Organization)) {
+            throw new Error("Expected Organization")
+        }
+
+        expect(response.body.id).toEqual(organization.id)
+        expect(response.body.groups.map(g => g.id).sort()).toEqual(groups.map(g => g.id).sort())
+    });
+
+});

package/src/endpoints/global/organizations/GetOrganizationFromDomainEndpoint.ts

@@ -0,0 +1,80 @@
+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 { Organization as OrganizationStruct } from "@stamhoofd/structures";
+import { GoogleTranslateHelper } from "@stamhoofd/utility";
+type Params = Record<string, never>;
+
+class Query extends AutoEncoder {
+    @field({ decoder: StringDecoder })
+    domain: string;
+}
+
+type Body = undefined
+type ResponseBody = OrganizationStruct;
+
+/**
+ * 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 GetOrganizationFromDomainEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = Query as Decoder<Query>
+    registrationDomains = [... new Set(Object.values(STAMHOOFD.domains.registration ?? {}))]
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "GET") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/organization-from-domain", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        // Clean up google translate domains -> make sure we can translate register pages
+        request.query.domain = GoogleTranslateHelper.getDomainFromTranslateDomain(request.query.domain)
+
+        for (const domain of this.registrationDomains) {
+            if (request.query.domain.endsWith("." + domain)) {
+                const strippped = request.query.domain.substr(0, request.query.domain.length - ("." + domain).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
+                    })
+                }
+                return new Response(await organization.getStructure());
+            }
+        }
+
+        // Check if we have an organization with a custom domain name
+
+        const organization = await Organization.getByRegisterDomain(request.query.domain)
+
+        if (!organization) {
+            throw new SimpleError({
+                code: "unknown_organization",
+                message: "No organization registered with this domain name",
+                statusCode: 404
+            })
+        }
+        return new Response(await organization.getStructure());
+    }
+}

package/src/endpoints/global/organizations/GetOrganizationFromUriEndpoint.ts

@@ -0,0 +1,49 @@
+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 { Organization as OrganizationStruct } from "@stamhoofd/structures";
+import { GoogleTranslateHelper } from "@stamhoofd/utility";
+type Params = Record<string, never>;
+
+class Query extends AutoEncoder {
+    @field({ decoder: StringDecoder })
+    uri: string;
+}
+
+type Body = undefined
+type ResponseBody = OrganizationStruct;
+
+/**
+ * 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 GetOrganizationFromUriEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = Query as Decoder<Query>
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "GET") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/organization-from-uri", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Organization.getByURI(request.query.uri)
+
+        if (!organization) {
+            throw new SimpleError({
+                code: "unknown_organization",
+                message: "No organization registered with this uri",
+                statusCode: 404
+            })
+        }
+        return new Response(await organization.getStructure());
+    }
+}

package/src/endpoints/global/organizations/SearchOrganizationEndpoint.test.ts

@@ -0,0 +1,58 @@
+import { Request } from "@simonbackx/simple-endpoints";
+import { OrganizationFactory } from '@stamhoofd/models';
+import { OrganizationSimple } from '@stamhoofd/structures';
+import { v4 as uuidv4 } from "uuid";
+
+import { testServer } from '../../../../tests/helpers/TestServer';
+import { SearchOrganizationEndpoint } from "./SearchOrganizationEndpoint";
+
+describe("Endpoint.SearchOrganization", () => {
+    // Test endpoint
+    const endpoint = new SearchOrganizationEndpoint();
+
+    test("Search for a given organization using exact search", async () => {
+        const organization = await new OrganizationFactory({
+            name: (uuidv4()).replace(/-/g, "")
+        }).create()
+
+        const r = Request.buildJson("GET", "/v19/organizations/search");
+        r.query = {
+            query: organization.name
+        };
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(1)
+
+        // Access token should be expired
+        expect(response.body[0]).toBeInstanceOf(OrganizationSimple);
+        expect(response.status).toEqual(200);
+        expect(response.body[0]).toMatchObject({
+            id: organization.id,
+            name: organization.name,
+            address: organization.address
+        })
+    });
+
+    test("Search for a given organization on city name using exact search", async () => {
+        const city = uuidv4()
+        const organizations = await new OrganizationFactory({
+            city
+        }).createMultiple(2)
+
+        const r = Request.buildJson("GET", "/v1/organizations/search");
+        r.query = {
+            query: city
+        };
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(2)
+
+        // Access token should be expired
+        expect(response.body[0]).toBeInstanceOf(OrganizationSimple);
+        expect(response.body[1]).toBeInstanceOf(OrganizationSimple);
+        expect(response.status).toEqual(200);
+        expect(response.body.map(o => o.id).sort()).toEqual(organizations.map(o => o.id).sort())
+    });
+});

package/src/endpoints/global/organizations/SearchOrganizationEndpoint.ts

@@ -0,0 +1,62 @@
+import { AutoEncoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { Organization } from "@stamhoofd/models";
+import { Organization as OrganizationStruct,OrganizationSimple } from "@stamhoofd/structures"; 
+
+type Params = Record<string, never>;
+
+class Query extends AutoEncoder {
+    @field({ decoder: StringDecoder })
+    query: string
+}
+
+type Body = undefined;
+type ResponseBody = (OrganizationSimple | OrganizationStruct)[]
+
+export class SearchOrganizationEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    protected queryDecoder = Query as Decoder<Query>
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "GET") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/organizations/search", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        // Escape query
+        const query = request.query.query.replace(/([-+><()~*"@\s]+)/g, " ").replace(/[^\w\d]+$/, "")
+        if (query.length == 0) {
+            // Do not try searching...
+            return new Response([])
+        }
+
+        const match = {
+            sign: "MATCH",
+            value: query + "*", // We replace special operators in boolean mode with spaces since special characters aren't indexed anyway
+            mode: "BOOLEAN"
+        };
+
+        // We had to add an order by in the query to fix the limit. MySQL doesn't want to limit the results correctly if we don't explicitly sort the results on their relevance
+        const organizations = await Organization.where({ searchIndex: match }, {
+            limit: 15,
+            sort: [
+                {
+                    column: { searchIndex: match },
+                    direction: "DESC"
+                }
+            ]
+        });
+        
+        if (request.request.getVersion() < 169) {
+            return new Response(organizations.map(o => OrganizationSimple.create(o)));
+        }
+        return new Response(await Promise.all(organizations.map(o => o.getStructure())));
+    }
+}