Add GPL modules

2 files changed, 374 insertions, 0 deletions

diff --git a/MediaBrowser.Controller/Playlists/IPlaylistManager.cs b/MediaBrowser.Controller/Playlists/IPlaylistManager.cs
new file mode 100644
index 0000000000..5e790111d9
--- /dev/null
+++ b/MediaBrowser.Controller/Playlists/IPlaylistManager.cs
@@ -0,0 +1,59 @@
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Model.Playlists;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using System;
+
+
+namespace MediaBrowser.Controller.Playlists
+{
+    public interface IPlaylistManager
+    {
+        /// <summary>
+        /// Gets the playlists.
+        /// </summary>
+        /// <param name="userId">The user identifier.</param>
+        /// <returns>IEnumerable&lt;Playlist&gt;.</returns>
+        IEnumerable<Playlist> GetPlaylists(Guid userId);
+
+        /// <summary>
+        /// Creates the playlist.
+        /// </summary>
+        /// <param name="options">The options.</param>
+        /// <returns>Task&lt;Playlist&gt;.</returns>
+        Task<PlaylistCreationResult> CreatePlaylist(PlaylistCreationRequest options);
+
+        /// <summary>
+        /// Adds to playlist.
+        /// </summary>
+        /// <param name="playlistId">The playlist identifier.</param>
+        /// <param name="itemIds">The item ids.</param>
+        /// <param name="userId">The user identifier.</param>
+        /// <returns>Task.</returns>
+        void AddToPlaylist(string playlistId, IEnumerable<Guid> itemIds, Guid userId);
+
+        /// <summary>
+        /// Removes from playlist.
+        /// </summary>
+        /// <param name="playlistId">The playlist identifier.</param>
+        /// <param name="entryIds">The entry ids.</param>
+        /// <returns>Task.</returns>
+        void RemoveFromPlaylist(string playlistId, IEnumerable<string> entryIds);
+
+        /// <summary>
+        /// Gets the playlists folder.
+        /// </summary>
+        /// <param name="userId">The user identifier.</param>
+        /// <returns>Folder.</returns>
+        Folder GetPlaylistsFolder(Guid userId);
+
+        /// <summary>
+        /// Moves the item.
+        /// </summary>
+        /// <param name="playlistId">The playlist identifier.</param>
+        /// <param name="entryId">The entry identifier.</param>
+        /// <param name="newIndex">The new index.</param>
+        /// <returns>Task.</returns>
+        void MoveItem(string playlistId, string entryId, int newIndex);
+    }
+}
diff --git a/MediaBrowser.Controller/Playlists/Playlist.cs b/MediaBrowser.Controller/Playlists/Playlist.cs
new file mode 100644
index 0000000000..78614340ad
--- /dev/null
+++ b/MediaBrowser.Controller/Playlists/Playlist.cs
@@ -0,0 +1,315 @@
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Querying;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using MediaBrowser.Model.Serialization;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Providers;
+using System.Threading;
+
+namespace MediaBrowser.Controller.Playlists
+{
+    public class Playlist : Folder, IHasShares
+    {
+        public static string[] SupportedExtensions = new string[] {
+
+            ".m3u",
+            ".m3u8",
+            ".pls",
+            ".wpl",
+            ".zpl"
+        };
+
+        public Guid OwnerUserId { get; set; }
+
+        public Share[] Shares { get; set; }
+
+        public Playlist()
+        {
+            Shares = new Share[] { };
+        }
+
+        [IgnoreDataMember]
+        public bool IsFile
+        {
+            get
+            {
+                return IsPlaylistFile(Path);
+            }
+        }
+
+        public static bool IsPlaylistFile(string path)
+        {
+            return System.IO.Path.HasExtension(path);
+        }
+
+        [IgnoreDataMember]
+        public override string ContainingFolderPath
+        {
+            get
+            {
+                var path = Path;
+
+                if (IsPlaylistFile(path))
+                {
+                    return FileSystem.GetDirectoryName(path);
+                }
+
+                return path;
+            }
+        }
+
+        [IgnoreDataMember]
+        protected override bool FilterLinkedChildrenPerUser
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        [IgnoreDataMember]
+        public override bool SupportsInheritedParentImages
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        [IgnoreDataMember]
+        public override bool SupportsPlayedStatus
+        {
+            get
+            {
+                return string.Equals(MediaType, "Video", StringComparison.OrdinalIgnoreCase);
+            }
+        }
+
+        [IgnoreDataMember]
+        public override bool AlwaysScanInternalMetadataPath
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        [IgnoreDataMember]
+        public override bool SupportsCumulativeRunTimeTicks
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public override double GetDefaultPrimaryImageAspectRatio()
+        {
+            return 1;
+        }
+
+        public override bool IsAuthorizedToDelete(User user, List<Folder> allCollectionFolders)
+        {
+            return true;
+        }
+
+        public override bool IsSaveLocalMetadataEnabled()
+        {
+            return true;
+        }
+
+        protected override List<BaseItem> LoadChildren()
+        {
+            // Save a trip to the database
+            return new List<BaseItem>();
+        }
+
+        protected override Task ValidateChildrenInternal(IProgress<double> progress, CancellationToken cancellationToken, bool recursive, bool refreshChildMetadata, MetadataRefreshOptions refreshOptions, IDirectoryService directoryService)
+        {
+            return Task.FromResult(true);
+        }
+
+        public override List<BaseItem> GetChildren(User user, bool includeLinkedChildren, InternalItemsQuery query)
+        {
+            return GetPlayableItems(user, query);
+        }
+
+        protected override IEnumerable<BaseItem> GetNonCachedChildren(IDirectoryService directoryService)
+        {
+            return new List<BaseItem>();
+        }
+
+        public override IEnumerable<BaseItem> GetRecursiveChildren(User user, InternalItemsQuery query)
+        {
+            return GetPlayableItems(user, query);
+        }
+
+        public IEnumerable<Tuple<LinkedChild, BaseItem>> GetManageableItems()
+        {
+            return GetLinkedChildrenInfos();
+        }
+
+        private List<BaseItem> GetPlayableItems(User user, InternalItemsQuery query)
+        {
+            if (query == null)
+            {
+                query = new InternalItemsQuery(user);
+            }
+
+            query.IsFolder = false;
+
+            return base.GetChildren(user, true, query);
+        }
+
+        public static List<BaseItem> GetPlaylistItems(string playlistMediaType, IEnumerable<BaseItem> inputItems, User user, DtoOptions options)
+        {
+            if (user != null)
+            {
+                inputItems = inputItems.Where(i => i.IsVisible(user));
+            }
+
+            var list = new List<BaseItem>();
+
+            foreach (var item in inputItems)
+            {
+                var playlistItems = GetPlaylistItems(item, user, playlistMediaType, options);
+                list.AddRange(playlistItems);
+            }
+
+            return list;
+        }
+
+        private static IEnumerable<BaseItem> GetPlaylistItems(BaseItem item, User user, string mediaType, DtoOptions options)
+        {
+            var musicGenre = item as MusicGenre;
+            if (musicGenre != null)
+            {
+                return LibraryManager.GetItemList(new InternalItemsQuery(user)
+                {
+                    Recursive = true,
+                    IncludeItemTypes = new[] { typeof(Audio).Name },
+                    GenreIds = new[] { musicGenre.Id },
+                    OrderBy = new[] { ItemSortBy.AlbumArtist, ItemSortBy.Album, ItemSortBy.SortName }.Select(i => new ValueTuple<string, SortOrder>(i, SortOrder.Ascending)).ToArray(),
+                    DtoOptions = options
+                });
+            }
+
+            var musicArtist = item as MusicArtist;
+            if (musicArtist != null)
+            {
+                return LibraryManager.GetItemList(new InternalItemsQuery(user)
+                {
+                    Recursive = true,
+                    IncludeItemTypes = new[] { typeof(Audio).Name },
+                    ArtistIds = new[] { musicArtist.Id },
+                    OrderBy = new[] { ItemSortBy.AlbumArtist, ItemSortBy.Album, ItemSortBy.SortName }.Select(i => new ValueTuple<string, SortOrder>(i, SortOrder.Ascending)).ToArray(),
+                    DtoOptions = options
+                });
+            }
+
+            var folder = item as Folder;
+            if (folder != null)
+            {
+                var query = new InternalItemsQuery(user)
+                {
+                    Recursive = true,
+                    IsFolder = false,
+                    OrderBy = new[] { ItemSortBy.SortName }.Select(i => new ValueTuple<string, SortOrder>(i, SortOrder.Ascending)).ToArray(),
+                    MediaTypes = new[] { mediaType },
+                    EnableTotalRecordCount = false,
+                    DtoOptions = options
+                };
+
+                return folder.GetItemList(query);
+            }
+
+            return new[] { item };
+        }
+
+        [IgnoreDataMember]
+        public override bool IsPreSorted
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public string PlaylistMediaType { get; set; }
+
+        [IgnoreDataMember]
+        public override string MediaType
+        {
+            get
+            {
+                return PlaylistMediaType;
+            }
+        }
+
+        public void SetMediaType(string value)
+        {
+            PlaylistMediaType = value;
+        }
+
+        [IgnoreDataMember]
+        private bool IsSharedItem
+        {
+            get
+            {
+                var path = Path;
+
+                if (string.IsNullOrEmpty(path))
+                {
+                    return false;
+                }
+
+                return FileSystem.ContainsSubPath(ConfigurationManager.ApplicationPaths.DataPath, path);
+            }
+        }
+
+        public override bool IsVisible(User user)
+        {
+            if (!IsSharedItem)
+            {
+                return base.IsVisible(user);
+            }
+
+            if (user.Id == OwnerUserId)
+            {
+                return true;
+            }
+
+            var shares = Shares;
+            if (shares.Length == 0)
+            {
+                return base.IsVisible(user);
+            }
+
+            var userId = user.Id.ToString("N");
+            foreach (var share in shares)
+            {
+                if (string.Equals(share.UserId, userId, StringComparison.OrdinalIgnoreCase))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public override bool IsVisibleStandalone(User user)
+        {
+            if (!IsSharedItem)
+            {
+                return base.IsVisibleStandalone(user);
+            }
+
+            return IsVisible(user);
+        }
+    }
+}