示例#1
0
        private static void ConvertSendToTG(
            Telegram.Bot.Types.Chat target,
            cqhttp.Cyan.Messages.Message message,
            string sender_nick
            )
        {
            foreach (var i in message.data)
            {
                switch (i.type)
                {
                case "text":
                    OptimisticModuleManager.SendText(target, $"[{NicknameLookup.GetCQNickname(sender_nick)}] {i.data["text"]}");
                    break;

                case "image":
                    OptimisticModuleManager.SendText(target, $"{NicknameLookup.GetCQNickname(sender_nick)}发送了图片");
                    OptimisticModuleManager.SendPhoto(target, i.data["url"]);
                    break;

                case "face":
                    OptimisticModuleManager.SendText(target, $"[{NicknameLookup.GetCQNickname(sender_nick)}] " +
                                                     $"{ConvertEmoji(Convert.ToInt32(i.data["id"]))}");
                    break;
                }
            }
        }
示例#2
0
        private async static void onMessageReceived(MessageEvent e)
        {
            (MessageType, long)endPoint = (e.messageType, getFromNum(e));
            // LOAD MOD FOR QQ GROUPS TOO!!!
            //api.RecallMessageAsync(message);
            Console.WriteLine(
                $"收到来自{e.sender.nickname}的QQ消息{e.message.raw_data_cq}"
                );
            WriteLog($"收到来自{e.sender.nickname}的QQ消息{e.message.raw_data_cq}");
            Message torep = Repeate(e.message, endPoint.Item2);

            if (torep != null)
            {
                await Config.CoolQClient.SendMessageAsync(
                    endPoint.Item1,
                    endPoint.Item2,
                    torep
                    );
            }
            string m = raw_string(e.message);

            if (e.message.raw_data_cq.Contains("[CQ:") == false)
            {
                try {
                    Message result =
                        Module_QQ.GetResult(m, e.sender.nickname);
                    if (result.data[0].type != "text" || result.data[0].data["text"] != "")
                    {
                        await Config.CoolQClient.SendMessageAsync(
                            e.messageType,
                            getFromNum (e),
                            result
                            );
                    }
                } catch { }

                try {
                    Config.lastSaid[e.sender.nickname] = e.message;
                } catch { }
                try {
                    Command com = Parser.ParseCommand(m, Config.module_ID);
                    switch (com.operation)
                    {
                    case 0:     //start_send
                        if (Config.CQsend.Contains(endPoint))
                        {
                            await Config.CoolQClient.SendTextAsync(
                                endPoint.Item1, endPoint.Item2,
                                string.Format(Config.alreadySendingMessage, "TG")
                                );

                            return;
                        }
                        Config.CQsend.Add(endPoint);
                        await Config.CoolQClient.SendTextAsync(
                            endPoint.Item1, endPoint.Item2,
                            string.Format(Config.startSendMessage, "TG")
                            );

                        return;

                    case 1:     //start_recv
                        if (Config.CQrecv.Contains(endPoint))
                        {
                            await Config.CoolQClient.SendTextAsync(
                                endPoint.Item1, endPoint.Item2,
                                string.Format(Config.alreadyRecvingMessage, "TG")
                                );

                            return;
                        }
                        Config.CQrecv.Add(endPoint);
                        await Config.CoolQClient.SendTextAsync(
                            endPoint.Item1, endPoint.Item2,
                            string.Format(Config.startRecvMessage, "TG")
                            );

                        return;

                    case 2:     //stop_send
                        if (Config.CQsend.Contains(endPoint))
                        {
                            Config.CQsend.Remove(endPoint);
                            await Config.CoolQClient.SendTextAsync(
                                endPoint.Item1, endPoint.Item2,
                                string.Format(Config.stopSendMessage, "TG")
                                );

                            return;
                        }
                        await Config.CoolQClient.SendTextAsync(
                            endPoint.Item1, endPoint.Item2,
                            string.Format(Config.notSendingMessage, "TG")
                            );

                        return;

                    case 3:     //stop_recv
                        if (Config.CQrecv.Contains(endPoint))
                        {
                            Config.CQrecv.Remove(endPoint);
                            await Config.CoolQClient.SendTextAsync(
                                endPoint.Item1, endPoint.Item2,
                                string.Format(Config.stopRecvMessage, "TG")
                                );

                            return;
                        }
                        await Config.CoolQClient.SendTextAsync(
                            endPoint.Item1, endPoint.Item2,
                            string.Format(Config.notRecvingMessage, "TG")
                            );

                        return;

                    case 4:     //send
                        try {
                            foreach (Telegram.Bot.Types.Chat i in Config.TGrecv)
                            {
                                ConvertSendToTG(i,
                                                e.message,
                                                NicknameLookup.GetCQNickname(e.sender.nickname)
                                                );
                            }
                            await Config.CoolQClient.SendTextAsync(
                                endPoint.Item1, endPoint.Item2,
                                Config.forceForwardSuccess
                                );
                        } catch (IndexOutOfRangeException) {
                            await Config.CoolQClient.SendTextAsync(
                                endPoint.Item1, endPoint.Item2,
                                Config.forceForwardFaliure
                                );
                        }
                        return;

                    case 5:     //setnick
                        if (com.parameters.Count != 2)
                        {
                            await Config.CoolQClient.SendTextAsync(
                                endPoint.Item1, endPoint.Item2,
                                Config.setNickFormatError
                                );

                            return;
                        }
                        NicknameLookup.SetTGNickname(com.parameters[0], com.parameters[1]);
                        //throw new NotImplementedException();
                        await Config.CoolQClient.SendTextAsync(
                            endPoint.Item1, endPoint.Item2,
                            Config.setNickSuccess
                            );

                        return;

                    case 6:     //getlast
                        if (com.parameters.Count != 1 || !Config.lastSaid.ContainsKey(com.parameters[0]))
                        {
                            await Config.CoolQClient.SendTextAsync(endPoint.Item1, endPoint.Item2, "爱莫能助");

                            return;
                        }
                        await Config.CoolQClient.SendTextAsync(
                            endPoint.Item1, endPoint.Item2,
                            $"{com.parameters[0]} 刚才发了:"
                            );

                        await Config.CoolQClient.SendMessageAsync(
                            endPoint.Item1, endPoint.Item2,
                            Config.lastSaid[com.parameters[0]]
                            );

                        return;
                    }
                } catch (CommandErrorException) {
                }
            }
            if (Config.CQsend.Contains(endPoint) == false)
            {
                return;
            }

            foreach (Telegram.Bot.Types.Chat i in Config.TGrecv)
            {
                ConvertSendToTG(i, e.message, e.sender.nickname);
            }
            //OptimisticModuleManager.SendText(i, $"[{NicknameLookup.GetCQNickname(message.Sender)}] {message.RawMessage}");
        }
示例#3
0
        public override string GetResult(Telegram.Bot.Types.Message msg)
        {
            bool isInList = false;

            /*if (msg.Type == MessageType.Photo) {
             *  foreach (Chat i in Config.TGsend)
             *      if (msg.Chat.Id == i.Id) {
             *          isInList = true;
             *          break;
             *      }
             *  if (!isInList) return "";
             *  string ms = $"[{NicknameLookup.GetTGNickname(msg.From)}] 发了一张图片";
             *  foreach (var i in Config.CQrecv) {
             *      Config.CoolQClient.SendTextAsync (i.Item1, i.Item2, ms);
             *      Config.CoolQClient.SendMessageAsync (i.Item1, i.Item2,
             *          //new cqhttp.Cyan.Messages.Message (new ElementImage (msg.NewChatPhoto))
             *      );
             *  }
             * }*/
            try {
                Command command = Parser.ParseCommand(msg.Text, moduleID);
                switch (command.operation)
                {
                case 0:     //start_send
                    foreach (Chat i in Config.TGsend)
                    {
                        if (i.Id == msg.Chat.Id)
                        {
                            return(string.Format(Config.alreadySendingMessage, "QQ"));
                        }
                    }
                    Config.TGsend.Add(msg.Chat);
                    return(string.Format(Config.startSendMessage, "QQ"));

                case 1:     //start_recv
                    foreach (Chat i in Config.TGrecv)
                    {
                        if (i.Id == msg.Chat.Id)
                        {
                            return(string.Format(Config.alreadyRecvingMessage, "QQ"));
                        }
                    }
                    Config.TGrecv.Add(msg.Chat);
                    return(string.Format(Config.startRecvMessage, "QQ"));

                case 2:     //stop_send
                    foreach (Chat i in Config.TGsend)
                    {
                        if (i.Id == msg.Chat.Id)
                        {
                            Config.TGsend.Remove(i);
                            return(string.Format(Config.stopSendMessage, "QQ"));
                        }
                    }
                    return(string.Format(Config.notSendingMessage, "QQ"));

                case 3:     //stop_recv
                    foreach (Chat i in Config.TGrecv)
                    {
                        if (i.Id == msg.Chat.Id)
                        {
                            Config.TGrecv.Remove(i);
                            return(string.Format(Config.stopRecvMessage, "QQ"));
                        }
                    }
                    return(string.Format(Config.notRecvingMessage, "QQ"));

                case 4:     //send
                    try {
                        foreach (var i in Config.CQrecv)
                        {
                            Config.CoolQClient.SendTextAsync(i.Item1, i.Item2, $"[{NicknameLookup.GetTGNickname(msg.From)}] {msg.Text.Substring(6)}");
                        }
                    } catch (IndexOutOfRangeException) {
                        return(Config.forceForwardFaliure);
                    }
                    return(Config.forceForwardSuccess);

                case 5:     //setnick
                    if (command.parameters.Count != 2)
                    {
                        return(Config.setNickFormatError);
                    }
                    NicknameLookup.SetCQNickname(command.parameters[0], command.parameters[1]);
                    //throw new NotImplementedException();
                    return(Config.setNickSuccess);
                }
            } catch (CommandErrorException) {
            }
            foreach (Chat i in Config.TGsend)
            {
                if (msg.Chat.Id == i.Id)
                {
                    isInList = true;
                    break;
                }
            }
            if (!isInList)
            {
                return("");
            }
            string message_send = $"[{NicknameLookup.GetTGNickname(msg.From)}] {msg.Text}";

            foreach (var i in Config.CQrecv)
            {
                Config.CoolQClient.SendTextAsync(i.Item1, i.Item2, message_send);
            }
            return("");
        }