public static async void SongProcessing(TelegramBotClient Client, Message Message, User currentUser)
        {
            try
            {
                var query = $"https://amdm.ru/search/?q={Message.Text}";

                var urls = await FindSongs(query, currentUser.LimitResultsNumber);

                if (urls.Count == 0)
                {
                    Client.SendTextMessageAsync(
                        Message.Chat.Id, "Трек не найден ❌",
                        replyMarkup: Keyboards.GetReturnKeyboard());
                    return;
                }

                Client.SendTextMessageAsync(
                    Message.Chat.Id, "Пожалуйста, подожди пару секунд ⏳",
                    replyMarkup: Keyboards.GetReturnKeyboard());

                foreach (var urlPair in urls)
                {
                    var songName = urlPair.Key;
                    var songUrl  = urlPair.Value;
                    if (songUrl != string.Empty)
                    {
                        string chordsUrl;
                        if (DataBase.CheckSong(songName, out chordsUrl))
                        {
                            if (chordsUrl != string.Empty)
                            {
                                SendFilesByFileId(Client, new Dictionary <string, string> {
                                    { chordsUrl, songName }
                                }, currentUser.id, true);
                                continue;
                            }
                        }
                        await SongSending(Client, currentUser.id, songName, songUrl);
                    }
                }

                try
                {
                    Client.SendTextMessageAsync(
                        Message.Chat.Id, $"Найденные {urls.Count} Песни 💎\n" +
                        $"Ты можешь сменить количество результатов в разделе НАСТРОЙКИ ⚙️",
                        replyMarkup: Keyboards.GetReturnKeyboard());
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
        public static async void SendStartMessage(ITelegramBotClient Bot, long id, string name)
        {
            try
            {
                var image   = new InputOnlineFile("https://telegra.ph/file/178ade71533890e6400c2.png");
                var caption = $"Привет, {name}!\n" +
                              $"Я Telegram бот для поиска гитарных аккордов";

                await Bot.SendPhotoAsync(id, image, caption, replyMarkup : Keyboards.GetMainMenu());
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
Esempio n. 3
0
        public static async void HandleCallbackQuery(object sender, CallbackQueryEventArgs queryEventArgs)
        {
            var Client   = sender as TelegramBotClient;
            var Callback = queryEventArgs.CallbackQuery;

            User currentUser = new User(Callback.From.Id);

            try
            {
                switch (Callback.Data)
                {
                case "addToFavourite":
                    await Client.EditMessageTextAsync(Callback.From.Id, Callback.Message.MessageId, Callback.Message.Text, replyMarkup : Keyboards.GetSongMenuKeyboard(false));

                    DataBase.UpdateString(currentUser.id, "IsFavourite", "1", "MessageId", Callback.Message.MessageId.ToString());
                    break;

                case "removeFromFavourite":
                    await Client.EditMessageTextAsync(Callback.From.Id, Callback.Message.MessageId, Callback.Message.Text, replyMarkup : Keyboards.GetSongMenuKeyboard(true));

                    DataBase.UpdateString(currentUser.id, "IsFavourite", "0", "MessageId", Callback.Message.MessageId.ToString());
                    break;
                }
            }
            catch { }

            currentUser.SaveUser();
        }
        public static async Task <bool> SongSending(TelegramBotClient client, long id, string songName, string songUrl)
        {
            var website = new HtmlWeb();

            website.OverrideEncoding = System.Text.Encoding.GetEncoding("utf-8");
            try
            {
                HtmlDocument doc = website.Load(songUrl);

                var songTextNode = doc?.DocumentNode?.SelectSingleNode("//*[@class=\"b-podbor__text\"]");

                var songText = songTextNode?.InnerText;

                var songsChordsImages = new List <string>();
                foreach (var node in doc?.DocumentNode?.SelectNodes("//*[@id=\"song_chords\"]"))
                {
                    foreach (var img in node?.ChildNodes)
                    {
                        songsChordsImages.Add($"https:{img?.Attributes[0]?.Value}");
                    }
                }
                var uniqueCode = DateTime.Now.Ticks;
                if (await DownloadImages(uniqueCode, songsChordsImages))
                {
                    var content = new List <NodeElement>();
                    content.Add(new NodeElement("img", new Dictionary <string, string>
                    {
                        ["src"] = $"https://telegra.ph/file/6e0006d12cf4319268af4.jpg"
                    }));

                    var compositeImages = await CreateCompositeImages(uniqueCode, songsChordsImages.Count);

                    foreach (var image in compositeImages)
                    {
                        var url = await UploadImage(image);

                        content.Add(new NodeElement("img", new Dictionary <string, string> {
                            ["src"] = "https://telegra.ph" + url
                        }));
                    }

                    content.Add(new NodeElement("div", null, children: songText.Replace("\r\n\r\n", "\r\n").Replace("&#180;", "´")));

                    var telegraphClient = new TelegraphClient();
                    var _tokenClient    = telegraphClient.GetTokenClient($"{AppSettings.TelegraphToken }");
                    var page            = _tokenClient.CreatePageAsync(
                        title: songName,
                        authorName: "Music Accords Bot",
                        authorUrl: "https://t.me/muschords_bot",
                        returnContent: true,
                        content: content.ToArray()
                        ).Result;

                    var message = await client.SendTextMessageAsync(id, page.Url, replyMarkup : Keyboards.GetSongMenuKeyboard(true));

                    AddSongToBase(id, message.MessageId, page.Url, songName);
                    DataBase.AddSongToLibrary(songName, page.Url);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return(false);
            }
            return(true);
        }
        private static async void SendFilesByFileId(TelegramBotClient Client, Dictionary <string, string> songs, long chatId, bool isFavourite, bool otherUser = false)
        {
            foreach (var song in songs)
            {
                var url      = song.Key;
                var songName = song.Value;
                try
                {
                    var message = await Client.SendTextMessageAsync(chatId, url, replyMarkup : Keyboards.GetSongMenuKeyboard(isFavourite));

                    if (otherUser)
                    {
                        AddSongToBase(chatId, message.MessageId, url, songName);
                    }
                    else
                    {
                        DataBase.UpdateString(chatId, "MessageId", message.MessageId.ToString(), "url", url);
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
        }
        public static async void MessageReceiving(object sender, MessageEventArgs args)
        {
            var client  = sender as TelegramBotClient;
            var Message = args.Message;

            if (Message.Text == null)
            {
                return;
            }

            User currentUser = new User(Message.From.Id);

            Console.WriteLine($"{DateTime.Now} {Message.From.FirstName} {Message.From.LastName} {Message.From.Id} {Message.Text}");

            if (Message.Text == "Вернуться в Главное Меню 🚀")
            {
                currentUser.Stage = State.Stage.Default;
                currentUser.State = State.Categories.Default;
                try
                {
                    await client.SendTextMessageAsync(
                        Message.Chat.Id, "Выберите раздел меню 🎯",
                        replyMarkup :
                        Keyboards.GetMainMenu());
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
                currentUser.SaveUser();
                return;
            }

            if (currentUser.State == State.Categories.Default)
            {
                currentUser.State = GetMessageCategory(Message.Text);
            }

            switch (currentUser.State)
            {
            case State.Categories.Start:
            {
                SendStartMessage(client, currentUser.id, Message.Chat.FirstName);
                currentUser.State = State.Categories.Default;
                break;
            }

            case State.Categories.Search:
            {
                if (currentUser.Stage == State.Stage.Default)
                {
                    try
                    {
                        await client.SendTextMessageAsync(
                            Message.Chat.Id,
                            "SEARCH 🔎\nЧто ты хочешь найти?\nВведите название песни или исполнителя ✏️",
                            replyMarkup : Keyboards.GetReturnKeyboard());
                    }
                    catch (Exception exc)
                    {
                        Console.WriteLine(exc.Message);
                    }

                    currentUser.Stage = State.Stage.Alpha;
                }
                else if (currentUser.Stage == State.Stage.Alpha)
                {
                    SongProcessing(client, Message, currentUser);
                }
                break;
            }

            case State.Categories.Settings:
            {
                if (currentUser.Stage == State.Stage.Default)
                {
                    try
                    {
                        await client.SendTextMessageAsync(
                            Message.Chat.Id, "НАСТРОЙКИ ⚙️",
                            replyMarkup :
                            Keyboards.GetSettingsMenu());
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                    }

                    currentUser.Stage = State.Stage.Alpha;
                }
                else if (currentUser.Stage == State.Stage.Alpha)
                {
                    switch (Message.Text)
                    {
                    case "Сменить количество результатов 🎲":
                    {
                        try
                        {
                            await client.SendTextMessageAsync(
                                Message.Chat.Id, "Отправь количество результатов в разделе ПОИСК ✏️",
                                replyMarkup :
                                Keyboards.GetNumberKeyboard());
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(ex.Message);
                        }
                        currentUser.Stage = State.Stage.SearchLimit;
                        break;
                    }

                    case "Связаться с разработчиком 📝":
                    {
                        try
                        {
                            await client.SendTextMessageAsync(
                                Message.Chat.Id, "Отправь свое сообщение ✏️ Оно будет прочитано разработчиком 📌",
                                replyMarkup :
                                Keyboards.GetRemoveKeyboard());
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(ex.Message);
                        }
                        currentUser.Stage = State.Stage.SendMessage;
                        break;
                    }

                    default:
                    {
                        try
                        {
                            await client.SendTextMessageAsync(
                                Message.Chat.Id, "Выбери раздел меню 🎯",
                                replyMarkup :
                                Keyboards.GetSettingsMenu());
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(ex.Message);
                        }
                        break;
                    }
                    }
                }
                else if (currentUser.Stage == State.Stage.SearchLimit)
                {
                    int count;
                    if (int.TryParse(Message.Text, out count) && count <= 10)
                    {
                        currentUser.LimitResultsNumber = count;
                    }
                    else
                    {
                        currentUser.LimitResultsNumber = 5;
                    }
                    try
                    {
                        await client.SendTextMessageAsync(
                            Message.Chat.Id, "НАСТРОЙКИ ⚙️\n" +
                            "Выбери раздел меню 🎯",
                            replyMarkup :
                            Keyboards.GetSettingsMenu());
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                    }

                    currentUser.Stage = State.Stage.Alpha;
                }
                else if (currentUser.Stage == State.Stage.SendMessage)
                {
                    try
                    {
                        await client.SendTextMessageAsync(
                            Message.Chat.Id, "Спасибо за твое сообщение 💎", replyMarkup : Keyboards.GetRemoveKeyboard());

                        await client.SendTextMessageAsync(
                            Message.Chat.Id, "Настройки ⚙️\n" +
                            "Выбери раздел меню 🎯",
                            replyMarkup :
                            Keyboards.GetSettingsMenu());
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                    }
                    currentUser.Stage = State.Stage.Alpha;
                }
                break;
            }

            case State.Categories.Popular:
            {
                try
                {
                    var query = "https://amdm.ru/akkordi/popular/week/";

                    var urls = await FindSongs(query, 10);

                    if (urls.Count == 0)
                    {
                        client.SendTextMessageAsync(
                            Message.Chat.Id, "Извините, раздел временно не работает!",
                            replyMarkup: Keyboards.GetReturnKeyboard());
                        return;
                    }

                    client.SendTextMessageAsync(
                        Message.Chat.Id, "Пожалуйста, подожди несколько секунд ⏳",
                        replyMarkup: Keyboards.GetReturnKeyboard());

                    foreach (var urlPair in urls)
                    {
                        var songName = urlPair.Key;
                        var songUrl  = urlPair.Value;
                        if (songUrl != string.Empty)
                        {
                            string chordsUrl;
                            if (DataBase.CheckSong(songName, out chordsUrl))
                            {
                                if (chordsUrl != string.Empty)
                                {
                                    SendFilesByFileId(client, new Dictionary <string, string> {
                                            { chordsUrl, songName }
                                        }, currentUser.id, true);
                                    continue;
                                }
                            }
                            SongSending(client, currentUser.id, songName, songUrl);
                        }
                    }

                    try
                    {
                        client.SendTextMessageAsync(
                            Message.Chat.Id, $"Найденные {urls.Count} Песни 💎\n" +
                            $"Ты можешь сменить количество результатов в разделе НАСТРОЙКИ ⚙️",
                            replyMarkup: Keyboards.GetReturnKeyboard());
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
                break;
            }

            case State.Categories.Playlist:
            {
                var urls = DataBase.GetMusicLibrary(currentUser.id);

                try
                {
                    if (urls.Count == 0)
                    {
                        await client.SendTextMessageAsync(
                            Message.Chat.Id, "Тут будут твои любимые песни 🎯",
                            replyMarkup : Keyboards.GetMainMenu());
                    }
                    else
                    {
                        SendFilesByFileId(client, urls, currentUser.id, false);
                    }
                }
                catch (Exception ex) {
                }

                currentUser.State = State.Categories.Default;
                break;
            }

            default:
            {
                try
                {
                    await client.SendTextMessageAsync(
                        Message.Chat.Id, "Выбери рздел меню 🎯",
                        replyMarkup : Keyboards.GetMainMenu());
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }

                currentUser.Stage = State.Stage.Default;
                break;
            }
            }
            currentUser.SaveUser();
        }