apps/fis-fingerprint/src/fis-fingerprint.controller.ts

@@ -19,4 +19,9 @@ export class FisFingerprintController {
   eventTest(message: string): void {
     console.log(`Hello there. Just Responding to Event pattern`)
   }
+
+  @EventPattern(`message`)
+  handleMessage(message: any): void {
+    this.fisFingerprintService.verifyFingeprint(message)
+  }
 }

apps/fis-fingerprint/src/fis-fingerprint.module.ts

@@ -24,6 +24,18 @@ import 'dotenv/config'
         }),
         inject: [ConfigService]
       },
+      {
+        name: `VERIFICATION_SERVICE`,
+        imports: [ConfigModule],
+        useFactory: async (configService: ConfigService) => ({
+          transport: Transport.TCP,
+          options: {
+            host: configService.get<string>(`verification.host`) as string,
+            port: configService.get<number>(`verification.tcpPort`) as number
+          }
+        }),
+        inject: [ConfigService]
+      },
     ])
   ],
   controllers: [FisFingerprintController],

apps/fis-fingerprint/src/fis-fingerprint.service.ts

@@ -1,14 +1,23 @@
-import { Inject, Injectable } from '@nestjs/common';
+import { Inject, Injectable, Logger } from '@nestjs/common';
 import { ClientProxy } from '@nestjs/microservices';
 
 @Injectable()
 export class FisFingerprintService {
+  private logger: Logger = new Logger(`FisFingerprintService`)
 
-  constructor(@Inject(`SAMPLEAPP_SERVICE`) private client: ClientProxy) {
+  constructor(
+    @Inject(`SAMPLEAPP_SERVICE`) private sampleAppClient: ClientProxy,
+    @Inject(`VERIFICATION_SERVICE`) private verificationClient: ClientProxy
+  ) {
     // logic here
     setTimeout(() => {
-      this.client.emit(`message`, `Fingeprint says HI`)
+      this.sampleAppClient.emit(`message`, `Fingeprint says HI`)
     }, 5000)
   }
 
+  verifyFingeprint(message: any): any {
+    this.logger.log(`Sending message to verification microservice`)
+    this.verificationClient.emit(`message`, message)
+  }
+
 }  

apps/fis-verification/src/fis-verification.controller.ts

@@ -17,5 +17,10 @@ export class FisVerificationController {
     console.log(`Hello there. Just Responding to Event pattern.`)
   }
 
+  @EventPattern(`message`)
+  handleMessage(message: any): void {
+    this.fisVerificationService.handleMessage(message)
+  }
+
 }
 

apps/fis-verification/src/fis-verification.service.ts

@@ -1,83 +1,54 @@
 import { Inject, Injectable } from '@nestjs/common';
 import { ClientProxy } from '@nestjs/microservices';
-import { interval } from 'rxjs';
+import { interval, Observable, Subject } from 'rxjs';
 import * as net from 'net'
 import { ConfigService } from '@nestjs/config';
+import { connectToAfisJava } from 'libs/java/afis.utils';
+import { Fingerprint, FingerprintPayload, FingerprintPayloadUI, FisMessage, JavaResponse, PersonFingerprintData } from 'libs';
+import { v1 as uuid } from 'uuid'
 
 @Injectable()
 export class FisVerificationService {
+  private port: number
+  private host: string
+  private javaClient: net.Socket
+  private incomingMessageFromJava!: Subject<JavaResponse>
+  private registeredFingerprintData: Fingerprint[] = []
 
   constructor(
     @Inject(`SAMPLEAPP_SERVICE`) private sampleClient: ClientProxy,
-    @Inject(`JAVA_AFIS`) private javaClient: ClientProxy, // this one cannot work unfortunately
     private configService: ConfigService
   ) {
-    // logic here
-    setTimeout(() => {
-      // logic here
-    }, 5000)
+    this.port = this.configService.get<number>('afis.tcpPort') as number
+    this.host = this.configService.get<string>('afis.host') as string
 
-    interval(3000).subscribe(interval => {
-      // this.sampleClient.emit(`message`, `Verification says HI`)
-      // this.javaClient.emit(`message`, `Testing Message  from Verification`)
-      // this.javaClient.send(`message`, `Testing Message  from Verification`)
+    this.javaClient = connectToAfisJava(this.host, this.port)
+    this.javaClient.on(`data`, (data) => {
+      let message: JavaResponse = JSON.parse(data.toString())
+      console.log(`Java server response: ${message.message}`)
+      if (message.operation == `Registration` && message.status == `Success`) {
+        this.registeredFingerprintData.push((message.data as PersonFingerprintData).fingerprints[0] as Fingerprint)
+        console.log(message.data)
+        // console.log(this.registeredFingerprintData)
+        console.log(`${this.registeredFingerprintData.length} registered print.`)
+      }
+      // this.incomingMessageFromJava.next(message)
     })
-
-    this.tryThis()
   }
 
-  tryThis() {
-    const port = this.configService.get<number>('afis.tcpPort')!;
-    const host = this.configService.get<string>('afis.host')!;
-    
-    const client = new net.Socket();
-  
-    const connectToServer = () => {
-      client.connect(port, host, () => {
-        console.log(`✅ Connected to Afis Java Server at ${host}:${port}`);
-      });
-    };
-  
-    // Attempt to connect initially
-    connectToServer();
-  
-    // Reconnect logic: try again after delay
-    client.on('error', (err) => {
-      console.error(`❌ TCP Error:`, err.message);
-      // Avoid crash on ECONNREFUSED etc.
-      setTimeout(connectToServer, 3000);
-    });
-  
-    client.on('close', (hadError) => {
-      console.warn(`⚠️ Connection closed${hadError ? ' due to error' : ''}. Reconnecting...`);
-      setTimeout(connectToServer, 3000);
-    });
-  
-    client.on('end', () => {
-      console.warn('⚠️ Server closed the connection.');
-    });
-  
-    // Optional: handle incoming data
-    client.on('data', (data) => {
-      console.log('📩 Received from server:', data.toString());
-    });
-  
-    // Message sending interval
-    interval(3000).subscribe(() => {
-      if (client.destroyed) {
-        console.warn('⚠️ Cannot send: socket is destroyed.');
-        return;
-      }
-  
-      const message = JSON.stringify({
-        pattern: 'get-user',
-        data: { id: 1 },
-      });
-  
-      client.write(message + '\n');
-    });
+  public handleMessage(message: FisMessage): void {
+    console.log(`Sending fingerprint data to Java verification....`)
+    let payload: FingerprintPayloadUI = message.data as FingerprintPayloadUI
+    let command: FingerprintPayload = {
+      ...payload,
+      fpTemplateArray: this.registeredFingerprintData
+    }
+    this.javaClient.write(JSON.stringify(command) + `\n`)
+    // let data = JSON.parse(message)
+    // console.log(data)
+    // this.javaClient.write(JSON.stringify(extractionMessage) + `\n`)
   }
-  
+
 }
 
 /* Reason based on ChatGPT: Why ClientProxy.send() or emit() won't work 
@@ -86,4 +57,9 @@ A message envelope that wraps your pattern and data.
 Message IDs and event headers.
 A specific serialization/deserialization logic that is not plain JSON.
 NO newline character at the end.
-So when your Java server, which expects a newline-terminated JSON message, receives this custom binary format, it gets confused or sees null.*/
+So when your Java server, which expects a newline-terminated JSON message, receives this custom binary format, it gets confused or sees null.*/
+
+/* data: {
+messageData: string
+messageTemplateData: string
+deviceInfo: object} */

apps/sample-app/src/main.ts

@@ -14,7 +14,6 @@ async function bootstrap() {
   const host: string = config.get<string>(`sampleApp.host`) as string
   const restPort: number = config.get<number>(`sampleApp.restPort`) as number
   const tcpPort: number = config.get<number>(`sampleApp.tcpPort`) as number
-  const socketPort: number = config.get<number>(`sampleApp.socketPort`) as number
 
   app.enableCors({
     origin: `*`, // specify the allowed origin(s)
@@ -35,6 +34,6 @@ async function bootstrap() {
 
   await app.startAllMicroservices();
   await app.listen(restPort, host);
-  console.log(`REST API is running on: ${await app.getUrl()} and TCP is running on ${host}:${tcpPort} and Socket is running on ${host}:${socketPort}`);
+  mainLogger.log(`REST API is running on: ${await app.getUrl()} and TCP is running on ${host}:${tcpPort} and Socket is running on ${host}:${restPort}`);
 }
 bootstrap();

apps/sample-app/src/sample-app.gateway.ts

@@ -1,7 +1,10 @@
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { ClientProxy } from '@nestjs/microservices';
 import { ConnectedSocket, MessageBody, OnGatewayConnection, OnGatewayDisconnect, SubscribeMessage, WebSocketGateway, WebSocketServer, WsResponse, } from '@nestjs/websockets';
 import { from, Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { Server, Socket } from 'socket.io';
+import { SampleAppService } from './sample-app.service';
 
 @WebSocketGateway({
     cors: {
@@ -11,11 +14,11 @@ import { Server, Socket } from 'socket.io';
 })
 export class SampleEventsGateway implements OnGatewayConnection, OnGatewayDisconnect {
     @WebSocketServer()
-    server: Server;
+    server!: Server;
+    logger: Logger = new Logger(`SampleEventGateway`)
 
-    constructor() {
+    constructor(private readonly service: SampleAppService) {
         // logic here
-        // console.log(`Socket Server started??`)
     }
 
     @SubscribeMessage('test')
@@ -25,16 +28,17 @@ export class SampleEventsGateway implements OnGatewayConnection, OnGatewayDiscon
 
     @SubscribeMessage('message')
     handleMesage(@MessageBody() data: string, @ConnectedSocket() client: Socket): void {
-        console.log(data)
-        console.log(`${data} from ${client.id}`)
+        // console.log(data)
+        this.logger.log(`Received data from ${client.id}`)
+        this.service.emit(data)
     }
 
     // this two methods are non essential. as they are used to keep track of the local ui port 3000, not keeping track of the actual clients 
     handleConnection(client: any) {
-        console.log('Monitoring UI connected:', client.id);
+        this.logger.log(`Socket Client ${client.id} connected`);
     }
 
     handleDisconnect(client: any) {
-        console.log('Monitoring UI disconnected:', client.id);
+        this.logger.log(`Socket Client ${client.id} disconnected`);
     }
 }

apps/sample-app/src/sample-app.service.ts

@@ -22,5 +22,7 @@ export class SampleAppService {
     return this.fingerprintClient.send<string>({ cmd: `messageTest` }, message)
   }
 
-
+  emit(data: any): void {
+    this.fingerprintClient.emit(`message`, data)
+  }
 }

libs/java/FingerprintDataVerification

@@ -1 +1 @@
-Subproject commit 65534930bf5adc95fee7305c20d58c37540a088c
+Subproject commit 3c7443ae2e744165dce0bebe1db80b152319f82a

libs/java/afis.utils.ts

@@ -0,0 +1,74 @@
+import * as net from 'net';
+import { interval, Subscription } from 'rxjs';
+
+export function connectToAfisJava(host: string, port: number, enableAutoPing = true): net.Socket {
+  const client = new net.Socket();
+  let reconnectTimeout: NodeJS.Timeout | null = null;
+  let pingSubscription: Subscription | null = null;
+
+  const connectToServer = () => {
+    client.connect(port, host, () => {
+      console.log(`✅ Connected to Afis Java Server at ${host}:${port}`);
+    });
+  };
+
+  const scheduleReconnect = () => {
+    if (!reconnectTimeout) {
+      reconnectTimeout = setTimeout(() => {
+        reconnectTimeout = null;
+        connectToServer();
+      }, 3000);
+    }
+  };
+
+  // Initial connection attempt
+  connectToServer();
+
+  // Reconnection logic
+  client.on('error', (err) => {
+    console.error(`❌ TCP Error:`, err.message);
+    scheduleReconnect();
+  });
+
+  client.on('close', (hadError) => {
+    console.warn(`⚠️ Connection closed${hadError ? ' due to error' : ''}. Reconnecting...`);
+    scheduleReconnect();
+  });
+
+  client.on('end', () => {
+    console.warn('⚠️ Server closed the connection.');
+  });
+
+  // Incoming data handler
+  client.on('data', (data) => {
+    // console.log('📩 Received from server:', data.toString());c
+    console.log(`Received 📩 From AfisServer` );
+  });
+
+  // Auto-message sending (optional)
+//   if (enableAutoPing) {
+//     pingSubscription = interval(3000).subscribe(() => {
+//       if (client.destroyed) {
+//         console.warn('⚠️ Cannot send: socket is destroyed.');
+//         return;
+//       }
+
+//       const message = JSON.stringify({
+//         pattern: 'get-user',
+//         data: { id: 1 },
+//       });
+
+//       client.write(message + '\n');
+//     });
+//   }
+
+  // Cleanup on destroy
+  client.on('destroy', () => {
+    if (pingSubscription) {
+      pingSubscription.unsubscribe();
+      pingSubscription = null;
+    }
+  });
+
+  return client;
+}

libs/types/index.ts

@@ -1,2 +1 @@
-export * from './message'
 export * from './interface'

libs/types/interface.ts

@@ -5,7 +5,7 @@ export interface Message {
 
 export interface ConnectionState {
     uuid?: string | number;
-    status: 'BUFFER' | 'DIRECT_PUBLISH' | 'LIMIT_EXCEEDED' ,
+    status: 'BUFFER' | 'DIRECT_PUBLISH' | 'LIMIT_EXCEEDED',
     reason?: string;
     payload?: any;
 }
@@ -16,4 +16,57 @@ export interface WrappedMessage {
     payload: any
     thisMessageID: string,
     previousMessageID: string | null,
-}
+}
+
+
+/* These are just sample interfaces to test with the verification process. */
+
+export interface FisMessage {
+    header: {
+        messageID: string,
+        messageName: string
+    },
+    data: any
+}
+
+export interface FingerprintPayloadUI {
+    id: string,
+    cmd: `Registration` | `Verification`,
+    date: Date,
+    personInfo: PersonInfo,
+    fpScan: string,
+    fingerPosition: number
+}
+export interface FingerprintPayload extends FingerprintPayloadUI {
+    fpTemplateArray: Fingerprint[]
+}
+
+export interface JavaResponse {
+    id: string,
+    operation: `Registration` | `Verification`,
+    status: `Failed` | `Success` | `Registered` | `Not Registered`,
+    message: string,
+    data: PersonFingerprintData,
+    score?: number
+}
+export interface PersonFingerprintData {
+    id: string,
+    name: string,
+    org: string,
+    code: string,
+    fingerprints: Fingerprint[]
+}
+
+export interface Fingerprint {
+    name: string,
+    fpPosition: number,
+    fpTemplate: string,
+}
+
+export interface PersonInfo {
+    id: string,
+    name: string,
+    org: string,
+    code: number
+}
+

libs/types/message.ts

@@ -1,41 +0,0 @@
-/*  This Message constants and interfaces and function are mostly for GRPC microservice */
-import { GrpcMethod } from "@nestjs/microservices";
-import { Observable } from "rxjs";
-
-export const messageProtobufPackage = "message";
-
-export interface Request {
-    id: string;
-    message: string;
-}
-
-export interface Response {
-    id: string;
-    message: string;
-}
-
-export const MESSAGE_PACKAGE_NAME = "message";
-
-export interface MessageServiceClient {
-    returnResponse(request): Response
-    returnStreamResponse(request: Request): Observable<Response>;
-    bidirectionalStream(request: Observable<Request>): Observable<Response>
-}
-
-export interface GrpcMessageServiceController {
-    returnResponse(request): Response
-    returnStreamResponse(request: Request): Observable<Response>;
-    bidirectionalStream(request: Observable<Request>): Observable<Response>
-}
-
-export function GrpcMessageServiceControllerMethods() {
-    return function (constructor: Function) {
-        const grpcMethods: string[] = ["returnResponse", "returnStreamResponse", "bidirectionalStream"];
-        for (const method of grpcMethods) {
-            const descriptor: any = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
-            GrpcMethod("GrpcMessageService", method)(constructor.prototype[method], method, descriptor);
-        }
-    };
-}
-
-export const MESSAGE_SERVICE_NAME = "GrpcMessageService";

tsconfig.json

@@ -14,7 +14,8 @@
     "skipLibCheck": true,
     "strictNullChecks": true,
     "forceConsistentCasingInFileNames": true,
-    "noImplicitAny": false,
+    "noImplicitAny": true,
+    "strict": true,
     "strictBindCallApply": false,
     "noFallthroughCasesInSwitch": false,
     "paths": {