106 lines
4.3 KiB
TypeScript
106 lines
4.3 KiB
TypeScript
import Center from "../Center/Center";
|
|
import Client from "../Client/Client";
|
|
import Logger from "../Logger";
|
|
import SmppSession from "../SmppSession";
|
|
import PduProcessor from "./PduProcessor";
|
|
import BindTranscieverReplyProcessor from "./Postprocessor/Center/BindTranscieverReplyProcessor";
|
|
import DeliveryReceiptProcessor from "./Postprocessor/Center/DeliveryReceiptProcessor";
|
|
import EchoPduProcessor from "./Postprocessor/Center/EchoPduProcessor";
|
|
import EnquireLinkReplyProcessor from "./Postprocessor/Center/EnquireLinkReplyProcessor";
|
|
import SubmitSmReplyProcessor from "./Postprocessor/Center/SubmitSmReplyProcessor";
|
|
import DeliverSmReplyProcessor from "./Postprocessor/Client/DeliverSmReplyProcessor";
|
|
import Postprocessor from "./Postprocessor/Postprocessor";
|
|
import DeliveryReceiptRequestProcessor from "./Preprocessor/Client/DeliveryReceiptRequestProcessor";
|
|
import DestinationEnumeratorProcessor from "./Preprocessor/Client/DestinationEnumeratorProcessor";
|
|
import SourceEnumeratorProcessor from "./Preprocessor/Client/SourceEnumeratorProcessor";
|
|
import Preprocessor from "./Preprocessor/Preprocessor";
|
|
|
|
export default class ProcessorManager {
|
|
static preprocessors: PduProcessor[];
|
|
static postprocessors: PduProcessor[];
|
|
private static readonly logger: Logger = new Logger(this.name);
|
|
|
|
constructor() {
|
|
// This is an IDIOTIC solution, but it works
|
|
// Try running eb22a43 to find out what's wrong with the previous approach
|
|
ProcessorManager.postprocessors = [
|
|
new EnquireLinkReplyProcessor(Center.name),
|
|
new EchoPduProcessor(Center.name),
|
|
new DeliverSmReplyProcessor(Client.name),
|
|
new SubmitSmReplyProcessor(Center.name),
|
|
new BindTranscieverReplyProcessor(Center.name),
|
|
new DeliveryReceiptProcessor(Center.name)
|
|
];
|
|
ProcessorManager.preprocessors = [
|
|
new DestinationEnumeratorProcessor(Client.name),
|
|
new SourceEnumeratorProcessor(Client.name),
|
|
new DeliveryReceiptRequestProcessor(Client.name)
|
|
];
|
|
}
|
|
|
|
static get processors(): PduProcessor[] {
|
|
return this.preprocessors.concat(this.postprocessors);
|
|
}
|
|
|
|
static getProcessor(name: string): PduProcessor {
|
|
this.logger.log1(`Looking for processor with name ${name}...`);
|
|
let pduProcessor: PduProcessor | undefined = this.processors.find((processor: PduProcessor) => 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 preprocessor ${processor.name} to session ${session.constructor.name}-${session.id}`);
|
|
if (this.areCompatible(session, processor)) {
|
|
// This could be done a little better but this is OK for now
|
|
switch (processor.type) {
|
|
case Preprocessor.name:
|
|
session.attachPreprocessor(processor);
|
|
break;
|
|
case Postprocessor.name:
|
|
session.attachPostprocessor(processor);
|
|
break;
|
|
default:
|
|
this.logger.log1(`Processor ${processor.name} is not a preprocessor or a postprocessor`);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static detachProcessor(session: SmppSession, processor: PduProcessor): void {
|
|
this.logger.log1(`Trying to detach processor ${processor.name} from session ${session.constructor.name}-${session.id}`);
|
|
switch (processor.type) {
|
|
case Preprocessor.name:
|
|
session.detachPreprocessor(processor);
|
|
break;
|
|
case Postprocessor.name:
|
|
session.detachPostprocessor(processor);
|
|
break;
|
|
default:
|
|
this.logger.log1(`Processor ${processor.name} is not a preprocessor or a postprocessor`);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static areCompatible(session: SmppSession, processor: PduProcessor): boolean {
|
|
this.logger.log1(`Checking compatibility between session ${session.constructor.name}-${session.id} and processor ${processor.name}`);
|
|
return session.constructor.name === processor.sessionType;
|
|
}
|
|
|
|
static getProcessorsForType(type: string): PduProcessor[] {
|
|
return this.processors.filter((processor: PduProcessor) => processor.sessionType === type);
|
|
}
|
|
|
|
static getPreprocessorsForType(type: string): PduProcessor[] {
|
|
return this.preprocessors.filter((processor: PduProcessor) => processor.sessionType === type);
|
|
}
|
|
|
|
static getPostprocessorsForType(type: string): PduProcessor[] {
|
|
return this.postprocessors.filter((processor: PduProcessor) => processor.sessionType === type);
|
|
}
|
|
} |