All files / core MessageBusPromiseReceiver.ts

0% Statements 0/31
0% Branches 0/10
0% Functions 0/6
0% Lines 0/30
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101                                                                                                                                                                                                         

import { IMessageBus } from '../types/IMessageBus';
import { createGUID, isNullOrUndefined, ArgumentException, ArgumentNullException } from '../common/common';
import { Promise } from 'es6-promise';
import { IMessageBusReceiver } from '../types/IMessageBusReceiver';

export interface IData {
    __sender: string;
}

export class MessageBusPromiseReceiver<TData extends IData, TResult> implements IMessageBusReceiver {

    private _messageBus: IMessageBus = null;
    private _useSync: boolean = false;
    private _promise: Promise<TResult>;
    private _backTopic: string = '';
    private _doLog: boolean = false;
    private _logger: any = console;
 
    constructor(messageBus: IMessageBus, topic: string, promise: Promise<TResult>, useSync?: boolean, timeout?: number) {
 
        if (isNullOrUndefined(messageBus)) {
            throw new ArgumentNullException('messageBus');
        }
        if (isNullOrUndefined(topic)) {
            throw new ArgumentNullException('topic');
        }
        if (isNullOrUndefined(timeout) || timeout < 0) {
            timeout = 30000;
        }
        if (isNullOrUndefined(useSync)) {
            useSync = false;
        }
        this._useSync = useSync;
        this._promise = promise;
        this._messageBus = messageBus;
        this._messageBus.subscribe(topic, this);
    };
 
    public receive = (data: TData) => {
        const backTopic = data.__sender;
        this.runAsync(() => {
            this._promise.then((data: TResult) => {
                this._messageBus.publish(backTopic, data);
            }, (err: any) => {
                this._messageBus.publish(backTopic, err);
            });
        })
    }
 
    /* istanbul ignore next */
    private log(message: string | any) {
        if (this._doLog !== true) {
            return;
        }
        if (isNullOrUndefined(this._logger)) {
            throw new ArgumentException('logger');
        }
        if (!isNullOrUndefined(this._logger.log)) {
            this._logger.log(message);
        }
    }
 
    /* istanbul ignore next */
    private warn(message: string) {
        if (this._doLog !== true) {
            return;
        }
        if (isNullOrUndefined(this._logger)) {
            throw new ArgumentException('logger');
        }
        if (!isNullOrUndefined(this._logger.warn)) {
            this._logger.warn(message);
        }
    }
 
    /* istanbul ignore next */
    private error(message: string) {
        if (this._doLog !== true) {
            return;
        }
        if (isNullOrUndefined(this._logger)) {
            throw new ArgumentException('logger');
        }
        if (!isNullOrUndefined(this._logger.error)) {
            this._logger.error(message);
        }
    }
 
    /* istanbul ignore next */
    private runAsync = (func: () => void) => {
        if (this._useSync === false) {
            setTimeout(() => {
                func();
            }, 0);
        } else {
            this.warn('Running in sync. Do not do this in production!');
            func();
        }
    };
}