@xmobitea/gn-server 2.5.1 → 2.6.0

package/dist/index.js

@@ -138,7 +138,6 @@ __webpack_require__.d(__webpack_exports__, {
   ItemDataParam: () => (/* reexport */ ItemDataParam),
   ItemStatisticsParam: () => (/* reexport */ ItemStatisticsParam),
   ItemType: () => (/* reexport */ ItemType),
-  LockService: () => (/* reexport */ LockService),
   LogSettings: () => (/* reexport */ LogSettings),
   MasterAdminMongoObject: () => (/* reexport */ MasterAdminMongoObject),
   MasterAdminPermissionRulesParam: () => (/* reexport */ MasterAdminPermissionRulesParam),
@@ -1774,7 +1773,7 @@ class AppleService {
                 signedTransactionInfoPayload = external_jsonwebtoken_default().decode(transactionInfoResponse.data.signedTransactionInfo);
             }
             catch (err) {
-                Debug.log("[GN] error while validate apple receipt " + err.toString());
+                Debug.log("[GearN] error while validate apple receipt " + err.toString());
             }
             return {
                 success: true,
@@ -1826,7 +1825,7 @@ class AppleService {
     // 	try {
     // 		let result = await axios.post(AppleService.MAIN_verifyAppleAppStoreAPIUrl, { "receipt-data": payload }, {
     // 			headers: {
-    // 				'Content-Type': 'application/x-www-form-urlencoded'
+    // 				"Content-Type": "application/x-www-form-urlencoded"
     // 			},
     // 		});
     // 		answer = result.data;
@@ -1840,7 +1839,7 @@ class AppleService {
     // 	try {
     // 		let result = await axios.post(AppleService.MAIN_verifySandboxAppleAppStoreAPIUrl, { "receipt-data": payload }, {
     // 			headers: {
-    // 				'Content-Type': 'application/x-www-form-urlencoded'
+    // 				"Content-Type": "application/x-www-form-urlencoded"
     // 			},
     // 		});
     // 		answer = result.data;
@@ -1856,8 +1855,8 @@ class AppleService {
         try {
             let result = await external_axios_default().get(url, {
                 headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': 'Bearer ' + token
+                    "Content-Type": "application/json",
+                    "Authorization": "Bearer " + token
                 },
             });
             return {
@@ -1879,18 +1878,18 @@ class AppleService {
             iss: this.issuerId,
             iat: now,
             exp: now + 30 * 60,
-            aud: 'appstoreconnect-v1',
+            aud: "appstoreconnect-v1",
             bid: this.appleClientId,
         };
         // Create the header
         let header = {
-            alg: 'ES256',
+            alg: "ES256",
             kid: this.keyId,
-            typ: 'JWT',
+            typ: "JWT",
         };
         // Generate the token
         const token = external_jsonwebtoken_default().sign(payload, this.p8Content, {
-            algorithm: 'ES256',
+            algorithm: "ES256",
             header: header,
         });
         return token;
@@ -2574,6 +2573,9 @@ class GNParameterCode {
     static OwnerIds = "ownerIds";
     static GetStoreUsed = "getStoreUsed";
     static RemoveStoreUsed = "removeStoreUsed";
+    static AdminSecretKeys = "adminSecretKeys";
+    static ServerSecretKeys = "serverSecretKeys";
+    static PlayerSecretKeys = "playerSecretKeys";
 }
 
 ;// ./src/GN-app-api/service/EventCallbackService.ts
@@ -2680,15 +2682,15 @@ class EventCallbackCloudScriptService {
     async executeSystem(eventName) {
         let cloudFunction = this.cloudScriptFunctionDict.get("system");
         if (cloudFunction == null) {
-            Debug.logError("[GN] [SystemEventCallback] system not found");
+            Debug.logError("[GearN] [SystemEventCallback] system not found");
             return;
         }
         let cloudScriptWorker = this.loadCloudScriptFunctionWorkerFromCache(cloudFunction.type, eventName);
         if (cloudScriptWorker == null) {
-            Debug.logError("[GN] [SystemEventCallback] worker not found at " + cloudFunction.type);
+            Debug.logError("[GearN] [SystemEventCallback] worker not found at " + cloudFunction.type);
             return;
         }
-        Debug.log("[GN] [SystemEventCallback] auto call " + eventName);
+        Debug.log("[GearN] [SystemEventCallback] auto call " + eventName);
         let requestId = StringUtility.generateRandomString(10, 0);
         let cloudScriptRequest = {
             requestId: requestId,
@@ -2730,22 +2732,22 @@ class EventCallbackCloudScriptService {
         if (cloudScriptResponse.logs.length != 0)
             Debug.log(JSON.stringify(cloudScriptResponse.logs));
         if (cloudScriptResponse.response.status == ExecuteResponseStatus.Ok) {
-            Debug.log("[GN] [SystemEventCallback] auto call success " + eventName);
+            Debug.log("[GearN] [SystemEventCallback] auto call success " + eventName);
         }
         else {
-            Debug.log("[GN] [SystemEventCallback] auto call failed " + eventName + " " + cloudScriptResponse.response.errorMessage);
+            Debug.log("[GearN] [SystemEventCallback] auto call failed " + eventName + " " + cloudScriptResponse.response.errorMessage);
         }
     }
     async executeRequestServerDetailSystem(gameId, matchmakingTicketCanMatch) {
         let cloudFunction = this.cloudScriptFunctionDict.get("system");
         if (cloudFunction == null) {
-            Debug.logError("[GN] [SystemEventCallback] system not found");
+            Debug.logError("[GearN] [SystemEventCallback] system not found");
             return { success: false };
         }
         let eventName = "system_RequestServerDetail";
         let cloudScriptWorker = this.loadCloudScriptFunctionWorkerFromCache(cloudFunction.type, eventName);
         if (cloudScriptWorker == null) {
-            Debug.logError("[GN] [SystemEventCallback] worker not found at " + cloudFunction.type);
+            Debug.logError("[GearN] [SystemEventCallback] worker not found at " + cloudFunction.type);
             return { success: false };
         }
         let requestId = StringUtility.generateRandomString(10, 0);
@@ -2803,12 +2805,12 @@ class EventCallbackCloudScriptService {
     async executeEvent(eventName, request, operationEvent) {
         let cloudFunction = this.cloudScriptFunctionDict.get("system");
         if (cloudFunction == null) {
-            Debug.logError("[GN] [SystemEventCallback] system not found");
+            Debug.logError("[GearN] [SystemEventCallback] system not found");
             return;
         }
         let cloudScriptWorker = this.loadCloudScriptFunctionWorkerFromCache(cloudFunction.type, eventName);
         if (cloudScriptWorker == null) {
-            Debug.logError("[GN] [SystemEventCallback] worker not found at " + cloudFunction.type);
+            Debug.logError("[GearN] [SystemEventCallback] worker not found at " + cloudFunction.type);
             return;
         }
         let requestId = StringUtility.generateRandomString(10, 0);
@@ -3180,7 +3182,7 @@ class EventCallbackCloudScriptService {
     loadCloudScriptWorker(type, version) {
         let finalVersion = type + "_" + version;
         let filePath = __dirname + "/./GN-startup/cloudScript/" + finalVersion + ".js";
-        Debug.log("[GN] [EventCallback] run cloudScript " + finalVersion);
+        Debug.log("[GearN] [EventCallback] run cloudScript " + finalVersion);
         let cloudScriptWorker = (0,external_child_process_namespaceObject.fork)(filePath, {
             env: {
                 gnServerSettingsOptions: JSON.stringify(this.gnServerSettingsOptions),
@@ -3245,7 +3247,7 @@ class EventCallbackCloudScriptService {
             }
         });
         cloudScriptWorker.on("exit", (code) => {
-            Debug.log("[GN] [EventCallback] terminal cloudScript " + finalVersion + " with code " + code);
+            Debug.log("[GearN] [EventCallback] terminal cloudScript " + finalVersion + " with code " + code);
             thiz.cloudScriptWorkerDict.delete(finalVersion);
         });
         this.cloudScriptWorkerDict.set(finalVersion, cloudScriptWorker);
@@ -3345,8 +3347,9 @@ class PreEventCallbackService {
     }
 }
 
-;// external "crypto-js"
-const external_crypto_js_namespaceObject = require("crypto-js");
+;// external "crypto"
+const external_crypto_namespaceObject = require("crypto");
+var external_crypto_default = /*#__PURE__*/__webpack_require__.n(external_crypto_namespaceObject);
 ;// ./src/GN-app-api/service/FacebookService.ts
 
 
@@ -3412,10 +3415,23 @@ class FacebookService {
         let signedRequest = payloadJson["json"]["signedRequest"];
         let appId = payloadJson["json"]["appId"];
         if (this.facebookValidationReceipt(signedRequest)) {
-            let json = external_crypto_js_namespaceObject.enc.Base64.parse(signedRequest.split('.')[1]).toString(external_crypto_js_namespaceObject.enc.Utf8);
-            let gsJson = JSON.parse(json);
-            if (appId == this.facebookAppId) {
-                let product_id = gsJson["product_id"];
+            // let json = CryptoJS.enc.Base64.parse(signedRequest.split(".")[1]).toString(CryptoJS.enc.Utf8);
+            // let gsJson = JSON.parse(json);
+            // if (appId == this.facebookAppId) {
+            // 	let product_id = gsJson["product_id"];
+            // 	return {
+            // 		success: true,
+            // 		productId: product_id,
+            // 	};
+            // }
+            const base64Payload = signedRequest.split(".")[1]
+                .replace(/-/g, "+")
+                .replace(/_/g, "/");
+            const payloadBuffer = Buffer.from(base64Payload, "base64");
+            const jsonStr = payloadBuffer.toString("utf8");
+            const gsJson = JSON.parse(jsonStr);
+            if (appId === this.facebookAppId) {
+                const product_id = gsJson["product_id"];
                 return {
                     success: true,
                     productId: product_id,
@@ -3427,11 +3443,21 @@ class FacebookService {
         };
     }
     facebookValidationReceipt(signedRequest) {
-        let firstpart = signedRequest.split('.')[0];
-        firstpart = firstpart.replace(/-/g, '+').replace(/_/g, '/');
-        let signature = external_crypto_js_namespaceObject.enc.Base64.parse(firstpart).toString();
-        let dataHash = external_crypto_js_namespaceObject.HmacSHA256(signedRequest.split('.')[1], this.facebookInappSecret).toString();
-        let isValid = signature === dataHash;
+        // let [encodedSig, encodedPayload] = signedRequest.split(".");
+        // let base64Sig = encodedSig.replace(/-/g, "+").replace(/_/g, "/");
+        // let signature = CryptoJS.enc.Base64.parse(base64Sig).toString();
+        // let dataHash = CryptoJS.HmacSHA256(encodedPayload, this.facebookInappSecret).toString();
+        // let isValid = signature === dataHash;
+        // return isValid;
+        const [encodedSig, encodedPayload] = signedRequest.split(".");
+        const base64Sig = encodedSig
+            .replace(/-/g, "+")
+            .replace(/_/g, "/");
+        const signatureBuffer = Buffer.from(base64Sig, "base64");
+        const hmac = (0,external_crypto_namespaceObject.createHmac)("sha256", this.facebookInappSecret);
+        hmac.update(encodedPayload);
+        const dataHashBuffer = hmac.digest();
+        const isValid = signatureBuffer.equals(dataHashBuffer);
         return isValid;
     }
     ;
@@ -3468,9 +3494,6 @@ class GenericService {
     }
 }
 
-;// external "crypto"
-const external_crypto_namespaceObject = require("crypto");
-var external_crypto_default = /*#__PURE__*/__webpack_require__.n(external_crypto_namespaceObject);
 ;// ./src/GN-app-api/service/GoogleService.ts
 
 
@@ -3558,16 +3581,16 @@ class GoogleService {
     androidValidationReceipt(signature, signedData) {
         if (!this.publicKeyString)
             return false;
-        let verifier = external_crypto_default().createVerify('RSA-SHA1');
+        let verifier = external_crypto_default().createVerify("RSA-SHA1");
         verifier.update(signedData);
-        return verifier.verify(this.publicKeyString, signature, 'base64');
+        return verifier.verify(this.publicKeyString, signature, "base64");
     }
     ;
     // gotta give credit to nothing2lose for this function
     generateFormattedPublickey(publicKeyStr) {
         var KEY_PREFIX, KEY_SUFFIX, chunkSize, chunks, str;
         KEY_PREFIX = "-----BEGIN PUBLIC KEY-----\n";
-        KEY_SUFFIX = '\n-----END PUBLIC KEY-----';
+        KEY_SUFFIX = "\n-----END PUBLIC KEY-----";
         str = publicKeyStr;
         chunks = [];
         chunkSize = 64;
@@ -3625,7 +3648,7 @@ class PushNotificationService {
             credential: external_firebase_admin_default().credential.cert({
                 projectId: this.projectId,
                 clientEmail: this.clientEmail,
-                privateKey: this.privateKey.replace(/\\n/g, '\n'),
+                privateKey: this.privateKey.replace(/\\n/g, "\n"),
             }),
         });
         this.messaging = external_firebase_admin_default().messaging();
@@ -5957,21 +5980,6 @@ class ConfigService {
     }
 }
 
-;// external "async-lock"
-const external_async_lock_namespaceObject = require("async-lock");
-var external_async_lock_default = /*#__PURE__*/__webpack_require__.n(external_async_lock_namespaceObject);
-;// ./src/GN-app-api/service/LockService.ts
-
-const asyncLock = new (external_async_lock_default())();
-class LockService {
-    async handle(key, fn) {
-        return await asyncLock.acquire(key, fn);
-    }
-    isBusy(key) {
-        return asyncLock.isBusy(key);
-    }
-}
-
 ;// ./src/GN-app-api/service/TimerService.ts
 
 
@@ -6473,6 +6481,7 @@ class SecretInfo_BuilderBase {
     role;
     remove;
     tsExpire;
+    displayName;
     permission;
     gameId;
     isDefault;
@@ -6492,6 +6501,9 @@ class SecretInfo_BuilderBase {
     getTsExpire() {
         return this.tsExpire;
     }
+    getDisplayName() {
+        return this.displayName;
+    }
     getGameId() {
         return this.gameId;
     }
@@ -6529,6 +6541,9 @@ class SecretInfo_BuilderBase {
         //this.tsExpire = tsExpire;
         return this;
     }
+    setDisplayName(displayName) {
+        return this;
+    }
     build() {
         return null;
     }
@@ -6548,6 +6563,10 @@ class SecretInfo_Builder extends SecretInfo_BuilderBase {
         this.tsExpire = tsExpire;
         return this;
     }
+    setDisplayName(displayName) {
+        this.displayName = displayName;
+        return this;
+    }
     setPermission(permission) {
         this.permission = permission;
         return this;
@@ -6570,6 +6589,7 @@ class SecretInfo extends SecretInfo_BuilderBase {
         this.role = builder.getRole();
         this.remove = builder.isRemove();
         this.tsExpire = builder.getTsExpire();
+        this.displayName = builder.getDisplayName();
         this.permission = builder.getPermission();
         this.gameId = builder.getGameId();
         this.isDefault = builder.getIsDefault();
@@ -6585,6 +6605,7 @@ class SecretInfo extends SecretInfo_BuilderBase {
             "role": this.role,
             "isRemove": this.remove,
             "tsExpire": this.tsExpire,
+            "displayName": this.displayName,
             "permission": this.permission,
             "gameId": this.gameId,
         };
@@ -6710,19 +6731,27 @@ class DisplayNameUtility {
                 inputReturn += "y";
             else if (char == "z")
                 inputReturn += "z";
+            else if (char == "0" ||
+                char == "1" ||
+                char == "2" ||
+                char == "3" ||
+                char == "4" ||
+                char == "5" ||
+                char == "6" ||
+                char == "7" ||
+                char == "8" ||
+                char == "9")
+                inputReturn += char;
         }
         return inputReturn;
     }
 }
 
-;// external "md5"
-const external_md5_namespaceObject = require("md5");
-var external_md5_default = /*#__PURE__*/__webpack_require__.n(external_md5_namespaceObject);
 ;// ./src/GN-common/helper/Md5Generate.ts
 
 class Md5Generate {
     static getMd5(input) {
-        return external_md5_default()(input);
+        return (0,external_crypto_namespaceObject.createHash)("md5").update(input).digest("hex");
     }
 }
 
@@ -7042,6 +7071,7 @@ class SecretInfoItem extends MasterAdminMongoObject {
     static _tsExpire = "tsExpire";
     static _permission = "permission";
     static _tsCreate = "tsCreate";
+    static _displayName = "displayName";
     static _creatorId = "creatorId";
     gameId;
     secretKey;
@@ -7050,6 +7080,7 @@ class SecretInfoItem extends MasterAdminMongoObject {
     creatorId;
     remove;
     tsExpire;
+    displayName;
     permission;
     constructor(result, collection) {
         super(result, collection);
@@ -7063,6 +7094,7 @@ class SecretInfoItem extends MasterAdminMongoObject {
     setDocumentMasterSecretInfoItem(result) {
         this.remove = result[SecretInfoItem._remove];
         this.tsExpire = result[SecretInfoItem._tsExpire];
+        this.displayName = result[SecretInfoItem._displayName];
         this.permission = result[SecretInfoItem._permission];
     }
     getGameId() {
@@ -7094,6 +7126,13 @@ class SecretInfoItem extends MasterAdminMongoObject {
         this.tsExpire = tsExpire;
         this.set(SecretInfoItem._tsExpire, this.tsExpire);
     }
+    getDisplayName() {
+        return this.displayName;
+    }
+    setDisplayName(displayName) {
+        this.displayName = displayName;
+        this.set(SecretInfoItem._displayName, this.displayName);
+    }
     getPermission() {
         return this.permission;
     }
@@ -8907,14 +8946,16 @@ class xDatabase {
         }).skip(skip).limit(limit);
         return this.convertToMasterPlayers(results, collection);
     }
-    async loadMasterPlayersWithDisplayNameAsync(keyword, skip, limit, masterPlayerFindOptions) {
+    async loadMasterPlayerWithDisplayNameAsync(displayName, masterPlayerFindOptions) {
         let collection = this.systemCollection("MasterPlayer");
-        let results = await collection.find({ displayNameNormalize: { $regex: keyword } }, {
+        let result = await collection.findOne({ displayName: displayName }, {
             projection: this.getFindOptions(masterPlayerFindOptions)
-        }).skip(skip).limit(limit);
-        return this.convertToMasterPlayers(results, collection);
+        });
+        if (!result)
+            return null;
+        return new MasterPlayer(result, collection);
     }
-    async loadMasterPlayerWithDisplayNameAsync(displayNameNormalize, masterPlayerFindOptions) {
+    async loadMasterPlayerWithDisplayNameNormalizeAsync(displayNameNormalize, masterPlayerFindOptions) {
         let collection = this.systemCollection("MasterPlayer");
         let result = await collection.findOne({ displayNameNormalize: displayNameNormalize }, {
             projection: this.getFindOptions(masterPlayerFindOptions)
@@ -8923,6 +8964,13 @@ class xDatabase {
             return null;
         return new MasterPlayer(result, collection);
     }
+    async loadMasterPlayersWithDisplayNameNormalizeRegexAsync(keyword, skip, limit, masterPlayerFindOptions) {
+        let collection = this.systemCollection("MasterPlayer");
+        let results = await collection.find({ displayNameNormalize: { $regex: keyword } }, {
+            projection: this.getFindOptions(masterPlayerFindOptions)
+        }).skip(skip).limit(limit);
+        return this.convertToMasterPlayers(results, collection);
+    }
     async loadMasterPlayersLeaderboardWithStatisticsAsync(key, skip, limit, direction, masterPlayerFindOptions) {
         let collection = this.systemCollection("MasterPlayer");
         let $sort = {};
@@ -9228,14 +9276,16 @@ class xDatabase {
         }).skip(skip).limit(limit);
         return this.convertToGamePlayers(results, collection);
     }
-    async loadGamePlayersWithDisplayNameAsync(keyword, skip, limit, gameId, gamePlayerFindOptions) {
-        let collection = this.systemGameCollection("GamePlayer", gameId);
-        let results = await collection.find({ displayNameNormalize: { $regex: keyword } }, {
+    async loadGamePlayerWithDisplayNameAsync(displayName, gamePlayerFindOptions) {
+        let collection = this.systemCollection("GamePlayer");
+        let result = await collection.findOne({ displayName: displayName }, {
             projection: this.getFindOptions(gamePlayerFindOptions)
-        }).skip(skip).limit(limit);
-        return this.convertToGamePlayers(results, collection);
+        });
+        if (!result)
+            return null;
+        return new GamePlayer(result, collection);
     }
-    async loadGamePlayerWithDisplayNameAsync(displayNameNormalize, gamePlayerFindOptions) {
+    async loadGamePlayerWithDisplayNameNormalizeAsync(displayNameNormalize, gamePlayerFindOptions) {
         let collection = this.systemCollection("GamePlayer");
         let result = await collection.findOne({ displayNameNormalize: displayNameNormalize }, {
             projection: this.getFindOptions(gamePlayerFindOptions)
@@ -9244,6 +9294,13 @@ class xDatabase {
             return null;
         return new GamePlayer(result, collection);
     }
+    async loadGamePlayersWithDisplayNameNormalizeRegexAsync(keyword, skip, limit, gameId, gamePlayerFindOptions) {
+        let collection = this.systemGameCollection("GamePlayer", gameId);
+        let results = await collection.find({ displayNameNormalize: { $regex: keyword } }, {
+            projection: this.getFindOptions(gamePlayerFindOptions)
+        }).skip(skip).limit(limit);
+        return this.convertToGamePlayers(results, collection);
+    }
     async loadGamePlayersLeaderboardWithStatisticsAsync(key, skip, limit, gameId, direction, gamePlayerFindOptions) {
         let collection = this.systemGameCollection("GamePlayer", gameId);
         let $sort = {};
@@ -9470,20 +9527,31 @@ class xDatabase {
         }).skip(skip).limit(limit);
         return this.convertToCharacterPlayers(results, collection);
     }
-    async loadCharacterPlayersWithDisplayNameAsync(keyword, skip, limit, gameId, characterPlayerFindOptions) {
+    async loadCharacterPlayerWithDisplayNameAsync(displayName, gameId, characterPlayerFindOptions) {
         let collection = this.systemGameCollection("CharacterPlayer", gameId);
-        let results = await collection.find({ displayNameNormalize: { $regex: keyword } }, {
+        let result = await collection.findOne({ displayName: displayName }, {
             projection: this.getFindOptions(characterPlayerFindOptions)
-        }).skip(skip).limit(limit);
-        return this.convertToCharacterPlayers(results, collection);
+        });
+        if (!result)
+            return null;
+        return new CharacterPlayer(result, collection);
     }
-    async loadCharacterPlayerWithDisplayNameAsync(displayNameNormalize, gameId, characterPlayerFindOptions) {
+    async loadCharacterPlayerWithDisplayNameNormalizeAsync(displayNameNormalize, gameId, characterPlayerFindOptions) {
         let collection = this.systemGameCollection("CharacterPlayer", gameId);
         let result = await collection.findOne({ displayNameNormalize: displayNameNormalize }, {
             projection: this.getFindOptions(characterPlayerFindOptions)
         });
+        if (!result)
+            return null;
         return new CharacterPlayer(result, collection);
     }
+    async loadCharacterPlayersWithDisplayNameNormalizeRegexAsync(keyword, skip, limit, gameId, characterPlayerFindOptions) {
+        let collection = this.systemGameCollection("CharacterPlayer", gameId);
+        let results = await collection.find({ displayNameNormalize: { $regex: keyword } }, {
+            projection: this.getFindOptions(characterPlayerFindOptions)
+        }).skip(skip).limit(limit);
+        return this.convertToCharacterPlayers(results, collection);
+    }
     async loadCharacterPlayersLeaderboardWithStatisticsAsync(key, skip, limit, catalogId, gameId, direction, characterPlayerFindOptions) {
         let collection = this.systemGameCollection("CharacterPlayer", gameId);
         let $sort = {};
@@ -9716,7 +9784,25 @@ class xDatabase {
         }).skip(skip).limit(limit);
         return this.convertToGroups(results, collection);
     }
-    async loadGroupsWithDisplayNameAsync(keyword, skip, limit, gameId, groupFindOptions) {
+    async loadGroupWithDisplayNameAsync(displayName, gameId, groupFindOptions) {
+        let collection = this.systemGameCollection("Group", gameId);
+        let result = await collection.findOne({ displayName: displayName }, {
+            projection: this.getFindOptions(groupFindOptions)
+        });
+        if (!result)
+            return null;
+        return new Group(result, collection);
+    }
+    async loadGroupWithDisplayNameNormalizeAsync(displayNameNormalize, gameId, groupFindOptions) {
+        let collection = this.systemGameCollection("Group", gameId);
+        let result = await collection.findOne({ displayNameNormalize: displayNameNormalize }, {
+            projection: this.getFindOptions(groupFindOptions)
+        });
+        if (!result)
+            return null;
+        return new Group(result, collection);
+    }
+    async loadGroupsWithDisplayNameNormalizeRegexAsync(keyword, skip, limit, gameId, groupFindOptions) {
         let collection = this.systemGameCollection("Group", gameId);
         let results = await collection.find({ displayNameNormalize: { $regex: keyword } }, {
             projection: this.getFindOptions(groupFindOptions)
@@ -9869,7 +9955,25 @@ class xDatabase {
         }).skip(skip).limit(limit);
         return this.convertToInventories(results, collection);
     }
-    async loadInventoriesWithDisplayNameAsync(keyword, skip, limit, gameId, inventoryFindOptions) {
+    async loadInventoryWithDisplayNameAsync(displayName, gameId, inventoryFindOptions) {
+        let collection = this.systemGameCollection("Inventory", gameId);
+        let result = await collection.findOne({ displayName: displayName }, {
+            projection: this.getFindOptions(inventoryFindOptions)
+        });
+        if (!result)
+            null;
+        return new Inventory(result, collection);
+    }
+    async loadInventoryWithDisplayNameNormalizeAsync(displayNameNormalize, gameId, inventoryFindOptions) {
+        let collection = this.systemGameCollection("Inventory", gameId);
+        let result = await collection.findOne({ displayNameNormalize: displayNameNormalize }, {
+            projection: this.getFindOptions(inventoryFindOptions)
+        });
+        if (!result)
+            null;
+        return new Inventory(result, collection);
+    }
+    async loadInventoriesWithDisplayNameNormalizeRegexAsync(keyword, skip, limit, gameId, inventoryFindOptions) {
         let collection = this.systemGameCollection("Inventory", gameId);
         let results = await collection.find({ displayNameNormalize: { $regex: keyword } }, {
             projection: this.getFindOptions(inventoryFindOptions)
@@ -10285,6 +10389,7 @@ const msgpack_namespaceObject = require("@msgpack/msgpack");
 
 
 
+
 var AntiDdosMiddleware_RequestType;
 (function (RequestType) {
     RequestType[RequestType["HTTP"] = 0] = "HTTP";
@@ -10297,6 +10402,7 @@ var BanType;
 })(BanType || (BanType = {}));
 class AntiDdosMiddleware {
     static FIVE_MINUTE_TS = 5 * 60 * 1000;
+    static K_MULTIPLE_ADMIN = 500;
     static K_MULTIPLE_WHITE_LIST = 100;
     static K_MULTIPLE_BLACK_LIST = 5;
     socketRequestPerIPDic;
@@ -10397,12 +10503,19 @@ class AntiDdosMiddleware {
             || url == "/167/11/1") {
             return ReturnCode.Ok;
         }
-        let contentLengthStr = req.headers['content-length'];
+        let contentLengthStr = req.header("content-length");
         if (contentLengthStr) {
             let ip = req.xip;
             let httpMaxRequestSize = this.httpMaxRequestSize;
             if (this.ipWhiteLst.includes(ip))
                 httpMaxRequestSize = httpMaxRequestSize * AntiDdosMiddleware.K_MULTIPLE_WHITE_LIST;
+            else {
+                let role = Number.parseInt(req.params.role);
+                if (!Number.isNaN(role)) {
+                    if (role == RequestRole.Admin || role == RequestRole.Server)
+                        httpMaxRequestSize = httpMaxRequestSize * AntiDdosMiddleware.K_MULTIPLE_ADMIN;
+                }
+            }
             let contentLength = parseInt(contentLengthStr);
             if (contentLength > httpMaxRequestSize) {
                 this.reportDdosCollection.insertOne({
@@ -10572,6 +10685,13 @@ class AntiDdosMiddleware {
             httpMaxRequestPerSecondPerIp = httpMaxRequestPerSecondPerIp / AntiDdosMiddleware.K_MULTIPLE_BLACK_LIST;
         else if (this.ipWhiteLst.includes(ip))
             httpMaxRequestPerSecondPerIp = httpMaxRequestPerSecondPerIp * AntiDdosMiddleware.K_MULTIPLE_WHITE_LIST;
+        else {
+            let role = Number.parseInt(req.params.role);
+            if (!Number.isNaN(role)) {
+                if (role == RequestRole.Admin || role == RequestRole.Server)
+                    httpMaxRequestPerSecondPerIp = httpMaxRequestPerSecondPerIp * AntiDdosMiddleware.K_MULTIPLE_ADMIN;
+            }
+        }
         if (httpRequestPerIPItem.count > httpMaxRequestPerSecondPerIp) {
             this.reportDdosCollection.insertOne({
                 returnCode: ReturnCode.MaxRequestReject,
@@ -10634,6 +10754,13 @@ class AntiDdosMiddleware {
                 httpMaxRequestPerSecondPerPeer = httpMaxRequestPerSecondPerPeer / AntiDdosMiddleware.K_MULTIPLE_BLACK_LIST;
             else if (this.ipWhiteLst.includes(ip))
                 httpMaxRequestPerSecondPerPeer = httpMaxRequestPerSecondPerPeer * AntiDdosMiddleware.K_MULTIPLE_WHITE_LIST;
+            else {
+                let role = Number.parseInt(req.params.role);
+                if (!Number.isNaN(role)) {
+                    if (role == RequestRole.Admin || role == RequestRole.Server)
+                        httpMaxRequestPerSecondPerPeer = httpMaxRequestPerSecondPerPeer * AntiDdosMiddleware.K_MULTIPLE_ADMIN;
+                }
+            }
             httpRequestPerPeerItem.count++;
             if (httpRequestPerPeerItem.count > httpMaxRequestPerSecondPerPeer) {
                 this.reportDdosCollection.insertOne({
@@ -10673,6 +10800,13 @@ class AntiDdosMiddleware {
             httpMaxPendingRequest = httpMaxPendingRequest / AntiDdosMiddleware.K_MULTIPLE_BLACK_LIST;
         else if (this.ipWhiteLst.includes(ip))
             httpMaxPendingRequest = httpMaxPendingRequest * AntiDdosMiddleware.K_MULTIPLE_WHITE_LIST;
+        else {
+            let role = Number.parseInt(req.params.role);
+            if (!Number.isNaN(role)) {
+                if (role == RequestRole.Admin || role == RequestRole.Server)
+                    httpMaxPendingRequest = httpMaxPendingRequest * AntiDdosMiddleware.K_MULTIPLE_ADMIN;
+            }
+        }
         if (this.currentHttpRequestCount > httpMaxPendingRequest) {
             this.reportDdosCollection.insertOne({
                 returnCode: ReturnCode.MaxRequestReject,
@@ -14597,7 +14731,7 @@ class ApiMiddleware {
             for (let key of keysNeedRemove) {
                 this.authInfoDict.delete(key);
             }
-            Debug.log("[GN] ApiMiddleware remove " + removeCount + "/" + startSize);
+            Debug.log("[GearN] ApiMiddleware remove " + removeCount + "/" + startSize);
         }
         catch (err) {
             Debug.logException(err);
@@ -14767,8 +14901,7 @@ class ApiMiddleware {
         return next();
     }
     async getReturnCodeAuthenticate(req) {
-        let headers = req.headers;
-        let authToken = headers[Commands.RequestAuthTokenCmd];
+        let authToken = req.header(Commands.RequestAuthTokenCmd);
         let currentMilliseconds = xDatetime.getCurrentMilliseconds();
         if (!authToken) {
             req.isAuthenticated = false;
@@ -14811,7 +14944,7 @@ class ApiMiddleware {
                 }
             }
         }
-        let secretKey = headers[Commands.RequestSecretCmd];
+        let secretKey = req.header(Commands.RequestSecretCmd);
         if (!secretKey) {
             if (!req.isAuthenticated) {
                 if (req.url != "/-1/9/3") {
@@ -14836,7 +14969,7 @@ class ApiMiddleware {
                 return ReturnCode.SecretInvalid;
             }
             if (!secretInfo.getGameId()) {
-                let gameId = headers[Commands.RequestGameIdCmd];
+                let gameId = req.header(Commands.RequestGameIdCmd);
                 if (!gameId)
                     gameId = ApiMiddleware.DEFAULT_GAME_ID;
                 let secretInfoAny = structuredClone(secretInfo);
@@ -15040,14 +15173,16 @@ class UploadFileMiddleware {
     }
 }
 
-;// external "async-middleware"
-const external_async_middleware_namespaceObject = require("async-middleware");
+;// ./src/GN-startup/routes/utils/wrap.ts
+function wrap(fn) {
+    return (req, res, next) => {
+        Promise.resolve(fn(req, res, next)).catch(next);
+    };
+}
+
 ;// external "express"
 const external_express_namespaceObject = require("express");
 var external_express_default = /*#__PURE__*/__webpack_require__.n(external_express_namespaceObject);
-;// external "express-msgpack"
-const external_express_msgpack_namespaceObject = require("express-msgpack");
-var external_express_msgpack_default = /*#__PURE__*/__webpack_require__.n(external_express_msgpack_namespaceObject);
 ;// ./src/GN-startup/routes/HttpAppHandler.ts
 
 
@@ -15059,7 +15194,6 @@ var external_express_msgpack_default = /*#__PURE__*/__webpack_require__.n(extern
 
 
 
-
 class HttpAppHandler {
     _onRequestCb;
     apiMiddleware;
@@ -15180,17 +15314,17 @@ class HttpAppHandler {
         this.router.use("/api", apiRouter);
         if (this.enablePostViaJson) {
             this.apiJsonRouter = external_express_default().Router();
-            apiRouter.use("/" + Commands.RequestCmd_Json, (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+            apiRouter.use("/" + Commands.RequestCmd_Json, wrap((req, res, next) => {
                 return this.apiMiddleware.getIP(req, res, next);
-            }), (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+            }), wrap((req, res, next) => {
                 return this.antiDdosMiddleware.checkMaxRequestPerSecondPerIpViaJson(req, res, next);
-            }), (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+            }), wrap((req, res, next) => {
                 return this.antiDdosMiddleware.checkRequestSizeBodyViaJson(req, res, next);
-            }), external_express_default().json({ limit: "10mb" }), (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+            }), wrap((req, res, next) => {
                 return this.apiMiddleware.authenticateTokenViaJson(req, res, next);
-            }), (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+            }), wrap((req, res, next) => {
                 return this.antiDdosMiddleware.checkMaxRequestPerSecondPerPeerViaJson(req, res, next);
-            }), (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+            }), external_express_default().json({ limit: "10mb" }), wrap((req, res, next) => {
                 return this.antiDdosMiddleware.addPendingRequestViaJson(req, res, next);
             }), this.apiJsonRouter);
             this.apiJsonRouter.post("/:code/:type/:role", async (req, res) => {
@@ -15218,17 +15352,33 @@ class HttpAppHandler {
         }
         if (this.enablePostViaMsgPack) {
             this.apiMsgPackRouter = external_express_default().Router();
-            apiRouter.use("/" + Commands.RequestCmd_MsgPack, (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+            apiRouter.use("/" + Commands.RequestCmd_MsgPack, wrap((req, res, next) => {
                 return this.apiMiddleware.getIP(req, res, next);
-            }), (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+            }), wrap((req, res, next) => {
                 return this.antiDdosMiddleware.checkMaxRequestPerSecondPerIpViaMsgPack(req, res, next);
-            }), (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+            }), wrap((req, res, next) => {
                 return this.antiDdosMiddleware.checkRequestSizeBodyViaMsgPack(req, res, next);
-            }), external_express_msgpack_default()(), (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+            }), wrap((req, res, next) => {
                 return this.apiMiddleware.authenticateTokenViaMsgPack(req, res, next);
-            }), (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+            }), wrap((req, res, next) => {
                 return this.antiDdosMiddleware.checkMaxRequestPerSecondPerPeerViaMsgPack(req, res, next);
-            }), (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+            }), (req, res, next) => {
+                if (req.header(Commands.CONTENT_TYPE) === Commands.APPLICATION_MSGPACK) {
+                    let buffer = [];
+                    req.on("data", chunk => buffer.push(chunk));
+                    req.on("end", () => {
+                        try {
+                            const raw = Buffer.concat(buffer);
+                            req.body = (0,msgpack_namespaceObject.decode)(raw);
+                            return next();
+                        }
+                        catch (err) {
+                            return next(err);
+                        }
+                    });
+                }
+                return next();
+            }, wrap((req, res, next) => {
                 return this.antiDdosMiddleware.addPendingRequestViaMsgPack(req, res, next);
             }), this.apiMsgPackRouter);
             this.apiMsgPackRouter.post("/:code/:type/:role", async (req, res) => {
@@ -15749,21 +15899,21 @@ class UploadFileHandler {
     }
     init() {
         this.uploadRouter = external_express_default().Router();
-        this.router.use("/upload", (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+        this.router.use("/upload", wrap((req, res, next) => {
             return this.apiMiddleware.getIP(req, res, next);
-        }), (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+        }), wrap((req, res, next) => {
             return this.antiDdosMiddleware.checkMaxUploadRequestPerSecondPerIp(req, res, next);
-        }), (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+        }), wrap((req, res, next) => {
             return this.apiMiddleware.authenticateUploadToken(req, res, next);
-        }), (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+        }), wrap((req, res, next) => {
             return this.antiDdosMiddleware.checkMaxUploadRequestPerSecondPerPeer(req, res, next);
         }), this.uploadRouter);
         let downloadRouter = external_express_default().Router();
-        this.router.use("/download", (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+        this.router.use("/download", wrap((req, res, next) => {
             return this.apiMiddleware.getIP(req, res, next);
-        }), (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+        }), wrap((req, res, next) => {
             return this.antiDdosMiddleware.checkMaxUploadRequestPerSecondPerIp(req, res, next);
-        }), (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+        }), wrap((req, res, next) => {
             return this.antiDdosMiddleware.checkMaxUploadRequestPerSecondPerPeer(req, res, next);
         }), downloadRouter);
         downloadRouter.get("/:downloadToken", 
@@ -15819,11 +15969,11 @@ class UploadFileHandler {
         if (!external_fs_default().existsSync(uploadPath)) {
             external_fs_default().mkdirSync(uploadPath, { mode: "0775" });
         }
-        this.uploadRouter.post("/:fileId", (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+        this.uploadRouter.post("/:fileId", wrap((req, res, next) => {
             return this.antiDdosMiddleware.addPendingUploadRequest(req, res, next);
-        }), (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+        }), wrap((req, res, next) => {
             return this.uploadFileMiddleware.checkFileUploadInvalid(req, res, next);
-        }), (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
+        }), wrap((req, res, next) => {
             return this.uploadFileMiddleware.handleUpload().single(Commands.File)(req, res, next);
         }), async (req, res) => {
             this.antiDdosMiddleware.removePendingUploadRequest(req, res);
@@ -15849,7 +15999,7 @@ class UploadFileHandler {
     }
     removeFile(fullPath) {
         external_fs_default().rm(fullPath, err => {
-            Debug.logError("[GN] remove file at path " + fullPath + ", error " + err);
+            Debug.logError("[GearN] remove file at path " + fullPath + ", error " + err);
         });
     }
 }
@@ -16657,11 +16807,11 @@ class ClusterHandler {
     }
     init() {
         this.clusterRouter = external_express_default().Router();
-        this.router.use("/cluster", (0,external_async_middleware_namespaceObject.wrap)((req, res, next) => {
-            // let pkt = req.header("privateKeyToken");
-            // if (!pkt || pkt != this.privateKeyToken) {
-            //     return res.sendStatus(401);
-            // }
+        this.router.use("/cluster", wrap((req, res, next) => {
+            let pkt = req.header("privateKeyToken");
+            if (!pkt || pkt != this.privateKeyToken) {
+                return res.sendStatus(401);
+            }
             return next();
         }), this.clusterRouter);
     }
@@ -16712,7 +16862,7 @@ class ClusterHandler {
             callback(data);
         }
         catch (err) {
-            Debug.logError("[GN] ClusterHandler receive event failed " + err.message);
+            Debug.logError("[GearN] ClusterHandler receive event failed " + err.message);
         }
     }
     async update() {
@@ -16840,10 +16990,10 @@ class ClusterHandler {
             if (nodeInfo.instanceId != this.instanceId)
                 external_axios_default().post(nodeInfo.fullUrl + "/cluster/sendEvent/" + name, data, { headers: { "pkt": this.privateKeyToken, "Content-Type": "application/json" } }).then(response => {
                     if (response.status != 200) {
-                        Debug.logError("[GN] ClusterHandler sendEvent failed with status " + response.status + ", instanceId: " + nodeInfo.instanceId);
+                        Debug.logError("[GearN] ClusterHandler sendEvent failed with status " + response.status + ", instanceId: " + nodeInfo.instanceId);
                     }
                 }).catch(err => {
-                    Debug.logError("[GN] ClusterHandler sendEvent failed " + err.message + ", instanceId: " + nodeInfo.instanceId);
+                    Debug.logError("[GearN] ClusterHandler sendEvent failed " + err.message + ", instanceId: " + nodeInfo.instanceId);
                 });
         }
         if (includeMe) {
@@ -26551,7 +26701,6 @@ var SetDisplayNameRequestHandler_metadata = (undefined && undefined.__metadata)
 
 
 
-
 class SetDisplayNameOperationRequest extends OperationRequest {
     userId;
     displayName;
@@ -26665,7 +26814,7 @@ class SetDisplayNameRequestHandler extends MasterPlayerBaseRequestHandler {
             displayName: true,
         };
         if (request.uniqueDisplayName) {
-            let masterPlayerWithThisDisplayName = await this.gnServer.getDatabase().loadMasterPlayerWithDisplayNameAsync(DisplayNameUtility.normalizeString(request.displayName), masterPlayerFindOptions);
+            let masterPlayerWithThisDisplayName = await this.gnServer.getDatabase().loadMasterPlayerWithDisplayNameAsync(request.displayName, masterPlayerFindOptions);
             if (masterPlayerWithThisDisplayName != null) {
                 operationResponse.setParameter(ParameterCode.ErrorCode, GNErrorCode.DisplayNameHasUse);
                 return operationResponse;
@@ -31761,7 +31910,7 @@ class GetPlayersWithDisplayNameRequestHandler extends MasterPlayerBaseRequestHan
         operationResponse.setReturnCode(ReturnCode.Ok);
         let masterPlayerFindOptions = this.convertToMasterPlayerFindOptions(request.infoRequestParam);
         let gnResults = new GNArray();
-        let masterPlayers = await this.gnServer.getDatabase().loadMasterPlayersWithDisplayNameAsync(DisplayNameUtility.normalizeString(request.keyword), request.skip, request.limit, masterPlayerFindOptions);
+        let masterPlayers = await this.gnServer.getDatabase().loadMasterPlayersWithDisplayNameNormalizeRegexAsync(DisplayNameUtility.normalizeString(request.keyword), request.skip, request.limit, masterPlayerFindOptions);
         for (let i = 0; i < masterPlayers.length; i++) {
             let masterPlayer = masterPlayers[i];
             let gnResult = new GNHashtable();
@@ -35298,7 +35447,6 @@ var characterPlayer_SetDisplayNameRequestHandler_metadata = (undefined && undefi
 
 
 
-
 class SetDisplayNameRequestHandler_SetDisplayNameOperationRequest extends OperationRequest {
     characterId;
     displayName;
@@ -35396,7 +35544,7 @@ class SetDisplayNameRequestHandler_SetDisplayNameRequestHandler extends Characte
             displayName: true,
         };
         if (request.uniqueDisplayName) {
-            let characterPlayerWithThisDisplayName = await this.gnServer.getDatabase().loadCharacterPlayerWithDisplayNameAsync(DisplayNameUtility.normalizeString(request.displayName), secretInfo.getGameId(), characterPlayerFindOptions);
+            let characterPlayerWithThisDisplayName = await this.gnServer.getDatabase().loadCharacterPlayerWithDisplayNameAsync(request.displayName, secretInfo.getGameId(), characterPlayerFindOptions);
             if (characterPlayerWithThisDisplayName != null) {
                 operationResponse.setParameter(ParameterCode.ErrorCode, GNErrorCode.DisplayNameHasUse);
                 return operationResponse;
@@ -41288,7 +41436,7 @@ class GetPlayersWithDisplayNameRequestHandler_GetPlayersWithDisplayNameRequestHa
         operationResponse.setReturnCode(ReturnCode.Ok);
         let characterPlayerFindOptions = this.convertToCharacterPlayerFindOptions(request.infoRequestParam);
         let gnResults = new GNArray();
-        let characterPlayers = await this.gnServer.getDatabase().loadCharacterPlayersWithDisplayNameAsync(DisplayNameUtility.normalizeString(request.keyword), request.skip, request.limit, secretInfo.getGameId(), characterPlayerFindOptions);
+        let characterPlayers = await this.gnServer.getDatabase().loadCharacterPlayersWithDisplayNameNormalizeRegexAsync(DisplayNameUtility.normalizeString(request.keyword), request.skip, request.limit, secretInfo.getGameId(), characterPlayerFindOptions);
         for (let i = 0; i < characterPlayers.length; i++) {
             let characterPlayer = characterPlayers[i];
             let gnResult = new GNHashtable();
@@ -44332,7 +44480,6 @@ var gamePlayer_SetDisplayNameRequestHandler_metadata = (undefined && undefined._
 
 
 
-
 class gamePlayer_SetDisplayNameRequestHandler_SetDisplayNameOperationRequest extends OperationRequest {
     userId;
     displayName;
@@ -44446,7 +44593,7 @@ class gamePlayer_SetDisplayNameRequestHandler_SetDisplayNameRequestHandler exten
             displayName: true,
         };
         if (request.uniqueDisplayName) {
-            let gamePlayerWithThisDisplayName = await this.gnServer.getDatabase().loadGamePlayerWithDisplayNameAsync(DisplayNameUtility.normalizeString(request.displayName), gamePlayerFindOptions);
+            let gamePlayerWithThisDisplayName = await this.gnServer.getDatabase().loadGamePlayerWithDisplayNameAsync(request.displayName, gamePlayerFindOptions);
             if (gamePlayerWithThisDisplayName != null) {
                 operationResponse.setParameter(ParameterCode.ErrorCode, GNErrorCode.DisplayNameHasUse);
                 return operationResponse;
@@ -49640,7 +49787,7 @@ class GrantPlayerCharacterRequestHandler extends GamePlayerBaseRequestHandler {
             return operationResponse;
         }
         if (request.uniqueDisplayName && request.displayName) {
-            let characterPlayerWithThisDisplayName = await this.gnServer.getDatabase().loadCharacterPlayerWithDisplayNameAsync(DisplayNameUtility.normalizeString(request.displayName), secretInfo.getGameId(), { displayName: true });
+            let characterPlayerWithThisDisplayName = await this.gnServer.getDatabase().loadCharacterPlayerWithDisplayNameAsync(request.displayName, secretInfo.getGameId(), { displayName: true });
             if (characterPlayerWithThisDisplayName != null) {
                 operationResponse.setParameter(ParameterCode.ErrorCode, GNErrorCode.DisplayNameHasUse);
                 return operationResponse;
@@ -50926,7 +51073,7 @@ class gamePlayer_GetPlayersWithDisplayNameRequestHandler_GetPlayersWithDisplayNa
         operationResponse.setReturnCode(ReturnCode.Ok);
         let gamePlayerFindOptions = this.convertToGamePlayerFindOptions(request.infoRequestParam);
         let gnResults = new GNArray();
-        let gamePlayers = await this.gnServer.getDatabase().loadGamePlayersWithDisplayNameAsync(DisplayNameUtility.normalizeString(request.keyword), request.skip, request.limit, secretInfo.getGameId(), gamePlayerFindOptions);
+        let gamePlayers = await this.gnServer.getDatabase().loadGamePlayersWithDisplayNameNormalizeRegexAsync(DisplayNameUtility.normalizeString(request.keyword), request.skip, request.limit, secretInfo.getGameId(), gamePlayerFindOptions);
         for (let i = 0; i < gamePlayers.length; i++) {
             let gamePlayer = gamePlayers[i];
             let gnResult = new GNHashtable();
@@ -53381,6 +53528,39 @@ class GroupBaseRequestHandler extends RequestHandler {
             answer = true;
         }
         if (!answer && permissionRules.selfEnable) {
+            let group = await this.gnServer.getDatabase().loadGroupAsync(groupId, gameId, {
+                members: true,
+                groupType: true,
+            });
+            if (group != null) {
+                let groupType = group.getGroupType();
+                if (groupType == OwnerType.GamePlayer) {
+                    let memberItem = group.getMember(userId);
+                    if (memberItem != null) {
+                        if (memberItem.status == GroupStatus.Member) {
+                            answer = true;
+                        }
+                    }
+                }
+                else if (groupType == OwnerType.CharacterPlayer) {
+                    let gamePlayer = await this.gnServer.getDatabase().loadGamePlayerAsync(userId, gameId, { playerCharacters: true });
+                    if (gamePlayer != null) {
+                        let characterPlayers = gamePlayer.getAllPlayerCharacters();
+                        if (characterPlayers != null) {
+                            for (let i = 0; i < characterPlayers.length; i++) {
+                                let characterPlayer = characterPlayers[i];
+                                let memberItem = group.getMember(characterPlayer.characterId);
+                                if (memberItem != null) {
+                                    if (memberItem.status == GroupStatus.Member) {
+                                        answer = true;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
             let gamePlayer = await this.gnServer.getDatabase().loadGamePlayerAsync(userId, gameId, { playerGroups: true });
             if (gamePlayer != null) {
                 let playerGroup = gamePlayer.getPlayerGroup(groupId);
@@ -57073,6 +57253,7 @@ var GetGroupInformationRequestHandler_metadata = (undefined && undefined.__metad
 
 
 
+
 class GetGroupInformationOperationRequest extends OperationRequest {
     groupId;
     infoRequestParam;
@@ -57125,12 +57306,39 @@ class GetGroupInformationRequestHandler extends GroupBaseRequestHandler {
             allowMethod = true;
         }
         if (secretInfo.getPermission().group.getGroupInformation.selfEnable) {
-            let gamePlayer = await this.gnServer.getDatabase().loadGamePlayerAsync(authInfo.getUserId(), secretInfo.getGameId(), { playerGroups: true });
-            if (gamePlayer != null) {
-                let playerGroup = gamePlayer.getPlayerGroup(request.groupId);
-                if (playerGroup != null && playerGroup.status == GroupStatus.Member) {
-                    allowMethod = true;
-                    owned = true;
+            let group = await this.gnServer.getDatabase().loadGroupAsync(request.groupId, secretInfo.getGameId(), {
+                members: true,
+                groupType: true,
+            });
+            if (group != null) {
+                let groupType = group.getGroupType();
+                if (groupType == OwnerType.GamePlayer) {
+                    let memberItem = group.getMember(authInfo.getUserId());
+                    if (memberItem != null) {
+                        if (memberItem.status == GroupStatus.Member) {
+                            allowMethod = true;
+                            owned = true;
+                        }
+                    }
+                }
+                else if (groupType == OwnerType.CharacterPlayer) {
+                    let gamePlayer = await this.gnServer.getDatabase().loadGamePlayerAsync(authInfo.getUserId(), secretInfo.getGameId(), { playerCharacters: true });
+                    if (gamePlayer != null) {
+                        let characterPlayers = gamePlayer.getAllPlayerCharacters();
+                        if (characterPlayers != null) {
+                            for (let i = 0; i < characterPlayers.length; i++) {
+                                let characterPlayer = characterPlayers[i];
+                                let memberItem = group.getMember(characterPlayer.characterId);
+                                if (memberItem != null) {
+                                    if (memberItem.status == GroupStatus.Member) {
+                                        allowMethod = true;
+                                        owned = true;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -59502,7 +59710,7 @@ class GetGroupsWithDisplayNameRequestHandler extends GroupBaseRequestHandler {
         operationResponse.setReturnCode(ReturnCode.Ok);
         let groupFindOptions = this.convertToGroupFindOptions(request.infoRequestParam);
         let gnResults = new GNArray();
-        let groups = await this.gnServer.getDatabase().loadGroupsWithDisplayNameAsync(DisplayNameUtility.normalizeString(request.keyword), request.skip, request.limit, secretInfo.getGameId(), groupFindOptions);
+        let groups = await this.gnServer.getDatabase().loadGroupsWithDisplayNameNormalizeRegexAsync(DisplayNameUtility.normalizeString(request.keyword), request.skip, request.limit, secretInfo.getGameId(), groupFindOptions);
         for (let i = 0; i < groups.length; i++) {
             let group = groups[i];
             let gnResult = new GNHashtable();
@@ -60048,6 +60256,7 @@ class group_GetCurrencyLogRequestHandler_GetCurrencyLogRequestHandler extends Re
 
 
 
+
 class ItemBaseRequestHandler extends RequestHandler {
     isGetAll(infoRequestParam) {
         return infoRequestParam.catalogId
@@ -60107,10 +60316,33 @@ class ItemBaseRequestHandler extends RequestHandler {
             answer = true;
         }
         if (!answer && permissionRules.selfEnable) {
-            let gamePlayer = await this.gnServer.getDatabase().loadGamePlayerAsync(userId, gameId, { playerInventories: true });
-            if (gamePlayer != null) {
-                if (gamePlayer.hasPlayerInventory(itemId))
-                    answer = true;
+            let inventory = await this.gnServer.getDatabase().loadInventoryAsync(itemId, gameId, { owner: true });
+            if (inventory != null) {
+                let owner = inventory.getOwner();
+                if (owner != null) {
+                    if (owner.type == OwnerType.GamePlayer) {
+                        if (owner.id == userId) {
+                            answer = true;
+                        }
+                    }
+                    else if (owner.type == OwnerType.CharacterPlayer) {
+                        let gamePlayer = await this.gnServer.getDatabase().loadGamePlayerAsync(userId, gameId, { playerCharacters: true });
+                        if (gamePlayer != null) {
+                            if (gamePlayer.hasPlayerCharacter(owner.id)) {
+                                answer = true;
+                            }
+                        }
+                    }
+                    else if (owner.type == OwnerType.Group) {
+                        let gamePlayer = await this.gnServer.getDatabase().loadGamePlayerAsync(userId, gameId, { playerGroups: true });
+                        if (gamePlayer != null) {
+                            let playerGroup = gamePlayer.getPlayerGroup(owner.id);
+                            if (playerGroup != null && playerGroup.status == GroupStatus.Member) {
+                                answer = true;
+                            }
+                        }
+                    }
+                }
             }
         }
         return answer;
@@ -63390,6 +63622,8 @@ var GetItemInformationRequestHandler_metadata = (undefined && undefined.__metada
 
 
 
+
+
 class GetItemInformationOperationRequest extends OperationRequest {
     itemId;
     infoRequestParam;
@@ -63442,11 +63676,35 @@ class GetItemInformationRequestHandler extends ItemBaseRequestHandler {
             allowMethod = true;
         }
         if (secretInfo.getPermission().inventory.getItemInformation.selfEnable) {
-            let gamePlayer = await this.gnServer.getDatabase().loadGamePlayerAsync(authInfo.getUserId(), secretInfo.getGameId(), { playerInventories: true });
-            if (gamePlayer != null) {
-                if (gamePlayer.hasPlayerCharacter(request.itemId)) {
-                    allowMethod = true;
-                    owned = true;
+            let inventory = await this.gnServer.getDatabase().loadInventoryAsync(request.itemId, secretInfo.getGameId(), { owner: true });
+            if (inventory != null) {
+                let owner = inventory.getOwner();
+                if (owner != null) {
+                    if (owner.type == OwnerType.GamePlayer) {
+                        if (owner.id == authInfo.getUserId()) {
+                            allowMethod = true;
+                            owned = true;
+                        }
+                    }
+                    else if (owner.type == OwnerType.CharacterPlayer) {
+                        let gamePlayer = await this.gnServer.getDatabase().loadGamePlayerAsync(authInfo.getUserId(), secretInfo.getGameId(), { playerCharacters: true });
+                        if (gamePlayer != null) {
+                            if (gamePlayer.hasPlayerCharacter(owner.id)) {
+                                allowMethod = true;
+                                owned = true;
+                            }
+                        }
+                    }
+                    else if (owner.type == OwnerType.Group) {
+                        let gamePlayer = await this.gnServer.getDatabase().loadGamePlayerAsync(authInfo.getUserId(), secretInfo.getGameId(), { playerGroups: true });
+                        if (gamePlayer != null) {
+                            let playerGroup = gamePlayer.getPlayerGroup(owner.id);
+                            if (playerGroup != null && playerGroup.status == GroupStatus.Member) {
+                                allowMethod = true;
+                                owned = true;
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -65161,7 +65419,7 @@ class GetItemsWithDisplayNameRequestHandler extends ItemBaseRequestHandler {
         operationResponse.setReturnCode(ReturnCode.Ok);
         let inventoryFindOptions = this.convertToInventoryFindOptions(request.infoRequestParam);
         let gnResults = new GNArray();
-        let inventorys = await this.gnServer.getDatabase().loadInventoriesWithDisplayNameAsync(DisplayNameUtility.normalizeString(request.keyword), request.skip, request.limit, secretInfo.getGameId(), inventoryFindOptions);
+        let inventorys = await this.gnServer.getDatabase().loadInventoriesWithDisplayNameNormalizeRegexAsync(DisplayNameUtility.normalizeString(request.keyword), request.skip, request.limit, secretInfo.getGameId(), inventoryFindOptions);
         for (let i = 0; i < inventorys.length; i++) {
             let inventory = inventorys[i];
             let gnResult = new GNHashtable();
@@ -70616,7 +70874,7 @@ class SetMasterGameSettingsRequestHandler extends RequestHandler {
                         let key = removeKeyLst[i];
                         let indexName = "playerCurrencies." + key + ".value_-1";
                         masterPlayerCollection.dropIndex(indexName);
-                        Debug.log("[GN] [Database] drop index " + indexName + " at " + masterPlayerCollection.collectionName);
+                        Debug.log("[GearN] [Database] drop index " + indexName + " at " + masterPlayerCollection.collectionName);
                     }
                     for (let i = 0; i < addKeyLst.length; i++) {
                         let key = addKeyLst[i];
@@ -70624,7 +70882,7 @@ class SetMasterGameSettingsRequestHandler extends RequestHandler {
                         indexDoc["playerCurrencies." + key + ".value"] = -1;
                         let indexName = "playerCurrencies." + key + ".value_-1";
                         masterPlayerCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                        Debug.log("[GN] [Database] create new index " + indexName + " at " + masterPlayerCollection.collectionName);
+                        Debug.log("[GearN] [Database] create new index " + indexName + " at " + masterPlayerCollection.collectionName);
                     }
                 }
                 masterPlayerSettings.playerCurrencySettings = playerCurrencySettings;
@@ -70678,7 +70936,7 @@ class SetMasterGameSettingsRequestHandler extends RequestHandler {
                             let key = removeKeyLst[i];
                             let indexName = "playerStatistics." + key + ".value_-1_playerStatistics." + key + ".tsLastUpdate_1";
                             masterPlayerCollection.dropIndex(indexName);
-                            Debug.log("[GN] [Database] drop index " + indexName + " at " + masterPlayerCollection.collectionName);
+                            Debug.log("[GearN] [Database] drop index " + indexName + " at " + masterPlayerCollection.collectionName);
                         }
                         for (let i = 0; i < addKeyLst.length; i++) {
                             let key = addKeyLst[i];
@@ -70687,7 +70945,7 @@ class SetMasterGameSettingsRequestHandler extends RequestHandler {
                             indexDoc["playerStatistics." + key + ".tsLastUpdate"] = 1;
                             let indexName = "playerStatistics." + key + ".value_-1_playerStatistics." + key + ".tsLastUpdate_1";
                             masterPlayerCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                            Debug.log("[GN] [Database] create new index " + indexName + " at " + masterPlayerCollection.collectionName);
+                            Debug.log("[GearN] [Database] create new index " + indexName + " at " + masterPlayerCollection.collectionName);
                         }
                     }
                 }
@@ -70706,7 +70964,7 @@ class SetMasterGameSettingsRequestHandler extends RequestHandler {
                             let key = removeKeyAscLst[i];
                             let indexName = "playerStatistics." + key + ".value_1_playerStatistics." + key + ".tsLastUpdate_1";
                             masterPlayerCollection.dropIndex(indexName);
-                            Debug.log("[GN] [Database] drop index " + indexName + " at " + masterPlayerCollection.collectionName);
+                            Debug.log("[GearN] [Database] drop index " + indexName + " at " + masterPlayerCollection.collectionName);
                         }
                         for (let i = 0; i < addKeyAscLst.length; i++) {
                             let key = addKeyAscLst[i];
@@ -70715,7 +70973,7 @@ class SetMasterGameSettingsRequestHandler extends RequestHandler {
                             indexDoc["playerStatistics." + key + ".tsLastUpdate"] = 1;
                             let indexName = "playerStatistics." + key + ".value_1_playerStatistics." + key + ".tsLastUpdate_1";
                             masterPlayerCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                            Debug.log("[GN] [Database] create new index " + indexName + " at " + masterPlayerCollection.collectionName);
+                            Debug.log("[GearN] [Database] create new index " + indexName + " at " + masterPlayerCollection.collectionName);
                         }
                     }
                 }
@@ -70781,7 +71039,7 @@ class SetMasterGameSettingsRequestHandler extends RequestHandler {
                         let key = removeKeyLst[i];
                         let indexName = "tags." + key + "_1";
                         masterPlayerCollection.dropIndex(indexName);
-                        Debug.log("[GN] [Database] drop index " + indexName + " at " + masterPlayerCollection.collectionName);
+                        Debug.log("[GearN] [Database] drop index " + indexName + " at " + masterPlayerCollection.collectionName);
                     }
                     for (let i = 0; i < addKeyLst.length; i++) {
                         let key = addKeyLst[i];
@@ -70789,7 +71047,7 @@ class SetMasterGameSettingsRequestHandler extends RequestHandler {
                         indexDoc["tags." + key] = 1;
                         let indexName = "tags." + key + "_1";
                         masterPlayerCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                        Debug.log("[GN] [Database] create new index " + indexName + " at " + masterPlayerCollection.collectionName);
+                        Debug.log("[GearN] [Database] create new index " + indexName + " at " + masterPlayerCollection.collectionName);
                     }
                 }
                 masterPlayerSettings.tagsSettings = tagsSettings;
@@ -72201,12 +72459,12 @@ class SetGameInformationRequestHandler extends RequestHandler {
                         {
                             let indexName = "playerCurrencies." + key + ".value_-1";
                             characterPlayerCollection.dropIndex(indexName);
-                            Debug.log("[GN] [Database] drop index " + indexName + " at " + characterPlayerCollection.collectionName);
+                            Debug.log("[GearN] [Database] drop index " + indexName + " at " + characterPlayerCollection.collectionName);
                         }
                         {
                             let indexName = "catalogId_1_" + "playerCurrencies." + key + ".value_-1";
                             characterPlayerCollection.dropIndex(indexName);
-                            Debug.log("[GN] [Database] drop index " + indexName + " at " + characterPlayerCollection.collectionName);
+                            Debug.log("[GearN] [Database] drop index " + indexName + " at " + characterPlayerCollection.collectionName);
                         }
                     }
                     for (let i = 0; i < addKeyLst.length; i++) {
@@ -72216,7 +72474,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                             indexDoc["playerCurrencies." + key + ".value"] = -1;
                             let indexName = "playerCurrencies." + key + ".value_-1";
                             characterPlayerCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                            Debug.log("[GN] [Database] create new index " + indexName + " at " + characterPlayerCollection.collectionName);
+                            Debug.log("[GearN] [Database] create new index " + indexName + " at " + characterPlayerCollection.collectionName);
                         }
                         {
                             let indexDoc = {};
@@ -72224,7 +72482,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                             indexDoc["playerCurrencies." + key + ".value"] = -1;
                             let indexName = "catalogId_1_" + "playerCurrencies." + key + ".value_-1";
                             characterPlayerCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                            Debug.log("[GN] [Database] create new index " + indexName + " at " + characterPlayerCollection.collectionName);
+                            Debug.log("[GearN] [Database] create new index " + indexName + " at " + characterPlayerCollection.collectionName);
                         }
                     }
                 }
@@ -72278,12 +72536,12 @@ class SetGameInformationRequestHandler extends RequestHandler {
                             {
                                 let indexName = "playerStatistics." + key + ".value_-1_playerStatistics." + key + ".tsLastUpdate_1";
                                 characterPlayerCollection.dropIndex(indexName);
-                                Debug.log("[GN] [Database] drop index " + indexName + " at " + characterPlayerCollection.collectionName);
+                                Debug.log("[GearN] [Database] drop index " + indexName + " at " + characterPlayerCollection.collectionName);
                             }
                             {
                                 let indexName = "catalogId_1_" + "playerStatistics." + key + ".value_-1_playerStatistics." + key + ".tsLastUpdate_1";
                                 characterPlayerCollection.dropIndex(indexName);
-                                Debug.log("[GN] [Database] drop index " + indexName + " at " + characterPlayerCollection.collectionName);
+                                Debug.log("[GearN] [Database] drop index " + indexName + " at " + characterPlayerCollection.collectionName);
                             }
                         }
                         for (let i = 0; i < addKeyLst.length; i++) {
@@ -72294,7 +72552,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                                 indexDoc["playerStatistics." + key + ".tsLastUpdate"] = 1;
                                 let indexName = "playerStatistics." + key + ".value_-1_playerStatistics." + key + ".tsLastUpdate_1";
                                 characterPlayerCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                                Debug.log("[GN] [Database] create new index " + indexName + " at " + characterPlayerCollection.collectionName);
+                                Debug.log("[GearN] [Database] create new index " + indexName + " at " + characterPlayerCollection.collectionName);
                             }
                             {
                                 let indexDoc = {};
@@ -72303,7 +72561,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                                 indexDoc["playerStatistics." + key + ".tsLastUpdate"] = 1;
                                 let indexName = "catalogId_1_" + "playerStatistics." + key + ".value_-1_playerStatistics." + key + ".tsLastUpdate_1";
                                 characterPlayerCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                                Debug.log("[GN] [Database] create new index " + indexName + " at " + characterPlayerCollection.collectionName);
+                                Debug.log("[GearN] [Database] create new index " + indexName + " at " + characterPlayerCollection.collectionName);
                             }
                         }
                     }
@@ -72322,12 +72580,12 @@ class SetGameInformationRequestHandler extends RequestHandler {
                             {
                                 let indexName = "playerStatistics." + key + ".value_1_playerStatistics." + key + ".tsLastUpdate_1";
                                 characterPlayerCollection.dropIndex(indexName);
-                                Debug.log("[GN] [Database] drop index " + indexName + " at " + characterPlayerCollection.collectionName);
+                                Debug.log("[GearN] [Database] drop index " + indexName + " at " + characterPlayerCollection.collectionName);
                             }
                             {
                                 let indexName = "catalogId_1_" + "playerStatistics." + key + ".value_1_playerStatistics." + key + ".tsLastUpdate_1";
                                 characterPlayerCollection.dropIndex(indexName);
-                                Debug.log("[GN] [Database] drop index " + indexName + " at " + characterPlayerCollection.collectionName);
+                                Debug.log("[GearN] [Database] drop index " + indexName + " at " + characterPlayerCollection.collectionName);
                             }
                         }
                         for (let i = 0; i < addKeyAscLst.length; i++) {
@@ -72338,7 +72596,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                                 indexDoc["playerStatistics." + key + ".tsLastUpdate"] = 1;
                                 let indexName = "playerStatistics." + key + ".value_1_playerStatistics." + key + ".tsLastUpdate_1";
                                 characterPlayerCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                                Debug.log("[GN] [Database] create new index " + indexName + " at " + characterPlayerCollection.collectionName);
+                                Debug.log("[GearN] [Database] create new index " + indexName + " at " + characterPlayerCollection.collectionName);
                             }
                             {
                                 let indexDoc = {};
@@ -72347,7 +72605,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                                 indexDoc["playerStatistics." + key + ".tsLastUpdate"] = 1;
                                 let indexName = "catalogId_1_" + "playerStatistics." + key + ".value_1_playerStatistics." + key + ".tsLastUpdate_1";
                                 characterPlayerCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                                Debug.log("[GN] [Database] create new index " + indexName + " at " + characterPlayerCollection.collectionName);
+                                Debug.log("[GearN] [Database] create new index " + indexName + " at " + characterPlayerCollection.collectionName);
                             }
                         }
                     }
@@ -72411,7 +72669,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                         let key = removeKeyLst[i];
                         let indexName = "tags." + key + "_1";
                         characterPlayerCollection.dropIndex(indexName);
-                        Debug.log("[GN] [Database] drop index " + indexName + " at " + characterPlayerCollection.collectionName);
+                        Debug.log("[GearN] [Database] drop index " + indexName + " at " + characterPlayerCollection.collectionName);
                     }
                     for (let i = 0; i < addKeyLst.length; i++) {
                         let key = addKeyLst[i];
@@ -72419,7 +72677,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                         indexDoc["tags." + key] = 1;
                         let indexName = "tags." + key + "_1";
                         characterPlayerCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                        Debug.log("[GN] [Database] create new index " + indexName + " at " + characterPlayerCollection.collectionName);
+                        Debug.log("[GearN] [Database] create new index " + indexName + " at " + characterPlayerCollection.collectionName);
                     }
                 }
                 if (request.gameSettings.characterPlayerSettings.playerGroupCatalogSettings != null) {
@@ -72499,7 +72757,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                         let key = removeKeyLst[i];
                         let indexName = "playerCurrencies." + key + ".value_-1";
                         gamePlayerCollection.dropIndex(indexName);
-                        Debug.log("[GN] [Database] drop index " + indexName + " at " + gamePlayerCollection.collectionName);
+                        Debug.log("[GearN] [Database] drop index " + indexName + " at " + gamePlayerCollection.collectionName);
                     }
                     for (let i = 0; i < addKeyLst.length; i++) {
                         let key = addKeyLst[i];
@@ -72507,7 +72765,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                         indexDoc["playerCurrencies." + key + ".value"] = -1;
                         let indexName = "playerCurrencies." + key + ".value_-1";
                         gamePlayerCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                        Debug.log("[GN] [Database] create new index " + indexName + " at " + gamePlayerCollection.collectionName);
+                        Debug.log("[GearN] [Database] create new index " + indexName + " at " + gamePlayerCollection.collectionName);
                     }
                 }
                 if (request.gameSettings.gamePlayerSettings.playerStatisticsSettings != null) {
@@ -72559,7 +72817,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                             let key = removeKeyLst[i];
                             let indexName = "playerStatistics." + key + ".value_-1_playerStatistics." + key + ".tsLastUpdate_1";
                             gamePlayerCollection.dropIndex(indexName);
-                            Debug.log("[GN] [Database] drop index " + indexName + " at " + gamePlayerCollection.collectionName);
+                            Debug.log("[GearN] [Database] drop index " + indexName + " at " + gamePlayerCollection.collectionName);
                         }
                         for (let i = 0; i < addKeyLst.length; i++) {
                             let key = addKeyLst[i];
@@ -72568,7 +72826,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                             indexDoc["playerStatistics." + key + ".tsLastUpdate"] = 1;
                             let indexName = "playerStatistics." + key + ".value_-1_playerStatistics." + key + ".tsLastUpdate_1";
                             gamePlayerCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                            Debug.log("[GN] [Database] create new index " + indexName + " at " + gamePlayerCollection.collectionName);
+                            Debug.log("[GearN] [Database] create new index " + indexName + " at " + gamePlayerCollection.collectionName);
                         }
                     }
                     {
@@ -72585,7 +72843,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                             let key = removeKeyAscLst[i];
                             let indexName = "playerStatistics." + key + ".value_1_playerStatistics." + key + ".tsLastUpdate_1";
                             gamePlayerCollection.dropIndex(indexName);
-                            Debug.log("[GN] [Database] drop index " + indexName + " at " + gamePlayerCollection.collectionName);
+                            Debug.log("[GearN] [Database] drop index " + indexName + " at " + gamePlayerCollection.collectionName);
                         }
                         for (let i = 0; i < addKeyAscLst.length; i++) {
                             let key = addKeyAscLst[i];
@@ -72594,7 +72852,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                             indexDoc["playerStatistics." + key + ".tsLastUpdate"] = 1;
                             let indexName = "playerStatistics." + key + ".value_1_playerStatistics." + key + ".tsLastUpdate_1";
                             gamePlayerCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                            Debug.log("[GN] [Database] create new index " + indexName + " at " + gamePlayerCollection.collectionName);
+                            Debug.log("[GearN] [Database] create new index " + indexName + " at " + gamePlayerCollection.collectionName);
                         }
                     }
                 }
@@ -72657,7 +72915,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                         let key = removeKeyLst[i];
                         let indexName = "tags." + key + "_1";
                         gamePlayerCollection.dropIndex(indexName);
-                        Debug.log("[GN] [Database] drop index " + indexName + " at " + gamePlayerCollection.collectionName);
+                        Debug.log("[GearN] [Database] drop index " + indexName + " at " + gamePlayerCollection.collectionName);
                     }
                     for (let i = 0; i < addKeyLst.length; i++) {
                         let key = addKeyLst[i];
@@ -72665,7 +72923,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                         indexDoc["tags." + key] = 1;
                         let indexName = "tags." + key + "_1";
                         gamePlayerCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                        Debug.log("[GN] [Database] create new index " + indexName + " at " + gamePlayerCollection.collectionName);
+                        Debug.log("[GearN] [Database] create new index " + indexName + " at " + gamePlayerCollection.collectionName);
                     }
                 }
                 if (request.gameSettings.gamePlayerSettings.playerCharacterCatalogSettings != null) {
@@ -72758,12 +73016,12 @@ class SetGameInformationRequestHandler extends RequestHandler {
                         {
                             let indexName = "groupCurrencies." + key + ".value_-1";
                             groupCollection.dropIndex(indexName);
-                            Debug.log("[GN] [Database] drop index " + indexName + " at " + groupCollection.collectionName);
+                            Debug.log("[GearN] [Database] drop index " + indexName + " at " + groupCollection.collectionName);
                         }
                         {
                             let indexName = "catalogId_1_" + "groupCurrencies." + key + ".value_-1";
                             groupCollection.dropIndex(indexName);
-                            Debug.log("[GN] [Database] drop index " + indexName + " at " + groupCollection.collectionName);
+                            Debug.log("[GearN] [Database] drop index " + indexName + " at " + groupCollection.collectionName);
                         }
                     }
                     for (let i = 0; i < addKeyLst.length; i++) {
@@ -72773,7 +73031,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                             indexDoc["groupCurrencies." + key + ".value"] = -1;
                             let indexName = "groupCurrencies." + key + ".value_-1";
                             groupCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                            Debug.log("[GN] [Database] create new index " + indexName + " at " + groupCollection.collectionName);
+                            Debug.log("[GearN] [Database] create new index " + indexName + " at " + groupCollection.collectionName);
                         }
                         {
                             let indexDoc = {};
@@ -72781,7 +73039,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                             indexDoc["groupCurrencies." + key + ".value"] = -1;
                             let indexName = "catalogId_1_" + "groupCurrencies." + key + ".value_-1";
                             groupCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                            Debug.log("[GN] [Database] create new index " + indexName + " at " + groupCollection.collectionName);
+                            Debug.log("[GearN] [Database] create new index " + indexName + " at " + groupCollection.collectionName);
                         }
                     }
                 }
@@ -72835,12 +73093,12 @@ class SetGameInformationRequestHandler extends RequestHandler {
                             {
                                 let indexName = "groupStatistics." + key + ".value_-1_groupStatistics." + key + ".tsLastUpdate_1";
                                 groupCollection.dropIndex(indexName);
-                                Debug.log("[GN] [Database] drop index " + indexName + " at " + groupCollection.collectionName);
+                                Debug.log("[GearN] [Database] drop index " + indexName + " at " + groupCollection.collectionName);
                             }
                             {
                                 let indexName = "catalogId_1_" + "groupStatistics." + key + ".value_-1_groupStatistics." + key + ".tsLastUpdate_1";
                                 groupCollection.dropIndex(indexName);
-                                Debug.log("[GN] [Database] drop index " + indexName + " at " + groupCollection.collectionName);
+                                Debug.log("[GearN] [Database] drop index " + indexName + " at " + groupCollection.collectionName);
                             }
                         }
                         for (let i = 0; i < addKeyLst.length; i++) {
@@ -72851,7 +73109,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                                 indexDoc["groupStatistics." + key + ".tsLastUpdate"] = 1;
                                 let indexName = "groupStatistics." + key + ".value_-1_groupStatistics." + key + ".tsLastUpdate_1";
                                 groupCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                                Debug.log("[GN] [Database] create new index " + indexName + " at " + groupCollection.collectionName);
+                                Debug.log("[GearN] [Database] create new index " + indexName + " at " + groupCollection.collectionName);
                             }
                             {
                                 let indexDoc = {};
@@ -72860,7 +73118,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                                 indexDoc["groupStatistics." + key + ".tsLastUpdate"] = 1;
                                 let indexName = "catalogId_1_" + "groupStatistics." + key + ".value_-1_groupStatistics." + key + ".tsLastUpdate_1";
                                 groupCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                                Debug.log("[GN] [Database] create new index " + indexName + " at " + groupCollection.collectionName);
+                                Debug.log("[GearN] [Database] create new index " + indexName + " at " + groupCollection.collectionName);
                             }
                         }
                     }
@@ -72879,12 +73137,12 @@ class SetGameInformationRequestHandler extends RequestHandler {
                             {
                                 let indexName = "groupStatistics." + key + ".value_1_groupStatistics." + key + ".tsLastUpdate_1";
                                 groupCollection.dropIndex(indexName);
-                                Debug.log("[GN] [Database] drop index " + indexName + " at " + groupCollection.collectionName);
+                                Debug.log("[GearN] [Database] drop index " + indexName + " at " + groupCollection.collectionName);
                             }
                             {
                                 let indexName = "catalogId_1_" + "groupStatistics." + key + ".value_1_groupStatistics." + key + ".tsLastUpdate_1";
                                 groupCollection.dropIndex(indexName);
-                                Debug.log("[GN] [Database] drop index " + indexName + " at " + groupCollection.collectionName);
+                                Debug.log("[GearN] [Database] drop index " + indexName + " at " + groupCollection.collectionName);
                             }
                         }
                         for (let i = 0; i < addKeyAscLst.length; i++) {
@@ -72895,7 +73153,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                                 indexDoc["groupStatistics." + key + ".tsLastUpdate"] = 1;
                                 let indexName = "groupStatistics." + key + ".value_1_groupStatistics." + key + ".tsLastUpdate_1";
                                 groupCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                                Debug.log("[GN] [Database] create new index " + indexName + " at " + groupCollection.collectionName);
+                                Debug.log("[GearN] [Database] create new index " + indexName + " at " + groupCollection.collectionName);
                             }
                             {
                                 let indexDoc = {};
@@ -72904,7 +73162,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                                 indexDoc["groupStatistics." + key + ".tsLastUpdate"] = 1;
                                 let indexName = "catalogId_1_" + "groupStatistics." + key + ".value_1_groupStatistics." + key + ".tsLastUpdate_1";
                                 groupCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                                Debug.log("[GN] [Database] create new index " + indexName + " at " + groupCollection.collectionName);
+                                Debug.log("[GearN] [Database] create new index " + indexName + " at " + groupCollection.collectionName);
                             }
                         }
                     }
@@ -72969,7 +73227,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                         groupCollection.dropIndex("tags." + key + "_1");
                         let indexName = "tags." + key + "_1";
                         groupCollection.dropIndex(indexName);
-                        Debug.log("[GN] [Database] drop index " + indexName + " at " + groupCollection.collectionName);
+                        Debug.log("[GearN] [Database] drop index " + indexName + " at " + groupCollection.collectionName);
                     }
                     for (let i = 0; i < addKeyLst.length; i++) {
                         let key = addKeyLst[i];
@@ -72977,7 +73235,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                         indexDoc["tags." + key] = 1;
                         let indexName = "tags." + key + "_1";
                         groupCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                        Debug.log("[GN] [Database] create new index " + indexName + " at " + groupCollection.collectionName);
+                        Debug.log("[GearN] [Database] create new index " + indexName + " at " + groupCollection.collectionName);
                     }
                 }
                 if (request.gameSettings.groupSettings.groupItemCatalogSettings != null) {
@@ -73048,12 +73306,12 @@ class SetGameInformationRequestHandler extends RequestHandler {
                             {
                                 let indexName = "itemStatistics." + key + ".value_-1_itemStatistics." + key + ".tsLastUpdate_1";
                                 inventoryCollection.dropIndex(indexName);
-                                Debug.log("[GN] [Database] drop index " + indexName + " at " + inventoryCollection.collectionName);
+                                Debug.log("[GearN] [Database] drop index " + indexName + " at " + inventoryCollection.collectionName);
                             }
                             {
                                 let indexName = "catalogId_1_" + "itemStatistics." + key + ".value_-1_itemStatistics." + key + ".tsLastUpdate_1";
                                 inventoryCollection.dropIndex(indexName);
-                                Debug.log("[GN] [Database] drop index " + indexName + " at " + inventoryCollection.collectionName);
+                                Debug.log("[GearN] [Database] drop index " + indexName + " at " + inventoryCollection.collectionName);
                             }
                         }
                         for (let i = 0; i < addKeyLst.length; i++) {
@@ -73064,7 +73322,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                                 indexDoc["itemStatistics." + key + ".tsLastUpdate"] = 1;
                                 let indexName = "itemStatistics." + key + ".value_-1_itemStatistics." + key + ".tsLastUpdate_1";
                                 inventoryCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                                Debug.log("[GN] [Database] create new index " + indexName + " at " + inventoryCollection.collectionName);
+                                Debug.log("[GearN] [Database] create new index " + indexName + " at " + inventoryCollection.collectionName);
                             }
                             {
                                 let indexDoc = {};
@@ -73073,7 +73331,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                                 indexDoc["itemStatistics." + key + ".tsLastUpdate"] = 1;
                                 let indexName = "catalogId_1_" + "itemStatistics." + key + ".value_-1_itemStatistics." + key + ".tsLastUpdate_1";
                                 inventoryCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                                Debug.log("[GN] [Database] create new index " + indexName + " at " + inventoryCollection.collectionName);
+                                Debug.log("[GearN] [Database] create new index " + indexName + " at " + inventoryCollection.collectionName);
                             }
                         }
                     }
@@ -73092,12 +73350,12 @@ class SetGameInformationRequestHandler extends RequestHandler {
                             {
                                 let indexName = "itemStatistics." + key + ".value_1_itemStatistics." + key + ".tsLastUpdate_1";
                                 inventoryCollection.dropIndex(indexName);
-                                Debug.log("[GN] [Database] drop index " + indexName + " at " + inventoryCollection.collectionName);
+                                Debug.log("[GearN] [Database] drop index " + indexName + " at " + inventoryCollection.collectionName);
                             }
                             {
                                 let indexName = "catalogId_1_" + "itemStatistics." + key + ".value_1_itemStatistics." + key + ".tsLastUpdate_1";
                                 inventoryCollection.dropIndex(indexName);
-                                Debug.log("[GN] [Database] drop index " + indexName + " at " + inventoryCollection.collectionName);
+                                Debug.log("[GearN] [Database] drop index " + indexName + " at " + inventoryCollection.collectionName);
                             }
                         }
                         for (let i = 0; i < addKeyAscLst.length; i++) {
@@ -73108,7 +73366,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                                 indexDoc["itemStatistics." + key + ".tsLastUpdate"] = 1;
                                 let indexName = "itemStatistics." + key + ".value_1_itemStatistics." + key + ".tsLastUpdate_1";
                                 inventoryCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                                Debug.log("[GN] [Database] create new index " + indexName + " at " + inventoryCollection.collectionName);
+                                Debug.log("[GearN] [Database] create new index " + indexName + " at " + inventoryCollection.collectionName);
                             }
                             {
                                 let indexDoc = {};
@@ -73117,7 +73375,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                                 indexDoc["itemStatistics." + key + ".tsLastUpdate"] = 1;
                                 let indexName = "catalogId_1_" + "itemStatistics." + key + ".value_1_itemStatistics." + key + ".tsLastUpdate_1";
                                 inventoryCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                                Debug.log("[GN] [Database] create new index " + indexName + " at " + inventoryCollection.collectionName);
+                                Debug.log("[GearN] [Database] create new index " + indexName + " at " + inventoryCollection.collectionName);
                             }
                         }
                     }
@@ -73181,7 +73439,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                         let key = removeKeyLst[i];
                         let indexName = "tags." + key + "_1";
                         inventoryCollection.dropIndex(indexName);
-                        Debug.log("[GN] [Database] drop index " + indexName + " at " + inventoryCollection.collectionName);
+                        Debug.log("[GearN] [Database] drop index " + indexName + " at " + inventoryCollection.collectionName);
                     }
                     for (let i = 0; i < addKeyLst.length; i++) {
                         let key = addKeyLst[i];
@@ -73189,7 +73447,7 @@ class SetGameInformationRequestHandler extends RequestHandler {
                         indexDoc["tags." + key] = 1;
                         let indexName = "tags." + key + "_1";
                         inventoryCollection.createIndex(indexDoc, { background: true, sparse: true, name: indexName });
-                        Debug.log("[GN] [Database] create new index " + indexName + " at " + inventoryCollection.collectionName);
+                        Debug.log("[GearN] [Database] create new index " + indexName + " at " + inventoryCollection.collectionName);
                     }
                 }
             }
@@ -73809,7 +74067,7 @@ class CloudScriptService {
     }
     loadCloudScriptWorker(version) {
         let filePath = __dirname + "/./GN-startup/cloudScript/" + version + ".js";
-        Debug.log("[GN] [CloudScript] run cloudScript " + version);
+        Debug.log("[GearN] [CloudScript] run cloudScript " + version);
         let cloudScriptWorker = (0,external_child_process_namespaceObject.fork)(filePath, {
             env: {
                 gameId: this.gameId,
@@ -73875,7 +74133,7 @@ class CloudScriptService {
             }
         });
         cloudScriptWorker.on("exit", (code) => {
-            Debug.log("[GN] [CloudScript] terminal cloudScript " + version + " with code " + code);
+            Debug.log("[GearN] [CloudScript] terminal cloudScript " + version + " with code " + code);
             thiz.cloudScriptWorkerDict.delete(version);
         });
         this.cloudScriptWorkerDict.set(version, cloudScriptWorker);
@@ -75515,6 +75773,7 @@ class GetSecretInfoInformationRequestHandler extends RequestHandler {
         operationResponse.setParameter(GNParameterCode.CreatorId, secretInfoItem.getCreatorId());
         operationResponse.setParameter(GNParameterCode.Remove, secretInfoItem.getRemove());
         operationResponse.setParameter(GNParameterCode.TsExpire, secretInfoItem.getTsExpire());
+        operationResponse.setParameter(GNParameterCode.DisplayName, secretInfoItem.getDisplayName());
         let gnPermission = GetSecretInfoInformationRequestHandler.getPermissionHashtable(secretInfoItem.getPermission());
         operationResponse.setParameter(GNParameterCode.Permission, gnPermission);
         operationResponse.setParameter(ParameterCode.ErrorCode, GNErrorCode.Ok);
@@ -78541,7 +78800,7 @@ class GetSecretInfoInformationRequestHandler extends RequestHandler {
                 gnPermissionRules.add(GNParameterCode.OtherSelfEnable, permissionRules.otherSelfEnable);
                 gnPermissionRules.add(GNParameterCode.ServerSelfEnable, permissionRules.serverSelfEnable);
                 gnPermissionRules.add(GNParameterCode.AdminSelfEnable, permissionRules.adminSelfEnable);
-                gnMasterAdmin.add(GNParameterCode.ChangePasswordAdminAccount, gnPermissionRules);
+                gnMasterAdmin.add(GNParameterCode.DeleteInDatabase, gnPermissionRules);
             }
             gnPermission.add(GNParameterCode.MasterAdmin, gnMasterAdmin);
         }
@@ -78705,6 +78964,7 @@ class GetSecretInfoInformationRequestHandler extends RequestHandler {
 
 
 
+
 class GetSecretInfoListOperationRequest extends OperationRequest {
     isValidRequest() {
         if (!super.isValidRequest())
@@ -78737,15 +78997,25 @@ class GetSecretInfoListRequestHandler extends RequestHandler {
         operationResponse = new OperationResponse(operationRequest.getOperationCode(), operationRequest.getRequestId(), operationRequest.isEncrypted());
         operationResponse.setReturnCode(ReturnCode.Ok);
         let collection = this.gnServer.getDatabase().systemCollection("MasterAdmin");
-        let results = await collection.find({ type: "secretInfo" }, { secretKey: true });
-        let gnSecretInfoItems = new GNArray();
+        let results = await collection.find({ type: "secretInfo" }, { secretKey: true, role: true });
+        let gnAdminSecretKeys = new GNArray();
+        let gnServerSecretKeys = new GNArray();
+        let gnPlayerSecretKeys = new GNArray();
         while (await results.hasNext()) {
             let secretInfoItem = new SecretInfoItem(await results.next(), collection);
             let gnSecretInfoItem = new GNHashtable();
             gnSecretInfoItem.add(GNParameterCode.SecretKey, secretInfoItem.getSecretKey());
-            gnSecretInfoItems.add(gnSecretInfoItem);
+            let role = secretInfoItem.getRole();
+            if (role == SecretRole.Admin)
+                gnAdminSecretKeys.add(gnSecretInfoItem);
+            else if (role == SecretRole.Server)
+                gnServerSecretKeys.add(gnSecretInfoItem);
+            else
+                gnPlayerSecretKeys.add(gnSecretInfoItem);
         }
-        operationResponse.setParameter(GNParameterCode.Results, gnSecretInfoItems);
+        operationResponse.setParameter(GNParameterCode.AdminSecretKeys, gnAdminSecretKeys);
+        operationResponse.setParameter(GNParameterCode.ServerSecretKeys, gnServerSecretKeys);
+        operationResponse.setParameter(GNParameterCode.PlayerSecretKeys, gnPlayerSecretKeys);
         operationResponse.setParameter(ParameterCode.ErrorCode, GNErrorCode.Ok);
         await this.gnServer.getPostEventCallbackService().onEvent("dashboard_GetSecretInfoList", request, secretInfo, operationRequest, operationResponse);
         return operationResponse;
@@ -78779,6 +79049,7 @@ class SetSecretInfoInformationOperationRequest extends OperationRequest {
     remove;
     tsExpire;
     permissionParam;
+    displayName;
     isValidRequest() {
         if (!super.isValidRequest())
             return false;
@@ -78801,6 +79072,10 @@ SetSecretInfoInformationRequestHandler_decorate([
     GNHashtableDataMember({ code: GNParameterCode.Permission, isOptional: true }),
     SetSecretInfoInformationRequestHandler_metadata("design:type", PermissionParam)
 ], SetSecretInfoInformationOperationRequest.prototype, "permissionParam", void 0);
+SetSecretInfoInformationRequestHandler_decorate([
+    StringDataMember({ code: GNParameterCode.DisplayName, isOptional: true }),
+    SetSecretInfoInformationRequestHandler_metadata("design:type", String)
+], SetSecretInfoInformationOperationRequest.prototype, "displayName", void 0);
 class SetSecretInfoInformationRequestHandler extends RequestHandler {
     getCode() {
         return OperationCode.SetSecretInfoInformation;
@@ -78821,6 +79096,7 @@ class SetSecretInfoInformationRequestHandler extends RequestHandler {
             remove: request.remove,
             tsExpire: request.tsExpire,
             permissionParam: request.permissionParam,
+            displayName: request.displayName,
         }, secretInfo, operationRequest);
     }
     async execute(request, secretInfo, operationRequest) {
@@ -78843,6 +79119,9 @@ class SetSecretInfoInformationRequestHandler extends RequestHandler {
         if (request.tsExpire != null) {
             secretInfoItem.setTsExpire(request.tsExpire);
         }
+        if (request.displayName != null) {
+            secretInfoItem.setDisplayName(request.displayName);
+        }
         // let secretRole = <SecretRole>secretInfoItem.getRole();
         if (request.permissionParam) {
             let permissionAny = secretInfoItem.getPermission();
@@ -78908,6 +79187,7 @@ class SetSecretInfoInformationRequestHandler extends RequestHandler {
             .setRole(secretInfoItem.getRole())
             .setSecretKey(secretInfoItem.getSecretKey())
             .setTsExpire(secretInfoItem.getTsExpire())
+            .setDisplayName(secretInfoItem.getDisplayName())
             .build();
         this.gnServer.getApiMiddleware().updateSecretInfo(newSecretInfo);
         operationResponse.setParameter(ParameterCode.ErrorCode, GNErrorCode.Ok);
@@ -79493,7 +79773,7 @@ class ResetStatisticsLeaderboardRequestHandler extends RequestHandler {
             let statisticsAggregationMethod = playerStatisticsSettingsItem.statisticsAggregationMethod;
             let direction = statisticsAggregationMethod == xStatisticsAggregationMethod.Minimum ? 1 : -1;
             let masterPlayerCollection = await this.gnServer.getDatabase().systemCollection("MasterPlayer");
-            Debug.log("[GN] ResetStatisticsLeaderboard for key " + key + " at " + masterPlayerCollection.collectionName + " starting");
+            Debug.log("[GearN] ResetStatisticsLeaderboard for key " + key + " at " + masterPlayerCollection.collectionName + " starting");
             let masterPlayers = await this.gnServer.getDatabase().loadMasterPlayersLeaderboardWithStatisticsAllAsync(key, direction, masterPlayerFindOptions);
             let backupData = {
                 key: key,
@@ -79539,7 +79819,7 @@ class ResetStatisticsLeaderboardRequestHandler extends RequestHandler {
             });
             await backupStatisticsLeaderboardCollection.insertOne(backupData);
             this.gnServer.getDatabase().insertMasterPlayerStatisticsLogsAsync(logRequests);
-            Debug.log("[GN] ResetStatisticsLeaderboard for key " + key + " at " + masterPlayerCollection.collectionName + " success");
+            Debug.log("[GearN] ResetStatisticsLeaderboard for key " + key + " at " + masterPlayerCollection.collectionName + " success");
         }
         else {
             let gameId = request.gameId;
@@ -79563,7 +79843,7 @@ class ResetStatisticsLeaderboardRequestHandler extends RequestHandler {
                 let statisticsAggregationMethod = playerStatisticsSettingsItem.statisticsAggregationMethod;
                 let direction = statisticsAggregationMethod == xStatisticsAggregationMethod.Minimum ? 1 : -1;
                 let gamePlayerCollection = await this.gnServer.getDatabase().systemGameCollection("GamePlayer", gameId);
-                Debug.log("[GN] ResetStatisticsLeaderboard for key " + key + " at " + gamePlayerCollection.collectionName + " starting");
+                Debug.log("[GearN] ResetStatisticsLeaderboard for key " + key + " at " + gamePlayerCollection.collectionName + " starting");
                 let gamePlayers = await this.gnServer.getDatabase().loadGamePlayersLeaderboardWithStatisticsAllAsync(key, gameId, direction, gamePlayerFindOptions);
                 let backupData = {
                     key: key,
@@ -79609,7 +79889,7 @@ class ResetStatisticsLeaderboardRequestHandler extends RequestHandler {
                 });
                 await backupStatisticsLeaderboardCollection.insertOne(backupData);
                 this.gnServer.getDatabase().insertGamePlayerStatisticsLogsAsync(logRequests, gameId);
-                Debug.log("[GN] ResetStatisticsLeaderboard for key " + key + " at " + gamePlayerCollection.collectionName + " success");
+                Debug.log("[GearN] ResetStatisticsLeaderboard for key " + key + " at " + gamePlayerCollection.collectionName + " success");
             }
             else if (type == OwnerType.CharacterPlayer) {
                 let backupStatisticsLeaderboardCollection = this.gnServer.getDatabase().runtimeGameCollection("CharacterPlayer.StatisticsBackup", gameId);
@@ -79631,7 +79911,7 @@ class ResetStatisticsLeaderboardRequestHandler extends RequestHandler {
                 let statisticsAggregationMethod = playerStatisticsSettingsItem.statisticsAggregationMethod;
                 let direction = statisticsAggregationMethod == xStatisticsAggregationMethod.Minimum ? 1 : -1;
                 let characterPlayerCollection = await this.gnServer.getDatabase().systemGameCollection("CharacterPlayer", gameId);
-                Debug.log("[GN] ResetStatisticsLeaderboard for key " + key + " at " + characterPlayerCollection.collectionName + " starting");
+                Debug.log("[GearN] ResetStatisticsLeaderboard for key " + key + " at " + characterPlayerCollection.collectionName + " starting");
                 let characterPlayers = await this.gnServer.getDatabase().loadCharacterPlayersLeaderboardWithStatisticsAllAsync(key, request.catalogId, gameId, direction, characterPlayerFindOptions);
                 let backupData = {
                     key: key,
@@ -79677,7 +79957,7 @@ class ResetStatisticsLeaderboardRequestHandler extends RequestHandler {
                 });
                 await backupStatisticsLeaderboardCollection.insertOne(backupData);
                 this.gnServer.getDatabase().insertCharacterPlayerStatisticsLogsAsync(logRequests, gameId);
-                Debug.log("[GN] ResetStatisticsLeaderboard for key " + key + " at " + characterPlayerCollection.collectionName + " success");
+                Debug.log("[GearN] ResetStatisticsLeaderboard for key " + key + " at " + characterPlayerCollection.collectionName + " success");
             }
             else if (type == OwnerType.Group) {
                 let backupStatisticsLeaderboardCollection = this.gnServer.getDatabase().runtimeGameCollection("Group.StatisticsBackup", gameId);
@@ -79699,7 +79979,7 @@ class ResetStatisticsLeaderboardRequestHandler extends RequestHandler {
                 let statisticsAggregationMethod = groupStatisticsSettingsItem.statisticsAggregationMethod;
                 let direction = statisticsAggregationMethod == xStatisticsAggregationMethod.Minimum ? 1 : -1;
                 let groupCollection = await this.gnServer.getDatabase().systemGameCollection("Group", gameId);
-                Debug.log("[GN] ResetStatisticsLeaderboard for key " + key + " at " + groupCollection.collectionName + " starting");
+                Debug.log("[GearN] ResetStatisticsLeaderboard for key " + key + " at " + groupCollection.collectionName + " starting");
                 let groups = await this.gnServer.getDatabase().loadGroupsLeaderboardWithStatisticsAllAsync(key, request.catalogId, gameId, direction, groupFindOptions);
                 let backupData = {
                     key: key,
@@ -79745,7 +80025,7 @@ class ResetStatisticsLeaderboardRequestHandler extends RequestHandler {
                 });
                 await backupStatisticsLeaderboardCollection.insertOne(backupData);
                 this.gnServer.getDatabase().insertGroupStatisticsLogsAsync(logRequests, gameId);
-                Debug.log("[GN] ResetStatisticsLeaderboard for key " + key + " at " + groupCollection.collectionName + " success");
+                Debug.log("[GearN] ResetStatisticsLeaderboard for key " + key + " at " + groupCollection.collectionName + " success");
             }
             else if (type == OwnerType.Inventory) {
                 let backupStatisticsLeaderboardCollection = this.gnServer.getDatabase().runtimeGameCollection("Inventory.StatisticsBackup", gameId);
@@ -79762,7 +80042,7 @@ class ResetStatisticsLeaderboardRequestHandler extends RequestHandler {
                 let statisticsAggregationMethod = inventoryStatisticsSettingsItem.statisticsAggregationMethod;
                 let direction = statisticsAggregationMethod == xStatisticsAggregationMethod.Minimum ? 1 : -1;
                 let inventoryCollection = await this.gnServer.getDatabase().systemGameCollection("Inventory", gameId);
-                Debug.log("[GN] ResetStatisticsLeaderboard for key " + key + " at " + inventoryCollection.collectionName + " starting");
+                Debug.log("[GearN] ResetStatisticsLeaderboard for key " + key + " at " + inventoryCollection.collectionName + " starting");
                 let inventories = await this.gnServer.getDatabase().loadInventoriesLeaderboardWithStatisticsAllAsync(key, request.catalogId, gameId, direction, inventoryFindOptions);
                 let backupData = {
                     key: key,
@@ -79808,7 +80088,7 @@ class ResetStatisticsLeaderboardRequestHandler extends RequestHandler {
                 });
                 await backupStatisticsLeaderboardCollection.insertOne(backupData);
                 this.gnServer.getDatabase().insertInventoryStatisticsLogsAsync(logRequests, gameId);
-                Debug.log("[GN] ResetStatisticsLeaderboard for key " + key + " at " + inventoryCollection.collectionName + " success");
+                Debug.log("[GearN] ResetStatisticsLeaderboard for key " + key + " at " + inventoryCollection.collectionName + " success");
             }
             else {
                 operationResponse.setParameter(ParameterCode.ErrorCode, GNErrorCode.OwnerTypeNotSupport);
@@ -80073,7 +80353,7 @@ class GetServerGameDataRequestHandler extends RequestHandler {
         }
         if (requestParams.groupCount) {
             let groupCollection = this.gnServer.getDatabase().systemGameCollection("Group", gameId);
-            operationResponse.setParameter(GNParameterCode.Group, await groupCollection.countDocuments());
+            operationResponse.setParameter(GNParameterCode.GroupCount, await groupCollection.countDocuments());
         }
         if (requestParams.country) {
             // [ { countryCode: "", regions: [{regionCode: "", "lat": 0, "lon": 0, ccu: 0}]} ]
@@ -84200,8 +84480,7 @@ class CountryIPDetailService {
 }
 
 ;// ./src/GNServer.ts
-const GN_VERSION = "2.5";
-
+const GN_VERSION = "2.6";
 
 
 
@@ -84586,7 +84865,6 @@ class GNServer {
     googlePlayGameService;
     gameCenterService;
     timerService;
-    lockService;
     requestConverterService;
     analyticsService;
     postEventCallbackService;
@@ -84612,7 +84890,6 @@ class GNServer {
         this.googlePlayGameService = new GooglePlayGameService();
         this.gameCenterService = new GameCenterService();
         this.timerService = new TimerService();
-        this.lockService = new LockService();
         this.requestConverterService = new RequestConverterService();
         this.pushNotificationService = new PushNotificationService();
         this.emailService = new EmailService();
@@ -85132,9 +85409,6 @@ class GNServer {
     getTimerService() {
         return this.timerService;
     }
-    getLockService() {
-        return this.lockService;
-    }
     getAnalyticsService() {
         return this.analyticsService;
     }
@@ -85279,7 +85553,7 @@ class GNServer {
     }
     async requestMatchServerDetail(gameId, matchmakingTicketCanMatch) {
         let matchId = matchmakingTicketCanMatch.matchId;
-        Debug.logInfo("[GN] [Matchmaking] request match server detail for " + matchId + " to set serverDetail on gameId " + gameId);
+        Debug.logInfo("[GearN] [Matchmaking] request match server detail for " + matchId + " to set serverDetail on gameId " + gameId);
         let thiz = this;
         let timeout = setTimeout(async () => {
             thiz.setMatchServerDetailFailed(gameId, matchId, matchmakingTicketCanMatch.ticketIds, "Timeout");
@@ -85307,7 +85581,7 @@ class GNServer {
             clearTimeout(timeout);
             this.waitingServerDetailDict.delete(matchId);
         }
-        Debug.logInfo("[GN] [Matchmaking] request match server detail for " + matchId + " failed on " + gameId + ", with reason " + reason);
+        Debug.logInfo("[GearN] [Matchmaking] request match server detail for " + matchId + " failed on " + gameId + ", with reason " + reason);
         let matchCollection = this.getDatabase().systemGameCollection("Match", gameId);
         matchCollection.updateOne({ matchId: matchId }, { $set: {} });
         let matchmakingTicketCollection = this.getDatabase().runtimeGameCollection("MatchmakingTicket", gameId);
@@ -85453,18 +85727,18 @@ class ServerApplication extends ServerApplication_BuilderBase {
                 fullLogPath = process.cwd() + "/" + configFullLogPath;
             }
         }
-        console.log("[GN] FullLogPath at: " + fullLogPath);
+        console.log("[GearN] FullLogPath at: " + fullLogPath);
         Debug.init({
             isLogToConsoleEnable: this.getLogSettings().getLogToConsoleEnable(),
             isLogToFileEnable: this.getLogSettings().getLogToFileEnable(),
             logPath: fullLogPath,
         });
         Debug.run();
-        Debug.log("[GN XmobiTea] -->>==>>>--<<<==<<-- [GN XmobiTea]");
-        const port = this.applicationSettings.getPort();
-        Debug.log("[GN] Try run server on the port " + port);
-        const socketPort = this.applicationSettings.getSocketPort();
-        Debug.log("[GN] Try run socket server on the port " + socketPort);
+        Debug.log("[GearN XmobiTea] -->>==>>>--<<<==<<-- [GN XmobiTea]");
+        const port = this.getApplicationSettings().getPort();
+        Debug.log("[GearN] Try run server on the port " + port);
+        const socketPort = this.getApplicationSettings().getSocketPort();
+        Debug.log("[GearN] Try run socket server on the port " + socketPort);
         const app = external_express_default()();
         const server = this.getServer(app, this.getApplicationSettings());
         const useOtherSocketServer = this.getApplicationSettings().getPort() != this.getApplicationSettings().getSocketPort() && this.getSocketAppSettings().getEnable();
@@ -85515,9 +85789,9 @@ class ServerApplication extends ServerApplication_BuilderBase {
         this.gnServer.setHttpApp(this.httpApp);
         this.gnServer.setSocketApp(this.socketApp);
         this.gnServer.getDatabase().run(() => {
-            Debug.log("[GN] Database run success");
+            Debug.log("[GearN] Database run success");
         }, (err) => {
-            Debug.logError("[GN] Database connect error " + err);
+            Debug.logError("[GearN] Database connect error " + err);
         });
         let authInfoCollection = this.gnServer.getDatabase().systemCollection("AuthInfo");
         this.apiMiddleware.setAuthInfoCollection(authInfoCollection);
@@ -85539,7 +85813,7 @@ class ServerApplication extends ServerApplication_BuilderBase {
         this.socketApp.setEmitter(adapterEventCollection);
         // if (this.mailSettings.getEnable()) {
         // 	this.gnServer.getMail().run(() => {
-        // 		Debug.log("[GN] Send Grid Mail run success");
+        // 		Debug.log("[GearN] Send Grid Mail run success");
         // 	});
         // }
         let uploadFileInfoCollection = this.gnServer.getDatabase().systemCollection("UploadFileInfo");
@@ -85549,7 +85823,7 @@ class ServerApplication extends ServerApplication_BuilderBase {
         this.uploadFileMiddleware.setUploadFileInfoCollection(uploadFileInfoCollection);
         this.gnServer.init();
         this.gnServer.run(() => {
-            Debug.log("[GN] Game Application run success");
+            Debug.log("[GearN] Game Application run success");
         });
         let secretInfoResults = await secretInfoCollection.find({ isDefault: true }).toArray();
         let secretInfo = secretInfoResults.at(0);
@@ -85565,7 +85839,6 @@ class ServerApplication extends ServerApplication_BuilderBase {
             reconnectDelay: 5000,
             pingInterval: 20000,
             pingTimeout: 20000,
-            gnServerSourcePath: "",
             logType: gn_typescript_client_namespaceObject.LogType.Off,
             adminSecretKey: secretKey,
             serverSecretKey: secretKey,
@@ -85589,12 +85862,12 @@ class ServerApplication extends ServerApplication_BuilderBase {
         this.gnServer.getPostEventCallbackService().setEventCallbackCollection(postEventCallbackCollection);
         this.gnServer.getPostEventCallbackService().setCloudScriptService(this.gnServer.getEventCallbackCloudScriptService());
         this.gnServer.getPreEventCallbackService().setCloudScriptService(this.gnServer.getEventCallbackCloudScriptService());
-        server.listen(port, () => {
-            Debug.log("[GN XmobiTea] -->>==>>>--<<<==<<-- [GN XmobiTea]");
-            Debug.log("[GN] Server Application running on the port " + port + " with id: " + this.sessionId);
+        server.listen(port, "0.0.0.0", () => {
+            Debug.log("[GearN XmobiTea] -->>==>>>--<<<==<<-- [GearN XmobiTea]");
+            Debug.log("[GearN] Server Application running on 0.0.0.0 the port " + port + " with sessionId: " + this.sessionId);
             if (useOtherSocketServer) {
-                socketServer.listen(socketPort, () => {
-                    Debug.log("[GN] Socket Server running on the port " + socketPort);
+                socketServer.listen(socketPort, "0.0.0.0", () => {
+                    Debug.log("[GearN] Socket Server running on 0.0.0.0 the port " + socketPort);
                 });
             }
             if (onRunSuccess != null)
@@ -85645,132 +85918,120 @@ class ServerApplication extends ServerApplication_BuilderBase {
         }
         let userId = StringUtility.generateRandomString(10, 0);
         {
-            let permission = GrantSecretInfoRequestHandler.generateRecommendAdminPermission();
-            {
-                permission.masterAdmin.setMasterGameSettings = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-                permission.masterAdmin.grantAdminAccount = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-                permission.masterAdmin.removeAdminAccount = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-                permission.masterAdmin.setPasswordAdminAccount = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-                permission.masterAdmin.setSecretKeyAdminAccount = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-                permission.masterAdmin.setGameInformation = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-                permission.masterAdmin.grantGame = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-                permission.masterAdmin.changePasswordAdminAccount = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-                permission.masterAdmin.getAdminAccountList = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-                permission.masterAdmin.getGameInformation = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-                permission.masterAdmin.getGameList = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-                permission.masterAdmin.getMasterGameSettings = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-                permission.masterAdmin.getSecretInfoInformation = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-                permission.masterAdmin.getSecretInfoList = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-                permission.masterAdmin.grantSecretInfo = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-                permission.masterAdmin.setSecretInfoInformation = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-                permission.masterAdmin.getEventCallbackCloudScript = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-                permission.masterAdmin.setEventCallbackCloudScript = {
-                    selfEnable: false,
-                    adminSelfEnable: false,
-                    otherSelfEnable: false,
-                    serverSelfEnable: false,
-                };
-            }
-            {
-                let newSecretInfo = SecretInfo.Builder()
-                    .setGameId("")
-                    .setIsRemove(false)
-                    .setPermission(permission)
-                    .setRole(SecretRole.Admin)
-                    .setSecretKey(StringUtility.generateRandomString(20, 0))
-                    .setTsExpire(-1)
-                    .setIsDefault(true)
-                    .build();
-                await this.gnServer.getApiMiddleware().updateSecretInfo(newSecretInfo);
-            }
             let currentMilliseconds = xDatetime.getCurrentMilliseconds();
             // create secretInfo for admin account
             {
+                let permission = GrantSecretInfoRequestHandler.generateRecommendAdminPermission();
+                {
+                    permission.masterAdmin.setMasterGameSettings = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                    permission.masterAdmin.grantAdminAccount = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                    permission.masterAdmin.removeAdminAccount = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                    permission.masterAdmin.setPasswordAdminAccount = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                    permission.masterAdmin.setSecretKeyAdminAccount = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                    permission.masterAdmin.setGameInformation = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                    permission.masterAdmin.grantGame = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                    permission.masterAdmin.changePasswordAdminAccount = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                    permission.masterAdmin.getAdminAccountList = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                    permission.masterAdmin.getGameInformation = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                    permission.masterAdmin.getGameList = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                    permission.masterAdmin.getMasterGameSettings = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                    permission.masterAdmin.getSecretInfoInformation = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                    permission.masterAdmin.getSecretInfoList = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                    permission.masterAdmin.grantSecretInfo = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                    permission.masterAdmin.setSecretInfoInformation = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                    permission.masterAdmin.getEventCallbackCloudScript = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                    permission.masterAdmin.setEventCallbackCloudScript = {
+                        selfEnable: false,
+                        adminSelfEnable: false,
+                        otherSelfEnable: false,
+                        serverSelfEnable: false,
+                    };
+                }
                 let adminPermission = structuredClone(permission);
                 // adminPermission.masterAdmin.grantAdminAccount.selfEnable = false;
                 // adminPermission.masterAdmin.removeAdminAccount.selfEnable = false;
@@ -85786,6 +86047,7 @@ class ServerApplication extends ServerApplication_BuilderBase {
                     creatorId: userId,
                     remove: false,
                     tsExpire: -1,
+                    displayName: "default recommend sub admin secret info",
                     tsCreate: currentMilliseconds,
                 };
                 await masterAdminCollection.insertOne(result);
@@ -85797,6 +86059,7 @@ class ServerApplication extends ServerApplication_BuilderBase {
                     .setRole(secretInfoItem.getRole())
                     .setSecretKey(secretInfoItem.getSecretKey())
                     .setTsExpire(secretInfoItem.getTsExpire())
+                    .setDisplayName(secretInfoItem.getDisplayName())
                     .build();
                 this.gnServer.getApiMiddleware().updateSecretInfo(newSecretInfo);
             }
@@ -85812,6 +86075,7 @@ class ServerApplication extends ServerApplication_BuilderBase {
                         creatorId: userId,
                         remove: false,
                         tsExpire: -1,
+                        displayName: "default recommend player secret info for gameId dev",
                         tsCreate: currentMilliseconds,
                     };
                     await masterAdminCollection.insertOne(result);
@@ -85823,6 +86087,7 @@ class ServerApplication extends ServerApplication_BuilderBase {
                         .setRole(secretInfoItem.getRole())
                         .setSecretKey(secretInfoItem.getSecretKey())
                         .setTsExpire(secretInfoItem.getTsExpire())
+                        .setDisplayName(secretInfoItem.getDisplayName())
                         .build();
                     this.gnServer.getApiMiddleware().updateSecretInfo(newSecretInfo);
                 }
@@ -85836,6 +86101,7 @@ class ServerApplication extends ServerApplication_BuilderBase {
                         creatorId: userId,
                         remove: false,
                         tsExpire: -1,
+                        displayName: "default recommend player secret info for gameId main",
                         tsCreate: currentMilliseconds,
                     };
                     await masterAdminCollection.insertOne(result);
@@ -85847,6 +86113,7 @@ class ServerApplication extends ServerApplication_BuilderBase {
                         .setRole(secretInfoItem.getRole())
                         .setSecretKey(secretInfoItem.getSecretKey())
                         .setTsExpire(secretInfoItem.getTsExpire())
+                        .setDisplayName(secretInfoItem.getDisplayName())
                         .build();
                     this.gnServer.getApiMiddleware().updateSecretInfo(newSecretInfo);
                 }
@@ -85856,7 +86123,7 @@ class ServerApplication extends ServerApplication_BuilderBase {
             // create secretInfo for admin account
             {
                 let permission = GrantSecretInfoRequestHandler.generateDefaultPermission(true, true, true, true);
-                let secretKey = "admin_" + StringUtility.generateRandomString(14, 0);
+                let secretKey = StringUtility.generateRandomString(20, 0);
                 let newSecretInfo = SecretInfo.Builder()
                     .setGameId("")
                     .setIsRemove(false)
@@ -85864,6 +86131,7 @@ class ServerApplication extends ServerApplication_BuilderBase {
                     .setRole(SecretRole.Admin)
                     .setSecretKey(secretKey)
                     .setTsExpire(-1)
+                    .setDisplayName("default root admin secret info")
                     .setIsDefault(true)
                     .setIsOnlyMasterAdmin(true)
                     .build();
@@ -87285,8 +87553,6 @@ group_model_GroupMemberParam_decorate([
 
 
 
-
-