@xmobitea/gn-server 2.0.1

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

@@ -0,0 +1,13 @@
+import { xCurrencySettings } from "./xCurrencySettings";
+import { xDataSettings } from "./xDataSettings";
+import { xItemCatalogSettings } from "./xItemCatalogSettings";
+import { xStatisticsSettings } from "./xStatisticsSettings";
+import { xTagSettings } from "./xTagSettings";
+export interface xGroupSettings {
+    groupCurrencySettings: Array<xCurrencySettings>;
+    groupStatisticsSettings: Array<xStatisticsSettings>;
+    groupDatasSettings: Array<xDataSettings>;
+    customDatasSettings: Array<xDataSettings>;
+    tagsSettings: Array<xTagSettings>;
+    groupItemCatalogSettings: Array<xItemCatalogSettings>;
+}

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

@@ -0,0 +1,9 @@
+import { xDataSettings } from "./xDataSettings";
+import { xStatisticsSettings } from "./xStatisticsSettings";
+import { xTagSettings } from "./xTagSettings";
+export interface xInventorySettings {
+    inventoryStatisticsSettings: Array<xStatisticsSettings>;
+    inventoryDatasSettings: Array<xDataSettings>;
+    customDatasSettings: Array<xDataSettings>;
+    tagsSettings: Array<xTagSettings>;
+}

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

@@ -0,0 +1,9 @@
+export interface xItemCatalogSettings {
+    catalogId: string;
+    itemType: number;
+    itemClassSettings: Array<xItemClassSettings>;
+}
+export interface xItemClassSettings {
+    classId: string;
+    displayName?: string;
+}

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

@@ -0,0 +1,13 @@
+import { xCurrencySettings } from "./xCurrencySettings";
+import { xDataSettings } from "./xDataSettings";
+import { xGenericServiceSettings } from "./xGenericServiceSettings";
+import { xStatisticsSettings } from "./xStatisticsSettings";
+import { xTagSettings } from "./xTagSettings";
+export interface xMasterPlayerSettings {
+    genericServiceSettings: Array<xGenericServiceSettings>;
+    playerCurrencySettings: Array<xCurrencySettings>;
+    playerStatisticsSettings: Array<xStatisticsSettings>;
+    playerDatasSettings: Array<xDataSettings>;
+    customDatasSettings: Array<xDataSettings>;
+    tagsSettings: Array<xTagSettings>;
+}

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

@@ -0,0 +1,181 @@
+export declare enum RuleType {
+    String = 1,
+    Difference = 2,
+    SetIntersection = 3,
+    MatchTotal = 4,
+    RegionSelection = 5,
+    TeamSizeBalance = 6,
+    TeamDifference = 7,
+    TeamTicketSizeSimilarity = 8
+}
+export declare enum RuleAttributeSource {
+    UserInput = 1,
+    PlayerData = 2
+}
+export declare enum RuleExpansionType {
+    None = 1,
+    Linear = 2,
+    Custom = 3
+}
+interface RuleBase {
+    name: string;
+    type: RuleType;
+}
+export declare enum RuleStringCompairType {
+    Equals = 1,
+    NotEquals = 2
+}
+export interface StringRule extends RuleBase {
+    attributeSource: RuleAttributeSource;
+    attributePath: string;
+    type: RuleType.String;
+    defaultValue: string;
+    compairType: RuleStringCompairType;
+    advancedSettings?: {
+        secondsUntilOptional: number;
+        expansionType: RuleExpansionType.None | RuleExpansionType.Custom;
+        customExpansions?: {
+            secondsBetweenExpansions: number;
+            overrideValue: string[];
+        };
+    };
+}
+export interface DifferenceRule extends RuleBase {
+    attributeSource: RuleAttributeSource;
+    attributePath: string;
+    type: RuleType.Difference;
+    defaultValue: number;
+    allowedDifference: number;
+    advancedSettings?: {
+        secondsUntilOptional: number;
+        expansionType: RuleExpansionType;
+        linearExpansions?: {
+            secondsBetweenExpansions: number;
+            delta: number;
+            limit: number;
+        };
+        customExpansions?: {
+            secondsBetweenExpansions: number;
+            overrideValue: number[];
+        };
+    };
+}
+export interface SetIntersectionRule extends RuleBase {
+    attributeSource: RuleAttributeSource;
+    attributePath: string;
+    type: RuleType.SetIntersection;
+    min: number;
+    defaultValue: string[];
+    advancedSettings?: {
+        secondsUntilOptional: number;
+        expansionType: RuleExpansionType;
+        linearExpansions?: {
+            secondsBetweenExpansions: number;
+            delta: number;
+        };
+        customExpansions?: {
+            secondsBetweenExpansions: number;
+            overrideValue: number[];
+        };
+    };
+}
+export interface MatchTotalRule extends RuleBase {
+    attributeSource: RuleAttributeSource;
+    attributePath: string;
+    type: RuleType.MatchTotal;
+    min: number;
+    max: number;
+    advancedSettings?: {
+        secondsUntilOptional: number;
+        expansionType: RuleExpansionType.None | RuleExpansionType.Custom;
+        customExpansions?: {
+            secondsBetweenExpansions: number;
+            overrideMin?: number[];
+            overrideMax?: number[];
+        };
+    };
+}
+export interface RegionSelectionRule extends RuleBase {
+    attributePath: string;
+    type: RuleType.RegionSelection;
+    max: number;
+    advancedSettings?: {
+        secondsUntilOptional: number;
+        expansionType: RuleExpansionType;
+        linearExpansions?: {
+            secondsBetweenExpansions: number;
+            delta: number;
+            limit: number;
+        };
+        customExpansions?: {
+            secondsBetweenExpansions: number;
+            overrideValue: number[];
+        };
+    };
+}
+export interface TeamSizeBalanceRule extends RuleBase {
+    type: RuleType.TeamSizeBalance;
+    allowedDifference: number;
+    advancedSettings?: {
+        secondsUntilOptional: number;
+        expansionType: RuleExpansionType;
+        linearExpansions?: {
+            secondsBetweenExpansions: number;
+            delta: number;
+            limit: number;
+        };
+        customExpansions?: {
+            secondsBetweenExpansions: number;
+            overrideValue: number[];
+        };
+    };
+}
+export interface TeamDifferenceRule extends RuleBase {
+    attributeSource: RuleAttributeSource;
+    attributePath: string;
+    type: RuleType.TeamDifference;
+    allowedDifference: number;
+    defaultValue: number;
+    advancedSettings?: {
+        secondsUntilOptional: number;
+        expansionType: RuleExpansionType;
+        linearExpansions?: {
+            secondsBetweenExpansions: number;
+            delta: number;
+            limit: number;
+        };
+        customExpansions?: {
+            secondsBetweenExpansions: number;
+            overrideValue: number[];
+        };
+    };
+}
+export interface TeamTicketSizeSimilarityRule extends RuleBase {
+    type: RuleType.TeamTicketSizeSimilarity;
+    advancedSettings?: {
+        secondsUntilOptional: number;
+    };
+}
+export interface xMatchmakingQueueSettings {
+    queueName: string;
+    matchSize: {
+        min: number;
+        max: number;
+    };
+    ticketSize: {
+        min: number;
+        max: number;
+    };
+    serverAllocation: {
+        enable: boolean;
+    };
+    teams?: {
+        teamId: string;
+        teamSize: {
+            min: number;
+            max: number;
+        };
+    }[];
+    rules?: (StringRule | DifferenceRule | SetIntersectionRule | MatchTotalRule | RegionSelectionRule | TeamSizeBalanceRule | TeamDifferenceRule | TeamTicketSizeSimilarityRule)[];
+}
+export {};

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

@@ -0,0 +1,6 @@
+export declare enum xStatisticsAggregationMethod {
+    Sum = 0,
+    Maximum = 1,
+    Minimum = 2,
+    Last = 3
+}

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

@@ -0,0 +1,6 @@
+export interface xStatisticsSettings {
+    key: string;
+    statisticsAggregationMethod: number;
+    maximumValue?: number;
+    minimumValue?: number;
+}

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

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

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

@@ -0,0 +1,17 @@
+export interface xThirtPartySettings {
+    googleSettings?: {
+        googleClientId: string;
+        packageId: string;
+        publicRSAKey: string;
+    };
+    appleSettings?: {
+        appleClientId: string;
+        sandboxEnable: boolean;
+    };
+    facebookSettings?: {
+        facebookAppId: string;
+        packageId: string;
+        facebookInappSecret: string;
+        facebookAppToken: string;
+    };
+}

package/dist/GN-library/xsettings/lib/xGNSettings.d.ts

@@ -0,0 +1,21 @@
+import { xCharacterPlayerSettings } from "./entity/xCharacterPlayerSettings";
+import { xGamePlayerSettings } from "./entity/xGamePlayerSettings";
+import { xGroupSettings } from "./entity/xGroupSettings";
+import { xInventorySettings } from "./entity/xInventorySettings";
+import { xMasterPlayerSettings } from "./entity/xMasterPlayerSettings";
+import { xMatchmakingQueueSettings } from "./entity/xMatchmakingQueueSettings";
+export declare class xGNSettings {
+    private masterPlayerSettings;
+    private gamePlayerSettingsDict;
+    private characterPlayerSettingsDict;
+    private groupSettingsDict;
+    private inventorySettingsDict;
+    private matchmakingQueueSettingsDict;
+    constructor();
+    getMasterPlayerSettings(): xMasterPlayerSettings;
+    getGamePlayerSettings(gameId: string): xGamePlayerSettings;
+    getCharacterPlayerSettings(gameId: string): xCharacterPlayerSettings;
+    getGroupSettings(gameId: string): xGroupSettings;
+    getInventorySettings(gameId: string): xInventorySettings;
+    getMatchmakingQueueSettings(gameId: string): xMatchmakingQueueSettings[];
+}

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

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

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

@@ -0,0 +1,46 @@
+import { HttpAppSettings } from "./settings/HttpAppSettings";
+import { HttpAppHandler } from "./routes/HttpAppHandler";
+import { UploadFileHandler } from "./routes/UploadFileHandler";
+import { Express } from "express";
+import { ApiMiddleware } from "./middleware/ApiMiddleware";
+import { UploadFileMiddleware } from "./middleware/UploadFileMiddleware";
+import { GNServer } from "./../GNServer";
+import { UploadFileSettings } from "./settings/UploadFileSettings";
+import { AntiDdosMiddleware } from "./middleware/AntiDdosMiddleware";
+import { SocketAppSettings } from "./settings/SocketAppSettings";
+import { ApplicationSettings } from "./settings/ApplicationSettings";
+import { LogSettings } from "./settings/LogSettings";
+import { AdminAppHandler } from "./routes/AdminAppHandler";
+export declare class HttpApp {
+    private applicationSettings;
+    private uploadFileSettings;
+    private appSettings;
+    private socketAppSettings;
+    private app;
+    private httpAppHandler;
+    private uploadFileHandler;
+    private adminAppHandler;
+    private antiDdosMiddleware;
+    private logSettings;
+    private apiMiddleware;
+    private uploadFileMiddleware;
+    private gnServer;
+    private sessionId;
+    setApp(app: Express): void;
+    getApp(): Express;
+    getHttpAppHandler(): HttpAppHandler;
+    getAdminAppHandler(): AdminAppHandler;
+    getUploadFileHandler(): UploadFileHandler;
+    setApiMiddleware(apiMiddleware: ApiMiddleware): void;
+    setUploadFileMiddleware(uploadFileMiddleware: UploadFileMiddleware): void;
+    setApplicationSettings(applicationSettings: ApplicationSettings): void;
+    setAppSettings(appSettings: HttpAppSettings): void;
+    setSocketAppSettings(socketAppSettings: SocketAppSettings): void;
+    setUploadFileSettings(uploadFileSettings: UploadFileSettings): void;
+    setGNServer(gnServer: GNServer): void;
+    setSessionId(sessionId: string): void;
+    setAntiDdosMiddleware(antiDdosMiddleware: AntiDdosMiddleware): void;
+    setLogSettings(logSettings: LogSettings): void;
+    run(): void;
+    constructor();
+}

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

@@ -0,0 +1,73 @@
+import { IBuilder } from "./../GN-library/xbuilder/lib/IBuilder";
+import { ApplicationSettings } from "./settings/ApplicationSettings";
+import { HttpAppSettings } from "./settings/HttpAppSettings";
+import { SocketAppSettings } from "./settings/SocketAppSettings";
+import { GNServer } from "./../GNServer";
+import { MailSettings } from "./settings/MailSettings";
+import { DatabaseSettings } from "./settings/DatabaseSettings";
+import { OtherSettings } from "./settings/OtherSettings";
+import { OnRunSuccess } from "./../GN-library/xbuilder/lib/OnRunSuccess";
+import { LogSettings } from "./settings/LogSettings";
+import { UploadFileSettings } from "./settings/UploadFileSettings";
+import { DdosSettings } from "./settings/DDosSettings";
+declare abstract class BuilderBase {
+    protected applicationSettings: ApplicationSettings;
+    protected httpAppSettings: HttpAppSettings;
+    protected socketAppSettings: SocketAppSettings;
+    protected mailSettings: MailSettings;
+    protected databaseSettings: DatabaseSettings;
+    protected otherSettings: OtherSettings;
+    protected logSettings: LogSettings;
+    protected uploadFileSettings: UploadFileSettings;
+    protected ddosSettings: DdosSettings;
+    getApplicationSettings(): ApplicationSettings;
+    getHttpAppSettings(): HttpAppSettings;
+    getSocketAppSettings(): SocketAppSettings;
+    getDatabaseSettings(): DatabaseSettings;
+    getMailSettings(): MailSettings;
+    getOtherSettings(): OtherSettings;
+    getLogSettings(): LogSettings;
+    getUploadFileSettings(): UploadFileSettings;
+    getDdosSettings(): DdosSettings;
+    constructor();
+}
+declare class Builder extends BuilderBase implements IBuilder<ServerApplication> {
+    setApplicationSettings(applicationSettings: ApplicationSettings): Builder;
+    setHttpAppSettings(httpAppSettings: HttpAppSettings): Builder;
+    setSocketAppSettings(socketAppSettings: SocketAppSettings): Builder;
+    setDatabaseSettings(databaseSettings: DatabaseSettings): Builder;
+    setMailSettings(mailSettings: MailSettings): Builder;
+    setOtherSettings(otherSettings: OtherSettings): Builder;
+    setLogSettings(logSettings: LogSettings): Builder;
+    setUploadFileSettings(uploadFileSettings: UploadFileSettings): Builder;
+    setDdosSettings(ddosSettings: DdosSettings): Builder;
+    build(): ServerApplication;
+    constructor();
+}
+export declare class ServerApplication extends BuilderBase {
+    private httpApp;
+    private socketApp;
+    private gnServer;
+    private apiMiddleware;
+    private antiDdosMiddleware;
+    private uploadFileMiddleware;
+    private sessionId;
+    private secretkey;
+    private secretId;
+    run(onRunSuccess?: OnRunSuccess): Promise<void>;
+    private setupDatabase;
+    private setupNewGNDatabase;
+    private reSetupGNDatabase;
+    private applySettingsGame;
+    private newGNServer;
+    private newApiMiddleware;
+    private newAntiDdosMiddleware;
+    private newUploadMiddleware;
+    getGNServer(): GNServer;
+    private newHttpApp;
+    private newSocketApp;
+    private getServer;
+    constructor(builder: BuilderBase);
+    static Builder(): Builder;
+}
+export {};

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

@@ -0,0 +1,7 @@
+import { DefaultApplicationStartup } from "./DefaultApplicationStartup";
+import { OnRunSuccess } from "./../GN-library/xbuilder/lib/OnRunSuccess";
+export declare class ServerApplicationStartup extends DefaultApplicationStartup {
+    private gnConfig;
+    config(gnConfig: {}): void;
+    run(onRunSuccess?: OnRunSuccess): void;
+}

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

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import { SocketAppSettings } from "./settings/SocketAppSettings";
+import { Server } from "socket.io";
+import http from "http";
+import { SocketAppHandler } from "./routes/SocketAppHandler";
+import { Emitter } from "@socket.io/mongo-emitter";
+import * as mongoDB from "mongodb";
+import { ApiMiddleware } from "./middleware/ApiMiddleware";
+import { AntiDdosMiddleware } from "./middleware/AntiDdosMiddleware";
+import { GNServer } from "./../GNServer";
+export declare class SocketApp {
+    private appSettings;
+    private server;
+    private socketAppHandler;
+    private apiMiddleware;
+    private antiDdosMiddleware;
+    private io;
+    private gnServer;
+    private emitter;
+    setServer(server: http.Server): void;
+    setGNServer(gnServer: GNServer): void;
+    getHttpServer(): http.Server;
+    getIO(): Server;
+    getEmitter(): Emitter;
+    getSocketAppHandler(): SocketAppHandler;
+    setApiMiddleware(apiMiddleware: ApiMiddleware): void;
+    setAppSettings(appSettings: SocketAppSettings): void;
+    setAntiDdosMiddleware(antiDdosMiddleware: AntiDdosMiddleware): void;
+    run(): void;
+    setEmitter(adapterEventCollection: mongoDB.Collection<mongoDB.Document>): void;
+    constructor();
+}

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

@@ -0,0 +1,73 @@
+import express from "express";
+import { Socket } from "socket.io";
+import * as mongoDB from "mongodb";
+export declare class AntiDdosMiddleware {
+    private static readonly FIVE_MINUTE_TS;
+    private static readonly K_MULTIPLE;
+    private socketRequestPerIPDic;
+    private socketRequestPerPeerDic;
+    private httpRequestPerIPDic;
+    private httpRequestPerPeerDic;
+    private currentHttpRequestCount;
+    private currentSocketRequestCount;
+    private currentHttpUploadRequestCount;
+    private currentHttpDownloadRequestCount;
+    private reportDdosCollection;
+    private banDdosCollection;
+    private socketMaxRequestPerSecondPerIp;
+    private socketMaxRequestPerSecondPerPeer;
+    private socketMaxPendingRequest;
+    private socketMaxRequestSize;
+    private httpMaxRequestPerSecondPerIp;
+    private httpMaxRequestPerSecondPerPeer;
+    private httpMaxPendingRequest;
+    private httpMaxRequestSize;
+    private maxUploadPendingRequest;
+    private maxDownloadPendingRequest;
+    private ipWhiteLst;
+    private ipBlackLst;
+    setReportDdosCollection(reportDdosCollection: mongoDB.Collection<mongoDB.Document>): void;
+    setBanDdosCollection(banDdosCollection: mongoDB.Collection<mongoDB.Document>): void;
+    setSocketMaxRequestPerSecondPerIp(socketMaxRequestPerSecondPerIp: number): void;
+    setSocketMaxRequestPerSecondPerPeer(socketMaxRequestPerSecondPerPeer: number): void;
+    setSocketMaxPendingRequest(socketMaxPendingRequest: number): void;
+    setSocketMaxRequestSize(socketMaxRequestSize: number): void;
+    setHttpMaxRequestPerSecondPerIp(httpMaxRequestPerSecondPerIp: number): void;
+    setHttpMaxRequestPerSecondPerPeer(httpMaxRequestPerSecondPerPeer: number): void;
+    setHttpMaxPendingRequest(httpMaxPendingRequest: number): void;
+    setHttpMaxRequestSize(httpMaxRequestSize: number): void;
+    setMaxUploadPendingRequest(maxUploadPendingRequest: number): void;
+    setMaxDownloadPendingRequest(maxDownloadPendingRequest: number): void;
+    checkRequestSizeBodyViaJson(req: express.Request, res: express.Response, next: Function): Promise<any>;
+    checkRequestSizeBodyViaMsgPack(req: express.Request, res: express.Response, next: Function): Promise<any>;
+    private getReturnCodeForRequestSizeHttp;
+    checkRequestSizeBodyViaSocketMsgPack(socket: Socket, data: any, next: Function): Promise<any>;
+    checkRequestSizeBodyViaSocketJson(socket: Socket, data: any, next: Function): Promise<any>;
+    checkMaxRequestPerSecondPerIpViaSocket(socket: Socket, data: any, next: Function): Promise<any>;
+    checkMaxRequestPerSecondPerPeerViaSocket(socket: Socket, data: any, next: Function): Promise<any>;
+    checkMaxRequestPerSecondPerIpViaJson(req: express.Request, res: express.Response, next: Function): Promise<any>;
+    checkMaxUploadRequestPerSecondPerIp(req: express.Request, res: express.Response, next: Function): Promise<any>;
+    checkMaxRequestPerSecondPerIpViaMsgPack(req: express.Request, res: express.Response, next: Function): Promise<any>;
+    private getReturnCodeForMaxRequestPerSecondPerIp;
+    checkMaxRequestPerSecondPerPeerViaJson(req: express.Request, res: express.Response, next: Function): Promise<any>;
+    checkMaxUploadRequestPerSecondPerPeer(req: express.Request, res: express.Response, next: Function): Promise<any>;
+    checkMaxRequestPerSecondPerPeerViaMsgPack(req: express.Request, res: express.Response, next: Function): Promise<any>;
+    private getReturnCodeForMaxRequestPerSecondPerPeer;
+    addPendingRequestViaJson(req: express.Request, res: express.Response, next: Function): Promise<any>;
+    addPendingRequestViaMsgPack(req: express.Request, res: express.Response, next: Function): Promise<any>;
+    private getReturnCodeForPendingRequest;
+    removePendingRequest(req: express.Request, res: express.Response): void;
+    addPendingUploadRequest(req: express.Request, res: express.Response, next: Function): Promise<any>;
+    removePendingUploadRequest(req: express.Request, res: express.Response): void;
+    addPendingRequestViaSocket(socket: Socket, data: any, next: Function): any;
+    removePendingRequestViaSocket(socket: Socket, data: any): void;
+    addPendingDownloadRequest(req: express.Request, res: express.Response, next: Function): Promise<any>;
+    removePendingDownloadRequest(req: express.Request, res: express.Response): void;
+    run(): void;
+    private getBanDdos;
+    private clearHttpRequestPerIPDic;
+    private clearHttpRequestPerPeerDic;
+    private clearSocketRequestPerIPDic;
+    private clearSocketRequestPerPeerDic;
+    constructor();
+}

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

@@ -0,0 +1,45 @@
+import express from "express";
+import { AuthInfo } from "./../../GN-common/entity/AuthInfo";
+import * as mongoDB from "mongodb";
+import { Socket } from "socket.io";
+import { SecretInfo } from "./../../GN-common/entity/SecretInfo";
+import jwt from "jsonwebtoken";
+import { TokenPayload } from "./../../GN-common/entity/TokenPayload";
+export declare class ApiMiddleware {
+    private static readonly FIVE_MINUTE_TS;
+    private static readonly TS_REMOVE_AUTH_INFO_DIC;
+    private authInfoDict;
+    private authInfoCollection;
+    private secretInfoDict;
+    private secretInfoCollection;
+    private playerGameCollection;
+    private expiredToken;
+    private privateKeyToken;
+    private headerIP;
+    private dauLast30Min;
+    private maxCCU;
+    setSecretInfoCollection(secretInfoCollection: mongoDB.Collection<mongoDB.Document>): void;
+    setAuthInfoCollection(authInfoCollection: mongoDB.Collection<mongoDB.Document>): void;
+    setPlayerGameCollection(playerGameCollection: mongoDB.Collection<mongoDB.Document>): void;
+    setExpiredToken(expiredToken: number): void;
+    setPrivateKeyToken(privateKeyToken: string): void;
+    setHeaderIP(headerIP: string): void;
+    getHeaderIP(): string;
+    run(): void;
+    private getDAULast30Min;
+    private checkAndRemoveDict;
+    generateAuthInfo(payload: TokenPayload): AuthInfo;
+    verifyAuthToken(authToken: string): jwt.JwtPayload;
+    getSecretInfoBySecretKeyInDatabase(secretKey: string): Promise<SecretInfo>;
+    getAuthInfoByGNTokenInDatabase(gnToken: string): Promise<AuthInfo>;
+    updateSecretInfo(secretInfo: SecretInfo): Promise<void>;
+    updateAuthInfo(authInfo: AuthInfo): Promise<void>;
+    authenticateTokenViaJson(req: express.Request, res: express.Response, next: Function): Promise<any>;
+    authenticateUploadToken(req: express.Request, res: express.Response, next: Function): Promise<any>;
+    authenticateTokenViaMsgPack(req: express.Request, res: express.Response, next: Function): Promise<any>;
+    getIP(req: express.Request, res: express.Response, next: Function): Promise<any>;
+    getReturnCodeAuthenticate(req: express.Request): Promise<number>;
+    socketAuthenticateToken(socket: Socket, next: (returnCode: number) => void): Promise<void>;
+    createIP(ip: string): string;
+    constructor();
+}

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

@@ -0,0 +1,17 @@
+import multer from "multer";
+import * as mongoDB from "mongodb";
+import express from "express";
+export declare class UploadFileMiddleware {
+    private uploadFileInfoCollection;
+    private uploadPath;
+    private maxSizeUpload;
+    private mimeTypeAccepts;
+    setUploadPath(uploadPath: string): void;
+    setMaxSizeUpload(maxSizeUpload: number): void;
+    setMimeTypeAccepts(mimeTypeAccepts: string[]): void;
+    setUploadFileInfoCollection(uploadFileInfoCollection: mongoDB.Collection<mongoDB.Document>): void;
+    run(): void;
+    private storage;
+    handleUpload(): multer.Multer;
+    checkFileUploadInvalid(req: express.Request, res: express.Response, next: Function): Promise<express.Response>;
+}

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

@@ -0,0 +1,30 @@
+import express from "express";
+import { ApiMiddleware } from "./../middleware/ApiMiddleware";
+import { GNServer } from "./../../GNServer";
+import { ApplicationSettings } from "./../settings/ApplicationSettings";
+import { SocketAppSettings } from "./../settings/SocketAppSettings";
+import { HttpAppSettings } from "./../settings/HttpAppSettings";
+import { LogSettings } from "./../settings/LogSettings";
+export declare class AdminAppHandler {
+    private applicationSettings;
+    private apiMiddleware;
+    private gnServer;
+    private router;
+    private adminRouter;
+    private adminApiRouter;
+    private socketAppSettings;
+    private httpAppSettings;
+    private logSettings;
+    setRouter(router: express.Express): void;
+    setApiMiddleware(apiMiddleware: ApiMiddleware): void;
+    setGNServer(gnServer: GNServer): void;
+    setApplicationSettings(applicationSettings: ApplicationSettings): void;
+    setSocketAppSettings(socketAppSettings: SocketAppSettings): void;
+    setHttpAppSettings(httpAppSettings: HttpAppSettings): void;
+    setLogSettings(logSettings: LogSettings): void;
+    private mustSignin;
+    private mustNotSignin;
+    run(): void;
+    runGNNetworkSdk(adminSecretKey: string, serverSecretKey: string, clientSecretKey: string): void;
+    private setupAdminRouter;
+}