@futdevpro/nts-dynamo 1.10.14 → 1.10.16

package/src/_modules/server/{error/error.controller.ts → errors/errors.controller.ts}

@@ -1,10 +1,10 @@
 
 import { Request, Response } from 'express';
 
-import { DyFM_Array, DyFM_Error, DyFM_HttpCallType, DyFM_Errors } from '@futdevpro/fsm-dynamo';
+import { DyFM_Array, DyFM_Error, DyFM_HttpCallType, DyFM_Errors, DyFM_RelativeDate } from '@futdevpro/fsm-dynamo';
 import { DyNTS_Controller } from '../../../_services/route/controller.service';
 import { DyNTS_Endpoint_Params } from '../../../_models/control-models/endpoint-params.control-model';
-import { DyNTS_Error_DataService } from './error.data-service';
+import { DyNTS_Errors_ControlService } from './errors.control-service';
 import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
 
 /**
@@ -30,34 +30,37 @@ import { DyNTS_global_settings } from '../../../_collections/global-settings.con
  * 
  *  
  */
-export abstract class DyNTS_Error_Controller<
+// Documentation: 
+// Local: [MD](./errors.md)
+// 
+export abstract class DyNTS_Errors_Controller<
   T_Error extends DyFM_Error,
   T_Errors extends DyFM_Errors<T_Error>,
-  T_ErrorDataService extends DyNTS_Error_DataService<T_Error, T_Errors>
+  T_Error_ControlService extends DyNTS_Errors_ControlService<T_Error, T_Errors>
 > extends DyNTS_Controller {
 
-  /* static getInstance(): FDPNTS_Error_Controller {
-    return FDPNTS_Error_Controller.getSingletonInstance();
+  /* static getInstance(): DyNTS_Error_Controller {
+    return DyNTS_Error_Controller.getSingletonInstance();
   } */
 
-  /* protected abstract errorDataService: FDPNTS_Error_DataService<T_Error>; */
-  protected abstract getErrorDataService?(
+  /* protected abstract errorDataService: DyNTS_Error_DataService<T_Error>; */
+  protected abstract getError_ControlService?(
     set?: { data?: T_Error, issuer?: string }
-  ): T_ErrorDataService;
+  ): T_Error_ControlService;
   protected readonly additionalEndpoints: DyNTS_Endpoint_Params[] = [];
 
   setupEndpoints(): void {
     /* if (!this.getErrorDataService) {
       throw new DyFM_Error({
         message: 'getUserDataService() method not implemented in Error_Controller.',
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-ERC-001`,
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-ERC-001`,
       });
     } */
 
     if (!this.additionalEndpoints) {
       throw new DyFM_Error({
         message: 'additionalEndpoints must be defined in Error_Controller.',
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-ERC-002`,
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-ERC-002`,
       });
     }
 
@@ -68,12 +71,12 @@ export abstract class DyNTS_Error_Controller<
         endpoint: '/error/log',
         tasks: [
           async (req: Request, res: Response, issuer?: string): Promise<void> => {
-            const error_DS: T_ErrorDataService = this.getErrorDataService({
+            const error_CS: T_Error_ControlService = this.getError_ControlService({
               data: req.body,
               issuer: issuer ?? req.body?.issuer ?? 'unknown-client',
             });
 
-            await error_DS.recordError();
+            await error_CS.recordError();
 
             res.send({
               result: 'error logged',
@@ -88,11 +91,11 @@ export abstract class DyNTS_Error_Controller<
         endpoint: '/error/mark-done/:errorId',
         tasks: [
           async (req: Request, res: Response, issuer?: string): Promise<void> => {
-            const error_DS: T_ErrorDataService = this.getErrorDataService({
+            const error_CS: T_Error_ControlService = this.getError_ControlService({
               issuer: issuer,
             });
   
-            await error_DS.deleteData(req.params.errorId, true);
+            await error_CS.deleteError(req.params.errorId, true);
   
             res.send({
               result: 'error deleted',
@@ -107,11 +110,11 @@ export abstract class DyNTS_Error_Controller<
         endpoint: '/error/mark-all-done',
         tasks: [
           async (req: Request, res: Response, issuer?: string): Promise<void> => {
-            const error_DS: T_ErrorDataService = this.getErrorDataService({
+            const error_CS: T_Error_ControlService = this.getError_ControlService({
               issuer: issuer,
             });
   
-            await error_DS.deleteAllData(true);
+            await error_CS.deleteAllErrors(true);
   
             res.send({
               result: 'all error deleted',
@@ -126,7 +129,7 @@ export abstract class DyNTS_Error_Controller<
         endpoint: '/mark-error-done/:errorId',
         tasks: [
           async (req: Request, res: Response, issuer?: string): Promise<void> => {
-            const errorDataService: FDPNTS_Error_DataService<Error_T> = this.getErrorDataService({
+            const errorDataService: DyNTS_Error_DataService<Error_T> = this.getErrorDataService({
               data: { _id: req.params.errorId },
               issuer: issuer,
             });
@@ -146,14 +149,12 @@ export abstract class DyNTS_Error_Controller<
         endpoint: '/error/get-range/:range',
         tasks: [
           async (req: Request, res: Response, issuer: string) : Promise<void> => {
-            const error_DS: T_ErrorDataService = this.getErrorDataService({
+            const error_CS: T_Error_ControlService = this.getError_ControlService({
               issuer: issuer,
             });
 
             res.send(
-              (await error_DS.getAll()).sort(
-                (a, b): number => b.priority - a.priority
-              ).slice(0, 10)
+              await error_CS.getErrorsInRange(req.params.range as DyFM_RelativeDate)
             );
           },
         ],
@@ -165,7 +166,7 @@ export abstract class DyNTS_Error_Controller<
         endpoint: '/error/get-paged/:range/:pageSize/:pageIndex',
         tasks: [
           async (req: Request, res: Response, issuer: string) : Promise<void> => {
-            const error_DS: T_ErrorDataService = this.getErrorDataService({
+            const error_CS: T_Error_ControlService = this.getError_ControlService({
               issuer: issuer,
             });
 
@@ -179,9 +180,11 @@ export abstract class DyNTS_Error_Controller<
             }
 
             res.send(
-              (await error_DS.getAll()).sort(
-                (a, b): number => b.priority - a.priority
-              ).slice(pageIndex * pageSize, (pageIndex + 1) * pageSize)
+              await error_CS.getErrorsPaged(
+                req.params.range as DyFM_RelativeDate, 
+                pageSize, 
+                pageIndex
+              )
             );
           },
         ],
@@ -193,7 +196,7 @@ export abstract class DyNTS_Error_Controller<
         endpoint: '/error/get-last-paged/:range/:pageSize/:pageIndex',
         tasks: [
           async (req: Request, res: Response, issuer: string) : Promise<void> => {
-            const error_DS: T_ErrorDataService = this.getErrorDataService({
+            const error_CS: T_Error_ControlService = this.getError_ControlService({
               issuer: issuer,
             });
 
@@ -207,15 +210,28 @@ export abstract class DyNTS_Error_Controller<
             }
 
             res.send(
-              DyFM_Array.paged(
-                (await error_DS.getAll()).sort(
-                  (a, b): number => +b.__lastModified - +a.__lastModified
-                ),
-                pageIndex, pageSize
+              await error_CS.getLastErrors(
+                req.params.range as DyFM_RelativeDate, 
+                pageSize, 
+                pageIndex
               )
-              /* (await errorDataService.getAll()).sort(
-                (a, b): number => +b.__lastModified - +a.__lastModified
-              ).slice(pageIndex * pageSize, (pageIndex + 1) * pageSize) */
+            );
+          },
+        ],
+      }),
+
+      new DyNTS_Endpoint_Params({
+        name: 'searchErrors',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/error/search',
+        tasks: [
+          async (req: Request, res: Response, issuer: string) : Promise<void> => {
+            const error_CS: T_Error_ControlService = this.getError_ControlService({
+              issuer: issuer,
+            });
+
+            res.send(
+              await error_CS.searchErrors(req.body)
             );
           },
         ],

package/src/_modules/server/{error/error.data-service.ts → errors/errors.data-service.ts}

@@ -2,42 +2,28 @@
 
 
 
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-import { DyNTS_DBUpdate } from '../../../_models/types/db-update.type';
-import { DyNTS_DataService } from '../../../_services/base/data.service';
-
 import {
   DyFM_AnyError,
   DyFM_DBFilter,
   DyFM_DataModel_Params, DyFM_Error, DyFM_ErrorLevel, DyFM_Error_Settings,
-  DyFM_Log, DyFM_Shared, DyFM_clone, DyFM_errorFlag, DyFM_Errors
+  DyFM_Log, DyFM_Shared, DyFM_clone, DyFM_errorFlag, DyFM_Errors,
+  DyFM_RelativeDate,
+  DyFM_Array,
+  DyFM_Paged,
+  DyFM_Time,
+  DyFM_SearchQuery,
+  DyFM_SearchResult
 } 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;
-}
+import { DyNTS_Errors_ControlService } from './errors.control-service';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_DBUpdate } from '../../../_models/types/db-update.type';
+import { DyNTS_DataService } from '../../../_services/base/data.service';
 
-export class DyNTS_Error_DataService<
+export class DyNTS_Errors_DataService<
   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> {
+> extends DyNTS_DataService<T_Errors> implements DyNTS_Errors_ControlService<T_Error, T_Errors> {
 
   debugLog: boolean = false;
   readonly version: string = DyNTS_global_settings.systemVersion;
@@ -51,7 +37,7 @@ 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
     );
@@ -81,7 +67,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`,
         });
       }
 
@@ -186,7 +172,7 @@ export class DyNTS_Error_DataService<
           error
         ),
 
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-EDS-RE0`,
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-RE0`,
       }); */
     }
   }
@@ -234,7 +220,7 @@ export class DyNTS_Error_DataService<
         }) 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);
       } */
 
@@ -245,12 +231,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) {
@@ -261,7 +247,7 @@ export class DyNTS_Error_DataService<
           error
         ),
 
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-EDS-HIE0`,
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-HIE0`,
       }); */
     }
   }
@@ -318,4 +304,122 @@ export class DyNTS_Error_DataService<
     }
   }
 
+  async getErrorsFromDate(
+    date: Date,
+    issuer: string,
+  ): Promise<DyFM_Paged<T_Errors>> {
+    try {
+      const errors: T_Errors[] = await this.findDataList({ __created: { $gte: date } });
+
+      return DyFM_Array.paged(errors, 0, 100);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'getErrorsFromDate',
+          error
+        ),
+        
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-GED0`,
+      });
+    }
+  }
+
+  async deleteError(errorId: string, alwaysDelete?: boolean): Promise<void> {
+    try {
+      await this.deleteData(errorId, alwaysDelete);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('deleteError', error),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-DE0`,
+      });
+    }
+  }
+
+  async deleteAllErrors(alwaysDelete?: boolean): Promise<void> {
+    try {
+      await this.deleteAllData(alwaysDelete);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('deleteAllErrors', error),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-DAE0`,
+      });
+    }
+  }
+
+  async getErrorsInRange(range: DyFM_RelativeDate): Promise<DyFM_Paged<T_Errors>> {
+    try {
+      const fromDate: Date = DyFM_Time.getDateByRelativeDate(range);
+
+      let errors: T_Errors[] = await this.findDataList({ __lastModified: { $gte: fromDate } }); 
+      errors = errors.sort(
+        (a, b): number => b.priority - a.priority
+      );
+
+      return DyFM_Array.paged(errors, 0, 10);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('getErrorsInRange', error),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-GIR0`,
+      });
+    }
+  }
+
+  async getErrorsPaged(
+    range: DyFM_RelativeDate,
+    pageSize: number,
+    pageIndex: number,
+  ): Promise<DyFM_Paged<T_Errors>> {
+    try {
+      const fromDate: Date = DyFM_Time.getDateByRelativeDate(range);
+
+      let errors: T_Errors[] = await this.findDataList({ __lastModified: { $gte: fromDate } }); 
+      errors = errors.sort(
+        (a, b): number => b.priority - a.priority
+      );
+
+      return DyFM_Array.paged(errors, pageIndex, pageSize);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('getErrorsPaged', error),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-GIP0`,
+      });
+    }
+  }
+
+  async getLastErrors(
+    range: DyFM_RelativeDate,
+    pageSize: number,
+    pageIndex: number,
+  ): Promise<DyFM_Paged<T_Errors>> {
+    try {
+      const fromDate: Date = DyFM_Time.getDateByRelativeDate(range);
+
+      let errors: T_Errors[] = await this.findDataList({ 
+        __lastModified: { $gte: fromDate } 
+      });
+      errors = errors.sort(
+        (a, b): number => +b.__lastModified - +a.__lastModified
+      );
+
+      return DyFM_Array.paged(errors, pageIndex, pageSize);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('getLastErrors', error),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-GLE0`,
+      });
+    }
+  }
+
+  async searchErrors(
+    searchQuery: DyFM_SearchQuery<T_Errors>,
+  ): Promise<DyFM_SearchResult<T_Errors>> {
+    try { 
+      return await this.searchData(searchQuery);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('searchErrors', error),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-SE0`,
+      });
+    }
+  }
 }

package/src/_modules/server/index.ts

@@ -1,7 +1,7 @@
 
 // ERROR
-export * from './error/error.controller';
-export * from './error/error.data-service';
+export * from './errors/errors.controller';
+export * from './errors/errors.control-service';
 
 // SERVER-STATUS
 export * from './server-status/server-status.control-service';

package/src/_modules/server/server-status/server-status-snapshot.data-service.ts

@@ -0,0 +1,45 @@
+
+
+
+
+/* import { ServerStatus_ControlService } from './server-status.control-service'; */
+
+import { DyFM_Error, DyFM_ServerStatus } from '@futdevpro/fsm-dynamo';
+import { DyNTS_DataService } from '../../../_services/base/data.service';
+
+export class DyNTS_ServerStatusSnapshot_DataService<
+  T_ServerStatus extends DyFM_ServerStatus
+> extends DyNTS_DataService<T_ServerStatus> {
+
+  /* constructor(
+    set: {
+      data?: T_ServerStatus,
+      issuer: string,
+    }
+  ) {
+    super(
+      new T_ServerStatus(set?.data),
+      set?.issuer,
+    );
+  } */
+
+  /* async getServerSnapshot(): Promise<CCAP_ServerStatusSnapshot> {
+    try {
+      const serverStatus_CS: ServerStatus_ControlService = 
+        ServerStatus_ControlService.getInstance();
+      
+      return new CCAP_ServerStatusSnapshot({
+        ...serverStatus_CS.getServerStatus(),
+      });
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'getMatchStatistics',
+          error?.response?.data ?? error
+        ),
+
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-SSS-GES0',
+      });
+    }
+  } */
+}

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

@@ -2,43 +2,27 @@
 
 import { 
   DyFM_Metadata, DyFM_RelativeDate, DyFM_Time, DyFM_ServerStatus, DyFM_ErrorLevel, DyFM_Log, 
-  DyFM_Error, DyFM_Error_Statistics, DyFM_Errors 
+  DyFM_Error, DyFM_Error_Statistics, DyFM_Errors, 
+  DyFM_Paged
 } from '@futdevpro/fsm-dynamo';
 
 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_Errors_ControlService } from '../errors/errors.control-service';
+
+
 
 export abstract class DyNTS_ServerStatus_ControlService<
   T_Error extends DyFM_Error,
   T_Errors extends DyFM_Errors<T_Error>,
   T_ServerStatus extends DyFM_ServerStatus,
-  T_ErrorDataService extends DyNTS_Error_DataService<T_Error, T_Errors>
+  T_Error_ControlService extends DyNTS_Errors_ControlService<T_Error, T_Errors>
 > extends DyNTS_SingletonService {
 
-  /* static getInstance(): FDPNTS_ServerStatus_ControlService {
-    return FDPNTS_ServerStatus_ControlService.getSingletonInstance();
-  } */
-
-  /* protected constructor() {
-    super();
-
-    if (!this.getErrorDataService) {
-      throw new DyFM_Error({
-        message: 'getErrorDataService() method not implemented in ServerStatus_ControlService.',
-        status: 500,
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-SSS-GED0',
-      });
-    }
-  } */
-
-  protected abstract getErrorDataService?(
+  protected abstract getErrorControlService?(
     set?: { data?: T_Errors, issuer?: string }
-  ): T_ErrorDataService;
-
-  /* protected abstract error_DS: FDPNTS_Error_DataService<T_Error>; */
+  ): T_Error_ControlService;
 
   protected readonly up: Date = new Date();
 
@@ -53,8 +37,6 @@ export abstract class DyNTS_ServerStatus_ControlService<
 
   override readonly defaultErrorUserMsg = 'Something went wrong';
 
-  /* private readonly serverSnapshotOverseer  */
-
   getServerStatus(clientVersion?: string): DyFM_ServerStatus {
     return {
       status: 'ready',
@@ -78,14 +60,13 @@ export abstract class DyNTS_ServerStatus_ControlService<
     issuer: string
   ): Promise<DyFM_Error_Statistics> {
     try {
-      const error_DS: T_ErrorDataService = 
-        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_Errors[] = await error_DS.findDataList({ 
-        __created: { $gte: from },
-      });
+      const errorsPaged: DyFM_Paged<T_Errors> = await error_DS.getErrorsFromDate(from, issuer);
+      const errors: T_Errors[] = errorsPaged.items;
 
       return {
         range: range,
@@ -167,7 +148,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

@@ -2,11 +2,11 @@
 import { Request, Response } from 'express';
 
 import { DyFM_Error, DyFM_Errors, DyFM_HttpCallType, DyFM_RelativeDate, DyFM_ServerStatus } from '@futdevpro/fsm-dynamo';
-import { DyNTS_ServerStatus_ControlService } from './server-status.control-service';
+import { DyNTS_Errors_ControlService } from '../errors/errors.control-service';
 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';
+import { DyNTS_ServerStatus_ControlService } from './server-status.control-service';
 
 
 /**
@@ -30,12 +30,12 @@ export abstract class DyNTS_ServerStatus_Controller<
     T_Error, 
     T_Errors, 
     T_ServerStatus, 
-    DyNTS_Error_DataService<T_Error, T_Errors>
+    DyNTS_Errors_ControlService<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;
@@ -47,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`,
       });
     }
   }