Implement pduProcessors

src/PDUProcessor/DebugPduProcessor.ts

@@ -1,6 +1,9 @@
+import {Center} from "../Center/Center";
 import {PduProcessor} from "./PduProcessor";
 
-export class PduDebugProcessor implements PduProcessor {
+export class DebugPduProcessor extends PduProcessor {
+    servesSessionType: string = Center.name;
+
 	processPdu(session: any, pdu: any, ...args: any[]): Promise<any> {
 		return new Promise<any>((resolve, reject) => {
 			session.send(pdu.response(), (replyPdu: any) => {
@@ -8,8 +11,4 @@ export class PduDebugProcessor implements PduProcessor {
 			});
 		})
 	}
-
-	serialize(): object {
-		return {};
-	}
 }

src/PDUProcessor/EchoPduProcessor.ts

@@ -0,0 +1,25 @@
+import {Center} from "../Center/Center";
+import {PduProcessor} from "./PduProcessor";
+const smpp = require("smpp");
+
+export class EchoPduProcessor extends PduProcessor {
+    servesSessionType: string = Center.name;
+	processPdu(session: any, pdu: any, ...args: any[]): Promise<any> {
+		return new Promise<any>((resolve, reject) => {
+			let promises = [];
+			let replyPromise = session.send(pdu.response());
+			let sendPromise = session.send(new smpp.PDU('deliver_sm', {
+				source_addr: pdu.destination_addr,
+				destination_addr: pdu.source_addr,
+				short_message: pdu.short_message
+			}));
+			promises.push(replyPromise);
+			promises.push(sendPromise);
+			Promise.all(promises).then((replyPdus: any) => {
+				resolve(replyPdus);
+			}).catch((error: any) => {
+				reject(error);
+			});
+		});
+	}
+}

src/PDUProcessor/PduProcessor.ts

@@ -1,5 +1,57 @@
-export interface PduProcessor {
-	processPdu(session: any, pdu: any, ...args: any[]): Promise<any>;
+import Logger from "../Logger";
+import {SmppSession} from "../SmppSession";
+import {DebugPduProcessor} from "./DebugPduProcessor";
 
-	serialize(): object;
+export abstract class PduProcessor {
+	static processors: PduProcessor[] = [];
+	abstract readonly servesSessionType: string;
+	readonly name: string = this.constructor.name;
+	readonly logger: Logger = new Logger(`PduProcessor: ${this.name}`);
+	private static logger: Logger = new Logger("PduProcessor");
+
+	static getProcessor(name: string): PduProcessor {
+		this.logger.log1(`Looking for processor with name ${name}...`);
+		let pduProcessor = this.processors.find((processor: any) => processor.name === name);
+		if (pduProcessor) {
+			this.logger.log1(`Found processor with name ${name}`);
+			return pduProcessor;
+		} else {
+			this.logger.log1(`Processor with name ${name} not found`);
+			return this.processors[0];
+		}
+	}
+
+	static attachProcessor(session: SmppSession, processor: PduProcessor): void {
+		this.logger.log1(`Trying to attach processor ${processor.name} to session ${session.constructor.name}-${session.getId()}`);
+		if (PduProcessor.areCompatible(session, processor)) {
+			session.addPduProcessor(processor);
+		}
+	}
+
+	static detachProcessor(session: SmppSession, processor: PduProcessor): void {
+		this.logger.log1(`Trying to detach processor ${processor.name} from session ${session.constructor.name}-${session.getId()}`);
+		session.removePduProcessor(processor);
+	}
+
+	static areCompatible(session: SmppSession, processor: PduProcessor): boolean {
+		this.logger.log1(`Checking compatibility between session ${session.constructor.name}-${session.getId()} and processor ${processor.name}`);
+		return session.constructor.name === processor.servesSessionType;
+	}
+
+	static addProcessor(processor: any): void {
+		PduProcessor.processors.push(new processor());
+	}
+
+	static getProcessorsForType(type: string): any[] {
+		return this.processors.filter((processor: any) => processor.servesSessionType === type);
+	}
+
+	abstract processPdu(session: any, pdu: any, ...args: any[]): Promise<any>;
+
+	serialize(): object {
+		return {
+			servesSessionType: this.servesSessionType,
+			name: this.name
+		};
+	}
 }