@futdevpro/fsm-dynamo 1.5.38 → 1.5.43

package/src/_collections/_tools/dynamo-shared.service.ts

@@ -0,0 +1,151 @@
+
+import { clone } from './utilities';
+
+export class Dynamo_Shared {
+
+  /**
+   * returns remapped object list by path list
+   * @param objList object list to map
+   * @param paths string list of path etc.:
+   * ```ts
+   * [ [ 'first', 'sub', 'label' ], [ 'first', 'dif', 'name' ] ] 
+   * ``` 
+   * will be...
+   * from
+   * ```ts
+   * {
+   *   first: {
+   *     sub: {
+   *       label: 'vlmi'
+   *     },
+   *     dif: {
+   *       name: 'asd'
+   *     }
+   *   }
+   * }[]
+   * ```
+   * to
+   * ```
+   * { label: 'vlmi', name: 'asd' }[]
+   * ```
+   * @returns remapped object list (the final obj will use the deepest keys)
+   */
+  static mapObjList(objList: object[], paths: string[][]): object[] {
+    let newObjList = [...objList];
+    newObjList = newObjList.map(obj => {
+      const newObj = {};
+      paths.forEach((path: string[]) => {
+        newObj[path[path.length - 1]] = this.getNestedData(obj, path);
+      });
+      return newObj;
+    });
+    return newObjList;
+  }
+
+  /**
+   * returns nested value from object
+   * @param parentObj data source object
+   * @param nestedDataKeys path of value as string list
+   * etc.: ['nestLvl1', 'nestLvl2', 'nestLvl3'] as parentObj.nestLvl1.nestLvl2.nestLvl3
+   * @returns data from object by path
+   */
+  static getNestedData(parentObj: object, nestedDataKeys: string[]): any {
+    let newData = clone(parentObj); // {...parentObj};
+    nestedDataKeys.forEach((dk: string) => {
+      if (newData) {
+        newData = newData[dk];
+      }
+    });
+    return newData;
+  }
+
+  /**
+   * recursive function that nests data
+   * @param newData the object that that is needed to be updated
+   * @param nestKeys the path where the data should be updated
+   * @param dataToSet the actual value that will be setted
+   * @returns modified data
+   */
+  static nestData(parentObj: object, nestKeys: string[], dataToSet: any): object {
+    const newData = clone(parentObj); // {...parentObj};
+    if (nestKeys.length > 1) {
+      const keys = [...nestKeys];
+      const nextNestKey = keys.shift();
+      newData[nextNestKey] = this.nestData(newData[nextNestKey], keys, dataToSet);
+    } else {
+      newData[nestKeys[0]] = dataToSet;
+    }
+    return newData;
+  }
+
+  /**
+   * recursive function that adds to nested data
+   * @param newData the object that that is needed to be updated
+   * @param nestKeys the path where the data should be updated
+   * @param dataToAdd the actual value that will be setted
+   * @returns modified data
+   */
+  static addToNestedData(parentObj: object, nestKeys: string[], dataToAdd: any): object {
+    const newData = clone(parentObj); // {...parentObj};
+    if (nestKeys.length > 1) {
+      const keys = [...nestKeys];
+      const nextNestKey = keys.shift();
+      newData[nextNestKey] = this.addToNestedData(newData[nextNestKey], keys, dataToAdd);
+    } else {
+      newData[nestKeys[0]] += dataToAdd;
+    }
+    return newData;
+  }
+
+  /**
+   * recursive function that pushes to nested data
+   * @param newData the object that that is needed to be updated
+   * @param nestKeys the path where the data should be updated
+   * @param dataToPush the actual value that will be setted
+   * @returns modified data
+   */
+  static pushToNestedData(parentObj: object, nestKeys: string[], dataToPush: any): object {
+    const newData = clone(parentObj); // {...parentObj};
+    if (nestKeys.length > 1) {
+      const keys = [...nestKeys];
+      const nextNestKey = keys.shift();
+      newData[nextNestKey] = this.pushToNestedData(newData[nextNestKey], keys, dataToPush);
+    } else {
+      if (Array.isArray(newData[nestKeys[0]])) {
+        newData[nestKeys[0]].push(dataToPush);
+      } else {
+        newData[nestKeys[0]] = [dataToPush];
+      }
+    }
+    return newData;
+  }
+
+  /**
+   * recursive function that nests data on recursive data structure etc.: xData: { ..., 'nestedListKey': xData[] }
+   * @param newData the object that that is needed to be updated
+   * @param nestedListKey the location of nested dataList
+   * @param nestIndexes path to the subject ect.: xData.listKey[1].listKey[4].listKey[0] will be [1, 4, 0]
+   * @param dataToSet the actual value that will be setted on location
+   * @returns modified data
+   */
+  static nestRecursiveListedData<T>(parentObj: T, nestedListKey: string, nestIndexes: number[], dataToSet: any): T {
+    const newData = clone(parentObj); // parentObj; // {...parentObj};
+    if (nestIndexes.length > 1) {
+      const indexes = [...nestIndexes];
+      const nextLevelKey = indexes.shift();
+      newData[nestedListKey][nextLevelKey] = this.nestRecursiveListedData(
+          newData[nestedListKey][nextLevelKey], nestedListKey, indexes, dataToSet);
+    } else {
+      newData[nestedListKey][nestIndexes[0]] = dataToSet;
+    }
+    return newData;
+  }
+
+  static addMetadataToSchema(schema: any): any {
+    schema.__created = { type: Date };
+    schema.__createdBy = { type: String };
+    schema.__lastModified = { type: Date };
+    schema.__lastModifiedBy = { type: String };
+    return schema;
+  }
+}

package/src/_collections/_tools/dynamo-time.ts

@@ -0,0 +1,47 @@
+
+import { day, hour, month, week, year } from '../../_constants/times';
+
+export class Dynamo_Time {
+
+  static getAge(birthDate: Date | number | string) {
+    return this.getYear(+new Date() - +new Date(birthDate));
+  }
+
+  static getYear(date: Date | number | string) {
+    if (typeof date === 'string') {
+      date = new Date(date);
+    }
+    return (+date  / year);
+  }
+
+  static getHour(date: Date | number | string) {
+    if (typeof date === 'string') {
+      date = new Date(date);
+    }
+    return (+date  / hour);
+  }
+
+  static getDateByAge(age: number) {
+    return new Date(+new Date() - (year * age));
+  }
+
+  static oneHourAgo(): Date {
+    return new Date(+new Date() - hour);
+  }
+
+  static oneDayAgo(): Date {
+    return new Date(+new Date() - day);
+  }
+
+  static oneWeekAgo(): Date {
+    return new Date(+new Date() - week);
+  }
+
+  static oneMonthAgo(): Date {
+    return new Date(+new Date() - month);
+  }
+  
+  static oneYearAgo(): Date {
+    return new Date(+new Date() - year);
+  }
+}

package/src/_collections/_tools/dynamo-trigonometry.ts

@@ -0,0 +1,63 @@
+
+export class Dynamo_Trigonometry {
+  
+  /**
+   * Befogó
+   * a Befogó mérete az átfogó, és a befogóval szemközti szög alapján
+   * a szemközti szög értéke opcionális 
+   * (amennyiben nem adjuk meg, 45 fokos szöggel számolunk)
+   * @param c átfogó
+   * @param angle a befogó oldallal szemközti szög (fokban)
+   * @returns befogó
+   */
+  static getClamp(c: number, angle?: number): number {
+    angle = angle !== undefined ? angle : 45;
+    return Math.sin(this.angleToRadians(angle)) * c;
+  }
+
+  /**
+   * Befogó
+   * a Befogó mérete az átfogó és a másik befogó alapján
+   * @param a befogó
+   * @param c átfogó
+   * @returns befogó
+   */
+  static getClampByClampAndHypotenuse(a: number, c: number): number {
+    if (a > c) {
+      throw { errorMessage: `getClampByClampAndHypotenuse error hypotenuse is smaller than clamp (a:${a} > c:${c})` };
+    }
+    return Math.sqrt((c * c) - (a * a));
+  }
+
+  /**
+   * Átfogó
+   * az Átfogó mérete a befogók alapján
+   * a második befogó értéke opcionális 
+   * (amennyiben nem adjuk meg, egyenlő szárú háromszöggel számolunk)
+   * @param a egyik befogó
+   * @param b másik befogó
+   * @returns átfogó
+   */
+  static getHypotenuse(a: number, b?: number): number {
+    b = b !== undefined ? b : a;
+    return Math.sqrt((a * a) + (b * b));
+  }
+
+  /**
+   * Szög fokmértéket átalakítja radiánsra
+   * @param angle szög fok
+   * @returns szög radiáns
+   */
+  static angleToRadians(angle: number): number {
+    return angle * Math.PI / 180;
+  }
+
+  /**
+   * Szög radiáns mértéket átalakítja fokra
+   * @param radians szög radiáns
+   * @returns szög fok
+   */
+  static radiansToAngle(radians: number): number {
+    return radians / Math.PI * 180;
+  }
+}

package/src/_collections/_tools/utilities.ts

@@ -0,0 +1,67 @@
+
+
+export function clone<T>(object: T): T {
+  try {
+    return object ? JSON.parse(JSON.stringify(object)) as T : object;
+  } catch (error) {
+    console.error('clone() failed. This might be happening becouse the object you trying to clone, containes object hooks for its own objects, therefore its creating an object loop. See further information in the detailed error:');
+    throw error;
+  }
+}
+
+export function sameObjects<T>(objA: T, objB: T): boolean {
+  return JSON.stringify(objA) === JSON.stringify(objB);
+}
+
+/**
+ * sets values if its existing on To, even if its null (but if undefined)
+ * @param setOn
+ * @param setTo 
+ */
+export function setExisitngValuesOnly(setOn: any, setTo: any): void {
+  for (const key in setTo) {
+    if (setTo[key] != undefined) {
+      setOn[key] = setTo[key];
+    }
+  }
+}
+
+export function delay(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms) );
+}
+
+/**
+ * You might be use getSortForTrueFn instead for a shorter expression
+ * 
+ * @param a 
+ * @param b 
+ * @param check 
+ * @returns 
+ * 
+ * @example 
+ * codes.sort((a,b) => sortForTrue(a,b,(c: Code) => c.haveImg));
+ */
+ export function sortForTrue<T>(a: T, b: T, check: (a: T) => boolean): 0 | 1 | -1 {
+  const isA = check(a);
+  return isA === check(b) ? 0 : isA ? -1 : 1;
+}
+
+/**
+ * 
+ * @param checkFor 
+ * @returns 
+ * 
+ * @example
+ * codes.sort(getSortForTrueFn((c: Code) => c.haveImg));
+ */
+export function getSortForTrueFn<T>(checkFor: (a: T) => boolean): (a: T, b: T) => 0 | 1 | -1 {
+  return (a: T, b: T) => sortForTrue<T>(a, b, checkFor);
+}
+
+export function JSONListify<T>(JSONList): T[] {
+  const result: T[] = [];
+  for (let i = 0; JSONList[i]; i++) {
+    result.push(JSONList[i] as T);
+  }
+  return result; 
+}

package/src/_collections/_tools/vector.ts

@@ -0,0 +1,119 @@
+
+import { Dynamo_Trigonometry } from './dynamo-trigonometry';
+
+export class Vector2 {
+  private _x: number;
+  set x (value: number) {
+    this._x = value;
+    this.calcMagnitude();
+  };
+  get x (): number { 
+    return this._x;
+  }
+
+  private _y: number;
+  set y (value: number) {
+    this._y = value;
+    this.calcMagnitude();
+  };
+  get y (): number { 
+    return this._y;
+  }
+
+  private _magintude: number;
+  get magintude (): number { 
+    return this._magintude;
+  }
+
+  constructor(x: number, y: number) {
+    this._x = x;
+    this._y = y;
+    this.calcMagnitude();
+  }
+
+  static readonly zero: Vector2 = new Vector2(0, 0);
+  static readonly left: Vector2 = new Vector2(-1, 0);
+  static readonly right: Vector2 = new Vector2(1, 0);
+  static readonly up: Vector2 = new Vector2(0, 1);
+  static readonly down: Vector2 = new Vector2(0, -1);
+  
+  static distance(a: Vector2, b: Vector2): number {
+    return this.minus(a, b).magintude;
+  }
+  distanceTo(to: Vector2): number {
+    return Vector2.distance(this, to);
+  }
+
+  static minus(a: Vector2, b: Vector2): Vector2 {
+    return this.plus(a, this.negative(b));
+  }
+  minus(vector: Vector2): void {
+    this.newVector(Vector2.minus(this, vector));
+  }
+
+  static plus(a: Vector2, b: Vector2): Vector2 {
+    return new Vector2(a.x + b.x, a.y + b.y);
+  }
+  plus(vector: Vector2): void {
+    this.newVector(Vector2.plus(this, vector));
+  }
+
+  static multiply(v: Vector2, n: number): Vector2 {
+    return new Vector2(v.x * n, v.y * n);
+  }
+  multiply(n: number): void {
+    this.newVector(Vector2.multiply(this, n));
+  }
+
+  static negative(v: Vector2): Vector2 {
+    return new Vector2(-v.x, -v.y);
+  }
+  getNegative(): Vector2 {
+    return Vector2.negative(this);
+  }
+  negate(): void {
+    this.newVector(Vector2.negative(this));
+  }
+
+  static rebase(v: Vector2, baseFrom: Vector2, baseTo: Vector2): Vector2 {
+    return this.plus(v, this.minus(baseTo, baseFrom));
+  }
+  rebase(baseFrom: Vector2, baseTo: Vector2): void {
+    this.newVector(Vector2.rebase(this, baseFrom, baseTo));
+  }
+
+  static rotate(vector: Vector2, angle: number): Vector2 {
+    const rad = Dynamo_Trigonometry.angleToRadians(angle);
+    return this.rotateRad(vector, rad);
+  }
+  static rotateRad(vector: Vector2, rad: number): Vector2 {
+    const cos = Math.cos(rad);
+    const sin = Math.sin(rad);
+    const newX = (vector.x * cos) - (vector.y * sin);
+    const newY = (vector.x * sin) + (vector.y * cos);
+    return new Vector2(newX, newY);
+  }
+  rotate(angle: number): void {
+    this.newVector(Vector2.rotate(this, angle));
+  }
+  rotateRad(rad: number): void {
+    this.newVector(Vector2.rotateRad(this, rad));
+  }
+
+  private newVector(newV: Vector2): void {
+    this.newXY(newV.x, newV.y);
+  }
+  newXY(newX: number, newY: number): void {
+    this._x = newX;
+    this._y = newY;
+    this.calcMagnitude();
+  }
+
+  private calcMagnitude() {
+    this._magintude = Dynamo_Trigonometry.getHypotenuse(this._x, this._y);
+  }
+
+  clone() {
+    return new Vector2(this._x, this._y);
+  }
+}

package/src/_collections/index.ts

@@ -1,6 +1,15 @@
 
-// COLLECTIONS
-export * from './dynamo-shared.service';
-
+// TOOLS
+export * from './_tools/dynamo-shared.service';
+export * from './_tools/dynamo-regions';
+export * from './_tools/dynamo-location';
+export * from './_tools/dynamo-log';
+export * from './_tools/dynamo-random';
+export * from './_tools/dynamo-location';
+export * from './_tools/dynamo-round-list';
+export * from './_tools/dynamo-time';
+export * from './_tools/dynamo-trigonometry';
+export * from './_tools/utilities';
+export * from './_tools/vector';
 
 

package/src/_enums/region.enum.ts

@@ -0,0 +1,9 @@
+
+export enum Region {
+  europe = 'Europe',
+  asia = 'Asia',
+  africa = 'Africa',
+  oceania = 'Oceania',
+  americas = 'Americas',
+}
+

package/src/_enums/sub-region.enum.ts

@@ -0,0 +1,26 @@
+
+export enum SubRegion {
+  northernEurope = 'Northern Europe',
+  southernEurope = 'Southern Europe',
+  westernEurope = 'Western Europe',
+  easternEurope = 'Eastern Europe',
+
+  northernAfrica = 'Northern Africa',
+  subSaharanAfrica = 'Sub-Saharan Africa',
+
+  northernAmerica = 'Northern America',
+  latinAmericaAndTheCaribbean = 'Latin America and the Caribbean',
+
+  southEasternAsia = 'South-eastern Asia',
+  easternAsia = 'Eastern Asia',
+  southernAsia = 'Southern Asia',
+  
+  westernAsia = 'Western Asia',
+  centralAsia = 'Central Asia',
+
+  australiaAndNewZealand = 'Australia and New Zealand',
+  melanesia = 'Melanesia',
+  micronesia = 'Micronesia',
+  polynesia = 'Polynesia',
+}
+

package/src/_models/control-models/country-iso.ts

@@ -0,0 +1,16 @@
+import { Region } from '../../_enums/region.enum';
+import { SubRegion } from '../../_enums/sub-region.enum';
+
+export interface CountryISO {
+  name: string;
+  iso2: string;
+  iso3: string;
+  countryCode: string;
+  fullIso: string;
+  region: Region;
+  regionCode: string;
+  subRegion: SubRegion;
+  subRegionCode: string;
+  subdivisionRegion: string;
+  subdivisionRegionCode: string;
+}

package/src/_models/control-models/country-phone-code.ts

@@ -0,0 +1,7 @@
+
+export interface CountryPhoneCode {
+  country: string;
+  code: string;
+  iso: string;
+}
+

package/src/_models/control-models/dynamo-error.ts

@@ -100,9 +100,9 @@ export class Dynamo_Error {
           }
           if (set.error.userMessages) {            
             if (Array.isArray(set.error.userMessages)) {
-              if (set.error.userMessages[0] == this.userMessages[0]) {
+              /* if (set.error.userMessages[0] == this.userMessages[0]) {
                 set.error.userMessages.shift();
-              }
+              } */
               this.userMessages.push(...set.error.userMessages);
             } else {
               this.userMessages.push(set.error.userMessages);
@@ -116,6 +116,19 @@ export class Dynamo_Error {
       this.message = set?.message ?? this.messages[0];
       this.error = set?.error ?? this.errors[0] ?? new Error(this.message);
 
+      if (0 < this.errorCodes.length && this.errorCode === this.errorCodes[0]) {
+        this.errorCodes.shift();
+      }
+      if (0 < this.userMessages.length && this.userMessage === this.userMessages[0]) {
+        this.userMessages.shift();
+      }
+      if (0 < this.messages.length && this.message === this.messages[0]) {
+        this.messages.shift();
+      }
+      if (0 < this.errors.length && this.error === this.errors[0]) {
+        this.errors.shift();
+      }
+
       if (set.addECToUserMsg) {
         this.userMessage += `\nErrorCode: ${this.errorCode}`
       }

package/src/_models/control-models/random-weight.ts

@@ -0,0 +1,7 @@
+
+
+export interface RandomWeight<T> {
+  chance: number;
+  result: T;
+}
+

package/src/_models/control-models/subdivision-collection.ts

@@ -0,0 +1,10 @@
+
+export interface SubdivisionCollection {
+  [iso2: string]: {
+    name: string;
+    divisions: {
+      [subDivisionCode: string]: string
+    }
+  }
+}
+

package/src/_models/control-models/subdivision-region-data.ts

@@ -0,0 +1,49 @@
+import { CountryISO } from './country-iso';
+
+export interface SubdivisionRegionData extends CountryISO {  
+  type?: SubdivisionRegionType;
+}
+
+
+export enum SubdivisionRegionType {
+  parish,
+  emirate,
+  province,
+  dependency,
+  county,
+  city,
+  region,
+  state,
+  territory,
+  autonomousRepublic,
+  municipate,
+  rayon,
+  division,
+  district,
+  governorate,
+  department,
+  specialMunicipality,
+  federalDistrict,
+  island,
+  town,
+  oblast,
+  commune,
+  prefecture,
+  economicPrefecture,
+  canton,
+  autonomousRegion,
+  specialAdministrativeRegion,
+  capitalDistrict,
+  geographicalRegion,
+  capitalCity,
+  ruralMunicipality,
+  urbanMunicipality,
+  autonomousCommunity,
+  autonomousCity,
+  administration,
+  regionalState,
+  metropolitanRegion,
+  overseasCollectivity,
+  // ... reduce specials // non-finished
+} 
+

package/src/_models/index.ts

@@ -1,15 +1,21 @@
 
 // MODELS
   // Control models
+export * from './control-models/country-iso';
+export * from './control-models/country-phone-code';
 export * from './control-models/dynamo-daily-usage-data';
+export * from './control-models/dynamo-error';
 export * from './control-models/dynamo-nts-data-params';
 export * from './control-models/dynamo-nts-data-property-params';
-export * from './control-models/dynamo-error';
-export * from './control-models/geo-ip-location';
-export * from './control-models/location-coordinates';
+export * from './control-models/dynamo-nts-module-settings';
+export * from './control-models/dynamo-poll';
 export * from './control-models/dynamo-usage-action';
 export * from './control-models/dynamo-usage-data';
-export * from './control-models/dynamo-poll';
+export * from './control-models/geo-ip-location';
+export * from './control-models/location-coordinates';
+export * from './control-models/random-weight';
+export * from './control-models/subdivision-collection';
+export * from './control-models/subdivision-region-data';
   // Data models
 export * from './data-models/dynamo-custom-data';
 export * from './data-models/dynamo-metadata';

package/src/_modules/shared-service.index.ts

@@ -1,6 +1,6 @@
 
 // SHARED SERVICE MODULE
-export * from '../_collections/dynamo-shared.service';
+export * from '../_collections/_tools/dynamo-shared.service';
 export * from '../_constants/times';
 export * from '../_enums/log-style.enum';
 export * from '../_models/control-models/dynamo-error';