fishpi 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Ryan Sonshine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+# 摸鱼派 API Package
+
+
+## 功能
+
+
+## 安装
+
+```bash
+npm install fishpi
+```
+
+## 用例
+
+```ts
+import FishPi from 'fishpi';
+
+```

package/lib/chatroom.d.ts

@@ -0,0 +1,27 @@
+import { ApiResponse, ChatRoomMessage } from '..';
+declare class ChatRoom {
+    private _token;
+    private _onlines;
+    private _rws;
+    private _wsTimer;
+    private _wsCallbacks;
+    constructor(token?: string);
+    get onlines(): any[];
+    setToken(token: string): void;
+    more(page?: number): Promise<ApiResponse<Array<ChatRoomMessage>>>;
+    revoke(oId: string): Promise<ApiResponse<undefined>>;
+    push(msg: string): Promise<{
+        code: number;
+    }>;
+    raw(oId: string): Promise<string>;
+    get emoji(): {
+        get(): Promise<Array<string>>;
+        set(data: Array<string>): Promise<any>;
+    };
+    get redpacket(): {
+        open(oId: string): Promise<any>;
+    };
+    removeListener(wsCallback: Function): void;
+    addListener(wsCallback: Function): void;
+}
+export default ChatRoom;

package/lib/chatroom.js

@@ -0,0 +1,271 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const reconnecting_websocket_1 = __importDefault(require("reconnecting-websocket"));
+const ws_1 = __importDefault(require("ws"));
+const utils_1 = require("./utils");
+class ChatRoom {
+    constructor(token = '') {
+        this._token = '';
+        this._onlines = [];
+        this._rws = null;
+        this._wsTimer = null;
+        this._wsCallbacks = [];
+        if (!token) {
+            return;
+        }
+        this._token = token;
+    }
+    get onlines() {
+        return this._onlines;
+    }
+    setToken(token) {
+        this._token = token;
+    }
+    more(page = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let rsp = yield (0, utils_1.request)({
+                    url: `chat-room/more?page=${page}&apiKey=${this._token}`
+                });
+                if (rsp.status === 401) {
+                    throw new Error('登录已失效，请重新登录！');
+                }
+                if (rsp.code != 0) {
+                    throw new Error(rsp.msg);
+                }
+                rsp = rsp.data;
+                if (!rsp.data)
+                    return rsp;
+                let redpacket;
+                rsp.data.forEach((d, i, data) => {
+                    try {
+                        redpacket = JSON.parse(d.content);
+                        if (redpacket.msgType !== 'msgType')
+                            return rsp;
+                        redpacket.recivers = JSON.parse(redpacket.recivers);
+                        data[i].content = redpacket;
+                    }
+                    catch (e) { }
+                });
+                return rsp;
+            }
+            catch (e) {
+                throw e;
+            }
+        });
+    }
+    revoke(oId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let rsp;
+            try {
+                rsp = yield (0, utils_1.request)({
+                    url: `chat-room/revoke/${oId}`,
+                    method: 'delete',
+                    data: {
+                        apiKey: this._token
+                    },
+                });
+                if (rsp.status === 401) {
+                    throw new Error('登录已失效，请重新登录！');
+                }
+                return rsp.data;
+            }
+            catch (e) {
+                throw e;
+            }
+        });
+    }
+    push(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let rsp;
+            try {
+                rsp = yield (0, utils_1.request)({
+                    url: `chat-room/send`,
+                    method: 'post',
+                    data: {
+                        content: msg,
+                        apiKey: this._token
+                    },
+                });
+                if (rsp.status === 401) {
+                    throw new Error('登录已失效，请重新登录！');
+                }
+                return rsp.data;
+            }
+            catch (e) {
+                throw e;
+            }
+        });
+    }
+    raw(oId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let rsp;
+            try {
+                rsp = yield (0, utils_1.request)({
+                    url: `cr/raw/${oId}`,
+                });
+                return rsp.data.replace(/<!--.*?-->/g, '');
+            }
+            catch (e) {
+                throw e;
+            }
+        });
+    }
+    get emoji() {
+        let apiKey = this._token;
+        return {
+            get() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    let rsp;
+                    try {
+                        rsp = yield (0, utils_1.request)({
+                            url: `api/cloud/get`,
+                            method: 'post',
+                            data: {
+                                gameId: 'emojis',
+                                apiKey
+                            },
+                        });
+                        if (rsp.status === 401) {
+                            throw new Error('登录已失效，请重新登录！');
+                        }
+                        return JSON.parse(rsp.data.data);
+                    }
+                    catch (e) {
+                        throw e;
+                    }
+                });
+            },
+            set(data) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    let rsp;
+                    try {
+                        rsp = yield (0, utils_1.request)({
+                            url: `api/cloud/sync`,
+                            method: 'post',
+                            data: {
+                                gameId: 'emojis',
+                                data: JSON.stringify(data),
+                                apiKey
+                            },
+                        });
+                        if (rsp.status === 401) {
+                            throw new Error('登录已失效，请重新登录！');
+                        }
+                        return rsp.data;
+                    }
+                    catch (e) {
+                        throw e;
+                    }
+                });
+            }
+        };
+    }
+    get redpacket() {
+        let apiKey = this._token;
+        return {
+            open(oId) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    let rsp;
+                    try {
+                        rsp = yield (0, utils_1.request)({
+                            url: `chat-room/red-packet/open`,
+                            method: 'post',
+                            data: {
+                                oId,
+                                apiKey
+                            },
+                        });
+                        if (rsp.status === 401) {
+                            throw new Error('登录已失效，请重新登录！');
+                        }
+                        return rsp.data;
+                    }
+                    catch (e) {
+                        throw e;
+                    }
+                });
+            }
+        };
+    }
+    removeListener(wsCallback) {
+        if (this._wsCallbacks.indexOf(wsCallback) < 0)
+            return;
+        this._wsCallbacks.splice(this._wsCallbacks.indexOf(wsCallback), 1);
+    }
+    addListener(wsCallback) {
+        if (this._rws !== null) {
+            if (this._wsCallbacks.indexOf(wsCallback) < 0)
+                this._wsCallbacks.push(wsCallback);
+            return;
+        }
+        this._rws = new reconnecting_websocket_1.default(`wss://${utils_1.domain}/chat-room-channel?apiKey=${this._token}`, [], {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            WebSocket: ws_1.default,
+            connectionTimeout: 10000
+        });
+        this._rws.onopen = (e) => {
+            if (this._wsTimer) {
+                clearInterval(this._wsTimer);
+            }
+            this._wsTimer = setInterval(() => {
+                var _a;
+                (_a = this._rws) === null || _a === void 0 ? void 0 : _a.send('-hb-');
+            }, 1000 * 60 * 3);
+        };
+        this._rws.onmessage = (e) => __awaiter(this, void 0, void 0, function* () {
+            let msg = JSON.parse(e.data);
+            let data = null;
+            switch (msg.type) {
+                case 'online': {
+                    data = this._onlines = msg.users;
+                    break;
+                }
+                case 'revoke': {
+                    data = msg.oId;
+                    break;
+                }
+                case 'msg': {
+                    let { oId, time, userName, userNickname, userAvatarURL, content, md } = msg;
+                    try {
+                        let { msg, recivers, money, count, type, got, who, msgType } = JSON.parse(content);
+                        if (msgType === 'redPacket') {
+                            data = {
+                                oId, time, userName, userNickname, userAvatarURL,
+                                redpacket: { msg, recivers, money, count, type, got, who }
+                            };
+                            break;
+                        }
+                    }
+                    catch (e) { }
+                    data = { oId, time, userName, userNickname, userAvatarURL, content, md };
+                    break;
+                }
+                case 'redPacketStatus': {
+                    let { oId, count, got, whoGive, whoGot } = msg;
+                    data = { oId, count, got, whoGive, whoGot };
+                    break;
+                }
+            }
+            this._wsCallbacks.forEach(call => call(Object.assign({ msg: { type: msg.type, data } }, e)));
+        });
+        this._rws.onerror = (e) => {
+            console.error(e);
+        };
+        this._rws.onclose = (e) => {
+        };
+    }
+}
+exports.default = ChatRoom;

package/lib/index.d.ts

@@ -0,0 +1,13 @@
+import { ApiResponse, Account, UserInfo, AtUserList } from '..';
+import ChatRoom from './chatroom';
+declare class FishPi {
+    token: string;
+    chat: ChatRoom;
+    constructor(token: string);
+    login(data: Account): Promise<ApiResponse<string>>;
+    info(): Promise<ApiResponse<UserInfo>>;
+    atlist(name: string): Promise<AtUserList>;
+    upload(files: Array<string>): Promise<any>;
+    liveness(): Promise<any>;
+}
+export default FishPi;

package/lib/index.js

@@ -0,0 +1,150 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const form_data_1 = __importDefault(require("form-data"));
+const utils_1 = require("./utils");
+const chatroom_1 = __importDefault(require("./chatroom"));
+class FishPi {
+    constructor(token) {
+        this.token = '';
+        this.chat = new chatroom_1.default();
+        if (!token) {
+            return;
+        }
+        this.token = token;
+        this.chat.setToken(this.token);
+    }
+    login(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let md5 = crypto.createHash('md5');
+                let rsp = yield (0, utils_1.request)({
+                    url: 'api/getKey',
+                    method: 'post',
+                    data: {
+                        nameOrEmail: data.username,
+                        userPassword: md5.update(data.passwd).digest('hex')
+                    },
+                });
+                this.token = rsp.data.Key;
+                this.chat.setToken(this.token);
+                return rsp.data;
+            }
+            catch (e) {
+                throw e;
+            }
+        });
+    }
+    info() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let rsp = yield (0, utils_1.request)({
+                    url: `api/user?apiKey=${this.token}`
+                });
+                if (rsp.status === 401) {
+                    throw new Error('登录已失效，请重新登录！');
+                }
+                return rsp.data;
+            }
+            catch (e) {
+                throw e;
+            }
+        });
+    }
+    atlist(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let rsp;
+            try {
+                rsp = yield (0, utils_1.request)({
+                    url: `users/names`,
+                    method: 'post',
+                    data: {
+                        name
+                    },
+                });
+                if (rsp.status === 401) {
+                    throw new Error('登录已失效，请重新登录！');
+                }
+                return rsp.data.data;
+            }
+            catch (e) {
+                throw e;
+            }
+        });
+    }
+    upload(files) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let data = new form_data_1.default();
+            files.forEach(f => data.append('file[]', fs.readFileSync(f), path.basename(f)));
+            let rsp;
+            try {
+                rsp = yield (0, utils_1.request)({
+                    url: `upload`,
+                    method: 'post',
+                    data,
+                    headers: data.getHeaders()
+                });
+                if (rsp.status === 401) {
+                    throw new Error('登录已失效，请重新登录！');
+                }
+                return rsp.data;
+            }
+            catch (e) {
+                throw e;
+            }
+        });
+    }
+    liveness() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.token) {
+                return 0;
+            }
+            try {
+                let rsp = yield (0, utils_1.request)({
+                    url: `user/liveness?apiKey=${this.token}`
+                });
+                if (rsp.status === 401) {
+                    throw new Error('登录已失效，请重新登录！');
+                }
+                return rsp.data.liveness;
+            }
+            catch (e) {
+                throw e;
+            }
+        });
+    }
+}
+exports.default = FishPi;

package/lib/src/chatroom.d.ts

@@ -0,0 +1,82 @@
+import { ApiResponse, ChatRoomMessage, RedPacket } from '..';
+declare class ChatRoom {
+    private _apiKey;
+    private _onlines;
+    private _rws;
+    private _wsTimer;
+    private _wsCallbacks;
+    constructor(token?: string);
+    /**
+     * 当前在线人数列表，需要先调用 addListener 添加聊天室消息监听
+     */
+    get onlines(): any[];
+    /**
+     * 重新设置请求 Token
+     * @param apiKey 接口 API Key
+     */
+    setToken(apiKey: string): void;
+    /**
+     * 查询聊天室历史消息
+     * @param page 消息页码
+     */
+    more(page?: number): Promise<ApiResponse<Array<ChatRoomMessage>>>;
+    /**
+     * 撤回消息，普通成员 24 小时内可撤回一条自己的消息，纪律委员/OP/管理员角色可以撤回任意人消息
+     * @param oId 消息 Id
+     */
+    revoke(oId: string): Promise<ApiResponse<undefined>>;
+    /**
+     * 发送一条消息
+     * @param msg 消息内容，支持 Markdown
+     */
+    send(msg: string): Promise<{
+        code: number;
+    }>;
+    /**
+     * 获取消息原文（比如 Markdown）
+     * @param oId 消息 Id
+     */
+    raw(oId: string): Promise<string>;
+    /**
+     * 表情包接口对象
+     */
+    get emoji(): {
+        /**
+         * 获取表情包图像列表
+         */
+        get(): Promise<Array<string>>;
+        /**
+         * 设置表情包列表
+         * @param data 所有表情包图像列表
+         */
+        set(data: Array<string>): Promise<any>;
+    };
+    /**
+     * 红包接口对象
+     */
+    get redpacket(): {
+        /**
+         * 打开一个红包
+         * @param oId 红包消息 Id
+         */
+        open(oId: string): Promise<any>;
+        /**
+         * 发送一个红包
+         * @param redpacket 红包对象
+         */
+        send(redpacket: RedPacket): Promise<{
+            code: number;
+        }>;
+    };
+    /**
+     * 移除聊天室消息监听函数
+     * @param wsCallback 消息监听函数
+     */
+    removeListener(wsCallback: Function): void;
+    /**
+     * 添加聊天室消息监听函数
+     * @param wsCallback 消息监听函数
+     */
+    addListener(wsCallback: Function): void;
+}
+export default ChatRoom;