@stamhoofd/backend 2.45.0 → 2.48.0

package/src/helpers/TagHelper.ts

@@ -0,0 +1,170 @@
+import { Organization, Platform } from '@stamhoofd/models';
+import { QueueHandler } from '@stamhoofd/queues';
+import { OrganizationTag, TagHelper as SharedTagHelper } from '@stamhoofd/structures';
+import { ModelHelper } from './ModelHelper';
+
+export class TagHelper extends SharedTagHelper {
+    static async updateOrganizations() {
+        const queueId = 'update-tags-on-organizations';
+        QueueHandler.cancel(queueId);
+
+        await QueueHandler.schedule(queueId, async () => {
+            let platform = await Platform.getShared();
+
+            const tagCounts = new Map<string, number>();
+            await this.loopOrganizations(async (organizations) => {
+                for (const organization of organizations) {
+                    organization.meta.tags = this.getAllTagsFromHierarchy(organization.meta.tags, platform.config.tags);
+
+                    for (const tag of organization.meta.tags) {
+                        tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
+                    }
+                }
+
+                await Promise.all(organizations.map(organization => organization.save()));
+            });
+
+            // Reload platform to avoid race conditions
+            platform = await Platform.getShared();
+            for (const [tag, count] of tagCounts.entries()) {
+                const tagObject = platform.config.tags.find(t => t.id === tag);
+                if (tagObject) {
+                    tagObject.organizationCount = count;
+                }
+            }
+            await platform.save();
+        });
+    }
+
+    private static async loopOrganizations(onBatchReceived: (batch: Organization[]) => Promise<void>) {
+        await ModelHelper.loop(Organization, 'id', onBatchReceived, { limit: 10 });
+    }
+
+    /**
+     * Removes child tag ids that do not exist and sorts the tags.
+     * @param platformTags
+     * @returns
+     */
+    static getCleanedUpTags(platformTags: OrganizationTag[]): OrganizationTag[] {
+        const existingTags = new Set(platformTags.map(t => t.id));
+
+        for (const tag of platformTags) {
+            tag.childTags = tag.childTags.filter(tag => existingTags.has(tag));
+        }
+
+        return this.getSortedTags(platformTags);
+    }
+
+    private static getSortedTags(tags: OrganizationTag[]): OrganizationTag[] {
+        // keep original order, but add child tags below parent tag
+        const map = new Map(tags.map(tag => [tag.id, tag]));
+        const rootTags = this.getRootTags(tags);
+        const sortedTags = this.sortTagsHelper(rootTags, map);
+
+        return Array.from(sortedTags);
+    }
+
+    private static sortTagsHelper(tags: OrganizationTag[], allTagsMap: Map<string, OrganizationTag>): Set<OrganizationTag> {
+        // set to prevent duplicates
+        const result = new Set<OrganizationTag>();
+
+        for (const tag of tags) {
+            result.add(tag);
+            if (tag.childTags) {
+                const childTags = tag.childTags.map(id => allTagsMap.get(id)).filter(x => x !== undefined);
+                this.sortTagsHelper(childTags, allTagsMap).forEach(tag => result.add(tag));
+            }
+        }
+
+        return result;
+    }
+
+    static validateTags(platformTags: OrganizationTag[]): boolean {
+        const tagMap = new Map(platformTags.map(tag => [tag.id, tag]));
+
+        for (const tag of platformTags) {
+            const tagId = tag.id;
+
+            if (tag.childTags.includes(tagId)) {
+                // a tag cannot contain itself
+                console.error(`Tag ${tag.name} contains itself.`);
+                return false;
+            }
+
+            let isChildTag = false;
+
+            for (const otherTag of platformTags) {
+                const otherTagId = otherTag.id;
+
+                if (tagId === otherTagId) {
+                    continue;
+                }
+
+                const isChildOfOtherTag = otherTag.childTags.includes(tagId);
+
+                if (isChildOfOtherTag) {
+                    if (isChildTag) {
+                        // a tag can only be a child tag of 1 tag
+                        console.error(`Tag ${tag.name} is a child tag of multiple tags.`);
+                        return false;
+                    }
+
+                    isChildTag = true;
+
+                    // infinite loop should not be possible
+                    // infinite loop if tag contains other tag in hierarchy
+                    if (this.containsDeep(tagId, otherTagId, { tagMap })) {
+                        console.error(`Tag ${tag.name} contains an infinite loop with ${otherTag.name}.`);
+                        return false;
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+
+    static getAllTagsFromHierarchy(tagIds: string[], platformTags: OrganizationTag[]) {
+        const result = new Set<string>();
+        const tagMap = new Map(platformTags.map(tag => [tag.id, tag]));
+
+        this.recursivelyGetAllTagsFromHierarchy(tagIds, tagMap, result);
+        const sorted = Array.from(result);
+
+        // Sort tags based on platform config order
+        sorted.sort((a, b) => {
+            const aIndex = platformTags.findIndex(t => t.id === a);
+            const bIndex = platformTags.findIndex(t => t.id === b);
+            return aIndex - bIndex;
+        });
+
+        return sorted;
+    }
+
+    private static recursivelyGetAllTagsFromHierarchy(tagIds: string[], tagMap: Map<string, OrganizationTag>, result: Set<string>): void {
+        for (const tagId of tagIds) {
+            const tag = tagMap.get(tagId);
+            if (tag) {
+                result.add(tagId);
+
+                const addedChildTags: string[] = [];
+
+                for (const [otherId, otherTag] of tagMap.entries()) {
+                    if (otherId === tagId) {
+                        tagMap.delete(tagId);
+                        continue;
+                    }
+                    if (otherTag.childTags.some(childTagId => childTagId === tagId)) {
+                        if (!result.has(otherId)) {
+                            addedChildTags.push(otherId);
+                        }
+                    }
+                }
+
+                if (addedChildTags.length > 0) {
+                    this.recursivelyGetAllTagsFromHierarchy(addedChildTags, tagMap, result);
+                }
+            }
+        }
+    }
+}

package/src/seeds/1729253172-update-orders.ts

@@ -0,0 +1,28 @@
+import { Migration } from '@simonbackx/simple-database';
+import { Order } from '@stamhoofd/models';
+import { sleep } from '@stamhoofd/utility';
+import { ModelHelper } from '../helpers/ModelHelper';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment === 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    console.log('Start saving orders.');
+
+    const limit = 100;
+    let count = limit;
+
+    await ModelHelper.loop(Order, 'id', async (batch: Order[]) => {
+        console.log('Saving orders...', `(${count})`);
+        // save all orders to update the new columns
+        await Promise.all(batch.map(order => order.save()));
+        count += limit;
+    },
+    { limit });
+
+    await sleep(1000);
+
+    console.log('Finished saving orders.');
+});

package/src/sql-filters/members.ts

@@ -8,26 +8,26 @@ import { registrationFilterCompilers } from './registrations';
  */
 export const memberFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    id: createSQLColumnFilterCompiler('id'),
-    memberNumber: createSQLColumnFilterCompiler('memberNumber'),
-    firstName: createSQLColumnFilterCompiler('firstName'),
-    lastName: createSQLColumnFilterCompiler('lastName'),
-    name: createSQLExpressionFilterCompiler(
+    'id': createSQLColumnFilterCompiler('id'),
+    'memberNumber': createSQLColumnFilterCompiler('memberNumber'),
+    'firstName': createSQLColumnFilterCompiler('firstName'),
+    'lastName': createSQLColumnFilterCompiler('lastName'),
+    'name': createSQLExpressionFilterCompiler(
         new SQLConcat(
             SQL.column('firstName'),
             new SQLScalar(' '),
             SQL.column('lastName'),
         ),
     ),
-    age: createSQLExpressionFilterCompiler(
+    'age': createSQLExpressionFilterCompiler(
         new SQLAge(SQL.column('birthDay')),
         { nullable: true },
     ),
-    gender: createSQLExpressionFilterCompiler(
+    'gender': createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.gender'),
         { isJSONValue: true, type: SQLValueType.JSONString },
     ),
-    birthDay: createSQLColumnFilterCompiler('birthDay', {
+    'birthDay': createSQLColumnFilterCompiler('birthDay', {
         normalizeValue: (d) => {
             if (typeof d === 'number') {
                 const date = new Date(d);
@@ -36,41 +36,76 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
             return d;
         },
     }),
-    organizationName: createSQLExpressionFilterCompiler(
+    'organizationName': createSQLExpressionFilterCompiler(
         SQL.column('organizations', 'name'),
     ),
 
-    email: createSQLExpressionFilterCompiler(
+    'details.requiresFinancialSupport': createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('details'), '$.value.requiresFinancialSupport.value'),
+        { isJSONValue: true, type: SQLValueType.JSONBoolean },
+    ),
+
+    'email': createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.email'),
         { isJSONValue: true, type: SQLValueType.JSONString },
     ),
 
-    parentEmail: createSQLExpressionFilterCompiler(
+    'parentEmail': createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.parents[*].email'),
         { isJSONValue: true, isJSONObject: true, type: SQLValueType.JSONString },
     ),
 
-    unverifiedEmail: createSQLExpressionFilterCompiler(
+    'unverifiedEmail': createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.unverifiedEmails'),
         { isJSONValue: true, isJSONObject: true, type: SQLValueType.JSONString },
     ),
 
-    phone: createSQLExpressionFilterCompiler(
+    'phone': createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.phone'),
         { isJSONValue: true },
     ),
 
-    parentPhone: createSQLExpressionFilterCompiler(
+    'details.address': createSQLFilterNamespace({
+        city: createSQLExpressionFilterCompiler(
+            SQL.jsonValue(SQL.column('details'), '$.value.address.city'),
+            { isJSONValue: true, type: SQLValueType.JSONString },
+        ),
+        postalCode: createSQLExpressionFilterCompiler(
+            SQL.jsonValue(SQL.column('details'), '$.value.address.postalCode'),
+            { isJSONValue: true, type: SQLValueType.JSONString },
+        ),
+        street: createSQLExpressionFilterCompiler(
+            SQL.jsonValue(SQL.column('details'), '$.value.address.street'),
+            { isJSONValue: true, type: SQLValueType.JSONString },
+        ),
+    }),
+
+    'details.parents[*].address': createSQLFilterNamespace({
+        city: createSQLExpressionFilterCompiler(
+            SQL.jsonValue(SQL.column('details'), '$.value.parents[*].address.city'),
+            { isJSONValue: true, isJSONObject: true },
+        ),
+        postalCode: createSQLExpressionFilterCompiler(
+            SQL.jsonValue(SQL.column('details'), '$.value.parents[*].address.postalCode'),
+            { isJSONValue: true, isJSONObject: true },
+        ),
+        street: createSQLExpressionFilterCompiler(
+            SQL.jsonValue(SQL.column('details'), '$.value.parents[*].address.street'),
+            { isJSONValue: true, isJSONObject: true },
+        ),
+    }),
+
+    'parentPhone': createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.parents[*].phone'),
         { isJSONValue: true, isJSONObject: true },
     ),
 
-    unverifiedPhone: createSQLExpressionFilterCompiler(
+    'unverifiedPhone': createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.unverifiedPhones'),
         { isJSONValue: true, isJSONObject: true },
     ),
 
-    registrations: createSQLRelationFilterCompiler(
+    'registrations': createSQLRelationFilterCompiler(
         SQL.select()
             .from(
                 SQL.table('registrations'),
@@ -109,7 +144,7 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
         },
     ),
 
-    responsibilities: createSQLRelationFilterCompiler(
+    'responsibilities': createSQLRelationFilterCompiler(
         SQL.select()
             .from(
                 SQL.table('member_responsibility_records'),
@@ -151,7 +186,7 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
         },
     ),
 
-    platformMemberships: createSQLRelationFilterCompiler(
+    'platformMemberships': createSQLRelationFilterCompiler(
         SQL.select()
             .from(
                 SQL.table('member_platform_memberships'),
@@ -178,7 +213,7 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
         },
     ),
 
-    organizations: createSQLRelationFilterCompiler(
+    'organizations': createSQLRelationFilterCompiler(
         SQL.select()
             .from(
                 SQL.table('registrations'),

package/src/sql-filters/orders.ts

@@ -1,9 +1,25 @@
-import { baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, SQL, SQLConcat, SQLFilterDefinitions, SQLScalar, SQLValueType } from '@stamhoofd/sql';
 
 export const orderFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
+    // only backend (not useful to filter on these in the frontend)
     organizationId: createSQLColumnFilterCompiler('organizationId'),
+    updatedAt: createSQLColumnFilterCompiler('updatedAt'),
+
+    // frontend and backend
+    webshopId: createSQLColumnFilterCompiler('webshopId'),
     id: createSQLColumnFilterCompiler('id'),
+    timeSlotEndTime: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.endTime'),
+        // todo: type?
+        { isJSONValue: true, type: SQLValueType.JSONString },
+    ),
+    timeSlotStartTime: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.startTime'),
+        // todo: type?
+        { isJSONValue: true, type: SQLValueType.JSONString },
+    ),
+    createdAt: createSQLColumnFilterCompiler('createdAt'),
     number: createSQLColumnFilterCompiler('number'),
     status: createSQLColumnFilterCompiler('status'),
     paymentMethod: createSQLExpressionFilterCompiler(
@@ -19,15 +35,34 @@ export const orderFilterCompilers: SQLFilterDefinitions = {
         // todo: type?
         { isJSONValue: true, type: SQLValueType.JSONString },
     ),
-    timeSlotTime: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.endTime'),
+    validAt: createSQLColumnFilterCompiler('validAt'),
+
+    // todo: TEST!
+    name: createSQLExpressionFilterCompiler(
+        new SQLConcat(
+            SQL.jsonValue(SQL.column('data'), '$.value.customer.firstName'),
+            new SQLScalar(' '),
+            SQL.jsonValue(SQL.column('data'), '$.value.customer.lastName'),
+        ),
+        // SQL.jsonValue(SQL.column('data'), '$.value.customer.name'),
         // todo: type?
         { isJSONValue: true, type: SQLValueType.JSONString },
     ),
-    validAt: createSQLColumnFilterCompiler('validAt'),
-    totalPrice: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('data'), '$.value.totalPrice'),
+    email: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('data'), '$.value.customer.email'),
+        // todo: type?
+        { isJSONValue: true, type: SQLValueType.JSONString },
+    ),
+    phone: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('data'), '$.value.customer.phone'),
         // todo: type?
-        { isJSONValue: true },
+        { isJSONValue: true, type: SQLValueType.JSONString },
     ),
+    totalPrice: createSQLColumnFilterCompiler('totalPrice'),
+    amount: createSQLColumnFilterCompiler('amount'),
+    timeSlotTime: createSQLColumnFilterCompiler('timeSlotTime'),
+
+    // only frontend
+    // openBalance
+    // location
 };

package/src/sql-filters/organizations.ts

@@ -33,6 +33,10 @@ export const organizationFilterCompilers: SQLFilterDefinitions = {
         SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.city'),
         { isJSONValue: true, type: SQLValueType.JSONString },
     ),
+    postalCode: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.postalCode'),
+        { isJSONValue: true, type: SQLValueType.JSONString },
+    ),
     country: createSQLExpressionFilterCompiler(
         SQL.jsonValue(
             SQL.column('organizations', 'address'),

package/src/sql-filters/payments.ts

@@ -15,6 +15,7 @@ export const paymentFilterCompilers: SQLFilterDefinitions = {
     paidAt: createSQLColumnFilterCompiler('paidAt', { nullable: true }),
     price: createSQLColumnFilterCompiler('price'),
     provider: createSQLColumnFilterCompiler('provider', { nullable: true }),
+    transferDescription: createSQLColumnFilterCompiler('transferDescription', { nullable: true }),
     customer: createSQLFilterNamespace({
         ...baseSQLFilterCompilers,
         email: createSQLExpressionFilterCompiler(

package/src/sql-filters/registrations.ts

@@ -1,4 +1,4 @@
-import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler, SQL, createSQLFilterNamespace, createSQLExpressionFilterCompiler } from '@stamhoofd/sql';
+import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler, SQL, createSQLFilterNamespace, createSQLExpressionFilterCompiler, SQLValueType } from '@stamhoofd/sql';
 
 export const registrationFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
@@ -15,9 +15,11 @@ export const registrationFilterCompilers: SQLFilterDefinitions = {
         id: createSQLColumnFilterCompiler('groupId'),
         name: createSQLExpressionFilterCompiler(
             SQL.jsonValue(SQL.column('groups', 'settings'), '$.value.name'),
+            { isJSONValue: true, type: SQLValueType.JSONString },
         ),
         status: createSQLExpressionFilterCompiler(
             SQL.column('groups', 'status'),
+            { isJSONValue: true, type: SQLValueType.JSONString },
         ),
         defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId'), { nullable: true }),
     }),