private async void ContentDialog_PrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
{
if (Main.SelectedIndex < 0 || Playlists.Count < 1 || Main.SelectedIndex > Playlists.Count)
{
}
else
{
if (Main.SelectedIndex == 0)
{
foreach (var item in songID)
{
await SQLOperator.Current().WriteFavoriteAsync(item, true);
}
}
else
{
await Playlists[Main.SelectedIndex].AddAsync(songID);
}
}
MainPage.Current.PopMessage($"Added {SmartFormat.Smart.Format(Consts.Localizer.GetString("SmartSongs"), songID.Length)} into collection");
}
public static async Task <List <Album> > GetAllAlbumsAsync()
{
var opr = SQLOperator.Current();
// get aritst-associated albums
var albums = await opr.GetAllAsync <ALBUM>();
var res = albums.ConvertAll(a => new Album(a));
var otherSongs = await opr.GetWithQueryAsync <SONG>($"SELECT * FROM SONG WHERE ALBUM IS NULL");
// remove duplicated (we suppose that artist's all song is just 1000+, this way can find all song and don't take long time)
var otherGrouping = from song in otherSongs group song by song.Album;
// otherSongs has item
if (!otherGrouping.IsNullorEmpty())
{
res.AddRange(otherGrouping.ToList().ConvertAll(a => new Album(a)));
}
return(res);
}
public static async Task <IEnumerable <ListWithKey <GenericMusicItem> > > GetHeroListAsync()
{
var opr = SQLOperator.Current();
var todaySuggestion = await opr.GetTodayListAsync();
var nowSuggestion = await opr.GetNowListAsync();
var recent = await opr.GetRecentListAsync();
var random = await GetRandomListAsync();
var res = new List <ListWithKey <GenericMusicItem> >
{
new ListWithKey <GenericMusicItem>("Random", random),
new ListWithKey <GenericMusicItem>(string.Format(Consts.Localizer.GetString("TodaySuggestionText"), DateTime.Today.DayOfWeek.GetDisplayName()), todaySuggestion),
new ListWithKey <GenericMusicItem>(string.Format(Consts.Localizer.GetString("TodayFavText"), DateTime.Now.GetHourString()), nowSuggestion),
new ListWithKey <GenericMusicItem>(Consts.Localizer.GetString("RencentlyPlayedText"), recent)
};
return(res);
}
public async Task Init()
{
var opr = SQLOperator.Current();
var folders = await opr.GetAllAsync <FOLDER>();
var p = from g in folders orderby g.IsFiltered select g;
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
foreach (var item in p)
{
if (item.Path == KnownFolders.MusicLibrary.Path || item.Path.Contains(ApplicationData.Current.LocalFolder.Path))
{
continue;
}
if (!item.Path.IsNullorEmpty())
{
Folders.Add(new FolderViewModel(item));
}
}
});
}
internal async Task <AlbumViewModel> FindAssociatedAlbumAsync()
{
var opr = SQLOperator.Current();
switch (InnerType)
{
case MediaType.Song:
if (Description.IsNullorEmpty())
{
return(null);
}
if (IsOnline)
{
if (OnlineAlbumID.IsNullorEmpty())
{
return(null);
}
return(new AlbumViewModel(await MainPageViewModel.Current.GetOnlineAlbumAsync(OnlineAlbumID)));
}
return(new AlbumViewModel(await opr.GetAlbumByNameAsync(Description, ContextualID)));
case MediaType.Album:
if (ContextualID == default(int))
{
return(new AlbumViewModel(await opr.GetAlbumByNameAsync(Title)));
}
return(new AlbumViewModel(await opr.GetAlbumByIDAsync(ContextualID)));
case MediaType.PlayList:
throw new NotImplementedException();
case MediaType.Artist:
throw new InvalidCastException("This GenericMusicItemViewModel is artist");
default:
return(null);
}
}
public static async Task <List <GenericMusicItem> > GetRandomListAsync()
{
var opr = SQLOperator.Current();
var p = Shared.Helpers.Tools.Random.Next(15);
var songs = await opr.GetRandomListAsync <SONG>(25 - p);
var albums = await opr.GetRandomListAsync <ALBUM>(p);
var list = songs.ConvertAll(x => new GenericMusicItem(x));
foreach (var album in albums)
{
var albumSongs = Array.ConvertAll(album.Songs.Split(new string[] { "|" }, StringSplitOptions.RemoveEmptyEntries), (a) =>
{
return(int.Parse(a));
});
list.Add(new GenericMusicItem(album));
}
list.Shuffle();
return(list);
}
//private const string Comma = ", ";
/// <summary>
/// Instancia un nuevo empaquetado para utilizar como una comparación
/// lógica en una Query de SQL
/// </summary>
/// <param name="Field">Campo de la tabla</param>
/// <param name="Value">Valor del campo</param>
/// <param name="ValueType">Tipo de variable del campo</param>
/// <param name="Operator">Tipo de operador de búsqueda (False "=", True "Like")</param>
/// <exception cref="ArgumentException"></exception>
public DataFieldTemplate(Enum Field, object Value, SQLValueType ValueType, SQLOperator Operator)
{
if (Field is null)
{
throw new ArgumentNullException(nameof(Field));
}
else
{
this.Field = Field;
}
if (Value is null)
{
throw new ArgumentNullException(nameof(Value));
}
else
{
this.Value = Value;
}
this.ValueType = ValueType;
this.Operator = Operator;
}
public static async Task Read(IList <StorageFolder> folder, IList <string> filterdFolderNames)
{
var list = new List <StorageFile>();
int i = 1;
var scan = Consts.Localizer.GetString("FolderScanText");
foreach (var item in folder)
{
var files = await GetFilesAsync(item, filterdFolderNames);
var opr = SQLOperator.Current();
if (KnownFolders.MusicLibrary.Path == item.Path || item.Path.Contains(ApplicationData.Current.LocalFolder.Path))
{
}
else
{
await opr.UpdateFolderAsync(item, files.Count);
}
list.AddRange(files);
ProgressUpdated?.Invoke(null, new ProgressReport()
{
Description = SmartFormat.Smart.Format(scan, i, folder.Count), Current = i, Total = folder.Count
});
i++;
}
await Task.Delay(200);
ProgressUpdated?.Invoke(null, new ProgressReport()
{
Description = Consts.Localizer.GetString("FolderScanFinishText"), Current = i, Total = folder.Count
});
await Task.Delay(200);
await ReadFileandSave(from a in list group a by a.Path into b select b.First());
}
public async Task Read(IList <StorageFolder> folder)
{
var list = new List <StorageFile>();
int i = 1;
foreach (var item in folder)
{
var files = await GetFilesAsync(item);
var opr = SQLOperator.Current();
if (KnownFolders.MusicLibrary.Path == item.Path || item.Path == ApplicationData.Current.LocalFolder.Path)
{
}
else
{
await opr.UpdateFolderAsync(item, files.Count);
}
list.AddRange(files);
ProgressUpdated?.Invoke(this, new ProgressReport()
{
Description = $"{i} of {folder.Count} folders scanned", Current = i, Total = folder.Count
});
i++;
}
await Task.Delay(200);
ProgressUpdated?.Invoke(this, new ProgressReport()
{
Description = "Folder scanning completed", Current = i, Total = folder.Count
});
await Task.Delay(200);
await ReadFileandSave(from a in list group a by a.Path into b select b.First());
}
internal static async Task <Podcast> BuildFromXMLAsync(string resXML, string XMLUrl)
{
var p = await SQLOperator.Current().TryGetPODCAST(XMLUrl);
var a = new Podcast(p);
await a.ReadXML(resXML);
var fileName = $"{a.Title}-{Guid.NewGuid().ToString()}";
if (p != null)
{
fileName = p.XMLPath;
}
else
{
}
var folder = await ApplicationData.Current.LocalFolder.CreateFolderAsync("Podcasts", CreationCollisionOption.OpenIfExists);
fileName = Shared.Utils.InvalidFileNameChars.Aggregate(fileName, (current, c) => current.Replace(c + "", "_"));
var file = await folder.CreateFileAsync($"{fileName}.xml", CreationCollisionOption.OpenIfExists);
await FileIO.WriteTextAsync(file, resXML);
a.XMLUrl = XMLUrl;
a.XMLPath = fileName;
a.ID = p?.ID ?? default(int);
a.Subscribed = p?.Subscribed ?? false;
a.SortRevert = p?.SortRevert ?? false;
await a.SaveAsync();
return(a);
}
private async Task RetryDownloads(IEnumerable <DownloadOperation> downloads, List <DownloadDesc> list)
{
BackgroundDownloader downloader = CreateBackgroundDownloader();
foreach (DownloadOperation download in downloads)
{
try
{
DownloadOperation download1 = downloader.CreateDownload(download.RequestedUri, download.ResultFile);
Task <DownloadOperation> startTask = download1.StartAsync().AsTask();
var p = list.Find(a => a.Guid == download.Guid);
p.Guid = download1.Guid;
await SQLOperator.Current().UpdateDownload(p);
list.Remove(p);
}
catch (Exception)
{
continue;
}
}
downloader.CompletionGroup.Enable();
}
public AddPlayList()
{
this.InitializeComponent();
Task.Run(async () =>
{
var list = await SQLOperator.Current().GetPlayListBriefAsync();
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, async () =>
{
foreach (var item in list)
{
Playlists.Add(new PlayListViewModel(item));
}
await Task.Delay(200);
if (list.Count > 0)
{
Main.SelectedIndex = 0;
}
else
{
IsPrimaryButtonEnabled = false;
}
});
});
}
internal virtual async Task <IList <Song> > GetSongsAsync()
{
if (IsOnline)
{
if (MainPageViewModel.Current.OnlineMusicExtension == null)
{
return(null);
}
var list = new List <Song>();
foreach (var item in OnlineIDs)
{
var s = await MainPageViewModel.Current.GetOnlineSongAsync(item);
if (s == null)
{
continue;
}
list.Add(s);
}
return(list);
}
else
{
if (IDs == null)
{
return(new List <Song>());
}
var opr = SQLOperator.Current();
var s = await opr.GetSongsAsync(IDs);
var s1 = s.OrderBy(x => x.Track);
s1 = s1.OrderBy(x => x.Disc);
return(s1.ToList());
}
}
public string buildWHERE(string column, SQLOperator op, object val)
{
StringBuilder sb = initBuilder();
appendWHERE(sb);
appendColumnCondition(sb, column, op, val);
return sb.ToString();
}
public async Task InitAsync()
{
var songs = await FileReader.GetAllSongAsync();
IEnumerable <GroupedItem <SongViewModel> > grouped;
//var grouped = GroupedItem<AlbumViewModel>.CreateGroups(albums.ConvertAll(x => new AlbumViewModel(x)), x => x.GetFormattedArtists());
//var grouped = GroupedItem<SongViewModel>.CreateGroups(songs.ConvertAll(x => new SongViewModel(x)), x => x.Year, true);
switch (Settings.Current.SongsSort)
{
case SortMode.Alphabet:
grouped = GroupedItem <SongViewModel> .CreateGroupsByAlpha(songs.ConvertAll(x => new SongViewModel(x)));
SortIndex = 0;
break;
case SortMode.Album:
grouped = GroupedItem <SongViewModel> .CreateGroups(songs.ConvertAll(x => new SongViewModel(x)), x => x.FormattedAlbum);
SortIndex = 1;
break;
case SortMode.Artist:
grouped = GroupedItem <SongViewModel> .CreateGroups(songs.ConvertAll(x => new SongViewModel(x)), x => x.GetFormattedArtists());
SortIndex = 2;
break;
case SortMode.Year:
grouped = GroupedItem <SongViewModel> .CreateGroups(songs.ConvertAll(x => new SongViewModel(x)), x => x.Song.Year);
SortIndex = 3;
break;
default:
grouped = GroupedItem <SongViewModel> .CreateGroupsByAlpha(songs.ConvertAll(x => new SongViewModel(x)));
SortIndex = 0;
break;
}
var aCount = await FileReader.GetArtistsCountAsync();
var favors = await SQLOperator.Current().GetFavoriteAsync();
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
SongsList.Clear();
foreach (var item in grouped)
{
item.Aggregate((x, y) =>
{
y.Index = x.Index + 1;
return(y);
});
SongsList.Add(item);
}
SongsCount = SmartFormat.Smart.Format(Consts.Localizer.GetString("SmartSongs"), songs.Count);
ArtistsCount = SmartFormat.Smart.Format(Consts.Localizer.GetString("SmartArtists"), aCount);
foreach (var item in grouped)
{
foreach (var song in item)
{
if (favors.Count == 0)
{
return;
}
if (favors.Contains(song.ID))
{
song.Favorite = true;
favors.Remove(song.ID);
}
}
}
var tileId = "songs";
IsPinned = SecondaryTile.Exists(tileId);
if (IsPinned)
{
Core.Tools.Tile.UpdateImage(tileId, SongsList.SelectMany(a => a.Where(c => c.Artwork != null).Select(b => b.Artwork.OriginalString)).Distinct().OrderBy(x => Guid.NewGuid()).Take(10).ToList(), Consts.Localizer.GetString("SongsText"), Consts.Localizer.GetString("SongsTile"));
}
});
}
/// <summary>
/// 配置比较操作符
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <param name="keySelector">属性选择</param>
/// <param name="operator">操作符</param>
/// <exception cref="ArgumentException"></exception>
/// <exception cref="ArgumentNullException"></exception>
/// <returns></returns>
public SQLCondition <T> OperatorFor <TKey>(Expression <Func <T, TKey> > keySelector, SQLOperator @operator)
{
if (keySelector is null)
{
throw new ArgumentNullException(nameof(keySelector));
}
if (keySelector.Body.NodeType != ExpressionType.MemberAccess)
{
throw new ArgumentException("要求表达式主体必须为MemberAccess表达式", nameof(keySelector));
}
var exp = keySelector.Body as MemberExpression;
foreach (var item in Items)
{
// ReSharper disable once PossibleNullReferenceException
if (item.Member == exp.Member)
{
item.Operator = @operator;
}
}
return(this);
}
public static async Task <IList <Song> > GetAsync(IEnumerable <int> songID)
{
return(await SQLOperator.Current().GetSongsAsync(songID));
}
public async Task Init(ArtistViewModel artist)
{
var b = ThreadPool.RunAsync(async x =>
{
var art = await MainPageViewModel.Current.GetArtistInfoAsync(artist.RawName);
if (art != null)
{
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
Artist.Description = art.Description;
Artist.Avatar = art.AvatarUri;
});
}
});
var opr = SQLOperator.Current();
var albums = await opr.GetAlbumsOfArtistAsync(artist.RawName);
var songs = await opr.GetSongsAsync(albums.SelectMany(s => s.Songs));
var empty = artist.RawName.IsNullorEmpty();
for (int i = songs.Count - 1; i >= 0; i--)
{
if (empty)
{
if (songs[i].Performers == null || songs[i].Performers.Length == 0)
{
continue;
}
else
{
songs.RemoveAt(i);
}
}
else
{
var flag = false;
if (songs[i].Performers != null)
{
foreach (var p in songs[i].Performers)
{
if (artist.RawName == p)
{
flag = true;
break;
}
}
}
if (!flag)
{
if (songs[i].AlbumArtists == null || songs[i].AlbumArtists.Length == 0)
{
songs.RemoveAt(i);
continue;
}
else
{
foreach (var p in songs[i].AlbumArtists)
{
if (artist.RawName == p)
{
flag = true;
break;
}
}
}
}
if (!flag)
{
songs.RemoveAt(i);
}
}
}
var grouped = GroupedItem <SongViewModel> .CreateGroupsByAlpha(songs.ConvertAll(x => new SongViewModel(x)));
var a = albums.OrderByDescending(x => x.Year);
var genres = (from alb in a
where !alb.Genres.IsNullorEmpty()
group alb by alb.Genres into grp
orderby grp.Count() descending
select grp.Key).FirstOrDefault();
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
AlbumList.Clear();
foreach (var item in a)
{
AlbumList.Add(new AlbumViewModel(item));
}
SongsList.Clear();
foreach (var item in grouped)
{
item.Aggregate((x, y) =>
{
y.Index = x.Index + 1;
return(y);
});
SongsList.Add(item);
}
SongsCount = SmartFormat.Smart.Format(Consts.Localizer.GetString("SmartAlbums"), AlbumList.Count);
Genres = genres.IsNullorEmpty() ? Consts.Localizer.GetString("VariousGenresText") : string.Join(Consts.CommaSeparator, genres);
});
}
private void appendSqlOperator(StringBuilder sb, SQLOperator op, bool appendTrailingBlank)
{
sb.Append(getSQLOperatorString(op));
if (appendTrailingBlank)
sb.Append(coBLANK);
}
private void appendColumnCondition(StringBuilder sb, string column, SQLOperator op, object value, bool appendTrailingBlank)
{
appendFullColumnName(sb, column);
appendSqlOperator(sb, op);
if ((value == null) || (value.ToString().Equals(String.Empty)))
sb.Append(0);
else
sb.Append(value);
if (appendTrailingBlank)
sb.Append(coBLANK);
}
internal async Task PlayAt(SongViewModel songViewModel)
{
var list = await SQLOperator.Current().GetSongsAsync(Model.SongsID);
await MainPageViewModel.Current.InstantPlay(list, list.FindIndex(x => x.ID == songViewModel.ID));
}
public SQLCondition(string column, SQLOperator op, int value) : this(column, op)
{
Condition += value;
}
public SQLCondition(string column, SQLOperator op, string value, SQLConditionType conditionType = SQLConditionType.None) : this(column, op, conditionType)
{
Condition += "'" + value + "'";
}
public SQLCondition(string column, SQLOperator op, string value) : this(column, op)
{
Condition += "'" + value + "'";
}
public static async Task UpdateSongAsync(Song model)
{
var opr = SQLOperator.Current();
await opr.UpdateSongAsync(model);
}
public static async Task ReadFileandSave(IEnumerable <StorageFile> files)
{
var opr = SQLOperator.Current();
var total = files.Count();
int i = 1;
var newlist = new List <SONG>();
var durationFilter = Settings.Current.FileDurationFilterEnabled;
var duration = Convert.ToInt32(Settings.Current.FileDurationFilter);
var scan = Consts.Localizer.GetString("FileReadText");
var oneDriveFailed = false;
foreach (var file in files.OrderBy(f => f.Path))
{
try
{
if (!file.IsAvailable || file.Attributes.HasFlag(FileAttributes.LocallyIncomplete))
{
if (file.Provider.Id != "OneDrive" || oneDriveFailed || !Settings.Current.OnedriveRoaming)
{
continue;
}
try
{
var oneDriveFile = await OneDrivePropertyProvider.GetOneDriveFilesAsync(file.Path);
var properties = oneDriveFile.OneDriveItem;
var audioProp = properties.Audio;
if (durationFilter && audioProp.Duration < duration)
{
continue;
}
var artist = audioProp?.Artist is null ? null : new[] { audioProp.Artist };
var composers = audioProp?.Composers is null ? null : new[] { audioProp.Composers };
var song = await Song.Create(null, file.Path, (audioProp?.Title, audioProp?.Album, artist, artist, composers, null, TimeSpan.FromMilliseconds(audioProp?.Duration ?? 0), (uint)(audioProp?.Bitrate * 1000 ?? 0), 0), null, oneDriveFile);
var t = await opr.InsertSongAsync(song);
if (t != null)
{
newlist.Add(t);
}
}
catch
{
// Prevent another try by next file.
oneDriveFailed = true;
// Will be handled by outer catch block.
throw;
}
}
else
{
using (var tagTemp = File.Create(file.Path))
{
var prop = await file.Properties.GetMusicPropertiesAsync();
var d = prop.Duration.Milliseconds < 1 ? tagTemp.Properties.Duration : prop.Duration;
if (durationFilter && d.Milliseconds < duration)
{
continue;
}
var song = await Song.Create(tagTemp.Tag, file.Path, await file.GetViolatePropertiesAsync(), tagTemp.Properties, null);
var t = await opr.InsertSongAsync(song);
if (t != null)
{
newlist.Add(t);
}
}
}
}
catch (Exception e)
{
Shared.Helpers.Tools.Logging(e);
continue;
}
finally
{
ProgressUpdated?.Invoke(null, new ProgressReport()
{
Description = SmartFormat.Smart.Format(scan, i, total), Current = i, Total = total
});
i++;
}
}
await RemoveDuplicate();
await SortAlbums();
Completed?.Invoke(null, EventArgs.Empty);
}
internal async void ChangeSort(int selectedIndex)
{
SongsList.Clear();
var songs = await FileReader.GetAllSongAsync();
IEnumerable <GroupedItem <SongViewModel> > grouped;
switch (selectedIndex)
{
case 0:
grouped = GroupedItem <SongViewModel> .CreateGroupsByAlpha(songs.ConvertAll(x => new SongViewModel(x)));
Settings.Current.SongsSort = SortMode.Alphabet;
break;
case 1:
grouped = GroupedItem <SongViewModel> .CreateGroups(songs.ConvertAll(x => new SongViewModel(x)), x => x.FormattedAlbum);
Settings.Current.SongsSort = SortMode.Album;
break;
case 2:
grouped = GroupedItem <SongViewModel> .CreateGroups(songs.ConvertAll(x => new SongViewModel(x)), x => x.GetFormattedArtists());
Settings.Current.SongsSort = SortMode.Artist;
break;
case 3:
grouped = GroupedItem <SongViewModel> .CreateGroups(songs.ConvertAll(x => new SongViewModel(x)), x => x.Song.Year);
Settings.Current.SongsSort = SortMode.Year;
break;
default:
grouped = GroupedItem <SongViewModel> .CreateGroupsByAlpha(songs.ConvertAll(x => new SongViewModel(x)));
Settings.Current.SongsSort = SortMode.Alphabet;
break;
}
SortIndex = selectedIndex;
Settings.Current.Save();
foreach (var item in grouped)
{
item.Aggregate((x, y) =>
{
y.Index = x.Index + 1;
return(y);
});
SongsList.Add(item);
}
//foreach (var item in SongsList)
//{
// foreach (var song in item)
// {
// song.RefreshFav();
// }
//}
var favors = await SQLOperator.Current().GetFavoriteAsync();
foreach (var item in SongsList)
{
foreach (var song in item)
{
if (favors.Count == 0)
{
return;
}
if (favors.Contains(song.ID))
{
song.Favorite = true;
favors.Remove(song.ID);
}
}
}
}
private void appendColumnCondition(StringBuilder sb, string column, SQLOperator op)
{
appendFullColumnName(sb, column);
appendSqlOperator(sb, op);
appendParamter(sb, column);
}
private void appendColumnCondition(StringBuilder sb, string column, SQLOperator op, object value)
{
appendColumnCondition(sb, column, op, value, true);
}
public LibraryPage()
{
this.InitializeComponent();
Current = this;
MainPageViewModel.Current.Title = Consts.Localizer.GetString("LibraryText");
MainPageViewModel.Current.NeedShowTitle = true;
MainPageViewModel.Current.LeftTopColor = Resources["SystemControlForegroundBaseHighBrush"] as SolidColorBrush;
CategoryList = new ObservableCollection <CategoryListItem>()
{
new CategoryListItem
{
Title = Consts.Localizer.GetString("SongsText"),
HeroImages = new List <ImageSource>()
{
new BitmapImage(new Uri("ms-appx:///Assets/Images/songs.png"))
},
NavigatType = typeof(SongsPage)
},
new CategoryListItem
{
Title = Consts.Localizer.GetString("AlbumsText"),
HeroImages = new List <ImageSource>()
{
new BitmapImage(new Uri("ms-appx:///Assets/Images/albums.png"))
},
NavigatType = typeof(AlbumsPage)
},
new CategoryListItem
{
Title = Consts.Localizer.GetString("ArtistsText"),
HeroImages = new List <ImageSource>()
{
new BitmapImage(new Uri("ms-appx:///Assets/Images/artists.png"))
},
NavigatType = typeof(ArtistsPage)
}
};
Task.Run(async() =>
{
playlists = await SQLOperator.Current().GetPlayListBriefAsync();
await Dispatcher.RunAsync(CoreDispatcherPriority.High, () =>
{
foreach (var playlist in playlists)
{
CategoryList.Add(new CategoryListItem
{
Title = playlist.Title,
HeroImages = playlist.HeroArtworks == null ? null : Array.ConvertAll(playlist.HeroArtworks, x => (ImageSource) new BitmapImage(new Uri(x))).ToList(),
NavigatType = typeof(PlayListPage)
});
}
});
});
var item = CategoryList.FirstOrDefault(x => x.Title == Settings.Current.CategoryLastClicked);
if (item != default(CategoryListItem))
{
item.IsCurrent = true;
CategoryList.Remove(item);
CategoryList.Insert(0, item);
}
else
{
CategoryList[0].IsCurrent = true;
}
if (CategoryList[0].NavigatType == typeof(PlayListPage))
{
Navigate(CategoryList[0].NavigatType, playlists.Find(x => x.Title == (CategoryList[0].Title)));
}
else
{
Navigate(CategoryList[0].NavigatType);
}
if (Window.Current.Bounds.Width <= 640)
{
MainPageViewModel.Current.NeedShowTitle = false;
}
}
private void appendSqlOperator(StringBuilder sb, SQLOperator op)
{
appendSqlOperator(sb, op, true);
}
public async Task GetSongsAsync(AlbumViewModel a)
{
Album = a;
await a.GetSongsAsync();
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
SongList.Clear();
var songViewmodels = new List <SongViewModel>();
for (int i = 0; i < a.Songs.Count; i++)
{
songViewmodels.Add(new SongViewModel(a.Songs[i])
{
Index = (uint)i
});
}
var group = GroupedItem <SongViewModel> .CreateGroups(songViewmodels, s => s.Disc);
foreach (var item in group)
{
var ordered = item.OrderBy(s => s.Track).ToList();
item.Clear();
foreach (var o in ordered)
{
item.Add(o);
}
SongList.Add(item);
}
Task.Run(async() =>
{
var favors = await SQLOperator.Current().GetFavoriteAsync();
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
foreach (var disc in SongList)
{
foreach (var song in disc)
{
if (favors.Contains(song.ID))
{
if (favors.Count == 0)
{
return;
}
song.Favorite = true;
favors.Remove(song.ID);
}
}
}
});
});
});
AlbumInfo info = null;
try
{
if (Album.Name != null)
{
info = await MainPageViewModel.Current.GetAlbumInfoAsync(Album.Name, Album.AlbumArtists?.FirstOrDefault());
}
}
catch (Exception)
{
}
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
if (info != null)
{
if (Album.ArtworkUri == null && info.AltArtwork != null)
{
Album.ArtworkUri = info.AltArtwork;
var task = ThreadPool.RunAsync(async k =>
{
if (!Album.IsOnline)
{
await SQLOperator.Current().UpdateAlbumArtworkAsync(album.ID, info.AltArtwork.OriginalString);
}
});
}
Album.Description = info.Description;
}
else
{
Album.Description = $"# {Consts.Localizer.GetString("LocaAlbumTitle")}";
}
});
}
private string getSQLOperatorString(SQLOperator op)
{
string ret = String.Empty;
switch (op)
{
case SQLOperator.Equal:
ret = coEQUAL;
break;
case SQLOperator.NotEqual:
ret = coNOTEQUAL;
break;
case SQLOperator.Greater:
ret = coGREATER;
break;
case SQLOperator.GreaterEqual:
ret = coGREATEREQUAL;
break;
case SQLOperator.Lower:
ret = coLOWER;
break;
case SQLOperator.LowerEqual:
ret = coLOWEREQUAL;
break;
case SQLOperator.Like:
ret = coLIKE;
break;
default:
ret = coEQUAL;
break;
}
return ret;
}
public string buildCondition(string column, SQLOperator op)
{
StringBuilder sb = new StringBuilder();
appendColumnCondition(sb, column, op);
return sb.ToString();
}
public static async Task <Song> GetAsync(int songID)
{
return(new Song(await SQLOperator.Current().GetSongAsync(songID)));
}
public string buildOR(string column, SQLOperator op)
{
return this.buildOR(column, op, coQUESTIONMARK + column);
}
internal AlbumViewDialog(AlbumViewModel album)
{
InitializeComponent();
RequestedTheme = Settings.Current.Theme;
if (album == null)
{
Title = Consts.Localizer.GetString("OopsText");
IsPrimaryButtonEnabled = false;
Album.Text = Consts.Localizer.GetString("SearchFailedText");
Artist.Visibility = Visibility.Collapsed;
Brief.Visibility = Visibility.Collapsed;
Descriptions.Visibility = Visibility.Collapsed;
}
this.album = album;
if (!album.IsOnline)
{
SecondaryButtonText = string.Empty;
}
var songs = AsyncHelper.RunSync(async() => { return(await album.GetSongsAsync()); });
uint i = 0;
foreach (var item in songs)
{
SongList.Add(new SongViewModel(item)
{
Index = i++,
});
}
Task.Run(async() =>
{
var favors = await SQLOperator.Current().GetFavoriteAsync();
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
foreach (var song in SongList)
{
if (favors.Contains(song.ID))
{
if (favors.Count == 0)
{
return;
}
song.Favorite = true;
favors.Remove(song.ID);
}
}
});
});
Album.Text = album.Name;
Artwork.Source = new BitmapImage(album.ArtworkUri ?? new Uri(Consts.NowPlaceholder));
Artist.Text = album.GetFormattedArtists();
Brief.Text = album.GetBrief();
if (album.Description.IsNullorEmpty())
{
var t = ThreadPool.RunAsync(async x =>
{
var info = await MainPageViewModel.Current.GetAlbumInfoAsync(album.Name, album.AlbumArtists.FirstOrDefault());
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
if (info != null)
{
if (album.ArtworkUri == null && info.AltArtwork != null)
{
Artwork.Source = new BitmapImage(info.AltArtwork);
UpdateArtwork?.Invoke(this, info.AltArtwork);
var task = ThreadPool.RunAsync(async k =>
{
if (!album.IsOnline)
{
await SQLOperator.Current().UpdateAlbumArtworkAsync(album.ID, info.AltArtwork.OriginalString);
}
});
}
Descriptions.Text = info.Description;
}
else
{
Descriptions.Text = $"# {Consts.Localizer.GetString("LocaAlbumTitle")}";
}
});
});
}
else
{
Descriptions.Text = album.Description;
}
}
public string buildWHERE(string column, SQLOperator op)
{
return this.buildWHERE(column, op, coPARAMETER + column);
}
public SQLCondition(string column, SQLOperator op, int value, SQLConditionType conditionType = SQLConditionType.None) : this(column, op, conditionType)
{
Condition += value;
}
public static async Task <List <GenericMusicItem> > GetFavListAsync()
{
return(await SQLOperator.Current().GetFavListAsync());
}
