@stamhoofd/backend 2.120.6 → 2.122.0

package/src/migrations/1750090029-document-update-year.ts

@@ -0,0 +1,103 @@
+import { Migration } from '@simonbackx/simple-database';
+import { DocumentTemplate, Group } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+import { Formatter } from '@stamhoofd/utility';
+import { SeedTools } from '../helpers/SeedTools.js';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.platformName.toLowerCase() !== 'stamhoofd') {
+        console.log('skipped for platform (only runs for Stamhoofd): ' + STAMHOOFD.platformName);
+        return;
+    }
+
+    process.stdout.write('\n');
+    console.log('Start updating year of document templates.');
+    await migrateDocumentYears();
+
+    return Promise.resolve();
+});
+
+export async function migrateDocumentYears() {
+    let realUpdate = 0;
+    const result = await SeedTools.loop({
+        query: DocumentTemplate.select(),
+        batchSize: 100,
+        useTransactionPerBatch: true,
+        action: async (document: DocumentTemplate) => {
+            // check
+            if (!document.year) {
+            // by default use the year before creation
+                let year: number = document.createdAt.getFullYear() - 1;
+
+                const groups = document.privateSettings.groups;
+                const groupIds: string[] = [...new Set(groups.map(g => g.group.id))];
+
+                if (groupIds.length > 0) {
+                    const query = Group.select().where(SQL.where('id', groupIds));
+                    const groupModels = await query.fetch();
+
+                    // count the number of groups per year
+                    const yearMap = new Map<number, number>();
+
+                    for (const group of groups) {
+                        const model = groupModels.find(g => g.id === group.group.id);
+                        if (!model) {
+                            continue;
+                        }
+
+                        // Note: we need to use the cycle settings to find the correct start and end dates
+                        const info = model.settings.cycleSettings.get(group.cycle);
+                        if (info && group.cycle !== model.cycle) {
+                            if (info.startDate) {
+                                const y = Formatter.luxon(info.startDate).year;
+
+                                const count = yearMap.get(y) ?? 0;
+                                yearMap.set(y, count + 1);
+                            } else {
+                                // Missing info: don't use the wrong year
+                            }
+                        } else {
+                            const y = Formatter.luxon(model.settings.startDate).year;
+                            const count = yearMap.get(y) ?? 0;
+                            yearMap.set(y, count + 1);
+                        }
+                    }
+
+                    // find the year with the highest count
+                    let topYear = 0;
+                    let topCount = 0;
+
+                    for (const [year, count] of yearMap) {
+                        if (count > topCount) {
+                            topYear = year;
+                            topCount = count;
+                        }
+                    }
+
+                    // use the year with the highest count
+                    if (topCount > 0) {
+                        year = topYear;
+                    }
+                }
+
+                const creationYear = Formatter.luxon(document.createdAt).year;
+                if (creationYear < year) {
+                    // This should never log: if this logs we should fix the migration
+                    console.error('FIXME: Unexpected document year ' + year + ' which is larger than creation year ' + creationYear + ' for ' + document.id);
+                    year = creationYear;
+                }
+
+                document.year = year;
+                if (await document.save({
+                    forceSave: true,
+                    skipMarkSaved: true,
+                    skipSendEvents: true,
+                })) {
+                    realUpdate += 1;
+                }
+            }
+        },
+    });
+
+    console.log('Migrated ' + realUpdate + ' document templates of ' + result.total + ' looped document templates');
+};

package/src/migrations/1750090030-records-configuration.ts

@@ -0,0 +1,92 @@
+import { column, Migration } from '@simonbackx/simple-database';
+import { AutoEncoder, field } from '@simonbackx/simple-encoding';
+import { Organization } from '@stamhoofd/models';
+import { QueryableModel, SQL } from '@stamhoofd/sql';
+import { DataPermissionsSettings, FinancialSupportSettings, Version } from '@stamhoofd/structures';
+import { v4 as uuidv4 } from 'uuid';
+import { SeedTools } from '../helpers/SeedTools.js';
+
+class OldOrganizationRecordsConfiguration extends AutoEncoder {
+    /**
+     * If the organizations provides support for families in financial difficulties
+     */
+    @field({ decoder: FinancialSupportSettings, nullable: true, version: 117 })
+    financialSupport: FinancialSupportSettings | null = null;
+
+    /**
+     * Ask permissions to collect data
+     */
+    @field({ decoder: DataPermissionsSettings, nullable: true, version: 117 })
+    dataPermission: DataPermissionsSettings | null = null;
+}
+
+class OldOrganizationMetaData extends AutoEncoder {
+    @field({
+        decoder: OldOrganizationRecordsConfiguration,
+        version: 53,
+        defaultValue: () => OldOrganizationRecordsConfiguration.create({}),
+    })
+    recordsConfiguration: OldOrganizationRecordsConfiguration = OldOrganizationRecordsConfiguration.create({});
+}
+
+// get data like it was in V1
+export class OldOrganization extends QueryableModel {
+    static table = 'organizations';
+
+    @column({
+        primary: true, type: 'string', beforeSave(value) {
+            return value ?? uuidv4();
+        },
+    })
+    id!: string;
+
+    /**
+     * Public meta data
+     */
+    @column({ type: 'json', decoder: OldOrganizationMetaData })
+    meta: OldOrganizationMetaData = OldOrganizationMetaData.create({});
+}
+
+export async function startRecordsConfigurationMigration() {
+    const result = await SeedTools.loop({
+        batchSize: 100,
+        query: OldOrganization.select().where(SQL.jsonValue(SQL.column('meta'), '$.version'), '<', Version),
+        useTransactionPerBatch: true,
+        action: async (oldOrganization: OldOrganization) => {
+            const oldFinancialSupport = oldOrganization.meta.recordsConfiguration.financialSupport;
+            const oldDataPermission = oldOrganization.meta.recordsConfiguration.dataPermission;
+
+            if (oldFinancialSupport || oldDataPermission) {
+                const newOrganization = await Organization.getByID(oldOrganization.id);
+
+                if (!newOrganization) {
+                    throw new Error('Organization with id ' + oldOrganization.id + ' not found');
+                }
+
+                newOrganization.meta.financialSupport = oldFinancialSupport;
+                newOrganization.meta.dataPermission = oldDataPermission;
+
+                await newOrganization.save({
+                    skipMarkSaved: true,
+                    skipSendEvents: true,
+                });
+            }
+        },
+    });
+
+    console.log('Succesfully migrated financialSupport and dataPermissions for ' + result.total + ' organizations');
+}
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment === 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    if (STAMHOOFD.platformName.toLowerCase() !== 'stamhoofd') {
+        console.log('skipped for platform (only runs for Stamhoofd): ' + STAMHOOFD.platformName);
+        return;
+    }
+
+    await startRecordsConfigurationMigration();
+});

package/src/migrations/1750090031-records-configuration-webshops.ts

@@ -0,0 +1,36 @@
+import { Migration } from '@simonbackx/simple-database';
+import { Webshop } from '@stamhoofd/models';
+import { SeedTools } from '../helpers/SeedTools.js';
+
+export async function startWebshopRecordsConfigurationMigration() {
+    let realSave = 0;
+
+    const result = await SeedTools.loop({
+        batchSize: 100,
+        query: Webshop.select(),
+        useTransactionPerBatch: true,
+        action: async (webshop: Webshop) => {
+            if (await webshop.save({
+                skipMarkSaved: true,
+                skipSendEvents: true,
+            })) {
+                realSave += 1;
+            }
+        },
+    });
+    console.log('Succesfully fetched and saved ' + realSave + ' webshops of ' + result.total + ' looped webshops');
+}
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment === 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    if (STAMHOOFD.platformName.toLowerCase() !== 'stamhoofd') {
+        console.log('skipped for platform (only runs for Stamhoofd): ' + STAMHOOFD.platformName);
+        return;
+    }
+
+    await startWebshopRecordsConfigurationMigration();
+});