public async Task <SpotifyTrack> GetTrackById(string id) { var track = new SpotifyTrack(); HttpWebRequest request = (HttpWebRequest)WebRequest.Create($"https://api.spotify.com/v1/tracks/" + id); request.Method = "GET"; request.KeepAlive = true; request.ContentType = "appication/json"; request.Headers.Add("Authorization", $"Bearer {(await GetToken()).AccessToken}"); //request.ContentType = "application/x-www-form-urlencoded"; HttpWebResponse response = (HttpWebResponse)request.GetResponse(); string myResponse = ""; using (System.IO.StreamReader sr = new System.IO.StreamReader(response.GetResponseStream())) { myResponse = sr.ReadToEnd(); } dynamic obj = JObject.Parse(myResponse); TimeSpan time = TimeSpan.FromMilliseconds(Convert.ToDouble(obj?.duration_ms.ToString())); var second = time.Seconds < 10 ? "0" : "" + $"{ time.Seconds}"; track = new SpotifyTrack { Name = obj?.artists[0]?.name.ToString() + " - " + obj?.name.ToString(), Id = obj?.id.ToString(), Image = obj?.album?.images[1].url.ToString(), Duration = $"{time.Minutes}:{second}" }; return(track); }
private async Task <bool> UpdateTrackInfoUsingWebApi() { if (this.Web?.API == null) { return(false); } // Pre-emptively waiting a little bit to let the remote Spotify server update its own information await Task.Delay(TimeSpan.FromMilliseconds(50)).ConfigureAwait(false); var currentlyPlayingObject = await this.Web.API.GetCurrentlyPlayingTrackAsync().ConfigureAwait(false); if (currentlyPlayingObject?.Track == null || !currentlyPlayingObject.Track.IsValid()) { return(false); } ISpotifyTrack newTrack = currentlyPlayingObject.Track; if (!SpotifyTrack.Equal(this.CurrentTrack, newTrack)) { ISpotifyTrack oldTrack = this.CurrentTrack; this.CurrentTrack = newTrack; await this.OnTrackChanged(oldTrack).ConfigureAwait(false); } await this.OnPlayStateChanged(currentlyPlayingObject.IsPlaying).ConfigureAwait(false); return(true); }
public TracksController(IMapper mapper, SpotifyTrack trackrepo, ICookieManager cookiesManager, FullTrackViewModel model) { _mapper = mapper; _trackrepo = trackrepo; _model = model; _cookiesManager = cookiesManager; }
public static TrackListViewModel ToListViewModel(this SpotifyTrack model) { return(new TrackListViewModel { Name = model.Name, ListeningLink = model.ListeningURL, Artists = string.Join(" - ", model.Artists.Select(x => x.Name)), DanceabilityScore = CalculateScore(model.DanceabilityValue) }); }
private SpotifyPlayer(JObject obj) : base(obj) { //Device = obj.GetObject("device", SpotifyDevice.Parse); //RepeatState = obj.GetString("repeat_state"); //ShuffleState = obj.GetString("shuffle_state"); Context = obj.GetObject("context", SpotifyContext.Parse); TimeStamp = obj.GetInt64("timestamp"); ProgressMs = int.Parse(obj.GetString("progress_ms")); IsPlaying = bool.Parse(obj.GetString("is_playing")); Item = obj.GetObject("item", SpotifyTrack.Parse); }
void ExtractTrack(string response) { SpotifyItem item = SpotifyItem.CreateFromJSON(response); /* If no track is being listened */ if (item == null) { trackName.text = "No track selected"; albumName.text = ""; artistName.text = ""; deviceName.text = ""; } else { SpotifyTrack track = item.item; /* Setting the current value of the progress bar */ slider.value = item.progress_ms; deviceName.text = "Listening on " + item.device.name; if (!item.is_playing && !isPaused) { animator.SetBool("paused", true); isPaused = true; } else if (item.is_playing && isPaused) { animator.SetBool("paused", false); isPaused = false; } /* Check to see if track has changed */ if (trackName.text != track.name) { trackName.text = track.name; artistName.text = "by " + track.artists[0].name; /* Setting the max value of the progress bar */ slider.maxValue = track.duration_ms; /* If album is a new one, download image and change image */ if (track.album.name != albumName.text) { albumName.text = track.album.name; animator.SetBool("loading", true); StartCoroutine(DownloadAlbumImage(track.album.images)); } } } }
private async Task <bool> TryPlaySpotifyAsync(IMusicPlayerService music, ITextChannel textChan, IGuildUser guser, string url) { SpotifyTrack track = await this.SpotifyToTrackAsync(url); if (track == null) { return(false); } await music.AddTrackAsync(guser.VoiceChannel, textChan, track); return(true); }
private async void SpotifyWindowTitleWatcher_TitleChanged(object sender, WindowTitleChangedEventArgs e) { // TODO: Refactor this method try { if (logger.IsDebugEnabled) { logger.Debug($"Spotify's window title changed: \"{e.NewTitle}\". Fetching song info..."); } if (!(Settings.Current.EnableSpotifyWebApi && this.IsWebApiRunning && await this.UpdateTrackInfoUsingWebApi().ConfigureAwait(false))) { // If the WebAPIs are disabled or they weren't able to retrieve the song info, fallback to // the old method based on the title of Spotify's window. if (logger.IsDebugEnabled) { logger.Debug("Fetching song info using old method based on the title of Spotify's window..."); } bool updateSong = true; if (SpotifyWindow.PausedTitles.Contains(e.NewTitle, StringComparer.InvariantCulture)) { await this.OnPlayStateChanged(false).ConfigureAwait(false); updateSong = false; } else if (!this.IsPlaying) { await this.OnPlayStateChanged(true).ConfigureAwait(false); } if (updateSong) { ISpotifyTrack newSong = Song.FromSpotifyWindowTitle(e.NewTitle); if (!SpotifyTrack.Equal(this.CurrentTrack, newSong)) { ISpotifyTrack oldSong = this.CurrentTrack; this.CurrentTrack = newSong; await this.OnTrackChanged(oldSong).ConfigureAwait(false); } } } } catch (Exception exception) { logger.Error($"Unhandled exception in {nameof(this.SpotifyWindowTitleWatcher_TitleChanged)}.", exception); } }
public SpotifyTrack GetTrack() { SpotifyTrack newTrack = new SpotifyTrack(); if (item.id == "Unavailable") { return(newTrack); } // Unique ID newTrack.ID = item.id; // Process Artist Information string artist = string.Empty; foreach (Artist a in item.artists) { artist += a.name + ", "; } if (artist.EndsWith(", ", StringComparison.Ordinal)) { artist = artist.Substring(0, artist.LastIndexOf(", ", StringComparison.Ordinal)); } newTrack.Artist = artist; // Process Track newTrack.Track = item.name; newTrack.Album = item.album.name; // URL if (item.external_urls.ContainsKey("spotify")) { newTrack.TrackURL = item.external_urls["spotify"]; } // Image if (item.album.images.Count > 0) { newTrack.ImageURL = item.album.images[0].url; foreach (Image i in item.album.images) { newTrack.Images.Add(new SpotifyTrack.Image(i.url, i.width, i.height)); } } return(newTrack); }
public static Track CreateTrack(SpotifyTrack inTrack) { return(new Track { Id = inTrack.Id, Uri = inTrack.Uri, Name = inTrack.Name, Album = CreateAlbum(inTrack.Album), Type = inTrack.Type, Artists = CreateArtists(inTrack.Artists), TrackNumber = inTrack.TrackNumber, DiscNumber = inTrack.DiscNumber, Duration = TimeSpan.FromMilliseconds(inTrack.DurationMs).ToString("g") }); }
private async Task OnGuildMemberUpdatedAsync(SocketGuildUser before, SocketGuildUser after) { if (before.Activity == after.Activity) { return; } if (!(after.Activity is SpotifyGame activity)) { return; } if (!_db.Tracks.Any(x => x.Id == activity.TrackId)) { var track = new SpotifyTrack { Id = activity.TrackId, Artists = string.Join(", ", activity.Artists), AlbumArtUrl = activity.AlbumArtUrl, AlbumTitle = activity.AlbumTitle, TrackTitle = activity.TrackTitle }; if (activity.Duration.HasValue) { track.Duration = activity.Duration.Value.Ticks; } await _db.Tracks.AddAsync(track); } await _db.Listens.AddAsync(new SpotifyListen { GuildId = after.Guild.Id, UserId = after.Id, TrackId = activity.TrackId }); await _db.SaveChangesAsync(); _logger.LogInformation($"{after.Guild}: {activity.ToString()}"); }
public async Task AddSpotifyTrackAsync(Artist artist, string track, string url) { if (artist == null || string.IsNullOrEmpty(url) || string.IsNullOrEmpty(track)) { return; } string formattedTrack = track.Length > 255 ? track.Substring(0, 255) : track; var existingTrack = await context.SpotifyTracks.FirstOrDefaultAsync(t => t.Track == formattedTrack && t.Artist.Name == artist.Name); if (existingTrack != null) { return; } var spotifyTrack = new SpotifyTrack { Url = url, Artist = artist, Track = formattedTrack }; await context.SpotifyTracks.AddAsync(spotifyTrack); try { await context.SaveChangesAsync(); } catch (ArgumentException e) { Console.WriteLine(e); } }
private static EmbedBuilder CreateTrackEmbed(SpotifyTrack track) { var embed = new EmbedBuilder { Color = BotService.DefaultEmbedColour, Author = new EmbedAuthorBuilder { Name = track.Artists.Select(a => a.Name).Humanize(), IconUrl = track.Album.Images.FirstOrDefault()?.Url, Url = track.Artists.FirstOrDefault()?.Id.Url }, Title = track.Name, ThumbnailUrl = track.Album.Images.FirstOrDefault()?.Url }; embed.AddField("Length", $"{track.Duration.Minutes} minutes, {track.Duration.Seconds} seconds", true); embed.AddField("Release Date", track.Album.ReleaseDate.ToString("D"), true); embed.AddField("Album", UrlHelper.CreateMarkdownUrl(track.Album.Name, track.Album.Id.Url), true); embed.AddField("Is Explicit", track.HasExplicitLyrics ? "Yes" : "No", true); embed.AddField("\u200B", UrlHelper.CreateMarkdownUrl("Click to listen!", track.Id.Url)); return(embed); }
public SpotifyTrackViewModel(SpotifyTrack track) { _track = track; _visible = true; }
public async Task <IEnumerable <SpotifyTrack> > SearchTracks(IEnumerable <Track> tracksToFind, string accessToken) { Logger.Section($"Searching For {tracksToFind.Count()} tracks on Spotify"); var foundTracks = new List <SpotifyTrack>(100); int messageThreshold = 50; int counter = 0; foreach (var trackToFind in tracksToFind) { var title = trackToFind.Title; title = title.Replace(" ", "%20"); // artist = artist.Replace(" ", "%20"); var queryString = new QueryString("q", $"{title}%20").Add("type", "track").Format(false); var uri = $"{TrackSearchEndpoint}?{queryString}"; var message = new HttpRequestMessage(HttpMethod.Get, uri); message.Headers.Add("Authorization", $"Bearer {accessToken}"); var response = await _httpClient.SendAsync(message); var json = await response.Content.ReadAsStringAsync(); var jobject = JObject.Parse(json); var items = jobject.SelectToken("tracks.items") as JArray; if (items == null) { continue; } var tracks = new List <SpotifyTrack>(); foreach (JObject node in items) { var type = node.SelectToken("type"); var artists = node.SelectToken("artists") as JArray; if (artists != null && artists.Any(x => x.SelectToken("name").Value <string>().Equals(trackToFind.Artist, StringComparison.OrdinalIgnoreCase))) { if (type != null) { if (type.Value <string>().Equals("track")) { var track = new SpotifyTrack { AlbumId = node.SelectToken("album.id").Value <string>(), Album = node.SelectToken("album.name").Value <string>(), Title = node.SelectToken("name").Value <string>(), Id = node.SelectToken("id").Value <string>(), Uri = node.SelectToken("uri").Value <string>() }; trackToFind.UnqiueId = node.SelectToken("uri").Value <string>(); if (track.Uri != null) { foundTracks.Add(track); break; } } } } } counter++; if (counter % messageThreshold == 0) { Logger.Magenta($"Processed {foundTracks.Count} tracks thus far...."); } } Logger.Magenta($"Found {foundTracks.Count} tracks from spotify."); return(foundTracks); }
private async void SpotifyWindowTitleWatcher_TitleChanged(object sender, WindowTitleChangedEventArgs e) { // TODO: Refactor this method try { if (logger.IsDebugEnabled) { logger.Debug($"Spotify's window title changed: \"{e.NewTitle}\". Fetching song info..."); } bool shouldUpdateUsingWindowTitle = !(Settings.Current.EnableSpotifyWebApi && this.IsWebApiRunning); this.apiTrackDelayedUpdateTimer?.Dispose(); bool tooFast = this.songChangesInTimespan >= 3; if (!shouldUpdateUsingWindowTitle && tooFast) { logger.Debug($"Songs are being changed too fast ({this.songChangesInTimespan} times in {this.songChangeBuffer.TotalMilliseconds} ms)!"); this.apiTrackDelayedUpdateTimer = new Timer(async state => { logger.Debug($"Executing delayed track update using WebAPI (\"{state}\")"); await this.UpdateTrackInfoUsingWebApi().ConfigureAwait(false); }, e.NewTitle, this.songChangeBuffer, TimeSpan.FromMilliseconds(-1)); shouldUpdateUsingWindowTitle = true; } if (!shouldUpdateUsingWindowTitle) { shouldUpdateUsingWindowTitle = !await this.UpdateTrackInfoUsingWebApi().ConfigureAwait(false); } if (shouldUpdateUsingWindowTitle) { // If the WebAPIs are disabled or they weren't able to retrieve the song info, fallback to // the old method based on the title of Spotify's window. if (logger.IsDebugEnabled) { logger.Debug("Fetching song info using old method based on the title of Spotify's window..."); } bool updateSong = true; if (SpotifyWindow.PausedTitles.Contains(e.NewTitle, StringComparer.InvariantCulture)) { await this.OnPlayStateChanged(false).ConfigureAwait(false); updateSong = false; } else if (!this.IsPlaying) { await this.OnPlayStateChanged(true).ConfigureAwait(false); } if (updateSong) { ISpotifyTrack newSong = Song.FromSpotifyWindowTitle(e.NewTitle); if (!SpotifyTrack.Equal(this.CurrentTrack, newSong)) { ISpotifyTrack oldSong = this.CurrentTrack; this.CurrentTrack = newSong; await this.OnTrackChanged(oldSong).ConfigureAwait(false); } } } this.songChangesInTimespan++; if (DateTime.Now - this.lastSongChange > this.songChangeBuffer) { this.songChangesInTimespan = 0; } this.lastSongChange = DateTime.Now; } catch (Exception exception) { logger.Error($"Unhandled exception in {nameof(this.SpotifyWindowTitleWatcher_TitleChanged)}.", exception); } }