Exemple #1
0
        private async void BW_TelegramLoop(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker tbw = sender as BackgroundWorker;
            var key = e.Argument as string;

            try
            {
                var bot = new Telegram.Bot.TelegramBotClient(key);
                await bot.SetWebhookAsync("");

                int offset = 0;

                while (true)
                {
                    var updates = await bot.GetUpdatesAsync(offset);

                    foreach (var update in updates)
                    {
                        bool res = await ProcessTelegramUpdate(bot, update);

                        offset = update.Id + 1;
                    }

                    System.Threading.Thread.Sleep(1000);    // to avoid CPU load
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Error {ex.Message}");
                SetStatus("Работа остановлена по ошибке");
            }
        }
Exemple #2
0
        async void BotInit()
        {
            await _bot.SetWebhookAsync("");

            _bot.OnUpdate += async(object su, Telegram.Bot.Args.UpdateEventArgs evu) =>
            {
                if (evu.Update.CallbackQuery != null || evu.Update.InlineQuery != null)
                {
                    return;
                }
                var update  = evu.Update;
                var message = update.Message;
                if (message == null)
                {
                    return;
                }
                if (message.Type == Telegram.Bot.Types.Enums.MessageType.TextMessage)
                {
                    HandleCommand(message.Text, message.Chat.Id, message.MessageId);
                }
            };

            _bot.OnCallbackQuery += async(object sc, Telegram.Bot.Args.CallbackQueryEventArgs ev) =>
            {
                var message = ev.CallbackQuery.Message;
                HandleCallback(ev.CallbackQuery.Data, message.Chat.Id, message.MessageId);
                await _bot.AnswerCallbackQueryAsync(ev.CallbackQuery.Id); // отсылаем пустое, чтобы убрать "частики" на кнопке
            };
            _bot.StartReceiving();
        }
Exemple #3
0
        /// <summary>
        /// Main loop of processing messages
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void TgBotWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            try
            {
                var bgWorker = sender as BackgroundWorker;
                var bot      = new Telegram.Bot.TelegramBotClient(this.ApiKey);
                // clear webhook field
                await bot.SetWebhookAsync("");

                int offset = 0;         //TODO: need read from file or database

                while (true)
                {
                    var updates = await bot.GetUpdatesAsync(offset, allowedUpdates : new UpdateType[] { UpdateType.MessageUpdate });

                    foreach (var update in updates)
                    {
                        var resProc = await ProcessTgUpdate(bot, update);

                        offset = update.Id + 1;
                    }

                    System.Threading.Thread.Sleep(1000);
                    if (bgWorker?.CancellationPending ?? false)
                    {
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                Log($"Exeption = {ex.ToString()}");
            }
        }
Exemple #4
0
        protected void Application_Start()
        {
            GlobalConfiguration.Configure(WebApiConfig.Register);


            Telegram.Bot.TelegramBotClient bot = new Telegram.Bot.TelegramBotClient("438518161:AAG5xVKFbV4uLf_6CtbyocQhbBv7hHLyL5A");
            bot.SetWebhookAsync("https://f5dbfba1.ngrok.io/api/webhook").Wait();
        }
Exemple #5
0
        async void button1Click(Object sender, EventArgs e)
        {
            var Bot = new Telegram.Bot.TelegramBotClient("400994008:AAF_AngoYyaakmuAhsv63kSR_fXkO6NA8ek"); // инициализируем API
            await Bot.SetWebhookAsync("");

            //Bot.SetWebhook(""); // Обязательно! убираем старую привязку к вебхуку для бота
            await Bot.SendTextMessageAsync(chatID, "Менты!! Мы закроемся не на долго🚔(Ведутся тех.работы)");

            Application.Exit();
        }
Exemple #6
0
        protected async void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            RouteConfig.RegisterRoutes(RouteTable.Routes);

            Answer.DictionaryInitialization();

            Bot = new Telegram.Bot.TelegramBotClient(key);
            await Bot.SetWebhookAsync("https://pyzhchordsbot.azurewebsites.net/api/message/update");
        }
Exemple #7
0
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);

            Telegram.Bot.TelegramBotClient bot = new Telegram.Bot.TelegramBotClient(Variables.Api);
            //bot.DeleteWebhookAsync();
            bot.SetWebhookAsync("https://tahaelectric.com/Tbot");
            // bot.SendTextMessageAsync(75094324, "Bot Ran");
        }
        protected async void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            RouteConfig.RegisterRoutes(RouteTable.Routes);

            Bot = new Telegram.Bot.TelegramBotClient(key);
            await Bot.SetWebhookAsync("https://pricebot2018.azurewebsites.net:443/api/message/update");

            await Bot.SendTextMessageAsync(ChatId, "START");

            while (true)
            {
                await Run(0);
            }
        }
Exemple #9
0
        public async Task <IActionResult> SetHook()
        {
            var urlBase = $"{this.Request.Scheme}://{this.Request.Host}";
            var urlHook = Url.Action("Hook");
            var fullUrl = new Uri(new Uri(urlBase), urlHook);

            var token = configuration.GetValue <string>("TelegramToken");

            var client = new Telegram.Bot.TelegramBotClient(token, httpClient);
            await client.SetWebhookAsync(fullUrl.ToString(), allowedUpdates : new List <UpdateType>
            {
                UpdateType.Message,
                UpdateType.ChannelPost
            });

            return(RedirectToAction("Index"));
        }
Exemple #10
0
        static void Main(string[] args)
        {
            Console.WriteLine("# Welcome to bot settings");
            Console.Write("# Please provider your token (or press enter): ");
            var token = Console.ReadLine();

            if (string.IsNullOrEmpty(token))
            {
                token = ConfigurationManager.AppSettings["token"];
                Console.WriteLine($"# Token from config file: {token}");
            }
            var client = new Telegram.Bot.TelegramBotClient(token);
            var task   = client.GetMeAsync();

            task.Wait();
            if (task.IsCompleted)
            {
                var user = task.Result;
                Console.WriteLine($"{user.FirstName} {user.LastName} is greeting you here!");
            }

            try
            {
                var stream = new FileStream("C:\\Users\\tsmirnov\\ssl\\fpublic.pem", FileMode.Open);

                var cert = new FileToSend()
                {
                    Content  = stream,
                    Filename = "felix"
                };
                client.SetWebhookAsync("https://cloundwin.westeurope.cloudapp.azure.com/api/webhooks/update", cert).Wait();
                client.StartReceiving();

                var message = new Message()
                {
                };
            }
            catch (Exception e)
            {
                throw;
            }
        }
Exemple #11
0
        protected async void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            RouteConfig.RegisterRoutes(RouteTable.Routes);

            Bot = new Telegram.Bot.TelegramBotClient(key);
            await Bot.SetWebhookAsync("https://cryptocurencybot.azurewebsites.net");

            var nn = await Bot.SendTextMessageAsync(ChatId, "START");

            while (true)
            {
                try
                {
                    await Run(0);
                }
                catch (Exception ex)
                {
                    Thread.Sleep(5000);
                }
            }
        }
Exemple #12
0
        async void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            var worker = sender as BackgroundWorker;
            var key    = e.Argument as String; // получаем ключ аргументов

            try
            {
                var Bot = new Telegram.Bot.TelegramBotClient(key); // инициализируем API
                await Bot.SetWebhookAsync("");                     //Bot.SetWebhook(""); // Обязательно! убираем старую привязку к вебхуку для бота

                int offset = 0;                                    // отступ по сообщениям
                while (true)
                {
                    var newUpdates = await Bot.GetUpdatesAsync(offset); // получаем массив обновлений

                    var updates = newUpdates.Distinct().ToArray();      // убираем повторения из списка новых запросов
                    foreach (var update in updates)                     // Перебираем все обновления
                    {
                        var message = update.Message;
                        if (message.Type == Telegram.Bot.Types.Enums.MessageType.Text)
                        {
                            if (message.Text == "/getimage" || message.Text == "/getimage@...") //После @ - пишем ссылку на вашего бота!!! Это нужно для исп бота в конфах!!!
                            {
                                ImgurPars imgurPars = new ImgurPars();
                                // в ответ на команду /getimage выводим картинку
                                await Bot.SendPhotoAsync(message.Chat.Id, imgurPars.GeneratePictur());
                            }
                        }
                        offset = update.Id + 1;
                    }
                }
            }
            catch (Telegram.Bot.Exceptions.ApiRequestException ex)
            {
                Console.WriteLine(ex.Message); // если ключ не подошел - пишем об этом в консоль отладки
            }
        }
Exemple #13
0
        static async void DoWork()
        {
            var Bot = new Telegram.Bot.TelegramBotClient("412328897:AAFFYLJ8W1JjRrY5oQk3dwlNE_O4qLynZhA");
            await Bot.SetWebhookAsync("");

            Bot.OnUpdate += async(object su, Telegram.Bot.Args.UpdateEventArgs evu) =>
            {
                if (evu.Update.CallbackQuery != null || evu.Update.InlineQuery != null)
                {
                    return;
                }
                var update  = evu.Update;
                var message = update.Message;
                if (message == null)
                {
                    return;
                }
                if (message.Type == Telegram.Bot.Types.Enums.MessageType.TextMessage)
                {
                    if (message.Text.ToLower() == "/start")
                    {
                        await Bot.SendTextMessageAsync(message.Chat.Id, "Здравствуйте, что вам от меня надо?", Telegram.Bot.Types.Enums.ParseMode.Default, false, false, 0, Keyboard());
                    }
                }
            };

            Bot.OnCallbackQuery += async(object sc, Telegram.Bot.Args.CallbackQueryEventArgs ev) =>
            {
                var message = ev.CallbackQuery.Message;
                if (ev.CallbackQuery.Data == "a")
                {
                    await Bot.SendTextMessageAsync(message.Chat.Id, @"@dvachannel
@mudak
@ftp_dank_memes
@LaQeque
@ruOvsyanochan
@mudaks
                               ");
                }
                else

                if (ev.CallbackQuery.Data == "r")
                {
                    await Bot.SendContactAsync(message.Chat.Id, "+79601206458", "Ostap", "Kit");
                }
                else
                if (ev.CallbackQuery.Data == "b")
                {
                    await Bot.SendTextMessageAsync(message.Chat.Id, "@meduzalive");
                }
                else
                if (ev.CallbackQuery.Data == "d")
                {
                    await Bot.SendTextMessageAsync(message.Chat.Id, "@sticker");
                }

                string[] represent = { "Мож ещё чего?", "Ещё чего надо?", "Что-нибудь ещё?", "Ещё что-нибудь?", "Что то ещё?", "Мож ещё чего ?" };

                await Bot.SendTextMessageAsync(message.Chat.Id, represent[new Random().Next(0, 6)], Telegram.Bot.Types.Enums.ParseMode.Default, false, false, 0, Keyboard());
            };

            Bot.StartReceiving();
        }
Exemple #14
0
        async void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            var worker = sender as BackgroundWorker;
            var key    = e.Argument as String; // получаем ключ из аргументов

            try
            {
                var Bot = new Telegram.Bot.TelegramBotClient(key); // инициализируем API

                try
                {
                    await Bot.SetWebhookAsync(""); // !!!!!!!!!!!!!!!!!!!!!!ЦИКЛ ПЕРЕЗАПУСКА
                }
                catch
                {
                    await Bot.SetWebhookAsync("");
                }


                // Inlin'ы
                Bot.OnInlineQuery += async(object si, Telegram.Bot.Args.InlineQueryEventArgs ei) =>
                {
                    var query = ei.InlineQuery.Query;
                };

                Bot.OnCallbackQuery += async(object sc, Telegram.Bot.Args.CallbackQueryEventArgs ev) =>
                {
                    var message = ev.CallbackQuery.Message;
                    if (ev.CallbackQuery.Data == "CallDaily")
                    {
                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                        await Bot.SendTextMessageAsync(message.Chat.Id, "CallDaily", ParseMode.Html, false, false, 0, null);
                    }

                    if (ev.CallbackQuery.Data == "PutDaily")
                    {
                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                        await Bot.SendTextMessageAsync(message.Chat.Id, "PutDaily", ParseMode.Html, false, false, 0, null);
                    }

                    if (ev.CallbackQuery.Data == "Call6Hr")
                    {
                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                        await Bot.SendTextMessageAsync(message.Chat.Id, "Call6Hr", ParseMode.Html, false, false, 0, null);
                    }

                    if (ev.CallbackQuery.Data == "Put6Hr")
                    {
                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                        await Bot.SendTextMessageAsync(message.Chat.Id, "Put6Hr", ParseMode.Html, false, false, 0, null);
                    }
                };

                Bot.OnUpdate += async(object su, Telegram.Bot.Args.UpdateEventArgs evu) =>
                {
                    try
                    {
                        var update  = evu.Update;
                        var message = update.Message;
                        if (message == null)
                        {
                            return;
                        }



                        if (message.Type == Telegram.Bot.Types.Enums.MessageType.Text)
                        {
                            for (; ;)
                            {
                                TronScan.tronscan();
                                for (int i = 0; i < TronScan.message.Count; i++)
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id = 460657014, TronScan.message[i], ParseMode.Html, false, false, 0, null);
                                }
                                Thread.Sleep(60000);
                            }



                            if (message.Text == "/price_option@TestTestTestTestTest111_bot")
                            {
                                try
                                {
                                    var inlineMainKeyboard = new InlineKeyboardMarkup(new[]
                                    {
                                        new []
                                        {
                                            new InlineKeyboardButton  {
                                                Text = "Call Daily Options ", CallbackData = "CallDaily"
                                            },

                                            new   InlineKeyboardButton {
                                                Text = "Put Daily Options ", CallbackData = "PutDaily"
                                            }
                                        },
                                        new []
                                        {
                                            new InlineKeyboardButton  {
                                                Text = "Call 6Hr Daily Options ", CallbackData = "Call6Hr"
                                            },

                                            new   InlineKeyboardButton {
                                                Text = "Put 6Hr Daily Options ", CallbackData = "Put6Hr"
                                            }
                                        }
                                    });


                                    string Current_price, Exercise_Price, Change, Potential, Contracts;
                                    await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                    await Bot.SendTextMessageAsync(message.Chat.Id, "<b>Цена на опционы!</b>", ParseMode.Html, false, false, 0, inlineMainKeyboard);
                                }
                                catch
                                {
                                }
                            }
                        }



                        if (message.Type == MessageType.ChatMemberLeft)
                        {
                            try
                            {
                                await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);
                            }
                            catch
                            {
                            }
                            return;
                        }
                        if (Data.HI == 1 & message.Type == MessageType.ChatMembersAdded)
                        {
                            try
                            {
                                await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);
                            }
                            catch
                            {
                            }
                            return;
                        }
                        if (message.Text == "/stop_hello_func@TestTestTestTestTest111_bot")
                        {
                            try
                            {
                                Data.HI = 1;
                            }


                            catch
                            {
                            }
                        }
                        if (message.Text == "/start_hello_func@TestTestTestTestTest111_bot")
                        {
                            try
                            {
                                Data.HI = 0;
                            }


                            catch
                            {
                            }
                        }

                        if (Data.HI == 0 & message.Type == MessageType.ChatMembersAdded)
                        {
                            try
                            {
                                var inlineKeyboardMarkup = new InlineKeyboardMarkup(new[]
                                {
                                    new  [] { new InlineKeyboardButton {
                                                  Text = "Скачать мобильное приложение!", CallbackData = "demo", Url = "https://medium.com/@abcc.com/our-mobile-app-is-ready-41fdd6663869 "
                                              } }
                                });
                                if (Hi.one == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string one = update.Message.From.Username;
                                        Hi.one = "@" + one;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string one = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.one = one;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }

                                if (Hi.two == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string two = update.Message.From.Username;
                                        Hi.two = "@" + two;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string two = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.two = two;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.three == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string three = update.Message.From.Username;
                                        Hi.three = "@" + three;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string three = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.three = three;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.four == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string four = update.Message.From.Username;
                                        Hi.four = "@" + four;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string four = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.four = four;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.five == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string five = update.Message.From.Username;
                                        Hi.five = "@" + five;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string five = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.five = five;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.six == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string six = update.Message.From.Username;
                                        Hi.six = "@" + six;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string six = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.six = six;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.seven == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string seven = update.Message.From.Username;
                                        Hi.seven = "@" + seven;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string seven = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.seven = seven;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.eight == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string eight = update.Message.From.Username;
                                        Hi.eight = "@" + eight;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string eight = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.eight = eight;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.nine == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string nine = update.Message.From.Username;
                                        Hi.nine = "@" + nine;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string nine = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.nine = nine;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.ten == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string ten = update.Message.From.Username;
                                        Hi.ten = "@" + ten;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string ten = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.ten = ten;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.H11 == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string H11 = update.Message.From.Username;
                                        Hi.H11 = "@" + H11;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string H11 = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.H11 = H11;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.H12 == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string H12 = update.Message.From.Username;
                                        Hi.H12 = "@" + H12;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string H12 = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.H12 = H12;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.H13 == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string H13 = update.Message.From.Username;
                                        Hi.H13 = "@" + H13;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string H13 = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.H13 = H13;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.H14 == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string H14 = update.Message.From.Username;
                                        Hi.H14 = "@" + H14;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string H14 = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.H14 = H14;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.H15 == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string H15 = update.Message.From.Username;
                                        Hi.H15 = "@" + H15;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string H15 = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.H15 = H15;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.H16 == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string H16 = update.Message.From.Username;
                                        Hi.H16 = "@" + H16;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string H16 = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.H16 = H16;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.H17 == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string H17 = update.Message.From.Username;
                                        Hi.H17 = "@" + H17;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string H17 = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.H17 = H17;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.H17 == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string H17 = update.Message.From.Username;
                                        Hi.H17 = "@" + H17;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string H17 = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.H17 = H17;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.H18 == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string H18 = update.Message.From.Username;
                                        Hi.H18 = "@" + H18;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string H18 = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.H18 = H18;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.H19 == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string H19 = update.Message.From.Username;
                                        Hi.H19 = "@" + H19;

                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    else
                                    {
                                        string H19 = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.H19 = H19;

                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                }
                                if (Hi.H20 == null)
                                {
                                    if (update.Message.From.Username != null)
                                    {
                                        string H20 = update.Message.From.Username;
                                        Hi.H20 = "@" + H20;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        await Bot.SendTextMessageAsync(message.Chat.Id, $"{Hi.one + ", " + Hi.two + ", " + Hi.three + ", " + Hi.four + ", " + Hi.five + ", " + Hi.six + ", " + Hi.seven + ", " + Hi.eight + ", " + Hi.nine + ", " + Hi.ten + ", " + Hi.H11 + ", " + Hi.H12 + ", " + Hi.H13 + ", " + Hi.H14 + ", " + Hi.H15 + ", " + Hi.H16 + ", " + Hi.H17 + ", " + Hi.H18 + ", " + Hi.H19 + ", " + Hi.H20  } \n<b>Добро пожаловать в наш уютный чат ABCC СНГ \nМы всегда рады тебе в нашем чате!😉\n" + "Воспользуйся нашим ботом</b> @TestTestTestTestTest111_bot <b>с множеством полезных команд!\n</b><b>Последний блок</b> /last_block@TestTestTestTestTest111_bot \n<b>Цена АТ</b> /at_usdt@TestTestTestTestTest111_bot \n<b>Цена BTC</b> /btc_usdt@TestTestTestTestTest111_bot \n<b>Цена ETH</b> /eth_usdt@TestTestTestTestTest111_bot \n<b>А также множество других команд! Нажми / и действуй!</b> \n<b>Обучающий ролик!</b>" + "\n" + @" <a href=""https://www.youtube.com/watch?v=shzrEeLKZWU"">📈📈📈</a>", ParseMode.Html, false, false, 0, inlineKeyboardMarkup);

                                        //https://www.youtube.com/watch?v=shzrEeLKZWU&t=1s
                                        Hi.one   = null;
                                        Hi.two   = null;
                                        Hi.three = null;
                                        Hi.four  = null;
                                        Hi.five  = null;
                                        Hi.six   = null;
                                        Hi.seven = null;
                                        Hi.eight = null;
                                        Hi.nine  = null;
                                        Hi.ten   = null;
                                        Hi.H11   = null;
                                        Hi.H12   = null;
                                        Hi.H13   = null;
                                        Hi.H14   = null;
                                        Hi.H15   = null;
                                        Hi.H16   = null;
                                        Hi.H17   = null;
                                        Hi.H18   = null;
                                        Hi.H19   = null;
                                        Hi.H20   = null;

                                        return;
                                    }
                                    else
                                    {
                                        string H20 = update.Message.From.FirstName + " " + update.Message.From.LastName;
                                        Hi.H20 = H20;
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        await Bot.SendTextMessageAsync(message.Chat.Id, $"{Hi.one + ", " + Hi.two + ", " + Hi.three + ", " + Hi.four + ", " + Hi.five + ", " + Hi.six + ", " + Hi.seven + ", " + Hi.eight + ", " + Hi.nine + ", " + Hi.ten + ", " + Hi.H11 + ", " + Hi.H12 + ", " + Hi.H13 + ", " + Hi.H14 + ", " + Hi.H15 + ", " + Hi.H16 + ", " + Hi.H17 + ", " + Hi.H18 + ", " + Hi.H19 + ", " + Hi.H20  } \n<b>Добро пожаловать в наш уютный чат ABCC СНГ \nМы всегда рады тебе в нашем чате!😉\n" + "Воспользуйся нашим ботом</b> @TestTestTestTestTest111_bot <b>с множеством полезных команд!\n</b><b>Последний блок</b> /last_block@TestTestTestTestTest111_bot \n<b>Цена АТ</b> /at_usdt@TestTestTestTestTest111_bot \n<b>Цена BTC</b> /btc_usdt@TestTestTestTestTest111_bot \n<b>Цена ETH</b> /eth_usdt@TestTestTestTestTest111_bot \n<b>А также множество других команд! Нажми / и действуй!</b> \n<b>Обучающий ролик!</b>" + "\n" + @" <a href=""https://www.youtube.com/watch?v=shzrEeLKZWU"">!</a>", ParseMode.Html, false, false, 0, inlineKeyboardMarkup);

                                        Hi.one   = null;
                                        Hi.two   = null;
                                        Hi.three = null;
                                        Hi.four  = null;
                                        Hi.five  = null;
                                        Hi.six   = null;
                                        Hi.seven = null;
                                        Hi.eight = null;
                                        Hi.nine  = null;
                                        Hi.ten   = null;
                                        Hi.H11   = null;
                                        Hi.H12   = null;
                                        Hi.H13   = null;
                                        Hi.H14   = null;
                                        Hi.H15   = null;
                                        Hi.H16   = null;
                                        Hi.H17   = null;
                                        Hi.H18   = null;
                                        Hi.H19   = null;
                                        Hi.H20   = null;

                                        return;
                                    }
                                }
                                return;
                            }
                            catch
                            {
                            }
                        }

                        var entities = message.Entities.Where(t => t.Type == MessageEntityType.Url ||
                                                              t.Type == MessageEntityType.Mention);
                        foreach (var entity in entities)
                        {
                            if (entity.Type == MessageEntityType.Url)
                            {
                                try
                                {
                                    //40103694 - @off_fov
                                    //571522545 -  @ProAggressive
                                    //320968789 - @timcheg1
                                    //273228404 - @hydranik
                                    //435567580 - Никита
                                    //352345393 - @i_am_zaytsev
                                    //430153320 - @KingOfMlnD
                                    //579784 - @kamiyar
                                    //536915847 - @m1Bean
                                    //460657014 - @DenisSenatorov

                                    if (message.From.Username == @"off_fov" || message.From.Username == @"LindaMao" || message.From.Username == @"XiniW" || message.From.Username == @"ProAggressive" || message.From.Username == @"timcheg1" || message.From.Username == @"hydranik" || message.From.Username == @"i_am_zaytsev" || message.From.Username == @"KingOfMlnD" || message.From.Username == @"kamiyar" || message.From.Username == @"m1Bean" || message.From.Username == @"DenisSenatorov" || message.From.Id == 435567580)
                                    {
                                        return;
                                    }
                                    else
                                    {
                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        if (update.Message.From.Username != null)
                                        {
                                            await Bot.SendTextMessageAsync(message.Chat.Id, "@" + message.From.Username + ", Ссылки запрещены!");

                                            return;
                                        }
                                        else
                                        {
                                            await Bot.SendTextMessageAsync(message.Chat.Id, message.From.FirstName + ", Ссылки запрещены!");

                                            return;
                                        }
                                    }
                                }
                                catch
                                {
                                }
                                return;
                            }
                        }
                    }
                    catch
                    {
                    }
                };

                Bot.StartReceiving();

                // запускаем прием обновлений
            }

            catch (Telegram.Bot.Exceptions.ApiRequestException ex)
            {
                Console.WriteLine(ex.Message); // если ключ не подошел - пишем об этом в консоль отладки
            }
        }
Exemple #15
0
        async void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            var worker = sender as BackgroundWorker;
            var key    = e.Argument as String; // получаем ключ из аргументов

            try
            {
                var Bot = new Telegram.Bot.TelegramBotClient(key); // инициализируем API
                await Bot.SetWebhookAsync("");                     // Обязательно! убираем старую привязку к вебхуку для бота

                //TEST

                try
                {
                    Bot.OnUpdate += async(object su, Telegram.Bot.Args.UpdateEventArgs evu) =>
                    {
                        if (evu.Update.CallbackQuery != null || evu.Update.InlineQuery != null)
                        {
                            return;                                                                     // в этом блоке нам келлбэки и инлайны не нужны
                        }
                        var update  = evu.Update;
                        var message = update.Message;

                        string txt = Properties.Settings.Default.solo;
                        if (message == null)
                        {
                            return;
                        }

                        if (message.Type == Telegram.Bot.Types.Enums.MessageType.Text)
                        {
                            var chtid    = message.Chat.Id;
                            int chtidi   = (int)chtid;
                            var username = message.From.Username;
                            var name     = message.From.FirstName;
                            var surname  = message.From.LastName;
                            var chatname = message.Chat.Title;

                            InputOnlineFile vzhuh     = new InputOnlineFile("CAADAgADKwADCpgGDM8eYp6xnBJwAg");
                            InputOnlineFile stick     = new InputOnlineFile("CAADAgADjAAD2kJgEdHmJbf9LcNAAg");
                            InputOnlineFile kickstick = new InputOnlineFile("CAADAgADFwADCpgGDPT5dlQ90N3vAg");
                            InputOnlineFile gogo      = new InputOnlineFile("CAADAgADIgADCpgGDP2DujSOYxb2Ag");
                            InputOnlineFile stb_1     = new InputOnlineFile("CAADAgADKAADCpgGDAlPwj3jog11Ag");
                            InputOnlineFile pipi      = new InputOnlineFile("MEDIA/bolt.jpg");
                            string          offlist   = System.IO.File.ReadAllText("offlist.txt");



                            try
                            {
                                if (message.Text.ToLower().Equals("987"))
                                {
                                    string tempz = Properties.Settings.Default.SettingsKey;
                                    await Bot.SendTextMessageAsync(message.Chat.Id, tempz);

                                    return;
                                }
                                //ВЫЗОВ ИЗ ЧАТА


                                if (message.Text.ToLower().Contains("ридонли"))
                                {
                                    int iserid = message.ReplyToMessage.From.Id;
                                    //string usrid = iserid.ToString();

                                    if (offlist.Contains(username))
                                    {
                                        var      RoS        = message.Text.ToString();
                                        Regex    my_reg     = new Regex(@"\D");
                                        string   out_string = my_reg.Replace(RoS, "");
                                        int      RoTime     = Convert.ToInt32(out_string);
                                        DateTime untilDate  = DateTime.Now.AddMinutes(RoTime);
                                        await Bot.RestrictChatMemberAsync(message.Chat.Id, iserid, untilDate);

                                        await Bot.SendStickerAsync(message.Chat.Id, vzhuh);

                                        await Bot.SendTextMessageAsync(message.Chat.Id, message.ReplyToMessage.From.FirstName + ", поздравляю!  В качестве бонуса, ты получаешь РО на " + RoTime.ToString() + " минут.", replyToMessageId : message.ReplyToMessage.MessageId);

                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    if (message.From.Id == iserid)
                                    {
                                        var      RoS        = message.Text.ToString();
                                        Regex    my_reg     = new Regex(@"\D");
                                        string   out_string = my_reg.Replace(RoS, "");
                                        int      RoTime     = Convert.ToInt32(out_string);
                                        DateTime untilDate  = DateTime.Now.AddMinutes(RoTime);
                                        await Bot.RestrictChatMemberAsync(message.Chat.Id, iserid, untilDate);

                                        await Bot.SendStickerAsync(message.Chat.Id, vzhuh);

                                        await Bot.SendTextMessageAsync(message.Chat.Id, message.ReplyToMessage.From.FirstName + ", очень жаль, но это было твое решение :(  Ты получаешь РО на " + RoTime.ToString() + " минут.", replyToMessageId : message.ReplyToMessage.MessageId);

                                        await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);

                                        return;
                                    }
                                    return;
                                }

                                //ДЛЯ ЕВЫ
                                if (message.Text.Contains("Ева, "))
                                {
                                    //В чате Кантины
                                    if (message.Chat.Id.Equals(-1001033483774))
                                    {
                                        List <string> lstT  = new List <string>();
                                        Random        randT = new Random();
                                        var           inxT  = System.IO.File.ReadAllLines(tost);
                                        string[]      str   = new string[1]; // здесь будут храниться n случаные неповторяющиеся строки из inxT
                                        int           k;

                                        for (int i = 0; i < str.Length; i++)
                                        {
                                            while (true)
                                            {
                                                k = randT.Next(inxT.Length);

                                                if (!lstT.Any(x => x.Equals(inxT[k])))
                                                {
                                                    lstT.Add(inxT[k]);

                                                    str[i] = inxT[k];

                                                    break;
                                                }
                                            }
                                        }
                                        //await Bot.SendTextMessageAsync(message.Chat.Id, "Тут этого делать нельзя.");
                                        string lls = string.Join("\r\n", lstT.ToArray());
                                        await Bot.SendTextMessageAsync(message.Chat.Id, "Я просто скажу тост:" + "\r\n" + lls);

                                        return;
                                    }

                                    //Во всех остальных чатах
                                    else
                                    {
                                        string inmess = message.Text.ToLower();
                                        //TEST CHAT ID
                                        System.IO.File.AppendAllText(all_msg, DateTime.Now + " " + chatname + " " + username + " " + name + " " + surname + "\r\n" + message.Text + "\r\n");
                                        string[] readText = System.IO.File.ReadAllLines(logs_path, Encoding.Default);

                                        if (inmess.Contains("hooba") && username.Equals("kanier"))
                                        {
                                            //string last_ten = System.IO.File.ReadAllText("123.txt");
                                            //string n = readText[i];
                                            await Bot.SendTextMessageAsync(message.Chat.Id, System.IO.File.ReadAllText("LOGS/123.txt"));

                                            return;
                                        }
                                        if (inmess.Contains("покажи всё") && username.Equals("kanier"))
                                        {
                                            //string last_ten = System.IO.File.ReadAllText("123.txt");
                                            //string n = readText[i];
                                            await Bot.SendTextMessageAsync(message.Chat.Id, System.IO.File.ReadAllText(logs_path));

                                            return;
                                        }
                                        if (inmess.Contains("срейд"))
                                        {
                                            string srtext = System.IO.File.ReadAllText(sreid_path);
                                            //await Bot.SendTextMessageAsync(message.Chat.Id, "[Тестовая ссылка из бота](https://t.me/iv?url=https%3A%2F%2Fyavin4.ru%2Fother%2Fthe-sith-triumvirate%2F&rhash=a6a7d09d8d0768)");
                                            await Bot.SendTextMessageAsync(message.Chat.Id, "Я просто оставлю это здесь...\n" + srtext);

                                            return;
                                        }
                                        if (inmess.Contains("взвод"))
                                        {
                                            await Bot.SendTextMessageAsync(message.Chat.Id, "https://yavin4.ru/other/tb-platoons/" + "\r\n" + "^^^^^^^^^^^^^^^^^^^^^^^^" + "\r\n" + "https://t.me/iv?url=https://yavin4.ru/other/tb-platoons/&rhash=a6a7d09d8d0768");

                                            return;
                                        }

                                        if (inmess.Contains("экстерминатус") && username.Equals("kanier") || inmess.Contains("экстерминатус") && username.Equals("vlad_o_v"))
                                        {
                                            InputOnlineFile stream = new InputOnlineFile("MEDIA/flu.mp4");
                                            //InputOnlineFile  fts = new InputOnlineFile(stream);

                                            //Stream stream_flu = null;
                                            //fts.Content = stream;
                                            stream.FileName = "FLU";

                                            //ТЕСТОВЫЙ КУСОК
                                            DateTime old_ticker_dt = Properties.Settings.Default.ticker_start;
                                            DateTime now_ticker_dt = DateTime.Now;
                                            TimeSpan alltime       = Properties.Settings.Default.best_try;
                                            TimeSpan nowalltime    = now_ticker_dt - old_ticker_dt;
                                            if (nowalltime > alltime)
                                            {
                                                Properties.Settings.Default.best_try = nowalltime;
                                                Properties.Settings.Default.Save();
                                            }
                                            else
                                            {
                                                Properties.Settings.Default.best_try = alltime;
                                                Properties.Settings.Default.Save();
                                            }


                                            ///Запомнить===>>//DateTime rec_time = Properties.Settings.Default.ticker_start;
                                            DateTime ticker = DateTime.Now;
                                            Properties.Settings.Default.ticker_start = ticker;
                                            Properties.Settings.Default.Save();
                                            string txt_ticker = ticker.ToString();
                                            //await Bot.SendTextMessageAsync(message.Chat.Id, "Мне очень печально это говорить но, ПРИНЕСИТЕ FLUGGEGECHEIMEN!!!", replyToMessageId: message.MessageId);
                                            //await Bot.SendDocumentAsync(message.Chat.Id, stream, "Мне очень печально это говорить но, ПРИНЕСИТЕ FLUGGEGECHEIMEN!!!");
                                            await Bot.SendVideoAsync(message.Chat.Id, stream);

                                            return;
                                        }
                                        if (inmess.Contains("счетчик") || inmess.Contains("счётчик"))
                                        {
                                            string   old_ticker    = Properties.Settings.Default.ticker_start.ToString();
                                            DateTime old_ticker_dt = Properties.Settings.Default.ticker_start;
                                            DateTime now_ticker_dt = DateTime.Now;
                                            TimeSpan alltime       = now_ticker_dt - old_ticker_dt;
                                            //Properties.Settings.Default.best_try = alltime;
                                            //string final_count_full = alltime.ToString();
                                            //string final_count_short = final_count_full.Substring(0, final_count_full.LastIndexOf("."));
                                            //string final_count_wo_days = alltime.ToString("DD:MM:SS");
                                            //await Bot.SendTextMessageAsync(message.Chat.Id, "Новый отсчёт был запущен: " + old_ticker);
                                            await Bot.SendTextMessageAsync(message.Chat.Id, "На Явине всё спокойно уже: " + string.Format("\nДней: {0:%d} \nЧасов: {0:%h} \nМинут: {0:%m} \nСекунд: {0:%s}", alltime) + "\nОтсчёт был запущен: " + old_ticker);

                                            string for_lbl = "На Явине всё спокойно уже: " + string.Format("\nДней: {0:%d} \nЧасов: {0:%h} \nМинут: {0:%m} \nСекунд: {0:%s}", alltime) + "\nОтсчёт был запущен: " + old_ticker;
                                            Properties.Settings.Default.out_txt = for_lbl;
                                            Properties.Settings.Default.Save();
                                            TimeSpan best_try = Properties.Settings.Default.best_try;
                                            await Bot.SendTextMessageAsync(message.Chat.Id, string.Format("Лучшее время: Дней: {0:%d} Часов: {0:%h} Минут: {0:%m} Секунд: {0:%s}", best_try));

                                            //await Bot.SendTextMessageAsync(message.Chat.Id, "Дней: " + final_count_short.Substring(0, final_count_short.LastIndexOf(".")));
                                            return;
                                        }
                                        if (inmess.Contains("обнули 900") && username.Equals("kanier"))
                                        {
                                            Properties.Settings.Default.best_try = new TimeSpan(0, 0, 0, 0);
                                            Properties.Settings.Default.Save();
                                            return;
                                        }

                                        if (inmess.Contains("пришло время"))
                                        {
                                            await Bot.SendStickerAsync(message.Chat.Id, kickstick);

                                            return;
                                        }


                                        if (inmess.Contains("chatid") && username.Equals("kanier"))
                                        {
                                            await Bot.SendTextMessageAsync(message.Chat.Id, chtid.ToString());

                                            return;
                                        }

                                        //TEST MESSAGE TO OTHER CHAT
                                        if (inmess.Contains("отправь") && offlist.Contains(username))
                                        {
                                            if (inmess.Contains("в кантину кота"))
                                            {
                                                await Bot.SendStickerAsync("-1001033483774", vzhuh);

                                                return;
                                            }
                                            if (inmess.Contains("стикер кик"))
                                            {
                                                await Bot.SendStickerAsync("-1001119850321", kickstick);

                                                return;
                                            }
                                            ////Properties.Settings.Default.buffer = inmess;
                                            //string sendinmess = inmess.Replace("Ева, ", "");
                                            //Properties.Settings.Default.buffer = sendinmess;
                                            //Properties.Settings.Default.Save();
                                            //string smess = Properties.Settings.Default.buffer;
                                            await Bot.SendTextMessageAsync("-1001119850321", message.Text.Replace("Ева, отправь ", ""));

                                            return;
                                        }
                                        //if (inmess.Contains("гого")&& offlist.Contains(username))
                                        //   {
                                        //       try
                                        //       {



                                        //           //await Bot.SendDocumentAsync("-1001119850321", fts, "Все на ТБ!!!");
                                        //           await Bot.SendStickerAsync("-1001119850321", gogo);
                                        //           await Bot.SendStickerAsync("-1001121566331 ", gogo);
                                        //           //            //await Bot.SendDocumentAsync(message.Chat.Id, new InputOnlineFile("GP.xlsx"));
                                        //           return;
                                        //       }
                                        //       catch (Exception ex)
                                        //       {
                                        //           System.IO.File.WriteAllText("LOGS/errorall.txt", ex.Message);
                                        //           //await Bot.SendTextMessageAsync(message.Chat.Id, "Что-то не так");
                                        //           return;

                                        //       }


                                        //   }
                                        if (inmess.Contains("привет") || inmess.Contains("как дела") || inmess.Contains("здрав"))
                                        {
                                            await Bot.SendTextMessageAsync(message.Chat.Id, "Привет, " + name + "." + "\r\n" + "Что ты хочешь знать?" + "\r\n" + "Я могу напомнить тебе правила Ямы или ААТ, показать список солистов или памятку по ТБ. Могу напомнить, кто закрывает соло следующую Яму-0. И многое другое ;) Достаточно обратиться ко мне по имени. К примеру: \"Ева, кто закрывает соло?\"", replyToMessageId : message.MessageId);

                                            return;
                                        }
                                        if (inmess.Contains("соло") || inmess.Contains("закрывает"))

                                        {
                                            if (offlist.Contains(username))
                                            {
                                                // в ответ на команду выводим сообщение
                                                await Bot.SendTextMessageAsync(message.Chat.Id, txt);

                                                return;
                                            }
                                            else
                                            {
                                                string ntxt  = Properties.Settings.Default.short_solo;
                                                string wotxt = ntxt.Replace("@", "");
                                                await Bot.SendTextMessageAsync(message.Chat.Id, "Для закрытия следующей Ямы-0, Колесом Фортуны избран " + wotxt + " !");

                                                return;
                                            }
                                        }

                                        //ТЕСТ РИДОНЛИ



                                        if (inmess.Contains("накати") || inmess.Contains("рря") || inmess.Contains("тост"))
                                        {
                                            List <string> lstT  = new List <string>();
                                            Random        randT = new Random();
                                            var           inxT  = System.IO.File.ReadAllLines(tost);
                                            string[]      str   = new string[1]; // здесь будут храниться n случаные неповторяющиеся строки из inxT
                                            int           k;

                                            for (int i = 0; i < str.Length; i++)
                                            {
                                                while (true)
                                                {
                                                    k = randT.Next(inxT.Length);

                                                    if (!lstT.Any(x => x.Equals(inxT[k])))
                                                    {
                                                        lstT.Add(inxT[k]);

                                                        str[i] = inxT[k];

                                                        break;
                                                    }
                                                }
                                            }

                                            string lls = string.Join("\r\n", lstT.ToArray());

                                            await Bot.SendTextMessageAsync(message.Chat.Id, lls);

                                            return;
                                        }

                                        if (inmess.Contains("стб"))
                                        {
                                            string          f1text  = System.IO.File.ReadAllText("TEXT/STB/f1.txt");
                                            string          f2text  = System.IO.File.ReadAllText("TEXT/STB/f2.txt");
                                            string          f3text  = System.IO.File.ReadAllText("TEXT/STB/f3.txt");
                                            string          f4text  = System.IO.File.ReadAllText("TEXT/STB/f4.txt");
                                            string          f5text  = System.IO.File.ReadAllText("TEXT/STB/f5.txt");
                                            string          f6text  = System.IO.File.ReadAllText("TEXT/STB/f6.txt");
                                            var             stream1 = System.IO.File.Open("MEDIA/STB.jpg", FileMode.Open);
                                            InputOnlineFile pipi1   = new InputOnlineFile(stream1)
                                            {
                                                //pipi1.ContentContent = stream1,
                                                //pipi1.FileName = "MEDIA/STB.jpg"
                                            };

                                            if (inmess.Contains("1"))
                                            {
                                                await Bot.SendPhotoAsync(message.Chat.Id, photo : pipi1);

                                                await Bot.SendTextMessageAsync(message.Chat.Id, f1text);

                                                return;
                                            }

                                            if (inmess.Contains("2"))
                                            {
                                                await Bot.SendPhotoAsync(message.Chat.Id, photo : pipi1);

                                                await Bot.SendTextMessageAsync(message.Chat.Id, f2text);

                                                return;
                                            }

                                            if (inmess.Contains("3"))
                                            {
                                                await Bot.SendPhotoAsync(message.Chat.Id, photo : pipi1);

                                                await Bot.SendTextMessageAsync(message.Chat.Id, f3text);

                                                return;
                                            }

                                            if (inmess.Contains("4"))
                                            {
                                                await Bot.SendPhotoAsync(message.Chat.Id, photo : pipi1);

                                                await Bot.SendTextMessageAsync(message.Chat.Id, f4text);

                                                return;
                                            }

                                            if (inmess.Contains("5"))
                                            {
                                                await Bot.SendPhotoAsync(message.Chat.Id, photo : pipi1);

                                                await Bot.SendTextMessageAsync(message.Chat.Id, f5text);

                                                return;
                                            }

                                            if (inmess.Contains("6"))
                                            {
                                                await Bot.SendPhotoAsync(message.Chat.Id, photo : pipi1);

                                                await Bot.SendTextMessageAsync(message.Chat.Id, f6text);

                                                return;
                                            }


                                            string tbfile = System.IO.File.ReadAllText("TEXT/STB/tb.txt");
                                            await Bot.SendTextMessageAsync(message.Chat.Id, tbfile);

                                            return;
                                        }
                                        if (inmess.Contains("ттб"))
                                        {
                                            await Bot.SendTextMessageAsync(message.Chat.Id, "К сожалению, мне пока ничего об этом не известно. Посмотрим, что там нахерачили ЕА.", replyToMessageId : message.MessageId);

                                            return;
                                        }
                                        if (inmess.Contains("прости") || inmess.Contains("извин"))
                                        {
                                            await Bot.SendTextMessageAsync(message.Chat.Id, "Ничего страшного! Но я это запомню...", replyToMessageId : message.MessageId);

                                            return;
                                        }
                                        if (inmess.Contains("ям") || inmess.Contains("ранкор"))
                                        {
                                            List <string> lstR = new List <string>();
                                            var           inxR = System.IO.File.ReadAllLines(rancor_path);
                                            string        llsR = string.Join("\r\n", inxR.ToArray());
                                            await Bot.SendTextMessageAsync(message.Chat.Id, "Я напомню тебе правила)))" + "\r\n" + llsR);

                                            return;
                                        }
                                        if (inmess.Contains("чудо") || inmess.Contains("хорошая") || inmess.Contains("умни") || inmess.Contains("умна") || inmess.Contains("крас"))
                                        {
                                            await Bot.SendTextMessageAsync(message.Chat.Id, "Спасибо, мне очень приятно!");

                                            return;
                                        }
                                        if (inmess.Contains("список"))
                                        {
                                            try
                                            {
                                                List <string> lstL   = new List <string>();
                                                string        lstall = System.IO.File.ReadAllText(solo_path);
                                                string        newlst = lstall.Replace("@", "");
                                                await Bot.SendTextMessageAsync(message.Chat.Id, newlst, replyToMessageId : message.MessageId);

                                                return;
                                            }
                                            catch
                                            {
                                                await Bot.SendTextMessageAsync(message.Chat.Id, "Список солистов пуст. Надо бы обновить.");

                                                return;
                                            }
                                        }
                                        if (inmess.Contains("аат") || inmess.Contains("танк"))
                                        {
                                            List <string> lstR = new List <string>();
                                            var           inxR = System.IO.File.ReadAllLines(aat_path);
                                            string        llsR = string.Join("\r\n", inxR.ToArray());
                                            await Bot.SendTextMessageAsync(message.Chat.Id, llsR, replyToMessageId : message.MessageId);

                                            return;
                                        }

                                        if (inmess.Contains("думаешь"))
                                        {
                                            await Bot.SendTextMessageAsync(message.Chat.Id, name + ", у меня просто нет слов.", replyToMessageId : message.MessageId);

                                            return;
                                        }

                                        if (inmess.Contains("выбери нового солиста"))
                                        {
                                            if (offlist.Contains(username))
                                            {
                                                //var checksolo = System.IO.File.ReadAllLines("solo.txt");
                                                //if (checksolo.Length == 0)
                                                //{
                                                //    MessageBox.Show("Файл пуст!");
                                                //}
                                                string lastsolo = Properties.Settings.Default.short_solo;
                                                var    soloL    = System.IO.File.ReadAllText(solo_path);
                                                var    soloX    = soloL.Replace(lastsolo, "");
                                                //var soloF = soloX.Replace("\n\n", "\n");
                                                //var lines = System.IO.File.ReadAllLines("solo.txt");
                                                //string[] linesX = lines.re
                                                //System.IO.File.WriteAllLines("solo.txt", lines);
                                                //MessageBox.Show(lastsolo);
                                                //MessageBox.Show(soloF);
                                                System.IO.File.WriteAllText(solo_path, soloX);

                                                string fileName       = solo_path;
                                                string outputFileName = "TEXT/solotemp.txt";
                                                string inputLine;

                                                System.IO.StreamReader sr = new System.IO.StreamReader(fileName);
                                                System.IO.StreamWriter sw = new System.IO.StreamWriter(outputFileName);

                                                inputLine = sr.ReadLine();
                                                while (inputLine != null)
                                                {
                                                    if (inputLine.Length > 0)
                                                    {
                                                        sw.WriteLine(inputLine);
                                                    }
                                                    // read the next line
                                                    inputLine = sr.ReadLine();
                                                }
                                                sr.Close();
                                                sw.Close();

                                                var transf = System.IO.File.ReadAllText("TEXT/solotemp.txt");
                                                System.IO.File.WriteAllText(solo_path, transf);
                                                try
                                                {
                                                    List <string> lst = new List <string>();

                                                    Random rand = new Random();

                                                    var inx = System.IO.File.ReadAllLines(solo_path);

                                                    string[] str = new string[1]; // здесь будут храниться n случаные неповторяющиеся строки из inx

                                                    int k;

                                                    for (int i = 0; i < str.Length; i++)
                                                    {
                                                        while (true)
                                                        {
                                                            k = rand.Next(inx.Length);
                                                            if (!lst.Any(x => x.Equals(inx[k])))
                                                            {
                                                                lst.Add(inx[k]);
                                                                str[i] = inx[k];
                                                                break;
                                                            }
                                                        }
                                                    }


                                                    string lls = string.Join("\r\n", lst.ToArray());
                                                    Properties.Settings.Default.short_solo = lls;
                                                    Properties.Settings.Default.solo       = "Для закрытия следующей Ямы-0, Колесом Фортуны избран " + lls + " !";
                                                    Properties.Settings.Default.Save();
                                                    await Bot.SendTextMessageAsync(message.Chat.Id, "В этот раз Фортуна избрала " + lls, replyToMessageId : message.MessageId);

                                                    return;
                                                }
                                                catch
                                                {
                                                    await Bot.SendTextMessageAsync(message.Chat.Id, "Список солистов пуст. Надо бы обновить");

                                                    return;
                                                }
                                            }

                                            else
                                            {
                                                await Bot.SendTextMessageAsync(message.Chat.Id, name + " , мне не говорили, что тебе можно это делать. Извини.", replyToMessageId : message.MessageId);

                                                return;
                                            }
                                        }


                                        if (inmess.Contains("спасибо") || inmess.Contains("благодар"))
                                        {
                                            await Bot.SendTextMessageAsync(message.Chat.Id, name + ", не стоит. Мне было даже немного приятно)))");

                                            return;
                                        }

                                        await Bot.SendTextMessageAsync(message.Chat.Id, name + ", что за ересь? Я не понимаю, что ты имеешь в виду(((");

                                        return;
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                System.IO.File.AppendAllText(logs_path, "\r\n" + DateTime.Now + "\r\n" + ex.Message + "\r\n");
                                return;
                            }

                            try
                            {
                                if (message.Text.Equals("Ева") || message.Text.Equals("/info") || message.Text.Equals("/info@YavinIV_rollbot"))
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "Слушаю тебя, " + name + "." + "\r\n" + "Что ты хочешь знать?" + "\r\n" + "Я могу напомнить тебе правила Ямы или ААТ, показать список солистов или памятку по ТБ. Могу напомнить, кто закрывает соло следующую Яму-0. И многое другое ;) Достаточно обратиться ко мне по имени. К примеру: \"Ева, кто закрывает соло?\"", replyToMessageId : message.MessageId);

                                    return;
                                }
                            }
                            catch (Exception ex)
                            {
                                System.IO.File.AppendAllText(logs_path, "\r\n" + DateTime.Now + "\r\n" + ex.Message + "\r\n");
                                System.IO.File.WriteAllText("LOGS/123.txt", "\r\n" + DateTime.Now + "\r\n" + ex.Message + "\r\n");
                                return;
                            }
                        }
                    };

                    // запускаем прием обновлений
                    Bot.StartReceiving();
                }
                catch (Telegram.Bot.Exceptions.ApiRequestException ex)
                {
                    System.IO.File.WriteAllText("LOGS/error.log", "\r\n" + DateTime.Now + "\r\n" + ex.Message + "\r\n"); // если ключ не подошел - пишем об этом в консоль отладки
                }
            }
            catch (Exception ex)
            {
                System.IO.File.AppendAllText(logs_path, "\r\n" + DateTime.Now + "\r\n" + ex.Message + "\r\n");
                System.IO.File.WriteAllText("LOGS/123.txt", "\r\n" + DateTime.Now + "\r\n" + ex.Message + "\r\n");
            }
        }
Exemple #16
0
        /// <summary>
        /// Получение сообщений и ответ на них
        /// </summary>
        public async Task BotWork()
        {
            var bot = new Telegram.Bot.TelegramBotClient(_key);
            await bot.SetWebhookAsync("");

            int offset = 0; //инервал между ответами

            while (!_token.IsCancellationRequested)
            {
                var updates = await bot.GetUpdatesAsync(offset);

                Message message;
                string  responseMessage;

                foreach (var update in updates)
                {
                    try
                    {
                        switch (update.Type)
                        {
                        case UpdateType.UnkownUpdate:
                            break;

                        case UpdateType.EditedMessage:
                            break;

                        case UpdateType.MessageUpdate:
                            message = update.Message;
                            switch (message.Type)
                            {
                            case MessageType.TextMessage:
                                responseMessage = _messageControl.MessageCommands(message);

                                if (_isWaitAnswerForRememder.Any(x => x == message.Chat.Id) || _isWaitAnswerForWeather.Any(x => x == message.Chat.Id))
                                {
                                    await bot.SendTextMessageAsync(message.Chat.Id, responseMessage,
                                                                   false, false, 0, CreateInlineKeyboard());
                                }
                                else
                                {
                                    await bot.SendTextMessageAsync(message.Chat.Id, responseMessage,
                                                                   false, false, 0, await CreateKeyboard(message.Chat.Id));
                                }
                                _logger.Info(message.Chat.FirstName + " " + message.Chat.Id + " - " + message.Text);
                                break;

                            case MessageType.VideoMessage:
                                await bot.SendTextMessageAsync(message.Chat.Id, "Сейчас посмотрю.");

                                break;

                            case MessageType.StickerMessage:
                                await bot.SendTextMessageAsync(message.Chat.Id, $"Очень смешно, {message.Chat.FirstName}.");

                                break;

                            case MessageType.LocationMessage:
                                responseMessage = _messageControl.LocationCommands(message.Location.Latitude, message.Location.Longitude);
                                await bot.SendTextMessageAsync(message.Chat.Id, responseMessage);

                                break;

                            default:
                                await bot.SendTextMessageAsync(message.Chat.Id, "И что мне на это ответить?");

                                break;
                            }
                            break;

                        case UpdateType.CallbackQueryUpdate:
                            await bot.EditMessageTextAsync(update.CallbackQuery.From.Id, update.CallbackQuery.Message.MessageId, "Возврат обратно.");

                            _isWaitAnswerForRememder.Remove(update.CallbackQuery.From.Id);
                            _isWaitAnswerForWeather.Remove(update.CallbackQuery.From.Id);
                            break;

                        default:
                            break;
                        }
                        offset = update.Id + 1;
                    }
                    catch (Exception ex)
                    {
                        _logger.Error(ex.Message);
                    }
                }
            }
        }
Exemple #17
0
        async void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            var worker = sender as BackgroundWorker;
            var key    = e.Argument as String;

            try
            {
                var Bot = new Telegram.Bot.TelegramBotClient(key);
                await Bot.SetWebhookAsync("");

                int offset = 0;
                while (true)
                {
                    var updates = await Bot.GetUpdatesAsync(offset);

                    foreach (var update in updates)
                    {
                        var message = update.Message;

                        const string req = @"^((8|\+7)[\- ]?)?(\(?9\d{2}\)?[\- ]?)?([\d][\- ]?){7}$";

                        Console.WriteLine(Regex.Replace(message.Text, @"\D+", ""));
                        String num = Regex.Replace(message.Text, @"\D+", "");

                        var regex = new Regex(req);

                        Console.WriteLine(regex.IsMatch(num));

                        if (regex.IsMatch(num))
                        {
                            String lastnum = Regex.Replace(num, @"^(8|\+7)?[\- ]?\(?(9\d{2})\)?[\- ]?([\d])[\- ]?([\d])[\- ]?([\d])[\- ]?([\d])[\- ]?([\d])[\- ]?([\d])[\- ]?([\d])$", "+7($2)$3$4$5-$6$7-$8$9");
                            Console.WriteLine(lastnum);
                        }
                        else
                        {
                            Console.WriteLine("Неверный номер");
                        }



                        if (message.Type == Telegram.Bot.Types.Enums.MessageType.TextMessage)
                        {
                            if (dict.ContainsKey(message.Chat.Id))
                            {
                                if (message.Date > dict[message.Chat.Id].AddSeconds(10))
                                {
                                    String phone = "";

                                    for (int i = 0; i < message.Text.Length; i++)
                                    {
                                        if (message.Text[i] >= '0' && message.Text[i] <= '9')
                                        {
                                            phone += message.Text[i];
                                        }
                                    }

                                    if (phone.Length == 10)
                                    {
                                        if (phone[0] == '9')
                                        {
                                            await Bot.SendTextMessage(message.Chat.Id, getPhone(phone), replyToMessageId : message.MessageId);
                                        }
                                        else
                                        {
                                            await Bot.SendTextMessage(message.Chat.Id, "Неверный номер", replyToMessageId : message.MessageId);
                                        }
                                    }

                                    else if (phone.Length == 11)
                                    {
                                        if ((phone[0] == '8' || phone[0] == '7') && phone[1] == '9')
                                        {
                                            await Bot.SendTextMessage(message.Chat.Id, getPhone(phone), replyToMessageId : message.MessageId);
                                        }
                                        else
                                        {
                                            await Bot.SendTextMessage(message.Chat.Id, "Неверный номер", replyToMessageId : message.MessageId);
                                        }
                                    }
                                    else
                                    {
                                        await Bot.SendTextMessage(message.Chat.Id, "Неверный номер", replyToMessageId : message.MessageId);
                                    }

                                    dict[message.Chat.Id] = message.Date;
                                }
                                else
                                {
                                    await Bot.SendTextMessage(message.Chat.Id, "Превышено количество обращений к боту", replyToMessageId : message.MessageId);
                                }
                            }
                            else
                            {
                                String phone = "";

                                for (int i = 0; i < message.Text.Length; i++)
                                {
                                    if (message.Text[i] >= '0' && message.Text[i] <= '9')
                                    {
                                        phone += message.Text[i];
                                    }
                                }

                                if (phone.Length == 10)
                                {
                                    if (phone[0] == '9')
                                    {
                                        await Bot.SendTextMessage(message.Chat.Id, getPhone(phone), replyToMessageId : message.MessageId);
                                    }
                                    else
                                    {
                                        await Bot.SendTextMessage(message.Chat.Id, "Неверный номер", replyToMessageId : message.MessageId);
                                    }
                                }

                                else if (phone.Length == 11)
                                {
                                    if ((phone[0] == '8' || phone[0] == '7') && phone[1] == '9')
                                    {
                                        await Bot.SendTextMessage(message.Chat.Id, getPhone(phone), replyToMessageId : message.MessageId);
                                    }
                                    else
                                    {
                                        await Bot.SendTextMessage(message.Chat.Id, "Неверный номер", replyToMessageId : message.MessageId);
                                    }
                                }
                                else
                                {
                                    await Bot.SendTextMessage(message.Chat.Id, "Неверный номер", replyToMessageId : message.MessageId);
                                }
                                dict.Add(message.Chat.Id, message.Date);
                            }
                        }

                        offset = update.Id + 1;
                    }
                }
            }
            catch (Telegram.Bot.Exceptions.ApiRequestException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
Exemple #18
0
        async void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            /*Commands.Add("/start");
             * Commands.Add("/balance");
             * Commands.Add("/chatID");
             * Commands.Add("/ОРЁЛ");
             * Commands.Add("/РЕШКА");
             * Commands.Add("/0,2");
             * Commands.Add("/0,4");
             * Commands.Add("/0,6");
             * Commands.Add("/0,8");*/

            var worker = sender as BackgroundWorker;
            var key    = "400994008:AAF_AngoYyaakmuAhsv63kSR_fXkO6NA8ek"; // получаем ключ из аргументов

            bool   rate = false;
            int    rateCount; //ОРЁЛ - 1 :РЕШКА - 2.
            int    randomizeCount;
            Random rand = new Random();

            try
            {
                var Bot = new Telegram.Bot.TelegramBotClient(key); // инициализируем API
                await Bot.SetWebhookAsync("");

                //Bot.SetWebhook(""); // Обязательно! убираем старую привязку к вебхуку для бота
                int offset = 0; // отступ по сообщениям
                while (true)
                {
                    var updates = await Bot.GetUpdatesAsync(offset); // получаем массив обновлений

                    foreach (var update in updates)                  // Перебираем все обновления
                    {
                        var message = update.Message;

                        chatID = message.Chat.Id;

                        const string connStr = "server=localhost;user=root;database=bot_1;password = 000000;";

                        MySqlConnection conn = new MySqlConnection(connStr);

                        conn.Open();

                        string blnc = "SELECT balance FROM bot_1.user where id = " + chatID;

                        MySqlCommand commandCheckBalance = new MySqlCommand(blnc, conn);

                        balance = (float)Convert.ToDouble(commandCheckBalance.ExecuteScalar());
                        conn.Clone();

                        if (message.Type == Telegram.Bot.Types.Enums.MessageType.TextMessage)
                        {
                            /*for (int i = 0; i < 9;i++)
                             * {
                             *      if (message.Text.Substring(0, 1) != Commands[i])
                             * {
                             *  await Bot.SendTextMessageAsync(message.Chat.Id, "Я тебя не понимаю..	Напиши /start !");
                             * }
                             * }*/



                            if (message.Text == "/start")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Начнём💸	"+
                                                               "\r\n\r\nДля начала я даю тебе " + startBonus.ToString() + " рублей." +
                                                               "\r\nА благодаря этому боту можно влёгкую поднять денег!👑 " +
                                                               "\r\nВсеголишь угадывая монету. " +
                                                               "\r\nПрямо сейчас можешь начать зарабатывать!");

                                // reply buttons
                                var keyboard = new Telegram.Bot.Types.ReplyMarkups.ReplyKeyboardMarkup
                                {
                                    Keyboard = new[] {
                                        new[]         // row 1
                                        {
                                            new Telegram.Bot.Types.KeyboardButton("/0,2"),
                                            new Telegram.Bot.Types.KeyboardButton("/0,4"),
                                            new Telegram.Bot.Types.KeyboardButton("/0,6"),
                                            new Telegram.Bot.Types.KeyboardButton("/0,8")
                                        },
                                    },
                                    ResizeKeyboard = true
                                };

                                await Bot.SendTextMessageAsync(message.Chat.Id, "Сделай ставку:", false, false, 0, keyboard, Telegram.Bot.Types.Enums.ParseMode.Default);
                            }

                            if (message.Text == "/0,2" || message.Text == "/0,4" || message.Text == "/0,6" || message.Text == "/0,8")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Ставки приняты💰");

                                var keyboard2 = new Telegram.Bot.Types.ReplyMarkups.ReplyKeyboardMarkup
                                {
                                    Keyboard = new[] {
                                        new[]         // row 1
                                        {
                                            new Telegram.Bot.Types.KeyboardButton("/ОРЁЛ"),
                                            new Telegram.Bot.Types.KeyboardButton("/РЕШКА")
                                        },
                                    },
                                    ResizeKeyboard = true
                                };

                                await Bot.SendTextMessageAsync(message.Chat.Id, "Испытай удачу!💸", false, false, 0, keyboard2, Telegram.Bot.Types.Enums.ParseMode.Default);
                            }



                            if (message.Text == "/balance")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Твой баланс💸:" + balance);
                            }
                            if (message.Text == "/chatID")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Твой chatID:" + chatID);
                            }

                            // обработка reply кнопок
                            if (message.Text == "/ОРЁЛ")
                            {
                                rate           = true;
                                rateCount      = 1;
                                randomizeCount = rand.Next(0, 2);
                                if (randomizeCount == 0)
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "Ии этооо... ОРЁЛ \r\nУгадал!😇");

                                    await Bot.SendTextMessageAsync(message.Chat.Id, "Тебе зачислено💸:");
                                }
                                if (randomizeCount == 1)
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "Ии этооо... РЕШКА \r\nНе угадал!😈");

                                    await Bot.SendTextMessageAsync(message.Chat.Id, "С чёта списано💵:");
                                }
                            }
                            if (message.Text == "/РЕШКА")
                            {
                                rate           = true;
                                rateCount      = 2;
                                randomizeCount = rand.Next(0, 2);
                                if (randomizeCount == 1)
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "Ии этооо... РЕШКА \r\nУгадал!😇");

                                    await Bot.SendTextMessageAsync(message.Chat.Id, "Тебе зачислено💸:");
                                }
                                if (randomizeCount == 0)
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "Ии этооо... ОРЁЛ \r\nНе угадал!😈");

                                    await Bot.SendTextMessageAsync(message.Chat.Id, "С чёта списано💵:");
                                }
                            }
                            Bot.StartReceiving();
                        }

                        offset = update.Id + 1;
                    }
                }
            }
            catch (Telegram.Bot.Exceptions.ApiRequestException ex)
            {
                Console.WriteLine(ex.Message); // если ключ не подошел - пишем об этом в консоль отладки
            }
        }
Exemple #19
0
        async void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            var    worker = sender as BackgroundWorker;
            string key    = "622335668:AAEv62L9dRi4BH6JVyW8gfEg-tCmd-qTRXo";

            try
            {
                var Bot = new Telegram.Bot.TelegramBotClient(key);
                await Bot.SetWebhookAsync("");

                // Callback'и от кнопок
                Bot.OnCallbackQuery += async(object sc, Telegram.Bot.Args.CallbackQueryEventArgs ev) =>
                {
                    var message = ev.CallbackQuery.Message;
                    if (ev.CallbackQuery.Data == "callback0")
                    {
                        await Bot.AnswerCallbackQueryAsync(ev.CallbackQuery.Id, "You hav choosen " + ev.CallbackQuery.Data, true);
                    }

                    else if (ev.CallbackQuery.Data.Contains("correctAnswer"))
                    {
                        await Bot.SendTextMessageAsync(message.Chat.Id, "Вірно!", replyToMessageId : message.MessageId);

                        await Bot.AnswerCallbackQueryAsync(ev.CallbackQuery.Id);                        // видаляє очікування (годинник)

                        GetQuestion(Bot, ev, message);
                        string tCountry = ev.CallbackQuery.Data.Replace("correctAnswer", "");
                        BotAs.RightAnswer(tCountry);
                    }

                    else if (ev.CallbackQuery.Data == "wrongAnswer")
                    {
                        await Bot.SendTextMessageAsync(message.Chat.Id, "Емм..Ні. Йдем далі...", replyToMessageId : message.MessageId);

                        await Bot.AnswerCallbackQueryAsync(ev.CallbackQuery.Id);                        // видаляє очікування (годинник)

                        GetQuestion(Bot, ev, message);
                        BotAs.WrongAnswer();
                    }

                    else
                    if (ev.CallbackQuery.Data.Contains("Continent:"))
                    {
                        string tContinent = ev.CallbackQuery.Data.Replace("Continent:", "");
                        await Bot.SendTextMessageAsync(message.Chat.Id, "Хмм, сміливо!", replyToMessageId : message.MessageId);

                        BotAs.ChooseContinent(tContinent);
                        GetQuestion(Bot, ev, message);
                    }
                };

                Bot.OnUpdate += async(object su, Telegram.Bot.Args.UpdateEventArgs evu) =>
                {
                    if (evu.Update.CallbackQuery != null || evu.Update.InlineQuery != null)
                    {
                        return;
                    }
                    var update  = evu.Update;
                    var message = update.Message;
                    if (message == null)
                    {
                        return;
                    }
                    if (message.Type == Telegram.Bot.Types.Enums.MessageType.Text)
                    {
                        if (message.Text == "/hello")
                        {
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Хелова", replyToMessageId : message.MessageId);
                        }
                        if (message.Text == "/getimage")
                        {
                            await Bot.SendPhotoAsync(message.Chat.Id, "https://static.365info.kz/uploads/2019/03/a346a3729504594579883eeb12a38d80.jpg", "Та й таке!");
                        }

                        if (message.Text == "/stopgame")
                        {
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Гру завершено! Правильних: " + BotAs.RightAnswers + " з " + (BotAs.WrongAnswers + BotAs.RightAnswers), replyToMessageId : message.MessageId);

                            BotAs.OverGame();
                        }

                        if (message.Text == "/capitals")
                        {
                            BotAs.StartGame();
                            List <string> continents = BotAs.GetContinents();
                            continents.Add("Все");

                            Telegram.Bot.Types.ReplyMarkups.InlineKeyboardButton[] Keys = new Telegram.Bot.Types.ReplyMarkups.InlineKeyboardButton[continents.Count];

                            int i = 0;

                            foreach (string continent in continents)
                            {
                                Keys[i] = new Telegram.Bot.Types.ReplyMarkups.InlineKeyboardButton {
                                    Text = continent, CallbackData = "Continent:" + continent
                                };
                                i++;
                            }

                            var keyboard = new Telegram.Bot.Types.ReplyMarkups.InlineKeyboardMarkup(
                                new Telegram.Bot.Types.ReplyMarkups.InlineKeyboardButton[][]
                            {
                                Keys
                            }
                                );

                            await Bot.SendTextMessageAsync(message.Chat.Id, "З чого розпочнемо гру?", replyMarkup : keyboard);
                        }
                    }
                };

                Bot.StartReceiving();
            }
            catch (Telegram.Bot.Exceptions.ApiRequestException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
Exemple #20
0
        async void do_work(object sender, DoWorkEventArgs e)
        {
            var worker = sender as BackgroundWorker;
            var key    = e.Argument as String;

            try
            {
                var bot = new Telegram.Bot.TelegramBotClient(key);
                await bot.SetWebhookAsync("");

                AIMLbot.Bot lazy = new AIMLbot.Bot();


                lazy.loadSettings();
                lazy.loadAIMLFromFiles();
                lazy.isAcceptingUserInput = false;
                AIMLbot.User us = new AIMLbot.User("Username", lazy);
                lazy.isAcceptingUserInput = true;


                bot.OnCallbackQuery += async(object sc, Telegram.Bot.Args.CallbackQueryEventArgs ev) =>
                {
                    Telegram.Bot.Types.FileToSend s;
                    var message = ev.CallbackQuery.Message;
                    if (ev.CallbackQuery.Data == "callback1")
                    {
                        s = new Telegram.Bot.Types.FileToSend("https://i.pinimg.com/originals/f7/e9/80/f7e980c9700c8395535b835e66f02a59.jpg");
                    }
                    else if (ev.CallbackQuery.Data == "callback2")
                    {
                        s = new Telegram.Bot.Types.FileToSend("https://static.independent.co.uk/s3fs-public/thumbnails/image/2012/02/29/22/pg-28-sloth-cooke.jpg");
                    }
                    await bot.SendPhotoAsync(message.Chat.Id, s, "Sure! But... not today :)");

                    await bot.AnswerCallbackQueryAsync(ev.CallbackQuery.Id);
                };

                bot.OnUpdate += async(object su, Telegram.Bot.Args.UpdateEventArgs evu) =>
                {
                    if (evu.Update.CallbackQuery != null || evu.Update.InlineQuery != null)
                    {
                        return;
                    }
                    var update  = evu.Update;
                    var message = update.Message;
                    if (message == null)
                    {
                        return;
                    }
                    if (message.Type == Telegram.Bot.Types.Enums.MessageType.TextMessage)
                    {
                        if (message.Text[0] == '/')
                        {
                            if (message.Text == "/test")
                            {
                                await bot.SendTextMessageAsync(message.Chat.Id, "Yeah...",
                                                               replyToMessageId : message.MessageId);
                            }

                            if (message.Text == "/sleep")
                            {
                                var s = new Telegram.Bot.Types.FileToSend("https://beano-uploads-production.imgix.net/store/f4046f22dffe92e3f2167accb6942f788159d0f979f970dcda59f1d0e529?auto=compress&w=752&h=423&fit=min");
                                await bot.SendPhotoAsync(message.Chat.Id,
                                                         s, "Yeeeeeeeeeah, sleeeeeeeeep!");
                            }

                            if (message.Text == "/song")
                            {
                                var s = new Telegram.Bot.Types.FileToSend("http://store.naitimp3.ru/download/0/cGR1a0tRTWJwZW8wMlI2aitkT1UzVkxNdXE2dUNiRTAvcGRkeGphMTVFVTdQcGFURWlFOFQyUGZFTXJ6UVo4cWxVSUNza2NOQUpoZkJOU2ozYTJhWUpLSVdiUTRTanQrVmZnN1hQV1U5Tkk9/eels_i_need_some_sleep_(NaitiMP3.ru).mp3");
                                await bot.SendAudioAsync(message.Chat.Id, s, "", 4, "Eels", "I need some sleep...");
                            }

                            if (message.Text == "/work")
                            {
                                var keyboard = new Telegram.Bot.Types.ReplyMarkups.InlineKeyboardMarkup(
                                    new Telegram.Bot.Types.InlineKeyboardButtons.InlineKeyboardButton[][]
                                {
                                    // First row
                                    new [] {
                                        // First column
                                        new Telegram.Bot.Types.InlineKeyboardButtons.InlineKeyboardCallbackButton("Work", "callback1"),

                                        // Second column
                                        new Telegram.Bot.Types.InlineKeyboardButtons.InlineKeyboardCallbackButton("Work harder", "callback2")
                                    },
                                }
                                    );

                                await bot.SendTextMessageAsync(message.Chat.Id, "Hmmmm... What should I do?..!", Telegram.Bot.Types.Enums.ParseMode.Default, false, false, 0, keyboard);
                            }
                        }
                        else if ((message.Text[0] >= 'а' && message.Text[0] <= 'я') || (message.Text[0] >= 'А' && message.Text[0] <= 'Я'))
                        {
                            await bot.SendTextMessageAsync(message.Chat.Id, "I'm too lazy to learn russian, sorry...",
                                                           replyToMessageId : message.MessageId);
                        }
                        else
                        {
                            AIMLbot.Request r   = new AIMLbot.Request(message.Text, us, lazy);
                            AIMLbot.Result  res = lazy.Chat(r);

                            await bot.SendTextMessageAsync(message.Chat.Id, res.Output,
                                                           replyToMessageId : message.MessageId);
                        }
                    }
                };

                bot.StartReceiving();
            }
            catch (Telegram.Bot.Exceptions.ApiRequestException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
Exemple #21
0
        static async void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            var worker = sender as BackgroundWorker;
            var key    = e.Argument as String;                    // получаем ключ из аргументов
            var Bot    = new Telegram.Bot.TelegramBotClient(key); // инициализируем API
            await Bot.SetWebhookAsync("");

            var preUpdates = await Bot.GetUpdatesAsync(-1);

            offset  = preUpdates.Select(s => s.Id).LastOrDefault();
            offset += 1;
            try
            {
                bool repeat = true;
                while (repeat)
                {
                    var updates = await Bot.GetUpdatesAsync(offset);

                    foreach (var update in updates) // Перебираем все обновления
                    {
                        offset += 1;
                        switch (update.Type)
                        {
                        case UpdateType.Message:
                            var message = update.Message;
                            if (update.Message.Type == Telegram.Bot.Types.Enums.MessageType.Text && message.Text.Replace("@BeOpenChatBot", "").ToLower() == ("/restart"))
                            {
                                repeat = false;
                                offset = 0;
                                throw new Exception($"Бот был перезапущен при помощи команды /restart , данную команду запустил @{message.From.Username} - {message.From.FirstName}");
                            }
                            else
                            {
                                if (update.Message.Type == Telegram.Bot.Types.Enums.MessageType.Text)
                                {
                                    await MessageHandling.MessageProcessingAsync(update, Bot, key);

                                    Console.WriteLine($"[{DateTime.Now}] - From: @{message.From.Username} - Message: {message.Text}");
                                }
                            }
                            if (update.Message.Type == Telegram.Bot.Types.Enums.MessageType.Voice || update.Message.Type == Telegram.Bot.Types.Enums.MessageType.VideoNote)
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Мне лень его слушать...", replyToMessageId : message.MessageId);
                            }
                            break;

                        case UpdateType.CallbackQuery:
                            break;

                        case UpdateType.InlineQuery:
                            break;

                        case UpdateType.EditedMessage:
                            break;

                        case UpdateType.EditedChannelPost:
                            break;

                        case UpdateType.ChosenInlineResult:
                            break;

                        case UpdateType.ChannelPost:
                            break;

                        case UpdateType.Poll:
                            break;

                        case UpdateType.PollAnswer:
                            break;

                        case UpdateType.PreCheckoutQuery:
                            break;

                        case UpdateType.ShippingQuery:
                            break;

                        case UpdateType.Unknown:
                            break;

                        default:
                            break;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                await Bot.SendTextMessageAsync("441224506", ex.Message + "-" + ex.StackTrace);

                bw.RunWorkerAsync(publicKey);
            }
        }
Exemple #22
0
        async void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            var worker = sender as BackgroundWorker;
            var key    = e.Argument as String; // получаем ключ из аргументов

            try
            {
                var Bot = new Telegram.Bot.TelegramBotClient(key); // инициализируем API
                await Bot.SetWebhookAsync("");                     // Обязательно! убираем старую привязку к вебхуку для бота

                // Inlin'ы
                Bot.OnInlineQuery += async(object si, Telegram.Bot.Args.InlineQueryEventArgs ei) =>
                {
                    var query = ei.InlineQuery.Query;

                    var msg = new Telegram.Bot.Types.InputMessageContents.InputTextMessageContent
                    {
                        MessageText = @"Это супер крутой текст статьи
с переносами
и <b>html</b> <i>тегами!</i>",
                        ParseMode   = Telegram.Bot.Types.Enums.ParseMode.Html,
                    };

                    Telegram.Bot.Types.InlineQueryResults.InlineQueryResult[] results =
                    {
                        new Telegram.Bot.Types.InlineQueryResults.InlineQueryResultArticle
                        {
                            Id                  = "1",
                            Title               = "Тестовый тайтл",
                            Description         = "Описание статьи тут",
                            InputMessageContent = msg,
                        },
                        new Telegram.Bot.Types.InlineQueryResults.InlineQueryResultAudio
                        {
                            Url    = "http://aftamat4ik.ru/wp-content/uploads/2017/05/mongol-shuudan_-_kozyr-nash-mandat.mp3",
                            Id     = "2",
                            FileId = "123423433",
                            Title  = "Монгол Шуудан - Козырь наш Мандат!",
                        },
                        new Telegram.Bot.Types.InlineQueryResults.InlineQueryResultPhoto
                        {
                            Id          = "3",
                            Url         = "http://aftamat4ik.ru/wp-content/uploads/2017/05/14277366494961.jpg",
                            ThumbUrl    = "http://aftamat4ik.ru/wp-content/uploads/2017/05/14277366494961-150x150.jpg",
                            Caption     = "Текст под фоткой",
                            Description = "Описание",
                        },
                        new Telegram.Bot.Types.InlineQueryResults.InlineQueryResultVideo
                        {
                            Id       = "4",
                            Url      = "http://aftamat4ik.ru/wp-content/uploads/2017/05/bb.mp4",
                            ThumbUrl = "http://aftamat4ik.ru/wp-content/uploads/2017/05/joker_5-150x150.jpg",
                            Title    = "демо видеоролика",
                            MimeType = "video/mp4",
                        }
                    };


                    await Bot.AnswerInlineQueryAsync(ei.InlineQuery.Id, results);
                };

                // Callback'и от кнопок
                Bot.OnCallbackQuery += async(object sc, Telegram.Bot.Args.CallbackQueryEventArgs ev) =>
                {
                    var message = ev.CallbackQuery.Message;
                    if (ev.CallbackQuery.Data == "callback1")
                    {
                        await Bot.AnswerCallbackQueryAsync(ev.CallbackQuery.Id, "You hav choosen " + ev.CallbackQuery.Data, true);
                    }
                    else
                    if (ev.CallbackQuery.Data == "callback2")
                    {
                        await Bot.SendTextMessageAsync(message.Chat.Id, "тест", replyToMessageId : message.MessageId);

                        await Bot.AnswerCallbackQueryAsync(ev.CallbackQuery.Id); // отсылаем пустое, чтобы убрать "частики" на кнопке
                    }
                };

                Bot.OnUpdate += async(object su, Telegram.Bot.Args.UpdateEventArgs evu) =>
                {
                    if (evu.Update.CallbackQuery != null || evu.Update.InlineQuery != null)
                    {
                        return;                                                                     // в этом блоке нам келлбэки и инлайны не нужны
                    }
                    var update  = evu.Update;
                    var message = update.Message;
                    if (message == null)
                    {
                        return;
                    }
                    if (message.Type == Telegram.Bot.Types.Enums.MessageType.TextMessage)
                    {
                        if (message.Text == "/hello")
                        {
                            // в ответ на команду /saysomething выводим сообщение
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Ну здарова! Как сам? :)", replyToMessageId : message.MessageId);
                        }
                        if (message.Text == "/help")
                        {
                            string txt = "Сори, я сам тут новенький :)\n /help - помощь\n /hello - поздароваться\n /getimg - получи картинку\n /rbuttons - Reply - кнопки\n /ibuttons - Inline кнопки";
                            // в ответ на команду /saysomething выводим сообщение
                            await Bot.SendTextMessageAsync(message.Chat.Id, txt, replyToMessageId : message.MessageId);
                        }
                        if (message.Text == "/getimg")
                        {
                            // в ответ на команду /getimage выводим картинку
                            await Bot.SendPhotoAsync(message.Chat.Id, "http://aftamat4ik.ru/wp-content/uploads/2017/03/photo_2016-12-13_23-21-07.jpg", "Revolution!");
                        }

                        // inline buttons
                        if (message.Text == "/ibuttons")
                        {
                            var keyboard = new Telegram.Bot.Types.ReplyMarkups.InlineKeyboardMarkup(
                                new Telegram.Bot.Types.InlineKeyboardButton[][]
                            {
                                // First row
                                new [] {
                                    // First column
                                    new Telegram.Bot.Types.InlineKeyboardButton("раз", "callback1"),

                                    // Second column
                                    new Telegram.Bot.Types.InlineKeyboardButton("два", "callback2"),
                                },
                            }
                                );

                            await Bot.SendTextMessageAsync(message.Chat.Id, "Давай накатим, товарищ, по одной!", false, false, 0, keyboard, Telegram.Bot.Types.Enums.ParseMode.Default);
                        }

                        // reply buttons
                        if (message.Text == "/rbuttons")
                        {
                            var keyboard = new Telegram.Bot.Types.ReplyMarkups.ReplyKeyboardMarkup
                            {
                                Keyboard = new[] {
                                    new[]             // row 1
                                    {
                                        new Telegram.Bot.Types.KeyboardButton("Накатим!"),
                                        new Telegram.Bot.Types.KeyboardButton("Рря!")
                                    },
                                },
                                ResizeKeyboard = true
                            };

                            await Bot.SendTextMessageAsync(message.Chat.Id, "Давай накатим, товарищ, мой!", false, false, 0, keyboard, Telegram.Bot.Types.Enums.ParseMode.Default);
                        }
                        // обработка reply кнопок
                        if (message.Text.ToLower() == "накатим!")
                        {
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Ну, за здоровье!", replyToMessageId : message.MessageId);
                        }
                        if (message.Text.ToLower() == "рря!")
                        {
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Ну, за демократию!", replyToMessageId : message.MessageId);
                        }
                    }
                };

                // запускаем прием обновлений
                Bot.StartReceiving();
            }
            catch (Telegram.Bot.Exceptions.ApiRequestException ex)
            {
                Console.WriteLine(ex.Message); // если ключ не подошел - пишем об этом в консоль отладки
            }
        }
Exemple #23
0
        async void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            var worker = sender as BackgroundWorker;

            try
            {
                int admin_id = Convert.ToInt32(admin_textbox.Text);
                var key_bot  = "952377344:AAGav52g97Q7WtvXyXxbMkyexx3Aj7WuV7s";
                var Bot      = new Telegram.Bot.TelegramBotClient(key_bot); // инициализируем API

                try
                {
                    await Bot.SetWebhookAsync(""); // !!!!!!!!!!!!!!!!!!!!!!ЦИКЛ ПЕРЕЗАПУСКА
                }
                catch
                {
                    await Bot.SetWebhookAsync("");
                }


                // Inlin'ы
                Bot.OnInlineQuery += async(object si, Telegram.Bot.Args.InlineQueryEventArgs ei) =>
                {
                    var query = ei.InlineQuery.Query;
                };



                Bot.OnUpdate += async(object su, Telegram.Bot.Args.UpdateEventArgs evu) =>
                {
                    var update  = evu.Update;
                    var message = update.Message;
                    var id_mess = message.MessageId;
                    var id_chat = message.Chat.Id;
                    // 670031730



                    if (message == null)
                    {
                        return;
                    }
                    try
                    {
                        string          connStr    = "server=localhost;user=root;database=tron;password="******";";
                        MySqlConnection connection = new MySqlConnection(connStr);
                        connection.Open();


                        //// получение айди поста из базы Русския

                        string Kryp_win_sql = "SELECT `Post_number` FROM `tron`.`post` WHERE(`idPost` = 1)";
                        string O_nas_sql    = "SELECT `Post_number` FROM `tron`.`post`  WHERE(`idPost` = 2)";
                        string News_sql     = "SELECT `Post_number` FROM `tron`.`post`  WHERE(`idPost` = 3)";
                        string Event_sql    = "SELECT `Post_number` FROM `tron`.`post`  WHERE(`idPost` = 4)";
                        string Social_sql   = "SELECT `Post_number` FROM `tron`.`post`  WHERE(`idPost` = 5)";
                        string Help_sql     = "SELECT `Post_number` FROM `tron`.`post` WHERE(`idPost` = 6)";

                        MySqlCommand Kryp_win_sql_ = new MySqlCommand(Kryp_win_sql, connection);
                        Kryp_win_sql_.ExecuteNonQuery();
                        Kryp_win_rus = Convert.ToInt32(Kryp_win_sql_.ExecuteScalar());

                        MySqlCommand O_nas_sql_ = new MySqlCommand(O_nas_sql, connection);
                        O_nas_sql_.ExecuteNonQuery();
                        O_nas_rus = Convert.ToInt32(O_nas_sql_.ExecuteScalar());

                        MySqlCommand News_sql_ = new MySqlCommand(News_sql, connection);
                        News_sql_.ExecuteNonQuery();
                        News_rus = Convert.ToInt32(News_sql_.ExecuteScalar());

                        MySqlCommand Event_sql_ = new MySqlCommand(Event_sql, connection);
                        Event_sql_.ExecuteNonQuery();
                        Event_rus = Convert.ToInt32(Event_sql_.ExecuteScalar());

                        MySqlCommand Social_sql_ = new MySqlCommand(Social_sql, connection);
                        Social_sql_.ExecuteNonQuery();
                        Social_rus = Convert.ToInt32(Social_sql_.ExecuteScalar());

                        MySqlCommand Help_sql_ = new MySqlCommand(Help_sql, connection);
                        Help_sql_.ExecuteNonQuery();
                        Help_rus = Convert.ToInt32(Help_sql_.ExecuteScalar());

                        /////
                        string Kryp_win_sql_eng = "SELECT `Post_number` FROM `tron`.`post_eng` WHERE(`idPost` = 1)";
                        string O_nas_sql_eng    = "SELECT `Post_number` FROM `tron`.`post_eng`  WHERE(`idPost` = 2)";
                        string News_sql_eng     = "SELECT `Post_number` FROM `tron`.`post_eng`  WHERE(`idPost` = 3)";
                        string Event_sql_eng    = "SELECT `Post_number` FROM `tron`.`post_eng`  WHERE(`idPost` = 4)";
                        string Social_sql_eng   = "SELECT `Post_number` FROM `tron`.`post_eng`  WHERE(`idPost` = 5)";
                        string Help_sql_eng     = "SELECT `Post_number` FROM `tron`.`post_eng` WHERE(`idPost` = 6)";

                        MySqlCommand Kryp_win_sql__eng = new MySqlCommand(Kryp_win_sql_eng, connection);
                        Kryp_win_sql__eng.ExecuteNonQuery();
                        Kryp_win_eng = Convert.ToInt32(Kryp_win_sql__eng.ExecuteScalar());

                        MySqlCommand O_nas_sql__eng = new MySqlCommand(O_nas_sql_eng, connection);
                        O_nas_sql__eng.ExecuteNonQuery();
                        O_nas_eng = Convert.ToInt32(O_nas_sql__eng.ExecuteScalar());

                        MySqlCommand News_sql__eng = new MySqlCommand(News_sql_eng, connection);
                        News_sql__eng.ExecuteNonQuery();
                        News_eng = Convert.ToInt32(News_sql__eng.ExecuteScalar());

                        MySqlCommand Event_sql__eng = new MySqlCommand(Event_sql_eng, connection);
                        Event_sql__eng.ExecuteNonQuery();
                        Event_eng = Convert.ToInt32(Event_sql__eng.ExecuteScalar());

                        MySqlCommand Social_sql__eng = new MySqlCommand(Social_sql_eng, connection);
                        Social_sql__eng.ExecuteNonQuery();
                        Social_eng = Convert.ToInt32(Social_sql__eng.ExecuteScalar());

                        MySqlCommand Help_sql__eng = new MySqlCommand(Help_sql_eng, connection);
                        Help_sql__eng.ExecuteNonQuery();
                        Help_eng = Convert.ToInt32(Help_sql__eng.ExecuteScalar());

                        string name = message.Chat.FirstName;
                        // запрос на добавление в базу языка
                        string language_sql_rus = @"UPDATE `tron`.`telegram`SET`Language` =""RUS"" WHERE (`Chat_id`)=" + message.Chat.Id;
                        string language_sql_eng = @"UPDATE `tron`.`telegram`SET`Language` =""ENG"" WHERE (`Chat_id`)=" + message.Chat.Id;
                        //sql Запрос на ввод данных Id
                        string id_sql = "INSERT INTO `tron`.`telegram`(`Chat_id`)VALUES(" + message.Chat.Id + ")";
                        //проверка наличия записи в бд
                        string id_proverka = "SELECT `Chat_id` FROM `tron`.`telegram` WHERE `Chat_id`=" + message.Chat.Id;
                        //запрос на язык
                        string Language = "SELECT `Language` FROM `tron`.`telegram` WHERE `Chat_id`=" + message.Chat.Id;

                        MySqlCommand Language_sql = new MySqlCommand(Language, connection);
                        Language_sql.ExecuteNonQuery();
                        string s         = Convert.ToString(Language_sql.ExecuteScalar());
                        var    main      = new ReplyKeyboardMarkup();
                        var    key_ru    = new ReplyKeyboardMarkup();
                        var    key_eng   = new ReplyKeyboardMarkup();
                        var    skip      = new ReplyKeyboardMarkup();
                        var    admin     = new ReplyKeyboardMarkup();
                        var    admin_eng = new ReplyKeyboardMarkup();
                        admin.Keyboard =
                            new KeyboardButton[][]
                        {
                            new KeyboardButton[]
                            {
                                new KeyboardButton(button11)
                            },
                            new KeyboardButton[]
                            {
                                new KeyboardButton(button2),
                                new KeyboardButton(button3),
                                new KeyboardButton(button4)
                            },
                            new KeyboardButton[]
                            {
                                new KeyboardButton(button6),
                                new KeyboardButton(button7)
                            },

                            new KeyboardButton[]
                            {
                                new KeyboardButton(@"Отправить оповещение")
                            }
                        };
                        admin.ResizeKeyboard  = true;
                        admin.OneTimeKeyboard = true;



                        admin_eng.Keyboard =
                            new KeyboardButton[][]
                        {
                            new KeyboardButton[]
                            {
                                new KeyboardButton(button1_eng)
                            },
                            new KeyboardButton[]
                            {
                                new KeyboardButton(button2_eng),
                                new KeyboardButton(button3_eng),
                                new KeyboardButton(button4_eng)
                            },
                            new KeyboardButton[]
                            {
                                new KeyboardButton(button6_eng),
                                new KeyboardButton(button7_eng)
                            },

                            new KeyboardButton[]
                            {
                                new KeyboardButton(@"Send message")
                            }
                        };
                        admin_eng.ResizeKeyboard  = true;
                        admin_eng.OneTimeKeyboard = true;



                        key_ru.Keyboard =
                            new KeyboardButton[][]
                        {
                            new KeyboardButton[]
                            {
                                new KeyboardButton(button11)
                            },
                            new KeyboardButton[]
                            {
                                new KeyboardButton(button2),
                                new KeyboardButton(button3),
                                new KeyboardButton(button4)
                            },
                            new KeyboardButton[]
                            {
                                new KeyboardButton(button5),
                                new KeyboardButton(button6),
                                new KeyboardButton(button7)
                            },
                            new KeyboardButton[]
                            {
                                new KeyboardButton(button8)
                            }
                        };
                        key_ru.ResizeKeyboard = true;



                        key_eng.Keyboard =
                            new KeyboardButton[][]
                        {
                            new KeyboardButton[]
                            {
                                new KeyboardButton(button1_eng)
                            },
                            new KeyboardButton[]
                            {
                                new KeyboardButton(button2_eng),
                                new KeyboardButton(button3_eng),
                                new KeyboardButton(button4_eng)
                            },
                            new KeyboardButton[]
                            {
                                new KeyboardButton(button5_eng),
                                new KeyboardButton(button6_eng),
                                new KeyboardButton(button7_eng)
                            },
                            new KeyboardButton[]
                            {
                                new KeyboardButton(button8_eng)
                            }
                        };
                        key_eng.ResizeKeyboard = true;


                        if (message.Text == "/start")
                        {
                            //Sql запрос проверка есть ли пользователь в базе.
                            MySqlCommand command1 = new MySqlCommand(id_proverka, connection);
                            command1.ExecuteNonQuery();
                            if (Convert.ToInt32(command1.ExecuteScalar()) == 0)
                            {
                                MySqlCommand command = new MySqlCommand(id_sql, connection);
                                command.ExecuteNonQuery();
                            }
                            //конец проверки
                            var language = new ReplyKeyboardMarkup();
                            language.Keyboard =
                                new KeyboardButton[][]
                            {
                                new KeyboardButton[]
                                {
                                    new KeyboardButton("🇷🇺 Russian"),
                                    new KeyboardButton("🇬🇧󠁧󠁢󠁥󠁮󠁧󠁿 English")
                                }
                            };
                            language.ResizeKeyboard  = true;
                            language.OneTimeKeyboard = true;
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Hello!", ParseMode.Html, false, true, 0, language);
                        }


                        if (message.From.Id == admin_id)
                        {
                            /*
                             * if (message.Text == "/admin")
                             * {
                             *
                             *
                             *  ///админка
                             *  //
                             *
                             * }
                             */
                            var mes = message.From.Id;



                            if (message.Text == "/eng")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Admin", ParseMode.Html, false, true, 0, admin_eng);
                            }
                            if (message.Text == "/rus")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Админ", ParseMode.Html, false, true, 0, admin);
                            }
                            if (message.Text == button11)
                            {
                                int          da       = message_id;
                                string       post     = @"UPDATE `tron`.`post` SET `Post_number` = '" + da + "' WHERE(`idPost` = '1')";
                                MySqlCommand command1 = new MySqlCommand(post, connection);
                                command1.ExecuteNonQuery();

                                await Bot.SendTextMessageAsync(message.Chat.Id, "Готово!", ParseMode.Html, false, true, 0, admin);
                            }

                            if (message.Text == button2)
                            {
                                int          da       = message_id;
                                string       post     = @"UPDATE `tron`.`post` SET `Post_number` = '" + da + "' WHERE(`idPost` = '2')";
                                MySqlCommand command1 = new MySqlCommand(post, connection);
                                command1.ExecuteNonQuery();

                                await Bot.SendTextMessageAsync(message.Chat.Id, "Готово!", ParseMode.Html, false, true, 0, admin);
                            }
                            if (message.Text == button3)
                            {
                                int          da       = message_id;
                                string       post     = @"UPDATE `tron`.`post` SET `Post_number` = '" + da + "' WHERE(`idPost` = '3')";
                                MySqlCommand command1 = new MySqlCommand(post, connection);
                                command1.ExecuteNonQuery();
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Готово!", ParseMode.Html, false, true, 0, admin);
                            }
                            if (message.Text == button4)
                            {
                                int          da       = message_id;
                                string       post     = @"UPDATE `tron`.`post` SET `Post_number` = '" + da + "' WHERE(`idPost` = '4')";
                                MySqlCommand command1 = new MySqlCommand(post, connection);
                                command1.ExecuteNonQuery();
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Готово!", ParseMode.Html, false, true, 0, admin);
                            }
                            if (message.Text == button6)
                            {
                                int          da       = message_id;
                                string       post     = @"UPDATE `tron`.`post` SET `Post_number` = '" + da + "' WHERE(`idPost` = '5')";
                                MySqlCommand command1 = new MySqlCommand(post, connection);
                                command1.ExecuteNonQuery();
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Готово!", ParseMode.Html, false, true, 0, admin);
                            }
                            if (message.Text == button7)
                            {
                                int          da       = message_id;
                                string       post     = @"UPDATE `tron`.`post` SET `Post_number` = '" + da + "' WHERE(`idPost` = '6')";
                                MySqlCommand command1 = new MySqlCommand(post, connection);
                                command1.ExecuteNonQuery();
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Готово!", ParseMode.Html, false, true, 0, admin);
                            }



                            if (message.Text == button1_eng)
                            {
                                int          da       = message_id;
                                string       post     = @"UPDATE `tron`.`post_eng` SET `Post_number` = '" + da + "' WHERE(`idPost` = '1')";
                                MySqlCommand command1 = new MySqlCommand(post, connection);
                                command1.ExecuteNonQuery();

                                await Bot.SendTextMessageAsync(message.Chat.Id, "Succes!", ParseMode.Html, false, true, 0, admin_eng);
                            }

                            if (message.Text == button2_eng)
                            {
                                int          da       = message_id;
                                string       post     = @"UPDATE `tron`.`post_eng` SET `Post_number` = '" + da + "' WHERE(`idPost` = '2')";
                                MySqlCommand command1 = new MySqlCommand(post, connection);
                                command1.ExecuteNonQuery();

                                await Bot.SendTextMessageAsync(message.Chat.Id, "Succes!", ParseMode.Html, false, true, 0, admin_eng);
                            }
                            if (message.Text == button3_eng)
                            {
                                int          da       = message_id;
                                string       post     = @"UPDATE `tron`.`post_eng` SET `Post_number` = '" + da + "' WHERE(`idPost` = '3')";
                                MySqlCommand command1 = new MySqlCommand(post, connection);
                                command1.ExecuteNonQuery();
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Succes!", ParseMode.Html, false, true, 0, admin_eng);
                            }
                            if (message.Text == button4_eng)
                            {
                                int          da       = message_id;
                                string       post     = @"UPDATE `tron`.`post_eng` SET `Post_number` = '" + da + "' WHERE(`idPost` = '4')";
                                MySqlCommand command1 = new MySqlCommand(post, connection);
                                command1.ExecuteNonQuery();
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Succes!", ParseMode.Html, false, true, 0, admin_eng);
                            }
                            if (message.Text == button6_eng)
                            {
                                int          da       = message_id;
                                string       post     = @"UPDATE `tron`.`post_eng` SET `Post_number` = '" + da + "' WHERE(`idPost` = '5')";
                                MySqlCommand command1 = new MySqlCommand(post, connection);
                                command1.ExecuteNonQuery();
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Succes!", ParseMode.Html, false, true, 0, admin_eng);
                            }
                            if (message.Text == button7_eng)
                            {
                                int          da       = message_id;
                                string       post     = @"UPDATE `tron`.`post_eng` SET `Post_number` = '" + da + "' WHERE(`idPost` = '6')";
                                MySqlCommand command1 = new MySqlCommand(post, connection);
                                command1.ExecuteNonQuery();
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Succes!", ParseMode.Html, false, true, 0, admin_eng);
                            }



                            if (message.Text == @"Send message")
                            {
                                MySqlCommand  command = new MySqlCommand("SELECT `Chat_id` FROM `tron`.`telegram`  WHERE(`Language` = 'ENG')", connection);
                                List <string> id      = new List <string>();
                                using (MySqlDataReader reader = command.ExecuteReader())
                                {
                                    while (reader.Read())
                                    {
                                        id.Add(reader[0].ToString());
                                    }
                                }
                                for (int i = 0; id.Count >= 0; i++)
                                {
                                    await Bot.SendTextMessageAsync(Convert.ToString(id[i]), message_text, ParseMode.Html, false, true, 0, key_eng);
                                }
                            }
                            if (message.Text == @"Отправить оповещение")
                            {
                                MySqlCommand  command = new MySqlCommand("SELECT `Chat_id` FROM `tron`.`telegram` WHERE(`Language` = 'RUS')", connection);
                                List <string> id      = new List <string>();
                                using (MySqlDataReader reader = command.ExecuteReader())
                                {
                                    while (reader.Read())
                                    {
                                        id.Add(reader[0].ToString());
                                    }
                                }
                                for (int i = 0; id.Count >= 0; i++)
                                {
                                    await Bot.SendTextMessageAsync(Convert.ToString(id[i]), message_text, ParseMode.Html, false, true, 0, key_ru);
                                }
                            }
                            message_text = message.Text;
                            if (message.From.IsBot == true || message.IsForwarded == true || message.ForwardFrom.IsBot == true)
                            {
                                message_id = message.MessageId;
                            }
                        }

                        if (message.Text == "🇷🇺 Russian")
                        {
                            skip.Keyboard =
                                new KeyboardButton[][]
                            {
                                new KeyboardButton[]
                                {
                                    new KeyboardButton("Пропустить")
                                }
                            };
                            skip.ResizeKeyboard  = true;
                            skip.OneTimeKeyboard = true;
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Привет, чтобы продолжить тебе нужно ввести свой TRON (TRX) кошелек.", ParseMode.Html, false, true, 0, skip);

                            MySqlCommand command = new MySqlCommand(language_sql_rus, connection);
                            command.ExecuteNonQuery();
                        }
                        if (message.Text == "🇬🇧󠁧󠁢󠁥󠁮󠁧󠁿 English")
                        {
                            skip.Keyboard =
                                new KeyboardButton[][]
                            {
                                new KeyboardButton[]
                                {
                                    new KeyboardButton("Skip")
                                }
                            }; skip.ResizeKeyboard = true;
                            skip.OneTimeKeyboard   = true;
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Hello, send me your TRON (TRX) wallet.", ParseMode.Html, false, true, 0, skip);

                            MySqlCommand command = new MySqlCommand(language_sql_eng, connection);
                            command.ExecuteNonQuery();
                        }



                        if (s == "RUS")
                        {
                            main.Keyboard =
                                new KeyboardButton[][]
                            {
                                new KeyboardButton[]
                                {
                                    new KeyboardButton(button11)
                                },
                                new KeyboardButton[]
                                {
                                    new KeyboardButton(button2),
                                    new KeyboardButton(button3),
                                    new KeyboardButton(button4)
                                },
                                new KeyboardButton[]
                                {
                                    new KeyboardButton(button5),
                                    new KeyboardButton(button6),
                                    new KeyboardButton(button7)
                                },
                                new KeyboardButton[]
                                {
                                    new KeyboardButton(button8)
                                }
                            };
                            main.ResizeKeyboard = true;
                        }
                        else
                        {
                            skip.Keyboard =
                                new KeyboardButton[][]
                            {
                                new KeyboardButton[]
                                {
                                    new KeyboardButton("Skip")
                                }
                            };

                            main.Keyboard =
                                new KeyboardButton[][]
                            {
                                new KeyboardButton[]
                                {
                                    new KeyboardButton(button1_eng)
                                },
                                new KeyboardButton[]
                                {
                                    new KeyboardButton(button2_eng),
                                    new KeyboardButton(button3_eng),
                                    new KeyboardButton(button4_eng)
                                },
                                new KeyboardButton[]
                                {
                                    new KeyboardButton(button5_eng),
                                    new KeyboardButton(button6_eng),
                                    new KeyboardButton(button7_eng)
                                },
                                new KeyboardButton[]
                                {
                                    new KeyboardButton(button8_eng)
                                }
                            };
                            main.ResizeKeyboard = true;
                        }
                        if (message.Type == Telegram.Bot.Types.Enums.MessageType.Text & message.From.Id != admin_id)
                        {
                            string patertn = @"T+\w{33}";


                            foreach (Match match in Regex.Matches(message.Text, patertn))
                            {
                                //запрос языка

                                if (s == "RUS")
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "Адресс добавлен в БД", ParseMode.Html, false, true, 0, main);
                                }
                                else
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "Success", ParseMode.Html, false, true, 0, main);
                                }



                                string da = message.Text;

                                //Добавление trx кошелька
                                string Wallet = @"UPDATE `tron`.`telegram` SET `Wallet` = '" + da + "' WHERE(`Chat_id` = '" + message.Chat.Id + "')";

                                MySqlCommand command = new MySqlCommand(Wallet, connection);
                                command.ExecuteNonQuery();
                            }

                            if (message.Text == @"Пропустить")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Добро пожаловать в бота 888TRON!", ParseMode.Html, false, true, 0, main);
                            }
                            if (message.Text == @"Skip")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Welcome to the 888TRON bot!", ParseMode.Html, false, true, 0, main);
                            }



                            //// eng
                            ///
                            if (message.Text == button1_eng)
                            {
                                await Bot.ForwardMessageAsync(message.Chat.Id, admin_id, Kryp_win_eng);
                            }
                            if (message.Text == button2_eng)
                            {
                                await Bot.ForwardMessageAsync(message.Chat.Id, admin_id, O_nas_eng);
                            }

                            if (message.Text == button3_eng)
                            {
                                await Bot.ForwardMessageAsync(message.Chat.Id, admin_id, News_eng);
                            }
                            if (message.Text == button4_eng)
                            {
                                await Bot.ForwardMessageAsync(message.Chat.Id, admin_id, Event_eng);
                            }

                            if (message.Text == button6_eng)
                            {
                                await Bot.ForwardMessageAsync(message.Chat.Id, admin_id, Social_eng);
                            }
                            if (message.Text == button7_eng)
                            {
                                await Bot.ForwardMessageAsync(message.Chat.Id, admin_id, Help_eng);
                            }



                            if (message.Text == button11)
                            {
                                await Bot.ForwardMessageAsync(message.Chat.Id, admin_id, Kryp_win_rus);
                            }
                            if (message.Text == button2)
                            {
                                await Bot.ForwardMessageAsync(message.Chat.Id, admin_id, O_nas_rus);
                            }

                            if (message.Text == button3)
                            {
                                await Bot.ForwardMessageAsync(message.Chat.Id, admin_id, News_rus);
                            }
                            if (message.Text == button4)
                            {
                                await Bot.ForwardMessageAsync(message.Chat.Id, admin_id, Event_rus);
                            }

                            if (message.Text == button6)
                            {
                                await Bot.ForwardMessageAsync(message.Chat.Id, admin_id, Social_rus);
                            }
                            if (message.Text == button7)
                            {
                                await Bot.ForwardMessageAsync(message.Chat.Id, admin_id, Help_rus);
                            }

                            if (message.Text == button8)
                            {
                                string lastPrice;
                                string _24change;
                                string high;
                                string full;
                                string low;
                                string volume;

                                string json = @"{""operationName"":null,""variables"":{},""query"":""{\n exchange(id: 12) {\n stats {\n lastPrice\n h24_change\n high\n low\n volume\n    }\n  }\n}\n""}";

                                var httpRequest = (HttpWebRequest)WebRequest.Create("https://trontrade.io/graphql");
                                httpRequest.Method      = "POST";
                                httpRequest.ContentType = "application/json; charset=utf-8";
                                using (var requestStream = httpRequest.GetRequestStream())
                                    using (var writer = new StreamWriter(requestStream))
                                    {
                                        writer.Write(json);
                                    }
                                using (var httpResponse = httpRequest.GetResponse())
                                    using (var responseStream = httpResponse.GetResponseStream())
                                        using (var reader = new StreamReader(responseStream))
                                        {
                                            string response = reader.ReadToEnd();
                                            full = response;
                                        }
                                MatchCollection matchList = Regex.Matches(full, @"([0-9])+?(.[0-9]+)");
                                var             list      = matchList.Cast <Match>().Select(match => match.Value).ToList();



                                lastPrice = Convert.ToString(Convert.ToDouble(list[0]) / 1000000);
                                _24change = Convert.ToString(list[1]);
                                high      = Convert.ToString(Convert.ToDouble(list[2]) / 1000000);
                                low       = Convert.ToString(Convert.ToDouble(list[3]) / 1000000);
                                volume    = Convert.ToString(Convert.ToDouble(list[4]) / 1000000);

                                volume = volume.Substring(0, volume.Length - 4);
                                volume = Convert.ToString(volume);

                                WebRequest send = WebRequest.Create("https://888tron.com/api1/getDividends");
                                send.Method = "POST";

                                string divedent_bad;
                                using (WebResponse result = send.GetResponse())
                                {
                                    StreamReader reader = new StreamReader(result.GetResponseStream());
                                    divedent_bad = reader.ReadToEnd();
                                }
                                string divedent = System.Text.RegularExpressions.Regex.Match(divedent_bad, @"(-)?[0-9]+").Groups[0].Value;

                                divedent = divedent.Substring(0, divedent.Length - 6);
                                double divedent_good = Convert.ToDouble(divedent);
                                divedent = divedent_good.ToString("#,#", CultureInfo.InvariantCulture);

                                // tron888 =date - DateTime.Now;
                                //string time = Convert.ToString(date.Hour + ":" + tron888.Minutes + ":" + tron888.Seconds);
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Доступные Дивиденды: " + divedent + " TRX" + "\nВыплата через: " + Times.Days + ":" + Times.Hours + ":" + Times.Minutes + ":" + Times.Seconds + "\nPrice: " + lastPrice + " TRX (" + _24change + "%)" + "\n24H High: " + high + " TRX" + "\n24H Low: " + low + " TRX" + "\n24H Volume: " + volume + " 888", ParseMode.Html, false, true, 0, main);
                            }

                            if (message.Text == button8_eng)
                            {
                                string lastPrice;
                                string _24change;
                                string high;
                                string full;
                                string low;
                                string volume;

                                string json = @"{""operationName"":null,""variables"":{},""query"":""{\n exchange(id: 12) {\n stats {\n lastPrice\n h24_change\n high\n low\n volume\n    }\n  }\n}\n""}";

                                var httpRequest = (HttpWebRequest)WebRequest.Create("https://trontrade.io/graphql");
                                httpRequest.Method      = "POST";
                                httpRequest.ContentType = "application/json; charset=utf-8";
                                using (var requestStream = httpRequest.GetRequestStream())
                                    using (var writer = new StreamWriter(requestStream))
                                    {
                                        writer.Write(json);
                                    }
                                using (var httpResponse = httpRequest.GetResponse())
                                    using (var responseStream = httpResponse.GetResponseStream())
                                        using (var reader = new StreamReader(responseStream))
                                        {
                                            string response = reader.ReadToEnd();
                                            full = response;
                                        }
                                MatchCollection matchList    = Regex.Matches(full, @"([0-9])+?(.[0-9]+)");
                                var             list         = matchList.Cast <Match>().Select(match => match.Value).ToList();
                                CultureInfo     temp_culture = Thread.CurrentThread.CurrentCulture;
                                Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");


                                lastPrice = (Convert.ToDouble(list[0]) / 1000000).ToString();
                                _24change = list[1];
                                high      = ((Convert.ToDouble(list[2]) / 1000000)).ToString();
                                low       = ((Convert.ToDouble(list[3]) / 1000000)).ToString();
                                volume    = ((Convert.ToDouble(list[4]) / 1000000)).ToString();

                                volume = volume.Substring(0, volume.Length - 4);

                                WebRequest send = WebRequest.Create("https://888tron.com/api1/getDividends");
                                send.Method = "POST";

                                string divedent_bad;
                                using (WebResponse result = send.GetResponse())
                                {
                                    StreamReader reader = new StreamReader(result.GetResponseStream());
                                    divedent_bad = reader.ReadToEnd();
                                }
                                string divedent = System.Text.RegularExpressions.Regex.Match(divedent_bad, @"(-)?[0-9]+").Groups[0].Value;

                                divedent = divedent.Substring(0, divedent.Length - 6);
                                double divedent_good = Convert.ToDouble(divedent);
                                string divedent222   = divedent_good.ToString("#,#", CultureInfo.InvariantCulture);


                                // tron888 =date - DateTime.Now;
                                //string time = Convert.ToString(date.Hour + ":" + tron888.Minutes + ":" + tron888.Seconds);
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Available Dividends: " + divedent222 + " TRX" + "\nDividends Countdown: " + Times.Days + ":" + Times.Hours + ":" + Times.Minutes + ":" + Times.Seconds + "\nPrice: " + lastPrice + " TRX (" + _24change + "%)" + "\n24H High: " + high + " TRX" + "\n24H Low: " + low + " TRX" + "\n24H Volume: " + volume + " 888", ParseMode.Html, false, true, 0, main);
                            }

                            if (message.Text == button5_eng)
                            {
                                var button = new InlineKeyboardButton {
                                    Url = "https://t.me/tron888 ", Text = "🇬🇧󠁧󠁢󠁥󠁮󠁧󠁿 English chat"
                                };
                                var markup = new InlineKeyboardMarkup(button);
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Press the button 👇", replyMarkup : markup);
                            }
                            if (message.Text == button5)
                            {
                                var button = new InlineKeyboardButton {
                                    Url = "https://t.me/Tron888rus", Text = "🇷🇺 Русский чат"
                                };
                                var markup = new InlineKeyboardMarkup(button);
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Нажмите на кнопку 👇", replyMarkup : markup);
                            }
                        }
                    }
                    catch
                    {
                    }
                };

                Bot.StartReceiving();

                // запускаем прием обновлений
            }

            catch (Telegram.Bot.Exceptions.ApiRequestException ex)
            {
                Console.WriteLine(ex.Message); // если ключ не подошел - пишем об этом в консоль отладки
            }
        }
Exemple #24
0
        async void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            var worker = sender as BackgroundWorker;
            var key    = e.Argument as String;

            try
            {
                var Bot = new Telegram.Bot.TelegramBotClient(key);
                await Bot.SetWebhookAsync("");

                Bot.OnInlineQuery += async(object si, Telegram.Bot.Args.InlineQueryEventArgs ei) =>
                {
                    var query = ei.InlineQuery.Query;

                    var msg = new Telegram.Bot.Types.InputMessageContents.InputTextMessageContent
                    {
                        ParseMode = Telegram.Bot.Types.Enums.ParseMode.Html,
                    };

                    Telegram.Bot.Types.InlineQueryResults.InlineQueryResult[] results =
                    {
                        new Telegram.Bot.Types.InlineQueryResults.InlineQueryResultArticle
                        {
                        },
                        new Telegram.Bot.Types.InlineQueryResults.InlineQueryResultAudio
                        {
                        },
                        new Telegram.Bot.Types.InlineQueryResults.InlineQueryResultPhoto
                        {
                        },
                        new Telegram.Bot.Types.InlineQueryResults.InlineQueryResultVideo
                        {
                        }
                    };


                    await Bot.AnswerInlineQueryAsync(ei.InlineQuery.Id, results);
                };

                Bot.OnUpdate += async(object su, Telegram.Bot.Args.UpdateEventArgs evu) =>
                {
                    if (evu.Update.CallbackQuery != null || evu.Update.InlineQuery != null)
                    {
                        return;
                    }
                    var update  = evu.Update;
                    var message = update.Message;
                    //пусть будут чрезвычайно длинные строки, мне лень делать что-то умное, ключ апи раздают всем подряд, палить его не боюсь
                    var randomRestaurantUrl =
                        "https://search-maps.yandex.ru/v1/?apikey=0d7404f4-957c-4116-b9a3-efe9fc40fbc7&results=500&text=Куда сходить пообедать баумана казань&lang=ru_RU&type=biz";
                    var buhichUrl = "https://search-maps.yandex.ru/v1/?apikey=0d7404f4-957c-4116-b9a3-efe9fc40fbc7&results=500&text=Куда сходить выпить пива баумана казань&lang=ru_RU&type=biz";
                    if (message == null)
                    {
                        return;
                    }
                    if (message.Type == Telegram.Bot.Types.Enums.MessageType.TextMessage)
                    {
                        if (message.Text == "/кудакушац")
                        {
                            string[] restaurants = { "Арома", "The Woods", "Brownbear", "ТЫ ПИДОР", "Big Butcher Grill", "OmNomNom", "Rock'n'Roll'ы", "Черный ящик", "Wok and Go", "Agafredo", "Твин Пикс", "KFC", "Тринити", "МАКДАК", "Бивень", "Соль", "The Тёлки", "Бинхартс" };
                            //хотел отправлять фотки, но потом стало лень их заливать
                            //string[] restaurantsPhotos = { "AgADAgAD5KkxG-nNgUsmW5IeJEGSBBIySw0ABA_maPNgEFdds1gRAAEC"};
                            //var randomPhoto = restaurantsPhotos[new Random().Next(0, restaurantsPhotos.Length)];
                            var randomCommand = restaurants[new Random().Next(0, restaurants.Length)];
                            //var photos = new Telegram.Bot.Types.FileToSend { FileId = randomPhoto };
                            string outputText = randomCommand + " - это место куда ты сегодня пойдешь обедать";
                            await Bot.SendTextMessageAsync(message.Chat.Id, outputText, replyToMessageId : message.MessageId);

                            //await Bot.SendPhotoAsync(message.Chat.Id, photos, replyToMessageId: message.MessageId);
                        }

                        if (message.Text == "/кудахавать")
                        {
                            await Bot.SendTextMessageAsync(message.Chat.Id, YandexRandomiser.GetRandomSearchResult(randomRestaurantUrl).Result, replyToMessageId : message.MessageId);
                        }

                        if (message.Text == "/кудабухать")
                        {
                            await Bot.SendTextMessageAsync(message.Chat.Id, YandexRandomiser.GetRandomSearchResult(buhichUrl).Result, replyToMessageId : message.MessageId);
                        }
                    }
                };

                // запускаем прием обновлений
                Bot.StartReceiving();
            }
            catch (Telegram.Bot.Exceptions.ApiRequestException ex)
            {
                Console.WriteLine(ex.Message); // если ключ не подошел - пишем об этом в консоль отладки
            }
        }
        async void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            var worker = sender as BackgroundWorker;
            int Answer = 0;

            var key = e.Argument as String;

            try
            {
                var Bot = new Telegram.Bot.TelegramBotClient(key);
                await Bot.SetWebhookAsync("");

                Bot.OnUpdate += async(object su, Telegram.Bot.Args.UpdateEventArgs evu) =>
                {
                    if (evu.Update.CallbackQuery != null || evu.Update.InlineQuery != null)
                    {
                        return;
                    }
                    var update  = evu.Update;
                    var message = update.Message;
                    if (message == null)
                    {
                        return;
                    }
                    if (message.Type == Telegram.Bot.Types.Enums.MessageType.TextMessage)
                    {
                        if (Answer == 0)
                        {
                            if (message.Text == "Начал" | message.Text == "начал")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Над чем Вы начали работать?", replyToMessageId : message.MessageId);

                                Answer = 1;
                                return;
                            }
                            if (message.Text == "Готово" | message.Text == "готово")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Молодец");

                                DBConnect qwe = new DBConnect();
                                qwe.Update(name);

                                return;
                            }
                            if (message.Text == "Отчет" | message.Text == "отчет")
                            {
                                DBConnect dsa = new DBConnect();
                                dsa.Select();
                            }
                        }
                        if (Answer == 1)
                        {
                            name = message.Text;
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Окей, какая сложность задачи (от 0 до 10)?!");

                            Answer = 2;
                            return;
                        }
                        if (Answer == 2)
                        {
                            String s = message.Chat.Id.ToString();
                            level = message.Text;
                            Regex regex = new Regex("[0-9]");
                            //   int nlevel = int.Parse(level.ToString());
                            bool       check;
                            Validation qw = new Validation();
                            check = qw.ValidLevel(level);
                            if (check == false)
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Неверный формат, попробуйте еще раз");

                                return;
                            }
                            else
                            {
                                DBConnect qwe = new DBConnect();
                                qwe.Insert(message.Chat.FirstName, message.Chat.LastName, s, name, level, DateTime.Now);

                                Answer = 0;
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Напишите 'Готово', как закончите");

                                return;
                            }
                        }
                    }
                };


                Bot.StartReceiving();
            }
            catch (Telegram.Bot.Exceptions.ApiRequestException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
        async void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            var  worker  = sender as BackgroundWorker;
            bool isSub   = false;
            bool isUnSub = false;
            var  key     = e.Argument as String;

            try
            {
                var Bot = new Telegram.Bot.TelegramBotClient(key);
                await Bot.SetWebhookAsync("");

                Bot.OnCallbackQuery += async(object sc, Telegram.Bot.Args.CallbackQueryEventArgs ev) =>
                {
                    var message = ev.CallbackQuery.Message;
                    switch (ev.CallbackQuery.Data)
                    {
                    case "VEHICLENUMBER":
                    {
                        await Bot.AnswerCallbackQueryAsync(ev.CallbackQuery.Id, "Please enter /find;VEHICLENUMBER;Your VEHICLENUMBER:", true);
                    }
                    break;

                    case "BODYNUMBER":
                    {
                        await Bot.AnswerCallbackQueryAsync(ev.CallbackQuery.Id, "Please enter /find;BODYNUMBER;Your BODYNUMBER:", true);
                    }
                    break;

                    case "ENGINENUMBER":
                    {
                        await Bot.AnswerCallbackQueryAsync(ev.CallbackQuery.Id, "Please enter /find;ENGINENUMBER;Your ENGINENUMBER:", true);
                    }
                    break;

                    default:
                        break;
                    }
                };
                Bot.OnUpdate += async(object su, Telegram.Bot.Args.UpdateEventArgs evu) =>
                {
                    if (evu.Update.CallbackQuery != null || evu.Update.InlineQuery != null)
                    {
                        return;
                    }
                    var update   = evu.Update;
                    var message  = update.Message;
                    var messages = message.Text.Split(';');
                    if (message == null)
                    {
                        return;
                    }
                    if (message.Type == Telegram.Bot.Types.Enums.MessageType.Text)
                    {
                        if (message.Text == "/test")
                        {
                            await Bot.SendTextMessageAsync(message.Chat.Id, "test",
                                                           replyToMessageId : message.MessageId);
                        }
                        else if (message.Text == "/check")
                        {
                            List <CarInfo> result = checkCarForUserSubscribes();
                            if (result.Count > 0)
                            {
                                foreach (var car in result)
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "This car was found\n" + "ID:" + car.Id + "\n" +
                                                                   "Місце реєстрації:" + car.OVD + "\n" +
                                                                   "Бренд:" + car.BRAND + "\n" +
                                                                   "Колір:" + car.COLOR + "\n" +
                                                                   "Державний номер:" + car.VEHICLENUMBER + "\n" +
                                                                   "Номер кузову:" + car.BODYNUMBER + "\n" +
                                                                   "Номер шасі:" + car.CHASSISNUMBER + "\n" +
                                                                   "Номер двигуна:" + car.ENGINENUMBER + "\n" +
                                                                   "Дата викрадення:" + car.THEFT_DATA + "\n" +
                                                                   "Дата додавання в сховище:" + car.INSERT_DATE + "\n");
                                }
                            }
                            else
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Nothing found by your request.");
                            }
                        }
                        else if (message.Text == "/subscribe")
                        {
                            getUsers();
                            isSub = true;
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Please write car number to subscribe on it",
                                                           replyToMessageId : message.MessageId);
                        }
                        else if (isSub)
                        {
                            if (CheckIfUserExist(message.Chat.Id.ToString()))
                            {
                                UserSubscribes user = new UserSubscribes
                                {
                                    Id         = message.Chat.Id.ToString(),
                                    Name       = message.Chat.Username,
                                    Subscribes = new List <string>()
                                    {
                                        message.Text
                                    }
                                };
                                users.Add(user);
                                setUsers(user);
                                await Bot.SendTextMessageAsync(message.Chat.Id, "You have been subscribed on " + message.Text);
                            }
                            else
                            {
                                foreach (var user in users)
                                {
                                    if (user.Id == message.Chat.Id.ToString())
                                    {
                                        user.Subscribes.Add(message.Text);
                                        updateUsers(user.Id, message.Text);
                                    }
                                }
                                await Bot.SendTextMessageAsync(message.Chat.Id, "You have been subscribed on " + message.Text);
                            }
                            isSub = false;
                        }
                        else if (message.Text == "/find")
                        {
                            var keyboard = new InlineKeyboardMarkup(
                                new InlineKeyboardButton[][]
                            {
                                new [] {
                                    new InlineKeyboardButton
                                    {
                                        Text         = "VEHICLENUMBER",
                                        CallbackData = "VEHICLENUMBER"
                                    },
                                    new InlineKeyboardButton
                                    {
                                        Text         = "BODYNUMBER",
                                        CallbackData = "BODYNUMBER"
                                    },
                                    new InlineKeyboardButton
                                    {
                                        Text         = "ENGINENUMBER",
                                        CallbackData = "ENGINENUMBER"
                                    },
                                },
                            }
                                );
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Choose parameter which bot will use to find:", Telegram.Bot.Types.Enums.ParseMode.Default, false, false, 0, keyboard);
                        }
                        else if (messages[0] == "/find" && messages[1] == "VEHICLENUMBER")
                        {
                            List <CarInfo> carInfos = FindCar(messages[1], messages[2]);
                            if (carInfos.Count > 0)
                            {
                                foreach (var car in carInfos)
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "This car was found\n" + "ID:" + car.Id + "\n" +
                                                                   "Місце реєстрації:" + car.OVD + "\n" +
                                                                   "Бренд:" + car.BRAND + "\n" +
                                                                   "Колір:" + car.COLOR + "\n" +
                                                                   "Державний номер:" + car.VEHICLENUMBER + "\n" +
                                                                   "Номер кузову:" + car.BODYNUMBER + "\n" +
                                                                   "Номер шасі:" + car.CHASSISNUMBER + "\n" +
                                                                   "Номер двигуна:" + car.ENGINENUMBER + "\n" +
                                                                   "Дата викрадення:" + car.THEFT_DATA + "\n" +
                                                                   "Дата додавання в сховище:" + car.INSERT_DATE + "\n");
                                }
                            }
                            else
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Didn't found any car by this request.");
                            }
                        }
                        else if (messages[0] == "/find" && messages[1] == "BODYNUMBER")
                        {
                            List <CarInfo> carInfos = FindCar(messages[1], messages[2]);
                            if (carInfos.Count > 0)
                            {
                                foreach (var car in carInfos)
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "This car was found\n" + "ID:" + car.Id + "\n" +
                                                                   "Місце реєстрації:" + car.OVD + "\n" +
                                                                   "Бренд:" + car.BRAND + "\n" +
                                                                   "Колір:" + car.COLOR + "\n" +
                                                                   "Державний номер:" + car.VEHICLENUMBER + "\n" +
                                                                   "Номер кузову:" + car.BODYNUMBER + "\n" +
                                                                   "Номер шасі:" + car.CHASSISNUMBER + "\n" +
                                                                   "Номер двигуна:" + car.ENGINENUMBER + "\n" +
                                                                   "Дата викрадення:" + car.THEFT_DATA + "\n" +
                                                                   "Дата додавання в сховище:" + car.INSERT_DATE + "\n");
                                }
                            }
                            else
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Didn't found any car by this request.");
                            }
                        }
                        else if (messages[0] == "/find" && messages[1] == "ENGINENUMBER")
                        {
                            List <CarInfo> carInfos = FindCar(messages[1], messages[2]);
                            if (carInfos.Count > 0)
                            {
                                foreach (var car in carInfos)
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "This car was found\n" + "ID:" + car.Id + "\n" +
                                                                   "Місце реєстрації:" + car.OVD + "\n" +
                                                                   "Бренд:" + car.BRAND + "\n" +
                                                                   "Колір:" + car.COLOR + "\n" +
                                                                   "Державний номер:" + car.VEHICLENUMBER + "\n" +
                                                                   "Номер кузову:" + car.BODYNUMBER + "\n" +
                                                                   "Номер шасі:" + car.CHASSISNUMBER + "\n" +
                                                                   "Номер двигуна:" + car.ENGINENUMBER + "\n" +
                                                                   "Дата викрадення:" + car.THEFT_DATA + "\n" +
                                                                   "Дата додавання в сховище:" + car.INSERT_DATE + "\n");
                                }
                            }
                            else
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Didn't found any car by this request.");
                            }
                        }
                        else if (message.Text == "/unsubscribe")
                        {
                            getUsers();
                            isUnSub = true;
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Please write car number to unsubscribe from it",
                                                           replyToMessageId : message.MessageId);
                        }
                        else if (isUnSub)
                        {
                            if (!CheckIfUserExist(message.Chat.Id.ToString()))
                            {
                                foreach (var user in users)
                                {
                                    if (user.Id == message.Chat.Id.ToString())
                                    {
                                        user.Subscribes.Remove(message.Text);
                                        setUsers(user);
                                    }
                                }
                                await Bot.SendTextMessageAsync(message.Chat.Id, "You have been unsubscribed from " + message.Text);
                            }
                            else
                            {
                                foreach (var user in users)
                                {
                                    if (user.Id == message.Chat.Id.ToString())
                                    {
                                        user.Subscribes.Add(message.Text);
                                        updateUsers(user.Id, message.Text);
                                    }
                                }
                                await Bot.SendTextMessageAsync(message.Chat.Id, "You have been unsubscribed from " + message.Text);
                            }
                            isUnSub = false;
                        }
                        else if (message.Text == "/help")
                        {
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Available commands:\n/find - check parameter to find a car\n/subscribe - subscribe on car number\n/unsubscribe - unsubscribe from car number\n/check - check your subscribes in database");
                        }
                        else
                        {
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Unknown command. Try /help to see list of commands");
                        }
                    }
                };

                Bot.StartReceiving();
            }
            catch (Telegram.Bot.Exceptions.ApiRequestException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
Exemple #27
0
        async void launchWorkerAsync(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker worker = sender as BackgroundWorker;
            string           key    = e.Argument as String;

            try
            {
                Bot = new Telegram.Bot.TelegramBotClient(key);
                await Bot.SetWebhookAsync("");

                int offset = 0;
                while (true)
                {
                    var messages = await Bot.GetUpdatesAsync(offset);

                    foreach (var message in messages)
                    {
                        var  msgText = message.Message;
                        User currentUser;
                        if (users.ContainsKey(msgText.Chat.Id))
                        {
                            currentUser = users[msgText.Chat.Id];
                        }
                        else
                        {
                            currentUser = new User("Уважаемый", bot);

                            currentUser.Predicates.addSetting("favouriteanimal", "default");
                            currentUser.Predicates.addSetting("name", "default");

                            users[msgText.Chat.Id] = currentUser;
                        }

                        if (msgText.Type == Telegram.Bot.Types.Enums.MessageType.Text && msgText.Text.Contains("/game"))
                        {
                            string text = msgText.Text;
                            text = text.Replace("/game ", "");
                            string[] clues = text.Split(',');
                            clues = clues.Select(x => x.Trim().ToLower()).ToArray();
                            List <string> games = Program.SetupFacts(clues.ToList(), "");
                            if (games.Count == 0)
                            {
                                await Bot.SendTextMessageAsync(msgText.Chat.Id, "Не знаю таких игра :(");
                            }
                            else
                            {
                                string res = games.Aggregate((i, j) => i + '?' + j);
                                res += '?';
                                await Bot.SendTextMessageAsync(msgText.Chat.Id, "Я что-то такое знаю. " + res);
                            }
                        }
                        else if (msgText.Type == Telegram.Bot.Types.Enums.MessageType.Text)
                        {
                            Console.WriteLine(msgText.Text.ToUpper());
                            Request r   = new Request(msgText.Text, currentUser, bot);
                            Result  res = bot.Chat(r);
                            if (res.Output != "")
                            {
                                if (res.Output.EndsWith(".jpg."))
                                {
                                    await Bot.SendPhotoAsync(msgText.Chat.Id, res.Output.Remove(res.Output.Count() - 1, 1));
                                }
                                else if (res.Output == "time.")
                                {
                                    var time = "У меня " + DateTime.Now.Hour.ToString() + ":" + DateTime.Now.Minute.ToString() + ", сколько у вас - не знаю";
                                    await Bot.SendTextMessageAsync(msgText.Chat.Id, time);
                                }
                                else if (res.Output == "foot.")
                                {
                                    string table = football.getTable();
                                    await Bot.SendTextMessageAsync(msgText.Chat.Id, table);
                                }
                                else if (res.Output == "anec.")
                                {
                                    string anec = Anecdot.anec();
                                    await Bot.SendTextMessageAsync(msgText.Chat.Id, anec);
                                }
                                else if (res.Output == "voice.")
                                {
                                    string anec = Anecdot.anec();

                                    SpeechSynthesizer speaker = new SpeechSynthesizer();

                                    speaker.Rate   = 2;
                                    speaker.Volume = 100;

                                    speaker.Speak(anec);

                                    speaker.SetOutputToWaveFile("soundfile.wav");
                                    speaker.Speak(anec + "\n АХАХАХАХАХАХ");
                                    speaker.SetOutputToDefaultAudioDevice();

                                    var fStream = new FileStream("soundfile.wav", FileMode.OpenOrCreate);
                                    await Bot.SendVoiceAsync(msgText.Chat.Id, new Telegram.Bot.Types.InputFiles.InputOnlineFile(fStream));

                                    fStream.Dispose();
                                }
                                else if (res.Output == "beauty.")
                                {
                                    var fStream = new FileStream("..\\..\\1beauty.jpg", FileMode.OpenOrCreate);
                                    await Bot.SendPhotoAsync(msgText.Chat.Id, new Telegram.Bot.Types.InputFiles.InputOnlineFile(fStream), "Красивее не сыскать");
                                }
                                else if (res.Output.Contains("poetryFlag"))
                                {
                                    var poem = res.Output.Replace("poetryFlag", "");
                                    SpeechSynthesizer speaker = new SpeechSynthesizer();

                                    speaker.Rate   = 2;
                                    speaker.Volume = 100;

                                    speaker.SetOutputToWaveFile("soundfile.wav");
                                    speaker.Speak(poem);
                                    speaker.SetOutputToDefaultAudioDevice();

                                    var fStream = new FileStream("soundfile.wav", FileMode.OpenOrCreate);
                                    await Bot.SendVoiceAsync(msgText.Chat.Id, new Telegram.Bot.Types.InputFiles.InputOnlineFile(fStream));

                                    fStream.Dispose();
                                }
                                else
                                {
                                    await Bot.SendTextMessageAsync(msgText.Chat.Id, res.Output);
                                }
                            }
                        }
                        else if (msgText.Type == Telegram.Bot.Types.Enums.MessageType.Photo)
                        {
                            ProcessImage(msgText.Photo[msgText.Photo.Length - 1].FileId, "", msgText.Chat.Id);
                        }
                        offset = message.Id + 1;
                    }
                }
            }
            catch (Telegram.Bot.Exceptions.ApiRequestException exception)
            {
                Console.WriteLine(exception.Message);
                asyncWorker.RunWorkerAsync("999037946:AAHbd0xIjp5l6iS0aGuVB-jIP2R4a99EUFo");
            }
        }
Exemple #28
0
        async void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            bool answer    = false;
            var  translate = new Translate();
            var  worker    = sender as BackgroundWorker;

            Telegram.Bot.Types.User u = new Telegram.Bot.Types.User();
            var key = e.Argument as String;

            try
            {
                var Bot = new Telegram.Bot.TelegramBotClient(key);
                await Bot.SetWebhookAsync("");

                int offset = 0;
                while (true)
                {
                    var updates = await Bot.GetUpdatesAsync(offset);

                    foreach (var update in updates)
                    {
                        var message = update.Message;
                        if (message == null)
                        {
                            continue;
                        }/*
                          * if ((message.Type == Telegram.Bot.Types.Enums.MessageType.StickerMessage)&&(message.From.FirstName=="Infinity"))
                          * await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);*/
                        if (message.Type == Telegram.Bot.Types.Enums.MessageType.TextMessage)
                        {
                            //music

                            /*if(message.Text.Contains("/music"))
                             * {
                             *  Telegram.Bot.Types.FileToSend f = new Telegram.Bot.Types.FileToSend("https://www.dropbox.com/s/1nwbwwe8d4m58uk/Death%20Note%20-%20L%27s%20Theme%20%28full%29.mp3");
                             *  await Bot.SendDocumentAsync(message.Chat.Id, f, "here it`s");
                             * }*/
                            //crypt
                            DateTime d = DateTime.Now;
                            if (d.Minute % 15 == 0)
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "vote for AA!");
                            }
                            if (message.Text.Contains("/encrypt"))
                            {
                                EnCrypt crypt = new EnCrypt();

                                try
                                {
                                    string[] s   = message.Text.Split(' ').ToArray();
                                    string   res = crypt.EncryptOrDecrypt(message.Text.Substring(message.Text.IndexOf("t") + 2), "1234");
                                    await Bot.SendTextMessageAsync(message.Chat.Id, res, replyToMessageId : message.MessageId);
                                }
                                catch (Exception)
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "error", replyToMessageId : message.MessageId);
                                }
                                try
                                {
                                    await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);
                                }
                                catch (Exception)
                                {
                                }
                            }

                            //rev
                            if (message.Text.ToLower().Contains("/realrevolution"))
                            {
                                try
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "It`s a revolution.", replyToMessageId : message.MessageId);

                                    await Bot.SendTextMessageAsync(message.Chat.Id, "В основном(5 человек) поддержали идею свержения Дани за:");

                                    await Bot.SendTextMessageAsync(message.Chat.Id, "•	Смену названия группы");

                                    await Bot.SendTextMessageAsync(message.Chat.Id, "•	Ненависть к аниме");

                                    await Bot.SendTextMessageAsync(message.Chat.Id, "•	Нечестные глосования(накрутка)");

                                    await Bot.SendTextMessageAsync(message.Chat.Id, "Итак, мы свергаем его, и всеми банами/нарушениями будет заниматся БОТ. Только система будет определять меру присечения человека.");

                                    await Bot.SendTextMessageAsync(message.Chat.Id, "Админами будут я Бот, и тот, кого выберут на новом голо-и.");

                                    await Bot.SetChatTitleAsync(message.Chat.Id, "AAA club oficial");
                                }
                                catch (Exception)
                                {
                                }
                            }
                            //ban

                            if (message.Text.ToLower().Contains("/ban"))
                            {
                                var ban = new Ban();
                                try
                                {
                                    ban.GetMessage(message.Text);
                                }
                                catch (Exception)
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, message.From.FirstName + " " + message.From.LastName + "(" + message.From.Username + " pidor ne lamay bota");
                                }

                                if (ban.NeedToBan())
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "Sviatoslav(@pauchok1love) ban please " + ban.Name(), replyToMessageId : message.MessageId);
                                }
                                else
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "system don`t need to ban " + ban.Name(), replyToMessageId : message.MessageId);
                                }
                            }
                            //counter
                            if (message.Text.ToLower().Contains("/counter"))
                            {
                                if (message.Text.Substring(message.Text.IndexOf("r") + 2).Length > 5)
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "error");

                                    continue;
                                }
                                Mamkate mamkate = new Mamkate();
                                mamkate.GetTime(Convert.ToInt32(message.Text.Substring(message.Text.IndexOf("r") + 2)));

                                try
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, mamkate.Timer());
                                }
                                catch (Exception)
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "error");
                                }
                            }
                            //trigger
                            if (message.Text.Contains("/trigger"))
                            {
                                if (message.Text.ToLower().Contains("dania") || message.Text.ToLower().Contains("даня"))
                                {
                                    Telegram.Bot.Types.FileToSend f  = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/ee1rvx/image.png");
                                    Telegram.Bot.Types.FileToSend f2 = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/mR9Gfx/20180228_073506_1.jpg");
                                    Telegram.Bot.Types.FileToSend f1 = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/janjhc/image.png");
                                    await Bot.SendPhotoAsync(message.Chat.Id, f, "trigger #1");

                                    await Bot.SendPhotoAsync(message.Chat.Id, f1, "trigger #2");

                                    await Bot.SendPhotoAsync(message.Chat.Id, f2, "trigger #3");
                                }
                                if (message.Text.ToLower().Contains("mark") || message.Text.ToLower().Contains("марк"))
                                {
                                    Telegram.Bot.Types.FileToSend f = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/nMRLOH/image.png");

                                    Telegram.Bot.Types.FileToSend f1 = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/dOnMVx/image.png");
                                    await Bot.SendPhotoAsync(message.Chat.Id, f, "trigger #1");

                                    await Bot.SendPhotoAsync(message.Chat.Id, f1, "trigger #2");
                                }
                                if (message.Text.ToLower().Contains("slavka") || message.Text.ToLower().Contains("славка"))
                                {
                                    Telegram.Bot.Types.FileToSend f  = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/gjhzHc/image.png");
                                    Telegram.Bot.Types.FileToSend f2 = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/jsLiCn/image.png");
                                    Telegram.Bot.Types.FileToSend f1 = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/cJvEiH/image.png");
                                    await Bot.SendPhotoAsync(message.Chat.Id, f, "trigger #1");

                                    await Bot.SendPhotoAsync(message.Chat.Id, f1, "trigger #2");

                                    await Bot.SendPhotoAsync(message.Chat.Id, f2, "trigger #3");
                                }
                                if (message.Text.ToLower().Contains("artur") || message.Text.ToLower().Contains("arturik") || message.Text.ToLower().Contains("артур") || message.Text.ToLower().Contains("артурик"))
                                {
                                    Telegram.Bot.Types.FileToSend f  = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/cC4tAx/image.png");
                                    Telegram.Bot.Types.FileToSend f1 = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/e3PRVx/image.png");
                                    Telegram.Bot.Types.FileToSend f2 = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/bMt8Sc/image.png");
                                    await Bot.SendPhotoAsync(message.Chat.Id, f, "trigger #1");

                                    await Bot.SendPhotoAsync(message.Chat.Id, f1, "trigger #2");

                                    await Bot.SendPhotoAsync(message.Chat.Id, f2, "trigger #3");
                                }
                                if (message.Text.ToLower().Contains("paliy") || message.Text.ToLower().Contains("палий"))
                                {
                                    Telegram.Bot.Types.FileToSend f  = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/mYqBxc/image.png");
                                    Telegram.Bot.Types.FileToSend f1 = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/ddXmfx/image.png");
                                    await Bot.SendPhotoAsync(message.Chat.Id, f, "trigger #1");

                                    await Bot.SendPhotoAsync(message.Chat.Id, f1, "trigger #2");
                                }
                            }
                            //fox
                            if (message.Text.ToLower().Contains("fox"))
                            {
                                Telegram.Bot.Types.FileToSend fs = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/cfkqJS/image.png");
                                await Bot.SendPhotoAsync(message.Chat.Id, fs, "here is a fox #1");

                                Telegram.Bot.Types.FileToSend fs1 = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/h0hqk7/image.png");
                                await Bot.SendPhotoAsync(message.Chat.Id, fs1, "here is a fox #2");
                            }
                            //say(need to upgrate)

                            if (message.Text == "/say" || message.Text == "/say@aaaclub_bot")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "slavka", replyToMessageId : message.MessageId);
                            }
                            //anime need to upgrate
                            if (message.Text == "/anime" || message.Text == "/anime@aaaclub_bot")
                            {
                                //await Bot.SendTextMessageAsync(message.Chat.Id, "Chose ganre", replyToMessageId: message.MessageId);
                                var keyboard = new Telegram.Bot.Types.ReplyMarkups.ReplyKeyboardMarkup
                                {
                                    Keyboard = new[]
                                    {
                                        new[]
                                        {
                                            new Telegram.Bot.Types.KeyboardButton("for paliy"),
                                            new Telegram.Bot.Types.KeyboardButton("for normal people"),
                                            new Telegram.Bot.Types.KeyboardButton("for artuturik")
                                        },
                                    },
                                    ResizeKeyboard = true
                                };
                                keyboard.OneTimeKeyboard = true;
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Chose ganre?", Telegram.Bot.Types.Enums.ParseMode.Default, false, false, 0, keyboard);
                            }
                            //monday
                            if (message.Text == "/monday" || message.Text == "/monday@aaaclub_bot")
                            {
                                var keyboard = new Telegram.Bot.Types.ReplyMarkups.ReplyKeyboardMarkup
                                {
                                    Keyboard = new[]
                                    {
                                        new[]
                                        {
                                            new Telegram.Bot.Types.KeyboardButton("yes, i`m ready"),
                                            new Telegram.Bot.Types.KeyboardButton("no, i`m not ready")
                                        },
                                    },
                                    ResizeKeyboard = true
                                };
                                keyboard.OneTimeKeyboard = true;

                                await Bot.SendTextMessageAsync(message.Chat.Id, "are u ready to zalupa?", Telegram.Bot.Types.Enums.ParseMode.Default, false, false, 0, keyboard);
                            }
                            //answer to sqr
                            if (answer)
                            {
                                try
                                {
                                    string s = message.Text.ToLower();
                                    if (math_1.input_message(s) == "error")
                                    {
                                        await Bot.SendTextMessageAsync(message.Chat.Id, "error", replyToMessageId : message.MessageId);
                                    }
                                    else
                                    {
                                        double x1 = 0, x2 = 0;
                                        math_1.x1x2(ref x1, ref x2);
                                        if (x1 == 2.228 && x2 == 2.228)
                                        {
                                            await Bot.SendTextMessageAsync(message.Chat.Id, "there are no roots", replyToMessageId : message.MessageId);
                                        }
                                        if (x2 == 2.228 && x1 != 2.228)
                                        {
                                            await Bot.SendTextMessageAsync(message.Chat.Id, "there is one root: " + Convert.ToString(x1), replyToMessageId : message.MessageId);
                                        }
                                        if (x1 != 2.228 && x2 != 2.228)
                                        {
                                            await Bot.SendTextMessageAsync(message.Chat.Id, "thereare two roots: " + Convert.ToString(x1) + " " + Convert.ToString(x2), replyToMessageId : message.MessageId);
                                        }
                                    }
                                    answer = false;
                                }
                                catch (Telegram.Bot.Exceptions.ApiRequestException ex)
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "error", replyToMessageId : message.MessageId);
                                }
                            }
                            //sqr
                            if (message.Text == "/sqr" || message.Text == "/sqr@aaaclub_bot")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "send me numbers", replyToMessageId : message.MessageId);

                                answer = true;
                            }
                            //zinia answer
                            if ((message.Text.ToLower().Contains("zinia") || message.Text.ToLower().Contains("зиня")) && !message.Text.ToLower().Contains("/zinia"))
                            {
                                Zinia zinia = new Zinia();

                                await Bot.SendTextMessageAsync(message.Chat.Id, zinia.res(message), replyToMessageId : message.MessageId);
                            }
                            //photo #1
                            if (message.Text == "/mamka" || message.Text == "/mamka@aaaclub_bot")
                            {
                                Telegram.Bot.Types.FileToSend fs = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/joBJ7c/image.png");
                                await Bot.SendPhotoAsync(message.Chat.Id, fs, "mamka");
                            }
                            //photo #2
                            if (message.Text == "/doge" || message.Text == "/doge@aaaclub_bot")
                            {
                                Telegram.Bot.Types.FileToSend fs = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/dHKuxc/image.png");
                                await Bot.SendPhotoAsync(message.Chat.Id, fs, "doge #1");

                                Telegram.Bot.Types.FileToSend fs2 = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/eV56Ax/image.png");
                                await Bot.SendPhotoAsync(message.Chat.Id, fs2, "doge #2");

                                Telegram.Bot.Types.FileToSend fs3 = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/cQhQ3H/image.png");
                                await Bot.SendPhotoAsync(message.Chat.Id, fs3, "doge #3");

                                Telegram.Bot.Types.FileToSend fs4 = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/cgajxc/image.png");
                                await Bot.SendPhotoAsync(message.Chat.Id, fs4, "doge #4");
                            }
                            //mark`s code
                            if (message.Text == "/pron" || message.Text == "/pron@aaaclub_bot")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "zaidi v kod marka: https://drive.google.com/open?id=1_MTeOLrL1KMg2bP7jCob7fRSeOL0-osg", replyToMessageId : message.MessageId);
                            }
                            //nakuzin
                            if (message.Text == "/nakuzin")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "hAAAAA NAEBAL!");
                            }
                            //mining
                            if (message.Text == "/mining" || message.Text == "/mining@aaaclub_bot")
                            {
                                Telegram.Bot.Types.FileToSend fs = new Telegram.Bot.Types.FileToSend("https://media.giphy.com/media/cAy7aIZ4dv5KiOAjFs/giphy.gif");
                                await Bot.SendDocumentAsync(message.Chat.Id, fs, "mayni dogecoini: https://cryptocash.guru/coin/dogecoin/majning-kriptovalyuty-dogecoin/");
                            }
                            //answers
                            if (message.Text.ToLower() == "yes, i`m ready")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "then u will die from biologi", replyToMessageId : message.MessageId);
                            }

                            if (message.Text.ToLower() == "no, i`m not ready")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "you will die on zalupa", replyToMessageId : message.MessageId);
                            }
                            if (message.Text.ToLower() == "for normal people")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "go to yummyanime.com/catalog/item/milyj-vo-frankce", replyToMessageId : message.MessageId);
                            }
                            if (message.Text.ToLower() == "for paliy")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "https://yummyanime.com/catalog/item/lyubovnye-nepriyatnosti-tv1", replyToMessageId : message.MessageId);
                            }
                            if (message.Text.ToLower() == "for artuturik")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "https://yummyanime.com/catalog/item/plastikovye-vospominaniya", replyToMessageId : message.MessageId);
                            }
                            //anime hater
                            if ((message.Text.ToLower().Contains("anime") || message.Text.ToLower().Contains("аниме")) && !message.Text.ToLower().Contains("/"))
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "ANIME - tupoe govno tupogo govna", replyToMessageId : message.MessageId);
                            }
                            //translate

                            if (message.Text.ToLower().Contains("/translate"))
                            {
                                int    index = message.Text.ToLower().IndexOf("e");
                                string s_res = String.Empty;
                                try
                                {
                                    s_res = message.Text.ToLower().Substring(index + 2);
                                }
                                catch (Exception)
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "error", replyToMessageId : message.MessageId);
                                }
                                await Bot.SendTextMessageAsync(message.Chat.Id, translate.tr(s_res), replyToMessageId : message.MessageId);
                            }
                            //mamkate
                            if (message.Text.ToLower().Contains("/mamkate"))
                            {
                                int    index = message.Text.ToLower().IndexOf("e");
                                string s_res = String.Empty;
                                try
                                {
                                    s_res = message.Text.ToLower().Substring(index + 2);
                                }
                                catch (Exception)
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, "error", replyToMessageId : message.MessageId);
                                }
                                Mamkate mamkate = new Mamkate();
                                await Bot.SendTextMessageAsync(message.Chat.Id, mamkate.tr(s_res), replyToMessageId : message.MessageId);
                            }
                            //analis rechi 2117
                            if (message.Text.ToLower().Contains("kofe") || message.Text.ToLower().Contains("кофе"))
                            {
                                Telegram.Bot.Types.FileToSend file = new Telegram.Bot.Types.FileToSend("https://image.ibb.co/jag72c/image.png");
                                await Bot.SendPhotoAsync(message.Chat.Id, file, "buy kofee for me, " + message.From.FirstName);
                            }
                            if (message.Text.ToLower().Contains("didur") || message.Text.ToLower().Contains("дидур"))
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "BLYAT DIDUR PIDOR", replyToMessageId : message.MessageId);
                            }
                            if (message.Text.ToLower().Contains("amd") || message.Text.ToLower().Contains("амд"))
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "AMD IS THE BEST KOMPANY", replyToMessageId : message.MessageId);
                            }
                            if (message.Text.ToLower().Contains("intel") || message.Text.ToLower().Contains("интел"))
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "INTEL HUINIA)", replyToMessageId : message.MessageId);
                            }
                            if (message.Text.ToLower().Contains("думал") || message.Text.ToLower().Contains("думать"))
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, "Не надо думать, у вас такого органа нет", replyToMessageId : message.MessageId);
                            }

                            /*
                             * if (message.Text.ToLower() .Contains("slavka daun")|| message.Text.ToLower().Contains("slavka eblan")|| message.Text.ToLower().Contains("славка даун") || message.Text.ToLower().Contains("славка еблан"))
                             * {
                             *  //ban
                             *
                             *  //u = message.From;
                             *  try
                             *  {
                             *      await Bot.SetChatDescriptionAsync(message.Chat.Id, message.Chat.Description + "         " + message.From.FirstName + " " + message.From.LastName + " - pidrila");
                             *      await Bot.DeleteMessageAsync(message.Chat.Id, message.MessageId);
                             *  }
                             *  catch(Exception)
                             *  {
                             *
                             *  }
                             *
                             * }/*
                             * if(u.FirstName!=null)
                             * if(message.From.FirstName.ToLower()==u.FirstName.ToLower())
                             * {
                             *  await Bot.SendTextMessageAsync(message.Chat.Id, "SASAT, pidrila", replyToMessageId: message.MessageId);
                             * }
                             */
                        }
                        offset = update.Id + 1;
                    }
                }
            }
            catch (Exception)
            {
                Console.WriteLine();
            }
        }
Exemple #29
0
        async void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            var worker = sender as BackgroundWorker;
            var key    = e.Argument as String; // получаем ключ из аргументов

            try
            {
                var Bot = new Telegram.Bot.TelegramBotClient(key); // инициализируем API
                await Bot.SetWebhookAsync("");                     // comment this line to remove http error and run bot. then uncomment and run again

                // Callback'и от кнопок
                Bot.OnCallbackQuery += async(object sc, Telegram.Bot.Args.CallbackQueryEventArgs ev) =>
                {
                    string _message = "";
                    var    message  = ev.CallbackQuery.Message;
                    if (previous.ToLower() == "меню")
                    {
                        if (ev.CallbackQuery.Data == "Рисовая каша")
                        {
                            Order.Ord.Add("Рисовая каша с кокосовым молоком - 220 г. - 3.50 р.");
                            Order.Price.Add(3.5);
                            _message = "Рисовая каша с кокосовым молоком";
                        }
                        else
                        if (ev.CallbackQuery.Data == "Клаб сэндвич")
                        {
                            Order.Ord.Add("Клаб сэндвич с цыпленком  - 300 г. - 9.00 р.");
                            Order.Price.Add(9.0);
                            _message = "Клаб сэндвич с цыпленком";
                        }
                        else
                        if (ev.CallbackQuery.Data == "Салат")
                        {
                            Order.Ord.Add("Салат с печеной тыквой и ореховым соусом - 150 г. - 5.50 р.");
                            Order.Price.Add(5.5);
                            _message = "Салат с печеной тыквой и ореховым соусом";
                        }
                        else
                        if (ev.CallbackQuery.Data == "Спагетти болоньезе")
                        {
                            Order.Ord.Add("Спагетти болоньезе с сыром Грана Падано  - 325 г. - 7.00 р.");
                            Order.Price.Add(7.0);
                            _message = "Спагетти болоньезе с сыром Грана Падано";
                        }
                        else
                        if (ev.CallbackQuery.Data == "Суп")
                        {
                            Order.Ord.Add("Суп Минестроне - 270 г. - 4.00 р.");
                            Order.Price.Add(4.0);
                            _message = "Суп Минестроне";
                        }
                        else
                        if (ev.CallbackQuery.Data == "Цветная капуста")
                        {
                            Order.Ord.Add("Цветная капуста с копченым соусом Чеддер  - 262 г. - 10.00 р.");
                            Order.Price.Add(10.0);
                            _message = "Цветная капуста с копченым соусом Чеддер";
                        }
                        else
                        if (ev.CallbackQuery.Data == "Говядина")
                        {
                            Order.Ord.Add("Говядина с вялеными грибами, соус демиглас - 330 г. - 24.00 р.");
                            Order.Price.Add(24.0);
                            _message = "Говядина с вялеными грибами, соус демиглас";
                        }
                        else
                        if (ev.CallbackQuery.Data == "Ризотто")
                        {
                            Order.Ord.Add("Ризотто с морепродуктами, соус биск  - 340 г. - 24.00 р.");
                            Order.Price.Add(24.0);
                            _message = "Ризотто с морепродуктами, соус биск";
                        }
                        else
                        if (ev.CallbackQuery.Data == "Ginger Ale")
                        {
                            Order.Ord.Add("Ginger Ale - 250 г. - 3.50 р.");
                            Order.Price.Add(3.5);
                            _message = "Ginger Ale";
                        }
                        else
                        if (ev.CallbackQuery.Data == "Сок виноградный")
                        {
                            Order.Ord.Add("Сок виноградный  - 200 г. - 2.00 р.");
                            Order.Price.Add(2.0);
                            _message = "Сок виноградный";
                        }
                        else
                        if (ev.CallbackQuery.Data == "Сок апельсиновый")
                        {
                            Order.Ord.Add("Сок апельсиновый  - 200 г. - 2.00 р.");
                            Order.Price.Add(2.0);
                            _message = "Сок апельсиновый";
                        }
                        else
                        if (ev.CallbackQuery.Data == "Pepsi")
                        {
                            Order.Ord.Add("Pepsi - 250 г. - 3.50 р.");
                            Order.Price.Add(3.5);
                            _message = "Pepsi";
                        }
                        ShowRBut = false;
                        var keyboard = new Telegram.Bot.Types.ReplyMarkups.ReplyKeyboardMarkup
                        {
                            Keyboard = new[] {
                                new[]             // row 1
                                {
                                    new Telegram.Bot.Types.KeyboardButton("Отправить заказ"),
                                },
                                new[]             // row 2
                                {
                                    new Telegram.Bot.Types.KeyboardButton("Отмена"),
                                    new Telegram.Bot.Types.KeyboardButton("Корзина [" + Order.Ord.Count.ToString() + "]"),
                                },
                            },
                            ResizeKeyboard = true
                        };
                        await Bot.SendTextMessageAsync(message.Chat.Id, "Added " + _message, false, false, 0, keyboard, Telegram.Bot.Types.Enums.ParseMode.Default);
                    }
                    if (previous == "бронировать столик")
                    {
                        Day      = Convert.ToInt32(ev.CallbackQuery.Data.ToString());
                        previous = "время";
                        var keyboard = new Telegram.Bot.Types.ReplyMarkups.InlineKeyboardMarkup(
                            new Telegram.Bot.Types.InlineKeyboardButton[][]
                        {
                            // First row
                            new [] {
                                new Telegram.Bot.Types.InlineKeyboardButton("16-17", "16-17"),
                                new Telegram.Bot.Types.InlineKeyboardButton("17-18", "17-18"),
                                new Telegram.Bot.Types.InlineKeyboardButton("18-19", "18-19"),
                                new Telegram.Bot.Types.InlineKeyboardButton("20-21", "20-21"),
                            },
                        }
                            );
                        await Bot.SendTextMessageAsync(message.Chat.Id, "Выберите время", false, false, 0, keyboard, Telegram.Bot.Types.Enums.ParseMode.Default);

                        goto End;
                    }
                    if (previous == "время")
                    {
                        previous = "точное время";
                        var keyboard = new Telegram.Bot.Types.ReplyMarkups.InlineKeyboardMarkup(
                            new Telegram.Bot.Types.InlineKeyboardButton[][]
                        {
                            // First row
                            new [] {
                                new Telegram.Bot.Types.InlineKeyboardButton(ev.CallbackQuery.Data[0].ToString() + ev.CallbackQuery.Data[1].ToString() + ":00", ev.CallbackQuery.Data[0].ToString() + ev.CallbackQuery.Data[1].ToString() + ":00"),
                                new Telegram.Bot.Types.InlineKeyboardButton(ev.CallbackQuery.Data[0].ToString() + ev.CallbackQuery.Data[1].ToString() + ":20", ev.CallbackQuery.Data[0].ToString() + ev.CallbackQuery.Data[1].ToString() + ":20"),
                                new Telegram.Bot.Types.InlineKeyboardButton(ev.CallbackQuery.Data[0].ToString() + ev.CallbackQuery.Data[1].ToString() + ":40", ev.CallbackQuery.Data[0].ToString() + ev.CallbackQuery.Data[1].ToString() + ":40"),
                            },
                        }
                            );
                        await Bot.SendTextMessageAsync(message.Chat.Id, "Выберите точное время", false, false, 0, keyboard, Telegram.Bot.Types.Enums.ParseMode.Default);

                        goto End;
                    }
                    if (previous == "точное время")
                    {
                        previous = "";
                        await Bot.SendTextMessageAsync(message.Chat.Id, "Ваш стол успешно забронирован на " + Day + " число на " + ev.CallbackQuery.Data + ".");
                    }
End:
                    int a = 0;
                };

                Bot.OnUpdate += async(object su, Telegram.Bot.Args.UpdateEventArgs evu) =>
                {
                    if (evu.Update.CallbackQuery != null || evu.Update.InlineQuery != null)
                    {
                        return;
                    }
                    var update  = evu.Update;
                    var message = update.Message;
                    if (message == null)
                    {
                        return;
                    }
                    if (message.Type == Telegram.Bot.Types.Enums.MessageType.TextMessage)
                    {
                        if (message.Text == "/start")
                        {
                            // в ответ на команду /saysomething выводим сообщение
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Добро пожаловать в ресторан «Interside»! Здесь можно забронировать столик, посмотреть меню и оформить заказ навынос.");

                            ShowRBut = true;
                            previous = "/start";
                        }
RBUT:
                        // reply buttons
                        if (ShowRBut)
                        {
                            var keyboard = new Telegram.Bot.Types.ReplyMarkups.ReplyKeyboardMarkup
                            {
                                Keyboard = new[] {
                                    new[]             // row 1
                                    {
                                        new Telegram.Bot.Types.KeyboardButton("Сделать заказ"),
                                        new Telegram.Bot.Types.KeyboardButton("Бронировать столик")
                                    },
                                    new[]             // row 2
                                    {
                                        new Telegram.Bot.Types.KeyboardButton("Оставить отзыв"),
                                        new Telegram.Bot.Types.KeyboardButton("О Ресторане")
                                    },
                                },
                                ResizeKeyboard = true
                            };
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Wait please", false, false, 0, keyboard, Telegram.Bot.Types.Enums.ParseMode.Default);
                        }
                        // обработка reply кнопок
                        if (previous.ToLower() == "оставить отзыв")
                        {
                            previous = "";
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Спасибо, ваша оценка очень ценна для нас");

                            ShowRBut = true;
                            goto RBUT;
                        }
                        if (message.Text.ToLower() == "сделать заказ")
                        {
                            previous = "сделать заказ";
                            var keyboard = new Telegram.Bot.Types.ReplyMarkups.InlineKeyboardMarkup(
                                new Telegram.Bot.Types.InlineKeyboardButton[][]
                            {
                                // First row
                                new [] {
                                    new Telegram.Bot.Types.InlineKeyboardButton("Рисовая каша с кокосовым молоком - 220 г. - 3.50 р.", "Рисовая каша"),
                                },
                                new[]
                                {
                                    new Telegram.Bot.Types.InlineKeyboardButton("Клаб сэндвич с цыпленком  - 300 г. - 9.00 р.", "Клаб сэндвич"),
                                },
                                new[]
                                {
                                    new Telegram.Bot.Types.InlineKeyboardButton("Салат с печеной тыквой и ореховым соусом - 150 г. - 5.50 р.", "Салат"),
                                },
                                new[]
                                {
                                    new Telegram.Bot.Types.InlineKeyboardButton("Спагетти болоньезе с сыром Грана Падано -325 г.-7.00 р.", "Спагетти болоньезе"),
                                },
                                new[]
                                {
                                    new Telegram.Bot.Types.InlineKeyboardButton("Суп Минестроне - 270 г. - 4.00 р.", "Суп"),
                                },
                                new[]
                                {
                                    new Telegram.Bot.Types.InlineKeyboardButton("Цветная капуста с копченым соусом Чеддер-262 г.-10.00 р.", "Цветная капуста"),
                                },
                                new[]
                                {
                                    new Telegram.Bot.Types.InlineKeyboardButton("Говядина с вялеными грибами, соус демиглас-330 г.-24.00 р.", "Говядина"),
                                },
                                new[]
                                {
                                    new Telegram.Bot.Types.InlineKeyboardButton("Ризотто с морепродуктами, соус биск  - 340 г. - 24.00 р.", "Ризотто"),
                                },
                                new[]
                                {
                                    new Telegram.Bot.Types.InlineKeyboardButton("Ginger Ale  - 250 г. - 3.50 р.", "Ginger Ale"),
                                },
                                new[]
                                {
                                    new Telegram.Bot.Types.InlineKeyboardButton("Сок виноградный  - 200 г. - 2.00 р.", "Сок виноградный"),
                                },
                                new[]
                                {
                                    new Telegram.Bot.Types.InlineKeyboardButton("Сок апельсиновый  - 200 г. - 2.00 р.", "Сок апельсиновый"),
                                },
                                new[]
                                {
                                    new Telegram.Bot.Types.InlineKeyboardButton("Pepsi  - 250 г. - 3.50 р.", "Pepsi"),
                                },
                            }
                                );

                            await Bot.SendTextMessageAsync(message.Chat.Id, "Меню находится выше", false, false, 0, keyboard, Telegram.Bot.Types.Enums.ParseMode.Default);
                        }
                        if (previous == "сделать заказ")
                        {
                            previous = "Меню";
                            ShowRBut = false;
                            var keyboard = new Telegram.Bot.Types.ReplyMarkups.ReplyKeyboardMarkup
                            {
                                Keyboard = new[] {
                                    new[]             // row 1
                                    {
                                        new Telegram.Bot.Types.KeyboardButton("Отмена"),
                                        new Telegram.Bot.Types.KeyboardButton("Корзина [" + Order.Ord.Count.ToString() + "]"),
                                    },
                                },
                                ResizeKeyboard = true
                            };
                            await Bot.SendTextMessageAsync(message.Chat.Id, "меню находится выше", false, false, 0, keyboard, Telegram.Bot.Types.Enums.ParseMode.Default);
                        }
                        else
                        if (message.Text.ToLower() == "отправить заказ" && previous == "Меню")
                        {
                            previous = "";
                            await Bot.SendTextMessageAsync(message.Chat.Id, "Ваш заказ отправлен и в данный момент обрабатывается");

                            ShowRBut = true;
                            goto RBUT;
                        }
                        else
                        if (message.Text.ToLower() == "отмена" && previous == "Меню")
                        {
                            previous = "";
                            Order.Ord.Clear();
                            Order.Price.Clear();
                            ShowRBut = true;
                            goto RBUT;
                        }
                        else
                        if (message.Text.ToLower() == "корзина [" + Order.Ord.Count.ToString() + "]" && previous == "Меню")
                        {
                            string order = "";
                            double price = 0;
                            for (int point = 0; point < Order.Ord.Count; ++point)
                            {
                                order += Order.Ord[point];
                                order += "\n";
                                price += Order.Price[point];
                            }
                            order += ("Общая стоимсоть: " + price);
                            await Bot.SendTextMessageAsync(message.Chat.Id, order);
                        }
                        else
                        if (message.Text.ToLower() == "бронировать столик")
                        {
                            previous = "бронировать столик";
                            var keyboard = new Telegram.Bot.Types.ReplyMarkups.InlineKeyboardMarkup(
                                new Telegram.Bot.Types.InlineKeyboardButton[][]
                            {
                                // First row
                                new [] {
                                    new Telegram.Bot.Types.InlineKeyboardButton(DateTime.Now.AddDays(1).ToString("dd"), DateTime.Now.AddDays(1).ToString("dd")),
                                    new Telegram.Bot.Types.InlineKeyboardButton(DateTime.Now.AddDays(2).ToString("dd"), DateTime.Now.AddDays(2).ToString("dd")),
                                    new Telegram.Bot.Types.InlineKeyboardButton(DateTime.Now.AddDays(3).ToString("dd"), DateTime.Now.AddDays(3).ToString("dd")),
                                    new Telegram.Bot.Types.InlineKeyboardButton(DateTime.Now.AddDays(4).ToString("dd"), DateTime.Now.AddDays(4).ToString("dd")),
                                    new Telegram.Bot.Types.InlineKeyboardButton(DateTime.Now.AddDays(5).ToString("dd"), DateTime.Now.AddDays(5).ToString("dd")),
                                    new Telegram.Bot.Types.InlineKeyboardButton(DateTime.Now.AddDays(6).ToString("dd"), DateTime.Now.AddDays(6).ToString("dd")),
                                    new Telegram.Bot.Types.InlineKeyboardButton(DateTime.Now.AddDays(7).ToString("dd"), DateTime.Now.AddDays(7).ToString("dd")),
                                },
                                new[]
                                {
                                    new Telegram.Bot.Types.InlineKeyboardButton(DateTime.Now.AddDays(8).ToString("dd"), DateTime.Now.AddDays(8).ToString("dd")),
                                    new Telegram.Bot.Types.InlineKeyboardButton(DateTime.Now.AddDays(9).ToString("dd"), DateTime.Now.AddDays(9).ToString("dd")),
                                    new Telegram.Bot.Types.InlineKeyboardButton(DateTime.Now.AddDays(10).ToString("dd"), DateTime.Now.AddDays(10).ToString("dd")),
                                    new Telegram.Bot.Types.InlineKeyboardButton(DateTime.Now.AddDays(11).ToString("dd"), DateTime.Now.AddDays(11).ToString("dd")),
                                    new Telegram.Bot.Types.InlineKeyboardButton(DateTime.Now.AddDays(12).ToString("dd"), DateTime.Now.AddDays(12).ToString("dd")),
                                    new Telegram.Bot.Types.InlineKeyboardButton(DateTime.Now.AddDays(13).ToString("dd"), DateTime.Now.AddDays(13).ToString("dd")),
                                    new Telegram.Bot.Types.InlineKeyboardButton(DateTime.Now.AddDays(14).ToString("dd"), DateTime.Now.AddDays(14).ToString("dd")),
                                },
                            }
                                );

                            await Bot.SendTextMessageAsync(message.Chat.Id, "Выберите дату", false, false, 0, keyboard, Telegram.Bot.Types.Enums.ParseMode.Default);
                        }
                        else
                        if (message.Text.ToLower() == "оставить отзыв")
                        {
                            previous = "оставить отзыв";
                            ShowRBut = false;
                            var keyboard = new Telegram.Bot.Types.ReplyMarkups.ReplyKeyboardMarkup
                            {
                                Keyboard = new[] {
                                    new[]             // row 1
                                    {
                                        new Telegram.Bot.Types.KeyboardButton("0"),
                                        new Telegram.Bot.Types.KeyboardButton("1"),
                                        new Telegram.Bot.Types.KeyboardButton("2"),
                                        new Telegram.Bot.Types.KeyboardButton("3"),
                                        new Telegram.Bot.Types.KeyboardButton("4"),
                                        new Telegram.Bot.Types.KeyboardButton("5")
                                    },
                                    new[]             // row 2
                                    {
                                        new Telegram.Bot.Types.KeyboardButton("6"),
                                        new Telegram.Bot.Types.KeyboardButton("7"),
                                        new Telegram.Bot.Types.KeyboardButton("8"),
                                        new Telegram.Bot.Types.KeyboardButton("9"),
                                        new Telegram.Bot.Types.KeyboardButton("10"),
                                    },
                                },
                                ResizeKeyboard = true
                            };

                            await Bot.SendTextMessageAsync(message.Chat.Id, "Пожалуйста, поставьте нам оценку от 0 👎до 10 👍.", false, false, 0, keyboard, Telegram.Bot.Types.Enums.ParseMode.Default);
                        }

                        else
                        {
                            if (message.Text.ToLower() == "о ресторане")
                            {
                                await Bot.SendTextMessageAsync(message.Chat.Id, @"Ресторан «Interside».
Одна ошибка и ты ошибся - Сократ, 399 г. до н. э.
📍г.Минск, ул.Платонова, 20Бк1
📞 375445284838
🌐 Intersie.by
📅 Понедельник - пятница:
🍳 Завтраки: 08.00 - 11.30 
🍝 Обеды: 12.00 - 16.30
🍨 Основное меню: 18:00 - 23:00
🍹 Бар и десерты: 08.00 - 23.00
📅 Суббота - воскресенье: 
      11:00 - 23:00");
                            }
                            else
                            {
                                previous = "";
                                if (ContainsSpecialChars(message.Text) && message.Text.ToLower() != "отмена" && message.Text.ToLower() != "отправить заказ")
                                {
                                    await Bot.SendTextMessageAsync(message.Chat.Id, RunPy(message.Text));
                                }
                            }
                        }
                    }
                };

                // запускаем прием обновлений
                Bot.StartReceiving();
            }
            catch (Telegram.Bot.Exceptions.ApiRequestException ex)
            {
                Console.WriteLine(ex.Message); // если ключ не подошел - пишем об этом в консоль отладки
            }
        }
Exemple #30
0
        async static void TelegramMetod()
        {
            string key = "417836710:AAHaiu8stm_QKQBiZX11MJqIcDCrOrTLyMk"; //telegram: @RandomPhoto_bot
            var    bot = new Telegram.Bot.TelegramBotClient(key);
            await bot.SetWebhookAsync("");

            int offset = 0;

            while (true)
            {
                var updates = await bot.GetUpdatesAsync(offset); // получаем массив обновлений

                foreach (var update in updates)                  // Перебираем все обновления
                {
                    var message = update.Message;
                    if (message?.Type == Telegram.Bot.Types.Enums.MessageType.TextMessage)
                    {
                        string rain = "";
                        if (message.Text == "/start")
                        {
                            await bot.SendTextMessageAsync(message.Chat.Id, "Привет " + message.Chat.FirstName);

                            var keyboard = new Telegram.Bot.Types.ReplyMarkups.ReplyKeyboardMarkup
                            {
                                Keyboard = new[] {
                                    new[] // row 1
                                    {
                                        new Telegram.Bot.Types.KeyboardButton("Пришли картинку"),
                                        new Telegram.Bot.Types.KeyboardButton("Пришли музыку")
                                    },
                                    new[] // row 1
                                    {
                                        new Telegram.Bot.Types.KeyboardButton("Какая погода?"),
                                        new Telegram.Bot.Types.KeyboardButton("Какая погода завтра?")
                                    },
                                },
                                ResizeKeyboard = true
                            };

                            await bot.SendTextMessageAsync(message.Chat.Id, "Выбери что хочешь получить",
                                                           ParseMode.Default, false, false, 0, keyboard, CancellationToken.None);
                        }

                        if (message.Text == "/getimage" || message.Text == "Пришли картинку")
                        {
                            string[] dirs = Directory.GetFiles(
                                @"C:\Users\workstation1\Documents\Visual Studio 2015\Projects\TelegramBotGetImage\TelegramBotGetImage\Images");
                            Random rnd     = new Random();
                            int    i       = rnd.Next(0, dirs.Length);
                            string FileUrl = dirs[i];

                            using (var stream = System.IO.File.Open(FileUrl, FileMode.Open))
                            {
                                FileToSend fts = new FileToSend();
                                fts.Content  = stream;
                                fts.Filename = FileUrl.Split('\\').Last();
                                await bot.SendPhotoAsync(message.Chat.Id, fts, "New IMG");
                            }
                        }

                        if (message.Text == "/getmusic" || message.Text == "Пришли музыку")
                        {
                            string[] dirs = Directory.GetFiles(
                                @"C:\Users\workstation1\Documents\Visual Studio 2015\Projects\TelegramBotGetImage\TelegramBotGetImage\Music");
                            Random rnd     = new Random();
                            int    w       = rnd.Next(0, dirs.Length);
                            string FileUrl = dirs[w];

                            using (var stream = System.IO.File.Open(FileUrl, FileMode.Open))
                            {
                                FileToSend fts = new FileToSend();
                                fts.Content  = stream;
                                fts.Filename = FileUrl.Split('\\').Last();
                                string[] eq       = fts.Filename.Split('-');
                                string   songName = eq.Last();
                                string   athor    = "";
                                for (int i = 0; i < eq.Length - 1; i++)
                                {
                                    athor += eq[i];
                                }
                                await bot.SendTextMessageAsync(message.Chat.Id, "Отправляю песню: " + athor + " - " + songName + " подождите");

                                await bot.SendAudioAsync(message.Chat.Id, fts, "Файл получен", 0,
                                                         athor, songName);
                            }
                        }

                        if (message.Text == "/about")
                        {
                            await bot.SendTextMessageAsync(message.Chat.Id, "Бот написан 22.09.2017\nАвтор: Тимофей Забалуев\nКонтактные данные: [email protected]");
                        }

                        if (message.Text == "/weathernow" || message.Text == "Какая погода?")
                        {
                            var q = GetSimpleWeather.WeatherGetNow();
                            //if (q.rain != null) rain = " дождь";
                            await bot.SendTextMessageAsync(message.Chat.Id, "В городе: " + q.Name + " сейчас " + q.Main.temp + " градусов");
                        }

                        if (message.Text == "/weathertomorrow" || message.Text == "Какая погода завтра?")
                        {
                            var w = GetSimpleWeather.WeatherGetFor5Days();
                            await bot.SendTextMessageAsync(message.Chat.Id, "В городе: " + w.city.name);

                            string str = " ";
                            for (int i = 1; i < 9; i++)
                            {
                                if (w.list[i].rain != null)
                                {
                                    rain = " дождь";
                                }

                                string[] split = w.list[i].dt_txt.Split(' ', ':', '-');
                                if (split[3] == "00")
                                {
                                    str += split[2] + "/" + split[1] + " "; //Выводим дополнительно число и месяц если следующий день
                                }
                                else
                                {
                                    str += "---------";
                                }
                                str += split[3] + ":00 = " + w.list[i].main.temp + "° " + rain + "\n";
                            }
                            await bot.SendTextMessageAsync(message.Chat.Id, str);
                        }
                    }
                    offset = update.Id + 1;
                }
            }
        }