public ShowScraperService(IRemoteShowProvider remoteShowProvider,
IShowRepository showRepository
)
{
_remoteShowProvider = remoteShowProvider;
_showRepository = showRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="ShowService"/> class.
/// </summary>
/// <param name="showRepository">The show repository.</param>
/// <param name="mapper">The mapper.</param>
/// <param name="imageHelper">The image helper.</param>
/// <param name="searchEngineHelper">The search engine helper.</param>
public ShowService(IShowRepository showRepository, IMapper mapper, IImageHelper imageHelper, ISearchEngineHelper searchEngineHelper)
{
_showRepository = showRepository;
_mapper = mapper;
_imageHelper = imageHelper;
_searchEngineHelper = searchEngineHelper;
}
public Service(IUserRepository userRepo, ITicketRepository ticketRepo, IShowRepository showRepo)
{
userRepository = userRepo;
ticketRepository = ticketRepo;
showRepository = showRepo;
loggedClients = new Dictionary <string, IObserver>();
}
public Scraper(IShowRepository repo, ITvMazeApiClient apiClient, IOptions <ScraperSettings> settings, ILogger <Scraper> logger)
{
_apiPageSize = settings.Value.ApiPageSize;
_repo = repo;
_apiClient = apiClient;
_logger = logger;
}
public SearchController(EpisodeSearch episodeSearch, ShowSearch showSearch, IShowRepository showRepo, ILogger <SearchController> logger)
{
_episodeSearch = episodeSearch;
_showSearch = showSearch;
_showRepo = showRepo;
_logger = logger;
}
public ShowsController(
IShowRepository showRepository,
IMapper mapper)
{
this.showRepository = showRepository;
this.mapper = mapper;
}
public async Task <List <Show> > GetShows(IShowRepository showRepository, int pageNumber)
{
var shows = new List <Show>();
_logger.LogInformation($"Stating copying data from {nameof(pageNumber)} {pageNumber}");
var showDtos = await _tvMazeService.GetShowsByPage(pageNumber).ConfigureAwait(false);
_logger.LogInformation($"Found {showDtos.Count} Shows from TvMaze API service");
foreach (var showDto in showDtos)
{
var tvMazeShowWithCast = await _tvMazeService.GetShowDataById(showDto.Id).ConfigureAwait(false);
_logger.LogInformation($"Found TvMaze show {tvMazeShowWithCast} with cast");
var show = new Show {
Id = tvMazeShowWithCast.Id, Name = tvMazeShowWithCast.Name
};
show.Cast.AddRange(tvMazeShowWithCast.Cast
.TakeWhile(personDto => personDto != null)
.Distinct(new PersonDtoEqualityComparer())
.Select(personDto => new Cast
{
CastPersonId = personDto.Id,
ShowId = show.Id,
Person = GetPerson(showRepository, personDto)
}));
shows.Add(show);
}
return(shows);
}
public AddNewShowsCommandHandler(
ITvMazeApiClient tvMazeApiClient,
IShowRepository repository)
{
_tvMazeApiClient = tvMazeApiClient;
_repository = repository;
}
public ShowScrapperService(ITvMazeClient tvMazeClient, IShowRepository showRepository,
IShowCastProvider showCastProvider, ILogger <ShowScrapperService> logger)
{
_tvMazeClient = tvMazeClient;
_showRepository = showRepository;
_logger = logger;
_showCastProvider = showCastProvider;
}
private static async Task <int> GetPageNumber(IShowRepository showRepository)
{
var startId = await showRepository.GetLastShowId();
var pageNumber = (int)Math.Floor((double)startId / 250);
return(pageNumber == 0 ? 1 : pageNumber);
}
public ScrapeHandlerImpl(
IScrapeService scrapeService,
IShowRepository showRepository
)
{
_scrapeService = scrapeService;
_showRepository = showRepository;
}
public ShowController(IShowRepository showRepository,
IGenreRepository genreRepository,
ICategoryRepository categoryRepository)
{
ShowRepository = showRepository;
GenreRepository = genreRepository;
CategoryRepository = categoryRepository;
}
public ScrapeService(IShowRepository showRepository, ICastMemberRepository castMemberRepository, ITVMazeApiHttpClient tvMazeApiHttpClient)
{
this.showRepository = showRepository;
this.castMemberRepository = castMemberRepository;
this.tvMazeApiHttpClient = tvMazeApiHttpClient;
this.taskLimiter = new TaskLimiter(1, TimeSpan.FromSeconds(this.tvMazeApiHttpClient.RateLimitCallPerSecond));
}
public ScrapeController(IScrapeService scrapeService,
IShowRepository showRepository,
IPersonRepository personRepository)
{
_scrapeService = scrapeService;
_showRepository = showRepository;
_personRepository = personRepository;
}
public Scraper(ITVMazeService tvMazeService, IShowRepository showRepository, IPersonRepository personRepository, ILoggerFactory loggerFactory)
{
this.tvMazeService = tvMazeService;
this.showRepository = showRepository;
this.personRepository = personRepository;
this.loggerFactory = loggerFactory;
logger = loggerFactory.CreateLogger("Scraper");
}
public ShowService(IJobRepository jobRepository, IShowRepository showRepository, ILibraryRepository libraryRepository,
IPersonService personService, IStatisticsRepository statisticsRepository, ISettingsService settingsService) : base(jobRepository, personService)
{
_showRepository = showRepository;
_libraryRepository = libraryRepository;
_statisticsRepository = statisticsRepository;
_settingsService = settingsService;
}
public TvMazeScraperService(IShowsAnticorruption showsAnticorruption,
IShowCastAnticorruption showCastAnticorruption, IShowRepository repository, ILogger <TvMazeScraperService> logger)
{
this.showsAnticorruption = showsAnticorruption;
this.showCastAnticorruption = showCastAnticorruption;
this.repository = repository;
this.logger = logger;
}
public ShowService(StatefulServiceContext serviceContext,
IReliableStateManagerReplica reliableStateManagerReplica) : base(serviceContext,
reliableStateManagerReplica)
{
_showRepository = new ShowRepository(StateManager);
_backupManager = new BackupManager(
new ServiceContextInfo(Context, Partition, StateManager),
new BackupContextInfo(BackupAsync, "showRequestHistory", "showBackupCountDict"));
}
/// <summary>
/// Constructor of Show manager
/// </summary>
/// <param name="showRepository"></param>
/// <param name="channelRepository"></param>
/// <param name="genreRepository"></param>
/// <param name="seasonRepository"></param>
/// <param name="episodeRepository"></param>
public ShowManager(IShowRepository showRepository, IChannelRepository channelRepository, IGenreRepository genreRepository,
ISeasonRepository seasonRepository, IEpisodeRepository episodeRepository)
{
_showRepository = showRepository;
_channelRepository = channelRepository;
_genreRepository = genreRepository;
_seasonRepository = seasonRepository;
_episodeRepository = episodeRepository;
}
public ListenedShowService(IListenedShowRepository repo,
IShowRepository showRepo)
{
Checks.Argument.IsNotNull(repo, "repo");
Checks.Argument.IsNotNull( showRepo, "showRepo" );
_repo = repo;
_showRepo = showRepo;
}
public ListenedShowService(IListenedShowRepository repo,
IShowRepository showRepo)
{
Checks.Argument.IsNotNull(repo, "repo");
Checks.Argument.IsNotNull(showRepo, "showRepo");
_repo = repo;
_showRepo = showRepo;
}
public ShowsController(IShowRepository ShowRepository,
IVenueRepository venueRepository,
IMovieRepository movieRepository,
ILogger <ShowsController> log)
{
this.ShowRepository = ShowRepository;
this.movieRepository = movieRepository;
this.venueRepository = venueRepository;
this.log = log;
}
public ShowsService(
IMapper mapper,
ILogger <ShowsService> logger,
IShowRepository showRepository,
IStringsProvider strings)
{
_mapper = mapper;
_logger = logger;
_showRepository = showRepository;
_strings = strings;
}
public PersonService(IPersonRepository personRepository, IShowRepository showRepository, IMovieRepository movieRepository,
IClientStrategy clientStrategy, ISettingsService settingsService)
{
_personRepository = personRepository;
_movieRepository = movieRepository;
_showRepository = showRepository;
_logger = LogFactory.CreateLoggerForType(typeof(PersonService), "PERSON-SERVICE");
var settings = settingsService.GetUserSettings();
_httpClient = clientStrategy.CreateHttpClient(settings.MediaServer?.ServerType ?? ServerType.Emby);
}
public ShowService( IShowRepository showRepository,
ISetRepository setRepository,
ISetSongRepository setSongRepository )
{
Checks.Argument.IsNotNull( showRepository, "showRepository" );
Checks.Argument.IsNotNull( setRepository, "setRepository" );
Checks.Argument.IsNotNull( setSongRepository, "setSongRepository" );
_ShowRepository = showRepository;
_SetRepository = setRepository;
_SetSongRepository = setSongRepository;
}
public ShowService(IShowRepository showRepository,
IHttpClientFactory clientFactory,
ICastCreditRepository castCreditRepository,
IPersonRepository personRepository,
IDatabaseRepository databaseRepository)
{
ShowRepository = showRepository;
HttpClient = clientFactory.CreateClient();
DatabaseRepository = databaseRepository;
CastCreditRepository = castCreditRepository;
PersonRepository = personRepository;
}
private static Person GetPerson(IShowRepository showRepository, PersonDto personDto)
{
if (showRepository.HasPersonWithId(personDto.Id))
{
return(null);
}
return(new Person
{
Id = personDto.Id,
Name = personDto.Name,
Birthdate = personDto.Birthdate
});
}
public void SetUp()
{
_mazeCacheConfig = Substitute.For <IOptions <MazeCacheConfig> >();
_mazeCacheConfig.Value.Returns(new MazeCacheConfig()
{
DbCacheSecond = 60
});
_showRepository = Substitute.For <IShowRepository>();
_decorated = Substitute.For <IShowApplication>();
_sut = new CachedShowApplication(_showRepository, _mazeCacheConfig, _decorated);
_decoratedShows = new List <Domain.ShowDomain.Show>();
_getShowRequest = new GetShowRequest();
_decorated.GetShowAsync(_getShowRequest).Returns(_decoratedShows);
}
public MediaServerService(IClientStrategy clientStrategy, IMediaServerRepository mediaServerRepository, ISessionService sessionService,
ISettingsService settingsService, IMovieRepository movieRepository, IShowRepository showRepository, ILibraryRepository libraryRepository)
{
_mediaServerRepository = mediaServerRepository;
_sessionService = sessionService;
_settingsService = settingsService;
_movieRepository = movieRepository;
_showRepository = showRepository;
_clientStrategy = clientStrategy;
_libraryRepository = libraryRepository;
_logger = LogFactory.CreateLoggerForType(typeof(MediaServerService), "SERVER-API");
var settings = _settingsService.GetUserSettings();
ChangeClientType(settings.MediaServer?.ServerType);
}
public TvMazeScrapeService(
IHttpClientFactory httpClientFactory,
IScrapeRepository scrapeRepository,
ILogger <TvMazeScrapeService> logger,
IMapper mapper,
IShowRepository showRepository,
IPersonRepository personRepository,
ICastMemberRepository castMemberRepository)
{
this.httpClientFactory = httpClientFactory;
this.scrapeRepository = scrapeRepository;
this.logger = logger;
this.mapper = mapper;
this.showRepository = showRepository;
this.personRepository = personRepository;
this.castMemberRepository = castMemberRepository;
}
private XMLRepositoryFactory(string _filename)
{
filename = _filename;
try
{
Document = XDocument.Load(filename);
}
//System.IO.DirectoryNotFoundException
catch (System.IO.FileNotFoundException ex)
{
//Repository doesn't exist, so create a new baseline.
Document = new XDocument(
new XElement("Repository",
new XElement("Config"),
new XElement("Shows")
)
);
Persist();
}
configurationRepository = new XMLConfigurationRepository(this);
//Initialize Show repository, with next ID from config
string nextShowID = ConfigurationRepository.GetValue("NextShowID");
if (nextShowID == null || nextShowID.Equals(""))
{
ConfigurationRepository.SetValue("NextShowID", "1");
showRepository = new XMLShowRepository(this, 1);
}
else { showRepository = new XMLShowRepository(this, Convert.ToInt32(nextShowID)); }
//Initialize Season repository, with next ID from config
string nextSeasonID = ConfigurationRepository.GetValue("NextSeasonID");
if (nextSeasonID == null || nextSeasonID.Equals(""))
{
ConfigurationRepository.SetValue("NextSeasonID", "1");
seasonRepository = new XMLSeasonRepository(this, 1);
}
else { seasonRepository = new XMLSeasonRepository(this, Convert.ToInt32(nextSeasonID)); }
//Initialize Season repository, with next ID from config
string nextEpisodeID = ConfigurationRepository.GetValue("NextEpisodeID");
if (nextEpisodeID == null || nextEpisodeID.Equals(""))
{
ConfigurationRepository.SetValue("NextEpisodeID", "1");
episodeRepository = new XMLEpisodeRepository(this, 1);
}
else { episodeRepository = new XMLEpisodeRepository(this, Convert.ToInt32(nextEpisodeID)); }
}
public MediaSyncJob(IJobHubHelper hubHelper, IJobRepository jobRepository, ISettingsService settingsService,
IClientStrategy clientStrategy, IMovieRepository movieRepository, IShowRepository showRepository,
ILibraryRepository libraryRepository, ITvdbClient tvdbClient, IStatisticsRepository statisticsRepository,
IMovieService movieService, IShowService showService) : base(hubHelper, jobRepository, settingsService,
typeof(MediaSyncJob), Constants.LogPrefix.MediaSyncJob)
{
_movieRepository = movieRepository;
_showRepository = showRepository;
_libraryRepository = libraryRepository;
_tvdbClient = tvdbClient;
_statisticsRepository = statisticsRepository;
_movieService = movieService;
_showService = showService;
Title = jobRepository.GetById(Id).Title;
var settings = settingsService.GetUserSettings();
_httpClient = clientStrategy.CreateHttpClient(settings.MediaServer?.ServerType ?? ServerType.Emby);
}
static void ConfigureServices(ServiceCollection serviceCollection)
{
var configBuilder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
var configuration = configBuilder.Build();
var connectionStr = configuration.GetConnectionString("DefaultConnection");
serviceCollection.AddDbContext <TVMazeScrapperDBContext>(options => options.UseSqlServer(connectionStr))
.AddTransient <IShowRepository, ShowRepository>()
.AddTransient <IPersonRepository, PersonRepository>()
.AddTransient <IScraper, Scraper>()
.AddTransient <ITVMazeService, TVMazeService>()
.AddTransient <ITVMazeService, TVMazeService>()
.AddSingleton(new LoggerFactory()
.AddConsole(configuration.GetSection("Logging"))
.AddDebug())
.AddLogging();
serviceCollection.AddHttpClient <TVMazeHttpClient>(client =>
{
client.BaseAddress = new Uri("https://api.tvmaze.com/");
client.DefaultRequestHeaders.Add("Accept", "application/json");
client.DefaultRequestHeaders.Add("User-Agent", "TVMazeScraper");
})
.SetHandlerLifetime(TimeSpan.FromMinutes(5))
.AddPolicyHandler(TVMazeHttpClient.GetRetryPolicy());
var services = serviceCollection.BuildServiceProvider();
tvMazeService = services.GetService <ITVMazeService>();
tvMazeHttpClient = services.GetService <TVMazeHttpClient>();
scrapper = services.GetService <IScraper>();
dbContext = services.GetService <TVMazeScrapperDBContext>();
showRepository = services.GetService <IShowRepository>();
}
public ShowService( IShowRepository repo )
{
Checks.Argument.IsNotNull( repo, "repo" );
_repo = repo;
}
