public static async Task <List <FindedSongObject> > SearchArtistSongs(FindedSongObject songToFind, Boolean useLinkToSongs = false)
        {
            IPageService            _pageService = new PageService();
            List <FindedSongObject> songs        = new List <FindedSongObject>();
            string html = null;
            string artistWithFirstCharUpper = char.ToUpper(songToFind.Artist[0]) + songToFind.Artist.Substring(1);
            string url = "";

            try
            {
                if (useLinkToSongs && !String.IsNullOrEmpty(songToFind.LinkToArtistSongs))
                {
                    url = $"https://www.tekstowo.pl/{songToFind.LinkToArtistSongs}";
                }
                else if (!String.IsNullOrEmpty(songToFind.WorkingArtist))
                {
                    url = $"https://www.tekstowo.pl/piosenki_artysty,{songToFind.WorkingArtist}.html";
                }
                else
                {
                    return(null);
                }
                HttpClient httpClient = new HttpClient();
                html = await httpClient.GetStringAsync(url);
            }
            catch (HttpRequestException)
            {
                await _pageService.DisplayAlert(AppResources.AlertDialog_SearchProblem, $"{AppResources.AlertDialog_CouldNotFindArtistsSongs} {artistWithFirstCharUpper}", AppResources.AlertDialog_OK);

                return(null);
            }
            finally
            {
                HtmlDocument htmlDocument = new HtmlDocument();
                htmlDocument.LoadHtml(html);

                // chech if is more than one pages of results

                HtmlNodeCollection queryPages = htmlDocument.DocumentNode.SelectNodes("//li[@class='page-item']");
                if (queryPages != null)
                {
                    var           listOfPages   = queryPages.ToList();
                    List <string> pagesHTMLLink = new List <string>();
                    if (!String.IsNullOrEmpty(url))
                    {
                        pagesHTMLLink.Add(url);
                    }

                    foreach (var div in listOfPages)
                    {
                        int indexStartLink = div.InnerHtml.IndexOf("href") + 7;
                        int indexEndLink   = div.InnerHtml.IndexOf("title=") - 2;
                        int checkIndexOfNextPageButtonElement = div.InnerHtml.IndexOf("tabindex=");
                        if (checkIndexOfNextPageButtonElement != -1)
                        {
                            continue;
                        }
                        if (indexStartLink != 0 && indexEndLink != 0)
                        {
                            string link = div.InnerHtml[indexStartLink..indexEndLink];
        public static async Task <string> FindTextFromArtistAndTitle(FindedSongObject songToFind, Boolean useLinkFromObject = false)
        {
            IPageService _pageService = new PageService();
            string       html         = null;
            string       text         = null;

            try
            {
                string url;
                if (useLinkFromObject && !String.IsNullOrEmpty(songToFind.LinkToSong))
                {
                    url = $"https://www.tekstowo.pl/" + songToFind.LinkToSong;
                }
                else if (songToFind.WorkingArtist != "" && songToFind.WorkingTitle != "")
                {
                    url = $"https://www.tekstowo.pl/piosenka,{songToFind.WorkingArtist},{songToFind.WorkingTitle}.html";
                }
                else
                {
                    return(null);
                }
                HttpClient httpClient = new HttpClient();
                html = await httpClient.GetStringAsync(url);
            }
            catch (HttpRequestException)
            {
                await _pageService.DisplayAlert(AppResources.AlertDialog_TextNotFound, $"{AppResources.AlertDialog_TextNotFoundFor} { songToFind.Title} { songToFind.Artist} \n{AppResources.AlertDialog_SelectArtistAndTrackManually}", AppResources.AlertDialog_OK);

                return(null);
            }
            finally
            {
                if (html != null && html != "")
                {
                    HtmlDocument htmlDocument = new HtmlDocument();
                    htmlDocument.LoadHtml(html);

                    text = htmlDocument.DocumentNode.SelectSingleNode("//div[@id='songText']").InnerText;

                    text = DeleteLines(text, 2, false);
                    text = DeleteLines(text, 4, true);
                    text = DeleteStartAndEndEmptyLines(text);
                }
            }
            return(text);
        }
Exemple #3
0
        async Task SearchText()
        {
            try
            {
                int searchType;
                FindedSongObject songToFind = new FindedSongObject()
                {
                    Title = Title, Artist = Artist
                };



                if ((Title != null && !Title.Equals("")) && (Artist != null && !Artist.Equals("")))
                {
                    songToFind.WorkingTitle  = TekstowoHelper.NormalizeTextWithoutPolishSpecialChar(Title.ToLower().Replace(" ", "_"));
                    songToFind.WorkingArtist = TekstowoHelper.NormalizeTextWithoutPolishSpecialChar(Artist.ToLower().Replace(" ", "_"));
                    searchType = 1;
                }
                else if ((Artist != null && !Artist.Equals("")) && (Title == null || Title.Equals("")))
                {
                    songToFind.WorkingArtist = TekstowoHelper.NormalizeTextWithoutPolishSpecialChar(Artist.ToLower().Replace(" ", "_"));
                    searchType = 2;
                }
                else if ((Artist == null || Artist.Equals("")) && (Title != null && !Title.Equals("")))
                {
                    songToFind.WorkingTitle = TekstowoHelper.NormalizeTextWithoutPolishSpecialChar(Title.ToLower().Replace(" ", "_"));
                    searchType = 3;
                }
                else
                {
                    await _pageService.DisplayAlert(AppResources.AlertDialog_Error, AppResources.AlertDialog_CompleteAtLeastOneField, AppResources.AlertDialog_OK);

                    return;
                }

                switch (searchType)
                {
                case 1:
                    Text = await TekstowoHelper.FindTextFromArtistAndTitle(songToFind);

                    if (Text == null)
                    {
                        goto case 2;
                    }
                    else
                    {
                        break;
                    }

                case 2:
                    List <FindedSongObject> artistSongs = await TekstowoHelper.SearchArtistSongs(songToFind);

                    if (artistSongs.Count == 0)
                    {
                        songToFind = await TekstowoHelper.SearchArtist(songToFind);

                        if (songToFind == null)
                        {
                            break;
                        }
                        List <FindedSongObject> findedSongs = await TekstowoHelper.SearchArtistSongs(songToFind, true);

                        if (findedSongs.Count != 0)
                        {
                            List <string> listOfSongsFullName = new List <string>();
                            foreach (var item in findedSongs)
                            {
                                listOfSongsFullName.Add(item.FullSongName);
                            }
                            string choosenSong = await _pageService.DisplayPositionToChoose(AppResources.DisplayPositionToChoose_ChooseSong, AppResources.AlertDialog_Cancel, null, listOfSongsFullName.ToArray());

                            if (choosenSong.Equals(AppResources.AlertDialog_Cancel))
                            {
                                break;
                            }
                            songToFind = findedSongs[listOfSongsFullName.IndexOf(choosenSong)];
                            Text       = await TekstowoHelper.FindTextFromArtistAndTitle(songToFind, true);

                            if (!String.IsNullOrEmpty(Text))
                            {
                                Title  = songToFind.Title;
                                Artist = songToFind.Artist;
                            }
                        }
                    }
                    else
                    {
                        List <string> listOfSongsFullName = new List <string>();
                        foreach (var item in artistSongs)
                        {
                            listOfSongsFullName.Add(item.FullSongName);
                        }
                        string choosenSong = await _pageService.DisplayPositionToChoose(AppResources.DisplayPositionToChoose_ChooseSong, AppResources.AlertDialog_Cancel, null, listOfSongsFullName.ToArray());

                        if (choosenSong.Equals(AppResources.AlertDialog_Cancel))
                        {
                            break;
                        }
                        songToFind = artistSongs[listOfSongsFullName.IndexOf(choosenSong)];
                        Text       = await TekstowoHelper.FindTextFromArtistAndTitle(songToFind, true);

                        if (!String.IsNullOrEmpty(Text))
                        {
                            Title = songToFind.Title;
                        }
                    }
                    break;

                case 3:
                    songToFind = await TekstowoHelper.SearchSong(songToFind);

                    if (songToFind == null)
                    {
                        break;
                    }
                    Text = await TekstowoHelper.FindTextFromArtistAndTitle(songToFind, true);

                    if (!String.IsNullOrEmpty(Text))
                    {
                        Title  = songToFind.Title;
                        Artist = songToFind.Artist;
                    }

                    break;

                default:
                    break;
                }
            }
            catch (Exception e)
            {
                Log.Debug(TAG, e.Message);
                await _pageService.DisplayAlert(AppResources.AlertDIalog_UnexpectedError, AppResources.AlertDIalog_UnexpectedErrorMessage, AppResources.AlertDialog_OK);
            }
        }