@futdevpro/nts-dynamo 1.5.88 → 1.5.92

package/src/_services/dynamo-nts-socket-client.service.ts

@@ -0,0 +1,63 @@
+
+
+
+import * as SocketIO from 'socket.io-client';
+
+import { DynamoNTS_SingletonService } from './dynamo-nts-singleton.service';
+import { Dynamo_Log } from '@futdevpro/fsm-dynamo';
+import { DynamoNTS_SocketClientServiceParams } from '../_models/control-models/dynamo-nts-socket-client-service-params.model';
+import { dynamoNTS_GlobalSettings } from '../_constants/dynamo-nts-global-settings.const';
+import { DynamoNTS_SocketEvent } from '../_models/control-models/dynamo-nts-socket-event.model';
+import { DynamoNTS_SocketEventType } from '../_enums/http/dynamo-nts-socket-event-type.enum';
+
+
+export abstract class SocketClientService extends DynamoNTS_SingletonService {
+
+  private _params: DynamoNTS_SocketClientServiceParams;
+  protected get params(): DynamoNTS_SocketClientServiceParams { return this._params; }
+
+  protected log: boolean = dynamoNTS_GlobalSettings.logSetup;
+
+  socket: SocketIO.Socket
+  
+  protected incomingEvents: DynamoNTS_SocketEvent<any>[];
+
+  private constructor() {
+    super();
+
+    try {
+      this.incomingEvents = this.getIncomingEvents() ?? [];
+      
+      this.connectSocket();
+
+      if (this.log) console.log(`Socket Controller setup done: ${this.params.name} (${this.params.port})\n`);
+    } catch (error) {
+      Dynamo_Log.error(`Socket Client setup failed: ${this.params.name} (${this.params.port})`, error);
+    }
+  }
+  
+  private connectSocket(): void {
+    this.socket = SocketIO.connect(`${this.params.address}:${this.params.port}`).on('connect', () => {
+      this.incomingEvents.forEach((event: DynamoNTS_SocketEvent<any>) => {
+        this.socket.on(event.event, async (content: any) => { 
+          try {
+            await event.executeEventTasks(this.params.service, content);
+          } catch (error) {
+            Dynamo_Log.error(`Socket Event failed: ${this.params.name} (${this.params.port})`, error);
+            this.socket.emit(DynamoNTS_SocketEventType.error, error);
+          }
+        });
+      });
+    });
+  }
+  
+  /**
+   * You must setup params for the service in this function
+   */
+  abstract getParams(): DynamoNTS_SocketClientServiceParams;
+
+  /**
+   * You must setup events and required services in this function
+   */
+  abstract getIncomingEvents(): DynamoNTS_SocketEvent<any>[];
+}

package/src/_services/{dynamo-nts-socket-service-collection.service.ts → dynamo-nts-socket-server-service-collection.service.ts}

@@ -1,11 +1,11 @@
 
 import { DynamoNTS_SingletonService } from './dynamo-nts-singleton.service';
-import { DynamoNTS_SocketService } from './dynamo-nts-socket.service';
+import { DynamoNTS_SocketServerService } from './dynamo-nts-socket-server.service';
 
 /**
  * 
  */
-export class DynamoNTS_SocketServiceCollection extends DynamoNTS_SingletonService {
+/* export class DynamoNTS_SocketServiceCollection extends DynamoNTS_SingletonService {
   
   static getInstance(): DynamoNTS_SocketServiceCollection {
     return DynamoNTS_SocketServiceCollection.getSingletonInstance();
@@ -13,4 +13,4 @@ export class DynamoNTS_SocketServiceCollection extends DynamoNTS_SingletonServic
 
   [service: string]: DynamoNTS_SocketService<any>;
   
-}
+} */

package/src/_services/{dynamo-nts-socket.service.ts → dynamo-nts-socket-server.service.ts}

@@ -3,30 +3,29 @@ import * as SocketIO from 'socket.io';
 
 import { Dynamo_Error, Dynamo_Log } from '@futdevpro/fsm-dynamo';
 
-import { DynamoNTS_GlobalService } from './dynamo-nts-global.service';
 import { DynamoNTS_SingletonService } from './dynamo-nts-singleton.service';
-import { dynamoNTS_GlobalSettings } from '../_constants/dynamo-nts-global-settings';
-import { DynamoNTS_SocketEventParams, DynamoNTS_SocketEventPreprocessTask, DynamoNTS_SocketEventTask } from '../_models/dynamo-nts-socket-event-params';
-import { DynamoNTS_SocketEvent } from '../_enums/http/dynamo-nts-socket-event.enum';
-import { DynamoNTS_SocketServiceParams } from '../_models/dynamo-nts-socket-service-params';
-import { DynamoNTS_SocketPresence } from '../_models/dynamo-nts-socket-presence';
+import { dynamoNTS_GlobalSettings } from '../_constants/dynamo-nts-global-settings.const';
+import { DynamoNTS_SocketEventType } from '../_enums/http/dynamo-nts-socket-event-type.enum';
 import { DynamoNTS_SocketSecurity } from '../_enums/dynamo-nts-socket-security.enum';
+import { DynamoNTS_SocketServerServiceParams } from '../_models/control-models/dynamo-nts-socket-server-service-params.model';
+import { DynamoNTS_SocketPresence } from '../_models/control-models/dynamo-nts-socket-presence.model';
+import { DynamoNTS_SocketEvent, DynamoNTS_SocketEventPreprocessTask, DynamoNTS_SocketEventTask } from '../_models/control-models/dynamo-nts-socket-event.model';
 
 /**
  * 
  */
-export abstract class DynamoNTS_SocketService<T_Presence extends DynamoNTS_SocketPresence, T_Content = any> extends DynamoNTS_SingletonService {
-  protected params: DynamoNTS_SocketServiceParams;
+export abstract class DynamoNTS_SocketServerService<T_Presence extends DynamoNTS_SocketPresence, T_Content = any> extends DynamoNTS_SingletonService {
+  protected params: DynamoNTS_SocketServerServiceParams;
   get name(): string { return this.params.name; }
   get port(): number { return this.params.port; }
   get security(): DynamoNTS_SocketSecurity { return this.params.security; }
 
   protected socketServer: SocketIO.Server;
 
-  private connectEvent: DynamoNTS_SocketEventParams<SocketIO.Socket>;
-  protected incomingEvents: DynamoNTS_SocketEventParams<any>[];
+  private connectEvent: DynamoNTS_SocketEvent<SocketIO.Socket>;
+  protected incomingEvents: DynamoNTS_SocketEvent<any>[];
 
-  private subscriptionEvent: DynamoNTS_SocketEventParams<any>;
+  private subscriptionEvent: DynamoNTS_SocketEvent<any>;
   /**
    * You need to setup a function that converts subscription event content to presence
    */
@@ -46,7 +45,7 @@ export abstract class DynamoNTS_SocketService<T_Presence extends DynamoNTS_Socke
       this.params = this.getServiceParams();
       this.incomingEvents = this.getIncomingEvents() ?? [];
       
-      this.attachToGlobalCollection();
+      /* this.attachToGlobalCollection(); */
       this.prepareEvents();
 
       if (this.log) console.log(`Socket Controller setup done: ${this.params.name} (${this.params.port}) serurity: ${this.params.security}\n`);
@@ -55,27 +54,27 @@ export abstract class DynamoNTS_SocketService<T_Presence extends DynamoNTS_Socke
     }
   }
 
-  private attachToGlobalCollection(): void {
+  /* private attachToGlobalCollection(): void {
     DynamoNTS_GlobalService.attachNewSocketService(this);
-  }
+  } */
 
   /**
    * You must setup events and required services for this function
    */
   private prepareEvents(): void {
-    const connectEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEventParams<any>) => event.event === DynamoNTS_SocketEvent.connection);
+    const connectEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.event === DynamoNTS_SocketEventType.connection);
     if (0 <= connectEventIndex) {
       this.connectEvent = this.incomingEvents.splice(connectEventIndex)[0];
     } else {
-      this.connectEvent = new DynamoNTS_SocketEventParams({
-        event: DynamoNTS_SocketEvent.connection,
+      this.connectEvent = new DynamoNTS_SocketEvent({
+        event: DynamoNTS_SocketEventType.connection,
         tasks: []
       });
     }
     this.connectEvent.socketName = this.params.name;
 
     if (this.getPresenceFromSubscrioptionEventContent) {
-      const subscriptionEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEventParams<any>) => event.event === DynamoNTS_SocketEvent.subscribe);
+      const subscriptionEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.event === DynamoNTS_SocketEventType.subscribe);
       if (0 <= subscriptionEventIndex) {
         this.subscriptionEvent = this.incomingEvents.splice(subscriptionEventIndex)[0];
         Dynamo_Log.error(
@@ -83,7 +82,7 @@ export abstract class DynamoNTS_SocketService<T_Presence extends DynamoNTS_Socke
           `in case you need additional steps for your subscripotions.`
         );
       } else {
-        this.subscriptionEvent = new DynamoNTS_SocketEventParams<SocketIO.Socket>({ event: DynamoNTS_SocketEvent.subscribe });
+        this.subscriptionEvent = new DynamoNTS_SocketEvent<SocketIO.Socket>({ event: DynamoNTS_SocketEventType.subscribe });
       }
       if (this.getSubscriptionPreProcessess) {
         this.subscriptionEvent.preProcessess.push(...this.getSubscriptionPreProcessess());
@@ -92,12 +91,12 @@ export abstract class DynamoNTS_SocketService<T_Presence extends DynamoNTS_Socke
         this.subscriptionEvent.tasks.push(...this.getSubscriptionTasks());
       }
 
-      const disconnectEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEventParams<any>) => event.event === DynamoNTS_SocketEvent.disconnect);
+      const disconnectEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.event === DynamoNTS_SocketEventType.disconnect);
       if (0 <= disconnectEventIndex) {
         this.incomingEvents[disconnectEventIndex].tasks.push(this.removeSubscriptionOnDisconnect);
       } else {
-        this.incomingEvents.push(new DynamoNTS_SocketEventParams<SocketIO.Socket>({
-          event: DynamoNTS_SocketEvent.disconnect,
+        this.incomingEvents.push(new DynamoNTS_SocketEvent<SocketIO.Socket>({
+          event: DynamoNTS_SocketEventType.disconnect,
           tasks: [
             this.removeSubscriptionOnDisconnect
           ]
@@ -107,26 +106,26 @@ export abstract class DynamoNTS_SocketService<T_Presence extends DynamoNTS_Socke
       this.subscriptionEvent.socketName = this.params.name;
     }
 
-    this.incomingEvents.forEach((event: DynamoNTS_SocketEventParams<any>) => {
+    this.incomingEvents.forEach((event: DynamoNTS_SocketEvent<any>) => {
       event.socketName = this.params.name;
     });
   }
 
   async setupSocketServer(newSocketServer: SocketIO.Server): Promise<void> {
     this.socketServer = newSocketServer;
-    this.socketServer.on(DynamoNTS_SocketEvent.connection, async (socket: SocketIO.Socket) => {
+    this.socketServer.on(DynamoNTS_SocketEventType.connection, async (socket: SocketIO.Socket) => {
       let issuer: string;
       
-      for(let i = 0; i < this.connectEvent.preProcessess.length; i++) {
+      for (let i = 0; i < this.connectEvent.preProcessess.length; i++) {
         await this.connectEvent.preProcessess[i](socket);
       }
 
-      for(let i = 0; i < this.connectEvent.tasks.length; i++) {
+      for (let i = 0; i < this.connectEvent.tasks.length; i++) {
         await this.connectEvent.tasks[i](socket);        
       }
 
       if (this.getPresenceFromSubscrioptionEventContent) {
-        socket.on(DynamoNTS_SocketEvent.subscribe, async (content: any) => {
+        socket.on(DynamoNTS_SocketEventType.subscribe, async (content: any) => {
           try {
             const presence: T_Presence = await this.getPresenceFromSubscrioptionEventContent(content);
             issuer = presence.issuerId;
@@ -135,18 +134,18 @@ export abstract class DynamoNTS_SocketService<T_Presence extends DynamoNTS_Socke
             await this.subscriptionEvent.executeEventTasks(issuer, content);
           } catch (error) {
             Dynamo_Log.error(`Socket Subscription failed: ${this.params.name} (${this.params.port})`, error);
-            socket.emit(DynamoNTS_SocketEvent.error, error);
+            socket.emit(DynamoNTS_SocketEventType.error, error);
           }
         })
       }
 
-      this.incomingEvents.forEach((event: DynamoNTS_SocketEventParams<any>) => {
+      this.incomingEvents.forEach((event: DynamoNTS_SocketEvent<any>) => {
         socket.on(event.event, async (content: any) => { 
           try {
             await event.executeEventTasks(issuer, content);
           } catch (error) {
             Dynamo_Log.error(`Socket Event failed: ${this.params.name} (${this.params.port})`, error);
-            socket.emit(DynamoNTS_SocketEvent.error, error);
+            socket.emit(DynamoNTS_SocketEventType.error, error);
           }
         });
       });
@@ -191,7 +190,7 @@ export abstract class DynamoNTS_SocketService<T_Presence extends DynamoNTS_Socke
   }
 
   emitError(presenceIssuerId: string, error: any): void {
-    this.sendEventForId(presenceIssuerId, DynamoNTS_SocketEvent.error, error);
+    this.sendEventForId(presenceIssuerId, DynamoNTS_SocketEventType.error, error);
   }
 
   async sendEventForId(id: string, event: string, content: any, error?: (err: any) => void): Promise<void> {
@@ -220,14 +219,13 @@ export abstract class DynamoNTS_SocketService<T_Presence extends DynamoNTS_Socke
 
   /**
    * You must setup params for the service in this function
-   * 
    */
-  abstract getServiceParams(): DynamoNTS_SocketServiceParams;
+  abstract getServiceParams(): DynamoNTS_SocketServerServiceParams;
 
   /**
    * You must setup events and required services in this function
    */
-  abstract getIncomingEvents(): DynamoNTS_SocketEventParams<any>[];
+  abstract getIncomingEvents(): DynamoNTS_SocketEvent<any>[];
 
   /**
    * You can setup tasks for the subscription event in this function

package/src/_services/index.ts

@@ -14,8 +14,8 @@ export * from './dynamo-nts-email-service-collection.service';
 export * from './dynamo-nts-email.service';
 export * from './dynamo-nts-global.service';
 export * from './dynamo-nts-routing-module.service';
-export * from './dynamo-nts-socket.service';
-export * from './dynamo-nts-socket-service-collection.service';
+export * from './dynamo-nts-socket-server.service';
+export * from './dynamo-nts-socket-server-service-collection.service';
 export * from './dynamo-nts-shared.service';
 export * from './dynamo-nts-singleton.service';
 

package/src/_interfaces/index.ts

@@ -1,5 +0,0 @@
-
-
-//export * from './global-service-settings.interface';
-//export * from './port-settings.interface';
-//export * from './certification-settings.interface';