/// <summary>
///
/// </summary>
/// <param name="subTreeNode"></param>
/// <returns>Returns whether the sub-tree has been fully expanded in the hierarchy.</returns>
public void GenerateSubTree(HierarchyNode subTreeNode)
{
ArtistGroup relatedArtistList = Client.GetRelatedArtists(subTreeNode.ArtistViewModel.Artist.ID);
//First determine which artists are new; add those.
List <Artist> newArtists = new List <Artist>();
int nodesAdded = 0;
foreach (Artist relatedArtist in relatedArtistList.Artists)
{
if (NodeDictionary.ContainsKey(relatedArtist.Name))
{
continue;
}
if (nodesAdded < MaxChildren)
{
newArtists.Add(relatedArtist);
ArtistViewModel artistViewModel = new ArtistViewModel(relatedArtist);
HierarchyNode relatedArtistNode = new HierarchyNode(artistViewModel, subTreeNode, subTreeNode.Level + 1);
subTreeNode.Children.Add(relatedArtistNode);
artistViewModel.SetHierarchyNode(relatedArtistNode);
NodeDictionary.Add(relatedArtist.Name, relatedArtistNode);
nodesAdded++;
}
else
{
return;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <returns>Returns whether the sub-tree has been fully expanded in the hierarchy.</returns>
public override void GenerateSubTree(IHierarchyNode node)
{
ArtistHierarchyNode subTreeNode = (ArtistHierarchyNode)node;
ArtistGroup relatedArtistList = Client.GetRelatedArtists(subTreeNode.ArtistViewModel.Artist.ID);
//First determine which artists are new; add those.
int nodesAdded = 0;
foreach (Artist relatedArtist in relatedArtistList.Artists)
{
if (NodeDictionary.ContainsKey(relatedArtist.Name))
{
continue;
}
if (nodesAdded < AddChildrenLimit)
{
ArtistViewModel artistViewModel = new ArtistViewModel(relatedArtist);
ArtistHierarchyNode relatedArtistNode = new ArtistHierarchyNode(artistViewModel, this, subTreeNode, subTreeNode.Level + 1);
subTreeNode.Children.Add(relatedArtistNode);
NodeDictionary.Add(relatedArtist.Name, relatedArtistNode);
nodesAdded++;
}
else
{
return;
}
}
}
private void GenerateTree(String artistName)
{
//Going to separate artists based on the genres used to describe them.
//Assume that the first artist is what we're pivoting on.
if (NodeDictionary.ContainsKey(artistName))
{
return;
}
ArtistList rootArtistList = Client.GetArtist(artistName);
//TODO: Using the first one for now. Since there could be multiple roots, we'll need to handle this.
Artist rootArtist = rootArtistList.Artists.Items[0];
ArtistViewModel rootViewModel = new ArtistViewModel(rootArtist);
HierarchyNode root = new HierarchyNode(rootViewModel, null, 0);
RootNodes.Add(root);
rootViewModel.SetHierarchyNode(root);
NodeDictionary.Add(rootArtist.Name, root);
ArtistGroup relatedArtistList = Client.GetRelatedArtists(rootArtist.ID);
//First determine which artists are new; add those.
List <Artist> newArtists = new List <Artist>();
int nodesAdded = 0;
foreach (Artist relatedArtist in relatedArtistList.Artists)
{
if (NodeDictionary.ContainsKey(relatedArtist.Name))
{
continue;
}
if (nodesAdded < MaxChildren)
{
newArtists.Add(relatedArtist);
ArtistViewModel artistViewModel = new ArtistViewModel(relatedArtist);
HierarchyNode relatedArtistNode = new HierarchyNode(artistViewModel, root, 1);
root.Children.Add(relatedArtistNode);
artistViewModel.SetHierarchyNode(relatedArtistNode);
NodeDictionary.Add(relatedArtist.Name, relatedArtistNode);
nodesAdded++;
}
else
{
break;
}
}
}
protected override async Task <CommandResult> HandleImpl(Command request)
{
ArtistGroup g = await Db.ArtistGroups
.Include(x => x.Members)
.SingleAsync(x => x.Name == request.Name);
Artist a = await Db.Artists
.SingleAsync(x => x.Name == request.ArtistName);
g.Members.Add(a);
return(CommandResult.Void);
}
protected override async Task <Model> HandleCore(Query request)
{
ArtistGroup g = await db.ArtistGroups
.Include(x => x.Members)
.SingleAsync(x => x.Name == request.Name);
return(new Model
{
Name = g.Name,
Artists = g.Members
.Select(x => x.Name)
.ToArray()
});
}
/// <summary>
/// Generates the tree from the root artist.
/// </summary>
/// <param name="artist"></param>
protected override void GenerateTree(object obj)
{
Artist artist = (Artist)obj;
if (NodeDictionary.ContainsKey(artist.Name))
{
return;
}
ArtistViewModel rootViewModel = new ArtistViewModel(artist);
ArtistHierarchyNode root = new ArtistHierarchyNode(rootViewModel, this, null, 0);
RootNodes.Add(root);
NodeDictionary.Add(artist.Name, root);
ArtistGroup relatedArtistList = Client.GetRelatedArtists(artist.ID);
//First determine which artists are new; add those.
List <Artist> newArtists = new List <Artist>();
int nodesAdded = 0;
foreach (Artist relatedArtist in relatedArtistList.Artists)
{
if (NodeDictionary.ContainsKey(relatedArtist.Name))
{
continue;
}
if (nodesAdded < AddChildrenLimit)
{
newArtists.Add(relatedArtist);
ArtistViewModel artistViewModel = new ArtistViewModel(relatedArtist);
ArtistHierarchyNode relatedArtistNode = new ArtistHierarchyNode(artistViewModel, this, root, 1);
root.Children.Add(relatedArtistNode);
NodeDictionary.Add(relatedArtist.Name, relatedArtistNode);
nodesAdded++;
}
else
{
break;
}
}
}
public bool IsSubTreeExpanded()
{
ArtistGroup relatedArtistList = SpotifyClientService.Client.GetRelatedArtists(ArtistViewModel.Artist.ID);
//First determine which artists are new; add those.
foreach (Artist relatedArtist in relatedArtistList.Artists)
{
if (Hierarchy.NodeExists(relatedArtist.Name))
{
continue;
}
if (Children.Where(node => ArtistViewModel.Artist == relatedArtist).Any())
{
return(false);
}
}
return(true);
}
public bool IsSubTreeExpanded(HierarchyNode subTreeNode)
{
ArtistGroup relatedArtistList = Client.GetRelatedArtists(subTreeNode.ArtistViewModel.Artist.ID);
//First determine which artists are new; add those.
foreach (Artist relatedArtist in relatedArtistList.Artists)
{
if (NodeDictionary.ContainsKey(relatedArtist.Name))
{
continue;
}
if (subTreeNode.Children.Where(node => node.ArtistViewModel.Artist == relatedArtist).Any())
{
return(false);
}
}
return(true);
}
public ArtistGroup GetRelatedArtists(String artistID)
{
try
{
String relatedArtistsURL = Endpoints.GetRelatedArtists(artistID);
WebRequest relatedArtistRequest = HttpWebRequest.Create(relatedArtistsURL);
WebResponse relatedArtistsURLArtistResponse = relatedArtistRequest.GetResponse();
using (StreamReader streamReader = new StreamReader(relatedArtistsURLArtistResponse.GetResponseStream()))
{
String relatedArtistJsonResponse = streamReader.ReadToEnd();
ArtistGroup relatedArtists = JsonConvert.DeserializeObject <ArtistGroup>(relatedArtistJsonResponse);
return(relatedArtists);
}
}
catch (WebException e)
{
Console.WriteLine(e.Message);
return(null);
}
}
protected override async Task <CommandResult> HandleImpl(Command request)
{
ArtistGroup newGroup = new ArtistGroup
{
Id = SequentualGuid.New(),
Name = request.Name
};
if (request.Members.Any())
{
foreach (string artistName in request.Members)
{
Artist theArtist = await Db
.Artists
.SingleAsync(x => x.Name.Equals(artistName));
newGroup.Members.Add(theArtist);
}
}
Db.ArtistGroups.Add(newGroup);
return(CommandResult.Void);
}
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);
}
