@jayesol/jayeson.lib.sports 2.2.7-beta → 2.2.7

package/lib/client.js

@@ -0,0 +1,686 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var MemoryDispatcher_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SportsFeedClient = exports.MemoryDispatcher = exports.AbstractComparableEPDispatcher = exports.FeedView = exports.Reset = exports.DeleteOdd = exports.UpdateOdd = exports.InsertOdd = exports.DeleteEvent = exports.UpdateEvent = exports.InsertEvent = exports.DeleteMatch = exports.UpdateMatch = exports.InsertMatch = void 0;
+const dispatch_1 = require("./dispatch");
+const codec_1 = require("./codec");
+const core_1 = require("./core");
+const delivery = __importStar(require("@jayesol/jayeson.lib.delivery"));
+const jayeson_lib_delivery_1 = require("@jayesol/jayeson.lib.delivery");
+const Collections = __importStar(require("typescript-collections"));
+const T = __importStar(require("ts-promise"));
+const data_structure_1 = require("./data_structure");
+const receive_1 = require("./receive");
+const message_class_1 = require("./message_class");
+//imports required for dependency injection
+require("reflect-metadata");
+const injection_js_1 = require("injection-js");
+class InsertMatch {
+    constructor(_after, _get) {
+        this._after = _after;
+        this._get = _get;
+    }
+    after() {
+        return this._after;
+    }
+    get() {
+        return this._get;
+    }
+}
+exports.InsertMatch = InsertMatch;
+class UpdateMatch {
+    constructor(_after, _get) {
+        this._after = _after;
+        this._get = _get;
+    }
+    after() {
+        return this._after;
+    }
+    get() {
+        return this._get;
+    }
+}
+exports.UpdateMatch = UpdateMatch;
+class DeleteMatch {
+    constructor(_after, _get) {
+        this._after = _after;
+        this._get = _get;
+    }
+    after() {
+        return this._after;
+    }
+    get() {
+        return this._get;
+    }
+}
+exports.DeleteMatch = DeleteMatch;
+class InsertEvent {
+    constructor(_after, _get) {
+        this._after = _after;
+        this._get = _get;
+    }
+    after() {
+        return this._after;
+    }
+    get() {
+        return this._get;
+    }
+}
+exports.InsertEvent = InsertEvent;
+class UpdateEvent {
+    constructor(_after, _get) {
+        this._after = _after;
+        this._get = _get;
+    }
+    after() {
+        return this._after;
+    }
+    get() {
+        return this._get;
+    }
+}
+exports.UpdateEvent = UpdateEvent;
+class DeleteEvent {
+    constructor(_after, _get) {
+        this._after = _after;
+        this._get = _get;
+    }
+    after() {
+        return this._after;
+    }
+    get() {
+        return this._get;
+    }
+}
+exports.DeleteEvent = DeleteEvent;
+class InsertOdd {
+    constructor(_after, _get) {
+        this._after = _after;
+        this._get = _get;
+    }
+    after() {
+        return this._after;
+    }
+    get() {
+        return this._get;
+    }
+}
+exports.InsertOdd = InsertOdd;
+class UpdateOdd {
+    constructor(_after, _get) {
+        this._after = _after;
+        this._get = _get;
+    }
+    after() {
+        return this._after;
+    }
+    get() {
+        return this._get;
+    }
+}
+exports.UpdateOdd = UpdateOdd;
+class DeleteOdd {
+    constructor(_after, _get) {
+        this._after = _after;
+        this._get = _get;
+    }
+    after() {
+        return this._after;
+    }
+    get() {
+        return this._get;
+    }
+}
+exports.DeleteOdd = DeleteOdd;
+class Reset {
+    constructor(_after, _get) {
+        this._after = _after;
+        this._get = _get;
+    }
+    after() {
+        return this._after;
+    }
+    get() {
+        return this._get;
+    }
+}
+exports.Reset = Reset;
+let FeedView = class FeedView {
+    constructor(manager, repo, grp) {
+        this._epgm = manager;
+        this._fsRepo = repo;
+        this._grp = grp;
+        this._handlers = [];
+    }
+    fsRepo() {
+        return this._fsRepo;
+    }
+    epgm() {
+        return this._epgm;
+    }
+    grp() {
+        return this._grp;
+    }
+    snapshot() {
+        return this._fsRepo.getSnapshot("");
+    }
+    register(listener) {
+        if (this.hasHandler(listener)) {
+            console.warn("Handler already registered.");
+            return;
+        }
+        let disp = new MemoryDispatcher(this._fsRepo, this._grp, listener);
+        this._epgm.registerEPD(disp);
+        this._handlers.push(new HandlerDispatcherTuple(listener, disp));
+    }
+    unregister(listener) {
+        let disp = this.removeHandler(listener);
+        if (disp != null) {
+            this._epgm.deregisterEPD(disp);
+        }
+    }
+    hasHandler(handler) {
+        return this._handlers.some(o => o.handler === handler);
+    }
+    removeHandler(handler) {
+        let disp = null;
+        let tuple = this._handlers.find(o => o.handler === handler);
+        if (tuple !== undefined) {
+            //remove the handler from the handlers array
+            let index = this._handlers.indexOf(tuple);
+            this._handlers.splice(index, 1);
+            //return the dispatcher associated with the handler
+            return tuple.dispatch;
+        }
+        else {
+            return null;
+        }
+    }
+    handlerSize() {
+        return this._handlers.length;
+    }
+    cleanUp() {
+        //clone the handlers array to avoid concurrent modification when removing the handlers.
+        let tuples = this._handlers.slice(0);
+        //deregister all the handlers
+        for (let tuple of tuples) {
+            this.unregister(tuple.handler);
+        }
+    }
+};
+FeedView = __decorate([
+    (0, injection_js_1.Injectable)(),
+    __param(0, (0, injection_js_1.Inject)(dispatch_1.EPGM_IMPL)),
+    __param(1, (0, injection_js_1.Inject)(core_1.FSREPO_IMPL)),
+    __metadata("design:paramtypes", [Object, Object, message_class_1.SportsFeedMessageGroup])
+], FeedView);
+exports.FeedView = FeedView;
+class HandlerDispatcherTuple {
+    constructor(handler, dispatch) {
+        this.handler = handler;
+        this.dispatch = dispatch;
+    }
+}
+class AbstractComparableEPDispatcher {
+    id() {
+        throw new Error("Method not implemented.");
+    }
+    submit(out) {
+        throw new Error("Method not implemented.");
+    }
+    onException(e) {
+        throw new Error("Method not implemented.");
+    }
+    constructor(_stream, _grp) {
+        this._stream = _stream;
+        this._grp = _grp;
+    }
+    stream() {
+        return this._stream;
+    }
+    grp() {
+        return this._grp;
+    }
+    isInitialized() {
+        return null;
+    }
+    readyToDispatch() {
+        this._readyToDispatch = true;
+    }
+    isReadyToDispatch() {
+        return this._readyToDispatch;
+    }
+}
+exports.AbstractComparableEPDispatcher = AbstractComparableEPDispatcher;
+let MemoryDispatcher = MemoryDispatcher_1 = class MemoryDispatcher extends AbstractComparableEPDispatcher {
+    constructor(_fsRepo, _grp, _handler) {
+        super(MemoryDispatcher_1.MEMORY_STREAM, _grp);
+        this._fsRepo = _fsRepo;
+        this.lastPushedSs = data_structure_1.IndexedSnapshotImpl.EMPTY_SNAPSHOT;
+        this._grp = _grp;
+        this._handler = _handler;
+        this._id = delivery.generateUUID();
+    }
+    grp() {
+        return this._grp;
+    }
+    handler() {
+        return this._handler;
+    }
+    id() {
+        return this._id;
+    }
+    submit(out) {
+        if (this.isInitialized().isFulfilled() && this.isInitialized().value()) {
+            this.handleMessage(out);
+        }
+    }
+    onException(e) {
+        console.error("Exception when dispatching outgoing messages to dispatchers:" + e);
+    }
+    handleMessage(msg) {
+        if (this.grp().isIndicatorMessage(msg.msgType())) {
+            if (msg.msgType() == this._grp.SWITCH_FILTER_START()) {
+                let requestId = Number(msg.msg());
+                this.pushSwitchFilterStart(requestId);
+            }
+            else if (msg.msgType() == this._grp.SWITCH_FILTER_END()) {
+                this.pushSwitchFilterEnd();
+            }
+            else if (msg.msgType() == this._grp.FULLSNAPSHOT_START()) {
+                this.pushFullSnapshotStart();
+            }
+            else if (msg.msgType() == this._grp.FULLSNAPSHOT_END()) {
+                this.pushFullSnapshotEnd();
+            }
+            else if (msg.msgType() == this._grp.SWITCH_FILTER_FAIL()) {
+                let requestId = Number(msg.msg());
+                this.pushSwitchFilterFail(requestId);
+            }
+            else if (msg.msgType() == this._grp.TTL_RESTORE_START()) {
+                this.pushFullSnapshotStart();
+            }
+            else if (msg.msgType() == this._grp.TTL_RESTORE_END()) {
+                this.pushFullSnapshotEnd();
+            }
+        }
+        else {
+            let out = msg;
+            if (this.isSame(out.msgType(), this._grp.DATA_INSERT_MATCH())) {
+                this.pushInsertMatch(out);
+            }
+            else if (this.isSame(out.msgType(), this._grp.DATA_INSERT_EVENT())) {
+                this.pushInsertEvent(out);
+            }
+            else if (this.isSame(out.msgType(), this._grp.DATA_INSERT_ODD())) {
+                this.pushInsertOdd(out);
+            }
+            else if (this.isSame(out.msgType(), this._grp.DATA_UPDATE_MATCH())) {
+                this.pushUpdateMatch(out);
+            }
+            else if (this.isSame(out.msgType(), this._grp.DATA_UPDATE_EVENT())) {
+                this.pushUpdateEvent(out);
+            }
+            else if (this.isSame(out.msgType(), this._grp.DATA_UPDATE_ODD())) {
+                this.pushUpdateOdd(out);
+            }
+            else if (this.isSame(out.msgType(), this._grp.DATA_DELETE_MATCH())) {
+                this.pushDeleteMatch(out);
+            }
+            else if (this.isSame(out.msgType(), this._grp.DATA_DELETE_EVENT())) {
+                this.pushDeleteEvent(out);
+            }
+            else if (this.isSame(out.msgType(), this._grp.DATA_DELETE_ODD())) {
+                this.pushDeleteOdd(out);
+            }
+            else if (this.isSame(out.msgType(), this._grp.DATA_RESET())) {
+                this.pushReset(out);
+            }
+        }
+    }
+    pushSwitchFilterStart(requestId) {
+        this._handler.onSwitchFilterStart(requestId);
+    }
+    pushSwitchFilterEnd() {
+        this._handler.onSwitchFilterEnd();
+    }
+    pushFullSnapshotStart() {
+        this._handler.onFullSnapshotStart();
+    }
+    pushFullSnapshotEnd() {
+        this._handler.onFullSnapshotEnd();
+    }
+    pushSwitchFilterFail(requestId) {
+        this._handler.onSwitchFilterFail(requestId);
+    }
+    pushInsertMatch(ds) {
+        let insert = [];
+        let update = [];
+        for (let m of ds.delta().matches()) {
+            if (ds.before().hasMatch(m.id())) {
+                update.push(m);
+            }
+            else {
+                insert.push(m);
+            }
+        }
+        if (insert.length != 0) {
+            let im = new InsertMatch(ds.after(), insert);
+            this._handler.onInsertMatch(im);
+        }
+        if (update.length != 0) {
+            let um = new UpdateMatch(ds.after(), update);
+            this._handler.onUpdateMatch(um);
+        }
+    }
+    pushInsertEvent(ds) {
+        let insert = [];
+        let update = [];
+        for (let e of this.events(ds.delta().matches())) {
+            let existingMatch = ds.before().match(e.matchId());
+            if (existingMatch != null && existingMatch.hasEvent(e.id())) {
+                update.push(e);
+            }
+            else {
+                insert.push(e);
+            }
+        }
+        if (insert.length != 0) {
+            let ie = new InsertEvent(ds.after(), insert);
+            this._handler.onInsertEvent(ie);
+        }
+        if (update.length > 0) {
+            let ue = new UpdateEvent(ds.after(), update);
+            this._handler.onUpdateEvent(ue);
+        }
+    }
+    pushInsertOdd(ds) {
+        let records = this.records(this.events(ds.delta().matches()));
+        if (records.length > 0) {
+            let io = new InsertOdd(ds.after(), records);
+            this._handler.onInsertOdd(io);
+        }
+    }
+    pushUpdateMatch(ds) {
+        let matches = ds.delta().matches();
+        if (matches.length > 0) {
+            let um = new UpdateMatch(ds.after(), matches);
+            this._handler.onUpdateMatch(um);
+        }
+    }
+    pushUpdateEvent(ds) {
+        let events = this.events(ds.delta().matches());
+        if (events.length > 0) {
+            let ue = new UpdateEvent(ds.after(), events);
+            this._handler.onUpdateEvent(ue);
+        }
+    }
+    pushUpdateOdd(ds) {
+        let records = this.records(this.events(ds.delta().matches()));
+        if (records.length > 0) {
+            let uo = new UpdateOdd(ds.after(), records);
+            this._handler.onUpdateOdd(uo);
+        }
+    }
+    pushDeleteMatch(ds) {
+        let update = [];
+        let delete_m = [];
+        for (let match of ds.delta().matches()) {
+            if (ds.after().hasMatch(match.id())) {
+                update.push(match);
+            }
+            else {
+                delete_m.push(match);
+            }
+        }
+        if (delete_m.length != 0) {
+            let dm = new DeleteMatch(ds.after(), delete_m);
+            this._handler.onDeleteMatch(dm);
+        }
+        if (update.length != 0) {
+            let um = new UpdateMatch(ds.after(), update);
+            this._handler.onUpdateMatch(um);
+        }
+    }
+    pushDeleteEvent(ds) {
+        let update = [];
+        let delete_e = [];
+        for (let event of this.events(ds.delta().matches())) {
+            let existingMatch = ds.after().match(event.matchId());
+            if (existingMatch != null && existingMatch.hasEvent(event.id())) {
+                update.push(event);
+            }
+            else {
+                delete_e.push(event);
+            }
+        }
+        if (delete_e.length != 0) {
+            let dm = new DeleteEvent(ds.after(), delete_e);
+            this._handler.onDeleteEvent(dm);
+        }
+        if (update.length != 0) {
+            let um = new UpdateEvent(ds.after(), update);
+            this._handler.onUpdateEvent(um);
+        }
+    }
+    pushDeleteOdd(ds) {
+        let records = this.records(this.events(ds.delta().matches()));
+        if (records.length > 0) {
+            let delo = new DeleteOdd(ds.after(), records);
+            this._handler.onDeleteOdd(delo);
+        }
+    }
+    pushReset(out) {
+        let partitions = out.delta().getPartitions().toArray();
+        let reset = new Reset(out.after(), partitions);
+        this._handler.onReset(reset);
+    }
+    events(matches) {
+        let events = [];
+        for (let m of matches) {
+            for (let e of m.events()) {
+                events.push(e);
+            }
+        }
+        return events;
+    }
+    records(events) {
+        let records = [];
+        for (let e of events) {
+            for (let r of e.records()) {
+                records.push(r);
+            }
+        }
+        return records;
+    }
+    states(events) {
+        let states = [];
+        for (let e of events) {
+            for (let es of e.eventStates()) {
+                states.push(es);
+            }
+        }
+        return states;
+    }
+    isSame(lhs, rhs) {
+        return lhs.id() == rhs.id();
+    }
+    isInitialized() {
+        return this._fsRepo.isReady(this.stream());
+    }
+};
+MemoryDispatcher.MEMORY_STREAM = "MEMORY_AGGREGATED_STREAM";
+MemoryDispatcher = MemoryDispatcher_1 = __decorate([
+    (0, injection_js_1.Injectable)(),
+    __metadata("design:paramtypes", [Object, message_class_1.SportsFeedMessageGroup, Object])
+], MemoryDispatcher);
+exports.MemoryDispatcher = MemoryDispatcher;
+let SportsFeedClient = class SportsFeedClient {
+    constructor(grp, fsRepo, epgm, subscriber, eventHandler, inProcessor) {
+        this._subscriber = subscriber;
+        this._epgm = epgm;
+        this._eventHandler = eventHandler;
+        this.configureEventHandler(eventHandler);
+        this._fsRepo = fsRepo;
+        this._grp = grp;
+        this._views = new Set();
+        this._viewTemplate = this.view();
+        this._viewTemplate.register(this);
+        let instance = this;
+        this.resolverMap = new Collections.Dictionary();
+        this.filterRequestCounter = 0;
+        inProcessor.startTtlVerification();
+    }
+    subscriber() {
+        return this._subscriber;
+    }
+    epgm() {
+        return this._epgm;
+    }
+    InEndPointEventHandler() {
+        return this._eventHandler;
+    }
+    fsRepo() {
+        return this._fsRepo;
+    }
+    grp() {
+        return this._grp;
+    }
+    eventHandler() {
+        return this._eventHandler;
+    }
+    eventListener(event) {
+        if (event instanceof jayeson_lib_delivery_1.Subscriber.Event.ConsumptionStart) {
+            let eve = event;
+            for (let streamId of eve.streams) {
+                console.log("ConsumptionsStartEvent for streams " + streamId + " from " + event.endPoint);
+            }
+        }
+        else if (event instanceof jayeson_lib_delivery_1.Subscriber.Event.ConsumptionError) {
+            let eve = event;
+            for (let streamId of eve.streams) {
+                console.log("ConsumptionsStartEvent for streams " + streamId);
+            }
+        }
+        else {
+            console.log("Received event " + event + " from " + event.endPoint);
+        }
+    }
+    configureEventHandler(eventHandler) {
+        this._subscriber.attachListener(eventHandler);
+    }
+    setUpStreamFilter(filterData) {
+        if (Object.keys(this._eventHandler.streamSources()).length === 0) {
+            let filterRequest = new codec_1.FilterRequest(codec_1.FilterRequest.IGNORED_REQUEST_ID, filterData);
+            this._eventHandler.updateFilter(filterRequest);
+            let resolver = null;
+            let filterResultReceived = new T.Promise((resolve, reject) => {
+                resolver = resolve;
+            });
+            resolver(true);
+            return filterResultReceived;
+        }
+        let requestId = this.filterRequestCounter++;
+        let filterRequest = new codec_1.FilterRequest(requestId, filterData);
+        let filterResultReceived = new T.Promise((resolve, reject) => {
+            this.resolverMap.setValue(requestId, resolve);
+        });
+        this._eventHandler.updateFilter(filterRequest);
+        return filterResultReceived;
+    }
+    getSubscriber() {
+        return this._subscriber;
+    }
+    start() {
+        this.getSubscriber().start();
+    }
+    view() {
+        let newView = new FeedView(this._epgm, this._fsRepo, this._grp);
+        this._views.add(newView);
+        return newView;
+    }
+    removeView(view) {
+        if (this._views.has(view)) {
+            view.cleanUp();
+            this._views.delete(view);
+        }
+    }
+    onSwitchFilterFail(requestId) {
+        if (requestId != codec_1.FilterRequest.IGNORED_REQUEST_ID) {
+            this.resolverMap.remove(requestId)(false);
+        }
+    }
+    onSwitchFilterStart(requestId) {
+        if (requestId != codec_1.FilterRequest.IGNORED_REQUEST_ID) {
+            this.resolverMap.remove(requestId)(true);
+        }
+    }
+    onInsertMatch(insertMatch) {
+    }
+    onUpdateMatch(updateMatch) {
+    }
+    onDeleteMatch(deleteMatch) {
+    }
+    onInsertEvent(insertEvent) {
+    }
+    onUpdateEvent(updateEvent) {
+    }
+    onDeleteEvent(deleteEvent) {
+    }
+    onInsertOdd(insertOdd) {
+    }
+    onUpdateOdd(updateOdd) {
+    }
+    onDeleteOdd(deleteOdd) {
+    }
+    onReset(resetKeys) {
+    }
+    onSwitchFilterEnd() {
+    }
+    onFullSnapshotStart() {
+    }
+    onFullSnapshotEnd() {
+    }
+};
+SportsFeedClient = __decorate([
+    (0, injection_js_1.Injectable)(),
+    __param(1, (0, injection_js_1.Inject)(core_1.FSREPO_IMPL)),
+    __param(2, (0, injection_js_1.Inject)(dispatch_1.EPGM_IMPL)),
+    __metadata("design:paramtypes", [message_class_1.SportsFeedMessageGroup, Object, Object, jayeson_lib_delivery_1.Subscriber, receive_1.InEndPointEventHandler, receive_1.SportsFeedInProcessor])
+], SportsFeedClient);
+exports.SportsFeedClient = SportsFeedClient;