public override void Disable()
{
_spotify = null;
_trackId = null;
_contextId = null;
_albumArtUrl = null;
}
private async Task HandleArtirst(SpotifyClient client, DisplayCard displayCard, string itemId)
{
var artist = await GetArtist(client, itemId);
displayCard.ContextName = artist.Name;
displayCard.ContextImage = artist.Images.FirstOrDefault().Url;
}
protected async Task <List <string> > GetTopArtistIds(string accessToken)
{
Logger.LogInformation("Getting top artists...");
try
{
//Initialise the SpotifyClient with the access token provided by the user authenticating with Spotify
var api = new SpotifyClient(accessToken);
var topArtistIds = new List <string>();
var response = await api.Personalization.GetTopArtists(new PersonalizationTopRequest
{
TimeRangeParam = PersonalizationTopRequest.TimeRange.LongTerm,
Limit = SpotifyConsts.MaxLimitGetTopArtists
});
topArtistIds.AddRange(response.Items.Select(artistItem => artistItem.Id));
Logger.LogInformation("Returning {0} top artists.", topArtistIds.Count);
return(topArtistIds);
}
catch (Exception ex)
{
Logger.LogError(ex, "");
//Not an essential method, just return empty
return(new List <string>());
}
}
/// <summary>
/// Attempt to get the user's email address. If this fails for any reason, it's not critical - it just
/// means we have to validate the email address before sending any other emails
/// </summary>
public async Task <GetUserEmailOutput> GetUserEmail(GetUserEmailInput input)
{
Logger.LogInformation("Getting user email...");
try
{
//Initialise the SpotifyClient with the access token provided by the user authenticating with Spotify
var api = new SpotifyClient(input.AccessToken);
var response = await api.UserProfile.Current();
//Don't actually log their email address, for privacy/security reasons
Logger.LogInformation("Returning user email...");
return(new GetUserEmailOutput
{
EmailAddress = response.Email
});
}
catch (Exception ex)
{
Logger.LogError(ex, "");
return(new GetUserEmailOutput
{
ErrorMessage = ex.Message
});
}
}
public static async Task <SimplePlaylist> getPlayListById(string id)
{
var json = await File.ReadAllTextAsync(CredentialsPath);
var token = JsonConvert.DeserializeObject <PKCETokenResponse>(json);
var authenticator = new PKCEAuthenticator(clientId !, token);
authenticator.TokenRefreshed += (sender, token) => File.WriteAllText(CredentialsPath, JsonConvert.SerializeObject(token));
var config = SpotifyClientConfig.CreateDefault()
.WithAuthenticator(authenticator);
var spotify = new SpotifyClient(config);
var me = await spotify.UserProfile.Current();
var playlists = await spotify.PaginateAll(await spotify.Playlists.CurrentUsers().ConfigureAwait(false));
SimplePlaylist item = null;
foreach (SimplePlaylist list_item in playlists)
{
if (list_item.Id == id)
{
item = list_item;
break;
}
}
_server.Dispose();
return(item);
}
public static async Task setVolume(int volume)
{
if (Mute)
{
await Desmute();
}
var json = await File.ReadAllTextAsync(CredentialsPath);
var token = JsonConvert.DeserializeObject <PKCETokenResponse>(json);
var authenticator = new PKCEAuthenticator(clientId !, token);
authenticator.TokenRefreshed += (sender, token) => File.WriteAllText(CredentialsPath, JsonConvert.SerializeObject(token));
var config = SpotifyClientConfig.CreateDefault()
.WithAuthenticator(authenticator);
var spotify = new SpotifyClient(config);
var me = await spotify.UserProfile.Current();
// Debug.WriteLine($"Welcome {me.DisplayName} ({me.Id}), you're authenticated!");
int atualpercent = spotify.Player.GetCurrentPlayback().Result.Device.VolumePercent.GetValueOrDefault();
int result = atualpercent + volume;
PlayerVolumeRequest playvolumecontext = new PlayerVolumeRequest(result);
await spotify.Player.SetVolume(playvolumecontext);
_server.Dispose();
// Environment.Exit(0);
}
public AtlasHierarchy(SpotifyClient client, AtlasViewOptions viewOptions)
{
Client = client;
NodeDictionary = new Dictionary<String, IHierarchyNode>();
RootNodes = new List<IHierarchyNode>();
AddChildrenLimit = viewOptions.AddChildrenCount;
}
public static async Task Desmute()
{
var json = await File.ReadAllTextAsync(CredentialsPath);
var token = JsonConvert.DeserializeObject <PKCETokenResponse>(json);
var authenticator = new PKCEAuthenticator(clientId !, token);
authenticator.TokenRefreshed += (sender, token) => File.WriteAllText(CredentialsPath, JsonConvert.SerializeObject(token));
var config = SpotifyClientConfig.CreateDefault()
.WithAuthenticator(authenticator);
var spotify = new SpotifyClient(config);
var me = await spotify.UserProfile.Current();
// Debug.WriteLine($"Welcome {me.DisplayName} ({me.Id}), you're authenticated!");
PlayerVolumeRequest playvolumecontext = new PlayerVolumeRequest(volumeBefore);
await spotify.Player.SetVolume(playvolumecontext);
Mute = false;
_server.Dispose();
}
public async Task <UserInformation> FinishLogIn(SpotifyCode spotifyCode)
{
var response = await new OAuthClient()
.RequestToken(new AuthorizationCodeTokenRequest(_spotifyService.ClientID, _spotifyService.ClientSecret, spotifyCode.Code, _spotifyService.RedirectUri));
var spotify = new SpotifyClient(response.AccessToken);
var user = await spotify.UserProfile.Current();
var userInformation = new UserInformation(user.DisplayName, user.Id, response.AccessToken);
// save refresh token to DB
try
{
var token = await _context.RefreshTokens.FirstOrDefaultAsync(t => t.UserID == user.Id);
if (token != null)
{
token.Token = response.RefreshToken;
}
else
{
var refreshToken = new RefreshToken(user.Id, response.RefreshToken);
await _context.RefreshTokens.AddAsync(refreshToken);
}
await _context.SaveChangesAsync();
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
}
return(userInformation);
}
public async Task Login(string code)
{
var(accessToken, refreshToken) = await SpotifyClient.GetTokensAsync(ClientId, ClientSecret, RedirectUrl, code).ConfigureAwait(false);
AccessToken = accessToken;
RefreshToken = refreshToken;
}
private async Task RefreshTokenAsync(string refreshToken)
{
try
{
// await File.WriteAllTextAsync("code.txt", code);
var response = await new OAuthClient().RequestToken(
new AuthorizationCodeRefreshRequest(spotifyConfig.ClientId, spotifyConfig.ClientSecret, refreshToken)
);
var config = SpotifyClientConfig
.CreateDefault()
.WithAuthenticator(new AuthorizationCodeAuthenticator(spotifyConfig.ClientId,
spotifyConfig.ClientSecret, new AuthorizationCodeTokenResponse()
{
AccessToken = response.AccessToken,
ExpiresIn = response.ExpiresIn,
RefreshToken = refreshToken,
CreatedAt = response.CreatedAt,
Scope = response.Scope,
TokenType = response.TokenType
}));
spotifyClient = new SpotifyClient(config);
IsAuthed = true;
}
catch (Exception ex)
{
// TODO: figure out what might lead here
return;
}
}
static async Task Main(string[] args)
{
try
{
var token = await SpotifyClient.GetAccessToken(CLIENT_ID, CLIENT_SECRET);
try
{
var client = new SpotifyClient(token);
var searchResponse = await client.Search("Coheed & Cambria", new string[] { "track" });
foreach (var track in searchResponse.Tracks.Items)
{
Console.WriteLine(track.Name);
}
}
catch (HttpRequestException e)
{
Console.WriteLine($"Error while executing API request: {e.Message}");
}
}
catch (HttpRequestException e)
{
Console.WriteLine($"Error while authenticating: {e.Message}");
}
catch (Exception e)
{
Console.WriteLine($"Uncaught error: {e}");
}
Console.WriteLine("\nPress any key to exit.");
Console.ReadKey();
}
public async Task <bool> SwapCodeForTokenAsync(string code)
{
try
{
// await File.WriteAllTextAsync("code.txt", code);
var response = await new OAuthClient().RequestToken(
new AuthorizationCodeTokenRequest(spotifyConfig.ClientId, spotifyConfig.ClientSecret, code,
new Uri("https://localhost:5001/callback"))
);
await File.WriteAllTextAsync("refresh.txt", response.RefreshToken);
var config = SpotifyClientConfig
.CreateDefault()
.WithAuthenticator(new AuthorizationCodeAuthenticator(spotifyConfig.ClientId,
spotifyConfig.ClientSecret, response));
spotifyClient = new SpotifyClient(config);
IsAuthed = true;
return(true);
}
catch (Exception ex)
{
// TODO: figure out what might lead here
return(false);
}
}
/// <summary>
/// Checks if user is authenticated
/// </summary>
/// <returns>
/// Null if failed, Profile if successful
/// </returns>
public static async Task <PrivateUser> IsAuthenticated()
{
//check if file with token exists, if it does not exist, login will be shown
if (!File.Exists(CredentialsPath))
{
return(null);
}
var json = await File.ReadAllTextAsync(CredentialsPath);
var token = JsonConvert.DeserializeObject <AuthorizationCodeTokenResponse>(json);
CheckCliendSecretId();
if (string.IsNullOrEmpty(clientId) || string.IsNullOrEmpty(clientSecret))
{
return(null);
}
var authenticator = new AuthorizationCodeAuthenticator(clientId, clientSecret, token);
authenticator.TokenRefreshed += (sender, tokenx) => File.WriteAllText(CredentialsPath, JsonConvert.SerializeObject(tokenx));
//might throw an error if user revoked access to their spotify account
var config = SpotifyClientConfig.CreateDefault()
.WithAuthenticator(authenticator);
SpotifyClient = new SpotifyClient(config);
//try and get user profile
return(await SpotifyClient.UserProfile.Current());
}
private async Task HandleAlbum(SpotifyClient client, DisplayCard displayCard, string itemId)
{
var album = await GetAlbum(client, itemId);
displayCard.ContextName = album.Name;
displayCard.ContextImage = album.Images.FirstOrDefault().Url;
}
private async Task LoginToSpotify(TaskCompletionSource <bool> tcs)
{
Server = new EmbedIOAuthServer(new Uri("http://localhost:5000/callback"), 5000);
await Server.Start();
Server.ImplictGrantReceived += async(object sender, ImplictGrantResponse response) =>
{
await Server.Stop();
if (response.AccessToken != null)
{
Spotify = new SpotifyClient(response.AccessToken);
Profile = await Spotify.UserProfile.Current();
tcs.SetResult(Spotify != null);
}
else
{
Log("Error when attempting to log in");
tcs.SetResult(false);
}
};
var request = new LoginRequest(Server.BaseUri, SpotifySecrets.CLIENT_ID, LoginRequest.ResponseType.Token)
{
Scope = new List <string>
{
Scopes.UserLibraryRead,
Scopes.PlaylistModifyPublic
}
};
BrowserUtil.Open(request.ToUri());
}
public override async Task <SkillResponse> HandleIntent(SkillRequest skillRequest, IntentRequest intentRequest,
ILambdaContext context)
{
await SpotifyClient.SkipPlaybackToNextAsync();
return(ReturnEmptySkillResponse());
}
private void Start()
{
Log.Instance.PrintMessage("Trying to connect to Spotify...", MessageType.Info, "Spotify.Start()");
User = null;
Stopwatch crono = Stopwatch.StartNew();
Kernel.InternetAvaliable(false);
try
{
SpotifyConfig = SpotifyClientConfig.CreateDefault().WithAuthenticator(new ClientCredentialsAuthenticator(PublicKey, PrivateKey));
SpotifyClient = new SpotifyClient(SpotifyConfig);
crono.Stop();
if (SpotifyConfig is not null) //??
{
Kernel.InternetAvaliable(true);
Log.Instance.PrintMessage("Connected!", MessageType.Correct, crono, TimeType.Milliseconds);
}
else //yo creoque esto nunca se ejecuta...
{
Kernel.InternetAvaliable(false);
Log.Instance.PrintMessage("Token is null", MessageType.Error, crono, TimeType.Milliseconds);
}
}
catch (APIException ex)
{
Kernel.InternetAvaliable(false);
Log.Instance.PrintMessage(ex.Message, MessageType.Error);
MessageBox.Show(Kernel.LocalTexts.GetString("error_internet"));
}
}
public static async Task Run(
//[TimerTrigger("0 * * * * *")] TimerInfo timer,
[TimerTrigger("0 0 0 1 * *")] TimerInfo timer,
[Table("chainLinks", Connection = "AzureWebJobsStorage")] CloudTable chainLinksCloudTable,
ILogger log)
{
log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
log.LogInformation("Getting chain links...");
var lastMonthsChainLinks = (await new ChainLinkRepository(chainLinksCloudTable)
.GetAll())
.GetLastMonthsChainLinks(DateTime.Today);
log.LogInformation($"Got chain links {lastMonthsChainLinks.Min(l => l.Position)} to {lastMonthsChainLinks.Max(l => l.Position)}.");
var client = new SpotifyClient(
new SpotifyConfiguration(
GetEnvironmentVariable("SpotifyClientId"),
GetEnvironmentVariable("SpotifyClientSecret"),
GetEnvironmentVariable("SpotifyRefreshToken")),
log);
await client.RefreshPlaylist(lastMonthsChainLinks,
new SpotifyPlaylist(
new Uri(GetEnvironmentVariable("SpotifyPlaylistUri")),
"The Chain Monthly", true, false,
$"{DateTime.Today.AddMonths(-1):MMMM} in The Chain, BBC Radio 6's listener-generated playlist of thematically linked songs. Check https://www.thechain.uk/ for more."
));
}
protected override void OnSpotifyConnectionChanged(SpotifyClient client)
{
base.OnSpotifyConnectionChanged(client);
_client = client;
// Start internal update loop
if (_client != null && UpdateFrequencyMS > 0)
{
if (SpotifyService.Instance.AreScopesAuthorized(Scopes.UserReadPlaybackState))
{
InvokeRepeating(nameof(FetchLatestPlayer), 0, UpdateFrequencyMS / 1000);
_isInvoking = true;
}
else
{
Debug.LogError($"Not authorized to access '{Scopes.UserReadPlaybackState}'");
}
}
else if (_client == null && _isInvoking)
{
CancelInvoke(nameof(FetchLatestPlayer));
_isInvoking = false;
// Invoke playing item changed, no more client, no more context
OnPlayingItemChanged?.Invoke(null);
}
}
//public Album()
// {
// tracks = new List<Track>();
// }
public void GetTracks(SpotifyClient client)
{
var responseA = client.Albums.GetTracks(id).Result;
var trackIds = client.Albums.GetTracks(id).Result.Items.Select(t => t.Id).ToList();
for (int i = 0; i < trackIds.Count; i += (trackIds.Count - i) >= 50 ? 50 : (trackIds.Count - i))
{
var request = new TracksRequest(trackIds.GetRange(i, ((trackIds.Count - i) >= 50 ? 50 : (trackIds.Count - i))));
var response = client.Tracks.GetSeveral(request).Result.Tracks;
response.ForEach(t =>
{
var track = new Track()
{
duration_ms = t.DurationMs,
isexplicit = t.Explicit,
name = t.Name,
popularity = t.Popularity,
preview_url = t.PreviewUrl,
track_number = t.TrackNumber,
type = t.Type.ToString(),
uri = t.Uri,
spotify_url = t.ExternalUrls.Values.FirstOrDefault(),
id = t.Id,
disc_number = t.DiscNumber
};
tracks.Add(track);
});
}
;
}
public async Task <FullPlaylist> CreatePlaylistFromArtists(
IEnumerable <string> artistNames, string playlistName, string accessToken)
{
var spotifyClient = new SpotifyClient(accessToken);
var tracks = new List <FullTrack>();
foreach (var artistName in artistNames)
{
var searchResponse = await spotifyClient.Search.Item(new SearchRequest(SearchRequest.Types.Track, $"artist:{artistName}"));
tracks.AddRange(searchResponse.Tracks.Items !.Take(10));
}
var currentUser = await spotifyClient.UserProfile.Current();
var playlist = await spotifyClient.Playlists.Create(currentUser.Id, new PlaylistCreateRequest(playlistName));
foreach (var tracksChunk in tracks.Shuffle().Chunk(100))
{
await spotifyClient.Playlists.AddItems(playlist.Id !,
new PlaylistAddItemsRequest(tracksChunk.Select(x => x.Uri).ToList()));
}
return(playlist);
}
private async Task <string?> GetSpotifyTrack(string link)
{
var spotifyConfig = SpotifyClientConfig
.CreateDefault()
.WithAuthenticator(
new ClientCredentialsAuthenticator(config["SpotifyId"], config["SpotifySecret"]));
var spotify = new SpotifyClient(spotifyConfig);
var id = link.Split("/").LastOrDefault();
var idWithoutQueryString = id?.Split("?").FirstOrDefault();
if (idWithoutQueryString != null)
{
id = idWithoutQueryString;
}
var track = await spotify.Tracks.Get(id ?? "");
string?result = null;
if (track != null)
{
result = "";
foreach (var artist in track.Artists)
{
result += artist.Name + " ";
}
result += " " + track.Name;
}
return(result);
}
public static async Task PlayPlaylist(SimplePlaylist playlist)
{
var json = await File.ReadAllTextAsync(CredentialsPath);
var token = JsonConvert.DeserializeObject <PKCETokenResponse>(json);
var authenticator = new PKCEAuthenticator(clientId !, token);
authenticator.TokenRefreshed += (sender, token) => File.WriteAllText(CredentialsPath, JsonConvert.SerializeObject(token));
var config = SpotifyClientConfig.CreateDefault()
.WithAuthenticator(authenticator);
var spotify = new SpotifyClient(config);
var me = await spotify.UserProfile.Current();
PlayerResumePlaybackRequest teste = new PlayerResumePlaybackRequest();
teste.ContextUri = playlist.Uri;
await spotify.Player.ResumePlayback(teste);
_server.Dispose();
// Environment.Exit(0);
}
public override async Task <SkillResponse> HandleIntent(SkillRequest skillRequest, IntentRequest intentRequest,
ILambdaContext context)
{
var profile = await SpotifyClient.GetPrivateProfileAsync();
if (profile.HasError())
{
return(TellWithoutEnding("There was an error getting your profile"));
}
var playlists = await SpotifyClient.GetUserPlaylistsAsync(profile.Id);
if (playlists.HasError())
{
return(TellWithoutEnding("There was an error getting your playlists"));
}
var playlistName = intentRequest.GetSlotValue("PlaylistName");
var list = (from playlist in playlists.Items
let score = new SmithWatermanGotoh().GetSimilarity(playlist.Name.ToLower(), playlistName.ToLower())
select new MostMatchingPlaylist(playlist, score)).ToList();
var mostMatching = list.MaxBy(x => x.Score).FirstOrDefault();
if (mostMatching == null)
{
return(TellWithoutEnding("Sorry. Couldn't find the requested playlist"));
}
var speech = $"Found {mostMatching.Playlist.Name}, is this the correct one?";
skillRequest.Session.SetSessionValue("PlaylistUri", mostMatching.Playlist.Uri);
return(ResponseBuilder.Ask(speech, new Reprompt(speech), skillRequest.Session));
}
public static async Task <System.Collections.Generic.IList <SpotifyAPI.Web.SimplePlaylist> > getAllPlayerList()
{
var json = await File.ReadAllTextAsync(CredentialsPath);
var token = JsonConvert.DeserializeObject <PKCETokenResponse>(json);
var authenticator = new PKCEAuthenticator(clientId !, token);
authenticator.TokenRefreshed += (sender, token) => File.WriteAllText(CredentialsPath, JsonConvert.SerializeObject(token));
var config = SpotifyClientConfig.CreateDefault()
.WithAuthenticator(authenticator);
var spotify = new SpotifyClient(config);
var me = await spotify.UserProfile.Current();
var playlists = await spotify.PaginateAll(await spotify.Playlists.CurrentUsers().ConfigureAwait(false));
_server.Dispose();
return(playlists);
// Environment.Exit(0);
}
public async void SetPlaylist(SimplePlaylist playlist)
{
_playlist = playlist;
// Add loading spinner on main thread
if (_loadSpinnerPrefab != null)
{
_dispatcher.Add(() =>
{
_instLoadSpinner = Instantiate(_loadSpinnerPrefab, _tracksListParent);
});
}
SpotifyClient client = SpotifyService.Instance.GetSpotifyClient();
// Get full details of simple playlist
_fullPlaylist = await client.Playlists.Get(_playlist.Id);
// Get all tracks inside full playlist
_allTracks = await GetAllTracks(client);
// Require ui update on main thread
_dispatcher.Add(() =>
{
UpdateUI();
if (_instLoadSpinner != null)
{
Destroy(_instLoadSpinner);
}
});
}
public override async Task <SkillResponse> HandleIntent(SkillRequest skillRequest, IntentRequest intentRequest,
ILambdaContext context)
{
await SpotifyClient.ResumePlaybackAsync(offset : "");
return(ReturnEmptySkillResponse());
}
private static async Task Start()
{
var json = await File.ReadAllTextAsync(CredentialsPath);
var token = JsonConvert.DeserializeObject <PKCETokenResponse>(json);
var authenticator = new PKCEAuthenticator(clientId !, token);
authenticator.TokenRefreshed += (sender, token) => File.WriteAllText(CredentialsPath, JsonConvert.SerializeObject(token));
var config = SpotifyClientConfig.CreateDefault()
.WithAuthenticator(authenticator);
var spotify = new SpotifyClient(config);
var me = await spotify.UserProfile.Current();
Console.WriteLine($"Welcome {me.DisplayName} ({me.Id}), you're authenticated!");
var playlists = await spotify.PaginateAll(await spotify.Playlists.CurrentUsers().ConfigureAwait(false));
Console.WriteLine($"Total Playlists in your Account: {playlists.Count}");
_server.Dispose();
Environment.Exit(0);
}
public async Task <ActionResult> PauseCurrentTrack()
{
try
{
var tokenGiven = _cookiesManager.GetCookie("TokenGiven", Request);
var tokenTimes = _cookiesManager.GetCookie("TokenTime", Request);
if (tokenGiven != null && tokenTimes != null)
{
if (ApiClientConfig.IsIfTokenExpired(Convert.ToDateTime(tokenTimes.Value), tokenGiven.Value))
{
return(RedirectToAction("LoginUser"));
}
}
else
{
return(RedirectToAction("LoginUser"));
}
client = ApiClientConfig.GetClientInstance(tokenGiven.Value);
var tryPauseTrack = await _playerRepo.PauseCurrentPlayBack(client);
var modelValues = await GetPrivateUserDefaultModel(client);
_model = modelValues;
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
return(View(ERROR_MESSAGE_PATH)); throw;
}
}
public SpotifyClientService()
{
var config = SpotifyClientConfig.CreateDefault()
.WithAuthenticator(new ClientCredentialsAuthenticator(SPOTIFY_CLIENT_ID, SPOTIFY_CLIENT_SECRET));
_spotify = new SpotifyClient(config);
}
public ArtistAtlasHierarchy(SpotifyClient client, IEnumerable<Artist> artists, AtlasViewOptions viewOptions)
: base(client, viewOptions) {
foreach (Artist artist in artists)
{
GenerateTree(artist);
}
}
public Artist Recommend(SpotifyClient client, Playlist playlist)
{
//Find a common ancestor for a portion of the artists in the playlist.
IEnumerable<Track> playlistEntries = playlist.Tracks.Select(track => track.Track);
Dictionary<string, ArtistGroup> cachedRelatedArtists = new Dictionary<string, ArtistGroup>();
Dictionary<string, RecommendationCriteria> relatedArtistMap = new Dictionary<string, RecommendationCriteria>();
playlistEntries.ToList().ForEach(track =>
{
ArtistGroup relatedArtists = null;
if (!cachedRelatedArtists.ContainsKey(track.Artists.First().ID))
{
relatedArtists = client.GetRelatedArtists(track.Artists.First().ID); //Handle only the first artist for now...
cachedRelatedArtists.Add(track.Artists.First().ID, relatedArtists);
}
else
{
relatedArtists = cachedRelatedArtists[track.Artists.First().ID];
}
relatedArtists.Artists.ForEach(relatedArtist =>
{
if (!relatedArtistMap.ContainsKey(relatedArtist.ID))
{
RecommendationCriteria recommendationCriteria = new RecommendationCriteria();
relatedArtistMap.Add(relatedArtist.ID, recommendationCriteria);
recommendationCriteria.TargetedArtist = relatedArtist;
}
if (!relatedArtistMap[relatedArtist.ID].RelatedArtists.Where(artist => artist.ID == track.Artists.First().ID).Any())
relatedArtistMap[relatedArtist.ID].RelatedArtists.Add(track.Artists.First());
relatedArtistMap[relatedArtist.ID].Weight++;
});
});
//Other ideas:
//Recommend by the playlist contents.
// Evaluate whether the playlist is a collection of like-artists or individual songs of a particular type (e.g. energetic, fast?)
//Recommend by the artist selected.
//
//Recommend something completely new.
//Recommend a set of brand-new songs.
// Analyze all changelists to get an idea of what a person likes in particular.
// Easily solution is to find artists that they don't have that are similar.
// Could also randomly find songs from various areas:
// The current Top 10-40 on the charts.
// The list of a band that is playing near you live.
// Find a whole smattering of a different genre (trip hop, hip hop, grunge alternative).
//Recommend by a specific song.
// Find songs that were popular at the same time (may not need to be part of the same genre).
IOrderedEnumerable<KeyValuePair<string, RecommendationCriteria>> orderedDictionary = relatedArtistMap.OrderByDescending(keyValuePair => keyValuePair.Value.Weight)
.ThenByDescending(keyValuePair => keyValuePair.Value.RelatedArtists.Count());
KeyValuePair<string, RecommendationCriteria> recommendedEntry = orderedDictionary.First();
return recommendedEntry.Value.TargetedArtist;
}
public void SpotifyClient_GetPlaylists()
{
SpotifyClient client = new SpotifyClient(creds);
SpotifyPlaylistsResponse response = null;
if(client.Connected)
response = client.GET<SpotifyPlaylistsResponse>(new SpotifyPlaylistsRequest());
Assert.AreNotEqual(null, response);
}
public PlaylistViewModel()
{
_playlist = null;
_client = SpotifyClientService.Client;
_showTutorialInfo = true;
_playlists = _client.GetPlaylists(SpotifyClientService.User.Id);
_displayPlaylists = _playlists.Playlists;
_displayPlaylists.Insert(0, new Playlist("New Playlist"));
}
public AtlasHierarchy(SpotifyClient client, IEnumerable<String> artistNames)
{
Client = client;
NodeDictionary = new Dictionary<String, HierarchyNode>();
RootNodes = new List<HierarchyNode>();
MaxChildren = 1;
foreach (String artistName in artistNames)
{
GenerateTree(artistName);
}
}
public void SpotifyClient_GetTracksForPlaylist()
{
SpotifyClient client = new SpotifyClient(creds);
SpotifyPlaylist playlist = null;
SpotifyPlaylistTracksRequest tracksRequest = null;
SpotifyPlaylistTracksResponse tracksResponse = null;
if (client.Connected)
{
playlist = client.GET<SpotifyPlaylistsResponse>(new SpotifyPlaylistsRequest()).Items.FirstOrDefault();
tracksRequest = new SpotifyPlaylistTracksRequest()
{
Playlist_ID = playlist.ID
};
tracksResponse = client.GET<SpotifyPlaylistTracksResponse>(tracksRequest);
Console.WriteLine("test");
}
}
static int Main(string[] args)
{
ClientInterface cli;
string searchQuery;
SpotifyClient.RequestType rt;
if (args.Length < 2)
{
return 0;
}
MyOptions options = new MyOptions(args);
searchQuery = options.getParameter(Params.QUERY);
if (options.getParameter(Params.CLIENT).Equals("spotify"))
{
rt = options.getParameter(Params.TRACK_OR_ARTIST).Equals("artist") ? SpotifyClient.RequestType.Artist : SpotifyClient.RequestType.Track;
cli = new SpotifyClient(rt, searchQuery, 300);
}
else if (options.getParameter(Params.CLIENT).Equals("soundcloud"))
{
cli = new SoundCloudClient(searchQuery);
}
else
{
return 1;
}
if (cli.Search())
{
cli.GetImages();
cli.DownloadImage();
}
return 0;
}
static SpotifyClientService()
{
Client = new SpotifyClient();
Country = "US"; //TODO: Determine the user's current market.
}
public SpotiFireService(IMapEngine mapEngine, IPlaylistHolder playlistHolder)
{
_mapEngine = mapEngine;
_spotiFire = new SpotifyClient();
_playlistHolder = playlistHolder;
}
public NewReleaseAtlasHierarchy(SpotifyClient client, IEnumerable<NewReleaseItem> newReleases, AtlasViewOptions viewOptions)
: base(client, viewOptions) {
foreach (NewReleaseItem newReleaseItem in newReleases) {
GenerateTree(newReleaseItem);
}
}
public void SpotifyClient_Connect()
{
SpotifyClient client = new SpotifyClient(creds);
Assert.AreEqual(true, client.Connected);
}
