@xmobitea/gn-typescript-client 2.6.8 → 2.6.9-tsc

package/dist/runtime/helper/ConverterService.js

@@ -0,0 +1,275 @@
+import { GNFieldDataType, getGNObjectMetadata } from "./../entity/DataMember";
+import { GNArray, GNData, GNHashtable } from "./../common/GNData";
+class DataMemberFieldInfoTypeMapper {
+    getGNEnhancedObjectFieldMetadata(cls) {
+        let declaredFields;
+        if (this.declaredFieldsMap.has(cls)) {
+            declaredFields = this.declaredFieldsMap.get(cls);
+        }
+        else {
+            let gnObjectMetadata = getGNObjectMetadata(cls);
+            declaredFields = gnObjectMetadata != null ? gnObjectMetadata.fields : [];
+            this.declaredFieldsMap.set(cls, declaredFields);
+        }
+        return declaredFields;
+    }
+    constructor() {
+        this.declaredFieldsMap = new Map();
+    }
+}
+class DeserializeConverter {
+    deserializeObject(gnHashtable, cls) {
+        if (gnHashtable == null)
+            return null;
+        let declaredFields = this.dataMemberFieldInfoMapper.getGNEnhancedObjectFieldMetadata(cls);
+        let answer = new cls();
+        declaredFields.forEach(declaredField => {
+            let value = gnHashtable.getObject(declaredField.code);
+            let typeOfValue = typeof value;
+            if (declaredField.gnFieldType == GNFieldDataType.String) {
+                if (value == null)
+                    answer[declaredField.name] = declaredField.defaultValue;
+                else if (typeOfValue == "string")
+                    answer[declaredField.name] = value;
+            }
+            else if (declaredField.gnFieldType == GNFieldDataType.Boolean) {
+                if (value == null)
+                    answer[declaredField.name] = declaredField.defaultValue;
+                else if (typeOfValue == "boolean")
+                    answer[declaredField.name] = value;
+            }
+            else if (declaredField.gnFieldType == GNFieldDataType.GNHashtable) {
+                if (value == null) {
+                    if (declaredField.defaultValue != null) {
+                        if (declaredField.cls == GNHashtable)
+                            answer[declaredField.name] = declaredField.defaultValue;
+                        else if (typeof declaredField.cls == "object")
+                            answer[declaredField.name] = declaredField.defaultValue.toData();
+                        else
+                            answer[declaredField.name] = this.deserializeObject(declaredField.defaultValue, declaredField.cls);
+                    }
+                }
+                else {
+                    if (declaredField.cls == GNHashtable)
+                        answer[declaredField.name] = value;
+                    else if (typeof declaredField.cls == "object")
+                        answer[declaredField.name] = value.toData();
+                    else
+                        answer[declaredField.name] = this.deserializeObject(value, declaredField.cls);
+                }
+            }
+            else if (declaredField.gnFieldType == GNFieldDataType.GNArray) {
+                if (value == null) {
+                    if (declaredField.defaultValue != null) {
+                        if (declaredField.cls == GNArray)
+                            answer[declaredField.name] = declaredField.defaultValue;
+                        else if (typeof declaredField.cls == "object")
+                            answer[declaredField.name] = declaredField.defaultValue.toData();
+                        else
+                            answer[declaredField.name] = this.deserializeArray(declaredField.defaultValue, declaredField.cls);
+                    }
+                }
+                else {
+                    if (declaredField.cls == GNArray)
+                        answer[declaredField.name] = value;
+                    else if (typeof declaredField.cls == "object")
+                        answer[declaredField.name] = value.toData();
+                    else
+                        answer[declaredField.name] = this.deserializeArray(value, declaredField.cls);
+                }
+            }
+            else if (declaredField.gnFieldType == GNFieldDataType.Number) {
+                if (value == null)
+                    answer[declaredField.name] = declaredField.defaultValue;
+                else if (typeOfValue == "number")
+                    answer[declaredField.name] = value;
+            }
+            else {
+                if (value == null) {
+                    if (declaredField.defaultValue != null) {
+                        if (declaredField.cls == Number)
+                            answer[declaredField.name] = declaredField.defaultValue;
+                        else if (declaredField.cls == String)
+                            answer[declaredField.name] = declaredField.defaultValue;
+                        else if (declaredField.cls == Boolean)
+                            answer[declaredField.name] = declaredField.defaultValue;
+                        else if (declaredField.cls == GNHashtable)
+                            answer[declaredField.name] = this.deserializeObject(declaredField.defaultValue, declaredField.cls);
+                        else if (declaredField.cls == GNArray)
+                            answer[declaredField.name] = this.deserializeArray(declaredField.defaultValue, declaredField.cls);
+                        else
+                            answer[declaredField.name] = declaredField.defaultValue;
+                    }
+                }
+                else {
+                    if (declaredField.cls == Number)
+                        answer[declaredField.name] = value;
+                    else if (declaredField.cls == String)
+                        answer[declaredField.name] = value;
+                    else if (declaredField.cls == Boolean)
+                        answer[declaredField.name] = value;
+                    else if (declaredField.cls == GNHashtable)
+                        answer[declaredField.name] = this.deserializeObject(value, declaredField.cls);
+                    else if (declaredField.cls == GNArray)
+                        answer[declaredField.name] = this.deserializeArray(value, declaredField.cls);
+                    else
+                        answer[declaredField.name] = value;
+                }
+            }
+        });
+        return answer;
+    }
+    deserializeArray(gnArray, cls) {
+        if (gnArray == null)
+            return null;
+        let answer = [];
+        for (let i = 0; i < gnArray.count(); i++) {
+            let value = gnArray.getObject(i);
+            if (value == null)
+                answer.push(null);
+            else {
+                let typeOfValue = typeof value;
+                if (typeOfValue == "number")
+                    answer.push(value);
+                else if (typeOfValue == "string")
+                    answer.push(value);
+                else if (typeOfValue == "boolean")
+                    answer.push(value);
+                else if (cls == GNArray)
+                    answer.push(value);
+                else if (cls == GNData)
+                    answer.push(value);
+                else if (typeOfValue == "object") {
+                    if (Array.isArray(value)) {
+                        answer.push(this.deserializeArray(gnArray.getGNArray(i), cls));
+                    }
+                    else {
+                        answer.push(this.deserializeObject(gnArray.getGNHashtable(i), cls));
+                    }
+                }
+            }
+        }
+        return answer;
+    }
+    constructor(dataMemberFieldInfoMapper) {
+        this.dataMemberFieldInfoMapper = dataMemberFieldInfoMapper;
+    }
+}
+class SerializeConverter {
+    serializeObject(obj, cls) {
+        if (obj == null)
+            return null;
+        let fieldInfos = this.dataMemberFieldInfoMapper.getGNEnhancedObjectFieldMetadata(cls);
+        let answer = new GNHashtable();
+        fieldInfos.forEach((field) => {
+            let dataMemberAnno = field;
+            let value = obj[dataMemberAnno.name];
+            if (value == null) {
+                if (!dataMemberAnno.isOptional)
+                    answer.add(dataMemberAnno.code, null);
+            }
+            else {
+                let typeOfValue = typeof value;
+                if (dataMemberAnno.gnFieldType == GNFieldDataType.String) {
+                    if (typeOfValue == "string")
+                        answer.add(dataMemberAnno.code, value);
+                }
+                else if (dataMemberAnno.gnFieldType == GNFieldDataType.Boolean) {
+                    if (typeOfValue == "boolean")
+                        answer.add(dataMemberAnno.code, value);
+                }
+                else if (dataMemberAnno.gnFieldType == GNFieldDataType.GNHashtable) {
+                    if (value instanceof GNHashtable)
+                        answer.add(dataMemberAnno.code, value);
+                    else if (typeOfValue === "object") {
+                        if (!Array.isArray(value))
+                            answer.add(dataMemberAnno.code, this.serializeObject(value, dataMemberAnno.cls));
+                    }
+                }
+                else if (dataMemberAnno.gnFieldType == GNFieldDataType.GNArray) {
+                    if (value instanceof GNArray)
+                        answer.add(dataMemberAnno.code, value);
+                    else if (typeOfValue === "object") {
+                        if (Array.isArray(value))
+                            answer.add(dataMemberAnno.code, this.serializeArray(value, dataMemberAnno.cls));
+                    }
+                }
+                else if (dataMemberAnno.gnFieldType == GNFieldDataType.Number) {
+                    if (typeOfValue == "number")
+                        answer.add(dataMemberAnno.code, value);
+                }
+                else {
+                    if (typeOfValue == "string")
+                        answer.add(dataMemberAnno.code, value);
+                    else if (typeOfValue == "boolean")
+                        answer.add(dataMemberAnno.code, value);
+                    else if (typeOfValue == "number")
+                        answer.add(dataMemberAnno.code, value);
+                    else if (value instanceof GNData)
+                        answer.add(dataMemberAnno.code, value);
+                    else if (typeOfValue == "object") {
+                        if (Array.isArray(value))
+                            answer.add(dataMemberAnno.code, this.serializeArray(value, dataMemberAnno.cls));
+                        else
+                            answer.add(dataMemberAnno.code, GNHashtable.builder().addAll(value).build());
+                    }
+                    else
+                        answer.add(dataMemberAnno.code, this.serializeObject(value, dataMemberAnno.cls));
+                }
+            }
+        });
+        return answer;
+    }
+    serializeArray(objLst, cls) {
+        if (objLst == null)
+            return null;
+        let answer = new GNArray();
+        for (let i = 0; i < objLst.length; i++) {
+            let obj = objLst[i];
+            if (obj == null)
+                answer.add(null);
+            else {
+                let typeOfValue = typeof obj;
+                if (typeOfValue === "string")
+                    answer.add(obj);
+                else if (typeOfValue === "boolean")
+                    answer.add(obj);
+                else if (typeOfValue === "number")
+                    answer.add(obj);
+                else if (obj instanceof GNData)
+                    answer.add(obj);
+                else {
+                    if (typeOfValue === "object") {
+                        if (Array.isArray(obj))
+                            answer.add(this.serializeArray(obj, cls));
+                        else
+                            answer.add(this.serializeObject(obj, cls));
+                    }
+                }
+            }
+        }
+        return answer;
+    }
+    constructor(dataMemberFieldInfoMapper) {
+        this.dataMemberFieldInfoMapper = dataMemberFieldInfoMapper;
+    }
+}
+export class ConverterService {
+    static deserializeObject(gnHashtable, cls) {
+        return ConverterService.deserializeConverter.deserializeObject(gnHashtable, cls);
+    }
+    static deserializeArray(gnArray, cls) {
+        return ConverterService.deserializeConverter.deserializeArray(gnArray, cls);
+    }
+    static serializeObject(obj, cls) {
+        return ConverterService.serializeConverter.serializeObject(obj, cls);
+    }
+    static serializeArray(objLst, cls) {
+        return ConverterService.serializeConverter.serializeArray(objLst, cls);
+    }
+    static init() {
+        let dataMemberFieldInfoMapper = new DataMemberFieldInfoTypeMapper();
+        ConverterService.serializeConverter = new SerializeConverter(dataMemberFieldInfoMapper);
+        ConverterService.deserializeConverter = new DeserializeConverter(dataMemberFieldInfoMapper);
+    }
+}

package/dist/runtime/helper/EnumUtility.js

@@ -0,0 +1,33 @@
+export class EnumUtility {
+    static getEnumKeys(enumType) {
+        let keys = this.enumKeyCache.get(enumType);
+        if (!keys) {
+            keys = Object.keys(enumType).filter(key => isNaN(Number(key)));
+            this.enumKeyCache.set(enumType, keys);
+        }
+        return keys;
+    }
+    static parse(enumType, value, ignoreCase) {
+        if (!ignoreCase) {
+            if (value in enumType) {
+                return enumType[value];
+            }
+        }
+        else {
+            let normalizedValue = value.toUpperCase();
+            let enumKeys = this.getEnumKeys(enumType);
+            for (const key of enumKeys) {
+                if (key.toUpperCase() === normalizedValue) {
+                    return enumType[key];
+                }
+            }
+        }
+        return null;
+    }
+    static toString(enumType, value) {
+        let enumKeys = this.getEnumKeys(enumType);
+        const key = enumKeys.find(k => enumType[k] === value);
+        return key !== null && key !== void 0 ? key : null;
+    }
+}
+EnumUtility.enumKeyCache = new Map();

package/dist/runtime/helper/GNSupport.js

@@ -0,0 +1,8 @@
+export class GNSupport {
+    static init() {
+        this._isBrowser = (typeof window !== "undefined");
+    }
+    static isBrowser() {
+        return this._isBrowser;
+    }
+}

package/dist/runtime/helper/GNUtils.js

@@ -0,0 +1,72 @@
+export class GNUtils {
+    static toDatasDictionary(datas) {
+        if (datas == null)
+            return null;
+        let answer = new Map();
+        for (let i = 0; i < datas.length; i++) {
+            let data = datas[i];
+            answer.set(data.key, data);
+        }
+        return answer;
+    }
+    static toTagsDictionary(tags) {
+        if (tags == null)
+            return null;
+        let answer = new Map();
+        for (let i = 0; i < tags.length; i++) {
+            let tag = tags[i];
+            answer.set(tag.key, tag);
+        }
+        return answer;
+    }
+    static toCurrenciesDictionary(currencies) {
+        if (currencies == null)
+            return null;
+        let answer = new Map();
+        for (let i = 0; i < currencies.length; i++) {
+            let currency = currencies[i];
+            answer.set(currency.key, currency);
+        }
+        return answer;
+    }
+    static toStatisticsDictionary(statistics) {
+        if (statistics == null)
+            return null;
+        let answer = new Map();
+        for (let i = 0; i < statistics.length; i++) {
+            let statistic = statistics[i];
+            answer.set(statistic.key, statistic);
+        }
+        return answer;
+    }
+    static toInventoriesDictionary(inventories) {
+        if (inventories == null)
+            return null;
+        let answer = new Map();
+        for (let i = 0; i < inventories.length; i++) {
+            let inventory = inventories[i];
+            answer.set(inventory.itemId, inventory);
+        }
+        return answer;
+    }
+    static toGroupDictionary(groups) {
+        if (groups == null)
+            return null;
+        let answer = new Map();
+        for (let i = 0; i < groups.length; i++) {
+            let group = groups[i];
+            answer.set(group.groupId, group);
+        }
+        return answer;
+    }
+    static toFriendDictionary(friends) {
+        if (friends == null)
+            return null;
+        let answer = new Map();
+        for (let i = 0; i < friends.length; i++) {
+            let friend = friends[i];
+            answer.set(friend.friendId, friend);
+        }
+        return answer;
+    }
+}

package/dist/runtime/helper/MessagePackConverterService.js

@@ -0,0 +1,9 @@
+import { encode, decode } from "@msgpack/msgpack";
+export class MessagePackConverterService {
+    static serialize(tObj) {
+        return encode(tObj);
+    }
+    static deserialize(data) {
+        return decode(data);
+    }
+}

package/dist/runtime/logger/GNDebug.js

@@ -0,0 +1,29 @@
+export var LogType;
+(function (LogType) {
+    LogType[LogType["Off"] = 0] = "Off";
+    LogType[LogType["Exception"] = 1] = "Exception";
+    LogType[LogType["Error"] = 2] = "Error";
+    LogType[LogType["Warning"] = 3] = "Warning";
+    LogType[LogType["All"] = 4] = "All";
+})(LogType || (LogType = {}));
+export class GNDebug {
+    static setLogType(logType) {
+        this._logType = logType;
+    }
+    static log(message) {
+        if (this._logType >= LogType.All)
+            console.log(message);
+    }
+    static logException(exception) {
+        if (this._logType >= LogType.Exception)
+            console.error(exception);
+    }
+    static logWarning(message) {
+        if (this._logType >= LogType.Warning)
+            console.warn(message);
+    }
+    static logError(message) {
+        if (this._logType >= LogType.Error)
+            console.error(message);
+    }
+}

package/dist/runtime/networking/AuthenticateStatus.js

@@ -0,0 +1,14 @@
+export class AuthenticateStatus {
+    getAuthToken() {
+        return this.authToken;
+    }
+    setAuthToken(authToken) {
+        this.authToken = authToken;
+    }
+    getUserId() {
+        return this.userId;
+    }
+    setUserId(userId) {
+        this.userId = userId;
+    }
+}

package/dist/runtime/networking/IPeer.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/networking/NetworkingPeer.js

@@ -0,0 +1,178 @@
+import { Commands } from "./../constant/Commands";
+import { GNHashtable } from "./../common/GNData";
+import { GNNetwork } from "./../GNNetwork";
+import { HttpPeer } from "./http/HttpPeer";
+import { SocketPeer } from "./socket/SocketPeer";
+import { AuthenticateStatus } from "./AuthenticateStatus";
+import { RequestRole } from "./../constant/enumType/RequestRole";
+import { ParameterCode } from "./../constant/parameterCode/ParameterCode";
+export class NetworkingPeer {
+    getPing() {
+        let count = 0;
+        let totalPing = 0;
+        if (this.httpPeer.isUsing()) {
+            count++;
+            totalPing += this.httpPeer.ping;
+        }
+        if (this.socketPeer.isUsing()) {
+            count++;
+            totalPing += this.socketPeer.ping;
+        }
+        return totalPing / count;
+    }
+    getClientId() {
+        return this.socketPeer.getClientId();
+    }
+    setServerTimeMilliseconds(currentServerMilliseconds) {
+        this.lastCurrentServerMilliseconds = currentServerMilliseconds;
+        this.lastGetCurrentMilliseconds = Date.now() / 1000;
+    }
+    getServerTimestamp() {
+        return this.lastCurrentServerMilliseconds + ((Date.now() / 1000 - this.lastGetCurrentMilliseconds) * 1000);
+    }
+    initPeer() {
+        this.setServerTimeMilliseconds(new Date().getUTCMilliseconds());
+        let gnServerSettings = GNNetwork.getGNServerSettings();
+        if (gnServerSettings == null)
+            throw new Error("Null GN Server Settings, please find it now");
+        this.authenticateStatus = new AuthenticateStatus();
+        this.httpPeer = new HttpPeer();
+        this.httpPeer.initPeer();
+        this.socketPeer = new SocketPeer();
+        this.socketPeer.initPeer();
+    }
+    service() {
+        if (this.httpPeer != null)
+            this.httpPeer.service();
+        if (this.socketPeer != null)
+            this.socketPeer.service();
+    }
+    sendViaSocket(requestType, role, request, onResponse = null, authToken = null, secretKey = null, customTags = null) {
+        if (authToken == null)
+            authToken = this.authenticateStatus.getAuthToken();
+        if (secretKey == null) {
+            if (role == RequestRole.Admin)
+                secretKey = GNNetwork.getGNServerSettings().getAdminSecretKey();
+            else if (role == RequestRole.Server)
+                secretKey = GNNetwork.getGNServerSettings().getServerSecretKey();
+            else if (role == RequestRole.Client)
+                secretKey = GNNetwork.getGNServerSettings().getClientSecretKey();
+        }
+        this.socketPeer.enqueue(requestType, role, request, onResponse, authToken, secretKey, customTags, this.gameId);
+    }
+    sendViaHttp(requestType, role, request, onResponse = null, authToken = null, secretKey = null, customTags = null) {
+        if (authToken == null)
+            authToken = this.authenticateStatus.getAuthToken();
+        if (secretKey == null) {
+            if (role == RequestRole.Admin)
+                secretKey = GNNetwork.getGNServerSettings().getAdminSecretKey();
+            else if (role == RequestRole.Server)
+                secretKey = GNNetwork.getGNServerSettings().getServerSecretKey();
+            else if (role == RequestRole.Client)
+                secretKey = GNNetwork.getGNServerSettings().getClientSecretKey();
+        }
+        this.httpPeer.enqueue(requestType, role, request, onResponse, authToken, secretKey, customTags, this.gameId);
+    }
+    sendRequestAuthSocket() {
+        this.socketPeer.sendRequestAuthSocket();
+    }
+    connectSocket(_onSocketConnect) {
+        this.socketPeer.connect(_onSocketConnect);
+    }
+    disconnectSocket(_onSocketDisconnect) {
+        this.socketPeer.disconnect(_onSocketDisconnect);
+    }
+    setOnEventHandler(_onEventHandler) {
+        this.socketPeer.setOnEventHandler(_onEventHandler);
+    }
+    setOnConnectHandler(_onConnectHandler) {
+        this.socketPeer.setOnConnectHandler(_onConnectHandler);
+    }
+    setOnDisconnectHandler(_onDisconnectHandler) {
+        this.socketPeer.setOnDisconnectHandler(_onDisconnectHandler);
+    }
+    removeOnConnectHandler(_onConnectHandler) {
+        this.socketPeer.removeOnConnectHandler(_onConnectHandler);
+    }
+    removeOnDisconnectHandler(_onDisconnectHandler) {
+        this.socketPeer.removeOnDisconnectHandler(_onDisconnectHandler);
+    }
+    subscriberServerEventHandler(serverEventHandler) {
+        this.socketPeer.subscriberAServerEventHandler(serverEventHandler);
+    }
+    syncTs(onResponse = null) {
+        let thiz = this;
+        this.httpPeer.getRequest(NetworkingPeer.SYNC_TS, (httpAppResponse) => {
+            if (!httpAppResponse.hasError()) {
+                if (httpAppResponse.statusCode == 200) {
+                    let returnDatas = JSON.parse(httpAppResponse.text);
+                    let gnHashtable = GNHashtable.builder()
+                        .addAll(returnDatas)
+                        .build();
+                    let newServerTimestamp = gnHashtable.getNumber(ParameterCode.Ts, new Date().getUTCMilliseconds());
+                    thiz.setServerTimeMilliseconds(newServerTimestamp);
+                }
+            }
+            if (onResponse != null)
+                onResponse(thiz.getServerTimestamp());
+        });
+    }
+    getAuthInfo(authToken, onResponse) {
+        this.httpPeer.getRequest(NetworkingPeer.GET_AUTH_INFO + "?authToken=" + authToken, (httpAppResponse) => {
+            if (!httpAppResponse.hasError()) {
+                if (httpAppResponse.statusCode == 200) {
+                    let returnDatas = JSON.parse(httpAppResponse.text);
+                    if (returnDatas.error) {
+                        if (onResponse != null)
+                            onResponse({
+                                error: returnDatas.error,
+                            });
+                    }
+                    else {
+                        if (onResponse != null) {
+                            let response = {
+                                error: null,
+                                data: returnDatas.data,
+                            };
+                            response.data.otherDatas = GNHashtable.builder()
+                                .addAll(returnDatas.data.otherDatas)
+                                .build();
+                            onResponse(response);
+                        }
+                    }
+                    return;
+                }
+            }
+            if (onResponse != null)
+                onResponse({
+                    error: httpAppResponse.error,
+                });
+        });
+    }
+    uploadFile(fileId, content, filename, mimetype, onResponse) {
+        this.httpPeer.uploadFile(fileId, content, filename, mimetype, (httpAppResponse) => {
+            var _a;
+            if (!httpAppResponse.hasError()) {
+                if (httpAppResponse.statusCode == 200) {
+                    if (onResponse != null) {
+                        let response = {
+                            error: null,
+                        };
+                        onResponse(response);
+                    }
+                    return;
+                }
+            }
+            if (onResponse != null)
+                onResponse({
+                    error: (_a = httpAppResponse.error) !== null && _a !== void 0 ? _a : "Unknown Error",
+                });
+        });
+    }
+}
+NetworkingPeer.SYNC_TS = "ts";
+NetworkingPeer.GET_AUTH_INFO = "getAuthInfo";
+NetworkingPeer.UPLOAD_FILE = "upload";
+NetworkingPeer.DOWNLOAD_FILE = "download";
+NetworkingPeer.API_JSON = "api/" + Commands.RequestCmd_Json;
+NetworkingPeer.API_MSG_PACK = "api/" + Commands.RequestCmd_MsgPack;

package/dist/runtime/networking/OperationPending.js

@@ -0,0 +1,53 @@
+import { OperationRequest } from "./../entity/OperationRequest";
+export class OperationPending {
+    constructor(requestType, role, operationRequest, onOperationResponse, authToken, secretKey, customTags, gameId) {
+        this.operationRequest = operationRequest;
+        this.onOperationResponse = onOperationResponse;
+        this.timeout = Date.now() / 1000 + OperationRequest.defaultTimeOut;
+        this.firstSend = 0;
+        this.secondsSend = 0;
+        this.requestType = requestType;
+        this.role = role;
+        this.authToken = authToken;
+        this.secretKey = secretKey;
+        this.gameId = gameId;
+        this.customTags = customTags;
+    }
+    getRequestType() {
+        return this.requestType;
+    }
+    getRole() {
+        return this.role;
+    }
+    getAuthToken() {
+        return this.authToken;
+    }
+    getSecretKey() {
+        return this.secretKey;
+    }
+    getGameId() {
+        return this.gameId;
+    }
+    getCustomTags() {
+        return this.customTags;
+    }
+    onSend() {
+        this.firstSend = Date.now() / 1000;
+        this.timeout = this.firstSend + this.operationRequest.getTimeout();
+    }
+    onRecv() {
+        this.secondsSend = Date.now() / 1000;
+    }
+    getExecuteTimerInMs() {
+        return (this.secondsSend - this.firstSend);
+    }
+    isTimeout() {
+        return this.timeout < Date.now() / 1000;
+    }
+    getOperationRequest() {
+        return this.operationRequest;
+    }
+    getCallback() {
+        return this.onOperationResponse;
+    }
+}