Merge pull request #971 from MediaBrowser/dev

3.0.5482.4

6 files changed, 230 insertions, 41 deletions

diff --git a/MediaBrowser.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs b/MediaBrowser.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs
index 0f703cb22..7c8ddabeb 100644
--- a/MediaBrowser.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs
+++ b/MediaBrowser.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs
@@ -1,7 +1,5 @@
 using MediaBrowser.Common.IO;
 using MediaBrowser.Controller.Entities.Audio;
-using MediaBrowser.Controller.Entities.Movies;
-using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Controller.Resolvers;
@@ -76,14 +74,10 @@ namespace MediaBrowser.Server.Implementations.Library.Resolvers.Audio
         /// </summary>
         /// <param name="path">The path.</param>
         /// <param name="directoryService">The directory service.</param>
-        /// <param name="logger">The logger.</param>
-        /// <param name="fileSystem">The file system.</param>
-        /// <param name="libraryManager">The library manager.</param>
         /// <returns><c>true</c> if [is music album] [the specified data]; otherwise, <c>false</c>.</returns>
-        public static bool IsMusicAlbum(string path, IDirectoryService directoryService, ILogger logger, IFileSystem fileSystem,
-            ILibraryManager libraryManager)
+        public bool IsMusicAlbum(string path, IDirectoryService directoryService)
         {
-            return ContainsMusic(directoryService.GetFileSystemEntries(path), true, directoryService, logger, fileSystem, libraryManager);
+            return ContainsMusic(directoryService.GetFileSystemEntries(path), true, directoryService, _logger, _fileSystem, _libraryManager);
         }
 
         /// <summary>
@@ -113,7 +107,7 @@ namespace MediaBrowser.Server.Implementations.Library.Resolvers.Audio
         /// <param name="fileSystem">The file system.</param>
         /// <param name="libraryManager">The library manager.</param>
         /// <returns><c>true</c> if the specified list contains music; otherwise, <c>false</c>.</returns>
-        private static bool ContainsMusic(IEnumerable<FileSystemInfo> list,
+        private bool ContainsMusic(IEnumerable<FileSystemInfo> list,
             bool allowSubfolders,
             IDirectoryService directoryService,
             ILogger logger,
@@ -131,17 +125,26 @@ namespace MediaBrowser.Server.Implementations.Library.Resolvers.Audio
                     {
                         var path = fileSystemInfo.FullName;
                         var isMultiDisc = IsMultiDiscFolder(path);
-                        var hasMusic = ContainsMusic(directoryService.GetFileSystemEntries(path), false, directoryService, logger, fileSystem, libraryManager);
 
-                        if (isMultiDisc && hasMusic)
+                        if (isMultiDisc)
                         {
-                            logger.Debug("Found multi-disc folder: " + path);
-                            discSubfolderCount++;
+                            var hasMusic = ContainsMusic(directoryService.GetFileSystemEntries(path), false, directoryService, logger, fileSystem, libraryManager);
+
+                            if (hasMusic)
+                            {
+                                logger.Debug("Found multi-disc folder: " + path);
+                                discSubfolderCount++;
+                            }
                         }
-                        else if (hasMusic)
+                        else
                         {
-                            // If there are folders underneath with music that are not multidisc, then this can't be a multi-disc album
-                            notMultiDisc = true;
+                            var hasMusic = ContainsMusic(directoryService.GetFileSystemEntries(path), false, directoryService, logger, fileSystem, libraryManager);
+
+                            if (hasMusic)
+                            {
+                                // If there are folders underneath with music that are not multidisc, then this can't be a multi-disc album
+                                notMultiDisc = true;
+                            }
                         }
                     }
                 }
@@ -159,12 +162,14 @@ namespace MediaBrowser.Server.Implementations.Library.Resolvers.Audio
                 return false;
             }
 
-            return discSubfolderCount > 0 && discSubfolderCount > 10;
+            return discSubfolderCount > 0;
         }
 
-        private static bool IsMultiDiscFolder(string path)
+        private bool IsMultiDiscFolder(string path)
         {
-            var parser = new AlbumParser(new ExtendedNamingOptions(), new Naming.Logging.NullLogger());
+            var namingOptions = ((LibraryManager)_libraryManager).GetNamingOptions();
+
+            var parser = new AlbumParser(namingOptions, new Naming.Logging.NullLogger());
             var result = parser.ParseMultiPart(path);
 
             return result.IsMultiPart;
diff --git a/MediaBrowser.Server.Implementations/Library/Resolvers/Audio/MusicArtistResolver.cs b/MediaBrowser.Server.Implementations/Library/Resolvers/Audio/MusicArtistResolver.cs
index edbc87415..9f3f24865 100644
--- a/MediaBrowser.Server.Implementations/Library/Resolvers/Audio/MusicArtistResolver.cs
+++ b/MediaBrowser.Server.Implementations/Library/Resolvers/Audio/MusicArtistResolver.cs
@@ -70,9 +70,11 @@ namespace MediaBrowser.Server.Implementations.Library.Resolvers.Audio
             }
 
             var directoryService = args.DirectoryService;
-            
+
+            var albumResolver = new MusicAlbumResolver(_logger, _fileSystem, _libraryManager);
+
             // If we contain an album assume we are an artist folder
-            return args.FileSystemChildren.Where(i => (i.Attributes & FileAttributes.Directory) == FileAttributes.Directory).Any(i => MusicAlbumResolver.IsMusicAlbum(i.FullName, directoryService, _logger, _fileSystem, _libraryManager)) ? new MusicArtist() : null;
+            return args.FileSystemChildren.Where(i => (i.Attributes & FileAttributes.Directory) == FileAttributes.Directory).Any(i => albumResolver.IsMusicAlbum(i.FullName, directoryService)) ? new MusicArtist() : null;
         }
 
     }
diff --git a/MediaBrowser.Server.Implementations/Library/Resolvers/BaseVideoResolver.cs b/MediaBrowser.Server.Implementations/Library/Resolvers/BaseVideoResolver.cs
index 8e2218b0a..1a4d35af5 100644
--- a/MediaBrowser.Server.Implementations/Library/Resolvers/BaseVideoResolver.cs
+++ b/MediaBrowser.Server.Implementations/Library/Resolvers/BaseVideoResolver.cs
@@ -44,8 +44,10 @@ namespace MediaBrowser.Server.Implementations.Library.Resolvers
         protected TVideoType ResolveVideo<TVideoType>(ItemResolveArgs args, bool parseName)
               where TVideoType : Video, new()
         {
+            var namingOptions = ((LibraryManager)LibraryManager).GetNamingOptions();
+            
             // If the path is a file check for a matching extensions
-            var parser = new Naming.Video.VideoResolver(new ExtendedNamingOptions(), new Naming.Logging.NullLogger());
+            var parser = new Naming.Video.VideoResolver(namingOptions, new Naming.Logging.NullLogger());
 
             if (args.IsDirectory)
             {
@@ -229,7 +231,9 @@ namespace MediaBrowser.Server.Implementations.Library.Resolvers
 
         protected void Set3DFormat(Video video)
         {
-            var resolver = new Format3DParser(new ExtendedNamingOptions(), new Naming.Logging.NullLogger());
+            var namingOptions = ((LibraryManager)LibraryManager).GetNamingOptions();
+
+            var resolver = new Format3DParser(namingOptions, new Naming.Logging.NullLogger());
             var result = resolver.Parse(video.Path);
 
             Set3DFormat(video, result.Is3D, result.Format3D);
diff --git a/MediaBrowser.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs b/MediaBrowser.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs
index 441fada6a..4c0767b08 100644
--- a/MediaBrowser.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs
+++ b/MediaBrowser.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs
@@ -1,10 +1,11 @@
-using MediaBrowser.Controller.Entities;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Controller.Resolvers;
 using MediaBrowser.Model.Entities;
-using MediaBrowser.Naming.Common;
 using MediaBrowser.Naming.IO;
 using MediaBrowser.Naming.Video;
 using System;
@@ -68,12 +69,17 @@ namespace MediaBrowser.Server.Implementations.Library.Resolvers.Movies
                     return ResolveVideos<Video>(parent, files, directoryService, collectionType, false);
                 }
 
-                return ResolveVideos<Video>(parent, files, directoryService, collectionType, false);
+                if (parent is Series || parent.Parents.OfType<Series>().Any())
+                {
+                    return null;
+                }
+
+                return ResolveVideos<Movie>(parent, files, directoryService, collectionType, false);
             }
 
             if (string.Equals(collectionType, CollectionType.Movies, StringComparison.OrdinalIgnoreCase))
             {
-                return ResolveVideos<Movie>(parent, files, directoryService, collectionType, false);
+                return ResolveVideos<Movie>(parent, files, directoryService, collectionType, true);
             }
 
             return null;
@@ -93,13 +99,19 @@ namespace MediaBrowser.Server.Implementations.Library.Resolvers.Movies
                 {
                     leftOver.Add(child);
                 }
+                else if (IsIgnored(child.Name))
+                {
+                    
+                }
                 else
                 {
                     files.Add(child);
                 }
             }
 
-            var resolver = new VideoListResolver(new ExtendedNamingOptions(), new Naming.Logging.NullLogger());
+            var namingOptions = ((LibraryManager)LibraryManager).GetNamingOptions();
+
+            var resolver = new VideoListResolver(namingOptions, new Naming.Logging.NullLogger());
             var resolverResult = resolver.Resolve(files.Select(i => new PortableFileInfo
             {
                 FullName = i.FullName,
@@ -173,7 +185,12 @@ namespace MediaBrowser.Server.Implementations.Library.Resolvers.Movies
                         return FindMovie<Video>(args.Path, args.Parent, args.FileSystemChildren.ToList(), args.DirectoryService, collectionType);
                     }
 
-                    return FindMovie<Video>(args.Path, args.Parent, args.FileSystemChildren.ToList(), args.DirectoryService, collectionType);
+                    if (args.HasParent<Series>())
+                    {
+                        return null;
+                    }
+
+                    return FindMovie<Movie>(args.Path, args.Parent, args.FileSystemChildren.ToList(), args.DirectoryService, collectionType);
                 }
 
                 if (string.Equals(collectionType, CollectionType.Movies, StringComparison.OrdinalIgnoreCase))
@@ -209,6 +226,11 @@ namespace MediaBrowser.Server.Implementations.Library.Resolvers.Movies
             }
             else if (string.IsNullOrEmpty(collectionType))
             {
+                if (args.HasParent<Series>())
+                {
+                    return null;
+                }
+
                 item = ResolveVideo<Video>(args, false);
             }
 
@@ -220,6 +242,22 @@ namespace MediaBrowser.Server.Implementations.Library.Resolvers.Movies
             return item;
         }
 
+        private bool IsIgnored(string filename)
+        {
+            // Ignore samples
+            var sampleFilename = " " + filename.Replace(".", " ", StringComparison.OrdinalIgnoreCase)
+                .Replace("-", " ", StringComparison.OrdinalIgnoreCase)
+                .Replace("_", " ", StringComparison.OrdinalIgnoreCase)
+                .Replace("!", " ", StringComparison.OrdinalIgnoreCase);
+
+            if (sampleFilename.IndexOf(" sample ", StringComparison.OrdinalIgnoreCase) != -1)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
         /// <summary>
         /// Sets the initial item values.
         /// </summary>
@@ -397,7 +435,8 @@ namespace MediaBrowser.Server.Implementations.Library.Resolvers.Movies
                 return null;
             }
 
-            var resolver = new StackResolver(new ExtendedNamingOptions(), new Naming.Logging.NullLogger());
+            var namingOptions = ((LibraryManager)LibraryManager).GetNamingOptions();
+            var resolver = new StackResolver(namingOptions, new Naming.Logging.NullLogger());
 
             var result = resolver.ResolveDirectories(folderPaths);
 
diff --git a/MediaBrowser.Server.Implementations/Library/Resolvers/TV/SeasonResolver.cs b/MediaBrowser.Server.Implementations/Library/Resolvers/TV/SeasonResolver.cs
index 80477e567..7d13b11ad 100644
--- a/MediaBrowser.Server.Implementations/Library/Resolvers/TV/SeasonResolver.cs
+++ b/MediaBrowser.Server.Implementations/Library/Resolvers/TV/SeasonResolver.cs
@@ -16,13 +16,16 @@ namespace MediaBrowser.Server.Implementations.Library.Resolvers.TV
         /// </summary>
         private readonly IServerConfigurationManager _config;
 
+        private readonly ILibraryManager _libraryManager;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="SeasonResolver"/> class.
         /// </summary>
         /// <param name="config">The config.</param>
-        public SeasonResolver(IServerConfigurationManager config)
+        public SeasonResolver(IServerConfigurationManager config, ILibraryManager libraryManager)
         {
             _config = config;
+            _libraryManager = libraryManager;
         }
 
         /// <summary>
@@ -34,9 +37,11 @@ namespace MediaBrowser.Server.Implementations.Library.Resolvers.TV
         {
             if (args.Parent is Series && args.IsDirectory)
             {
+                var namingOptions = ((LibraryManager)_libraryManager).GetNamingOptions();
+                
                 var season = new Season
                 {
-                    IndexNumber = new SeasonPathParser(new ExtendedNamingOptions(), new RegexProvider()).Parse(args.Path, true).SeasonNumber
+                    IndexNumber = new SeasonPathParser(namingOptions, new RegexProvider()).Parse(args.Path, true, true).SeasonNumber
                 };
                 
                 if (season.IndexNumber.HasValue && season.IndexNumber.Value == 0)
diff --git a/MediaBrowser.Server.Implementations/Library/Resolvers/TV/SeriesResolver.cs b/MediaBrowser.Server.Implementations/Library/Resolvers/TV/SeriesResolver.cs
index 7f1416ad6..e68f005be 100644
--- a/MediaBrowser.Server.Implementations/Library/Resolvers/TV/SeriesResolver.cs
+++ b/MediaBrowser.Server.Implementations/Library/Resolvers/TV/SeriesResolver.cs
@@ -1,9 +1,17 @@
-using MediaBrowser.Controller.Entities.TV;
+using System.Collections.Generic;
+using MediaBrowser.Common.IO;
+using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
 using MediaBrowser.Controller.Resolvers;
 using MediaBrowser.Model.Entities;
 using System;
 using System.IO;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Naming.Common;
+using MediaBrowser.Naming.IO;
+using MediaBrowser.Naming.TV;
+using EpisodeInfo = MediaBrowser.Controller.Providers.EpisodeInfo;
 
 namespace MediaBrowser.Server.Implementations.Library.Resolvers.TV
 {
@@ -12,6 +20,17 @@ namespace MediaBrowser.Server.Implementations.Library.Resolvers.TV
     /// </summary>
     public class SeriesResolver : FolderResolver<Series>
     {
+        private readonly IFileSystem _fileSystem;
+        private readonly ILogger _logger;
+        private readonly ILibraryManager _libraryManager;
+
+        public SeriesResolver(IFileSystem fileSystem, ILogger logger, ILibraryManager libraryManager)
+        {
+            _fileSystem = fileSystem;
+            _logger = logger;
+            _libraryManager = libraryManager;
+        }
+
         /// <summary>
         /// Gets the priority.
         /// </summary>
@@ -34,26 +53,141 @@ namespace MediaBrowser.Server.Implementations.Library.Resolvers.TV
             if (args.IsDirectory)
             {
                 var collectionType = args.GetCollectionType();
-
-                // If there's a collection type and it's not tv, it can't be a series
                 if (string.Equals(collectionType, CollectionType.TvShows, StringComparison.OrdinalIgnoreCase))
                 {
                     if (args.HasParent<Series>())
                     {
                         return null;
-                    } 
-                    
-                    return new Series
+                    }
+
+                    var configuredContentType = _libraryManager.GetConfiguredContentType(args.Path);
+                    if (!string.Equals(configuredContentType, CollectionType.TvShows, StringComparison.OrdinalIgnoreCase))
                     {
-                        Path = args.Path,
-                        Name = Path.GetFileName(args.Path)
-                    };
+                        return new Series
+                        {
+                            Path = args.Path,
+                            Name = Path.GetFileName(args.Path)
+                        };
+                    }
+                }
+                else
+                {
+                    if (string.IsNullOrWhiteSpace(collectionType))
+                    {
+                        if (args.HasParent<Series>())
+                        {
+                            return null;
+                        }
+
+                        if (args.Parent.IsRoot)
+                        {
+                            return null;
+                        }
+                        if (IsSeriesFolder(args.Path, args.FileSystemChildren, args.DirectoryService, _fileSystem, _logger, _libraryManager, false))
+                        {
+                            return new Series
+                            {
+                                Path = args.Path,
+                                Name = Path.GetFileName(args.Path)
+                            };
+                        }
+                    }
                 }
             }
 
             return null;
         }
 
+        public static bool IsSeriesFolder(string path,
+            IEnumerable<FileSystemInfo> fileSystemChildren,
+            IDirectoryService directoryService,
+            IFileSystem fileSystem,
+            ILogger logger,
+            ILibraryManager libraryManager,
+            bool isTvContentType)
+        {
+            foreach (var child in fileSystemChildren)
+            {
+                var attributes = child.Attributes;
+
+                if ((attributes & FileAttributes.Hidden) == FileAttributes.Hidden)
+                {
+                    //logger.Debug("Igoring series file or folder marked hidden: {0}", child.FullName);
+                    continue;
+                }
+
+                // Can't enforce this because files saved by Bitcasa are always marked System
+                //if ((attributes & FileAttributes.System) == FileAttributes.System)
+                //{
+                //    logger.Debug("Igoring series subfolder marked system: {0}", child.FullName);
+                //    continue;
+                //}
+
+                if ((attributes & FileAttributes.Directory) == FileAttributes.Directory)
+                {
+                    if (IsSeasonFolder(child.FullName, isTvContentType))
+                    {
+                        //logger.Debug("{0} is a series because of season folder {1}.", path, child.FullName);
+                        return true;
+                    }
+                }
+                else
+                {
+                    string fullName = child.FullName;
+                    if (libraryManager.IsVideoFile(fullName))
+                    {
+                        if (isTvContentType)
+                        {
+                            return true;
+                        }
+
+                        var namingOptions = ((LibraryManager)libraryManager).GetNamingOptions();
+
+                        var episodeResolver = new Naming.TV.EpisodeResolver(namingOptions, new Naming.Logging.NullLogger());
+                        var episodeInfo = episodeResolver.Resolve(fullName, FileInfoType.File, false);
+                        if (episodeInfo != null && episodeInfo.EpisodeNumber.HasValue)
+                        {
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            logger.Debug("{0} is not a series folder.", path);
+            return false;
+        }
+
+        /// <summary>
+        /// Determines whether [is place holder] [the specified path].
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <returns><c>true</c> if [is place holder] [the specified path]; otherwise, <c>false</c>.</returns>
+        /// <exception cref="System.ArgumentNullException">path</exception>
+        private static bool IsVideoPlaceHolder(string path)
+        {
+            if (string.IsNullOrEmpty(path))
+            {
+                throw new ArgumentNullException("path");
+            }
+
+            var extension = Path.GetExtension(path);
+
+            return string.Equals(extension, ".disc", StringComparison.OrdinalIgnoreCase);
+        }
+
+        /// <summary>
+        /// Determines whether [is season folder] [the specified path].
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <param name="isTvContentType">if set to <c>true</c> [is tv content type].</param>
+        /// <returns><c>true</c> if [is season folder] [the specified path]; otherwise, <c>false</c>.</returns>
+        private static bool IsSeasonFolder(string path, bool isTvContentType)
+        {
+            var seasonNumber = new SeasonPathParser(new ExtendedNamingOptions(), new RegexProvider()).Parse(path, isTvContentType, isTvContentType).SeasonNumber;
+
+            return seasonNumber.HasValue;
+        }
+
         /// <summary>
         /// Sets the initial item values.
         /// </summary>