Fis-MessageTransmission/src/connector/connector.manager.ts

import { v4 as uuidv4 } from 'uuid'
import { ConnectionEvent, ConnectionManager as ConnectionManagerInterface, ConnectionSet, Transport } from "../interface/connector.interface"
import { TransmitterConnectionAdapter } from './connector.transmitter'
import { ReceiverConnectionAdapter } from './connector.receiver'
import { TransmissionEvent } from '../interface/transport.interface'
import { Subject } from 'rxjs'
import { WebsocketTransportService } from '../transport/websocket'
import { RequestResponseConnectionAdapter } from './connector.request.response'
import { HttpTransportService } from '../transport/http'

export class ConnectionManager implements ConnectionManagerInterface {
    transportService: any;
    transmissionEvent: Subject<TransmissionEvent> = new Subject()
    connectionEvent: Subject<ConnectionEvent> = new Subject()
    transmissionSet: ConnectionSet[] = []

    constructor(messageTransmissionEvent: Subject<TransmissionEvent>) {
        messageTransmissionEvent.subscribe(this.transmissionEvent)
        // logic here
        this.getTransportService(process.env.Transport as unknown as Transport)
    }

    getTransmitterConnectionAdapter(): TransmitterConnectionAdapter {
        if (this.transportService) {
            let adapter: TransmitterConnectionAdapter = new TransmitterConnectionAdapter(this.transportService)
            return adapter
        } else {
            throw new Error(`Transmitter Transport NOT initialized.`)
        }
    }

    getReceiverConnectionAdapter(): ReceiverConnectionAdapter {
        if (this.transportService) {
            let adapter: ReceiverConnectionAdapter = new ReceiverConnectionAdapter(this.transportService)
            return adapter
        } else {
            throw new Error(`Receiver Transport NOT initialized.`)
        }
    }

    getRequestResponseConnectionAdapter(transmitterAdapter: TransmitterConnectionAdapter, receiverAdapter: ReceiverConnectionAdapter): RequestResponseConnectionAdapter {
        if (this.transportService) {
            let adapter: RequestResponseConnectionAdapter = new RequestResponseConnectionAdapter(transmitterAdapter, receiverAdapter)
            return adapter
        } else {
            throw new Error(`Request Response Transport NOT initialized.`)
        }
    }

    getTransportService(transportType: Transport): any {
        console.log(`Getting this to work ${transportType}`)
        if (transportType == Transport.Websocket) {
            this.transportService = new WebsocketTransportService()
            this.connectionEvent.next({
                id: uuidv4(),
                event: 'Setup',
                data: {
                    message: `Setting up Websocket Transport Service`
                }
            })
        }
        if (transportType == Transport.Http) {
            this.transportService = new HttpTransportService()
            this.connectionEvent.next({
                id: uuidv4(),
                event: 'Setup',
                data: {
                    message: `Setting up Http Transport Service`
                }
            })
        }
    }
}