@stamhoofd/models 2.1.1

package/src/models/Webshop.ts

@@ -0,0 +1,206 @@
+import { column, Database, ManyToOneRelation, Model } from "@simonbackx/simple-database";
+import { ArrayDecoder } from '@simonbackx/simple-encoding';
+import { Category, DNSRecordStatus, Product, WebshopMetaData, WebshopPrivateMetaData, WebshopServerMetaData } from '@stamhoofd/structures';
+import { v4 as uuidv4 } from "uuid";
+import { validateDNSRecords } from "../helpers/DNSValidator";
+
+import { Organization } from './';
+
+export class Webshop extends Model {
+    static table = "webshops";
+
+    // Columns
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ foreignKey: Webshop.organization, type: "string" })
+    organizationId: string;
+    
+    // A custom domain name that is used to host the webshop application (should be unique)
+    // E.g. webshop.scoutswetteren.be
+    @column({ type: "string", nullable: true })
+    domain: string | null = null;
+
+    // If a domain is used, the optional suffix on that domain
+    // E.g. webshop.scoutswetteren.be/wafelbak
+    @column({ type: "string", nullable: true })
+    domainUri: string | null = null;
+
+    // Unique representation of this webshop from a string, that is used to provide the default domains
+    // in shop.stamhoofd.be/uri, and stamhoofd.be/shop/uri
+    @column({ type: "string" })
+    uri: string;
+
+    // Old uri format, which was only unique on a per-organization basis
+    // in org.stamhoofd.shop/legacyUri
+    @column({ type: "string", nullable: true })
+    legacyUri: string | null = null;
+
+    /**
+     * Public meta data
+     */
+    @column({ type: "json", decoder: WebshopMetaData })
+    meta: WebshopMetaData = WebshopMetaData.create({})
+
+    /**
+     * Data only accessible by the owners / users with special permissions
+     */
+    @column({ type: "json", decoder: WebshopPrivateMetaData })
+    privateMeta: WebshopPrivateMetaData = WebshopPrivateMetaData.create({})
+
+    /**
+     * Data only accessible by the server
+     */
+    @column({ type: "json", decoder: WebshopServerMetaData })
+    serverMeta: WebshopServerMetaData = WebshopServerMetaData.create({})
+
+
+    /**
+     * Contains all the products
+     */
+    @column({ type: "json", decoder: new ArrayDecoder(Product) })
+    products: Product[] = [];
+
+    /**
+     * Contains all the categories in the right order
+     */
+    @column({ type: "json", decoder: new ArrayDecoder(Category) })
+    categories: Category[] = [];
+
+    @column({
+        type: "datetime", beforeSave(old?: any) {
+            if (old !== undefined) {
+                return old;
+            }
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        }
+    })
+    createdAt: Date
+
+    @column({
+        type: "datetime", beforeSave() {
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        },
+        skipUpdate: true
+    })
+    updatedAt: Date
+
+    static organization = new ManyToOneRelation(Organization, "organization");
+
+    // Methods
+    static async getByLegacyURI(organizationId: string, uri: string): Promise<Webshop | undefined> {
+        const [rows] = await Database.select(
+            `SELECT ${this.getDefaultSelect()} FROM ${this.table} WHERE \`organizationId\` = ? AND \`legacyUri\` = ? LIMIT 1`,
+            [organizationId, uri]
+        );
+
+        if (rows.length == 0) {
+            return undefined;
+        }
+
+        // Read member + address from first row
+        return this.fromRow(rows[0][this.table]);
+    }
+
+    // Methods
+    static async getByURI(uri: string): Promise<Webshop | undefined> {
+        const [rows] = await Database.select(
+            `SELECT ${this.getDefaultSelect()} FROM ${this.table} WHERE \`uri\` = ? LIMIT 1`,
+            [uri]
+        );
+
+        if (rows.length == 0) {
+            return undefined;
+        }
+
+        // Read member + address from first row
+        return this.fromRow(rows[0][this.table]);
+    }
+
+    // Methods
+    static async getByDomainOnly(host: string): Promise<Webshop[]> {
+        const [rows] = await Database.select(
+            `SELECT ${this.getDefaultSelect()} FROM ${this.table} WHERE \`domain\` = ? LIMIT 200`,
+            [host]
+        );
+
+        // Read member + address from first row
+        return this.fromRows(rows, this.table);
+    }
+
+    // Methods
+    static async getByDomain(host: string, uri: string | null): Promise<Webshop | undefined> {
+        if (uri === null || uri.length == 0) {
+            const [rows] = await Database.select(
+                `SELECT ${this.getDefaultSelect()} FROM ${this.table} WHERE \`domain\` = ? AND (\`domainUri\` is null OR \`domainUri\` = "") LIMIT 1`,
+                [host]
+            );
+
+            if (rows.length == 0) {
+                return undefined;
+            }
+
+            // Read member + address from first row
+            return this.fromRow(rows[0][this.table]);
+        }
+        const [rows] = await Database.select(
+            `SELECT ${this.getDefaultSelect()} FROM ${this.table} WHERE \`domain\` = ? AND \`domainUri\` = ? LIMIT 1`,
+            [host, uri]
+        );
+
+        if (rows.length == 0) {
+            return undefined;
+        }
+
+        // Read member + address from first row
+        return this.fromRow(rows[0][this.table]);
+    }
+
+    // Return the location of the webshop
+    getHost(this: Webshop & { organization: Organization }) {
+        if (this.domain && this.meta.domainActive) {
+            if (this.domainUri) {
+                return this.domain+"/"+this.domainUri
+            }
+            return this.domain
+        }
+
+        const domain = STAMHOOFD.domains.webshop[this.organization.address.country] ?? STAMHOOFD.domains.webshop[""];
+        return domain+"/"+this.uri
+    }
+
+    async updateDNSRecords(background = false) {
+        // Check initial status
+        let isValidRecords = true
+        for (const record of this.privateMeta.dnsRecords) {
+            if (record.status != DNSRecordStatus.Valid) {
+                isValidRecords = false
+            }
+        }
+
+        let { allValid } = await validateDNSRecords(this.privateMeta.dnsRecords)
+
+        if (STAMHOOFD.environment === "development" || STAMHOOFD.environment === "staging") {
+            allValid = true
+        }
+
+        if (allValid) {
+            if (!this.meta.domainActive && background) {
+                // TODO: send an email
+                // + prevent ping pong emails when the dns is not workign properly
+            }
+            this.meta.domainActive = true
+        } else {
+            this.meta.domainActive = false
+        }
+        await this.save()
+    }
+}

package/src/models/WebshopDiscountCode.ts

@@ -0,0 +1,81 @@
+import { column, Model } from "@simonbackx/simple-database";
+import { ArrayDecoder } from '@simonbackx/simple-encoding';
+import { Discount, DiscountCode } from '@stamhoofd/structures';
+import { v4 as uuidv4 } from "uuid";
+
+export class WebshopDiscountCode extends Model {
+    static table = "webshop_discount_codes";
+
+    // Columns
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ type: "string" })
+    organizationId: string;
+
+    @column({ type: "string" })
+    webshopId: string;
+
+    @column({ type: "string" })
+    code: string;
+
+    @column({ type: "string" })
+    description = ''
+    
+    @column({ type: "json", decoder: new ArrayDecoder(Discount) })
+    discounts: Discount[] = []
+
+    @column({ type: "integer" })
+    usageCount = 0
+
+    @column({ type: "integer", nullable: true })
+    maximumUsage: number|null = null
+
+    @column({
+        type: "datetime", beforeSave(old?: any) {
+            if (old !== undefined) {
+                return old;
+            }
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        }
+    })
+    createdAt: Date
+
+    @column({
+        type: "datetime", beforeSave() {
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        },
+        skipUpdate: true
+    })
+    updatedAt: Date
+
+    getStructure(): DiscountCode {
+        return DiscountCode.create(this)
+    }
+
+    static async getActiveCodes(webshopId: string, codes: string[]) {
+        if (codes.length === 0) {
+            return [];
+        }
+
+        let models = await WebshopDiscountCode.where({
+            webshopId,
+            code: {
+                sign: 'IN',
+                value: codes
+            }
+        });
+
+        // Remove used discount codes
+        models = models.filter(c => c.maximumUsage === null || c.maximumUsage > c.usageCount)
+        return models;
+    }
+}

package/src/models/addresses/City.ts

@@ -0,0 +1,31 @@
+import { column,ManyToOneRelation,Model } from '@simonbackx/simple-database';
+import { Country } from '@stamhoofd/structures';
+import { v4 as uuidv4 } from "uuid";
+
+import { Province } from './Province';
+
+export class City extends Model {
+    static table = "cities"
+
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ type: "string" })
+    name: string;
+
+    @column({ type: "string", foreignKey: City.province })
+    provinceId: string;
+
+    @column({ type: "string", foreignKey: City.parentCity, nullable: true })
+    parentCityId: string | null = null;
+
+    @column({ type: "string" })
+    country: Country;
+
+    static parentCity = new ManyToOneRelation(City, "parentCity")
+    static province = new ManyToOneRelation(Province, "province")
+}

package/src/models/addresses/PostalCode.test.ts

@@ -0,0 +1,117 @@
+import { Country } from "@stamhoofd/structures";
+
+import { City } from "./City";
+import { PostalCode } from './PostalCode';
+import { Province } from './Province';
+
+
+describe("Model.PostalCode", () => {
+    let oostVlaanderen!: Province;
+    let gent!: City;
+    let mariakerke!: City;
+
+    let wetteren!: City;
+    let massemen!: City;
+
+    let gentZip!: PostalCode;
+    let mariakerkeZip!: PostalCode;
+
+    let wetterenZip!: PostalCode;
+    let massemenZip!: PostalCode;
+
+    beforeAll(async () => {
+        oostVlaanderen = new Province()
+        oostVlaanderen.name = "Oost-Vlaanderen"
+        oostVlaanderen.country = Country.Belgium
+        await oostVlaanderen.save()
+
+        // Create some cities
+        gent = new City()
+        gent.name = "Gent"
+        gent.provinceId = oostVlaanderen.id
+        gent.country = Country.Belgium
+        await gent.save()
+
+        // Create some cities
+        mariakerke = new City()
+        mariakerke.name = "Mariakerke"
+        mariakerke.provinceId = oostVlaanderen.id
+        mariakerke.parentCityId = gent.id
+        mariakerke.country = Country.Belgium
+        await mariakerke.save()
+
+        // Create some cities
+        wetteren = new City()
+        wetteren.name = "Wetteren"
+        wetteren.provinceId = oostVlaanderen.id
+        wetteren.country = Country.Belgium
+        await wetteren.save()
+
+        // Create some cities
+        massemen = new City()
+        massemen.name = "Massemen"
+        massemen.provinceId = oostVlaanderen.id
+        massemen.parentCityId = wetteren.id
+        massemen.country = Country.Belgium
+        await massemen.save()
+
+        // Create postal codes
+        gentZip = new PostalCode()
+        gentZip.postalCode = "9000"
+        gentZip.cityId = gent.id
+        gentZip.country = Country.Belgium
+        await gentZip.save()
+
+        // Create postal codes
+        mariakerkeZip = new PostalCode()
+        mariakerkeZip.postalCode = "9030"
+        mariakerkeZip.cityId = mariakerke.id
+        mariakerkeZip.country = Country.Belgium
+        await mariakerkeZip.save()
+
+        // Create postal codes
+        wetterenZip = new PostalCode()
+        wetterenZip.postalCode = "9230"
+        wetterenZip.cityId = wetteren.id
+        wetterenZip.country = Country.Belgium
+        await wetterenZip.save()
+
+        // Create postal codes
+        massemenZip = new PostalCode()
+        massemenZip.postalCode = "9230"
+        massemenZip.cityId = massemen.id
+        massemenZip.country = Country.Belgium
+        await massemenZip.save()
+    });
+
+    test("Normal flow", async () => {
+        const test = await PostalCode.getCity("9000", "Gent", Country.Belgium);
+        expect(test).toMatchObject(gent)
+    });
+
+    test("Entering the postal code of the parent city works", async () => {
+        const test = await PostalCode.getCity("9000", "Mariakerke", Country.Belgium);
+        expect(test).toMatchObject(gent)
+    });
+
+     test("Entering the postal code of a child city works", async () => {
+        const test = await PostalCode.getCity("9030", "Gent", Country.Belgium);
+        expect(test).toMatchObject(mariakerke)
+    });
+
+    test("Search normal", async () => {
+        const test = await PostalCode.getCity("9230", "Wetteren", Country.Belgium);
+        expect(test).toMatchObject(wetteren)
+
+        const test2 = await PostalCode.getCity("9230", "Massemen", Country.Belgium);
+        expect(test2).toMatchObject(massemen)
+    });
+
+    test("Allow typo", async () => {
+        const test = await PostalCode.getCity("9230", "Wettern", Country.Belgium);
+        expect(test).toMatchObject(wetteren)
+
+        const test2 = await PostalCode.getCity("9230", "Masemen", Country.Belgium);
+        expect(test2).toMatchObject(massemen)
+    });
+});

package/src/models/addresses/PostalCode.ts

@@ -0,0 +1,164 @@
+import { column,Database,ManyToOneRelation,Model } from '@simonbackx/simple-database';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Country } from '@stamhoofd/structures';
+import { Formatter, StringCompare } from '@stamhoofd/utility';
+import { v4 as uuidv4 } from "uuid";
+
+import { City } from './City';
+
+export class PostalCode extends Model {
+    static table = "postal_codes"
+
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ type: "string" })
+    postalCode: string;
+
+    @column({ type: "string", foreignKey: PostalCode.city })
+    cityId: string;
+
+    @column({ type: "string" })
+    country: Country;
+
+    static city = new ManyToOneRelation(City, "city")
+
+    /**
+     * Search for a given city via it's postal code and country, collecting information about the city (id), parentCity (id) and province (id)
+     */
+    static async getCity(postalCode: string, cityName: string, country: Country): Promise<City | null> {
+        let query = `SELECT ${City.getDefaultSelect()}from \`${PostalCode.table}\`\n`;
+        query += `JOIN \`${City.table}\` ON \`${PostalCode.table}\`.\`${PostalCode.city.foreignKey}\` = \`${City.table}\`.\`${City.primary.name}\`\n`
+
+        // We do an extra join because we also need to get the other registrations of each member (only one regitration has to match the query)
+        query += `where \`${PostalCode.table}\`.\`postalCode\` = ? AND \`${PostalCode.table}\`.\`country\` = ?`
+
+        const [results] = await Database.select(query, [postalCode, country])
+
+        const cities = City.fromRows(results, City.table)
+
+        if (cities.length == 1) {
+            return cities[0]
+        }
+
+        // Search by city name (first exact match, then allow errors)
+        let bestScore = 0
+        let bestCity: City | null = null
+
+        for (const city of cities) {
+            const typo = StringCompare.typoCount(cityName, city.name)
+            if (typo == 0) {
+                return city
+            }
+
+            if (bestCity === null || typo < bestScore) {
+                bestCity = city
+                bestScore = typo
+            }
+        }
+
+        if (bestCity && (bestScore < 3 || StringCompare.contains(cityName, bestCity.name) || StringCompare.contains(bestCity.name, cityName))) {
+            return bestCity
+        }
+
+        bestScore = 0
+        bestCity = null
+
+        for (const city of cities) {
+            const match = StringCompare.matchCount(cityName, city.name)
+
+            if (bestCity === null || match > bestScore) {
+                bestCity = city
+                bestScore = match
+            }
+        }
+
+        if (bestCity && (bestScore > cityName.length/2 || StringCompare.contains(cityName, bestCity.name))) {
+            return bestCity
+        }
+
+        if (cities.length >= 1 && cities[0].parentCityId !== null && cities.every(c => c.parentCityId === cities[0].parentCityId)) {
+            // Might have put a postal code of the parent city
+            const parent = await City.getByID(cities[0].parentCityId)
+            if (parent) {
+                const typo = StringCompare.typoCount(cityName, parent.name)
+                if (typo < 4 || StringCompare.contains(cityName, parent.name)) {
+                    if (cities.length > 1) {
+                        throw new SimpleError({
+                            code: "invalid_field",
+                            message: "Invalid city. Suggestions: " + Formatter.joinLast(cities.map(c => c.name), ", ", " of ") + "?",
+                            human: "Welke gemeente bedoel je precies? " + Formatter.joinLast(cities.map(c => c.name), ", ", " of ") + "?",
+                            field: "city"
+                        })
+                    }
+                    return cities[0] // do not return parent here, because the postal code has priority
+                }
+            }
+        }
+
+        // Search parent in belgium only
+        if (country == Country.Belgium) {
+            return this.getCityByParent(postalCode, cityName, country)
+        }
+
+        return null;
+    }
+
+    /**
+     * Search for a given city via it's postal code and country, collecting information about the city (id), parentCity (id) and province (id)
+     */
+    static async getCityByParent(postalCode: string, cityName: string, country: Country): Promise<City | null> {
+        let query = `SELECT ${City.getDefaultSelect()}from \`${PostalCode.table}\`\n`;
+        query += `JOIN \`${City.table}\` as parent ON \`${PostalCode.table}\`.\`${PostalCode.city.foreignKey}\` = \`parent\`.\`${City.primary.name}\`\n`
+        query += `JOIN \`${City.table}\` ON \`parent\`.\`${City.primary.name}\` = \`${City.table}\`.\`${City.parentCity.foreignKey}\`\n`
+
+        // We do an extra join because we also need to get the other registrations of each member (only one regitration has to match the query)
+        query += `where \`${PostalCode.table}\`.\`postalCode\` = ? AND \`${PostalCode.table}\`.\`country\` = ?`
+
+        const [results] = await Database.select(query, [postalCode, country])
+
+        const cities = City.fromRows(results, City.table)
+
+        // Search by city name (first exact match, then allow errors)
+        let bestScore = 0
+        let bestCity: City | null = null
+
+        for (const city of cities) {
+            const typo = StringCompare.typoCount(cityName, city.name)
+            if (typo == 0) {
+                return city
+            }
+
+            if (bestCity === null || typo < bestScore) {
+                bestCity = city
+                bestScore = typo
+            }
+        }
+
+        if (bestCity && (bestScore < 3 || StringCompare.contains(cityName, bestCity.name) || StringCompare.contains(bestCity.name, cityName))) {
+            return bestCity
+        }
+
+        bestScore = 0
+        bestCity = null
+
+        for (const city of cities) {
+            const match = StringCompare.matchCount(cityName, city.name)
+
+            if (bestCity === null || match > bestScore) {
+                bestCity = city
+                bestScore = match
+            }
+        }
+
+        if (bestCity && (bestScore > cityName.length/2 || StringCompare.contains(cityName, bestCity.name))) {
+            return bestCity
+        }
+
+        return null;
+    }
+}

package/src/models/addresses/Province.ts

@@ -0,0 +1,20 @@
+import { column,Model } from '@simonbackx/simple-database';
+import { Country } from '@stamhoofd/structures';
+import { v4 as uuidv4 } from "uuid";
+
+export class Province extends Model {
+    static table = "provinces"
+
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ type: "string" })
+    name: string;
+
+    @column({ type: "string" })
+    country: Country;
+}

package/src/models/addresses/Street.ts

@@ -0,0 +1,25 @@
+import { column, ManyToOneRelation, Model } from '@simonbackx/simple-database';
+import { v4 as uuidv4 } from "uuid";
+
+import { City } from './City';
+
+export class Street extends Model {
+    static table = "streets"
+
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+    
+    @column({ type: "string" })
+    name: string;
+    
+    @column({ type: "string", foreignKey: Street.city })
+    cityId: string;
+
+    static city = new ManyToOneRelation(City, "city")
+
+    
+}

package/src/models/index.ts

@@ -0,0 +1,49 @@
+/* eslint-disable simple-import-sort/exports */
+export {Organization} from "./Organization"
+export {User} from "./User"
+export {Payment} from "./Payment"
+export {Registration} from "./Registration"
+export {Member, RegistrationWithMember, MemberWithRegistrations} from "./Member"
+
+export * from "./EmailVerificationCode"
+
+export * from "./Image"
+export * from "./MolliePayment"
+export * from "./MollieToken"
+export {Order} from "./Order"
+export * from "./PasswordToken"
+export * from "./PayconiqPayment"
+export * from "./RegisterCode"
+export * from "./STInvoice"
+export * from "./STPackage"
+export {STPendingInvoice} from "./STPendingInvoice"
+export {Token, TokenWithUser} from "./Token"
+export * from "./Webshop"
+export * from "./STCredit"
+export * from "./UsedRegisterCode"
+export * from "./Ticket"
+export * from "./EmailTemplate"
+export * from "./BuckarooPayment"
+export {BalanceItem} from "./BalanceItem"
+export {BalanceItemPayment} from "./BalanceItemPayment"
+export {Group} from "./Group"
+
+export * from "./addresses/Street"
+export * from "./addresses/City"
+export * from "./addresses/PostalCode"
+export * from "./addresses/Province"
+
+export * from "./StripeAccount"
+export * from "./StripePaymentIntent"
+export * from "./StripeCheckoutSession"
+
+export * from "./Document"
+export * from "./DocumentTemplate"
+
+export * from "./WebshopDiscountCode"
+
+export * from "./Platform"
+export * from "./MemberResponsibilityRecord"
+
+export * from "./OrganizationRegistrationPeriod"
+export * from "./RegistrationPeriod"