public DeleteItemsFromDatabaseHandler(
IMediaItemRepository mediaItemRepository,
ISearchIndex searchIndex)
{
_mediaItemRepository = mediaItemRepository;
_searchIndex = searchIndex;
}
public EmptyTrashHandler(
IMediaItemRepository mediaItemRepository,
ISearchIndex searchIndex)
{
_mediaItemRepository = mediaItemRepository;
_searchIndex = searchIndex;
}
public ContentController(IContentRepository contentRepository, ICategoryRepository categoryRepository, IUserRepository userRepository, IMediaItemRepository mediaItemRepository, IMemoryCacheManager cacheManager)
{
_contentRepository = contentRepository;
_categoryRepository = categoryRepository;
_userRepository = userRepository;
_mediaItemRepository = mediaItemRepository;
_cacheManager = cacheManager;
}
public async Task UpdateTags(ItemTagsDto dto)
{
await Task.Run(() =>
{
// begin transaction
IUnitOfWork uow = this._uowProvider.Get();
IMediaItemRepository itemRepo = this._repoProvider.Get(uow);
ITagRepository tagRepo = this._tagRepoProvider.Get(uow);
uow.Begin();
// add tags
foreach (var tag in dto.TagsToAdd)
{
if (tagRepo.ExistsWithName(tag))
{
// tag exists
// get the Id
int tagId = tagRepo.GetIdByName(tag);
// insert record into link table
tagRepo.LinkMediaItem(dto.Id, tagId);
}
else
{
// tag does not exist
// insert it
tagRepo.Create(new Tag {
Name = tag
});
// get the id
int tagId = tagRepo.GetIdByName(tag);
// insert record into link table
tagRepo.LinkMediaItem(dto.Id, tagId);
}
}
// remove tags
foreach (var tag in dto.TagsToRemove)
{
if (tagRepo.ExistsWithName(tag))
{
// tag exists
// get the id
int tagId = tagRepo.GetIdByName(tag);
// delete record from link table
tagRepo.UnlinkMediaItem(dto.Id, tagId);
}
}
// commit transaction
uow.Commit();
});
}
public async virtual Task <IEnumerable <MediaItem> > GetAll()
{
IEnumerable <MediaItem> allItems = null;
await Task.Run(() =>
{
IUnitOfWork uow = this._uowProvider.Get();
IMediaItemRepository repo = this._repoProvider.Get(uow);
allItems = repo.ReadAll();
uow.Dispose();
});
return(allItems);
}
public async Task <MediaItem> GetById(int id)
{
MediaItem item = null;
await Task.Run(() =>
{
IUnitOfWork uow = this._uowProvider.Get();
IMediaItemRepository repo = this._repoProvider.Get(uow);
item = repo.GetById(id);
uow.Dispose();
});
return(item);
}
public async Task <bool> ExistsWithTitle(string title)
{
bool exists = false;
await Task.Run(() =>
{
IUnitOfWork uow = this._uowProvider.Get();
IMediaItemRepository repo = this._repoProvider.Get(uow);
exists = repo.GetTitles().Any(t => t.Equals(title));
uow.Dispose();
});
return(exists);
}
public async Task Update(MediaItem item)
{
await Task.Run(() =>
{
// begin transaction
IUnitOfWork uow = this._uowProvider.Get();
IMediaItemRepository repo = this._repoProvider.Get(uow);
uow.Begin();
// do the work
repo.Update(item);
// commit transaction
uow.Commit();
});
}
public async Task Add(MediaItem item)
{
await Task.Run(() =>
{
// begin transaction
IUnitOfWork uow = this._uowProvider.Get();
IMediaItemRepository itemRepo = this._repoProvider.Get(uow);
ITagRepository tagRepo = this._tagRepoProvider.Get(uow);
uow.Begin();
// insert Media table record
itemRepo.Create(item);
// handle tags
// get all tag Ids
List <int> tagIds = new List <int>();
foreach (var tag in item.Tags)
{
if (tagRepo.ExistsWithName(tag.Name))
{
// tag exists
// get the Id
int tagId = tagRepo.GetIdByName(tag.Name);
tagIds.Add(tagId);
}
else
{
// tag does not exist
// insert tag
tagRepo.Create(tag);
// get the Id
int tagId = tagRepo.GetIdByName(tag.Name);
tagIds.Add(tagId);
}
}
// insert record(s) in Media_Tag link table
int itemId = itemRepo.GetIdByTitle(item.Title);
foreach (int tagId in tagIds)
{
tagRepo.LinkMediaItem(itemId, tagId);
}
// commit transaction
uow.Commit();
});
}
public MediaRepository(IPlaylistMapper playlistMapper,
IMediaItemMapper mediaItemMapper,
IMediaPlayerMapper mediaPlayerMapper,
IMediaItemRepository mediaItemRepository,
IMediaPlayerRepository mediaPlayerRepository,
IPlaylistRepository playlistRepository)
{
_mediaItemMapper = mediaItemMapper ?? throw new ArgumentNullException(nameof(mediaItemMapper), $"{nameof(mediaItemMapper)} {Resources.IsRequired}");
_playlistMapper = playlistMapper ?? throw new ArgumentNullException(nameof(playlistMapper), $"{nameof(playlistMapper)} {Resources.IsRequired}");
_mediaPlayerMapper = mediaPlayerMapper ?? throw new ArgumentNullException(nameof(mediaPlayerMapper), $"{nameof(mediaPlayerMapper)} {Resources.IsRequired}");
_mediaItemRepository = mediaItemRepository ?? throw new ArgumentNullException(nameof(mediaItemRepository), $"{nameof(mediaItemRepository)} {Resources.IsRequired}");
_mediaPlayerRepository = mediaPlayerRepository ?? throw new ArgumentNullException(nameof(mediaPlayerRepository), $"{nameof(mediaPlayerRepository)} {Resources.IsRequired}");
_playlistRepository = playlistRepository ?? throw new ArgumentNullException(nameof(playlistRepository), $"{nameof(playlistRepository)} {Resources.IsRequired}");
_busyStack = new BusyStack();
_busyStack.OnChanged += (hasItems) => { IsBusy = hasItems; };
}
public MusicVideoFolderScanner(
ILocalFileSystem localFileSystem,
ILocalStatisticsProvider localStatisticsProvider,
ILocalMetadataProvider localMetadataProvider,
ILocalSubtitlesProvider localSubtitlesProvider,
IMetadataRepository metadataRepository,
IImageCache imageCache,
ISearchIndex searchIndex,
ISearchRepository searchRepository,
IArtistRepository artistRepository,
IMusicVideoRepository musicVideoRepository,
ILibraryRepository libraryRepository,
IMediaItemRepository mediaItemRepository,
IMediator mediator,
IFFmpegProcessService ffmpegProcessService,
ITempFilePool tempFilePool,
IClient client,
ILogger <MusicVideoFolderScanner> logger) : base(
localFileSystem,
localStatisticsProvider,
metadataRepository,
mediaItemRepository,
imageCache,
ffmpegProcessService,
tempFilePool,
client,
logger)
{
_localFileSystem = localFileSystem;
_localMetadataProvider = localMetadataProvider;
_localSubtitlesProvider = localSubtitlesProvider;
_searchIndex = searchIndex;
_searchRepository = searchRepository;
_artistRepository = artistRepository;
_musicVideoRepository = musicVideoRepository;
_libraryRepository = libraryRepository;
_mediator = mediator;
_client = client;
_logger = logger;
}
public MediaIndexerController(IMediaItemImporter importer, IMediaItemRepository repository)
{
_importer = importer;
_repository = repository;
}
public SearchAllMediaItemsHandler(IMediaItemRepository mediaItemRepository) =>
public GetAllMediaItemsHandler(IMediaItemRepository mediaItemRepository) =>
public GetMediaItemByIdHandler(IMediaItemRepository mediaItemRepository) =>
public MediaController(ILogger <MediaController> logger, IMediaLibraryService mediaLibraryService, IMediaItemRepository repository)
{
this.logger = logger;
this.mediaLibraryService = mediaLibraryService;
this.repository = repository;
}
public GetAllLanguageCodesHandler(IMediaItemRepository mediaItemRepository) =>
public ValuesController(IMediaItemRepository media)
{
mediaRepo = media;
}
