public bool RemoveArtist(Artist input)
 {
     if (input != null)
     {
         if (Artists.Count != 0)
         {
             if (Artists.Contains(input))
             {
                 Artists.Remove(input);
                 return(true);
             }
             else
             {
                 return(false);
             }
         }
         else
         {
             return(false);
         }
     }
     else
     {
         throw new ArgumentNullException();
     }
 }
Exemple #2
0
        private void DeleteRelatedObjects(Track track)
        {
            var displaySameAsAlbumArtist = track.DisplayArtist.EqualsIgnoreCase(track.AlbumArtist);

            var albumArtist = Artists.FirstOrDefault(p =>
                                                     p.Name.EqualsIgnoreCase(track.AlbumArtist));

            if (albumArtist != null)
            {
                albumArtist.Tracks.Remove(track);
                if (albumArtist.Tracks.Count == 0 && albumArtist.TracksThatAppearsIn.Count == 0)
                {
                    Artists.Remove(albumArtist);
                }
            }

            DeleteAlbum(track, albumArtist);

            if (!displaySameAsAlbumArtist)
            {
                DeleteDisplayArtist(track);
            }

            DeleteSecondaryArtists(track);
        }
Exemple #3
0
        public async Task RemoveMediaFromCollectionAndDatabase(IMediaItem media)
        {
            if (media is TrackItem)
            {
                var trackItem = media as TrackItem;
                var trackDB   = LoadTrackById(trackItem.Id);
                if (trackDB == null)
                {
                    return;
                }
                musicDatabase.Remove(trackDB);

                var albumDB = LoadAlbum(trackItem.AlbumId);
                if (albumDB == null)
                {
                    return;
                }
                var albumTracks = LoadTracksByAlbumId(albumDB.Id);
                if (!albumTracks.Any())
                {
                    Albums.Remove(Albums.FirstOrDefault(x => x.Id == trackItem.AlbumId));
                    musicDatabase.Remove(albumDB);
                }

                var artistDB = LoadArtist(trackItem.ArtistId);
                if (artistDB == null)
                {
                    return;
                }
                var artistAlbums = LoadAlbums(artistDB.Id);
                if (!artistAlbums.Any())
                {
                    Artists.Remove(Artists.FirstOrDefault(x => x.Id == trackItem.ArtistId));
                    musicDatabase.Remove(artistDB);
                }

                await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
                {
                    Tracks.Remove(Tracks.FirstOrDefault(x => x.Path == trackItem.Path));

                    var playingTrack = Locator.MediaPlaybackViewModel.PlaybackService.Playlist.FirstOrDefault(x => x.Id == trackItem.Id);
                    if (playingTrack != null)
                    {
                        Locator.MediaPlaybackViewModel.PlaybackService.Playlist.Remove(playingTrack);
                    }
                });
            }
            else if (media is VideoItem)
            {
                var videoItem = media as VideoItem;
                var videoDb   = LoadVideoById(videoItem.Id);
                if (videoDb == null)
                {
                    return;
                }
                videoDatabase.Remove(videoDb);

                Videos.Remove(Videos.FirstOrDefault(x => x.Path == videoItem.Path));
            }
        }
 public void DeleteObject(object entity)
 {
     if (entity is Genre)
     {
         Genres.Remove((Genre)entity);
     }
     if (entity is Artist)
     {
         Artists.Remove((Artist)entity);
     }
     if (entity is Album)
     {
         Albums.Remove((Album)entity);
     }
     if (entity is Cart)
     {
         Carts.Remove((Cart)entity);
     }
     if (entity is Order)
     {
         Orders.Remove((Order)entity);
     }
     if (entity is OrderDetail)
     {
         OrderDetails.Remove((OrderDetail)entity);
     }
 }
Exemple #5
0
        private void CheckForDeleted(ListBox lbSongsView, TreeView artistView, TreeView albumView)
        {
            var artists = new Dictionary <string, Artist>(Artists);

            foreach (var artist in artists)
            {
                if (artist.Value.Albums.Count == 0)
                {
                    Artists.Remove(artist.Key);
                }
                else
                {
                    var albums = new Dictionary <string, Album>(artist.Value.Albums);
                    foreach (var album in albums)
                    {
                        if (album.Value.Songs.Count != 0)
                        {
                            continue;
                        }
                        artist.Value.Albums.Remove(album.Key);
                        CheckForDeleted(lbSongsView, artistView, albumView);
                    }
                }
            }

            lbSongsView.Items.Clear();
            artistView.Nodes.Clear();
            albumView.Nodes.Clear();
            ShowAlbumsOnTreeView(albumView);
            ShowArtistsOnTreeView(artistView);
            ShowSongsOnControl(lbSongsView);
        }
        public async Task DeleteSongAsync(Song song)
        {
            // remove it from artist and albums songs
            var artist = Artists.FirstOrDefault(p => p.Songs.Contains(song));
            var album  = Albums.FirstOrDefault(p => p.Songs.Contains(song));

            if (album != null)
            {
                album.Songs.Remove(song);
                if (album.Songs.Count == 0)
                {
                    await _sqlService.DeleteItemAsync(album);

                    Albums.Remove(album);
                }
            }

            if (artist != null)
            {
                artist.Songs.Remove(song);
                if (artist.Songs.Count == 0)
                {
                    await _sqlService.DeleteItemAsync(artist);

                    Artists.Remove(artist);
                }
            }

            //good, now lets delete it from the db
            await _sqlService.DeleteItemAsync(song);

            Songs.Remove(song);
        }
Exemple #7
0
        public void DeleteSongArtist(int id)
        {
            var artist = Artists.SingleOrDefault(x => x.Id == id);

            if (artist != null)
            {
                Artists.Remove(artist);
            }
            this.SaveChanges();
        }
Exemple #8
0
        private void DeleteDisplayArtist(Track track)
        {
            var displayArtist = Artists.FirstOrDefault(p =>
                                                       p.Name.EqualsIgnoreCase(track.DisplayArtist));

            displayArtist.Tracks.Remove(track);
            if (displayArtist.TracksThatAppearsIn.Count == 0 && displayArtist.Tracks.Count == 0)
            {
                Artists.Remove(displayArtist);
            }
        }
Exemple #9
0
 public LikedArtistsViewModel()
 {
     DeleteCommand = new RelayCommand <LikedArtist>(async(artist) =>
     {
         try
         {
             await LikedArtistsService.RemoveArtist(artist.Id);
             var msg = new MessageDialog($"Исполнитель {artist.Name} больше не находится в Ваших любимчиках!");
             Artists.Remove(SelectArtist);
             Changed("Artists");
         }catch (Exception e)
         {
             await ContentDialogService.Show(new ExceptionDialog("Невозможно удалить артиста", "Пока что нет возможности удалить, но скоро все будет хорооооошо :)", e));
         }
     });
 }
Exemple #10
0
        private void DeleteSecondaryArtists(Track track)
        {
            var artistAppearing = track.Artists.Split(';').Select(p => p.Trim());

            foreach (var artist in artistAppearing
                     .Where(p => !p.EqualsIgnoreCase(track.DisplayArtist) &&
                            !p.EqualsIgnoreCase(track.AlbumArtist)).Select(artistName => Artists.First(p =>
                                                                                                       p.Name.EqualsIgnoreCase(artistName))))
            {
                artist.TracksThatAppearsIn.Remove(track);

                if (artist.TracksThatAppearsIn.Count == 0 && artist.Tracks.Count == 0)
                {
                    Artists.Remove(artist);
                }
            }
        }
        private async void BtnDelete_Click(object sender, RoutedEventArgs e)
        {
            var artist = (Artist)((FrameworkElement)sender).DataContext;

            var ret = (bool)await DialogHost.Show(new ConfirmDialog("Remove Artist " + artist.Name + "?"));

            if (ret == true)
            {
                if (DatabaseOperations.DeleteArtist(artist) > 0)
                {
                    Artists.Remove(artist);
                    ToggleVisibility();
                }
                else
                {
                    await DialogHost.Show(new ErrorDialog("The artist has not been removed!"));
                }
            }
        }
Exemple #12
0
        public void RemoveSelectedSongs(TreeView tvArtistsView, ListBox lbSongsView, TreeView albumView)
        {
            var remove = tvArtistsView.SelectedNode;

            switch (remove.Level)
            {
            case 0:
            {
                var artist = (Artist)remove.Tag;
                Artists.Remove(artist.Name);
            }
            break;

            case 1:
            {
                var album  = (Album)remove.Tag;
                var artist = (Artist)remove.Parent.Tag;
                Artists[artist.Name].Albums.Remove(album.Name);
            }
            break;

            case 2:
            {
                var song = (Song)remove.Tag;
                for (var i = 0; i < lbSongsView.Items.Count; i++)
                {
                    lbSongsView.SetSelected(i, false);
                    if (lbSongsView.Items[i] == song)
                    {
                        lbSongsView.SetSelected(i, true);
                    }
                }
                RemoveSelectedSongs(lbSongsView, tvArtistsView, albumView);
            }
            break;

            default:
                return;
            }

            CheckForDeleted(lbSongsView, tvArtistsView, albumView);
        }
        public DeletionResult DeleteSong(Song song, RealObservableCollection <GroupInfoList <Artist> > artistsList,
                                         RealObservableCollection <GroupInfoList <Album> > albumsList,
                                         RealObservableCollection <GroupInfoList <Song> > songsList)
        {
            GroupInfoList <Song> songList = MusicLibrary.GetItemGroup(songsList, song, a => a.SongTitle[0]);

            List <Song> songs;

            if (Songs.TryGetValue(song.Artist.ToLower() + "--" + song.Album.ToLower(), out songs))
            {
                songList.Remove(song);
                songs.Remove(song);
            }
            songs = GetSongs(song.Artist, song.Album);
            if (songs.Count == 0)
            {
                Songs.Remove(song.Artist.ToLower() + "--" + song.Album.ToLower());
                List <Album> albums;
                if (Albums.TryGetValue(song.Artist.ToLower(), out albums))
                {
                    Album album = albums.FirstOrDefault((a) => a.AlbumName == song.Album);
                    albums.Remove(album);
                    if (albums.Count == 0)
                    {
                        GroupInfoList <Album> albumList = MusicLibrary.GetItemGroup(albumsList, album, aa => aa.AlbumName[0]);
                        Albums.Remove(song.Artist.ToLower());
                        albumList.Remove(album);

                        Artist artist = Artists[song.Artist.ToLower()];

                        GroupInfoList <Artist> artistList = MusicLibrary.GetItemGroup(artistsList, artist, a => a.ArtistName[0]);
                        Artists.Remove(song.Artist.ToLower());
                        artistList.Remove(artist);
                        return(DeletionResult.Artist);
                    }
                    return(DeletionResult.Album);
                }
            }
            return(DeletionResult.Song);
        }
        public async Task AddSongAsync(Song song, Tag tags = null)
        {
            var primaryArtist = (song.Album == null ? song.Artist : song.Album.PrimaryArtist)
                                ?? new Artist {
                Name = "Unknown Artist", ProviderId = "autc.unknown"
            };
            var artist =
                _inProgressArtists.Union(Artists).FirstOrDefault(
                    entry =>
                    entry.ProviderId == primaryArtist.ProviderId ||
                    string.Equals(entry.Name, primaryArtist.Name, StringComparison.CurrentCultureIgnoreCase));

            if (artist == null)
            {
                await _sqlService.InsertAsync(primaryArtist);

                _inProgressArtists.Add(primaryArtist);

                song.Artist   = primaryArtist;
                song.ArtistId = primaryArtist.Id;

                if (song.Album != null)
                {
                    song.Album.PrimaryArtistId = song.Artist.Id;
                    song.Album.PrimaryArtist   = song.Artist;
                }
            }
            else
            {
                song.Artist = artist;

                if (song.Album != null)
                {
                    song.Album.PrimaryArtistId = artist.Id;
                    song.Album.PrimaryArtist   = artist;
                }
            }

            song.ArtistId = song.Artist.Id;

            if (song.Album == null)
            {
                song.Album = new Album
                {
                    PrimaryArtistId = song.ArtistId,
                    Name            = song.Name,
                    PrimaryArtist   = song.Artist,
                    ProviderId      = "autc.single." + song.ProviderId
                };
            }

            var album = _inProgressAlbums.Union(Albums).FirstOrDefault(p => p.ProviderId == song.Album.ProviderId);

            if (album != null)
            {
                song.Album = album;
            }
            else
            {
                await _sqlService.InsertAsync(song.Album);

                _inProgressAlbums.Add(song.Album);
                await _dispatcher.RunAsync(() =>
                {
                    var artwork = song.Artist.HasArtwork
                                    ? song.Artist.Artwork
                                    : _missingArtwork;
                    song.Album.Artwork       = artwork;
                    song.Album.MediumArtwork = artwork;
                    song.Album.SmallArtwork  = artwork;
                });

                if (tags != null && tags.Pictures != null && tags.Pictures.Length > 0)
                {
                    var    albumFilePath = string.Format(_artworkFilePath, song.Album.Id);
                    Stream artwork       = null;

                    var image = tags.Pictures.FirstOrDefault();
                    if (image != null)
                    {
                        artwork = new MemoryStream(image.Data.Data);
                    }

                    if (artwork != null)
                    {
                        using (artwork)
                        {
                            try
                            {
                                var file =
                                    await
                                    StorageHelper.CreateFileAsync(
                                        albumFilePath,
                                        option : CreationCollisionOption.ReplaceExisting);

                                using (var fileStream = await file.OpenAsync(FileAccess.ReadAndWrite))
                                {
                                    var bytes = tags.Pictures[0].Data.Data;
                                    await fileStream.WriteAsync(bytes, 0, bytes.Length);

                                    song.Album.HasArtwork = true;
                                    await _sqlService.UpdateItemAsync(song.Album);
                                }
                            }
                            catch
                            {
                                // ignored
                            }
                        }
                    }

                    // set it
                    if (song.Album.HasArtwork)
                    {
                        await _dispatcher.RunAsync(
                            () =>
                        {
                            var path = _localFilePrefix + albumFilePath;

                            song.Album.Artwork = _bitmapFactory.CreateImage(new Uri(path));

                            if (ScaledImageSize == 0)
                            {
                                return;
                            }

                            song.Album.Artwork.SetDecodedPixel(ScaledImageSize);

                            song.Album.MediumArtwork = _bitmapFactory.CreateImage(new Uri(path));
                            song.Album.MediumArtwork.SetDecodedPixel(ScaledImageSize / 2);

                            song.Album.SmallArtwork = _bitmapFactory.CreateImage(new Uri(path));
                            song.Album.SmallArtwork.SetDecodedPixel(50);
                        });
                    }
                }
            }

            song.AlbumId = song.Album.Id;

            if (string.IsNullOrEmpty(song.ArtistName))
            {
                song.ArtistName = song.Artist.Name;
            }

            await _sqlService.InsertAsync(song);

            await _dispatcher.RunAsync(
                () =>
            {
                if (!song.IsTemp)
                {
                    var orderedAlbumSong = song.Album.Songs.ToList();
                    orderedAlbumSong.Add(song);
                    orderedAlbumSong = orderedAlbumSong.OrderBy(p => p.TrackNumber).ToList();

                    var index = orderedAlbumSong.IndexOf(song);
                    song.Album.Songs.Insert(index, song);


                    var orderedArtistSong = song.Artist.Songs.ToList();
                    orderedArtistSong.Add(song);
                    orderedArtistSong = orderedArtistSong.OrderBy(p => p.Name).ToList();

                    index = orderedArtistSong.IndexOf(song);
                    song.Artist.Songs.Insert(index, song);

                    #region Order artist album

                    if (!song.Artist.Albums.Contains(song.Album))
                    {
                        var orderedArtistAlbum = song.Artist.Albums.ToList();
                        orderedArtistAlbum.Add(song.Album);
                        orderedArtistAlbum = orderedArtistAlbum.OrderBy(p => p.Name).ToList();

                        index = orderedArtistAlbum.IndexOf(song.Album);
                        song.Artist.Albums.Insert(index, song.Album);
                    }

                    #endregion
                }

                _inProgressAlbums.Remove(song.Album);
                _inProgressArtists.Remove(song.Artist);

                if (!Albums.Contains(song.Album))
                {
                    Albums.Add(song.Album);
                }
                else if (song.Album.Songs.Count == 1)
                {
                    // This means the album was added with a temp song
                    // Have to remove and readd it to get it to show up
                    Albums.Remove(song.Album);
                    Albums.Add(song.Album);
                }

                if (!Artists.Contains(song.Artist))
                {
                    Artists.Add(song.Artist);
                }
                else if (song.Artist.Songs.Count == 1)
                {
                    // This means the album was added with a temp song
                    // Have to remove and readd it to get it to show up
                    Artists.Remove(song.Artist);
                    Artists.Add(song.Artist);
                }

                Songs.Add(song);
            });
        }
        public async Task DeleteSongAsync(Song song)
        {
            var queueSong = PlaybackQueue.FirstOrDefault(p => p.SongId == song.Id);

            if (queueSong != null)
            {
                await DeleteFromQueueAsync(queueSong);
            }

            // remove it from artist, albums and playlists songs
            var playlists = Playlists.Where(p => p.Songs.Count(pp => pp.SongId == song.Id) > 0).ToList();

            foreach (var playlist in playlists)
            {
                var songs = playlist.Songs.Where(p => p.SongId == song.Id).ToList();
                foreach (var playlistSong in songs)
                {
                    await DeleteFromPlaylistAsync(playlist, playlistSong);
                }

                if (playlist.Songs.Count == 0)
                {
                    await DeletePlaylistAsync(playlist);
                }
            }

            if (song.Album != null)
            {
                song.Album.Songs.Remove(song);

                // If the album is empty, make sure that is not being used by any temp song
                if (song.Album.Songs.Count == 0 && Songs.Count(p => p.AlbumId == song.AlbumId) < 2)
                {
                    await _sqlService.DeleteItemAsync(song.Album);

                    await _dispatcher.RunAsync(
                        () =>
                    {
                        Albums.Remove(song.Album);
                        if (song.Artist != null)
                        {
                            song.Artist.Albums.Remove(song.Album);
                        }
                    });
                }
            }

            if (song.Artist != null)
            {
                song.Artist.Songs.Remove(song);
                if (song.Artist.Songs.Count == 0 && Songs.Count(p => p.ArtistId == song.ArtistId) < 2)
                {
                    await _sqlService.DeleteItemAsync(song.Artist);

                    await _dispatcher.RunAsync(
                        () => { Artists.Remove(song.Artist); });
                }
            }

            // good, now lets delete it from the db
            await _sqlService.DeleteItemAsync(song);

            await _dispatcher.RunAsync(() => Songs.Remove(song));
        }