@futdevpro/nts-dynamo 1.7.16 → 1.7.20

package/src/_modules/test/test.controller.ts

@@ -5,109 +5,111 @@ import { testModuleSettings } from '@futdevpro/fsm-dynamo/test-module';
 
 import { DynamoNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
 import { DynamoNTS_Controller } from '../../_services/route/controller.service';
-import { DynamoNTS_EndpointParams } from '../../_models/control-models/endpoint-params.control-model';
+import { 
+  DynamoNTS_EndpointParams 
+} from '../../_models/control-models/endpoint-params.control-model';
 import { DynamoNTS_GlobalService } from '../../_services/core/global.service';
 
 export class TestController extends DynamoNTS_Controller {
 
-    static getInstance(): TestController {
-      return TestController.getSingletonInstance();
-    }
+  static getInstance(): TestController {
+    return TestController.getSingletonInstance();
+  }
 
-    setupEndpoints(): void {
-        this.endpoints = [
-            // TESTS
-            new DynamoNTS_EndpointParams({
-                name: 'testGet',
-                type: DynamoNTS_HttpCallType.get,
-                endpoint: testModuleSettings.endPoints.testGet,
-                tasks: [ 
-                    async (req: Request, res: Response) => {
-                        res.send({
-                            url: req.url,
-                            result: 'test-get call was successful!',
-                            request: req.body
-                        });
-                    }
-                ]
-            }),
-            
-            new DynamoNTS_EndpointParams({
-                name: 'testPost',
-                type: DynamoNTS_HttpCallType.post,
-                endpoint: testModuleSettings.endPoints.testPost,
-                tasks: [ 
-                    async (req: Request, res: Response) => {
-                        res.send({
-                            url: req.url,
-                            result: 'test-post call was successful!',
-                            request: req.body
-                        });
-                    }
-                ]
-            }),
+  setupEndpoints(): void {
+    this.endpoints = [
+      // TESTS
+      new DynamoNTS_EndpointParams({
+        name: 'testGet',
+        type: DynamoNTS_HttpCallType.get,
+        endpoint: testModuleSettings.endPoints.testGet,
+        tasks: [
+          async (req: Request, res: Response): Promise<void> => {
+            res.send({
+              url: req.url,
+              result: 'test-get call was successful!',
+              request: req.body
+            });
+          }
+        ]
+      }),
 
-            new DynamoNTS_EndpointParams({
-                name: 'testPut',
-                type: DynamoNTS_HttpCallType.put,
-                endpoint: testModuleSettings.endPoints.testPut,
-                tasks: [ 
-                    async (req: Request, res: Response) => {
-                        res.send({
-                            url: req.url,
-                            result: 'test-put call was successful!',
-                            request: req.body
-                        });
-                    }
-                ]
-            }),
+      new DynamoNTS_EndpointParams({
+        name: 'testPost',
+        type: DynamoNTS_HttpCallType.post,
+        endpoint: testModuleSettings.endPoints.testPost,
+        tasks: [
+          async (req: Request, res: Response): Promise<void> => {
+            res.send({
+              url: req.url,
+              result: 'test-post call was successful!',
+              request: req.body
+            });
+          }
+        ]
+      }),
 
-            new DynamoNTS_EndpointParams({
-                name: 'testPatch',
-                type: DynamoNTS_HttpCallType.patch,
-                endpoint: testModuleSettings.endPoints.testPatch,
-                tasks: [ 
-                    async (req: Request, res: Response) => {
-                        res.send({
-                            url: req.url,
-                            result: 'test-patch call was successful!',
-                            request: req.body
-                        });
-                    }
-                ]
-            }),
+      new DynamoNTS_EndpointParams({
+        name: 'testPut',
+        type: DynamoNTS_HttpCallType.put,
+        endpoint: testModuleSettings.endPoints.testPut,
+        tasks: [
+          async (req: Request, res: Response): Promise<void> => {
+            res.send({
+              url: req.url,
+              result: 'test-put call was successful!',
+              request: req.body
+            });
+          }
+        ]
+      }),
 
-            new DynamoNTS_EndpointParams({
-                name: 'testDelete',
-                type: DynamoNTS_HttpCallType.delete,
-                endpoint: testModuleSettings.endPoints.testDelete,
-                tasks: [ 
-                    async (req: Request, res: Response) => {
-                        res.send({
-                            url: req.url,
-                            result: 'test-delete call was successful!',
-                            request: req.body
-                        });
-                    }
-                ]
-            }),
-            
-            new DynamoNTS_EndpointParams({
-                name: 'getServerStatus',
-                type: DynamoNTS_HttpCallType.get,
-                endpoint: testModuleSettings.endPoints.getServerStatus,
-                tasks: [ 
-                    async (req: Request, res: Response) => {
-                        
-                        res.send({
-                            status: 'ready',
-                            version: DynamoNTS_GlobalService.params.version,
-                            upTime: DynamoNTS_GlobalService.upTime,
-                        });
-                    }
-                ]
-            }),
-        ];
-    }
+      new DynamoNTS_EndpointParams({
+        name: 'testPatch',
+        type: DynamoNTS_HttpCallType.patch,
+        endpoint: testModuleSettings.endPoints.testPatch,
+        tasks: [
+          async (req: Request, res: Response): Promise<void> => {
+            res.send({
+              url: req.url,
+              result: 'test-patch call was successful!',
+              request: req.body
+            });
+          }
+        ]
+      }),
+
+      new DynamoNTS_EndpointParams({
+        name: 'testDelete',
+        type: DynamoNTS_HttpCallType.delete,
+        endpoint: testModuleSettings.endPoints.testDelete,
+        tasks: [
+          async (req: Request, res: Response): Promise<void> => {
+            res.send({
+              url: req.url,
+              result: 'test-delete call was successful!',
+              request: req.body
+            });
+          }
+        ]
+      }),
+
+      new DynamoNTS_EndpointParams({
+        name: 'getServerStatus',
+        type: DynamoNTS_HttpCallType.get,
+        endpoint: testModuleSettings.endPoints.getServerStatus,
+        tasks: [
+          async (req: Request, res: Response): Promise<void> => {
+
+            res.send({
+              status: 'ready',
+              version: DynamoNTS_GlobalService.params.version,
+              upTime: DynamoNTS_GlobalService.upTime,
+            });
+          }
+        ]
+      }),
+    ];
+  }
 }
 

package/src/_modules/usage/get-usage-routing-module.util.ts

@@ -1,15 +1,19 @@
 
 import { usageModuleSettings } from '@futdevpro/fsm-dynamo/usage-module';
 import { DynamoNTS_RouteSecurity } from '../../_enums/route-security.enum';
-import { DynamoNTS_RoutingModuleSettings } from '../../_models/interfaces/routing-module-settings.interface';
+import { 
+  DynamoNTS_RoutingModuleSettings 
+} from '../../_models/interfaces/routing-module-settings.interface';
 import { DynamoNTS_RoutingModule } from '../../_services/route/routing-module.service';
 import { UsageController } from './usage.controller';
 
-export function getUsageRoutingModule(securityOverride?: DynamoNTS_RouteSecurity): DynamoNTS_RoutingModule {
+export function getUsageRoutingModule(
+  securityOverride?: DynamoNTS_RouteSecurity
+): DynamoNTS_RoutingModule {
   const set: DynamoNTS_RoutingModuleSettings = {
     route: usageModuleSettings.mainRoute,
-    controllers: [ UsageController.getInstance() ]
-  }
+    controllers: [ UsageController.getInstance() ],
+  };
 
   if (securityOverride) {
     set.securityOverride = securityOverride;

package/src/_modules/usage/usage.controller.ts

@@ -1,115 +1,121 @@
 
 import { Request, Response } from 'express';
 
-import { usageModuleSettings, Dynamo_UsageSession } from '@futdevpro/fsm-dynamo/usage-module';
+import { 
+  usageModuleSettings, Dynamo_UsageSession, Dynamo_RelativeDate 
+} from '@futdevpro/fsm-dynamo/usage-module';
 
 import { DynamoNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
 import { DynamoNTS_AuthService } from '../../_services/core/auth.service';
 import { DynamoNTS_Controller } from '../../_services/route/controller.service';
 import { DynamoNTS_GlobalService } from '../../_services/core/global.service';
-import { DynamoNTS_EndpointParams } from '../../_models/control-models/endpoint-params.control-model';
+import { 
+  DynamoNTS_EndpointParams 
+} from '../../_models/control-models/endpoint-params.control-model';
 import { UsageService } from './usage.data-service';
 
 export class UsageController extends DynamoNTS_Controller {
-    
-    static getInstance(): UsageController {
-      return UsageController.getSingletonInstance();
-    }
-  
-    // SERVICES
-    private authService: DynamoNTS_AuthService;
-
-    setupEndpoints(): void {
-        this.authService = DynamoNTS_GlobalService.getAuthService();
-
-        this.endpoints = [
-            new DynamoNTS_EndpointParams({
-                name: 'newSession',
-                type: DynamoNTS_HttpCallType.get,
-                endpoint: usageModuleSettings.endPoints.newSession,
-                tasks: [ 
-                    async (req: Request, res: Response, issuer: string) => {
-                        const authService = DynamoNTS_GlobalService.getAuthService();
-                        const username = authService.getUsernameFromRequest(req);
-                        const usageService = new UsageService({
-                            usageSession: new Dynamo_UsageSession({ 
-                                sessionStart: new Date(),
-                                issuer: username,
-                            }),
-                            issuer
-                        });
-
-                        await usageService.getLocationDataFromRequest(req);
-                        await usageService.saveData();
-
-                        res.send(
-                            usageService.data
-                        );
-                    }
-                ]
-            }),
-            
-            new DynamoNTS_EndpointParams({
-                name: 'updateUsage',
-                type: DynamoNTS_HttpCallType.post,
-                endpoint: usageModuleSettings.endPoints.updateUsage,
-                logRequestsContent: false,
-                tasks: [ 
-                    async (req: Request, res: Response, issuer: string) => {
-                        const usageService = new UsageService({ 
-                            usageSession: { _id: req.params.sessionId },
-                            usageData: req.body,
-                            issuer
-                        });            
-
-                        await usageService.updateUsageData(req);
-
-                        res.send(
-                            usageService.data
-                        );
-                    }
-                ]
-            }),
-            
-            new DynamoNTS_EndpointParams({
-                name: 'closeSession',
-                type: DynamoNTS_HttpCallType.get,
-                endpoint: usageModuleSettings.endPoints.closeSession,
-                tasks: [ 
-                    async (req: Request, res: Response, issuer: string) => {
-                        const usageService = new UsageService({
-                            usageSession: { _id: req.params.sessionId },
-                            issuer
-                        });
-
-                        await usageService.closeSession(req);
-
-                        res.send(
-                            usageService.data
-                        );
-                    }
-                ]
-            }),
-            
-            new DynamoNTS_EndpointParams({
-                name: 'getAllUsageData',
-                type: DynamoNTS_HttpCallType.get,
-                endpoint: usageModuleSettings.endPoints.getAllUsageData,
-                preProcessess: [ this.authService.authTokenPermAccUsageData ],
-                tasks: [ 
-                    async (req: Request, res: Response) => {
-                        const usageService = new UsageService();
-
-                        await usageService.getLastWeekUsage();
-
-                        res.send(
-                            usageService.simplifiedDailyUsage
-                        );
-                    }
-                ]
-            }),
-
-        ];
-    }
+
+  static getInstance(): UsageController {
+    return UsageController.getSingletonInstance();
+  }
+
+  // SERVICES
+  private authService: DynamoNTS_AuthService;
+
+  setupEndpoints(): void {
+    this.authService = DynamoNTS_GlobalService.getAuthService();
+
+    this.endpoints = [
+      new DynamoNTS_EndpointParams({
+        name: 'newSession',
+        type: DynamoNTS_HttpCallType.get,
+        endpoint: usageModuleSettings.endPoints.newSession,
+        tasks: [
+          async (req: Request, res: Response, issuer: string): Promise<void> => {
+            const authService = DynamoNTS_GlobalService.getAuthService();
+            const username = authService.getUsernameFromRequest(req);
+            const usageService = new UsageService({
+              usageSession: new Dynamo_UsageSession({
+                sessionStart: new Date(),
+                issuer: username,
+              }),
+              issuer,
+            });
+
+            await usageService.getLocationDataFromRequest(req);
+            await usageService.saveData();
+
+            res.send(
+              usageService.data
+            );
+          },
+        ],
+      }),
+
+      new DynamoNTS_EndpointParams({
+        name: 'updateUsage',
+        type: DynamoNTS_HttpCallType.post,
+        endpoint: usageModuleSettings.endPoints.updateUsage,
+        logRequestsContent: false,
+        tasks: [
+          async (req: Request, res: Response, issuer: string): Promise<void> => {
+            const usageService = new UsageService({
+              usageSession: { _id: req.params.sessionId },
+              usageData: req.body,
+              issuer,
+            });
+
+            await usageService.updateUsageData(req);
+
+            res.send(
+              usageService.data
+            );
+          },
+        ],
+      }),
+
+      new DynamoNTS_EndpointParams({
+        name: 'closeSession',
+        type: DynamoNTS_HttpCallType.get,
+        endpoint: usageModuleSettings.endPoints.closeSession,
+        tasks: [
+          async (req: Request, res: Response, issuer: string): Promise<void> => {
+            const usageService = new UsageService({
+              usageSession: { _id: req.params.sessionId },
+              issuer,
+            });
+
+            await usageService.closeSession(req);
+
+            res.send(
+              usageService.data
+            );
+          },
+        ],
+      }),
+
+      new DynamoNTS_EndpointParams({
+        name: 'getUsageData',
+        type: DynamoNTS_HttpCallType.get,
+        endpoint: usageModuleSettings.endPoints.getUsageData,
+        preProcessess: [this.authService.authTokenPermAccUsageData],
+        tasks: [
+          async (req: Request, res: Response): Promise<void> => {
+            const range: Dynamo_RelativeDate = req.params.range as Dynamo_RelativeDate;
+
+            const usageService = new UsageService();
+
+            await usageService.getUsage(range);
+
+            res.send(
+              usageService.simplifiedDailyUsage
+            );
+          },
+        ],
+      }),
+
+    ];
+  }
 }
 

package/src/_modules/usage/usage.data-service.ts

@@ -1,6 +1,6 @@
 
 import { Request } from 'express';
-import { Dynamo_Error, Dynamo_Time } from '@futdevpro/fsm-dynamo';
+import { Dynamo_Error, Dynamo_Time, Dynamo_RelativeDate } from '@futdevpro/fsm-dynamo';
 import { Dynamo_UsageSession, usageSessionModelParams, Dynamo_UsageData, 
   Dynamo_DailyUsageData } from '@futdevpro/fsm-dynamo/usage-module';
 
@@ -34,31 +34,35 @@ export class UsageService extends DynamoNTS_DataService<Dynamo_UsageSession> {
       /* console.log(`...getLocationDataFromRequest... ip: ${this.data.address}`, this.data.locationData); */
     } catch (error) {
       throw new Dynamo_Error({ 
-        status: 417, 
+        ...this.getDefaultErrorSettings('getLocationDataFromRequest', error),
+        
         errorCode: 'NTS-US0-GLD',
-        message: 'getLocationDataFromRequest was unsuccessful', 
         userMessage: `We were unable to deep analyze your request.`,
-        error 
       });
     }
   }
 
-  async getLastWeekUsage(): Promise<void> {
+  async getUsage(range: Dynamo_RelativeDate = Dynamo_RelativeDate.lastWeek): Promise<void> {
     try {
       await this.dataDBService.find({
-        sessionStart: { $gte: Dynamo_Time.oneWeekAgo() }
-      }).then((res: Dynamo_UsageSession[]) => {
+        sessionStart: { $gte: Dynamo_Time.getDateByRelativeDate(range) },
+      }).then((res: Dynamo_UsageSession[]): void => {
         this.dataList = res;
       });
       this.simplifiedDailyUsage = [];
-      this.dataList.forEach((session: Dynamo_UsageSession) => {
+      this.dataList.forEach((session: Dynamo_UsageSession): void => {
         let dateIndex = this.simplifiedDailyUsage.findIndex(
-          (dailyData: Dynamo_DailyUsageData) => dailyData.date === session.date
+          (dailyData: Dynamo_DailyUsageData): boolean => dailyData.date === session.date
         );
+
         if (-1 < dateIndex) {
           this.simplifiedDailyUsage[dateIndex].visitations.push(session);
         } else {
-          const newUsageSimple = new Dynamo_DailyUsageData({ date: session.date, visitations: [ session ] });
+          const newUsageSimple = new Dynamo_DailyUsageData({ 
+            date: session.date, 
+            visitations: [ session ],
+          });
+
           this.simplifiedDailyUsage.push(newUsageSimple);
           dateIndex = this.simplifiedDailyUsage.length - 1;
         }
@@ -72,27 +76,28 @@ export class UsageService extends DynamoNTS_DataService<Dynamo_UsageSession> {
         }
         this.simplifiedDailyUsage[dateIndex].totalVisitTime += session.totalSessionTime;
         this.simplifiedDailyUsage[dateIndex].averageVisitTime = Math.round(
-            (this.simplifiedDailyUsage[dateIndex].totalVisitTime /
-              this.simplifiedDailyUsage[dateIndex].visitations.length) * 100
-          ) / 100;
+          (this.simplifiedDailyUsage[dateIndex].totalVisitTime /
+            this.simplifiedDailyUsage[dateIndex].visitations.length) * 100
+        ) / 100;
       });
 
       this.simplifiedDailyUsage.sort(
-        (a: Dynamo_DailyUsageData, b: Dynamo_DailyUsageData) => +new Date(b.date) - +new Date(a.date)
+        (a: Dynamo_DailyUsageData, b: Dynamo_DailyUsageData): number => 
+          +new Date(b.date) - +new Date(a.date)
       );
-      this.simplifiedDailyUsage.forEach((daily: Dynamo_DailyUsageData) => {
+      this.simplifiedDailyUsage.forEach((daily: Dynamo_DailyUsageData): void => {
         daily.visitations.sort(
-          (a: Dynamo_UsageSession, b: Dynamo_UsageSession) => +a.sessionStart - +b.sessionStart
+          (a: Dynamo_UsageSession, b: Dynamo_UsageSession): number => 
+            +a.sessionStart - +b.sessionStart
         );
       });
 
     } catch (error) {
       throw new Dynamo_Error({ 
-        status: 417, 
+        ...this.getDefaultErrorSettings('getLastWeekUsage', error),
+        
         errorCode: 'NTS-US0-GLW',
-        message: 'getDailyUsage was unsuccessful', 
         userMessage: `We've failed to collect last week's usage data.`,
-        error 
       });
     }
   }
@@ -102,9 +107,11 @@ export class UsageService extends DynamoNTS_DataService<Dynamo_UsageSession> {
       await this.getDataById();
       this.data.usageData = this.usageData;
       let totalTime = 0;
-      this.data.usageData.forEach((data: Dynamo_UsageData) => {
+
+      this.data.usageData.forEach((data: Dynamo_UsageData): void => {
         totalTime += data.timeSpentOnPage;
       });
+
       if (!this.data.locationData) {
         this.getLocationDataFromRequest(req);
       }
@@ -112,11 +119,10 @@ export class UsageService extends DynamoNTS_DataService<Dynamo_UsageSession> {
       await this.saveData();
     } catch (error) {
       throw new Dynamo_Error({ 
-        status: 417, 
+        ...this.getDefaultErrorSettings('updateUsageData', error),
+        
         errorCode: 'NTS-US0-UU0',
-        message: 'updateSessionData was unsuccessful', 
         userMessage: `The attempt to update Usage Data was unsuccessful.`,
-        error 
       });
     }
   }
@@ -126,21 +132,41 @@ export class UsageService extends DynamoNTS_DataService<Dynamo_UsageSession> {
       await this.getDataById();
       this.data.sessionEnd = new Date();
       const newTotalSessionTime = +this.data.sessionEnd - +this.data.sessionStart;
-      this.data.usageData[this.data.usageData.length - 1].timeSpentOnPage = newTotalSessionTime - this.data.totalSessionTime;
+
+      this.data.usageData[this.data.usageData.length - 1].timeSpentOnPage = 
+        newTotalSessionTime - this.data.totalSessionTime;
+      
       if (!this.data.locationData) {
         this.getLocationDataFromRequest(req);
       }
-      this.data.usageData.sort((a: Dynamo_UsageData, b: Dynamo_UsageData) => +a.opened - +b.opened);
+      this.data.usageData.sort(
+        (a: Dynamo_UsageData, b: Dynamo_UsageData): number => +a.opened - +b.opened
+      );
       this.data.totalSessionTime = newTotalSessionTime;
       await this.saveData();
     } catch (error) {
       throw new Dynamo_Error({ 
-        status: 417, 
+        ...this.getDefaultErrorSettings('closeSession', error),
+        
         errorCode: 'NTS-US0-CS0',
-        message: 'closeSession was unsuccessful', 
         userMessage: `The attempt to close Usage Session was unsuccessful.`,
-        error 
       });
     }
   }
+  
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  private getDefaultErrorSettings(
+    fnName: string, 
+    error: Error | Dynamo_Error
+  )/* : Dynamo_ErrorSettings */ {
+    return {
+      status: (error as Dynamo_Error)?.___status ?? 417,
+      message: (error as Error)?.message ?? `${fnName} was UNSUCCESFUL (NTS; ${this.serviceName})`,
+      addECToUserMsg: true,
+      userMessage: this.defaultErrorUserMsg,
+      issuer: this.issuer,
+      issuerService: this.serviceName,
+      error: error,
+    };
+  }
 }