plutosdk 0.0.8-beta.1

package/lib/sdk.js

@@ -0,0 +1,306 @@
+import PubSub from 'pubsub-js';
+import { CODE, EVENT_GAME_INFO_LOADED, EVENT_GAME_READY, EVENT_PURCHASE_COMPLETED, EVENT_SWITCH_PAGE, PAGE_ID } from './utils/constant';
+import { clipboard } from './utils/Utils';
+import Config from './utils/Config';
+import walletManager from './utils/WalletManager';
+import net from './utils/Net';
+import user from './utils/User';
+import platform from './utils/Platform';
+/**
+ *
+ */
+export const init = () => {
+    return sdk.init();
+};
+/**
+ *
+ */
+export const login = () => {
+    return sdk.login();
+};
+/**
+ *
+ */
+export const ready = () => {
+    sdk.ready();
+};
+/**
+ *
+ */
+export const share = () => {
+    sdk.share();
+};
+/**
+ *
+ */
+export const getShareLink = () => {
+    return sdk.getShareLink();
+};
+/**
+ *
+ */
+export const copyShareLink = () => {
+    return sdk.copyShareLink();
+};
+/**
+ *
+ * @param name
+ * @param orderId
+ * @param amount
+ * @param customData
+ * @param callback
+ */
+export const purchase = (productId, name, orderId, amount, customData = '', callback = null) => {
+    return sdk.purchase(productId, name, orderId, amount, customData, callback);
+};
+/**
+ *
+ */
+export const connectWallet = () => {
+    return sdk.connectWallet();
+};
+/**
+ *
+ */
+export const disconnectWallet = () => {
+    return sdk.disconnectWallet();
+};
+/**
+ *
+ */
+export const getWalletConnected = () => {
+    return sdk.getWalletConnected();
+};
+/**
+ *
+ */
+class Sdk {
+    /**
+     *
+     */
+    constructor() {
+        //
+        this._loadingGame = false;
+        //
+        this._loadGameRetryCount = 0;
+        //
+        this._initialized = false;
+        //
+        this._logined = false;
+        //
+        this._purchaseing = false;
+        //
+        this._purchaseCallback = null;
+        /**
+         *
+         * @param _
+         * @param status
+         */
+        this.onPuchaseCompleted = (_, status) => {
+            if (this._purchaseCallback) {
+                let obj = {
+                    success: status,
+                    productId: user.purchaseData.productId,
+                    orderId: user.purchaseData.orderId,
+                    customData: user.purchaseData.customData
+                };
+                this._purchaseCallback.apply(null, [obj]);
+                this._purchaseCallback = null;
+            }
+        };
+        PubSub.subscribe(EVENT_PURCHASE_COMPLETED, this.onPuchaseCompleted);
+        Config.init();
+        net.init();
+        platform.init();
+        walletManager.init();
+        this.getGameInfo();
+    }
+    /**
+     *
+     */
+    getGameInfo() {
+        if (this._loadingGame) {
+            return;
+        }
+        //
+        this._loadingGame = true;
+        this._loadGameRetryCount++;
+        platform.reqGameInfo().then(data => {
+            this._loadingGame = false;
+            PubSub.publish(EVENT_SWITCH_PAGE, PAGE_ID.Login);
+            PubSub.publish(EVENT_GAME_INFO_LOADED, true);
+        }).catch((error) => {
+            this._loadingGame = false;
+            PubSub.publish(EVENT_GAME_INFO_LOADED, false);
+            console.log(error.message);
+        });
+    }
+    /**
+     *
+     */
+    init() {
+        return new Promise((resolve, reject) => {
+            //
+            if (user.gameInfo) {
+                this._initialized = true;
+                return resolve();
+            }
+            //
+            let loadGame = () => {
+                PubSub.subscribeOnce(EVENT_GAME_INFO_LOADED, (_, result) => {
+                    if (result) {
+                        this._initialized = true;
+                        return resolve();
+                    }
+                    //
+                    if (this._loadGameRetryCount < 5) {
+                        return loadGame();
+                    }
+                    //
+                    reject({
+                        code: CODE.InitError,
+                        message: 'load game config error.'
+                    });
+                });
+                this.getGameInfo();
+            };
+            loadGame();
+        });
+    }
+    /**
+     *
+     */
+    login() {
+        if (!this._initialized) {
+            return Promise.reject({
+                code: CODE.NotInit,
+                message: 'pluto sdk not initialize.'
+            });
+        }
+        //
+        if (this._logined) {
+            return Promise.reject({
+                code: CODE.Logined,
+                message: 'pluto sdk already login.'
+            });
+        }
+        //
+        return platform.reqLogin().then(data => {
+            this._logined = true;
+            return data;
+        });
+    }
+    /**
+     *
+     */
+    ready() {
+        if (!this._logined) {
+            console.warn('pluto sdk not login!');
+            return;
+        }
+        //
+        PubSub.publish(EVENT_GAME_READY, true);
+    }
+    /**
+     * @param productId
+     * @param name
+     * @param orderId
+     * @param amount
+     * @param customData
+     * @param callback
+     */
+    purchase(productId, name, orderId, amount, customData, callback) {
+        return new Promise((resolve, reject) => {
+            if (!this._logined) {
+                console.warn('pluto sdk not login!');
+                return reject({
+                    code: CODE.NotLogin,
+                    message: 'pluto sdk not login'
+                });
+            }
+            //
+            if (this._purchaseing) {
+                console.warn('payment is being processed!');
+                return reject({
+                    code: CODE.Purchaseing,
+                    message: 'payment is being processed'
+                });
+            }
+            //
+            this._purchaseing = true;
+            this._purchaseCallback = callback;
+            platform.reqPurchase(productId, name, orderId, amount, customData).then(() => {
+                this._purchaseing = false;
+                PubSub.publish(EVENT_SWITCH_PAGE, PAGE_ID.Purchase);
+                resolve();
+            }).catch((error) => {
+                this._purchaseing = false;
+                console.log(error.message);
+                reject(error);
+            });
+        });
+    }
+    /**
+     *
+     */
+    share() {
+        if (!this._initialized) {
+            return console.log('pluto sdk not initialize.');
+        }
+        console.log('pluto sdk share');
+        platform.share(user.gameInfo.describe);
+    }
+    /**
+     *
+     */
+    getShareLink() {
+        if (!this._initialized) {
+            console.log('pluto sdk not initialize.');
+            return "";
+        }
+        let link = `https://t.me/${Config.BOT_NAME}/games?startapp=g_${Config.GAME_ID}_${user.plutoId}`;
+        return link;
+    }
+    /**
+     *
+     */
+    copyShareLink() {
+        return new Promise((resolve, reject) => {
+            if (!this._initialized) {
+                return reject({
+                    code: CODE.NotInit,
+                    message: 'pluto sdk not initialize.'
+                });
+            }
+            //
+            let link = `https://t.me/${Config.BOT_NAME}/games?startapp=g_${Config.GAME_ID}_${user.plutoId}`;
+            clipboard(link).then(() => {
+                resolve();
+            }).catch(error => {
+                reject({
+                    code: CODE.ClipboardError,
+                    message: error
+                });
+            });
+        });
+    }
+    /**
+     *
+     */
+    connectWallet() {
+        return walletManager.connect();
+    }
+    /**
+     *
+     */
+    disconnectWallet() {
+        return walletManager.disconnect();
+    }
+    /**
+     *
+     */
+    getWalletConnected() {
+        return walletManager.connected;
+    }
+}
+const sdk = new Sdk();

package/lib/utils/Api.d.ts

@@ -0,0 +1,32 @@
+/**
+ *
+ */
+export default class Api {
+    /**
+     *
+     */
+    private static showLog;
+    /**
+     *
+     */
+    static gameInfo(): Promise<any>;
+    /**
+     *
+     */
+    static login(): Promise<any>;
+    /**
+     *
+     * @param amount
+     */
+    static priceExchange(amount: number): Promise<any>;
+    /**
+     * @param productId
+     * @param name
+     * @param orderId
+     * @param amount
+     * @param payType
+     * @param currency
+     * @param customData
+     */
+    static order(productId: string, name: string, orderId: string, amount: number, payType: number, currency: string, customData: string): Promise<any>;
+}

package/lib/utils/Api.js

@@ -0,0 +1,122 @@
+import Config from './Config';
+import net from './Net';
+/**
+ *
+ */
+export default class Api {
+    /**
+     *
+     */
+    static showLog(msg) {
+        if (Config.TEST_MODE) {
+            console.log(msg);
+        }
+    }
+    /**
+     *
+     */
+    static gameInfo() {
+        return new Promise((resolve, reject) => {
+            let path = `api/pluto/gameinfo/${Config.GAME_ID}`;
+            let param = {
+                botname: Config.BOT_NAME,
+                initdata: Config.INIT_DATA
+            };
+            net.post(path, param).then(resp => {
+                Api.showLog(`gameInfo=>${JSON.stringify(resp)}`);
+                if (resp.code != 0) {
+                    return reject({
+                        code: resp.code,
+                        message: resp.message
+                    });
+                }
+                resolve(resp.data);
+            }).catch(error => {
+                reject(error);
+            });
+        });
+    }
+    /**
+     *
+     */
+    static login() {
+        return new Promise((resolve, reject) => {
+            let path = `api/pluto/login/${Config.GAME_ID}`;
+            let param = {
+                botname: Config.BOT_NAME,
+                initdata: Config.INIT_DATA
+            };
+            net.post(path, param).then(resp => {
+                Api.showLog(`login=>${JSON.stringify(resp)}`);
+                if (resp.code != 0) {
+                    return reject({
+                        code: resp.code,
+                        message: resp.message
+                    });
+                }
+                resolve(resp.data);
+            }).catch(error => {
+                reject(error);
+            });
+        });
+    }
+    /**
+     *
+     * @param amount
+     */
+    static priceExchange(amount) {
+        return new Promise((resolve, reject) => {
+            let path = `api/pluto/priceexchange/${Config.GAME_ID}`;
+            let param = {
+                amount
+            };
+            net.post(path, param).then(resp => {
+                Api.showLog(`priceExchange=>${JSON.stringify(resp)}`);
+                if (resp.code != 0) {
+                    return reject({
+                        code: resp.code,
+                        message: resp.message
+                    });
+                }
+                resolve(resp.data);
+            }).catch(error => {
+                reject(error);
+            });
+        });
+    }
+    /**
+     * @param productId
+     * @param name
+     * @param orderId
+     * @param amount
+     * @param payType
+     * @param currency
+     * @param customData
+     */
+    static order(productId, name, orderId, amount, payType, currency, customData) {
+        return new Promise((resolve, reject) => {
+            let path = `api/pluto/order/${Config.GAME_ID}`;
+            let param = {
+                productid: productId,
+                productname: name,
+                orderid: orderId,
+                amount: amount,
+                paytype: payType,
+                currencycode: currency,
+                customdata: customData
+            };
+            net.post(path, param).then(resp => {
+                Api.showLog(`order=>${JSON.stringify(resp)}`);
+                if (resp.code != 0) {
+                    return reject({
+                        code: resp.code,
+                        message: resp.message
+                    });
+                }
+                resolve(resp.data);
+            }).catch(error => {
+                reject(error);
+            });
+        });
+    }
+}

package/lib/utils/Net.d.ts

@@ -0,0 +1,33 @@
+/**
+ *
+ */
+declare class Net {
+    private _axios;
+    private _baseUrl;
+    private _token;
+    /**
+     *
+     */
+    set token(value: string);
+    /**
+     *
+     * @param baseUrl
+     */
+    init(): void;
+    /**
+     *
+     * @param url
+     * @param params
+     * @param isInternal
+     */
+    get(url: string, params?: any, isInternal?: boolean): Promise<any>;
+    /**
+     *
+     * @param url
+     * @param data
+     * @param isInternal
+     */
+    post(url: string, data: any, isInternal?: boolean): Promise<any>;
+}
+declare const _default: Net;
+export default _default;

package/lib/utils/Net.js

@@ -0,0 +1,94 @@
+import axios from "axios";
+import { CODE } from "./constant";
+import Config from "./Config";
+/**
+ *
+ */
+class Net {
+    constructor() {
+        //
+        this._baseUrl = '';
+        //
+        this._token = '';
+    }
+    /**
+     *
+     */
+    set token(value) {
+        this._token = value;
+    }
+    /**
+     *
+     * @param baseUrl
+     */
+    init() {
+        this._baseUrl = Config.API_URL;
+        this._axios = axios.create({
+            timeout: 10000 //超时10s
+        });
+        //添加响应拦截器
+        this._axios.interceptors.response.use(response => {
+            //2xx 范围内的状态码都会触发该函数
+            return response;
+        }, error => {
+            //超出 2xx 范围的状态码都会触发该函数
+            console.log(error.toJSON());
+            return Promise.reject({
+                code: CODE.NetError,
+                message: error.message
+            });
+        });
+    }
+    /**
+     *
+     * @param url
+     * @param params
+     * @param isInternal
+     */
+    get(url, params = null, isInternal = true) {
+        let config = {};
+        //
+        if (params) {
+            config.params = params;
+        }
+        //
+        if (isInternal) {
+            url = this._baseUrl + url;
+            //
+            if (this._token) {
+                config.headers = {
+                    Authorization: `Bearer ${this._token}`
+                };
+            }
+        }
+        //
+        return this._axios.get(url, config).then(response => {
+            return response.data;
+        });
+    }
+    /**
+     *
+     * @param url
+     * @param data
+     * @param isInternal
+     */
+    post(url, data, isInternal = true) {
+        let config = {};
+        //
+        if (isInternal) {
+            url = this._baseUrl + url;
+            //
+            if (this._token) {
+                config.headers = {
+                    Authorization: `Bearer ${this._token}`
+                };
+            }
+        }
+        //
+        return this._axios.post(url, data, config).then(response => {
+            return response.data;
+        });
+    }
+}
+//
+export default new Net();

package/lib/utils/Platform.d.ts

@@ -0,0 +1,63 @@
+import { IGame, ILogin, IOrder } from "../interface";
+import { CURRENCY, PAY_TYPE } from './constant';
+/**
+ *
+ */
+declare class Platform {
+    /**
+     *
+     */
+    init(): void;
+    /**
+     *
+     */
+    reqGameInfo(): Promise<IGame>;
+    /**
+     *
+     */
+    reqLogin(): Promise<ILogin>;
+    /**
+     * @param productId
+     * @param name
+     * @param orderId
+     * @param price
+     * @param customData
+     */
+    reqPurchase(productId: string, name: string, orderId: string, amount: number, customData: string): Promise<void>;
+    /**
+     *
+     * @param payType
+     * @param currency
+     */
+    reqOrder(payType: PAY_TYPE, currency: CURRENCY): Promise<IOrder>;
+    /**
+     *
+     * @param url
+     */
+    openLink(url: string): void;
+    /**
+     *
+     * @param url
+     */
+    openTelegramLink(url: string): void;
+    /**
+     *
+     * @param url
+     */
+    openInvoice(url: string): Promise<void>;
+    /**
+     *
+     * @param content
+     */
+    share(content: string): void;
+    /**
+     *
+     */
+    enableClosingConfirmation(): void;
+    /**
+     *
+     */
+    disableClosingConfirmation(): void;
+}
+declare const _default: Platform;
+export default _default;