public void SaveUser(PrivateProfile user)
{
var dProfile = new dPrivateProfile
{
Id = user.Id,
Birthdate = user.Birthdate,
Country = user.Country,
DisplayName = user.DisplayName,
Email = user.Email,
product = user.Product,
Type = user.Type
};
//lets send the user to the database
using (var db = new AiApiDbContext())
{
// if we don't find the user in the data base
if (db.PrivateProfiles.Find(dProfile.Id) == null)
{
db.PrivateProfiles.Add(dProfile);
}
db.SaveChanges();
}
}
/// <summary>
/// Removes the saved tracks from the database
/// </summary>
public async void RemoveSavedTracks(string userId)
{
try
{
//launch up a new Db context
using (var db = new AiApiDbContext())
{
//removes all the records
var tracksToRemove = db.SavedTracks.Where(x => x.UserName == userId).ToList();
db.SavedTracks.RemoveRange(tracksToRemove);
await db.SaveChangesAsync();
}
}
catch (Exception ex)
{
Console.WriteLine("=====================");
Console.WriteLine(ex.Message);
Console.WriteLine(ex.InnerException);
Console.WriteLine(ex.StackTrace);
Console.WriteLine("=====================");
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public async Task <List <object> > Get()
{
//all of this code up here may not be neccessary
//I need a way to speed up the application.
var list = new List <object>();
using (var db = new AiApiDbContext())
{
var tracks = db.RecentlyPlayed.ToList();
list.AddRange(tracks);
}
Thread kickThread = null;
kickThread = new Thread(async() =>
{
await KickoffSpotifySync();
AiThreadManager.RemoveThread(kickThread);
});
AiThreadManager.AddThread(kickThread);
if (list.Any())
{
return(list);
}
return(new List <object>());
}
/// <summary>
/// Deletes and rewrites the Top Artists and Top Tracks from spotify. Asynchnonously while also launching up two new threads.
/// </summary>
/// <param name="user">The user to get this information for.</param>
public void SyncTopList(PrivateProfile user)
{
Thread artistThread = null;
Thread trackThread = null;
try
{
//the new thread for the artists objects
artistThread = new Thread(async() =>
{
await GetUsersTopArtistsShortTerm(user.Id);
await GetUsersTopArtistsMeduimTerm(user.Id);
await GetUsersTopArtistsLongTerm(user.Id);
AiThreadManager.RemoveThread(artistThread);
});
AiThreadManager.AddThread(artistThread);
//the new thread for the track objects
trackThread = new Thread(async() =>
{
await GetUsersTopTracksShortTerm(user.Id);
await GetUsersTopTracksMeduimTerm(user.Id);
await GetUsersTopTracksLongTerm(user.Id);
AiThreadManager.RemoveThread(trackThread);
});
AiThreadManager.AddThread(trackThread);
}
catch (Exception ex)
{
Console.WriteLine(ex.InnerException);
}
finally
{
using (var db = new AiApiDbContext())
{
db.TopSyncDates.Add(new sTopSync()
{
UserId = user.Id,
SyncTop = SpotifyTopOptions.Artists
});
db.TopSyncDates.Add(new sTopSync()
{
UserId = user.Id,
SyncTop = SpotifyTopOptions.Tracks
});
db.SaveChangesAsync();
}
}
}
/// <summary>
/// Returns the current logged in users top tracks from the last 4 weeks.
/// </summary>
/// <returns></returns>
public async Task <List <FullArtist> > GetUsersTopArtistsShortTerm(string userId)
{
_shortTermArtists.Clear();
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", AccessToken);
HttpResponseMessage responseMessage = await client.GetAsync("https://api.spotify.com/v1/me/top/artists?time_range=short_term");
if (responseMessage.IsSuccessStatusCode)
{
var responseContent = await responseMessage.Content.ReadAsStringAsync();
var data = JsonConvert.DeserializeObject <Paging <FullArtist> >(responseContent);
_shortTermArtists.AddRange(data.Items);
try
{
using (var db = new AiApiDbContext())
{
var rank = 1;
_shortTermArtists.ForEach(x =>
{
var artist = new dTopArtist
{
Name = x.Name,
Popularity = x.Popularity,
Term = Term.Short,
UserId = userId,
Uri = x.Uri,
Rank = rank++
};
if (!db.TopArtists.Any(a => a.Name == artist.Name && a.Term == artist.Term && a.UserId == userId))
{
db.TopArtists.Add(artist);
}
});
await db.SaveChangesAsync();
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
}
return(_shortTermArtists);
}
public async Task <List <dArtist> > Get()
{
//var caller = new Spotify.SpotifyWebApi();
using (var db = new AiApiDbContext())
{
var artistList = db.Artist.Where(x => x.Popularity > 90).Take(5).ToList();
return(artistList);
}
return(new List <dArtist>());
}
/// <summary>
/// Returns the current logged in users top tracks from the last 6 months.
/// </summary>
/// <returns></returns>
public async Task <List <FullTrack> > GetUsersTopTracksMeduimTerm(string userId)
{
var medTermTracks = new List <FullTrack>();
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", AccessToken);
HttpResponseMessage responseMessage = await client.GetAsync("https://api.spotify.com/v1/me/top/tracks?time_range=medium_term");
if (responseMessage.IsSuccessStatusCode)
{
var responseContent = await responseMessage.Content.ReadAsStringAsync();
var data = JsonConvert.DeserializeObject <Paging <FullTrack> >(responseContent);
_usersTopTracks.AddRange(data.Items);
using (var db = new AiApiDbContext())
{
var index = 1;
medTermTracks.ForEach(x =>
{
//lets try to add the fulltrack (spotify verson) of the track to the database
dFullTrack.AddFullTrackToDb(x);
var newTrack = new dTopTrack
{
Name = x.Name,
FullTrackId = x.Id,
Popularity = x.Popularity,
Uri = x.Uri,
Term = Term.Medium,
Rank = index++,
UserName = userId
};
db.TopTracks.Add(newTrack);
});
await db.SaveChangesAsync();
}
}
}
return(medTermTracks);
}
public async void GetRecentlyPlayedArtist()
{
var recentTracks = new List <PlayHistory>();
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", AccessToken);
HttpResponseMessage responseMessage = await client.GetAsync("https://api.spotify.com/v1/me/player/recently-played?limit=50");
if (responseMessage.IsSuccessStatusCode)
{
var responseContent = await responseMessage.Content.ReadAsStringAsync();
var data = JsonConvert.DeserializeObject <CursorPaging <PlayHistory> >(responseContent);
recentTracks.AddRange(data.Items);
}
using (var db = new AiApiDbContext())
{
var index = 0;
recentTracks.ForEach(x =>
{
var dPlayHistory = new dPlayHistory();
dPlayHistory.TrackId = x.Track.Id;
dPlayHistory.PlayedAt = x.PlayedAt;
dPlayHistory.Id = index;
var existingTrack = db.Songs.Find(dPlayHistory.TrackId);
//if (existingTrack != null)
//{
// db.Songs.Add()
//}
db.RecentlyPlayed.Add(dPlayHistory);
index++;
});
}
}
}
/// <summary>
/// Kicks off the spotify sync methods. The will run in the background while we fetch the users data.
/// </summary>
internal async Task <bool> KickoffSpotifySync()
{
var SController = new Spotify.SpotifyWebApi();
var trackedSynced = true;
//let's make sure we have a acces token because if not we cannot make any calls
if (SController.AccessToken != null)
{
//get the current user
var user = SController.GetCurrentUser();
if (user != null)
{
//get and save the currently playing track.
await SController.GetCurrentlyPlayingTrack(user.Id);
DateTime date;
using (var db = new AiApiDbContext())
{
//when was the last time we synched
date = db.GetLastSyncDate(user.Id);
//this call attemps to save the user
//if the user is already in the database it wont save them again.
SController.SaveUser(user);
var syncNeeded = DateTime.Compare(date, DateTime.Today);
if (!string.IsNullOrWhiteSpace(user.Id) && syncNeeded < 0)
{
//await SController.ResyncSavedTracks(user.Id);
}
//caller.GetRecentlyPlayedArtist();
//this determines if we should sync up the users top tracks and artists
//SController.SyncTopList(user);
}
}
return(true);
}
return(false);
}
/// <summary>
/// Gets all the saved tracks from the database
/// </summary>
public List <dSavedTrack> GetSavedTrackFromDb(string userId, int retRec)
{
try
{
//launch up a new Db context
using (var db = new AiApiDbContext())
{
var returnedRecords = db.SavedTracks.Where(x => x.UserName == userId).Take(retRec).ToList();
//removes all the records
return(returnedRecords);
}
}
catch (Exception ex)
{
Console.WriteLine("=====================");
Console.WriteLine(ex.Message);
Console.WriteLine(ex.InnerException);
Console.WriteLine(ex.StackTrace);
Console.WriteLine("=====================");
}
return(new List <dSavedTrack>());
}
//public void BuildArtistList()
//{
// var artistList = new HashSet<string>();
// if (artistList.Count < 50)
// {
// track.Track.Artists.ForEach(x =>
// {
// artistList.Add(x.Id);
// });
// }
// else
// {
// await GetArtistFromSpotify(artistList);
// artistList.Clear();
// continue; ;
// }
//}
/// <summary>
/// Gets all the saved tracks from the database
/// </summary>
public async Task <List <dSavedTrack> > GetAllSavedTracksFromDb()
{
try
{
//launch up a new Db context
using (var db = new AiApiDbContext())
{
var returnedRecords = db.SavedTracks.ToListAsync();
//removes all the records
return(await returnedRecords);
}
}
catch (Exception ex)
{
Console.WriteLine("=====================");
Console.WriteLine(ex.Message);
Console.WriteLine(ex.InnerException);
Console.WriteLine(ex.StackTrace);
Console.WriteLine("=====================");
}
return(new List <dSavedTrack>());
}
/// <summary>
/// Gets artist from spotify and then saved them out to the database
/// </summary>
/// <param name="nextUrl"></param>
/// <returns></returns>
public async Task <bool> GetArtistFromSpotify(List <string> ids)
{
_artist.Clear();
try
{
using (var db = new AiApiDbContext())
{
if (ids.Count > 50)
{
ids.RemoveAt(ids.Count - 1);
}
var empString = "";
foreach (var id in ids)
{
if (string.IsNullOrWhiteSpace(empString))
{
empString += $"{id}";
}
else
{
empString += $",{id}";
}
}
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", AccessToken);
HttpResponseMessage responseMessage = await client.GetAsync("https://api.spotify.com/v1/artists?ids=" + empString);
if (responseMessage.IsSuccessStatusCode)
{
var responseContent = await responseMessage.Content.ReadAsStringAsync();
var data = JsonConvert.DeserializeObject <SeveralArtists>(responseContent);
data.Artists.ForEach(_artist.Add);
}
}
foreach (var a in _artist)
{
var dArtist = new dArtist()
{
Id = a.Id,
Popularity = a.Popularity,
Name = a.Name,
Uri = a.Uri,
Type = a.Type
};
foreach (var genreString in a.Genres)
{
if (string.IsNullOrWhiteSpace(dArtist.Genre1))
{
dArtist.Genre1 = genreString;
continue;
}
if (string.IsNullOrWhiteSpace(dArtist.Genre2))
{
dArtist.Genre2 = genreString;
continue;
}
if (string.IsNullOrWhiteSpace(dArtist.Genre3))
{
dArtist.Genre3 = genreString;
continue;
}
if (string.IsNullOrWhiteSpace(dArtist.Genre4))
{
dArtist.Genre4 = genreString;
continue;
}
if (string.IsNullOrWhiteSpace(dArtist.Genre5))
{
dArtist.Genre5 = genreString;
break;
}
}
var t = db.Artist.Where(x => x.Id == dArtist.Id).ToList();
if (!db.Artist.Where(x => x.Id == dArtist.Id).ToList().Any())
{
db.Artist.Add(dArtist);
}
}
await db.SaveChangesAsync();
_artist.Clear();
return(true);
}
}
catch (Exception ex)
{
Console.Write(ex);
return(false);
}
}
/// <summary>
/// Resyncs the current user's synced tracks
/// </summary>
public async Task <bool> ResyncSavedTracks(string userName)
{
//get's all the tracks from the database
var tracks = GetAllSavedTracks();
using (var db = new AiApiDbContext())
{
if (db.SavedTracks.Any())
{
//let's clear out all the other tracks in the database
RemoveSavedTracks(userName);
}
try
{
//update the lave sync date
db.UdpateSyncDate(userName);
var artistList = new List <string>();
var index = 0;
foreach (var track in tracks)
{
if (artistList.Count < 50)
{
track.Track.Artists.ForEach(x =>
{
if (!artistList.Contains(x.Id))
{
artistList.Add(x.Id);
}
});
}
else
{
await GetArtistFromSpotify(artistList);
artistList.Clear();
continue;;
}
//let's extract what we need from the track object
dSavedTrack savedTrack = new dSavedTrack();
savedTrack.Id = index;
savedTrack.FullTrackId = track.Track.Id;
savedTrack.AddedAt = track.AddedAt;
savedTrack.UserName = userName;
dFullTrack fullTrack = new dFullTrack
{
Id = track.Track.Id,
Name = track.Track.Name,
Explicit = track.Track.Explicit,
Type = track.Track.Type,
PreviewUrl = track.Track.PreviewUrl,
TrackNumber = track.Track.TrackNumber,
Uri = track.Track.Uri,
};
//if the track has an artist (which it should)
//and the artist is not already saved in my library than save the artist out
if (track.Track.Artists.Any())
{
fullTrack.Artist1Id = track.Track.Artists[0].Id;
if (track.Track.Artists.Count > 1)
{
fullTrack.Artist2Id = track.Track.Artists[1].Id;
}
}
if (db.SavedTracks.Find(savedTrack.Id) == null)
{
//add the track to query
db.SavedTracks.Add(savedTrack);
}
if (db.Songs.Find(fullTrack.Id) == null)
{
db.Songs.Add(fullTrack);
}
//let's increment the index;
index++;
}
await db.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
Console.WriteLine("=====================");
Console.WriteLine(ex.Message);
Console.WriteLine(ex.InnerException);
Console.WriteLine(ex.StackTrace);
Console.WriteLine("=====================");
return(false);
}
}
return(false);
}
