public static Task<RadioSong> GetCurrentSong()
        {
            var tcs = new TaskCompletionSource<RadioSong>();

            WebClient wc = new WebClient();
            wc.DownloadStringCompleted += (s, args) =>
            {
                if (args.Error == null)
                {
                    try
                    {
                        var json = JObject.Parse(args.Result);
                        var currentSong = new RadioSong();
                        currentSong.Album = json["album"].ToString();
                        currentSong.AlbumArt = json["album_art"].ToString();
                        currentSong.Artist = json["artist"].ToString();
                        currentSong.Title = json["title"].ToString();
                        tcs.TrySetResult(currentSong);
                    }
                    catch (Exception ex)
                    {
                        tcs.TrySetException(new HomeControllerApiException("Could not parse JSON response"));
                    }
                }
                else
                {
                    tcs.TrySetException(new HomeControllerApiException("Could not get current song"));
                }
            };
            wc.DownloadStringAsync(new Uri(BaseUrl + "music/nowplaying?nocache=" + Environment.TickCount.ToString(), UriKind.Absolute));

            return tcs.Task;
        }
        public async Task UpdateAsync()
        {
            var addresses = GetAddresses();

            var songs_names = new List <Tuple <string, int> >();

            foreach (var ad in addresses)
            {
                songs_names.AddRange(get_names_from_url(ad.Key, ad.Value).ToList());
            }

            songs_names.Sort();


            //  var list_of_songs = new List<RadioSong>();
            var hash_songs = new HashSet <string>();

            foreach (var tu in songs_names)
            {
                hash_songs.Add(tu.Item1);
            }

            var hash_songs_list = hash_songs.ToList();

            /* foreach(var name in hash_songs.ToList())
             * {
             *  await  _liveContext.RadioSongs.AddAsync(new RadioSong(name));
             *  await _liveContext.SaveChangesAsync();
             * }  */

            var r_stations = new List <int>()
            {
                1, 2, 3, 4, 5, 6, 40, 9, 30, 8
            };

            // var list_from_database = await _liveContext.RadioSongs.ToListAsync();

            foreach (var song in hash_songs_list)
            {
                var song_to_data = new RadioSong(song);

                foreach (var station in r_stations)
                {
                    int count = songs_names.Where(t => t.Item1 == song && t.Item2 == station).ToList().Count;

                    if (count > 0)
                    {
                        //Console.WriteLine(song+"------"+station+"-----"+count);
                        song_to_data.setCount(station, count);
                    }

                    /*  int count = 100;
                     * song.setCount(station, count);
                     * _liveContext.Update(song);
                     * await _liveContext.SaveChangesAsync(); */

                    //    Console.WriteLine(song.Name +"---"+ station +"------"+count);
                }
                await _liveContext.RadioSongs.AddAsync(song_to_data);

                await _liveContext.SaveChangesAsync();
            }
        }
Esempio n. 3
0
 public RadioEngineBuilder SetParser(string title, string artist)
 {
     _mock.Setup(x => x.Parse(It.IsAny <Uri>())).Returns(RadioSong.Create(title, artist));
     return(this);
 }
Esempio n. 4
0
 public bool RadioSongExists(string name, RadioSong radioSong)
 {
     return(_stream.GetEvents().OfType <RadioSongParsed>()
            .Any(x => x == new RadioSongParsed(name, radioSong.Title, radioSong.Artist)));
 }