public ImageRefreshOptions(IDirectoryService directoryService) { ImageRefreshMode = ImageRefreshMode.Default; DirectoryService = directoryService; ReplaceImages = new List<ImageType>(); }
public List<LocalImageInfo> GetImages(IHasImages item, IDirectoryService directoryService) { var parentPath = Path.GetDirectoryName(item.Path); var parentPathFiles = directoryService.GetFileSystemEntries(parentPath) .ToList(); var nameWithoutExtension = _fileSystem.GetFileNameWithoutExtension(item.Path); var files = GetFilesFromParentFolder(nameWithoutExtension, parentPathFiles); if (files.Count > 0) { return files; } var metadataPath = Path.Combine(parentPath, "metadata"); if (parentPathFiles.Any(i => string.Equals(i.FullName, metadataPath, StringComparison.OrdinalIgnoreCase))) { return GetFilesFromParentFolder(nameWithoutExtension, directoryService.GetFiles(metadataPath)); } return new List<LocalImageInfo>(); }
public LoginViewModel (IDirectoryService service) { this.service = service; Username = ""; Password = ""; }
public LoginViewModel(IDirectoryService service) { this.service = service; Username = string.Empty; Password = string.Empty; }
/// <summary> /// Sets the initial item values. /// </summary> /// <param name="item">The item.</param> /// <param name="parent">The parent.</param> /// <param name="fileSystem">The file system.</param> /// <param name="libraryManager">The library manager.</param> /// <param name="directoryService">The directory service.</param> /// <exception cref="System.ArgumentException">Item must have a path</exception> public static void SetInitialItemValues(BaseItem item, Folder parent, IFileSystem fileSystem, ILibraryManager libraryManager, IDirectoryService directoryService) { // This version of the below method has no ItemResolveArgs, so we have to require the path already being set if (string.IsNullOrWhiteSpace(item.Path)) { throw new ArgumentException("Item must have a Path"); } // If the resolver didn't specify this if (parent != null) { item.Parent = parent; } item.Id = libraryManager.GetNewItemId(item.Path, item.GetType()); item.IsLocked = item.Path.IndexOf("[dontfetchmeta]", StringComparison.OrdinalIgnoreCase) != -1 || item.Parents.Any(i => i.IsLocked); // Make sure DateCreated and DateModified have values var fileInfo = directoryService.GetFile(item.Path); item.DateModified = fileSystem.GetLastWriteTimeUtc(fileInfo); SetDateCreated(item, fileSystem, fileInfo); EnsureName(item, fileInfo); }
public RibbonViewModel(INavigationService navigationService, IUIVisualizerService uiVisualizerService, ICommandManager commandManager, IRecentlyUsedItemsService recentlyUsedItemsService, IProcessService processService, IMessageService messageService, ISelectDirectoryService selectDirectoryService, IDirectoryService directoryService) { Argument.IsNotNull(() => navigationService); Argument.IsNotNull(() => uiVisualizerService); Argument.IsNotNull(() => commandManager); Argument.IsNotNull(() => recentlyUsedItemsService); Argument.IsNotNull(() => processService); Argument.IsNotNull(() => messageService); Argument.IsNotNull(() => selectDirectoryService); Argument.IsNotNull(() => directoryService); _navigationService = navigationService; _uiVisualizerService = uiVisualizerService; _recentlyUsedItemsService = recentlyUsedItemsService; _processService = processService; _messageService = messageService; _selectDirectoryService = selectDirectoryService; _directoryService = directoryService; OpenProject = new Command(OnOpenProjectExecute); OpenRecentlyUsedItem = new Command<string>(OnOpenRecentlyUsedItemExecute); OpenInExplorer = new Command<string>(OnOpenInExplorerExecute); UnpinItem = new Command<string>(OnUnpinItemExecute); PinItem = new Command<string>(OnPinItemExecute); ShowKeyboardMappings = new Command(OnShowKeyboardMappingsExecute); commandManager.RegisterCommand("File.Open", OpenProject, this); var assembly = AssemblyHelper.GetEntryAssembly(); Title = assembly.Title(); }
public AppDataService(IMessageService messageService, ISaveFileService saveFileService, IProcessService processService, IDirectoryService directoryService, IFileService fileService) { Argument.IsNotNull(() => messageService); Argument.IsNotNull(() => saveFileService); Argument.IsNotNull(() => processService); Argument.IsNotNull(() => directoryService); Argument.IsNotNull(() => fileService); _messageService = messageService; _saveFileService = saveFileService; _processService = processService; _directoryService = directoryService; _fileService = fileService; ExclusionFilters = new List<string>(new [] { "licenseinfo.xml", "*.log" }); var applicationDataDirectory = Catel.IO.Path.GetApplicationDataDirectory(); _directoryService.Create(applicationDataDirectory); ApplicationDataDirectory = applicationDataDirectory; }
public EndpointResolverService(IDirectoryService directoryService, IDefaultEndpointConfiguration defaultEndpointConfiguration, IUrlBuilder urlBuilder, IDirectoryRepository directoryRepository, ILogger logger) { _directoryService = directoryService; _defaultEndpointConfiguration = defaultEndpointConfiguration; _urlBuilder = urlBuilder; _directoryRepository = directoryRepository; _logger = logger; }
public DirectoryController(IEndpointResolverService endpointResolverService, IAccountSettings accountSettings, ICallService callService, ILogger logger, IDirectoryService directoryService) { _endpointResolverService = endpointResolverService; _accountSettings = accountSettings; _callService = callService; _logger = logger; _directoryService = directoryService; }
public override bool FinishedLaunching (UIApplication app, NSDictionary options) { if(!UIDevice.CurrentDevice.CheckSystemVersion(7,0)) Theme.Apply (); // // Create the service // // Local CSV file service = MemoryDirectoryService.FromCsv ("Data/XamarinDirectory.csv"); // LDAP service - uncomment to try it out. //service = new LdapDirectoryService { // Host = "ldap.mit.edu", // SearchBase = "dc=mit,dc=edu", //}; // // Load the favorites // var favoritesRepository = XmlFavoritesRepository.OpenIsolatedStorage ("Favorites.xml"); if (favoritesRepository.GetAll ().Count () == 0) { favoritesRepository = XmlFavoritesRepository.OpenFile ("Data/XamarinFavorites.xml"); favoritesRepository.IsolatedStorageName = "Favorites.xml"; } // // Load the last search // Search search = null; try { search = Search.Open ("Search.xml"); } catch (Exception) { search = new Search ("Search.xml"); } // // Build the UI // favoritesViewController = new FavoritesViewController (favoritesRepository, service, search); window = new UIWindow (UIScreen.MainScreen.Bounds); window.RootViewController = new UINavigationController (favoritesViewController); window.MakeKeyAndVisible (); // // Show the login screen at startup // var login = new LoginViewController (service); favoritesViewController.PresentViewController (login, false, null); return true; }
public CodeGenerationService(IEntityPluralService entityPluralService, IFileService fileService, IDirectoryService directoryService) { Argument.IsNotNull(() => entityPluralService); Argument.IsNotNull(() => fileService); Argument.IsNotNull(() => directoryService); _entityPluralService = entityPluralService; _fileService = fileService; _directoryService = directoryService; }
public SearchViewModel (IDirectoryService service, Search search) { if (service == null) throw new ArgumentNullException ("service"); this.service = service; if (search == null) throw new ArgumentNullException ("search"); this.search = search; SetGroupedPeople (); }
public List<LocalImageInfo> GetImages(IHasImages item, IDirectoryService directoryService) { var files = GetFiles(item, true, directoryService).ToList(); var list = new List<LocalImageInfo>(); PopulateImages(item, list, files, true, directoryService); return list; }
public bool HasChanged(IHasMetadata item, IDirectoryService directoryService) { var liveTvItem = item as ILiveTvRecording; if (liveTvItem != null) { return !liveTvItem.HasImage(ImageType.Primary); } return false; }
public bool HasChanged(IHasMetadata item, MetadataStatus status, IDirectoryService directoryService) { var liveTvItem = item as LiveTvProgram; if (liveTvItem != null) { return !liveTvItem.HasImage(ImageType.Primary); } return false; }
public bool HasChanged(IHasMetadata item, IDirectoryService directoryService, DateTime date) { var channelItem = item as IChannelItem; if (channelItem != null) { return !channelItem.HasImage(ImageType.Primary) && !string.IsNullOrWhiteSpace(channelItem.OriginalImageUrl); } return false; }
public List<LocalImageInfo> GetImages(IHasImages item, IDirectoryService directoryService) { var path = item.GetInternalMetadataPath(); try { return new LocalImageProvider(_fileSystem).GetImages(item, path, true, directoryService); } catch (DirectoryNotFoundException) { return new List<LocalImageInfo>(); } }
public List<LocalImageInfo> GetImages(IHasImages item, IDirectoryService directoryService) { var path = _config.ApplicationPaths.GetInternalMetadataPath(item.Id); try { return new LocalImageProvider().GetImages(item, path, directoryService); } catch (DirectoryNotFoundException) { return new List<LocalImageInfo>(); } }
public ImageRepository(HttpServerUtilityBase server, IDirectoryService directory, string rootPath) { string path = server.MapPath(rootPath); var files = directory.EnumerateFiles(path, "*.jpg"); foreach (var file in files) { string imageUrl = VirtualPathUtility.Combine(VirtualPathUtility.AppendTrailingSlash(rootPath), Path.GetFileName(file)); string metaPath = file + ".meta"; using (var reader = directory.GetReader(metaPath)) { _images.Add(new ImageMetadata(imageUrl, reader)); } } }
public List<LocalImageInfo> GetImages(IHasImages item, IDirectoryService directoryService) { var name = _fileSystem.GetValidFilename(item.Name); var path = Path.Combine(_config.ApplicationPaths.GeneralPath, name); try { return new LocalImageProvider(_fileSystem).GetImages(item, path, directoryService); } catch (DirectoryNotFoundException) { return new List<LocalImageInfo>(); } }
public bool ValidateImages(IHasImages item, IEnumerable<IImageProvider> providers, IDirectoryService directoryService) { var hasChanges = item.ValidateImages(directoryService); foreach (var provider in providers.OfType<ILocalImageFileProvider>()) { var images = provider.GetImages(item, directoryService); if (MergeImages(item, images)) { hasChanges = true; } } return hasChanges; }
protected override async Task ValidateChildrenInternal(IProgress<double> progress, CancellationToken cancellationToken, bool recursive, bool refreshChildMetadata, MetadataRefreshOptions refreshOptions, IDirectoryService directoryService) { await base.ValidateChildrenInternal(progress, cancellationToken, recursive, refreshChildMetadata, refreshOptions, directoryService) .ConfigureAwait(false); // Not the best way to handle this, but it solves an issue // CollectionFolders aren't always getting saved after changes // This means that grabbing the item by Id may end up returning the old one // Fix is in two places - make sure the folder gets saved // And here to remedy it for affected users. // In theory this can be removed eventually. foreach (var item in Children) { LibraryManager.RegisterItem(item); } }
public bool ValidateImages(IHasImages item, IEnumerable<IImageProvider> providers, IDirectoryService directoryService) { var hasChanges = false; if (!(item is Photo)) { var images = providers.OfType<ILocalImageFileProvider>() .SelectMany(i => i.GetImages(item, directoryService)) .ToList(); if (MergeImages(item, images)) { hasChanges = true; } } return hasChanges; }
private IEnumerable<FileSystemInfo> GetFiles(IHasImages item, bool includeDirectories, IDirectoryService directoryService) { if (item.LocationType != LocationType.FileSystem) { return new List<FileSystemInfo>(); } var path = item.ContainingFolderPath; if (includeDirectories) { return directoryService.GetFileSystemEntries(path) .Where(i => BaseItem.SupportedImageExtensions.Contains(i.Extension, StringComparer.OrdinalIgnoreCase) || (i.Attributes & FileAttributes.Directory) == FileAttributes.Directory); } return directoryService.GetFiles(path) .Where(i => BaseItem.SupportedImageExtensions.Contains(i.Extension, StringComparer.OrdinalIgnoreCase)); }
public FavoritesViewController(IFavoritesRepository favoritesRepository, IDirectoryService service, Search savedSearch) { this.favoritesRepository = favoritesRepository; Title = "Favorites"; viewModel = new FavoritesViewModel (favoritesRepository, groupByLastName: true); viewModel.PropertyChanged += HandleViewModelPropertyChanged; searchViewModel = new SearchViewModel (service, savedSearch); // // Configure this view // var favoritesDelegate = new PeopleGroupsDelegate (TableView); favoritesDelegate.PersonSelected += HandlePersonSelected; TableView.DataSource = new PeopleGroupsDataSource (viewModel.Groups); TableView.Delegate = favoritesDelegate; TableView.SectionIndexMinimumDisplayRowCount = 10; // // Configure the search bar // searchBar = new UISearchBar (new CGRect (0f, 0f, 320f, 44f)) { ShowsScopeBar = true, }; searchBar.ScopeButtonTitles = new[] { "Name", "Title", "Dept", "All" }; searchBar.SelectedScopeButtonIndex = (int)savedSearch.Property; searchController = new UISearchDisplayController (searchBar, this) { SearchResultsDataSource = new PeopleGroupsDataSource (searchViewModel.Groups), Delegate = new SearchDisplayDelegate (searchViewModel) }; var searchDelegate = new PeopleGroupsDelegate (searchController.SearchResultsTableView); searchController.SearchResultsTableView.SectionIndexMinimumDisplayRowCount = 10; searchDelegate.PersonSelected += HandleSearchPersonSelected; searchController.SearchResultsDelegate = searchDelegate; TableView.TableHeaderView = searchBar; }
private IEnumerable<FileSystemMetadata> GetFiles(IHasImages item, bool includeDirectories, IDirectoryService directoryService) { if (item.LocationType != LocationType.FileSystem) { return new List<FileSystemMetadata>(); } var path = item.ContainingFolderPath; if (includeDirectories) { return directoryService.GetFileSystemEntries(path) .Where(i => BaseItem.SupportedImageExtensions.Contains(i.Extension, StringComparer.OrdinalIgnoreCase) || i.IsDirectory) .OrderBy(i => BaseItem.SupportedImageExtensionsList.IndexOf(i.Extension ?? string.Empty)); } return directoryService.GetFiles(path) .Where(i => BaseItem.SupportedImageExtensions.Contains(i.Extension, StringComparer.OrdinalIgnoreCase)) .OrderBy(i => BaseItem.SupportedImageExtensionsList.IndexOf(i.Extension ?? string.Empty)); }
private ItemResolveArgs CreateResolveArgs(IDirectoryService directoryService) { var path = ContainingFolderPath; var args = new ItemResolveArgs(ConfigurationManager.ApplicationPaths, LibraryManager, directoryService) { FileInfo = new DirectoryInfo(path), Path = path, Parent = Parent, CollectionType = CollectionType }; // Gather child folder and files if (args.IsDirectory) { var isPhysicalRoot = args.IsPhysicalRoot; // When resolving the root, we need it's grandchildren (children of user views) var flattenFolderDepth = isPhysicalRoot ? 2 : 0; var fileSystemDictionary = FileData.GetFilteredFileSystemEntries(directoryService, args.Path, FileSystem, Logger, args, flattenFolderDepth: flattenFolderDepth, resolveShortcuts: isPhysicalRoot || args.IsVf); // Need to remove subpaths that may have been resolved from shortcuts // Example: if \\server\movies exists, then strip out \\server\movies\action if (isPhysicalRoot) { var paths = LibraryManager.NormalizeRootPathList(fileSystemDictionary.Keys); fileSystemDictionary = paths.Select(i => (FileSystemInfo)new DirectoryInfo(i)).ToDictionary(i => i.FullName); } args.FileSystemDictionary = fileSystemDictionary; } PhysicalLocationsList = args.PhysicalLocations.ToList(); return args; }
public static Page GetMainPage () { // // Create the service // // // Local CSV file Service = MemoryDirectoryService.FromCsv ("XamarinDirectory.csv").Result; // // LDAP service - uncomment to try it out. //Service = new LdapDirectoryService { // Host = "ldap.mit.edu", // SearchBase = "dc=mit,dc=edu", //}; var employeeList = new EmployeeListXaml (); var mainNav = new NavigationPage (employeeList); return mainNav; }
private MultiItemResolverResult ResolveVideos <T>(Folder parent, IEnumerable <FileSystemMetadata> fileSystemEntries, IDirectoryService directoryService, bool suppportMultiEditions) where T : Video, new() { var files = new List <FileSystemMetadata>(); var videos = new List <BaseItem>(); var leftOver = new List <FileSystemMetadata>(); // Loop through each child file/folder and see if we find a video foreach (var child in fileSystemEntries) { if ((child.Attributes & FileAttributes.Directory) == FileAttributes.Directory) { leftOver.Add(child); } else if (IsIgnored(child.Name)) { } else { files.Add(child); } } var namingOptions = ((LibraryManager)LibraryManager).GetNamingOptions(); var resolver = new VideoListResolver(namingOptions, new PatternsLogger()); var resolverResult = resolver.Resolve(files.Select(i => new FileMetadata { Id = i.FullName, IsFolder = i.IsDirectory }).ToList(), suppportMultiEditions).ToList(); var result = new MultiItemResolverResult { ExtraFiles = leftOver, Items = videos }; var isInMixedFolder = resolverResult.Count > 1; foreach (var video in resolverResult) { var firstVideo = video.Files.First(); var videoItem = new T { Path = video.Files[0].Path, IsInMixedFolder = isInMixedFolder, ProductionYear = video.Year, Name = video.Name, AdditionalParts = video.Files.Skip(1).Select(i => i.Path).ToList(), LocalAlternateVersions = video.AlternateVersions.Select(i => i.Path).ToList() }; SetVideoType(videoItem, firstVideo); Set3DFormat(videoItem, firstVideo); result.Items.Add(videoItem); } result.ExtraFiles.AddRange(files.Where(i => !ContainsFile(resolverResult, i))); return(result); }
public List <LocalImageInfo> GetImages(BaseItem item, IEnumerable <string> paths, bool arePathsInMediaFolders, IDirectoryService directoryService) { IEnumerable <FileSystemMetadata> files = paths.SelectMany(i => _fileSystem.GetFiles(i, BaseItem.SupportedImageExtensions, true, false)); files = files .OrderBy(i => BaseItem.SupportedImageExtensionsList.IndexOf(i.Extension ?? string.Empty)); var list = new List <LocalImageInfo>(); PopulateImages(item, list, files.ToList(), false, directoryService); return(list); }
/// <summary> /// Finds a movie based on a child file system entries /// </summary> /// <typeparam name="T"></typeparam> /// <param name="path">The path.</param> /// <param name="parent">The parent.</param> /// <param name="fileSystemEntries">The file system entries.</param> /// <param name="directoryService">The directory service.</param> /// <param name="collectionType">Type of the collection.</param> /// <returns>Movie.</returns> private T FindMovie <T>(string path, Folder parent, List <FileSystemMetadata> fileSystemEntries, IDirectoryService directoryService, string collectionType) where T : Video, new() { var multiDiscFolders = new List <FileSystemMetadata>(); // Search for a folder rip foreach (var child in fileSystemEntries) { var filename = child.Name; if ((child.Attributes & FileAttributes.Directory) == FileAttributes.Directory) { if (IsDvdDirectory(filename)) { var movie = new T { Path = path, VideoType = VideoType.Dvd }; Set3DFormat(movie); return(movie); } if (IsBluRayDirectory(filename)) { var movie = new T { Path = path, VideoType = VideoType.BluRay }; Set3DFormat(movie); return(movie); } multiDiscFolders.Add(child); } else if (IsDvdFile(filename)) { var movie = new T { Path = path, VideoType = VideoType.Dvd }; Set3DFormat(movie); return(movie); } } var supportsMultiVersion = !string.Equals(collectionType, CollectionType.HomeVideos) && !string.Equals(collectionType, CollectionType.Photos) && !string.Equals(collectionType, CollectionType.MusicVideos); var result = ResolveVideos <T>(parent, fileSystemEntries, directoryService, supportsMultiVersion); if (result.Items.Count == 1) { var movie = (T)result.Items[0]; movie.IsInMixedFolder = false; movie.Name = Path.GetFileName(movie.ContainingFolderPath); return(movie); } if (result.Items.Count == 0 && multiDiscFolders.Count > 0) { return(GetMultiDiscMovie <T>(multiDiscFolders, directoryService)); } return(null); }
private MultiItemResolverResult ResolveVideos <T>( Folder parent, IEnumerable <FileSystemMetadata> fileSystemEntries, IDirectoryService directoryService, bool suppportMultiEditions, string collectionType, bool parseName) where T : Video, new() { var files = new List <FileSystemMetadata>(); var videos = new List <BaseItem>(); var leftOver = new List <FileSystemMetadata>(); // Loop through each child file/folder and see if we find a video foreach (var child in fileSystemEntries) { // This is a hack but currently no better way to resolve a sometimes ambiguous situation if (string.IsNullOrEmpty(collectionType)) { if (string.Equals(child.Name, "tvshow.nfo", StringComparison.OrdinalIgnoreCase) || string.Equals(child.Name, "season.nfo", StringComparison.OrdinalIgnoreCase)) { return(null); } } if (child.IsDirectory) { leftOver.Add(child); } else if (!IsIgnored(child.Name)) { files.Add(child); } } var namingOptions = ((LibraryManager)LibraryManager).GetNamingOptions(); var resolver = new VideoListResolver(namingOptions); var resolverResult = resolver.Resolve(files, suppportMultiEditions).ToList(); var result = new MultiItemResolverResult { ExtraFiles = leftOver, Items = videos }; var isInMixedFolder = resolverResult.Count > 1 || (parent != null && parent.IsTopParent); foreach (var video in resolverResult) { var firstVideo = video.Files[0]; var videoItem = new T { Path = video.Files[0].Path, IsInMixedFolder = isInMixedFolder, ProductionYear = video.Year, Name = parseName ? video.Name : Path.GetFileNameWithoutExtension(video.Files[0].Path), AdditionalParts = video.Files.Skip(1).Select(i => i.Path).ToArray(), LocalAlternateVersions = video.AlternateVersions.Select(i => i.Path).ToArray() }; SetVideoType(videoItem, firstVideo); Set3DFormat(videoItem, firstVideo); result.Items.Add(videoItem); } result.ExtraFiles.AddRange(files.Where(i => !ContainsFile(resolverResult, i))); return(result); }
public List <LocalImageInfo> GetImages(BaseItem item, string path, bool isPathInMediaFolder, IDirectoryService directoryService) { return(GetImages(item, new[] { path }, isPathInMediaFolder, directoryService)); }
public RoomsController(IBookingRepository bookingRepository, ILocationRepository locationRepository, IRoomRepository roomRepository, IDirectoryService directoryService) { _logger = NLog.LogManager.GetCurrentClassLogger(); _directoryService = directoryService; _locationRepository = locationRepository; _roomRepository = roomRepository; _bookingRepository = bookingRepository; }
/// <summary> /// Adds the external subtitles. /// </summary> /// <param name="video">The video.</param> /// <param name="currentStreams">The current streams.</param> private void AddExternalSubtitles(Video video, List <MediaStream> currentStreams, IDirectoryService directoryService) { var files = GetSubtitleFiles(video, directoryService); var startIndex = currentStreams.Count; var streams = new List <MediaStream>(); var videoFileNameWithoutExtension = Path.GetFileNameWithoutExtension(video.Path); foreach (var file in files) { var fullName = file.FullName; var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fullName); // If the subtitle file matches the video file name if (string.Equals(videoFileNameWithoutExtension, fileNameWithoutExtension, StringComparison.OrdinalIgnoreCase)) { streams.Add(new MediaStream { Index = startIndex++, Type = MediaStreamType.Subtitle, IsExternal = true, Path = fullName, Codec = Path.GetExtension(fullName).ToLower().TrimStart('.') }); } else if (fileNameWithoutExtension.StartsWith(videoFileNameWithoutExtension + ".", StringComparison.OrdinalIgnoreCase)) { // Support xbmc naming conventions - 300.spanish.srt var language = fileNameWithoutExtension.Split('.').LastOrDefault(); // Try to translate to three character code // Be flexible and check against both the full and three character versions var culture = _localization.GetCultures() .FirstOrDefault(i => string.Equals(i.DisplayName, language, StringComparison.OrdinalIgnoreCase) || string.Equals(i.Name, language, StringComparison.OrdinalIgnoreCase) || string.Equals(i.ThreeLetterISOLanguageName, language, StringComparison.OrdinalIgnoreCase) || string.Equals(i.TwoLetterISOLanguageName, language, StringComparison.OrdinalIgnoreCase)); if (culture != null) { language = culture.ThreeLetterISOLanguageName; } streams.Add(new MediaStream { Index = startIndex++, Type = MediaStreamType.Subtitle, IsExternal = true, Path = fullName, Codec = Path.GetExtension(fullName).ToLower().TrimStart('.'), Language = language }); } } video.SubtitleFiles = streams.Select(i => i.Path).OrderBy(i => i).ToList(); currentStreams.AddRange(streams); }
protected async Task Fetch(Video video, CancellationToken cancellationToken, InternalMediaInfoResult data, IIsoMount isoMount, BlurayDiscInfo blurayInfo, IDirectoryService directoryService) { var mediaInfo = MediaEncoderHelpers.GetMediaInfo(data); var mediaStreams = mediaInfo.MediaStreams; video.TotalBitrate = mediaInfo.TotalBitrate; video.FormatName = (mediaInfo.Format ?? string.Empty) .Replace("matroska", "mkv", StringComparison.OrdinalIgnoreCase); if (data.format != null) { // For dvd's this may not always be accurate, so don't set the runtime if the item already has one var needToSetRuntime = video.VideoType != VideoType.Dvd || video.RunTimeTicks == null || video.RunTimeTicks.Value == 0; if (needToSetRuntime && !string.IsNullOrEmpty(data.format.duration)) { video.RunTimeTicks = TimeSpan.FromSeconds(double.Parse(data.format.duration, _usCulture)).Ticks; } if (video.VideoType == VideoType.VideoFile) { var extension = (Path.GetExtension(video.Path) ?? string.Empty).TrimStart('.'); video.Container = extension; } else { video.Container = null; } if (!string.IsNullOrEmpty(data.format.size)) { video.Size = long.Parse(data.format.size, _usCulture); } else { video.Size = null; } } var mediaChapters = (data.Chapters ?? new MediaChapter[] { }).ToList(); var chapters = mediaChapters.Select(GetChapterInfo).ToList(); if (video.VideoType == VideoType.BluRay || (video.IsoType.HasValue && video.IsoType.Value == IsoType.BluRay)) { FetchBdInfo(video, chapters, mediaStreams, blurayInfo); } AddExternalSubtitles(video, mediaStreams, directoryService); FetchWtvInfo(video, data); video.IsHD = mediaStreams.Any(i => i.Type == MediaStreamType.Video && i.Width.HasValue && i.Width.Value >= 1270); if (chapters.Count == 0 && mediaStreams.Any(i => i.Type == MediaStreamType.Video)) { AddDummyChapters(video, chapters); } var videoStream = mediaStreams.FirstOrDefault(i => i.Type == MediaStreamType.Video); video.VideoBitRate = videoStream == null ? null : videoStream.BitRate; video.DefaultVideoStreamIndex = videoStream == null ? (int?)null : videoStream.Index; video.HasSubtitles = mediaStreams.Any(i => i.Type == MediaStreamType.Subtitle); ExtractTimestamp(video); await _encodingManager.RefreshChapterImages(new ChapterImageRefreshOptions { Chapters = chapters, Video = video, ExtractImages = false, SaveChapters = false }, cancellationToken).ConfigureAwait(false); await _itemRepo.SaveMediaStreams(video.Id, mediaStreams, cancellationToken).ConfigureAwait(false); await _itemRepo.SaveChapters(video.Id, chapters, cancellationToken).ConfigureAwait(false); }
private void PopulateBackdrops(BaseItem item, List <LocalImageInfo> images, List <FileSystemMetadata> files, string imagePrefix, bool isInMixedFolder, IDirectoryService directoryService) { if (!string.IsNullOrEmpty(item.Path)) { var name = item.FileNameWithoutExtension; if (!string.IsNullOrEmpty(name)) { AddImage(files, images, imagePrefix + name + "-fanart", ImageType.Backdrop); // Support without the prefix if it's in it's own folder if (!isInMixedFolder) { AddImage(files, images, name + "-fanart", ImageType.Backdrop); } } } PopulateBackdrops(images, files, imagePrefix, "fanart", "fanart-", isInMixedFolder, ImageType.Backdrop); PopulateBackdrops(images, files, imagePrefix, "background", "background-", isInMixedFolder, ImageType.Backdrop); PopulateBackdrops(images, files, imagePrefix, "art", "art-", isInMixedFolder, ImageType.Backdrop); var extraFanartFolder = files .FirstOrDefault(i => string.Equals(i.Name, "extrafanart", StringComparison.OrdinalIgnoreCase)); if (extraFanartFolder != null) { PopulateBackdropsFromExtraFanart(extraFanartFolder.FullName, images, directoryService); } PopulateBackdrops(images, files, imagePrefix, "backdrop", "backdrop", isInMixedFolder, ImageType.Backdrop); }
private void PopulateBackdropsFromExtraFanart(string path, List <LocalImageInfo> images, IDirectoryService directoryService) { var imageFiles = _fileSystem.GetFiles(path, BaseItem.SupportedImageExtensions, false, false); images.AddRange(imageFiles.Where(i => i.Length > 0).Select(i => new LocalImageInfo { FileInfo = i, Type = ImageType.Backdrop })); }
public IEnumerable <MediaStream> GetExternalSubtitleStreams(Video video, int startIndex, IDirectoryService directoryService, bool clearCache) { var files = GetSubtitleFiles(video, directoryService, _fileSystem, clearCache); var streams = new List <MediaStream>(); var videoFileNameWithoutExtension = _fileSystem.GetFileNameWithoutExtension(video.Path); videoFileNameWithoutExtension = NormalizeFilenameForSubtitleComparison(videoFileNameWithoutExtension); foreach (var fullName in files) { var fileNameWithoutExtension = _fileSystem.GetFileNameWithoutExtension(fullName); fileNameWithoutExtension = NormalizeFilenameForSubtitleComparison(fileNameWithoutExtension); var codec = Path.GetExtension(fullName).ToLower().TrimStart('.'); if (string.Equals(codec, "txt", StringComparison.OrdinalIgnoreCase)) { codec = "srt"; } // If the subtitle file matches the video file name if (string.Equals(videoFileNameWithoutExtension, fileNameWithoutExtension, StringComparison.OrdinalIgnoreCase)) { streams.Add(new MediaStream { Index = startIndex++, Type = MediaStreamType.Subtitle, IsExternal = true, Path = fullName, Codec = codec }); } else if (fileNameWithoutExtension.StartsWith(videoFileNameWithoutExtension + ".", StringComparison.OrdinalIgnoreCase)) { var isForced = fullName.IndexOf(".forced.", StringComparison.OrdinalIgnoreCase) != -1 || fullName.IndexOf(".foreign.", StringComparison.OrdinalIgnoreCase) != -1; var isDefault = fullName.IndexOf(".default.", StringComparison.OrdinalIgnoreCase) != -1; // Support xbmc naming conventions - 300.spanish.srt var language = fileNameWithoutExtension .Replace(".forced", string.Empty, StringComparison.OrdinalIgnoreCase) .Replace(".foreign", string.Empty, StringComparison.OrdinalIgnoreCase) .Split('.') .LastOrDefault(); // Try to translate to three character code // Be flexible and check against both the full and three character versions var culture = _localization.GetCultures() .FirstOrDefault(i => string.Equals(i.DisplayName, language, StringComparison.OrdinalIgnoreCase) || string.Equals(i.Name, language, StringComparison.OrdinalIgnoreCase) || string.Equals(i.ThreeLetterISOLanguageName, language, StringComparison.OrdinalIgnoreCase) || string.Equals(i.TwoLetterISOLanguageName, language, StringComparison.OrdinalIgnoreCase)); if (culture != null) { language = culture.ThreeLetterISOLanguageName; } streams.Add(new MediaStream { Index = startIndex++, Type = MediaStreamType.Subtitle, IsExternal = true, Path = fullName, Codec = codec, Language = language, IsForced = isForced, IsDefault = isDefault }); } } return(streams); }
public bool HasChanged(IHasMetadata item, MetadataStatus status, IDirectoryService directoryService) { return GetSupportedImages(item).Any(i => !item.HasImage(i)); }
/// <summary> /// Finds a movie based on a child file system entries. /// </summary> /// <returns>Movie.</returns> private T FindMovie <T>(ItemResolveArgs args, string path, Folder parent, List <FileSystemMetadata> fileSystemEntries, IDirectoryService directoryService, string collectionType, bool parseName) where T : Video, new() { var multiDiscFolders = new List <FileSystemMetadata>(); var libraryOptions = args.GetLibraryOptions(); var supportPhotos = string.Equals(collectionType, CollectionType.HomeVideos, StringComparison.OrdinalIgnoreCase) && libraryOptions.EnablePhotos; var photos = new List <FileSystemMetadata>(); // Search for a folder rip foreach (var child in fileSystemEntries) { var filename = child.Name; if (child.IsDirectory) { if (IsDvdDirectory(child.FullName, filename, directoryService)) { var movie = new T { Path = path, VideoType = VideoType.Dvd }; Set3DFormat(movie); return(movie); } if (IsBluRayDirectory(child.FullName, filename, directoryService)) { var movie = new T { Path = path, VideoType = VideoType.BluRay }; Set3DFormat(movie); return(movie); } multiDiscFolders.Add(child); } else if (IsDvdFile(filename)) { var movie = new T { Path = path, VideoType = VideoType.Dvd }; Set3DFormat(movie); return(movie); } else if (supportPhotos && PhotoResolver.IsImageFile(child.FullName, _imageProcessor)) { photos.Add(child); } } // TODO: Allow GetMultiDiscMovie in here const bool SupportsMultiVersion = true; var result = ResolveVideos <T>(parent, fileSystemEntries, directoryService, SupportsMultiVersion, collectionType, parseName) ?? new MultiItemResolverResult(); if (result.Items.Count == 1) { var videoPath = result.Items[0].Path; var hasPhotos = photos.Any(i => !PhotoResolver.IsOwnedByResolvedMedia(LibraryManager, videoPath, i.Name)); if (!hasPhotos) { var movie = (T)result.Items[0]; movie.IsInMixedFolder = false; movie.Name = Path.GetFileName(movie.ContainingFolderPath); return(movie); } } else if (result.Items.Count == 0 && multiDiscFolders.Count > 0) { return(GetMultiDiscMovie <T>(multiDiscFolders, directoryService)); } return(null); }
/// <summary> /// Determine if the supplied file data points to a music album /// </summary> public bool IsMusicAlbum(string path, IDirectoryService directoryService, LibraryOptions libraryOptions) { return(ContainsMusic(directoryService.GetFileSystemEntries(path), true, directoryService, _logger, _fileSystem, libraryOptions, _libraryManager)); }
/// <summary> /// Gets the filtered file system entries. /// </summary> /// <param name="directoryService">The directory service.</param> /// <param name="path">The path.</param> /// <param name="fileSystem">The file system.</param> /// <param name="logger">The logger.</param> /// <param name="args">The args.</param> /// <param name="flattenFolderDepth">The flatten folder depth.</param> /// <param name="resolveShortcuts">if set to <c>true</c> [resolve shortcuts].</param> /// <returns>Dictionary{System.StringFileSystemInfo}.</returns> /// <exception cref="System.ArgumentNullException">path</exception> public static Dictionary <string, FileSystemMetadata> GetFilteredFileSystemEntries(IDirectoryService directoryService, string path, IFileSystem fileSystem, ILogger logger, ItemResolveArgs args, int flattenFolderDepth = 0, bool resolveShortcuts = true) { if (string.IsNullOrEmpty(path)) { throw new ArgumentNullException("path"); } if (args == null) { throw new ArgumentNullException("args"); } if (!resolveShortcuts && flattenFolderDepth == 0) { return(directoryService.GetFileSystemDictionary(path)); } var entries = directoryService.GetFileSystemEntries(path); var dict = new Dictionary <string, FileSystemMetadata>(StringComparer.OrdinalIgnoreCase); foreach (var entry in entries) { var isDirectory = entry.IsDirectory; var fullName = entry.FullName; if (resolveShortcuts && fileSystem.IsShortcut(fullName)) { try { var newPath = fileSystem.ResolveShortcut(fullName); if (string.IsNullOrWhiteSpace(newPath)) { //invalid shortcut - could be old or target could just be unavailable logger.Warn("Encountered invalid shortcut: " + fullName); continue; } // Don't check if it exists here because that could return false for network shares. var data = fileSystem.GetDirectoryInfo(newPath); // add to our physical locations args.AddAdditionalLocation(newPath); dict[newPath] = data; } catch (Exception ex) { logger.ErrorException("Error resolving shortcut from {0}", ex, fullName); } } else if (flattenFolderDepth > 0 && isDirectory) { foreach (var child in GetFilteredFileSystemEntries(directoryService, fullName, fileSystem, logger, args, flattenFolderDepth: flattenFolderDepth - 1, resolveShortcuts: resolveShortcuts)) { dict[child.Key] = child.Value; } } else { dict[fullName] = entry; } } return(dict); }
/// <summary> /// Gets the multi disc movie. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="multiDiscFolders">The folders.</param> /// <param name="directoryService">The directory service.</param> /// <returns>``0.</returns> private T GetMultiDiscMovie <T>(List <FileSystemMetadata> multiDiscFolders, IDirectoryService directoryService) where T : Video, new() { var videoTypes = new List <VideoType>(); var folderPaths = multiDiscFolders.Select(i => i.FullName).Where(i => { var subFileEntries = directoryService.GetFileSystemEntries(i) .ToList(); var subfolders = subFileEntries .Where(e => (e.Attributes & FileAttributes.Directory) == FileAttributes.Directory) .Select(d => d.Name) .ToList(); if (subfolders.Any(IsDvdDirectory)) { videoTypes.Add(VideoType.Dvd); return(true); } if (subfolders.Any(IsBluRayDirectory)) { videoTypes.Add(VideoType.BluRay); return(true); } var subFiles = subFileEntries .Where(e => (e.Attributes & FileAttributes.Directory) != FileAttributes.Directory) .Select(d => d.Name); if (subFiles.Any(IsDvdFile)) { videoTypes.Add(VideoType.Dvd); return(true); } return(false); }).OrderBy(i => i).ToList(); // If different video types were found, don't allow this if (videoTypes.Distinct().Count() > 1) { return(null); } if (folderPaths.Count == 0) { return(null); } var namingOptions = ((LibraryManager)LibraryManager).GetNamingOptions(); var resolver = new StackResolver(namingOptions, new PatternsLogger()); var result = resolver.ResolveDirectories(folderPaths); if (result.Stacks.Count != 1) { return(null); } var returnVideo = new T { Path = folderPaths[0], AdditionalParts = folderPaths.Skip(1).ToList(), VideoType = videoTypes[0], Name = result.Stacks[0].Name }; SetIsoType(returnVideo); return(returnVideo); }
protected override IEnumerable <BaseItem> GetNonCachedChildren(IDirectoryService directoryService) { return(new List <BaseItem>()); }
private IEnumerable <FileSystemMetadata> GetFiles(BaseItem item, bool includeDirectories, IDirectoryService directoryService) { if (!item.IsFileProtocol) { return(new List <FileSystemMetadata>()); } var path = item.ContainingFolderPath; if (includeDirectories) { return(directoryService.GetFileSystemEntries(path) .Where(i => BaseItem.SupportedImageExtensions.Contains(i.Extension, StringComparer.OrdinalIgnoreCase) || i.IsDirectory) .OrderBy(i => BaseItem.SupportedImageExtensionsList.IndexOf(i.Extension ?? string.Empty))); } return(directoryService.GetFiles(path) .Where(i => BaseItem.SupportedImageExtensions.Contains(i.Extension, StringComparer.OrdinalIgnoreCase)) .OrderBy(i => BaseItem.SupportedImageExtensionsList.IndexOf(i.Extension ?? string.Empty))); }
protected override Task ValidateChildrenInternal(IProgress <double> progress, bool recursive, bool refreshChildMetadata, MetadataRefreshOptions refreshOptions, IDirectoryService directoryService, CancellationToken cancellationToken) { return(Task.CompletedTask); }
private void PopulateImages(BaseItem item, List <LocalImageInfo> images, List <FileSystemMetadata> files, bool supportParentSeriesFiles, IDirectoryService directoryService) { if (supportParentSeriesFiles) { var season = item as Season; if (season != null) { PopulateSeasonImagesFromSeriesFolder(season, images, directoryService); } } var imagePrefix = item.FileNameWithoutExtension + "-"; var isInMixedFolder = item.IsInMixedFolder; PopulatePrimaryImages(item, images, files, imagePrefix, isInMixedFolder); var added = false; var isEpisode = item is Episode; var isSong = item.GetType() == typeof(Audio); var isGame = item is Game; var isPerson = item is Person; // Logo if (!isEpisode && !isSong && !isPerson) { added = AddImage(files, images, "logo", imagePrefix, isInMixedFolder, ImageType.Logo); if (!added) { added = AddImage(files, images, "clearlogo", imagePrefix, isInMixedFolder, ImageType.Logo); } } // Art if (!isEpisode && !isSong && !isPerson) { AddImage(files, images, "clearart", imagePrefix, isInMixedFolder, ImageType.Art); } // For music albums, prefer cdart before disc if (item is MusicAlbum) { added = AddImage(files, images, "cdart", imagePrefix, isInMixedFolder, ImageType.Disc); if (!added) { added = AddImage(files, images, "disc", imagePrefix, isInMixedFolder, ImageType.Disc); } } else if (isGame || item is Video || item is BoxSet) { added = AddImage(files, images, "disc", imagePrefix, isInMixedFolder, ImageType.Disc); if (!added) { added = AddImage(files, images, "cdart", imagePrefix, isInMixedFolder, ImageType.Disc); } if (!added) { added = AddImage(files, images, "discart", imagePrefix, isInMixedFolder, ImageType.Disc); } } if (isGame) { AddImage(files, images, "box", imagePrefix, isInMixedFolder, ImageType.Box); AddImage(files, images, "menu", imagePrefix, isInMixedFolder, ImageType.Menu); added = AddImage(files, images, "back", imagePrefix, isInMixedFolder, ImageType.BoxRear); if (!added) { added = AddImage(files, images, "boxrear", imagePrefix, isInMixedFolder, ImageType.BoxRear); } } // Banner if (!isEpisode && !isSong && !isPerson) { AddImage(files, images, "banner", imagePrefix, isInMixedFolder, ImageType.Banner); } // Thumb if (!isEpisode && !isSong && !isPerson) { added = AddImage(files, images, "landscape", imagePrefix, isInMixedFolder, ImageType.Thumb); if (!added) { added = AddImage(files, images, "thumb", imagePrefix, isInMixedFolder, ImageType.Thumb); } } if (!isEpisode && !isSong && !isPerson) { PopulateBackdrops(item, images, files, imagePrefix, isInMixedFolder, directoryService); } if (item is IHasScreenshots) { PopulateScreenshots(images, files, imagePrefix, isInMixedFolder); } }
protected override FileSystemMetadata GetXmlFile(ItemInfo info, IDirectoryService directoryService) { return(directoryService.GetFile(Path.Combine(info.Path, "gamesystem.xml"))); }
public DirectoriesController(IDirectoryService directoryService) { _directoryService = directoryService; }
/// <summary> /// Finds a movie based on a child file system entries /// </summary> /// <typeparam name="T"></typeparam> /// <param name="path">The path.</param> /// <param name="parent">The parent.</param> /// <param name="fileSystemEntries">The file system entries.</param> /// <param name="directoryService">The directory service.</param> /// <param name="supportMultiFileItems">if set to <c>true</c> [support multi file items].</param> /// <returns>Movie.</returns> private T FindMovie <T>(string path, Folder parent, IEnumerable <FileSystemInfo> fileSystemEntries, IDirectoryService directoryService, bool supportMultiFileItems, bool supportsMultipleSources) where T : Video, new() { var movies = new List <T>(); var multiDiscFolders = new List <FileSystemInfo>(); // Loop through each child file/folder and see if we find a video foreach (var child in fileSystemEntries) { var filename = child.Name; if ((child.Attributes & FileAttributes.Directory) == FileAttributes.Directory) { if (IsDvdDirectory(filename)) { return(new T { Path = path, VideoType = VideoType.Dvd }); } if (IsBluRayDirectory(filename)) { return(new T { Path = path, VideoType = VideoType.BluRay }); } if (EntityResolutionHelper.IsMultiPartFolder(filename)) { multiDiscFolders.Add(child); } continue; } // Don't misidentify xbmc trailers as a movie if (filename.IndexOf(BaseItem.XbmcTrailerFileSuffix, StringComparison.OrdinalIgnoreCase) != -1) { continue; } var childArgs = new ItemResolveArgs(_applicationPaths, _libraryManager, directoryService) { FileInfo = child, Path = child.FullName, Parent = parent }; var item = ResolveVideo <T>(childArgs); if (item != null) { item.IsInMixedFolder = false; movies.Add(item); } } if (movies.Count > 1) { if (supportMultiFileItems) { var result = GetMultiFileMovie(movies); if (result != null) { return(result); } } if (supportsMultipleSources) { var result = GetMovieWithMultipleSources(movies); if (result != null) { return(result); } } return(null); } if (movies.Count == 1) { return(movies[0]); } if (multiDiscFolders.Count > 0) { var folders = fileSystemEntries.Where(child => (child.Attributes & FileAttributes.Directory) == FileAttributes.Directory); return(GetMultiDiscMovie <T>(multiDiscFolders, folders)); } return(null); }
public AliasesRepository(ILogger logger, IAliasesService aliasesService, IDirectoryService directoryService) { _logger = logger; _aliasesService = aliasesService; _directoryService = directoryService; }
protected override FileSystemMetadata GetJsonFile(ItemInfo info, IDirectoryService directoryService) { return(directoryService.GetFile( Path.ChangeExtension(info.Path, ".json") )); }
private void PopulateSeasonImagesFromSeriesFolder(Season season, List <LocalImageInfo> images, IDirectoryService directoryService) { var seasonNumber = season.IndexNumber; var series = season.Series; if (!seasonNumber.HasValue || !series.IsFileProtocol) { return; } var seriesFiles = GetFiles(series, false, directoryService).ToList(); // Try using the season name var prefix = season.Name.ToLower().Replace(" ", string.Empty); var filenamePrefixes = new List <string> { prefix }; var seasonMarker = seasonNumber.Value == 0 ? "-specials" : seasonNumber.Value.ToString("00", _usCulture); // Get this one directly from the file system since we have to go up a level if (!string.Equals(prefix, seasonMarker, StringComparison.OrdinalIgnoreCase)) { filenamePrefixes.Add("season" + seasonMarker); } foreach (var filename in filenamePrefixes) { AddImage(seriesFiles, images, filename + "-poster", ImageType.Primary); AddImage(seriesFiles, images, filename + "-fanart", ImageType.Backdrop); AddImage(seriesFiles, images, filename + "-banner", ImageType.Banner); AddImage(seriesFiles, images, filename + "-landscape", ImageType.Thumb); } }
protected override Task ValidateChildrenInternal(IProgress <double> progress, CancellationToken cancellationToken, bool recursive, bool refreshChildMetadata, MetadataRefreshOptions refreshOptions, IDirectoryService directoryService) { if (IsAccessedByName) { // Should never get in here anyway return(Task.CompletedTask); } return(base.ValidateChildrenInternal(progress, cancellationToken, recursive, refreshChildMetadata, refreshOptions, directoryService)); }
protected override FileSystemMetadata GetXmlFile(ItemInfo info, IDirectoryService directoryService) { return(MovieXmlProvider.GetXmlFileInfo(info, FileSystem)); }
/// <summary> /// Gets the multi disc movie. /// </summary> /// <param name="multiDiscFolders">The folders.</param> /// <param name="directoryService">The directory service.</param> /// <returns>``0.</returns> private T GetMultiDiscMovie <T>(List <FileSystemMetadata> multiDiscFolders, IDirectoryService directoryService) where T : Video, new() { var videoTypes = new List <VideoType>(); var folderPaths = multiDiscFolders.Select(i => i.FullName).Where(i => { var subFileEntries = directoryService.GetFileSystemEntries(i); var subfolders = subFileEntries .Where(e => e.IsDirectory) .ToList(); if (subfolders.Any(s => IsDvdDirectory(s.FullName, s.Name, directoryService))) { videoTypes.Add(VideoType.Dvd); return(true); } if (subfolders.Any(s => IsBluRayDirectory(s.FullName, s.Name, directoryService))) { videoTypes.Add(VideoType.BluRay); return(true); } var subFiles = subFileEntries .Where(e => !e.IsDirectory) .Select(d => d.Name); if (subFiles.Any(IsDvdFile)) { videoTypes.Add(VideoType.Dvd); return(true); } return(false); }).OrderBy(i => i).ToList(); // If different video types were found, don't allow this if (videoTypes.Distinct().Count() > 1) { return(null); } if (folderPaths.Count == 0) { return(null); } var namingOptions = ((LibraryManager)LibraryManager).GetNamingOptions(); var result = new StackResolver(namingOptions).ResolveDirectories(folderPaths).ToList(); if (result.Count != 1) { return(null); } int additionalPartsLen = folderPaths.Count - 1; var additionalParts = new string[additionalPartsLen]; folderPaths.CopyTo(1, additionalParts, 0, additionalPartsLen); var returnVideo = new T { Path = folderPaths[0], AdditionalParts = additionalParts, VideoType = videoTypes[0], Name = result[0].Name }; SetIsoType(returnVideo); return(returnVideo); }
public MetadataRefreshOptions(IDirectoryService directoryService) : base(directoryService) { MetadataRefreshMode = MetadataRefreshMode.Default; }
public bool HasChanged(IHasMetadata item, IDirectoryService directoryService, DateTime date) { if (!_config.Configuration.EnableFanArtUpdates) { return false; } var tvdbId = item.GetProviderId(MetadataProviders.Tvdb); if (!String.IsNullOrEmpty(tvdbId)) { // Process images var imagesXmlPath = GetFanartXmlPath(tvdbId); var fileInfo = new FileInfo(imagesXmlPath); return !fileInfo.Exists || _fileSystem.GetLastWriteTimeUtc(fileInfo) > date; } return false; }
public List <LocalImageInfo> GetImages(BaseItem item, IDirectoryService directoryService) { var collectionFolder = (CollectionFolder)item; return(new LocalImageProvider(_fileSystem).GetImages(item, collectionFolder.PhysicalLocations, true, directoryService)); }