@futdevpro/nts-dynamo 1.10.12 → 1.10.15

package/src/_modules/server/error/error.data-service.ts

@@ -13,14 +13,40 @@ import {
   DyFM_Log, DyFM_Shared, DyFM_clone, DyFM_errorFlag, DyFM_Errors
 } from '@futdevpro/fsm-dynamo';
 
+export abstract class DyNTS_Error_ControlService<
+  T_Error extends DyFM_Error,
+  T_Errors extends DyFM_Errors<T_Error>
+> {
+  debugLog: boolean = false;
+  readonly version: string = DyNTS_global_settings.systemVersion;
+  duplicationCounter: number;
+
+  abstract recordError(data?: T_Errors, alwaysRecord?: boolean): Promise<void>;
+
+  abstract handleInternalError(
+    error: DyFM_AnyError | any, 
+    issuer: string,
+    alwaysRecord?: boolean,
+  ): Promise<void>;
+
+  abstract checkErrorIsStringifyableOrResolvable(error: T_Error): T_Error | 'UNRESOLVABLE';
+
+  abstract getPriorityMultiplierByLevel(level: DyFM_ErrorLevel): number;
+
+  abstract getErrorsFromDate(
+    date: Date,
+    issuer: string,
+  ): Promise<T_Errors[]>;
+}
 
 export class DyNTS_Error_DataService<
-  T_Error extends DyFM_Errors
-> extends DyNTS_DataService<T_Error> {
+  T_Error extends DyFM_Error,
+  T_Errors extends DyFM_Errors<T_Error>
+> extends DyNTS_DataService<T_Errors> implements DyNTS_Error_ControlService<T_Error, T_Errors> {
 
   debugLog: boolean = false;
   readonly version: string = DyNTS_global_settings.systemVersion;
-  protected duplicationCounter: number;
+  duplicationCounter: number;
 
   /* constructor(
     set: {
@@ -30,13 +56,13 @@ export class DyNTS_Error_DataService<
     dataParams: DyFM_DataModel_Params<T_Error>
   ) {
     super(
-      new FDP_Error(set?.data) as T_Error,
+      new FDP_Errors(set?.data) as T_Error,
       dataParams,
       set.issuer
     );
   } */
 
-  async recordError(data?: T_Error, alwaysRecord?: boolean): Promise<void> {
+  async recordError(data?: T_Errors, alwaysRecord?: boolean): Promise<void> {
     try {
       if (
         !alwaysRecord &&
@@ -60,7 +86,7 @@ export class DyNTS_Error_DataService<
             new Error('error data is not defined')
           ),
   
-          errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-EDS-RE1`,
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-RE1`,
         });
       }
 
@@ -74,12 +100,12 @@ export class DyNTS_Error_DataService<
         data.message += '\n' + data.exception.split('() (at <')[0];
       }
 
-      const duplicateError: T_Error = await this.findData({
+      const duplicateError: T_Errors = await this.findData({
         version: data.version,
         message: data.message,
-      } as DyFM_DBFilter<T_Error>, true);
+      } as DyFM_DBFilter<T_Errors>, true);
 
-      data.d_error = this.checkErrorIsStringifyableOrResolvable(data.d_error) as DyFM_Error;
+      data.d_error = this.checkErrorIsStringifyableOrResolvable(data.d_error) as T_Error;
       
       try {
         JSON.stringify(data);
@@ -113,10 +139,10 @@ export class DyNTS_Error_DataService<
         this.duplicationCounter = duplicateError.count + 1;
 
         await this.updateData({
-          filterBy: { _id: duplicateError._id } as DyFM_DBFilter<T_Error>,
+          filterBy: { _id: duplicateError._id } as DyFM_DBFilter<T_Errors>,
           update: { 
             $inc: { count: 1, priority: this.getPriorityMultiplierByLevel(data?.level) },
-          } as DyNTS_DBUpdate<T_Error>,
+          } as DyNTS_DBUpdate<T_Errors>,
         });
 
         // ezt majd ha leülepedett, hogy biztos nem kellenek a deep duplication-ök 
@@ -165,48 +191,11 @@ export class DyNTS_Error_DataService<
           error
         ),
 
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-EDS-RE0`,
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-RE0`,
       }); */
     }
   }
 
-  async preProcessWBError(): Promise<void> {
-    try {
-      const innerError = this.data?.error;
-
-      if (
-        innerError && 
-        !innerError?.message &&
-        !innerError?.userMessage &&
-        !innerError?.d_error?.message &&
-        !innerError?.d_error?.userMessage
-      ) {
-        delete this.data.error;
-      }
-
-      const innerDError: DyFM_Error = this.data?.d_error;
-
-      if (
-        innerDError && 
-        !innerDError?._message &&
-        !innerDError?.__userMessage &&
-        !innerDError?._errorCode
-      ) {
-        delete this.data.d_error;
-      }
-
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings(
-          'preProcessWBError',
-          error
-        ),
-
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-EDS-PPE0`,
-      });
-    }
-  }
-
   async handleInternalError(
     error: DyFM_AnyError | any, 
     issuer: string,
@@ -233,7 +222,7 @@ export class DyNTS_Error_DataService<
             ),
 
           additionalContent: (error as DyFM_Error)?.additionalContent,
-        }) as T_Error;       
+        }) as T_Errors;       
       } else {
         this.data = new DyFM_Errors({
           issuer: issuer,
@@ -247,10 +236,10 @@ export class DyNTS_Error_DataService<
 
           message: (error as Error)?.message,
           exceptionObj: (error as Error)?.stack?.split('\n'),
-        }) as T_Error;
+        }) as T_Errors;
       }
 
-      /* if (!(error as FDP_Error)?.flag?.includes('WB-ERROR-OBJECT')) {
+      /* if (!(error as FDP_Errors)?.flag?.includes('WB-ERROR-OBJECT')) {
         DyFM_Log.H_error('__ERROR__:', error);
       } */
 
@@ -261,12 +250,12 @@ export class DyNTS_Error_DataService<
         !(error instanceof DyFM_Error)
       ) {
         DyFM_Log.H_error(
-          `FDPNTS_Error_DataService handling InternalError...`,
+          `DyNTS_Error_DataService handling InternalError...`,
           `\n    ERROR:`, error
         );
       } else {
         error.logSimple(
-          `FDPNTS_Error_DataService handling InternalError...`
+          `DyNTS_Error_DataService handling InternalError...`
         );
       }
     } catch (error) {
@@ -277,18 +266,18 @@ export class DyNTS_Error_DataService<
           error
         ),
 
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-EDS-HIE0`,
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-HIE0`,
       }); */
     }
   }
 
-  private checkErrorIsStringifyableOrResolvable(error: DyFM_Error): DyFM_Error | 'UNRESOLVABLE' {
+  checkErrorIsStringifyableOrResolvable(error: T_Error): T_Error | 'UNRESOLVABLE' {
     try {
       JSON.stringify(error);
     } catch (err) {
       DyFM_Log.error('error data is not stringifyable! trying to resolve...');
 
-      error = DyFM_Shared.resolveCirculation(error) as DyFM_Error;
+      error = DyFM_Shared.resolveCirculation(error) as T_Error;
 
       try {
         JSON.stringify(error);
@@ -307,10 +296,10 @@ export class DyNTS_Error_DataService<
       }
     }   
 
-    return error;
+    return error as T_Error;
   }
 
-  private getPriorityMultiplierByLevel(level: DyFM_ErrorLevel): number {
+  getPriorityMultiplierByLevel(level: DyFM_ErrorLevel): number {
     switch (level) {
       case DyFM_ErrorLevel.critical: 
       case DyFM_ErrorLevel.fatal:
@@ -334,4 +323,22 @@ export class DyNTS_Error_DataService<
     }
   }
 
+  async getErrorsFromDate(
+    date: Date,
+    issuer: string,
+  ): Promise<T_Errors[]> {
+    try {
+      return await this.findDataList({ __created: { $gte: date } });
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'getErrorsFromDate',
+          error
+        ),
+        
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-GED0`,
+      });
+    }
+  }
+
 }

package/src/_modules/server/server-status/server-status.control-service.ts

@@ -9,15 +9,19 @@ import { version as _serverVersion } from '../../../../package.json';
 import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
 import { DyNTS_DataService } from '../../../_services/base/data.service';
 import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-import { DyNTS_Error_DataService } from '../error/error.data-service';
+import { DyNTS_Error_ControlService, DyNTS_Error_DataService } from '../error/error.data-service';
+
+
 
 export abstract class DyNTS_ServerStatus_ControlService<
-  T_Error extends DyFM_Errors,
-  T_ServerStatus extends DyFM_ServerStatus
+  T_Error extends DyFM_Error,
+  T_Errors extends DyFM_Errors<T_Error>,
+  T_ServerStatus extends DyFM_ServerStatus,
+  T_Error_ControlService extends DyNTS_Error_ControlService<T_Error, T_Errors>
 > extends DyNTS_SingletonService {
 
-  /* static getInstance(): FDPNTS_ServerStatus_ControlService {
-    return FDPNTS_ServerStatus_ControlService.getSingletonInstance();
+  /* static getInstance(): DyNTS_ServerStatus_ControlService {
+    return DyNTS_ServerStatus_ControlService.getSingletonInstance();
   } */
 
   /* protected constructor() {
@@ -27,16 +31,16 @@ export abstract class DyNTS_ServerStatus_ControlService<
       throw new DyFM_Error({
         message: 'getErrorDataService() method not implemented in ServerStatus_ControlService.',
         status: 500,
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-SSS-GED0',
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SSS-GED0',
       });
     }
   } */
 
-  protected abstract getErrorDataService?(
-    set?: { data?: T_Error, issuer?: string }
-  ): DyNTS_Error_DataService<T_Error>;
+  protected abstract getErrorControlService?(
+    set?: { data?: T_Errors, issuer?: string }
+  ): T_Error_ControlService;
 
-  /* protected abstract error_DS: FDPNTS_Error_DataService<T_Error>; */
+  /* protected abstract error_DS: DyNTS_Error_DataService<T_Error>; */
 
   protected readonly up: Date = new Date();
 
@@ -76,85 +80,83 @@ export abstract class DyNTS_ServerStatus_ControlService<
     issuer: string
   ): Promise<DyFM_Error_Statistics> {
     try {
-      const error_DS: DyNTS_Error_DataService<T_Error> = 
-        this.getErrorDataService({ issuer: issuer });
-        /* new FDPNTS_Error_DataService({ issuer: issuer }); */
+      const error_DS: T_Error_ControlService = 
+        this.getErrorControlService({ issuer: issuer });
+        /* new DyNTS_Error_DataService({ issuer: issuer }); */
 
       const from: Date = DyFM_Time.getDateByRelativeDate(range);
-      const errors: T_Error[] = await error_DS.findDataList({ 
-        __created: { $gte: from },
-      });
+      const errors: T_Errors[] = await error_DS.getErrorsFromDate(from, issuer);
 
       return {
         range: range,
 
         allErrors: errors.length,
         allAllErrors: errors.reduce(
-          (sum: number, error: T_Error): number => sum + error.count, 
+          (sum: number, error: T_Errors): number => sum + error.count, 
           0
         ),
 
         serverErrors: 
           errors.filter(
-            (error: T_Error): boolean => error.source.includes('SERVER')
+            (error: T_Errors): boolean => error.source.includes('SERVER')
           ).length,
         clientErrors:
           errors.filter(
-            (error: T_Error): boolean => !error.source.includes('SERVER')
+            (error: T_Errors): boolean => !error.source.includes('SERVER')
           ).length,
         allServerErrors: 
           errors.filter(
-            (error: T_Error): boolean => error.source.includes('SERVER')
+            (error: T_Errors): boolean => error.source.includes('SERVER')
           ).reduce(
-            (sum: number, error: T_Error): number => sum + error.count, 0
+            (sum: number, error: T_Errors): number => sum + error.count, 0
           ),
         allClientErrors: 
           errors.filter(
-            (error: T_Error): boolean => !error.source.includes('SERVER')
+            (error: T_Errors): boolean => !error.source.includes('SERVER')
           ).reduce(
-            (sum: number, error: T_Error): number => sum + error.count, 0
+            (sum: number, error: T_Errors): number => sum + error.count, 0
           ),
 
         infoErrors: 
           errors.filter(
-            (error: T_Error): boolean => error.level === DyFM_ErrorLevel.info
+            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.info
           ).length,
         warningErrors: 
           errors.filter(
-            (error: T_Error): boolean => error.level === DyFM_ErrorLevel.warning
+            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.warning
           ).length,
         errorErrors: 
           errors.filter(
-            (error: T_Error): boolean => error.level === DyFM_ErrorLevel.error
+            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.error
           ).length,
         criticalErrors: 
           errors.filter(
-            (error: T_Error): boolean => error.level === DyFM_ErrorLevel.critical
+            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.critical
           ).length,
 
         allInfoErrors: 
           errors.filter(
-            (error: T_Error): boolean => error.level === DyFM_ErrorLevel.info
+            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.info
           ).reduce(
-            (sum: number, error: T_Error): number => sum + error.count, 0
+            (sum: number, error: T_Errors): number => sum + error.count, 0
           ),
         allWarningErrors: 
           errors.filter(
-            (error: T_Error): boolean => error.level === DyFM_ErrorLevel.warning
+            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.warning
           ).reduce(
-            (sum: number, error: T_Error): number => sum + error.count, 0
+            (sum: number, error: T_Errors): number => sum + error.count, 0
           ),
         allErrorErrors: 
           errors.filter(
-            (error: T_Error): boolean => error.level === DyFM_ErrorLevel.error
+            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.error
           ).reduce(
-            (sum: number, error: T_Error): number => sum + error.count, 0
+            (sum: number, error: T_Errors): number => sum + error.count, 0
           ),
         allCriticalErrors: 
           errors.filter(
-            (error: T_Error): boolean => error.level === DyFM_ErrorLevel.critical
+            (error: T_Errors): boolean => error.level === DyFM_ErrorLevel.critical
           ).reduce(
-            (sum: number, error: T_Error): number => sum + error.count, 0
+            (sum: number, error: T_Errors): number => sum + error.count, 0
           ),
       } as DyFM_Error_Statistics;
     } catch (error) {
@@ -165,7 +167,7 @@ export abstract class DyNTS_ServerStatus_ControlService<
           issuer
         ),
 
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-SSS-GES0`,
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SSS-GES0`,
       });
     }
   }

package/src/_modules/server/server-status/server-status.controller.ts

@@ -6,6 +6,7 @@ import { DyNTS_ServerStatus_ControlService } from './server-status.control-servi
 import { DyNTS_Controller } from '../../../_services/route/controller.service';
 import { DyNTS_Endpoint_Params } from '../../../_models/control-models/endpoint-params.control-model';
 import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_Error_DataService } from '../error/error.data-service';
 
 
 /**
@@ -22,13 +23,19 @@ import { DyNTS_global_settings } from '../../../_collections/global-settings.con
  * 
  */
 export abstract class DyNTS_ServerStatus_Controller<
-  T_Error extends DyFM_Errors,
+  T_Error extends DyFM_Error,
+  T_Errors extends DyFM_Errors<T_Error>,
   T_ServerStatus extends DyFM_ServerStatus,
-  T_ServerStatusService extends DyNTS_ServerStatus_ControlService<T_Error, T_ServerStatus>
+  T_ServerStatusService extends DyNTS_ServerStatus_ControlService<
+    T_Error, 
+    T_Errors, 
+    T_ServerStatus, 
+    DyNTS_Error_DataService<T_Error, T_Errors>
+  >
 > extends DyNTS_Controller {
 
-  /* static getInstance(): FDPNTS_ServerStatus_Controller {
-    return FDPNTS_ServerStatus_Controller.getSingletonInstance();
+  /* static getInstance(): DyNTS_ServerStatus_Controller {
+    return DyNTS_ServerStatus_Controller.getSingletonInstance();
   } */
 
   protected abstract readonly server_CS: T_ServerStatusService;
@@ -40,7 +47,7 @@ export abstract class DyNTS_ServerStatus_Controller<
     /* if (!this.getServerService) {
       throw new DyFM_Error({
         message: 'getServerService() method not implemented in ServerStatus_Controller.',
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-SSC-001`,
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SSC-001`,
       });
     } */
 

package/src/_modules/socket/_models/socket-presence.control-model.ts

@@ -3,6 +3,7 @@ import {
   DyFM_AnyError, DyFM_Error, DyFM_Error_Settings, DyFM_Log
 } from '@futdevpro/fsm-dynamo';
 import * as SocketIO from 'socket.io';
+import { DyNTS_global_settings } from '../../..';
 
 /**
  * socket handling and clarification is under development
@@ -53,7 +54,7 @@ export class DyNTS_SocketPresence {
           ),
           set?.issuer
         ),
-        errorCode: 'NTS-SD0-C00',
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SD0-C00`,
         additionalContent: { set: set },
       });
     }
@@ -83,7 +84,7 @@ export class DyNTS_SocketPresence {
           set?.issuer
         ),
 
-        errorCode: 'NTS-SD0-C01',
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SD0-C01`,
       });
     }
 
@@ -112,7 +113,7 @@ export class DyNTS_SocketPresence {
           ),
           issuer
         ),
-        errorCode: 'NTS-SPC-EE1',
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SPC-EE1`,
       });
     }
 
@@ -126,7 +127,7 @@ export class DyNTS_SocketPresence {
         /* errors.push(
           new DyFM_Error({
             status: 500,
-            errorCode: 'NTS-SPC-EE2',
+            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SPC-EE2',
             addECToUserMsg: true,
             message: 
             `Emitting event '${event}' on socket(${this.serviceName})-(${index}) failed!`+
@@ -179,7 +180,7 @@ export class DyNTS_SocketPresence {
           issuer
         ),
 
-        errorCode: 'NTS-SPC-EE3',
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SPC-EE3`,
         additionalContent: {
           inactiveSockets: inactiveSockets,
           errors: errors,
@@ -196,7 +197,7 @@ export class DyNTS_SocketPresence {
           ),
           issuer
         ),
-        errorCode: 'NTS-SPC-EE3',
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SPC-EE3`,
       });
     }
   }

package/src/_modules/socket/_services/socket-client.service.ts

@@ -125,7 +125,7 @@ export abstract class DyNTS_SocketClient_ServiceBase extends DyNTS_SingletonServ
       DyFM_Log.error(`socket-client(${this.params?.name}) Service setup failed!`, error);
 
       throw new DyFM_Error({
-        errorCode: 'NTS-SCS-001',
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-SCS-001`,
         error: error,        
       });
     }