public GenreRepositoryCache(IMetadataRepository metadataRepository, string genre, Guid collectionId)
{
var repositoryDelegate = new GenreRepositoryDelegate(genre, collectionId);
repositoryDelegate.Method = repositoryDelegate.CreateMethod(metadataRepository);
RepositoryDelegate = repositoryDelegate;
}
public StatsBusiness(IStatsRepository statsRepository, IMetadataRepository metadataRepository, ICartographerContext db, ISettings settings)
{
_statsRepository = statsRepository;
_metadataRepository = metadataRepository;
_db = db;
_settings = settings;
}
public MetaDataController
(
IMetadataRepository <BillingCycle, BillingCycleDto> billingCycleRepository,
IMetadataRepository <StorageType, StorageTypeDto> storageTypeRepository,
IMetadataRepository <Route, RouteDto> routeRepository,
IMetadataRepository <ServiceCategory, ServiceCategoryDto> serviceRepository,
IMetadataRepository <Department, DepartmentDto> departmentRepository,
IMetadataRepository <ReceiveType, ReceiveTypeDto> receiveTypeRepository,
IMetadataRepository <RequestType, RequestTypeDto> requestTypeTypeManagerRepository,
IMetadataRepository <WorkOrderRequestType, WorkOrderTypeDto> workOrderTypeRepository,
IMetadataRepository <DisposalTimeFrame, DisposalTimeFrameDto> disposalTimeFrame,
IMetadataRepository <MobileDevice, MobileDeviceDto> mobileDeviceRepository,
IMetadataRepository <PostingType, PostingTypeDto> postingTypeRepository,
IMetadataRepository <TaxType, TaxTypeDto> taxTypeManagerRepository,
IMetadataRepository <Module, ModuleMetaDataDto> moduleRepository,
IMetadataRepository <ModuleSub, ModuleSubMetaDataDto> subModuleRepository,
IRolePermissionManagerRepository rolePermission)
{
_billingCycleRepository = billingCycleRepository;
_routeRepository = routeRepository;
_serviceRepository = serviceRepository;
_storageTypeRepository = storageTypeRepository;
_departmentRepository = departmentRepository;
_receiveTypeRepository = receiveTypeRepository;
_disposalTimeFrameRepository = disposalTimeFrame;
_workOrderTypeRepository = workOrderTypeRepository;
_mobileDeviceRepository = mobileDeviceRepository;
_postingTypeRepository = postingTypeRepository;
_taxTypeManagerRepository = taxTypeManagerRepository;
_requestTypeTypeManagerRepository = requestTypeTypeManagerRepository;
_moduleRepository = moduleRepository;
_subModuleRepository = subModuleRepository;
_rolePermission = rolePermission;
}
public ArtistRepositoryCache(IMetadataRepository metadataRepository, Guid userId, string artist, Guid collectionId)
{
var repositoryDelegate = new ArtistRepositoryDelegate(userId, artist, collectionId);
repositoryDelegate.Method = repositoryDelegate.CreateMethod(metadataRepository);
RepositoryDelegate = repositoryDelegate;
}
public void SetUp()
{
linkConnection = connectionFactory.Create(connectionString);
linkConnection.Open();
linkRepository = new SQLiteLinkRepository(logger, linkConnection);
linkRepository.Initialize();
tagConnection = connectionFactory.Create(connectionString);
tagConnection.Open();
tagRepository = new SQLiteTagRepository(logger, tagTypeFactory, tagConnection);
tagRepository.Initialize();
mediaConnection = connectionFactory.Create(connectionString);
mediaConnection.Open();
mediaRepository = new SQLiteMediaRepository(logger, mediaFactory, mediaConnection);
mediaRepository.Initialize();
itemConnection = connectionFactory.Create(connectionString);
itemConnection.Open();
mediaItemRepository = new SQLiteMetadataRepository(logger, securityContext, mediaFactory, itemConnection);
mediaItemRepository.Initialize();
audioStreamFactory = new AudioStreamFactory();
spider = new CatalogSpider(logger, securityContext, mediaFactory, linkRepository, tagRepository, mediaRepository, mediaItemRepository, audioStreamFactory);
}
public Func <CancellationToken, Task <Genre> > CreateMethod(IMetadataRepository metadataRepository)
{
return(async cancellationToken =>
{
var genre = await metadataRepository.GetGenreAsync(Genre, CollectionId, cancellationToken).ConfigureAwait(false);
if (genre != null)
{
return genre;
}
var now = DateTime.UtcNow;
genre = new Genre
{
Name = Genre,
CollectionId = CollectionId,
DateAdded = now,
DateModified = now
};
await metadataRepository.InsertOrUpdateGenreAsync(genre, cancellationToken).ConfigureAwait(false);
return genre;
});
}
public TrackRepositoryPathCache(IMetadataRepository metadataRepository, IMetadataRepositoryCache metadataRepositoryCache, ITagReaderFactory tagReaderFactory, Guid userId, string path, Guid collectionId, bool populate, bool updateCollection)
{
var repositoryDelegate = new TrackRepositoryPathDelegate(userId, path, collectionId, populate, updateCollection);
repositoryDelegate.Method = repositoryDelegate.CreateMethod(metadataRepository, metadataRepositoryCache, tagReaderFactory);
RepositoryDelegate = repositoryDelegate;
}
public SiteInfoChangedQuery(
ISiteRepository siteRepository,
IMetadataRepository metadataRepository)
{
_siteRepository = siteRepository;
_metadataRepository = metadataRepository;
}
public PlexMovieLibraryScanner(
IPlexServerApiClient plexServerApiClient,
IMovieRepository movieRepository,
IMetadataRepository metadataRepository,
ISearchIndex searchIndex,
ISearchRepository searchRepository,
IMediator mediator,
IMediaSourceRepository mediaSourceRepository,
IPlexMovieRepository plexMovieRepository,
IPlexPathReplacementService plexPathReplacementService,
ILocalFileSystem localFileSystem,
ILocalStatisticsProvider localStatisticsProvider,
ILocalSubtitlesProvider localSubtitlesProvider,
ILogger <PlexMovieLibraryScanner> logger)
: base(
localStatisticsProvider,
localSubtitlesProvider,
localFileSystem,
mediator,
searchIndex,
searchRepository,
logger)
{
_plexServerApiClient = plexServerApiClient;
_movieRepository = movieRepository;
_metadataRepository = metadataRepository;
_mediaSourceRepository = mediaSourceRepository;
_plexMovieRepository = plexMovieRepository;
_plexPathReplacementService = plexPathReplacementService;
_logger = logger;
}
protected virtual async Task InitializeRepository(IMetadataRepository repository)
{
var tocCacheKey = GetTocCacheKey(repository);
var cachedToc = await _cache.GetStringAsync(tocCacheKey);
MetadataTOCPayload toc;
DateTime?cacheUntil = null;
if (cachedToc != null)
{
toc = JsonConvert.DeserializeObject <MetadataTOCPayload>(cachedToc);
cacheUntil = GetCacheUntilTime(toc);
}
else
{
_log?.LogInformation($"TOC for {repository.GetType().Name} not cached so loading from MDS...");
try
{
toc = await repository.GetToc();
}
catch (Exception ex)
{
_log?.LogError(ex, "Error getting TOC from {0}", repository.GetType().Name);
throw;
}
_log?.LogInformation($"TOC for {repository.GetType().Name} not cached so loading from MDS... Done.");
cacheUntil = GetCacheUntilTime(toc);
if (cacheUntil.HasValue)
{
await _cache.SetStringAsync(
tocCacheKey,
JsonConvert.SerializeObject(toc),
new DistributedCacheEntryOptions()
{
AbsoluteExpiration = cacheUntil
});
}
}
foreach (var entry in toc.Entries)
{
if (!string.IsNullOrEmpty(entry.AaGuid)) //Only load FIDO2 entries
{
try
{
await LoadTocEntryStatement(repository, toc, entry, cacheUntil);
}
catch (Exception ex)
{
_log?.LogError(ex, "Error getting statement from {0} for AAGUID '{1}'.\nTOC entry:\n{2} ", repository.GetType().Name, entry.AaGuid, JsonConvert.SerializeObject(entry, Formatting.Indented));
}
}
}
}
public PlexTelevisionLibraryScanner(
IPlexServerApiClient plexServerApiClient,
ITelevisionRepository televisionRepository,
IMetadataRepository metadataRepository,
ISearchIndex searchIndex,
ISearchRepository searchRepository,
IMediator mediator,
IMediaSourceRepository mediaSourceRepository,
IPlexPathReplacementService plexPathReplacementService,
IPlexTelevisionRepository plexTelevisionRepository,
ILocalFileSystem localFileSystem,
ILocalStatisticsProvider localStatisticsProvider,
ILocalSubtitlesProvider localSubtitlesProvider,
ILogger <PlexTelevisionLibraryScanner> logger)
: base(metadataRepository, logger)
{
_plexServerApiClient = plexServerApiClient;
_televisionRepository = televisionRepository;
_metadataRepository = metadataRepository;
_searchIndex = searchIndex;
_searchRepository = searchRepository;
_mediator = mediator;
_mediaSourceRepository = mediaSourceRepository;
_plexPathReplacementService = plexPathReplacementService;
_plexTelevisionRepository = plexTelevisionRepository;
_localFileSystem = localFileSystem;
_localStatisticsProvider = localStatisticsProvider;
_localSubtitlesProvider = localSubtitlesProvider;
_logger = logger;
}
public SpiderFactory(ILogger logger, ISecurityContext securityContext, IMediaFactory mediaFactory, ILinkRepository linkRepository, ITagRepository tagRepository, IMediaRepository mediaRepository, IMetadataRepository mediaItemRepository, IAudioStreamFactory audioStreamFactory)
{
if (logger == null)
throw new ArgumentNullException("logger");
if (securityContext == null)
throw new ArgumentNullException("securityContext");
if (mediaFactory == null)
throw new ArgumentNullException("mediaFactory");
if (linkRepository == null)
throw new ArgumentNullException("linkRepository");
if (tagRepository == null)
throw new ArgumentNullException("tagRepository");
if (mediaRepository == null)
throw new ArgumentNullException("mediaRepository");
if (mediaItemRepository == null)
throw new ArgumentNullException("mediaItemRepository");
this.logger = logger;
this.securityContext = securityContext;
this.securityContext = securityContext;
this.mediaFactory = mediaFactory;
this.linkRepository = linkRepository;
this.tagRepository = tagRepository;
this.mediaRepository = mediaRepository;
this.mediaItemRepository = mediaItemRepository;
this.audioStreamFactory = audioStreamFactory;
}
public void SetUp()
{
linkConnection = connectionFactory.Create(connectionString);
linkConnection.Open();
linkRepository = new SQLiteLinkRepository(logger, linkConnection);
linkRepository.Initialize();
tagConnection = connectionFactory.Create(connectionString);
tagConnection.Open();
tagRepository = new SQLiteTagRepository(logger, tagTypeFactory, tagConnection);
tagRepository.Initialize();
mediaConnection = connectionFactory.Create(connectionString);
mediaConnection.Open();
mediaRepository = new SQLiteMediaRepository(logger, mediaFactory, mediaConnection);
mediaRepository.Initialize();
itemConnection = connectionFactory.Create(connectionString);
itemConnection.Open();
mediaItemRepository = new SQLiteMetadataRepository(logger, securityContext, mediaFactory, itemConnection);
mediaItemRepository.Initialize();
audioStreamFactory = new AudioStreamFactory();
spider = new CatalogSpider(logger, securityContext, mediaFactory, linkRepository, tagRepository, mediaRepository, mediaItemRepository, audioStreamFactory);
}
public TaskController(ILogger logger, IMediaFactory mediaFactory, IVideoPlayer videoPlayer, SpiderFactory spiderFactory, IMetadataController metadataController, IMarqueeRepository marqueeRepository, IMetadataRepository mediaItemRepository)
{
if (logger == null)
throw new ArgumentNullException("logger");
if (mediaFactory == null)
throw new ArgumentNullException("mediaFactory");
if (videoPlayer == null)
throw new ArgumentNullException("videoPlayer");
if (spiderFactory == null)
throw new ArgumentNullException("spiderFactory");
if (metadataController == null)
throw new ArgumentNullException("metadataController");
if (marqueeRepository == null)
throw new ArgumentNullException("marqueeRepository");
if (mediaItemRepository == null)
throw new ArgumentNullException("mediaItemRepository");
this.logger = logger;
this.mediaFactory = mediaFactory;
this.videoPlayer = videoPlayer;
this.spiderFactory = spiderFactory;
this.metadataController = metadataController;
this.marqueeRepository = marqueeRepository;
this.mediaItemRepository = mediaItemRepository;
this.audioStreamFactory = new AudioStreamFactory();
}
public MetadataType addMetadata(
[GraphQLNonNullType] MetadataInput newMetadata,
[Service] IMetadataRepository repo
)
{
return(repo.addMetadataToDatabase(newMetadata).Result);
}
protected virtual async Task LoadTocEntryStatement(
IMetadataRepository repository,
MetadataBLOBPayload blob,
MetadataBLOBPayloadEntry entry,
DateTime?cacheUntil = null)
{
if (entry.AaGuid != null && !_entries.ContainsKey(Guid.Parse(entry.AaGuid)))
{
var entryAaGuid = Guid.Parse(entry.AaGuid);
var cacheKey = GetEntryCacheKey(repository, entryAaGuid);
var cachedEntry = await _cache.GetStringAsync(cacheKey);
if (cachedEntry != null)
{
var statement = JsonSerializer.Deserialize <MetadataStatement>(cachedEntry);
if (!string.IsNullOrWhiteSpace(statement.AaGuid))
{
var aaGuid = Guid.Parse(statement.AaGuid);
_metadataStatements.TryAdd(aaGuid, statement);
_entries.TryAdd(aaGuid, entry);
}
}
else
{
_log?.LogInformation("Entry for {0} {1} not cached so loading from MDS...", entry.AaGuid, entry.MetadataStatement?.Description ?? entry.StatusReports?.FirstOrDefault().CertificationDescriptor ?? "(unknown)");
try
{
if (!string.IsNullOrWhiteSpace(entry.AaGuid))
{
var statementJson = JsonSerializer.Serialize(entry.MetadataStatement, new JsonSerializerOptions {
WriteIndented = true
});
_log?.LogDebug("{0}:{1}\n{2}", entry.AaGuid, entry.MetadataStatement.Description, statementJson);
var aaGuid = Guid.Parse(entry.AaGuid);
_metadataStatements.TryAdd(aaGuid, entry.MetadataStatement);
_entries.TryAdd(aaGuid, entry);
if (cacheUntil.HasValue)
{
await _cache.SetStringAsync(cacheKey, statementJson, new DistributedCacheEntryOptions
{
AbsoluteExpiration = cacheUntil
});
}
}
}
catch (Exception ex)
{
_log?.LogError(ex, "Error getting MetadataStatement from {0} for AAGUID '{1}' ", repository.GetType().Name, entry.AaGuid);
throw;
}
}
}
}
public TrackRepositoryArtistAndTrackCache(IMetadataRepository metadataRepository, Guid userId, string artist, string track, Guid?collectionId, bool populate)
{
var repositoryDelegate = new TrackRepositoryArtistAndTrackDelegate(userId, artist, track, collectionId, populate);
repositoryDelegate.Method = repositoryDelegate.CreateMethod(metadataRepository);
RepositoryDelegate = repositoryDelegate;
}
public AlbumRepositoryCache(IMetadataRepository metadataRepository, Guid userId, HashSet <Artist> artists, string name, Guid collectionId, bool populate)
{
var repositoryDelegate = new AlbumRepositoryDelegate(userId, artists, name, collectionId, populate);
repositoryDelegate.Method = repositoryDelegate.CreateMethod(metadataRepository);
RepositoryDelegate = repositoryDelegate;
}
public PlaylistRepositoryIdCache(IMetadataRepository metadataRepository, Guid userId, Guid id, bool getTracks)
{
var repositoryDelegate = new PlaylistRepositoryIdDelegate(userId, id, getTracks);
repositoryDelegate.Method = repositoryDelegate.CreateMethod(metadataRepository);
RepositoryDelegate = repositoryDelegate;
}
public TrackRepositoryIdCache(IMetadataRepository metadataRepository, Guid userId, Guid id, bool populate)
{
var repositoryDelegate = new TrackRepositoryIdDelegate(userId, id, populate);
repositoryDelegate.Method = repositoryDelegate.CreateMethod(metadataRepository);
RepositoryDelegate = repositoryDelegate;
}
public ArtistRepositoryIdCache(IMetadataRepository metadataRepository, Guid userId, Guid id)
{
var repositoryDelegate = new ArtistRepositoryIdDelegate(userId, id);
repositoryDelegate.Method = repositoryDelegate.CreateMethod(metadataRepository);
RepositoryDelegate = repositoryDelegate;
}
public AlbumRepositoryByArtistIdCache(IMetadataRepository metadataRepository, Guid userId, Guid artistId, bool populate)
{
var repositoryDelegate = new AlbumRepositoryByArtistIdDelegate(userId, artistId, populate);
repositoryDelegate.Method = repositoryDelegate.CreateMethod(metadataRepository);
RepositoryDelegate = repositoryDelegate;
}
public MetadataService(IMetadataFieldRepository metadataFieldRepository,
IMetadataRepository <T> metadataRepository,
IComponentContext context)
{
this.metadataFieldRepository = metadataFieldRepository;
this.metadataRepository = metadataRepository;
this.context = context;
}
public MediaLibrary(IMetadataRepository metadataRepository, ILastFmClient lastFmClient, ISettingsRepository settingsRepository, ICoverArtRepository coverArtRepository, IMetadataRepositoryCache metadataRepositoryCache)
{
_metadataRepository = metadataRepository;
_lastFmClient = lastFmClient;
_coverArtRepository = coverArtRepository;
_metadataRepositoryCache = metadataRepositoryCache;
_settingsRepository = settingsRepository;
}
public ItemMetadataProvider(IMetadataRepository metadataRepository)
{
if (metadataRepository == null)
{
throw new ArgumentNullException(nameof(metadataRepository));
}
_metadataRepository = metadataRepository;
}
public GetSpecificFormDefinition(IMetadataRepository repository,
ISecurityService guard,
User requester)
{
this.repository = repository ?? throw new ArgumentNullException(nameof(repository));
this.guard = guard ?? throw new ArgumentNullException(nameof(guard));
this.requester = requester ?? throw new ArgumentNullException(nameof(requester));
}
public CreateNewFormDefinition(IMetadataRepository repository,
ISecurityService guard,
User requester)
{
this.repository = repository;
this.guard = guard;
this.requester = requester;
}
public ConceptValidationService(IStatusRepository status, IMetadataRepository meta, ICategoryRepository category, IMediaTypeRepository mediaType, IOptions <LanguageConfig> language)
{
_statusRepository = status;
_metadataRepository = meta;
_categoryRepository = category;
_mediaTypeRepository = mediaType;
LanguageConfig = language.Value;
}
public ConceptService(IConceptRepository concept, IStatusRepository status, IConceptMediaRepository media, IMetadataRepository meta, ILanguageRepository language, IMapper mapper, IUrlHelper urlHelper) : base(mapper, urlHelper)
{
_conceptRepository = concept;
_statusRepository = status;
_conceptMediaRepository = media;
_metaRepository = meta;
_languageRepository = language;
}
public Func <CancellationToken, Task <MediaBundle <Track> > > CreateMethod(IMetadataRepository metadataRepository, IMetadataRepositoryCache metadataRepositoryCache, ITagReaderFactory tagReaderFactory)
{
return(async cancellationToken =>
{
var mediaBundle = await metadataRepository.GetTrackAsync(UserId, Path, CollectionId, Populate, cancellationToken).ConfigureAwait(false);
Track track = null;
if (mediaBundle != null)
{
track = mediaBundle.Media;
}
else if (!UpdateCollection)
{
return null;
}
if (track != null && track.DateFileModified.ToUniversalTime() >= File.GetLastWriteTimeUtc(Path))
{
return mediaBundle;
}
var now = DateTime.UtcNow;
var dateAdded = now;
Guid?trackId = null;
if (track != null)
{
trackId = track.Id;
dateAdded = track.DateAdded;
}
var tagReader = tagReaderFactory.CreateTagReader(Path);
track = await metadataRepositoryCache.TagReaderToTrackModelAsync(UserId, tagReader, CollectionId, cancellationToken).ConfigureAwait(false);
if (trackId.HasValue)
{
track.Id = trackId.Value;
}
track.CollectionId = CollectionId;
track.DateAdded = dateAdded;
track.DateModified = now;
track.Visible = true;
await metadataRepository.InsertOrUpdateTrackAsync(track, cancellationToken).ConfigureAwait(false);
mediaBundle = new MediaBundle <Track>
{
Media = track,
Dispositions = new List <Disposition>(),
Playback = new List <Playback>()
};
return mediaBundle;
});
}
public CognitiveService(IOptions <ConfigurationValues> Configuration, IComputerVisionClient visionClient, IBlobService blobService, AssetManagementSystemDBContext DbContext, IMetadataRepository metadataRepository, IImageVariantRepository imageVariantRepository, IAssetRepository assetRepository)
{
_Configuration = Configuration.Value;
_visionClient = visionClient;
_blobService = blobService;
_metadataRepository = metadataRepository;
_imageVariantRepository = imageVariantRepository;
_assetRepository = assetRepository;
}
public ReportsManager(
IMapper mapper,
IReportRepository reportRepository,
IMetadataRepository metadataRepository)
{
this.mapper = mapper;
this.reportRepository = reportRepository;
this.metadataRepository = metadataRepository;
}
protected virtual async Task InitializeClient(IMetadataRepository repository)
{
var tocCacheKey = GetTocCacheKey(repository);
var cachedToc = await _cache.GetStringAsync(tocCacheKey);
MetadataTOCPayload toc;
DateTime?cacheUntil = null;
if (cachedToc != null)
{
toc = JsonConvert.DeserializeObject <MetadataTOCPayload>(cachedToc);
cacheUntil = GetCacheUntilTime(toc);
}
else
{
_log?.LogInformation("TOC not cached so loading from MDS...");
try
{
toc = await repository.GetToc();
}
catch (Exception ex)
{
_log?.LogError(ex, "Error getting TOC from {0}", repository.GetType().Name);
throw;
}
_log?.LogInformation("TOC not cached so loading from MDS... Done.");
cacheUntil = GetCacheUntilTime(toc);
if (cacheUntil.HasValue)
{
await _cache.SetStringAsync(
tocCacheKey,
JsonConvert.SerializeObject(toc),
new DistributedCacheEntryOptions()
{
AbsoluteExpiration = cacheUntil
});
}
}
foreach (var entry in toc.Entries)
{
if (!string.IsNullOrEmpty(entry.AaGuid))
{
if (_entries.TryAdd(Guid.Parse(entry.AaGuid), entry))
{
//Load if it doesn't already exist
await LoadEntryStatement(repository, entry, cacheUntil);
}
}
}
}
public PayPalService(IGeocodeService geocodeService, IMetadataRepository metadataReposity, ILog log)
{
_geocodeService = geocodeService;
_metadataRepository = metadataReposity;
Log = log;
#if DEBUG
WebSrcUrl = "https://www.sandbox.paypal.com/cgi-bin/webscr";
#else
WebSrcUrl = ConfigurationManager.AppSettings["PayPal:WebScrUrl"];
#endif
}
public override IClip GetClip(ISecurityContext securityContext, IMediaFactory mediaFactory, IMetadataRepository mediaItemRepository, IArtist artist, IAlbum album)
{
var clip = mediaItemRepository.GetByTarget<IClip>(Location).FirstOrDefault();
if (clip != null)
{
return clip;
}
var name = GetClipName();
var summary = string.Empty;
var number = GetClipNumber();
var date = GetDate();
var duration = file != null && file.Properties != null ? file.Properties.Duration : TimeSpan.FromMinutes(5);
var height = file != null && file.Properties != null ? (uint)file.Properties.VideoHeight : 480;
var width = file != null && file.Properties != null ? (uint)file.Properties.VideoWidth : 640;
var builder = new MediaItemBuilder<IClip>(securityContext, mediaFactory)
.Identity(name, summary, date, date, number)
.Size(duration, height, width)
.Target(Location, Type.Name);
return builder.ToMediaItem();
}
public virtual IAlbum GetAlbum(ISecurityContext securityContext, IMediaFactory mediaFactory, IMetadataRepository mediaItemRepository, IArtist artist)
{
return null;
}
public void Initialiaze()
{
_metadataRepository = A.Fake<IMetadataRepository>();
_metadataService = new MetadataService(_metadataRepository);
}
public MetadataService(IMetadataRepository metadataRepository)
{
_metadataRepository = metadataRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="MetadataMapper"/> class.
/// </summary>
/// <param name="metadataRepository">
/// The metadata repository.
/// </param>
public MetadataMapper( IMetadataRepository metadataRepository )
{
_metadataRepository = metadataRepository;
}
public CatalogController(ILogger logger, ISecurityContext securityContext, IMediaFactory mediaFactory, IMediaRepository mediaRepository, ILinkRepository linkRepository, ITagRepository tagRepository, IMetadataRepository mediaItemRepository, IAudioStreamFactory audioStreamFactory)
{
this.logger = logger;
spider = new CatalogSpider(logger, securityContext, mediaFactory, linkRepository, tagRepository, mediaRepository, mediaItemRepository, audioStreamFactory);
}
public virtual ITrack GetTrack(ISecurityContext securityContext, IMediaFactory mediaFactory, IMetadataRepository mediaItemRepository, IAudioStreamFactory audioStreamFactory, IArtist artist, IAlbum album)
{
return null;
}
/// <summary>
/// Initializes controller with an instance of repository interface.
/// </summary>
public AccountController(IAccountRepository accountRepository, IMetadataRepository metadataRepository)
{
_accountRepository = accountRepository;
_metadataRepository = metadataRepository;
}
public PostNotificationSender(IHttpNotificationSender httpNotificationSender, IMetadataRepository repository)
{
_httpNotificationSender = httpNotificationSender;
_repository = repository;
}
public override IArtist GetArtist(ISecurityContext securityContext, IMediaFactory mediaFactory, IMetadataRepository mediaItemRepository)
{
IArtist artist = null;
var track = mediaItemRepository.GetByTarget<ITrack>(Location).FirstOrDefault();
if (track != null)
{
artist = mediaItemRepository.GetByLocation<IArtist>(track.Creator);
if (artist != null)
return artist;
}
if (id3v2Tag == null || id3v2Tag.JoinedPerformers == null)
return new MediaItemBuilder<IArtist>(securityContext, mediaFactory).GetDefault();
var artistName = id3v2Tag.JoinedPerformers;
var summary = string.Empty;
artist = mediaItemRepository.GetByName<IArtist>(artistName).FirstOrDefault();
if (artist != null)
return artist;
var builder = new MediaItemBuilder<IArtist>(securityContext, mediaFactory)
.Identity(artistName, summary);
return builder.ToMediaItem();
}
public override IAlbum GetAlbum(ISecurityContext securityContext, IMediaFactory mediaFactory, IMetadataRepository mediaItemRepository, IArtist artist)
{
IAlbum album = null;
var track = mediaItemRepository.GetByTarget<ITrack>(Location).FirstOrDefault();
if (track != null)
{
album = mediaItemRepository.GetByLocation<IAlbum>(track.Catalog);
if (album != null)
return album;
}
var albumTitle = "Unknown Album";
var summary = string.Empty;
//var albumTag = GetTags().Where(x => x.Type == Id3v2TagType.Album).FirstOrDefault();
if (id3v2Tag != null && id3v2Tag.Album != null)
{
albumTitle = id3v2Tag.Album; //albumTag.Tuple.ToString();
album = mediaItemRepository.GetByCreatorAndName<IAlbum>(artist.Location, albumTitle);
if (album != null)
return album;
}
var builder = new MediaItemBuilder<IAlbum>(securityContext, mediaFactory)
.Identity(albumTitle, summary)
.Creator(artist.Location, artist.Name);
return builder.ToMediaItem();
}
public GoogleGeocodeService(IMetadataRepository metadataReposity, ILog log)
{
_metadataRepository = metadataReposity;
Log = log;
ServiceUrlFormat = ConfigurationManager.AppSettings["GeocodeUrlFormat"];
}
/// <summary>
/// Initializes controller with an instance of repository interface.
/// </summary>
public HeroController(IHeroRepository heroRepository, IMetadataRepository metadataRepository)
{
_heroRepository = heroRepository;
_metadataRepository = metadataRepository;
}
public virtual IArtist GetArtist(ISecurityContext securityContext, IMediaFactory mediaFactory, IMetadataRepository mediaItemRepository)
{
var clip = mediaItemRepository.GetByTarget<IClip>(Location).FirstOrDefault();
if (clip != null)
{
var artist = mediaItemRepository.GetByLocation<IArtist>(clip.Creator);
if (artist != null)
return artist;
}
return new MediaItemBuilder<IArtist>(securityContext, mediaFactory).GetDefault();
}
/// <summary>
/// Initializes a new instance of the <see cref="MetadataFactory"/> class.
/// </summary>
/// <param name="metadataRepository">The metadata repository.</param>
public MetadataFactory( IMetadataRepository metadataRepository )
{
_metadataRepository = metadataRepository;
}
public virtual IAlbum GetAlbum(ISecurityContext securityContext, IMediaFactory mediaFactory, IMetadataRepository mediaItemRepository, IArtist artist)
{
IAlbum album = null;
var clip = mediaItemRepository.GetByTarget<IClip>(Location).FirstOrDefault();
if (clip != null)
{
album = mediaItemRepository.GetByLocation<IAlbum>(clip.Catalog);
if (album != null)
return album;
}
var albumName = GetAlbumName();
var summary = string.Empty;
album = mediaItemRepository.GetByName<IAlbum>(albumName).FirstOrDefault();
if (album != null)
{
return album;
}
var albumNumber = GetAlbumNumber();
var date = GetDate();
var builder = new MediaItemBuilder<IAlbum>(securityContext, mediaFactory)
.Identity(albumName, summary, date, date, albumNumber)
.Creator(artist.Location, artist.Name);
return builder.ToMediaItem();
}
public void SetUp()
{
_repository = Mock.Of<IMetadataRepository>();
_sender = Mock.Of<IHttpNotificationSender>();
}
public override ITrack GetTrack(ISecurityContext securityContext, IMediaFactory mediaFactory, IMetadataRepository mediaItemRepository, IAudioStreamFactory audioStreamFactory, IArtist artist, IAlbum album)
{
var track = mediaItemRepository.GetByTarget<ITrack>(Location).FirstOrDefault();
//if (track != null)
//return track;
if (id3v2Tag == null)
{
if (track != null)
return track;
var builder = new MediaItemBuilder<ITrack>(securityContext, mediaFactory)
.Identity("Unknown", string.Empty)
.Creator(artist.Location, artist.Name)
.Catalog(album.Location, album.Name)
.Target(Location, Type.Name);
return builder.ToMediaItem();
}
var name = id3v2Tag.Title != null ? id3v2Tag.Title : "Unknown Track";
var summary = id3v2Tag.Lyrics ?? string.Empty;
var recordDate = DateTime.MinValue;
if (id3v2Tag != null && id3v2Tag.RecordingDate > DateTime.MinValue)
recordDate = id3v2Tag.RecordingDate;
else if (id3v1Tag != null && id3v1Tag.Year >= DateTime.MinValue.Year && id3v1Tag.Year <= DateTime.MaxValue.Year)
recordDate = new DateTime((int)id3v1Tag.Year, 1, 1);
var releaseDate = DateTime.MinValue;
if (id3v2Tag != null && id3v2Tag.ReleaseDate > DateTime.MinValue)
releaseDate = id3v2Tag.ReleaseDate;
else if (id3v1Tag != null && id3v1Tag.Year >= DateTime.MinValue.Year && id3v1Tag.Year <= DateTime.MaxValue.Year)
releaseDate = new DateTime((int)id3v1Tag.Year, 1, 1);
var number = id3v2Tag.Track;
var duration = id3v2Tag.Duration;
if (duration == TimeSpan.Zero)
{
using (var audioStream = audioStreamFactory.CreateAudioStream(Location))
{
if (audioStream != null)
{
duration = audioStream.Duration;
}
}
}
var thumbnail = Guid.Empty.ToUrn();
var thumbnailData = id3v2Tag.Pictures != null && id3v2Tag.Pictures.Length > 0 ? id3v2Tag.Pictures[0].Data.ToArray() : new byte[0];
var trackId = track != null ? track.Location : Guid.NewGuid().ToUrn();
var fullBuilder = new MediaItemBuilder<ITrack>(securityContext, mediaFactory)
.Identity(name, summary, recordDate, releaseDate, number, trackId)
.Size(duration)
.Creator(artist.Location, artist.Name)
.Catalog(album.Location, album.Name)
.Target(Location, Type.Name)
.Thumbnail(thumbnail, thumbnailData);
return fullBuilder.ToMediaItem();
}
