public async Task SpotifyPlaylist(CommandContext ctx, string uri)
{
FullAlbum album = await global.spotify.Albums.Get(uri.Split(":").Last());
if (album.Tracks.Items.Count != 0)
{
await ctx.Message.Channel.SendMessageAsync("Loading playlist...");
if (await global.lavaPlayer.Join(ctx))
{
List <LavalinkTrack> tracks = new List <LavalinkTrack>(album.Tracks.Items.Count);
foreach (SimpleTrack track in album.Tracks.Items)
{
LavalinkTrack lavaTrack = await LavaPlayer.SearchToTrack(ctx, $"{track.Name} - {track.Artists[0].Name}");
if (lavaTrack != null)
{
tracks.Add(lavaTrack);
}
}
tracks.TrimExcess();
await global.lavaPlayer.PlayTracksList(ctx, tracks);
}
}
else
{
await ctx.Message.Channel.SendMessageAsync("Invalid link!");
}
}
public void MapSpotifyAlbumToTrack(Track track, FullAlbum spotifyAlbum)
{
track.AlbumArtists = GetAlbumArtistFromSimpleArtistList(spotifyAlbum.Artists);
track.Album = spotifyAlbum.Name;
track.Genres = spotifyAlbum.Genres.ToArray();
if (DateTime.TryParse(spotifyAlbum.ReleaseDate ?? "", out var date))
{
track.Year = date.Year;
}
if (spotifyAlbum.Images?.Count > 0)
{
var sorted = spotifyAlbum.Images.OrderByDescending(i => i.Width).ToList();
if (sorted.Count > 0)
{
track.ArtExtraLargeUrl = sorted[0].Url;
}
if (sorted.Count > 1)
{
track.ArtLargeUrl = sorted[1].Url;
}
if (sorted.Count > 2)
{
track.ArtMediumUrl = sorted[2].Url;
}
if (sorted.Count > 3)
{
track.ArtSmallUrl = sorted[3].Url;
}
}
}
public static List <Track> GetAlbumTracks(string albumId)
{
Paging <SimpleTrack> album = _spotify.GetAlbumTracks(albumId);
FullAlbum albumInfo = _spotify.GetAlbum(albumId);
List <Track> tracks = new List <Track>();
foreach (SimpleTrack track in album.Items)
{
string artists = "";
track.Artists.ForEach(artist => artists += artist.Name + ",");
tracks.Add(new Track()
{
SongTitle = track.Name,
Album = albumInfo.Name,
Artists = artists,
TrackNumber = track.TrackNumber,
DiscNumber = track.DiscNumber,
Year = albumInfo.ReleaseDate,
CoverLink = new Uri(albumInfo.Images[0].Url),
Status = -1,
Progress = 0,
Platform = Agent.Spotify
});
}
return(tracks);
}
internal void MapSpotifyAlbumToTrackMissingImages_ReturnsExpectedTrack()
{
var fullAlbum = new FullAlbum
{
Artists = new List <SimpleArtist>
{
new SimpleArtist {
Name = "Artist"
},
new SimpleArtist {
Name = "Other Artist"
}
},
Name = "Album Name",
Genres = new List <string> {
"Reggae", "Rock", "Jazz"
},
ReleaseDate = "2010-10-10",
Images = new List <Image>()
};
_spotifyAPI.MapSpotifyAlbumToTrack(_track, fullAlbum);
Assert.Equal(new[] { "Artist", "Other Artist" }, _track.AlbumArtists);
Assert.Equal("Album Name", _track.Album);
Assert.Equal(new[] { "Reggae", "Rock", "Jazz" }, _track.Genres);
Assert.Equal(2010, _track.Year);
Assert.Null(_track.ArtExtraLargeUrl);
Assert.Null(_track.ArtLargeUrl);
Assert.Null(_track.ArtMediumUrl);
Assert.Null(_track.ArtSmallUrl);
}
public SpotifyCollection(FullAlbum album, IEnumerable <SpotifyTrack> items)
{
Items = items;
Images = album.Images.Select(image => image.Url)
.ToArray();
Authors = album.Artists.ToDictionary(
artist => artist.Name,
artist =>
{
try
{
return(new Uri(artist.ExternalUrls["spotify"]));
}
catch (KeyNotFoundException) // Should never fail
{
return(new Uri(artist.Uri));
}
});
ExternUrls = new Dictionary <string, Uri>(
album.ExternalUrls.Select(
pair => new KeyValuePair <string, Uri>(pair.Key, new Uri(pair.Value)))); // Convert value to URI
Id = album.Id;
Name = album.Name;
Type = album.Type;
try
{
Uri = ExternUrls["spotify"];
}
catch (KeyNotFoundException) // Should never fail
{
// Convert Spotify URI to a track link (wont link track to playlist or album if it was linked)
Uri = new Uri(album.Uri);
}
}
public IMusic ParseUri(string uri)
{
//https://open.spotify.com/track/2fTdRdN73RgIgcUZN33dvt
//https://open.spotify.com/album/2N367tN1eIXrHNVe86aVy4?si=A-1kS4F4Tfy2I_PYEDVhMA
//https://open.spotify.com/artist/5cj0lLjcoR7YOSnhnX0Po5
uri = NormalizeSpotifyUri(uri);
string[] uriParts = uri.Split("/");
if (uriParts.Contains("track"))
{
FullTrack sTrack = ConverterBot.Clients.SpotifyClient.Tracks.Get(uriParts.Last( )).Result;
return(new Track(sTrack.Name,
sTrack.Artists.First( ).Name,
sTrack.Album.Name,
0,
sTrack.Id));
}
if (uriParts.Contains("album"))
{
string id;
if (uriParts.Last( ).Contains("?"))
{
id = uriParts.Last( ).Split("?").First( );
}
else
{
id = uriParts.Last( );
}
FullAlbum sAlbum = ConverterBot.Clients.SpotifyClient.Albums.Get(id).Result;
return(new Album(sAlbum.Name,
sAlbum.Artists.First( ).Name,
sAlbum.ReleaseDate,
sAlbum.Id));
}
if (uriParts.Contains("artist"))
{
FullArtist sArtist = ConverterBot.Clients.SpotifyClient.Artists.Get(uriParts.Last( )).Result;
List <SimpleAlbum>?sArtistAlbums = ConverterBot.Clients.SpotifyClient.Artists.GetAlbums(uriParts.Last( )).Result.Items;
SimpleAlbum sSampleAlbum = sArtistAlbums?.First( );
Album sampleAlbum = new Album(sSampleAlbum?.Name,
sArtist.Name,
sSampleAlbum?.ReleaseDate,
sSampleAlbum?.Id);
return(new Artist(sArtist.Name,
sampleAlbum,
null,
sArtist.Id));
}
return(null);
}
// GET: Musics/MusicDetails/5
public ActionResult MusicDetails(string Id)
{
List <MusicModels> musics = db.Musics.ToList();
foreach (var m in musics)
{
if (m.ID.ToString() == Id)
{
return(View(db.Musics.Include(mu => mu.ID_Album).Where(mu => mu.ID.ToString().Equals(Id)).First()));
}
}
FullTrack track = _spotify.GetTrack(Id);
FullAlbum album = null;
ViewBag.Boolean = IsBuy(User.Identity.GetUserId().ToString(), Id);
MusicModels v = new MusicModels
{
ID_Spotify = Id,
Title = track.Name,
prix = track.Popularity / 7,
Note = track.Popularity,
ID_User = track.Artists,
PreviewUrl = track.PreviewUrl,
};
if (track.Album != null)
{
album = _spotify.GetAlbum(track.Album.Id);
v.Album = album.Name;
v.ReleaseDate = DateTime.Parse(album.ReleaseDate);
}
return(View(v));
}
public void MapSpotifyAlbumToTrack(Track track, FullAlbum spotifyAlbum)
{
track.AlbumArtists = spotifyAlbum.Artists.Select(a => a.Name).ToArray();
track.Album = spotifyAlbum.Name;
track.Genres = spotifyAlbum.Genres.ToArray();
if (uint.TryParse(spotifyAlbum.ReleaseDate?.Substring(0, 4), out var year))
{
track.Year = year;
}
if (spotifyAlbum.Images.Count > 0)
{
var sorted = spotifyAlbum.Images.OrderByDescending(i => i.Width).ToList();
if (sorted.Count > 0)
{
track.ArtExtraLargeUrl = sorted[0].Url;
}
if (sorted.Count > 1)
{
track.ArtLargeUrl = sorted[1].Url;
}
if (sorted.Count > 2)
{
track.ArtMediumUrl = sorted[2].Url;
}
if (sorted.Count > 3)
{
track.ArtSmallUrl = sorted[3].Url;
}
}
}
public static async Task <List <Track> > IndexNewAlbumTracksAsync(
Guid albumId,
FullAlbum album,
IEnumerable <Artist> albumArtists,
IRepositoryManager repositoryManager,
IMapper mapper,
SpotifyAPICredentials spotifyAPICredentials)
{
List <Track> newAlbumTracks = new List <Track>();
HashSet <string> albumArtistsSpotifyIds = albumArtists.Select(a => a.SpotifyId).ToHashSet();
foreach (var track in album.Tracks.Items)
{
var newTrack = new Track
{
SpotifyId = track.Id,
AlbumId = albumId,
Name = track.Name,
TrackNumber = (short)track.TrackNumber,
DiscNumber = (byte)track.DiscNumber,
Duration = track.DurationMs
};
newTrack.TrackArtists = await MapTrackArtistsAsync(
track,
albumArtistsSpotifyIds,
albumArtists,
repositoryManager,
mapper,
spotifyAPICredentials).ConfigureAwait(false);
}
return(newAlbumTracks);
}
private async Task <(FullAlbum album, IEnumerable <SpotifyTrackInfo> infos)> GetSpotifyInfos(string id, int startIndex, int maxResults)
{
FullAlbum album = await this.RunConfig.Api.GetAlbumAsync(id);
IEnumerable <SpotifyTrackInfo> sourceTracks = album.Tracks.Items.Select(track => new SpotifyTrackInfo(track));
IEnumerable <SpotifyTrackInfo> infos = await SpotifyCollectionHandler.GetAllSpotifyInfosAsync(sourceTracks, id, new CollectionOptions(album.Tracks.Total, startIndex, maxResults), this.CollectionGetter);
return(album, infos);
}
private static DateTime GetDateTime(FullAlbum album)
{
if (album.ReleaseDatePrecision != "year")
{
return(DateTime.Parse(album.ReleaseDate));
}
var year = int.Parse(album.ReleaseDate);
return(new DateTime(year, 1, 1));
}
public static Album ToAlbum(this FullAlbum fullAlbum)
{
var album = new Album
{
ProviderId = "spotify." + fullAlbum.Id,
Name = fullAlbum.Name.Trim().Replace(" ", " "),
ReleaseDate = GetDateTime(fullAlbum)
};
return(album);
}
public string ReturnSongFromAlbum(FullAlbum album, string cancion)
{
foreach (SimpleTrack track in album.Tracks.Items)
{
if (track.Name == cancion)
{
return(track.Id);
}
}
return(string.Empty);
}
public ErrorResponse ReproducirCancion(string uri, CancionLarga cl)
{
FullAlbum album = _spotify.GetAlbum(uri);
List <string> uris = new List <string>();
foreach (Cancion parte in cl.Partes)
{
uris.Add("spotify:track:" + DevolverCancionDelAlbum(uri, parte.titulo));
}
return(_spotify.ResumePlayback(uris: uris, offset: "", positionMs: 0));
}
public void procesarAlbum(FullAlbum album)
{
String[] parseFecha = album.ReleaseDate.Split('-');
string portada = album.Name + "_" + album.Artists[0].Name + ".jpg";
foreach (char ch in CaracteresProhibidosWindows)
{
if (portada.Contains(ch.ToString()))
{
portada = portada.Replace(ch.ToString(), string.Empty);
}
}
using (System.Net.WebClient cliente = new System.Net.WebClient())
{
try
{
System.IO.Directory.CreateDirectory(Environment.CurrentDirectory + "/covers");
cliente.DownloadFile(new Uri(album.Images[0].Url), Environment.CurrentDirectory + "/covers/" + portada);
}
catch (System.Net.WebException)
{
System.Windows.Forms.MessageBox.Show("");
portada = "";
}
}
Album a = new Album(album.Name, album.Artists[0].Name, Convert.ToInt16(parseFecha[0]), Convert.ToInt16(album.TotalTracks), Environment.CurrentDirectory + "/covers/" + portada); //creamos A
if (Programa.miColeccion.estaEnColeccion(a))
{
Log.Instance.ImprimirMensaje("Intentando añadir duplicado, cancelando...", TipoMensaje.Advertencia);
throw new InvalidOperationException();
}
a.SetSpotifyID(album.Id);
List <Cancion> canciones = new List <Cancion>(a.numCanciones);
List <SimpleTrack> c = _spotify.GetAlbumTracks(album.Id, a.numCanciones).Items;
for (int i = 0; i < c.Count; i++)
{
canciones.Add(new Cancion(c[i].Name, new TimeSpan(0, 0, 0, 0, c[i].DurationMs), ref a));
if (canciones[i].duracion.Milliseconds > 500)
{
canciones[i].duracion += new TimeSpan(0, 0, 0, 0, 1000 - canciones[i].duracion.Milliseconds);
}
else
{
canciones[i].duracion -= new TimeSpan(0, 0, 0, 0, canciones[i].duracion.Milliseconds);
}
a.duracion += canciones[i].duracion;
}
a.canciones = canciones;
a.LevantarBorrado();
Programa.miColeccion.agregarAlbum(ref a);
}
public static Album ToAlbum(this FullAlbum fullAlbum)
{
var album = new Album
{
ProviderId = "spotify." + fullAlbum.Id,
Name = fullAlbum.Name.Trim().Replace(" ", " "),
ReleaseDate = GetDateTime(fullAlbum),
Genre = fullAlbum.Genres != null?fullAlbum.Genres.FirstOrDefault() : ""
};
return(album);
}
public async Task <Release> GetReleaseById(string id)
{
FullAlbum album = await dataLayer.ExecuteQuery(new AlbumByIdQuery(id));
SimpleArtist artist = album.Artists.First();
return(new Release(
id,
name: album.Name,
artistId: artist.Id,
artistName: artist.Name,
url: album.ExternalUrls["spotify"]));
}
public string DevolverCancionDelAlbum(string uri, string cancion)
{
FullAlbum album = _spotify.GetAlbum(uri);
foreach (SimpleTrack track in album.Tracks.Items)
{
if (track.Name == cancion)
{
return(track.Id);
}
}
return(string.Empty);
}
public void GetRecommendations()
{
Debug.Log("GetRecommendations called");
if (activeSeeds.Count > 0)
{
List <string> artistIds = new List <string>();
List <string> trackIds = new List <string>();
foreach (var seed in activeSeeds)
{
PlaylistScript playlistScript = seed.GetComponent <VinylScript>().playlistScript;
if (playlistScript.trackType == PlaylistScript.TrackType.artist)
{
artistIds.Add(playlistScript.artistId);
}
else if (playlistScript.trackType == PlaylistScript.TrackType.playlist)
{
FullPlaylist fullPlaylist = spotifyManagerScript.GetPlaylist(playlistScript.ownerId, playlistScript.playlistId);
artistIds.Add(fullPlaylist.Tracks.Items[0].Track.Artists[0].Id);
}
else if (playlistScript.trackType == PlaylistScript.TrackType.track)
{
trackIds.Add(playlistScript.trackId);
}
else if (playlistScript.trackType == PlaylistScript.TrackType.album)
{
FullAlbum fullAlbum = spotifyManagerScript.GetAlbum(playlistScript.albumId);
artistIds.Add(fullAlbum.Artists[0].Id);
}
else
{
Debug.LogError("Unsupported track type");
}
}
if (artistIds.Count != 0)
{
StartCoroutine(userRecommendations.LoadUserRecommendationsWithArtist(artistIds));
}
else if (trackIds.Count != 0)
{
StartCoroutine(userRecommendations.LoadUserRecommendationsWithTrack(trackIds));
}
else
{
Debug.LogError("Seed Id list is empty");
}
}
}
public static async Task <FullAlbum> GetAlbumWithoutExceptionAsync(this SpotifyWebAPI api, string id)
{
FullAlbum album = null;
try
{
album = await api.GetAlbumAsync(id);
}
catch
{
// ignored
}
return(album);
}
private void CreatePlaylist(List <string> tracks)
{
FullPlaylist newReleases = spotify.CreatePlaylist(profile.Id, DateTime.Now.ToString("MM/dd") + " Releases");
SearchItem song = new SearchItem();
ErrorResponse response = new ErrorResponse();
if (newReleases.HasError()) //This might need more graceful integration
{
Console.WriteLine(newReleases.Error.Message);
}
foreach (string target in tracks)
{
if (target.Contains("EP") || target.Contains("Album") || target.Contains("Remixes"))
{
song = spotify.SearchItems(target, SearchType.Album);
if (song.Albums.Total > 0)
{
FullAlbum album = spotify.GetAlbum(song.Albums.Items[0].Id);
for (int i = 0; i < album.Tracks.Total; i++)
{
response = spotify.AddPlaylistTrack(profile.Id, newReleases.Id, album.Tracks.Items[i].Uri);
playlistsListBox.Items.Add(album.Tracks.Items[i].Name);
}
}
}
else
{
song = spotify.SearchItems(target, SearchType.Track);
if (song.Tracks.Items.Count > 0)
{
response = spotify.AddPlaylistTrack(profile.Id, newReleases.Id, song.Tracks.Items[0].Uri);
playlistsListBox.Items.Add(song.Tracks.Items[0].Name);
}
if (response.HasError()) //This might need more graceful integration
{
Console.WriteLine(response.Error.Message);
}
}
}
MessageBox.Show("Playlist Created!");
if (response.HasError()) //This might need more graceful integration
{
Console.WriteLine(response.Error.Message);
}
}
private void lstAlbum_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
lstSong.Items.Clear();
txtbDesc.Inlines.Clear();
string cid = "84654d712193471199189e4f593781dc";
string sid = "ab7ead187ddd4f0aaa17542b26ca8d5e";
ClientCredentialsAuth C = new ClientCredentialsAuth()
{
ClientId = cid,
ClientSecret = sid,
};
Token T = C.DoAuth();
SpotifyWebAPI Spot1 = new SpotifyWebAPI()
{
UseAuth = true,
AccessToken = T.AccessToken,
UseAutoRetry = true,
TokenType = T.TokenType,
};
try
{
var selection = (SimpleAlbum)((ListBoxItem)lstAlbum.SelectedItem).Tag;
Paging <SimpleTrack> st = Spot1.GetAlbumTracks(selection.Id);
st.Items.ForEach(x => lstSong.Items.Add(x.Name));
FullAlbum imgs = Spot1.GetAlbum(selection.Id);
BitmapImage img = new BitmapImage();
img.BeginInit();
img.UriSource = new Uri(imgs.Images[0].Url);
img.EndInit();
imgalbum.Source = img;
txtbDesc.Inlines.Add($"Popularity rating: {imgs.Popularity.ToString()}\nReleased on: {imgs.ReleaseDate}");
//txtbDesc.Inlines.Add($"");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
lstArtist.Items.Clear();
lstAlbum.Items.Clear();
lstSong.Items.Clear();
}
}
internal void MapSpotifyAlbumToTrackMissingImageSizes_ReturnsExpectedTrack()
{
var fullAlbum = new FullAlbum()
{
Artists = new List <SimpleArtist>()
{
new SimpleArtist {
Name = "Artist"
},
new SimpleArtist {
Name = "Other Artist"
}
},
Name = "Album Name",
Genres = new List <string>()
{
"Reggae", "Rock", "Jazz"
},
ReleaseDate = "2010-10-10",
Images = new List <SpotifyAPI.Web.Models.Image>()
{
new SpotifyAPI.Web.Models.Image()
{
Height = 64,
Width = 64,
Url = "http://64x64.img",
},
new SpotifyAPI.Web.Models.Image()
{
Height = 256,
Width = 256,
Url = "http://256x256.img",
},
}
};
_spotifyAPI.MapSpotifyAlbumToTrack(_track, fullAlbum);
Assert.Equal(new[] { "Artist", "Other Artist" }, _track.AlbumArtists);
Assert.Equal("Album Name", _track.Album);
Assert.Equal(new[] { "Reggae", "Rock", "Jazz" }, _track.Genres);
Assert.Equal(2010, _track.Year);
Assert.Equal("http://256x256.img", _track.ArtExtraLargeUrl);
Assert.Equal("http://64x64.img", _track.ArtLargeUrl);
Assert.Null(_track.ArtMediumUrl);
Assert.Null(_track.ArtSmallUrl);
}
public IEnumerator Test_Spotify_GetAlbum()
{
Spotify spotify = new Spotify();
spotify.TestSetup(); #if UNITY_IPHONE
//Big Fish Theory
string albumId = "1qnEwPuG3l4PqRu8h3ULH7";
FullAlbum fullAlbum = spotify.GetAlbum(albumId);
yield return(null);
Debug.Log(fullAlbum.Name);
Assert.IsFalse(fullAlbum.HasError());
}
public async Task <ActionResult> EditResult(FullAlbum model, HttpPostedFileBase coverfile)
{
if (model != null && ModelState.IsValid)
{
if (coverfile != null)
{
string fileName = System.IO.Path.GetFileName(coverfile.FileName);
coverfile.SaveAs(Server.MapPath("~/Content/img/covers/" + fileName));
model.Album.AlbumCover = fileName;
}
await _commonService.UpdateThis(model.Album);
return(RedirectToAction("ViewAlbum", new { id = model.Album.AlbumId }));
}
return(HttpNotFound());
}
public void PlaySong(string uri, LongSong cl)
{
try
{
FullAlbum album = SpotifyClient.Albums.Get(uri).Result;
List <string> uris = new List <string>();
foreach (Song parte in cl.Parts)
{
uris.Add("spotify:track:" + ReturnSongFromAlbum(album, parte.Title));
}
PlaySong(uris);
}
catch (APIException ex)
{
throw ex;
}
}
public static async Task SaveSpotifyAlbumLevel1(FullAlbum album)
{
if (!App.Locator.Setting.IsLoggedIn)
{
if (_warningCount > 0)
{
ToastManager.ShowError("Login required.");
return;
}
await MessageHelpers.LoginRequired();
_warningCount += 1;
}
App.Locator.PBar.IsEnable = true;
try
{
if (album != null)
{
foreach (var obj in album.Tracks.Items)
{
var fTrack = obj;
obj.Name = obj.Name.GetSongNameFromMain();
obj.Artist.Name = obj.Artist.Name.GetArtistName();
if (obj.Name == "Unknown Track")
{
obj.Name = fTrack.Name;
}
if (obj.Artist.Name == "Unknown Artist" && fTrack.Artist.Name != "Unknown Artist")
{
obj.Artist.Name = fTrack.Artist.Name;
}
}
}
await SpotifySavingHelper.SaveSpotifyAlbumLevel1(album);
}
catch
{
await SpotifySavingHelper.SaveSpotifyAlbumLevel1(album);
}
App.Locator.PBar.IsEnable = false;
}
private WebAlbum CreateAlbum(FullAlbum album)
{
var webAlbum = CreateAlbum(album as SimpleAlbum);
webAlbum.IsPartial = false;
webAlbum.Tracks = album.Tracks?.Items?.Select(CreateSong).ToList();
webAlbum.Artist = CreateArtist(album.Artist);
webAlbum.Genres = album.Genres;
DateTime released;
if (DateTime.TryParse(album.ReleaseDate, out released))
{
webAlbum.ReleaseDate = released;
}
return(webAlbum);
}
public void insertarAlbumFromURI(string uri)
{
Log.Instance.ImprimirMensaje("Insertando álbum con URI " + uri, TipoMensaje.Info);
Stopwatch crono = Stopwatch.StartNew();
FullAlbum sa = _spotify.GetAlbum(uri);
try
{
procesarAlbum(sa);
}
catch (Exception)
{
return;
}
crono.Stop();
Log.Instance.ImprimirMensaje("Añadido", TipoMensaje.Correcto, crono);
Programa.refrescarVista();
}
// GET: Albums/Details/5
public ActionResult Details(string id)
{
int albumID = int.Parse(id);
AlbumModels alb = db.Albums.Include(a => a.Musics).Where(a => a.ID == albumID).First();
return(View(alb));
FullAlbum album = _spotify.GetAlbum(id);
AlbumModels v = new AlbumModels
{
Title = album.Name,
Genre = album.Genres,
ID_User = album.Artists,
Note = album.Popularity
};
return(View(v));
}
