@futdevpro/nts-dynamo 1.2.90

package/src/_models/fullstack-models/control-models/dynamobe-error.ts

@@ -0,0 +1,207 @@
+
+// import { Error as MongooseError } from 'mongoose';
+
+export class DynamoBEError {
+  flag = 'DYNAMO-BE ERROR OBJECT';
+  handled: boolean;
+  status: number;
+  errors: any[] = [];
+  error: any;
+  // dberrors: MongooseError[] = [];
+  messages: string[] = [];
+  userMessages: string[] = [];
+
+  constructor(
+    customConstructor: {
+      status?: number,
+      message?: string,
+      messages?: string[],
+      userMessage?: string,
+      error?: any,
+      consoleLog?: boolean,
+    }
+  ) {
+    //console.log('HEREIAM', customConstructor);
+    if (customConstructor.status) {
+      this.status = customConstructor.status;
+    }
+    this.status = customConstructor?.error?.status ? customConstructor.error.status : this.status;
+
+    if (customConstructor?.error?.errors) {
+      this.errors = this.errors.concat(customConstructor?.error?.errors);
+    }
+    /* if (customConstructor?.error?.dberrors) {
+      this.dberrors= this.dberrors.concat(customConstructor?.error?.dberrors);
+    } */
+    if (customConstructor?.error?.messages) {
+      this.messages = this.messages.concat(customConstructor?.error?.messages);
+    }
+    if (customConstructor?.error?.userMessages) {
+      this.userMessages = this.userMessages.concat(customConstructor?.error?.userMessages);
+    }
+
+    if (customConstructor.error) {
+      if (customConstructor.error instanceof DynamoBEError) {
+        this.errors.push(customConstructor.error.error);
+      } else {
+        if (customConstructor.error.error) {
+          this.errors.push(customConstructor.error.error);
+        }
+        this.errors.push(customConstructor.error);
+      }
+      /* if (customConstructor.error instanceof MongooseError) {
+        this.dberrors.push(customConstructor.error);
+      } */
+      if (customConstructor.error.message) {
+        this.messages.push(customConstructor.error.message);
+      }
+      if (customConstructor.error.status) {
+        this.status = customConstructor.error.status;
+      }
+    }
+    if (customConstructor.message) {
+      this.messages.push(customConstructor.message)
+    }
+    if (customConstructor.messages) {
+      this.messages.push(...customConstructor.messages)
+    }
+    if (customConstructor.userMessage) {
+      this.userMessages.push(customConstructor.userMessage)
+    }
+    if (customConstructor.consoleLog) {
+      console.log(this);
+    }
+  }
+}
+
+/*
+
+//                  //
+// RESPONSE STATUS  //
+//                  //
+
+1XX informational response
+
+  100 Continue
+  101 Switching Protocols
+  102 Processing
+  103 Early Hints
+
+
+2XX success
+
+  200 OK
+  201 Created
+  202 Accepted
+  203 Non-Authoritative Information
+  204 No Content
+  205 Reset Content
+  206 Partial Content 
+  207 Multi-Status
+  208 Already Reported
+  226 IM Used
+
+  
+3XX redirection
+
+  300 Multiple Choices
+  301 Moved Permanently
+  302 Found
+  303 See Other
+  304 Not Modified
+  305 Use Proxy
+  306 Switch Proxy
+  307 Temporary Redirect
+  308 Permanent Redirect
+
+
+4XX client errors
+
+  400 Bad Request
+  401 Unauthorized
+  402 Payment Required
+  403 Forbidden
+  404 Not Found
+  405 Method Not Allowed
+  406 Not Acceptable
+  407 Proxy Authentication Required
+  408 Request Timeout
+  409 Conflict
+  410 Gone
+  411 Length Required
+  412 Precondition Failed
+  413 Payload Too Large 
+  414 URI Too Long
+  415 Unsupported Media Type
+  416 Range Not Satisfiable
+  417 Expectation Failed
+  418 I'm a teapot
+  421 Misdirected Request
+  422 Unprocessable Entity
+  423 Locked
+  424 Failed Dependency
+  425 Too Early
+  426 Upgrade Required
+  428 Precondition Required
+  429 Too Many Requests
+  431 Request Header Fields Too Large
+  451 Unavailable For Legal Reasons
+
+
+5XX server errors
+
+  500 Internal Server Error
+  501 Not Implemented
+  502 Bad Gateway
+  503 Service Unavailable
+  504 Gateway Timeout
+  505 HTTP Version Not Supported
+  506 Variant Also Negotiates
+  507 Insufficient Storage
+  508 Loop Detected 
+  510 Not Extended
+  511 Network Authentication Required
+
+
+Unofficial codes
+
+  103 Checkpoint
+  218 This is fine (Apache Web Server)
+  419 Page Expired (Laravel Framework)
+  420 Enhance Your Calm (Twitter)
+  430 Request Header Fields Too Large (Shopify)
+  450 Blocked by Windows Parental Controls (Microsoft)
+  498 Invalid Token (Esri)
+  499 Token Required (Esri)
+  509 Bandwidth Limit Exceeded (Apache Web Server/cPanel)
+  526 Invalid SSL Certificate
+  529 Site is overloaded
+  530 Site is frozen
+  598 (Informal convention) Network read timeout error
+
+  440 Login Time-out
+  449 Retry With
+  451 Redirect
+
+  444 No Response
+  494 Request header too large
+  495 SSL Certificate Error
+  496 SSL Certificate Required
+  497 HTTP Request Sent to HTTPS Port
+  499 Client Closed Request
+
+  520 Web Server Returned an Unknown Error
+  521 Web Server Is Down
+  522 Connection Timed Out
+  523 Origin Is Unreachable
+  524 A Timeout Occurred
+  525 SSL Handshake Failed
+  526 Invalid SSL Certificate
+  527 Railgun Error
+
+  530
+
+  460
+  463
+
+*/

package/src/_models/fullstack-models/control-models/geo-ip-location.ts

@@ -0,0 +1,26 @@
+
+export interface GeoIpLocation {
+  /** [ <low bound of IP block>, <high bound of IP block> ] */
+  range: [number, number];
+  /** 2 letter ISO-3166-1 country code https://www.iban.com/country-codes */
+  country: string;
+  /**
+   * Up to 3 alphanumeric variable length characters as ISO 3166-2 code
+   * For US states this is the 2 letter state
+   * For the United Kingdom this could be ENG as a country like “England
+   * FIPS 10-4 subcountry code
+   */
+  region: string;
+  /** 1 if the country is a member state of the European Union, 0 otherwise. */
+  eu: '1' | '0';
+  /** "Country/Zone" Timezone from IANA Time Zone Database */
+  timezone: string;
+  /** This is the full city name */
+  city: string;
+  /** The latitude and longitude of the city */
+  ll: [number, number];
+  /** Metro code */
+  metro: number;
+  /** The approximate accuracy radius (km), around the latitude and longitude */
+  area: number;
+}

package/src/_models/fullstack-models/control-models/usage-action.ts

@@ -0,0 +1,18 @@
+
+export class DynamoUsageAction {
+  action?: string;
+  time?: Date;
+
+  constructor(
+    set?: {
+      action?: string,
+      time?: Date,
+    }
+  ) {
+    if (set) {
+      this.action = set.action;
+      this.time = set.time;
+    }
+  }
+}
+

package/src/_models/fullstack-models/control-models/usage-data.ts

@@ -0,0 +1,26 @@
+
+import { DynamoUsageAction } from './usage-action';
+
+export class DynamoUsageData {
+  page?: string;
+  opened?: Date;
+  timeSpentOnPage?: number;
+  actions?: DynamoUsageAction[] = [];
+
+  constructor(
+    set?: {
+      page?: string,
+      opened?: Date;
+      timeSpentOnPage?: number,
+      actions?: DynamoUsageAction[],
+    }
+  ) {
+    if (set) {
+      this.page = set.page;
+      this.opened = set.opened;
+      this.timeSpentOnPage = set.timeSpentOnPage;
+      this.actions = set.actions ? set.actions : [];
+    }
+  }
+}
+

package/src/_models/fullstack-models/data-models/custom-data.ts

@@ -0,0 +1,37 @@
+
+import { DynamoBEDataPropertyParams } from '../control-models/dynamobe-data-property-params';
+import { Metadata } from './metadata';
+
+export class CustomData extends Metadata {
+  data?: string;
+
+  constructor(
+    set?: {
+      _id?: string,
+
+      data?: string,
+      
+      __v?: number,
+      __created?: Date,
+      __createdBy?: string,
+      __lastModified?: Date,
+      __lastModifiedBy?: string,
+    }
+  ) {
+    super({
+      _id: set._id,
+      __v: set.__v,
+      __created: set.__created,
+      __createdBy: set.__createdBy,
+      __lastModified: set.__lastModified,
+      __lastModifiedBy: set.__lastModifiedBy,
+    })
+    if (set) {
+      this.data = set.data;
+    }
+  }
+}
+
+export const customDataModelParams: DynamoBEDataPropertyParams[] = [
+  { key: 'data', type: 'string', required: true },
+];

package/src/_models/fullstack-models/data-models/metadata.ts

@@ -0,0 +1,28 @@
+
+
+export class Metadata {
+  _id?: string;
+  __created?: Date;
+  __createdBy?: string;
+  __lastModified?: Date;
+  __lastModifiedBy?: string;
+  __v?: number;
+
+  constructor(metadata?: {
+    _id?: string,
+    __created?: Date,
+    __createdBy?: string,
+    __lastModified?: Date,
+    __lastModifiedBy?: string,
+    __v?: number;
+  } | Metadata){
+    if (metadata) {
+      this._id = metadata._id;
+      this.__created = metadata.__created;
+      this.__createdBy = metadata.__createdBy;
+      this.__lastModified = metadata.__lastModified;
+      this.__lastModifiedBy = metadata.__lastModifiedBy;
+      this.__v = metadata.__v;
+    }
+  }
+}

package/src/_models/fullstack-models/data-models/usage-session.ts

@@ -0,0 +1,82 @@
+
+import { DynamoBEDataPropertyParams } from '../control-models/dynamobe-data-property-params';
+import { GeoIpLocation } from '../control-models/geo-ip-location';
+import { Metadata } from './metadata';
+import { DynamoUsageData } from '../control-models/usage-data';
+
+export class DynamoUsageSession extends Metadata {
+  date?: string;
+  sessionStart?: Date;
+  sessionEnd?: Date;
+  address?: string;
+  issuer?: string;
+  locationData?: GeoIpLocation;
+
+  usageData?: DynamoUsageData[];
+  totalSessionTime?: number;
+  loggedInAs?: string;
+
+  constructor(
+    set?: {
+      _id?: string,
+
+      date?: string;
+      sessionStart?: Date,
+      sessionEnd?: Date,
+      address?: string,
+      issuer?: string,
+      locationData?: GeoIpLocation,
+
+      usageData?: DynamoUsageData[],
+      totalSessionTime?: number,
+      loggedInAs?: string,
+
+      __created?: Date,
+      __createdBy?: string,
+      __lastModified?: Date,
+      __lastModifiedBy?: string,
+      __v?: number
+    }
+  ) {
+    super({
+      _id: set?._id,
+      __created: set?.__created,
+      __createdBy: set?.__createdBy,
+      __lastModified: set?.__lastModified,
+      __lastModifiedBy: set?.__lastModifiedBy,
+      __v: set?.__v,
+    });
+    if (set) {
+      if (set.date) {
+        this.date = set.date;
+      } else if (set.sessionStart) {
+        this.date = set.sessionStart.toISOString().substring(0, 10);
+      }
+      this.sessionStart = set.sessionStart;
+      this.sessionEnd = set.sessionEnd;
+      this.address = set.address;
+      this.issuer = set.issuer;
+      this.locationData = set.locationData;
+
+      this.usageData = set.usageData ? set.usageData : [];
+      this.totalSessionTime = set.totalSessionTime;
+      this.loggedInAs = set.loggedInAs;
+    }
+  }
+}
+
+export const usageSessionModelParams: DynamoBEDataPropertyParams[] = [
+  { key: 'date', type: 'string',
+    required: true, index: true
+  },
+  { key: 'sessionStart', type: 'Date',
+    required: true, index: true
+  },
+  { key: 'sessionEnd', type: 'Date' },
+  { key: 'address', type: 'string' },
+  { key: 'issuer', type: 'string' },
+  { key: 'locationData', type: 'IpApiLocation' },
+  { key: 'usageData', type: 'UsageData[]' },
+  { key: 'totalSessionTime', type: 'number' },
+  { key: 'loggedInAs', type: 'string' },
+];

package/src/_modules/test-route/custom-data.service.ts

@@ -0,0 +1,21 @@
+
+
+
+import { CustomData, customDataModelParams } from '../../_models/fullstack-models/data-models/custom-data';
+import { DynamoBEDataService } from '../../_services/dynamobe-data.service';
+import { DBE_Global_S } from '../../_services/dynamobe-global.service';
+
+export class CustomDataService extends DynamoBEDataService<CustomData> {
+
+  constructor(
+    customData?: CustomData,
+    issuer?: string,
+  ) {
+    super(
+      DBE_Global_S.getDBServiceCollection().customDataDBService, 
+      new CustomData(customData),
+      customDataModelParams,
+      issuer
+    );
+  }
+}

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

@@ -0,0 +1,136 @@
+
+import { Request, Response } from 'express';
+import { HttpCallType } from '../../_enum/http/http-call-type.enum';
+import { DynamoBEEndpointParams } from '../../_models/dynamobe-endpoint-control';
+import { DynamoBEController } from '../../_services/dynamobe-controller.service';
+import { CustomDataService } from './custom-data.service';
+
+export class TestController extends DynamoBEController {
+
+    static getInstance(): TestController {
+      return TestController.getSingletonInstance();
+    }
+
+    setupEndpoints(): void {
+        this.endpoints = [
+            // TESTS
+            new DynamoBEEndpointParams({
+                name: 'testGet',
+                type: HttpCallType.get,
+                endpoint: '/test-get',
+                tasks: [ 
+                    async (req: Request, res: Response) => {
+                        res.send({
+                            url: req.url,
+                            result: 'test-get call was successful!',
+                            request: req.body
+                        });
+                    }
+                ]
+            }),
+            
+            new DynamoBEEndpointParams({
+                name: 'testPost',
+                type: HttpCallType.post,
+                endpoint: '/test-post',
+                tasks: [ 
+                    async (req: Request, res: Response) => {
+                        res.send({
+                            url: req.url,
+                            result: 'test-post call was successful!',
+                            request: req.body
+                        });
+                    }
+                ]
+            }),
+
+            new DynamoBEEndpointParams({
+                name: 'testPut',
+                type: HttpCallType.put,
+                endpoint: '/test-put',
+                tasks: [ 
+                    async (req: Request, res: Response) => {
+                        res.send({
+                            url: req.url,
+                            result: 'test-put call was successful!',
+                            request: req.body
+                        });
+                    }
+                ]
+            }),
+
+            new DynamoBEEndpointParams({
+                name: 'testPatch',
+                type: HttpCallType.patch,
+                endpoint: '/test-patch',
+                tasks: [ 
+                    async (req: Request, res: Response) => {
+                        res.send({
+                            url: req.url,
+                            result: 'test-patch call was successful!',
+                            request: req.body
+                        });
+                    }
+                ]
+            }),
+
+            new DynamoBEEndpointParams({
+                name: 'testDelete',
+                type: HttpCallType.delete,
+                endpoint: '/test-delete',
+                tasks: [ 
+                    async (req: Request, res: Response) => {
+                        res.send({
+                            url: req.url,
+                            result: 'test-delete call was successful!',
+                            request: req.body
+                        });
+                    }
+                ]
+            }),
+            
+            // CUSTOM DATA
+            new DynamoBEEndpointParams({
+                name: 'getCustomData',
+                type: HttpCallType.get,
+                endpoint: '/custom/get/:customId',
+                tasks: [ 
+                    async (req: Request, res: Response) => {
+                        const customDataService = new CustomDataService({ _id: req.params.customId });
+            
+                        await customDataService.getDataById();
+            
+                        res.send({
+                            url: req.url,
+                            result: 'get custom call was successful!',
+                            response: customDataService.data,
+                            request: `.../custom/get/${req.params.customId}`
+                        });
+                    }
+                ]
+            }),
+            
+            new DynamoBEEndpointParams({
+                name: 'modifyCustomData',
+                type: HttpCallType.post,
+                endpoint: '/custom/post',
+                tasks: [ 
+                    async (req: Request, res: Response, issuer: string) => {
+                        const customDataService = new CustomDataService(req.body, issuer);
+            
+                        await customDataService.saveData();
+            
+                        res.send({
+                            url: req.url,
+                            result: 'post custom call was successful!',
+                            response: customDataService.data,
+                            warning: 'keep in mind that this is a playground DB, and it will be cleared out from time to time',
+                            request: req.body
+                        });
+                    }
+                ]
+            }),
+        ];
+    }
+}
+

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

@@ -0,0 +1,114 @@
+
+import { Request, Response } from 'express';
+import { HttpCallType } from '../../_enum/http/http-call-type.enum';
+import { DynamoBEEndpointParams } from '../../_models/dynamobe-endpoint-control';
+import { DynamoUsageSession } from '../../_models/fullstack-models/data-models/usage-session';
+import { DynamoBEAuthService } from '../../_services/dynamobe-auth.service';
+import { DynamoBEController } from '../../_services/dynamobe-controller.service';
+import { DBE_Global_S } from '../../_services/dynamobe-global.service';
+import { UsageService } from './usage.service';
+
+export class UsageController extends DynamoBEController {
+    
+    static getInstance(): UsageController {
+      return UsageController.getSingletonInstance();
+    }
+  
+    // SERVICES
+    private authService: DynamoBEAuthService;
+
+    setupEndpoints(): void {
+        this.authService = DBE_Global_S.getAuthService();
+
+        this.endpoints = [
+            new DynamoBEEndpointParams({
+                name: 'newSession',
+                type: HttpCallType.get,
+                endpoint: '/new-session',
+                tasks: [ 
+                    async (req: Request, res: Response, issuer: string) => {
+                        const authService = DBE_Global_S.getAuthService();
+                        const username = authService.getUsernameFromRequest(req);
+                        const usageService = new UsageService({
+                            usageSession: new DynamoUsageSession({ 
+                                sessionStart: new Date(),
+                                issuer: username,
+                            }),
+                            issuer
+                        });
+
+                        await usageService.getLocationDataFromRequest(req);
+                        await usageService.saveData();
+
+                        res.send(
+                            usageService.data
+                        );
+                    }
+                ]
+            }),
+            
+            new DynamoBEEndpointParams({
+                name: 'updateUsageData',
+                type: HttpCallType.post,
+                endpoint: '/update/:sessionId',
+                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 DynamoBEEndpointParams({
+                name: 'closeSession',
+                type: HttpCallType.get,
+                endpoint: '/close-session/:sessionId',
+                preProcessess: [ this.authService.authTokenPermAccUsageData ],
+                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 DynamoBEEndpointParams({
+                name: 'getAllUsageData',
+                type: HttpCallType.get,
+                endpoint: '/get/all',
+                preProcessess: [ this.authService.authTokenPermAccUsageData ],
+                tasks: [ 
+                    async (req: Request, res: Response) => {
+                        const usageService = new UsageService();
+
+                        await usageService.getLastWeekUsage();
+
+                        res.send(
+                            usageService.simplifiedDailyUsage
+                        );
+                    }
+                ]
+            }),
+
+        ];
+    }
+}
+