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()); }