Exemple #1
0
        public IEnumerable <VideoInfo> Resolve(List <FileSystemMetadata> files, bool supportMultiVersion = true)
        {
            var videoResolver = new VideoResolver(_options, _regexProvider);

            var videoInfos = files
                             .Select(i => videoResolver.Resolve(i.FullName, i.IsDirectory))
                             .Where(i => i != null)
                             .ToList();

            // Filter out all extras, otherwise they could cause stacks to not be resolved
            // See the unit test TestStackedWithTrailer
            var nonExtras = videoInfos
                            .Where(i => string.IsNullOrEmpty(i.ExtraType))
                            .Select(i => new FileSystemMetadata
            {
                FullName    = i.Path,
                IsDirectory = i.IsDirectory
            });

            var stackResult = new StackResolver(_options, _regexProvider)
                              .Resolve(nonExtras);

            var remainingFiles = videoInfos
                                 .Where(i => !stackResult.Stacks.Any(s => s.ContainsFile(i.Path, i.IsDirectory)))
                                 .ToList();

            var list = new List <VideoInfo>();

            foreach (var stack in stackResult.Stacks)
            {
                var info = new VideoInfo
                {
                    Files = stack.Files.Select(i => videoResolver.Resolve(i, stack.IsDirectoryStack)).ToList(),
                    Name  = stack.Name
                };

                info.Year = info.Files.First().Year;

                var extraBaseNames = new List <string>
                {
                    stack.Name,
                    Path.GetFileNameWithoutExtension(stack.Files[0])
                };

                var extras = GetExtras(remainingFiles, extraBaseNames);

                if (extras.Count > 0)
                {
                    remainingFiles = remainingFiles
                                     .Except(extras)
                                     .ToList();

                    info.Extras = extras;
                }

                list.Add(info);
            }

            var standaloneMedia = remainingFiles
                                  .Where(i => string.IsNullOrEmpty(i.ExtraType))
                                  .ToList();

            foreach (var media in standaloneMedia)
            {
                var info = new VideoInfo
                {
                    Files = new List <VideoFileInfo> {
                        media
                    },
                    Name = media.Name
                };

                info.Year = info.Files.First().Year;

                var extras = GetExtras(remainingFiles, new List <string> {
                    media.FileNameWithoutExtension
                });

                remainingFiles = remainingFiles
                                 .Except(extras.Concat(new[] { media }))
                                 .ToList();

                info.Extras = extras;

                list.Add(info);
            }

            if (supportMultiVersion)
            {
                list = GetVideosGroupedByVersion(list)
                       .ToList();
            }

            // If there's only one resolved video, use the folder name as well to find extras
            if (list.Count == 1)
            {
                var info       = list[0];
                var videoPath  = list[0].Files[0].Path;
                var parentPath = Path.GetDirectoryName(videoPath);

                if (!string.IsNullOrEmpty(parentPath))
                {
                    var folderName = Path.GetFileName(Path.GetDirectoryName(videoPath));
                    if (!string.IsNullOrEmpty(folderName))
                    {
                        var extras = GetExtras(remainingFiles, new List <string> {
                            folderName
                        });

                        remainingFiles = remainingFiles
                                         .Except(extras)
                                         .ToList();

                        info.Extras.AddRange(extras);
                    }
                }

                // Add the extras that are just based on file name as well
                var extrasByFileName = remainingFiles
                                       .Where(i => i.ExtraRule != null && i.ExtraRule.RuleType == ExtraRuleType.Filename)
                                       .ToList();

                remainingFiles = remainingFiles
                                 .Except(extrasByFileName)
                                 .ToList();

                info.Extras.AddRange(extrasByFileName);
            }

            // If there's only one video, accept all trailers
            // Be lenient because people use all kinds of mish mash conventions with trailers
            if (list.Count == 1)
            {
                var trailers = remainingFiles
                               .Where(i => string.Equals(i.ExtraType, "trailer", StringComparison.OrdinalIgnoreCase))
                               .ToList();

                list[0].Extras.AddRange(trailers);

                remainingFiles = remainingFiles
                                 .Except(trailers)
                                 .ToList();
            }

            // Whatever files are left, just add them
            list.AddRange(remainingFiles.Select(i => new VideoInfo
            {
                Files = new List <VideoFileInfo> {
                    i
                },
                Name = i.Name,
                Year = i.Year
            }));

            var orderedList = list.OrderBy(i => i.Name);

            return(orderedList);
        }
        /// <summary>
        /// Resolves alternative versions and extras from list of video files.
        /// </summary>
        /// <param name="files">List of related video files.</param>
        /// <param name="namingOptions">The naming options.</param>
        /// <param name="supportMultiVersion">Indication we should consider multi-versions of content.</param>
        /// <returns>Returns enumerable of <see cref="VideoInfo"/> which groups files together when related.</returns>
        public static IEnumerable <VideoInfo> Resolve(IEnumerable <FileSystemMetadata> files, NamingOptions namingOptions, bool supportMultiVersion = true)
        {
            var videoInfos = files
                             .Select(i => VideoResolver.Resolve(i.FullName, i.IsDirectory, namingOptions))
                             .OfType <VideoFileInfo>()
                             .ToList();

            // Filter out all extras, otherwise they could cause stacks to not be resolved
            // See the unit test TestStackedWithTrailer
            var nonExtras = videoInfos
                            .Where(i => i.ExtraType == null)
                            .Select(i => new FileSystemMetadata {
                FullName = i.Path, IsDirectory = i.IsDirectory
            });

            var stackResult = new StackResolver(namingOptions)
                              .Resolve(nonExtras).ToList();

            var remainingFiles = videoInfos
                                 .Where(i => !stackResult.Any(s => i.Path != null && s.ContainsFile(i.Path, i.IsDirectory)))
                                 .ToList();

            var list = new List <VideoInfo>();

            foreach (var stack in stackResult)
            {
                var info = new VideoInfo(stack.Name)
                {
                    Files = stack.Files.Select(i => VideoResolver.Resolve(i, stack.IsDirectoryStack, namingOptions))
                            .OfType <VideoFileInfo>()
                            .ToList()
                };

                info.Year = info.Files[0].Year;

                var extras = ExtractExtras(remainingFiles, stack.Name, Path.GetFileNameWithoutExtension(stack.Files[0].AsSpan()), namingOptions.VideoFlagDelimiters);

                if (extras.Count > 0)
                {
                    info.Extras = extras;
                }

                list.Add(info);
            }

            var standaloneMedia = remainingFiles
                                  .Where(i => i.ExtraType == null)
                                  .ToList();

            foreach (var media in standaloneMedia)
            {
                var info = new VideoInfo(media.Name)
                {
                    Files = new[] { media }
                };

                info.Year = info.Files[0].Year;

                remainingFiles.Remove(media);
                var extras = ExtractExtras(remainingFiles, media.FileNameWithoutExtension, namingOptions.VideoFlagDelimiters);

                info.Extras = extras;

                list.Add(info);
            }

            if (supportMultiVersion)
            {
                list = GetVideosGroupedByVersion(list, namingOptions);
            }

            // If there's only one resolved video, use the folder name as well to find extras
            if (list.Count == 1)
            {
                var info       = list[0];
                var videoPath  = list[0].Files[0].Path;
                var parentPath = Path.GetDirectoryName(videoPath.AsSpan());

                if (!parentPath.IsEmpty)
                {
                    var folderName = Path.GetFileName(parentPath);
                    if (!folderName.IsEmpty)
                    {
                        var extras = ExtractExtras(remainingFiles, folderName, namingOptions.VideoFlagDelimiters);
                        extras.AddRange(info.Extras);
                        info.Extras = extras;
                    }
                }

                // Add the extras that are just based on file name as well
                var extrasByFileName = remainingFiles
                                       .Where(i => i.ExtraRule != null && i.ExtraRule.RuleType == ExtraRuleType.Filename)
                                       .ToList();

                remainingFiles = remainingFiles
                                 .Except(extrasByFileName)
                                 .ToList();

                extrasByFileName.AddRange(info.Extras);
                info.Extras = extrasByFileName;
            }

            // If there's only one video, accept all trailers
            // Be lenient because people use all kinds of mishmash conventions with trailers.
            if (list.Count == 1)
            {
                var trailers = remainingFiles
                               .Where(i => i.ExtraType == ExtraType.Trailer)
                               .ToList();

                trailers.AddRange(list[0].Extras);
                list[0].Extras = trailers;

                remainingFiles = remainingFiles
                                 .Except(trailers)
                                 .ToList();
            }

            // Whatever files are left, just add them
            list.AddRange(remainingFiles.Select(i => new VideoInfo(i.Name)
            {
                Files = new[] { i },
                Year  = i.Year
            }));

            return(list);
        }
Exemple #3
0
        /// <summary>
        /// Resolves alternative versions and extras from list of video files.
        /// </summary>
        /// <param name="files">List of related video files.</param>
        /// <param name="namingOptions">The naming options.</param>
        /// <param name="supportMultiVersion">Indication we should consider multi-versions of content.</param>
        /// <param name="parseName">Whether to parse the name or use the filename.</param>
        /// <returns>Returns enumerable of <see cref="VideoInfo"/> which groups files together when related.</returns>
        public static IReadOnlyList <VideoInfo> Resolve(IEnumerable <FileSystemMetadata> files, NamingOptions namingOptions, bool supportMultiVersion = true, bool parseName = true)
        {
            var videoInfos = files
                             .Select(i => VideoResolver.Resolve(i.FullName, i.IsDirectory, namingOptions, parseName))
                             .OfType <VideoFileInfo>()
                             .ToList();

            // Filter out all extras, otherwise they could cause stacks to not be resolved
            // See the unit test TestStackedWithTrailer
            var nonExtras = videoInfos
                            .Where(i => i.ExtraType == null)
                            .Select(i => new FileSystemMetadata {
                FullName = i.Path, IsDirectory = i.IsDirectory
            });

            var stackResult = StackResolver.Resolve(nonExtras, namingOptions).ToList();

            var remainingFiles  = new List <VideoFileInfo>();
            var standaloneMedia = new List <VideoFileInfo>();

            for (var i = 0; i < videoInfos.Count; i++)
            {
                var current = videoInfos[i];
                if (stackResult.Any(s => s.ContainsFile(current.Path, current.IsDirectory)))
                {
                    continue;
                }

                remainingFiles.Add(current);
                if (current.ExtraType == null)
                {
                    standaloneMedia.Add(current);
                }
            }

            var list = new List <VideoInfo>();

            foreach (var stack in stackResult)
            {
                var info = new VideoInfo(stack.Name)
                {
                    Files = stack.Files.Select(i => VideoResolver.Resolve(i, stack.IsDirectoryStack, namingOptions, parseName))
                            .OfType <VideoFileInfo>()
                            .ToList()
                };

                info.Year = info.Files[0].Year;
                list.Add(info);
            }

            foreach (var media in standaloneMedia)
            {
                var info = new VideoInfo(media.Name)
                {
                    Files = new[] { media }
                };

                info.Year = info.Files[0].Year;

                remainingFiles.Remove(media);
                list.Add(info);
            }

            if (supportMultiVersion)
            {
                list = GetVideosGroupedByVersion(list, namingOptions);
            }

            // Whatever files are left, just add them
            list.AddRange(remainingFiles.Select(i => new VideoInfo(i.Name)
            {
                Files     = new[] { i },
                Year      = i.Year,
                ExtraType = i.ExtraType
            }));

            return(list);
        }