Merge pull request #66 from open-template-hub/develop

Release/event search updates

Author: Furkan Yavuz

.github/workflows/cron-dependency-checker-workflow.yml

@@ -24,9 +24,18 @@ jobs:
       - name: Npm Outdated
         run: npm run outdated
 
+      - name: Check for Changes
+        run: |
+          if git diff --exit-code; then
+            echo "changes_exist=false" >> $GITHUB_ENV
+          else
+            echo "changes_exist=true" >> $GITHUB_ENV
+          fi
+
       - name: Git Commit and Push
+        if: ${{ env.changes_exist == 'true' }}
         run: |
-          git config --global user.email "furknyavuz@gmail.com"
-          git config --global user.name "Furkan Yavuz"
+          git config --global user.email "98660390+oth-service-user@users.noreply.github.com"
+          git config --global user.name "OTH Service User"
           git commit -am "Workflow/dependency check"
           git push

README.md

@@ -5,7 +5,7 @@
 </p>
 
 <h1 align="center">
-Open Template Hub - Analytics Server Template v3
+Open Template Hub - Analytics Server Template v4
 </h1>
 
 [![License](https://img.shields.io/github/license/open-template-hub/analytics-server-template?color=43b043&style=for-the-badge)](LICENSE)
@@ -74,6 +74,12 @@ ACCESS_TOKEN_SECRET={Access Token Secret}
 RESPONSE_ENCRYPTION_SECRET={Response Encryption Secret}
 ```
 
+## Postman Regression Tests
+
+To be able to configure regression tests, refer to **[REGRESSION_TESTS.md](docs/REGRESSION_TESTS.md)** file.
+
+<br/>
+
 ## Http Requests
 
 You can find list of available http request in the [requests](assets/requests) directory. You can run http requests directly via **WebStorm**, for more information check out: [jetbrains.com/help/idea/http-client-in-product-code-editor.html](https://jetbrains.com/help/idea/http-client-in-product-code-editor.html)

app/controller/event.controller.ts

@@ -3,34 +3,40 @@
  */
 
 import { Context } from '@open-template-hub/common';
-import { EventCategory } from '../enum/event-category.enum';
+import { Environment } from '../../environment';
 import { EventFilter } from '../interface/event-filter.interface';
 import { Event } from '../interface/event.interface';
+import { EventConfigRepository } from '../repository/event-config.repository';
 import { EventRepository } from '../repository/event.repository';
 
 export class EventController {
+
+  constructor( private environment = new Environment() ) {
+    // Intentionally blank
+  }
+
   /**
    * creates event
    * @param context context
    * @param event event
    * @returns created event
    */
-  createEvent = async (context: Context, event: Event) => {
+  createEvent = async ( context: Context, event: Event ) => {
     const eventRepository = await new EventRepository().initialize(
-      context.mongodb_provider.getConnection()
+        context.mongodb_provider.getConnection()
     );
 
-    if (!event.timestamp) {
+    if ( !event.timestamp ) {
       event.timestamp = Date.now();
     }
 
-    if (!event.category) {
-      event.category = EventCategory.DEFAULT;
+    if ( !event.category ) {
+      event.category = 'DEFAULT';
     }
 
     event.reporter = context.username;
 
-    return eventRepository.createEvent(event);
+    return eventRepository.createEvent( event );
   };
 
   /**
@@ -39,42 +45,58 @@ export class EventController {
    * @param filter filter
    * @returns filtered events
    */
-  filterEvents = async (context: Context, filter: EventFilter) => {
+  filterEvents = async ( context: Context, filter: EventFilter ) => {
     const eventRepository = await new EventRepository().initialize(
-      context.mongodb_provider.getConnection()
+        context.mongodb_provider.getConnection()
     );
 
-    const query = this.getQueryFromFilter(context, filter);
+    const query = this.getQueryFromFilter( context, filter );
 
-    return eventRepository.filterEvents(query, filter.limit);
+    return eventRepository.filterEvents( query, filter.skip, filter.limit );
   };
 
   /**
    * creates query from the filter
+   *@param context context
    * @param filter filter
    * @returns query
    */
-  getQueryFromFilter = (context: Context, filter: EventFilter) => {
-    var query = {} as any;
+  getQueryFromFilter = ( context: Context, filter: EventFilter ) => {
+    let query = {} as any;
 
     query.reporter = context.username;
 
-    if (filter.name) {
+    if ( filter.name ) {
       query.name = { $eq: filter.name };
     }
 
-    if (filter.category) {
+    if ( filter.category && filter.category !== 'ALL' ) {
       query.category = { $eq: filter.category };
     }
 
-    if (filter.start) {
+    if ( filter.start ) {
       query.timestamp = { $gte: filter.start };
     }
 
-    if (filter.end) {
+    if ( filter.end ) {
       query.timestamp = { $lte: filter.end };
     }
 
+    const maxQueryLimit = +( this.environment.args().serverSpecificArgs?.maxQueryLimit ?? '1000' );
+    if ( filter.limit > maxQueryLimit ) {
+      filter.limit = maxQueryLimit;
+    }
+
     return query;
   };
+
+  getCategories = async ( context: Context, language: string ) => {
+    const eventConfigRepository = await new EventConfigRepository().initialize(
+        context.mongodb_provider.getConnection()
+    );
+
+    const defaultLanguage = process.env.DEFAULT_LANGUAGE ?? 'en';
+
+    return eventConfigRepository.getCategories( context.role, language, defaultLanguage );
+  };
 }

app/data/event-config.data.ts

@@ -0,0 +1,35 @@
+/**
+ * @description holds event model
+ */
+
+ import mongoose from 'mongoose';
+
+ export class EventConfigDataModel {
+   private readonly collectionName: string = 'event_config';
+   private dataSchema: mongoose.Schema;
+ 
+   constructor() {
+     /**
+      * Provider schema
+      */
+     const schema: mongoose.SchemaDefinition = {
+       key: { type: String, required: true },
+       roles: { type: Array, default: [] },
+       messages: { type: Number, default: [] }
+     };
+     this.dataSchema = new mongoose.Schema( schema );
+   }
+ 
+   /**
+    * creates provider model
+    * @returns provider model
+    */
+   getDataModel = async ( conn: mongoose.Connection ) => {
+     return conn.model(
+         this.collectionName,
+         this.dataSchema,
+         this.collectionName
+     );
+   };
+ }
+ 

app/enum/event-category.enum.ts

@@ -2,13 +2,12 @@
  * @description holds event filter interface
  */
 
-import { EventCategory } from '../enum/event-category.enum';
-
 export interface EventFilter {
   name: string;
-  category: EventCategory;
+  category: string;
   start: number;
   end: number;
+  skip: number;
   limit: number;
   reporter: string;
 }

app/interface/event-filter.interface.ts

@@ -2,12 +2,11 @@
  * @description holds event interface
  */
 
-import { EventCategory } from '../enum/event-category.enum';
 
 export interface Event {
   source: string;
   timestamp: number;
   payload: any;
-  category: EventCategory;
+  category: string;
   reporter: string;
 }

app/interface/event.interface.ts

@@ -0,0 +1,67 @@
+import { UserRole } from "@open-template-hub/common";
+import { EventConfigDataModel } from "../data/event-config.data";
+
+export class EventConfigRepository {
+    private dataModel: any = null;
+
+    /**
+     * initializes eventConfig repository
+     * @param connection db connection
+     */
+    initialize = async ( connection: any ) => {
+      this.dataModel = await new EventConfigDataModel().getDataModel( connection );
+      return this;
+    };
+
+    getCategory = async ( key: string )  => {
+      try {
+        return await this.dataModel.findOne( key );
+      } catch(error) {
+        console.error( '> getCategory error: ', error );
+        throw error;
+      }
+    }
+  
+    getCategories = async ( userRole: UserRole, language: string, defaultLanguage: string ) => {
+      try {
+        let dataModel = await this.dataModel.aggregate( [ 
+          { $match: { roles: { $in: [userRole] } } },
+          { $project: { 
+            key: 1,
+            messages: {
+              $filter: {
+                input: "$messages",
+                as: "item",
+                cond: {
+                  $or: [ 
+                    { $eq: [ "$$item.language", language ] }, 
+                    { $eq: ["$$item.language", defaultLanguage ] }
+                  ] }
+              }
+            } 
+          } }
+        ] );
+
+        let newMessagesArray: string[] = [];
+        for(let i = 0; i < dataModel.length; i++) {
+          if( dataModel[i].messages?.length > 1 ) {
+            for(let j = 0; j < dataModel[i].messages.length; j++ ) {
+              if( dataModel[i].messages[j].language === language ) {
+                newMessagesArray.push( dataModel[i].messages[j] );
+              }
+            }
+    
+            if( newMessagesArray.length > 0 ) {
+              dataModel[i].messages = newMessagesArray;
+            }
+          }
+        }
+  
+        return dataModel
+
+      } catch ( error ) {
+        console.error( '> getCategories error: ', error );
+        throw error;
+      }
+    };
+}

app/repository/event-config.repository.ts

@@ -37,9 +37,37 @@ export class EventRepository {
    * @param limit limit
    * @returns filtered events
    */
-  filterEvents = async ( query: any, limit: number ) => {
+  filterEvents = async ( query: any, skip: number, limit: number ) => {
     try {
-      return await this.dataModel.find( query ).sort( { timestamp: -1 } ).limit( limit );
+      let queryResult = await this.dataModel.aggregate([
+        { $match: query },
+        { $sort: { timestamp: -1 } },
+        { $facet: {
+          data: [
+            { $match: { } },
+            { $skip: skip },
+            { $limit: limit }
+          ],
+          meta: [
+            { $count: "count" },
+            { $addFields: {
+              skip: skip,
+              limit: limit
+            }}
+          ]
+        }}
+      ]);
+
+      if( queryResult.length > 0 ) {
+        queryResult = queryResult[0];
+
+        if( queryResult.meta.length > 0 ) {
+          queryResult.meta = queryResult.meta[0]
+        }
+
+        return queryResult
+      } 
+      return { }
     } catch ( error ) {
       console.error( '> filterEvents error: ', error );
       throw error;