Пример #1
0
        /// <summary>
        /// Duplicate the SongPlaylist in the specified library
        /// </summary>
        /// <param name="playlistToDuplicate"></param>
        /// <returns></returns>
        private static async void DuplicateSongPlaylistAsync(SongPlaylist playlistToDuplicate, int libraryId)
        {
            // Attempt to find matching songs for each SongPlaylistItem in the SongPlaylist
            // Need to access the songs via the Sources associated with the Library
            List <Source> sources = Sources.GetSourcesForLibrary(libraryId);

            // Keep track of the matching songs
            List <Song> songsToAdd = new();

            foreach (SongPlaylistItem item in playlistToDuplicate.PlaylistItems)
            {
                Song matchingSong = null;
                int  sourceIndex  = 0;

                while ((matchingSong == null) && (sourceIndex < sources.Count))
                {
                    // Get a list of all the songs with matching Titles in the source
                    List <Song> matchingTitles = Songs.GetSourceSongsWithName(sources[sourceIndex++].Id, item.Song.Title);

                    // Now for each song access the associated artist
                    int titleIndex = 0;
                    while ((matchingSong == null) && (titleIndex < matchingTitles.Count))
                    {
                        Artist nameCheck = Artists.GetArtistById(ArtistAlbums.GetArtistAlbumById(matchingTitles[titleIndex].ArtistAlbumId).ArtistId);

                        // Correct name?
                        if (nameCheck.Name == item.Artist.Name)
                        {
                            matchingSong = matchingTitles[titleIndex];
                            songsToAdd.Add(matchingSong);

                            // Make sure that the Artist is stored with the song
                            matchingSong.Artist = nameCheck;
                        }

                        titleIndex++;
                    }
                }
            }

            // Only create the playlist if at least one of the songs was found
            if (songsToAdd.Count > 0)
            {
                SongPlaylist duplicatedPlaylist = new() { Name = playlistToDuplicate.Name, LibraryId = libraryId };

                // Wait for the playlist to be added as we're going to use its id
                await Playlists.AddPlaylistAsync(duplicatedPlaylist);

                // Add the songs to the new SongPlaylist.
                duplicatedPlaylist.AddSongs(songsToAdd);
            }
        }
Пример #2
0
 /// <summary>
 /// Clear the data held by this model
 /// </summary>
 public static void ClearModel()
 {
     Artists.Clear();
     UnfilteredArtists.Clear();
     ArtistsAndAlbums.Clear();
     LibraryId = -1;
     FilterSelector.CurrentFilter = null;
     FilteredAlbumsIds.Clear();
     BaseModel.SortSelector.SetActiveSortOrder(SortSelector.SortType.alphabetic);               // This also sets the sort order to alphabetic ascending
     FastScrollSections      = null;
     FastScrollSectionLookup = null;
     BaseModel.Clear();
 }
Пример #3
0
        /// <summary>
        /// Get the PlaylistItems and associated songs for this playlist
        /// </summary>
        /// <param name="playlistItems"></param>
        public void GetContents(IEnumerable <SongPlaylistItem> playlistItems)
        {
            // Get all the SongPlaylistItem entries associated with this SongPlaylist and then the Song entries for each of them
            PlaylistItems.AddRange(playlistItems.Where(item => item.PlaylistId == Id));

            foreach (SongPlaylistItem playlistItem in PlaylistItems)
            {
                playlistItem.Song        = Songs.GetSongById(playlistItem.SongId);
                playlistItem.Artist      = Artists.GetArtistById(ArtistAlbums.GetArtistAlbumById(playlistItem.Song.ArtistAlbumId).ArtistId);
                playlistItem.Song.Artist = playlistItem.Artist;
            }

            PlaylistItems.Sort((a, b) => a.Index.CompareTo(b.Index));
        }
Пример #4
0
        /// <summary>
        /// Categorise the specified selected objects
        /// </summary>
        /// <param name="selectedObjects"></param>
        public GroupedSelection(IEnumerable <object> selectedObjects)
        {
            // Save the unprocessed objects.
            SelectedObjects = selectedObjects;

            // Group the objects into sets of Song, PlaylistItem, IPlaylist, Artist, ArtistAlbum, Album and Genre (string) items
            foreach (object selectedObject in selectedObjects)
            {
                if (selectedObject is Song song)
                {
                    Songs.Add(song);
                }
                else if (selectedObject is PlaylistItem playlistItem)
                {
                    PlaylistItems.Add(playlistItem);
                }
                else if (selectedObject is Playlist playlist)
                {
                    Playlists.Add(playlist);
                }
                else if (selectedObject is Artist artist)
                {
                    Artists.Add(artist);
                }
                else if (selectedObject is ArtistAlbum artistAlbum)
                {
                    ArtistAlbums.Add(artistAlbum);
                }
                else if (selectedObject is Album album)
                {
                    Albums.Add(album);
                }
                else if (selectedObject is string str)
                {
                    Genres.Add(str);
                }
            }

            // Determine if there is a parent playlist
            if (PlaylistItems.Count > 0)
            {
                ParentPlaylist = DBTest.Playlists.GetParentPlaylist(PlaylistItems[0]);
            }
        }
        /// <summary>
        /// Clear the contents of the specified library
        /// </summary>
        /// <param name="libraryToClear"></param>
        /// <returns></returns>
        public static void ClearLibrary(Library libraryToClear)
        {
            int libId = libraryToClear.Id;

            // Delete all the artists in the library and their associated ArtistAlbum entries
            List <Artist> artists = Artists.ArtistCollection.Where(art => art.LibraryId == libId).ToList();

            Artists.DeleteArtists(artists);

            ArtistAlbums.DeleteArtistAlbums(
                ArtistAlbums.ArtistAlbumCollection.Where(artAlb => artists.Any(art => art.Id == artAlb.ArtistId)).Distinct().ToList());

            // Delete all the albums in the library and any tags associated with them
            List <Album> albums = Albums.AlbumCollection.Where(alb => alb.LibraryId == libId).ToList();

            Albums.DeleteAlbums(albums);

            // We can use the FilterManagementController to carry out the Tag deletions.
            new AlbumsDeletedMessage()
            {
                DeletedAlbumIds = albums.Select(alb => alb.Id).ToList()
            }.Send();

            // Delete all the user playlists and thier contents
            Playlists.GetPlaylistsForLibrary(libId).ForEach(play => Playlists.DeletePlaylist(play));

            // Delete the contents of the NowPlayingList but keep the playlist itself
            Playlist nowPlaying = Playlists.GetNowPlayingPlaylist(libId);

            nowPlaying.Clear();
            nowPlaying.SongIndex = -1;

            // Delete all the songs in each of the sources associated with the library
            List <Source> sources = Sources.GetSourcesForLibrary(libId);

            foreach (Source source in sources)
            {
                Songs.DeleteSongs(Songs.GetSourceSongs(source.Id));
                source.Songs = null;
            }
        }
Пример #6
0
        /// <summary>
        /// Get an existing Artist or create a new one.
        /// </summary>
        /// <param name="artistName"></param>
        /// <returns></returns>
        private async Task <Artist> GetArtistToHoldSongsAsync(string artistName)
        {
            // Find the Artist for this song. The 'scanLibrary' can be used for this search as it is already fully populated with the
            // artists
            Artist songArtist = artistsInLibrary.GetValueOrDefault(artistName.ToUpper());

            Logger.Log(string.Format("Artist: {0} {1}", artistName, (songArtist != null) ? "found" : "not found creating in db"));

            if (songArtist == null)
            {
                // Create a new Artist and add it to the database
                songArtist = new Artist()
                {
                    Name = artistName, ArtistAlbums = new List <ArtistAlbum>(), LibraryId = scanLibrary
                };
                await Artists.AddArtistAsync(songArtist);

                // Add it to the collection for this library only
                artistsInLibrary[songArtist.Name.ToUpper()] = songArtist;
            }

            return(songArtist);
        }
Пример #7
0
        /// <summary>
        /// Called to determine whether a song that has been scanned requires adding to the library, or just an existing entry updated
        /// </summary>
        /// <param name="song"></param>
        /// <returns></returns>
        private async Task <bool> DoesSongRequireAdding(ScannedSong song)
        {
            bool needsAdding = true;

            // Lookup the path of this song in the dictionary
            if ((songLookup.TryGetValue(song.SourcePath, out Song matchedSong) == true) && (matchedSong.ScanAction == Song.ScanActionType.Differ))
            {
                // The library is about to be changed in some way so set the modified flag
                LibraryModified = true;

                // Need to check whether the matched Artist or Album names have changed. If they have then treat this as a new song and mark
                // the matched song for deletion
                ArtistAlbum matchedArtistAlbum = ArtistAlbums.GetArtistAlbumById(matchedSong.ArtistAlbumId);
                Artist      matchedArtist      = Artists.GetArtistById(matchedArtistAlbum.ArtistId);

                // If the artist or album name has changed then treat this as a new song. Otherwise update the existing song in the library
                if ((matchedArtist.Name.ToUpper() != song.ArtistName.ToUpper()) || (matchedArtistAlbum.Name.ToUpper() != song.Tags.Album.ToUpper()))
                {
                    // The existing song needs to be deleted now.
                    // If the song is not deleted then there will be more than one associated with the same storage location.
                    // This is much less complicated than trying to move the existing song to a new Artist or Album
                    // If an Artist has been deleted due to this song deletion then remove it from the dictionary being used here
                    Artist deletedArtist = LibraryScanController.DeleteSong(matchedSong);
                    if (deletedArtist != null)
                    {
                        artistsInLibrary.Remove(deletedArtist.Name.ToUpper());
                    }

                    matchedSong.ScanAction = Song.ScanActionType.Matched;
                }
                else
                {
                    // No need to add a new song, update the existing one
                    needsAdding = false;

                    matchedSong.Length       = song.Length;
                    matchedSong.ModifiedTime = song.Modified;
                    matchedSong.Title        = song.Tags.Title;
                    matchedSong.Track        = song.Track;
                    await ConnectionDetailsModel.AsynchConnection.UpdateAsync(matchedSong);

                    // Check if the year or genre fields on the album needs updating
                    // Don't update the Album if it is a 'various artists' album as the these fields is not applicable
                    Album matchedAlbum = Albums.GetAlbumById(matchedArtistAlbum.AlbumId);

                    if (matchedAlbum.ArtistName != SongStorage.VariousArtistsString)
                    {
                        // Update the stored year if it is different to the artist year and the artist year is defined.
                        // Log when a valid year is overwritten by different year
                        if (matchedAlbum.Year != song.Year)
                        {
                            if (song.Year != 0)
                            {
                                matchedAlbum.Year = song.Year;
                                await ConnectionDetailsModel.AsynchConnection.UpdateAsync(matchedAlbum);
                            }
                        }

                        if (song.Tags.Genre.Length > 0)
                        {
                            // If this album does not already have a genre, or the genre has been changed then set it now
                            if ((matchedAlbum.Genre == null) || (matchedAlbum.Genre != song.Tags.Genre))
                            {
                                matchedAlbum.Genre = song.Tags.Genre;
                                await ConnectionDetailsModel.AsynchConnection.UpdateAsync(matchedAlbum);
                            }
                        }
                    }
                }
            }

            return(needsAdding);
        }