public async Task ShouldReplacePlaylistItems()
{
// Arrange
const string playlistId = "40C5k2GWBlficlUyQKmR0S";
var uris = new[] { SpotifyUri.OfTrack("3n3Ppam7vgaVa1iaRUc9Lp"), SpotifyUri.OfEpisode("512ojhOuo1ktJprKbVcKyQ") };
this.MockHttp
.ExpectSpotifyRequest(HttpMethod.Put, $"playlists/{playlistId}/tracks")
.WithExactQueryString(string.Empty)
.WithJsonContent(j =>
j.EnumerateObject().Count() == 1 &&
j.TryGetProperty("uris", out var array) && array.EnumerateArray().ToArray().Select(x => x.GetString()).SequenceEqual(uris))
.Respond(HttpStatusCode.OK, "application/json", "{}");
// Act
var result = await this.Client.Playlists(playlistId).Items.ReplaceAsync(uris);
// Assert
this.MockHttp.VerifyNoOutstandingExpectation();
result.Should().NotBeNull();
}
public async void UpdateTrack(Track track)
{
_currentTrack = track;
//advertLabel.Text = track.IsAd() ? "ADVERT" : "";
timeProgressBar.Maximum = track.Length;
if (track.IsAd())
{
return; //Don't process further, maybe null values
}
titleLinkLabel.Text = track.TrackResource.Name;
titleLinkLabel.Tag = track.TrackResource.Uri;
trackRight.Text = track.TrackResource.Name;
trackRight.Tag = track.TrackResource.Uri;
titleLinkLabel.UseMnemonic = false;
trackRight.UseMnemonic = false;
artistLinkLabel.Text = track.ArtistResource.Name;
artistLinkLabel.Tag = track.ArtistResource.Uri;
artistRight.Text = track.ArtistResource.Name;
artistRight.Tag = track.ArtistResource.Uri;
artistLinkLabel.UseMnemonic = false;
artistRight.UseMnemonic = false;
albumLinkLabel.Text = track.AlbumResource.Name;
albumLinkLabel.Tag = track.AlbumResource.Uri;
albumRight.Text = track.AlbumResource.Name;
albumRight.Tag = track.AlbumResource.Uri;
albumLinkLabel.UseMnemonic = false;
albumRight.UseMnemonic = false;
SpotifyUri uri = track.TrackResource.ParseUri();
//trackInfoBox.Text = $@"Track Info - {uri.Id}";
//bigAlbumPicture.Image = await track.GetAlbumArtAsync(AlbumArtSize.Size640);
smallAlbumPicture.Image = await track.GetAlbumArtAsync(AlbumArtSize.Size160);
}
public async Task ShouldAddItemToPlaybackQueueForSpecificDevice()
{
// Arrange
const string deviceId = "device1";
var uri = SpotifyUri.OfAlbum("6akEvsycLGftJxYudPjmqK");
this.MockHttp
.ExpectSpotifyRequest(HttpMethod.Post, $"me/player/queue")
.WithExactQueryString(new Dictionary <string, string>
{
["device_id"] = deviceId,
["uri"] = uri
})
.WithNullContent()
.Respond(HttpStatusCode.OK);
// Act
await this.Client.Me.Player.Playback(deviceId).Queue.AddAsync(uri);
// Assert
this.MockHttp.VerifyNoOutstandingExpectation();
}
/// <inheritdoc />
public async Task <IList <SimpleAlbum> > GetArtistAlbums(SpotifyUri artistUri, AlbumType albumTypes, string market, int maxResults, int offset)
{
var albumTypeString = string.Empty;
if (albumTypes.HasFlag(AlbumType.Album))
{
albumTypeString += "album,";
}
if (albumTypes.HasFlag(AlbumType.AppearsOn))
{
albumTypeString += "appears_on,";
}
if (albumTypes.HasFlag(AlbumType.Compilation))
{
albumTypeString += "compilation,";
}
if (albumTypes.HasFlag(AlbumType.Single))
{
albumTypeString += "compilation,";
}
albumTypeString = albumTypeString.Remove(albumTypeString.Length - 1);
var r = await ApiClient.GetAsync <Paging <SimpleAlbum> >(
MakeUri(
$"artists/{artistUri.Id}/albums?{albumTypeString}",
("album_type", albumTypeString),
("limit", "50"),
("offset", offset.ToString()),
("market", market)),
this.Token);
if (r.Response is Paging <SimpleAlbum> res)
{
return(await res.LoadToList(this.Token));
}
return(new List <SimpleAlbum>());
}
public IActionResult Index()
{
var playlistTracks = new List <PlaylistTrack>();
if (_spotifyAuthService.GetToken() != null)
{
var api = new SpotifyWebApi.SpotifyWebApi(_spotifyAuthService.GetToken());
var fullPlaylistTracks = api.Playlist.GetPlaylistTracks(SpotifyUri.Make("1233033915", "2CuhODa4xTTlemWopeXG71")).Result;
foreach (var track in fullPlaylistTracks)
{
var usernameModel = _usernames.GetValueOrDefault(track.AddedBy.Id);
playlistTracks.Add(new PlaylistTrack
{
Name = track.Track.Name,
Artist = track.Track.Artists.FirstOrDefault().Name,
AddedBy = usernameModel?.Name,
AddedByImage = usernameModel?.ImageName
});
}
}
List <PlayedTrackViewModel> playedTrackViewModels = new List <PlayedTrackViewModel>();
var playedTrackEntities = _storageService.GetPlayedTracks().Result;
if (playedTrackEntities != null)
{
for (var i = 0; i < playedTrackEntities.Count(); i++)
{
playedTrackViewModels.Add(TrackEntityToPlayedTrackViewModel.Map(playedTrackEntities[i], i, playlistTracks));
}
}
ViewBag.PlayedTracks = playedTrackViewModels;
return(View());
}
/// <inheritdoc />
public Task <FullPlaylist> CreatePlaylist(
SpotifyUri user, string name, bool @public, bool collaborative, string description)
{
throw new NotImplementedException();
}
/// <inheritdoc />
public Task AddTracksToPlaylist(SpotifyUri playlistUri, IList <SpotifyUri> tracks, int?position = null)
{
throw new NotImplementedException();
}
public async Task ShouldStartNewPlaybackForDeviceFromUrisWithAllParams()
{
// Arrange
const string deviceId = "device1";
var positon = TimeSpan.FromSeconds(10);
var uris = new[] { SpotifyUri.OfAlbum("6akEvsycLGftJxYudPjmqK"), SpotifyUri.OfEpisode("512ojhOuo1ktJprKbVcKyQ") };
var offset = uris[1];
this.MockHttp
.ExpectSpotifyRequest(HttpMethod.Put, $"me/player/play")
.WithExactQueryString(new Dictionary <string, string> {
["device_id"] = deviceId
})
.WithJsonContent(j =>
j.EnumerateObject().Count() == 3 &&
j.TryGetProperty("uris", out var array) && array.EnumerateArray().ToArray().Select(x => x.GetString()).SequenceEqual(uris) &&
j.TryGetProperty("offset", out var offsetProperty) && offsetProperty.EnumerateObject().Count() == 1 &&
offsetProperty.TryGetProperty("uri", out var uriProperty) && uriProperty.GetString() == offset &&
j.TryGetProperty("position_ms", out var positionMs) && positionMs.GetInt32() == 10000)
.Respond(HttpStatusCode.OK, "application/json", "{}");
// Act
await this.Client.Me.Player.Playback(deviceId).StartNewAsync(uris, offset, positon);
// Assert
this.MockHttp.VerifyNoOutstandingExpectation();
}
public void ShouldThrowArgumentExceptionForInvalidUri()
{
Assert.Throws <ArgumentException>(() => SpotifyUri.Parse("asdafadfgsrsegqejfa"));
}
public IPlaybackPlayWithOffsetBuilder Playlist(string ownerId, string playlistId)
{
return(new PlaybackPlayBuilder(this.playbackContext, new Body {
ContextUri = SpotifyUri.ForPlaylist(ownerId, playlistId)
}));
}
public IPlaybackPlayWithOffsetBuilder Tracks(IEnumerable <string> ids)
{
return(new PlaybackPlayBuilder(this.playbackContext, new Body {
TrackUris = ids.Select(item => SpotifyUri.ForTrack(item)).ToArray()
}));
}
public void MakeTest()
{
SpotifyUri.Make("spotify:playlist:3ewZM7pLkkmbqULVsRZwnM");
}
/// <inheritdoc />
public Task StartPlayback(Device device = null, SpotifyUri contextUri = null, List <SpotifyUri> uris = null)
{
throw new NotImplementedException();
}
/// <summary>Activates the playlist.</summary>
public void ActivatePlaylist()
{
this.playListViewModel.ActivatePlaylist(SpotifyUri.Make(this.Uri));
}
public void GetPlaylistTest()
{
var test = this.Api.Playlist.GetPlaylist(SpotifyUri.Make("spotify:playlist:3ewZM7pLkkmbqULVsRZwnM")).Result;
}
/// <summary>Activates the playlist.</summary>
/// <param name="uri">The URI of the playlist to activate.</param>
public void ActivatePlaylist(SpotifyUri uri)
{
this.AttachedDataModel = null;
this.playListService.SetPlaylist(uri);
}
/// <summary>Sets the currently played playlist.</summary>
/// <param name="uri">The uri of the playlist.</param>
public async void SetPlaylist(SpotifyUri uri)
{
await this.EnsureActiveDeviceExists();
await this.api.Player.StartPlayback(null, uri, null, null);
}
/// <summary>
/// Executes the play command.
/// </summary>
private void PlayCommandExecute()
{
this.playBackService.SetPlaylist(SpotifyUri.Make(this.Uri));
}
public async Task GetAlbumTracksTest(string uri, int expectedTrackCount)
{
var tracks = await this.Api.Album.GetAlbumTracks(SpotifyUri.Make(uri));
Assert.Equal(expectedTrackCount, tracks.Count);
}
public IPlaybackPlayWithOffsetBuilder Album(string id)
{
return(new PlaybackPlayBuilder(this.playbackContext, new Body {
ContextUri = SpotifyUri.ForAlbum(id)
}));
}
/// <summary>Executes the play command.</summary>
private void PlayCommandExecute()
{
this.playbackService.SetSong(SpotifyUri.Make(this.PlaylistUri), SpotifyUri.Make(this.Uri));
}
public IPlaybackPlayBuilder Artist(string id)
{
return(new PlaybackPlayBuilder(this.playbackContext, new Body {
ContextUri = SpotifyUri.ForArtist(id)
}));
}
