@xmobitea/gn-server 2.5.0 → 2.6.0

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

@@ -9,6 +9,7 @@ export declare class SecretInfoItem extends MasterAdminMongoObject {
     private static readonly _tsExpire;
     private static readonly _permission;
     private static readonly _tsCreate;
+    private static readonly _displayName;
     private static readonly _creatorId;
     private readonly gameId;
     private readonly secretKey;
@@ -17,6 +18,7 @@ export declare class SecretInfoItem extends MasterAdminMongoObject {
     private readonly creatorId;
     private remove;
     private tsExpire;
+    private displayName;
     private permission;
     constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
     private setDocumentMasterSecretInfoItem;
@@ -29,6 +31,8 @@ export declare class SecretInfoItem extends MasterAdminMongoObject {
     setRemove(isRemove: boolean): void;
     getTsExpire(): number;
     setTsExpire(tsExpire: number): void;
+    getDisplayName(): string;
+    setDisplayName(displayName: string): void;
     getPermission(): SecretPermissionItem;
     setPermission(permission: SecretPermissionItem): void;
 }

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

@@ -13,6 +13,7 @@ import { InventoryFindOptions } from "./entity/pro/findOptions/InventoryFindOpti
 import { StoreInventoryFindOptions } from "./entity/pro/findOptions/StoreInventoryFindOptions";
 import { StoreInventory } from "./entity/pro/StoreInventory";
 import { UploadFileInfo } from "./entity/pro/UploadFileInfo";
+import { FileUploadInfoFindOptions } from "./entity/pro/findOptions/FileUploadInfoFindOptions";
 interface OnMongoRunError {
     (error: mongoDB.AnyError): void;
 }
@@ -48,8 +49,9 @@ export declare class xDatabase {
     loadMasterPlayersWithGenericServiceAsync(genericService: string, genericIds: string[], masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
     loadMasterPlayersWithSegmentAsync(segment: string, skip: number, limit: number, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
     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(displayNameNormalize: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerWithDisplayNameAsync(displayName: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerWithDisplayNameNormalizeAsync(displayNameNormalize: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayersWithDisplayNameNormalizeRegexAsync(keyword: 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>>;
@@ -78,8 +80,9 @@ export declare class xDatabase {
     private convertToGamePlayers;
     loadGamePlayersWithSegmentAsync(segment: string, skip: number, limit: number, gameId: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<Array<GamePlayer>>;
     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(displayNameNormalize: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<GamePlayer>;
+    loadGamePlayerWithDisplayNameAsync(displayName: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<GamePlayer>;
+    loadGamePlayerWithDisplayNameNormalizeAsync(displayNameNormalize: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<GamePlayer>;
+    loadGamePlayersWithDisplayNameNormalizeRegexAsync(keyword: 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>>;
@@ -119,7 +122,9 @@ export declare class xDatabase {
     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>>;
+    loadCharacterPlayerWithDisplayNameAsync(displayName: string, gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<CharacterPlayer>;
+    loadCharacterPlayerWithDisplayNameNormalizeAsync(displayNameNormalize: string, gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<CharacterPlayer>;
+    loadCharacterPlayersWithDisplayNameNormalizeRegexAsync(keyword: string, skip: number, limit: number, gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
     loadCharacterPlayersLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, catalogId: string, gameId: string, direction: -1 | 1, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
     loadCharacterPlayersLeaderboardWithStatisticsAllAsync(key: string, catalogId: string, gameId: string, direction: -1 | 1, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
     loadCharacterPlayersLeaderboardWithCreateAsync(skip: number, limit: number, gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
@@ -170,7 +175,9 @@ export declare class xDatabase {
     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>>;
+    loadGroupWithDisplayNameAsync(displayName: string, gameId: string, groupFindOptions?: GroupFindOptions): Promise<Group>;
+    loadGroupWithDisplayNameNormalizeAsync(displayNameNormalize: string, gameId: string, groupFindOptions?: GroupFindOptions): Promise<Group>;
+    loadGroupsWithDisplayNameNormalizeRegexAsync(keyword: string, skip: number, limit: number, gameId: string, groupFindOptions?: GroupFindOptions): Promise<Array<Group>>;
     loadGroupsLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, catalogId: string, gameId: string, direction: -1 | 1, groupFindOptions?: GroupFindOptions): Promise<Array<Group>>;
     loadGroupsLeaderboardWithStatisticsAllAsync(key: string, catalogId: string, gameId: string, direction: -1 | 1, groupFindOptions?: GroupFindOptions): Promise<Array<Group>>;
     loadGroupsLeaderboardWithCreateAsync(skip: number, limit: number, gameId: string, groupFindOptions?: GroupFindOptions): Promise<Array<Group>>;
@@ -182,7 +189,9 @@ export declare class xDatabase {
     private convertToInventories;
     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>>;
+    loadInventoryWithDisplayNameAsync(displayName: string, gameId: string, inventoryFindOptions?: InventoryFindOptions): Promise<Inventory>;
+    loadInventoryWithDisplayNameNormalizeAsync(displayNameNormalize: string, gameId: string, inventoryFindOptions?: InventoryFindOptions): Promise<Inventory>;
+    loadInventoriesWithDisplayNameNormalizeRegexAsync(keyword: string, skip: number, limit: number, gameId: string, inventoryFindOptions?: InventoryFindOptions): Promise<Array<Inventory>>;
     loadInventoriesLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, catalogId: string, gameId: string, direction: -1 | 1, inventoryFindOptions?: InventoryFindOptions): Promise<Array<Inventory>>;
     loadInventoriesLeaderboardWithStatisticsAllAsync(key: string, catalogId: string, gameId: string, direction: -1 | 1, inventoryFindOptions?: InventoryFindOptions): Promise<Array<Inventory>>;
     loadInventoriesLeaderboardWithCreateAsync(skip: number, limit: number, gameId: string, inventoryFindOptions?: InventoryFindOptions): Promise<Array<Inventory>>;
@@ -234,7 +243,7 @@ export declare class xDatabase {
     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>;
+    loadUploadFileInfoAsync(fileId: string, fileUploadInfoFindOptions?: FileUploadInfoFindOptions): Promise<UploadFileInfo>;
     createUploadFileInfoAsync(result: any): Promise<UploadFileInfo>;
     private getFindOptions;
 }

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

@@ -9,9 +9,10 @@ import { OnRunSuccess } from "./../GN-library/xbuilder/lib/OnRunSuccess";
 import { LogSettings } from "./settings/LogSettings";
 import { UploadFileSettings } from "./settings/UploadFileSettings";
 import { DdosSettings } from "./settings/DDosSettings";
+import { ClusterSettings } from "./settings/ClusterSettings";
 export declare class DefaultApplicationStartup {
     protected serverApplication: ServerApplication;
     run(onRunSuccess?: OnRunSuccess): void;
-    protected newServerApplication(applicationSettings: ApplicationSettings, httpAppSettings: HttpAppSettings, socketAppSettings: SocketAppSettings, otherSettings: OtherSettings, databaseSettings: DatabaseSettings, 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, clusterSettings: ClusterSettings): ServerApplication;
     getGNServer(): GNServer;
 }

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

@@ -1,6 +1,7 @@
 import { HttpAppSettings } from "./settings/HttpAppSettings";
 import { HttpAppHandler } from "./routes/HttpAppHandler";
 import { UploadFileHandler } from "./routes/UploadFileHandler";
+import { ClusterHandler } from "./routes/ClusterHandler";
 import { Express } from "express";
 import { ApiMiddleware } from "./middleware/ApiMiddleware";
 import { UploadFileMiddleware } from "./middleware/UploadFileMiddleware";
@@ -10,14 +11,17 @@ import { AntiDdosMiddleware } from "./middleware/AntiDdosMiddleware";
 import { SocketAppSettings } from "./settings/SocketAppSettings";
 import { ApplicationSettings } from "./settings/ApplicationSettings";
 import { LogSettings } from "./settings/LogSettings";
+import { ClusterSettings } from "./settings/ClusterSettings";
 export declare class HttpApp {
     private applicationSettings;
     private uploadFileSettings;
     private appSettings;
     private socketAppSettings;
+    private clusterSettings;
     private app;
     private httpAppHandler;
     private uploadFileHandler;
+    private clusterHandler;
     private antiDdosMiddleware;
     private logSettings;
     private apiMiddleware;
@@ -28,11 +32,13 @@ export declare class HttpApp {
     getApp(): Express;
     getHttpAppHandler(): HttpAppHandler;
     getUploadFileHandler(): UploadFileHandler;
+    getClusterHandler(): ClusterHandler;
     setApiMiddleware(apiMiddleware: ApiMiddleware): void;
     setUploadFileMiddleware(uploadFileMiddleware: UploadFileMiddleware): void;
     setApplicationSettings(applicationSettings: ApplicationSettings): void;
     setAppSettings(appSettings: HttpAppSettings): void;
     setSocketAppSettings(socketAppSettings: SocketAppSettings): void;
+    setClusterSettings(clusterSettings: ClusterSettings): void;
     setUploadFileSettings(uploadFileSettings: UploadFileSettings): void;
     setGNServer(gnServer: GNServer): void;
     setSessionId(sessionId: string): void;

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

@@ -9,6 +9,7 @@ import { OnRunSuccess } from "./../GN-library/xbuilder/lib/OnRunSuccess";
 import { LogSettings } from "./settings/LogSettings";
 import { UploadFileSettings } from "./settings/UploadFileSettings";
 import { DdosSettings } from "./settings/DDosSettings";
+import { ClusterSettings } from "./settings/ClusterSettings";
 declare abstract class BuilderBase {
     protected applicationSettings: ApplicationSettings;
     protected httpAppSettings: HttpAppSettings;
@@ -18,6 +19,7 @@ declare abstract class BuilderBase {
     protected logSettings: LogSettings;
     protected uploadFileSettings: UploadFileSettings;
     protected ddosSettings: DdosSettings;
+    protected clusterSettings: ClusterSettings;
     getApplicationSettings(): ApplicationSettings;
     getHttpAppSettings(): HttpAppSettings;
     getSocketAppSettings(): SocketAppSettings;
@@ -26,6 +28,7 @@ declare abstract class BuilderBase {
     getLogSettings(): LogSettings;
     getUploadFileSettings(): UploadFileSettings;
     getDdosSettings(): DdosSettings;
+    getClusterSettings(): ClusterSettings;
     constructor();
 }
 declare class Builder extends BuilderBase implements IBuilder<ServerApplication> {
@@ -37,6 +40,7 @@ declare class Builder extends BuilderBase implements IBuilder<ServerApplication>
     setLogSettings(logSettings: LogSettings): Builder;
     setUploadFileSettings(uploadFileSettings: UploadFileSettings): Builder;
     setDdosSettings(ddosSettings: DdosSettings): Builder;
+    setClusterSettings(clusterSettings: ClusterSettings): Builder;
     build(): ServerApplication;
     constructor();
 }

package/dist/GN-startup/cloudScript/eventCallbackCloudScriptData.json

@@ -378,7 +378,7 @@
             },
             {
                 "eventName": "characterPlayer_SetDisplayName",
-                "script": "\npreHandlers.characterPlayer_SetDisplayName = async (request: { characterId: string, displayName: string }, secretInfo: SecretInfo, operationRequest: OperationRequest, log: (log: any) => void) => {\n\n\treturn null;\n}\n\npostHandlers.characterPlayer_SetDisplayName = async (request: { characterId: string, displayName: string }, secretInfo: SecretInfo, operationRequest: OperationRequest, operationResponse: OperationResponse, log: (log: any) => void) => {\n\n\treturn operationResponse;\n}\n",
+                "script": "\npreHandlers.characterPlayer_SetDisplayName = async (request: { characterId: string, displayName: string, uniqueDisplayName: boolean, }, secretInfo: SecretInfo, operationRequest: OperationRequest, log: (log: any) => void) => {\n\n\treturn null;\n}\n\npostHandlers.characterPlayer_SetDisplayName = async (request: { characterId: string, displayName: string, uniqueDisplayName: boolean, }, secretInfo: SecretInfo, operationRequest: OperationRequest, operationResponse: OperationResponse, log: (log: any) => void) => {\n\n\treturn operationResponse;\n}\n",
                 "hasEdit": false
             },
             {
@@ -459,7 +459,7 @@
         "childScripts": [
             {
                 "eventName": "content_CreateNewFileUploadInfo",
-                "script": "\npreHandlers.content_CreateNewFileUploadInfo = async (request: { userId: string, fileName: string }, secretInfo: SecretInfo, operationRequest: OperationRequest, log: (log: any) => void) => {\n\n\treturn null;\n}\n\npostHandlers.content_CreateNewFileUploadInfo = async (request: { userId: string, fileName: string }, secretInfo: SecretInfo, operationRequest: OperationRequest, operationResponse: OperationResponse, log: (log: any) => void) => {\n\n\treturn operationResponse;\n}\n",
+                "script": "\npreHandlers.content_CreateNewFileUploadInfo = async (request: { fileName: string }, secretInfo: SecretInfo, operationRequest: OperationRequest, log: (log: any) => void) => {\n\n\treturn null;\n}\n\npostHandlers.content_CreateNewFileUploadInfo = async (request: { fileName: string }, secretInfo: SecretInfo, operationRequest: OperationRequest, operationResponse: OperationResponse, log: (log: any) => void) => {\n\n\treturn operationResponse;\n}\n",
                 "hasEdit": false
             },
             {
@@ -622,7 +622,7 @@
             },
             {
                 "eventName": "dashboard_SetSecretInfoInformation",
-                "script": "\npreHandlers.dashboard_SetSecretInfoInformation = async (request: { secretKey: string, remove: boolean, tsExpire: number, permissionParam: PermissionParam }, secretInfo: SecretInfo, operationRequest: OperationRequest, log: (log: any) => void) => {\n\n\treturn null;\n}\n\npostHandlers.dashboard_SetSecretInfoInformation = async (request: { secretKey: string, remove: boolean, tsExpire: number, permissionParam: PermissionParam }, secretInfo: SecretInfo, operationRequest: OperationRequest, operationResponse: OperationResponse, log: (log: any) => void) => {\n\n\treturn operationResponse;\n}\n",
+                "script": "\npreHandlers.dashboard_SetSecretInfoInformation = async (request: { secretKey: string, remove: boolean, tsExpire: number, permissionParam: PermissionParam, displayName: string, }, secretInfo: SecretInfo, operationRequest: OperationRequest, log: (log: any) => void) => {\n\n\treturn null;\n}\n\npostHandlers.dashboard_SetSecretInfoInformation = async (request: { secretKey: string, remove: boolean, tsExpire: number, permissionParam: PermissionParam, displayName: string, }, secretInfo: SecretInfo, operationRequest: OperationRequest, operationResponse: OperationResponse, log: (log: any) => void) => {\n\n\treturn operationResponse;\n}\n",
                 "hasEdit": false
             },
             {
@@ -810,7 +810,7 @@
             },
             {
                 "eventName": "gamePlayer_GrantPlayerCharacter",
-                "script": "\npreHandlers.gamePlayer_GrantPlayerCharacter = async (request: { userId: string, catalogId: string, displayName: string, ipAddress: string }, secretInfo: SecretInfo, operationRequest: OperationRequest, log: (log: any) => void) => {\n\n\treturn null;\n}\n\npostHandlers.gamePlayer_GrantPlayerCharacter = async (request: { userId: string, catalogId: string, displayName: string, ipAddress: string }, secretInfo: SecretInfo, operationRequest: OperationRequest, operationResponse: OperationResponse, log: (log: any) => void) => {\n\n\treturn operationResponse;\n}\n",
+                "script": "\npreHandlers.gamePlayer_GrantPlayerCharacter = async (request: { userId: string, catalogId: string, displayName: string, uniqueDisplayName: boolean, ipAddress: string }, secretInfo: SecretInfo, operationRequest: OperationRequest, log: (log: any) => void) => {\n\n\treturn null;\n}\n\npostHandlers.gamePlayer_GrantPlayerCharacter = async (request: { userId: string, catalogId: string, displayName: string, uniqueDisplayName: boolean, ipAddress: string }, secretInfo: SecretInfo, operationRequest: OperationRequest, operationResponse: OperationResponse, log: (log: any) => void) => {\n\n\treturn operationResponse;\n}\n",
                 "hasEdit": false
             },
             {

package/dist/GN-startup/cloudScript/templateCloudScript.ts

@@ -375,6 +375,38 @@ class CloudScriptPushNotification {
                 },
             });
 	}
+
+    public async subscribeToTopic(tokens: string[], topic: string) {
+		if (process?.send)
+            process.send({
+                eventType: 33,
+                receiver: null,
+                operationEvent: {
+                    eventCode: 0,
+                    encrypted: false,
+                    parameters: {
+                        tokens: tokens,
+                        topic: topic,
+                    },
+                },
+            });
+	}
+
+    public async unsubscribeFromTopic(tokens: string[], topic: string) {
+		if (process?.send)
+            process.send({
+                eventType: 34,
+                receiver: null,
+                operationEvent: {
+                    eventCode: 0,
+                    encrypted: false,
+                    parameters: {
+                        tokens: tokens,
+                        topic: topic,
+                    },
+                },
+            });
+	}
 }
 
 interface CloudScriptRequest {

package/dist/GN-startup/cloudScript/templateEventCallback.ts

@@ -470,6 +470,38 @@ class CloudScriptPushNotification {
                 },
             });
 	}
+
+    public async subscribeToTopic(tokens: string[], topic: string) {
+		if (process?.send)
+            process.send({
+                eventType: 33,
+                receiver: null,
+                operationEvent: {
+                    eventCode: 0,
+                    encrypted: false,
+                    parameters: {
+                        tokens: tokens,
+                        topic: topic,
+                    },
+                },
+            });
+	}
+
+    public async unsubscribeFromTopic(tokens: string[], topic: string) {
+		if (process?.send)
+            process.send({
+                eventType: 34,
+                receiver: null,
+                operationEvent: {
+                    eventCode: 0,
+                    encrypted: false,
+                    parameters: {
+                        tokens: tokens,
+                        topic: topic,
+                    },
+                },
+            });
+	}
 }
 
 enum EventCallbackType {

package/dist/GN-startup/middleware/AntiDdosMiddleware.d.ts

@@ -3,6 +3,7 @@ import { Socket } from "socket.io";
 import * as mongoDB from "mongodb";
 export declare class AntiDdosMiddleware {
     private static readonly FIVE_MINUTE_TS;
+    private static readonly K_MULTIPLE_ADMIN;
     private static readonly K_MULTIPLE_WHITE_LIST;
     private static readonly K_MULTIPLE_BLACK_LIST;
     private socketRequestPerIPDic;

package/dist/GN-startup/routes/ClusterHandler.d.ts

@@ -0,0 +1,34 @@
+import express from "express";
+interface NodeInfo {
+    instanceId: string;
+    fullUrl: string;
+}
+export declare class ClusterHandler {
+    private router;
+    private clusterRouter;
+    private instanceId;
+    private isPrimary;
+    private privateKeyToken;
+    private allNodes;
+    private instanceInfoStatus;
+    private instanceInfos;
+    private onEventCallback;
+    private isSingleNode;
+    setRouter(router: express.Express): void;
+    setInstanceId(instanceId: string): void;
+    setIsPrimary(isPrimary: boolean): void;
+    getIsPrimary(): boolean;
+    getIsSingleNode(): boolean;
+    setPrivateKeyToken(privateKeyToken: string): void;
+    setAllNodes(allNodes: NodeInfo[]): void;
+    init(): void;
+    run(): void;
+    private callbackInvoke;
+    private update;
+    private checkInstanceStatus;
+    private checkInstancePrimary;
+    onEvent(name: string, onData: (data: any) => void): void;
+    sendEvent(name: string, data?: any, includeMe?: boolean): Promise<void>;
+    constructor();
+}
+export {};

package/dist/GN-startup/routes/UploadFileHandler.d.ts

@@ -21,4 +21,5 @@ export declare class UploadFileHandler {
     setDownloadFileSessionCollection(downloadFileSessionCollection: mongoDB.Collection<mongoDB.Document>): void;
     init(): void;
     run(): void;
+    removeFile(fullPath: string): void;
 }

package/dist/GN-startup/routes/utils/wrap.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction, RequestHandler } from 'express';
+export declare function wrap(fn: (req: Request, res: Response, next: NextFunction) => any): RequestHandler;

package/dist/GN-startup/settings/ClusterSettings.d.ts

@@ -0,0 +1,29 @@
+import { IBuilder } from "./../../GN-library/xbuilder/lib/IBuilder";
+interface NodeInfo {
+    instanceId: string;
+    fullUrl: string;
+}
+declare abstract class BuilderBase {
+    protected instanceId: string;
+    protected isPrimary: boolean;
+    protected privateKeyToken: string;
+    protected allNodes: NodeInfo[];
+    getInstanceId(): string;
+    getIsPrimary(): boolean;
+    getPrivateKeyToken(): string;
+    getAllNodes(): NodeInfo[];
+    constructor();
+}
+declare class Builder extends BuilderBase implements IBuilder<ClusterSettings> {
+    setInstanceId(instanceId: string): Builder;
+    setIsPrimary(isPrimary: boolean): Builder;
+    setPrivateKeyToken(privateKeyToken: string): Builder;
+    setAllNodes(allNodes: NodeInfo[]): Builder;
+    constructor();
+    build(): ClusterSettings;
+}
+export declare class ClusterSettings extends BuilderBase {
+    constructor(builder: Builder);
+    static Builder(): Builder;
+}
+export {};

package/dist/GNServer.d.ts

@@ -1,24 +1,23 @@
 import { RequestController } from "./GN-app-api/handler/controller/RequestController";
 import { OperationEvent } from "./GN-common/entity/operationEvent/OperationEvent";
-import { xConfig } from "./GN-library/xconfig/lib/xConfig";
 import { xDatabase } from "./GN-library/xdatabase/lib/xDatabase";
 import { SocketApp } from "./GN-startup/SocketApp";
 import { HttpApp } from "./GN-startup/HttpApp";
 import { IRequestHandler } from "./GN-app-api/handler/controller/handler/base/IRequestHandler";
-import { xMail } from "./GN-library/xmail/lib/xMail";
-import { xPushNotification } from "./GN-library/xnotification/lib/xPushNotification";
 import { IFacebookService } from "./GN-app-api/service/IFacebookService";
 import { IGenericService } from "./GN-app-api/service/IGenericService";
 import { IAppleService } from "./GN-app-api/service/IAppleService";
 import { ICloudScriptService } from "./GN-app-api/service/ICloudScriptService";
 import { ITimerService } from "./GN-app-api/service/ITimerService";
 import { OnRunSuccess } from "./GN-library/xbuilder/lib/OnRunSuccess";
-import { ILockService } from "./GN-app-api/service/ILockService";
-import { xCacheData } from "./GN-library/xcachedata/lib/xCacheData";
 import { ApiMiddleware } from "./GN-startup/middleware/ApiMiddleware";
 import { IRequestConverterService } from "./GN-app-api/service/IRequestConverterService";
 import { IGoogleService } from "./GN-app-api/service/IGoogleService";
 import { IAnalyticsService } from "./GN-app-api/service/IAnalyticsService";
+import { IPushNotificationService } from "./GN-app-api/service/IPushNotificationService";
+import { IEmailService } from "./GN-app-api/service/IEmailService";
+import { ICacheService } from "./GN-app-api/service/ICacheService";
+import { IConfigService } from "./GN-app-api/service/IConfigService";
 import { xGNSettings } from "./GN-library/xsettings/lib/xGNSettings";
 import { IPostEventCallbackService, IPreEventCallbackService } from "./GN-app-api/service/IEventCallbackService";
 import { IEventCallbackCloudScriptService } from "./GN-app-api/service/EventCallbackService";
@@ -38,12 +37,8 @@ export declare class GNServer {
     private apiMiddleware;
     private requestController;
     private idTypeCase;
-    private xConfigDic;
     private xGNSettings;
     private xDatabase;
-    private xMail;
-    private xPushNotification;
-    private xCacheDataDic;
     private facebookService;
     private genericService;
     private appleService;
@@ -51,7 +46,6 @@ export declare class GNServer {
     private googlePlayGameService;
     private gameCenterService;
     private timerService;
-    private lockService;
     private requestConverterService;
     private analyticsService;
     private postEventCallbackService;
@@ -59,6 +53,10 @@ export declare class GNServer {
     private cloudScriptServiceDic;
     private eventCallbackCloudScriptService;
     private countryIPDetailService;
+    private pushNotificationService;
+    private emailService;
+    private cacheServiceDic;
+    private configServiceDic;
     private gameIds;
     private matchmakingHandler;
     private waitingServerDetailDict;
@@ -79,16 +77,14 @@ export declare class GNServer {
     createIndex(collectionName: string, index: {
         [k: string]: any;
     }, options?: CreateIndexesOptions): void;
-    getConfigGame(gameId: string): xConfig;
-    setConfigGame(gameId: string, config: xConfig): void;
+    getConfigService(gameId: string): IConfigService;
+    setConfigGame(gameId: string, configService: IConfigService): void;
     setIdTypeCase(idTypeCase: number): void;
     getIdTypeCase(): number;
     getGNSettings(): xGNSettings;
     getDatabase(): xDatabase;
-    getMail(): xMail;
-    getPushNotification(): xPushNotification;
-    getCacheData(gameId: string): xCacheData;
-    setCacheData(gameId: string, cacheData: xCacheData): void;
+    getCacheService(gameId: string): ICacheService;
+    setCacheService(gameId: string, cacheService: ICacheService): void;
     getFacebookService(): IFacebookService;
     getGenericService(): IGenericService;
     getPostEventCallbackService(): IPostEventCallbackService;
@@ -100,9 +96,10 @@ export declare class GNServer {
     getGooglePlayGameService(): IGooglePlayGameService;
     getGameCenterService(): IGameCenterService;
     getTimerService(): ITimerService;
-    getLockService(): ILockService;
     getAnalyticsService(): IAnalyticsService;
     getRequestConverterService(): IRequestConverterService;
+    getEmailService(): IEmailService;
+    getPushNotificationService(): IPushNotificationService;
     getCloudScriptService(gameId: string): ICloudScriptService;
     setCloudScriptService(gameId: string, cloudScriptService: ICloudScriptService): Map<string, ICloudScriptService>;
     sendEventTo(userId: string, operationEvent: OperationEvent): Promise<void>;
@@ -121,5 +118,6 @@ export declare class GNServer {
     setMatchServerDetail(gameId: string, matchId: string, serverDetail: ServerDetail, ticketIds: string[]): void;
     setMatchServerDetailFailed(gameId: string, matchId: string, ticketIds: string[], reason: string): void;
     getGameIds(): string[];
+    isPrimary(): boolean;
 }
 export {};

package/dist/index.d.ts

@@ -26,18 +26,28 @@ import { IGenericService, IGenericServiceHandler } from "./GN-app-api/service/IG
 export { IGenericService, IGenericServiceHandler };
 import { IGoogleService } from "./GN-app-api/service/IGoogleService";
 export { IGoogleService };
-import { ILockService } from "./GN-app-api/service/ILockService";
-export { ILockService };
 import { IPushNotificationService } from "./GN-app-api/service/IPushNotificationService";
 export { IPushNotificationService };
+import { PushNotificationService } from "./GN-app-api/service/PushNotificationService";
+export { PushNotificationService };
 import { IRequestConverterService } from "./GN-app-api/service/IRequestConverterService";
 export { IRequestConverterService };
-import { ITimerService } from "./GN-app-api/service/ITimerService";
-export { ITimerService };
-import { LockService } from "./GN-app-api/service/LockService";
-export { LockService };
 import { RequestConverterService } from "./GN-app-api/service/RequestConverterService";
 export { RequestConverterService };
+import { IEmailService } from "./GN-app-api/service/IEmailService";
+export { IEmailService };
+import { EmailService } from "./GN-app-api/service/EmailService";
+export { EmailService };
+import { ICacheService, CacheItem } from "./GN-app-api/service/ICacheService";
+export { ICacheService, CacheItem };
+import { CacheService, ICacheServiceController, MemoryCacheServiceController, MongoDbCacheServiceController } from "./GN-app-api/service/CacheService";
+export { CacheService, ICacheServiceController, MemoryCacheServiceController, MongoDbCacheServiceController };
+import { IConfigService, ConfigItem } from "./GN-app-api/service/IConfigService";
+export { IConfigService, ConfigItem };
+import { ConfigService } from "./GN-app-api/service/ConfigService";
+export { ConfigService };
+import { ITimerService } from "./GN-app-api/service/ITimerService";
+export { ITimerService };
 import { TimerService } from "./GN-app-api/service/TimerService";
 export { TimerService };
 import { GNData, GNArray, GNArrayBuilder, GNHashtable, GNHashtableBuilder } from "./GN-common/common/GNData";
@@ -122,14 +132,6 @@ import { IBuilder } from "./GN-library/xbuilder/lib/IBuilder";
 export { IBuilder };
 import { OnRunSuccess } from "./GN-library/xbuilder/lib/OnRunSuccess";
 export { OnRunSuccess };
-import { xCacheData } from "./GN-library/xcachedata/lib/xCacheData";
-export { xCacheData };
-import { xCacheItem } from "./GN-library/xcachedata/lib/xCacheItem";
-export { xCacheItem };
-import { xConfigItem } from "./GN-library/xconfig/lib/entity/xConfigItem";
-export { xConfigItem };
-import { xConfig } from "./GN-library/xconfig/lib/xConfig";
-export { xConfig };
 import { CharacterPlayerFindOptions } from "./GN-library/xdatabase/lib/entity/pro/findOptions/CharacterPlayerFindOptions";
 export { CharacterPlayerFindOptions };
 import { GamePlayerFindOptions } from "./GN-library/xdatabase/lib/entity/pro/findOptions/GamePlayerFindOptions";
@@ -228,10 +230,6 @@ import { xDatetime } from "./GN-library/xdatetime/lib/xDatetime";
 export { xDatetime };
 import { Debug } from "./GN-library/xdebug/lib/xDebug";
 export { Debug };
-import { xMail } from "./GN-library/xmail/lib/xMail";
-export { xMail };
-import { xPushNotification } from "./GN-library/xnotification/lib/xPushNotification";
-export { xPushNotification };
 import { xRandom } from "./GN-library/xrandom/lib/xRandom";
 export { xRandom };
 import { xCharacterCatalogSettings } from "./GN-library/xsettings/lib/entity/xCharacterCatalogSettings";
@@ -294,6 +292,8 @@ import { DatabaseSettings } from "./GN-startup/settings/DatabaseSettings";
 export { DatabaseSettings };
 import { DdosSettings } from "./GN-startup/settings/DDosSettings";
 export { DdosSettings };
+import { ClusterSettings } from "./GN-startup/settings/ClusterSettings";
+export { ClusterSettings };
 import { HttpAppSettings } from "./GN-startup/settings/HttpAppSettings";
 export { HttpAppSettings };
 import { LogSettings } from "./GN-startup/settings/LogSettings";