feat: Achievements

.env.example

@@ -69,4 +69,5 @@ ZOOM_ACCOUNT_ID=
 ZOOM_MEETING_SDK_CLIENT_ID=
 ZOOM_MEETING_SDK_CLIENT_SECRET=
 
-ZOOM_ACTIVE=
+ZOOM_ACTIVE=
+GAMIFICATION_ACTIVE=

.env.integration-tests

@@ -17,4 +17,6 @@ ZOOM_MEETING_SDK_CLIENT_SECRET="ZOOM_MEETING_SDK_CLIENT_SECRET"
 ZOOM_MEETING_SDK_CLIENT_ID="ZOOM_MEETING_SDK_CLIENT_ID"
 ZOOM_API_KEY="ZOOM_API_KEY"
 ZOOM_API_SECRET="ZOOM_API_SECRET"
-ZOOM_ACCOUNT_ID="ZOOM_ACCOUNT_ID"
+ZOOM_ACCOUNT_ID="ZOOM_ACCOUNT_ID"
+
+GAMIFICATION_ACTIVE=true

.env.integration-tests.debug

@@ -17,4 +17,6 @@ ZOOM_MEETING_SDK_CLIENT_SECRET="ZOOM_MEETING_SDK_CLIENT_SECRET"
 ZOOM_MEETING_SDK_CLIENT_ID="ZOOM_MEETING_SDK_CLIENT_ID"
 ZOOM_API_KEY="ZOOM_API_KEY"
 ZOOM_API_SECRET="ZOOM_API_SECRET"
-ZOOM_ACCOUNT_ID="ZOOM_ACCOUNT_ID"
+ZOOM_ACCOUNT_ID="ZOOM_ACCOUNT_ID"
+
+GAMIFICATION_ACTIVE=true

.github/workflows/node.js.yml

@@ -2,7 +2,7 @@ name: Master Barrier
 
 on:
     pull_request:
-        branches: [master]
+        types: ['opened', 'edited', 'reopened', 'synchronize']
 
 jobs:
     integration:

common/achievement/aggregator.spec.ts

@@ -0,0 +1,113 @@
+import { aggregators } from './aggregator';
+
+describe('test sum aggregator', () => {
+    const tests: {
+        name: string;
+        elements: number[];
+        expected: number;
+    }[] = [
+        {
+            name: 'should sum all elements in array',
+            elements: [1, 2, 3, 4, 5],
+            expected: 15,
+        },
+        {
+            name: 'should return 0 for empty array',
+            elements: [],
+            expected: 0,
+        },
+    ];
+
+    it.each(tests)('$name', ({ elements, expected }) => {
+        expect(aggregators['sum'].function(elements)).toEqual(expected);
+    });
+});
+
+describe('test count aggregator', () => {
+    const tests: {
+        name: string;
+        elements: number[];
+        expected: number;
+    }[] = [
+        {
+            name: 'should count all elements in array',
+            elements: [1, 2, 3, 4, 5],
+            expected: 5,
+        },
+        {
+            name: 'should return 0 for empty array',
+            elements: [],
+            expected: 0,
+        },
+        {
+            name: 'should skip elements that are zero',
+            elements: [1, 0, 3, 0, 5],
+            expected: 3,
+        },
+    ];
+
+    it.each(tests)('$name', ({ elements, expected }) => {
+        expect(aggregators['count'].function(elements)).toEqual(expected);
+    });
+});
+
+describe('test presenceOfEvents aggregator', () => {
+    const tests: {
+        name: string;
+        elements: number[];
+        expected: number;
+    }[] = [
+        {
+            name: 'should return 1 if at least one element is present',
+            elements: [1, 2, 3, 4, 5],
+            expected: 1,
+        },
+        {
+            name: 'should return 0 for empty array',
+            elements: [],
+            expected: 0,
+        },
+        {
+            name: 'should return 0 if all elements are zero',
+            elements: [0, 0, 0, 0, 0],
+            expected: 0,
+        },
+    ];
+
+    it.each(tests)('$name', ({ elements, expected }) => {
+        expect(aggregators['presenceOfEvents'].function(elements)).toEqual(expected);
+    });
+});
+
+describe('test lastStreakLength aggregator', () => {
+    const tests: {
+        name: string;
+        elements: number[];
+        expected: number;
+    }[] = [
+        {
+            name: 'should get a streak of five',
+            elements: [1, 2, 3, 4, 5],
+            expected: 5,
+        },
+        {
+            name: 'should not have a streak if no elements are present',
+            elements: [],
+            expected: 0,
+        },
+        {
+            name: 'should reset streak if zero in chain',
+            elements: [1, 1, 1, 0, 1],
+            expected: 3,
+        },
+        {
+            name: 'should have a streak of 0 if first element is zero',
+            elements: [0, 1, 1, 1, 1],
+            expected: 0,
+        },
+    ];
+
+    it.each(tests)('$name', ({ elements, expected }) => {
+        expect(aggregators['lastStreakLength'].function(elements)).toEqual(expected);
+    });
+});

common/achievement/aggregator.ts

@@ -4,4 +4,34 @@ type Aggregator = Record<string, AggregatorFunction>;
 
 // Aggregators are needed to aggregate event values (achievement_event.value) or buckets for evaluation (like sum, count, max, min, avg)
 
-export const aggregators: Aggregator = {};
+export const aggregators: Aggregator = {
+    sum: {
+        function: (elements): number => {
+            return elements.reduce((total, num) => total + num, 0);
+        },
+    },
+    count: {
+        function: (elements): number => {
+            return elements.filter((num) => num != 0).length;
+        },
+    },
+    // this aggregator should be used to check if min one event exist in a bucket, i.e. if one event happend in one week / one month
+    presenceOfEvents: {
+        function: (elements): number => {
+            return elements.filter((num) => num != 0).length > 0 ? 1 : 0;
+        },
+    },
+    lastStreakLength: {
+        function: (elements): number => {
+            // elements are sorted desc, i.e. [KW 52, KW 51, KW 50]
+            let value = 0;
+            for (const element of elements) {
+                if (element === 0) {
+                    break;
+                }
+                value += 1;
+            }
+            return value;
+        },
+    },
+};