public ExternalController
(
IExternalRepository externalRepository
)
{
_externalRepository = externalRepository;
}
public NewsletterJob(IPlexContentRepository plex, IEmbyContentRepository emby, IJellyfinContentRepository jellyfin, IRepository <RecentlyAddedLog> addedLog,
IMovieDbApi movieApi, IEmailProvider email, ISettingsService <CustomizationSettings> custom,
ISettingsService <EmailNotificationSettings> emailSettings, INotificationTemplatesRepository templateRepo,
UserManager <OmbiUser> um, ISettingsService <NewsletterSettings> newsletter, ILogger <NewsletterJob> log,
ILidarrApi lidarrApi, IExternalRepository <LidarrAlbumCache> albumCache, ISettingsService <LidarrSettings> lidarrSettings,
ISettingsService <OmbiSettings> ombiSettings, ISettingsService <PlexSettings> plexSettings, ISettingsService <EmbySettings> embySettings, ISettingsService <JellyfinSettings> jellyfinSettings,
IHubContext <NotificationHub> notification, IRefreshMetadata refreshMetadata)
{
_plex = plex;
_emby = emby;
_jellyfin = jellyfin;
_recentlyAddedLog = addedLog;
_movieApi = movieApi;
_email = email;
_customizationSettings = custom;
_templateRepo = templateRepo;
_emailSettings = emailSettings;
_newsletterSettings = newsletter;
_userManager = um;
_log = log;
_lidarrApi = lidarrApi;
_lidarrAlbumRepository = albumCache;
_lidarrSettings = lidarrSettings;
_ombiSettings = ombiSettings;
_plexSettings = plexSettings;
_embySettings = embySettings;
_jellyfinSettings = jellyfinSettings;
_notification = notification;
_ombiSettings.ClearCache();
_plexSettings.ClearCache();
_emailSettings.ClearCache();
_customizationSettings.ClearCache();
_refreshMetadata = refreshMetadata;
}
public VoucherReader(IExternalRepository externalRepository)
{
_strategies = new Dictionary <SearchType, IVouchersReadingStrategy>();
_strategies.Add(SearchType.ByDateRange, new ReadVoucherByDateRangeStrategy(externalRepository));
_strategies.Add(SearchType.ByIDRange, new ReadVoucherByIDRangeStrategy(externalRepository));
_strategies.Add(SearchType.BySpecificIDs, new ReadVoucherByIDStrategy(externalRepository));
}
public LidarrAvailabilityChecker(IMusicRequestRepository requests, IExternalRepository <LidarrAlbumCache> albums, ILogger <LidarrAvailabilityChecker> log,
INotificationHelper notification, IHubContext <NotificationHub> notificationHub)
{
_cachedAlbums = albums;
_requestRepository = requests;
_logger = log;
_notificationService = notification;
_notification = notificationHub;
}
private static void bootstrapDI()
{
//setup DI
var kernel = new StandardKernel();
kernel.Bind <IVoucherExporter>().To <VoucherExporter>().InSingletonScope();
kernel.Bind <IExternalRepository>().To <ExternalRepository>().InSingletonScope();
kernel.Bind <IVoucherReader>().To <VoucherReader>().InTransientScope();
_externalRepository = kernel.Get <IExternalRepository>();
_exporter = kernel.Get <IVoucherExporter>();
_voucherReader = kernel.Get <IVoucherReader>();
}
public RadarrSync(ISettingsService <RadarrSettings> radarr, ISettingsService <Radarr4KSettings> radarr4k, IRadarrV3Api radarrApi, ILogger <RadarrSync> log, ExternalContext ctx,
IExternalRepository <RadarrCache> radarrRepo)
{
_radarrSettings = radarr;
_radarr4kSettings = radarr4k;
_api = radarrApi;
_logger = log;
_ctx = ctx;
_radarrRepo = radarrRepo;
_radarrSettings.ClearCache();
_radarr4kSettings.ClearCache();
}
public PlexWatchlistImport(IPlexApi plexApi, ISettingsService <PlexSettings> settings, OmbiUserManager ombiUserManager,
IMovieRequestEngine movieRequestEngine, ITvRequestEngine tvRequestEngine, IHubContext <NotificationHub> hub,
ILogger <PlexWatchlistImport> logger, IExternalRepository <PlexWatchlistHistory> watchlistRepo)
{
_plexApi = plexApi;
_settings = settings;
_ombiUserManager = ombiUserManager;
_movieRequestEngine = movieRequestEngine;
_tvRequestEngine = tvRequestEngine;
_hub = hub;
_logger = logger;
_watchlistRepo = watchlistRepo;
}
public ArrAvailabilityChecker(
IExternalRepository <RadarrCache> radarrRepo,
IExternalRepository <SonarrCache> sonarrRepo,
IExternalRepository <SonarrEpisodeCache> sonarrEpisodeRepo,
INotificationHelper notification, IHubContext <NotificationHub> hub,
ITvRequestRepository tvRequest, IMovieRequestRepository movies,
ILogger <ArrAvailabilityChecker> log,
ISettingsService <RadarrSettings> radarrSettings,
ISettingsService <SonarrSettings> sonarrSettings)
{
_radarrRepo = radarrRepo;
_sonarrRepo = sonarrRepo;
_sonarrEpisodeRepo = sonarrEpisodeRepo;
_notification = notification;
_hub = hub;
_tvRequest = tvRequest;
_movies = movies;
_logger = log;
_radarrSettings = radarrSettings;
_sonarrSettings = sonarrSettings;
}
private HashSet <LidarrAlbumCache> GetMusicContent(IExternalRepository <LidarrAlbumCache> repository, bool test)
{
var lidarrContent = repository.GetAll().AsNoTracking().ToList().Where(x => x.FullyAvailable);
HashSet <LidarrAlbumCache> albumsToSend;
if (test)
{
albumsToSend = lidarrContent.OrderByDescending(x => x.AddedAt).Take(10).ToHashSet();
}
else
{
// Filter out the ones that we haven't sent yet
var addedLog = _recentlyAddedLog.GetAll().ToList();
HashSet <string> addedAlbumLogIds;
GetRecentlyAddedMoviesData(addedLog, out addedAlbumLogIds);
albumsToSend = lidarrContent.Where(x => !addedAlbumLogIds.Contains(x.ForeignAlbumId)).ToHashSet();
}
_log.LogInformation("Albums to send: {0}", albumsToSend.Count());
return(albumsToSend);
}
public ReadVoucherByDateRangeStrategy(IExternalRepository infotaxiRepository)
{
_externalRepository = infotaxiRepository;
}
public CouchPotatoCacheRule(IExternalRepository <CouchPotatoCache> ctx)
{
_ctx = ctx;
}
public LidarrAlbumCacheRule(IExternalRepository <LidarrAlbumCache> db)
{
_db = db;
}
public ReadVoucherByIDStrategy(IExternalRepository repository)
{
_externalRepository = repository;
}
public RadarrCacheRule(IExternalRepository <RadarrCache> db)
{
_db = db;
}
public Repository(IExternalRepository <TEntity> external, IPersistenceRepository <TEntity> persistence, ILogger <Repository <TEntity> > logger)
{
_external = external;
_persistence = persistence;
_logger = logger;
}
