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

package/lib/codec.d.ts

@@ -0,0 +1,57 @@
+import * as proto from "./protobuf_bundle";
+import * as rec from "@jayesol/jayeson.lib.record";
+import { RuleCombination } from "@jayesol/jayeson.model";
+import Long = require("long");
+export declare enum EncodeAction {
+    INSERT = 0,
+    UPDATE = 1,
+    DELETE = 2
+}
+export interface ICodec {
+    decodeRecord(input: proto.BaseRecord[], pool: string[], action: EncodeAction, key: rec.PartitionKey): rec.IBetMatch[];
+    decodeEvent(input: proto.BaseEvent[], pool: string[], action: EncodeAction, key: rec.PartitionKey): rec.IBetMatch[];
+    decodeMatch(input: proto.BaseMatch[], pool: string[], action: EncodeAction, key: rec.PartitionKey): rec.IBetMatch[];
+}
+export declare class CodecHelper {
+    constructor();
+    coerceInt64(val: number | Long): number;
+    populatePKIntoMetaInfo(meta: rec.StringMap, key: rec.PartitionKey): rec.StringMap;
+    formatRate(num: number): number;
+}
+export declare class FilterRequest {
+    private _requestId;
+    private _ruleCombination;
+    static readonly IGNORED_REQUEST_ID = -1;
+    constructor(_requestId: number, _ruleCombination: RuleCombination);
+    getRequestId(): number;
+    getFilterData(): RuleCombination;
+    toJSON(): any;
+}
+export declare class Util {
+    private static SEPARATOR;
+    /**
+     * Utility to Store array of String values as single String Also see
+     * {@link #removeKey(String, String)}
+     *
+     * @param existing
+     *            "IBC_LIVE,CROWN_LIVE"
+     * @param incoming
+     *            "SBO_LIVE"
+     * @return "IBC_LIVE,CROWN_LIVE,SBO_LIVE"
+     *
+     */
+    static addKey(existing: string, incoming: string): string;
+    /**
+     * Utility to remove element from string values Stored as String Also see
+     * {@link #addKey(String, String)}
+     *
+     * @param existing
+     *            "IBC_LIVE,CROWN_LIVE"
+     * @param incoming
+     *            "IBC_LIVE"
+     * @return "CROWN_LIVE". return empty string if there are no more keys. Return
+     *         existing string if incoming is not present in existing
+     */
+    static removeKey(existing: string, incoming: string): string;
+    static containsKey(existing: string, incoming: string): boolean;
+}

package/lib/codec.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Util = exports.FilterRequest = exports.CodecHelper = exports.EncodeAction = void 0;
+const mutable_1 = require("./mutable");
+var EncodeAction;
+(function (EncodeAction) {
+    EncodeAction[EncodeAction["INSERT"] = 0] = "INSERT";
+    EncodeAction[EncodeAction["UPDATE"] = 1] = "UPDATE";
+    EncodeAction[EncodeAction["DELETE"] = 2] = "DELETE";
+})(EncodeAction = exports.EncodeAction || (exports.EncodeAction = {}));
+class CodecHelper {
+    constructor() { }
+    coerceInt64(val) {
+        if (val.toNumber) {
+            return val.toNumber();
+        }
+        else {
+            return val;
+        }
+    }
+    populatePKIntoMetaInfo(meta, key) {
+        meta[mutable_1.Const.AGGREGATE_KEY] = key.toString();
+        return meta;
+    }
+    formatRate(num) {
+        //Round input to 4 decimal places
+        return Math.round(num * 10000) / 10000;
+    }
+}
+exports.CodecHelper = CodecHelper;
+class FilterRequest {
+    constructor(_requestId, _ruleCombination) {
+        this._requestId = _requestId;
+        this._ruleCombination = _ruleCombination;
+    }
+    getRequestId() {
+        return this._requestId;
+    }
+    getFilterData() {
+        return this._ruleCombination;
+    }
+    toJSON() {
+        return { "requestId": this.getRequestId(), "namespace": this._ruleCombination.namespace, "filterRules": this._ruleCombination.filterRules };
+    }
+}
+exports.FilterRequest = FilterRequest;
+FilterRequest.IGNORED_REQUEST_ID = -1;
+class Util {
+    /**
+     * Utility to Store array of String values as single String Also see
+     * {@link #removeKey(String, String)}
+     *
+     * @param existing
+     *            "IBC_LIVE,CROWN_LIVE"
+     * @param incoming
+     *            "SBO_LIVE"
+     * @return "IBC_LIVE,CROWN_LIVE,SBO_LIVE"
+     *
+     */
+    static addKey(existing, incoming) {
+        if (incoming.search(Util.SEPARATOR) != -1) {
+            throw new TypeError("Incoming String cannot contain Separator: " + Util.SEPARATOR + " Incoming: " + incoming);
+        }
+        if (existing.length == 0) {
+            return incoming;
+        }
+        else {
+            if (existing.indexOf(incoming) === -1) {
+                return existing + Util.SEPARATOR + incoming;
+            }
+            else {
+                return existing;
+            }
+        }
+    }
+    /**
+     * Utility to remove element from string values Stored as String Also see
+     * {@link #addKey(String, String)}
+     *
+     * @param existing
+     *            "IBC_LIVE,CROWN_LIVE"
+     * @param incoming
+     *            "IBC_LIVE"
+     * @return "CROWN_LIVE". return empty string if there are no more keys. Return
+     *         existing string if incoming is not present in existing
+     */
+    static removeKey(existing, incoming) {
+        let split = existing.split(Util.SEPARATOR);
+        let incomingArr = incoming.split(Util.SEPARATOR);
+        split.sort();
+        for (let incoming of incomingArr) {
+            let index = split.indexOf(incoming);
+            // If not found return
+            if (index < 0) {
+                continue;
+            }
+            else {
+                split.splice(index, 1);
+                // Return empty string if removed is empty
+                if (split.length == 0) {
+                    return "";
+                }
+            }
+        }
+        let finalStr = split[0];
+        for (let i = 1; i < split.length; i++) {
+            finalStr = Util.addKey(finalStr, split[i]);
+        }
+        return finalStr;
+    }
+    static containsKey(existing, incoming) {
+        if (existing == undefined) {
+            return false;
+        }
+        if (incoming.search(Util.SEPARATOR) != -1) {
+            throw new TypeError("Incoming String cannot contain Separator: " + Util.SEPARATOR + " Incoming: " + incoming);
+        }
+        let split = existing.split(Util.SEPARATOR);
+        let index = split.indexOf(incoming);
+        if (index < 0) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+}
+exports.Util = Util;
+Util.SEPARATOR = ",";

package/lib/core.d.ts

@@ -0,0 +1,159 @@
+import { Incoming, IndexedSnapshot, DeltaOutgoing, Outgoing } from "./data_structure";
+import * as D from "@jayesol/jayeson.lib.delivery";
+import * as Collections from 'typescript-collections';
+import * as T from 'ts-promise';
+import 'reflect-metadata';
+import { InjectionToken } from 'injection-js';
+import { PartitionKey, IBetMatch } from "@jayesol/jayeson.lib.record";
+import { SportsFeedMessageGroup } from "./message_class";
+import { MergeableWrapper, TTLWrapper } from "./data_structure";
+export interface ISnapshotHandler {
+    process(streamName: string, snapshot: Outgoing): void;
+    toString(): string;
+}
+export interface FSRepo {
+    appendSnapshot(stream: string, mergeable: Mergeable): DeltaOutgoing[];
+    getSnapshot(streamName: string): IndexedSnapshot;
+    registerSnapshotHandler(ssHandler: ISnapshotHandler): void;
+    deRegisterSnapshotHandler(ssHandler: ISnapshotHandler): void;
+    getRegisteredHandlers(): ISnapshotHandler[];
+    push(outgoing: Outgoing): void;
+    isReady(stream: string): T.Promise<Boolean>;
+}
+export declare const FSREPO_IMPL: InjectionToken<FSRepo>;
+export declare abstract class AbstractFSRepo implements FSRepo {
+    abstract getTtlRemoveSnapshot(): TTLRemoveCheck[];
+    protected _handlers: Collections.Set<ISnapshotHandler>;
+    constructor();
+    handlers(): Collections.Set<ISnapshotHandler>;
+    appendSnapshot(stream: string, mergeable: Mergeable): DeltaOutgoing[];
+    getSnapshot(streamName: string): IndexedSnapshot;
+    registerSnapshotHandler(ssHandler: ISnapshotHandler): void;
+    deRegisterSnapshotHandler(ssHandler: ISnapshotHandler): void;
+    getRegisteredHandlers(): ISnapshotHandler[];
+    push(outgoing: Outgoing): void;
+    isReady(stream: string): T.Promise<Boolean>;
+}
+export declare class FSRepoImpl extends AbstractFSRepo implements FSRepo {
+    outputStreamName: string;
+    private sportsGroup;
+    private _head;
+    static outputStream: InjectionToken<string>;
+    private fssEndReceived;
+    private result;
+    private promiseResolver;
+    private promiseRejector;
+    constructor(outputStreamName: string, sportsGroup: SportsFeedMessageGroup);
+    head(): IndexedSnapshot;
+    appendSnapshot(stream: string, logic: Mergeable): DeltaOutgoing[];
+    getSnapshot(streamName?: string): IndexedSnapshot;
+    getTtlRemoveSnapshot(): TTLRemoveCheck[];
+    push(outgoing: Outgoing): void;
+    isReady(stream: string): T.Promise<Boolean>;
+}
+export declare class Delta implements DeltaOutgoing {
+    private _incoming;
+    private _after;
+    private _before;
+    constructor(_incoming: Incoming, _after: IndexedSnapshot, _before: IndexedSnapshot);
+    incoming(): Incoming;
+    msgType(): D.IMessageClass;
+    after(): IndexedSnapshot;
+    delta(): IndexedSnapshot;
+    before(): IndexedSnapshot;
+}
+export interface Mergeable {
+    apply(before: IndexedSnapshot): MergeableWrapper;
+}
+export declare class TTLConfig {
+    private livettl;
+    private todayttl;
+    private earlyttl;
+    private enableTtl;
+    getLivettl(): number;
+    setLivettl(livettl: number): void;
+    getTodayttl(): number;
+    setTodayttl(todayttl: number): void;
+    getEarlyttl(): number;
+    setEarlyttl(earlyttl: number): void;
+    getRunInterval(): number;
+    isEnableTtl(): boolean;
+    setEnableTtl(enableTtl: boolean): void;
+}
+export declare enum TTLType {
+    REMOVE = 0,
+    RESTORE = 1
+}
+export declare class TTLOutgoing extends Delta implements DeltaOutgoing {
+    private readonly ttlType;
+    constructor(ttlType: TTLType, incoming: Incoming, after: IndexedSnapshot, before: IndexedSnapshot);
+    getTtlType(): TTLType;
+}
+export declare abstract class TTLCheck implements Mergeable {
+    private readonly ttlType;
+    private recycleBin;
+    private readonly keys;
+    private readonly stream;
+    constructor(ttlType: TTLType, recycleBin: RecycleBin, keys: PartitionKey[], stream: string);
+    getKeys(): PartitionKey[];
+    getKeysMapping(): Collections.Dictionary<PartitionKey, number>;
+    getTtlType(): TTLType;
+    getRecycleBin(): RecycleBin;
+    setRecycleBin(recycleBin: RecycleBin): void;
+    getStream(): string;
+    abstract apply(before: IndexedSnapshot): MergeableWrapper;
+}
+export declare class TTLRestoreCheck extends TTLCheck {
+    private ttlRestoreWrapper;
+    private transformingLogic;
+    constructor(recycleBin: RecycleBin, keys: PartitionKey[], stream: string);
+    apply(before: IndexedSnapshot): MergeableWrapper;
+}
+export declare class TTLRemoveCheck extends TTLCheck {
+    private ttlRemoveWrapper;
+    constructor(recycleBin: RecycleBin, keys: PartitionKey[], stream: string);
+    apply(before: IndexedSnapshot): MergeableWrapper;
+}
+export declare class RecycleBin {
+    private ttlConfig;
+    private grp;
+    private fsRepo;
+    private expiredMatches;
+    private ttlStatus;
+    constructor(ttlConfig: TTLConfig, grp: SportsFeedMessageGroup, fsRepo: AbstractFSRepo);
+    /**
+     * Remove the data for a given PartitionKey from a snapshot and return the
+     * modified snapshot. The removed data will be stored in this recycle bin.
+     *
+     * @param snapshot
+     * @param key
+     */
+    removeData(ttlRemoveWrapper: TTLWrapper, snapshot: IndexedSnapshot, key: PartitionKey): TTLWrapper;
+    /**
+     * Retrieves the data in this bin with given PartitionKey and combine it with
+     * the given snapshot.
+     *
+     * @param parent
+     * @param key
+     */
+    restoreData(ttlRestore: TTLWrapper, parent: IndexedSnapshot, key: PartitionKey, restoreTime: number): TTLWrapper;
+    clearBin(key: PartitionKey): void;
+    containData(key: PartitionKey): boolean;
+    getTtlConfig(): TTLConfig;
+    getFsRepo(): AbstractFSRepo;
+    getTtlRestoreSnapshot(incoming: Incoming): TTLRestoreCheck;
+    getTtlRemoveSnapshot(): TTLRemoveCheck[];
+    /**
+     * Copies the data in this RecycleBin related to the given PartitionKey into the
+     * list of matches.
+     *
+     * @param key
+     * @param matches
+     */
+    copyData(key: PartitionKey, matches: {
+        [sport: number]: IBetMatch[];
+    }): {
+        [sport: number]: IBetMatch[];
+    };
+    getGrp(): SportsFeedMessageGroup;
+}