@jayesol/jayeson.lib.sports 2.2.5-beta.1205v2 → 2.2.5-beta.1205v3

package/lib/basketball_codec.d.ts

@@ -0,0 +1,11 @@
+import { IBetMatch, BasketballMatchImpl, BasketballEventState, PartitionKey } from '@jayesol/jayeson.lib.record';
+import * as proto from './protobuf_bundle';
+import { ICodec, EncodeAction, CodecHelper } from './codec';
+export declare class BasketballCodec implements ICodec {
+    private codecHelper;
+    constructor(codecHelper?: CodecHelper);
+    decodeMatch(input: proto.BaseMatch[], pool: string[], action: EncodeAction, key: PartitionKey): BasketballMatchImpl[];
+    decodeEvent(input: proto.BaseEvent[], pool: string[], action: EncodeAction, key: PartitionKey): IBetMatch[];
+    decodeRecord(input: proto.BaseRecord[], pool: string[], action: EncodeAction, key: PartitionKey): BasketballMatchImpl[];
+    decodeState(matchId: string, eventId: string, state: proto.BaseEventState, pool: string[], action: EncodeAction, key: PartitionKey, time?: number): BasketballEventState;
+}

package/lib/basketball_codec.js

@@ -0,0 +1,209 @@
+"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 __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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasketballCodec = void 0;
+const jayeson_lib_record_1 = require("@jayesol/jayeson.lib.record");
+const proto = __importStar(require("./protobuf_bundle"));
+const codec_1 = require("./codec");
+class BasketballCodec {
+    constructor(codecHelper = new codec_1.CodecHelper()) {
+        this.codecHelper = codecHelper;
+    }
+    decodeMatch(input, pool, action, key) {
+        return input.map(match => {
+            let host = pool[match.participants[0]];
+            let guest = pool[match.participants[1]];
+            let id = pool[match.id];
+            let startTime = this.codecHelper.coerceInt64(match.startTime);
+            let league = pool[match.league];
+            let country = pool[match.country];
+            let gender = null;
+            let meta = {};
+            if (match.metaInfo != null) {
+                meta = match.metaInfo;
+            }
+            let bballMatch = match.basketballMatch;
+            if (bballMatch) {
+                switch (bballMatch.gender) {
+                    case proto.BasketballMatch.Gender.MEN:
+                        gender = jayeson_lib_record_1.BasketballGender.MEN;
+                        break;
+                    case proto.BasketballMatch.Gender.WOMEN:
+                        gender = jayeson_lib_record_1.BasketballGender.WOMEN;
+                        break;
+                }
+            }
+            meta = this.codecHelper.populatePKIntoMetaInfo(meta, key);
+            return new jayeson_lib_record_1.BasketballMatchImpl(host, guest, startTime, [], id, league, gender, country, meta);
+        });
+    }
+    decodeEvent(input, pool, action, key) {
+        var result = [];
+        let matchIdToEvents = {};
+        input.forEach(event => {
+            let id = pool[event.id];
+            let meta = event.metaInfo;
+            let eType = jayeson_lib_record_1.BasketballEventType.NONE;
+            switch (event.eventType.basketballEventType) {
+                case proto.BasketballEvent.Type.NONE:
+                    eType = jayeson_lib_record_1.BasketballEventType.NONE;
+                    break;
+                case proto.BasketballEvent.Type.FIRST_TO_20:
+                    eType = jayeson_lib_record_1.BasketballEventType.FIRST_TO_20;
+                    break;
+                case proto.BasketballEvent.Type.LAST_BASKET:
+                    eType = jayeson_lib_record_1.BasketballEventType.LAST_BASKET;
+                    break;
+                case proto.BasketballEvent.Type.TEAM_POINTS:
+                    eType = jayeson_lib_record_1.BasketballEventType.TEAM_POINTS;
+                    break;
+                case proto.BasketballEvent.Type.THREE_POINTERS:
+                    eType = jayeson_lib_record_1.BasketballEventType.THREE_POINTERS;
+                    break;
+                case proto.BasketballEvent.Type.HOME_POINT:
+                    eType = jayeson_lib_record_1.BasketballEventType.HOME_POINT;
+                    break;
+                case proto.BasketballEvent.Type.AWAY_POINT:
+                    eType = jayeson_lib_record_1.BasketballEventType.AWAY_POINT;
+                    break;
+            }
+            let mId = pool[event.matchId];
+            let states = [];
+            if (event.state != null) {
+                states.push(this.decodeState(mId, id, event.state, pool, action, key));
+            }
+            let ev = new jayeson_lib_record_1.BasketballEventImpl(id, [], states, mId, eType, meta);
+            if (matchIdToEvents[mId] === undefined) {
+                matchIdToEvents[mId] = [];
+            }
+            matchIdToEvents[mId].push(ev);
+        });
+        //add the matches
+        for (let matchId in matchIdToEvents) {
+            let currMatch = new jayeson_lib_record_1.BasketballMatchImpl('', '', 0, matchIdToEvents[matchId], matchId, '', jayeson_lib_record_1.BasketballGender.MEN, "", {});
+            result.push(currMatch);
+        }
+        return result;
+    }
+    decodeRecord(input, pool, action, key) {
+        let result = [];
+        let matchMap = {}; //map of match id to events array for that particular match
+        input.forEach(record => {
+            let id = this.codecHelper.coerceInt64(record.id);
+            let oddType = jayeson_lib_record_1.OddType[record.oddType.toString()];
+            let lbType = jayeson_lib_record_1.LBType[record.lbType.toString()];
+            let timeType = null;
+            let protoTimeType = record.timeType.basketballTimeType;
+            let str = proto.BasketballTimeType.SettleOn[protoTimeType.settle.toString()];
+            switch (str) {
+                case "FT":
+                    timeType = jayeson_lib_record_1.BasketballTimeType.FT;
+                    break;
+                case "H1":
+                    timeType = jayeson_lib_record_1.BasketballTimeType.H1;
+                    break;
+                case "H2":
+                    timeType = jayeson_lib_record_1.BasketballTimeType.H2;
+                    break;
+                case "Q1":
+                    timeType = jayeson_lib_record_1.BasketballTimeType.Q1;
+                    break;
+                case "Q2":
+                    timeType = jayeson_lib_record_1.BasketballTimeType.Q2;
+                    break;
+                case "Q3":
+                    timeType = jayeson_lib_record_1.BasketballTimeType.Q3;
+                    break;
+                case "Q4":
+                    timeType = jayeson_lib_record_1.BasketballTimeType.Q4;
+                    break;
+            }
+            let source = pool[record.source];
+            let oddFormat = jayeson_lib_record_1.OddFormat[record.format.toString()];
+            let meta = record.metaInfo;
+            let pivotValue = record.pivotValue;
+            let pivotType = jayeson_lib_record_1.PivotType[record.pivotType.toString()];
+            let pivotBias = jayeson_lib_record_1.PivotBias[record.pivotBias.toString()];
+            let bballRec = record.basketballRecord;
+            let isSwapped = false;
+            if (bballRec) {
+                isSwapped = bballRec.swapped;
+            }
+            let rateOver = this.codecHelper.formatRate(record.rates[0]);
+            let rateUnder = this.codecHelper.formatRate(record.rates[1]);
+            let rateEqual = this.codecHelper.formatRate(record.rates[2]);
+            let rateOverId = pool[record.rateIds[0]];
+            let rateUnderId = pool[record.rateIds[1]];
+            let rateEqualId = pool[record.rateIds[2]];
+            let eId = pool[record.eventId];
+            let mId = pool[record.matchId];
+            let rec = new jayeson_lib_record_1.BasketballRecord(mId, eId, id, oddType, lbType, timeType, source, oddFormat, meta, rateOver, rateUnder, rateEqual, pivotValue, pivotType, pivotBias, rateOverId, rateUnderId, rateEqualId, isSwapped);
+            if (matchMap[mId] === undefined) {
+                matchMap[mId] = {};
+            }
+            if (matchMap[mId][eId] === undefined) {
+                matchMap[mId][eId] = [];
+            }
+            matchMap[mId][eId].push(rec);
+        });
+        for (let mId in matchMap) {
+            let eventMap = matchMap[mId];
+            let eventArray = [];
+            for (let eId in eventMap) {
+                let ev = new jayeson_lib_record_1.BasketballEventImpl(eId, eventMap[eId], [], mId, jayeson_lib_record_1.BasketballEventType.NONE, {});
+                eventArray.push(ev);
+            }
+            let match = new jayeson_lib_record_1.BasketballMatchImpl('', '', 0, eventArray, mId, '', jayeson_lib_record_1.BasketballGender.MEN, "", {});
+            result.push(match);
+        }
+        return result;
+    }
+    decodeState(matchId, eventId, state, pool, action, key, time = Date.now()) {
+        let duration = state.duration;
+        let bballState = state.basketballEventState;
+        let seg = jayeson_lib_record_1.BasketballSegment[state.basketballEventState.segment.toString()];
+        let timeout = bballState.timeout;
+        var hostStat = state.participantStats[0].scores;
+        var guestStat = state.participantStats[1].scores;
+        if (hostStat.length < 7) {
+            var hostLength = hostStat.length;
+            for (var i = 0; hostLength + i < 7; i++) {
+                hostStat.push(-1);
+            }
+        }
+        if (guestStat.length < 7) {
+            var guestLength = guestStat.length;
+            for (var i = 0; guestLength + i < 7; i++) {
+                guestStat.push(-1);
+            }
+        }
+        let p1Stat = new jayeson_lib_record_1.BasketballStats(hostStat[0], hostStat[1], hostStat[2], hostStat[3], hostStat[4], hostStat[5], hostStat[6]);
+        let p2Stat = new jayeson_lib_record_1.BasketballStats(guestStat[0], guestStat[1], guestStat[2], guestStat[3], guestStat[4], guestStat[5], guestStat[6]);
+        let bookPriority = bballState.bookPriority;
+        let s = new jayeson_lib_record_1.BasketballEventState(p1Stat, p2Stat, duration, key, matchId, eventId, time, seg, timeout, bookPriority);
+        return s;
+    }
+}
+exports.BasketballCodec = BasketballCodec;

package/lib/client.d.ts

@@ -0,0 +1,202 @@
+import { IBetEvent, IBetMatch, IBetRecord, IBetEventState, ISnapshot, PartitionKey } from '@jayesol/jayeson.lib.record';
+import { IEndPointDispatcher, IEndPointGroupManager } from './dispatch';
+import { FSRepo } from './core';
+import { IMessageClass, Subscriber, EPEvent } from '@jayesol/jayeson.lib.delivery';
+import * as T from 'ts-promise';
+import { IndexedSnapshot, DeltaOutgoing, Outgoing, IndexedSnapshotImpl } from "./data_structure";
+import { InEndPointEventHandler, SportsFeedInProcessor } from "./receive";
+import { SportsFeedMessageGroup } from "./message_class";
+import 'reflect-metadata';
+import { RuleCombination } from '@jayesol/jayeson.model';
+export declare class InsertMatch<M extends IBetMatch> {
+    private _after;
+    private _get;
+    constructor(_after: ISnapshot<IBetMatch>, _get: M[]);
+    after(): ISnapshot<IBetMatch>;
+    get(): M[];
+}
+export declare class UpdateMatch<M extends IBetMatch> {
+    private _after;
+    private _get;
+    constructor(_after: ISnapshot<IBetMatch>, _get: M[]);
+    after(): ISnapshot<IBetMatch>;
+    get(): M[];
+}
+export declare class DeleteMatch<M extends IBetMatch> {
+    private _after;
+    private _get;
+    constructor(_after: ISnapshot<IBetMatch>, _get: M[]);
+    after(): ISnapshot<IBetMatch>;
+    get(): M[];
+}
+export declare class InsertEvent<E extends IBetEvent> {
+    private _after;
+    private _get;
+    constructor(_after: ISnapshot<IBetMatch>, _get: E[]);
+    after(): ISnapshot<IBetMatch>;
+    get(): E[];
+}
+export declare class UpdateEvent<E extends IBetEvent> {
+    private _after;
+    private _get;
+    constructor(_after: ISnapshot<IBetMatch>, _get: E[]);
+    after(): ISnapshot<IBetMatch>;
+    get(): E[];
+}
+export declare class DeleteEvent<E extends IBetEvent> {
+    private _after;
+    private _get;
+    constructor(_after: ISnapshot<IBetMatch>, _get: E[]);
+    after(): ISnapshot<IBetMatch>;
+    get(): E[];
+}
+export declare class InsertOdd<R extends IBetRecord> {
+    private _after;
+    private _get;
+    constructor(_after: ISnapshot<IBetMatch>, _get: R[]);
+    after(): ISnapshot<IBetMatch>;
+    get(): R[];
+}
+export declare class UpdateOdd<R extends IBetRecord> {
+    private _after;
+    private _get;
+    constructor(_after: ISnapshot<IBetMatch>, _get: R[]);
+    after(): ISnapshot<IBetMatch>;
+    get(): R[];
+}
+export declare class DeleteOdd<R extends IBetRecord> {
+    private _after;
+    private _get;
+    constructor(_after: ISnapshot<IBetMatch>, _get: R[]);
+    after(): ISnapshot<IBetMatch>;
+    get(): R[];
+}
+export declare class Reset {
+    private _after;
+    private _get;
+    constructor(_after: ISnapshot<IBetMatch>, _get: PartitionKey[]);
+    after(): ISnapshot<IBetMatch>;
+    get(): PartitionKey[];
+}
+export interface DeltaEventHandler<M extends IBetMatch, E extends IBetEvent, R extends IBetRecord> {
+    onInsertMatch(insertMatch: InsertMatch<M>): void;
+    onUpdateMatch(updateMatch: UpdateMatch<M>): void;
+    onDeleteMatch(deleteMatch: DeleteMatch<M>): void;
+    onInsertEvent(insertEvent: InsertEvent<E>): void;
+    onUpdateEvent(updateEvent: UpdateEvent<E>): void;
+    onDeleteEvent(deleteEvent: DeleteEvent<E>): void;
+    onInsertOdd(insertOdd: InsertOdd<R>): void;
+    onUpdateOdd(updateOdd: UpdateOdd<R>): void;
+    onDeleteOdd(deleteOdd: DeleteOdd<R>): void;
+    onReset(resetKeys: Reset): void;
+    onSwitchFilterStart(requestId?: number): void;
+    onSwitchFilterEnd(): void;
+    onFullSnapshotStart(): void;
+    onFullSnapshotEnd(): void;
+    onSwitchFilterFail(requestId?: number): void;
+}
+export declare class FeedView<M extends IBetMatch> {
+    private _fsRepo;
+    private _epgm;
+    private _grp;
+    private _handlers;
+    constructor(manager: IEndPointGroupManager, repo: FSRepo, grp: SportsFeedMessageGroup);
+    fsRepo(): FSRepo;
+    epgm(): IEndPointGroupManager;
+    grp(): SportsFeedMessageGroup;
+    snapshot(): IndexedSnapshot;
+    register<E extends IBetEvent, R extends IBetRecord>(listener: DeltaEventHandler<M, E, R>): void;
+    unregister<E extends IBetEvent, R extends IBetRecord>(listener: DeltaEventHandler<M, E, R>): void;
+    private hasHandler;
+    private removeHandler;
+    handlerSize(): number;
+    cleanUp(): void;
+}
+export declare class AbstractComparableEPDispatcher implements IEndPointDispatcher {
+    private _stream;
+    id(): string;
+    submit(out: Outgoing): void;
+    onException(e: Error): void;
+    protected _grp: SportsFeedMessageGroup;
+    protected _readyToDispatch: boolean;
+    constructor(_stream: string, _grp: SportsFeedMessageGroup);
+    stream(): string;
+    grp(): SportsFeedMessageGroup;
+    isInitialized(): T.Promise<Boolean>;
+    readyToDispatch(): void;
+    isReadyToDispatch(): boolean;
+}
+export declare class MemoryDispatcher extends AbstractComparableEPDispatcher {
+    private _fsRepo;
+    private _handler;
+    static MEMORY_STREAM: string;
+    lastPushedSs: IndexedSnapshotImpl;
+    _id: string;
+    constructor(_fsRepo: FSRepo, _grp: SportsFeedMessageGroup, _handler: DeltaEventHandler<IBetMatch, IBetEvent, IBetRecord>);
+    grp(): SportsFeedMessageGroup;
+    handler(): DeltaEventHandler<IBetMatch, IBetEvent, IBetRecord>;
+    id(): string;
+    submit(out: Outgoing): void;
+    onException(e: Error): void;
+    handleMessage(msg: Outgoing): void;
+    protected pushSwitchFilterStart(requestId: number): void;
+    protected pushSwitchFilterEnd(): void;
+    protected pushFullSnapshotStart(): void;
+    protected pushFullSnapshotEnd(): void;
+    protected pushSwitchFilterFail(requestId: number): void;
+    protected pushInsertMatch(ds: DeltaOutgoing): void;
+    protected pushInsertEvent(ds: DeltaOutgoing): void;
+    protected pushInsertOdd(ds: DeltaOutgoing): void;
+    protected pushUpdateMatch(ds: DeltaOutgoing): void;
+    protected pushUpdateEvent(ds: DeltaOutgoing): void;
+    protected pushUpdateOdd(ds: DeltaOutgoing): void;
+    protected pushDeleteMatch(ds: DeltaOutgoing): void;
+    protected pushDeleteEvent(ds: DeltaOutgoing): void;
+    protected pushDeleteOdd(ds: DeltaOutgoing): void;
+    private pushReset;
+    protected events(matches: IBetMatch[]): IBetEvent[];
+    protected records(events: IBetEvent[]): IBetRecord[];
+    protected states(events: IBetEvent[]): IBetEventState[];
+    isSame(lhs: IMessageClass, rhs: IMessageClass): boolean;
+    isInitialized(): T.Promise<Boolean>;
+}
+export declare class SportsFeedClient implements DeltaEventHandler<IBetMatch, IBetEvent, IBetRecord> {
+    private _subscriber;
+    private _eventHandler;
+    private _viewTemplate;
+    private _epgm;
+    private _fsRepo;
+    private _grp;
+    private _views;
+    private filterRequestCounter;
+    private resolverMap;
+    constructor(grp: SportsFeedMessageGroup, fsRepo: FSRepo, epgm: IEndPointGroupManager, subscriber: Subscriber, eventHandler: InEndPointEventHandler, inProcessor: SportsFeedInProcessor);
+    subscriber(): Subscriber;
+    epgm(): IEndPointGroupManager;
+    InEndPointEventHandler(): InEndPointEventHandler;
+    fsRepo(): FSRepo;
+    grp(): SportsFeedMessageGroup;
+    eventHandler(): InEndPointEventHandler;
+    eventListener(event: EPEvent): void;
+    configureEventHandler(eventHandler: InEndPointEventHandler): void;
+    setUpStreamFilter(filterData: RuleCombination): T.Promise<Boolean>;
+    getSubscriber(): Subscriber;
+    start(): void;
+    view<M extends IBetMatch>(): FeedView<M>;
+    removeView<M extends IBetMatch>(view: FeedView<M>): void;
+    onSwitchFilterFail(requestId: number): void;
+    onSwitchFilterStart(requestId: number): void;
+    onInsertMatch(insertMatch: InsertMatch<IBetMatch>): void;
+    onUpdateMatch(updateMatch: UpdateMatch<IBetMatch>): void;
+    onDeleteMatch(deleteMatch: DeleteMatch<IBetMatch>): void;
+    onInsertEvent(insertEvent: InsertEvent<IBetEvent>): void;
+    onUpdateEvent(updateEvent: UpdateEvent<IBetEvent>): void;
+    onDeleteEvent(deleteEvent: DeleteEvent<IBetEvent>): void;
+    onInsertOdd(insertOdd: InsertOdd<IBetRecord>): void;
+    onUpdateOdd(updateOdd: UpdateOdd<IBetRecord>): void;
+    onDeleteOdd(deleteOdd: DeleteOdd<IBetRecord>): void;
+    onReset(resetKeys: Reset): void;
+    onSwitchFilterEnd(): void;
+    onFullSnapshotStart(): void;
+    onFullSnapshotEnd(): void;
+}