fix: 完善错误延时重试(#82)

- 成功 0
- 评论 未知错误 1001
- 评论 原动态已删除 1002
- 评论 评论区已关闭 1003
- 评论 需要输入验证码 1004
- 评论 已被对方拉入黑名单 1005
- 评论 黑名单用户无法互动 1006
- 评论 UP主已关闭评论区 1007
- 关注 未知错误 2001
- 关注 您已被对方拉入黑名单 2002
- 关注 黑名单用户无法关注 2003
- 关注 账号异常 2004
- 关注 关注已达上限 2005
- 分区 移动失败 3001
- 点赞 未知错误 4001
- 点赞 点赞异常 4002
- 点赞 点赞频繁 4003
- 转发 未知错误 5001
- 转发 该动态不能转发分享 5002
- 转发 请求数据发生错误，请刷新或稍后重试 5003
- 转发 操作太频繁了，请稍后重试 5004

lib/core/monitor.js

@@ -1,4 +1,4 @@
-const { log, hasEnv, shuffle, getRandomOne, delay, try_for_each } = require('../utils');
+const { log, hasEnv, shuffle, getRandomOne, delay, try_for_each, retryfn } = require('../utils');
 const { send } = require('../net/http');
 const bili = require('../net/bili');
 const { sendNotify } = require('../helper/notify');
@@ -49,13 +49,16 @@ class Monitor extends Searcher {
             case 0:
                 event_bus.emit('Turn_on_the_Monitor')
                 break;
-            case 11:
+            case 1001:
                 event_bus.emit('Turn_off_the_Monitor', '评论失败')
-                break
+                break;
-            case 21:
+            case 2001:
                 event_bus.emit('Turn_off_the_Monitor', '关注出错')
-                break
+                break;
-            case 22:
+            case 3001:
+                event_bus.emit('Turn_off_the_Monitor', '分区移动出错')
+                break;
+            case 2004:
                 log.warn('账号异常', `UID(${global_var.get('myUID')})异常号只会对部分UP出现关注异常`)
                 if (!config.is_exception) {
                     await sendNotify('[动态抽奖]账号异常通知', `UID: ${global_var.get('myUID')}\n\n异常号只会对部分UP出现关注异常\n\n可在设置中令is_exception为true关闭此推送`)
@@ -63,7 +66,7 @@ class Monitor extends Searcher {
                 config.is_exception = true;
                 event_bus.emit('Turn_on_the_Monitor')
                 break
-            case 23:
+            case 2005:
                 log.warn('关注已达上限', `UID(${global_var.get('myUID')})关注已达上限,已临时进入只转已关注模式`)
                 if (!config.is_outof_maxfollow) {
                     await sendNotify('[动态抽奖]关注已达上限', `UID: ${global_var.get('myUID')}\n\n关注已达上限,已临时进入只转已关注模式\n\n可在设置中令is_outof_maxfollow为true关闭此推送`)
@@ -72,17 +75,17 @@ class Monitor extends Searcher {
                 config.only_followed = true;
                 event_bus.emit('Turn_on_the_Monitor')
                 break
-            case 31:
+            case 5001:
                 event_bus.emit('Turn_off_the_Monitor', '转发失败')
                 break
-            case 41:
+            case 6001:
                 event_bus.emit('Turn_off_the_Monitor', '获取开奖时间失败')
                 break
-            case 51:
+            case 7001:
                 event_bus.emit('Turn_off_the_Monitor', '获取关注数失败')
                 break
             default:
-                event_bus.emit('Turn_off_the_Monitor', '未知错误')
+                event_bus.emit('Turn_off_the_Monitor', '??? 未知错误')
                 break;
         }
     }
@@ -117,7 +120,7 @@ class Monitor extends Searcher {
                     let { ts } = await bili.getLotteryNotice(lottery.dyid);
                     const ts_10 = Date.now() / 1000;
                     if (ts < 0) {
-                        return 41
+                        return 6001
                     }
                     if (ts < ts_10) {
                         log.info('过滤', '已过开奖时间')
@@ -134,7 +137,7 @@ class Monitor extends Searcher {
                     if (minfollower > 0) {
                         const followerNum = await bili.getUserInfo(lottery.uid[0]);
                         if (followerNum < 0) {
-                            return 51
+                            return 7001
                         }
                         if (followerNum < minfollower) {
                             log.info('过滤', `粉丝数(${followerNum})小于指定数量`)
@@ -158,16 +161,31 @@ class Monitor extends Searcher {
                 status = await this.go(lottery)
                 switch (status) {
                     case 0:
-                    case 9:
+                    case 1002:
-                    case 19:
+                    case 1003:
+                    case 1004:
+                    case 1005:
+                    case 1006:
+                    case 1007:
+                    case 2002:
+                    case 2003:
+                    case 4001:
+                    case 4002:
+                    case 4003:
+                    case 5002:
+                    case 5003:
+                    case 5004:
                         break;
-                    case 22:
+                    case 2004:
-                        is_exception = 22
+                        is_exception = 2004
                         break;
-                    case 23:
+                    case 2005:
-                        is_outof_maxfollow = 23
+                        is_outof_maxfollow = 2005
                         break;
-                    default:
+                    case 1001:
+                    case 2001:
+                    case 3001:
+                    case 5001:
                         return status
                 }
 
@@ -418,14 +436,27 @@ class Monitor extends Searcher {
      * 关注转发评论
      * @param {LotteryOptions} option
      * @returns {Promise<number>}
-     * 0 - 成功  
+     * - 成功 0
-     * 9 - 评论黑名单/评论区关闭/动态删除  
+     * - 评论 未知错误 1001
-     * 11 - 评论错误  
+     * - 评论 原动态已删除 1002
-     * 19 - 关注黑名单  
+     * - 评论 评论区已关闭 1003
-     * 21 - 关注错误  
+     * - 评论 需要输入验证码 1004
-     * 22 - 关注异常  
+     * - 评论 已被对方拉入黑名单 1005
-     * 23 - 关注已达上限  
+     * - 评论 黑名单用户无法互动 1006
-     * 31 - 转发失败  
+     * - 评论 UP主已关闭评论区 1007
+     * - 关注 未知错误 2001
+     * - 关注 您已被对方拉入黑名单 2002
+     * - 关注 黑名单用户无法关注 2003
+     * - 关注 账号异常 2004
+     * - 关注 关注已达上限 2005
+     * - 分区 移动失败 3001
+     * - 点赞 未知错误 4001
+     * - 点赞 点赞异常 4002
+     * - 点赞 点赞频繁 4003
+     * - 转发 未知错误 5001
+     * - 转发 该动态不能转发分享 5002
+     * - 转发 请求数据发生错误，请刷新或稍后重试 5003
+     * - 转发 操作太频繁了，请稍后重试 5004
      */
     async go(option) {
         log.debug('正在转发的动态信息', option);
@@ -434,64 +465,69 @@ class Monitor extends Searcher {
             return 0
         }
 
+        let status = 0
         const { uid, dyid, chat_type, rid, relay_chat, ctrl } = option;
 
         /* 评论 */
         if (rid && chat_type) {
-            let status = 0
+            const { chat } = config;
-            const
+
-                { chat } = config,
+            status = await retryfn(
-                retry = [...new Array(5).keys()],
+                5,
-                max_retry_times = retry.length;
+                [1, 4],
-            await try_for_each(retry, async (times) => {
+                () => bili.sendChat(rid, getRandomOne(chat), chat_type)
-                status = await bili.sendChat(rid, getRandomOne(chat), chat_type)
+            )
-                switch (status) {
+
-                    case 0:
+            if (status) {
-                        return true
+                log.warn("抽奖信息", `dyid: ${dyid}, rid: ${rid}, chat_type: ${chat_type}`)
-                    case -1:
+                return 1000 + status
-                        log.warn('抽奖信息', `uid: ${uid},dyid: ${dyid}`)
-                        return true
-                    default:
-                        log.error('抽奖信息', `uid: ${uid},dyid: ${dyid}`)
-                        log.info('自动评论', `将在 ${times + 1} 分钟后再次发送评论(${times + 1}/${max_retry_times})`)
-                        await delay(60 * 1000 * (times + 1))
-                        return false
             }
-            })
-            if (status) return 10 + status;
         }
 
         /* 关注 */
         if (uid.length) {
-            let status = 0
             await try_for_each(uid, async (u) => {
                 status = await bili.autoAttention(u)
-                switch (status) {
+                if (status) {
-                    case 0:
+                    log.warn("抽奖信息", `dyid: ${dyid}, uid: ${u}`)
-                        if (await bili.movePartition(u, this.tagid)) {
+                    return true
-                            log.error('抽奖信息', `uid: ${u},dyid: ${dyid}`)
+                } else if (await bili.movePartition(u, this.tagid)) {
-                        }
+                    log.warn("抽奖信息", `dyid: ${dyid}, uid: ${u} tagid: ${this.tagid}`)
+                    /* 3000系错误 */
+                    status = 1001
+                    return true
+                } else {
                     return false
-                    case -1:
-                    case 2:
-                    case 3:
-                        log.warn('抽奖信息', `uid: ${u},dyid: ${dyid}`)
-                        return true
-                    default:
-                        log.error('抽奖信息', `uid: ${u},dyid: ${dyid}`)
-                        return true
                 }
             })
-            if (status) return 20 + status
+            if (status) return 2000 + status
         }
 
         /* 点赞 */
-        await bili.autolike(dyid)
+        status = await retryfn(
+            5,
+            [1, 2, 3],
+            () => bili.autolike(dyid)
+        )
+
+        if (status) {
+            log.warn("抽奖信息", `dyid: ${dyid}`)
+            return 4000 + status
+        }
 
         /* 转发 */
-        if (await bili.autoRelay(global_var.get("myUID"), dyid, relay_chat, ctrl)) return 31;
+        status = await retryfn(
+            5,
+            [1, 3, 4],
+            () => bili.autoRelay(global_var.get("myUID"), dyid, relay_chat, ctrl)
+        )
 
-        return 0
+        if (status) {
+            log.warn("抽奖信息", `dyid: ${dyid}`)
+            return 5000 + status
+        }
+
+        return status
     }
 }
 

lib/net/bili.js

@@ -618,13 +618,13 @@ const bili_client = {
             case 0:
                 return [false, 0, '关注+1']
             case 22002:
-                return [false, -1, '您已被对方拉入黑名单']
+                return [false, 2, '您已被对方拉入黑名单']
             case 22003:
-                return [false, -1, '黑名单用户无法关注']
+                return [false, 3, '黑名单用户无法关注']
             case 22015:
-                return [false, 2, '账号异常']
+                return [false, 4, '账号异常']
             case 22009:
-                return [false, 3, '关注已达上限']
+                return [false, 5, '关注已达上限']
             default:
                 return [true, 1, `未知错误\n${responseText}`]
         }
@@ -636,11 +636,12 @@ const bili_client = {
      * @param {Number} uid
      * 被关注者的UID
      * @returns {Promise<number>}
-     * -1 - 黑名单  
+     * - 成功 0  
-     * 0 - 成功  
+     * - 未知错误 1  
-     * 1 - 失败  
+     * - 您已被对方拉入黑名单 2  
-     * 2 - 异常  
+     * - 黑名单用户无法关注 3  
-     * 3 - 关注已达上限
+     * - 账号异常 4  
+     * - 关注已达上限 5  
      */
     autoAttention(uid) {
         return this._autoAttention.run(uid)
@@ -650,8 +651,8 @@ const bili_client = {
      * @param {number} uid
      * @param {number} tagid 关注分区的ID
      * @returns {Promise<number>}
-     * 0 - 成功  
+     * - 成功 0  
-     * 1 - 失败  
+     * - 失败 1  
      */
     async movePartition(uid, tagid) {
         const responseText = await post({
@@ -703,11 +704,14 @@ const bili_client = {
      * 动态自动点赞
      * @param {string} dyid
      * @returns {Promise<number>}
-     * 0 - 成功  
+     * - 成功 0  
-     * 1 - 失败  
+     * - 未知错误 1  
+     * - 点赞异常 2  
+     * - 点赞频繁 3  
      */
     async autolike(dyid) {
-        const responseText = await post({
+        const
+            responseText = await post({
                 url: API.DYNAMIC_LIKE_THUMB,
                 contents: {
                     uid: GlobalVar.get("myUID"),
@@ -715,12 +719,20 @@ const bili_client = {
                     up: 1,
                     csrf: GlobalVar.get("csrf")
                 }
-        });
+            }),
-        if (/^{"code":0/.test(responseText)) {
+            res = strToJson(responseText);
+        switch (res.code) {
+            case 0:
                 log.info('自动点赞', '点赞成功');
                 return 0;
-        } else {
+            case 1000113:
-            log.error('自动点赞', `点赞失败\n${responseText}`);
+                log.warn('自动点赞', '点赞异常');
+                return 2;
+            case 1000001:
+                log.warn('自动点赞', '点赞频繁');
+                return 3;
+            default:
+                log.error('自动点赞', `未知错误\n${responseText}`);
                 return 1;
         }
     },
@@ -733,8 +745,11 @@ const bili_client = {
      * @param {string} [msg]
      * 动态的ID
      * @returns {Promise<number>}
-     * 0 - 成功  
+     * - 成功 0  
-     * 1 - 失败  
+     * - 未知错误 1  
+     * - 该动态不能转发分享 2  
+     * - 请求数据发生错误，请刷新或稍后重试 3  
+     * - 操作太频繁了，请稍后重试 4  
      */
     async autoRelay(uid, dyid, msg = '转发动态', ctrl = '[]') {
         const len = msg.length;
@@ -756,17 +771,21 @@ const bili_client = {
                 }
             }),
             res = strToJson(responseText);
-        if (res.code === 0) {
+        switch (res.code) {
+            case 0:
                 log.info('转发动态', '成功转发一条动态');
                 return 0;
-        } else if (res.code === 1101004) {
+            case 1101004:
                 log.warn('转发动态', '该动态不能转发分享');
-            return 0;
+                return 2;
-        } else if (res.code === 2201116) {
+            case 2201116:
                 log.warn('转发动态', '请求数据发生错误，请刷新或稍后重试');
-            return 0;
+                return 3;
-        } else {
+            case 1101008:
-            log.error('转发动态', `转发动态失败\n${responseText}`);
+                log.warn('转发动态', '操作太频繁了，请稍后重试');
+                return 4;
+            default:
+                log.error('转发动态', `未知错误\n${responseText}`);
                 return 1;
         }
     },
@@ -897,8 +916,13 @@ const bili_client = {
      * 17(无图)
      * @returns {Promise<number>}
      * - 成功 0
-     * - 失败 1
+     * - 未知错误 1
-     * - 黑名单/评论区关闭/动态删除 -1
+     * - 原动态已删除 2
+     * - 评论区已关闭 3
+     * - 需要输入验证码 4
+     * - 已被对方拉入黑名单 5
+     * - 黑名单用户无法互动 6
+     * - UP主已关闭评论区 7
      */
     async sendChat(rid, msg, type) {
         const
@@ -918,22 +942,22 @@ const bili_client = {
                 return 0;
             case -404:
                 log.error('自动评论', '原动态已删除');
-                return -1;
+                return 2;
             case 12002:
                 log.error('自动评论', '评论区已关闭');
-                return -1;
+                return 3;
             case 12015:
                 log.error('自动评论', '需要输入验证码');
-                return 1;
+                return 4;
             case 12035:
                 log.error('自动评论', `已被对方拉入黑名单`);
-                return -1;
+                return 5;
             case 12053:
                 log.error('自动评论', '黑名单用户无法互动');
-                return -1;
+                return 6;
             case 12061:
                 log.error('自动评论', 'UP主已关闭评论区');
-                return -1;
+                return 7;
             default:
                 log.error('自动评论', `未知错误\n${responseText}`);
                 return 1;

lib/utils.js

@@ -57,6 +57,25 @@ const utils = {
             if (await fn(item)) break
         }
     },
+    /**
+     * @template T
+     * @param {number} max_times
+     * @param {Array<T>} unexpected
+     * @param {() => Promise<T>} fn
+     */
+    async retryfn(max_times, unexpected, fn) {
+        let ret = null;
+        for (let times = 0; times < max_times; times++) {
+            ret = await fn()
+            if (unexpected.includes(ret)) {
+                utils.log.warn('自动重试', `将在 ${times + 1} 分钟后再次尝试(${times + 1}/${max_times})`)
+                await utils.delay(60 * 1000 * (times + 1))
+            } else {
+                break
+            }
+        }
+        return ret;
+    },
     /**
      * 函数柯里化
      * @template T