@stamhoofd/backend 2.44.0 → 2.45.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.44.0",
+    "version": "2.45.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -36,14 +36,14 @@
         "@simonbackx/simple-encoding": "2.15.1",
         "@simonbackx/simple-endpoints": "1.14.0",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.44.0",
-        "@stamhoofd/backend-middleware": "2.44.0",
-        "@stamhoofd/email": "2.44.0",
-        "@stamhoofd/models": "2.44.0",
-        "@stamhoofd/queues": "2.44.0",
-        "@stamhoofd/sql": "2.44.0",
-        "@stamhoofd/structures": "2.44.0",
-        "@stamhoofd/utility": "2.44.0",
+        "@stamhoofd/backend-i18n": "2.45.0",
+        "@stamhoofd/backend-middleware": "2.45.0",
+        "@stamhoofd/email": "2.45.0",
+        "@stamhoofd/models": "2.45.0",
+        "@stamhoofd/queues": "2.45.0",
+        "@stamhoofd/sql": "2.45.0",
+        "@stamhoofd/structures": "2.45.0",
+        "@stamhoofd/utility": "2.45.0",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -60,5 +60,5 @@
         "postmark": "^4.0.5",
         "stripe": "^16.6.0"
     },
-    "gitHead": "1168aea7895e1aba48cd3123b09fc0b09a2b336f"
+    "gitHead": "c61562d189e2486d7669bd2bac5f3dca1804dc2c"
 }

package/src/endpoints/organization/dashboard/registration-periods/PatchOrganizationRegistrationPeriodsEndpoint.ts

@@ -3,7 +3,7 @@ import { GroupPrivateSettings, Group as GroupStruct, GroupType, OrganizationRegi
 
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { Group, Member, Organization, OrganizationRegistrationPeriod, Platform, RegistrationPeriod } from '@stamhoofd/models';
+import { Group, Member, Organization, OrganizationRegistrationPeriod, Platform, RegistrationPeriod, SetupStepUpdater } from '@stamhoofd/models';
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';
 
@@ -166,10 +166,12 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
             // #endregion
 
             await organizationPeriod.save();
+            let shouldUpdateSetupSteps = false;
 
             // Check changes to groups
             const deleteGroups = patch.groups.getDeletes();
             if (deleteGroups.length > 0) {
+                shouldUpdateSetupSteps = true;
                 for (const id of deleteGroups) {
                     await PatchOrganizationRegistrationPeriodsEndpoint.deleteGroup(id);
                     deleteUnreachable = true;
@@ -177,6 +179,7 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
             }
 
             for (const groupPut of patch.groups.getPuts()) {
+                shouldUpdateSetupSteps = true;
                 await PatchOrganizationRegistrationPeriodsEndpoint.createGroup(groupPut.put, organization.id, period, { allowedIds });
                 deleteUnreachable = true;
             }
@@ -193,6 +196,10 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
                 await Group.deleteUnreachable(organization.id, organizationPeriod, groups);
             }
 
+            if (shouldUpdateSetupSteps) {
+                SetupStepUpdater.updateForOrganization(organization).catch(console.error);
+            }
+
             periods.push(organizationPeriod);
         }
 

package/src/seeds/1728928973-balance-item-pending.ts

@@ -0,0 +1,11 @@
+import { Migration } from '@simonbackx/simple-database';
+import { BalanceItem } from '@stamhoofd/models';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment == 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    await BalanceItem.updatePricePending('all');
+});

package/src/seeds/1728928974-update-cached-outstanding-balance-from-items.ts

@@ -0,0 +1,40 @@
+import { Migration } from '@simonbackx/simple-database';
+import { logger } from '@simonbackx/simple-logging';
+import { BalanceItem } from '@stamhoofd/models';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment == 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    process.stdout.write('\n');
+    let c = 0;
+    let id: string = '';
+
+    await logger.setContext({ tags: ['silent-seed', 'seed'] }, async () => {
+        while (true) {
+            const items = await BalanceItem.where({
+                id: {
+                    value: id,
+                    sign: '>',
+                },
+            }, { limit: 1000, sort: ['id'] });
+
+            await BalanceItem.updateOutstanding(items);
+
+            c += items.length;
+            process.stdout.write('.');
+
+            if (items.length < 1000) {
+                break;
+            }
+            id = items[items.length - 1].id;
+        }
+    });
+
+    console.log('Updated outstanding balance for ' + c + ' items');
+
+    // Do something here
+    return Promise.resolve();
+});

package/src/sql-filters/orders.ts

@@ -1,26 +1,33 @@
-import { baseSQLFilterCompilers, createSQLColumnFilterCompiler, SQLFilterDefinitions } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
 
 export const orderFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    id: createSQLColumnFilterCompiler('id'),
     organizationId: createSQLColumnFilterCompiler('organizationId'),
+    id: createSQLColumnFilterCompiler('id'),
     number: createSQLColumnFilterCompiler('number'),
-    // 'startDate': createSQLColumnFilterCompiler('startDate'),
-    // 'endDate': createSQLColumnFilterCompiler('endDate'),
-    // 'groupIds': createSQLExpressionFilterCompiler(
-    //     SQL.jsonValue(SQL.column('meta'), '$.value.groups[*].id'),
-    //     { isJSONValue: true, isJSONObject: true },
-    // ),
-    // 'defaultAgeGroupIds': createSQLExpressionFilterCompiler(
-    //     SQL.jsonValue(SQL.column('meta'), '$.value.defaultAgeGroupIds'),
-    //     { isJSONValue: true, isJSONObject: true },
-    // ),
-    // 'organizationTagIds': createSQLExpressionFilterCompiler(
-    //     SQL.jsonValue(SQL.column('meta'), '$.value.organizationTagIds'),
-    //     { isJSONValue: true, isJSONObject: true },
-    // ),
-    // 'meta.visible': createSQLExpressionFilterCompiler(
-    //     SQL.jsonValue(SQL.column('meta'), '$.value.visible'),
-    //     { isJSONValue: true, type: SQLValueType.JSONBoolean },
-    // ),
+    status: createSQLColumnFilterCompiler('status'),
+    paymentMethod: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('data'), '$.value.paymentMethod'),
+        { isJSONValue: true, type: SQLValueType.JSONString },
+    ),
+    checkoutMethod: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('data'), '$.value.checkoutMethod.type'),
+        { isJSONValue: true, type: SQLValueType.JSONString },
+    ),
+    timeSlotDate: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.date'),
+        // todo: type?
+        { isJSONValue: true, type: SQLValueType.JSONString },
+    ),
+    timeSlotTime: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.endTime'),
+        // todo: type?
+        { isJSONValue: true, type: SQLValueType.JSONString },
+    ),
+    validAt: createSQLColumnFilterCompiler('validAt'),
+    totalPrice: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('data'), '$.value.totalPrice'),
+        // todo: type?
+        { isJSONValue: true },
+    ),
 };

package/src/sql-sorters/orders.ts

@@ -10,14 +10,13 @@ export const orderSorters: SQLSortDefinitions<Order> = {
     // Why? Because ORDER BY firstName, lastName produces a different order dan ORDER BY CONCAT(firstName, ' ', lastName) if there are multiple people with spaces in the first name
     // And that again causes issues with pagination because the next query will append a filter of name > 'John Doe' - causing duplicate and/or skipped results
     // What if you need mapping? simply map the sorters in the frontend: name -> firstname, lastname, age -> birthDay, etc.
-
-    number: {
+    createdAt: {
         getValue(a) {
-            return a.number;
+            return Formatter.dateTimeIso(a.createdAt);
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
-                column: SQL.column('number'),
+                column: SQL.column('createdAt'),
                 direction,
             });
         },
@@ -33,15 +32,99 @@ export const orderSorters: SQLSortDefinitions<Order> = {
             });
         },
     },
-    createdAt: {
+    number: {
         getValue(a) {
-            return Formatter.dateTimeIso(a.createdAt);
+            return a.number;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
-                column: SQL.column('createdAt'),
+                column: SQL.column('number'),
+                direction,
+            });
+        },
+    },
+    status: {
+        getValue(a) {
+            return a.status;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('status'),
+                direction,
+            });
+        },
+    },
+    paymentMethod: {
+        getValue(a) {
+            return a.data.paymentMethod;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.jsonValue(SQL.column('data'), '$.value.paymentMethod'),
+                direction,
+            });
+        },
+    },
+    checkoutMethod: {
+        getValue(a) {
+            return a.data.checkoutMethod?.type;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.jsonValue(SQL.column('data'), '$.value.checkoutMethod.type'),
+                direction,
+            });
+        },
+    },
+    timeSlotDate: {
+        getValue(a) {
+            return a.data.timeSlot?.date.getTime();
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.date'),
+                direction,
+            });
+        },
+    },
+    timeSlotTime: {
+        getValue(a) {
+            return a.data.timeSlot?.endTime;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.endTime'),
+                direction,
+            });
+        },
+    },
+    validAt: {
+        getValue(a) {
+            return a.validAt?.getTime();
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('validAt'),
+                direction,
+            });
+        },
+    },
+    totalPrice: {
+        getValue(a) {
+            return a.data.totalPrice;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.jsonValue(SQL.column('data'), '$.value.totalPrice'),
                 direction,
             });
         },
     },
+    // amount: {
+    //     getValue: (order) => {
+    //         return order.data.cart.items.reduce((acc, item) => {
+    //             return acc + item.amount;
+    //         }, 0);
+    //     }
+    // }
 };