@stamhoofd/models 2.120.6 → 2.122.0

package/src/helpers/InvoiceCounter.ts

@@ -0,0 +1,162 @@
+import { QueueHandler } from '@stamhoofd/queues';
+
+import type { OrganizationInvoiceSettings } from '@stamhoofd/structures/OrganizationInvoiceSettings.js';
+import { Formatter } from '@stamhoofd/utility';
+import type { DateTime } from 'luxon';
+import { Invoice } from '../models/Invoice.js';
+
+export class InvoiceCounter {
+    static numberCache: Map<string, {lastNumber: number, date: Date}> = new Map();
+
+
+    private static getNextResetDate(last: DateTime, resetMonth: number): DateTime {
+        const candidate = last.set({ month: resetMonth, day: 1 }).startOf('day');
+        return candidate > last ? candidate : candidate.plus({ years: 1 }).startOf('day');
+    }
+
+    static shouldStartNewSeries(settings: OrganizationInvoiceSettings, lastInvoiceDate: Date, invoiceDate: Date) {
+        if (settings.resetMonth === null) {
+            return false;
+        }
+
+        const last = Formatter.luxon(lastInvoiceDate);
+        const current = Formatter.luxon(invoiceDate);
+
+        return current >= this.getNextResetDate(last, settings.resetMonth)
+    }
+
+    /**
+     * XXX-123 -> 123
+     * YYY-0001 -> 1
+     * 
+     * if prefix is enabled:
+     * 2025001 -> 1
+     * STA-2025001 -> 1
+     */
+    static parseNumber(settings: OrganizationInvoiceSettings, str: string) {
+        str = str.replace(/\D+/g, '-').replace(/^-+/, '').replace(/-+$/, '');
+        // Remove prefixes and possibly year
+        const splitted = str.split('-');
+
+        let last = splitted[splitted.length - 1];
+
+        const stripYear = settings.prefixYear
+
+        if (last.length) {
+            if (stripYear) {
+                if (last.length <= 4) {
+                    console.error('Could not parse invoice number from string ' + str + ' (could not trim year prefix)')
+                    return null;
+                }
+                last = last.substring(4)
+            }
+
+            const int = parseInt(last);
+            if (int !== 0 && !isNaN(int) && isFinite(int)) {
+                return int;
+            }
+        }
+
+        console.error('Could not parse invoice number from string ' + str)
+        return null;
+    }
+
+    static formatNumber(settings: OrganizationInvoiceSettings, int: number, invoicedAt: Date) {
+        let str = int.toFixed(0).padStart(settings.padZeroLength, '0')
+
+        if (settings.prefixYear) {
+            const year = Formatter.luxon(invoicedAt).year
+            str = year + str;
+        }
+
+        if (settings.fixedPrefix) {
+            if (!settings.fixedPrefix.match(/\D$/)) {
+                // Need seperation character
+                str = settings.fixedPrefix.replace(/-$/, '') + '-' + str;
+            } else {
+                str = settings.fixedPrefix +  str;
+            }
+        }
+
+        return str;
+    }
+
+    static async assignNextNumber(invoice: Invoice, settings: OrganizationInvoiceSettings): Promise<void> {
+        const organizationId = invoice.organizationId
+        return await QueueHandler.schedule('invoice/numbers-' + organizationId, async () => {
+            // Invoice date should be inside the queue to ensure it is chronologically generated
+            const invoicedAt = new Date();
+
+            const c = this.numberCache.get(organizationId);
+            if (c !== undefined) {
+                const lastNumber = c.lastNumber
+
+                // check date
+                if (!this.shouldStartNewSeries(settings, c.date, invoicedAt)) {
+                    // Set and save.
+                    // we do this here because it assures we'll not increase the next number if the save fails
+                    invoice.number = this.formatNumber(settings, lastNumber + 1, invoicedAt);
+                    invoice.invoicedAt = invoicedAt;
+                    await invoice.save()
+
+                    // If save succeeds, increase cache:
+                    this.numberCache.set(organizationId, {
+                        lastNumber: lastNumber + 1,
+                        date: new Date(invoicedAt)
+                    });
+                    return
+                }
+            }
+
+            const lastInvoice = await Invoice.select()
+                    .where('organizationId', organizationId)
+                    .where('number', '!=', null)
+                    .where('invoicedAt', '!=', null)
+                    .orderBy('invoicedAt', 'DESC')
+                    .first(false);
+
+            if (lastInvoice && lastInvoice.number && lastInvoice.invoicedAt) {
+                // check date
+                if (!this.shouldStartNewSeries(settings, lastInvoice.invoicedAt, invoicedAt)) {
+                    const lastNumber = this.parseNumber(settings, lastInvoice.number)
+
+                    if (lastNumber) {
+                        invoice.number = this.formatNumber(settings, lastNumber + 1, invoicedAt);
+                        invoice.invoicedAt = invoicedAt;
+                        await invoice.save()
+                        
+                        this.numberCache.set(organizationId, {
+                            lastNumber: lastNumber + 1,
+                            date: new Date(invoicedAt)
+                        });
+                        return;
+                    }
+                }
+            }
+
+            // Start new
+            invoice.number = this.formatNumber(settings, 1, invoicedAt);
+            invoice.invoicedAt = invoicedAt;
+            await invoice.save()
+            
+            this.numberCache.set(organizationId, {
+                lastNumber: 1,
+                date: new Date(invoicedAt)
+            });
+            return;
+        });
+    }
+
+    static async resetNumbers(organizationId: string): Promise<void> {
+        // Prevent race conditions: create a queue
+        // The queue can only run one at a time for the same webshop (so multiple webshops at the same time are allowed)
+        return await QueueHandler.schedule('invoice/numbers-' + organizationId, async () => {
+            this.numberCache.delete(organizationId);
+            return Promise.resolve();
+        });
+    }
+
+    static clearAll() {
+        this.numberCache.clear();
+    }
+}

package/src/index.ts

@@ -1,6 +1,5 @@
 // Helpers
 export * from './helpers/EmailBuilder.js';
-export * from './helpers/MemberMerger.js';
 export * from './helpers/RateLimiter.js';
 export * from './helpers/WebshopCounter.js';
 

package/src/migrations/1605262045-import-postcodes.ts

@@ -1,7 +1,8 @@
-import { column, Migration } from '@simonbackx/simple-database';
+import { column, Database, Migration } from '@simonbackx/simple-database';
 import { QueryableModel } from '@stamhoofd/sql';
 import { Country } from '@stamhoofd/types/Country';
 import { StringCompare } from '@stamhoofd/utility';
+import { v4 as uuidv4 } from 'uuid';
 import { City } from '../models/addresses/City.js';
 import { PostalCode } from '../models/addresses/PostalCode.js';
 import { Province } from '../models/addresses/Province.js';
@@ -33,16 +34,17 @@ export class Gemeente extends QueryableModel {
     city!: City;
 }
 
-async function getProvince(name: string, provinces: Province[]): Promise<Province> {
+function getProvince(name: string, provinces: Province[], provinceRows: string[][]): Province {
     const p = provinces.find(p => StringCompare.typoCount(p.name, name) < 2 && p.country == Country.Belgium);
     if (p) {
         return p;
     }
     const province = new Province();
+    province.id = uuidv4();
     province.country = Country.Belgium;
     province.name = name.trim();
-    await province.save();
     provinces.push(province);
+    provinceRows.push([province.id, province.name, province.country]);
     return province;
 }
 
@@ -54,42 +56,38 @@ export default new Migration(async () => {
     // Loop all gemeenten
     const provinces = await Province.all();
     const gemeenten = await Gemeente.all();
-    const cities: City[] = [];
+    const citiesByNameAndProvince = new Map<string, City>();
+    const provinceRows: string[][] = [];
+    const cityRows: unknown[][] = [];
+    const postalCodeRows: string[][] = [];
+    const parentCityUpdates = new Map<string, string>();
 
     for (const gemeente of gemeenten) {
-        const province = await getProvince(gemeente.provincie, provinces);
+        const province = getProvince(gemeente.provincie, provinces, provinceRows);
 
         // Some cities have the same name
-        const found = cities.find(c => c.name.trim() == gemeente.gemeente.trim() && c.provinceId == province.id);
+        const found = citiesByNameAndProvince.get(cityKey(gemeente.gemeente, province.id));
 
         if (!found) {
             // Create the city
             const city = new City();
+            city.id = uuidv4();
             city.name = gemeente.gemeente.trim();
             city.country = Country.Belgium;
             city.provinceId = province.id;
-
-            await city.save();
+            cityRows.push([city.id, city.name, city.provinceId, city.parentCityId, city.country]);
 
             // Also add postal code already
-            const postalCode = new PostalCode();
-            postalCode.postalCode = gemeente.postcode;
-            postalCode.cityId = city.id;
-            postalCode.country = Country.Belgium;
-            await postalCode.save();
+            postalCodeRows.push([uuidv4(), gemeente.postcode, city.id, Country.Belgium]);
 
             gemeente.city = city;
-            cities.push(city);
+            citiesByNameAndProvince.set(cityKey(city.name, city.provinceId), city);
         }
         else {
             gemeente.city = found;
 
             // Also add postal code already
-            const postalCode = new PostalCode();
-            postalCode.postalCode = gemeente.postcode;
-            postalCode.cityId = found.id;
-            postalCode.country = Country.Belgium;
-            await postalCode.save();
+            postalCodeRows.push([uuidv4(), gemeente.postcode, found.id, Country.Belgium]);
         }
     }
 
@@ -98,28 +96,67 @@ export default new Migration(async () => {
             continue;
         }
 
-        const hoofd = cities.find(c => c.name.trim() == gemeente.hoofdgemeente.trim() && c.provinceId == gemeente.city.provinceId);
+        const hoofd = citiesByNameAndProvince.get(cityKey(gemeente.hoofdgemeente, gemeente.city.provinceId));
         if (!hoofd) {
             // Create the city
             const city = new City();
+            city.id = uuidv4();
             city.name = gemeente.hoofdgemeente.trim();
             city.country = Country.Belgium;
 
-            const province = await getProvince(gemeente.provincie, provinces);
+            const province = getProvince(gemeente.provincie, provinces, provinceRows);
             city.provinceId = province.id;
-            await city.save();
+            cityRows.push([city.id, city.name, city.provinceId, city.parentCityId, city.country]);
 
-            cities.push(city);
+            citiesByNameAndProvince.set(cityKey(city.name, city.provinceId), city);
             // do not create a postal code here, these don't have one
 
             // console.log('Assigning ' + gemeente.gemeente + ' to ' + city.name);
             gemeente.city.parentCityId = city.id;
-            await gemeente.city.save();
+            parentCityUpdates.set(gemeente.city.id, city.id);
         }
         else {
             // console.log('Assigning ' + gemeente.gemeente + ' to ' + hoofd.name);
             gemeente.city.parentCityId = hoofd.id;
-            await gemeente.city.save();
+            parentCityUpdates.set(gemeente.city.id, hoofd.id);
         }
     }
+
+    await insertRows(Province.table, ['id', 'name', 'country'], provinceRows);
+    await insertRows(City.table, ['id', 'name', 'provinceId', 'parentCityId', 'country'], cityRows);
+    await insertRows(PostalCode.table, ['id', 'postalCode', 'cityId', 'country'], postalCodeRows);
+    await updateParentCityIds([...parentCityUpdates.entries()]);
 });
+function cityKey(name: string, provinceId: string): string {
+    return `${name.trim()}\0${provinceId}`;
+}
+
+async function insertRows(table: string, columns: string[], rows: unknown[][]): Promise<void> {
+    for (const chunk of chunks(rows, 1000)) {
+        if (chunk.length === 0) {
+            continue;
+        }
+        await Database.insert(`INSERT INTO \`${table}\` (${columns.map(column => `\`${column}\``).join(', ')}) VALUES ?`, [chunk]);
+    }
+}
+
+async function updateParentCityIds(rows: string[][]): Promise<void> {
+    for (const chunk of chunks(rows, 1000)) {
+        if (chunk.length === 0) {
+            continue;
+        }
+        const cases = chunk.map(() => 'WHEN ? THEN ?').join(' ');
+        await Database.statement(`UPDATE \`${City.table}\` SET \`parentCityId\` = CASE \`id\` ${cases} END WHERE \`id\` IN (?)`, [
+            ...chunk.flatMap(([cityId, parentCityId]) => [cityId, parentCityId]),
+            chunk.map(([cityId]) => cityId),
+        ]);
+    }
+}
+
+function chunks<T>(values: T[], size: number): T[][] {
+    const result: T[][] = [];
+    for (let index = 0; index < values.length; index += size) {
+        result.push(values.slice(index, index + size));
+    }
+    return result;
+}

package/src/migrations/1605262046-import-postcodes-nl.ts

@@ -1,39 +1,42 @@
-import { Migration } from '@simonbackx/simple-database';
+import { Database, Migration } from '@simonbackx/simple-database';
 import { Country } from '@stamhoofd/types/Country';
 import { StringCompare } from '@stamhoofd/utility';
 import fs from 'fs';
 import readline from 'readline';
+import { v4 as uuidv4 } from 'uuid';
 
 import { City } from '../models/addresses/City.js';
 import { PostalCode } from '../models/addresses/PostalCode.js';
 import { Province } from '../models/addresses/Province.js';
 
-async function getProvince(name: string, provinces: Province[]): Promise<Province> {
+function getProvince(name: string, provinces: Province[], provinceRows: string[][]): Province {
     const p = provinces.find(p => StringCompare.typoCount(p.name, name) == 0 && p.country == Country.Netherlands);
     if (p) {
         return p;
     }
     const province = new Province();
+    province.id = uuidv4();
     province.country = Country.Netherlands;
     province.name = name;
-    await province.save();
 
     provinces.push(province);
+    provinceRows.push([province.id, province.name, province.country]);
     return province;
 }
 
-async function getCity(name: string, provinceId: string, cities: City[]): Promise<City> {
-    const p = cities.find(p => StringCompare.typoCount(p.name, name) == 0 && p.country == Country.Netherlands);
+function getCity(name: string, provinceId: string, citiesByName: Map<string, City>, cityRows: unknown[][]): City {
+    const p = citiesByName.get(normalizeCityName(name));
     if (p) {
         return p;
     }
     const city = new City();
+    city.id = uuidv4();
     city.name = name;
     city.country = Country.Netherlands;
     city.provinceId = provinceId;
-    await city.save();
+    cityRows.push([city.id, city.name, city.provinceId, city.parentCityId, city.country]);
 
-    cities.push(city);
+    citiesByName.set(normalizeCityName(city.name), city);
     return city;
 }
 
@@ -52,11 +55,15 @@ export default new Migration(async () => {
         });
 
     const allProvinces = await Province.where({ country: Country.Netherlands });
+    const provinceRows: string[][] = [];
+    const cityRows: unknown[][] = [];
+    const postalCodeRows: string[][] = [];
+    const parentCityUpdates: string[][] = [];
 
     for (const p of provinces) {
         // console.log(p.name);
 
-        const province = await getProvince(p.name.trim(), allProvinces);
+        const province = getProvince(p.name.trim(), allProvinces, provinceRows);
 
         // const cities = await fs.readFile(p.path, { encoding: "utf-8" });
 
@@ -64,7 +71,7 @@ export default new Migration(async () => {
             input: fs.createReadStream(p.path, { encoding: 'utf-8' }),
         });
 
-        const cities: City[] = [];
+        const citiesByName = new Map<string, City>();
 
         for await (const line of lineReader) {
             const splitted = line.split('\t');
@@ -77,19 +84,53 @@ export default new Migration(async () => {
             const plaats = splitted[2].trim();
 
             // Check plaats and gemeente
-            const city = await getCity(plaats, province.id, cities);
-            const city2 = await getCity(gemeente, province.id, cities); // might be the same as city
+            const city = getCity(plaats, province.id, citiesByName, cityRows);
+            const city2 = getCity(gemeente, province.id, citiesByName, cityRows); // might be the same as city
             if (city2.id !== city.id && city.parentCityId === null) {
                 city.parentCityId = city2.id;
-                await city.save();
+                parentCityUpdates.push([city.id, city2.id]);
             }
 
             // Also add postal code already
-            const postalCode = new PostalCode();
-            postalCode.postalCode = postcode;
-            postalCode.cityId = city.id;
-            postalCode.country = Country.Netherlands;
-            await postalCode.save();
+            postalCodeRows.push([uuidv4(), postcode, city.id, Country.Netherlands]);
         }
     }
+
+    await insertRows(Province.table, ['id', 'name', 'country'], provinceRows);
+    await insertRows(City.table, ['id', 'name', 'provinceId', 'parentCityId', 'country'], cityRows);
+    await insertRows(PostalCode.table, ['id', 'postalCode', 'cityId', 'country'], postalCodeRows);
+    await updateParentCityIds(parentCityUpdates);
 });
+function normalizeCityName(name: string): string {
+    return name.normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/\s+/, ' ').trim();
+}
+
+async function insertRows(table: string, columns: string[], rows: unknown[][]): Promise<void> {
+    for (const chunk of chunks(rows, 1000)) {
+        if (chunk.length === 0) {
+            continue;
+        }
+        await Database.insert(`INSERT INTO \`${table}\` (${columns.map(column => `\`${column}\``).join(', ')}) VALUES ?`, [chunk]);
+    }
+}
+
+async function updateParentCityIds(rows: string[][]): Promise<void> {
+    for (const chunk of chunks(rows, 1000)) {
+        if (chunk.length === 0) {
+            continue;
+        }
+        const cases = chunk.map(() => 'WHEN ? THEN ?').join(' ');
+        await Database.statement(`UPDATE \`${City.table}\` SET \`parentCityId\` = CASE \`id\` ${cases} END WHERE \`id\` IN (?)`, [
+            ...chunk.flatMap(([cityId, parentCityId]) => [cityId, parentCityId]),
+            chunk.map(([cityId]) => cityId),
+        ]);
+    }
+}
+
+function chunks<T>(values: T[], size: number): T[][] {
+    const result: T[][] = [];
+    for (let index = 0; index < values.length; index += size) {
+        result.push(values.slice(index, index + size));
+    }
+    return result;
+}

package/src/migrations/1719567881-organization-periodId.sql

@@ -1,2 +1,4 @@
+SET FOREIGN_KEY_CHECKS=0;
 ALTER TABLE `organizations` ADD COLUMN `periodId` varchar(36) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL;
 ALTER TABLE `organizations` ADD FOREIGN KEY (`periodId`) REFERENCES `registration_periods` (`id`) ON UPDATE CASCADE ON DELETE RESTRICT;
+SET FOREIGN_KEY_CHECKS=1;

package/src/migrations/1719567882-groups-periodId.sql

@@ -1,2 +1,4 @@
+SET FOREIGN_KEY_CHECKS=0;
 ALTER TABLE `groups` ADD COLUMN `periodId` varchar(36) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL;
 ALTER TABLE `groups` ADD FOREIGN KEY (`periodId`) REFERENCES `registration_periods` (`id`) ON UPDATE CASCADE ON DELETE RESTRICT;
+SET FOREIGN_KEY_CHECKS=1;

package/src/migrations/1720080975-convert-charset.ts

@@ -0,0 +1,34 @@
+import { Database, Migration } from '@simonbackx/simple-database';
+import { LoggingTools } from '@stamhoofd/utility';
+
+export default new Migration(async () => {
+    process.stdout.write('\n');
+
+    if (STAMHOOFD.userMode === 'platform' && (STAMHOOFD.environment === 'production' || STAMHOOFD.environment === 'staging')) {
+        console.log('Skipped convert charset for userMode platform in production.');
+        return;
+    }
+
+    const tables = ['_members_users', 'balance_item_payments', 'balance_items', 'buckaroo_payments', 'cities', 'document_templates', 'documents', 'email_templates', 'email_verification_codes', 'groups', 'images', 'members', 'migrations', 'mollie_payments', 'mollie_tokens', 'organization_registration_periods', 'organizations', 'password_tokens', 'payconiq_payments', 'payments', 'platform', 'postal_codes', 'provinces', 'register_codes', 'registration_periods', 'registrations', 'stamhoofd_credits', 'stamhoofd_invoices', 'stamhoofd_packages', 'stamhoofd_pending_invoices', 'streets', 'stripe_accounts', 'stripe_checkout_sessions', 'stripe_payment_intents', 'tokens', 'used_register_codes', 'users', 'webshop_discount_codes', 'webshop_orders', 'webshop_tickets', 'webshops'];
+
+    const progressLogger = LoggingTools.createProgressLogger(tables.length, { tag: 'convert tables charset' });
+
+    for (const table of tables) {
+        await convertTable(table);
+        progressLogger.update();
+    }
+
+    console.log('Start set database charset.');
+    await Database.statement('ALTER DATABASE CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;');
+});
+
+async function convertTable(name: string): Promise<void> {
+    await Database.beginTransaction(async () => {
+        await Database.statement('set foreign_key_checks=0;');
+
+        console.log('Start converting charset of table: ' + name);
+        await Database.statement('ALTER TABLE `' + name + '` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;');
+
+        await Database.statement('set foreign_key_checks=1;');
+    });
+}

package/src/migrations/1720080976-convert-charset-leads.ts

@@ -3,14 +3,14 @@ import { Database, Migration } from '@simonbackx/simple-database';
 /**
  * If the charset of the leads table is not converted this results
  * in foreign keys constraint errors in other migrations.
- * 
+ *
  * todo: will we keep the leads table after the migration?
  */
 export default new Migration(async () => {
     process.stdout.write('\n');
 
-    if (STAMHOOFD.userMode === 'platform') {
-        console.log('Skipped update leads charset for userMode platform.')
+    if (STAMHOOFD.userMode === 'platform' && (STAMHOOFD.environment === 'production' || STAMHOOFD.environment === 'staging')) {
+        console.log('Skipped update leads charset for userMode platform in production.');
         return Promise.resolve();
     }
 
@@ -18,15 +18,7 @@ export default new Migration(async () => {
     console.log('Has leads table: ' + hasTable);
 
     if (hasTable) {
-        const sqlStatement: string = [
-            'set foreign_key_checks=0;',
-            'ALTER TABLE `leads` CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;',
-            'ALTER TABLE `leads` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;',
-            'set foreign_key_checks=1;'
-        ].join('');
-
-        console.log('Start updating charset of leads table.');
-        await Database.statement(sqlStatement);
+        await convertTable('leads');
     }
 
     return Promise.resolve();
@@ -40,7 +32,7 @@ async function tableExists(tableName: string): Promise<boolean> {
         WHERE table_schema = DATABASE()
         AND table_name = ?
         `,
-        [tableName]
+        [tableName],
     );
 
     const count = rows[0]['']['count'];
@@ -51,3 +43,14 @@ async function tableExists(tableName: string): Promise<boolean> {
 
     return count > 0;
 }
+
+async function convertTable(name: string): Promise<void> {
+    await Database.beginTransaction(async () => {
+        await Database.statement('set foreign_key_checks=0;');
+
+        console.log('Start converting charset of table: ' + name);
+        await Database.statement('ALTER TABLE `' + name + '` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;');
+
+        await Database.statement('set foreign_key_checks=1;');
+    });
+}

package/src/migrations/1721400546-users-memberId.sql

@@ -1,3 +1,5 @@
+SET FOREIGN_KEY_CHECKS=0;
 ALTER TABLE `users`
 ADD COLUMN `memberId` varchar(36) NULL AFTER `id`;
 ALTER TABLE `users` ADD FOREIGN KEY (`memberId`) REFERENCES `members` (`id`) ON UPDATE CASCADE ON DELETE SET NULL;
+SET FOREIGN_KEY_CHECKS=1;

package/src/migrations/1722269236-group-waitinglist-id.sql

@@ -1,4 +1,5 @@
+SET FOREIGN_KEY_CHECKS=0;
 ALTER TABLE `groups`
 ADD COLUMN `waitingListId` varchar(36) NULL AFTER `defaultAgeGroupId`;
-
 ALTER TABLE `groups` ADD FOREIGN KEY (`waitingListId`) REFERENCES `groups` (`id`) ON UPDATE CASCADE ON DELETE SET NULL;
+SET FOREIGN_KEY_CHECKS=1;

package/src/migrations/1722525785-balance-item-paying-organization-id.sql

@@ -1,2 +1,4 @@
+SET FOREIGN_KEY_CHECKS=0;
 ALTER TABLE `balance_items` ADD COLUMN `payingOrganizationId` varchar(36) NULL;
 ALTER TABLE `balance_items` ADD FOREIGN KEY (`payingOrganizationId`) REFERENCES `organizations` (`id`) ON UPDATE CASCADE ON DELETE SET NULL;
+SET FOREIGN_KEY_CHECKS=1;

package/src/migrations/1722525787-depending-balance-item.sql

@@ -1,2 +1,4 @@
+SET FOREIGN_KEY_CHECKS=0;
 ALTER TABLE `balance_items` ADD COLUMN `dependingBalanceItemId` varchar(36) NULL;
 ALTER TABLE `balance_items` ADD FOREIGN KEY (`dependingBalanceItemId`) REFERENCES `balance_items` (`id`) ON UPDATE CASCADE ON DELETE SET NULL;
+SET FOREIGN_KEY_CHECKS=1;

package/src/migrations/1722963554-registration-group-price-and-options.sql

@@ -1,3 +1,3 @@
 ALTER TABLE `registrations`
 ADD COLUMN `options` json NOT NULL DEFAULT ('{"value": [], "version": 0}') AFTER `price`,
-ADD COLUMN `groupPrice` json NOT NULL DEFAULT ('{"value": {"id": "unknown", "name": "Onbekend", "price": {"price": 0, "reducedPrice": null}}, "version": 0}') AFTER `price`;
+ADD COLUMN `groupPrice` json NOT NULL DEFAULT ('{"value": {"id": "unknown", "name": "Standaardtarief", "price": {"price": 0, "reducedPrice": null}}, "version": 0}') AFTER `price`;

package/src/migrations/1723652797-payments-paying-organization-id-fk.sql

@@ -1,2 +1,4 @@
 
+SET FOREIGN_KEY_CHECKS=0;
 ALTER TABLE `payments` ADD FOREIGN KEY (`payingOrganizationId`) REFERENCES `organizations` (`id`) ON UPDATE CASCADE ON DELETE SET NULL;
+SET FOREIGN_KEY_CHECKS=1;

package/src/migrations/1733317908-added-missing-organization-fk-on-registrations.sql

@@ -1 +1,3 @@
+SET FOREIGN_KEY_CHECKS=0;
 ALTER TABLE `registrations` ADD FOREIGN KEY (`organizationId`) REFERENCES `organizations` (`id`) ON UPDATE CASCADE ON DELETE CASCADE;
+SET FOREIGN_KEY_CHECKS=1;

package/src/migrations/1733317910-paying-organization-id-fk.sql

@@ -1 +1,3 @@
+SET FOREIGN_KEY_CHECKS=0;
 ALTER TABLE `registrations` ADD FOREIGN KEY (`payingOrganizationId`) REFERENCES `organizations` (`id`) ON UPDATE CASCADE ON DELETE SET NULL;
+SET FOREIGN_KEY_CHECKS=1;

package/src/migrations/1733504881-negative-invoice-id.sql

@@ -0,0 +1,6 @@
+ALTER TABLE
+    `stamhoofd_invoices`
+ADD
+    COLUMN `negativeInvoiceId` varchar(36) NULL,
+ADD
+    FOREIGN KEY (`negativeInvoiceId`) REFERENCES `stamhoofd_invoices` (`id`) ON UPDATE CASCADE ON DELETE SET NULL;

package/src/migrations/1733994455-balance-item-status-open.ts

@@ -0,0 +1,30 @@
+import { Database, Migration } from '@simonbackx/simple-database';
+import { BalanceItemStatus } from '@stamhoofd/structures';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment === 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    const query = `
+        UPDATE
+            balance_items
+        SET status = ?
+        WHERE status IN (?)`;
+    await Database.update(query, [
+        BalanceItemStatus.Due,
+        ['Paid', 'Pending'],
+    ]);
+
+    const q2 = `
+        UPDATE
+            balance_items
+        SET status = ?,
+            amount = coalesce(nullif(ROUND(coalesce(pricePaid / nullif(unitPrice, 0), 0)), 0), 1)
+        WHERE amount = 0 AND status = ?`;
+    await Database.update(q2, [
+        BalanceItemStatus.Canceled,
+        BalanceItemStatus.Due,
+    ]);
+});

package/src/migrations/1763216320-bigint-balance-item-payments.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `balance_item_payments`
+CHANGE `price` `price` bigint NOT NULL DEFAULT '0';