public bool TryGetFanArt(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom, out IList <FanArtImage> result) { result = null; if (mediaType != FanArtConstants.FanArtMediaType.Album || fanArtType != FanArtConstants.FanArtType.Poster || string.IsNullOrEmpty(name)) { return(false); } IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(false); if (mediaLibrary == null) { return(false); } IFilter filter = new RelationalFilter(AudioAspect.ATTR_ALBUM, RelationalOperator.EQ, name); MediaItemQuery query = new MediaItemQuery(NECESSARY_MIAS, filter); var items = mediaLibrary.Search(query, false); result = new List <FanArtImage>(); foreach (var mediaItem in items) { byte[] textureData; if (!MediaItemAspect.TryGetAttribute(mediaItem.Aspects, ThumbnailLargeAspect.ATTR_THUMBNAIL, out textureData)) { continue; } // Only one record required result.Add(new FanArtImage(name, textureData)); return(true); } return(true); }
protected void ImportRecording(string fileName) { ISystemResolver systemResolver = ServiceRegistration.Get <ISystemResolver>(); IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(); List <Share> possibleShares = new List <Share>(); // Shares can point to different depth, we try to find the deepest one foreach (var share in mediaLibrary.GetShares(systemResolver.LocalSystemId).Values) { var dir = LocalFsResourceProviderBase.ToDosPath(share.BaseResourcePath.LastPathSegment.Path); if (dir != null && fileName.StartsWith(dir, StringComparison.InvariantCultureIgnoreCase)) { possibleShares.Add(share); } } if (possibleShares.Count == 0) { ServiceRegistration.Get <ILogger>().Warn("SlimTvService: Received notifaction of new recording but could not find a media source. Have you added recordings folder as media source? File: {0}", fileName); return; } Share usedShare = possibleShares.OrderByDescending(s => s.BaseResourcePath.LastPathSegment.Path.Length).First(); IImporterWorker importerWorker = ServiceRegistration.Get <IImporterWorker>(); importerWorker.ScheduleImport(LocalFsResourceProviderBase.ToResourcePath(fileName), usedShare.MediaCategories, false); }
protected bool TryGetMediaItem(string name, out MediaItem mediaItem) { mediaItem = null; Guid mediaItemId; if (!Guid.TryParse(name, out mediaItemId) || mediaItemId == Guid.Empty) { return(false); } IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(false); if (mediaLibrary == null) { return(false); } IFilter filter = new MediaItemIdFilter(mediaItemId); IList <MediaItem> items = mediaLibrary.Search(new MediaItemQuery(NECESSARY_MIAS, filter), false, null, true); if (items == null || items.Count == 0) { return(false); } mediaItem = items.First(); return(true); }
/// <summary> /// Deletes the specified <see cref="IMediaLibrary"/> in the CMS System. /// </summary> /// <param name="library">The <see cref="IMediaLibrary"/> to set.</param> private void RemoveMediaLibrary(IMediaLibrary library) { if (this.ShouldProcess(library.LibraryName, "delete")) { this.MediaLibraryService.DeleteMediaLibrary(library); } }
public override void Initialise(string sortCriteria, uint?offset = null, uint?count = null) { Logger.Debug("MediaServer initialise share containers"); base.Initialise(sortCriteria, offset, count); IDictionary <Guid, Share> shares = GetShares(); IMediaLibrary library = ServiceRegistration.Get <IMediaLibrary>(); BasicContainer parent = new BasicContainer(Id, Client); var items = (from share in shares select new { Item = library.LoadItem(share.Value.SystemId, share.Value.BaseResourcePath, NECESSARY_SHARE_MIA_TYPE_IDS, OPTIONAL_SHARE_MIA_TYPE_IDS), ShareName = share.Value.Name }).ToList(); foreach (var item in items.OrderBy(s => s.ShareName)) { try { if (item.Item != null) { Add((BasicObject)MediaLibraryHelper.InstansiateMediaLibraryObject(item.Item, parent, item.ShareName)); } } catch (Exception ex) { Logger.Error("Media item '{0}' could not be added", ex, item.Item); } } }
public override void Initialise(string sortCriteria, uint?offset = null, uint?count = null) { base.Initialise(sortCriteria, offset, count); IMediaLibrary library = ServiceRegistration.Get <IMediaLibrary>(); var allowedShares = GetAllowedShares(); List <MediaItem> shares = new List <MediaItem>(); foreach (var share in allowedShares) { if (share.MediaCategories.Any(x => x.Contains("Image"))) { MediaItem item = library.LoadItem(share.SystemId, share.BaseResourcePath, NECESSARY_SHARE_MIA_TYPE_IDS, OPTIONAL_SHARE_MIA_TYPE_IDS, UserId); if (item != null && item.Aspects.ContainsKey(DirectoryAspect.ASPECT_ID)) { shares.Add(item); } } } foreach (MediaItem share in shares.OrderBy(s => MediaItemAspect.TryGetAspect(s.Aspects, MediaAspect.Metadata, out var aspect) ? aspect.GetAttributeValue <string>(MediaAspect.ATTR_SORT_TITLE) : "")) { IList <MediaItem> albums = library.Browse(share.MediaItemId, NECESSARY_SHARE_MIA_TYPE_IDS, OPTIONAL_SHARE_MIA_TYPE_IDS, UserId, false); foreach (MediaItem album in albums) { if (album != null && album.Aspects.ContainsKey(DirectoryAspect.ASPECT_ID)) { Add(new MediaLibraryBrowser(album, Client)); } } } }
public void DetachClientAndRemoveShares(string clientSystemId) { ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>(); ITransaction transaction = database.BeginTransaction(); try { using (IDbCommand command = ClientManager_SubSchema.DeleteAttachedClientCommand(transaction, clientSystemId)) command.ExecuteNonQuery(); IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(); mediaLibrary.DeleteMediaItemOrPath(clientSystemId, null, true); mediaLibrary.RemoveSharesOfSystem(clientSystemId); transaction.Commit(); } catch (Exception e) { ServiceRegistration.Get <ILogger>().Error("ClientManager: Error detaching client '{0}'", e, clientSystemId); transaction.Rollback(); throw; } ServiceRegistration.Get <ILogger>().Info("ClientManager: Client with system ID '{0}' detached", clientSystemId); // Last action: Remove the client from the collection of attached clients and disconnect the client connection, if connected _attachedClients = ReadAttachedClientsFromDB(); _controlPoint.RemoveAttachedClient(clientSystemId); ClientManagerMessaging.SendClientAttachmentChangeMessage(ClientManagerMessaging.MessageType.ClientDetached, clientSystemId); }
/// <summary> /// Checks whether the <paramref name="action"/> has any aspects and if not /// tries to restore them from the media library. /// </summary> /// <param name="action">The action to check.</param> /// <returns>True if the aspects were present or successfully restored.</returns> protected async Task <bool> TryRestoreAspects(FanArtManagerAction action) { //Already has aspects, nothing to do if (action.Aspects != null) { return(true); } //No aspects, this resource was restored from disk, try and restore the aspects from the media library. //Throttle the number of concurrent queries To avoid a spike during startup. await _loadItemThrottle.WaitAsync(_cts.Token); try { IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(); MediaItemQuery query = new MediaItemQuery(null, mediaLibrary.GetManagedMediaItemAspectMetadata().Keys, new MediaItemIdFilter(action.MediaItemId)); var items = mediaLibrary.Search(query, false, null, true); if (items != null && items.Count > 0) { action.Aspects = items[0].Aspects; return(true); } ServiceRegistration.Get <ILogger>().Warn("FanArtActionBlock: Unable to restore FanArtAction, media item with id {0} was not found in the media library", action.MediaItemId); return(false); } finally { _loadItemThrottle.Release(); } }
public Task RegisterLocallyKnownMediaItemAspectTypeAsync(MediaItemAspectMetadata miam) { IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(); mediaLibrary.AddMediaItemAspectStorage(miam); return(Task.CompletedTask); }
public bool TryGetFanArt(string mediaType, string fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom, out IList <FanArtImage> result) { result = null; Guid mediaItemId; var isImage = mediaType == FanArtMediaTypes.Image; if (!Guid.TryParse(name, out mediaItemId) || mediaType != FanArtMediaTypes.Undefined && !isImage || fanArtType != FanArtTypes.Thumbnail) { return(false); } IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(false); if (mediaLibrary == null) { return(false); } // Try to load thumbnail from ML List <Guid> thumbGuids = new List <Guid> { ThumbnailLargeAspect.ASPECT_ID }; // Check for Image's rotation info if (isImage) { thumbGuids.Add(ImageAspect.ASPECT_ID); } IFilter filter = new MediaItemIdFilter(mediaItemId); IList <MediaItem> items = mediaLibrary.Search(new MediaItemQuery(thumbGuids, filter), false, null, true); if (items == null || items.Count == 0) { return(false); } MediaItem mediaItem = items.First(); byte[] textureData; if (!MediaItemAspect.TryGetAttribute(mediaItem.Aspects, ThumbnailLargeAspect.ATTR_THUMBNAIL, out textureData)) { return(false); } if (isImage) { textureData = AutoRotateThumb(mediaItem, textureData); } // Only one record required result = new List <FanArtImage> { new FanArtImage(name, textureData) }; return(true); }
public void VerifyCreate(IMediaLibrary expectedLibrary) { this.libraryMock.LibraryDisplayName.Should().Be(expectedLibrary.LibraryDisplayName); this.libraryMock.LibraryName.Should().Be(expectedLibrary.LibraryName); this.libraryMock.LibrarySiteID.Should().Be(expectedLibrary.LibrarySiteID); this.libraryMock.LibraryDescription.Should().Be(expectedLibrary.LibraryDescription); this.libraryMock.LibraryFolder.Should().Be(expectedLibrary.LibraryFolder); }
public AddMovieViewModel(IMediaLibrary library, IEventAggregator eventAggregator) { Add = new DelegateCommand(() => AddMovie(library, eventAggregator)); Delete = new DelegateCommand(() => DeleteMovie(library, eventAggregator)); DeleteDialog = new DelegateCommand(DeleteDialogBox); CancelDelete = new DelegateCommand(CancelDeleteDialog); DeleteDialogOpen = false; }
/// <inheritdoc/> protected override void ActOnObject(IMediaLibrary library) { if (this.MediaLibrary != null) { library = this.MediaLibrary.ActLike <IMediaLibrary>(); } this.RemoveBusinessLayer.Remove(library); }
/// <inheritdoc/> protected override void ActOnObject(IMediaLibrary library) { if (this.MediaLibrary != null) { library = this.MediaLibrary.ActLike <IMediaLibrary>(); } this.SetOptionBusinessLayer.SetMediaLibrarySecurityOption(library, this.SecurityProperty, this.SecurityAccess); }
public static MediaItem GetMediaItem(this IMediaLibrary mediaLibrary, Guid mediaItemId, IEnumerable <Guid> necessaryMIATypes, IEnumerable <Guid> optionalMIATypes) { var items = mediaLibrary.LoadCustomPlaylist(new List <Guid>() { mediaItemId }, necessaryMIATypes, optionalMIATypes); return(items.Count > 0 ? items[0] : null); }
public void SetMediaLibrarySecurityOption(IMediaLibrary library, SecurityPropertyEnum option, SecurityAccessEnum securityAccess) { MediaLibraryMock mock = (MediaLibraryMock)library; // Get security property name from enum string propName = Enum.GetName(typeof(SecurityPropertyEnum), option); // Set security property value using reflection mock.GetType().GetProperty(propName).SetValue(library, securityAccess); }
/// <inheritdoc/> public void DeleteMediaLibrary(IMediaLibrary library) { // Gets the media library var deleteLibrary = GetMediaLibrary(library); if (deleteLibrary != null) { // Deletes the media library MediaLibraryInfoProvider.DeleteMediaLibraryInfo(deleteLibrary); } }
/// <summary> /// Adds a movie and raises an event /// </summary> /// <param name="library"></param> /// <param name="eventAggregator"></param> private void AddMovie(IMediaLibrary library, IEventAggregator eventAggregator) { var movie = new Movie { Title = this.Title, ReleaseDate = DateTime.Now }; library.Add(movie); eventAggregator.Raise <IMovieAdded>(evt => evt.Movie = movie); }
public HomogenousMap GetItems(string sortCriteria) { List <Guid> necessaryMias = new List <Guid>(_necessaryMiaTypeIds); if (necessaryMias.Contains(MediaAspect.ASPECT_ID)) { necessaryMias.Remove(MediaAspect.ASPECT_ID); //Group MIA cannot be present } IMediaLibrary library = ServiceRegistration.Get <IMediaLibrary>(); return(library.GetValueGroups(MediaAspect.ATTR_RECORDINGTIME, null, ProjectionFunction.DateToYear, necessaryMias, null, true, false)); }
private void AddMovie(IMediaLibrary library, IEventAggregator eventAggregator) { var movie = new Movie { Title = this.Title, ReleaseDate = DateTime.Now }; library.Add(movie); eventAggregator.Raise<IMovieAdded>(evt => evt.Movie = movie); }
public HomogenousMap GetItems(string sortCriteria) { List <Guid> necessaryMias = new List <Guid>(_necessaryMIAs); if (necessaryMias.Contains(GenreAspect.ASPECT_ID)) { necessaryMias.Remove(GenreAspect.ASPECT_ID); //Group MIA cannot be present } IMediaLibrary library = ServiceRegistration.Get <IMediaLibrary>(); return(library.GetValueGroups(GenreAspect.ATTR_GENRE, null, ProjectionFunction.None, necessaryMias, AppendUserFilter(null, necessaryMias), true, false)); }
/// <summary> /// Checks whether the <paramref name="actions"/> has any aspects and if not /// tries to load them from the media library. /// </summary> /// <param name="actions">The action to check.</param> /// <returns>True if the aspects were present or successfully loaded.</returns> protected async Task LoadAspects(FanArtManagerAction[] actions) { var mediaItemIds = actions.Where(a => a.Type == ActionType.Collect && (a.Aspects == null || a.Aspects.Count == 0)) .Select(a => a.MediaItemId).Distinct(); var queryFilter = new MediaItemIdFilter(mediaItemIds); if (queryFilter.MediaItemIds.Count == 0) { return; } IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(); MediaItemQuery query = new MediaItemQuery(null, mediaLibrary.GetManagedMediaItemAspectMetadata().Keys, queryFilter); // Throttle the number of concurrent queries To avoid spikes when loading aspects. await _loadItemThrottle.WaitAsync(_cts.Token); try { var items = mediaLibrary.Search(query, false, null, true); if (items != null && items.Count > 0) { foreach (var item in items) { foreach (var action in actions) { if (action.MediaItemId == item.MediaItemId) { action.Aspects = item.Aspects; break; } } } } else { ServiceRegistration.Get <ILogger>().Warn("FanArtActionBlock: Unable to load aspects, no matching media items were found in the media library"); } } catch (Exception ex) { ServiceRegistration.Get <ILogger>().Error("FanArtActionBlock: Error loading aspects from the media library", ex); } finally { _loadItemThrottle.Release(); } }
private IList <MediaItem> GetItems(string sortCriteria) { IMediaLibrary library = ServiceRegistration.Get <IMediaLibrary>(); IFilter filter = new FilteredRelationshipFilter(_role, _linkedRole, AppendUserFilter(null, _necessaryMIAs)); MediaItemQuery query = new MediaItemQuery(NECESSARY_PERSON_MIA_TYPE_IDS, filter) { SortInformation = new List <ISortInformation> { new AttributeSortInformation(PersonAspect.ATTR_PERSON_NAME, SortDirection.Ascending) }, }; return(library.Search(query, true, UserId, false)); }
protected bool GetSharesForPath(ResourcePath resourcePath, string localSystemId, out List <Share> possibleShares) { IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(); possibleShares = new List <Share>(); foreach (var share in mediaLibrary.GetShares(localSystemId).Values) { if (resourcePath.ToString().StartsWith(share.BaseResourcePath.ToString(), StringComparison.InvariantCultureIgnoreCase)) { possibleShares.Add(share); } } return(possibleShares.Count > 0); }
public IMediaLibrary CreateMediaLibrary(IMediaLibrary library) { this.libraryMock = library; var testServer = new Mock <IMediaLibrary>(); testServer.SetupGet(x => x.LibraryDisplayName).Returns(library.LibraryDisplayName); testServer.SetupGet(x => x.LibraryName).Returns(library.LibraryName); testServer.SetupGet(x => x.LibrarySiteID).Returns(library.LibrarySiteID); testServer.SetupGet(x => x.LibraryDescription).Returns(library.LibraryDescription); testServer.SetupGet(x => x.LibraryFolder).Returns(library.LibraryFolder); return(testServer.Object); }
protected SpecialPlaylistBase(IMediaLibrary library, PlaylistType type, string name) { if (library == null) throw new ArgumentNullException("library"); if (type == PlaylistType.None) throw new ArgumentException("type"); if (string.IsNullOrEmpty(name)) name = type.ToString(); m_library = library; m_type = type; m_id = library.Id + (byte)type; m_name = name; }
protected bool GetSharesForPath(string fileName, string localSystemId, out List <Share> possibleShares) { IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(); possibleShares = new List <Share>(); foreach (var share in mediaLibrary.GetShares(localSystemId).Values) { var dir = LocalFsResourceProviderBase.ToDosPath(share.BaseResourcePath.LastPathSegment.Path); if (dir != null && fileName.StartsWith(dir, StringComparison.InvariantCultureIgnoreCase)) { possibleShares.Add(share); } } return(possibleShares.Count > 0); }
/// <inheritdoc/> public IMediaFile GetMediaFile(IMediaLibrary library, string folder, string fileName) { MediaFileInfo mediaFile = null; // Gets the media library var existingLibrary = GetMediaLibrary(library); if (existingLibrary != null) { // Gets the media file mediaFile = MediaFileInfoProvider.GetMediaFileInfo(existingLibrary.LibraryID, $"{folder}/{fileName}"); } return(mediaFile.ActLike <IMediaFile>()); }
private IDictionary <Guid, Share> GetShares() { var allowedShares = GetAllowedShares(); IDictionary <Guid, Share> shares = new Dictionary <Guid, Share>(); IMediaLibrary library = ServiceRegistration.Get <IMediaLibrary>(); foreach (var share in GetAllowedShares()) { if (CategoryFilter == null || CategoryFilter.Count == 0 || share.MediaCategories.Any(x => CategoryFilter.Contains(x))) { shares.Add(share.ShareId, share); } } return(shares); }
public ICollection <string> GetMediaCategories(ResourcePath path) { ISystemResolver systemResolver = ServiceRegistration.Get <ISystemResolver>(); IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(); ICollection <Share> shares = mediaLibrary.GetShares(systemResolver.LocalSystemId).Values; Share bestShare = SharesHelper.BestContainingPath(shares, path); List <string> categories = new List <string>(); if (bestShare != null) { categories.AddRange(bestShare.MediaCategories); } return(categories); }
/// <inheritdoc/> public void SetMediaLibrarySecurityOption(IMediaLibrary library, SecurityPropertyEnum option, SecurityAccessEnum securityAccess) { // Gets the media library var existingLibrary = GetMediaLibrary(library); if (existingLibrary != null) { // Get security property name from enum string propName = Enum.GetName(typeof(SecurityPropertyEnum), option); // Set security property value using reflection existingLibrary.GetType().GetProperty(propName).SetValue(existingLibrary, securityAccess); // Saves the updated media library to the database MediaLibraryInfoProvider.SetMediaLibraryInfo(existingLibrary); } }
protected ICollection <Share> GetAllowedShares() { IMediaLibrary library = ServiceRegistration.Get <IMediaLibrary>(); ICollection <Share> shares = library.GetShares(null)?.Values; IUserProfileDataManagement userProfileDataManagement = ServiceRegistration.Get <IUserProfileDataManagement>(); var res = userProfileDataManagement.GetProfileAsync(UserId).Result; if (!res.Success || !res.Result.RestrictShares) { return(shares); } var allowedShareIds = res.Result.GetAllowedShares(); return(shares.Where(s => allowedShareIds.Contains(s.ShareId)).ToList()); }
/// <inheritdoc/> public IMediaLibrary CreateMediaLibrary(IMediaLibrary library) { // Creates a new media library object MediaLibraryInfo newLibrary = new MediaLibraryInfo { // Sets the library properties LibraryDisplayName = library.LibraryDisplayName, LibraryName = library.LibraryName, LibraryDescription = library.LibraryDescription, LibraryFolder = library.LibraryFolder, LibrarySiteID = library.LibrarySiteID, }; // Saves the new media library to the database MediaLibraryInfoProvider.SetMediaLibraryInfo(newLibrary); return(newLibrary.ActLike <IMediaLibrary>()); }
/// <summary> /// Initializes the controller /// </summary> /// <param name="library">Library to use</param> public MoviesController(IMediaLibrary library) { _library = library; }
public AddMovieViewModel(IMediaLibrary library, IEventAggregator eventAggregator) { this.Add = new DelegateCommand(() => AddMovie(library, eventAggregator)); }
private void DeleteMovie(IMediaLibrary library, IEventAggregator eventAggregator) { eventAggregator.Raise<ISelectedMovieDeleted>(e => {}); DeleteDialogOpen = false; OnPropertyChanged("DeleteDialogOpen"); }
public MusicPlaylist(IMediaLibrary library, string name) : base(library, PlaylistType.Music, name) { }
public MoviesPlaylist(IMediaLibrary library, string name) : base(library, PlaylistType.Movies, name) { }
internal MediaSource(IMediaLibrary backend) { library = backend; library.mediasource = this; }
/// <summary> /// Initializes the controller /// </summary> /// <param name="library">Library to use</param> /// <param name="factory">Factory to create movies</param> public MoviesController(IMediaLibrary library, IMovieFactory factory) { _library = library; _factory = factory; }