Exemplo n.º 1
0
 public MovieService(IMapper mapper, MolliesMoviesContext context, ISystemClock clock, IOptions <MovieOptions> options)
 {
     _mapper  = mapper;
     _context = context;
     _clock   = clock;
     _options = options;
 }
Exemplo n.º 2
0
 public static async Task <MovieSource> GetLatestMovieBySourceAsync(this MolliesMoviesContext context,
                                                                    string source,
                                                                    CancellationToken cancellationToken = default) =>
 await context.Set <MovieSource>()
 .Where(x => x.Source == source)
 .OrderByDescending(x => x.DateCreated)
 .FirstOrDefaultAsync(cancellationToken);
Exemplo n.º 3
0
 public static IQueryable <Movie> Movies(this MolliesMoviesContext context) =>
 context.Set <Movie>()
 .AsNoTracking()
 .Include(x => x.MovieGenres)
 .ThenInclude(x => x.Genre)
 .Include(x => x.MovieSources)
 .ThenInclude(x => x.Torrents)
 .Include(x => x.DownloadedMovies)
 .ThenInclude(x => x.LocalMovie)
 .Include(x => x.TransmissionContexts)
 .ThenInclude(x => x.Statuses);
Exemplo n.º 4
0
 public ScraperService(
     IEnumerable <IScraper> scrapers,
     ISystemClock clock,
     ILogger <ScraperService> logger,
     IMapper mapper,
     MolliesMoviesContext context,
     IMovieService movieService,
     IPlexApiClient plexApiClient,
     IOptions <ScraperOptions> options)
 {
     _clock         = clock;
     _logger        = logger;
     _mapper        = mapper;
     _context       = context;
     _movieService  = movieService;
     _plexApiClient = plexApiClient;
     _options       = options;
     _scrapers      = scrapers.ToList();
 }
Exemplo n.º 5
0
 public TransmissionService(
     IOptions <TransmissionOptions> options,
     IMovieService movieService,
     ILogger <TransmissionService> logger,
     MolliesMoviesContext context,
     ISystemClock clock,
     IScraperService scraperService,
     IScraperBackgroundService scraperBackgroundService,
     IMapper mapper)
 {
     _options                  = options;
     _movieService             = movieService;
     _logger                   = logger;
     _context                  = context;
     _clock                    = clock;
     _scraperService           = scraperService;
     _scraperBackgroundService = scraperBackgroundService;
     _mapper                   = mapper;
 }
Exemplo n.º 6
0
 public ScrapeSession(
     string source,
     ScraperType type,
     DateTime?scrapeFrom,
     List <string> movieImdbCodes,
     List <string> localImdbCodes,
     MolliesMoviesContext context,
     ISystemClock clock,
     CancellationToken cancellationToken,
     MovieOptions options)
 {
     ScrapeFrom         = scrapeFrom;
     _source            = source;
     _type              = type;
     MovieImdbCodes     = movieImdbCodes;
     LocalImdbCodes     = localImdbCodes;
     _context           = context;
     _scrapeDate        = clock.UtcNow;
     _cancellationToken = cancellationToken;
     _options           = options;
 }
Exemplo n.º 7
0
        public static async Task <ICollection <Genre> > AssertGenresAsync(
            this MolliesMoviesContext context, ICollection <string> toAssert, CancellationToken cancellationToken = default)
        {
            var cleaned = toAssert.Select(x => x.Trim()).ToList();
            var result  = await context.Set <Genre>()
                          .Where(x => cleaned.Contains(x.Name))
                          .ToListAsync(cancellationToken);

            var newGenres = cleaned.Except(result.Select(x => x.Name)).ToList();

            if (newGenres.Any())
            {
                var toAdd = newGenres.Select(x => new Genre {
                    Name = x
                }).ToList();

                result.AddRange(toAdd);
                await context.AddRangeAsync(toAdd, cancellationToken);

                await context.SaveChangesAsync(cancellationToken);
            }

            return(result);
        }
Exemplo n.º 8
0
 public static IQueryable <TransmissionContext> TransmissionContexts(this MolliesMoviesContext context) =>
 context.Set <TransmissionContext>().Include(x => x.Statuses);
Exemplo n.º 9
0
        public static async Task <PaginatedData <Movie> > SearchMoviesAsync(this MolliesMoviesContext context, PaginatedMovieQuery query,
                                                                            CancellationToken cancellationToken = default)
        {
            var dbQuery = context.Movies();

            if (!(query.Title is null))
            {
                var pattern = $"%{query.Title}%";
                dbQuery = dbQuery.Where(m => EF.Functions.Like(m.Title, pattern));
            }

            if (!(query.Quality is null))
            {
                dbQuery = dbQuery.Where(m => m.MovieSources.Any(s => s.Torrents.Any(t => t.Quality == query.Quality)));
            }

            if (!(query.Language is null))
            {
                dbQuery = dbQuery.Where(m => m.Language == query.Language);
            }

            if (query.Downloaded.HasValue)
            {
                dbQuery = query.Downloaded.Value
                    ? dbQuery.Where(x => x.DownloadedMovies.Any())
                    : dbQuery.Where(x => !x.DownloadedMovies.Any());
            }

            if (!string.IsNullOrEmpty(query.Genre))
            {
                dbQuery = dbQuery.Where(x => x.MovieGenres.Any(g => g.Genre.Name == query.Genre));
            }

            if (query.YearFrom.HasValue)
            {
                dbQuery = dbQuery.Where(m => m.Year >= query.YearFrom.Value);
            }

            if (query.YearTo.HasValue)
            {
                dbQuery = dbQuery.Where(m => m.Year <= query.YearTo.Value);
            }

            if (query.RatingFrom.HasValue)
            {
                dbQuery = dbQuery.Where(m => m.Rating >= query.RatingFrom.Value);
            }

            if (query.RatingTo.HasValue)
            {
                dbQuery = dbQuery.Where(m => m.Rating <= query.RatingTo.Value);
            }

            if (!(query.OrderBy is null))
            {
                for (var i = 0; i < query.OrderBy.Count; i++)
                {
                    var by = query.OrderBy.ElementAt(i);
                    dbQuery = (i == 0, @by.Descending) switch
                    {
                        (true, false) => dbQuery.OrderBy(@by.Property),
                        (true, true) => dbQuery.OrderByDescending(@by.Property),
                        (false, false) => ((IOrderedQueryable <Movie>)dbQuery).ThenBy(@by.Property),
                        (false, true) => ((IOrderedQueryable <Movie>)dbQuery).ThenByDescending(@by.Property)
                    };
                }
            }

            var count = await dbQuery.CountAsync(cancellationToken);

            var movies = count > 0
                ? await dbQuery
                         .Skip((query.Page - 1) *query.Limit)
                         .Take(query.Limit)
                         .ToListAsync(cancellationToken)
                : new List <Movie>();

            return(new PaginatedData <Movie>
            {
                Page = query.Page,
                Limit = query.Limit,
                Count = count,
                Data = movies
            });
        }
Exemplo n.º 10
0
 public static async Task <Movie> GetMovieByImdbCodeAsync(this MolliesMoviesContext context, string imdbCode, CancellationToken cancellationToken = default) =>
 await context.Set <Movie>().FirstOrDefaultAsync(x => x.ImdbCode == imdbCode, cancellationToken);
Exemplo n.º 11
0
 public static async Task <Movie> GetMovieDetailByIdAsync(this MolliesMoviesContext context, int id, CancellationToken cancellationToken = default) =>
 await context.Movies().FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
Exemplo n.º 12
0
 public static IQueryable <Scrape> Scrapes(this MolliesMoviesContext context) =>
 context.Set <Scrape>().Include(x => x.ScrapeSources);