//load me
public async Task LoadTabForm()
{
Profile profile = Globals.DataStore.SelectedProfile;
lblDisplayName.Text = profile.display_name;
try
{
picProfile.LoadAsync(profile.images.FirstOrDefault().url.ToString());
}
catch (Exception exce)
{
picProfile.Image = null;
}
PlaylistList myPlaylists = Globals.DataStore.PlaylistList;
lblNumFollowers.Text = $"{profile.followers.total.ToString(),3} followers";
lblNumPlaylists.Text = $"{myPlaylists.total,3} playlists";
dgvRecentlyPlayed.Rows.Clear();
if (profile.id == Globals.DataStore.MyId)
{
foreach (Item item in Globals.DataStore.SelectedRecentlyPlayed.items)
{
dgvRecentlyPlayed.Rows.Add($"{item.track.name}", $"{item.track.artists.FirstOrDefault().name}", "Load track", item.track.id);
}
}
}
public async Task GetPlaylist(string playlistId)
{
//sets selected playlist
string playlistJson = await Globals.Requester.GetAsync($"https://api.spotify.com/v1/playlists/{playlistId}?limit=999");
Playlist playlist = JsonConvert.DeserializeObject <Playlist>(playlistJson);
SelectedPlaylist = playlist;
//gets playlist items
string playlistTracksJson = await Globals.Requester.GetAsync($"https://api.spotify.com/v1/playlists/{playlistId}/tracks?limit=99");
PlaylistTracks playlistTracks = JsonConvert.DeserializeObject <PlaylistTracks>(playlistTracksJson);
if (playlistTracks.total > 99)
{
int numLoops = (int)Math.Ceiling(Convert.ToDouble(playlistTracks.total) / 99.0);
for (int i = 1; i < numLoops; i++)
{
playlistTracksJson = await Globals.Requester.GetAsync($"https://api.spotify.com/v1/playlists/{playlistId}/tracks?limit=99&offset={99*i}");
PlaylistList playlistTracksOffset = JsonConvert.DeserializeObject <PlaylistList>(playlistTracksJson);
playlistTracks.items.AddRange(playlistTracksOffset.items.ToArray());
}
}
SelectedPlaylistTracks = playlistTracks;
}
/// <summary>
/// Clears the search results objects to purge them from memory
/// </summary>
private void ClearResults()
{
while (Results.Items.Count > 0)
{
object listItem = Results.Items.ElementAt(0);
if (listItem is PlaylistList)
{
PlaylistList playlistList = listItem as PlaylistList;
playlistList.Unload();
Results.Items.Remove(playlistList);
}
else if (listItem is TrackList)
{
TrackList trackList = listItem as TrackList;
trackList.Unload();
Results.Items.Remove(trackList);
}
else if (listItem is AlbumList)
{
AlbumList albumList = listItem as AlbumList;
albumList.Unload();
Results.Items.Remove(albumList);
}
}
}
/// <summary>
/// Used when freeing memory
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public async void Page_Unloaded(object sender, RoutedEventArgs e)
{
if (App.isInBackgroundMode)
{
playlistsOffset = 0;
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Bindings.StopTracking();
PlaylistsView.ItemClick -= PlaylistsView_ItemClick;
ClearPlaylists();
LogIn.Click -= LogIn_Click;
PlaylistsRefresh.Click -= PlaylistsRefresh_Click;
PlaylistsMore.Click -= PlaylistsMore_Click;
while (preEmptiveLoadPlaylists.Count > 0)
{
PlaylistList playlistList = preEmptiveLoadPlaylists.ElementAt(0) as PlaylistList;
playlistList.Unload();
preEmptiveLoadPlaylists.Remove(playlistList);
}
});
}
}
public PlaylistList GetPlaylists(String userId)
{
PlaylistInfoList playlistInfoList = GetPagedRequest <PlaylistInfoList>(Endpoints.GetPlaylists(userId), true);
PlaylistList playlistList = new PlaylistList(playlistInfoList);
return(playlistList);
}
public Task <Library.Models.Pagination.PagedResult <PlaylistList> > List(PagedRequest request, User roadieUser = null)
{
var sw = new Stopwatch();
sw.Start();
int[] playlistWithArtistTrackIds = new int[0];
if (request.FilterToArtistId.HasValue)
{
playlistWithArtistTrackIds = (from pl in this.DbContext.Playlists
join pltr in this.DbContext.PlaylistTracks on pl.Id equals pltr.PlayListId
join t in this.DbContext.Tracks on pltr.TrackId equals t.Id
join rm in this.DbContext.ReleaseMedias on t.ReleaseMediaId equals rm.Id
join r in this.DbContext.Releases on rm.ReleaseId equals r.Id
join a in this.DbContext.Artists on r.ArtistId equals a.Id
where a.RoadieId == request.FilterToArtistId
select pl.Id
).ToArray();
}
int[] playlistReleaseTrackIds = new int[0];
if (request.FilterToReleaseId.HasValue)
{
playlistReleaseTrackIds = (from pl in this.DbContext.Playlists
join pltr in this.DbContext.PlaylistTracks on pl.Id equals pltr.PlayListId
join t in this.DbContext.Tracks on pltr.TrackId equals t.Id
join rm in this.DbContext.ReleaseMedias on t.ReleaseMediaId equals rm.Id
join r in this.DbContext.Releases on rm.ReleaseId equals r.Id
where r.RoadieId == request.FilterToReleaseId
select pl.Id
).ToArray();
}
var result = (from pl in this.DbContext.Playlists
join u in this.DbContext.Users on pl.UserId equals u.Id
where (request.FilterToPlaylistId == null || pl.RoadieId == request.FilterToPlaylistId)
where (request.FilterToArtistId == null || playlistWithArtistTrackIds.Contains(pl.Id))
where (request.FilterToReleaseId == null || playlistReleaseTrackIds.Contains(pl.Id))
where ((roadieUser == null && pl.IsPublic) || (roadieUser != null && u.RoadieId == roadieUser.UserId || pl.IsPublic))
where (request.FilterValue.Length == 0 || (request.FilterValue.Length > 0 && (pl.Name != null && pl.Name.Contains(request.FilterValue))))
select PlaylistList.FromDataPlaylist(pl, u, this.MakePlaylistThumbnailImage(pl.RoadieId), this.MakeUserThumbnailImage(u.RoadieId)));
var sortBy = string.IsNullOrEmpty(request.Sort) ? request.OrderValue(new Dictionary <string, string> {
{ "Playlist.Text", "ASC" }
}) : request.OrderValue(null);
var rowCount = result.Count();
var rows = result.OrderBy(sortBy).Skip(request.SkipValue).Take(request.LimitValue).ToArray();
sw.Stop();
return(Task.FromResult(new Library.Models.Pagination.PagedResult <PlaylistList>
{
TotalCount = rowCount,
CurrentPage = request.PageValue,
TotalPages = (int)Math.Ceiling((double)rowCount / request.LimitValue),
OperationTime = sw.ElapsedMilliseconds,
Rows = rows
}));
}
void getPlaylists()
{
lsbPlaylist.Items.Clear();
playlists = iPod.Playlists;
for (int i = 0; i < playlists.Count; i++)
{
lsbPlaylist.Items.Add(playlists[i].Name.ToString());
}
lblPlaylist.Text = "Playlists : " + playlists.Count;
}
/// <summary>
/// Clears UI playlists
/// </summary>
public void ClearPlaylists()
{
playlistsOffset = 0;
while (PlaylistsView.Items.Count > 0)
{
PlaylistList playlistList = PlaylistsView.Items.ElementAt(0) as PlaylistList;
playlistList.Unload();
PlaylistsView.Items.Remove(playlistList);
}
}
private void PopulatePlaylistList()
{
PlaylistList.Clear();
List <Playlist> temp = QueryManager.GetPlaylists("");
for (int i = 0; i < temp.Count; i++)
{
PlaylistList.Add(temp[i]);
}
}
public JsonSerializationContent(string serializationFolder, UploadList uploadList, TemplateList templateList, PlaylistList playlistList)
{
this.playlistListFilePath = Path.Combine(serializationFolder, "playlistlist.json");
this.uploadListFilePath = Path.Combine(serializationFolder, "uploadlist.json");
this.templateListFilePath = Path.Combine(serializationFolder, "templatelist.json");
this.allUploadsFilePath = Path.Combine(serializationFolder, "uploads.json");
this.uploadList = uploadList;
this.templateList = templateList;
this.playlistList = playlistList;
}
private void Form1_Load(object sender, EventArgs e)
{
XmlImportExport <PlaylistList> xmlImport = new XmlImportExport <PlaylistList>();
playlistList = xmlImport.DeserializeXml("playlists.xml", "PlaylistList");
var form = new Forms.FormAllPlaylists(playlistList);
form.playlistEventHandler += OpenPlaylistFromReceivingEvent;
OpenChildForm(form, null);
Application.DoEvents();
}
public async Task LoadTabForm()
{
PlaylistList myPlayListList = Globals.DataStore.PlaylistList;
cmbPlaylistSelect.Items.Clear();
foreach (Item i in Globals.DataStore.PlaylistList.items)
{
cmbPlaylistSelect.Items.Add(i.name);
}
}
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"));
}
/// <summary>
/// 初期化する
/// </summary>
internal async Task Initialize()
{
// プレイリスト一覧を空にする
PlaylistList.Clear();
var playlists = await m_YouTubeService.GetMyPlaylists();
foreach (var playlist in playlists)
{
PlaylistList.Add(new PlaylistViewModel(playlist, m_WebClientService));
}
}
private void BtnFavouritePlaylists_Click(object sender, EventArgs e)
{
PlaylistList temp = new PlaylistList();
foreach (var playlist in playlistList.playlistList)
{
if (playlist.isFavourite)
{
temp.playlistList.Add(playlist);
}
}
OpenChildForm(new FormAllPlaylists(temp), sender);
}
public async Task <PlaylistList> GetLibraryPlaylists(string continuation = null)
{
string url = GetYTMUrl("browse", continuation);
var data = JObject.FromObject(new
{
browseId = "FEmusic_liked_playlists"
});
var response = await Post <BrowseResponse>(url, data, authRequired : true);
return(PlaylistList.FromBrowseResponse(response));
}
/// <summary>
/// Sets the playlists without updating the UI
/// </summary>
/// <returns></returns>
public static async Task SetPlaylists()
{
UriBuilder playlistsBuilder = new UriBuilder(playlistsHref);
List <KeyValuePair <string, string> > queryParams = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("limit", playlistLimit.ToString()),
new KeyValuePair <string, string>("offset", playlistsOffset.ToString())
};
playlistsBuilder.Query = RequestHandler.ConvertToQueryString(queryParams);
string playlistsString = await RequestHandler.SendAuthGetRequest(playlistsBuilder.Uri.ToString());
JsonObject playlistsJson = new JsonObject();
try
{
playlistsJson = JsonObject.Parse(playlistsString);
}
catch (COMException)
{
return;
}
if (playlistsJson.TryGetValue("total", out IJsonValue totalJson) && totalJson.ValueType == JsonValueType.Number)
{
playlistsTotal = Convert.ToInt32(totalJson.GetNumber());
}
if (playlistsJson.TryGetValue("items", out IJsonValue itemsJson) && itemsJson.ValueType == JsonValueType.Array)
{
JsonArray playlistsArray = itemsJson.GetArray();
playlistsCount = playlistsArray.Count;
foreach (JsonValue playlistJson in playlistsArray)
{
if (playlistJson.GetObject().TryGetValue("href", out IJsonValue fullHref) && fullHref.ValueType == JsonValueType.String)
{
string fullPlaylistString = await RequestHandler.SendCliGetRequest(fullHref.GetString());
Playlist playlist = new Playlist();
await playlist.SetInfo(fullPlaylistString);
PlaylistList playlistList = new PlaylistList(playlist);
preEmptiveLoadPlaylists.Add(playlistList);
if (preEmptiveLoadPlaylists.IndexOf(playlistList) % 2 == 1)
{
playlistList.TurnOffOpaqueBackground();
}
}
}
}
}
public async Task <bool> RefreshInitialDataStore()
{
//todo: async webcalls
// List<Task> webCalls = new List<Task>();
//MyProfile:
string myProfileJson = await Globals.Requester.GetAsync("https://api.spotify.com/v1/me");
SelectedProfile = JsonConvert.DeserializeObject <Profile>(myProfileJson);
MyId = SelectedProfile.id;
//MyPlaylists:
string myPlaylistsJson = await Globals.Requester.GetAsync("https://api.spotify.com/v1/me/playlists/?limit=49");
PlaylistList = JsonConvert.DeserializeObject <PlaylistList>(myPlaylistsJson);
//because max limit is 50, must loop
if (PlaylistList.total > 49)
{
int numLoops = (int)Math.Ceiling(Convert.ToDouble(PlaylistList.total) / 49.0);
for (int i = 1; i < numLoops; i++)
{
myPlaylistsJson = await Globals.Requester.GetAsync($"https://api.spotify.com/v1/me/playlists/?limit=49&offset={49*i}");
PlaylistList playlistOffset = JsonConvert.DeserializeObject <PlaylistList>(myPlaylistsJson);
PlaylistList.items.AddRange(playlistOffset.items.ToArray());
}
}
//ProfileRecentlyPlayed:
string myRecentlyPlayedJson = await Globals.Requester.GetAsync($"https://api.spotify.com/v1/me/player/recently-played?limit=10");
SelectedRecentlyPlayed = JsonConvert.DeserializeObject <RecentlyPlayed>(myRecentlyPlayedJson);
//Track
await GetTrack(SelectedRecentlyPlayed.items.FirstOrDefault().track.id);
//returns success
return(true);
}
public async Task GetPlaylistList(string userId)
{
//MyPlaylists:
string myPlaylistsJson = await Globals.Requester.GetAsync($"https://api.spotify.com/v1/users/{userId}/playlists/");
PlaylistList = JsonConvert.DeserializeObject <PlaylistList>(myPlaylistsJson);
//because max limit is 50, must loop
if (PlaylistList.total > 49)
{
int numLoops = (int)Math.Ceiling(Convert.ToDouble(PlaylistList.total) / 49.0);
for (int i = 1; i < numLoops; i++)
{
myPlaylistsJson = await Globals.Requester.GetAsync($"https://api.spotify.com/v1/me/playlists/?limit=49&offset={49 * i}");
PlaylistList playlistOffset = JsonConvert.DeserializeObject <PlaylistList>(myPlaylistsJson);
PlaylistList.items.AddRange(playlistOffset.items.ToArray());
}
}
}
/// <summary>
/// Refreshes the users playlists
/// </summary>
/// <returns></returns>
public async Task LoadPlaylists()
{
PlaylistsHeader.Visibility = Visibility.Collapsed;
EmptyMessage.Visibility = Visibility.Collapsed;
PlaylistsMore.IsEnabled = false;
PlaylistsRefresh.IsEnabled = false;
long loadingKey = DateTime.Now.Ticks;
MainPage.AddLoadingLock(loadingKey);
App.mainPage.SetLoadingProgress(PlaybackSource.Spotify, 0, 1, loadingKey);
UriBuilder playlistsBuilder = new UriBuilder(playlistsHref);
List <KeyValuePair <string, string> > queryParams = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("limit", playlistLimit.ToString()),
new KeyValuePair <string, string>("offset", playlistsOffset.ToString())
};
playlistsBuilder.Query = RequestHandler.ConvertToQueryString(queryParams);
string playlistsString = await RequestHandler.SendAuthGetRequest(playlistsBuilder.Uri.ToString());
JsonObject playlistsJson = new JsonObject();
try
{
playlistsJson = JsonObject.Parse(playlistsString);
}
catch (COMException)
{
return;
}
if (playlistsJson.TryGetValue("total", out IJsonValue totalJson) && totalJson.ValueType == JsonValueType.Number)
{
playlistsTotal = Convert.ToInt32(totalJson.GetNumber());
}
if (playlistsJson.TryGetValue("items", out IJsonValue itemsJson) && itemsJson.ValueType == JsonValueType.Array)
{
JsonArray playlistsArray = itemsJson.GetArray();
if (playlistsArray.Count == 0)
{
PlaylistsHeader.Visibility = Visibility.Collapsed;
EmptyMessage.Visibility = Visibility.Visible;
App.mainPage.SetLoadingProgress(PlaybackSource.Spotify, 1, 1, loadingKey);
}
else
{
PlaylistsHeader.Visibility = Visibility.Visible;
foreach (JsonValue playlistJson in playlistsArray)
{
if (playlistJson.GetObject().TryGetValue("href", out IJsonValue fullHref) && fullHref.ValueType == JsonValueType.String)
{
string fullPlaylistString = await RequestHandler.SendCliGetRequest(fullHref.GetString());
Playlist playlist = new Playlist();
await playlist.SetInfo(fullPlaylistString);
PlaylistList playlistList = new PlaylistList(playlist);
PlaylistsView.Items.Add(playlistList);
if (PlaylistsView.Items.IndexOf(playlistList) % 2 == 1)
{
playlistList.TurnOffOpaqueBackground();
}
App.mainPage.SetLoadingProgress(PlaybackSource.Spotify, PlaylistsView.Items.Count, playlistsArray.Count, loadingKey);
}
}
}
}
PlaylistsRefresh.IsEnabled = true;
if (playlistsOffset + playlistLimit >= playlistsTotal)
{
PlaylistsMore.Content = "No More";
PlaylistsMore.IsEnabled = false;
}
else
{
PlaylistsMore.Content = "More";
PlaylistsMore.IsEnabled = true;
}
MainPage.RemoveLoadingLock(loadingKey);
}
public PlaylistChooserViewModel()
{
PlaylistList servicePlaylists = SpotifyClientService.Client.GetPlaylists(SpotifyClientService.User.Id);
_playlists = servicePlaylists.Playlists;
}
public NavigationViewModel()
{
PlaylistList servicePlaylists = SpotifyClientService.Client.GetPlaylists(SpotifyClientService.User.Id);
_playlists = servicePlaylists.Playlists;
}
public void DeletePlaylist(Playlist playlist)
{
QueryManager.DeletePlaylist(playlist);
PlaylistList.Remove(playlist);
}
/// <summary>
/// Search for the selected item in Spotify
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void SearchButton_Click(object sender, RoutedEventArgs e)
{
string feedbackMessage = "";
if (Feedback == null)
{
return;
}
Feedback.Text = "";
feedbackMessage = "";
PlaylistHeader.Visibility = Visibility.Collapsed;
TracklistHeader.Visibility = Visibility.Collapsed;
AlbumlistHeader.Visibility = Visibility.Collapsed;
ResultsHeaderContainer.Visibility = Visibility.Collapsed;
if (SearchBox.Text == "")
{
feedbackMessage = "Please enter text to search for (I can't read your mind...yet)";
}
else
{
searchSave = SearchBox.Text;
searchTypeSave = SearchType.SelectedIndex;
MainPanel.SetValue(MarginProperty, new Thickness(0, 20, 0, 0));
RelativePanel.SetAlignTopWithPanel(SearchBox, true);
ComboBoxItem selected = SearchType.SelectedValue as ComboBoxItem;
String selectedString = selected.Content.ToString().ToLower();
UriBuilder searchUriBuilder = new UriBuilder(SEARCH_URL);
List <KeyValuePair <string, string> > queryParams = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("type", selectedString),
new KeyValuePair <string, string>("limit", "10"),
new KeyValuePair <string, string>("q", SearchBox.Text.Replace(" ", "+"))
};
string queryParamsString = RequestHandler.ConvertToQueryString(queryParams);
searchUriBuilder.Query = queryParamsString;
string searchResultString = await RequestHandler.SendCliGetRequest(searchUriBuilder.Uri.ToString());
JsonObject searchResultJson = new JsonObject();
try
{
searchResultJson = JsonObject.Parse(searchResultString);
}
catch (COMException)
{
return;
}
ClearResults();
Results.Visibility = Visibility.Visible;
// playlists
if (selectedString == "playlist")
{
if (searchResultJson.TryGetValue("playlists", out IJsonValue playlistsJson) && playlistsJson.ValueType == JsonValueType.Object)
{
JsonObject playlists = playlistsJson.GetObject();
if (playlists.TryGetValue("items", out IJsonValue itemsJson) && itemsJson.ValueType == JsonValueType.Array)
{
JsonArray playlistsArray = itemsJson.GetArray();
if (playlistsArray.Count == 0)
{
feedbackMessage = "No playlists found.";
}
else
{
ResultsHeaderContainer.Visibility = Visibility.Visible;
PlaylistHeader.Visibility = Visibility.Visible;
long loadingKey = DateTime.Now.Ticks;
MainPage.AddLoadingLock(loadingKey);
App.mainPage.SetLoadingProgress(PlaybackSource.Spotify, 0, playlistsArray.Count, loadingKey);
foreach (JsonValue playlistJson in playlistsArray)
{
if (playlistJson.GetObject().TryGetValue("href", out IJsonValue fullHref) && fullHref.ValueType == JsonValueType.String)
{
string fullPlaylistString = await RequestHandler.SendCliGetRequest(fullHref.GetString());
Playlist playlist = new Playlist();
await playlist.SetInfo(fullPlaylistString);
PlaylistList playlistList = new PlaylistList(playlist);
try
{
if (!App.isInBackgroundMode)
{
Results.Items.Add(playlistList);
if (Results.Items.IndexOf(playlistList) % 2 == 1)
{
playlistList.TurnOffOpaqueBackground();
}
}
}
catch (COMException) { }
App.mainPage.SetLoadingProgress(PlaybackSource.Spotify, Results.Items.Count, playlistsArray.Count, loadingKey);
}
}
MainPage.RemoveLoadingLock(loadingKey);
}
}
}
}
// track
else if (selectedString == "track")
{
if (searchResultJson.TryGetValue("tracks", out IJsonValue tracksJson) && tracksJson.ValueType == JsonValueType.Object)
{
JsonObject tracks = tracksJson.GetObject();
if (tracks.TryGetValue("items", out IJsonValue itemsJson) && itemsJson.ValueType == JsonValueType.Array)
{
JsonArray tracksArray = itemsJson.GetArray();
if (tracksArray.Count == 0)
{
feedbackMessage = "No tracks found.";
}
else
{
ResultsHeaderContainer.Visibility = Visibility.Visible;
TracklistHeader.Visibility = Visibility.Visible;
long loadingKey = DateTime.Now.Ticks;
MainPage.AddLoadingLock(loadingKey);
App.mainPage.SetLoadingProgress(PlaybackSource.Spotify, 0, tracksArray.Count, loadingKey);
foreach (JsonValue trackJson in tracksArray)
{
Track track = new Track();
await track.SetInfoDirect(trackJson.Stringify());
TrackList trackList = new TrackList(track);
try
{
if (!App.isInBackgroundMode)
{
Results.Items.Add(trackList);
if (Results.Items.IndexOf(trackList) % 2 == 1)
{
trackList.TurnOffOpaqueBackground();
}
}
}
catch (COMException) { }
App.mainPage.SetLoadingProgress(PlaybackSource.Spotify, Results.Items.Count, tracksArray.Count, loadingKey);
}
MainPage.RemoveLoadingLock(loadingKey);
}
}
}
}
// album
else if (selectedString == "album")
{
if (searchResultJson.TryGetValue("albums", out IJsonValue albumsJson) && albumsJson.ValueType == JsonValueType.Object)
{
JsonObject albums = albumsJson.GetObject();
if (albums.TryGetValue("items", out IJsonValue itemsJson) && itemsJson.ValueType == JsonValueType.Array)
{
JsonArray albumsArray = itemsJson.GetArray();
if (albumsArray.Count == 0)
{
feedbackMessage = "No albums found.";
}
else
{
ResultsHeaderContainer.Visibility = Visibility.Visible;
AlbumlistHeader.Visibility = Visibility.Visible;
long loadingKey = DateTime.Now.Ticks;
MainPage.AddLoadingLock(loadingKey);
App.mainPage.SetLoadingProgress(PlaybackSource.Spotify, 0, albumsArray.Count, loadingKey);
foreach (JsonValue albumJson in albumsArray)
{
Album album = new Album();
await album.SetInfo(albumJson.Stringify());
AlbumList albumList = new AlbumList(album);
try
{
if (!App.isInBackgroundMode)
{
Results.Items.Add(albumList);
if (Results.Items.IndexOf(albumList) % 2 == 1)
{
albumList.TurnOffOpaqueBackground();
}
}
}
catch (COMException) { }
App.mainPage.SetLoadingProgress(PlaybackSource.Spotify, Results.Items.Count, albumsArray.Count, loadingKey);
}
MainPage.RemoveLoadingLock(loadingKey);
}
}
}
}
}
Feedback.Text = feedbackMessage;
if (feedbackMessage == "")
{
Feedback.Visibility = Visibility.Collapsed;
}
else
{
Feedback.Visibility = Visibility.Visible;
}
}
public static void ClearRepositories()
{
UploadList = null;
TemplateList = null;
PlaylistList = null;
}
public async Task <Library.Models.Pagination.PagedResult <models.BookmarkList> > List(User roadieUser, PagedRequest request, bool?doRandomize = false, BookmarkType?filterType = null)
{
var sw = new Stopwatch();
sw.Start();
var result = from b in DbContext.Bookmarks
join u in DbContext.Users on b.UserId equals u.Id
where b.UserId == roadieUser.Id
where filterType == null || b.BookmarkType == filterType
select new models.BookmarkList
{
Comment = b.Comment,
Position = b.Position,
User = new models.DataToken
{
Text = u.UserName,
Value = u.RoadieId.ToString()
},
DatabaseId = b.Id,
Id = b.RoadieId,
CreatedDate = b.CreatedDate,
LastUpdated = b.LastUpdated,
Type = b.BookmarkType,
BookmarkTargetId = b.BookmarkTargetId
};
var sortBy = string.IsNullOrEmpty(request.Sort)
? request.OrderValue(new Dictionary <string, string> {
{ "CreatedDate", "DESC" }
})
: request.OrderValue();
var rowCount = result.Count();
var rows = result.OrderBy(sortBy).Skip(request.SkipValue).Take(request.LimitValue).ToArray();
var user = await GetUser(roadieUser.UserId);
foreach (var row in rows)
{
switch (row.Type)
{
case BookmarkType.Artist:
var artist = DbContext.Artists.FirstOrDefault(x => x.Id == row.BookmarkTargetId);
if (artist == null)
{
continue;
}
row.Bookmark = new models.DataToken
{
Text = artist.Name,
Value = artist.RoadieId.ToString()
};
row.Artist =
models.ArtistList.FromDataArtist(artist, ImageHelper.MakeArtistThumbnailImage(Configuration, HttpContext, artist.RoadieId));
row.Thumbnail = ImageHelper.MakeArtistThumbnailImage(Configuration, HttpContext, artist.RoadieId);
row.SortName = artist.SortName ?? artist.Name;
break;
case BookmarkType.Release:
var release = DbContext.Releases.Include(x => x.Artist)
.FirstOrDefault(x => x.Id == row.BookmarkTargetId);
if (release == null)
{
continue;
}
row.Bookmark = new models.DataToken
{
Text = release.Title,
Value = release.RoadieId.ToString()
};
row.Release = ReleaseList.FromDataRelease(release, release.Artist, HttpContext.BaseUrl,
ImageHelper.MakeArtistThumbnailImage(Configuration, HttpContext, release.Artist.RoadieId),
ImageHelper.MakeReleaseThumbnailImage(Configuration, HttpContext, release.RoadieId));
row.Thumbnail = ImageHelper.MakeReleaseThumbnailImage(Configuration, HttpContext, release.RoadieId);
row.SortName = release.SortTitleValue;
break;
case BookmarkType.Track:
var track = DbContext.Tracks
.Include(x => x.ReleaseMedia)
.Include(x => x.ReleaseMedia.Release)
.Include(x => x.ReleaseMedia.Release.Artist)
.Include(x => x.TrackArtist)
.FirstOrDefault(x => x.Id == row.BookmarkTargetId);
if (track == null)
{
continue;
}
row.Bookmark = new models.DataToken
{
Text = track.Title,
Value = track.RoadieId.ToString()
};
row.Track = models.TrackList.FromDataTrack(MakeTrackPlayUrl(user, HttpContext.BaseUrl, track.RoadieId),
track,
track.ReleaseMedia.MediaNumber,
track.ReleaseMedia.Release,
track.ReleaseMedia.Release.Artist,
track.TrackArtist,
HttpContext.BaseUrl,
ImageHelper.MakeTrackThumbnailImage(Configuration, HttpContext, track.RoadieId),
ImageHelper.MakeReleaseThumbnailImage(Configuration, HttpContext, track.ReleaseMedia.Release.RoadieId),
ImageHelper.MakeArtistThumbnailImage(Configuration, HttpContext, track.ReleaseMedia.Release.Artist.RoadieId),
ImageHelper.MakeArtistThumbnailImage(Configuration, HttpContext, track.TrackArtist == null
? null
: (Guid?)track.TrackArtist.RoadieId));
row.Track.TrackPlayUrl = MakeTrackPlayUrl(user, HttpContext.BaseUrl, track.RoadieId);
row.Thumbnail = ImageHelper.MakeTrackThumbnailImage(Configuration, HttpContext, track.RoadieId);
row.SortName = track.Title;
break;
case BookmarkType.Playlist:
var playlist = DbContext.Playlists
.Include(x => x.User)
.FirstOrDefault(x => x.Id == row.BookmarkTargetId);
if (playlist == null)
{
continue;
}
row.Bookmark = new models.DataToken
{
Text = playlist.Name,
Value = playlist.RoadieId.ToString()
};
row.Playlist = PlaylistList.FromDataPlaylist(playlist, playlist.User,
ImageHelper.MakePlaylistThumbnailImage(Configuration, HttpContext, playlist.RoadieId),
ImageHelper.MakeUserThumbnailImage(Configuration, HttpContext, playlist.User.RoadieId));
row.Thumbnail = ImageHelper.MakePlaylistThumbnailImage(Configuration, HttpContext, playlist.RoadieId);
row.SortName = playlist.Name;
break;
case BookmarkType.Collection:
var collection = DbContext.Collections.FirstOrDefault(x => x.Id == row.BookmarkTargetId);
if (collection == null)
{
continue;
}
row.Bookmark = new models.DataToken
{
Text = collection.Name,
Value = collection.RoadieId.ToString()
};
row.Collection = CollectionList.FromDataCollection(collection,
(from crc in DbContext.CollectionReleases
where crc.CollectionId == collection.Id
select crc.Id).Count(), ImageHelper.MakeCollectionThumbnailImage(Configuration, HttpContext, collection.RoadieId));
row.Thumbnail = ImageHelper.MakeCollectionThumbnailImage(Configuration, HttpContext, collection.RoadieId);
row.SortName = collection.SortName ?? collection.Name;
break;
case BookmarkType.Label:
var label = DbContext.Labels.FirstOrDefault(x => x.Id == row.BookmarkTargetId);
if (label == null)
{
continue;
}
row.Bookmark = new models.DataToken
{
Text = label.Name,
Value = label.RoadieId.ToString()
};
row.Label = models.LabelList.FromDataLabel(label, ImageHelper.MakeLabelThumbnailImage(Configuration, HttpContext, label.RoadieId));
row.Thumbnail = ImageHelper.MakeLabelThumbnailImage(Configuration, HttpContext, label.RoadieId);
row.SortName = label.SortName ?? label.Name;
break;
}
}
;
sw.Stop();
return(new Library.Models.Pagination.PagedResult <models.BookmarkList>
{
TotalCount = rowCount,
CurrentPage = request.PageValue,
TotalPages = (int)Math.Ceiling((double)rowCount / request.LimitValue),
OperationTime = sw.ElapsedMilliseconds,
Rows = rows
});
}
public void CreatePlaylist(Playlist playlist)
{
playlist.PlaylistId = QueryManager.CreatePlaylist(ref playlist);
PlaylistList.Add(playlist);
}
public FormAllPlaylists(PlaylistList playlistList)
{
InitializeComponent();
this.playlistList = playlistList;
}
void getPlaylists()
{
lsbPlaylist.Items.Clear();
playlists = iPod.Playlists;
for (int i = 0; i < playlists.Count; i++)
{
lsbPlaylist.Items.Add(playlists[i].Name.ToString());
}
lblPlaylist.Text = "Playlists : " + playlists.Count;
}
