@futdevpro/nts-dynamo 1.2.90

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

@@ -0,0 +1,125 @@
+
+import { DynamoBEDataService } from '../../_services/dynamobe-data.service';
+import { DynamoBEError } from '../../_models/fullstack-models/control-models/dynamobe-error';
+import { DBE_Shared } from '../../_services/dynamobe-shared.service';
+import { Request } from 'express';
+import { DynamoUsageData } from '../../_models/fullstack-models/control-models/usage-data';
+import { DailyUsageData } from '../../_models/fullstack-models/control-models/daily-usage-data';
+import { DynamoUsageSession, usageSessionModelParams } from '../../_models/fullstack-models/data-models/usage-session';
+import { DBE_Global_S } from '../../_services/dynamobe-global.service';
+
+export class UsageService extends DynamoBEDataService<DynamoUsageSession> {
+  usageData: DynamoUsageData[] = [];
+  simplifiedDailyUsage: DailyUsageData[] = [];
+
+  constructor(
+    set?: {
+      usageSession?: DynamoUsageSession,
+      usageData?: DynamoUsageData[],
+      issuer?: string,
+    }
+  ) {
+    super(
+      DBE_Global_S.getDBServiceCollection().usageDataDBService,
+      new DynamoUsageSession(set?.usageSession),
+      usageSessionModelParams,
+      set?.issuer
+    );
+
+    this.usageData = set?.usageData ? set?.usageData : [];
+  }
+
+  getLocationDataFromRequest(req: Request): void {
+    try {
+      this.data.address = DBE_Shared.getIpFromRequest(req);
+      this.data.locationData = DBE_Shared.getLocationDataByRequest(req);
+
+      /* console.log(`...getLocationDataFromRequest... ip: ${this.data.address}`, this.data.locationData); */
+    } catch (error) {
+      throw new DynamoBEError({ status: 417, message: 'getLocationDataFromRequest was unsuccessful', error });
+    }
+  }
+
+  async getLastWeekUsage(): Promise<void> {
+    try {
+      await this.dataDBService.find({
+        sessionStart: { $gte: DBE_Shared.oneWeekAgo() }
+      }).then((res: DynamoUsageSession[]) => {
+        this.dataList = res;
+      });
+      this.simplifiedDailyUsage = [];
+      this.dataList.forEach((session: DynamoUsageSession) => {
+        let dateIndex = this.simplifiedDailyUsage.findIndex(
+          (dailyData: DailyUsageData) => dailyData.date === session.date
+        );
+        if (-1 < dateIndex) {
+          this.simplifiedDailyUsage[dateIndex].visitations.push(session);
+        } else {
+          const newUsageSimple = new DailyUsageData({ date: session.date, visitations: [ session ] });
+          this.simplifiedDailyUsage.push(newUsageSimple);
+          dateIndex = this.simplifiedDailyUsage.length - 1;
+        }
+
+        if (session?.locationData?.country) {
+          if (session.locationData.country === 'HU') {
+            this.simplifiedDailyUsage[dateIndex].visitorsHun++;
+          } else {
+            this.simplifiedDailyUsage[dateIndex].visitorsElse++;
+          }
+        }
+        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.sort(
+        (a: DailyUsageData, b: DailyUsageData) => +new Date(b.date) - +new Date(a.date)
+      );
+      this.simplifiedDailyUsage.forEach((daily: DailyUsageData) => {
+        daily.visitations.sort(
+          (a: DynamoUsageSession, b: DynamoUsageSession) => +a.sessionStart - +b.sessionStart
+        );
+      });
+
+    } catch (error) {
+      throw new DynamoBEError({ status: 417, message: 'getDailyUsage was unsuccessful', error });
+    }
+  }
+
+  async updateUsageData(req: Request): Promise<void> {
+    try {
+      await this.getDataById();
+      this.data.usageData = this.usageData;
+      let totalTime = 0;
+      this.data.usageData.forEach((data: DynamoUsageData) => {
+        totalTime += data.timeSpentOnPage;
+      });
+      if (!this.data.locationData) {
+        this.getLocationDataFromRequest(req);
+      }
+      this.data.totalSessionTime = totalTime;
+      await this.saveData();
+    } catch (error) {
+      throw new DynamoBEError({ status: 417, message: 'updateSessionData was unsuccessful', error });
+    }
+  }
+
+  async closeSession(req: Request): Promise<void> {
+    try {
+      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;
+      if (!this.data.locationData) {
+        this.getLocationDataFromRequest(req);
+      }
+      this.data.usageData.sort((a: DynamoUsageData, b: DynamoUsageData) => +a.opened - +b.opened);
+      this.data.totalSessionTime = newTotalSessionTime;
+      await this.saveData();
+    } catch (error) {
+      throw new DynamoBEError({ status: 417, message: 'closeSession was unsuccessful', error });
+    }
+  }
+}

package/src/_services/dynamobe-api.service.ts

@@ -0,0 +1,135 @@
+
+import * as axios from 'axios';
+import { HttpCallType } from '../_enum/http/http-call-type.enum';
+import { HttpResponseType } from '../_enum/http/http-response-type.enum';
+import { DynamoBEApiCallParams } from '../_models/dynamobe-api-call-params';
+import { DynamoBEError } from '../_models/fullstack-models/control-models/dynamobe-error';
+import { DBE_Shared } from './dynamobe-shared.service';
+
+export class DynamoBEApiService {
+
+  public static async startApiCall<T>(
+    callParams: DynamoBEApiCallParams,
+    inputParams?: {
+      pathParams?: {
+        [param: string]: string
+      },
+      /* queryParams?: object, */
+      body?: any
+    }
+  ): Promise<T> {
+    try {
+        let a: any;
+        let url: string = callParams.baseUrl + callParams.endPoint;
+        const privateAxiosInstance = axios.default.create();
+
+        if (callParams?.httpOptions?.headers) {
+            for (const headerKey in callParams.httpOptions.headers) {
+                if (callParams.httpOptions.headers[headerKey]) {
+                    privateAxiosInstance.defaults.headers.common[headerKey] = callParams.httpOptions.headers[headerKey];
+                } else {
+                    DBE_Shared.logError('DYNAMOBE ERROR: \n missing header:', headerKey, '\n\n', new Error());
+                }
+            }
+        }
+
+        if (inputParams?.pathParams) {
+            for (const pathParamKey in inputParams.pathParams) {
+                if (inputParams.pathParams[pathParamKey]) {
+                    const paramType = typeof inputParams.pathParams[pathParamKey]
+                    switch (paramType) {
+                    case 'number':
+                        url = url.replace(`{${pathParamKey}}`, inputParams.pathParams[pathParamKey].toString());
+                        break;
+                    case 'string':
+                        url = url.replace(`{${pathParamKey}}`, inputParams.pathParams[pathParamKey]);
+                        break;
+                    default:
+                        DBE_Shared.logError(`DYNAMOBE ERROR: \n wrong path param type: (${pathParamKey}): ${paramType} \n${inputParams.pathParams[pathParamKey]}\nMUST BE string or number\n\n`, new Error());
+                        break;
+                    }
+                } else {
+                    DBE_Shared.logError('DYNAMOBE ERROR: \n missing pathParam:', pathParamKey, '\n\n', new Error());
+                }
+            }
+        }
+
+        /* if (inputParams?.queryParams) {
+            const httpParams = new HttpParams();
+            for (const queryParamKey in inputParams.queryParams) {
+            if (inputParams.queryParams[queryParamKey]) {
+                switch (typeof inputParams.queryParams[queryParamKey]) {
+                case 'number':
+                    httpParams.set(queryParamKey, inputParams.queryParams[queryParamKey].toString());
+                    break;
+                case 'string':
+                    httpParams.set(queryParamKey, inputParams.queryParams[queryParamKey]);
+                    break;
+                default:
+                    console.error('DYNAMOBE ERROR: \n wrong query param type', '\n\n', new Error());
+                    break;
+                }
+            }
+            }
+            callParams.httpOptions.params = httpParams;
+        } */
+
+        switch (callParams.type) {
+            case HttpCallType.get:
+                if (inputParams?.body) {
+                    console.log('WARNING you cant send body in get calls');
+                }
+                await privateAxiosInstance.get<T>(url, callParams.httpOptions).then((res: axios.AxiosResponse ) => {
+                    a = res.data;
+                    console.log(`${callParams.name} was successful`, res.data);
+                });
+            break;
+            case HttpCallType.delete:
+                if (inputParams?.body) {
+                    console.log('WARNING you cant send body in delete calls');
+                }
+                await privateAxiosInstance.delete<T>(url, callParams.httpOptions).then((res: axios.AxiosResponse ) => {
+                    console.log(`${callParams.name} was successful`, res.data);
+                });
+            break;
+            case HttpCallType.post:
+            case HttpCallType.put:
+            case HttpCallType.patch:
+                if (!inputParams?.body) {
+                    if (!inputParams) {
+                        inputParams = {};
+                    }
+                    inputParams.body = {};
+                }
+                await privateAxiosInstance[callParams.type]<T>(url, inputParams.body, callParams.httpOptions).then((res: axios.AxiosResponse ) => {
+                    a = res.data;
+                    console.log(`${callParams.name} was successful`, res.data);
+                });
+            break;
+            default:
+                DBE_Shared.logError('DYNAMOBE ERROR: \n wrong api call type', '\n\n', new Error());
+            break;
+        }
+
+      return a as T;
+    } catch (error) {
+        DBE_Shared.logError('API ERRROR');
+        if (callParams?.httpOptions?.responseType === HttpResponseType.text) {
+            error.error = JSON.parse(error.error);
+        }
+        if (error?.response?.data?.flag === 'DYNAMO-BE ERROR OBJECT') {
+            DBE_Shared.logError(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
+            throw new DynamoBEError(error.response.data);
+        } else if (error.code === 'ENOTFOUND') {
+            DBE_Shared.logError(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
+            throw new DynamoBEError({ message: 'DNS error; address cannot be resolved!', status: 404, error: error });
+        } else if (error.config && error.message) {
+            throw new DynamoBEError({ status: +error.message.substring(error.message.length - 4, 3), error: error });
+        } else {
+            DBE_Shared.logError(`\n${callParams.name} was UNSUCCESSFUL`, error, '\n\n', new Error());
+            throw error;
+        }
+    }
+  }
+}
+

package/src/_services/dynamobe-app.ts

@@ -0,0 +1,49 @@
+
+import { DynamoBEAppParams } from '../_models/dynamobe-app-params';
+import * as Mongoose from 'mongoose';
+import { DBE_Shared } from './dynamobe-shared.service';
+import { DynamoBESingletonService } from './dynamobe-singleton.service';
+
+export abstract class DynamoBEApp extends DynamoBESingletonService {
+
+  protected params: DynamoBEAppParams;
+  
+  protected mongoose = Mongoose;
+
+  constructor(){
+    super();
+
+    try {
+      this.setupAppParams();
+      console.log(`\n\n\nStarting ${this.params.name}... \nVersion: ${this.params.version}`);
+      if (this.params.title) console.log(this.params.title);
+
+      this.startDB();
+
+      this.setGlobalServiceCollection();
+    } catch (error) {
+      DBE_Shared.logError('\nApplication start failed.\n', error);
+    }
+  }
+
+  private startDB(): void {
+    this.mongoose.connection
+      .on('error', (error) => {
+        DBE_Shared.logError('Unable to connect to MongoDB server, ERROR: ', error);
+      })
+      .once('open', () => {
+        DBE_Shared.logSuccess('\nConnected to MongoDB\n');
+      });
+
+    this.mongoose.connect(
+        this.params.dbUri, 
+        {
+          useNewUrlParser: true,
+          useUnifiedTopology: true 
+        }
+    );
+  }
+
+  abstract setupAppParams(): void;
+  abstract setGlobalServiceCollection(): void;
+}

package/src/_services/dynamobe-auth.service.ts

@@ -0,0 +1,42 @@
+
+import { NextFunction, Request, Response } from 'express';
+import { DynamoBEError } from '../_models/fullstack-models/control-models/dynamobe-error';
+import { DynamoBESingletonService } from './dynamobe-singleton.service';
+
+export abstract class DynamoBEAuthService extends DynamoBESingletonService {
+
+  /**
+   * 
+   * @param req 
+   * @returns 
+   */
+  static getTokenFromRequest(req: Request): string {
+    const authHeader = req.headers['authorization'];
+    if (!authHeader) {
+      throw new DynamoBEError({ message: 'AuthHeader missing!' });
+    }
+    const token = authHeader.split(' ')[1];
+    if (!token) {
+      throw new DynamoBEError({ message: 'Token missing!' });
+    }
+    return token;
+  }
+  
+  abstract authenticateTokenSelf(req: Request, res: Response, next: NextFunction): Promise<void>;
+  abstract authenticateToken(req: Request, res: Response, next: NextFunction): Promise<void>;
+  
+  /**
+   * Authenticate Token for Permission to Access UsageData
+   * @param req 
+   * @param res 
+   * @param next 
+   */
+  abstract authTokenPermAccUsageData(req: Request, res: Response, next: NextFunction): Promise<void>;
+
+  /**
+   * The DynamoBE System is using this to get issuer, that will be set on DBServices
+   * @param req 
+   */
+  abstract getAccountIdFromRequest(req: Request): string;
+  abstract getUsernameFromRequest(req: Request): string;
+}

package/src/_services/dynamobe-controller.service.ts

@@ -0,0 +1,20 @@
+
+
+import { DynamoBEEndpointParams } from '../_models/dynamobe-endpoint-control';
+import { DynamoBESingletonService } from './dynamobe-singleton.service';
+
+export abstract class DynamoBEController extends DynamoBESingletonService {
+
+  endpoints: DynamoBEEndpointParams[];
+
+  protected constructor(){
+    super();
+    
+    this.setupEndpoints();
+  }
+
+  /**
+   * You must setup endpoints and required services in this function
+   */
+  abstract setupEndpoints(): void
+}

package/src/_services/dynamobe-data.service.ts

@@ -0,0 +1,215 @@
+
+import { DynamoBEError } from '../_models/fullstack-models/control-models/dynamobe-error';
+import { Metadata } from '../_models/fullstack-models/data-models/metadata';
+import { DynamoBEDBService } from './dynamobe-db.service';
+import { DynamoBEDataPropertyParams } from '../_models/fullstack-models/control-models/dynamobe-data-property-params';
+import { DBE_Global_S } from './dynamobe-global.service';
+
+export class DynamoBEDataService<T extends Metadata> {
+  dataDBService: DynamoBEDBService<T>;
+  data: T;
+  dataList: T[] = [];
+  issuer?: string;
+
+  depKey?: string;
+  depDBServiceKey?: string;
+
+  dataModelParams?: DynamoBEDataPropertyParams[] = [];
+
+  constructor(
+    dataDBService: DynamoBEDBService<T>,
+    data: T,
+    dataModelParams: DynamoBEDataPropertyParams[], // this will be used for dependency dataHook
+    issuer?: string,
+  ) {
+    this.dataDBService = dataDBService;
+    this.data = data;
+    if (dataModelParams) {
+      this.dataModelParams = dataModelParams;
+      this.lookForDependencyDataSettings();
+    }
+    this.issuer = issuer;
+  }
+
+  /**
+   * returns all data from database to service dataList
+   */
+  async getAll(): Promise<void> {
+    try {
+      await this.dataDBService.getAll().then((dataList: T[]) => {
+        this.dataList = dataList;
+      });
+    } catch (error) {
+      throw new DynamoBEError({ status: 417, message: 'getAll was unsuccessful', error: error });
+    }
+  }
+
+  /**
+   * returns data from database by id
+   */
+  async getDataById(dontSetToService?: boolean): Promise<T> {
+    try {
+      if (this.data._id) {
+        let dataExists: T;
+        await this.dataDBService.getDataById(this.data._id).then((data: T) => {
+          if (!dontSetToService) {
+            this.data = data;
+          }
+          dataExists = data;
+        });
+        return dataExists;
+      } else {
+        throw new DynamoBEError({ status: 417, message: 'ID is missing!' });
+      }
+    } catch (error) {
+      throw new DynamoBEError({ status: 417, message: 'getDataById was unsuccessful', error: error });
+    }
+  }
+  
+  /**
+   * returns data from database by dependencyId to the service
+   * @param dependencyId 
+   */
+  async getDataByDependencyId(dependencyId?: string): Promise<void> {
+    try {
+      if (this.depKey) {
+        if (dependencyId || this.data[this.depKey]) {
+          await this.dataDBService.getDataByDependencyId(dependencyId ? dependencyId : this.data[this.depKey]).then((data: T) => {
+            this.data = data;
+          });
+        } else {
+          throw new DynamoBEError({ status: 417, message: `${this.depKey} is missing!` });
+        }
+      } else {
+        throw new DynamoBEError({ status: 417, message: 'dependencyDataIdKey is missing from service!' });
+      }
+    } catch (error) {
+      throw new DynamoBEError({ status: 417, message: 'getDataByDependencyId was unsuccessful', error: error });
+    }
+  }
+  
+  /**
+   * returns dataList from database by dependencyId to the service
+   * @param dependencyId 
+   */
+  async getDataListByDependencyId(dependencyId?: string): Promise<void> {
+    try {
+      if (this.depKey) {
+        if (dependencyId || this.data[this.depKey]) {
+          await this.dataDBService.getDataListByDependencyId(dependencyId ? dependencyId : this.data[this.depKey]).then((data: T[]) => {
+            this.dataList = data;
+          });
+        } else {
+          throw new DynamoBEError({ status: 417, message: `${this.depKey} is missing!` });
+        }
+      } else {
+        throw new DynamoBEError({ status: 417, message: 'dependencyDataIdKey is missing from service!' });
+      }
+    } catch (error) {
+      throw new DynamoBEError({ status: 417, message: 'getDataListByDependencyId was unsuccessful', error: error });
+    }
+  }
+
+  /**
+   * modifies data if the data have ID and already exists in the DB, 
+   * creates new if the ID is not present or cant find in DB, 
+   * and if dependency data setted up, will check before creation
+   */
+  async saveData(): Promise<void> {
+    try {
+      if (this.data._id) {
+        // check if already exists
+        let dataExists: T;
+        await this.getDataById(true).then((data: T) => {
+          dataExists = data;
+        }).catch(() => {});
+        if (!dataExists) {
+          // if data not exists check that dependency already exists for this id 
+          // !!!!!!!!!!!!!!!!!! only if have depKey????
+          await this.getDependencyDataDBService().getDataById(this.data[this.depKey]);
+          // if data not exists create new data
+          await this.dataDBService.createData(this.data, this.issuer).then((data: T) => {
+            this.data = data; // !!!!!!!!! this is somehow returns the old data on api 
+            // !!!!!!!!!!!!!!!!! if not using await for saveData??
+          });
+        } else {
+          // if data exists do modify
+          await this.dataDBService.modifyData(this.data, this.issuer).then((data: T) => {
+            this.data = data; // !!!!!!!!! this is somehow returns the old data on api 
+            // !!!!!!!!!!!!!!!!! if not using await for saveData??
+          });
+        }
+      } else {
+        // if ID is not present, data not exists, create new data
+        await this.dataDBService.createData(this.data, this.issuer).then((data: T) => {
+          this.data = data;
+        });
+      }
+    } catch (error) {
+      throw new DynamoBEError({ status: 417, message: 'modifyData was unsuccessful', error: error });
+    }
+  }
+
+  /**
+   * permanently deletes data from database by data._id
+   */
+  async deleteData(): Promise<void> {
+    try {
+      if (this.data._id) {
+        await this.dataDBService.deleteDataById(this.data._id);
+      } else {
+        throw new DynamoBEError({ status: 417, message: 'ID is missing!' });
+      }
+    } catch (error) {
+      throw new DynamoBEError({ status: 417, message: 'deleteData was unsuccessful', error: error });
+    }
+  }
+
+  /**
+   * validation of data, for modify and create, by the ModelParams
+   */
+  async validateForSave(): Promise<void> {
+    try {
+      for (let i = 0; i < this.dataModelParams.length; i++) {
+        // basic required validations
+        if ((this.dataModelParams[i].required && (this.data[this.dataModelParams[i].key] === null || this.data[this.dataModelParams[i].key] === undefined)) ||
+            (this.dataModelParams[i].index && (this.data[this.dataModelParams[i].key] === null || this.data[this.dataModelParams[i].key] === undefined))) {
+          throw new DynamoBEError({ status: 422, message: `${this.dataModelParams[i].key} is missing! (${this.dataModelParams[i].required ? 'required' : 'index'})` });
+        }
+        // specific Date validation
+        if (this.dataModelParams[i].type === 'Date' && !(new Date(this.data[this.dataModelParams[i].key]) instanceof Date)) {
+          throw new DynamoBEError({ status: 422, message: `${this.dataModelParams[i].key} is not a date!` });
+        }
+        // call additional validators
+        if (this.dataModelParams[i].additionalValidators) {
+          for (let j = 0; j < this.dataModelParams[i].additionalValidators.length; j++) {
+            this.dataModelParams[i].additionalValidators[j](this.data[this.dataModelParams[i].key]);
+          }
+        }
+      }
+    } catch (error) {
+      throw new DynamoBEError({ status: 422, message: 'validateForSave was unsuccessful', error: error });
+    }
+  }
+
+  /**
+   * setting up dependency dataHook by DynamoBEDataModelParams
+   */
+  private lookForDependencyDataSettings(): void {
+    const dependencyParam: DynamoBEDataPropertyParams = this.dataModelParams.find((modelParams: DynamoBEDataPropertyParams) => modelParams.isDependencyHook);
+    if (dependencyParam) {
+      this.depKey = dependencyParam.key;
+      if (dependencyParam.dependencyDBServiceName) {
+        this.depDBServiceKey = dependencyParam.dependencyDBServiceName;
+      }
+    }
+  }
+
+  getDependencyDataDBService(): DynamoBEDBService<any> {
+    if (this.depDBServiceKey) {
+      return DBE_Global_S.getDBServiceCollection()[this.depDBServiceKey];
+    } else {
+      throw new DynamoBEError({ status: 501, message: 'getDependencyDataDBService was unsuccessful, service key not setted up!' });
+    }
+  }
+}

package/src/_services/dynamobe-db-service-collection.service.ts

@@ -0,0 +1,9 @@
+
+import { DynamoBEDBService } from './dynamobe-db.service';
+import { DynamoBESingletonService } from './dynamobe-singleton.service';
+
+export class DynamoBEDBServiceCollection extends DynamoBESingletonService {
+
+  [service: string]: DynamoBEDBService<any>;
+
+}