refactor: emitMsg

src/onebot/config/config.ts

@@ -206,3 +206,17 @@ export function migrateOneBotConfigsV1(config: Partial<v1Config>): OneBotConfig
     }
     return mergedConfig;
 }
+export function getConfigBoolKey(
+    configs: Array<NetworkConfigAdapter>,
+    prediction: (config: NetworkConfigAdapter) => boolean
+): { positive: Array<string>, negative: Array<string> } {
+    const result: { positive: string[], negative: string[] } = { positive: [], negative: [] };
+    configs.forEach(config => {
+        if (prediction(config)) {
+            result.positive.push(config.name);
+        } else {
+            result.negative.push(config.name);
+        }
+    });
+    return result;
+}

src/onebot/index.ts

@@ -543,24 +543,39 @@ export class NapCatOneBot11Adapter {
     }
 
     private async emitMsg(message: RawMessage) {
-        const network = Object.values(this.configLoader.configData.network) as Array<
+        const network = Object.values(this.configLoader.configData.network) as Array<NetworkConfigAdapter>;
-            (typeof this.configLoader.configData.network)[keyof typeof this.configLoader.configData.network]
-        >;
         this.context.logger.logDebug('收到新消息 RawMessage', message);
-        this.apis.MsgApi.parseMessageV2(message)
+        try {
-            .then((ob11Msg) => {
+            const ob11Msg = await this.apis.MsgApi.parseMessageV2(message);
             if (!ob11Msg) return;
-                const isSelfMsg =
+
-                    ob11Msg.stringMsg.user_id.toString() == this.core.selfInfo.uin ||
+            const isSelfMsg = this.isSelfMessage(ob11Msg);
-                    ob11Msg.arrayMsg.user_id.toString() == this.core.selfInfo.uin;
             this.context.logger.logDebug('转化为 OB11Message', ob11Msg);
+
+            const msgMap = this.createMsgMap(network, ob11Msg, isSelfMsg, message);
+            this.handleDebugNetwork(network, msgMap, message);
+            this.handleNotReportSelfNetwork(network, msgMap, isSelfMsg);
+
+            this.networkManager.emitEventByNames(msgMap);
+        } catch (e) {
+            this.context.logger.logError('constructMessage error: ', e);
+        }
+
+        this.handleGroupEvent(message);
+        this.handlePrivateMsgEvent(message);
+    }
+
+    private isSelfMessage(ob11Msg: {
+        stringMsg: OB11Message;
+        arrayMsg: OB11Message;
+    }): boolean {
+        return ob11Msg.stringMsg.user_id.toString() == this.core.selfInfo.uin ||
+            ob11Msg.arrayMsg.user_id.toString() == this.core.selfInfo.uin;
+    }
+
+    private createMsgMap(network: Array<NetworkConfigAdapter>, ob11Msg: any, isSelfMsg: boolean, message: RawMessage): Map<string, OB11Message> {
         const msgMap: Map<string, OB11Message> = new Map();
-                const enable_client: string[] = [];
+        network.flat().filter(e => e.enable).forEach(e => {
-                network
-                    .flat()
-                    .filter((e) => e.enable)
-                    .map((e) => {
-                        enable_client.push(e.name);
             if (e.messagePostFormat == 'string') {
                 msgMap.set(e.name, structuredClone(ob11Msg.stringMsg));
             } else {
@@ -571,48 +586,52 @@ export class NapCatOneBot11Adapter {
                 ob11Msg.arrayMsg.target_id = parseInt(message.peerUin);
             }
         });
+        return msgMap;
+    }
 
-                const debug_network = network.flat().filter((e) => e.enable && e.debug);
+    private handleDebugNetwork(network: Array<NetworkConfigAdapter>, msgMap: Map<string, OB11Message>, message: RawMessage) {
-                if (debug_network.length > 0) {
+        const debugNetwork = network.flat().filter(e => e.enable && e.debug);
-                    for (const adapter of debug_network) {
+        if (debugNetwork.length > 0) {
-                        if (adapter.name) {
+            debugNetwork.forEach(adapter => {
                 const msg = msgMap.get(adapter.name);
                 if (msg) {
                     msg.raw = message;
                 }
-                        }
+            });
-                    }
+        } else if (msgMap.size === 0) {
-                } else if (ob11Msg.stringMsg.message.length === 0 || ob11Msg.arrayMsg.message.length == 0) {
             return;
         }
-                const notreportSelf_network = network.flat().filter((e) => e.enable && (('reportSelfMessage' in e && !e.reportSelfMessage) || !('reportSelfMessage' in e)));
+    }
+
+    private handleNotReportSelfNetwork(network: Array<NetworkConfigAdapter>, msgMap: Map<string, OB11Message>, isSelfMsg: boolean) {
         if (isSelfMsg) {
-                    for (const adapter of notreportSelf_network) {
+            const notReportSelfNetwork = network.flat().filter(e => e.enable && (('reportSelfMessage' in e && !e.reportSelfMessage) || !('reportSelfMessage' in e)));
+            notReportSelfNetwork.forEach(adapter => {
                 msgMap.delete(adapter.name);
+            });
         }
     }
 
-                this.networkManager.emitEventByNames(msgMap);
+    private async handleGroupEvent(message: RawMessage) {
-            })
+        try {
-            .catch((e) => this.context.logger.logError.bind(this.context.logger)('constructMessage error: ', e));
+            const groupEvent = await this.apis.GroupApi.parseGroupEvent(message);
-
-        this.apis.GroupApi.parseGroupEvent(message)
-            .then((groupEvent) => {
             if (groupEvent) {
-                    // log("post group event", groupEvent);
                 this.networkManager.emitEvent(groupEvent);
             }
-            })
+        } catch (e) {
-            .catch((e) => this.context.logger.logError.bind(this.context.logger)('constructGroupEvent error: ', e));
+            this.context.logger.logError('constructGroupEvent error: ', e);
+        }
+    }
 
-        this.apis.MsgApi.parsePrivateMsgEvent(message)
+    private async handlePrivateMsgEvent(message: RawMessage) {
-            .then((privateEvent) => {
+        try {
+            const privateEvent = await this.apis.MsgApi.parsePrivateMsgEvent(message);
             if (privateEvent) {
-                    // log("post private event", privateEvent);
                 this.networkManager.emitEvent(privateEvent);
             }
-            })
+        } catch (e) {
-            .catch((e) => this.context.logger.logError.bind(this.context.logger)('constructPrivateEvent error: ', e));
+            this.context.logger.logError('constructPrivateEvent error: ', e);
+        }
     }
     private async emitRecallMsg(msgList: RawMessage[], cache: LRUCache<string, boolean>) {
         for (const message of msgList) {