@xmobitea/gn-server 2.1.0 → 2.3.0

package/dist/GN-library/xcachedata/lib/xCacheData.d.ts

@@ -1,5 +1,6 @@
 export declare class xCacheData {
     private dataDic;
+    hasData(key: string): boolean;
     getData<T>(key: string): T;
     setData<T>(key: string, tData: T, expireAfterMs: number): void;
     removeData(key: string): boolean;

package/dist/GN-library/xconfig/lib/xConfig.d.ts

@@ -3,8 +3,9 @@ import * as mongoDB from "mongodb";
 import { OnRunSuccess } from "./../../xbuilder/lib/OnRunSuccess";
 export declare class xConfig {
     private configDic;
+    private gameId;
     private configCollection;
-    setConfigCollection(configCollection: mongoDB.Collection<mongoDB.Document>): void;
+    setConfigCollection(gameId: string, configCollection: mongoDB.Collection<mongoDB.Document>): void;
     run(onRunSuccess?: OnRunSuccess): void;
     syncAllConfigAsync(): Promise<void>;
     syncConfigFromDatabaseAsync(configName: string, label: string): Promise<xConfigItem>;

package/dist/GN-library/xdatabase/lib/entity/pro/ExternalItem.d.ts

@@ -35,4 +35,14 @@ export interface ExternalItem {
             serviceId: string;
         }>;
     };
+    googlePlayGameService?: {
+        playerId: string;
+        email: string;
+        displayName: string;
+    };
+    gameCenter?: {
+        playerId: string;
+        email: string;
+        displayName: string;
+    };
 }

package/dist/GN-library/xdatabase/lib/entity/pro/IPDetailItem.d.ts

@@ -0,0 +1,5 @@
+export interface IPDetailItem {
+    ipAddress: string;
+    countryCode: string;
+    regionCode: string;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/MasterPlayer.d.ts

@@ -1,13 +1,19 @@
 import * as mongoDB from "mongodb";
 import { ExternalItem } from "./ExternalItem";
 import { PlayerBase } from "./PlayerBase";
+import { IPDetailItem } from "./IPDetailItem";
+import { PushNotificationItem } from "./PushNotificationItem";
 export declare class MasterPlayer extends PlayerBase {
     private static readonly _external;
     private static readonly _userId;
     private static readonly _email;
+    private static readonly _lastIPDetail;
+    private static readonly _pushNotifications;
     private readonly userId;
     private external;
     private email;
+    private lastIPDetail;
+    private pushNotifications;
     constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
     private setDocumentMasterPlayer;
     getUserId(): string;
@@ -16,4 +22,11 @@ export declare class MasterPlayer extends PlayerBase {
     setExternal(externalItem: ExternalItem): void;
     getEmail(): string;
     setEmail(email: string): void;
+    getLastIPDetail(): IPDetailItem;
+    setLastIPDetail(ipDetail: IPDetailItem): void;
+    getAllPushNotifications(): Array<PushNotificationItem>;
+    hasPushNotification(pushId: string): boolean;
+    getPushNotification(pushId: string): PushNotificationItem;
+    setPushNotification(pushId: string, value: PushNotificationItem): void;
+    removePushNotification(pushId: string): void;
 }

package/dist/GN-library/xdatabase/lib/entity/pro/MongoObject.d.ts

@@ -12,7 +12,9 @@ export declare class MongoObject {
     protected mul(field: string, value: number): void;
     protected rename(field: string, newField: string): void;
     protected set(field: string, value: any): void;
+    protected removeSet(field: string): void;
     protected setOnInsert(field: string, value: any): void;
     protected unset(field: string): void;
+    getObjectId(): mongoDB.ObjectId;
     saveAsync(): Promise<mongoDB.UpdateResult>;
 }

package/dist/GN-library/xdatabase/lib/entity/pro/PushNotificationItem.d.ts

@@ -0,0 +1,5 @@
+export interface PushNotificationItem {
+    pushId: string;
+    token: string;
+    platformType: number;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/StoreInventory.d.ts

@@ -16,6 +16,7 @@ interface InAppPurchase {
     appleAppStoreId: string;
     googlePlayStoreId: string;
     facebookStoreId: string;
+    analyticsPrice: number;
 }
 export declare class StoreInventory extends DataObjectBase {
     private static readonly _storeId;

package/dist/GN-library/xdatabase/lib/entity/pro/findOptions/MasterPlayerFindOptions.d.ts

@@ -1,5 +1,6 @@
 export interface MasterPlayerFindOptions {
     userId?: boolean;
+    lastIPDetail?: boolean;
     external?: boolean;
     segments?: boolean;
     customDatas?: boolean;
@@ -15,4 +16,5 @@ export interface MasterPlayerFindOptions {
     countryCode?: boolean;
     tsLastLogin?: boolean;
     email?: boolean;
+    pushNotifications?: boolean;
 }

package/dist/GN-library/xdatabase/lib/entity/pro/masterAdmin/MasterGameSettings.d.ts

@@ -2,15 +2,25 @@ import * as mongoDB from "mongodb";
 import { MasterAdminMongoObject } from "./MasterAdminMongoObject";
 import { xThirtPartySettings } from "./../../../../../xsettings/lib/entity/xThirtPartySettings";
 import { xMasterPlayerSettings } from "./../../../../../xsettings/lib/entity/xMasterPlayerSettings";
+import { xEmailSettings } from "./../../../../../xsettings/lib/entity/xEmailSettings";
+import { xPushNotificationSettings } from "./../../../../../xsettings/lib/entity/xPushNotificationSettings";
 export declare class MasterGameSettings extends MasterAdminMongoObject {
     private static readonly _thirtPartySettings;
     private static readonly _masterPlayerSettings;
+    private static readonly _emailSettings;
+    private static readonly _pushNotificationSettings;
     private thirtPartySettings;
     private masterPlayerSettings;
+    private emailSettings;
+    private pushNotificationSettings;
     constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
     private setDocumentMasterGameSettings;
     getThirtPartySettings(): xThirtPartySettings;
     setThirtPartySettings(thirtPartySettings: xThirtPartySettings): void;
     getMasterPlayerSettings(): xMasterPlayerSettings;
     setMasterPlayerSettings(masterPlayerSettings: xMasterPlayerSettings): void;
+    getEmailSettings(): xEmailSettings;
+    setEmailSettings(emailSettings: xEmailSettings): void;
+    getPushNotificationSettings(): xPushNotificationSettings;
+    setPushNotificationSettings(pushNotificationSettings: xPushNotificationSettings): void;
 }

package/dist/GN-library/xdatabase/lib/xDatabase.d.ts

@@ -41,6 +41,8 @@ export declare class xDatabase {
     }): void;
     private convertToMasterPlayers;
     loadMasterPlayersWithGoogleAsync(googleIds: string[], masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
+    loadMasterPlayersWithGooglePlayGameServiceAsync(playerIds: string[], masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
+    loadMasterPlayersWithGameCenterAsync(playerIds: string[], masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
     loadMasterPlayersWithFacebookAsync(facebookIds: string[], masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
     loadMasterPlayersWithAppleAsync(appleIds: string[], masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
     loadMasterPlayersWithGenericServiceAsync(genericService: string, genericIds: string[], masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
@@ -48,9 +50,12 @@ export declare class xDatabase {
     loadMasterPlayersWithTagAsync(key: string, value: string, skip: number, limit: number, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
     loadMasterPlayersWithDisplayNameAsync(keyword: string, skip: number, limit: number, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
     loadMasterPlayerWithDisplayNameAsync(displayName: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
-    loadMasterPlayersLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
+    loadMasterPlayersLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, direction: -1 | 1, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
+    loadMasterPlayersLeaderboardWithStatisticsAllAsync(key: string, direction: -1 | 1, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
     loadMasterPlayersLeaderboardWithCurrenciesAsync(key: string, skip: number, limit: number, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
-    loadPositionMasterPlayerLeaderboardWithStatisticsAsync(key: string, userId: string): Promise<number>;
+    loadMasterPlayersLeaderboardWithLastLoginAsync(skip: number, limit: number, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
+    loadMasterPlayersLeaderboardWithCreateAsync(skip: number, limit: number, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
+    loadPositionMasterPlayerLeaderboardWithStatisticsAsync(key: string, userId: string, initialValue: number, direction: -1 | 1): Promise<number>;
     loadPositionMasterPlayerLeaderboardWithCurrencies(key: string, userId: string): Promise<number>;
     loadMasterPlayerAsync(userId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
     loadMasterPlayerByCustomDeviceIdAsync(customDeviceId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
@@ -65,6 +70,8 @@ export declare class xDatabase {
     loadMasterPlayerByCustomIdAsync(customId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
     loadMasterPlayerByAppleAsync(appleId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
     loadMasterPlayerByGoogleAsync(googleId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerByGooglePlayGameServiceAsync(playerId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerByGameCenterAsync(playerId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
     loadMasterPlayerByFacebookAsync(facebookId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
     loadMasterPlayerByGenericServiceAsync(serviceName: string, serviceId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
     createMasterPlayerAsync(result: any): Promise<MasterPlayer>;
@@ -73,31 +80,100 @@ export declare class xDatabase {
     loadGamePlayersWithTagAsync(key: string, value: string, skip: number, limit: number, gameId: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<Array<GamePlayer>>;
     loadGamePlayersWithDisplayNameAsync(keyword: string, skip: number, limit: number, gameId: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<Array<GamePlayer>>;
     loadGamePlayerWithDisplayNameAsync(displayName: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<GamePlayer>;
-    loadGamePlayersLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, gameId: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<Array<GamePlayer>>;
+    loadGamePlayersLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, gameId: string, direction: -1 | 1, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<Array<GamePlayer>>;
+    loadGamePlayersLeaderboardWithStatisticsAllAsync(key: string, gameId: string, direction: -1 | 1, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<Array<GamePlayer>>;
+    loadGamePlayersLeaderboardWithCreateAsync(skip: number, limit: number, gameId: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<Array<GamePlayer>>;
     loadFriendGamePlayersLeaderboardWithStatisticsAsync(friendIds: string[], gameId: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<Array<GamePlayer>>;
     loadGamePlayersLeaderboardWithCurrenciesAsync(key: string, skip: number, limit: number, gameId: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<Array<GamePlayer>>;
-    loadPositionGamePlayerLeaderboardWithStatisticsAsync(key: string, userId: string, gameId: string): Promise<number>;
+    loadPositionGamePlayerLeaderboardWithStatisticsAsync(key: string, userId: string, gameId: string, initialValue: number, direction: -1 | 1): Promise<number>;
     loadPositionGamePlayerLeaderboardWithCurrenciesAsync(key: string, userId: string, gameId: string): Promise<number>;
     loadGamePlayerAsync(userId: string, gameId: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<GamePlayer>;
     createGamePlayerAsync(result: any, gameId: string): Promise<GamePlayer>;
+    insertMasterPlayerStatisticsLogAsync(userId: string, key: string, amount: number, startValue: number, finalValue: number, log: string): Promise<void>;
+    insertMasterPlayerCurrencyLogAsync(userId: string, key: string, amount: number, startValue: number, finalValue: number, log: string): Promise<void>;
+    insertMasterPlayerStatisticsLogsAsync(requests: {
+        userId: string;
+        key: string;
+        amount: number;
+        startValue: number;
+        finalValue: number;
+        tsCreate: number;
+        log: string;
+    }[]): Promise<void>;
+    loadMasterPlayerStatisticsLogAsync($filter: {}, limit: number): Promise<mongoDB.FindCursor<mongoDB.WithId<mongoDB.BSON.Document>>>;
+    loadMasterPlayerCurrencyLogAsync($filter: {}, limit: number): Promise<mongoDB.FindCursor<mongoDB.WithId<mongoDB.BSON.Document>>>;
+    insertGamePlayerStatisticsLogAsync(userId: string, gameId: string, key: string, amount: number, startValue: number, finalValue: number, log: string): Promise<void>;
+    insertGamePlayerStatisticsLogsAsync(requests: {
+        userId: string;
+        key: string;
+        amount: number;
+        startValue: number;
+        finalValue: number;
+        tsCreate: number;
+        log: string;
+    }[], gameId: string): Promise<void>;
+    insertGamePlayerCurrencyLogAsync(userId: string, gameId: string, key: string, amount: number, startValue: number, finalValue: number, log: string): Promise<void>;
+    loadGamePlayerStatisticsLogAsync($filter: {}, gameId: string, limit: number): Promise<mongoDB.FindCursor<mongoDB.WithId<mongoDB.BSON.Document>>>;
+    loadGamePlayerCurrencyLogAsync($filter: {}, gameId: string, limit: number): Promise<mongoDB.FindCursor<mongoDB.WithId<mongoDB.BSON.Document>>>;
     private convertToCharacterPlayers;
     loadCharacterPlayersWithSegmentAsync(segment: string, skip: number, limit: number, gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
     loadCharacterPlayersWithTagAsync(key: string, value: string, skip: number, limit: number, gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
     loadCharacterPlayersWithDisplayNameAsync(keyword: string, skip: number, limit: number, gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
-    loadCharacterPlayersLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
+    loadCharacterPlayersLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, gameId: string, direction: -1 | 1, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
+    loadCharacterPlayersLeaderboardWithStatisticsAllAsync(key: string, gameId: string, direction: -1 | 1, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
+    loadCharacterPlayersLeaderboardWithCreateAsync(skip: number, limit: number, gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
     loadCharacterPlayersLeaderboardWithCurrenciesAsync(key: string, skip: number, limit: number, gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
-    loadPositionCharacterPlayerLeaderboardWithStatisticsAsync(key: string, userId: string, gameId: string): Promise<number>;
+    loadPositionCharacterPlayerLeaderboardWithStatisticsAsync(key: string, userId: string, gameId: string, initialValue: number, direction: -1 | 1): Promise<number>;
     loadPositionCharacterPlayerLeaderboardWithCurrenciesAsync(key: string, userId: string, gameId: string): Promise<number>;
     loadFriendCharacterPlayersLeaderboardWithStatisticsAsync(friendIds: string[], gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
     loadCharacterPlayerAsync(characterId: string, gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<CharacterPlayer>;
     createCharacterPlayerAsync(result: any, gameId: string): Promise<CharacterPlayer>;
+    insertCharacterPlayerStatisticsLogAsync(characterId: string, gameId: string, key: string, amount: number, startValue: number, finalValue: number, log: string): Promise<void>;
+    insertCharacterPlayerStatisticsLogsAsync(requests: {
+        characterId: string;
+        key: string;
+        amount: number;
+        startValue: number;
+        finalValue: number;
+        tsCreate: number;
+        log: string;
+    }[], gameId: string): Promise<void>;
+    insertCharacterPlayerCurrencyLogAsync(characterId: string, gameId: string, key: string, amount: number, startValue: number, finalValue: number, log: string): Promise<void>;
+    insertStoreInventoryLogAsync(storeId: string, gameId: string, id: string, type: number, priceCurrencyStartValues: {
+        key: string;
+        value: number;
+    }[], priceCurrencyAmountValues: {
+        key: string;
+        value: number;
+    }[], priceCurrencyFinalValues: {
+        key: string;
+        value: number;
+    }[], storeCurrencyStartValues: {
+        key: string;
+        value: number;
+    }[], storeCurrencyAmountValues: {
+        key: string;
+        value: number;
+    }[], storeCurrencyFinalValues: {
+        key: string;
+        value: number;
+    }[], storeItemFinalValues: {
+        catalogId: string;
+        classId: string;
+        itemId: string;
+    }[], transactionId: string, storeReceiveType: number, log: string): Promise<void>;
+    getStoreInventoryLogAsync($filter: {}, gameId: string, limit: number): Promise<mongoDB.FindCursor<mongoDB.WithId<mongoDB.BSON.Document>>>;
+    loadCharacterPlayerStatisticsLogAsync($filter: {}, gameId: string, limit: number): Promise<mongoDB.FindCursor<mongoDB.WithId<mongoDB.BSON.Document>>>;
+    loadCharacterPlayerCurrencyLogAsync($filter: {}, gameId: string, limit: number): Promise<mongoDB.FindCursor<mongoDB.WithId<mongoDB.BSON.Document>>>;
     private convertToGroups;
     loadGroupsWithSegmentAsync(segment: string, skip: number, limit: number, gameId: string, groupFindOptions?: GroupFindOptions): Promise<Array<Group>>;
     loadGroupsWithTagAsync(key: string, value: string, skip: number, limit: number, gameId: string, groupFindOptions?: GroupFindOptions): Promise<Array<Group>>;
     loadGroupsWithDisplayNameAsync(keyword: string, skip: number, limit: number, gameId: string, groupFindOptions?: GroupFindOptions): Promise<Array<Group>>;
-    loadGroupsLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, gameId: string, groupFindOptions?: GroupFindOptions): Promise<Array<Group>>;
+    loadGroupsLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, gameId: string, direction: -1 | 1, groupFindOptions?: GroupFindOptions): Promise<Array<Group>>;
+    loadGroupsLeaderboardWithStatisticsAllAsync(key: string, gameId: string, direction: -1 | 1, groupFindOptions?: GroupFindOptions): Promise<Array<Group>>;
+    loadGroupsLeaderboardWithCreateAsync(skip: number, limit: number, gameId: string, groupFindOptions?: GroupFindOptions): Promise<Array<Group>>;
     loadGroupsLeaderboardWithCurrenciesAsync(key: string, skip: number, limit: number, gameId: string, groupFindOptions?: GroupFindOptions): Promise<Array<Group>>;
-    loadPositionGroupLeaderboardWithStatisticsAsync(key: string, groupId: string, gameId: string): Promise<number>;
+    loadPositionGroupLeaderboardWithStatisticsAsync(key: string, groupId: string, gameId: string, initialValue: number, direction: -1 | 1): Promise<number>;
     loadPositionGroupLeaderboardWithCurrenciesAsync(key: string, groupId: string, gameId: string): Promise<number>;
     loadGroupAsync(groupId: string, gameId: string, groupFindOptions?: GroupFindOptions): Promise<Group>;
     createGroupAsync(result: any, gameId: string): Promise<Group>;
@@ -105,19 +181,46 @@ export declare class xDatabase {
     loadInventoriesWithSegmentAsync(segment: string, skip: number, limit: number, gameId: string, inventoryFindOptions?: InventoryFindOptions): Promise<Array<Inventory>>;
     loadInventoriesWithTagAsync(key: string, value: string, skip: number, limit: number, gameId: string, inventoryFindOptions?: InventoryFindOptions): Promise<Array<Inventory>>;
     loadInventoriesWithDisplayNameAsync(keyword: string, skip: number, limit: number, gameId: string, inventoryFindOptions?: InventoryFindOptions): Promise<Array<Inventory>>;
-    loadInventoriesLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, gameId: string, inventoryFindOptions?: InventoryFindOptions): Promise<Array<Inventory>>;
-    loadPositionInventoryLeaderboardWithStatisticsAsync(key: string, itemId: string, gameId: string): Promise<number>;
+    loadInventoriesLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, gameId: string, direction: -1 | 1, inventoryFindOptions?: InventoryFindOptions): Promise<Array<Inventory>>;
+    loadInventoriesLeaderboardWithStatisticsAllAsync(key: string, gameId: string, direction: -1 | 1, inventoryFindOptions?: InventoryFindOptions): Promise<Array<Inventory>>;
+    loadInventoriesLeaderboardWithCreateAsync(skip: number, limit: number, gameId: string, inventoryFindOptions?: InventoryFindOptions): Promise<Array<Inventory>>;
+    loadPositionInventoryLeaderboardWithStatisticsAsync(key: string, itemId: string, gameId: string, initialValue: number, direction: -1 | 1): Promise<number>;
     loadInventoryAsync(itemId: string, gameId: string, inventoryFindOptions?: InventoryFindOptions): Promise<Inventory>;
     createInventoryAsync(result: any, gameId: string): Promise<Inventory>;
+    insertInventoryStatisticsLogAsync(itemId: string, gameId: string, key: string, amount: number, startValue: number, finalValue: number, log: string): Promise<void>;
+    insertInventoryStatisticsLogsAsync(requests: {
+        itemId: string;
+        key: string;
+        amount: number;
+        startValue: number;
+        finalValue: number;
+        tsCreate: number;
+        log: string;
+    }[], gameId: string): Promise<void>;
+    loadInventoryStatisticsLogAsync($filter: {}, gameId: string, limit: number): Promise<mongoDB.FindCursor<mongoDB.WithId<mongoDB.BSON.Document>>>;
     private convertToStoreInventories;
     loadStoreInventoryAsync(storeId: string, gameId: string, storeInventoryFindOptions?: StoreInventoryFindOptions): Promise<StoreInventory>;
     loadStoreInventoryByFacebookStoreAsync(productId: string, gameId: string, storeInventoryFindOptions?: StoreInventoryFindOptions): Promise<StoreInventory>;
     loadStoreInventoryByAppleAppStoreAsync(productId: string, gameId: string, storeInventoryFindOptions?: StoreInventoryFindOptions): Promise<StoreInventory>;
     loadStoreInventoryByGooglePlayStoreAsync(productId: string, gameId: string, storeInventoryFindOptions?: StoreInventoryFindOptions): Promise<StoreInventory>;
     loadStoreInventoriesWithTagAsync(key: string, value: string, skip: number, limit: number, gameId: string, storeInventoryFindOptions?: StoreInventoryFindOptions): Promise<Array<StoreInventory>>;
+    loadStoreInventoriesLeaderboardWithCreateAsync(skip: number, limit: number, gameId: string, storeInventoryFindOptions?: StoreInventoryFindOptions): Promise<Array<StoreInventory>>;
     createStoreInventoryAsync(result: any, gameId: string): Promise<StoreInventory>;
     loadGroupMessagesAsync(groupId: string, gameId: string, skip: number, limit: number): Promise<mongoDB.FindCursor<mongoDB.WithId<mongoDB.Document>>>;
     createGroupMessageAsync(groupId: string, gameId: string, senderId: string, senderType: number, message: string, tsCreate: number): Promise<mongoDB.Document>;
+    insertGroupStatisticsLogAsync(groupId: string, gameId: string, key: string, amount: number, startValue: number, finalValue: number, log: string): Promise<void>;
+    insertGroupStatisticsLogsAsync(requests: {
+        groupId: string;
+        key: string;
+        amount: number;
+        startValue: number;
+        finalValue: number;
+        tsCreate: number;
+        log: string;
+    }[], gameId: string): Promise<void>;
+    insertGroupCurrencyLogAsync(groupId: string, gameId: string, key: string, amount: number, startValue: number, finalValue: number, log: string): Promise<void>;
+    loadGroupStatisticsLogAsync($filter: {}, gameId: string, limit: number): Promise<mongoDB.FindCursor<mongoDB.WithId<mongoDB.BSON.Document>>>;
+    loadGroupCurrencyLogAsync($filter: {}, gameId: string, limit: number): Promise<mongoDB.FindCursor<mongoDB.WithId<mongoDB.BSON.Document>>>;
     loadUploadFileInfoAsync(fileId: string): Promise<UploadFileInfo>;
     createUploadFileInfoAsync(result: any): Promise<UploadFileInfo>;
     private getFindOptions;

package/dist/GN-library/xdebug/lib/xDebug.d.ts

@@ -9,6 +9,7 @@ export declare class Debug {
     private static logPath;
     private static logger;
     static init(config: DebugConfiguration): void;
+    static getLogPath(): string;
     static run(): void;
     static log(message: any, ...args: any[]): void;
     static logInfo(message: any, ...args: any[]): void;

package/dist/GN-library/xmail/lib/xMail.d.ts

@@ -9,8 +9,10 @@ export declare class xMail {
     private isInit;
     private sendGridApiKey;
     private fromEmail;
+    private needSetup;
     init(sendGridApiKey: string, fromEmail: string): void;
     run(onRunSuccess?: OnRunSuccess): void;
-    sendMail(toEmail: string, subject: string, contentHTML: string, onSendMailSuccess?: OnSendMailSuccess, onSendMailError?: OnSendMailError): Promise<void>;
+    sendMail(toEmail: string, subject: string, contentHtml: string, onSendMailSuccess?: OnSendMailSuccess, onSendMailError?: OnSendMailError): Promise<void>;
+    sendMailToMore(toEmails: string[], subject: string, contentHtml: string, onSendMailSuccess?: OnSendMailSuccess, onSendMailError?: OnSendMailError): Promise<void>;
 }
 export {};

package/dist/GN-library/xnotification/lib/xPushNotification.d.ts

@@ -0,0 +1,27 @@
+import { OnRunSuccess } from "./../../xbuilder/lib/OnRunSuccess";
+interface OnSendNotificationSuccess {
+    (): void;
+}
+interface OnSendNotificationError {
+    (error: string): void;
+}
+export declare class xPushNotification {
+    private isInit;
+    private projectId;
+    private clientEmail;
+    private privateKey;
+    private messaging;
+    private needSetup;
+    init(projectId: string, clientEmail: string, privateKey: string): void;
+    run(onRunSuccess?: OnRunSuccess): Promise<void>;
+    sendNotification(token: string, title: string, body: string, badge?: number, sound?: string, icon?: string, data?: {
+        [k: string]: any;
+    }, onSendNotificationSuccess?: OnSendNotificationSuccess, onSendNotificationError?: OnSendNotificationError): Promise<any>;
+    sendNotificationToMore(tokens: string[], title: string, body: string, badge?: number, sound?: string, icon?: string, data?: {
+        [k: string]: any;
+    }, onSendNotificationSuccess?: OnSendNotificationSuccess, onSendNotificationError?: OnSendNotificationError): Promise<any>;
+    sendNotificationToTopic(topic: string, title: string, body: string, badge?: number, sound?: string, icon?: string, data?: {
+        [k: string]: any;
+    }, onSendNotificationSuccess?: OnSendNotificationSuccess, onSendNotificationError?: OnSendNotificationError): Promise<any>;
+}
+export {};

package/dist/GN-library/xsettings/lib/entity/xCurrencySettings.d.ts

@@ -1,4 +1,6 @@
 export interface xCurrencySettings {
     key: string;
     initialValue: number;
+    displayName: string;
+    index: boolean;
 }

package/dist/GN-library/xsettings/lib/entity/xEmailSettings.d.ts

@@ -0,0 +1,4 @@
+export interface xEmailSettings {
+    sendFrom: string;
+    sendGridApiKey: string;
+}

package/dist/GN-library/xsettings/lib/entity/xPushNotificationSettings.d.ts

@@ -0,0 +1,5 @@
+export interface xPushNotificationSettings {
+    projectId: string;
+    clientEmail: string;
+    privateKey: string;
+}

package/dist/GN-library/xsettings/lib/entity/xStatisticsSettings.d.ts

@@ -3,4 +3,7 @@ export interface xStatisticsSettings {
     statisticsAggregationMethod: number;
     maximumValue?: number;
     minimumValue?: number;
+    displayName: string;
+    initialValue: number;
+    index: boolean;
 }

package/dist/GN-library/xsettings/lib/entity/xTagSettings.d.ts

@@ -1,4 +1,5 @@
 export interface xTagSettings {
     key: string;
     displayName: string;
+    index: boolean;
 }

package/dist/GN-library/xsettings/lib/entity/xThirtPartySettings.d.ts

@@ -7,6 +7,9 @@ export interface xThirtPartySettings {
     appleSettings?: {
         appleClientId: string;
         sandboxEnable: boolean;
+        issuerId: string;
+        keyId: string;
+        p8Content: string;
     };
     facebookSettings?: {
         facebookAppId: string;
@@ -14,4 +17,13 @@ export interface xThirtPartySettings {
         facebookInappSecret: string;
         facebookAppToken: string;
     };
+    googlePlayGameSettings?: {
+        applicationId: string;
+        clientId: string;
+        clientSecret: string;
+        redirectUri: string;
+    };
+    gameCenterSettings?: {
+        packageId: string;
+    };
 }

package/dist/GN-startup/DefaultApplicationStartup.d.ts

@@ -5,7 +5,6 @@ import { ServerApplication } from "./ServerApplication";
 import { GNServer } from "./../GNServer";
 import { OtherSettings } from "./settings/OtherSettings";
 import { DatabaseSettings } from "./settings/DatabaseSettings";
-import { MailSettings } from "./settings/MailSettings";
 import { OnRunSuccess } from "./../GN-library/xbuilder/lib/OnRunSuccess";
 import { LogSettings } from "./settings/LogSettings";
 import { UploadFileSettings } from "./settings/UploadFileSettings";
@@ -13,6 +12,6 @@ import { DdosSettings } from "./settings/DDosSettings";
 export declare class DefaultApplicationStartup {
     protected serverApplication: ServerApplication;
     run(onRunSuccess?: OnRunSuccess): void;
-    protected newServerApplication(applicationSettings: ApplicationSettings, httpAppSettings: HttpAppSettings, socketAppSettings: SocketAppSettings, otherSettings: OtherSettings, databaseSettings: DatabaseSettings, mailSettings: MailSettings, logSettings: LogSettings, uploadFileSettings: UploadFileSettings, ddosSettings: DdosSettings): ServerApplication;
+    protected newServerApplication(applicationSettings: ApplicationSettings, httpAppSettings: HttpAppSettings, socketAppSettings: SocketAppSettings, otherSettings: OtherSettings, databaseSettings: DatabaseSettings, logSettings: LogSettings, uploadFileSettings: UploadFileSettings, ddosSettings: DdosSettings): ServerApplication;
     getGNServer(): GNServer;
 }

package/dist/GN-startup/HttpApp.d.ts

@@ -10,7 +10,6 @@ import { AntiDdosMiddleware } from "./middleware/AntiDdosMiddleware";
 import { SocketAppSettings } from "./settings/SocketAppSettings";
 import { ApplicationSettings } from "./settings/ApplicationSettings";
 import { LogSettings } from "./settings/LogSettings";
-import { AdminAppHandler } from "./routes/AdminAppHandler";
 export declare class HttpApp {
     private applicationSettings;
     private uploadFileSettings;
@@ -19,7 +18,6 @@ export declare class HttpApp {
     private app;
     private httpAppHandler;
     private uploadFileHandler;
-    private adminAppHandler;
     private antiDdosMiddleware;
     private logSettings;
     private apiMiddleware;
@@ -29,7 +27,6 @@ export declare class HttpApp {
     setApp(app: Express): void;
     getApp(): Express;
     getHttpAppHandler(): HttpAppHandler;
-    getAdminAppHandler(): AdminAppHandler;
     getUploadFileHandler(): UploadFileHandler;
     setApiMiddleware(apiMiddleware: ApiMiddleware): void;
     setUploadFileMiddleware(uploadFileMiddleware: UploadFileMiddleware): void;

package/dist/GN-startup/ServerApplication.d.ts

@@ -3,7 +3,6 @@ import { ApplicationSettings } from "./settings/ApplicationSettings";
 import { HttpAppSettings } from "./settings/HttpAppSettings";
 import { SocketAppSettings } from "./settings/SocketAppSettings";
 import { GNServer } from "./../GNServer";
-import { MailSettings } from "./settings/MailSettings";
 import { DatabaseSettings } from "./settings/DatabaseSettings";
 import { OtherSettings } from "./settings/OtherSettings";
 import { OnRunSuccess } from "./../GN-library/xbuilder/lib/OnRunSuccess";
@@ -14,7 +13,6 @@ declare abstract class BuilderBase {
     protected applicationSettings: ApplicationSettings;
     protected httpAppSettings: HttpAppSettings;
     protected socketAppSettings: SocketAppSettings;
-    protected mailSettings: MailSettings;
     protected databaseSettings: DatabaseSettings;
     protected otherSettings: OtherSettings;
     protected logSettings: LogSettings;
@@ -24,7 +22,6 @@ declare abstract class BuilderBase {
     getHttpAppSettings(): HttpAppSettings;
     getSocketAppSettings(): SocketAppSettings;
     getDatabaseSettings(): DatabaseSettings;
-    getMailSettings(): MailSettings;
     getOtherSettings(): OtherSettings;
     getLogSettings(): LogSettings;
     getUploadFileSettings(): UploadFileSettings;
@@ -36,7 +33,6 @@ declare class Builder extends BuilderBase implements IBuilder<ServerApplication>
     setHttpAppSettings(httpAppSettings: HttpAppSettings): Builder;
     setSocketAppSettings(socketAppSettings: SocketAppSettings): Builder;
     setDatabaseSettings(databaseSettings: DatabaseSettings): Builder;
-    setMailSettings(mailSettings: MailSettings): Builder;
     setOtherSettings(otherSettings: OtherSettings): Builder;
     setLogSettings(logSettings: LogSettings): Builder;
     setUploadFileSettings(uploadFileSettings: UploadFileSettings): Builder;